The Tor Browser: browser/extensions/pdfjs/content/build/pdf.worker.js@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

     3 /* Copyright 2012 Mozilla Foundation

     4  *

     5  * Licensed under the Apache License, Version 2.0 (the "License");

     6  * you may not use this file except in compliance with the License.

     7  * You may obtain a copy of the License at

     8  *

     9  *     http://www.apache.org/licenses/LICENSE-2.0

    10  *

    11  * Unless required by applicable law or agreed to in writing, software

    12  * distributed under the License is distributed on an "AS IS" BASIS,

    13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    14  * See the License for the specific language governing permissions and

    15  * limitations under the License.

    16  */

    17 /*jshint globalstrict: false */

    19 // Initializing PDFJS global object (if still undefined)

    20 if (typeof PDFJS === 'undefined') {

    21   (typeof window !== 'undefined' ? window : this).PDFJS = {};

    22 }

    24 PDFJS.version = '1.0.68';

    25 PDFJS.build = 'ead4cbf';

    27 (function pdfjsWrapper() {

    28   // Use strict in our context only - users might not want it

    29   'use strict';

    31 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

    32 /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

    33 /* Copyright 2012 Mozilla Foundation

    34  *

    35  * Licensed under the Apache License, Version 2.0 (the "License");

    36  * you may not use this file except in compliance with the License.

    37  * You may obtain a copy of the License at

    38  *

    39  *     http://www.apache.org/licenses/LICENSE-2.0

    40  *

    41  * Unless required by applicable law or agreed to in writing, software

    42  * distributed under the License is distributed on an "AS IS" BASIS,

    43  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    44  * See the License for the specific language governing permissions and

    45  * limitations under the License.

    46  */

    47 /* globals Cmd, ColorSpace, Dict, MozBlobBuilder, Name, PDFJS, Ref, URL,

    48            Promise */

    50 'use strict';

    52 var globalScope = (typeof window === 'undefined') ? this : window;

    54 var isWorker = (typeof window == 'undefined');

    56 var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];

    58 var TextRenderingMode = {

    59   FILL: 0,

    60   STROKE: 1,

    61   FILL_STROKE: 2,

    62   INVISIBLE: 3,

    63   FILL_ADD_TO_PATH: 4,

    64   STROKE_ADD_TO_PATH: 5,

    65   FILL_STROKE_ADD_TO_PATH: 6,

    66   ADD_TO_PATH: 7,

    67   FILL_STROKE_MASK: 3,

    68   ADD_TO_PATH_FLAG: 4

    69 };

    71 var ImageKind = {

    72   GRAYSCALE_1BPP: 1,

    73   RGB_24BPP: 2,

    74   RGBA_32BPP: 3

    75 };

    77 // The global PDFJS object exposes the API

    78 // In production, it will be declared outside a global wrapper

    79 // In development, it will be declared here

    80 if (!globalScope.PDFJS) {

    81   globalScope.PDFJS = {};

    82 }

    84 globalScope.PDFJS.pdfBug = false;

    86 PDFJS.VERBOSITY_LEVELS = {

    87   errors: 0,

    88   warnings: 1,

    89   infos: 5

    90 };

    92 // All the possible operations for an operator list.

    93 var OPS = PDFJS.OPS = {

    94   // Intentionally start from 1 so it is easy to spot bad operators that will be

    95   // 0's.

    96   dependency: 1,

    97   setLineWidth: 2,

    98   setLineCap: 3,

    99   setLineJoin: 4,

   100   setMiterLimit: 5,

   101   setDash: 6,

   102   setRenderingIntent: 7,

   103   setFlatness: 8,

   104   setGState: 9,

   105   save: 10,

   106   restore: 11,

   107   transform: 12,

   108   moveTo: 13,

   109   lineTo: 14,

   110   curveTo: 15,

   111   curveTo2: 16,

   112   curveTo3: 17,

   113   closePath: 18,

   114   rectangle: 19,

   115   stroke: 20,

   116   closeStroke: 21,

   117   fill: 22,

   118   eoFill: 23,

   119   fillStroke: 24,

   120   eoFillStroke: 25,

   121   closeFillStroke: 26,

   122   closeEOFillStroke: 27,

   123   endPath: 28,

   124   clip: 29,

   125   eoClip: 30,

   126   beginText: 31,

   127   endText: 32,

   128   setCharSpacing: 33,

   129   setWordSpacing: 34,

   130   setHScale: 35,

   131   setLeading: 36,

   132   setFont: 37,

   133   setTextRenderingMode: 38,

   134   setTextRise: 39,

   135   moveText: 40,

   136   setLeadingMoveText: 41,

   137   setTextMatrix: 42,

   138   nextLine: 43,

   139   showText: 44,

   140   showSpacedText: 45,

   141   nextLineShowText: 46,

   142   nextLineSetSpacingShowText: 47,

   143   setCharWidth: 48,

   144   setCharWidthAndBounds: 49,

   145   setStrokeColorSpace: 50,

   146   setFillColorSpace: 51,

   147   setStrokeColor: 52,

   148   setStrokeColorN: 53,

   149   setFillColor: 54,

   150   setFillColorN: 55,

   151   setStrokeGray: 56,

   152   setFillGray: 57,

   153   setStrokeRGBColor: 58,

   154   setFillRGBColor: 59,

   155   setStrokeCMYKColor: 60,

   156   setFillCMYKColor: 61,

   157   shadingFill: 62,

   158   beginInlineImage: 63,

   159   beginImageData: 64,

   160   endInlineImage: 65,

   161   paintXObject: 66,

   162   markPoint: 67,

   163   markPointProps: 68,

   164   beginMarkedContent: 69,

   165   beginMarkedContentProps: 70,

   166   endMarkedContent: 71,

   167   beginCompat: 72,

   168   endCompat: 73,

   169   paintFormXObjectBegin: 74,

   170   paintFormXObjectEnd: 75,

   171   beginGroup: 76,

   172   endGroup: 77,

   173   beginAnnotations: 78,

   174   endAnnotations: 79,

   175   beginAnnotation: 80,

   176   endAnnotation: 81,

   177   paintJpegXObject: 82,

   178   paintImageMaskXObject: 83,

   179   paintImageMaskXObjectGroup: 84,

   180   paintImageXObject: 85,

   181   paintInlineImageXObject: 86,

   182   paintInlineImageXObjectGroup: 87,

   183   paintImageXObjectRepeat: 88,

   184   paintImageMaskXObjectRepeat: 89,

   185   paintSolidColorImageMask: 90

   186 };

   188 // A notice for devs. These are good for things that are helpful to devs, such

   189 // as warning that Workers were disabled, which is important to devs but not

   190 // end users.

   191 function info(msg) {

   192   if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) {

   193     console.log('Info: ' + msg);

   194   }

   195 }

   197 // Non-fatal warnings.

   198 function warn(msg) {

   199   if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) {

   200     console.log('Warning: ' + msg);

   201   }

   202 }

   204 // Fatal errors that should trigger the fallback UI and halt execution by

   205 // throwing an exception.

   206 function error(msg) {

   207   // If multiple arguments were passed, pass them all to the log function.

   208   if (arguments.length > 1) {

   209     var logArguments = ['Error:'];

   210     logArguments.push.apply(logArguments, arguments);

   211     console.log.apply(console, logArguments);

   212     // Join the arguments into a single string for the lines below.

   213     msg = [].join.call(arguments, ' ');

   214   } else {

   215     console.log('Error: ' + msg);

   216   }

   217   console.log(backtrace());

   218   UnsupportedManager.notify(UNSUPPORTED_FEATURES.unknown);

   219   throw new Error(msg);

   220 }

   222 function backtrace() {

   223   try {

   224     throw new Error();

   225   } catch (e) {

   226     return e.stack ? e.stack.split('\n').slice(2).join('\n') : '';

   227   }

   228 }

   230 function assert(cond, msg) {

   231   if (!cond) {

   232     error(msg);

   233   }

   234 }

   236 var UNSUPPORTED_FEATURES = PDFJS.UNSUPPORTED_FEATURES = {

   237   unknown: 'unknown',

   238   forms: 'forms',

   239   javaScript: 'javaScript',

   240   smask: 'smask',

   241   shadingPattern: 'shadingPattern',

   242   font: 'font'

   243 };

   245 var UnsupportedManager = PDFJS.UnsupportedManager =

   246   (function UnsupportedManagerClosure() {

   247   var listeners = [];

   248   return {

   249     listen: function (cb) {

   250       listeners.push(cb);

   251     },

   252     notify: function (featureId) {

   253       warn('Unsupported feature "' + featureId + '"');

   254       for (var i = 0, ii = listeners.length; i < ii; i++) {

   255         listeners[i](featureId);

   256       }

   257     }

   258   };

   259 })();

   261 // Combines two URLs. The baseUrl shall be absolute URL. If the url is an

   262 // absolute URL, it will be returned as is.

   263 function combineUrl(baseUrl, url) {

   264   if (!url) {

   265     return baseUrl;

   266   }

   267   if (/^[a-z][a-z0-9+\-.]*:/i.test(url)) {

   268     return url;

   269   }

   270   var i;

   271   if (url.charAt(0) == '/') {

   272     // absolute path

   273     i = baseUrl.indexOf('://');

   274     if (url.charAt(1) === '/') {

   275       ++i;

   276     } else {

   277       i = baseUrl.indexOf('/', i + 3);

   278     }

   279     return baseUrl.substring(0, i) + url;

   280   } else {

   281     // relative path

   282     var pathLength = baseUrl.length;

   283     i = baseUrl.lastIndexOf('#');

   284     pathLength = i >= 0 ? i : pathLength;

   285     i = baseUrl.lastIndexOf('?', pathLength);

   286     pathLength = i >= 0 ? i : pathLength;

   287     var prefixLength = baseUrl.lastIndexOf('/', pathLength);

   288     return baseUrl.substring(0, prefixLength + 1) + url;

   289   }

   290 }

   292 // Validates if URL is safe and allowed, e.g. to avoid XSS.

   293 function isValidUrl(url, allowRelative) {

   294   if (!url) {

   295     return false;

   296   }

   297   // RFC 3986 (http://tools.ietf.org/html/rfc3986#section-3.1)

   298   // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )

   299   var protocol = /^[a-z][a-z0-9+\-.]*(?=:)/i.exec(url);

   300   if (!protocol) {

   301     return allowRelative;

   302   }

   303   protocol = protocol[0].toLowerCase();

   304   switch (protocol) {

   305     case 'http':

   306     case 'https':

   307     case 'ftp':

   308     case 'mailto':

   309       return true;

   310     default:

   311       return false;

   312   }

   313 }

   314 PDFJS.isValidUrl = isValidUrl;

   316 function shadow(obj, prop, value) {

   317   Object.defineProperty(obj, prop, { value: value,

   318                                      enumerable: true,

   319                                      configurable: true,

   320                                      writable: false });

   321   return value;

   322 }

   324 var PasswordResponses = PDFJS.PasswordResponses = {

   325   NEED_PASSWORD: 1,

   326   INCORRECT_PASSWORD: 2

   327 };

   329 var PasswordException = (function PasswordExceptionClosure() {

   330   function PasswordException(msg, code) {

   331     this.name = 'PasswordException';

   332     this.message = msg;

   333     this.code = code;

   334   }

   336   PasswordException.prototype = new Error();

   337   PasswordException.constructor = PasswordException;

   339   return PasswordException;

   340 })();

   342 var UnknownErrorException = (function UnknownErrorExceptionClosure() {

   343   function UnknownErrorException(msg, details) {

   344     this.name = 'UnknownErrorException';

   345     this.message = msg;

   346     this.details = details;

   347   }

   349   UnknownErrorException.prototype = new Error();

   350   UnknownErrorException.constructor = UnknownErrorException;

   352   return UnknownErrorException;

   353 })();

   355 var InvalidPDFException = (function InvalidPDFExceptionClosure() {

   356   function InvalidPDFException(msg) {

   357     this.name = 'InvalidPDFException';

   358     this.message = msg;

   359   }

   361   InvalidPDFException.prototype = new Error();

   362   InvalidPDFException.constructor = InvalidPDFException;

   364   return InvalidPDFException;

   365 })();

   367 var MissingPDFException = (function MissingPDFExceptionClosure() {

   368   function MissingPDFException(msg) {

   369     this.name = 'MissingPDFException';

   370     this.message = msg;

   371   }

   373   MissingPDFException.prototype = new Error();

   374   MissingPDFException.constructor = MissingPDFException;

   376   return MissingPDFException;

   377 })();

   379 var NotImplementedException = (function NotImplementedExceptionClosure() {

   380   function NotImplementedException(msg) {

   381     this.message = msg;

   382   }

   384   NotImplementedException.prototype = new Error();

   385   NotImplementedException.prototype.name = 'NotImplementedException';

   386   NotImplementedException.constructor = NotImplementedException;

   388   return NotImplementedException;

   389 })();

   391 var MissingDataException = (function MissingDataExceptionClosure() {

   392   function MissingDataException(begin, end) {

   393     this.begin = begin;

   394     this.end = end;

   395     this.message = 'Missing data [' + begin + ', ' + end + ')';

   396   }

   398   MissingDataException.prototype = new Error();

   399   MissingDataException.prototype.name = 'MissingDataException';

   400   MissingDataException.constructor = MissingDataException;

   402   return MissingDataException;

   403 })();

   405 var XRefParseException = (function XRefParseExceptionClosure() {

   406   function XRefParseException(msg) {

   407     this.message = msg;

   408   }

   410   XRefParseException.prototype = new Error();

   411   XRefParseException.prototype.name = 'XRefParseException';

   412   XRefParseException.constructor = XRefParseException;

   414   return XRefParseException;

   415 })();

   418 function bytesToString(bytes) {

   419   var length = bytes.length;

   420   var MAX_ARGUMENT_COUNT = 8192;

   421   if (length < MAX_ARGUMENT_COUNT) {

   422     return String.fromCharCode.apply(null, bytes);

   423   }

   424   var strBuf = [];

   425   for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {

   426     var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);

   427     var chunk = bytes.subarray(i, chunkEnd);

   428     strBuf.push(String.fromCharCode.apply(null, chunk));

   429   }

   430   return strBuf.join('');

   431 }

   433 function stringToArray(str) {

   434   var length = str.length;

   435   var array = [];

   436   for (var i = 0; i < length; ++i) {

   437     array[i] = str.charCodeAt(i);

   438   }

   439   return array;

   440 }

   442 function stringToBytes(str) {

   443   var length = str.length;

   444   var bytes = new Uint8Array(length);

   445   for (var i = 0; i < length; ++i) {

   446     bytes[i] = str.charCodeAt(i) & 0xFF;

   447   }

   448   return bytes;

   449 }

   451 function string32(value) {

   452   return String.fromCharCode((value >> 24) & 0xff, (value >> 16) & 0xff,

   453                              (value >> 8) & 0xff, value & 0xff);

   454 }

   456 function log2(x) {

   457   var n = 1, i = 0;

   458   while (x > n) {

   459     n <<= 1;

   460     i++;

   461   }

   462   return i;

   463 }

   465 function readInt8(data, start) {

   466   return (data[start] << 24) >> 24;

   467 }

   469 function readUint16(data, offset) {

   470   return (data[offset] << 8) | data[offset + 1];

   471 }

   473 function readUint32(data, offset) {

   474   return ((data[offset] << 24) | (data[offset + 1] << 16) |

   475          (data[offset + 2] << 8) | data[offset + 3]) >>> 0;

   476 }

   478 // Lazy test the endianness of the platform

   479 // NOTE: This will be 'true' for simulated TypedArrays

   480 function isLittleEndian() {

   481   var buffer8 = new Uint8Array(2);

   482   buffer8[0] = 1;

   483   var buffer16 = new Uint16Array(buffer8.buffer);

   484   return (buffer16[0] === 1);

   485 }

   487 Object.defineProperty(PDFJS, 'isLittleEndian', {

   488   configurable: true,

   489   get: function PDFJS_isLittleEndian() {

   490     return shadow(PDFJS, 'isLittleEndian', isLittleEndian());

   491   }

   492 });

   494   PDFJS.hasCanvasTypedArrays = true;

   496 var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];

   498 var Util = PDFJS.Util = (function UtilClosure() {

   499   function Util() {}

   501   Util.makeCssRgb = function Util_makeCssRgb(rgb) {

   502     return 'rgb(' + rgb[0] + ',' + rgb[1] + ',' + rgb[2] + ')';

   503   };

   505   Util.makeCssCmyk = function Util_makeCssCmyk(cmyk) {

   506     var rgb = ColorSpace.singletons.cmyk.getRgb(cmyk, 0);

   507     return Util.makeCssRgb(rgb);

   508   };

   510   // Concatenates two transformation matrices together and returns the result.

   511   Util.transform = function Util_transform(m1, m2) {

   512     return [

   513       m1[0] * m2[0] + m1[2] * m2[1],

   514       m1[1] * m2[0] + m1[3] * m2[1],

   515       m1[0] * m2[2] + m1[2] * m2[3],

   516       m1[1] * m2[2] + m1[3] * m2[3],

   517       m1[0] * m2[4] + m1[2] * m2[5] + m1[4],

   518       m1[1] * m2[4] + m1[3] * m2[5] + m1[5]

   519     ];

   520   };

   522   // For 2d affine transforms

   523   Util.applyTransform = function Util_applyTransform(p, m) {

   524     var xt = p[0] * m[0] + p[1] * m[2] + m[4];

   525     var yt = p[0] * m[1] + p[1] * m[3] + m[5];

   526     return [xt, yt];

   527   };

   529   Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {

   530     var d = m[0] * m[3] - m[1] * m[2];

   531     var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;

   532     var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;

   533     return [xt, yt];

   534   };

   536   // Applies the transform to the rectangle and finds the minimum axially

   537   // aligned bounding box.

   538   Util.getAxialAlignedBoundingBox =

   539     function Util_getAxialAlignedBoundingBox(r, m) {

   541     var p1 = Util.applyTransform(r, m);

   542     var p2 = Util.applyTransform(r.slice(2, 4), m);

   543     var p3 = Util.applyTransform([r[0], r[3]], m);

   544     var p4 = Util.applyTransform([r[2], r[1]], m);

   545     return [

   546       Math.min(p1[0], p2[0], p3[0], p4[0]),

   547       Math.min(p1[1], p2[1], p3[1], p4[1]),

   548       Math.max(p1[0], p2[0], p3[0], p4[0]),

   549       Math.max(p1[1], p2[1], p3[1], p4[1])

   550     ];

   551   };

   553   Util.inverseTransform = function Util_inverseTransform(m) {

   554     var d = m[0] * m[3] - m[1] * m[2];

   555     return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d,

   556       (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];

   557   };

   559   // Apply a generic 3d matrix M on a 3-vector v:

   560   //   | a b c |   | X |

   561   //   | d e f | x | Y |

   562   //   | g h i |   | Z |

   563   // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],

   564   // with v as [X,Y,Z]

   565   Util.apply3dTransform = function Util_apply3dTransform(m, v) {

   566     return [

   567       m[0] * v[0] + m[1] * v[1] + m[2] * v[2],

   568       m[3] * v[0] + m[4] * v[1] + m[5] * v[2],

   569       m[6] * v[0] + m[7] * v[1] + m[8] * v[2]

   570     ];

   571   };

   573   // This calculation uses Singular Value Decomposition.

   574   // The SVD can be represented with formula A = USV. We are interested in the

   575   // matrix S here because it represents the scale values.

   576   Util.singularValueDecompose2dScale =

   577     function Util_singularValueDecompose2dScale(m) {

   579     var transpose = [m[0], m[2], m[1], m[3]];

   581     // Multiply matrix m with its transpose.

   582     var a = m[0] * transpose[0] + m[1] * transpose[2];

   583     var b = m[0] * transpose[1] + m[1] * transpose[3];

   584     var c = m[2] * transpose[0] + m[3] * transpose[2];

   585     var d = m[2] * transpose[1] + m[3] * transpose[3];

   587     // Solve the second degree polynomial to get roots.

   588     var first = (a + d) / 2;

   589     var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;

   590     var sx = first + second || 1;

   591     var sy = first - second || 1;

   593     // Scale values are the square roots of the eigenvalues.

   594     return [Math.sqrt(sx), Math.sqrt(sy)];

   595   };

   597   // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)

   598   // For coordinate systems whose origin lies in the bottom-left, this

   599   // means normalization to (BL,TR) ordering. For systems with origin in the

   600   // top-left, this means (TL,BR) ordering.

   601   Util.normalizeRect = function Util_normalizeRect(rect) {

   602     var r = rect.slice(0); // clone rect

   603     if (rect[0] > rect[2]) {

   604       r[0] = rect[2];

   605       r[2] = rect[0];

   606     }

   607     if (rect[1] > rect[3]) {

   608       r[1] = rect[3];

   609       r[3] = rect[1];

   610     }

   611     return r;

   612   };

   614   // Returns a rectangle [x1, y1, x2, y2] corresponding to the

   615   // intersection of rect1 and rect2. If no intersection, returns 'false'

   616   // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]

   617   Util.intersect = function Util_intersect(rect1, rect2) {

   618     function compare(a, b) {

   619       return a - b;

   620     }

   622     // Order points along the axes

   623     var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),

   624         orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),

   625         result = [];

   627     rect1 = Util.normalizeRect(rect1);

   628     rect2 = Util.normalizeRect(rect2);

   630     // X: first and second points belong to different rectangles?

   631     if ((orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||

   632         (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])) {

   633       // Intersection must be between second and third points

   634       result[0] = orderedX[1];

   635       result[2] = orderedX[2];

   636     } else {

   637       return false;

   638     }

   640     // Y: first and second points belong to different rectangles?

   641     if ((orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||

   642         (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])) {

   643       // Intersection must be between second and third points

   644       result[1] = orderedY[1];

   645       result[3] = orderedY[2];

   646     } else {

   647       return false;

   648     }

   650     return result;

   651   };

   653   Util.sign = function Util_sign(num) {

   654     return num < 0 ? -1 : 1;

   655   };

   657   // TODO(mack): Rename appendToArray

   658   Util.concatenateToArray = function concatenateToArray(arr1, arr2) {

   659     Array.prototype.push.apply(arr1, arr2);

   660   };

   662   Util.prependToArray = function concatenateToArray(arr1, arr2) {

   663     Array.prototype.unshift.apply(arr1, arr2);

   664   };

   666   Util.extendObj = function extendObj(obj1, obj2) {

   667     for (var key in obj2) {

   668       obj1[key] = obj2[key];

   669     }

   670   };

   672   Util.getInheritableProperty = function Util_getInheritableProperty(dict,

   673                                                                      name) {

   674     while (dict && !dict.has(name)) {

   675       dict = dict.get('Parent');

   676     }

   677     if (!dict) {

   678       return null;

   679     }

   680     return dict.get(name);

   681   };

   683   Util.inherit = function Util_inherit(sub, base, prototype) {

   684     sub.prototype = Object.create(base.prototype);

   685     sub.prototype.constructor = sub;

   686     for (var prop in prototype) {

   687       sub.prototype[prop] = prototype[prop];

   688     }

   689   };

   691   Util.loadScript = function Util_loadScript(src, callback) {

   692     var script = document.createElement('script');

   693     var loaded = false;

   694     script.setAttribute('src', src);

   695     if (callback) {

   696       script.onload = function() {

   697         if (!loaded) {

   698           callback();

   699         }

   700         loaded = true;

   701       };

   702     }

   703     document.getElementsByTagName('head')[0].appendChild(script);

   704   };

   706   return Util;

   707 })();

   709 var PageViewport = PDFJS.PageViewport = (function PageViewportClosure() {

   710   function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {

   711     this.viewBox = viewBox;

   712     this.scale = scale;

   713     this.rotation = rotation;

   714     this.offsetX = offsetX;

   715     this.offsetY = offsetY;

   717     // creating transform to convert pdf coordinate system to the normal

   718     // canvas like coordinates taking in account scale and rotation

   719     var centerX = (viewBox[2] + viewBox[0]) / 2;

   720     var centerY = (viewBox[3] + viewBox[1]) / 2;

   721     var rotateA, rotateB, rotateC, rotateD;

   722     rotation = rotation % 360;

   723     rotation = rotation < 0 ? rotation + 360 : rotation;

   724     switch (rotation) {

   725       case 180:

   726         rotateA = -1; rotateB = 0; rotateC = 0; rotateD = 1;

   727         break;

   728       case 90:

   729         rotateA = 0; rotateB = 1; rotateC = 1; rotateD = 0;

   730         break;

   731       case 270:

   732         rotateA = 0; rotateB = -1; rotateC = -1; rotateD = 0;

   733         break;

   734       //case 0:

   735       default:

   736         rotateA = 1; rotateB = 0; rotateC = 0; rotateD = -1;

   737         break;

   738     }

   740     if (dontFlip) {

   741       rotateC = -rotateC; rotateD = -rotateD;

   742     }

   744     var offsetCanvasX, offsetCanvasY;

   745     var width, height;

   746     if (rotateA === 0) {

   747       offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;

   748       offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;

   749       width = Math.abs(viewBox[3] - viewBox[1]) * scale;

   750       height = Math.abs(viewBox[2] - viewBox[0]) * scale;

   751     } else {

   752       offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;

   753       offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;

   754       width = Math.abs(viewBox[2] - viewBox[0]) * scale;

   755       height = Math.abs(viewBox[3] - viewBox[1]) * scale;

   756     }

   757     // creating transform for the following operations:

   758     // translate(-centerX, -centerY), rotate and flip vertically,

   759     // scale, and translate(offsetCanvasX, offsetCanvasY)

   760     this.transform = [

   761       rotateA * scale,

   762       rotateB * scale,

   763       rotateC * scale,

   764       rotateD * scale,

   765       offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,

   766       offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY

   767     ];

   769     this.width = width;

   770     this.height = height;

   771     this.fontScale = scale;

   772   }

   773   PageViewport.prototype = {

   774     clone: function PageViewPort_clone(args) {

   775       args = args || {};

   776       var scale = 'scale' in args ? args.scale : this.scale;

   777       var rotation = 'rotation' in args ? args.rotation : this.rotation;

   778       return new PageViewport(this.viewBox.slice(), scale, rotation,

   779                               this.offsetX, this.offsetY, args.dontFlip);

   780     },

   781     convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {

   782       return Util.applyTransform([x, y], this.transform);

   783     },

   784     convertToViewportRectangle:

   785       function PageViewport_convertToViewportRectangle(rect) {

   786       var tl = Util.applyTransform([rect[0], rect[1]], this.transform);

   787       var br = Util.applyTransform([rect[2], rect[3]], this.transform);

   788       return [tl[0], tl[1], br[0], br[1]];

   789     },

   790     convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {

   791       return Util.applyInverseTransform([x, y], this.transform);

   792     }

   793   };

   794   return PageViewport;

   795 })();

   797 var PDFStringTranslateTable = [

   798   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   799   0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,

   800   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   801   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   802   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   803   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,

   804   0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,

   805   0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,

   806   0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC

   807 ];

   809 function stringToPDFString(str) {

   810   var i, n = str.length, strBuf = [];

   811   if (str[0] === '\xFE' && str[1] === '\xFF') {

   812     // UTF16BE BOM

   813     for (i = 2; i < n; i += 2) {

   814       strBuf.push(String.fromCharCode(

   815         (str.charCodeAt(i) << 8) | str.charCodeAt(i + 1)));

   816     }

   817   } else {

   818     for (i = 0; i < n; ++i) {

   819       var code = PDFStringTranslateTable[str.charCodeAt(i)];

   820       strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));

   821     }

   822   }

   823   return strBuf.join('');

   824 }

   826 function stringToUTF8String(str) {

   827   return decodeURIComponent(escape(str));

   828 }

   830 function isEmptyObj(obj) {

   831   for (var key in obj) {

   832     return false;

   833   }

   834   return true;

   835 }

   837 function isBool(v) {

   838   return typeof v == 'boolean';

   839 }

   841 function isInt(v) {

   842   return typeof v == 'number' && ((v | 0) == v);

   843 }

   845 function isNum(v) {

   846   return typeof v == 'number';

   847 }

   849 function isString(v) {

   850   return typeof v == 'string';

   851 }

   853 function isNull(v) {

   854   return v === null;

   855 }

   857 function isName(v) {

   858   return v instanceof Name;

   859 }

   861 function isCmd(v, cmd) {

   862   return v instanceof Cmd && (!cmd || v.cmd == cmd);

   863 }

   865 function isDict(v, type) {

   866   if (!(v instanceof Dict)) {

   867     return false;

   868   }

   869   if (!type) {

   870     return true;

   871   }

   872   var dictType = v.get('Type');

   873   return isName(dictType) && dictType.name == type;

   874 }

   876 function isArray(v) {

   877   return v instanceof Array;

   878 }

   880 function isStream(v) {

   881   return typeof v == 'object' && v !== null && v !== undefined &&

   882          ('getBytes' in v);

   883 }

   885 function isArrayBuffer(v) {

   886   return typeof v == 'object' && v !== null && v !== undefined &&

   887          ('byteLength' in v);

   888 }

   890 function isRef(v) {

   891   return v instanceof Ref;

   892 }

   894 function isPDFFunction(v) {

   895   var fnDict;

   896   if (typeof v != 'object') {

   897     return false;

   898   } else if (isDict(v)) {

   899     fnDict = v;

   900   } else if (isStream(v)) {

   901     fnDict = v.dict;

   902   } else {

   903     return false;

   904   }

   905   return fnDict.has('FunctionType');

   906 }

   908 /**

   909  * Legacy support for PDFJS Promise implementation.

   910  * TODO remove eventually

   911  * @ignore

   912  */

   913 var LegacyPromise = PDFJS.LegacyPromise = (function LegacyPromiseClosure() {

   914   return function LegacyPromise() {

   915     var resolve, reject;

   916     var promise = new Promise(function (resolve_, reject_) {

   917       resolve = resolve_;

   918       reject = reject_;

   919     });

   920     promise.resolve = resolve;

   921     promise.reject = reject;

   922     return promise;

   923   };

   924 })();

   926 /**

   927  * Polyfill for Promises:

   928  * The following promise implementation tries to generally implment the

   929  * Promise/A+ spec. Some notable differences from other promise libaries are:

   930  * - There currently isn't a seperate deferred and promise object.

   931  * - Unhandled rejections eventually show an error if they aren't handled.

   932  *

   933  * Based off of the work in:

   934  * https://bugzilla.mozilla.org/show_bug.cgi?id=810490

   935  */

   936 (function PromiseClosure() {

   937   if (globalScope.Promise) {

   938     // Promises existing in the DOM/Worker, checking presence of all/resolve

   939     if (typeof globalScope.Promise.all !== 'function') {

   940       globalScope.Promise.all = function (iterable) {

   941         var count = 0, results = [], resolve, reject;

   942         var promise = new globalScope.Promise(function (resolve_, reject_) {

   943           resolve = resolve_;

   944           reject = reject_;

   945         });

   946         iterable.forEach(function (p, i) {

   947           count++;

   948           p.then(function (result) {

   949             results[i] = result;

   950             count--;

   951             if (count === 0) {

   952               resolve(results);

   953             }

   954           }, reject);

   955         });

   956         if (count === 0) {

   957           resolve(results);

   958         }

   959         return promise;

   960       };

   961     }

   962     if (typeof globalScope.Promise.resolve !== 'function') {

   963       globalScope.Promise.resolve = function (x) {

   964         return new globalScope.Promise(function (resolve) { resolve(x); });

   965       };

   966     }

   967     return;

   968   }

   969   throw new Error('DOM Promise is not present');

   970 })();

   972 var StatTimer = (function StatTimerClosure() {

   973   function rpad(str, pad, length) {

   974     while (str.length < length) {

   975       str += pad;

   976     }

   977     return str;

   978   }

   979   function StatTimer() {

   980     this.started = {};

   981     this.times = [];

   982     this.enabled = true;

   983   }

   984   StatTimer.prototype = {

   985     time: function StatTimer_time(name) {

   986       if (!this.enabled) {

   987         return;

   988       }

   989       if (name in this.started) {

   990         warn('Timer is already running for ' + name);

   991       }

   992       this.started[name] = Date.now();

   993     },

   994     timeEnd: function StatTimer_timeEnd(name) {

   995       if (!this.enabled) {

   996         return;

   997       }

   998       if (!(name in this.started)) {

   999         warn('Timer has not been started for ' + name);

  1000       }

  1001       this.times.push({

  1002         'name': name,

  1003         'start': this.started[name],

  1004         'end': Date.now()

  1005       });

  1006       // Remove timer from started so it can be called again.

  1007       delete this.started[name];

  1008     },

  1009     toString: function StatTimer_toString() {

  1010       var i, ii;

  1011       var times = this.times;

  1012       var out = '';

  1013       // Find the longest name for padding purposes.

  1014       var longest = 0;

  1015       for (i = 0, ii = times.length; i < ii; ++i) {

  1016         var name = times[i]['name'];

  1017         if (name.length > longest) {

  1018           longest = name.length;

  1019         }

  1020       }

  1021       for (i = 0, ii = times.length; i < ii; ++i) {

  1022         var span = times[i];

  1023         var duration = span.end - span.start;

  1024         out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n';

  1025       }

  1026       return out;

  1027     }

  1028   };

  1029   return StatTimer;

  1030 })();

  1032 PDFJS.createBlob = function createBlob(data, contentType) {

  1033   if (typeof Blob !== 'undefined') {

  1034     return new Blob([data], { type: contentType });

  1035   }

  1036   // Blob builder is deprecated in FF14 and removed in FF18.

  1037   var bb = new MozBlobBuilder();

  1038   bb.append(data);

  1039   return bb.getBlob(contentType);

  1040 };

  1042 PDFJS.createObjectURL = (function createObjectURLClosure() {

  1043   // Blob/createObjectURL is not available, falling back to data schema.

  1044   var digits =

  1045     'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

  1047   return function createObjectURL(data, contentType) {

  1048     if (!PDFJS.disableCreateObjectURL &&

  1049         typeof URL !== 'undefined' && URL.createObjectURL) {

  1050       var blob = PDFJS.createBlob(data, contentType);

  1051       return URL.createObjectURL(blob);

  1052     }

  1054     var buffer = 'data:' + contentType + ';base64,';

  1055     for (var i = 0, ii = data.length; i < ii; i += 3) {

  1056       var b1 = data[i] & 0xFF;

  1057       var b2 = data[i + 1] & 0xFF;

  1058       var b3 = data[i + 2] & 0xFF;

  1059       var d1 = b1 >> 2, d2 = ((b1 & 3) << 4) | (b2 >> 4);

  1060       var d3 = i + 1 < ii ? ((b2 & 0xF) << 2) | (b3 >> 6) : 64;

  1061       var d4 = i + 2 < ii ? (b3 & 0x3F) : 64;

  1062       buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];

  1063     }

  1064     return buffer;

  1065   };

  1066 })();

  1068 function MessageHandler(name, comObj) {

  1069   this.name = name;

  1070   this.comObj = comObj;

  1071   this.callbackIndex = 1;

  1072   this.postMessageTransfers = true;

  1073   var callbacks = this.callbacks = {};

  1074   var ah = this.actionHandler = {};

  1076   ah['console_log'] = [function ahConsoleLog(data) {

  1077     console.log.apply(console, data);

  1078   }];

  1079   ah['console_error'] = [function ahConsoleError(data) {

  1080     console.error.apply(console, data);

  1081   }];

  1082   ah['_unsupported_feature'] = [function ah_unsupportedFeature(data) {

  1083     UnsupportedManager.notify(data);

  1084   }];

  1086   comObj.onmessage = function messageHandlerComObjOnMessage(event) {

  1087     var data = event.data;

  1088     if (data.isReply) {

  1089       var callbackId = data.callbackId;

  1090       if (data.callbackId in callbacks) {

  1091         var callback = callbacks[callbackId];

  1092         delete callbacks[callbackId];

  1093         callback(data.data);

  1094       } else {

  1095         error('Cannot resolve callback ' + callbackId);

  1096       }

  1097     } else if (data.action in ah) {

  1098       var action = ah[data.action];

  1099       if (data.callbackId) {

  1100         var deferred = {};

  1101         var promise = new Promise(function (resolve, reject) {

  1102           deferred.resolve = resolve;

  1103           deferred.reject = reject;

  1104         });

  1105         deferred.promise = promise;

  1106         promise.then(function(resolvedData) {

  1107           comObj.postMessage({

  1108             isReply: true,

  1109             callbackId: data.callbackId,

  1110             data: resolvedData

  1111           });

  1112         });

  1113         action[0].call(action[1], data.data, deferred);

  1114       } else {

  1115         action[0].call(action[1], data.data);

  1116       }

  1117     } else {

  1118       error('Unkown action from worker: ' + data.action);

  1119     }

  1120   };

  1121 }

  1123 MessageHandler.prototype = {

  1124   on: function messageHandlerOn(actionName, handler, scope) {

  1125     var ah = this.actionHandler;

  1126     if (ah[actionName]) {

  1127       error('There is already an actionName called "' + actionName + '"');

  1128     }

  1129     ah[actionName] = [handler, scope];

  1130   },

  1131   /**

  1132    * Sends a message to the comObj to invoke the action with the supplied data.

  1133    * @param {String} actionName Action to call.

  1134    * @param {JSON} data JSON data to send.

  1135    * @param {function} [callback] Optional callback that will handle a reply.

  1136    * @param {Array} [transfers] Optional list of transfers/ArrayBuffers

  1137    */

  1138   send: function messageHandlerSend(actionName, data, callback, transfers) {

  1139     var message = {

  1140       action: actionName,

  1141       data: data

  1142     };

  1143     if (callback) {

  1144       var callbackId = this.callbackIndex++;

  1145       this.callbacks[callbackId] = callback;

  1146       message.callbackId = callbackId;

  1147     }

  1148     if (transfers && this.postMessageTransfers) {

  1149       this.comObj.postMessage(message, transfers);

  1150     } else {

  1151       this.comObj.postMessage(message);

  1152     }

  1153   }

  1154 };

  1156 function loadJpegStream(id, imageUrl, objs) {

  1157   var img = new Image();

  1158   img.onload = (function loadJpegStream_onloadClosure() {

  1159     objs.resolve(id, img);

  1160   });

  1161   img.src = imageUrl;

  1162 }

  1165 var ColorSpace = (function ColorSpaceClosure() {

  1166   // Constructor should define this.numComps, this.defaultColor, this.name

  1167   function ColorSpace() {

  1168     error('should not call ColorSpace constructor');

  1169   }

  1171   ColorSpace.prototype = {

  1172     /**

  1173      * Converts the color value to the RGB color. The color components are

  1174      * located in the src array starting from the srcOffset. Returns the array

  1175      * of the rgb components, each value ranging from [0,255].

  1176      */

  1177     getRgb: function ColorSpace_getRgb(src, srcOffset) {

  1178       var rgb = new Uint8Array(3);

  1179       this.getRgbItem(src, srcOffset, rgb, 0);

  1180       return rgb;

  1181     },

  1182     /**

  1183      * Converts the color value to the RGB color, similar to the getRgb method.

  1184      * The result placed into the dest array starting from the destOffset.

  1185      */

  1186     getRgbItem: function ColorSpace_getRgbItem(src, srcOffset,

  1187                                                dest, destOffset) {

  1188       error('Should not call ColorSpace.getRgbItem');

  1189     },

  1190     /**

  1191      * Converts the specified number of the color values to the RGB colors.

  1192      * The colors are located in the src array starting from the srcOffset.

  1193      * The result is placed into the dest array starting from the destOffset.

  1194      * The src array items shall be in [0,2^bits) range, the dest array items

  1195      * will be in [0,255] range. alpha01 indicates how many alpha components

  1196      * there are in the dest array; it will be either 0 (RGB array) or 1 (RGBA

  1197      * array).

  1198      */

  1199     getRgbBuffer: function ColorSpace_getRgbBuffer(src, srcOffset, count,

  1200                                                    dest, destOffset, bits,

  1201                                                    alpha01) {

  1202       error('Should not call ColorSpace.getRgbBuffer');

  1203     },

  1204     /**

  1205      * Determines the number of bytes required to store the result of the

  1206      * conversion done by the getRgbBuffer method. As in getRgbBuffer,

  1207      * |alpha01| is either 0 (RGB output) or 1 (RGBA output).

  1208      */

  1209     getOutputLength: function ColorSpace_getOutputLength(inputLength,

  1210                                                          alpha01) {

  1211       error('Should not call ColorSpace.getOutputLength');

  1212     },

  1213     /**

  1214      * Returns true if source data will be equal the result/output data.

  1215      */

  1216     isPassthrough: function ColorSpace_isPassthrough(bits) {

  1217       return false;

  1218     },

  1219     /**

  1220      * Fills in the RGB colors in the destination buffer.  alpha01 indicates

  1221      * how many alpha components there are in the dest array; it will be either

  1222      * 0 (RGB array) or 1 (RGBA array).

  1223      */

  1224     fillRgb: function ColorSpace_fillRgb(dest, originalWidth,

  1225                                          originalHeight, width, height,

  1226                                          actualHeight, bpc, comps, alpha01) {

  1227       var count = originalWidth * originalHeight;

  1228       var rgbBuf = null;

  1229       var numComponentColors = 1 << bpc;

  1230       var needsResizing = originalHeight != height || originalWidth != width;

  1231       var i, ii;

  1233       if (this.isPassthrough(bpc)) {

  1234         rgbBuf = comps;

  1235       } else if (this.numComps === 1 && count > numComponentColors &&

  1236           this.name !== 'DeviceGray' && this.name !== 'DeviceRGB') {

  1237         // Optimization: create a color map when there is just one component and

  1238         // we are converting more colors than the size of the color map. We

  1239         // don't build the map if the colorspace is gray or rgb since those

  1240         // methods are faster than building a map. This mainly offers big speed

  1241         // ups for indexed and alternate colorspaces.

  1242         //

  1243         // TODO it may be worth while to cache the color map. While running

  1244         // testing I never hit a cache so I will leave that out for now (perhaps

  1245         // we are reparsing colorspaces too much?).

  1246         var allColors = bpc <= 8 ? new Uint8Array(numComponentColors) :

  1247                                    new Uint16Array(numComponentColors);

  1248         var key;

  1249         for (i = 0; i < numComponentColors; i++) {

  1250           allColors[i] = i;

  1251         }

  1252         var colorMap = new Uint8Array(numComponentColors * 3);

  1253         this.getRgbBuffer(allColors, 0, numComponentColors, colorMap, 0, bpc,

  1254                           /* alpha01 = */ 0);

  1256         var destPos, rgbPos;

  1257         if (!needsResizing) {

  1258           // Fill in the RGB values directly into |dest|.

  1259           destPos = 0;

  1260           for (i = 0; i < count; ++i) {

  1261             key = comps[i] * 3;

  1262             dest[destPos++] = colorMap[key];

  1263             dest[destPos++] = colorMap[key + 1];

  1264             dest[destPos++] = colorMap[key + 2];

  1265             destPos += alpha01;

  1266           }

  1267         } else {

  1268           rgbBuf = new Uint8Array(count * 3);

  1269           rgbPos = 0;

  1270           for (i = 0; i < count; ++i) {

  1271             key = comps[i] * 3;

  1272             rgbBuf[rgbPos++] = colorMap[key];

  1273             rgbBuf[rgbPos++] = colorMap[key + 1];

  1274             rgbBuf[rgbPos++] = colorMap[key + 2];

  1275           }

  1276         }

  1277       } else {

  1278         if (!needsResizing) {

  1279           // Fill in the RGB values directly into |dest|.

  1280           this.getRgbBuffer(comps, 0, width * actualHeight, dest, 0, bpc,

  1281                             alpha01);

  1282         } else {

  1283           rgbBuf = new Uint8Array(count * 3);

  1284           this.getRgbBuffer(comps, 0, count, rgbBuf, 0, bpc,

  1285                             /* alpha01 = */ 0);

  1286         }

  1287       }

  1289       if (rgbBuf) {

  1290         if (needsResizing) {

  1291           rgbBuf = PDFImage.resize(rgbBuf, bpc, 3, originalWidth,

  1292                                    originalHeight, width, height);

  1293         }

  1294         rgbPos = 0;

  1295         destPos = 0;

  1296         for (i = 0, ii = width * actualHeight; i < ii; i++) {

  1297           dest[destPos++] = rgbBuf[rgbPos++];

  1298           dest[destPos++] = rgbBuf[rgbPos++];

  1299           dest[destPos++] = rgbBuf[rgbPos++];

  1300           destPos += alpha01;

  1301         }

  1302       }

  1303     },

  1304     /**

  1305      * True if the colorspace has components in the default range of [0, 1].

  1306      * This should be true for all colorspaces except for lab color spaces

  1307      * which are [0,100], [-128, 127], [-128, 127].

  1308      */

  1309     usesZeroToOneRange: true

  1310   };

  1312   ColorSpace.parse = function ColorSpace_parse(cs, xref, res) {

  1313     var IR = ColorSpace.parseToIR(cs, xref, res);

  1314     if (IR instanceof AlternateCS) {

  1315       return IR;

  1316     }

  1317     return ColorSpace.fromIR(IR);

  1318   };

  1320   ColorSpace.fromIR = function ColorSpace_fromIR(IR) {

  1321     var name = isArray(IR) ? IR[0] : IR;

  1322     var whitePoint, blackPoint;

  1324     switch (name) {

  1325       case 'DeviceGrayCS':

  1326         return this.singletons.gray;

  1327       case 'DeviceRgbCS':

  1328         return this.singletons.rgb;

  1329       case 'DeviceCmykCS':

  1330         return this.singletons.cmyk;

  1331       case 'CalGrayCS':

  1332         whitePoint = IR[1].WhitePoint;

  1333         blackPoint = IR[1].BlackPoint;

  1334         var gamma = IR[1].Gamma;

  1335         return new CalGrayCS(whitePoint, blackPoint, gamma);

  1336       case 'PatternCS':

  1337         var basePatternCS = IR[1];

  1338         if (basePatternCS) {

  1339           basePatternCS = ColorSpace.fromIR(basePatternCS);

  1340         }

  1341         return new PatternCS(basePatternCS);

  1342       case 'IndexedCS':

  1343         var baseIndexedCS = IR[1];

  1344         var hiVal = IR[2];

  1345         var lookup = IR[3];

  1346         return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup);

  1347       case 'AlternateCS':

  1348         var numComps = IR[1];

  1349         var alt = IR[2];

  1350         var tintFnIR = IR[3];

  1352         return new AlternateCS(numComps, ColorSpace.fromIR(alt),

  1353                                 PDFFunction.fromIR(tintFnIR));

  1354       case 'LabCS':

  1355         whitePoint = IR[1].WhitePoint;

  1356         blackPoint = IR[1].BlackPoint;

  1357         var range = IR[1].Range;

  1358         return new LabCS(whitePoint, blackPoint, range);

  1359       default:

  1360         error('Unkown name ' + name);

  1361     }

  1362     return null;

  1363   };

  1365   ColorSpace.parseToIR = function ColorSpace_parseToIR(cs, xref, res) {

  1366     if (isName(cs)) {

  1367       var colorSpaces = res.get('ColorSpace');

  1368       if (isDict(colorSpaces)) {

  1369         var refcs = colorSpaces.get(cs.name);

  1370         if (refcs) {

  1371           cs = refcs;

  1372         }

  1373       }

  1374     }

  1376     cs = xref.fetchIfRef(cs);

  1377     var mode;

  1379     if (isName(cs)) {

  1380       mode = cs.name;

  1381       this.mode = mode;

  1383       switch (mode) {

  1384         case 'DeviceGray':

  1385         case 'G':

  1386           return 'DeviceGrayCS';

  1387         case 'DeviceRGB':

  1388         case 'RGB':

  1389           return 'DeviceRgbCS';

  1390         case 'DeviceCMYK':

  1391         case 'CMYK':

  1392           return 'DeviceCmykCS';

  1393         case 'Pattern':

  1394           return ['PatternCS', null];

  1395         default:

  1396           error('unrecognized colorspace ' + mode);

  1397       }

  1398     } else if (isArray(cs)) {

  1399       mode = cs[0].name;

  1400       this.mode = mode;

  1401       var numComps, params;

  1403       switch (mode) {

  1404         case 'DeviceGray':

  1405         case 'G':

  1406           return 'DeviceGrayCS';

  1407         case 'DeviceRGB':

  1408         case 'RGB':

  1409           return 'DeviceRgbCS';

  1410         case 'DeviceCMYK':

  1411         case 'CMYK':

  1412           return 'DeviceCmykCS';

  1413         case 'CalGray':

  1414           params = cs[1].getAll();

  1415           return ['CalGrayCS', params];

  1416         case 'CalRGB':

  1417           return 'DeviceRgbCS';

  1418         case 'ICCBased':

  1419           var stream = xref.fetchIfRef(cs[1]);

  1420           var dict = stream.dict;

  1421           numComps = dict.get('N');

  1422           if (numComps == 1) {

  1423             return 'DeviceGrayCS';

  1424           } else if (numComps == 3) {

  1425             return 'DeviceRgbCS';

  1426           } else if (numComps == 4) {

  1427             return 'DeviceCmykCS';

  1428           }

  1429           break;

  1430         case 'Pattern':

  1431           var basePatternCS = cs[1];

  1432           if (basePatternCS) {

  1433             basePatternCS = ColorSpace.parseToIR(basePatternCS, xref, res);

  1434           }

  1435           return ['PatternCS', basePatternCS];

  1436         case 'Indexed':

  1437         case 'I':

  1438           var baseIndexedCS = ColorSpace.parseToIR(cs[1], xref, res);

  1439           var hiVal = cs[2] + 1;

  1440           var lookup = xref.fetchIfRef(cs[3]);

  1441           if (isStream(lookup)) {

  1442             lookup = lookup.getBytes();

  1443           }

  1444           return ['IndexedCS', baseIndexedCS, hiVal, lookup];

  1445         case 'Separation':

  1446         case 'DeviceN':

  1447           var name = cs[1];

  1448           numComps = 1;

  1449           if (isName(name)) {

  1450             numComps = 1;

  1451           } else if (isArray(name)) {

  1452             numComps = name.length;

  1453           }

  1454           var alt = ColorSpace.parseToIR(cs[2], xref, res);

  1455           var tintFnIR = PDFFunction.getIR(xref, xref.fetchIfRef(cs[3]));

  1456           return ['AlternateCS', numComps, alt, tintFnIR];

  1457         case 'Lab':

  1458           params = cs[1].getAll();

  1459           return ['LabCS', params];

  1460         default:

  1461           error('unimplemented color space object "' + mode + '"');

  1462       }

  1463     } else {

  1464       error('unrecognized color space object: "' + cs + '"');

  1465     }

  1466     return null;

  1467   };

  1468   /**

  1469    * Checks if a decode map matches the default decode map for a color space.

  1470    * This handles the general decode maps where there are two values per

  1471    * component. e.g. [0, 1, 0, 1, 0, 1] for a RGB color.

  1472    * This does not handle Lab, Indexed, or Pattern decode maps since they are

  1473    * slightly different.

  1474    * @param {Array} decode Decode map (usually from an image).

  1475    * @param {Number} n Number of components the color space has.

  1476    */

  1477   ColorSpace.isDefaultDecode = function ColorSpace_isDefaultDecode(decode, n) {

  1478     if (!decode) {

  1479       return true;

  1480     }

  1482     if (n * 2 !== decode.length) {

  1483       warn('The decode map is not the correct length');

  1484       return true;

  1485     }

  1486     for (var i = 0, ii = decode.length; i < ii; i += 2) {

  1487       if (decode[i] !== 0 || decode[i + 1] != 1) {

  1488         return false;

  1489       }

  1490     }

  1491     return true;

  1492   };

  1494   ColorSpace.singletons = {

  1495     get gray() {

  1496       return shadow(this, 'gray', new DeviceGrayCS());

  1497     },

  1498     get rgb() {

  1499       return shadow(this, 'rgb', new DeviceRgbCS());

  1500     },

  1501     get cmyk() {

  1502       return shadow(this, 'cmyk', new DeviceCmykCS());

  1503     }

  1504   };

  1506   return ColorSpace;

  1507 })();

  1509 /**

  1510  * Alternate color space handles both Separation and DeviceN color spaces.  A

  1511  * Separation color space is actually just a DeviceN with one color component.

  1512  * Both color spaces use a tinting function to convert colors to a base color

  1513  * space.

  1514  */

  1515 var AlternateCS = (function AlternateCSClosure() {

  1516   function AlternateCS(numComps, base, tintFn) {

  1517     this.name = 'Alternate';

  1518     this.numComps = numComps;

  1519     this.defaultColor = new Float32Array(numComps);

  1520     for (var i = 0; i < numComps; ++i) {

  1521       this.defaultColor[i] = 1;

  1522     }

  1523     this.base = base;

  1524     this.tintFn = tintFn;

  1525   }

  1527   AlternateCS.prototype = {

  1528     getRgb: ColorSpace.prototype.getRgb,

  1529     getRgbItem: function AlternateCS_getRgbItem(src, srcOffset,

  1530                                                 dest, destOffset) {

  1531       var baseNumComps = this.base.numComps;

  1532       var input = 'subarray' in src ?

  1533         src.subarray(srcOffset, srcOffset + this.numComps) :

  1534         Array.prototype.slice.call(src, srcOffset, srcOffset + this.numComps);

  1535       var tinted = this.tintFn(input);

  1536       this.base.getRgbItem(tinted, 0, dest, destOffset);

  1537     },

  1538     getRgbBuffer: function AlternateCS_getRgbBuffer(src, srcOffset, count,

  1539                                                     dest, destOffset, bits,

  1540                                                     alpha01) {

  1541       var tintFn = this.tintFn;

  1542       var base = this.base;

  1543       var scale = 1 / ((1 << bits) - 1);

  1544       var baseNumComps = base.numComps;

  1545       var usesZeroToOneRange = base.usesZeroToOneRange;

  1546       var isPassthrough = (base.isPassthrough(8) || !usesZeroToOneRange) &&

  1547                           alpha01 === 0;

  1548       var pos = isPassthrough ? destOffset : 0;

  1549       var baseBuf = isPassthrough ? dest : new Uint8Array(baseNumComps * count);

  1550       var numComps = this.numComps;

  1552       var scaled = new Float32Array(numComps);

  1553       var i, j;

  1554       for (i = 0; i < count; i++) {

  1555         for (j = 0; j < numComps; j++) {

  1556           scaled[j] = src[srcOffset++] * scale;

  1557         }

  1558         var tinted = tintFn(scaled);

  1559         if (usesZeroToOneRange) {

  1560           for (j = 0; j < baseNumComps; j++) {

  1561             baseBuf[pos++] = tinted[j] * 255;

  1562           }

  1563         } else {

  1564           base.getRgbItem(tinted, 0, baseBuf, pos);

  1565           pos += baseNumComps;

  1566         }

  1567       }

  1568       if (!isPassthrough) {

  1569         base.getRgbBuffer(baseBuf, 0, count, dest, destOffset, 8, alpha01);

  1570       }

  1571     },

  1572     getOutputLength: function AlternateCS_getOutputLength(inputLength,

  1573                                                           alpha01) {

  1574       return this.base.getOutputLength(inputLength *

  1575                                        this.base.numComps / this.numComps,

  1576                                        alpha01);

  1577     },

  1578     isPassthrough: ColorSpace.prototype.isPassthrough,

  1579     fillRgb: ColorSpace.prototype.fillRgb,

  1580     isDefaultDecode: function AlternateCS_isDefaultDecode(decodeMap) {

  1581       return ColorSpace.isDefaultDecode(decodeMap, this.numComps);

  1582     },

  1583     usesZeroToOneRange: true

  1584   };

  1586   return AlternateCS;

  1587 })();

  1589 var PatternCS = (function PatternCSClosure() {

  1590   function PatternCS(baseCS) {

  1591     this.name = 'Pattern';

  1592     this.base = baseCS;

  1593   }

  1594   PatternCS.prototype = {};

  1596   return PatternCS;

  1597 })();

  1599 var IndexedCS = (function IndexedCSClosure() {

  1600   function IndexedCS(base, highVal, lookup) {

  1601     this.name = 'Indexed';

  1602     this.numComps = 1;

  1603     this.defaultColor = new Uint8Array([0]);

  1604     this.base = base;

  1605     this.highVal = highVal;

  1607     var baseNumComps = base.numComps;

  1608     var length = baseNumComps * highVal;

  1609     var lookupArray;

  1611     if (isStream(lookup)) {

  1612       lookupArray = new Uint8Array(length);

  1613       var bytes = lookup.getBytes(length);

  1614       lookupArray.set(bytes);

  1615     } else if (isString(lookup)) {

  1616       lookupArray = new Uint8Array(length);

  1617       for (var i = 0; i < length; ++i) {

  1618         lookupArray[i] = lookup.charCodeAt(i);

  1619       }

  1620     } else if (lookup instanceof Uint8Array || lookup instanceof Array) {

  1621       lookupArray = lookup;

  1622     } else {

  1623       error('Unrecognized lookup table: ' + lookup);

  1624     }

  1625     this.lookup = lookupArray;

  1626   }

  1628   IndexedCS.prototype = {

  1629     getRgb: ColorSpace.prototype.getRgb,

  1630     getRgbItem: function IndexedCS_getRgbItem(src, srcOffset,

  1631                                               dest, destOffset) {

  1632       var numComps = this.base.numComps;

  1633       var start = src[srcOffset] * numComps;

  1634       this.base.getRgbItem(this.lookup, start, dest, destOffset);

  1635     },

  1636     getRgbBuffer: function IndexedCS_getRgbBuffer(src, srcOffset, count,

  1637                                                   dest, destOffset, bits,

  1638                                                   alpha01) {

  1639       var base = this.base;

  1640       var numComps = base.numComps;

  1641       var outputDelta = base.getOutputLength(numComps, alpha01);

  1642       var lookup = this.lookup;

  1644       for (var i = 0; i < count; ++i) {

  1645         var lookupPos = src[srcOffset++] * numComps;

  1646         base.getRgbBuffer(lookup, lookupPos, 1, dest, destOffset, 8, alpha01);

  1647         destOffset += outputDelta;

  1648       }

  1649     },

  1650     getOutputLength: function IndexedCS_getOutputLength(inputLength, alpha01) {

  1651       return this.base.getOutputLength(inputLength * this.base.numComps,

  1652                                        alpha01);

  1653     },

  1654     isPassthrough: ColorSpace.prototype.isPassthrough,

  1655     fillRgb: ColorSpace.prototype.fillRgb,

  1656     isDefaultDecode: function IndexedCS_isDefaultDecode(decodeMap) {

  1657       // indexed color maps shouldn't be changed

  1658       return true;

  1659     },

  1660     usesZeroToOneRange: true

  1661   };

  1662   return IndexedCS;

  1663 })();

  1665 var DeviceGrayCS = (function DeviceGrayCSClosure() {

  1666   function DeviceGrayCS() {

  1667     this.name = 'DeviceGray';

  1668     this.numComps = 1;

  1669     this.defaultColor = new Float32Array([0]);

  1670   }

  1672   DeviceGrayCS.prototype = {

  1673     getRgb: ColorSpace.prototype.getRgb,

  1674     getRgbItem: function DeviceGrayCS_getRgbItem(src, srcOffset,

  1675                                                  dest, destOffset) {

  1676       var c = (src[srcOffset] * 255) | 0;

  1677       c = c < 0 ? 0 : c > 255 ? 255 : c;

  1678       dest[destOffset] = dest[destOffset + 1] = dest[destOffset + 2] = c;

  1679     },

  1680     getRgbBuffer: function DeviceGrayCS_getRgbBuffer(src, srcOffset, count,

  1681                                                      dest, destOffset, bits,

  1682                                                      alpha01) {

  1683       var scale = 255 / ((1 << bits) - 1);

  1684       var j = srcOffset, q = destOffset;

  1685       for (var i = 0; i < count; ++i) {

  1686         var c = (scale * src[j++]) | 0;

  1687         dest[q++] = c;

  1688         dest[q++] = c;

  1689         dest[q++] = c;

  1690         q += alpha01;

  1691       }

  1692     },

  1693     getOutputLength: function DeviceGrayCS_getOutputLength(inputLength,

  1694                                                            alpha01) {

  1695       return inputLength * (3 + alpha01);

  1696     },

  1697     isPassthrough: ColorSpace.prototype.isPassthrough,

  1698     fillRgb: ColorSpace.prototype.fillRgb,

  1699     isDefaultDecode: function DeviceGrayCS_isDefaultDecode(decodeMap) {

  1700       return ColorSpace.isDefaultDecode(decodeMap, this.numComps);

  1701     },

  1702     usesZeroToOneRange: true

  1703   };

  1704   return DeviceGrayCS;

  1705 })();

  1707 var DeviceRgbCS = (function DeviceRgbCSClosure() {

  1708   function DeviceRgbCS() {

  1709     this.name = 'DeviceRGB';

  1710     this.numComps = 3;

  1711     this.defaultColor = new Float32Array([0, 0, 0]);

  1712   }

  1713   DeviceRgbCS.prototype = {

  1714     getRgb: ColorSpace.prototype.getRgb,

  1715     getRgbItem: function DeviceRgbCS_getRgbItem(src, srcOffset,

  1716                                                 dest, destOffset) {

  1717       var r = (src[srcOffset] * 255) | 0;

  1718       var g = (src[srcOffset + 1] * 255) | 0;

  1719       var b = (src[srcOffset + 2] * 255) | 0;

  1720       dest[destOffset] = r < 0 ? 0 : r > 255 ? 255 : r;

  1721       dest[destOffset + 1] = g < 0 ? 0 : g > 255 ? 255 : g;

  1722       dest[destOffset + 2] = b < 0 ? 0 : b > 255 ? 255 : b;

  1723     },

  1724     getRgbBuffer: function DeviceRgbCS_getRgbBuffer(src, srcOffset, count,

  1725                                                     dest, destOffset, bits,

  1726                                                     alpha01) {

  1727       if (bits === 8 && alpha01 === 0) {

  1728         dest.set(src.subarray(srcOffset, srcOffset + count * 3), destOffset);

  1729         return;

  1730       }

  1731       var scale = 255 / ((1 << bits) - 1);

  1732       var j = srcOffset, q = destOffset;

  1733       for (var i = 0; i < count; ++i) {

  1734         dest[q++] = (scale * src[j++]) | 0;

  1735         dest[q++] = (scale * src[j++]) | 0;

  1736         dest[q++] = (scale * src[j++]) | 0;

  1737         q += alpha01;

  1738       }

  1739     },

  1740     getOutputLength: function DeviceRgbCS_getOutputLength(inputLength,

  1741                                                           alpha01) {

  1742       return (inputLength * (3 + alpha01) / 3) | 0;

  1743     },

  1744     isPassthrough: function DeviceRgbCS_isPassthrough(bits) {

  1745       return bits == 8;

  1746     },

  1747     fillRgb: ColorSpace.prototype.fillRgb,

  1748     isDefaultDecode: function DeviceRgbCS_isDefaultDecode(decodeMap) {

  1749       return ColorSpace.isDefaultDecode(decodeMap, this.numComps);

  1750     },

  1751     usesZeroToOneRange: true

  1752   };

  1753   return DeviceRgbCS;

  1754 })();

  1756 var DeviceCmykCS = (function DeviceCmykCSClosure() {

  1757   // The coefficients below was found using numerical analysis: the method of

  1758   // steepest descent for the sum((f_i - color_value_i)^2) for r/g/b colors,

  1759   // where color_value is the tabular value from the table of sampled RGB colors

  1760   // from CMYK US Web Coated (SWOP) colorspace, and f_i is the corresponding

  1761   // CMYK color conversion using the estimation below:

  1762   //   f(A, B,.. N) = Acc+Bcm+Ccy+Dck+c+Fmm+Gmy+Hmk+Im+Jyy+Kyk+Ly+Mkk+Nk+255

  1763   function convertToRgb(src, srcOffset, srcScale, dest, destOffset) {

  1764     var c = src[srcOffset + 0] * srcScale;

  1765     var m = src[srcOffset + 1] * srcScale;

  1766     var y = src[srcOffset + 2] * srcScale;

  1767     var k = src[srcOffset + 3] * srcScale;

  1769     var r =

  1770       (c * (-4.387332384609988 * c + 54.48615194189176 * m +

  1771             18.82290502165302 * y + 212.25662451639585 * k +

  1772             -285.2331026137004) +

  1773        m * (1.7149763477362134 * m - 5.6096736904047315 * y +

  1774             -17.873870861415444 * k - 5.497006427196366) +

  1775        y * (-2.5217340131683033 * y - 21.248923337353073 * k +

  1776             17.5119270841813) +

  1777        k * (-21.86122147463605 * k - 189.48180835922747) + 255) | 0;

  1778     var g =

  1779       (c * (8.841041422036149 * c + 60.118027045597366 * m +

  1780             6.871425592049007 * y + 31.159100130055922 * k +

  1781             -79.2970844816548) +

  1782        m * (-15.310361306967817 * m + 17.575251261109482 * y +

  1783             131.35250912493976 * k - 190.9453302588951) +

  1784        y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) +

  1785        k * (-20.737325471181034 * k - 187.80453709719578) + 255) | 0;

  1786     var b =

  1787       (c * (0.8842522430003296 * c + 8.078677503112928 * m +

  1788             30.89978309703729 * y - 0.23883238689178934 * k +

  1789             -14.183576799673286) +

  1790        m * (10.49593273432072 * m + 63.02378494754052 * y +

  1791             50.606957656360734 * k - 112.23884253719248) +

  1792        y * (0.03296041114873217 * y + 115.60384449646641 * k +

  1793             -193.58209356861505) +

  1794        k * (-22.33816807309886 * k - 180.12613974708367) + 255) | 0;

  1796     dest[destOffset] = r > 255 ? 255 : r < 0 ? 0 : r;

  1797     dest[destOffset + 1] = g > 255 ? 255 : g < 0 ? 0 : g;

  1798     dest[destOffset + 2] = b > 255 ? 255 : b < 0 ? 0 : b;

  1799   }

  1801   function DeviceCmykCS() {

  1802     this.name = 'DeviceCMYK';

  1803     this.numComps = 4;

  1804     this.defaultColor = new Float32Array([0, 0, 0, 1]);

  1805   }

  1806   DeviceCmykCS.prototype = {

  1807     getRgb: ColorSpace.prototype.getRgb,

  1808     getRgbItem: function DeviceCmykCS_getRgbItem(src, srcOffset,

  1809                                                  dest, destOffset) {

  1810       convertToRgb(src, srcOffset, 1, dest, destOffset);

  1811     },

  1812     getRgbBuffer: function DeviceCmykCS_getRgbBuffer(src, srcOffset, count,

  1813                                                      dest, destOffset, bits,

  1814                                                      alpha01) {

  1815       var scale = 1 / ((1 << bits) - 1);

  1816       for (var i = 0; i < count; i++) {

  1817         convertToRgb(src, srcOffset, scale, dest, destOffset);

  1818         srcOffset += 4;

  1819         destOffset += 3 + alpha01;

  1820       }

  1821     },

  1822     getOutputLength: function DeviceCmykCS_getOutputLength(inputLength,

  1823                                                            alpha01) {

  1824       return (inputLength / 4 * (3 + alpha01)) | 0;

  1825     },

  1826     isPassthrough: ColorSpace.prototype.isPassthrough,

  1827     fillRgb: ColorSpace.prototype.fillRgb,

  1828     isDefaultDecode: function DeviceCmykCS_isDefaultDecode(decodeMap) {

  1829       return ColorSpace.isDefaultDecode(decodeMap, this.numComps);

  1830     },

  1831     usesZeroToOneRange: true

  1832   };

  1834   return DeviceCmykCS;

  1835 })();

  1837 //

  1838 // CalGrayCS: Based on "PDF Reference, Sixth Ed", p.245

  1839 //

  1840 var CalGrayCS = (function CalGrayCSClosure() {

  1841   function CalGrayCS(whitePoint, blackPoint, gamma) {

  1842     this.name = 'CalGray';

  1843     this.numComps = 1;

  1844     this.defaultColor = new Float32Array([0]);

  1846     if (!whitePoint) {

  1847       error('WhitePoint missing - required for color space CalGray');

  1848     }

  1849     blackPoint = blackPoint || [0, 0, 0];

  1850     gamma = gamma || 1;

  1852     // Translate arguments to spec variables.

  1853     this.XW = whitePoint[0];

  1854     this.YW = whitePoint[1];

  1855     this.ZW = whitePoint[2];

  1857     this.XB = blackPoint[0];

  1858     this.YB = blackPoint[1];

  1859     this.ZB = blackPoint[2];

  1861     this.G = gamma;

  1863     // Validate variables as per spec.

  1864     if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {

  1865       error('Invalid WhitePoint components for ' + this.name +

  1866             ', no fallback available');

  1867     }

  1869     if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {

  1870       info('Invalid BlackPoint for ' + this.name + ', falling back to default');

  1871       this.XB = this.YB = this.ZB = 0;

  1872     }

  1874     if (this.XB !== 0 || this.YB !== 0 || this.ZB !== 0) {

  1875       warn(this.name + ', BlackPoint: XB: ' + this.XB + ', YB: ' + this.YB +

  1876            ', ZB: ' + this.ZB + ', only default values are supported.');

  1877     }

  1879     if (this.G < 1) {

  1880       info('Invalid Gamma: ' + this.G + ' for ' + this.name +

  1881            ', falling back to default');

  1882       this.G = 1;

  1883     }

  1884   }

  1886   function convertToRgb(cs, src, srcOffset, dest, destOffset, scale) {

  1887     // A represents a gray component of a calibrated gray space.

  1888     // A <---> AG in the spec

  1889     var A = src[srcOffset] * scale;

  1890     var AG = Math.pow(A, cs.G);

  1892     // Computes intermediate variables M, L, N as per spec.

  1893     // Except if other than default BlackPoint values are used.

  1894     var M = cs.XW * AG;

  1895     var L = cs.YW * AG;

  1896     var N = cs.ZW * AG;

  1898     // Decode XYZ, as per spec.

  1899     var X = M;

  1900     var Y = L;

  1901     var Z = N;

  1903     // http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html, Ch 4.

  1904     // This yields values in range [0, 100].

  1905     var Lstar = Math.max(116 * Math.pow(Y, 1 / 3) - 16, 0);

  1907     // Convert values to rgb range [0, 255].

  1908     dest[destOffset] = Lstar * 255 / 100;

  1909     dest[destOffset + 1] = Lstar * 255 / 100;

  1910     dest[destOffset + 2] = Lstar * 255 / 100;

  1911   }

  1913   CalGrayCS.prototype = {

  1914     getRgb: ColorSpace.prototype.getRgb,

  1915     getRgbItem: function CalGrayCS_getRgbItem(src, srcOffset,

  1916                                               dest, destOffset) {

  1917       convertToRgb(this, src, srcOffset, dest, destOffset, 1);

  1918     },

  1919     getRgbBuffer: function CalGrayCS_getRgbBuffer(src, srcOffset, count,

  1920                                                   dest, destOffset, bits,

  1921                                                   alpha01) {

  1922       var scale = 1 / ((1 << bits) - 1);

  1924       for (var i = 0; i < count; ++i) {

  1925         convertToRgb(this, src, srcOffset, dest, destOffset, scale);

  1926         srcOffset += 1;

  1927         destOffset += 3 + alpha01;

  1928       }

  1929     },

  1930     getOutputLength: function CalGrayCS_getOutputLength(inputLength, alpha01) {

  1931       return inputLength * (3 + alpha01);

  1932     },

  1933     isPassthrough: ColorSpace.prototype.isPassthrough,

  1934     fillRgb: ColorSpace.prototype.fillRgb,

  1935     isDefaultDecode: function CalGrayCS_isDefaultDecode(decodeMap) {

  1936       return ColorSpace.isDefaultDecode(decodeMap, this.numComps);

  1937     },

  1938     usesZeroToOneRange: true

  1939   };

  1940   return CalGrayCS;

  1941 })();

  1943 //

  1944 // LabCS: Based on "PDF Reference, Sixth Ed", p.250

  1945 //

  1946 var LabCS = (function LabCSClosure() {

  1947   function LabCS(whitePoint, blackPoint, range) {

  1948     this.name = 'Lab';

  1949     this.numComps = 3;

  1950     this.defaultColor = new Float32Array([0, 0, 0]);

  1952     if (!whitePoint) {

  1953       error('WhitePoint missing - required for color space Lab');

  1954     }

  1955     blackPoint = blackPoint || [0, 0, 0];

  1956     range = range || [-100, 100, -100, 100];

  1958     // Translate args to spec variables

  1959     this.XW = whitePoint[0];

  1960     this.YW = whitePoint[1];

  1961     this.ZW = whitePoint[2];

  1962     this.amin = range[0];

  1963     this.amax = range[1];

  1964     this.bmin = range[2];

  1965     this.bmax = range[3];

  1967     // These are here just for completeness - the spec doesn't offer any

  1968     // formulas that use BlackPoint in Lab

  1969     this.XB = blackPoint[0];

  1970     this.YB = blackPoint[1];

  1971     this.ZB = blackPoint[2];

  1973     // Validate vars as per spec

  1974     if (this.XW < 0 || this.ZW < 0 || this.YW !== 1) {

  1975       error('Invalid WhitePoint components, no fallback available');

  1976     }

  1978     if (this.XB < 0 || this.YB < 0 || this.ZB < 0) {

  1979       info('Invalid BlackPoint, falling back to default');

  1980       this.XB = this.YB = this.ZB = 0;

  1981     }

  1983     if (this.amin > this.amax || this.bmin > this.bmax) {

  1984       info('Invalid Range, falling back to defaults');

  1985       this.amin = -100;

  1986       this.amax = 100;

  1987       this.bmin = -100;

  1988       this.bmax = 100;

  1989     }

  1990   }

  1992   // Function g(x) from spec

  1993   function fn_g(x) {

  1994     if (x >= 6 / 29) {

  1995       return x * x * x;

  1996     } else {

  1997       return (108 / 841) * (x - 4 / 29);

  1998     }

  1999   }

  2001   function decode(value, high1, low2, high2) {

  2002     return low2 + (value) * (high2 - low2) / (high1);

  2003   }

  2005   // If decoding is needed maxVal should be 2^bits per component - 1.

  2006   function convertToRgb(cs, src, srcOffset, maxVal, dest, destOffset) {

  2007     // XXX: Lab input is in the range of [0, 100], [amin, amax], [bmin, bmax]

  2008     // not the usual [0, 1]. If a command like setFillColor is used the src

  2009     // values will already be within the correct range. However, if we are

  2010     // converting an image we have to map the values to the correct range given

  2011     // above.

  2012     // Ls,as,bs <---> L*,a*,b* in the spec

  2013     var Ls = src[srcOffset];

  2014     var as = src[srcOffset + 1];

  2015     var bs = src[srcOffset + 2];

  2016     if (maxVal !== false) {

  2017       Ls = decode(Ls, maxVal, 0, 100);

  2018       as = decode(as, maxVal, cs.amin, cs.amax);

  2019       bs = decode(bs, maxVal, cs.bmin, cs.bmax);

  2020     }

  2022     // Adjust limits of 'as' and 'bs'

  2023     as = as > cs.amax ? cs.amax : as < cs.amin ? cs.amin : as;

  2024     bs = bs > cs.bmax ? cs.bmax : bs < cs.bmin ? cs.bmin : bs;

  2026     // Computes intermediate variables X,Y,Z as per spec

  2027     var M = (Ls + 16) / 116;

  2028     var L = M + (as / 500);

  2029     var N = M - (bs / 200);

  2031     var X = cs.XW * fn_g(L);

  2032     var Y = cs.YW * fn_g(M);

  2033     var Z = cs.ZW * fn_g(N);

  2035     var r, g, b;

  2036     // Using different conversions for D50 and D65 white points,

  2037     // per http://www.color.org/srgb.pdf

  2038     if (cs.ZW < 1) {

  2039       // Assuming D50 (X=0.9642, Y=1.00, Z=0.8249)

  2040       r = X * 3.1339 + Y * -1.6170 + Z * -0.4906;

  2041       g = X * -0.9785 + Y * 1.9160 + Z * 0.0333;

  2042       b = X * 0.0720 + Y * -0.2290 + Z * 1.4057;

  2043     } else {

  2044       // Assuming D65 (X=0.9505, Y=1.00, Z=1.0888)

  2045       r = X * 3.2406 + Y * -1.5372 + Z * -0.4986;

  2046       g = X * -0.9689 + Y * 1.8758 + Z * 0.0415;

  2047       b = X * 0.0557 + Y * -0.2040 + Z * 1.0570;

  2048     }

  2049     // clamp color values to [0,1] range then convert to [0,255] range.

  2050     dest[destOffset] = r <= 0 ? 0 : r >= 1 ? 255 : Math.sqrt(r) * 255 | 0;

  2051     dest[destOffset + 1] = g <= 0 ? 0 : g >= 1 ? 255 : Math.sqrt(g) * 255 | 0;

  2052     dest[destOffset + 2] = b <= 0 ? 0 : b >= 1 ? 255 : Math.sqrt(b) * 255 | 0;

  2053   }

  2055   LabCS.prototype = {

  2056     getRgb: ColorSpace.prototype.getRgb,

  2057     getRgbItem: function LabCS_getRgbItem(src, srcOffset, dest, destOffset) {

  2058       convertToRgb(this, src, srcOffset, false, dest, destOffset);

  2059     },

  2060     getRgbBuffer: function LabCS_getRgbBuffer(src, srcOffset, count,

  2061                                               dest, destOffset, bits,

  2062                                               alpha01) {

  2063       var maxVal = (1 << bits) - 1;

  2064       for (var i = 0; i < count; i++) {

  2065         convertToRgb(this, src, srcOffset, maxVal, dest, destOffset);

  2066         srcOffset += 3;

  2067         destOffset += 3 + alpha01;

  2068       }

  2069     },

  2070     getOutputLength: function LabCS_getOutputLength(inputLength, alpha01) {

  2071       return (inputLength * (3 + alpha01) / 3) | 0;

  2072     },

  2073     isPassthrough: ColorSpace.prototype.isPassthrough,

  2074     isDefaultDecode: function LabCS_isDefaultDecode(decodeMap) {

  2075       // XXX: Decoding is handled with the lab conversion because of the strange

  2076       // ranges that are used.

  2077       return true;

  2078     },

  2079     usesZeroToOneRange: false

  2080   };

  2081   return LabCS;

  2082 })();

  2086 var PDFFunction = (function PDFFunctionClosure() {

  2087   var CONSTRUCT_SAMPLED = 0;

  2088   var CONSTRUCT_INTERPOLATED = 2;

  2089   var CONSTRUCT_STICHED = 3;

  2090   var CONSTRUCT_POSTSCRIPT = 4;

  2092   return {

  2093     getSampleArray: function PDFFunction_getSampleArray(size, outputSize, bps,

  2094                                                        str) {

  2095       var i, ii;

  2096       var length = 1;

  2097       for (i = 0, ii = size.length; i < ii; i++) {

  2098         length *= size[i];

  2099       }

  2100       length *= outputSize;

  2102       var array = [];

  2103       var codeSize = 0;

  2104       var codeBuf = 0;

  2105       // 32 is a valid bps so shifting won't work

  2106       var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);

  2108       var strBytes = str.getBytes((length * bps + 7) / 8);

  2109       var strIdx = 0;

  2110       for (i = 0; i < length; i++) {

  2111         while (codeSize < bps) {

  2112           codeBuf <<= 8;

  2113           codeBuf |= strBytes[strIdx++];

  2114           codeSize += 8;

  2115         }

  2116         codeSize -= bps;

  2117         array.push((codeBuf >> codeSize) * sampleMul);

  2118         codeBuf &= (1 << codeSize) - 1;

  2119       }

  2120       return array;

  2121     },

  2123     getIR: function PDFFunction_getIR(xref, fn) {

  2124       var dict = fn.dict;

  2125       if (!dict) {

  2126         dict = fn;

  2127       }

  2129       var types = [this.constructSampled,

  2130                    null,

  2131                    this.constructInterpolated,

  2132                    this.constructStiched,

  2133                    this.constructPostScript];

  2135       var typeNum = dict.get('FunctionType');

  2136       var typeFn = types[typeNum];

  2137       if (!typeFn) {

  2138         error('Unknown type of function');

  2139       }

  2141       return typeFn.call(this, fn, dict, xref);

  2142     },

  2144     fromIR: function PDFFunction_fromIR(IR) {

  2145       var type = IR[0];

  2146       switch (type) {

  2147         case CONSTRUCT_SAMPLED:

  2148           return this.constructSampledFromIR(IR);

  2149         case CONSTRUCT_INTERPOLATED:

  2150           return this.constructInterpolatedFromIR(IR);

  2151         case CONSTRUCT_STICHED:

  2152           return this.constructStichedFromIR(IR);

  2153         //case CONSTRUCT_POSTSCRIPT:

  2154         default:

  2155           return this.constructPostScriptFromIR(IR);

  2156       }

  2157     },

  2159     parse: function PDFFunction_parse(xref, fn) {

  2160       var IR = this.getIR(xref, fn);

  2161       return this.fromIR(IR);

  2162     },

  2164     constructSampled: function PDFFunction_constructSampled(str, dict) {

  2165       function toMultiArray(arr) {

  2166         var inputLength = arr.length;

  2167         var out = [];

  2168         var index = 0;

  2169         for (var i = 0; i < inputLength; i += 2) {

  2170           out[index] = [arr[i], arr[i + 1]];

  2171           ++index;

  2172         }

  2173         return out;

  2174       }

  2175       var domain = dict.get('Domain');

  2176       var range = dict.get('Range');

  2178       if (!domain || !range) {

  2179         error('No domain or range');

  2180       }

  2182       var inputSize = domain.length / 2;

  2183       var outputSize = range.length / 2;

  2185       domain = toMultiArray(domain);

  2186       range = toMultiArray(range);

  2188       var size = dict.get('Size');

  2189       var bps = dict.get('BitsPerSample');

  2190       var order = dict.get('Order') || 1;

  2191       if (order !== 1) {

  2192         // No description how cubic spline interpolation works in PDF32000:2008

  2193         // As in poppler, ignoring order, linear interpolation may work as good

  2194         info('No support for cubic spline interpolation: ' + order);

  2195       }

  2197       var encode = dict.get('Encode');

  2198       if (!encode) {

  2199         encode = [];

  2200         for (var i = 0; i < inputSize; ++i) {

  2201           encode.push(0);

  2202           encode.push(size[i] - 1);

  2203         }

  2204       }

  2205       encode = toMultiArray(encode);

  2207       var decode = dict.get('Decode');

  2208       if (!decode) {

  2209         decode = range;

  2210       } else {

  2211         decode = toMultiArray(decode);

  2212       }

  2214       var samples = this.getSampleArray(size, outputSize, bps, str);

  2216       return [

  2217         CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size,

  2218         outputSize, Math.pow(2, bps) - 1, range

  2219       ];

  2220     },

  2222     constructSampledFromIR: function PDFFunction_constructSampledFromIR(IR) {

  2223       // See chapter 3, page 109 of the PDF reference

  2224       function interpolate(x, xmin, xmax, ymin, ymax) {

  2225         return ymin + ((x - xmin) * ((ymax - ymin) / (xmax - xmin)));

  2226       }

  2228       return function constructSampledFromIRResult(args) {

  2229         // See chapter 3, page 110 of the PDF reference.

  2230         var m = IR[1];

  2231         var domain = IR[2];

  2232         var encode = IR[3];

  2233         var decode = IR[4];

  2234         var samples = IR[5];

  2235         var size = IR[6];

  2236         var n = IR[7];

  2237         //var mask = IR[8];

  2238         var range = IR[9];

  2240         if (m != args.length) {

  2241           error('Incorrect number of arguments: ' + m + ' != ' +

  2242                 args.length);

  2243         }

  2245         var x = args;

  2247         // Building the cube vertices: its part and sample index

  2248         // http://rjwagner49.com/Mathematics/Interpolation.pdf

  2249         var cubeVertices = 1 << m;

  2250         var cubeN = new Float64Array(cubeVertices);

  2251         var cubeVertex = new Uint32Array(cubeVertices);

  2252         var i, j;

  2253         for (j = 0; j < cubeVertices; j++) {

  2254           cubeN[j] = 1;

  2255         }

  2257         var k = n, pos = 1;

  2258         // Map x_i to y_j for 0 <= i < m using the sampled function.

  2259         for (i = 0; i < m; ++i) {

  2260           // x_i' = min(max(x_i, Domain_2i), Domain_2i+1)

  2261           var domain_2i = domain[i][0];

  2262           var domain_2i_1 = domain[i][1];

  2263           var xi = Math.min(Math.max(x[i], domain_2i), domain_2i_1);

  2265           // e_i = Interpolate(x_i', Domain_2i, Domain_2i+1,

  2266           //                   Encode_2i, Encode_2i+1)

  2267           var e = interpolate(xi, domain_2i, domain_2i_1,

  2268                               encode[i][0], encode[i][1]);

  2270           // e_i' = min(max(e_i, 0), Size_i - 1)

  2271           var size_i = size[i];

  2272           e = Math.min(Math.max(e, 0), size_i - 1);

  2274           // Adjusting the cube: N and vertex sample index

  2275           var e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1;

  2276           var n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0);

  2277           var n1 = e - e0; // (e - e0) / (e1 - e0);

  2278           var offset0 = e0 * k;

  2279           var offset1 = offset0 + k; // e1 * k

  2280           for (j = 0; j < cubeVertices; j++) {

  2281             if (j & pos) {

  2282               cubeN[j] *= n1;

  2283               cubeVertex[j] += offset1;

  2284             } else {

  2285               cubeN[j] *= n0;

  2286               cubeVertex[j] += offset0;

  2287             }

  2288           }

  2290           k *= size_i;

  2291           pos <<= 1;

  2292         }

  2294         var y = new Float64Array(n);

  2295         for (j = 0; j < n; ++j) {

  2296           // Sum all cube vertices' samples portions

  2297           var rj = 0;

  2298           for (i = 0; i < cubeVertices; i++) {

  2299             rj += samples[cubeVertex[i] + j] * cubeN[i];

  2300           }

  2302           // r_j' = Interpolate(r_j, 0, 2^BitsPerSample - 1,

  2303           //                    Decode_2j, Decode_2j+1)

  2304           rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);

  2306           // y_j = min(max(r_j, range_2j), range_2j+1)

  2307           y[j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);

  2308         }

  2310         return y;

  2311       };

  2312     },

  2314     constructInterpolated: function PDFFunction_constructInterpolated(str,

  2315                                                                       dict) {

  2316       var c0 = dict.get('C0') || [0];

  2317       var c1 = dict.get('C1') || [1];

  2318       var n = dict.get('N');

  2320       if (!isArray(c0) || !isArray(c1)) {

  2321         error('Illegal dictionary for interpolated function');

  2322       }

  2324       var length = c0.length;

  2325       var diff = [];

  2326       for (var i = 0; i < length; ++i) {

  2327         diff.push(c1[i] - c0[i]);

  2328       }

  2330       return [CONSTRUCT_INTERPOLATED, c0, diff, n];

  2331     },

  2333     constructInterpolatedFromIR:

  2334       function PDFFunction_constructInterpolatedFromIR(IR) {

  2335       var c0 = IR[1];

  2336       var diff = IR[2];

  2337       var n = IR[3];

  2339       var length = diff.length;

  2341       return function constructInterpolatedFromIRResult(args) {

  2342         var x = n == 1 ? args[0] : Math.pow(args[0], n);

  2344         var out = [];

  2345         for (var j = 0; j < length; ++j) {

  2346           out.push(c0[j] + (x * diff[j]));

  2347         }

  2349         return out;

  2351       };

  2352     },

  2354     constructStiched: function PDFFunction_constructStiched(fn, dict, xref) {

  2355       var domain = dict.get('Domain');

  2357       if (!domain) {

  2358         error('No domain');

  2359       }

  2361       var inputSize = domain.length / 2;

  2362       if (inputSize != 1) {

  2363         error('Bad domain for stiched function');

  2364       }

  2366       var fnRefs = dict.get('Functions');

  2367       var fns = [];

  2368       for (var i = 0, ii = fnRefs.length; i < ii; ++i) {

  2369         fns.push(PDFFunction.getIR(xref, xref.fetchIfRef(fnRefs[i])));

  2370       }

  2372       var bounds = dict.get('Bounds');

  2373       var encode = dict.get('Encode');

  2375       return [CONSTRUCT_STICHED, domain, bounds, encode, fns];

  2376     },

  2378     constructStichedFromIR: function PDFFunction_constructStichedFromIR(IR) {

  2379       var domain = IR[1];

  2380       var bounds = IR[2];

  2381       var encode = IR[3];

  2382       var fnsIR = IR[4];

  2383       var fns = [];

  2385       for (var i = 0, ii = fnsIR.length; i < ii; i++) {

  2386         fns.push(PDFFunction.fromIR(fnsIR[i]));

  2387       }

  2389       return function constructStichedFromIRResult(args) {

  2390         var clip = function constructStichedFromIRClip(v, min, max) {

  2391           if (v > max) {

  2392             v = max;

  2393           } else if (v < min) {

  2394             v = min;

  2395           }

  2396           return v;

  2397         };

  2399         // clip to domain

  2400         var v = clip(args[0], domain[0], domain[1]);

  2401         // calulate which bound the value is in

  2402         for (var i = 0, ii = bounds.length; i < ii; ++i) {

  2403           if (v < bounds[i]) {

  2404             break;

  2405           }

  2406         }

  2408         // encode value into domain of function

  2409         var dmin = domain[0];

  2410         if (i > 0) {

  2411           dmin = bounds[i - 1];

  2412         }

  2413         var dmax = domain[1];

  2414         if (i < bounds.length) {

  2415           dmax = bounds[i];

  2416         }

  2418         var rmin = encode[2 * i];

  2419         var rmax = encode[2 * i + 1];

  2421         var v2 = rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);

  2423         // call the appropriate function

  2424         return fns[i]([v2]);

  2425       };

  2426     },

  2428     constructPostScript: function PDFFunction_constructPostScript(fn, dict,

  2429                                                                   xref) {

  2430       var domain = dict.get('Domain');

  2431       var range = dict.get('Range');

  2433       if (!domain) {

  2434         error('No domain.');

  2435       }

  2437       if (!range) {

  2438         error('No range.');

  2439       }

  2441       var lexer = new PostScriptLexer(fn);

  2442       var parser = new PostScriptParser(lexer);

  2443       var code = parser.parse();

  2445       return [CONSTRUCT_POSTSCRIPT, domain, range, code];

  2446     },

  2448     constructPostScriptFromIR: function PDFFunction_constructPostScriptFromIR(

  2449                                           IR) {

  2450       var domain = IR[1];

  2451       var range = IR[2];

  2452       var code = IR[3];

  2453       var numOutputs = range.length / 2;

  2454       var evaluator = new PostScriptEvaluator(code);

  2455       // Cache the values for a big speed up, the cache size is limited though

  2456       // since the number of possible values can be huge from a PS function.

  2457       var cache = new FunctionCache();

  2458       return function constructPostScriptFromIRResult(args) {

  2459         var initialStack = [];

  2460         for (var i = 0, ii = (domain.length / 2); i < ii; ++i) {

  2461           initialStack.push(args[i]);

  2462         }

  2464         var key = initialStack.join('_');

  2465         if (cache.has(key)) {

  2466           return cache.get(key);

  2467         }

  2469         var stack = evaluator.execute(initialStack);

  2470         var transformed = [];

  2471         for (i = numOutputs - 1; i >= 0; --i) {

  2472           var out = stack.pop();

  2473           var rangeIndex = 2 * i;

  2474           if (out < range[rangeIndex]) {

  2475             out = range[rangeIndex];

  2476           } else if (out > range[rangeIndex + 1]) {

  2477             out = range[rangeIndex + 1];

  2478           }

  2479           transformed[i] = out;

  2480         }

  2481         cache.set(key, transformed);

  2482         return transformed;

  2483       };

  2484     }

  2485   };

  2486 })();

  2488 var FunctionCache = (function FunctionCacheClosure() {

  2489   // Of 10 PDF's with type4 functions the maxium number of distinct values seen

  2490   // was 256. This still may need some tweaking in the future though.

  2491   var MAX_CACHE_SIZE = 1024;

  2492   function FunctionCache() {

  2493     this.cache = {};

  2494     this.total = 0;

  2495   }

  2496   FunctionCache.prototype = {

  2497     has: function FunctionCache_has(key) {

  2498       return key in this.cache;

  2499     },

  2500     get: function FunctionCache_get(key) {

  2501       return this.cache[key];

  2502     },

  2503     set: function FunctionCache_set(key, value) {

  2504       if (this.total < MAX_CACHE_SIZE) {

  2505         this.cache[key] = value;

  2506         this.total++;

  2507       }

  2508     }

  2509   };

  2510   return FunctionCache;

  2511 })();

  2513 var PostScriptStack = (function PostScriptStackClosure() {

  2514   var MAX_STACK_SIZE = 100;

  2515   function PostScriptStack(initialStack) {

  2516     this.stack = initialStack || [];

  2517   }

  2519   PostScriptStack.prototype = {

  2520     push: function PostScriptStack_push(value) {

  2521       if (this.stack.length >= MAX_STACK_SIZE) {

  2522         error('PostScript function stack overflow.');

  2523       }

  2524       this.stack.push(value);

  2525     },

  2526     pop: function PostScriptStack_pop() {

  2527       if (this.stack.length <= 0) {

  2528         error('PostScript function stack underflow.');

  2529       }

  2530       return this.stack.pop();

  2531     },

  2532     copy: function PostScriptStack_copy(n) {

  2533       if (this.stack.length + n >= MAX_STACK_SIZE) {

  2534         error('PostScript function stack overflow.');

  2535       }

  2536       var stack = this.stack;

  2537       for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {

  2538         stack.push(stack[i]);

  2539       }

  2540     },

  2541     index: function PostScriptStack_index(n) {

  2542       this.push(this.stack[this.stack.length - n - 1]);

  2543     },

  2544     // rotate the last n stack elements p times

  2545     roll: function PostScriptStack_roll(n, p) {

  2546       var stack = this.stack;

  2547       var l = stack.length - n;

  2548       var r = stack.length - 1, c = l + (p - Math.floor(p / n) * n), i, j, t;

  2549       for (i = l, j = r; i < j; i++, j--) {

  2550         t = stack[i]; stack[i] = stack[j]; stack[j] = t;

  2551       }

  2552       for (i = l, j = c - 1; i < j; i++, j--) {

  2553         t = stack[i]; stack[i] = stack[j]; stack[j] = t;

  2554       }

  2555       for (i = c, j = r; i < j; i++, j--) {

  2556         t = stack[i]; stack[i] = stack[j]; stack[j] = t;

  2557       }

  2558     }

  2559   };

  2560   return PostScriptStack;

  2561 })();

  2562 var PostScriptEvaluator = (function PostScriptEvaluatorClosure() {

  2563   function PostScriptEvaluator(operators) {

  2564     this.operators = operators;

  2565   }

  2566   PostScriptEvaluator.prototype = {

  2567     execute: function PostScriptEvaluator_execute(initialStack) {

  2568       var stack = new PostScriptStack(initialStack);

  2569       var counter = 0;

  2570       var operators = this.operators;

  2571       var length = operators.length;

  2572       var operator, a, b;

  2573       while (counter < length) {

  2574         operator = operators[counter++];

  2575         if (typeof operator == 'number') {

  2576           // Operator is really an operand and should be pushed to the stack.

  2577           stack.push(operator);

  2578           continue;

  2579         }

  2580         switch (operator) {

  2581           // non standard ps operators

  2582           case 'jz': // jump if false

  2583             b = stack.pop();

  2584             a = stack.pop();

  2585             if (!a) {

  2586               counter = b;

  2587             }

  2588             break;

  2589           case 'j': // jump

  2590             a = stack.pop();

  2591             counter = a;

  2592             break;

  2594           // all ps operators in alphabetical order (excluding if/ifelse)

  2595           case 'abs':

  2596             a = stack.pop();

  2597             stack.push(Math.abs(a));

  2598             break;

  2599           case 'add':

  2600             b = stack.pop();

  2601             a = stack.pop();

  2602             stack.push(a + b);

  2603             break;

  2604           case 'and':

  2605             b = stack.pop();

  2606             a = stack.pop();

  2607             if (isBool(a) && isBool(b)) {

  2608               stack.push(a && b);

  2609             } else {

  2610               stack.push(a & b);

  2611             }

  2612             break;

  2613           case 'atan':

  2614             a = stack.pop();

  2615             stack.push(Math.atan(a));

  2616             break;

  2617           case 'bitshift':

  2618             b = stack.pop();

  2619             a = stack.pop();

  2620             if (a > 0) {

  2621               stack.push(a << b);

  2622             } else {

  2623               stack.push(a >> b);

  2624             }

  2625             break;

  2626           case 'ceiling':

  2627             a = stack.pop();

  2628             stack.push(Math.ceil(a));

  2629             break;

  2630           case 'copy':

  2631             a = stack.pop();

  2632             stack.copy(a);

  2633             break;

  2634           case 'cos':

  2635             a = stack.pop();

  2636             stack.push(Math.cos(a));

  2637             break;

  2638           case 'cvi':

  2639             a = stack.pop() | 0;

  2640             stack.push(a);

  2641             break;

  2642           case 'cvr':

  2643             // noop

  2644             break;

  2645           case 'div':

  2646             b = stack.pop();

  2647             a = stack.pop();

  2648             stack.push(a / b);

  2649             break;

  2650           case 'dup':

  2651             stack.copy(1);

  2652             break;

  2653           case 'eq':

  2654             b = stack.pop();

  2655             a = stack.pop();

  2656             stack.push(a == b);

  2657             break;

  2658           case 'exch':

  2659             stack.roll(2, 1);

  2660             break;

  2661           case 'exp':

  2662             b = stack.pop();

  2663             a = stack.pop();

  2664             stack.push(Math.pow(a, b));

  2665             break;

  2666           case 'false':

  2667             stack.push(false);

  2668             break;

  2669           case 'floor':

  2670             a = stack.pop();

  2671             stack.push(Math.floor(a));

  2672             break;

  2673           case 'ge':

  2674             b = stack.pop();

  2675             a = stack.pop();

  2676             stack.push(a >= b);

  2677             break;

  2678           case 'gt':

  2679             b = stack.pop();

  2680             a = stack.pop();

  2681             stack.push(a > b);

  2682             break;

  2683           case 'idiv':

  2684             b = stack.pop();

  2685             a = stack.pop();

  2686             stack.push((a / b) | 0);

  2687             break;

  2688           case 'index':

  2689             a = stack.pop();

  2690             stack.index(a);

  2691             break;

  2692           case 'le':

  2693             b = stack.pop();

  2694             a = stack.pop();

  2695             stack.push(a <= b);

  2696             break;

  2697           case 'ln':

  2698             a = stack.pop();

  2699             stack.push(Math.log(a));

  2700             break;

  2701           case 'log':

  2702             a = stack.pop();

  2703             stack.push(Math.log(a) / Math.LN10);

  2704             break;

  2705           case 'lt':

  2706             b = stack.pop();

  2707             a = stack.pop();

  2708             stack.push(a < b);

  2709             break;

  2710           case 'mod':

  2711             b = stack.pop();

  2712             a = stack.pop();

  2713             stack.push(a % b);

  2714             break;

  2715           case 'mul':

  2716             b = stack.pop();

  2717             a = stack.pop();

  2718             stack.push(a * b);

  2719             break;

  2720           case 'ne':

  2721             b = stack.pop();

  2722             a = stack.pop();

  2723             stack.push(a != b);

  2724             break;

  2725           case 'neg':

  2726             a = stack.pop();

  2727             stack.push(-b);

  2728             break;

  2729           case 'not':

  2730             a = stack.pop();

  2731             if (isBool(a) && isBool(b)) {

  2732               stack.push(a && b);

  2733             } else {

  2734               stack.push(a & b);

  2735             }

  2736             break;

  2737           case 'or':

  2738             b = stack.pop();

  2739             a = stack.pop();

  2740             if (isBool(a) && isBool(b)) {

  2741               stack.push(a || b);

  2742             } else {

  2743               stack.push(a | b);

  2744             }

  2745             break;

  2746           case 'pop':

  2747             stack.pop();

  2748             break;

  2749           case 'roll':

  2750             b = stack.pop();

  2751             a = stack.pop();

  2752             stack.roll(a, b);

  2753             break;

  2754           case 'round':

  2755             a = stack.pop();

  2756             stack.push(Math.round(a));

  2757             break;

  2758           case 'sin':

  2759             a = stack.pop();

  2760             stack.push(Math.sin(a));

  2761             break;

  2762           case 'sqrt':

  2763             a = stack.pop();

  2764             stack.push(Math.sqrt(a));

  2765             break;

  2766           case 'sub':

  2767             b = stack.pop();

  2768             a = stack.pop();

  2769             stack.push(a - b);

  2770             break;

  2771           case 'true':

  2772             stack.push(true);

  2773             break;

  2774           case 'truncate':

  2775             a = stack.pop();

  2776             a = a < 0 ? Math.ceil(a) : Math.floor(a);

  2777             stack.push(a);

  2778             break;

  2779           case 'xor':

  2780             b = stack.pop();

  2781             a = stack.pop();

  2782             if (isBool(a) && isBool(b)) {

  2783               stack.push(a != b);

  2784             } else {

  2785               stack.push(a ^ b);

  2786             }

  2787             break;

  2788           default:

  2789             error('Unknown operator ' + operator);

  2790             break;

  2791         }

  2792       }

  2793       return stack.stack;

  2794     }

  2795   };

  2796   return PostScriptEvaluator;

  2797 })();

  2800 var HIGHLIGHT_OFFSET = 4; // px

  2801 var SUPPORTED_TYPES = ['Link', 'Text', 'Widget'];

  2803 var Annotation = (function AnnotationClosure() {

  2804   // 12.5.5: Algorithm: Appearance streams

  2805   function getTransformMatrix(rect, bbox, matrix) {

  2806     var bounds = Util.getAxialAlignedBoundingBox(bbox, matrix);

  2807     var minX = bounds[0];

  2808     var minY = bounds[1];

  2809     var maxX = bounds[2];

  2810     var maxY = bounds[3];

  2812     if (minX === maxX || minY === maxY) {

  2813       // From real-life file, bbox was [0, 0, 0, 0]. In this case,

  2814       // just apply the transform for rect

  2815       return [1, 0, 0, 1, rect[0], rect[1]];

  2816     }

  2818     var xRatio = (rect[2] - rect[0]) / (maxX - minX);

  2819     var yRatio = (rect[3] - rect[1]) / (maxY - minY);

  2820     return [

  2821       xRatio,

  2822       0,

  2823       0,

  2824       yRatio,

  2825       rect[0] - minX * xRatio,

  2826       rect[1] - minY * yRatio

  2827     ];

  2828   }

  2830   function getDefaultAppearance(dict) {

  2831     var appearanceState = dict.get('AP');

  2832     if (!isDict(appearanceState)) {

  2833       return;

  2834     }

  2836     var appearance;

  2837     var appearances = appearanceState.get('N');

  2838     if (isDict(appearances)) {

  2839       var as = dict.get('AS');

  2840       if (as && appearances.has(as.name)) {

  2841         appearance = appearances.get(as.name);

  2842       }

  2843     } else {

  2844       appearance = appearances;

  2845     }

  2846     return appearance;

  2847   }

  2849   function Annotation(params) {

  2850     if (params.data) {

  2851       this.data = params.data;

  2852       return;

  2853     }

  2855     var dict = params.dict;

  2856     var data = this.data = {};

  2858     data.subtype = dict.get('Subtype').name;

  2859     var rect = dict.get('Rect') || [0, 0, 0, 0];

  2860     data.rect = Util.normalizeRect(rect);

  2861     data.annotationFlags = dict.get('F');

  2863     var color = dict.get('C');

  2864     if (isArray(color) && color.length === 3) {

  2865       // TODO(mack): currently only supporting rgb; need support different

  2866       // colorspaces

  2867       data.color = color;

  2868     } else {

  2869       data.color = [0, 0, 0];

  2870     }

  2872     // Some types of annotations have border style dict which has more

  2873     // info than the border array

  2874     if (dict.has('BS')) {

  2875       var borderStyle = dict.get('BS');

  2876       data.borderWidth = borderStyle.has('W') ? borderStyle.get('W') : 1;

  2877     } else {

  2878       var borderArray = dict.get('Border') || [0, 0, 1];

  2879       data.borderWidth = borderArray[2] || 0;

  2881       // TODO: implement proper support for annotations with line dash patterns.

  2882       var dashArray = borderArray[3];

  2883       if (data.borderWidth > 0 && dashArray && isArray(dashArray)) {

  2884         var dashArrayLength = dashArray.length;

  2885         if (dashArrayLength > 0) {

  2886           // According to the PDF specification: the elements in a dashArray

  2887           // shall be numbers that are nonnegative and not all equal to zero.

  2888           var isInvalid = false;

  2889           var numPositive = 0;

  2890           for (var i = 0; i < dashArrayLength; i++) {

  2891             var validNumber = (+dashArray[i] >= 0);

  2892             if (!validNumber) {

  2893               isInvalid = true;

  2894               break;

  2895             } else if (dashArray[i] > 0) {

  2896               numPositive++;

  2897             }

  2898           }

  2899           if (isInvalid || numPositive === 0) {

  2900             data.borderWidth = 0;

  2901           }

  2902         }

  2903       }

  2904     }

  2906     this.appearance = getDefaultAppearance(dict);

  2907     data.hasAppearance = !!this.appearance;

  2908     data.id = params.ref.num;

  2909   }

  2911   Annotation.prototype = {

  2913     getData: function Annotation_getData() {

  2914       return this.data;

  2915     },

  2917     hasHtml: function Annotation_hasHtml() {

  2918       return false;

  2919     },

  2921     getHtmlElement: function Annotation_getHtmlElement(commonObjs) {

  2922       throw new NotImplementedException(

  2923         'getHtmlElement() should be implemented in subclass');

  2924     },

  2926     // TODO(mack): Remove this, it's not really that helpful.

  2927     getEmptyContainer: function Annotation_getEmptyContainer(tagName, rect,

  2928                                                              borderWidth) {

  2929       assert(!isWorker,

  2930         'getEmptyContainer() should be called from main thread');

  2932       var bWidth = borderWidth || 0;

  2934       rect = rect || this.data.rect;

  2935       var element = document.createElement(tagName);

  2936       element.style.borderWidth = bWidth + 'px';

  2937       var width = rect[2] - rect[0] - 2 * bWidth;

  2938       var height = rect[3] - rect[1] - 2 * bWidth;

  2939       element.style.width = width + 'px';

  2940       element.style.height = height + 'px';

  2941       return element;

  2942     },

  2944     isInvisible: function Annotation_isInvisible() {

  2945       var data = this.data;

  2946       if (data && SUPPORTED_TYPES.indexOf(data.subtype) !== -1) {

  2947         return false;

  2948       } else {

  2949         return !!(data &&

  2950                   data.annotationFlags &&            // Default: not invisible

  2951                   data.annotationFlags & 0x1);       // Invisible

  2952       }

  2953     },

  2955     isViewable: function Annotation_isViewable() {

  2956       var data = this.data;

  2957       return !!(!this.isInvisible() &&

  2958                 data &&

  2959                 (!data.annotationFlags ||

  2960                  !(data.annotationFlags & 0x22)) &&  // Hidden or NoView

  2961                 data.rect);                          // rectangle is nessessary

  2962     },

  2964     isPrintable: function Annotation_isPrintable() {

  2965       var data = this.data;

  2966       return !!(!this.isInvisible() &&

  2967                 data &&

  2968                 data.annotationFlags &&              // Default: not printable

  2969                 data.annotationFlags & 0x4 &&        // Print

  2970                 data.rect);                          // rectangle is nessessary

  2971     },

  2973     loadResources: function(keys) {

  2974       var promise = new LegacyPromise();

  2975       this.appearance.dict.getAsync('Resources').then(function(resources) {

  2976         if (!resources) {

  2977           promise.resolve();

  2978           return;

  2979         }

  2980         var objectLoader = new ObjectLoader(resources.map,

  2981                                             keys,

  2982                                             resources.xref);

  2983         objectLoader.load().then(function() {

  2984           promise.resolve(resources);

  2985         });

  2986       }.bind(this));

  2988       return promise;

  2989     },

  2991     getOperatorList: function Annotation_getOperatorList(evaluator) {

  2993       var promise = new LegacyPromise();

  2995       if (!this.appearance) {

  2996         promise.resolve(new OperatorList());

  2997         return promise;

  2998       }

  3000       var data = this.data;

  3002       var appearanceDict = this.appearance.dict;

  3003       var resourcesPromise = this.loadResources([

  3004         'ExtGState',

  3005         'ColorSpace',

  3006         'Pattern',

  3007         'Shading',

  3008         'XObject',

  3009         'Font'

  3010         // ProcSet

  3011         // Properties

  3012       ]);

  3013       var bbox = appearanceDict.get('BBox') || [0, 0, 1, 1];

  3014       var matrix = appearanceDict.get('Matrix') || [1, 0, 0, 1, 0 ,0];

  3015       var transform = getTransformMatrix(data.rect, bbox, matrix);

  3017       resourcesPromise.then(function(resources) {

  3018         var opList = new OperatorList();

  3019         opList.addOp(OPS.beginAnnotation, [data.rect, transform, matrix]);

  3020         evaluator.getOperatorList(this.appearance, resources, opList);

  3021         opList.addOp(OPS.endAnnotation, []);

  3022         promise.resolve(opList);

  3024         this.appearance.reset();

  3025       }.bind(this));

  3027       return promise;

  3028     }

  3029   };

  3031   Annotation.getConstructor =

  3032       function Annotation_getConstructor(subtype, fieldType) {

  3034     if (!subtype) {

  3035       return;

  3036     }

  3038     // TODO(mack): Implement FreeText annotations

  3039     if (subtype === 'Link') {

  3040       return LinkAnnotation;

  3041     } else if (subtype === 'Text') {

  3042       return TextAnnotation;

  3043     } else if (subtype === 'Widget') {

  3044       if (!fieldType) {

  3045         return;

  3046       }

  3048       if (fieldType === 'Tx') {

  3049         return TextWidgetAnnotation;

  3050       } else {

  3051         return WidgetAnnotation;

  3052       }

  3053     } else {

  3054       return Annotation;

  3055     }

  3056   };

  3058   // TODO(mack): Support loading annotation from data

  3059   Annotation.fromData = function Annotation_fromData(data) {

  3060     var subtype = data.subtype;

  3061     var fieldType = data.fieldType;

  3062     var Constructor = Annotation.getConstructor(subtype, fieldType);

  3063     if (Constructor) {

  3064       return new Constructor({ data: data });

  3065     }

  3066   };

  3068   Annotation.fromRef = function Annotation_fromRef(xref, ref) {

  3070     var dict = xref.fetchIfRef(ref);

  3071     if (!isDict(dict)) {

  3072       return;

  3073     }

  3075     var subtype = dict.get('Subtype');

  3076     subtype = isName(subtype) ? subtype.name : '';

  3077     if (!subtype) {

  3078       return;

  3079     }

  3081     var fieldType = Util.getInheritableProperty(dict, 'FT');

  3082     fieldType = isName(fieldType) ? fieldType.name : '';

  3084     var Constructor = Annotation.getConstructor(subtype, fieldType);

  3085     if (!Constructor) {

  3086       return;

  3087     }

  3089     var params = {

  3090       dict: dict,

  3091       ref: ref,

  3092     };

  3094     var annotation = new Constructor(params);

  3096     if (annotation.isViewable() || annotation.isPrintable()) {

  3097       return annotation;

  3098     } else {

  3099       warn('unimplemented annotation type: ' + subtype);

  3100     }

  3101   };

  3103   Annotation.appendToOperatorList = function Annotation_appendToOperatorList(

  3104       annotations, opList, pdfManager, partialEvaluator, intent) {

  3106     function reject(e) {

  3107       annotationsReadyPromise.reject(e);

  3108     }

  3110     var annotationsReadyPromise = new LegacyPromise();

  3112     var annotationPromises = [];

  3113     for (var i = 0, n = annotations.length; i < n; ++i) {

  3114       if (intent === 'display' && annotations[i].isViewable() ||

  3115           intent === 'print' && annotations[i].isPrintable()) {

  3116         annotationPromises.push(

  3117           annotations[i].getOperatorList(partialEvaluator));

  3118       }

  3119     }

  3120     Promise.all(annotationPromises).then(function(datas) {

  3121       opList.addOp(OPS.beginAnnotations, []);

  3122       for (var i = 0, n = datas.length; i < n; ++i) {

  3123         var annotOpList = datas[i];

  3124         opList.addOpList(annotOpList);

  3125       }

  3126       opList.addOp(OPS.endAnnotations, []);

  3127       annotationsReadyPromise.resolve();

  3128     }, reject);

  3130     return annotationsReadyPromise;

  3131   };

  3133   return Annotation;

  3134 })();

  3135 PDFJS.Annotation = Annotation;

  3138 var WidgetAnnotation = (function WidgetAnnotationClosure() {

  3140   function WidgetAnnotation(params) {

  3141     Annotation.call(this, params);

  3143     if (params.data) {

  3144       return;

  3145     }

  3147     var dict = params.dict;

  3148     var data = this.data;

  3150     data.fieldValue = stringToPDFString(

  3151       Util.getInheritableProperty(dict, 'V') || '');

  3152     data.alternativeText = stringToPDFString(dict.get('TU') || '');

  3153     data.defaultAppearance = Util.getInheritableProperty(dict, 'DA') || '';

  3154     var fieldType = Util.getInheritableProperty(dict, 'FT');

  3155     data.fieldType = isName(fieldType) ? fieldType.name : '';

  3156     data.fieldFlags = Util.getInheritableProperty(dict, 'Ff') || 0;

  3157     this.fieldResources = Util.getInheritableProperty(dict, 'DR') || Dict.empty;

  3159     // Building the full field name by collecting the field and

  3160     // its ancestors 'T' data and joining them using '.'.

  3161     var fieldName = [];

  3162     var namedItem = dict;

  3163     var ref = params.ref;

  3164     while (namedItem) {

  3165       var parent = namedItem.get('Parent');

  3166       var parentRef = namedItem.getRaw('Parent');

  3167       var name = namedItem.get('T');

  3168       if (name) {

  3169         fieldName.unshift(stringToPDFString(name));

  3170       } else {

  3171         // The field name is absent, that means more than one field

  3172         // with the same name may exist. Replacing the empty name

  3173         // with the '`' plus index in the parent's 'Kids' array.

  3174         // This is not in the PDF spec but necessary to id the

  3175         // the input controls.

  3176         var kids = parent.get('Kids');

  3177         var j, jj;

  3178         for (j = 0, jj = kids.length; j < jj; j++) {

  3179           var kidRef = kids[j];

  3180           if (kidRef.num == ref.num && kidRef.gen == ref.gen) {

  3181             break;

  3182           }

  3183         }

  3184         fieldName.unshift('`' + j);

  3185       }

  3186       namedItem = parent;

  3187       ref = parentRef;

  3188     }

  3189     data.fullName = fieldName.join('.');

  3190   }

  3192   var parent = Annotation.prototype;

  3193   Util.inherit(WidgetAnnotation, Annotation, {

  3194     isViewable: function WidgetAnnotation_isViewable() {

  3195       if (this.data.fieldType === 'Sig') {

  3196         warn('unimplemented annotation type: Widget signature');

  3197         return false;

  3198       }

  3200       return parent.isViewable.call(this);

  3201     }

  3202   });

  3204   return WidgetAnnotation;

  3205 })();

  3207 var TextWidgetAnnotation = (function TextWidgetAnnotationClosure() {

  3208   function TextWidgetAnnotation(params) {

  3209     WidgetAnnotation.call(this, params);

  3211     if (params.data) {

  3212       return;

  3213     }

  3215     this.data.textAlignment = Util.getInheritableProperty(params.dict, 'Q');

  3216   }

  3218   // TODO(mack): This dupes some of the logic in CanvasGraphics.setFont()

  3219   function setTextStyles(element, item, fontObj) {

  3221     var style = element.style;

  3222     style.fontSize = item.fontSize + 'px';

  3223     style.direction = item.fontDirection < 0 ? 'rtl': 'ltr';

  3225     if (!fontObj) {

  3226       return;

  3227     }

  3229     style.fontWeight = fontObj.black ?

  3230                             (fontObj.bold ? 'bolder' : 'bold') :

  3231                             (fontObj.bold ? 'bold' : 'normal');

  3232     style.fontStyle = fontObj.italic ? 'italic' : 'normal';

  3234     var fontName = fontObj.loadedName;

  3235     var fontFamily = fontName ? '"' + fontName + '", ' : '';

  3236     // Use a reasonable default font if the font doesn't specify a fallback

  3237     var fallbackName = fontObj.fallbackName || 'Helvetica, sans-serif';

  3238     style.fontFamily = fontFamily + fallbackName;

  3239   }

  3242   Util.inherit(TextWidgetAnnotation, WidgetAnnotation, {

  3243     hasHtml: function TextWidgetAnnotation_hasHtml() {

  3244       return !this.data.hasAppearance && !!this.data.fieldValue;

  3245     },

  3247     getHtmlElement: function TextWidgetAnnotation_getHtmlElement(commonObjs) {

  3248       assert(!isWorker, 'getHtmlElement() shall be called from main thread');

  3250       var item = this.data;

  3252       var element = this.getEmptyContainer('div');

  3253       element.style.display = 'table';

  3255       var content = document.createElement('div');

  3256       content.textContent = item.fieldValue;

  3257       var textAlignment = item.textAlignment;

  3258       content.style.textAlign = ['left', 'center', 'right'][textAlignment];

  3259       content.style.verticalAlign = 'middle';

  3260       content.style.display = 'table-cell';

  3262       var fontObj = item.fontRefName ?

  3263                     commonObjs.getData(item.fontRefName) : null;

  3264       setTextStyles(content, item, fontObj);

  3266       element.appendChild(content);

  3268       return element;

  3269     },

  3271     getOperatorList: function TextWidgetAnnotation_getOperatorList(evaluator) {

  3272       if (this.appearance) {

  3273         return Annotation.prototype.getOperatorList.call(this, evaluator);

  3274       }

  3276       var promise = new LegacyPromise();

  3277       var opList = new OperatorList();

  3278       var data = this.data;

  3280       // Even if there is an appearance stream, ignore it. This is the

  3281       // behaviour used by Adobe Reader.

  3283       var defaultAppearance = data.defaultAppearance;

  3284       if (!defaultAppearance) {

  3285         promise.resolve(opList);

  3286         return promise;

  3287       }

  3289       // Include any font resources found in the default appearance

  3291       var stream = new Stream(stringToBytes(defaultAppearance));

  3292       evaluator.getOperatorList(stream, this.fieldResources, opList);

  3293       var appearanceFnArray = opList.fnArray;

  3294       var appearanceArgsArray = opList.argsArray;

  3295       var fnArray = [];

  3297       // TODO(mack): Add support for stroke color

  3298       data.rgb = [0, 0, 0];

  3299       // TODO THIS DOESN'T MAKE ANY SENSE SINCE THE fnArray IS EMPTY!

  3300       for (var i = 0, n = fnArray.length; i < n; ++i) {

  3301         var fnId = appearanceFnArray[i];

  3302         var args = appearanceArgsArray[i];

  3304         if (fnId === OPS.setFont) {

  3305           data.fontRefName = args[0];

  3306           var size = args[1];

  3307           if (size < 0) {

  3308             data.fontDirection = -1;

  3309             data.fontSize = -size;

  3310           } else {

  3311             data.fontDirection = 1;

  3312             data.fontSize = size;

  3313           }

  3314         } else if (fnId === OPS.setFillRGBColor) {

  3315           data.rgb = args;

  3316         } else if (fnId === OPS.setFillGray) {

  3317           var rgbValue = args[0] * 255;

  3318           data.rgb = [rgbValue, rgbValue, rgbValue];

  3319         }

  3320       }

  3321       promise.resolve(opList);

  3322       return promise;

  3323     }

  3324   });

  3326   return TextWidgetAnnotation;

  3327 })();

  3329 var InteractiveAnnotation = (function InteractiveAnnotationClosure() {

  3330   function InteractiveAnnotation(params) {

  3331     Annotation.call(this, params);

  3332   }

  3334   Util.inherit(InteractiveAnnotation, Annotation, {

  3335     hasHtml: function InteractiveAnnotation_hasHtml() {

  3336       return true;

  3337     },

  3339     highlight: function InteractiveAnnotation_highlight() {

  3340       if (this.highlightElement &&

  3341          this.highlightElement.hasAttribute('hidden')) {

  3342         this.highlightElement.removeAttribute('hidden');

  3343       }

  3344     },

  3346     unhighlight: function InteractiveAnnotation_unhighlight() {

  3347       if (this.highlightElement &&

  3348          !this.highlightElement.hasAttribute('hidden')) {

  3349         this.highlightElement.setAttribute('hidden', true);

  3350       }

  3351     },

  3353     initContainer: function InteractiveAnnotation_initContainer() {

  3355       var item = this.data;

  3356       var rect = item.rect;

  3358       var container = this.getEmptyContainer('section', rect, item.borderWidth);

  3359       container.style.backgroundColor = item.color;

  3361       var color = item.color;

  3362       var rgb = [];

  3363       for (var i = 0; i < 3; ++i) {

  3364         rgb[i] = Math.round(color[i] * 255);

  3365       }

  3366       item.colorCssRgb = Util.makeCssRgb(rgb);

  3368       var highlight = document.createElement('div');

  3369       highlight.className = 'annotationHighlight';

  3370       highlight.style.left = highlight.style.top = -HIGHLIGHT_OFFSET + 'px';

  3371       highlight.style.right = highlight.style.bottom = -HIGHLIGHT_OFFSET + 'px';

  3372       highlight.setAttribute('hidden', true);

  3374       this.highlightElement = highlight;

  3375       container.appendChild(this.highlightElement);

  3377       return container;

  3378     }

  3379   });

  3381   return InteractiveAnnotation;

  3382 })();

  3384 var TextAnnotation = (function TextAnnotationClosure() {

  3385   function TextAnnotation(params) {

  3386     InteractiveAnnotation.call(this, params);

  3388     if (params.data) {

  3389       return;

  3390     }

  3392     var dict = params.dict;

  3393     var data = this.data;

  3395     var content = dict.get('Contents');

  3396     var title = dict.get('T');

  3397     data.content = stringToPDFString(content || '');

  3398     data.title = stringToPDFString(title || '');

  3400     if (data.hasAppearance) {

  3401       data.name = 'NoIcon';

  3402     } else {

  3403       data.name = dict.has('Name') ? dict.get('Name').name : 'Note';

  3404     }

  3406     if (dict.has('C')) {

  3407       data.hasBgColor = true;

  3408     }

  3409   }

  3411   var ANNOT_MIN_SIZE = 10;

  3413   Util.inherit(TextAnnotation, InteractiveAnnotation, {

  3415     getHtmlElement: function TextAnnotation_getHtmlElement(commonObjs) {

  3416       assert(!isWorker, 'getHtmlElement() shall be called from main thread');

  3418       var item = this.data;

  3419       var rect = item.rect;

  3421       // sanity check because of OOo-generated PDFs

  3422       if ((rect[3] - rect[1]) < ANNOT_MIN_SIZE) {

  3423         rect[3] = rect[1] + ANNOT_MIN_SIZE;

  3424       }

  3425       if ((rect[2] - rect[0]) < ANNOT_MIN_SIZE) {

  3426         rect[2] = rect[0] + (rect[3] - rect[1]); // make it square

  3427       }

  3429       var container = this.initContainer();

  3430       container.className = 'annotText';

  3432       var image  = document.createElement('img');

  3433       image.style.height = container.style.height;

  3434       image.style.width = container.style.width;

  3435       var iconName = item.name;

  3436       image.src = PDFJS.imageResourcesPath + 'annotation-' +

  3437         iconName.toLowerCase() + '.svg';

  3438       image.alt = '[{{type}} Annotation]';

  3439       image.dataset.l10nId = 'text_annotation_type';

  3440       image.dataset.l10nArgs = JSON.stringify({type: iconName});

  3442       var contentWrapper = document.createElement('div');

  3443       contentWrapper.className = 'annotTextContentWrapper';

  3444       contentWrapper.style.left = Math.floor(rect[2] - rect[0] + 5) + 'px';

  3445       contentWrapper.style.top = '-10px';

  3447       var content = document.createElement('div');

  3448       content.className = 'annotTextContent';

  3449       content.setAttribute('hidden', true);

  3451       var i, ii;

  3452       if (item.hasBgColor) {

  3453         var color = item.color;

  3454         var rgb = [];

  3455         for (i = 0; i < 3; ++i) {

  3456           // Enlighten the color (70%)

  3457           var c = Math.round(color[i] * 255);

  3458           rgb[i] = Math.round((255 - c) * 0.7) + c;

  3459         }

  3460         content.style.backgroundColor = Util.makeCssRgb(rgb);

  3461       }

  3463       var title = document.createElement('h1');

  3464       var text = document.createElement('p');

  3465       title.textContent = item.title;

  3467       if (!item.content && !item.title) {

  3468         content.setAttribute('hidden', true);

  3469       } else {

  3470         var e = document.createElement('span');

  3471         var lines = item.content.split(/(?:\r\n?|\n)/);

  3472         for (i = 0, ii = lines.length; i < ii; ++i) {

  3473           var line = lines[i];

  3474           e.appendChild(document.createTextNode(line));

  3475           if (i < (ii - 1)) {

  3476             e.appendChild(document.createElement('br'));

  3477           }

  3478         }

  3479         text.appendChild(e);

  3481         var pinned = false;

  3483         var showAnnotation = function showAnnotation(pin) {

  3484           if (pin) {

  3485             pinned = true;

  3486           }

  3487           if (content.hasAttribute('hidden')) {

  3488             container.style.zIndex += 1;

  3489             content.removeAttribute('hidden');

  3490           }

  3491         };

  3493         var hideAnnotation = function hideAnnotation(unpin) {

  3494           if (unpin) {

  3495             pinned = false;

  3496           }

  3497           if (!content.hasAttribute('hidden') && !pinned) {

  3498             container.style.zIndex -= 1;

  3499             content.setAttribute('hidden', true);

  3500           }

  3501         };

  3503         var toggleAnnotation = function toggleAnnotation() {

  3504           if (pinned) {

  3505             hideAnnotation(true);

  3506           } else {

  3507             showAnnotation(true);

  3508           }

  3509         };

  3511         image.addEventListener('click', function image_clickHandler() {

  3512           toggleAnnotation();

  3513         }, false);

  3514         image.addEventListener('mouseover', function image_mouseOverHandler() {

  3515           showAnnotation();

  3516         }, false);

  3517         image.addEventListener('mouseout', function image_mouseOutHandler() {

  3518           hideAnnotation();

  3519         }, false);

  3521         content.addEventListener('click', function content_clickHandler() {

  3522           hideAnnotation(true);

  3523         }, false);

  3524       }

  3526       content.appendChild(title);

  3527       content.appendChild(text);

  3528       contentWrapper.appendChild(content);

  3529       container.appendChild(image);

  3530       container.appendChild(contentWrapper);

  3532       return container;

  3533     }

  3534   });

  3536   return TextAnnotation;

  3537 })();

  3539 var LinkAnnotation = (function LinkAnnotationClosure() {

  3540   function LinkAnnotation(params) {

  3541     InteractiveAnnotation.call(this, params);

  3543     if (params.data) {

  3544       return;

  3545     }

  3547     var dict = params.dict;

  3548     var data = this.data;

  3550     var action = dict.get('A');

  3551     if (action) {

  3552       var linkType = action.get('S').name;

  3553       if (linkType === 'URI') {

  3554         var url = action.get('URI');

  3555         if (isName(url)) {

  3556           // Some bad PDFs do not put parentheses around relative URLs.

  3557           url = '/' + url.name;

  3558         } else if (url) {

  3559           url = addDefaultProtocolToUrl(url);

  3560         }

  3561         // TODO: pdf spec mentions urls can be relative to a Base

  3562         // entry in the dictionary.

  3563         if (!isValidUrl(url, false)) {

  3564           url = '';

  3565         }

  3566         data.url = url;

  3567       } else if (linkType === 'GoTo') {

  3568         data.dest = action.get('D');

  3569       } else if (linkType === 'GoToR') {

  3570         var urlDict = action.get('F');

  3571         if (isDict(urlDict)) {

  3572           // We assume that the 'url' is a Filspec dictionary

  3573           // and fetch the url without checking any further

  3574           url = urlDict.get('F') || '';

  3575         }

  3577         // TODO: pdf reference says that GoToR

  3578         // can also have 'NewWindow' attribute

  3579         if (!isValidUrl(url, false)) {

  3580           url = '';

  3581         }

  3582         data.url = url;

  3583         data.dest = action.get('D');

  3584       } else if (linkType === 'Named') {

  3585         data.action = action.get('N').name;

  3586       } else {

  3587         warn('unrecognized link type: ' + linkType);

  3588       }

  3589     } else if (dict.has('Dest')) {

  3590       // simple destination link

  3591       var dest = dict.get('Dest');

  3592       data.dest = isName(dest) ? dest.name : dest;

  3593     }

  3594   }

  3596   // Lets URLs beginning with 'www.' default to using the 'http://' protocol.

  3597   function addDefaultProtocolToUrl(url) {

  3598     if (url && url.indexOf('www.') === 0) {

  3599       return ('http://' + url);

  3600     }

  3601     return url;

  3602   }

  3604   Util.inherit(LinkAnnotation, InteractiveAnnotation, {

  3605     hasOperatorList: function LinkAnnotation_hasOperatorList() {

  3606       return false;

  3607     },

  3609     getHtmlElement: function LinkAnnotation_getHtmlElement(commonObjs) {

  3611       var container = this.initContainer();

  3612       container.className = 'annotLink';

  3614       var item = this.data;

  3616       container.style.borderColor = item.colorCssRgb;

  3617       container.style.borderStyle = 'solid';

  3619       var link = document.createElement('a');

  3620       link.href = link.title = this.data.url || '';

  3622       container.appendChild(link);

  3624       return container;

  3625     }

  3626   });

  3628   return LinkAnnotation;

  3629 })();

  3632 var ChunkedStream = (function ChunkedStreamClosure() {

  3633   function ChunkedStream(length, chunkSize, manager) {

  3634     this.bytes = new Uint8Array(length);

  3635     this.start = 0;

  3636     this.pos = 0;

  3637     this.end = length;

  3638     this.chunkSize = chunkSize;

  3639     this.loadedChunks = [];

  3640     this.numChunksLoaded = 0;

  3641     this.numChunks = Math.ceil(length / chunkSize);

  3642     this.manager = manager;

  3643     this.initialDataLength = 0;

  3644   }

  3646   // required methods for a stream. if a particular stream does not

  3647   // implement these, an error should be thrown

  3648   ChunkedStream.prototype = {

  3650     getMissingChunks: function ChunkedStream_getMissingChunks() {

  3651       var chunks = [];

  3652       for (var chunk = 0, n = this.numChunks; chunk < n; ++chunk) {

  3653         if (!(chunk in this.loadedChunks)) {

  3654           chunks.push(chunk);

  3655         }

  3656       }

  3657       return chunks;

  3658     },

  3660     getBaseStreams: function ChunkedStream_getBaseStreams() {

  3661       return [this];

  3662     },

  3664     allChunksLoaded: function ChunkedStream_allChunksLoaded() {

  3665       return this.numChunksLoaded === this.numChunks;

  3666     },

  3668     onReceiveData: function ChunkedStream_onReceiveData(begin, chunk) {

  3669       var end = begin + chunk.byteLength;

  3671       assert(begin % this.chunkSize === 0, 'Bad begin offset: ' + begin);

  3672       // Using this.length is inaccurate here since this.start can be moved

  3673       // See ChunkedStream.moveStart()

  3674       var length = this.bytes.length;

  3675       assert(end % this.chunkSize === 0 || end === length,

  3676              'Bad end offset: ' + end);

  3678       this.bytes.set(new Uint8Array(chunk), begin);

  3679       var chunkSize = this.chunkSize;

  3680       var beginChunk = Math.floor(begin / chunkSize);

  3681       var endChunk = Math.floor((end - 1) / chunkSize) + 1;

  3682       var curChunk;

  3684       for (curChunk = beginChunk; curChunk < endChunk; ++curChunk) {

  3685         if (!(curChunk in this.loadedChunks)) {

  3686           this.loadedChunks[curChunk] = true;

  3687           ++this.numChunksLoaded;

  3688         }

  3689       }

  3690     },

  3692     onReceiveInitialData: function ChunkedStream_onReceiveInitialData(data) {

  3693       this.bytes.set(data);

  3694       this.initialDataLength = data.length;

  3695       var endChunk = (this.end === data.length ?

  3696         this.numChunks : Math.floor(data.length / this.chunkSize));

  3697       for (var i = 0; i < endChunk; i++) {

  3698         this.loadedChunks[i] = true;

  3699         ++this.numChunksLoaded;

  3700       }

  3701     },

  3703     ensureRange: function ChunkedStream_ensureRange(begin, end) {

  3704       if (begin >= end) {

  3705         return;

  3706       }

  3708       if (end <= this.initialDataLength) {

  3709         return;

  3710       }

  3712       var chunkSize = this.chunkSize;

  3713       var beginChunk = Math.floor(begin / chunkSize);

  3714       var endChunk = Math.floor((end - 1) / chunkSize) + 1;

  3715       for (var chunk = beginChunk; chunk < endChunk; ++chunk) {

  3716         if (!(chunk in this.loadedChunks)) {

  3717           throw new MissingDataException(begin, end);

  3718         }

  3719       }

  3720     },

  3722     nextEmptyChunk: function ChunkedStream_nextEmptyChunk(beginChunk) {

  3723       var chunk, n;

  3724       for (chunk = beginChunk, n = this.numChunks; chunk < n; ++chunk) {

  3725         if (!(chunk in this.loadedChunks)) {

  3726           return chunk;

  3727         }

  3728       }

  3729       // Wrap around to beginning

  3730       for (chunk = 0; chunk < beginChunk; ++chunk) {

  3731         if (!(chunk in this.loadedChunks)) {

  3732           return chunk;

  3733         }

  3734       }

  3735       return null;

  3736     },

  3738     hasChunk: function ChunkedStream_hasChunk(chunk) {

  3739       return chunk in this.loadedChunks;

  3740     },

  3742     get length() {

  3743       return this.end - this.start;

  3744     },

  3746     getByte: function ChunkedStream_getByte() {

  3747       var pos = this.pos;

  3748       if (pos >= this.end) {

  3749         return -1;

  3750       }

  3751       this.ensureRange(pos, pos + 1);

  3752       return this.bytes[this.pos++];

  3753     },

  3755     getUint16: function ChunkedStream_getUint16() {

  3756       var b0 = this.getByte();

  3757       var b1 = this.getByte();

  3758       return (b0 << 8) + b1;

  3759     },

  3761     getInt32: function ChunkedStream_getInt32() {

  3762       var b0 = this.getByte();

  3763       var b1 = this.getByte();

  3764       var b2 = this.getByte();

  3765       var b3 = this.getByte();

  3766       return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;

  3767     },

  3769     // returns subarray of original buffer

  3770     // should only be read

  3771     getBytes: function ChunkedStream_getBytes(length) {

  3772       var bytes = this.bytes;

  3773       var pos = this.pos;

  3774       var strEnd = this.end;

  3776       if (!length) {

  3777         this.ensureRange(pos, strEnd);

  3778         return bytes.subarray(pos, strEnd);

  3779       }

  3781       var end = pos + length;

  3782       if (end > strEnd) {

  3783         end = strEnd;

  3784       }

  3785       this.ensureRange(pos, end);

  3787       this.pos = end;

  3788       return bytes.subarray(pos, end);

  3789     },

  3791     peekBytes: function ChunkedStream_peekBytes(length) {

  3792       var bytes = this.getBytes(length);

  3793       this.pos -= bytes.length;

  3794       return bytes;

  3795     },

  3797     getByteRange: function ChunkedStream_getBytes(begin, end) {

  3798       this.ensureRange(begin, end);

  3799       return this.bytes.subarray(begin, end);

  3800     },

  3802     skip: function ChunkedStream_skip(n) {

  3803       if (!n) {

  3804         n = 1;

  3805       }

  3806       this.pos += n;

  3807     },

  3809     reset: function ChunkedStream_reset() {

  3810       this.pos = this.start;

  3811     },

  3813     moveStart: function ChunkedStream_moveStart() {

  3814       this.start = this.pos;

  3815     },

  3817     makeSubStream: function ChunkedStream_makeSubStream(start, length, dict) {

  3818       this.ensureRange(start, start + length);

  3820       function ChunkedStreamSubstream() {}

  3821       ChunkedStreamSubstream.prototype = Object.create(this);

  3822       ChunkedStreamSubstream.prototype.getMissingChunks = function() {

  3823         var chunkSize = this.chunkSize;

  3824         var beginChunk = Math.floor(this.start / chunkSize);

  3825         var endChunk = Math.floor((this.end - 1) / chunkSize) + 1;

  3826         var missingChunks = [];

  3827         for (var chunk = beginChunk; chunk < endChunk; ++chunk) {

  3828           if (!(chunk in this.loadedChunks)) {

  3829             missingChunks.push(chunk);

  3830           }

  3831         }

  3832         return missingChunks;

  3833       };

  3834       var subStream = new ChunkedStreamSubstream();

  3835       subStream.pos = subStream.start = start;

  3836       subStream.end = start + length || this.end;

  3837       subStream.dict = dict;

  3838       return subStream;

  3839     },

  3841     isStream: true

  3842   };

  3844   return ChunkedStream;

  3845 })();

  3847 var ChunkedStreamManager = (function ChunkedStreamManagerClosure() {

  3849   function ChunkedStreamManager(length, chunkSize, url, args) {

  3850     this.stream = new ChunkedStream(length, chunkSize, this);

  3851     this.length = length;

  3852     this.chunkSize = chunkSize;

  3853     this.url = url;

  3854     this.disableAutoFetch = args.disableAutoFetch;

  3855     var msgHandler = this.msgHandler = args.msgHandler;

  3857     if (args.chunkedViewerLoading) {

  3858       msgHandler.on('OnDataRange', this.onReceiveData.bind(this));

  3859       msgHandler.on('OnDataProgress', this.onProgress.bind(this));

  3860       this.sendRequest = function ChunkedStreamManager_sendRequest(begin, end) {

  3861         msgHandler.send('RequestDataRange', { begin: begin, end: end });

  3862       };

  3863     } else {

  3865       var getXhr = function getXhr() {

  3866         return new XMLHttpRequest();

  3867       };

  3868       this.networkManager = new NetworkManager(this.url, {

  3869         getXhr: getXhr,

  3870         httpHeaders: args.httpHeaders,

  3871         withCredentials: args.withCredentials

  3872       });

  3873       this.sendRequest = function ChunkedStreamManager_sendRequest(begin, end) {

  3874         this.networkManager.requestRange(begin, end, {

  3875           onDone: this.onReceiveData.bind(this),

  3876           onProgress: this.onProgress.bind(this)

  3877         });

  3878       };

  3879     }

  3881     this.currRequestId = 0;

  3883     this.chunksNeededByRequest = {};

  3884     this.requestsByChunk = {};

  3885     this.callbacksByRequest = {};

  3887     this.loadedStream = new LegacyPromise();

  3888     if (args.initialData) {

  3889       this.setInitialData(args.initialData);

  3890     }

  3891   }

  3893   ChunkedStreamManager.prototype = {

  3895     setInitialData: function ChunkedStreamManager_setInitialData(data) {

  3896       this.stream.onReceiveInitialData(data);

  3897       if (this.stream.allChunksLoaded()) {

  3898         this.loadedStream.resolve(this.stream);

  3899       } else if (this.msgHandler) {

  3900         this.msgHandler.send('DocProgress', {

  3901           loaded: data.length,

  3902           total: this.length

  3903         });

  3904       }

  3905     },

  3907     onLoadedStream: function ChunkedStreamManager_getLoadedStream() {

  3908       return this.loadedStream;

  3909     },

  3911     // Get all the chunks that are not yet loaded and groups them into

  3912     // contiguous ranges to load in as few requests as possible

  3913     requestAllChunks: function ChunkedStreamManager_requestAllChunks() {

  3914       var missingChunks = this.stream.getMissingChunks();

  3915       this.requestChunks(missingChunks);

  3916       return this.loadedStream;

  3917     },

  3919     requestChunks: function ChunkedStreamManager_requestChunks(chunks,

  3920                                                                callback) {

  3921       var requestId = this.currRequestId++;

  3923       var chunksNeeded;

  3924       var i, ii;

  3925       this.chunksNeededByRequest[requestId] = chunksNeeded = {};

  3926       for (i = 0, ii = chunks.length; i < ii; i++) {

  3927         if (!this.stream.hasChunk(chunks[i])) {

  3928           chunksNeeded[chunks[i]] = true;

  3929         }

  3930       }

  3932       if (isEmptyObj(chunksNeeded)) {

  3933         if (callback) {

  3934           callback();

  3935         }

  3936         return;

  3937       }

  3939       this.callbacksByRequest[requestId] = callback;

  3941       var chunksToRequest = [];

  3942       for (var chunk in chunksNeeded) {

  3943         chunk = chunk | 0;

  3944         if (!(chunk in this.requestsByChunk)) {

  3945           this.requestsByChunk[chunk] = [];

  3946           chunksToRequest.push(chunk);

  3947         }

  3948         this.requestsByChunk[chunk].push(requestId);

  3949       }

  3951       if (!chunksToRequest.length) {

  3952         return;

  3953       }

  3955       var groupedChunksToRequest = this.groupChunks(chunksToRequest);

  3957       for (i = 0; i < groupedChunksToRequest.length; ++i) {

  3958         var groupedChunk = groupedChunksToRequest[i];

  3959         var begin = groupedChunk.beginChunk * this.chunkSize;

  3960         var end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);

  3961         this.sendRequest(begin, end);

  3962       }

  3963     },

  3965     getStream: function ChunkedStreamManager_getStream() {

  3966       return this.stream;

  3967     },

  3969     // Loads any chunks in the requested range that are not yet loaded

  3970     requestRange: function ChunkedStreamManager_requestRange(

  3971                       begin, end, callback) {

  3973       end = Math.min(end, this.length);

  3975       var beginChunk = this.getBeginChunk(begin);

  3976       var endChunk = this.getEndChunk(end);

  3978       var chunks = [];

  3979       for (var chunk = beginChunk; chunk < endChunk; ++chunk) {

  3980         chunks.push(chunk);

  3981       }

  3983       this.requestChunks(chunks, callback);

  3984     },

  3986     requestRanges: function ChunkedStreamManager_requestRanges(ranges,

  3987                                                                callback) {

  3988       ranges = ranges || [];

  3989       var chunksToRequest = [];

  3991       for (var i = 0; i < ranges.length; i++) {

  3992         var beginChunk = this.getBeginChunk(ranges[i].begin);

  3993         var endChunk = this.getEndChunk(ranges[i].end);

  3994         for (var chunk = beginChunk; chunk < endChunk; ++chunk) {

  3995           if (chunksToRequest.indexOf(chunk) < 0) {

  3996             chunksToRequest.push(chunk);

  3997           }

  3998         }

  3999       }

  4001       chunksToRequest.sort(function(a, b) { return a - b; });

  4002       this.requestChunks(chunksToRequest, callback);

  4003     },

  4005     // Groups a sorted array of chunks into as few continguous larger

  4006     // chunks as possible

  4007     groupChunks: function ChunkedStreamManager_groupChunks(chunks) {

  4008       var groupedChunks = [];

  4009       var beginChunk = -1;

  4010       var prevChunk = -1;

  4011       for (var i = 0; i < chunks.length; ++i) {

  4012         var chunk = chunks[i];

  4014         if (beginChunk < 0) {

  4015           beginChunk = chunk;

  4016         }

  4018         if (prevChunk >= 0 && prevChunk + 1 !== chunk) {

  4019           groupedChunks.push({ beginChunk: beginChunk,

  4020                                endChunk: prevChunk + 1 });

  4021           beginChunk = chunk;

  4022         }

  4023         if (i + 1 === chunks.length) {

  4024           groupedChunks.push({ beginChunk: beginChunk,

  4025                                endChunk: chunk + 1 });

  4026         }

  4028         prevChunk = chunk;

  4029       }

  4030       return groupedChunks;

  4031     },

  4033     onProgress: function ChunkedStreamManager_onProgress(args) {

  4034       var bytesLoaded = (this.stream.numChunksLoaded * this.chunkSize +

  4035                          args.loaded);

  4036       this.msgHandler.send('DocProgress', {

  4037         loaded: bytesLoaded,

  4038         total: this.length

  4039       });

  4040     },

  4042     onReceiveData: function ChunkedStreamManager_onReceiveData(args) {

  4043       var chunk = args.chunk;

  4044       var begin = args.begin;

  4045       var end = begin + chunk.byteLength;

  4047       var beginChunk = this.getBeginChunk(begin);

  4048       var endChunk = this.getEndChunk(end);

  4050       this.stream.onReceiveData(begin, chunk);

  4051       if (this.stream.allChunksLoaded()) {

  4052         this.loadedStream.resolve(this.stream);

  4053       }

  4055       var loadedRequests = [];

  4056       var i, requestId;

  4057       for (chunk = beginChunk; chunk < endChunk; ++chunk) {

  4058         // The server might return more chunks than requested

  4059         var requestIds = this.requestsByChunk[chunk] || [];

  4060         delete this.requestsByChunk[chunk];

  4062         for (i = 0; i < requestIds.length; ++i) {

  4063           requestId = requestIds[i];

  4064           var chunksNeeded = this.chunksNeededByRequest[requestId];

  4065           if (chunk in chunksNeeded) {

  4066             delete chunksNeeded[chunk];

  4067           }

  4069           if (!isEmptyObj(chunksNeeded)) {

  4070             continue;

  4071           }

  4073           loadedRequests.push(requestId);

  4074         }

  4075       }

  4077       // If there are no pending requests, automatically fetch the next

  4078       // unfetched chunk of the PDF

  4079       if (!this.disableAutoFetch && isEmptyObj(this.requestsByChunk)) {

  4080         var nextEmptyChunk;

  4081         if (this.stream.numChunksLoaded === 1) {

  4082           // This is a special optimization so that after fetching the first

  4083           // chunk, rather than fetching the second chunk, we fetch the last

  4084           // chunk.

  4085           var lastChunk = this.stream.numChunks - 1;

  4086           if (!this.stream.hasChunk(lastChunk)) {

  4087             nextEmptyChunk = lastChunk;

  4088           }

  4089         } else {

  4090           nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);

  4091         }

  4092         if (isInt(nextEmptyChunk)) {

  4093           this.requestChunks([nextEmptyChunk]);

  4094         }

  4095       }

  4097       for (i = 0; i < loadedRequests.length; ++i) {

  4098         requestId = loadedRequests[i];

  4099         var callback = this.callbacksByRequest[requestId];

  4100         delete this.callbacksByRequest[requestId];

  4101         if (callback) {

  4102           callback();

  4103         }

  4104       }

  4106       this.msgHandler.send('DocProgress', {

  4107         loaded: this.stream.numChunksLoaded * this.chunkSize,

  4108         total: this.length

  4109       });

  4110     },

  4112     getBeginChunk: function ChunkedStreamManager_getBeginChunk(begin) {

  4113       var chunk = Math.floor(begin / this.chunkSize);

  4114       return chunk;

  4115     },

  4117     getEndChunk: function ChunkedStreamManager_getEndChunk(end) {

  4118       if (end % this.chunkSize === 0) {

  4119         return end / this.chunkSize;

  4120       }

  4122       // 0 -> 0

  4123       // 1 -> 1

  4124       // 99 -> 1

  4125       // 100 -> 1

  4126       // 101 -> 2

  4127       var chunk = Math.floor((end - 1) / this.chunkSize) + 1;

  4128       return chunk;

  4129     }

  4130   };

  4132   return ChunkedStreamManager;

  4133 })();

  4137 // The maximum number of bytes fetched per range request

  4138 var RANGE_CHUNK_SIZE = 65536;

  4140 // TODO(mack): Make use of PDFJS.Util.inherit() when it becomes available

  4141 var BasePdfManager = (function BasePdfManagerClosure() {

  4142   function BasePdfManager() {

  4143     throw new Error('Cannot initialize BaseManagerManager');

  4144   }

  4146   BasePdfManager.prototype = {

  4147     onLoadedStream: function BasePdfManager_onLoadedStream() {

  4148       throw new NotImplementedException();

  4149     },

  4151     ensureDoc: function BasePdfManager_ensureDoc(prop, args) {

  4152       return this.ensure(this.pdfDocument, prop, args);

  4153     },

  4155     ensureXRef: function BasePdfManager_ensureXRef(prop, args) {

  4156       return this.ensure(this.pdfDocument.xref, prop, args);

  4157     },

  4159     ensureCatalog: function BasePdfManager_ensureCatalog(prop, args) {

  4160       return this.ensure(this.pdfDocument.catalog, prop, args);

  4161     },

  4163     getPage: function BasePdfManager_pagePage(pageIndex) {

  4164       return this.pdfDocument.getPage(pageIndex);

  4165     },

  4167     cleanup: function BasePdfManager_cleanup() {

  4168       return this.pdfDocument.cleanup();

  4169     },

  4171     ensure: function BasePdfManager_ensure(obj, prop, args) {

  4172       return new NotImplementedException();

  4173     },

  4175     requestRange: function BasePdfManager_ensure(begin, end) {

  4176       return new NotImplementedException();

  4177     },

  4179     requestLoadedStream: function BasePdfManager_requestLoadedStream() {

  4180       return new NotImplementedException();

  4181     },

  4183     updatePassword: function BasePdfManager_updatePassword(password) {

  4184       this.pdfDocument.xref.password = this.password = password;

  4185       if (this.passwordChangedPromise) {

  4186         this.passwordChangedPromise.resolve();

  4187       }

  4188     },

  4190     terminate: function BasePdfManager_terminate() {

  4191       return new NotImplementedException();

  4192     }

  4193   };

  4195   return BasePdfManager;

  4196 })();

  4198 var LocalPdfManager = (function LocalPdfManagerClosure() {

  4199   function LocalPdfManager(data, password) {

  4200     var stream = new Stream(data);

  4201     this.pdfDocument = new PDFDocument(this, stream, password);

  4202     this.loadedStream = new LegacyPromise();

  4203     this.loadedStream.resolve(stream);

  4204   }

  4206   LocalPdfManager.prototype = Object.create(BasePdfManager.prototype);

  4207   LocalPdfManager.prototype.constructor = LocalPdfManager;

  4209   LocalPdfManager.prototype.ensure =

  4210       function LocalPdfManager_ensure(obj, prop, args) {

  4211     var promise = new LegacyPromise();

  4212     try {

  4213       var value = obj[prop];

  4214       var result;

  4215       if (typeof(value) === 'function') {

  4216         result = value.apply(obj, args);

  4217       } else {

  4218         result = value;

  4219       }

  4220       promise.resolve(result);

  4221     } catch (e) {

  4222       console.log(e.stack);

  4223       promise.reject(e);

  4224     }

  4225     return promise;

  4226   };

  4228   LocalPdfManager.prototype.requestRange =

  4229       function LocalPdfManager_requestRange(begin, end) {

  4230     var promise = new LegacyPromise();

  4231     promise.resolve();

  4232     return promise;

  4233   };

  4235   LocalPdfManager.prototype.requestLoadedStream =

  4236       function LocalPdfManager_requestLoadedStream() {

  4237   };

  4239   LocalPdfManager.prototype.onLoadedStream =

  4240       function LocalPdfManager_getLoadedStream() {

  4241     return this.loadedStream;

  4242   };

  4244   LocalPdfManager.prototype.terminate =

  4245       function LocalPdfManager_terminate() {

  4246     return;

  4247   };

  4249   return LocalPdfManager;

  4250 })();

  4252 var NetworkPdfManager = (function NetworkPdfManagerClosure() {

  4253   function NetworkPdfManager(args, msgHandler) {

  4255     this.msgHandler = msgHandler;

  4257     var params = {

  4258       msgHandler: msgHandler,

  4259       httpHeaders: args.httpHeaders,

  4260       withCredentials: args.withCredentials,

  4261       chunkedViewerLoading: args.chunkedViewerLoading,

  4262       disableAutoFetch: args.disableAutoFetch,

  4263       initialData: args.initialData

  4264     };

  4265     this.streamManager = new ChunkedStreamManager(args.length, RANGE_CHUNK_SIZE,

  4266                                                   args.url, params);

  4268     this.pdfDocument = new PDFDocument(this, this.streamManager.getStream(),

  4269                                     args.password);

  4270   }

  4272   NetworkPdfManager.prototype = Object.create(BasePdfManager.prototype);

  4273   NetworkPdfManager.prototype.constructor = NetworkPdfManager;

  4275   NetworkPdfManager.prototype.ensure =

  4276       function NetworkPdfManager_ensure(obj, prop, args) {

  4277     var promise = new LegacyPromise();

  4278     this.ensureHelper(promise, obj, prop, args);

  4279     return promise;

  4280   };

  4282   NetworkPdfManager.prototype.ensureHelper =

  4283       function NetworkPdfManager_ensureHelper(promise, obj, prop, args) {

  4284     try {

  4285       var result;

  4286       var value = obj[prop];

  4287       if (typeof(value) === 'function') {

  4288         result = value.apply(obj, args);

  4289       } else {

  4290         result = value;

  4291       }

  4292       promise.resolve(result);

  4293     } catch(e) {

  4294       if (!(e instanceof MissingDataException)) {

  4295         console.log(e.stack);

  4296         promise.reject(e);

  4297         return;

  4298       }

  4300       this.streamManager.requestRange(e.begin, e.end, function() {

  4301         this.ensureHelper(promise, obj, prop, args);

  4302       }.bind(this));

  4303     }

  4304   };

  4306   NetworkPdfManager.prototype.requestRange =

  4307       function NetworkPdfManager_requestRange(begin, end) {

  4308     var promise = new LegacyPromise();

  4309     this.streamManager.requestRange(begin, end, function() {

  4310       promise.resolve();

  4311     });

  4312     return promise;

  4313   };

  4315   NetworkPdfManager.prototype.requestLoadedStream =

  4316       function NetworkPdfManager_requestLoadedStream() {

  4317     this.streamManager.requestAllChunks();

  4318   };

  4320   NetworkPdfManager.prototype.onLoadedStream =

  4321       function NetworkPdfManager_getLoadedStream() {

  4322     return this.streamManager.onLoadedStream();

  4323   };

  4325   NetworkPdfManager.prototype.terminate =

  4326       function NetworkPdfManager_terminate() {

  4327     this.streamManager.networkManager.abortAllRequests();

  4328   };

  4330   return NetworkPdfManager;

  4331 })();

  4335 var Page = (function PageClosure() {

  4337   var LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];

  4339   function Page(pdfManager, xref, pageIndex, pageDict, ref, fontCache) {

  4340     this.pdfManager = pdfManager;

  4341     this.pageIndex = pageIndex;

  4342     this.pageDict = pageDict;

  4343     this.xref = xref;

  4344     this.ref = ref;

  4345     this.fontCache = fontCache;

  4346     this.idCounters = {

  4347       obj: 0

  4348     };

  4349     this.resourcesPromise = null;

  4350   }

  4352   Page.prototype = {

  4353     getPageProp: function Page_getPageProp(key) {

  4354       return this.pageDict.get(key);

  4355     },

  4357     getInheritedPageProp: function Page_inheritPageProp(key) {

  4358       var dict = this.pageDict;

  4359       var value = dict.get(key);

  4360       while (value === undefined) {

  4361         dict = dict.get('Parent');

  4362         if (!dict) {

  4363           break;

  4364         }

  4365         value = dict.get(key);

  4366       }

  4367       return value;

  4368     },

  4370     get content() {

  4371       return this.getPageProp('Contents');

  4372     },

  4374     get resources() {

  4375       var value = this.getInheritedPageProp('Resources');

  4376       // For robustness: The spec states that a \Resources entry has to be

  4377       // present, but can be empty. Some document omit it still. In this case

  4378       // return an empty dictionary:

  4379       if (value === undefined) {

  4380         value = Dict.empty;

  4381       }

  4382       return shadow(this, 'resources', value);

  4383     },

  4385     get mediaBox() {

  4386       var obj = this.getInheritedPageProp('MediaBox');

  4387       // Reset invalid media box to letter size.

  4388       if (!isArray(obj) || obj.length !== 4) {

  4389         obj = LETTER_SIZE_MEDIABOX;

  4390       }

  4391       return shadow(this, 'mediaBox', obj);

  4392     },

  4394     get view() {

  4395       var mediaBox = this.mediaBox;

  4396       var cropBox = this.getInheritedPageProp('CropBox');

  4397       if (!isArray(cropBox) || cropBox.length !== 4) {

  4398         return shadow(this, 'view', mediaBox);

  4399       }

  4401       // From the spec, 6th ed., p.963:

  4402       // "The crop, bleed, trim, and art boxes should not ordinarily

  4403       // extend beyond the boundaries of the media box. If they do, they are

  4404       // effectively reduced to their intersection with the media box."

  4405       cropBox = Util.intersect(cropBox, mediaBox);

  4406       if (!cropBox) {

  4407         return shadow(this, 'view', mediaBox);

  4408       }

  4409       return shadow(this, 'view', cropBox);

  4410     },

  4412     get annotationRefs() {

  4413       return shadow(this, 'annotationRefs',

  4414                     this.getInheritedPageProp('Annots'));

  4415     },

  4417     get rotate() {

  4418       var rotate = this.getInheritedPageProp('Rotate') || 0;

  4419       // Normalize rotation so it's a multiple of 90 and between 0 and 270

  4420       if (rotate % 90 !== 0) {

  4421         rotate = 0;

  4422       } else if (rotate >= 360) {

  4423         rotate = rotate % 360;

  4424       } else if (rotate < 0) {

  4425         // The spec doesn't cover negatives, assume its counterclockwise

  4426         // rotation. The following is the other implementation of modulo.

  4427         rotate = ((rotate % 360) + 360) % 360;

  4428       }

  4429       return shadow(this, 'rotate', rotate);

  4430     },

  4432     getContentStream: function Page_getContentStream() {

  4433       var content = this.content;

  4434       var stream;

  4435       if (isArray(content)) {

  4436         // fetching items

  4437         var xref = this.xref;

  4438         var i, n = content.length;

  4439         var streams = [];

  4440         for (i = 0; i < n; ++i) {

  4441           streams.push(xref.fetchIfRef(content[i]));

  4442         }

  4443         stream = new StreamsSequenceStream(streams);

  4444       } else if (isStream(content)) {

  4445         stream = content;

  4446       } else {

  4447         // replacing non-existent page content with empty one

  4448         stream = new NullStream();

  4449       }

  4450       return stream;

  4451     },

  4453     loadResources: function(keys) {

  4454       if (!this.resourcesPromise) {

  4455         // TODO: add async getInheritedPageProp and remove this.

  4456         this.resourcesPromise = this.pdfManager.ensure(this, 'resources');

  4457       }

  4458       var promise = new LegacyPromise();

  4459       this.resourcesPromise.then(function resourceSuccess() {

  4460         var objectLoader = new ObjectLoader(this.resources.map,

  4461                                             keys,

  4462                                             this.xref);

  4463         objectLoader.load().then(function objectLoaderSuccess() {

  4464           promise.resolve();

  4465         });

  4466       }.bind(this));

  4467       return promise;

  4468     },

  4470     getOperatorList: function Page_getOperatorList(handler, intent) {

  4471       var self = this;

  4472       var promise = new LegacyPromise();

  4474       function reject(e) {

  4475         promise.reject(e);

  4476       }

  4478       var pageListPromise = new LegacyPromise();

  4480       var pdfManager = this.pdfManager;

  4481       var contentStreamPromise = pdfManager.ensure(this, 'getContentStream',

  4482                                                    []);

  4483       var resourcesPromise = this.loadResources([

  4484         'ExtGState',

  4485         'ColorSpace',

  4486         'Pattern',

  4487         'Shading',

  4488         'XObject',

  4489         'Font'

  4490         // ProcSet

  4491         // Properties

  4492       ]);

  4494       var partialEvaluator = new PartialEvaluator(pdfManager, this.xref,

  4495                                                   handler, this.pageIndex,

  4496                                                   'p' + this.pageIndex + '_',

  4497                                                   this.idCounters,

  4498                                                   this.fontCache);

  4500       var dataPromises = Promise.all([contentStreamPromise, resourcesPromise],

  4501                                      reject);

  4502       dataPromises.then(function(data) {

  4503         var contentStream = data[0];

  4504         var opList = new OperatorList(intent, handler, self.pageIndex);

  4506         handler.send('StartRenderPage', {

  4507           transparency: partialEvaluator.hasBlendModes(self.resources),

  4508           pageIndex: self.pageIndex,

  4509           intent: intent

  4510         });

  4511         partialEvaluator.getOperatorList(contentStream, self.resources, opList);

  4512         pageListPromise.resolve(opList);

  4513       });

  4515       var annotationsPromise = pdfManager.ensure(this, 'annotations');

  4516       Promise.all([pageListPromise, annotationsPromise]).then(function(datas) {

  4517         var pageOpList = datas[0];

  4518         var annotations = datas[1];

  4520         if (annotations.length === 0) {

  4521           pageOpList.flush(true);

  4522           promise.resolve(pageOpList);

  4523           return;

  4524         }

  4526         var annotationsReadyPromise = Annotation.appendToOperatorList(

  4527           annotations, pageOpList, pdfManager, partialEvaluator, intent);

  4528         annotationsReadyPromise.then(function () {

  4529           pageOpList.flush(true);

  4530           promise.resolve(pageOpList);

  4531         }, reject);

  4532       }, reject);

  4534       return promise;

  4535     },

  4537     extractTextContent: function Page_extractTextContent() {

  4538       var handler = {

  4539         on: function nullHandlerOn() {},

  4540         send: function nullHandlerSend() {}

  4541       };

  4543       var self = this;

  4545       var pdfManager = this.pdfManager;

  4546       var contentStreamPromise = pdfManager.ensure(this, 'getContentStream',

  4547                                                    []);

  4549       var resourcesPromise = this.loadResources([

  4550         'ExtGState',

  4551         'XObject',

  4552         'Font'

  4553       ]);

  4555       var dataPromises = Promise.all([contentStreamPromise,

  4556                                       resourcesPromise]);

  4557       return dataPromises.then(function(data) {

  4558         var contentStream = data[0];

  4559         var partialEvaluator = new PartialEvaluator(pdfManager, self.xref,

  4560                                                     handler, self.pageIndex,

  4561                                                     'p' + self.pageIndex + '_',

  4562                                                     self.idCounters,

  4563                                                     self.fontCache);

  4565         return partialEvaluator.getTextContent(contentStream,

  4566                                                self.resources);

  4567       });

  4568     },

  4570     getAnnotationsData: function Page_getAnnotationsData() {

  4571       var annotations = this.annotations;

  4572       var annotationsData = [];

  4573       for (var i = 0, n = annotations.length; i < n; ++i) {

  4574         annotationsData.push(annotations[i].getData());

  4575       }

  4576       return annotationsData;

  4577     },

  4579     get annotations() {

  4580       var annotations = [];

  4581       var annotationRefs = (this.annotationRefs || []);

  4582       for (var i = 0, n = annotationRefs.length; i < n; ++i) {

  4583         var annotationRef = annotationRefs[i];

  4584         var annotation = Annotation.fromRef(this.xref, annotationRef);

  4585         if (annotation) {

  4586           annotations.push(annotation);

  4587         }

  4588       }

  4589       return shadow(this, 'annotations', annotations);

  4590     }

  4591   };

  4593   return Page;

  4594 })();

  4596 /**

  4597  * The `PDFDocument` holds all the data of the PDF file. Compared to the

  4598  * `PDFDoc`, this one doesn't have any job management code.

  4599  * Right now there exists one PDFDocument on the main thread + one object

  4600  * for each worker. If there is no worker support enabled, there are two

  4601  * `PDFDocument` objects on the main thread created.

  4602  */

  4603 var PDFDocument = (function PDFDocumentClosure() {

  4604   function PDFDocument(pdfManager, arg, password) {

  4605     if (isStream(arg)) {

  4606       init.call(this, pdfManager, arg, password);

  4607     } else if (isArrayBuffer(arg)) {

  4608       init.call(this, pdfManager, new Stream(arg), password);

  4609     } else {

  4610       error('PDFDocument: Unknown argument type');

  4611     }

  4612   }

  4614   function init(pdfManager, stream, password) {

  4615     assert(stream.length > 0, 'stream must have data');

  4616     this.pdfManager = pdfManager;

  4617     this.stream = stream;

  4618     var xref = new XRef(this.stream, password, pdfManager);

  4619     this.xref = xref;

  4620   }

  4622   function find(stream, needle, limit, backwards) {

  4623     var pos = stream.pos;

  4624     var end = stream.end;

  4625     var strBuf = [];

  4626     if (pos + limit > end) {

  4627       limit = end - pos;

  4628     }

  4629     for (var n = 0; n < limit; ++n) {

  4630       strBuf.push(String.fromCharCode(stream.getByte()));

  4631     }

  4632     var str = strBuf.join('');

  4633     stream.pos = pos;

  4634     var index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle);

  4635     if (index == -1) {

  4636       return false; /* not found */

  4637     }

  4638     stream.pos += index;

  4639     return true; /* found */

  4640   }

  4642   var DocumentInfoValidators = {

  4643     get entries() {

  4644       // Lazily build this since all the validation functions below are not

  4645       // defined until after this file loads.

  4646       return shadow(this, 'entries', {

  4647         Title: isString,

  4648         Author: isString,

  4649         Subject: isString,

  4650         Keywords: isString,

  4651         Creator: isString,

  4652         Producer: isString,

  4653         CreationDate: isString,

  4654         ModDate: isString,

  4655         Trapped: isName

  4656       });

  4657     }

  4658   };

  4660   PDFDocument.prototype = {

  4661     parse: function PDFDocument_parse(recoveryMode) {

  4662       this.setup(recoveryMode);

  4663       try {

  4664         // checking if AcroForm is present

  4665         this.acroForm = this.catalog.catDict.get('AcroForm');

  4666         if (this.acroForm) {

  4667           this.xfa = this.acroForm.get('XFA');

  4668           var fields = this.acroForm.get('Fields');

  4669           if ((!fields || !isArray(fields) || fields.length === 0) &&

  4670               !this.xfa) {

  4671             // no fields and no XFA -- not a form (?)

  4672             this.acroForm = null;

  4673           }

  4674         }

  4675       } catch (ex) {

  4676         info('Something wrong with AcroForm entry');

  4677         this.acroForm = null;

  4678       }

  4679     },

  4681     get linearization() {

  4682       var length = this.stream.length;

  4683       var linearization = false;

  4684       if (length) {

  4685         try {

  4686           linearization = new Linearization(this.stream);

  4687           if (linearization.length != length) {

  4688             linearization = false;

  4689           }

  4690         } catch (err) {

  4691           if (err instanceof MissingDataException) {

  4692             throw err;

  4693           }

  4695           info('The linearization data is not available ' +

  4696                'or unreadable PDF data is found');

  4697           linearization = false;

  4698         }

  4699       }

  4700       // shadow the prototype getter with a data property

  4701       return shadow(this, 'linearization', linearization);

  4702     },

  4703     get startXRef() {

  4704       var stream = this.stream;

  4705       var startXRef = 0;

  4706       var linearization = this.linearization;

  4707       if (linearization) {

  4708         // Find end of first obj.

  4709         stream.reset();

  4710         if (find(stream, 'endobj', 1024)) {

  4711           startXRef = stream.pos + 6;

  4712         }

  4713       } else {

  4714         // Find startxref by jumping backward from the end of the file.

  4715         var step = 1024;

  4716         var found = false, pos = stream.end;

  4717         while (!found && pos > 0) {

  4718           pos -= step - 'startxref'.length;

  4719           if (pos < 0) {

  4720             pos = 0;

  4721           }

  4722           stream.pos = pos;

  4723           found = find(stream, 'startxref', step, true);

  4724         }

  4725         if (found) {

  4726           stream.skip(9);

  4727           var ch;

  4728           do {

  4729             ch = stream.getByte();

  4730           } while (Lexer.isSpace(ch));

  4731           var str = '';

  4732           while (ch >= 0x20 && ch <= 0x39) { // < '9'

  4733             str += String.fromCharCode(ch);

  4734             ch = stream.getByte();

  4735           }

  4736           startXRef = parseInt(str, 10);

  4737           if (isNaN(startXRef)) {

  4738             startXRef = 0;

  4739           }

  4740         }

  4741       }

  4742       // shadow the prototype getter with a data property

  4743       return shadow(this, 'startXRef', startXRef);

  4744     },

  4745     get mainXRefEntriesOffset() {

  4746       var mainXRefEntriesOffset = 0;

  4747       var linearization = this.linearization;

  4748       if (linearization) {

  4749         mainXRefEntriesOffset = linearization.mainXRefEntriesOffset;

  4750       }

  4751       // shadow the prototype getter with a data property

  4752       return shadow(this, 'mainXRefEntriesOffset', mainXRefEntriesOffset);

  4753     },

  4754     // Find the header, remove leading garbage and setup the stream

  4755     // starting from the header.

  4756     checkHeader: function PDFDocument_checkHeader() {

  4757       var stream = this.stream;

  4758       stream.reset();

  4759       if (find(stream, '%PDF-', 1024)) {

  4760         // Found the header, trim off any garbage before it.

  4761         stream.moveStart();

  4762         // Reading file format version

  4763         var MAX_VERSION_LENGTH = 12;

  4764         var version = '', ch;

  4765         while ((ch = stream.getByte()) > 0x20) { // SPACE

  4766           if (version.length >= MAX_VERSION_LENGTH) {

  4767             break;

  4768           }

  4769           version += String.fromCharCode(ch);

  4770         }

  4771         // removing "%PDF-"-prefix

  4772         this.pdfFormatVersion = version.substring(5);

  4773         return;

  4774       }

  4775       // May not be a PDF file, continue anyway.

  4776     },

  4777     parseStartXRef: function PDFDocument_parseStartXRef() {

  4778       var startXRef = this.startXRef;

  4779       this.xref.setStartXRef(startXRef);

  4780     },

  4781     setup: function PDFDocument_setup(recoveryMode) {

  4782       this.xref.parse(recoveryMode);

  4783       this.catalog = new Catalog(this.pdfManager, this.xref);

  4784     },

  4785     get numPages() {

  4786       var linearization = this.linearization;

  4787       var num = linearization ? linearization.numPages : this.catalog.numPages;

  4788       // shadow the prototype getter

  4789       return shadow(this, 'numPages', num);

  4790     },

  4791     get documentInfo() {

  4792       var docInfo = {

  4793         PDFFormatVersion: this.pdfFormatVersion,

  4794         IsAcroFormPresent: !!this.acroForm,

  4795         IsXFAPresent: !!this.xfa

  4796       };

  4797       var infoDict;

  4798       try {

  4799         infoDict = this.xref.trailer.get('Info');

  4800       } catch (err) {

  4801         info('The document information dictionary is invalid.');

  4802       }

  4803       if (infoDict) {

  4804         var validEntries = DocumentInfoValidators.entries;

  4805         // Only fill the document info with valid entries from the spec.

  4806         for (var key in validEntries) {

  4807           if (infoDict.has(key)) {

  4808             var value = infoDict.get(key);

  4809             // Make sure the value conforms to the spec.

  4810             if (validEntries[key](value)) {

  4811               docInfo[key] = (typeof value !== 'string' ?

  4812                               value : stringToPDFString(value));

  4813             } else {

  4814               info('Bad value in document info for "' + key + '"');

  4815             }

  4816           }

  4817         }

  4818       }

  4819       return shadow(this, 'documentInfo', docInfo);

  4820     },

  4821     get fingerprint() {

  4822       var xref = this.xref, hash, fileID = '';

  4824       if (xref.trailer.has('ID')) {

  4825         hash = stringToBytes(xref.trailer.get('ID')[0]);

  4826       } else {

  4827         hash = calculateMD5(this.stream.bytes.subarray(0, 100), 0, 100);

  4828       }

  4830       for (var i = 0, n = hash.length; i < n; i++) {

  4831         fileID += hash[i].toString(16);

  4832       }

  4834       return shadow(this, 'fingerprint', fileID);

  4835     },

  4837     getPage: function PDFDocument_getPage(pageIndex) {

  4838       return this.catalog.getPage(pageIndex);

  4839     },

  4841     cleanup: function PDFDocument_cleanup() {

  4842       return this.catalog.cleanup();

  4843     }

  4844   };

  4846   return PDFDocument;

  4847 })();

  4851 var Name = (function NameClosure() {

  4852   function Name(name) {

  4853     this.name = name;

  4854   }

  4856   Name.prototype = {};

  4858   var nameCache = {};

  4860   Name.get = function Name_get(name) {

  4861     var nameValue = nameCache[name];

  4862     return (nameValue ? nameValue : (nameCache[name] = new Name(name)));

  4863   };

  4865   return Name;

  4866 })();

  4868 var Cmd = (function CmdClosure() {

  4869   function Cmd(cmd) {

  4870     this.cmd = cmd;

  4871   }

  4873   Cmd.prototype = {};

  4875   var cmdCache = {};

  4877   Cmd.get = function Cmd_get(cmd) {

  4878     var cmdValue = cmdCache[cmd];

  4879     return (cmdValue ? cmdValue : (cmdCache[cmd] = new Cmd(cmd)));

  4880   };

  4882   return Cmd;

  4883 })();

  4885 var Dict = (function DictClosure() {

  4886   var nonSerializable = function nonSerializableClosure() {

  4887     return nonSerializable; // creating closure on some variable

  4888   };

  4890   var GETALL_DICTIONARY_TYPES_WHITELIST = {

  4891     'Background': true,

  4892     'ExtGState': true,

  4893     'Halftone': true,

  4894     'Layout': true,

  4895     'Mask': true,

  4896     'Pagination': true,

  4897     'Printing': true

  4898   };

  4900   function isRecursionAllowedFor(dict) {

  4901     if (!isName(dict.Type)) {

  4902       return true;

  4903     }

  4904     var dictType = dict.Type.name;

  4905     return GETALL_DICTIONARY_TYPES_WHITELIST[dictType] === true;

  4906   }

  4908   // xref is optional

  4909   function Dict(xref) {

  4910     // Map should only be used internally, use functions below to access.

  4911     this.map = Object.create(null);

  4912     this.xref = xref;

  4913     this.objId = null;

  4914     this.__nonSerializable__ = nonSerializable; // disable cloning of the Dict

  4915   }

  4917   Dict.prototype = {

  4918     assignXref: function Dict_assignXref(newXref) {

  4919       this.xref = newXref;

  4920     },

  4922     // automatically dereferences Ref objects

  4923     get: function Dict_get(key1, key2, key3) {

  4924       var value;

  4925       var xref = this.xref;

  4926       if (typeof (value = this.map[key1]) != 'undefined' || key1 in this.map ||

  4927           typeof key2 == 'undefined') {

  4928         return xref ? xref.fetchIfRef(value) : value;

  4929       }

  4930       if (typeof (value = this.map[key2]) != 'undefined' || key2 in this.map ||

  4931           typeof key3 == 'undefined') {

  4932         return xref ? xref.fetchIfRef(value) : value;

  4933       }

  4934       value = this.map[key3] || null;

  4935       return xref ? xref.fetchIfRef(value) : value;

  4936     },

  4938     // Same as get(), but returns a promise and uses fetchIfRefAsync().

  4939     getAsync: function Dict_getAsync(key1, key2, key3) {

  4940       var value;

  4941       var promise;

  4942       var xref = this.xref;

  4943       if (typeof (value = this.map[key1]) !== undefined || key1 in this.map ||

  4944           typeof key2 === undefined) {

  4945         if (xref) {

  4946           return xref.fetchIfRefAsync(value);

  4947         }

  4948         promise = new LegacyPromise();

  4949         promise.resolve(value);

  4950         return promise;

  4951       }

  4952       if (typeof (value = this.map[key2]) !== undefined || key2 in this.map ||

  4953           typeof key3 === undefined) {

  4954         if (xref) {

  4955           return xref.fetchIfRefAsync(value);

  4956         }

  4957         promise = new LegacyPromise();

  4958         promise.resolve(value);

  4959         return promise;

  4960       }

  4961       value = this.map[key3] || null;

  4962       if (xref) {

  4963         return xref.fetchIfRefAsync(value);

  4964       }

  4965       promise = new LegacyPromise();

  4966       promise.resolve(value);

  4967       return promise;

  4968     },

  4970     // no dereferencing

  4971     getRaw: function Dict_getRaw(key) {

  4972       return this.map[key];

  4973     },

  4975     // creates new map and dereferences all Refs

  4976     getAll: function Dict_getAll() {

  4977       var all = Object.create(null);

  4978       var queue = null;

  4979       var key, obj;

  4980       for (key in this.map) {

  4981         obj = this.get(key);

  4982         if (obj instanceof Dict) {

  4983           if (isRecursionAllowedFor(obj)) {

  4984             (queue || (queue = [])).push({target: all, key: key, obj: obj});

  4985           } else {

  4986             all[key] = this.getRaw(key);

  4987           }

  4988         } else {

  4989           all[key] = obj;

  4990         }

  4991       }

  4992       if (!queue) {

  4993         return all;

  4994       }

  4996       // trying to take cyclic references into the account

  4997       var processed = Object.create(null);

  4998       while (queue.length > 0) {

  4999         var item = queue.shift();

  5000         var itemObj = item.obj;

  5001         var objId = itemObj.objId;

  5002         if (objId && objId in processed) {

  5003           item.target[item.key] = processed[objId];

  5004           continue;

  5005         }

  5006         var dereferenced = Object.create(null);

  5007         for (key in itemObj.map) {

  5008           obj = itemObj.get(key);

  5009           if (obj instanceof Dict) {

  5010             if (isRecursionAllowedFor(obj)) {

  5011               queue.push({target: dereferenced, key: key, obj: obj});

  5012             } else {

  5013               dereferenced[key] = itemObj.getRaw(key);

  5014             }

  5015           } else {

  5016             dereferenced[key] = obj;

  5017           }

  5018         }

  5019         if (objId) {

  5020           processed[objId] = dereferenced;

  5021         }

  5022         item.target[item.key] = dereferenced;

  5023       }

  5024       return all;

  5025     },

  5027     set: function Dict_set(key, value) {

  5028       this.map[key] = value;

  5029     },

  5031     has: function Dict_has(key) {

  5032       return key in this.map;

  5033     },

  5035     forEach: function Dict_forEach(callback) {

  5036       for (var key in this.map) {

  5037         callback(key, this.get(key));

  5038       }

  5039     }

  5040   };

  5042   Dict.empty = new Dict(null);

  5044   return Dict;

  5045 })();

  5047 var Ref = (function RefClosure() {

  5048   function Ref(num, gen) {

  5049     this.num = num;

  5050     this.gen = gen;

  5051   }

  5053   Ref.prototype = {};

  5055   return Ref;

  5056 })();

  5058 // The reference is identified by number and generation.

  5059 // This structure stores only one instance of the reference.

  5060 var RefSet = (function RefSetClosure() {

  5061   function RefSet() {

  5062     this.dict = {};

  5063   }

  5065   RefSet.prototype = {

  5066     has: function RefSet_has(ref) {

  5067       return ('R' + ref.num + '.' + ref.gen) in this.dict;

  5068     },

  5070     put: function RefSet_put(ref) {

  5071       this.dict['R' + ref.num + '.' + ref.gen] = true;

  5072     },

  5074     remove: function RefSet_remove(ref) {

  5075       delete this.dict['R' + ref.num + '.' + ref.gen];

  5076     }

  5077   };

  5079   return RefSet;

  5080 })();

  5082 var RefSetCache = (function RefSetCacheClosure() {

  5083   function RefSetCache() {

  5084     this.dict = Object.create(null);

  5085   }

  5087   RefSetCache.prototype = {

  5088     get: function RefSetCache_get(ref) {

  5089       return this.dict['R' + ref.num + '.' + ref.gen];

  5090     },

  5092     has: function RefSetCache_has(ref) {

  5093       return ('R' + ref.num + '.' + ref.gen) in this.dict;

  5094     },

  5096     put: function RefSetCache_put(ref, obj) {

  5097       this.dict['R' + ref.num + '.' + ref.gen] = obj;

  5098     },

  5100     putAlias: function RefSetCache_putAlias(ref, aliasRef) {

  5101       this.dict['R' + ref.num + '.' + ref.gen] = this.get(aliasRef);

  5102     },

  5104     forEach: function RefSetCache_forEach(fn, thisArg) {

  5105       for (var i in this.dict) {

  5106         fn.call(thisArg, this.dict[i]);

  5107       }

  5108     },

  5110     clear: function RefSetCache_clear() {

  5111       this.dict = Object.create(null);

  5112     }

  5113   };

  5115   return RefSetCache;

  5116 })();

  5118 var Catalog = (function CatalogClosure() {

  5119   function Catalog(pdfManager, xref) {

  5120     this.pdfManager = pdfManager;

  5121     this.xref = xref;

  5122     this.catDict = xref.getCatalogObj();

  5123     this.fontCache = new RefSetCache();

  5124     assert(isDict(this.catDict),

  5125       'catalog object is not a dictionary');

  5127     this.pagePromises = [];

  5128   }

  5130   Catalog.prototype = {

  5131     get metadata() {

  5132       var streamRef = this.catDict.getRaw('Metadata');

  5133       if (!isRef(streamRef)) {

  5134         return shadow(this, 'metadata', null);

  5135       }

  5137       var encryptMetadata = (!this.xref.encrypt ? false :

  5138                              this.xref.encrypt.encryptMetadata);

  5140       var stream = this.xref.fetch(streamRef, !encryptMetadata);

  5141       var metadata;

  5142       if (stream && isDict(stream.dict)) {

  5143         var type = stream.dict.get('Type');

  5144         var subtype = stream.dict.get('Subtype');

  5146         if (isName(type) && isName(subtype) &&

  5147             type.name === 'Metadata' && subtype.name === 'XML') {

  5148           // XXX: This should examine the charset the XML document defines,

  5149           // however since there are currently no real means to decode

  5150           // arbitrary charsets, let's just hope that the author of the PDF

  5151           // was reasonable enough to stick with the XML default charset,

  5152           // which is UTF-8.

  5153           try {

  5154             metadata = stringToUTF8String(bytesToString(stream.getBytes()));

  5155           } catch (e) {

  5156             info('Skipping invalid metadata.');

  5157           }

  5158         }

  5159       }

  5161       return shadow(this, 'metadata', metadata);

  5162     },

  5163     get toplevelPagesDict() {

  5164       var pagesObj = this.catDict.get('Pages');

  5165       assert(isDict(pagesObj), 'invalid top-level pages dictionary');

  5166       // shadow the prototype getter

  5167       return shadow(this, 'toplevelPagesDict', pagesObj);

  5168     },

  5169     get documentOutline() {

  5170       var obj = null;

  5171       try {

  5172         obj = this.readDocumentOutline();

  5173       } catch (ex) {

  5174         if (ex instanceof MissingDataException) {

  5175           throw ex;

  5176         }

  5177         warn('Unable to read document outline');

  5178       }

  5179       return shadow(this, 'documentOutline', obj);

  5180     },

  5181     readDocumentOutline: function Catalog_readDocumentOutline() {

  5182       var xref = this.xref;

  5183       var obj = this.catDict.get('Outlines');

  5184       var root = { items: [] };

  5185       if (isDict(obj)) {

  5186         obj = obj.getRaw('First');

  5187         var processed = new RefSet();

  5188         if (isRef(obj)) {

  5189           var queue = [{obj: obj, parent: root}];

  5190           // to avoid recursion keeping track of the items

  5191           // in the processed dictionary

  5192           processed.put(obj);

  5193           while (queue.length > 0) {

  5194             var i = queue.shift();

  5195             var outlineDict = xref.fetchIfRef(i.obj);

  5196             if (outlineDict === null) {

  5197               continue;

  5198             }

  5199             if (!outlineDict.has('Title')) {

  5200               error('Invalid outline item');

  5201             }

  5202             var dest = outlineDict.get('A');

  5203             if (dest) {

  5204               dest = dest.get('D');

  5205             } else if (outlineDict.has('Dest')) {

  5206               dest = outlineDict.getRaw('Dest');

  5207               if (isName(dest)) {

  5208                 dest = dest.name;

  5209               }

  5210             }

  5211             var title = outlineDict.get('Title');

  5212             var outlineItem = {

  5213               dest: dest,

  5214               title: stringToPDFString(title),

  5215               color: outlineDict.get('C') || [0, 0, 0],

  5216               count: outlineDict.get('Count'),

  5217               bold: !!(outlineDict.get('F') & 2),

  5218               italic: !!(outlineDict.get('F') & 1),

  5219               items: []

  5220             };

  5221             i.parent.items.push(outlineItem);

  5222             obj = outlineDict.getRaw('First');

  5223             if (isRef(obj) && !processed.has(obj)) {

  5224               queue.push({obj: obj, parent: outlineItem});

  5225               processed.put(obj);

  5226             }

  5227             obj = outlineDict.getRaw('Next');

  5228             if (isRef(obj) && !processed.has(obj)) {

  5229               queue.push({obj: obj, parent: i.parent});

  5230               processed.put(obj);

  5231             }

  5232           }

  5233         }

  5234       }

  5235       return (root.items.length > 0 ? root.items : null);

  5236     },

  5237     get numPages() {

  5238       var obj = this.toplevelPagesDict.get('Count');

  5239       assert(

  5240         isInt(obj),

  5241         'page count in top level pages object is not an integer'

  5242       );

  5243       // shadow the prototype getter

  5244       return shadow(this, 'num', obj);

  5245     },

  5246     get destinations() {

  5247       function fetchDestination(dest) {

  5248         return isDict(dest) ? dest.get('D') : dest;

  5249       }

  5251       var xref = this.xref;

  5252       var dests = {}, nameTreeRef, nameDictionaryRef;

  5253       var obj = this.catDict.get('Names');

  5254       if (obj) {

  5255         nameTreeRef = obj.getRaw('Dests');

  5256       } else if (this.catDict.has('Dests')) {

  5257         nameDictionaryRef = this.catDict.get('Dests');

  5258       }

  5260       if (nameDictionaryRef) {

  5261         // reading simple destination dictionary

  5262         obj = nameDictionaryRef;

  5263         obj.forEach(function catalogForEach(key, value) {

  5264           if (!value) {

  5265             return;

  5266           }

  5267           dests[key] = fetchDestination(value);

  5268         });

  5269       }

  5270       if (nameTreeRef) {

  5271         var nameTree = new NameTree(nameTreeRef, xref);

  5272         var names = nameTree.getAll();

  5273         for (var name in names) {

  5274           if (!names.hasOwnProperty(name)) {

  5275             continue;

  5276           }

  5277           dests[name] = fetchDestination(names[name]);

  5278         }

  5279       }

  5280       return shadow(this, 'destinations', dests);

  5281     },

  5282     get attachments() {

  5283       var xref = this.xref;

  5284       var attachments, nameTreeRef;

  5285       var obj = this.catDict.get('Names');

  5286       if (obj) {

  5287         nameTreeRef = obj.getRaw('EmbeddedFiles');

  5288       }

  5290       if (nameTreeRef) {

  5291         var nameTree = new NameTree(nameTreeRef, xref);

  5292         var names = nameTree.getAll();

  5293         for (var name in names) {

  5294           if (!names.hasOwnProperty(name)) {

  5295             continue;

  5296           }

  5297           var fs = new FileSpec(names[name], xref);

  5298           if (!attachments) {

  5299             attachments = {};

  5300           }

  5301           attachments[stringToPDFString(name)] = fs.serializable;

  5302         }

  5303       }

  5304       return shadow(this, 'attachments', attachments);

  5305     },

  5306     get javaScript() {

  5307       var xref = this.xref;

  5308       var obj = this.catDict.get('Names');

  5310       var javaScript = [];

  5311       if (obj && obj.has('JavaScript')) {

  5312         var nameTree = new NameTree(obj.getRaw('JavaScript'), xref);

  5313         var names = nameTree.getAll();

  5314         for (var name in names) {

  5315           if (!names.hasOwnProperty(name)) {

  5316             continue;

  5317           }

  5318           // We don't really use the JavaScript right now. This code is

  5319           // defensive so we don't cause errors on document load.

  5320           var jsDict = names[name];

  5321           if (!isDict(jsDict)) {

  5322             continue;

  5323           }

  5324           var type = jsDict.get('S');

  5325           if (!isName(type) || type.name !== 'JavaScript') {

  5326             continue;

  5327           }

  5328           var js = jsDict.get('JS');

  5329           if (!isString(js) && !isStream(js)) {

  5330             continue;

  5331           }

  5332           if (isStream(js)) {

  5333             js = bytesToString(js.getBytes());

  5334           }

  5335           javaScript.push(stringToPDFString(js));

  5336         }

  5337       }

  5338       return shadow(this, 'javaScript', javaScript);

  5339     },

  5341     cleanup: function Catalog_cleanup() {

  5342       this.fontCache.forEach(function (font) {

  5343         delete font.sent;

  5344         delete font.translated;

  5345       });

  5346       this.fontCache.clear();

  5347     },

  5349     getPage: function Catalog_getPage(pageIndex) {

  5350       if (!(pageIndex in this.pagePromises)) {

  5351         this.pagePromises[pageIndex] = this.getPageDict(pageIndex).then(

  5352           function (a) {

  5353             var dict = a[0];

  5354             var ref = a[1];

  5355             return new Page(this.pdfManager, this.xref, pageIndex, dict, ref,

  5356                             this.fontCache);

  5357           }.bind(this)

  5358         );

  5359       }

  5360       return this.pagePromises[pageIndex];

  5361     },

  5363     getPageDict: function Catalog_getPageDict(pageIndex) {

  5364       var promise = new LegacyPromise();

  5365       var nodesToVisit = [this.catDict.getRaw('Pages')];

  5366       var currentPageIndex = 0;

  5367       var xref = this.xref;

  5369       function next() {

  5370         while (nodesToVisit.length) {

  5371           var currentNode = nodesToVisit.pop();

  5373           if (isRef(currentNode)) {

  5374             xref.fetchAsync(currentNode).then(function (obj) {

  5375               if ((isDict(obj, 'Page') || (isDict(obj) && !obj.has('Kids')))) {

  5376                 if (pageIndex === currentPageIndex) {

  5377                   promise.resolve([obj, currentNode]);

  5378                 } else {

  5379                   currentPageIndex++;

  5380                   next();

  5381                 }

  5382                 return;

  5383               }

  5384               nodesToVisit.push(obj);

  5385               next();

  5386             }.bind(this), promise.reject.bind(promise));

  5387             return;

  5388           }

  5390           // must be a child page dictionary

  5391           assert(

  5392             isDict(currentNode),

  5393             'page dictionary kid reference points to wrong type of object'

  5394           );

  5395           var count = currentNode.get('Count');

  5396           // Skip nodes where the page can't be.

  5397           if (currentPageIndex + count <= pageIndex) {

  5398             currentPageIndex += count;

  5399             continue;

  5400           }

  5402           var kids = currentNode.get('Kids');

  5403           assert(isArray(kids), 'page dictionary kids object is not an array');

  5404           if (count === kids.length) {

  5405             // Nodes that don't have the page have been skipped and this is the

  5406             // bottom of the tree which means the page requested must be a

  5407             // descendant of this pages node. Ideally we would just resolve the

  5408             // promise with the page ref here, but there is the case where more

  5409             // pages nodes could link to single a page (see issue 3666 pdf). To

  5410             // handle this push it back on the queue so if it is a pages node it

  5411             // will be descended into.

  5412             nodesToVisit = [kids[pageIndex - currentPageIndex]];

  5413             currentPageIndex = pageIndex;

  5414             continue;

  5415           } else {

  5416             for (var last = kids.length - 1; last >= 0; last--) {

  5417               nodesToVisit.push(kids[last]);

  5418             }

  5419           }

  5420         }

  5421         promise.reject('Page index ' + pageIndex + ' not found.');

  5422       }

  5423       next();

  5424       return promise;

  5425     },

  5427     getPageIndex: function Catalog_getPageIndex(ref) {

  5428       // The page tree nodes have the count of all the leaves below them. To get

  5429       // how many pages are before we just have to walk up the tree and keep

  5430       // adding the count of siblings to the left of the node.

  5431       var xref = this.xref;

  5432       function pagesBeforeRef(kidRef) {

  5433         var total = 0;

  5434         var parentRef;

  5435         return xref.fetchAsync(kidRef).then(function (node) {

  5436           if (!node) {

  5437             return null;

  5438           }

  5439           parentRef = node.getRaw('Parent');

  5440           return node.getAsync('Parent');

  5441         }).then(function (parent) {

  5442           if (!parent) {

  5443             return null;

  5444           }

  5445           return parent.getAsync('Kids');

  5446         }).then(function (kids) {

  5447           if (!kids) {

  5448             return null;

  5449           }

  5450           var kidPromises = [];

  5451           var found = false;

  5452           for (var i = 0; i < kids.length; i++) {

  5453             var kid = kids[i];

  5454             assert(isRef(kid), 'kids must be a ref');

  5455             if (kid.num == kidRef.num) {

  5456               found = true;

  5457               break;

  5458             }

  5459             kidPromises.push(xref.fetchAsync(kid).then(function (kid) {

  5460               if (kid.has('Count')) {

  5461                 var count = kid.get('Count');

  5462                 total += count;

  5463               } else { // page leaf node

  5464                 total++;

  5465               }

  5466             }));

  5467           }

  5468           if (!found) {

  5469             error('kid ref not found in parents kids');

  5470           }

  5471           return Promise.all(kidPromises).then(function () {

  5472             return [total, parentRef];

  5473           });

  5474         });

  5475       }

  5477       var total = 0;

  5478       function next(ref) {

  5479         return pagesBeforeRef(ref).then(function (args) {

  5480           if (!args) {

  5481             return total;

  5482           }

  5483           var count = args[0];

  5484           var parentRef = args[1];

  5485           total += count;

  5486           return next(parentRef);

  5487         });

  5488       }

  5490       return next(ref);

  5491     }

  5492   };

  5494   return Catalog;

  5495 })();

  5497 var XRef = (function XRefClosure() {

  5498   function XRef(stream, password) {

  5499     this.stream = stream;

  5500     this.entries = [];

  5501     this.xrefstms = {};

  5502     // prepare the XRef cache

  5503     this.cache = [];

  5504     this.password = password;

  5505   }

  5507   XRef.prototype = {

  5508     setStartXRef: function XRef_setStartXRef(startXRef) {

  5509       // Store the starting positions of xref tables as we process them

  5510       // so we can recover from missing data errors

  5511       this.startXRefQueue = [startXRef];

  5512     },

  5514     parse: function XRef_parse(recoveryMode) {

  5515       var trailerDict;

  5516       if (!recoveryMode) {

  5517         trailerDict = this.readXRef();

  5518       } else {

  5519         warn('Indexing all PDF objects');

  5520         trailerDict = this.indexObjects();

  5521       }

  5522       trailerDict.assignXref(this);

  5523       this.trailer = trailerDict;

  5524       var encrypt = trailerDict.get('Encrypt');

  5525       if (encrypt) {

  5526         var ids = trailerDict.get('ID');

  5527         var fileId = (ids && ids.length) ? ids[0] : '';

  5528         this.encrypt = new CipherTransformFactory(encrypt, fileId,

  5529                                                   this.password);

  5530       }

  5532       // get the root dictionary (catalog) object

  5533       if (!(this.root = trailerDict.get('Root'))) {

  5534         error('Invalid root reference');

  5535       }

  5536     },

  5538     processXRefTable: function XRef_processXRefTable(parser) {

  5539       if (!('tableState' in this)) {

  5540         // Stores state of the table as we process it so we can resume

  5541         // from middle of table in case of missing data error

  5542         this.tableState = {

  5543           entryNum: 0,

  5544           streamPos: parser.lexer.stream.pos,

  5545           parserBuf1: parser.buf1,

  5546           parserBuf2: parser.buf2

  5547         };

  5548       }

  5550       var obj = this.readXRefTable(parser);

  5552       // Sanity check

  5553       if (!isCmd(obj, 'trailer')) {

  5554         error('Invalid XRef table: could not find trailer dictionary');

  5555       }

  5556       // Read trailer dictionary, e.g.

  5557       // trailer

  5558       //    << /Size 22

  5559       //      /Root 20R

  5560       //      /Info 10R

  5561       //      /ID [ <81b14aafa313db63dbd6f981e49f94f4> ]

  5562       //    >>

  5563       // The parser goes through the entire stream << ... >> and provides

  5564       // a getter interface for the key-value table

  5565       var dict = parser.getObj();

  5566       if (!isDict(dict)) {

  5567         error('Invalid XRef table: could not parse trailer dictionary');

  5568       }

  5569       delete this.tableState;

  5571       return dict;

  5572     },

  5574     readXRefTable: function XRef_readXRefTable(parser) {

  5575       // Example of cross-reference table:

  5576       // xref

  5577       // 0 1                    <-- subsection header (first obj #, obj count)

  5578       // 0000000000 65535 f     <-- actual object (offset, generation #, f/n)

  5579       // 23 2                   <-- subsection header ... and so on ...

  5580       // 0000025518 00002 n

  5581       // 0000025635 00000 n

  5582       // trailer

  5583       // ...

  5585       var stream = parser.lexer.stream;

  5586       var tableState = this.tableState;

  5587       stream.pos = tableState.streamPos;

  5588       parser.buf1 = tableState.parserBuf1;

  5589       parser.buf2 = tableState.parserBuf2;

  5591       // Outer loop is over subsection headers

  5592       var obj;

  5594       while (true) {

  5595         if (!('firstEntryNum' in tableState) || !('entryCount' in tableState)) {

  5596           if (isCmd(obj = parser.getObj(), 'trailer')) {

  5597             break;

  5598           }

  5599           tableState.firstEntryNum = obj;

  5600           tableState.entryCount = parser.getObj();

  5601         }

  5603         var first = tableState.firstEntryNum;

  5604         var count = tableState.entryCount;

  5605         if (!isInt(first) || !isInt(count)) {

  5606           error('Invalid XRef table: wrong types in subsection header');

  5607         }

  5608         // Inner loop is over objects themselves

  5609         for (var i = tableState.entryNum; i < count; i++) {

  5610           tableState.streamPos = stream.pos;

  5611           tableState.entryNum = i;

  5612           tableState.parserBuf1 = parser.buf1;

  5613           tableState.parserBuf2 = parser.buf2;

  5615           var entry = {};

  5616           entry.offset = parser.getObj();

  5617           entry.gen = parser.getObj();

  5618           var type = parser.getObj();

  5620           if (isCmd(type, 'f')) {

  5621             entry.free = true;

  5622           } else if (isCmd(type, 'n')) {

  5623             entry.uncompressed = true;

  5624           }

  5626           // Validate entry obj

  5627           if (!isInt(entry.offset) || !isInt(entry.gen) ||

  5628               !(entry.free || entry.uncompressed)) {

  5629             console.log(entry.offset, entry.gen, entry.free,

  5630                         entry.uncompressed);

  5631             error('Invalid entry in XRef subsection: ' + first + ', ' + count);

  5632           }

  5634           if (!this.entries[i + first]) {

  5635             this.entries[i + first] = entry;

  5636           }

  5637         }

  5639         tableState.entryNum = 0;

  5640         tableState.streamPos = stream.pos;

  5641         tableState.parserBuf1 = parser.buf1;

  5642         tableState.parserBuf2 = parser.buf2;

  5643         delete tableState.firstEntryNum;

  5644         delete tableState.entryCount;

  5645       }

  5647       // Per issue 3248: hp scanners generate bad XRef

  5648       if (first === 1 && this.entries[1] && this.entries[1].free) {

  5649         // shifting the entries

  5650         this.entries.shift();

  5651       }

  5653       // Sanity check: as per spec, first object must be free

  5654       if (this.entries[0] && !this.entries[0].free) {

  5655         error('Invalid XRef table: unexpected first object');

  5656       }

  5657       return obj;

  5658     },

  5660     processXRefStream: function XRef_processXRefStream(stream) {

  5661       if (!('streamState' in this)) {

  5662         // Stores state of the stream as we process it so we can resume

  5663         // from middle of stream in case of missing data error

  5664         var streamParameters = stream.dict;

  5665         var byteWidths = streamParameters.get('W');

  5666         var range = streamParameters.get('Index');

  5667         if (!range) {

  5668           range = [0, streamParameters.get('Size')];

  5669         }

  5671         this.streamState = {

  5672           entryRanges: range,

  5673           byteWidths: byteWidths,

  5674           entryNum: 0,

  5675           streamPos: stream.pos

  5676         };

  5677       }

  5678       this.readXRefStream(stream);

  5679       delete this.streamState;

  5681       return stream.dict;

  5682     },

  5684     readXRefStream: function XRef_readXRefStream(stream) {

  5685       var i, j;

  5686       var streamState = this.streamState;

  5687       stream.pos = streamState.streamPos;

  5689       var byteWidths = streamState.byteWidths;

  5690       var typeFieldWidth = byteWidths[0];

  5691       var offsetFieldWidth = byteWidths[1];

  5692       var generationFieldWidth = byteWidths[2];

  5694       var entryRanges = streamState.entryRanges;

  5695       while (entryRanges.length > 0) {

  5696         var first = entryRanges[0];

  5697         var n = entryRanges[1];

  5699         if (!isInt(first) || !isInt(n)) {

  5700           error('Invalid XRef range fields: ' + first + ', ' + n);

  5701         }

  5702         if (!isInt(typeFieldWidth) || !isInt(offsetFieldWidth) ||

  5703             !isInt(generationFieldWidth)) {

  5704           error('Invalid XRef entry fields length: ' + first + ', ' + n);

  5705         }

  5706         for (i = streamState.entryNum; i < n; ++i) {

  5707           streamState.entryNum = i;

  5708           streamState.streamPos = stream.pos;

  5710           var type = 0, offset = 0, generation = 0;

  5711           for (j = 0; j < typeFieldWidth; ++j) {

  5712             type = (type << 8) | stream.getByte();

  5713           }

  5714           // if type field is absent, its default value is 1

  5715           if (typeFieldWidth === 0) {

  5716             type = 1;

  5717           }

  5718           for (j = 0; j < offsetFieldWidth; ++j) {

  5719             offset = (offset << 8) | stream.getByte();

  5720           }

  5721           for (j = 0; j < generationFieldWidth; ++j) {

  5722             generation = (generation << 8) | stream.getByte();

  5723           }

  5724           var entry = {};

  5725           entry.offset = offset;

  5726           entry.gen = generation;

  5727           switch (type) {

  5728             case 0:

  5729               entry.free = true;

  5730               break;

  5731             case 1:

  5732               entry.uncompressed = true;

  5733               break;

  5734             case 2:

  5735               break;

  5736             default:

  5737               error('Invalid XRef entry type: ' + type);

  5738           }

  5739           if (!this.entries[first + i]) {

  5740             this.entries[first + i] = entry;

  5741           }

  5742         }

  5744         streamState.entryNum = 0;

  5745         streamState.streamPos = stream.pos;

  5746         entryRanges.splice(0, 2);

  5747       }

  5748     },

  5750     indexObjects: function XRef_indexObjects() {

  5751       // Simple scan through the PDF content to find objects,

  5752       // trailers and XRef streams.

  5753       function readToken(data, offset) {

  5754         var token = '', ch = data[offset];

  5755         while (ch !== 13 && ch !== 10) {

  5756           if (++offset >= data.length) {

  5757             break;

  5758           }

  5759           token += String.fromCharCode(ch);

  5760           ch = data[offset];

  5761         }

  5762         return token;

  5763       }

  5764       function skipUntil(data, offset, what) {

  5765         var length = what.length, dataLength = data.length;

  5766         var skipped = 0;

  5767         // finding byte sequence

  5768         while (offset < dataLength) {

  5769           var i = 0;

  5770           while (i < length && data[offset + i] == what[i]) {

  5771             ++i;

  5772           }

  5773           if (i >= length) {

  5774             break; // sequence found

  5775           }

  5776           offset++;

  5777           skipped++;

  5778         }

  5779         return skipped;

  5780       }

  5781       var trailerBytes = new Uint8Array([116, 114, 97, 105, 108, 101, 114]);

  5782       var startxrefBytes = new Uint8Array([115, 116, 97, 114, 116, 120, 114,

  5783                                           101, 102]);

  5784       var endobjBytes = new Uint8Array([101, 110, 100, 111, 98, 106]);

  5785       var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);

  5787       var stream = this.stream;

  5788       stream.pos = 0;

  5789       var buffer = stream.getBytes();

  5790       var position = stream.start, length = buffer.length;

  5791       var trailers = [], xrefStms = [];

  5792       while (position < length) {

  5793         var ch = buffer[position];

  5794         if (ch === 32 || ch === 9 || ch === 13 || ch === 10) {

  5795           ++position;

  5796           continue;

  5797         }

  5798         if (ch === 37) { // %-comment

  5799           do {

  5800             ++position;

  5801             if (position >= length) {

  5802               break;

  5803             }

  5804             ch = buffer[position];

  5805           } while (ch !== 13 && ch !== 10);

  5806           continue;

  5807         }

  5808         var token = readToken(buffer, position);

  5809         var m;

  5810         if (token === 'xref') {

  5811           position += skipUntil(buffer, position, trailerBytes);

  5812           trailers.push(position);

  5813           position += skipUntil(buffer, position, startxrefBytes);

  5814         } else if ((m = /^(\d+)\s+(\d+)\s+obj\b/.exec(token))) {

  5815           this.entries[m[1]] = {

  5816             offset: position,

  5817             gen: m[2] | 0,

  5818             uncompressed: true

  5819           };

  5821           var contentLength = skipUntil(buffer, position, endobjBytes) + 7;

  5822           var content = buffer.subarray(position, position + contentLength);

  5824           // checking XRef stream suspect

  5825           // (it shall have '/XRef' and next char is not a letter)

  5826           var xrefTagOffset = skipUntil(content, 0, xrefBytes);

  5827           if (xrefTagOffset < contentLength &&

  5828               content[xrefTagOffset + 5] < 64) {

  5829             xrefStms.push(position);

  5830             this.xrefstms[position] = 1; // don't read it recursively

  5831           }

  5833           position += contentLength;

  5834         } else {

  5835           position += token.length + 1;

  5836         }

  5837       }

  5838       // reading XRef streams

  5839       var i, ii;

  5840       for (i = 0, ii = xrefStms.length; i < ii; ++i) {

  5841         this.startXRefQueue.push(xrefStms[i]);

  5842         this.readXRef(/* recoveryMode */ true);

  5843       }

  5844       // finding main trailer

  5845       var dict;

  5846       for (i = 0, ii = trailers.length; i < ii; ++i) {

  5847         stream.pos = trailers[i];

  5848         var parser = new Parser(new Lexer(stream), true, null);

  5849         var obj = parser.getObj();

  5850         if (!isCmd(obj, 'trailer')) {

  5851           continue;

  5852         }

  5853         // read the trailer dictionary

  5854         if (!isDict(dict = parser.getObj())) {

  5855           continue;

  5856         }

  5857         // taking the first one with 'ID'

  5858         if (dict.has('ID')) {

  5859           return dict;

  5860         }

  5861       }

  5862       // no tailer with 'ID', taking last one (if exists)

  5863       if (dict) {

  5864         return dict;

  5865       }

  5866       // nothing helps

  5867       // calling error() would reject worker with an UnknownErrorException.

  5868       throw new InvalidPDFException('Invalid PDF structure');

  5869     },

  5871     readXRef: function XRef_readXRef(recoveryMode) {

  5872       var stream = this.stream;

  5874       try {

  5875         while (this.startXRefQueue.length) {

  5876           var startXRef = this.startXRefQueue[0];

  5878           stream.pos = startXRef + stream.start;

  5880           var parser = new Parser(new Lexer(stream), true, null);

  5881           var obj = parser.getObj();

  5882           var dict;

  5884           // Get dictionary

  5885           if (isCmd(obj, 'xref')) {

  5886             // Parse end-of-file XRef

  5887             dict = this.processXRefTable(parser);

  5888             if (!this.topDict) {

  5889               this.topDict = dict;

  5890             }

  5892             // Recursively get other XRefs 'XRefStm', if any

  5893             obj = dict.get('XRefStm');

  5894             if (isInt(obj)) {

  5895               var pos = obj;

  5896               // ignore previously loaded xref streams

  5897               // (possible infinite recursion)

  5898               if (!(pos in this.xrefstms)) {

  5899                 this.xrefstms[pos] = 1;

  5900                 this.startXRefQueue.push(pos);

  5901               }

  5902             }

  5903           } else if (isInt(obj)) {

  5904             // Parse in-stream XRef

  5905             if (!isInt(parser.getObj()) ||

  5906                 !isCmd(parser.getObj(), 'obj') ||

  5907                 !isStream(obj = parser.getObj())) {

  5908               error('Invalid XRef stream');

  5909             }

  5910             dict = this.processXRefStream(obj);

  5911             if (!this.topDict) {

  5912               this.topDict = dict;

  5913             }

  5914             if (!dict) {

  5915               error('Failed to read XRef stream');

  5916             }

  5917           } else {

  5918             error('Invalid XRef stream header');

  5919           }

  5921           // Recursively get previous dictionary, if any

  5922           obj = dict.get('Prev');

  5923           if (isInt(obj)) {

  5924             this.startXRefQueue.push(obj);

  5925           } else if (isRef(obj)) {

  5926             // The spec says Prev must not be a reference, i.e. "/Prev NNN"

  5927             // This is a fallback for non-compliant PDFs, i.e. "/Prev NNN 0 R"

  5928             this.startXRefQueue.push(obj.num);

  5929           }

  5931           this.startXRefQueue.shift();

  5932         }

  5934         return this.topDict;

  5935       } catch (e) {

  5936         if (e instanceof MissingDataException) {

  5937           throw e;

  5938         }

  5939         info('(while reading XRef): ' + e);

  5940       }

  5942       if (recoveryMode) {

  5943         return;

  5944       }

  5945       throw new XRefParseException();

  5946     },

  5948     getEntry: function XRef_getEntry(i) {

  5949       var xrefEntry = this.entries[i];

  5950       if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {

  5951         return xrefEntry;

  5952       }

  5953       return null;

  5954     },

  5956     fetchIfRef: function XRef_fetchIfRef(obj) {

  5957       if (!isRef(obj)) {

  5958         return obj;

  5959       }

  5960       return this.fetch(obj);

  5961     },

  5963     fetch: function XRef_fetch(ref, suppressEncryption) {

  5964       assert(isRef(ref), 'ref object is not a reference');

  5965       var num = ref.num;

  5966       if (num in this.cache) {

  5967         var cacheEntry = this.cache[num];

  5968         return cacheEntry;

  5969       }

  5971       var xrefEntry = this.getEntry(num);

  5973       // the referenced entry can be free

  5974       if (xrefEntry === null) {

  5975         return (this.cache[num] = null);

  5976       }

  5978       if (xrefEntry.uncompressed) {

  5979         xrefEntry = this.fetchUncompressed(ref, xrefEntry, suppressEncryption);

  5980       } else {

  5981         xrefEntry = this.fetchCompressed(xrefEntry, suppressEncryption);

  5982       }

  5984       if (isDict(xrefEntry)) {

  5985         xrefEntry.objId = 'R' + ref.num + '.' + ref.gen;

  5986       }

  5987       return xrefEntry;

  5988     },

  5990     fetchUncompressed: function XRef_fetchUncompressed(ref, xrefEntry,

  5991                                                        suppressEncryption) {

  5992       var gen = ref.gen;

  5993       var num = ref.num;

  5994       if (xrefEntry.gen !== gen) {

  5995         error('inconsistent generation in XRef');

  5996       }

  5997       var stream = this.stream.makeSubStream(xrefEntry.offset +

  5998                                              this.stream.start);

  5999       var parser = new Parser(new Lexer(stream), true, this);

  6000       var obj1 = parser.getObj();

  6001       var obj2 = parser.getObj();

  6002       var obj3 = parser.getObj();

  6003       if (!isInt(obj1) || parseInt(obj1, 10) !== num ||

  6004           !isInt(obj2) || parseInt(obj2, 10) !== gen ||

  6005           !isCmd(obj3)) {

  6006         error('bad XRef entry');

  6007       }

  6008       if (!isCmd(obj3, 'obj')) {

  6009         // some bad PDFs use "obj1234" and really mean 1234

  6010         if (obj3.cmd.indexOf('obj') === 0) {

  6011           num = parseInt(obj3.cmd.substring(3), 10);

  6012           if (!isNaN(num)) {

  6013             return num;

  6014           }

  6015         }

  6016         error('bad XRef entry');

  6017       }

  6018       if (this.encrypt && !suppressEncryption) {

  6019         try {

  6020           xrefEntry = parser.getObj(this.encrypt.createCipherTransform(num,

  6021                                                                        gen));

  6022         } catch (ex) {

  6023           // Almost all streams must be encrypted, but sometimes

  6024           // they are not, probably due to some broken generators.

  6025           // Retrying without encryption...

  6026           return this.fetch(ref, true);

  6027         }

  6028       } else {

  6029         xrefEntry = parser.getObj();

  6030       }

  6031       if (!isStream(xrefEntry)) {

  6032         this.cache[num] = xrefEntry;

  6033       }

  6034       return xrefEntry;

  6035     },

  6037     fetchCompressed: function XRef_fetchCompressed(xrefEntry,

  6038                                                    suppressEncryption) {

  6039       var tableOffset = xrefEntry.offset;

  6040       var stream = this.fetch(new Ref(tableOffset, 0));

  6041       if (!isStream(stream)) {

  6042         error('bad ObjStm stream');

  6043       }

  6044       var first = stream.dict.get('First');

  6045       var n = stream.dict.get('N');

  6046       if (!isInt(first) || !isInt(n)) {

  6047         error('invalid first and n parameters for ObjStm stream');

  6048       }

  6049       var parser = new Parser(new Lexer(stream), false, this);

  6050       parser.allowStreams = true;

  6051       var i, entries = [], num, nums = [];

  6052       // read the object numbers to populate cache

  6053       for (i = 0; i < n; ++i) {

  6054         num = parser.getObj();

  6055         if (!isInt(num)) {

  6056           error('invalid object number in the ObjStm stream: ' + num);

  6057         }

  6058         nums.push(num);

  6059         var offset = parser.getObj();

  6060         if (!isInt(offset)) {

  6061           error('invalid object offset in the ObjStm stream: ' + offset);

  6062         }

  6063       }

  6064       // read stream objects for cache

  6065       for (i = 0; i < n; ++i) {

  6066         entries.push(parser.getObj());

  6067         num = nums[i];

  6068         var entry = this.entries[num];

  6069         if (entry && entry.offset === tableOffset && entry.gen === i) {

  6070           this.cache[num] = entries[i];

  6071         }

  6072       }

  6073       xrefEntry = entries[xrefEntry.gen];

  6074       if (xrefEntry === undefined) {

  6075         error('bad XRef entry for compressed object');

  6076       }

  6077       return xrefEntry;

  6078     },

  6080     fetchIfRefAsync: function XRef_fetchIfRefAsync(obj) {

  6081       if (!isRef(obj)) {

  6082         var promise = new LegacyPromise();

  6083         promise.resolve(obj);

  6084         return promise;

  6085       }

  6086       return this.fetchAsync(obj);

  6087     },

  6089     fetchAsync: function XRef_fetchAsync(ref, suppressEncryption) {

  6090       var promise = new LegacyPromise();

  6091       var tryFetch = function (promise) {

  6092         try {

  6093           promise.resolve(this.fetch(ref, suppressEncryption));

  6094         } catch (e) {

  6095           if (e instanceof MissingDataException) {

  6096             this.stream.manager.requestRange(e.begin, e.end, tryFetch);

  6097             return;

  6098           }

  6099           promise.reject(e);

  6100         }

  6101       }.bind(this, promise);

  6102       tryFetch();

  6103       return promise;

  6104     },

  6106     getCatalogObj: function XRef_getCatalogObj() {

  6107       return this.root;

  6108     }

  6109   };

  6111   return XRef;

  6112 })();

  6114 /**

  6115  * A NameTree is like a Dict but has some advantageous properties, see the

  6116  * spec (7.9.6) for more details.

  6117  * TODO: implement all the Dict functions and make this more efficent.

  6118  */

  6119 var NameTree = (function NameTreeClosure() {

  6120   function NameTree(root, xref) {

  6121     this.root = root;

  6122     this.xref = xref;

  6123   }

  6125   NameTree.prototype = {

  6126     getAll: function NameTree_getAll() {

  6127       var dict = {};

  6128       if (!this.root) {

  6129         return dict;

  6130       }

  6131       var xref = this.xref;

  6132       // reading name tree

  6133       var processed = new RefSet();

  6134       processed.put(this.root);

  6135       var queue = [this.root];

  6136       while (queue.length > 0) {

  6137         var i, n;

  6138         var obj = xref.fetchIfRef(queue.shift());

  6139         if (!isDict(obj)) {

  6140           continue;

  6141         }

  6142         if (obj.has('Kids')) {

  6143           var kids = obj.get('Kids');

  6144           for (i = 0, n = kids.length; i < n; i++) {

  6145             var kid = kids[i];

  6146             if (processed.has(kid)) {

  6147               error('invalid destinations');

  6148             }

  6149             queue.push(kid);

  6150             processed.put(kid);

  6151           }

  6152           continue;

  6153         }

  6154         var names = obj.get('Names');

  6155         if (names) {

  6156           for (i = 0, n = names.length; i < n; i += 2) {

  6157             dict[names[i]] = xref.fetchIfRef(names[i + 1]);

  6158           }

  6159         }

  6160       }

  6161       return dict;

  6162     }

  6163   };

  6164   return NameTree;

  6165 })();

  6167 /**

  6168  * "A PDF file can refer to the contents of another file by using a File

  6169  * Specification (PDF 1.1)", see the spec (7.11) for more details.

  6170  * NOTE: Only embedded files are supported (as part of the attachments support)

  6171  * TODO: support the 'URL' file system (with caching if !/V), portable

  6172  * collections attributes and related files (/RF)

  6173  */

  6174 var FileSpec = (function FileSpecClosure() {

  6175   function FileSpec(root, xref) {

  6176     if (!root || !isDict(root)) {

  6177       return;

  6178     }

  6179     this.xref = xref;

  6180     this.root = root;

  6181     if (root.has('FS')) {

  6182       this.fs = root.get('FS');

  6183     }

  6184     this.description = root.has('Desc') ?

  6185                          stringToPDFString(root.get('Desc')) :

  6186                          '';

  6187     if (root.has('RF')) {

  6188       warn('Related file specifications are not supported');

  6189     }

  6190     this.contentAvailable = true;

  6191     if (!root.has('EF')) {

  6192       this.contentAvailable = false;

  6193       warn('Non-embedded file specifications are not supported');

  6194     }

  6195   }

  6197   function pickPlatformItem(dict) {

  6198     // Look for the filename in this order:

  6199     // UF, F, Unix, Mac, DOS

  6200     if (dict.has('UF')) {

  6201       return dict.get('UF');

  6202     } else if (dict.has('F')) {

  6203       return dict.get('F');

  6204     } else if (dict.has('Unix')) {

  6205       return dict.get('Unix');

  6206     } else if (dict.has('Mac')) {

  6207       return dict.get('Mac');

  6208     } else if (dict.has('DOS')) {

  6209       return dict.get('DOS');

  6210     } else {

  6211       return null;

  6212     }

  6213   }

  6215   FileSpec.prototype = {

  6216     get filename() {

  6217       if (!this._filename && this.root) {

  6218         var filename = pickPlatformItem(this.root) || 'unnamed';

  6219         this._filename = stringToPDFString(filename).

  6220           replace(/\\\\/g, '\\').

  6221           replace(/\\\//g, '/').

  6222           replace(/\\/g, '/');

  6223       }

  6224       return this._filename;

  6225     },

  6226     get content() {

  6227       if (!this.contentAvailable) {

  6228         return null;

  6229       }

  6230       if (!this.contentRef && this.root) {

  6231         this.contentRef = pickPlatformItem(this.root.get('EF'));

  6232       }

  6233       var content = null;

  6234       if (this.contentRef) {

  6235         var xref = this.xref;

  6236         var fileObj = xref.fetchIfRef(this.contentRef);

  6237         if (fileObj && isStream(fileObj)) {

  6238           content = fileObj.getBytes();

  6239         } else {

  6240           warn('Embedded file specification points to non-existing/invalid ' +

  6241             'content');

  6242         }

  6243       } else {

  6244         warn('Embedded file specification does not have a content');

  6245       }

  6246       return content;

  6247     },

  6248     get serializable() {

  6249       return {

  6250         filename: this.filename,

  6251         content: this.content

  6252       };

  6253     }

  6254   };

  6255   return FileSpec;

  6256 })();

  6258 /**

  6259  * A helper for loading missing data in object graphs. It traverses the graph

  6260  * depth first and queues up any objects that have missing data. Once it has

  6261  * has traversed as many objects that are available it attempts to bundle the

  6262  * missing data requests and then resume from the nodes that weren't ready.

  6263  *

  6264  * NOTE: It provides protection from circular references by keeping track of

  6265  * of loaded references. However, you must be careful not to load any graphs

  6266  * that have references to the catalog or other pages since that will cause the

  6267  * entire PDF document object graph to be traversed.

  6268  */

  6269 var ObjectLoader = (function() {

  6270   function mayHaveChildren(value) {

  6271     return isRef(value) || isDict(value) || isArray(value) || isStream(value);

  6272   }

  6274   function addChildren(node, nodesToVisit) {

  6275     var value;

  6276     if (isDict(node) || isStream(node)) {

  6277       var map;

  6278       if (isDict(node)) {

  6279         map = node.map;

  6280       } else {

  6281         map = node.dict.map;

  6282       }

  6283       for (var key in map) {

  6284         value = map[key];

  6285         if (mayHaveChildren(value)) {

  6286           nodesToVisit.push(value);

  6287         }

  6288       }

  6289     } else if (isArray(node)) {

  6290       for (var i = 0, ii = node.length; i < ii; i++) {

  6291         value = node[i];

  6292         if (mayHaveChildren(value)) {

  6293           nodesToVisit.push(value);

  6294         }

  6295       }

  6296     }

  6297   }

  6299   function ObjectLoader(obj, keys, xref) {

  6300     this.obj = obj;

  6301     this.keys = keys;

  6302     this.xref = xref;

  6303     this.refSet = null;

  6304   }

  6306   ObjectLoader.prototype = {

  6307     load: function ObjectLoader_load() {

  6308       var keys = this.keys;

  6309       this.promise = new LegacyPromise();

  6310       // Don't walk the graph if all the data is already loaded.

  6311       if (!(this.xref.stream instanceof ChunkedStream) ||

  6312           this.xref.stream.getMissingChunks().length === 0) {

  6313         this.promise.resolve();

  6314         return this.promise;

  6315       }

  6317       this.refSet = new RefSet();

  6318       // Setup the initial nodes to visit.

  6319       var nodesToVisit = [];

  6320       for (var i = 0; i < keys.length; i++) {

  6321         nodesToVisit.push(this.obj[keys[i]]);

  6322       }

  6324       this.walk(nodesToVisit);

  6325       return this.promise;

  6326     },

  6328     walk: function ObjectLoader_walk(nodesToVisit) {

  6329       var nodesToRevisit = [];

  6330       var pendingRequests = [];

  6331       // DFS walk of the object graph.

  6332       while (nodesToVisit.length) {

  6333         var currentNode = nodesToVisit.pop();

  6335         // Only references or chunked streams can cause missing data exceptions.

  6336         if (isRef(currentNode)) {

  6337           // Skip nodes that have already been visited.

  6338           if (this.refSet.has(currentNode)) {

  6339             continue;

  6340           }

  6341           try {

  6342             var ref = currentNode;

  6343             this.refSet.put(ref);

  6344             currentNode = this.xref.fetch(currentNode);

  6345           } catch (e) {

  6346             if (!(e instanceof MissingDataException)) {

  6347               throw e;

  6348             }

  6349             nodesToRevisit.push(currentNode);

  6350             pendingRequests.push({ begin: e.begin, end: e.end });

  6351           }

  6352         }

  6353         if (currentNode && currentNode.getBaseStreams) {

  6354           var baseStreams = currentNode.getBaseStreams();

  6355           var foundMissingData = false;

  6356           for (var i = 0; i < baseStreams.length; i++) {

  6357             var stream = baseStreams[i];

  6358             if (stream.getMissingChunks && stream.getMissingChunks().length) {

  6359               foundMissingData = true;

  6360               pendingRequests.push({

  6361                 begin: stream.start,

  6362                 end: stream.end

  6363               });

  6364             }

  6365           }

  6366           if (foundMissingData) {

  6367             nodesToRevisit.push(currentNode);

  6368           }

  6369         }

  6371         addChildren(currentNode, nodesToVisit);

  6372       }

  6374       if (pendingRequests.length) {

  6375         this.xref.stream.manager.requestRanges(pendingRequests,

  6376             function pendingRequestCallback() {

  6377           nodesToVisit = nodesToRevisit;

  6378           for (var i = 0; i < nodesToRevisit.length; i++) {

  6379             var node = nodesToRevisit[i];

  6380             // Remove any reference nodes from the currrent refset so they

  6381             // aren't skipped when we revist them.

  6382             if (isRef(node)) {

  6383               this.refSet.remove(node);

  6384             }

  6385           }

  6386           this.walk(nodesToVisit);

  6387         }.bind(this));

  6388         return;

  6389       }

  6390       // Everything is loaded.

  6391       this.refSet = null;

  6392       this.promise.resolve();

  6393     }

  6394   };

  6396   return ObjectLoader;

  6397 })();

  6400 var ISOAdobeCharset = [

  6401   '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar',

  6402   'percent', 'ampersand', 'quoteright', 'parenleft', 'parenright',

  6403   'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash', 'zero',

  6404   'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',

  6405   'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question',

  6406   'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',

  6407   'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',

  6408   'bracketleft', 'backslash', 'bracketright', 'asciicircum', 'underscore',

  6409   'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',

  6410   'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',

  6411   'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent',

  6412   'sterling', 'fraction', 'yen', 'florin', 'section', 'currency',

  6413   'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft',

  6414   'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl',

  6415   'periodcentered', 'paragraph', 'bullet', 'quotesinglbase',

  6416   'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis',

  6417   'perthousand', 'questiondown', 'grave', 'acute', 'circumflex', 'tilde',

  6418   'macron', 'breve', 'dotaccent', 'dieresis', 'ring', 'cedilla',

  6419   'hungarumlaut', 'ogonek', 'caron', 'emdash', 'AE', 'ordfeminine',

  6420   'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae', 'dotlessi', 'lslash',

  6421   'oslash', 'oe', 'germandbls', 'onesuperior', 'logicalnot', 'mu',

  6422   'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn', 'onequarter',

  6423   'divide', 'brokenbar', 'degree', 'thorn', 'threequarters', 'twosuperior',

  6424   'registered', 'minus', 'eth', 'multiply', 'threesuperior', 'copyright',

  6425   'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring', 'Atilde',

  6426   'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave', 'Iacute',

  6427   'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute', 'Ocircumflex',

  6428   'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute', 'Ucircumflex',

  6429   'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron', 'aacute',

  6430   'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde', 'ccedilla',

  6431   'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute', 'icircumflex',

  6432   'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex', 'odieresis',

  6433   'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex', 'udieresis',

  6434   'ugrave', 'yacute', 'ydieresis', 'zcaron'

  6435 ];

  6437 var ExpertCharset = [

  6438   '.notdef', 'space', 'exclamsmall', 'Hungarumlautsmall', 'dollaroldstyle',

  6439   'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior',

  6440   'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'comma',

  6441   'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle',

  6442   'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle',

  6443   'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle',

  6444   'colon', 'semicolon', 'commasuperior', 'threequartersemdash',

  6445   'periodsuperior', 'questionsmall', 'asuperior', 'bsuperior',

  6446   'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior',

  6447   'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',

  6448   'tsuperior', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior',

  6449   'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall',

  6450   'Asmall', 'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall',

  6451   'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall',

  6452   'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall',

  6453   'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary',

  6454   'onefitted', 'rupiah', 'Tildesmall', 'exclamdownsmall', 'centoldstyle',

  6455   'Lslashsmall', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall',

  6456   'Brevesmall', 'Caronsmall', 'Dotaccentsmall', 'Macronsmall',

  6457   'figuredash', 'hypheninferior', 'Ogoneksmall', 'Ringsmall',

  6458   'Cedillasmall', 'onequarter', 'onehalf', 'threequarters',

  6459   'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths',

  6460   'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior',

  6461   'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior',

  6462   'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior',

  6463   'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior',

  6464   'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior',

  6465   'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior',

  6466   'periodinferior', 'commainferior', 'Agravesmall', 'Aacutesmall',

  6467   'Acircumflexsmall', 'Atildesmall', 'Adieresissmall', 'Aringsmall',

  6468   'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall',

  6469   'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall',

  6470   'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall',

  6471   'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall',

  6472   'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall',

  6473   'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall',

  6474   'Ydieresissmall'

  6475 ];

  6477 var ExpertSubsetCharset = [

  6478   '.notdef', 'space', 'dollaroldstyle', 'dollarsuperior',

  6479   'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',

  6480   'onedotenleader', 'comma', 'hyphen', 'period', 'fraction',

  6481   'zerooldstyle', 'oneoldstyle', 'twooldstyle', 'threeoldstyle',

  6482   'fouroldstyle', 'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle',

  6483   'eightoldstyle', 'nineoldstyle', 'colon', 'semicolon', 'commasuperior',

  6484   'threequartersemdash', 'periodsuperior', 'asuperior', 'bsuperior',

  6485   'centsuperior', 'dsuperior', 'esuperior', 'isuperior', 'lsuperior',

  6486   'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',

  6487   'tsuperior', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior',

  6488   'parenrightinferior', 'hyphensuperior', 'colonmonetary', 'onefitted',

  6489   'rupiah', 'centoldstyle', 'figuredash', 'hypheninferior', 'onequarter',

  6490   'onehalf', 'threequarters', 'oneeighth', 'threeeighths', 'fiveeighths',

  6491   'seveneighths', 'onethird', 'twothirds', 'zerosuperior', 'onesuperior',

  6492   'twosuperior', 'threesuperior', 'foursuperior', 'fivesuperior',

  6493   'sixsuperior', 'sevensuperior', 'eightsuperior', 'ninesuperior',

  6494   'zeroinferior', 'oneinferior', 'twoinferior', 'threeinferior',

  6495   'fourinferior', 'fiveinferior', 'sixinferior', 'seveninferior',

  6496   'eightinferior', 'nineinferior', 'centinferior', 'dollarinferior',

  6497   'periodinferior', 'commainferior'

  6498 ];

  6502 var CIDToUnicodeMaps = {

  6503   'Adobe-Japan1': [[32, 160], {f: 12, c: 33}, [45, 8209], {f: 46, c: 46}, 165,

  6504     {f: 2, c: 93}, [95, 818], [96, 768], {f: 27, c: 97}, 166, 125, [732, 771],

  6505     [700, 8217], 92, [699, 8216], 124, [126, 8764], {f: 3, c: 161}, 8260, 402,

  6506     0, 164, 8220, 171, {f: 2, c: 8249}, {f: 2, c: 64257}, [8210, 8211], 0, 0,

  6507     [183, 8729], 0, 8226, 8218, 8222, 8221, 187, 0, 0, 191, {f: 2, c: 769},

  6508     [175, 772], {f: 3, c: 774}, 778, [184, 807], 779, 808, 780, [822, 8212],

  6509     198, 170, 321, 216, 338, 186, 230, 305, 322, 248, 339, 223, 173, 169, 172,

  6510     174, 0, 0, {f: 2, c: 178}, 181, 185, {f: 3, c: 188}, {f: 6, c: 192},

  6511     {f: 16, c: 199}, 0, {f: 6, c: 217}, {f: 6, c: 224}, {f: 16, c: 231}, 0,

  6512     {f: 7, c: 249}, 352, 376, 381, [773, 8254], 353, 8482, 382, 0, 8194,

  6513     {f: 59, c: 33}, 165, {f: 31, c: 93}, 65512, {f: 2, c: 125}, 0,

  6514     {f: 63, c: 65377}, {s: 243}, [8195, 12288],

  6515     {f: 2, c: 12289}, 65292, 65294, 12539, {f: 2, c: 65306}, 65311, 65281,

  6516     {f: 2, c: 12443}, 180, 65344, 168, 65342, 65507, 65343, {f: 2, c: 12541},

  6517     {f: 2, c: 12445}, 12291, 20189, {f: 3, c: 12293}, 12540, 8213, 8208, 65295,

  6518     65340, [12316, 65374], 8214, 65372, 8230, 8229, {s: 4}, {f: 2, c: 65288},

  6519     {f: 2, c: 12308}, 65339, 65341, 65371, 65373, {f: 10, c: 12296}, 65291,

  6520     [8722, 65293], 177, 215, 247, 65309, 8800, 65308, 65310, {f: 2, c: 8806},

  6521     8734, 8756, 9794, 9792, 176, {f: 2, c: 8242}, 8451, 65509, 65284,

  6522     {f: 2, c: 65504}, 65285, 65283, 65286, 65290, 65312, 167, 9734, 9733, 9675,

  6523     9679, 9678, 9671, 9670, 9633, 9632, 9651, 9650, 9661, 9660, 8251, 12306,

  6524     8594, {f: 2, c: 8592}, 8595, 12307, 8712, 8715, {f: 2, c: 8838},

  6525     {f: 2, c: 8834}, 8746, 8745, {f: 2, c: 8743}, 65506, 8658, 8660, 8704,

  6526     8707, 8736, 8869, 8978, 8706, 8711, 8801, 8786, {f: 2, c: 8810}, 8730,

  6527     8765, 8733, 8757, {f: 2, c: 8747}, 8491, 8240, 9839, 9837, 9834,

  6528     {f: 2, c: 8224}, 182, 9711, {f: 10, c: 65296}, {f: 26, c: 65313},

  6529     {f: 26, c: 65345}, {f: 83, c: 12353}, {f: 86, c: 12449}, {f: 17, c: 913},

  6530     {f: 7, c: 931}, {f: 17, c: 945}, {f: 7, c: 963}, {f: 6, c: 1040}, 1025,

  6531     {f: 32, c: 1046}, 1105, {f: 26, c: 1078}, 20124, 21782, 23043, 38463,

  6532     21696, 24859, 25384, 23030, 36898, 33909, 33564, 31312, 24746, 25569,

  6533     28197, 26093, 33894, 33446, 39925, 26771, 22311, 26017, 25201, 23451,

  6534     22992, 34427, 39156, 32098, 32190, 39822, 25110, 31903, 34999, 23433,

  6535     24245, 25353, 26263, 26696, 38343, 38797, 26447, 20197, 20234, 20301,

  6536     20381, 20553, 22258, 22839, 22996, 23041, 23561, 24799, 24847, 24944,

  6537     26131, 26885, 28858, 30031, 30064, 31227, 32173, 32239, 32963, 33806,

  6538     [12176, 34915], 35586, 36949, 36986, 21307, 20117, 20133, 22495, 32946,

  6539     37057, 30959, [12032, 19968], 22769, 28322, 36920, 31282, 33576, 33419,

  6540     39983, 20801, 21360, 21693, 21729, 22240, 23035, 24341, 39154, 28139,

  6541     32996, 34093, 38498, 38512, 38560, 38907, 21515, 21491, 23431, 28879,

  6542     [12155, 32701], 36802, [12204, 38632], 21359, 40284, 31418, 19985, 30867,

  6543     [12165, 33276], 28198, 22040, 21764, 27421, 34074, 39995, 23013, 21417,

  6544     28006, [12128, 29916], 38287, 22082, 20113, 36939, 38642, 33615, 39180,

  6545     21473, 21942, 23344, 24433, 26144, 26355, 26628, 27704, 27891, 27945,

  6546     29787, 30408, 31310, 38964, 33521, 34907, 35424, 37613, 28082, 30123,

  6547     30410, 39365, 24742, 35585, 36234, 38322, 27022, 21421, 20870, 22290,

  6548     22576, 22852, 23476, 24310, 24616, 25513, 25588, 27839, 28436, 28814,

  6549     28948, 29017, 29141, 29503, 32257, 33398, 33489, 34199, 36960, 37467,

  6550     40219, 22633, 26044, 27738, 29989, 20985, 22830, 22885, 24448, 24540,

  6551     25276, 26106, 27178, 27431, 27572, 29579, 32705, 35158, 40236, 40206,

  6552     [12009, 40644], 23713, 27798, 33659, 20740, 23627, 25014, 33222, 26742,

  6553     29281, [12036, 20057], 20474, 21368, 24681, 28201, 31311, [12211, 38899],

  6554     19979, 21270, 20206, 20309, 20285, 20385, 20339, 21152, 21487, 22025,

  6555     22799, 23233, 23478, 23521, 31185, 26247, 26524, 26550, 27468, 27827,

  6556     [12117, 28779], 29634, 31117, [12146, 31166], 31292, 31623, 33457, 33499,

  6557     33540, 33655, 33775, 33747, 34662, 35506, 22057, 36008, 36838, 36942,

  6558     38686, 34442, 20420, 23784, 25105, [12123, 29273], 30011, 33253, 33469,

  6559     34558, 36032, 38597, 39187, 39381, 20171, 20250, 35299, 22238, 22602,

  6560     22730, 24315, 24555, 24618, 24724, 24674, 25040, 25106, 25296, 25913,

  6561     39745, 26214, 26800, 28023, 28784, 30028, 30342, 32117, 33445, 34809,

  6562     38283, 38542, [12185, 35997], 20977, 21182, 22806, 21683, 23475, 23830,

  6563     24936, 27010, 28079, 30861, 33995, 34903, 35442, 37799, 39608, 28012,

  6564     39336, 34521, 22435, 26623, 34510, 37390, 21123, 22151, 21508, 24275,

  6565     25313, 25785, 26684, 26680, 27579, 29554, 30906, 31339, 35226,

  6566     [12179, 35282], 36203, 36611, 37101, 38307, 38548, [12208, 38761], 23398,

  6567     23731, 27005, {f: 2, c: 38989}, 25499, 31520, 27179, 27263, 26806, 39949,

  6568     28511, 21106, 21917, 24688, 25324, 27963, 28167, 28369, 33883, 35088,

  6569     36676, 19988, 39993, 21494, 26907, 27194, 38788, 26666, 20828, 31427,

  6570     33970, 37340, 37772, 22107, 40232, 26658, 33541, 33841, 31909, 21000,

  6571     33477, [12129, 29926], 20094, 20355, 20896, 23506, 21002, 21208, 21223,

  6572     24059, 21914, 22570, 23014, 23436, 23448, 23515, [12082, 24178], 24185,

  6573     24739, 24863, 24931, 25022, 25563, 25954, 26577, 26707, 26874, 27454,

  6574     27475, 27735, 28450, 28567, 28485, 29872, [12130, 29976], 30435, 30475,

  6575     31487, 31649, 31777, 32233, [12152, 32566], 32752, 32925, 33382, 33694,

  6576     35251, 35532, 36011, 36996, 37969, 38291, 38289, 38306, 38501, 38867,

  6577     39208, 33304, 20024, 21547, 23736, 24012, 29609, 30284, 30524, 23721,

  6578     32747, 36107, 38593, 38929, 38996, 39000, 20225, 20238, 21361, 21916,

  6579     22120, 22522, 22855, 23305, 23492, 23696, 24076, 24190, 24524, 25582,

  6580     26426, 26071, 26082, 26399, 26827, 26820, 27231, 24112, 27589, 27671,

  6581     27773, 30079, 31048, 23395, 31232, 32000, 24509, 35215, 35352, 36020,

  6582     36215, 36556, 36637, 39138, 39438, [12004, 12225, 39740], [12018, 20096],

  6583     20605, 20736, 22931, 23452, 25135, 25216, 25836, 27450, 29344, 30097,

  6584     31047, 32681, 34811, 35516, 35696, 25516, 33738, 38816, 21513, 21507,

  6585     21931, 26708, 27224, 35440, 30759, 26485, [12233, 40653], 21364, 23458,

  6586     33050, 34384, 36870, 19992, 20037, 20167, 20241, 21450, 21560, 23470,

  6587     [12088, 24339], 24613, 25937, 26429, 27714, 27762, 27875, 28792, 29699,

  6588     31350, 31406, 31496, 32026, 31998, 32102, 26087, [12124, 29275], 21435,

  6589     23621, 24040, 25298, 25312, 25369, 28192, 34394, 35377, 36317, 37624,

  6590     28417, 31142, [12226, 39770], 20136, {f: 2, c: 20139}, 20379, 20384, 20689,

  6591     20807, 31478, 20849, 20982, 21332, 21281, 21375, 21483, 21932, 22659,

  6592     23777, 24375, 24394, 24623, 24656, 24685, 25375, 25945, 27211, 27841,

  6593     29378, 29421, 30703, 33016, 33029, 33288, 34126, 37111, 37857, 38911,

  6594     39255, 39514, 20208, 20957, 23597, 26241, 26989, 23616, 26354, 26997,

  6595     [12127, 29577], 26704, 31873, 20677, 21220, 22343, [12081, 24062], 37670,

  6596     [12100, 26020], 27427, 27453, 29748, 31105, 31165, 31563, 32202, 33465,

  6597     33740, 34943, 35167, 35641, 36817, [12198, 37329], 21535, 37504, 20061,

  6598     20534, 21477, 21306, 29399, 29590, 30697, 33510, 36527, 39366, 39368,

  6599     39378, 20855, 24858, 34398, 21936, 31354, 20598, 23507, 36935, 38533,

  6600     20018, 27355, 37351, 23633, 23624, 25496, 31391, 27795, 38772, 36705,

  6601     31402, 29066, 38536, 31874, 26647, 32368, 26705, 37740, 21234, 21531,

  6602     34219, 35347, 32676, 36557, 37089, 21350, 34952, 31041, 20418, 20670,

  6603     21009, 20804, 21843, 22317, 29674, 22411, 22865, 24418, 24452, 24693,

  6604     24950, 24935, 25001, 25522, 25658, 25964, 26223, 26690, 28179, 30054,

  6605     31293, 31995, 32076, 32153, 32331, 32619, 33550, 33610, 34509, 35336,

  6606     35427, 35686, 36605, 38938, 40335, 33464, 36814, 39912, 21127, 25119,

  6607     25731, 28608, 38553, 26689, 20625, [12107, 27424], 27770, 28500,

  6608     [12147, 31348], 32080, [12174, 34880], 35363, [12105, 26376], 20214, 20537,

  6609     20518, 20581, 20860, 21048, 21091, 21927, 22287, 22533, 23244, 24314,

  6610     25010, 25080, 25331, 25458, 26908, 27177, 29309, [12125, 29356], 29486,

  6611     30740, 30831, 32121, 30476, 32937, [12178, 35211], 35609, 36066, 36562,

  6612     36963, 37749, 38522, 38997, 39443, 40568, 20803, 21407, 21427, 24187,

  6613     24358, 28187, 28304, [12126, 29572], 29694, 32067, 33335, [12180, 35328],

  6614     35578, 38480, 20046, 20491, 21476, 21628, 22266, 22993, 23396,

  6615     [12080, 24049], 24235, 24359, [12094, 25144], 25925, 26543, 28246, 29392,

  6616     31946, 34996, 32929, 32993, 33776, [11969, 34382], 35463, 36328, 37431,

  6617     38599, 39015, [12238, 40723], 20116, 20114, 20237, 21320, 21577, 21566,

  6618     23087, 24460, 24481, 24735, 26791, 27278, 29786, 30849, 35486, 35492,

  6619     35703, 37264, 20062, 39881, 20132, 20348, 20399, 20505, 20502, 20809,

  6620     20844, 21151, 21177, 21246, 21402, [12061, 21475], 21521, 21518, 21897,

  6621     22353, 22434, 22909, 23380, 23389, 23439, [12079, 24037], 24039, 24055,

  6622     24184, 24195, 24218, 24247, 24344, 24658, 24908, 25239, 25304, 25511,

  6623     25915, 26114, 26179, 26356, 26477, 26657, 26775, 27083, 27743, 27946,

  6624     28009, 28207, 28317, 30002, 30343, 30828, 31295, 31968, 32005, 32024,

  6625     32094, 32177, 32789, 32771, 32943, 32945, 33108, 33167, 33322, 33618,

  6626     [12175, 34892], 34913, 35611, 36002, 36092, 37066, 37237, 37489, 30783,

  6627     37628, 38308, 38477, 38917, [12217, 39321], [12220, 39640], 40251, 21083,

  6628     21163, 21495, 21512, 22741, 25335, 28640, 35946, 36703, 40633, 20811,

  6629     21051, 21578, 22269, 31296, 37239, 40288, [12234, 40658], 29508, 28425,

  6630     33136, 29969, 24573, 24794, [12219, 39592], 29403, 36796, 27492, 38915,

  6631     20170, 22256, 22372, 22718, 23130, 24680, 25031, 26127, 26118, 26681,

  6632     26801, 28151, 30165, 32058, [12169, 33390], 39746, 20123, 20304, 21449,

  6633     21766, 23919, 24038, 24046, 26619, 27801, 29811, 30722, 35408, 37782,

  6634     35039, 22352, 24231, 25387, 20661, 20652, 20877, 26368, 21705, 22622,

  6635     22971, 23472, 24425, 25165, 25505, 26685, 27507, 28168, 28797, 37319,

  6636     29312, 30741, 30758, 31085, 25998, 32048, 33756, 35009, 36617, 38555,

  6637     21092, 22312, 26448, 32618, 36001, 20916, 22338, 38442, 22586, 27018,

  6638     32948, 21682, 23822, 22524, 30869, 40442, 20316, 21066, 21643, 25662,

  6639     26152, 26388, 26613, 31364, 31574, 32034, 37679, 26716, 39853, 31545,

  6640     21273, 20874, 21047, 23519, 25334, 25774, 25830, 26413, 27578, 34217,

  6641     38609, 30352, 39894, 25420, 37638, 39851, [12139, 30399], 26194, 19977,

  6642     20632, 21442, [12077, 23665], 24808, 25746, 25955, 26719, 29158, 29642,

  6643     29987, 31639, 32386, 34453, 35715, 36059, 37240, 39184, 26028, 26283,

  6644     27531, 20181, 20180, 20282, 20351, 21050, 21496, 21490, 21987, 22235,

  6645     [12064, 22763], 22987, 22985, 23039, [12070, 23376], 23629, 24066, 24107,

  6646     24535, 24605, 25351, [12096, 25903], 23388, 26031, 26045, 26088, 26525,

  6647     [12108, 27490], 27515, [12114, 27663], 29509, 31049, 31169, [12151, 31992],

  6648     32025, 32043, 32930, 33026, [12164, 33267], 35222, 35422, 35433, 35430,

  6649     35468, 35566, 36039, 36060, 38604, 39164, [12013, 27503], 20107, 20284,

  6650     20365, 20816, 23383, 23546, 24904, 25345, 26178, 27425, 28363, 27835,

  6651     29246, 29885, 30164, 30913, [12144, 31034], [12157, 32780], [12159, 32819],

  6652     [12163, 33258], 33940, 36766, 27728, [12229, 40575], 24335, 35672, 40235,

  6653     31482, 36600, 23437, 38635, 19971, 21489, 22519, 22833, 23241, 23460,

  6654     24713, 28287, 28422, 30142, 36074, 23455, 34048, 31712, 20594, 26612,

  6655     33437, 23649, 34122, 32286, 33294, 20889, 23556, 25448, 36198, 26012,

  6656     29038, 31038, 32023, 32773, 35613, [12190, 36554], 36974, 34503, 37034,

  6657     20511, 21242, 23610, 26451, 28796, 29237, 37196, 37320, 37675, 33509,

  6658     23490, 24369, 24825, 20027, 21462, 23432, [12095, 25163], 26417, 27530,

  6659     29417, 29664, 31278, 33131, 36259, 37202, [12216, 39318], 20754, 21463,

  6660     21610, 23551, 25480, 27193, 32172, 38656, 22234, 21454, 21608, 23447,

  6661     23601, 24030, 20462, 24833, 25342, 27954, 31168, 31179, 32066, 32333,

  6662     32722, 33261, [12168, 33311], 33936, 34886, 35186, 35728, 36468, 36655,

  6663     36913, 37195, 37228, 38598, 37276, 20160, 20303, 20805, [12055, 21313],

  6664     24467, 25102, 26580, 27713, 28171, 29539, 32294, 37325, 37507, 21460,

  6665     22809, 23487, 28113, 31069, 32302, 31899, 22654, 29087, 20986, 34899,

  6666     36848, 20426, 23803, 26149, 30636, 31459, 33308, 39423, 20934, 24490,

  6667     26092, 26991, 27529, 28147, 28310, 28516, 30462, 32020, 24033, 36981,

  6668     37255, 38918, 20966, 21021, 25152, 26257, 26329, 28186, 24246, 32210,

  6669     32626, 26360, 34223, 34295, 35576, 21161, 21465, [12069, 22899], 24207,

  6670     24464, 24661, 37604, 38500, 20663, 20767, 21213, 21280, 21319, 21484,

  6671     21736, 21830, 21809, 22039, 22888, 22974, 23100, 23477, 23558,

  6672     [12073, 23567], 23569, 23578, 24196, 24202, 24288, 24432, 25215, 25220,

  6673     25307, 25484, 25463, 26119, 26124, 26157, 26230, 26494, 26786, 27167,

  6674     27189, 27836, 28040, 28169, 28248, 28988, 28966, 29031, 30151, 30465,

  6675     30813, 30977, 31077, 31216, 31456, 31505, 31911, 32057, 32918, 33750,

  6676     33931, 34121, 34909, 35059, 35359, 35388, 35412, 35443, 35937, 36062,

  6677     37284, 37478, 37758, 37912, 38556, 38808, 19978, 19976, 19998, 20055,

  6678     20887, 21104, 22478, 22580, 22732, 23330, 24120, 24773, 25854, 26465,

  6679     26454, 27972, 29366, 30067, 31331, 33976, 35698, 37304, 37664, 22065,

  6680     22516, 39166, 25325, 26893, 27542, 29165, 32340, 32887, [12170, 33394],

  6681     35302, [12215, 39135], 34645, 36785, 23611, 20280, 20449, 20405, 21767,

  6682     23072, 23517, 23529, [12092, 24515], 24910, 25391, 26032, 26187, 26862,

  6683     27035, 28024, 28145, 30003, 30137, 30495, 31070, 31206, 32051,

  6684     [12162, 33251], 33455, 34218, 35242, 35386, [12189, 36523], [12191, 36763],

  6685     36914, 37341, 38663, [12040, 20154], 20161, 20995, 22645, 22764, 23563,

  6686     29978, 23613, 33102, 35338, 36805, 38499, 38765, 31525, 35535, 38920,

  6687     37218, 22259, 21416, 36887, 21561, 22402, 24101, 25512, [12116, 27700],

  6688     28810, 30561, 31883, 32736, 34928, 36930, 37204, 37648, 37656, 38543,

  6689     29790, 39620, 23815, 23913, 25968, 26530, 36264, 38619, 25454, 26441,

  6690     26905, 33733, 38935, 38592, 35070, 28548, 25722, [12072, 23544], 19990,

  6691     28716, 30045, 26159, 20932, 21046, 21218, 22995, 24449, 24615, 25104,

  6692     25919, 25972, 26143, 26228, 26866, 26646, 27491, 28165, 29298,

  6693     [12131, 29983], 30427, 31934, 32854, 22768, 35069, [11972, 35199], 35488,

  6694     35475, 35531, 36893, 37266, [11992, 38738], 38745, [12011, 25993], 31246,

  6695     33030, 38587, 24109, 24796, 25114, 26021, 26132, 26512, [12143, 30707],

  6696     31309, 31821, 32318, 33034, 36012, [12186, 36196], 36321, 36447, 30889,

  6697     20999, 25305, 25509, 25666, 25240, 35373, 31363, 31680, 35500, 38634,

  6698     32118, [12166, 33292], 34633, 20185, 20808, 21315, 21344, 23459, 23554,

  6699     23574, 24029, 25126, 25159, 25776, 26643, 26676, 27849, 27973, 27927,

  6700     26579, 28508, 29006, 29053, 26059, 31359, 31661, 32218, 32330, 32680,

  6701     33146, [12167, 33307], 33337, 34214, 35438, 36046, 36341, 36984, 36983,

  6702     37549, 37521, 38275, 39854, 21069, 21892, 28472, 28982, 20840, 31109,

  6703     32341, 33203, 31950, 22092, 22609, 23720, 25514, 26366, 26365, 26970,

  6704     29401, 30095, 30094, 30990, 31062, 31199, 31895, 32032, 32068, 34311,

  6705     35380, 38459, 36961, [12239, 40736], 20711, 21109, 21452, 21474, 20489,

  6706     21930, 22766, 22863, 29245, 23435, 23652, 21277, 24803, 24819, 25436,

  6707     25475, 25407, 25531, 25805, 26089, 26361, 24035, 27085, 27133, 28437,

  6708     29157, 20105, 30185, 30456, 31379, 31967, 32207, 32156, 32865, 33609,

  6709     33624, 33900, 33980, 34299, 35013, [12187, 36208], 36865, 36973, 37783,

  6710     38684, 39442, 20687, 22679, 24974, 33235, 34101, 36104, 36896, 20419,

  6711     20596, 21063, 21363, 24687, 25417, 26463, 28204, [12188, 36275], 36895,

  6712     20439, 23646, 36042, 26063, 32154, 21330, 34966, 20854, 25539, 23384,

  6713     23403, 23562, 25613, 26449, 36956, 20182, 22810, 22826, 27760, 35409,

  6714     21822, 22549, 22949, 24816, 25171, 26561, 33333, 26965, 38464, 39364,

  6715     39464, 20307, 22534, 23550, 32784, 23729, 24111, 24453, 24608, 24907,

  6716     25140, 26367, 27888, 28382, 32974, 33151, 33492, 34955, 36024, 36864,

  6717     36910, 38538, 40667, 39899, 20195, 21488, [12068, 22823], 31532, 37261,

  6718     38988, 40441, 28381, 28711, 21331, 21828, 23429, 25176, 25246, 25299,

  6719     27810, 28655, 29730, 35351, 37944, 28609, 35582, 33592, 20967, 34552,

  6720     21482, 21481, 20294, 36948, [12192, 36784], 22890, 33073, 24061, 31466,

  6721     36799, 26842, [12181, 35895], 29432, 40008, 27197, 35504, 20025, 21336,

  6722     22022, 22374, 25285, 25506, 26086, 27470, 28129, 28251, 28845, 30701,

  6723     31471, 31658, 32187, 32829, 32966, 34507, 35477, 37723, 22243, 22727,

  6724     24382, 26029, 26262, 27264, 27573, 30007, 35527, 20516, 30693, 22320,

  6725     24347, 24677, 26234, 27744, 30196, 31258, 32622, 33268, 34584, 36933,

  6726     39347, 31689, 30044, [12149, 31481], 31569, 33988, 36880, 31209, 31378,

  6727     33590, 23265, 30528, 20013, 20210, 23449, 24544, 25277, 26172, 26609,

  6728     27880, [12173, 34411], 34935, 35387, 37198, 37619, 39376, 27159, 28710,

  6729     29482, 33511, 33879, 36015, 19969, 20806, 20939, 21899, 23541, 24086,

  6730     24115, 24193, 24340, 24373, 24427, 24500, 25074, 25361, 26274, 26397,

  6731     28526, 29266, 30010, 30522, 32884, 33081, 33144, 34678, 35519, 35548,

  6732     36229, 36339, 37530, [11985, 12199, 38263], 38914, [12227, 40165], 21189,

  6733     25431, 30452, 26389, 27784, 29645, 36035, 37806, 38515, 27941, 22684,

  6734     26894, 27084, 36861, 37786, 30171, 36890, 22618, 26626, 25524, 27131,

  6735     20291, 28460, 26584, 36795, 34086, 32180, 37716, 26943, 28528, 22378,

  6736     22775, 23340, 32044, [12118, 29226], 21514, 37347, 40372, 20141, 20302,

  6737     20572, 20597, 21059, 35998, 21576, 22564, 23450, 24093, 24213, 24237,

  6738     24311, 24351, 24716, 25269, 25402, 25552, 26799, 27712, 30855, 31118,

  6739     31243, 32224, 33351, 35330, 35558, 36420, 36883, 37048, 37165, 37336,

  6740     [12237, 40718], 27877, 25688, 25826, 25973, 28404, 30340, 31515, 36969,

  6741     37841, 28346, 21746, 24505, 25764, 36685, 36845, 37444, 20856, 22635,

  6742     22825, 23637, 24215, 28155, 32399, 29980, 36028, 36578, 39003, 28857,

  6743     20253, 27583, 28593, [12133, 30000], 38651, 20814, 21520, 22581, 22615,

  6744     22956, 23648, 24466, [12099, 26007], 26460, 28193, 30331, 33759, 36077,

  6745     36884, 37117, 37709, 30757, 30778, 21162, 24230, [12063, 22303], 22900,

  6746     24594, 20498, 20826, 20908, 20941, [12049, 20992], 21776, 22612, 22616,

  6747     22871, 23445, 23798, 23947, 24764, 25237, 25645, 26481, 26691, 26812,

  6748     26847, 30423, 28120, 28271, 28059, 28783, 29128, 24403, 30168, 31095,

  6749     31561, 31572, 31570, 31958, 32113, 21040, 33891, 34153, 34276, 35342,

  6750     35588, [12182, 35910], 36367, 36867, 36879, 37913, 38518, 38957, 39472,

  6751     38360, 20685, 21205, 21516, 22530, 23566, 24999, 25758, 27934, 30643,

  6752     31461, 33012, 33796, 36947, 37509, 23776, 40199, 21311, 24471, 24499,

  6753     28060, 29305, 30563, 31167, 31716, 27602, 29420, 35501, 26627, 27233,

  6754     20984, 31361, 26932, 23626, 40182, 33515, 23493, [12195, 37193], 28702,

  6755     22136, 23663, 24775, 25958, 27788, 35930, 36929, 38931, 21585, 26311,

  6756     37389, 22856, 37027, 20869, 20045, 20970, 34201, 35598, 28760, 25466,

  6757     37707, 26978, 39348, 32260, 30071, 21335, 26976, 36575, 38627, 27741,

  6758     [12038, 20108], 23612, 24336, 36841, 21250, 36049, [12161, 32905], 34425,

  6759     24319, [12103, 26085], 20083, [12042, 20837], 22914, 23615, 38894, 20219,

  6760     22922, 24525, 35469, 28641, 31152, 31074, 23527, 33905, 29483, 29105,

  6761     24180, 24565, 25467, 25754, 29123, 31896, 20035, 24316, 20043, 22492,

  6762     22178, 24745, 28611, 32013, 33021, 33075, 33215, 36786, 35223, 34468,

  6763     24052, 25226, 25773, 35207, 26487, 27874, 27966, 29750, 30772, 23110,

  6764     32629, 33453, [12218, 39340], 20467, 24259, 25309, 25490, 25943, 26479,

  6765     30403, 29260, 32972, 32954, 36649, 37197, 20493, 22521, 23186, 26757,

  6766     26995, 29028, 29437, 36023, 22770, 36064, 38506, 36889, 34687, 31204,

  6767     30695, 33833, 20271, 21093, 21338, 25293, 26575, 27850, [12137, 30333],

  6768     31636, 31893, 33334, 34180, 36843, 26333, 28448, 29190, 32283, 33707,

  6769     39361, [12008, 40614], 20989, 31665, 30834, 31672, 32903, 31560, 27368,

  6770     24161, 32908, 30033, 30048, [12043, 20843], 37474, 28300, 30330, 37271,

  6771     39658, 20240, 32624, 25244, 31567, 38309, 40169, 22138, 22617, 34532,

  6772     38588, 20276, 21028, 21322, 21453, 21467, 24070, 25644, 26001, 26495,

  6773     27710, 27726, 29256, 29359, 29677, 30036, 32321, 33324, 34281, 36009,

  6774     31684, [12196, 37318], 29033, 38930, 39151, 25405, 26217, 30058, 30436,

  6775     30928, 34115, 34542, 21290, 21329, 21542, 22915, 24199, 24444, 24754,

  6776     25161, 25209, 25259, 26000, [12112, 27604], 27852, 30130, [12138, 30382],

  6777     30865, 31192, 32203, 32631, 32933, 34987, 35513, 36027, 36991,

  6778     [12206, 38750], [12214, 39131], 27147, 31800, 20633, 23614, 24494, 26503,

  6779     27608, 29749, 30473, 32654, [12240, 40763], 26570, 31255, 21305,

  6780     [12134, 30091], 39661, 24422, 33181, 33777, 32920, 24380, 24517, 30050,

  6781     31558, 36924, 26727, 23019, 23195, 32016, 30334, 35628, 20469, 24426,

  6782     27161, 27703, 28418, 29922, 31080, 34920, 35413, 35961, 24287, 25551,

  6783     30149, 31186, 33495, 37672, 37618, 33948, 34541, 39981, 21697, 24428,

  6784     25996, 27996, 28693, 36007, 36051, 38971, 25935, 29942, 19981, 20184,

  6785     22496, 22827, 23142, 23500, 20904, 24067, 24220, 24598, 25206, 25975,

  6786     26023, 26222, 28014, [12119, 29238], 31526, 33104, 33178, 33433, 35676,

  6787     36000, 36070, 36212, [12201, 38428], 38468, 20398, 25771, 27494, 33310,

  6788     33889, 34154, 37096, 23553, 26963, [12213, 39080], 33914, 34135, 20239,

  6789     21103, 24489, 24133, 26381, 31119, 33145, 35079, 35206, 28149, 24343,

  6790     25173, 27832, 20175, 29289, 39826, 20998, 21563, 22132, 22707, 24996,

  6791     25198, 28954, 22894, 31881, 31966, 32027, 38640, [12098, 25991], 32862,

  6792     19993, 20341, 20853, 22592, 24163, 24179, 24330, 26564, 20006, 34109,

  6793     38281, 38491, [12150, 31859], [12212, 38913], 20731, 22721, 30294, 30887,

  6794     21029, 30629, 34065, 31622, 20559, 22793, [12122, 29255], 31687, 32232,

  6795     36794, 36820, 36941, 20415, 21193, 23081, 24321, 38829, 20445, 33303,

  6796     37610, 22275, 25429, 27497, 29995, 35036, 36628, 31298, 21215, 22675,

  6797     24917, 25098, 26286, [11935, 27597], 31807, 33769, 20515, 20472, 21253,

  6798     21574, 22577, 22857, 23453, 23792, 23791, 23849, 24214, 25265, 25447,

  6799     25918, [12101, 26041], 26379, 27861, 27873, 28921, 30770, 32299, 32990,

  6800     33459, 33804, 34028, 34562, 35090, 35370, 35914, 37030, 37586, 39165,

  6801     40179, 40300, 20047, 20129, 20621, 21078, 22346, 22952, 24125,

  6802     {f: 2, c: 24536}, 25151, 26292, 26395, 26576, 26834, 20882, 32033, 32938,

  6803     33192, 35584, 35980, 36031, 37502, 38450, 21536, 38956, 21271, 20693,

  6804     [12056, 21340], 22696, 25778, 26420, 29287, 30566, 31302, 37350, 21187,

  6805     27809, 27526, 22528, 24140, 22868, 26412, 32763, 20961, 30406, 25705,

  6806     30952, 39764, [12231, 40635], 22475, 22969, 26151, 26522, 27598, 21737,

  6807     27097, 24149, 33180, 26517, 39850, 26622, 40018, 26717, 20134, 20451,

  6808     [12060, 21448], 25273, 26411, 27819, 36804, 20397, 32365, 40639, 19975,

  6809     24930, 28288, 28459, 34067, 21619, 26410, 39749, [11922, 24051], 31637,

  6810     23724, 23494, 34588, 28234, 34001, 31252, 33032, 22937, 31885,

  6811     [11936, 27665], 30496, 21209, 22818, 28961, 29279, [12141, 30683], 38695,

  6812     40289, 26891, 23167, 23064, 20901, 21517, 21629, 26126, 30431, 36855,

  6813     37528, 40180, 23018, 29277, 28357, 20813, 26825, 32191, 32236,

  6814     [12207, 38754], 40634, 25720, 27169, 33538, 22916, 23391, [12113, 27611],

  6815     29467, 30450, 32178, 32791, 33945, 20786, [12106, 26408], 40665,

  6816     [12140, 30446], 26466, 21247, 39173, 23588, 25147, 31870, 36016, 21839,

  6817     24758, 32011, [12200, 38272], 21249, 20063, 20918, 22812, 29242, 32822,

  6818     37326, 24357, [12142, 30690], 21380, 24441, 32004, 34220, 35379, 36493,

  6819     38742, 26611, 34222, 37971, 24841, 24840, 27833, 30290, 35565, 36664,

  6820     21807, 20305, 20778, 21191, 21451, 23461, 24189, 24736, 24962, 25558,

  6821     26377, 26586, 28263, 28044, {f: 2, c: 29494}, 30001, 31056, 35029, 35480,

  6822     36938, [12194, 37009], 37109, 38596, 34701, [12067, 22805], 20104, 20313,

  6823     19982, 35465, 36671, 38928, 20653, 24188, 22934, 23481, 24248, 25562,

  6824     25594, 25793, 26332, 26954, 27096, 27915, 28342, 29076, [12132, 29992],

  6825     31407, [12154, 32650], 32768, 33865, 33993, 35201, 35617, 36362, 36965,

  6826     38525, 39178, 24958, 25233, 27442, 27779, 28020, 32716, 32764, 28096,

  6827     32645, 34746, 35064, 26469, 33713, 38972, 38647, 27931, 32097, 33853,

  6828     37226, 20081, 21365, 23888, 27396, 28651, 34253, 34349, 35239, 21033,

  6829     21519, 23653, 26446, 26792, 29702, 29827, 30178, 35023, 35041,

  6830     [12197, 37324], 38626, 38520, 24459, 29575, [12148, 31435], 33870, 25504,

  6831     30053, 21129, 27969, 28316, 29705, 30041, 30827, 31890, 38534,

  6832     [12015, 31452], [12243, 40845], 20406, 24942, 26053, 34396, 20102, 20142,

  6833     20698, 20001, 20940, 23534, 26009, 26753, 28092, 29471, 30274, 30637,

  6834     31260, 31975, 33391, 35538, 36988, 37327, 38517, 38936, [12050, 21147],

  6835     32209, 20523, 21400, 26519, 28107, 29136, 29747, 33256, 36650, 38563,

  6836     40023, 40607, 29792, 22593, 28057, 32047, 39006, 20196, 20278, 20363,

  6837     20919, 21169, 23994, 24604, 29618, 31036, 33491, 37428, 38583, 38646,

  6838     38666, 40599, 40802, 26278, 27508, 21015, 21155, 28872, 35010, 24265,

  6839     24651, 24976, 28451, 29001, 31806, 32244, 32879, 34030, 36899, 37676,

  6840     21570, 39791, 27347, 28809, 36034, 36335, 38706, 21172, 23105, 24266,

  6841     24324, 26391, 27004, 27028, 28010, 28431, 29282, 29436, 31725,

  6842     [12156, 32769], 32894, 34635, 37070, 20845, 40595, 31108, 32907, 37682,

  6843     35542, 20525, 21644, 35441, 27498, 36036, 33031, 24785, 26528, 40434,

  6844     20121, 20120, 39952, 35435, 34241, 34152, 26880, 28286, 30871, 33109,

  6845     24332, 19984, 19989, 20010, 20017, [12034, 20022], 20028, [12035, 20031],

  6846     20034, 20054, 20056, 20098, [12037, 20101], 35947, 20106, 33298, 24333,

  6847     20110, {f: 2, c: 20126}, [12039, 20128], 20130, 20144, 20147, 20150, 20174,

  6848     20173, 20164, 20166, 20162, 20183, 20190, 20205, 20191, 20215, 20233,

  6849     20314, 20272, 20315, 20317, 20311, 20295, 20342, 20360, 20367, 20376,

  6850     20347, 20329, 20336, 20369, 20335, 20358, 20374, 20760, 20436, 20447,

  6851     20430, 20440, 20443, 20433, 20442, 20432, {f: 2, c: 20452}, 20506, 20520,

  6852     20500, 20522, 20517, 20485, 20252, 20470, 20513, 20521, 20524, 20478,

  6853     20463, 20497, 20486, 20547, 20551, 26371, 20565, 20560, 20552, 20570,

  6854     20566, 20588, 20600, 20608, 20634, 20613, 20660, 20658, {f: 2, c: 20681},

  6855     20659, 20674, 20694, 20702, 20709, 20717, 20707, 20718, 20729, 20725,

  6856     20745, {f: 2, c: 20737}, 20758, 20757, 20756, 20762, 20769, 20794, 20791,

  6857     20796, 20795, [12041, 20799], [11918, 20800], 20818, 20812, 20820, 20834,

  6858     31480, {f: 2, c: 20841}, 20846, 20864, [12044, 20866], 22232, 20876, 20873,

  6859     20879, 20881, 20883, 20885, [12045, 20886], 20900, 20902, 20898,

  6860     {f: 2, c: 20905}, [12046, 20907], 20915, {f: 2, c: 20913}, 20912, 20917,

  6861     20925, 20933, 20937, 20955, [12047, 20960], 34389, 20969, 20973, 20976,

  6862     [12048, 20981], 20990, 20996, 21003, 21012, 21006, 21031, 21034, 21038,

  6863     21043, 21049, 21071, 21060, {f: 2, c: 21067}, 21086, 21076, 21098, 21108,

  6864     21097, 21107, 21119, 21117, 21133, 21140, 21138, 21105, 21128, 21137,

  6865     36776, 36775, {f: 2, c: 21164}, 21180, 21173, 21185, 21197, 21207, 21214,

  6866     21219, 21222, 39149, 21216, 21235, 21237, 21240, [12051, 21241], 21254,

  6867     21256, 30008, 21261, 21264, 21263, [12052, 21269], [12053, 21274], 21283,

  6868     21295, 21297, 21299, [12054, 21304], 21312, 21318, 21317, 19991, 21321,

  6869     21325, 20950, 21342, [12057, 21353], 21358, 22808, 21371, 21367,

  6870     [12058, 21378], 21398, 21408, 21414, 21413, 21422, 21424, [12059, 21430],

  6871     21443, 31762, 38617, 21471, 26364, 29166, 21486, 21480, 21485, 21498,

  6872     21505, 21565, 21568, {f: 2, c: 21548}, 21564, 21550, 21558, 21545, 21533,

  6873     21582, 21647, 21621, 21646, 21599, 21617, 21623, 21616, 21650, 21627,

  6874     21632, 21622, 21636, 21648, 21638, 21703, 21666, 21688, 21669, 21676,

  6875     21700, 21704, 21672, 21675, 21698, 21668, 21694, 21692, 21720,

  6876     {f: 2, c: 21733}, 21775, 21780, 21757, 21742, 21741, 21754, 21730, 21817,

  6877     21824, 21859, 21836, 21806, 21852, 21829, {f: 2, c: 21846}, 21816, 21811,

  6878     21853, 21913, 21888, 21679, 21898, 21919, 21883, 21886, 21912, 21918,

  6879     21934, 21884, 21891, 21929, 21895, 21928, 21978, 21957, 21983, 21956,

  6880     21980, 21988, 21972, 22036, 22007, 22038, 22014, 22013, 22043, 22009,

  6881     22094, 22096, 29151, 22068, 22070, 22066, 22072, 22123, 22116, 22063,

  6882     22124, 22122, 22150, 22144, 22154, 22176, 22164, 22159, 22181, 22190,

  6883     22198, 22196, 22210, 22204, 22209, 22211, 22208, 22216, 22222, 22225,

  6884     22227, [12062, 22231], 22254, 22265, 22272, 22271, 22276, 22281, 22280,

  6885     22283, 22285, 22291, 22296, 22294, 21959, 22300, 22310, {f: 2, c: 22327},

  6886     22350, 22331, 22336, 22351, 22377, 22464, 22408, 22369, 22399, 22409,

  6887     22419, 22432, 22451, 22436, 22442, 22448, 22467, 22470, 22484,

  6888     {f: 2, c: 22482}, 22538, 22486, 22499, 22539, 22553, 22557, 22642, 22561,

  6889     22626, 22603, 22640, 27584, 22610, 22589, 22649, 22661, 22713, 22687,

  6890     22699, 22714, 22750, 22715, 22712, 22702, 22725, 22739, 22737, 22743,

  6891     22745, 22744, 22757, 22748, 22756, 22751, 22767, 22778, 22777,

  6892     {f: 3, c: 22779}, [12065, 22786], [12066, 22794], 22800, 22811, 26790,

  6893     22821, {f: 2, c: 22828}, 22834, 22840, 22846, 31442, 22869, 22864, 22862,

  6894     22874, 22872, 22882, 22880, 22887, 22892, 22889, 22904, 22913, 22941,

  6895     20318, 20395, 22947, 22962, 22982, 23016, 23004, 22925, {f: 2, c: 23001},

  6896     23077, 23071, 23057, 23068, 23049, 23066, 23104, 23148, 23113,

  6897     {f: 2, c: 23093}, 23138, 23146, 23194, 23228, 23230, 23243, 23234, 23229,

  6898     23267, 23255, 23270, 23273, 23254, {f: 2, c: 23290}, 23308, 23307, 23318,

  6899     23346, 23248, 23338, 23350, 23358, 23363, 23365, 23360, 23377, 23381,

  6900     {f: 2, c: 23386}, 23397, 23401, 23408, 23411, 23413, 23416, 25992, 23418,

  6901     [12071, 23424], 23427, 23462, 23480, 23491, 23495, 23497, 23508, 23504,

  6902     23524, 23526, 23522, 23518, 23525, 23531, 23536, 23542, 23539, 23557,

  6903     {f: 2, c: 23559}, 23565, 23571, 23584, [11920, 12074, 23586], 23592,

  6904     [12075, 23608], 23609, 23617, 23622, 23630, 23635, 23632, 23631, 23409,

  6905     23660, [12076, 23662], 20066, 23670, 23673, 23692, 23697, 23700, 22939,

  6906     23723, 23739, 23734, 23740, 23735, 23749, 23742, 23751, 23769, 23785,

  6907     23805, 23802, 23789, 23948, 23786, 23819, 23829, 23831, 23900, 23839,

  6908     23835, 23825, 23828, 23842, 23834, 23833, 23832, 23884, 23890, 23886,

  6909     23883, 23916, 23923, 23926, 23943, 23940, 23938, 23970, 23965, 23980,

  6910     23982, 23997, 23952, 23991, 23996, 24009, 24013, 24019, 24018, 24022,

  6911     [12078, 24027], 24043, 24050, 24053, 24075, 24090, 24089, 24081, 24091,

  6912     {f: 2, c: 24118}, 24132, 24131, 24128, 24142, 24151, 24148, 24159, 24162,

  6913     24164, 24135, {f: 2, c: 24181}, [11923, 12083, 24186], 40636,

  6914     [12084, 24191], 24224, {f: 2, c: 24257}, 24264, 24272, 24271, 24278, 24291,

  6915     24285, {f: 2, c: 24282}, 24290, 24289, {f: 2, c: 24296}, 24300, 24305,

  6916     24307, 24304, [12085, 24308], 24312, [12086, 24318], 24323, 24329, 24413,

  6917     24412, [12087, 24331], 24337, 24342, 24361, 24365, 24376, 24385, 24392,

  6918     24396, 24398, 24367, [11924, 24401], {f: 2, c: 24406}, 24409,

  6919     [12090, 24417], 24429, [12091, 24435], 24439, 24451, 24450, 24447, 24458,

  6920     24456, 24465, 24455, 24478, 24473, 24472, 24480, 24488, 24493, 24508,

  6921     24534, 24571, 24548, 24568, 24561, 24541, 24755, 24575, 24609, 24672,

  6922     24601, 24592, 24617, 24590, 24625, 24603, 24597, 24619, 24614, 24591,

  6923     24634, 24666, 24641, 24682, 24695, 24671, 24650, 24646, 24653, 24675,

  6924     24643, 24676, 24642, 24684, 24683, 24665, 24705, 24717, 24807, 24707,

  6925     24730, 24708, 24731, {f: 2, c: 24726}, 24722, 24743, 24715, 24801, 24760,

  6926     24800, 24787, 24756, 24560, 24765, 24774, 24757, 24792, 24909, 24853,

  6927     24838, {f: 2, c: 24822}, 24832, 24820, 24826, 24835, 24865, 24827, 24817,

  6928     {f: 2, c: 24845}, 24903, 24894, 24872, 24871, 24906, 24895, 24892, 24876,

  6929     24884, 24893, 24898, 24900, 24947, 24951, {f: 3, c: 24920}, 24939, 24948,

  6930     24943, 24933, 24945, 24927, 24925, 24915, 24949, 24985, 24982, 24967,

  6931     25004, 24980, 24986, 24970, 24977, 25003, 25006, 25036, 25034, 25033,

  6932     25079, 25032, 25027, 25030, 25018, 25035, 32633, 25037, 25062, 25059,

  6933     25078, 25082, 25076, 25087, 25085, 25084, 25086, 25088, [12093, 25096],

  6934     25097, 25101, 25100, 25108, 25115, 25118, 25121, 25130, 25134, 25136,

  6935     {f: 2, c: 25138}, 25153, 25166, 25182, 25187, 25179, 25184, 25192, 25212,

  6936     25218, 25225, 25214, {f: 2, c: 25234}, 25238, 25300, 25219, 25236, 25303,

  6937     25297, 25275, 25295, 25343, 25286, 25812, 25288, 25308, 25292, 25290,

  6938     25282, 25287, 25243, 25289, 25356, 25326, 25329, 25383, 25346, 25352,

  6939     25327, 25333, 25424, 25406, 25421, 25628, 25423, 25494, 25486, 25472,

  6940     25515, 25462, 25507, 25487, 25481, 25503, 25525, 25451, 25449, 25534,

  6941     25577, 25536, 25542, 25571, 25545, 25554, 25590, 25540, 25622, 25652,

  6942     25606, 25619, 25638, 25654, 25885, 25623, 25640, 25615, 25703, 25711,

  6943     25718, 25678, 25898, 25749, 25747, 25765, 25769, 25736, 25788, 25818,

  6944     25810, 25797, 25799, 25787, 25816, 25794, 25841, 25831, 33289,

  6945     {f: 2, c: 25824}, 25260, 25827, 25839, 25900, 25846, 25844, 25842, 25850,

  6946     25856, 25853, 25880, 25884, 25861, 25892, 25891, 25899, [12097, 25908],

  6947     [11929, 25909], 25911, 25910, 25912, 30027, 25928, 25942, 25941, 25933,

  6948     25944, 25950, 25949, 25970, 25976, {f: 2, c: 25986}, 35722, 26011, 26015,

  6949     26027, 26039, 26051, 26054, 26049, 26052, 26060, 26066, 26075, 26073,

  6950     [12102, 26080], [11931, 26081], 26097, 26482, 26122, 26115, 26107, 26483,

  6951     {f: 2, c: 26165}, 26164, 26140, 26191, 26180, 26185, 26177, 26206, 26205,

  6952     26212, {f: 2, c: 26215}, 26207, 26210, 26224, 26243, 26248, 26254, 26249,

  6953     26244, 26264, 26269, 26305, 26297, 26313, 26302, 26300, 26308, 26296,

  6954     26326, 26330, 26336, 26175, 26342, 26345, [12104, 26352], 26357, 26359,

  6955     26383, 26390, 26398, {f: 2, c: 26406}, 38712, 26414, 26431, 26422, 26433,

  6956     26424, 26423, 26438, 26462, 26464, 26457, {f: 2, c: 26467}, 26505, 26480,

  6957     26537, 26492, 26474, 26508, 26507, 26534, 26529, 26501, 26551, 26607,

  6958     26548, 26604, 26547, 26601, 26552, 26596, 26590, 26589, 26594, 26606,

  6959     26553, 26574, 26566, 26599, 27292, 26654, 26694, 26665, 26688, 26701,

  6960     26674, 26702, 26803, 26667, 26713, 26723, 26743, 26751, 26783, 26767,

  6961     26797, 26772, 26781, 26779, 26755, 27310, 26809, 26740, 26805, 26784,

  6962     26810, 26895, 26765, 26750, 26881, 26826, 26888, 26840, 26914, 26918,

  6963     26849, 26892, 26829, 26836, 26855, 26837, 26934, 26898, 26884, 26839,

  6964     26851, 26917, 26873, 26848, 26863, 26920, 26922, 26906, 26915, 26913,

  6965     26822, 27001, 26999, 26972, 27000, 26987, 26964, 27006, 26990, 26937,

  6966     26996, 26941, 26969, 26928, 26977, 26974, 26973, 27009, 26986, 27058,

  6967     27054, 27088, 27071, 27073, 27091, 27070, 27086, 23528, 27082, 27101,

  6968     27067, 27075, 27047, 27182, 27025, 27040, 27036, 27029, 27060, 27102,

  6969     27112, 27138, 27163, 27135, 27402, 27129, 27122, 27111, 27141, 27057,

  6970     27166, 27117, 27156, 27115, 27146, 27154, 27329, 27171, 27155, 27204,

  6971     27148, 27250, 27190, 27256, 27207, 27234, 27225, 27238, 27208, 27192,

  6972     27170, 27280, 27277, 27296, 27268, {f: 2, c: 27298}, 27287, 34327, 27323,

  6973     27331, 27330, 27320, 27315, 27308, 27358, 27345, 27359, 27306, 27354,

  6974     27370, 27387, 27397, 34326, 27386, 27410, 27414, 39729, 27423, 27448,

  6975     27447, 30428, 27449, 39150, 27463, 27459, 27465, 27472, 27481, 27476,

  6976     27483, 27487, 27489, 27512, [12109, 27513], {f: 2, c: 27519}, 27524, 27523,

  6977     27533, 27544, 27541, 27550, 27556, {f: 2, c: 27562}, 27567, 27570, 27569,

  6978     [12110, 27571], 27575, 27580, 27590, [12111, 27595], 27603, 27615, 27628,

  6979     27627, 27635, 27631, 40638, 27656, 27667, [12115, 27668], 27675, 27684,

  6980     27683, 27742, 27733, 27746, 27754, 27778, 27789, 27802, 27777, 27803,

  6981     27774, 27752, 27763, 27794, 27792, 27844, 27889, 27859, 27837, 27863,

  6982     27845, 27869, 27822, 27825, 27838, 27834, 27867, 27887, 27865, 27882,

  6983     27935, 34893, 27958, 27947, 27965, 27960, 27929, 27957, 27955, 27922,

  6984     27916, 28003, 28051, 28004, 27994, 28025, 27993, 28046, 28053, 28644,

  6985     28037, 28153, 28181, 28170, 28085, 28103, 28134, 28088, 28102, 28140,

  6986     28126, 28108, 28136, 28114, 28101, 28154, 28121, 28132, 28117, 28138,

  6987     28142, 28205, 28270, 28206, 28185, 28274, 28255, 28222, 28195, 28267,

  6988     28203, 28278, 28237, 28191, 28227, 28218, 28238, 28196, 28415, 28189,

  6989     28216, 28290, 28330, 28312, 28361, 28343, 28371, 28349, 28335, 28356,

  6990     28338, {f: 2, c: 28372}, 28303, 28325, 28354, 28319, 28481, 28433, 28748,

  6991     28396, 28408, 28414, 28479, 28402, 28465, 28399, 28466, 28364, 28478,

  6992     28435, 28407, 28550, 28538, 28536, 28545, 28544, 28527, 28507, 28659,

  6993     28525, 28546, 28540, 28504, 28558, 28561, 28610, 28518, 28595, 28579,

  6994     28577, 28580, 28601, 28614, 28586, 28639, 28629, 28652, 28628, 28632,

  6995     28657, 28654, 28635, 28681, 28683, 28666, 28689, 28673, 28687, 28670,

  6996     28699, 28698, 28532, 28701, 28696, 28703, 28720, 28734, 28722, 28753,

  6997     28771, 28825, 28818, 28847, 28913, 28844, 28856, 28851, 28846, 28895,

  6998     28875, 28893, 28889, 28937, 28925, 28956, 28953, 29029, 29013, 29064,

  6999     29030, 29026, 29004, 29014, 29036, 29071, 29179, 29060, 29077, 29096,

  7000     29100, 29143, 29113, 29118, 29138, 29129, 29140, 29134, 29152, 29164,

  7001     29159, 29173, 29180, 29177, 29183, 29197, 29200, 29211, 29224, 29229,

  7002     29228, 29232, 29234, [12120, 29243], 29244, [12121, 29247], 29248, 29254,

  7003     29259, 29272, 29300, 29310, 29314, 29313, 29319, 29330, 29334, 29346,

  7004     29351, 29369, 29362, 29379, 29382, 29380, 29390, 29394, 29410,

  7005     {f: 2, c: 29408}, 29433, 29431, 20495, 29463, 29450, 29468, 29462, 29469,

  7006     29492, 29487, 29481, 29477, 29502, {f: 2, c: 29518}, 40664, 29527, 29546,

  7007     29544, 29552, 29560, 29557, 29563, 29562, 29640, 29619, 29646, 29627,

  7008     29632, 29669, 29678, 29662, 29858, 29701, 29807, 29733, 29688, 29746,

  7009     29754, 29781, 29759, 29791, 29785, 29761, 29788, 29801, 29808, 29795,

  7010     29802, 29814, 29822, 29835, 29854, 29863, 29898, 29903, 29908, 29681,

  7011     29920, 29923, 29927, 29929, 29934, 29938, {f: 2, c: 29936}, 29944, 29943,

  7012     29956, 29955, 29957, 29964, 29966, 29965, 29973, 29971, 29982, 29990,

  7013     29996, 30012, 30020, 30029, 30026, 30025, 30043, 30022, 30042, 30057,

  7014     30052, 30055, 30059, 30061, 30072, 30070, {f: 2, c: 30086}, 30068, 30090,

  7015     30089, 30082, 30100, 30106, 30109, 30117, 30115, 30146, 30131, 30147,

  7016     30133, 30141, 30136, 30140, 30129, 30157, 30154, 30162, 30169, 30179,

  7017     30174, {f: 2, c: 30206}, 30204, 30209, 30192, 30202, {f: 2, c: 30194},

  7018     30219, 30221, 30217, 30239, 30247, {f: 3, c: 30240}, 30244, 30260, 30256,

  7019     30267, {f: 2, c: 30279}, 30278, 30300, 30296, {f: 2, c: 30305},

  7020     {f: 3, c: 30312}, 30311, 30316, 30320, 30322, [12136, 30326], 30328, 30332,

  7021     30336, 30339, 30344, 30347, 30350, 30358, 30355, {f: 2, c: 30361}, 30384,

  7022     30388, {f: 3, c: 30392}, 30402, 30413, 30422, 30418, 30430, 30433, 30437,

  7023     30439, 30442, 34351, 30459, 30472, 30471, 30468, 30505, 30500, 30494,

  7024     {f: 2, c: 30501}, 30491, {f: 2, c: 30519}, 30535, 30554, 30568, 30571,

  7025     30555, 30565, 30591, 30590, 30585, 30606, 30603, 30609, 30624, 30622,

  7026     30640, 30646, 30649, 30655, {f: 2, c: 30652}, 30651, 30663, 30669, 30679,

  7027     30682, 30684, 30691, 30702, 30716, 30732, 30738, 31014, 30752, 31018,

  7028     30789, 30862, 30836, 30854, 30844, 30874, 30860, 30883, 30901, 30890,

  7029     30895, 30929, 30918, 30923, 30932, 30910, 30908, 30917, 30922, 30956,

  7030     30951, 30938, 30973, 30964, 30983, 30994, 30993, 31001, 31020, 31019,

  7031     31040, 31072, 31063, 31071, 31066, 31061, 31059, 31098, 31103, 31114,

  7032     31133, 31143, 40779, 31146, 31150, 31155, {f: 2, c: 31161}, 31177, 31189,

  7033     31207, 31212, 31201, 31203, 31240, 31245, {f: 2, c: 31256}, 31264, 31263,

  7034     31104, 31281, 31291, 31294, 31287, 31299, 31319, 31305, {f: 2, c: 31329},

  7035     31337, 40861, 31344, 31353, 31357, 31368, 31383, 31381, 31384, 31382,

  7036     31401, 31432, 31408, 31414, 31429, 31428, 31423, 36995, 31431, 31434,

  7037     31437, 31439, 31445, 31443, {f: 2, c: 31449}, 31453, {f: 2, c: 31457},

  7038     31462, 31469, 31472, 31490, 31503, 31498, 31494, 31539, {f: 2, c: 31512},

  7039     31518, 31541, 31528, 31542, 31568, 31610, 31492, 31565, 31499, 31564,

  7040     31557, 31605, 31589, 31604, 31591, {f: 2, c: 31600}, 31596, 31598, 31645,

  7041     31640, 31647, 31629, 31644, 31642, 31627, 31634, 31631, 31581, 31641,

  7042     31691, 31681, 31692, 31695, 31668, 31686, 31709, 31721, 31761, 31764,

  7043     31718, 31717, 31840, 31744, 31751, 31763, 31731, 31735, 31767, 31757,

  7044     31734, 31779, 31783, 31786, 31775, 31799, 31787, 31805, 31820, 31811,

  7045     31828, 31823, 31808, 31824, 31832, 31839, 31844, 31830, 31845, 31852,

  7046     31861, 31875, 31888, 31908, 31917, 31906, 31915, 31905, 31912, 31923,

  7047     31922, 31921, 31918, 31929, 31933, 31936, 31941, 31938, 31960, 31954,

  7048     31964, 31970, 39739, 31983, 31986, 31988, 31990, 31994, 32006, 32002,

  7049     32028, 32021, 32010, 32069, 32075, 32046, 32050, 32063, 32053, 32070,

  7050     32115, 32086, 32078, 32114, 32104, 32110, 32079, 32099, 32147, 32137,

  7051     32091, 32143, 32125, 32155, 32186, 32174, 32163, 32181, 32199, 32189,

  7052     32171, 32317, 32162, 32175, 32220, 32184, 32159, 32176, 32216, 32221,

  7053     32228, 32222, 32251, 32242, 32225, 32261, 32266, 32291, 32289, 32274,

  7054     32305, 32287, 32265, 32267, 32290, 32326, 32358, 32315, 32309, 32313,

  7055     32323, 32311, 32306, 32314, 32359, 32349, 32342, 32350, {f: 2, c: 32345},

  7056     32377, 32362, 32361, 32380, 32379, 32387, 32213, 32381, 36782, 32383,

  7057     {f: 2, c: 32392}, 32396, 32402, 32400, {f: 2, c: 32403}, 32406, 32398,

  7058     {f: 2, c: 32411}, 32568, 32570, 32581, {f: 3, c: 32588}, 32592,

  7059     [12153, 32593], 32597, 32596, 32600, {f: 2, c: 32607}, {f: 2, c: 32616},

  7060     32615, 32632, 32642, 32646, 32643, 32648, 32647, 32652, 32660, 32670,

  7061     32669, 32666, 32675, 32687, 32690, 32697, 32686, 32694, 32696, 35697,

  7062     {f: 2, c: 32709}, 32714, 32725, 32724, 32737, 32742, 32745, 32755, 32761,

  7063     39132, 32774, 32772, 32779, [12158, 32786], {f: 2, c: 32792}, 32796, 32801,

  7064     32808, 32831, 32827, 32842, 32838, 32850, 32856, 32858, 32863, 32866,

  7065     32872, 32883, 32882, 32880, 32886, 32889, 32893, [12160, 32895], 32900,

  7066     32902, 32901, 32923, 32915, 32922, 32941, 20880, 32940, 32987, 32997,

  7067     32985, 32989, 32964, 32986, 32982, 33033, 33007, 33009, 33051, 33065,

  7068     33059, 33071, 33099, 38539, 33094, 33086, 33107, 33105, 33020, 33137,

  7069     33134, {f: 2, c: 33125}, 33140, 33155, 33160, 33162, 33152, 33154, 33184,

  7070     33173, 33188, 33187, 33119, 33171, 33193, 33200, 33205, 33214, 33208,

  7071     33213, 33216, 33218, 33210, 33225, 33229, 33233, 33241, 33240, 33224,

  7072     33242, {f: 2, c: 33247}, 33255, {f: 2, c: 33274}, 33278, {f: 2, c: 33281},

  7073     33285, 33287, 33290, 33293, 33296, 33302, 33321, 33323, 33336, 33331,

  7074     33344, 33369, 33368, 33373, 33370, 33375, 33380, 33378, 33384,

  7075     {f: 2, c: 33386}, 33326, 33393, 33399, [12171, 33400], 33406, 33421, 33426,

  7076     33451, 33439, 33467, 33452, 33505, 33507, 33503, 33490, 33524, 33523,

  7077     33530, 33683, 33539, 33531, 33529, 33502, 33542, 33500, 33545, 33497,

  7078     33589, 33588, 33558, 33586, 33585, 33600, 33593, 33616, 33605, 33583,

  7079     33579, {f: 2, c: 33559}, 33669, 33690, 33706, 33695, 33698, 33686, 33571,

  7080     33678, 33671, 33674, 33660, 33717, 33651, 33653, 33696, 33673, 33704,

  7081     33780, 33811, 33771, 33742, 33789, 33795, 33752, 33803, 33729, 33783,

  7082     33799, 33760, 33778, 33805, 33826, 33824, 33725, 33848, 34054, 33787,

  7083     33901, 33834, 33852, 34138, 33924, 33911, 33899, 33965, 33902, 33922,

  7084     33897, 33862, 33836, 33903, 33913, 33845, 33994, 33890, 33977, 33983,

  7085     33951, 34009, 33997, 33979, 34010, 34000, 33985, 33990, 34006, 33953,

  7086     34081, 34047, 34036, {f: 2, c: 34071}, 34092, 34079, 34069, 34068, 34044,

  7087     34112, 34147, 34136, 34120, 34113, 34306, 34123, 34133, 34176, 34212,

  7088     34184, 34193, 34186, 34216, 34157, 34196, 34203, 34282, 34183, 34204,

  7089     34167, 34174, 34192, 34249, 34234, 34255, 34233, 34256, 34261, 34269,

  7090     34277, 34268, 34297, 34314, 34323, 34315, 34302, 34298, 34310, 34338,

  7091     34330, 34352, 34367, [12172, 34381], 20053, 34388, 34399, 34407, 34417,

  7092     34451, 34467, {f: 2, c: 34473}, {f: 2, c: 34443}, 34486, 34479, 34500,

  7093     34502, 34480, 34505, 34851, 34475, 34516, 34526, 34537, 34540, 34527,

  7094     34523, 34543, 34578, 34566, 34568, 34560, 34563, 34555, 34577, 34569,

  7095     34573, 34553, 34570, 34612, 34623, 34615, 34619, 34597, 34601, 34586,

  7096     34656, 34655, 34680, 34636, 34638, 34676, 34647, 34664, 34670, 34649,

  7097     34643, 34659, 34666, 34821, 34722, 34719, 34690, 34735, 34763, 34749,

  7098     34752, 34768, 38614, 34731, 34756, 34739, 34759, 34758, 34747, 34799,

  7099     34802, 34784, 34831, 34829, 34814, {f: 2, c: 34806}, 34830, 34770, 34833,

  7100     34838, 34837, 34850, 34849, 34865, 34870, 34873, 34855, 34875, 34884,

  7101     34882, 34898, 34905, 34910, 34914, 34923, 34945, 34942, 34974, 34933,

  7102     34941, 34997, 34930, 34946, 34967, 34962, 34990, 34969, 34978, 34957,

  7103     34980, 34992, 35007, 34993, {f: 2, c: 35011}, 35028, {f: 2, c: 35032},

  7104     35037, 35065, 35074, 35068, 35060, 35048, 35058, 35076, 35084, 35082,

  7105     35091, 35139, 35102, 35109, {f: 2, c: 35114}, 35137, 35140, 35131, 35126,

  7106     35128, 35148, 35101, 35168, 35166, 35174, 35172, 35181, 35178, 35183,

  7107     35188, 35191, [12177, 35198], 35203, 35208, 35210, 35219, 35224, 35233,

  7108     35241, 35238, 35244, 35247, 35250, 35258, 35261, {f: 2, c: 35263}, 35290,

  7109     {f: 2, c: 35292}, 35303, 35316, 35320, 35331, 35350, 35344, 35340, 35355,

  7110     35357, 35365, 35382, 35393, 35419, 35410, 35398, 35400, 35452, 35437,

  7111     35436, 35426, 35461, 35458, 35460, 35496, 35489, 35473, {f: 2, c: 35493},

  7112     35482, 35491, 35524, 35533, 35522, 35546, 35563, 35571, 35559, 35556,

  7113     35569, 35604, 35552, 35554, 35575, 35550, 35547, 35596, 35591, 35610,

  7114     35553, 35606, 35600, 35607, 35616, 35635, 38827, 35622, 35627, 35646,

  7115     35624, 35649, 35660, 35663, 35662, 35657, 35670, 35675, 35674, 35691,

  7116     35679, 35692, 35695, 35700, 35709, 35712, 35724, 35726, {f: 2, c: 35730},

  7117     35734, {f: 2, c: 35737}, 35898, 35905, 35903, 35912, 35916, 35918, 35920,

  7118     [12183, 35925], 35938, 35948, [12184, 35960], 35962, 35970, 35977, 35973,

  7119     35978, {f: 2, c: 35981}, 35988, 35964, 35992, 25117, 36013, 36010, 36029,

  7120     {f: 2, c: 36018}, 36014, 36022, 36040, 36033, 36068, 36067, 36058, 36093,

  7121     {f: 2, c: 36090}, {f: 2, c: 36100}, 36106, 36103, 36111, 36109, 36112,

  7122     40782, 36115, 36045, 36116, 36118, 36199, 36205, 36209, 36211, 36225,

  7123     36249, 36290, 36286, 36282, 36303, 36314, 36310, 36300, 36315, 36299,

  7124     {f: 2, c: 36330}, 36319, 36323, 36348, {f: 2, c: 36360}, 36351,

  7125     {f: 2, c: 36381}, 36368, 36383, 36418, 36405, 36400, 36404, 36426, 36423,

  7126     36425, 36428, 36432, 36424, 36441, 36452, 36448, 36394, 36451, 36437,

  7127     36470, 36466, 36476, 36481, 36487, 36485, 36484, 36491, 36490, 36499,

  7128     36497, 36500, 36505, 36522, 36513, 36524, 36528, 36550, 36529, 36542,

  7129     36549, 36552, 36555, 36571, 36579, 36604, 36603, 36587, 36606, 36618,

  7130     36613, 36629, 36626, 36633, 36627, 36636, 36639, 36635, 36620, 36646,

  7131     36659, 36667, 36665, 36677, 36674, 36670, 36684, 36681, 36678, 36686,

  7132     36695, 36700, {f: 3, c: 36706}, 36764, 36767, 36771, 36781, 36783, 36791,

  7133     36826, 36837, 36834, 36842, 36847, 36999, 36852, 36869, {f: 2, c: 36857},

  7134     36881, 36885, 36897, 36877, 36894, 36886, 36875, 36903, 36918, 36917,

  7135     36921, 36856, {f: 4, c: 36943}, 36878, 36937, 36926, 36950, 36952, 36958,

  7136     36968, 36975, 36982, 38568, 36978, 36994, 36989, 36993, 36992, 37002,

  7137     37001, 37007, 37032, 37039, 37041, 37045, 37090, 37092, 25160, 37083,

  7138     37122, 37138, 37145, 37170, 37168, 37194, 37206, 37208, 37219, 37221,

  7139     37225, 37235, 37234, 37259, 37257, 37250, 37282, 37291, 37295, 37290,

  7140     37301, 37300, 37306, {f: 2, c: 37312}, 37321, 37323, 37328, 37334, 37343,

  7141     37345, 37339, 37372, {f: 2, c: 37365}, 37406, 37375, 37396, 37420, 37397,

  7142     37393, 37470, 37463, 37445, 37449, 37476, 37448, 37525, 37439, 37451,

  7143     37456, 37532, 37526, 37523, 37531, 37466, 37583, 37561, 37559, 37609,

  7144     37647, 37626, 37700, 37678, 37657, 37666, 37658, 37667, 37690, 37685,

  7145     37691, 37724, 37728, 37756, 37742, 37718, 37808, {f: 2, c: 37804}, 37780,

  7146     37817, {f: 2, c: 37846}, 37864, 37861, 37848, 37827, 37853, 37840, 37832,

  7147     37860, 37914, 37908, 37907, 37891, 37895, 37904, 37942, 37931, 37941,

  7148     37921, 37946, 37953, 37970, 37956, 37979, 37984, 37986, 37982, 37994,

  7149     37417, 38000, 38005, 38007, 38013, 37978, 38012, 38014, 38017, 38015,

  7150     38274, 38279, 38282, 38292, 38294, {f: 2, c: 38296}, 38304, 38312, 38311,

  7151     38317, 38332, 38331, 38329, 38334, 38346, 28662, 38339, 38349, 38348,

  7152     38357, 38356, 38358, 38364, 38369, 38373, 38370, 38433, 38440,

  7153     {f: 2, c: 38446}, 38466, 38476, 38479, 38475, 38519, 38492, 38494, 38493,

  7154     38495, 38502, 38514, 38508, 38541, 38552, 38549, 38551, 38570, 38567,

  7155     {f: 2, c: 38577}, 38576, 38580, [12202, 38582], 38584, [12203, 38585],

  7156     38606, 38603, 38601, 38605, 35149, 38620, 38669, 38613, 38649, 38660,

  7157     38662, 38664, 38675, 38670, 38673, 38671, 38678, 38681, 38692, 38698,

  7158     38704, 38713, {f: 2, c: 38717}, 38724, 38726, 38728, 38722, 38729, 38748,

  7159     38752, 38756, 38758, 38760, 21202, 38763, 38769, 38777, 38789, 38780,

  7160     38785, 38778, 38790, 38795, {f: 2, c: 38799}, 38812, 38824, 38822, 38819,

  7161     {f: 2, c: 38835}, 38851, 38854, 38856, [12209, 38859], 38876,

  7162     [12210, 38893], 40783, 38898, 31455, 38902, 38901, 38927, 38924, 38968,

  7163     38948, 38945, 38967, 38973, 38982, 38991, 38987, 39019, {f: 3, c: 39023},

  7164     39028, 39027, 39082, 39087, 39089, 39094, 39108, 39107, 39110, 39145,

  7165     39147, 39171, 39177, 39186, 39188, 39192, 39201, {f: 2, c: 39197}, 39204,

  7166     39200, 39212, 39214, {f: 2, c: 39229}, 39234, 39241, 39237, 39248, 39243,

  7167     {f: 2, c: 39249}, 39244, 39253, {f: 2, c: 39319}, 39333, {f: 2, c: 39341},

  7168     39356, 39391, 39387, 39389, 39384, 39377, {f: 2, c: 39405},

  7169     {f: 2, c: 39409}, 39419, 39416, 39425, 39439, 39429, 39394, 39449, 39467,

  7170     39479, 39493, 39490, 39488, 39491, 39486, 39509, 39501, 39515, 39511,

  7171     39519, 39522, 39525, 39524, 39529, 39531, 39530, 39597, 39600, 39612,

  7172     39616, 39631, 39633, {f: 2, c: 39635}, 39646, [12221, 39647],

  7173     {f: 2, c: 39650}, 39654, 39663, 39659, 39662, 39668, 39665, 39671, 39675,

  7174     39686, 39704, 39706, 39711, {f: 2, c: 39714}, [12222, 39717],

  7175     {f: 4, c: 39719}, 39726, [12223, 39727], [12224, 39730], 39748, 39747,

  7176     39759, {f: 2, c: 39757}, 39761, 39768, 39796, 39827, 39811, 39825,

  7177     {f: 2, c: 39830}, {f: 2, c: 39839}, 39848, 39860, 39872, 39882, 39865,

  7178     39878, 39887, {f: 2, c: 39889}, 39907, 39906, 39908, 39892, 39905, 39994,

  7179     39922, 39921, 39920, 39957, 39956, 39945, 39955, 39948, 39942, 39944,

  7180     39954, 39946, 39940, 39982, 39963, 39973, 39972, 39969, 39984, 40007,

  7181     39986, 40006, 39998, 40026, 40032, 40039, 40054, 40056, 40167, 40172,

  7182     40176, 40201, 40200, 40171, 40195, 40198, 40234, 40230, 40367, 40227,

  7183     40223, 40260, 40213, 40210, 40257, 40255, 40254, 40262, 40264,

  7184     {f: 2, c: 40285}, 40292, 40273, 40272, 40281, 40306, 40329, 40327, 40363,

  7185     40303, 40314, 40346, 40356, 40361, 40370, 40388, 40385, 40379, 40376,

  7186     40378, 40390, 40399, 40386, 40409, 40403, 40440, 40422, 40429, 40431,

  7187     40445, {f: 2, c: 40474}, 40478, [12228, 40565], 40569, 40573, 40577, 40584,

  7188     {f: 2, c: 40587}, 40594, 40597, 40593, 40605, [12230, 40613], 40617, 40632,

  7189     40618, 40621, 38753, 40652, {f: 3, c: 40654}, 40660, 40668, 40670, 40669,

  7190     40672, 40677, 40680, 40687, 40692, {f: 2, c: 40694}, [12235, 40697],

  7191     {f: 2, c: 40699}, [12236, 40701], {f: 2, c: 40711}, 30391, 40725, 40737,

  7192     40748, 40766, [12241, 40778], [12242, 40786], 40788, 40803,

  7193     {f: 3, c: 40799}, {f: 2, c: 40806}, 40812, 40810, 40823, 40818, 40822,

  7194     40853, [12244, 40860], [12245, 40864], 22575, 27079, 36953, 29796, 0,

  7195     {f: 76, c: 9472}, {f: 20, c: 9312}, {f: 10, c: 8544}, 13129, 13076, 0,

  7196     13133, 0, 13095, 0, 13110, 13137, 0, 13069, 13094, 0, 13099, 13130, 0,

  7197     {f: 3, c: 13212}, {f: 2, c: 13198}, 13252, 13217, 12317, 12319, 8470,

  7198     13261, 0, {f: 5, c: 12964}, {f: 2, c: 12849}, 12857, 13182, 13181, 13180,

  7199     8750, 8721, {s: 3}, 8735, 8895, 0, 0, 21854, {s: 7}, 167133, 0, 0, 28976,

  7200     0, 40407, {s: 4}, 64054, 0, 0, 22169, 15694, {s: 4}, 20448, 0, 0, 36544, 0,

  7201     194797, {s: 4}, 153716, 32363, 33606, 167670, {s: 3}, 40572, 0, 0, 26171,

  7202     0, 40628, {s: 4}, 26629, {s: 5}, 23650, 0, 194780, 0, 32353, 0, 0, 64070,

  7203     {s: 5}, 34083, 37292, {s: 7}, 34796, {s: 8}, 25620, 0, 0, 39506, {s: 4},

  7204     64074, 0, 194692, {s: 4}, 31774, {s: 6}, 64016, 25681, 0, 0, 63980, 22625,

  7205     39002, 0, 194679, {s: 3}, 31153, 0, 28678, {s: 9}, 22218, {s: 3}, 21085, 0,

  7206     28497, 37297, {s: 10}, 64106, {s: 6}, 38960, 0, 40629, {s: 9}, 33802,

  7207     63939, {f: 2, c: 63890}, 63897, 0, 34847, 194575, 0, 194771, 194584,

  7208     {s: 7}, 137754, 23643, {s: 4}, 25890, 0, 0, 26618, 0, 26766, 0, 148432,

  7209     194848, {s: 21}, 34110, {s: 15}, 30562, {s: 12}, 65075, 0,

  7210     {f: 2, c: 65073}, {s: 4}, 65072, {f: 2, c: 65077}, {f: 2, c: 65081}, 0, 0,

  7211     {f: 2, c: 65079}, {f: 2, c: 65087}, {f: 2, c: 65085}, {f: 4, c: 65089},

  7212     {f: 2, c: 65083}, {s: 41}, {f: 3, c: 12436}, 0, 0, 22099, {s: 41}, 65508,

  7213     65287, 65282, 0, 9665, 9655, 8681, 8679, 8678, 8680, 9634, 9831, 9825,

  7214     9828, 9826, 13216, 13218, {f: 2, c: 13220}, 13207, 8467, 13208, 13235,

  7215     13234, 13233, 13232, {f: 3, c: 13189}, 13259, 13200, 13268, 13206, 13090,

  7216     13078, 13080, 13077, 13059, 13091, 13143, 13122, 13113, 13115, 13056,

  7217     13105, 13127, 13086, 13098, 0, 13183, 8481, 9742, 12342, 12320, {s: 3},

  7218     {f: 9, c: 9352}, {f: 20, c: 9332}, 12881, {f: 10, c: 8560},

  7219     {f: 10, c: 12882}, {f: 26, c: 9372}, 12867, 12861, 12863, 12852, 12856,

  7220     12851, 12860, 12866, 12862, 12854, 12853, 12859, 12864, 12858, 12976,

  7221     12973, 12969, 12975, 12948, 12970, 12952, 12971, 12946, 12945, 12947,

  7222     12972, 12974, 12950, {s: 8}, {f: 3, c: 9131}, 0, {f: 3, c: 9127}, 0, 13260,

  7223     13061, 0, 0, 13215, 13219, 13222, 0, 0, 12958, {f: 2, c: 13192}, 13256,

  7224     8749, 0, 12848, {f: 6, c: 12842}, 12855, 12865, 10145, {s: 3}, 9673, 9824,

  7225     9829, 9827, 9830, {f: 4, c: 9728}, 9758, {f: 2, c: 9756}, 9759, 12953,

  7226     9450, {f: 2, c: 8554}, {s: 3}, {f: 8, c: 9601}, 9615, 9614, 9613, 9612,

  7227     9611, 9610, 9609, {f: 2, c: 9620}, {f: 2, c: 9581}, 9584, 9583, 9552, 9566,

  7228     9578, 9569, {f: 2, c: 9698}, 9701, 9700, 0, 0, {f: 3, c: 9585}, {s: 20},

  7229     20956, 29081, {f: 9, c: 10102}, {s: 3}, {f: 2, c: 8570}, {s: 3}, 8575,

  7230     8458, 8457, 0, 0, 12292, 8646, {f: 2, c: 8644}, 0, {f: 4, c: 12535}, 0, 0,

  7231     12957, {s: 3}, 13179, {s: 3}, 13107, 13134, {s: 30}, 32394, 35100, 37704,

  7232     37512, 34012, 20425, 28859, 26161, 26824, 37625, 26363, 24389,

  7233     [12033, 20008], 20193, 20220, 20224, 20227, 20281, 20310, 20370, 20362,

  7234     20378, 20372, 20429, 20544, 20514, 20479, 20510, 20550, 20592, 20546,

  7235     20628, 20724, 20696, 20810, 20836, 20893, 20926, 20972, 21013, 21148,

  7236     21158, 21184, 21211, 21248, 0, 21284, 21362, 21395, 21426, 21469, 64014,

  7237     21660, 21642, 21673, 21759, 21894, 22361, 22373, 22444, 22472, 22471,

  7238     64015, 0, 22686, 22706, 22795, 22867, 22875, 22877, 22883, 22948, 22970,

  7239     23382, 23488, 29999, 23512, 0, 23582, 23718, 23738, 23797, 23847, 23891, 0,

  7240     23874, 23917, {f: 2, c: 23992}, 24016, 24353, 24372, 24423, 24503, 24542,

  7241     24669, 24709, 24714, 24798, 24789, 24864, 24818, 24849, 24887, 24880,

  7242     24984, 25107, 25254, 25589, 25696, 25757, 25806, 25934, 26112, 26133,

  7243     26121, 26158, 0, 26148, 26213, 26199, 26201, 64018, 26227, 26265, 26272,

  7244     26290, 26303, 26362, 26382, 0, 26470, 26555, 26706, 26560, 0, 26692, 26831,

  7245     64019, 26984, 64020, 27032, 27106, 27184, 27243, 27206, 27251, 27262,

  7246     27362, 27364, 27606, 27711, 27740, 27782, 27759, 27866, 27908, 28039,

  7247     28015, 28054, 28076, 28111, 28152, 28146, 28156, 28217, 28252, 28199,

  7248     28220, 28351, 28552, 28597, 28661, 28677, 28679, 28712, 28805, 28843,

  7249     28943, 28932, 29020, {f: 2, c: 28998}, 0, 29121, 29182, 29361, 29374,

  7250     29476, 64022, 29559, 29629, 29641, 29654, 29667, 29650, 29703, 29685,

  7251     29734, 29738, 29737, 29742, 0, 29833, 29855, 29953, 30063, 30338, 30364,

  7252     30366, 30363, 30374, 64023, 30534, 21167, 30753, 30798, 30820, 30842,

  7253     31024, {f: 3, c: 64024}, 31124, 64027, 31131, 31441, 31463, 64028, 31467,

  7254     31646, 64029, 32072, 0, 32183, 32160, 32214, 32338, 32583, 32673, 64030,

  7255     33537, 33634, 33663, 33735, 33782, 33864, 33972, 34131, 34137, 34155,

  7256     64031, 34224, {f: 2, c: 64032}, 34823, 35061, 35346, 35383, 35449, 35495,

  7257     35518, 35551, 64034, 35574, 35667, 35711, 36080, 36084, 36114, 36214,

  7258     64035, 36559, 0, 64037, 36967, 37086, 64038, 37141, 37159, 37338, 37335,

  7259     37342, {f: 2, c: 37357}, {f: 2, c: 37348}, 37382, 37392, 37386, 37434,

  7260     37440, 37436, 37454, 37465, 37457, 37433, 37479, 37543, {f: 2, c: 37495},

  7261     37607, 37591, 37593, 37584, 64039, 37589, 37600, 37587, 37669, 37665,

  7262     37627, 64040, 37662, 37631, 37661, 37634, 37744, 37719, 37796, 37830,

  7263     37854, 37880, 37937, 37957, 37960, 38290, 0, 64041, 38557, 38575, 38707,

  7264     38715, 38723, 38733, 38735, [12205, 38737], 0, 38999, 39013,

  7265     {f: 2, c: 64042}, 39207, 64044, 39326, 39502, 39641, 39644, 39797, 39794,

  7266     39823, 39857, 39867, 39936, 40304, 40299, 64045, 40473, 40657, 0, 92,

  7267     {s: 634}, 8364, 8486, 0, 0, 64256, {f: 2, c: 64259}, 257, 299, 363, 275,

  7268     333, 256, 298, 362, 274, 332, {f: 4, c: 8539}, {f: 2, c: 8531}, 8304,

  7269     {f: 6, c: 8308}, {f: 10, c: 8320}, 461, 282, 0, 7868, 463, 0, 296, 465, 0,

  7270     467, 366, 360, 462, 283, 0, 7869, 464, 0, 297, 466, 0, 468, 367, 361, 593,

  7271     8049, 8048, 509, 0, 596, 0, 0, 601, 0, 0, 602, 0, 0, 603, 8051, 8050, 0,

  7272     331, 629, 652, 0, 0, 658, 643, 720, {s: 682}, {f: 10, c: 12832}, {s: 108},

  7273     {f: 4, c: 12892}, {f: 15, c: 12977}, {s: 50}, {f: 26, c: 9424},

  7274     {f: 26, c: 9398}, {s: 48}, {f: 47, c: 13008}, 0, {f: 10, c: 12928}, 12944,

  7275     {f: 6, c: 12938}, 0, 12959, {s: 6}, {f: 2, c: 12960}, 12955, 12954, 12963,

  7276     12962, 12951, 0, 12956, 12949, {s: 6}, 9676, {s: 11}, 10111,

  7277     {f: 10, c: 9451}, {s: 510}, 8414, {s: 815}, 13274, {s: 3}, 8448, 13250, 0,

  7278     0, 8453, 0, 13169, 0, 0, 13197, 13211, {s: 3}, {f: 2, c: 13271}, {s: 3},

  7279     {f: 2, c: 13057}, 13060, 13062, 0, 13064, 0, 13063, 13066, 0, 13065, 0,

  7280     13067, 0, 13068, {f: 6, c: 13070}, 0, 13079, 0, 13081, 0, {f: 4, c: 13082},

  7281     {f: 3, c: 13087}, 13092, 0, 13093, 0, 0, {f: 2, c: 13096}, 0, 13101, 0, 0,

  7282     {f: 3, c: 13102}, 13106, 0, 0, {f: 2, c: 13108}, 13116, {s: 3}, 13111, 0,

  7283     13112, 13114, 13117, 13121, {f: 3, c: 13118}, {f: 4, c: 13123}, 13128,

  7284     {f: 2, c: 13131}, {f: 2, c: 13135}, 0, 0, 13138, 13140, 0, 0, 13139,

  7285     {f: 2, c: 13141}, {s: 132}, 8501, 976, 8714, 8463, 0, 981, 987, 977, 0,

  7286     {f: 2, c: 9832}, 9836, {s: 5}, 12347, 0, {f: 3, c: 12339}, 8252, 8265,

  7287     {s: 5}, 8723, 0, 8771, {f: 2, c: 8818}, {s: 6}, {f: 2, c: 12312},

  7288     {f: 2, c: 65375}, {s: 10}, 9115, {f: 2, c: 9117}, 9120, {s: 4}, 9121,

  7289     {f: 2, c: 9123}, 9126, {s: 12}, [9116, 9119, 9122, 9125, 9130], {s: 8},

  7290     9986, 0, 0, 12349, 0, 12447, 0, 0, 8709, 8864, 8854, 8856, 8853, 8855,

  7291     {s: 4}, 9664, 9654, {s: 4}, 8656, 8596, {f: 2, c: 8600}, {f: 2, c: 8598},

  7292     8652, 8651, {s: 10}, 12336, 8967, {s: 8}, 10048, 10047, {s: 7}, 9643, 0,

  7293     9642, 0, 10010, {s: 12}, 9702, {s: 4}, 10070, {s: 379}, {f: 2, c: 65093},

  7294     {s: 679}, 64103, 64098, 32227, [12232, 40643], 28331, 64082, 64061, 64069,

  7295     64062, 27114, 28212, 64096, 64071, 64056, 64066, 64078, 34395, 64105,

  7296     64052, 64099, 25581, 25802, 30799, 64084, 63856, 64077, 64097, 64072,

  7297     64076, {f: 2, c: 64091}, 64081, 64067, 64090, 28041, 29376, 0, 194885,

  7298     64086, 64080, 64049, 64059, 24034, 64063, 64101, 21373, 64055, 64095,

  7299     24501, 64064, 0, 64083, 0, 64085, 64104, 64068, 64089, 26202, 64053, 64075,

  7300     64100, 64065, 64048, 0, 64057, 64051, 27493, 64058, 27599, 64050, 25150,

  7301     64079, 63773, 63964, 63798, 28122, 63952, 26310, 27511, 64087, 37706, 0,

  7302     37636, {s: 120}, 133390, {s: 120}, 35999, 11991, [11965, 158033], {s: 5},

  7303     37555, 38321, 0, 0, 194812, {s: 13}, 194965, {s: 8}, 194794, 0, 26478,

  7304     11974, 0, 194594, {s: 13}, 13314, 0, 0, 26083, {s: 4}, 134071, {s: 10},

  7305     171339, 0, 194611, 24378, {s: 8}, 11945, 0, 20465, {s: 7}, 63753, {s: 7},

  7306     11964, 0, 0, 194732, 26435, {s: 3}, 133732, 35329, 25142, 0, 0, 21555,

  7307     23067, {s: 3}, 25221, 0, 0, 194819, {s: 6}, 21567, {s: 9}, 27506, {s: 4},

  7308     29986, 19256, 0, 0, 24063, {s: 6}, 194827, 29626, 134047, {s: 3}, 194600,

  7309     0, 194849, {s: 5}, 194623, {s: 16}, 194675, {f: 2, c: 11916}, 23577,

  7310     {s: 3}, 131083, 23426, 194642, {s: 5}, 11997, [11999, 39136],

  7311     [11998, 169599], 14221, 0, [11927, 14586], 0, 194887, 0, [11909, 20155],

  7312     131490, {s: 7}, 13599, 0, 194738, 0, 0, [11971, 35200], {s: 4}, 31237,

  7313     {s: 4}, 35498, 0, 32085, 0, 28568, {s: 7}, 25591, 30246, {s: 4},

  7314     [11978, 163767], {s: 5}, 146686, {s: 5}, 13351, 0, 0, 33067, 0, 0, 194842,

  7315     {s: 5}, 11950, {s: 5}, 194714, {s: 3}, 194831, {s: 19}, 22305, 135741,

  7316     194586, 0, 64003, {s: 7}, 21534, 15240, 20839, {s: 4}, 63839, {s: 9},

  7317     20023, {s: 13}, [11946, 150804], 24421, 23020, 194658, 0, 24217, {s: 46},

  7318     13416, {s: 8}, 21200, {s: 9}, 26625, 0, 195024, 195039, {s: 5}, 153215, 0,

  7319     0, 11959, {s: 4}, 36534, 63775, {s: 3}, 63875, {s: 5}, 31867, 63906, 0,

  7320     63898, 0, [11961, 32770], 157360, {s: 4}, [11911, 132648], 0, 0, 131210,

  7321     194604, [11915, 13630], {s: 4}, 21589, 0, 22841, 0, 0, 23414, 194669,

  7322     23572, 14306, 23782, 0, 20040, 0, 0, 194742, {s: 4}, 158105, 25371, 0, 0,

  7323     26211, 0, 194779, 0, 0, 27126, 27014, {s: 3}, 27596, 0, 28183, 0, 0, 27818,

  7324     {s: 3}, [11942, 20012], 0, 0, 29935, 30069, 30188, 30286, 16305, 30570,

  7325     30633, {s: 6}, 31571, 0, 0, 16996, {s: 3}, 194924, 0, 0, 32328, {s: 5},

  7326     11955, {s: 4}, 33089, 17491, 0, [11966, 33401], [11967, 64094],

  7327     [11968, 64093], 0, 20857, 33626, {s: 3}, 17701, 0, 34292, 131248, {s: 4},

  7328     34429, 0, 13358, 35014, {s: 6}, 18406, {s: 8}, 36808, {s: 19}, 166279, 0,

  7329     0, 167447, 0, 0, 38969, {s: 6}, 39432, {s: 4}, 39903, {s: 10}, 148206,

  7330     {s: 5}, 21385, 0, 64017, 194785, 0, 146622, 132625, 0, {f: 2, c: 19972},

  7331     19999, 20011, {f: 2, c: 20015}, {f: 2, c: 20032}, 20036, [11907, 20058],

  7332     20095, 20109, 20118, 20153, 20176, 20192, 20221, 20223, 20235, 20245,

  7333     20320, 20283, 20297, 20308, 20346, {f: 2, c: 20349}, 20375, 20414, 20431,

  7334     20477, {f: 2, c: 20480}, 20496, 20507, 20519, 20526, 20567, 20582, 20586,

  7335     20539, 20623, 20630, 20636, 20684, 20710, 20713, 20719, 20744, 20747,

  7336     20752, 20763, 20766, 20831, 20897, 20924, 0, 20974, 20980, 20993,

  7337     [11913, 20994], 21011, 21065, 21089, 21094, 21139, 21192, 21232,

  7338     {f: 2, c: 21258}, 21310, 21324, 21323, 21345, 21356, 21419, 21466, 21478,

  7339     21493, 21543, 21581, 21606, 21611, 21620, 21645, 21654, 21665, 21677,

  7340     21689, 21695, 21702, 21709, 21774, 21803, 21813, 21834, 21856, 0, 21896,

  7341     21902, 22024, {f: 2, c: 22030}, 22071, 22079, 22089, 22091, 22095, 22118,

  7342     22121, 22127, {f: 2, c: 22129}, 22165, 22170, {f: 2, c: 22188}, 22193,

  7343     22217, 22237, 22244, 22282, 22293, 22307, 22319, {f: 2, c: 22323}, 22348,

  7344     22384, 22412, 22428, 22456, 22502, 22509, {f: 2, c: 22517}, 22527, 22537,

  7345     22560, 22578, 22652, 22656, 22697, 22734, 22736, 22740, 22746, 22761,

  7346     22796, 22820, 22831, 22881, 22893, 22986, 22994, 23005, {f: 2, c: 23011},

  7347     23044, 23052, 23075, 23111, 23125, 23139, 23149, 23166, 23198, 23207,

  7348     23212, 23219, 23264, 23296, 23321, 23333, 23341, 23361, 23420,

  7349     {f: 2, c: 23422}, 23434, [11919, 23587], 23595, 23600, 23651, 23657, 23676,

  7350     23755, 23762, 23796, 23844, 23846, 23875, 23878, 23882, 23954, 23956,

  7351     23961, 23968, 24024, 24032, 24056, 24064, 24082, {f: 2, c: 24084}, 24088,

  7352     24110, 24152, {f: 2, c: 24171}, 24232, 24234, {f: 2, c: 24254}, 0, 24274,

  7353     24327, 24334, {f: 2, c: 24348}, 24354, 24360, 24374, 24379, 24384,

  7354     [12089, 24400], 24408, 24420, 24457, 24476, 24487, 24484, 24495, 24504,

  7355     [11926, 24516], 24521, 24545, 24553, 24557, 24572, 24599, 24602, 24627,

  7356     24673, 24703, 24734, 24740, 24752, 24779, 24795, 24824, {f: 3, c: 24850},

  7357     24860, 24956, 24973, 24991, 25000, 25026, 25055, 25109, 25129, 25155,

  7358     25158, [11928, 25164], 25169, 25174, 25284, 25340, 25354, 25357, 25368,

  7359     25401, {f: 2, c: 25410}, 25445, 25460, 25469, 25476, 25479, 25488, 25502,

  7360     25553, 25564, 25609, 25616, 25634, 25684, 25691, 25709, 25723,

  7361     {f: 2, c: 25790}, 25829, 25847, 25851, 25860, 25878, 25881, 25927, 25959,

  7362     25985, 25989, 26050, 26096, 26098, 26156, 26188, {f: 2, c: 26203}, 26209,

  7363     26219, 0, 26276, 26312, 26348, 26373, 26387, 26419, 26440, 26444, 26486,

  7364     26491, 26544, 26546, 26617, 26583, 26585, 26608, 26668, {f: 2, c: 26672},

  7365     26715, 26738, 26741, 26746, 26756, 26789, 26802, 26832, 26838, 26856,

  7366     26861, {f: 2, c: 26864}, 26876, 26897, 26899, 26933, 26939, 26967, 26979,

  7367     26994, {f: 2, c: 27007}, 27046, 27053, 27063, {f: 2, c: 27094}, 27137,

  7368     27151, 27157, 27176, 27188, 27198, 27205, {f: 2, c: 27216}, 27222, 27227,

  7369     27267, 27273, 27281, {f: 3, c: 27293}, 27356, 27367, 27372, 27422, 27428,

  7370     27445, 27462, 27478, 27488, 27522, 27582, 27617, 27633, 27664, 27699,

  7371     [11937, 27701], 11938, 27737, 27766, 27771, 27781, 27797, 27804, 27856,

  7372     27860, 27862, 27872, {f: 2, c: 27883}, 27886, 27914, 27918, 27921, 27950,

  7373     27991, 27998, 28005, 28034, 28095, 28100, 28106, 28118, 28137, 28194,

  7374     28241, 28359, 28362, 28366, 28413, 28442, 28458, 28463, 28467, 28506,

  7375     28510, 28514, 28541, 28555, 28557, 28562, 28564, 28570, {f: 2, c: 28583},

  7376     28598, 28634, 28638, 0, 28729, 28732, 0, 28756, {f: 2, c: 28765}, 28772,

  7377     [11939, 28780], 28798, 28801, 28821, 28855, {f: 2, c: 28883}, 28888, 28892,

  7378     28935, 28960, 28977, 29002, 29010, 29024, 29049, 29074, 0, 29131, 29139,

  7379     29142, 29184, 29213, 29227, 29240, 29249, 29267, {f: 2, c: 29269}, 29276,

  7380     29325, [11944, 29357], 29364, 29383, 29435, {f: 2, c: 29444}, 29480, 29489,

  7381     29507, 29548, 29564, 29571, {f: 2, c: 29573}, 29589, {f: 3, c: 29598},

  7382     29606, 29611, 29621, 29623, 29628, 29647, 29657, 29673, 29684, 29693,

  7383     29700, 29706, {f: 2, c: 29722}, 29732, 29736, 29740, {f: 3, c: 29743},

  7384     29753, 29764, 29767, 29771, 29773, 29777, 29783, 29798, 29803, 29809,

  7385     29824, {f: 3, c: 29829}, 29840, 29848, 29852, 29856, 29859, 29864, 29867,

  7386     29877, 29887, 29896, 29914, 29918, 30030, 30073, 30081, 30096,

  7387     [12135, 30098], 30099, 30132, 30180, 30201, 30208, 30218, {f: 2, c: 30229},

  7388     30233, 30238, 30253, 30261, 30275, 30283, 30309, 30317, 30319, 30321,

  7389     30324, {f: 2, c: 30372}, 30405, 30412, 30444, 30460, 30516, 30518, 30556,

  7390     {f: 2, c: 30559}, 30578, 30589, 30613, 30634, 30694, 30704, 30708, 30726,

  7391     30754, {f: 2, c: 30765}, 30768, 30773, 30824, 30878, 30920, 30924, 30926,

  7392     30948, {f: 2, c: 30944}, 30962, 30967, 30971, 31025, 0, [11949, 31035],

  7393     31037, 31045, {f: 2, c: 31067}, 31115, 31126, 31128, [12145, 31160], 31163,

  7394     31178, 31194, 31235, 31241, 31249, 31262, 31277, 31289, 31301, 31308,

  7395     31325, 0, 31341, 31352, 31392, 31395, 31411, {f: 2, c: 31419}, 31430,

  7396     31495, 31508, 31527, 31537, 31559, 31566, 31584, 31593, 31597, 31602,

  7397     31633, 31663, 31703, 31705, 31755, 31759, 31776, 31782, 31793, 31798,

  7398     31825, 31833, 31847, 31854, 31856, 31932, 31935, {f: 2, c: 31944}, 31959,

  7399     31961, 31965, 31979, {f: 3, c: 32007}, 32019, 32029, 32035, 32065, 32083,

  7400     32089, 32093, 32122, 32134, {f: 2, c: 32139}, 32204, 32235, 32241, 32249,

  7401     32264, 32273, 32277, 32288, 32327, 32354, 32366, 32371, 32397, 32401,

  7402     32408, 32580, 32591, [11947, 11954, 32594], [11953, 32595], 32609, 32657,

  7403     32703, 32718, 32735, 32741, 32748, {f: 2, c: 32750}, 32762, 32782, 32785,

  7404     32788, 32804, 32806, 32826, 32828, 32864, 32881, 32885, 32926, 32934,

  7405     32939, {f: 2, c: 32983}, 33046, 33048, 33082, 33098, 33100, 33153, 33156,

  7406     33204, 33231, 33273, 33283, 33313, 33330, 33332, 33350, 33355, 33359,

  7407     33422, 33454, 33463, 33470, 33478, 33534, 33603, 33617, 33621, 33670,

  7408     33677, 33682, 33688, 33705, {f: 2, c: 33727}, 33770, 33807, 33809, 33866,

  7409     33910, 33960, 33967, 33984, 33986, 34032, 34045, 34060, 34100, 34142,

  7410     34191, 34231, 34254, 34221, 34322, 34345, 34386, 34403, 34412, 34415,

  7411     34426, 34445, 34449, 34456, {f: 2, c: 34471}, 34554, 34557, 34571, 34579,

  7412     34585, 34590, 34600, 34622, 34673, 34696, 34713, {f: 2, c: 34732}, 34741,

  7413     34774, 34795, 34797, 34817, 0, 34822, 34827, 34836, 34844, 34902, 34911,

  7414     [11970, 34916], 34968, 34986, {f: 2, c: 35005}, 35018, 35026, 35035,

  7415     {f: 2, c: 35056}, 35078, {f: 3, c: 35096}, 35111, 35120, 35134, 35195,

  7416     35284, 35286, 35301, 35313, 35335, 35343, 35349, 35362, 35406, 35455,

  7417     35572, 35615, 35639, {f: 2, c: 35651}, 35668, 35740, 35742, 35911, 35924,

  7418     35955, 36004, 36057, 36065, 36088, 36094, 36123, 36201, 36204, 36228,

  7419     36237, 36245, 36262, 36294, 36302, 36324, 36332, 36384, 36427, 36460,

  7420     36464, 36474, 36498, 36526, 36531, 36561, 36564, 36601, 36631, 36662,

  7421     36774, [12193, 36789], [11981, 36790], 0, 36832, 36836, 36854, 36866,

  7422     36908, 36932, 37000, 37013, 37017, 37019, 37026, 37044, 37079, 37085,

  7423     37108, 37143, 37148, 37169, 37178, 37181, 37192, 37211, 37217, 37220,

  7424     37262, 37278, 37288, {f: 2, c: 37293}, 37298, 37308, 37360, 37367, 37371,

  7425     37383, 37416, 37427, 37432, 37443, 37447, 37455, 37472, 37570,

  7426     {f: 2, c: 37579}, 37599, 37645, 37653, 37663, 37671, 37703, 37714, 0,

  7427     37738, 37741, 37787, 37818, 37801, 37825, 37834, 37858, 37882, 37885,

  7428     37903, 37940, 37951, 37973, 37995, 38002, [11986, 38264], 38310, 38313, 0,

  7429     38324, 38333, 38362, [11983, 11990, 38429], 38465, 38488, 38532, 38564,

  7430     38569, 38610, 195060, 38622, 38633, 38641, 38658, 38665, 38746, 38755,

  7431     38766, 38771, 38810, 38818, {f: 2, c: 38837}, 38873, 38878, 38900, 38922,

  7432     38926, 38942, 38947, 38955, 38974, {f: 2, c: 38994}, 39001, 39020, 39096,

  7433     39098, 39103, 39112, 39141, {f: 2, c: 39218}, 39232, 39245, 39260, 39263,

  7434     39345, {f: 2, c: 39353}, 39369, 39426, 39446, 39460, 39463,

  7435     {f: 2, c: 39469}, 39478, 39480, 39498, 39510, {f: 2, c: 39605}, 39673,

  7436     39683, 39712, {f: 2, c: 39731}, 39795, 39801, 39847, 39873, 39879, 39895,

  7437     39911, 39915, 39927, 39930, 39933, 39947, 39975, 39978, 39990, 40001,

  7438     40019, 40035, 40048, 40055, 40194, 40258, 40263, 40291, 40297, 40316,

  7439     40318, 40333, 40369, 40387, 40391, 40406, 40415, 40427, 40436, 40469,

  7440     40477, 40612, 40616, 40620, 40679, 40686, 40720, 40722, 40727, 40729,

  7441     40751, 40759, 40761, 40769, 40773, 40791, 40808, 40817, 40821, 40848,

  7442     40852, 40866, 0, 13317, 194564, 22048, 24267, 11925, 0, 144954, 0, 28665,

  7443     28390, 29107, [11940, 64073], {s: 4}, [11980, 64102], 0, 23986, 0, 20435,

  7444     20697, 20720, 20931, 22134, 27220, 27905, 28112, 28226, 28377, 29668,

  7445     29729, 30060, 30801, 34805, 144382, 29608, 15091, 13531, 17420, 16010, 0,

  7446     0, 19432, 0, 16090, 15138, 0, 17786, 16531, 0, 18021, 16643, 17043, 18094,

  7447     13448, 140809, {f: 3, c: 63584}, 63610, 63615, {s: 23}, {f: 2, c: 8836},

  7448     {f: 2, c: 8842}, 8713, 0, {f: 2, c: 8965}, {s: 9}, {f: 2, c: 8741},

  7449     {s: 14}, 8802, 0, 8773, 8776, {f: 2, c: 8822}, {s: 4}, 8487, {s: 209},

  7450     {f: 2, c: 8922}, 8533, 8984, {f: 2, c: 7742}, {f: 2, c: 504}, 470, 472,

  7451     474, 476, 260, 728, 317, 346, 350, 356, 377, 379, 261, 731, 318, 347, 711,

  7452     351, 357, 378, 733, 380, 340, 258, 313, 262, 268, 280, 270, 323, 327, 336,

  7453     344, 368, 354, 341, 259, 314, 263, 269, 281, 271, 273, 324, 328, 337, 345,

  7454     369, 355, 729, 264, 284, 292, 308, 348, 364, 265, 285, 293, 309, 349, 365,

  7455     625, 651, 638, 620, 622, 633, 648, 598, 627, 637, 642, 656, 635, 621, 607,

  7456     626, 669, 654, 609, 624, 641, 295, 661, 660, 614, 664, 450, 595, 599, 644,

  7457     608, 403, 616, 649, 600, 604, 606, 592, 623, 650, 612, 594, 653, 613, 674,

  7458     673, 597, 657, 634, 615, 865, 712, 716, 721, 8255, 783, {f: 5, c: 741}, 0,

  7459     0, 805, 812, 825, 796, {f: 2, c: 799}, 829, 809, 815, 734, 804, 816, 828,

  7460     820, {f: 2, c: 797}, {f: 2, c: 792}, 810, {f: 2, c: 826}, 794, {s: 3},

  7461     {f: 2, c: 610}, 618, 628, 630, 632, 640, 655, 665, 668, 671, 688, 690, 695,

  7462     704, {f: 2, c: 736}, {s: 6}, 8862, {s: 287}, 12348, 12543, 0,

  7463     {f: 2, c: 12310}, 9838, 9835, {f: 2, c: 10548}, 10687, 0, 12448, 0,

  7464     {f: 2, c: 10746}, {s: 13}, 962, {f: 10, c: 9461}, {f: 2, c: 9750}, 9649,

  7465     {f: 10, c: 12784}, 0, {f: 6, c: 12794}, {f: 15, c: 9150}, 0, 0, 10003, 0,

  7466     9251, 9166, {f: 4, c: 9680}, {f: 2, c: 8263}, 0, 8273, 8258,

  7467     {f: 16, c: 12688}, {s: 13}, {f: 2, c: 9136}, {f: 12, c: 9842},

  7468     {f: 2, c: 12441}, 8413, {s: 450}, 20296, 20319, 20330, 20332, 20494, 20504,

  7469     20545, 20722, 20688, 20742, 20739, 20789, 20821, 20823, 13493, 20938,

  7470     20962, 21079, 21196, 21206, 21243, 21276, 21347, 21405, 21522, 21631,

  7471     21640, 21840, 21889, 21933, 21966, 22075, 22174, 22185, 22195, 22391,

  7472     22396, 135963, 22479, 22500, 22628, 22665, 136302, 22738, 22752, 34369,

  7473     22923, 22930, 22979, 23059, 23143, 23159, 23172, 23236, 137405, 23421,

  7474     23443, 23570, 64060, 136884, 23674, 23695, 23711, 23715, 23722, 23760,

  7475     138804, 23821, 23879, 23937, 23972, 23975, 24011, 24158, 24313, 24320,

  7476     24322, 24355, 24381, 24404, 24445, 24589, 24596, 24600, 24629, 24647,

  7477     24733, 24788, 24797, 24875, 25020, 25017, 25122, 25178, 25199, 25302,

  7478     25468, 25573, 25721, 25796, 25808, 25897, 26013, 26170, 26146, 26155,

  7479     26160, 26163, 26184, 143812, {f: 2, c: 26231}, 26253, 26299, 26331, 26344,

  7480     26439, 26497, 26515, 26520, 26523, 26620, 26653, 26787, 26890, 26953,

  7481     144836, 26946, 26980, 27045, 27087, 15286, 15299, 27113, 27125, 145215,

  7482     27195, 145251, 27284, 27301, 15375, 27419, 27436, 27495, 27561, 27565,

  7483     27607, 27647, 27653, 27764, 27800, 27899, 27846, 27953, 27961, 27967,

  7484     27992, 28052, 28074, 28123, 28125, 28228, 28254, 28337, 28353, 28432,

  7485     28505, 28513, 28542, 28556, 28576, 28604, 28615, 28618, 28656, 28750,

  7486     28789, 28836, 28900, 28971, 28958, 28974, 29009, 29032, 29061, 29063,

  7487     29114, 29124, 29205, 15935, 29339, 149489, 29479, 29520, 29542, 29602,

  7488     29739, 29766, 29794, 29805, 29862, 29865, 29897, 29951, 29975, 16242,

  7489     30158, 30210, 30216, 30308, 30337, 30365, 30378, 30390, 30414, 30420,

  7490     30438, 30449, 30474, 30489, {f: 2, c: 30541}, 30586, 30592, 30612, 30688,

  7491     152718, 30787, 30830, 30896, 152846, 30893, 30976, 31004, 31022, 31028,

  7492     31046, 31097, 31176, 153457, 31188, 31198, 31211, 31213, 31365, 154052,

  7493     31438, 31485, 31506, 31533, 31547, 31599, 31745, 31795, 155041, 31853,

  7494     31865, 31887, 31892, 31904, 31957, 32049, 32092, 32131, 32166, 32194,

  7495     32296, 32663, 32731, 32821, 32823, 32970, 32992, 33011, 33120,

  7496     {f: 2, c: 33127}, 33133, 33211, 33226, 33239, 17499, 33376, 33396, 158463,

  7497     33441, {f: 2, c: 33443}, 33449, 33471, 33493, 33533, 33536, 33570, 33581,

  7498     33594, 33607, 33661, 33703, 33743, 33745, 33761, 33793, 33798, 33887,

  7499     33904, 33907, 33925, 33950, 33978, 159296, 34098, 34078, 34095, 34148,

  7500     34170, 34188, 34210, 34251, 34285, 34303, {f: 2, c: 34308}, 34320, 159988,

  7501     34328, 34360, 34391, 34402, 17821, 34421, 34488, 34556, 34695, 17898,

  7502     34826, 34832, 35022, 161412, 35122, 35129, 35136, 35220, 35318, 35399,

  7503     35421, 35425, 35445, 35536, 35654, 35673, 35689, 35741, 35913, 35944,

  7504     36271, 36305, 36311, 36387, 36413, 36475, 164471, 18500, 36602, 36638,

  7505     36653, 36692, 164813, 36840, 36846, 36872, 36909, 37015, 37043, 37054,

  7506     {f: 2, c: 37060}, 37063, 37103, 37140, 37142, {f: 2, c: 37154}, 37167,

  7507     37172, 37251, 37361, 37705, {f: 2, c: 37732}, 37795, 37855, 37892, 37939,

  7508     37962, 37987, 38001, 38286, 38303, 38316, 38326, 38347, 38352, 38355,

  7509     18864, 38366, 38565, 38639, 38734, 38805, 38830, 38842, 38849, 38857,

  7510     38875, 38998, 39143, 39256, 39427, 39617, 39619, 39630, 39638, 39682,

  7511     39688, 19479, 39725, 39774, 39782, 39812, 39818, 39838, 39886, 39909,

  7512     39928, 39971, {f: 2, c: 40015}, 40037, {f: 2, c: 40221}, 40259, 40274,

  7513     40330, 40342, 40384, 40364, 40380, 172432, 40423, 40455, 40606, 40623,

  7514     40855, 131209, 19970, 19983, 19986, 20009, 20014, 20039, 131234, 20049,

  7515     13318, 131236, 20073, 20125, 13356, 20156, 20163, 20168, 20203, 20186,

  7516     20209, 20213, 20246, 20324, 20279, 20286, 20312, 131603, {f: 2, c: 20343},

  7517     20354, 20357, 20454, 20402, 20421, 20427, 20434, 13418, 20466, 20499,

  7518     20508, 20558, 20563, 20579, 20643, 20616, {f: 2, c: 20626}, 20629, 20650,

  7519     131883, 20657, {f: 2, c: 20666}, 20676, 20679, 20723, 131969, 20686,

  7520     131953, 20692, 20705, 13458, 132089, 20759, 132170, 20832, 132361, 20851,

  7521     20867, 20875, 13500, 20888, 20899, 20909, 13511, 132566, 20979, 21010,

  7522     21014, 132943, 21077, 21084, 21100, 21111, 21124, 21122, 133127, 21144,

  7523     133178, 21156, {f: 2, c: 21178}, 21194, 21201, 133305, 21239, 21301, 21314,

  7524     133500, 133533, 21351, 21370, 21412, 21428, 133843, 21431, 21440, 133917,

  7525     {f: 2, c: 13661}, 21461, 13667, 21492, 21540, 21544, 13678, 21571, 21602,

  7526     21612, 21653, 21664, 21670, 21678, 21687, 21690, 21699, 134469, 21740,

  7527     21743, 21745, 21747, {f: 2, c: 21760}, 21769, 21820, 21825, 13734, 21831,

  7528     13736, 21860, 134625, 21885, 21890, 21905, 13765, 21970, 134805, 134765,

  7529     21951, 21961, 21964, 21969, 21981, 13786, 21986, 134756, 21993, 22056,

  7530     135007, 22023, 22032, 22064, 13812, 22077, 22080, 22087, 22110, 22112,

  7531     22125, 13829, 22152, 22156, 22173, 22184, 22194, 22213, 22221, 22239,

  7532     22248, {f: 2, c: 22262}, 135681, 135765, 22313, 135803, {f: 2, c: 22341},

  7533     22349, 135796, 22376, 22383, {f: 3, c: 22387}, 22395, 135908, 135895,

  7534     22426, {f: 2, c: 22429}, 22440, 22487, 135933, 22476, 135990, 136004,

  7535     22494, 22512, 13898, 22520, 22523, 22525, 22532, 22558, 22567, 22585,

  7536     136132, 22601, 22604, 22631, {f: 2, c: 22666}, 22669, {f: 2, c: 22671},

  7537     22676, 22685, 22698, 22705, 136301, 22723, 22733, 22754, {f: 2, c: 22771},

  7538     {f: 2, c: 22789}, 22797, 22804, 136663, 13969, 22845, 13977, 22854, 13974,

  7539     158761, 22879, 136775, {f: 2, c: 22901}, 22908, 22943, 22958, 22972, 22984,

  7540     22989, 23006, 23015, 23022, 136966, 137026, 14031, 23053, 23063, 23079,

  7541     23085, 23141, 23162, 23179, 23196, {f: 2, c: 23199}, 23202, 23217, 23221,

  7542     23226, 23231, 23258, 23260, 23269, 23280, 23278, 23285, 23304, 23319,

  7543     23348, 23372, 23378, 23400, 23407, 23425, 23428, 137667, 23446, 23468,

  7544     {f: 2, c: 14177}, 23502, 23510, 14188, 14187, 23537, 23549, 14197, 23555,

  7545     23593, 138326, 23647, {f: 2, c: 23655}, 23664, 138541, 138565, 138616,

  7546     138594, 23688, 23690, 14273, 138657, 138652, 23712, 23714, 23719, 138642,

  7547     23725, 23733, 138679, 23753, 138720, 138803, 23814, 23824, 23851, 23837,

  7548     23840, 23857, 23865, 14312, 23905, 23914, 14324, 23920, 139038, 14333,

  7549     23944, 14336, 23959, 23984, 23988, 139126, 24017, 24023, 139258, 24036,

  7550     24041, 14383, 14390, 14400, 24095, 24126, 24137, 14428, 24150, 14433,

  7551     {f: 2, c: 24173}, 139643, 24229, 24236, 24249, 24262, 24281, 140062, 24317,

  7552     24328, 140205, 24350, 24391, 24419, 24434, 24446, 24463, 24482, 24519,

  7553     24523, {f: 3, c: 24530}, 24546, {f: 2, c: 24558}, 24563, 14615, 24610,

  7554     24612, 14618, 24652, 24725, 24744, 141043, 24753, 24766, 24776, 24793,

  7555     24814, 24821, 24848, 24857, 24862, 24890, 14703, 24897, 24902, 24928,

  7556     141403, {f: 2, c: 24978}, 24983, 24997, 25005, 141483, 25045, 25053, 25077,

  7557     141711, 25123, 25170, 25185, 25188, 25211, 25197, 25203, 25241, 25301,

  7558     142008, 25341, 25347, 25360, {f: 2, c: 142159}, 25394, 25397,

  7559     {f: 2, c: 25403}, 25409, 25412, 25422, 142150, 25433, 142365, 142246,

  7560     25452, 25497, 142372, 25492, 25533, {f: 2, c: 25556}, 25568,

  7561     {f: 2, c: 25579}, 25586, 25630, 25637, 25641, 25647, 25690, 25693, 25715,

  7562     25725, 25735, 25745, 25759, {f: 2, c: 25803}, 25813, 25815, 142817, 25828,

  7563     25855, 14958, 25871, 25876, 14963, 25886, 25906, 25924, 25940, 25963,

  7564     25978, 25988, 25994, 26034, 26037, 26040, 26047, 26057, 26068, 15062,

  7565     26105, 26108, 26116, 26120, 26145, 26154, 26181, 26193, 26190, 15082,

  7566     143811, 143861, 143798, 26218, {f: 2, c: 26220}, 26235, 26240, 26256,

  7567     26258, 15118, 26285, 26289, 26293, 15130, 15132, 15063, 26369, 26386,

  7568     144242, 26393, 144339, 144338, 26445, 26452, 26461, 144336, 144356, 144341,

  7569     26484, 144346, 26514, 144351, 33635, 26640, 26563, 26568, 26578, 26587,

  7570     26615, 144458, 144465, 144459, 26648, 26655, 26669, 144485, 26675, 26683,

  7571     26686, 26693, 26697, 26700, 26709, 26711, 15223, 26731, 26734, 26748,

  7572     26754, 26768, 26774, 15213, {f: 3, c: 26776}, 26780, {f: 2, c: 26794},

  7573     26804, 26811, 26875, 144612, 144730, 26819, 26821, 26828, 26841,

  7574     {f: 2, c: 26852}, 26860, 26871, 26883, 26887, 15239, 144788, 15245, 26950,

  7575     26985, 26988, 27002, 27026, 15268, 27030, 27056, 27066, 27068, 27072,

  7576     27089, 144953, 144967, 144952, 27107, {f: 2, c: 27118}, 27123, 15309,

  7577     27124, 27134, 27153, 27162, 27165, 145180, {f: 2, c: 27186}, 27199, 27209,

  7578     27258, 27214, 27218, 27236, 145164, 27275, 15344, 27297, 145252, 27307,

  7579     27325, 27334, 27348, 27344, 27357, 145407, 145383, {f: 3, c: 27377}, 27389,

  7580     145444, 27403, {f: 3, c: 27407}, 145469, 27415, 15398, 27439, 27466, 27480,

  7581     27500, 27509, [11934, 27514], 27521, 27547, 27566, 146072, 27581,

  7582     {f: 3, c: 27591}, 27610, {f: 2, c: 27622}, 27630, 27650, 27658, 27662,

  7583     27702, 146559, 27725, 27739, 27757, 27780, 27785, 15555, 27796, 27799,

  7584     27821, 27842, 15570, 27868, 27881, 27885, 146688, 27904, 27940,

  7585     {f: 2, c: 27942}, 27751, 27951, 27964, 27995, 28000, 28016,

  7586     {f: 2, c: 28032}, 28042, 28045, 28049, 28056, 146752, 146938, 146937,

  7587     146899, 28075, 28078, 28084, 28098, 27956, 28104, 28110, 28127, 28150,

  7588     28214, 28190, 15633, 28210, {f: 2, c: 28232}, {f: 2, c: 28235}, 28239,

  7589     {f: 2, c: 28243}, 28247, 28259, 15646, 28307, 28327, 28340, 28355, 28469,

  7590     28395, 28409, 28411, 28426, 28428, 28440, 28453, 28470, 28476, 147326,

  7591     28498, 28503, 28512, 28520, 28560, 28566, 28606, 28575, 28581, 28591,

  7592     15716, {f: 2, c: 28616}, 28649, 147606, 28668, 28672, 28682, 28707, 147715,

  7593     28730, 28739, 28743, 28747, 15770, 28773, 28777, 28782, 28790, 28806,

  7594     28823, 147910, 28831, 28849, 147966, 28908, 28874, 28881, 28931, 28934,

  7595     28936, 28940, 15808, 28975, 29008, 29011, 29022, 15828, 29078, 29056,

  7596     29083, 29088, 29090, {f: 2, c: 29102}, 148412, 29145, 29148, 29191, 15877,

  7597     29236, 29241, 29250, 29271, 29283, 149033, {f: 2, c: 29294}, 29304, 29311,

  7598     29326, 149157, 29358, 29360, 29377, 15968, 29388, 15974, 15976, 29427,

  7599     29434, 29447, 29458, {f: 2, c: 29464}, 16003, 29497, 29484, 29491, 29501,

  7600     29522, 16020, 29547, 149654, {f: 2, c: 29550}, 29553, 29569, 29578, 29588,

  7601     29592, 29596, 29605, 29625, 29631, 29637, 29643, 29665, 29671, 29689,

  7602     29715, 29690, 29697, 29779, 29760, 29763, 29778, 29789, 29825, 29832,

  7603     150093, 29842, 29847, 29849, 29857, 29861, 29866, 29881, 29883, 29882,

  7604     29910, 29912, 29931, 150358, 29946, 150383, 29984, 29988, 29994, 16215,

  7605     150550, {f: 2, c: 30013}, 30016, 30024, 30032, 30034, 30066, 30065, 30074,

  7606     {f: 2, c: 30077}, 30092, 16245, 30114, 16247, 30128, 30135,

  7607     {f: 2, c: 30143}, 30150, 30159, 30163, 30173, {f: 2, c: 30175}, 30183,

  7608     30190, 30193, 30211, 30232, 30215, 30223, 16302, 151054, 30227,

  7609     {f: 2, c: 30235}, 151095, 30245, 30248, 30268, 30259, 151146, 16329, 30273,

  7610     151179, 30281, 30293, 16343, 30318, 30357, 30369, 30368, {f: 2, c: 30375},

  7611     30383, 151626, 30409, 151637, 30440, 151842, 30487, 30490, 30509, 30517,

  7612     151977, 16441, 152037, 152013, 30552, 152094, 30588, 152140, 16472, 30618,

  7613     30623, 30626, 30628, {f: 2, c: 30686}, 30692, 30698, 30700, 30715, 152622,

  7614     30725, 30729, 30733, 30745, 30764, 30791, 30826, 152793, 30858, 30868,

  7615     30884, 30877, 30879, 30907, 30933, 30950, {f: 2, c: 30969}, 30974, 152999,

  7616     30992, 31003, 31013, 31050, 31064, 16645, 31079, 31090, 31125, 31137,

  7617     31145, 31156, 31170, 31175, {f: 2, c: 31180}, 31190, 16712, 153513, 153524,

  7618     16719, 31242, 31253, 31259, 16739, 31288, 31303, 31318, 31321, 31324,

  7619     31327, 31335, 31338, 31349, 31362, 31370, 31376, 31404, 154068, 16820,

  7620     31417, 31422, 16831, 31436, 31464, 31476, 154340, 154339, 154353, 31549,

  7621     31530, {f: 2, c: 31534}, 16870, 16883, 31615, 31553, 16878, 31573, 31609,

  7622     31588, 31590, 31603, 154546, 16903, 31632, 31643, 16910, 31669, 31676,

  7623     31685, 31690, 154699, 154724, 31700, 31702, 31706, 31722, 31728, 31747,

  7624     31758, 31813, 31818, 31831, 31838, 31841, 31849, 31855, 155182, 155222,

  7625     155237, 31910, 155234, {f: 2, c: 31926}, 155352, 31940, 155330, 31949,

  7626     155368, 155427, 31974, 155484, 31989, 32003, 17094, 32018, 32030, 155616,

  7627     155604, {f: 2, c: 32061}, 32064, 32071, 155660, 155643, 17110, 32090,

  7628     32106, 32112, 17117, 32127, 155671, 32136, 32151, 155744, 32157, 32167,

  7629     32170, 32182, 32192, 32215, 32217, 32230, 17154, 155885, 64088, 32272,

  7630     32279, 32285, 32295, 32300, 32325, 32373, 32382, {f: 2, c: 32390}, 17195,

  7631     32410, 17219, 32572, 32571, 32574, 32579, 13505, 156272, 156294,

  7632     {f: 2, c: 32611}, 32621, {f: 2, c: 32637}, 32656, 20859, 146702, 32662,

  7633     32668, 32685, 156674, 32707, 32719, 32739, 32754, 32778, 32776, 32790,

  7634     32812, 32816, 32835, 32870, 32891, 32921, 32924, 32932, 32935, 32952,

  7635     157310, 32965, 32981, 32998, 33037, 33013, 33019, 17390, 33077, 33054,

  7636     17392, 33060, 33063, 33068, 157469, 33085, 17416, 33129, 17431, 17436,

  7637     33157, 17442, 33176, 33202, 33217, 33219, 33238, 33243, 157917, 33252,

  7638     157930, 33260, 33277, 33279, 158063, 33284, 158173, 33305, 33314, 158238,

  7639     33340, 33353, 33349, 158296, 17526, 17530, 33367, 158348, 33372, 33379,

  7640     158391, 17553, 33405, 33407, 33411, 33418, 33427, {f: 2, c: 33447}, 33458,

  7641     33460, 33466, 33468, 33506, 33512, 33527, {f: 2, c: 33543}, 33548, 33620,

  7642     33563, 33565, 33584, 33596, 33604, 33623, 17598, 17620, 17587,

  7643     {f: 2, c: 33684}, 33691, 33693, 33737, 33744, 33748, 33757, 33765, 33785,

  7644     33813, 158835, 33815, 33849, 33871, {f: 2, c: 33873}, {f: 2, c: 33881},

  7645     33884, 158941, 33893, 33912, 33916, 33921, 17677, 33943, 33958, 33982,

  7646     17672, {f: 2, c: 33998}, 34003, 159333, 34023, 34026, 34031, 34033, 34042,

  7647     34075, {f: 2, c: 34084}, 34091, 34127, 34159, 17731, 34129,

  7648     {f: 2, c: 34145}, 159636, 34171, 34173, 34175, 34177, 34182, 34195, 34205,

  7649     34207, 159736, {f: 2, c: 159734}, 34236, 34247, 34250, {f: 2, c: 34264},

  7650     34271, 34273, 34278, 34294, 34304, 34321, 34334, 34337, 34340, 34343,

  7651     160013, 34361, 34364, 160057, 34368, 34387, 34390, 34423, 34439, 34441,

  7652     {f: 2, c: 34460}, 34481, 34483, 34497, 34499, 34513, 34517, 34519, 34531,

  7653     34534, 17848, 34565, 34567, 34574, 34576, 34591, 34593, 34595, 34609,

  7654     34618, 34624, 34627, 34641, 34648, {f: 2, c: 34660}, 34674, 34684, 160731,

  7655     160730, 34727, 34697, 34699, 34707, 34720, 160766, 17893, 34750, 160784,

  7656     34753, 34766, 34783, 160841, 34787, {f: 2, c: 34789}, 34794, 34835, 34856,

  7657     34862, 34866, 34876, 17935, 34890, 34904, 161301, 161300, 34921, 161329,

  7658     34927, 34976, 35004, 35008, 161427, 35025, 35027, 17985, 35073, 161550,

  7659     35127, 161571, 35138, 35141, 35145, 161618, 35170, 35209, 35216, 35231,

  7660     35248, 35255, 35288, 35307, 18081, 35315, 35325, 35327, 18095, 35345,

  7661     35348, 162181, 35361, 35381, 35390, 35397, 35405, 35416, 35502, 35472,

  7662     35511, 35543, 35580, 162436, 35594, 35589, 35597, 35612, 35629, 18188,

  7663     35665, 35678, 35702, 35713, 35723, {f: 2, c: 35732}, 35897, 162739, 35901,

  7664     162750, 162759, 35909, 35919, 35927, 35945, 35949, 163000, 35987, 35986,

  7665     35993, 18276, 35995, 36054, 36053, 163232, 36081, 163344, 36105, 36110,

  7666     36296, 36313, 36364, 18429, 36349, 36358, 163978, 36372, 36374,

  7667     {f: 2, c: 36385}, 36391, 164027, 18454, 36406, 36409, 36436, 36450, 36461,

  7668     36463, 36504, 36510, 36533, 36539, 164482, 18510, 164595, 36608, 36616,

  7669     36651, 36672, 36682, 36696, 164876, 36772, 36788, 164949, 36801, 36806,

  7670     64036, 36810, 36813, 36819, 36821, 36849, 36853, 36859, 36876, 36919,

  7671     165227, 36931, 36957, {f: 2, c: 165320}, 36997, 37004, 37008, 37025, 18613,

  7672     37040, 37046, 37059, 37064, 165591, 37084, 37087, 165626, 37110, 37106,

  7673     37120, 37099, {f: 2, c: 37118}, 37124, 37126, 37144, 37150, 37175, 37177,

  7674     {f: 2, c: 37190}, 37207, 37209, 37236, 37241, 37253, 37299, 37302,

  7675     {f: 2, c: 37315}, 166217, 166214, 37356, 37377, {f: 2, c: 37398}, 166251,

  7676     37442, 37450, 37462, 37473, 37477, 37480, 166280, {f: 2, c: 37500}, 37503,

  7677     37513, 37517, 37527, 37529, 37535, 37547, {f: 2, c: 166330}, 37554,

  7678     {f: 2, c: 37567}, 37574, 37582, 37605, 37649, 166430, 166441, 37623, 37673,

  7679     166513, 166467, 37713, 37722, 37739, 37745, 37747, 37793, 166553, 166605,

  7680     37768, 37771, 37775, 37790, 37877, 166628, 166621, 37873, 37831, 37852,

  7681     37863, 37897, {f: 2, c: 37910}, 37883, 37938, 37947, 166849, 166895, 37997,

  7682     37999, 38265, 38278, {f: 2, c: 38284}, 167184, 167281, 38344, 167419,

  7683     167455, 38444, {f: 2, c: 38451}, 167478, 38460, 38497, 167561, 38530,

  7684     167659, 38554, 167730, 18919, 38579, 38586, 38589, 18938, 167928, 38616,

  7685     38618, 38621, 18948, 38676, 38691, 18985, 38710, 38721, 38727, 38743,

  7686     38747, 38762, 168608, 168625, 38806, 38814, {f: 2, c: 38833}, 38846, 38860,

  7687     38865, 38868, 38872, 38881, 38897, 38916, 38925, 38932, 38934, 19132,

  7688     169104, {f: 2, c: 38962}, 38949, 38983, 39014, 39083, 39085, 39088, 169423,

  7689     39095, {f: 2, c: 39099}, 39106, 39111, 39115, 39137, 39139, 39146,

  7690     {f: 2, c: 39152}, 39155, 39176, 19259, 169712, {f: 2, c: 39190}, 169753,

  7691     {f: 3, c: 39194}, 169808, 39217, {f: 3, c: 39226}, 39233, 39238, 39246,

  7692     39264, 39331, 39334, 39357, 39359, 39363, 39380, 39385, 39390, 170182,

  7693     39408, 39417, 39420, 39434, 39441, 39450, 39456, 39473, 39492, 39500,

  7694     39512, 19394, 39599, 19402, 39607, 19410, 39609, 170610, 39622, 39632,

  7695     39634, 39637, 39648, 39653, 39657, 39692, 39696, 39698, 39702, 39708,

  7696     39723, 39741, 19488, 39755, 39779, 39781, {f: 2, c: 39787},

  7697     {f: 2, c: 39798}, 39846, 39852, 171483, 39858, 39864, 39870, 39923, 39896,

  7698     39901, 39914, 39919, 39918, 171541, 171658, 171593, 39958,

  7699     {f: 3, c: 39960}, 39965, 39970, 39977, 171716, 39985, 39991, 40005, 40028,

  7700     171753, {f: 2, c: 40009}, 171739, 40020, 40024, 40027, 40029, 40031,

  7701     {f: 3, c: 40041}, {f: 2, c: 40045}, 40050, 40053, 40058, 40166, 40178,

  7702     40203, [171982, 171991], 40209, {f: 2, c: 40215}, 172079, 19652, 172058,

  7703     40242, 19665, 40266, 40287, 40290, 172281, 172162, 40307, {f: 2, c: 40310},

  7704     40324, 40345, 40353, 40383, 40373, 40377, 40381, 40393, 40410, 40416,

  7705     40419, 19719, 40458, 40450, 40461, 40476, 40571, 139800, 40576, 40581,

  7706     40603, 172940, 40637, 173111, 40671, 40703, 40706, 19831, 40707, 40762,

  7707     40765, 40774, 40787, 40789, 40792, 173553, 40797, 173570, 40809, 40813,

  7708     40816, 173746, 11948, 13844, 14509, 15820, 16348, 17854, 17936, 19326,

  7709     19512, 19681, 19980, {f: 2, c: 20003}, 20089, 20211, 20236, 20249, 20267,

  7710     20270, 20273, 20356, 20382, 20407, 20484, 20492, 20556, 20575, 20578,

  7711     20599, 20622, 20638, 20642, 20675, 20712, 20721, 20734, 20743,

  7712     {f: 3, c: 20748}, 20787, 20792, 20852, 20868, 20920, 20922, 20936, 20943,

  7713     20945, {f: 2, c: 20947}, 20952, 20959, 20997, 21030, 21032, 21035,

  7714     {f: 2, c: 21041}, 21045, 21052, 21082, 21088, 21102, {f: 2, c: 21112},

  7715     21130, 21132, 21217, 21225, 21233, 21251, 21265, 21279, 21293, 21298,

  7716     21309, 21349, 21357, 21369, 21374, 21396, 21401, 21418, 21423, 21434,

  7717     21441, {f: 2, c: 21444}, 21472, 21523, 21546, 21553, {f: 2, c: 21556},

  7718     21580, 21671, 21674, 21681, 21691, 21710, 21738, 21756, 21765, 21768,

  7719     21781, 21799, 21802, 21814, 21841, 21862, 21903, 21906, 21908, 21924,

  7720     21938, 21955, 21958, 21971, 21979, 21996, 21998, 22001, 22006, 22008,

  7721     22021, 22029, {f: 2, c: 22033}, 22060, 22069, 22073, 22093, 22100, 22149,

  7722     22175, 22182, 22199, 22220, 22223, 22233, 22241, 22251, 22253, 22257,

  7723     22279, 22284, {f: 2, c: 22298}, 22301, 22316, 22318, {f: 2, c: 22333},

  7724     22367, 22379, 22381, 22394, 22403, 22423, 22446, 22485, 22503, 22541,

  7725     22566, 22605, 22607, 22623, 22637, 22655, 22657, 22680, 22716, 22815,

  7726     22819, 22873, 22905, 22935, 22959, 22963, 23007, 23025, 23032, 23218,

  7727     23224, 23274, 23286, 23323, 23325, 23329, 23352, 23479, 23511, 23520,

  7728     23583, 23594, 23596, 23606, 23641, 23644, 23661, 23773, 23809, 23860,

  7729     23869, 23897, 23934, 23939, 24007, 24057, 24104, 24114, 24117, 24155,

  7730     24168, 24170, 24183, 24192, 24203, 24243, 24253, 24273, {f: 2, c: 24276},

  7731     24397, 24492, 24554, 24583, 24649, 24660, 24679, 24763, 24772, 24829,

  7732     24842, 24854, 24874, 24886, 24926, 24932, 24955, 24957, 24959, 24989,

  7733     25016, 25052, 25058, 25061, 25064, 25092, 25095, 25137, 25145, 25149,

  7734     25210, 25232, 25256, 25306, 25332, 25366, 25386, 25398, 25414, 25419,

  7735     25427, 25457, 25461, 25471, 25474, 25482, {f: 2, c: 25518}, 25578,

  7736     {f: 2, c: 25592}, 25618, 25624, 25632, 25636, 25642, 25653, 25661, 25663,

  7737     25682, 25695, 25716, 25744, {f: 2, c: 25752}, 25772, 25779, 25837, 25840,

  7738     25883, 25887, 25902, 25929, 25952, 26002, 26005, 26036, 26046, 26056,

  7739     26062, 26064, 26079, 26238, {f: 2, c: 26251}, 26291, 26304, 26319, 26405,

  7740     26421, 26453, 26496, 26511, 26513, 26532, 26545, 26549, 26558, 26664,

  7741     26758, 26859, 26869, 26903, 26931, 26936, 26971, 26981, 27048, 27051,

  7742     27055, 27109, 27121, 27210, 27221, 27239, 27249, 27311, {f: 2, c: 27336},

  7743     27395, 27451, 27455, {f: 2, c: 27517}, 27568, 27639, 27641, 27652, 27657,

  7744     27661, 27692, 27722, 27730, 27732, 27769, 27820, 27828, 27858, 28001,

  7745     28028, 28089, 28144, 28229, 28275, 28283, 28285, 28297, 28348,

  7746     {f: 2, c: 28378}, 28454, 28457, 28464, 28551, 28573, 28590, 28599, 28685,

  7747     28704, 28745, 28824, 28848, {f: 2, c: 28885}, 28997, 29106, 29172, 29207,

  7748     29215, 29251, {f: 2, c: 29263}, 29274, 29280, 29288, 29303, 29316, 29385,

  7749     29413, 29428, 29442, 29451, 29470, 29474, {f: 2, c: 29498}, 29517, 29528,

  7750     29543, 29810, 29871, 29919, 29924, 29940, 29947, 29974, 29985, 30015,

  7751     30046, 30105, 30116, 30145, 30148, 30156, 30167, 30172, 30177, 30191,

  7752     30212, 30220, 30237, 30258, 30264, 30277, 30282, 30303, 30381, 30397,

  7753     30425, 30443, 30448, 30457, 30464, 30478, 30498, 30504, 30511, 30521,

  7754     30526, 30533, 30538, 30543, 30558, 30564, 30567, 30572, 30596,

  7755     {f: 2, c: 30604}, 30614, 30631, 30639, 30647, 30654, 30665, 30673, 30681,

  7756     30705, 30775, 30812, 30846, 30872, 30881, 30897, 30899, 30921, 30931,

  7757     30988, 31007, {f: 2, c: 31015}, 31039, 31042, 31060, 31083, 31100, 31147,

  7758     31172, 31210, 31234, 31244, 31280, 31290, 31300, 31360, 31366, 31380,

  7759     31413, 31421, 31486, 31531, 31607, 31648, 31660, 31664, 31720, 31730,

  7760     31736, 31740, 31742, 31753, 31784, 31791, 31810, {f: 2, c: 31826},

  7761     {f: 3, c: 31835}, 31858, 31869, 31879, 31902, 31930, 31943, 31955, 31962,

  7762     32060, 32077, 32130, 32133, 32141, 32145, 32158, 32179, 32185, 32208,

  7763     32229, {f: 2, c: 32245}, 32303, 32310, 32324, 32367, 32376, 32385, 32573,

  7764     32603, 32605, 32613, 32625, {f: 2, c: 32639}, 32651, 32674,

  7765     {f: 3, c: 32765}, 32775, 32781, 32798, 32825, 32904, 32910, 32975, 32980,

  7766     33005, 33008, 33015, 33018, 33022, 33027, 33047, 33072, 33111, 33135,

  7767     33139, 33163, 33168, 33179, 33182, 33227, 33237, {f: 2, c: 33245}, 33249,

  7768     33263, 33270, 33280, 33291, {f: 2, c: 33299}, 33306, 33338, 33348, 33389,

  7769     33412, 33417, 33425, 33450, 33456, 33488, 33514, 33519, 33526, 33622,

  7770     33656, 33784, 33788, 33880, 33939, 33969, 33981, 34043, 34118, 34134,

  7771     34141, 34181, 34200, 34370, 34374, 34496, 34580, 34594, 34606, 34617,

  7772     34653, 34683, 34700, 34702, {f: 2, c: 34711}, 34718, 34723, 34734, 34751,

  7773     34761, 34778, 34840, 34843, 34861, 34874, 34885, 34891, 34894, 34901,

  7774     34906, 34926, {f: 3, c: 34970}, 35021, 35040, 35055, {f: 2, c: 35086},

  7775     35110, 35125, 35162, 35164, 35179, 35184, 35196, 35237, 35253, 35260,

  7776     35285, 35401, 35415, 35431, 35454, 35462, 35478, 35510, 35529, 35537,

  7777     35549, 35564, 35573, 35590, 35599, 35601, 35653, 35666, 35693, 35704,

  7778     35708, 35710, 35717, 35743, 35915, 35923, 35963, 36026, 36037, 36041,

  7779     36050, 36076, 36085, 36087, 36097, 36099, 36119, 36124, 36206, 36241,

  7780     36255, 36267, 36274, 36309, 36327, {f: 2, c: 36337}, 36340, 36353, 36363,

  7781     36390, 36401, {f: 2, c: 36416}, 36429, 36431, 36444, 36449, 36457, 36465,

  7782     36469, 36471, 36489, 36496, 36501, 36506, 36519, 36521, 36525, 36584,

  7783     36592, 36615, 36632, 36645, 36647, 36652, 36661, 36666, 36675, 36679,

  7784     36689, 36693, {f: 3, c: 36768}, 36773, 36868, 36891, 36911, 36940, 36955,

  7785     36976, 36980, 36985, 37003, 37016, 37024, 37042, 37053, 37065, 37104,

  7786     37125, 37157, 37210, 37223, 37242, 37258, 37265, 37269, 37296, 37307,

  7787     37309, 37314, 37317, 37376, 37385, 37411, 37494, 37518, 37551,

  7788     {f: 2, c: 37563}, 37569, 37571, 37573, 37576, 37652, 37683, 37686, 37720,

  7789     37759, 37762, 37770, 37819, 37836, 37862, 37881, 37890, {f: 2, c: 37901},

  7790     37934, 37964, 38280, 38305, 38335, 38342, 38345, {f: 2, c: 38353}, 38368,

  7791     38372, 38374, 38436, 38449, 38456, 38461, 38484, 38516, 38523, 38527,

  7792     38529, 38531, 38537, 38550, 38574, 38659, 38683, {f: 2, c: 38689}, 38696,

  7793     38705, 38759, 38774, 38781, 38783, 38809, 38815, 38828, 38841, 38861,

  7794     38880, 38895, 38919, 38950, 38958, {f: 2, c: 39010}, 39092, 39109, 39170,

  7795     39185, 39189, 39221, 39240, 39252, 39262, 39393, 39436, 39440, 39459,

  7796     39489, 39505, {f: 2, c: 39613}, 39681, 39689, 39691, {f: 2, c: 39693},

  7797     39705, 39733, 39752, 39765, 39784, 39808, 39814, 39824, 39837, 39856,

  7798     39871, 39880, 39935, 39938, 39964, 39989, 40004, 40022, 40033, 40040,

  7799     40240, 40253, 40298, 40315, 40421, 40425, 40435, 40570, {f: 3, c: 40578},

  7800     40624, 40676, 40688, 40690, 40713, 40719, 40724, 40731, 40738, 40742,

  7801     {f: 2, c: 40746}, 40756, 40794, 40815, 40862, 40869, 131317, 151044,

  7802     151538, 163187, 194581, 194630, 194713, 194726, 194789, 195038, 13790,

  7803     {s: 4}, 172722, 0, 0, 131416, {s: 4}, 132529, 0, 0, 132844, {s: 6}, 134488,

  7804     {s: 21}, 154060, {s: 9}, 14756, 14776, 142914, 0, 0, 14940, 0, 0, 143339,

  7805     0, 0, 162228, 0, 15044, 15051, {s: 5}, 14981, {s: 8}, 15347, 27384, {s: 5},

  7806     15665, {s: 9}, 147531, 0, 15936, 14497, {s: 34}, 158878, {s: 12}, 18207,

  7807     162876, {s: 4}, 18462, {s: 71}, 39709, 39724, 20482, 20958, 21255, 23532,

  7808     63784, 26142, 63785, 28746, 64021, 21857, 27706, 31328, 156492, 34819,

  7809     38315, 38741, 171581, 173594],

  7810   'Adobe-Korea1': [{f: 95, c: 32}, 8361, 8208, 169, 0, 0, [12288, 12644],

  7811     {f: 2, c: 12289}, 12539, 8229, [8230, 8943], 168, 12291, {f: 2, c: 8211},

  7812     8214, 65340, 65374, {f: 2, c: 8216}, {f: 2, c: 8220}, {f: 2, c: 12308},

  7813     {f: 10, c: 12296}, 177, 215, 247, 8800, {f: 2, c: 8804}, 8734, 8756, 176,

  7814     {f: 2, c: 8242}, 8451, 8491, {f: 2, c: 65504}, 65509, 9794, 9792, 8736,

  7815     8869, 8978, 8706, 8711, 8801, 8786, 167, 8251, 9734, 9733, 9675, 9679,

  7816     9678, 9671, 9670, 9633, 9632, 9651, 9650, 9661, 9660, 8594,

  7817     {f: 2, c: 8592}, {f: 2, c: 8595}, 12307, 171, 187, 8730, 8765, 8733, 8757,

  7818     {f: 2, c: 8747}, 8712, 8715, {f: 2, c: 8838}, {f: 2, c: 8834}, 8746, 8745,

  7819     {f: 2, c: 8743}, 65506, 8658, 8660, 8704, 8707, 180, 732, 711, 728, 733,

  7820     730, 729, 184, 731, 161, 191, 8758, 8750, 8721, 8719, 164, 8457, 8240,

  7821     9665, 9664, 9655, 9654, 9828, {f: 2, c: 9824}, 9829, 9831, 9827, 9673,

  7822     9672, 9635, {f: 2, c: 9680}, 9618, {f: 2, c: 9636}, 9640, 9639, 9638, 9641,

  7823     9832, 9743, 9742, 9756, 9758, 182, {f: 2, c: 8224}, 8597, 8599, 8601, 8598,

  7824     8600, 9837, {f: 2, c: 9833}, 9836, 12927, 12828, 8470, 13255, 8482, 13250,

  7825     13272, 8481, {f: 59, c: 65281}, 65510, {f: 33, c: 65341}, 65507,

  7826     {f: 51, c: 12593}, {f: 42, c: 12645}, {f: 10, c: 8560}, {f: 10, c: 8544},

  7827     {f: 17, c: 913}, {f: 7, c: 931}, {f: 17, c: 945}, {f: 7, c: 963}, 9472,

  7828     9474, 9484, 9488, 9496, 9492, 9500, 9516, 9508, 9524, 9532, 9473, 9475,

  7829     9487, 9491, 9499, 9495, 9507, 9523, 9515, 9531, 9547, 9504, 9519, 9512,

  7830     9527, 9535, 9501, 9520, 9509, 9528, 9538, 9490, 9489, 9498, 9497, 9494,

  7831     9493, 9486, 9485, {f: 2, c: 9502}, {f: 2, c: 9505}, {f: 2, c: 9510},

  7832     {f: 2, c: 9513}, {f: 2, c: 9517}, {f: 2, c: 9521}, {f: 2, c: 9525},

  7833     {f: 2, c: 9529}, {f: 2, c: 9533}, {f: 2, c: 9536}, {f: 8, c: 9539},

  7834     {f: 3, c: 13205}, 8467, 13208, 13252, {f: 4, c: 13219}, {f: 10, c: 13209},

  7835     13258, {f: 3, c: 13197}, 13263, {f: 2, c: 13192}, 13256, {f: 2, c: 13223},

  7836     {f: 10, c: 13232}, {f: 5, c: 13184}, {f: 6, c: 13242}, {f: 5, c: 13200},

  7837     8486, {f: 2, c: 13248}, {f: 3, c: 13194}, 13270, 13253, {f: 3, c: 13229},

  7838     13275, {f: 4, c: 13225}, 13277, 13264, 13267, 13251, 13257, 13276, 13254,

  7839     198, 208, 170, 294, 306, 319, 321, 216, 338, 186, 222, 358, 330,

  7840     {f: 28, c: 12896}, {f: 26, c: 9424}, {f: 15, c: 9312}, 189,

  7841     {f: 2, c: 8531}, 188, 190, {f: 4, c: 8539}, 230, 273, 240, 295, 305, 307,

  7842     312, 320, 322, 248, 339, 223, 254, 359, 331, 329, {f: 28, c: 12800},

  7843     {f: 26, c: 9372}, {f: 15, c: 9332}, 185, {f: 2, c: 178}, 8308, 8319,

  7844     {f: 4, c: 8321}, {f: 83, c: 12353}, {f: 86, c: 12449}, {f: 6, c: 1040},

  7845     1025, {f: 32, c: 1046}, 1105, {f: 26, c: 1078}, {f: 2, c: 44032}, 44036,

  7846     {f: 4, c: 44039}, {f: 8, c: 44048}, {f: 5, c: 44057}, 44064, 44068,

  7847     {f: 2, c: 44076}, {f: 3, c: 44079}, {f: 2, c: 44088}, 44092, 44096, 44107,

  7848     44109, 44116, 44120, 44124, {f: 2, c: 44144}, 44148, {f: 2, c: 44151},

  7849     44154, {f: 2, c: 44160}, {f: 4, c: 44163}, {f: 4, c: 44169}, 44176, 44180,

  7850     {f: 2, c: 44188}, {f: 3, c: 44191}, {f: 3, c: 44200}, 44204,

  7851     {f: 2, c: 44207}, {f: 2, c: 44216}, {f: 3, c: 44219}, 44225, 44228, 44232,

  7852     44236, 44245, 44247, {f: 2, c: 44256}, 44260, {f: 2, c: 44263}, 44266,

  7853     44268, {f: 3, c: 44271}, 44275, {f: 2, c: 44277}, {f: 2, c: 44284}, 44288,

  7854     44292, 44294, {f: 2, c: 44300}, 44303, 44305, 44312, 44316, 44320, 44329,

  7855     {f: 2, c: 44332}, {f: 2, c: 44340}, 44344, 44348, {f: 2, c: 44356}, 44359,

  7856     44361, 44368, 44372, 44376, 44385, 44387, {f: 2, c: 44396}, 44400,

  7857     {f: 4, c: 44403}, {f: 3, c: 44411}, 44415, {f: 2, c: 44417},

  7858     {f: 2, c: 44424}, 44428, 44432, {f: 2, c: 44444}, 44452, 44471,

  7859     {f: 2, c: 44480}, 44484, 44488, {f: 2, c: 44496}, 44499, 44508, 44512,

  7860     44516, {f: 2, c: 44536}, 44540, {f: 3, c: 44543}, {f: 2, c: 44552}, 44555,

  7861     44557, 44564, {f: 2, c: 44592}, 44596, {f: 2, c: 44599}, 44602,

  7862     {f: 2, c: 44608}, 44611, {f: 2, c: 44613}, 44618, {f: 3, c: 44620}, 44624,

  7863     44628, 44630, {f: 2, c: 44636}, {f: 3, c: 44639}, 44645, {f: 2, c: 44648},

  7864     44652, 44656, {f: 2, c: 44664}, {f: 3, c: 44667}, {f: 2, c: 44676}, 44684,

  7865     {f: 3, c: 44732}, 44736, 44740, {f: 2, c: 44748}, {f: 3, c: 44751},

  7866     {f: 2, c: 44760}, 44764, 44776, 44779, 44781, 44788, 44792, 44796,

  7867     {f: 2, c: 44807}, 44813, 44816, {f: 2, c: 44844}, 44848, 44850, 44852,

  7868     {f: 2, c: 44860}, 44863, {f: 3, c: 44865}, {f: 2, c: 44872}, 44880,

  7869     {f: 2, c: 44892}, {f: 2, c: 44900}, 44921, 44928, 44932, 44936,

  7870     {f: 2, c: 44944}, 44949, 44956, {f: 2, c: 44984}, 44988, 44992,

  7871     {f: 3, c: 44999}, 45003, {f: 2, c: 45005}, 45012, 45020, {f: 2, c: 45032},

  7872     {f: 2, c: 45040}, 45044, 45048, {f: 2, c: 45056}, 45060, 45068, 45072,

  7873     45076, {f: 2, c: 45084}, 45096, {f: 2, c: 45124}, 45128, 45130, 45132,

  7874     45134, {f: 3, c: 45139}, 45143, 45145, 45149, {f: 2, c: 45180}, 45184,

  7875     45188, {f: 2, c: 45196}, 45199, 45201, {f: 3, c: 45208}, 45212,

  7876     {f: 4, c: 45215}, {f: 2, c: 45224}, {f: 5, c: 45227}, 45233,

  7877     {f: 3, c: 45235}, 45240, 45244, {f: 2, c: 45252}, {f: 3, c: 45255},

  7878     {f: 2, c: 45264}, 45268, 45272, 45280, 45285, {f: 2, c: 45320},

  7879     {f: 2, c: 45323}, 45328, {f: 2, c: 45330}, {f: 2, c: 45336},

  7880     {f: 3, c: 45339}, {f: 3, c: 45347}, 45352, 45356, {f: 2, c: 45364},

  7881     {f: 3, c: 45367}, {f: 2, c: 45376}, 45380, 45384, {f: 2, c: 45392},

  7882     {f: 2, c: 45396}, 45400, 45404, 45408, {f: 2, c: 45432}, 45436, 45440,

  7883     45442, {f: 2, c: 45448}, 45451, 45453, {f: 3, c: 45458}, 45464, 45468,

  7884     45480, 45516, 45520, 45524, {f: 2, c: 45532}, 45535, {f: 2, c: 45544},

  7885     45548, 45552, 45561, 45563, 45565, {f: 2, c: 45572}, 45576,

  7886     {f: 2, c: 45579}, {f: 2, c: 45588}, 45591, 45593, 45600, 45620, 45628,

  7887     45656, 45660, 45664, {f: 2, c: 45672}, {f: 2, c: 45684}, 45692,

  7888     {f: 2, c: 45700}, 45705, {f: 2, c: 45712}, 45716, {f: 3, c: 45720},

  7889     {f: 2, c: 45728}, 45731, {f: 2, c: 45733}, 45738, 45740, 45744, 45748,

  7890     {f: 2, c: 45768}, 45772, 45776, 45778, {f: 2, c: 45784}, 45787, 45789,

  7891     45794, {f: 3, c: 45796}, 45800, {f: 5, c: 45803}, {f: 3, c: 45811},

  7892     {f: 5, c: 45815}, {f: 3, c: 45823}, 45828, 45832, {f: 2, c: 45840},

  7893     {f: 3, c: 45843}, 45852, {f: 3, c: 45908}, 45912, {f: 2, c: 45915},

  7894     {f: 2, c: 45918}, {f: 2, c: 45924}, 45927, 45929, 45931, 45934,

  7895     {f: 2, c: 45936}, 45940, 45944, {f: 2, c: 45952}, {f: 3, c: 45955}, 45964,

  7896     45968, 45972, {f: 2, c: 45984}, 45992, 45996, {f: 2, c: 46020}, 46024,

  7897     {f: 2, c: 46027}, 46030, 46032, {f: 2, c: 46036}, 46039, 46041, 46043,

  7898     46045, 46048, 46052, 46056, 46076, 46096, 46104, 46108, 46112,

  7899     {f: 2, c: 46120}, 46123, 46132, {f: 2, c: 46160}, 46164, 46168,

  7900     {f: 2, c: 46176}, 46179, 46181, 46188, 46208, 46216, 46237, 46244, 46248,

  7901     46252, 46261, 46263, 46265, 46272, 46276, 46280, 46288, 46293,

  7902     {f: 2, c: 46300}, 46304, {f: 2, c: 46307}, 46310, {f: 2, c: 46316}, 46319,

  7903     46321, 46328, {f: 2, c: 46356}, 46360, {f: 2, c: 46363}, {f: 2, c: 46372},

  7904     {f: 4, c: 46375}, {f: 2, c: 46384}, 46388, 46392, {f: 2, c: 46400},

  7905     {f: 3, c: 46403}, {f: 3, c: 46411}, 46416, 46420, {f: 2, c: 46428},

  7906     {f: 3, c: 46431}, {f: 2, c: 46496}, 46500, 46504, {f: 2, c: 46506},

  7907     {f: 2, c: 46512}, {f: 3, c: 46515}, {f: 3, c: 46523}, 46528, 46532,

  7908     {f: 2, c: 46540}, {f: 3, c: 46543}, 46552, 46572, {f: 2, c: 46608}, 46612,

  7909     46616, 46629, 46636, 46644, 46664, 46692, 46696, {f: 2, c: 46748}, 46752,

  7910     46756, {f: 2, c: 46763}, 46769, 46804, 46832, 46836, 46840,

  7911     {f: 2, c: 46848}, 46853, {f: 2, c: 46888}, 46892, {f: 2, c: 46895},

  7912     {f: 2, c: 46904}, 46907, 46916, 46920, 46924, {f: 2, c: 46932}, 46944,

  7913     46948, 46952, {f: 2, c: 46960}, 46963, 46965, {f: 2, c: 46972}, 46976,

  7914     46980, {f: 2, c: 46988}, {f: 4, c: 46991}, {f: 4, c: 46998}, 47004, 47008,

  7915     {f: 2, c: 47016}, {f: 3, c: 47019}, {f: 2, c: 47028}, 47032, 47047, 47049,

  7916     {f: 2, c: 47084}, 47088, 47092, {f: 2, c: 47100}, {f: 3, c: 47103},

  7917     {f: 3, c: 47111}, 47116, 47120, {f: 2, c: 47128}, 47131, 47133,

  7918     {f: 2, c: 47140}, 47144, 47148, {f: 2, c: 47156}, {f: 3, c: 47159}, 47168,

  7919     47172, 47185, 47187, {f: 2, c: 47196}, 47200, 47204, {f: 2, c: 47212},

  7920     47215, 47217, 47224, 47228, 47245, 47272, 47280, 47284, 47288,

  7921     {f: 2, c: 47296}, 47299, 47301, 47308, 47312, 47316, 47325, 47327, 47329,

  7922     {f: 2, c: 47336}, 47340, 47344, {f: 2, c: 47352}, 47355, 47357, 47364,

  7923     47384, 47392, {f: 2, c: 47420}, 47424, 47428, 47436, 47439, 47441,

  7924     {f: 2, c: 47448}, 47452, 47456, {f: 2, c: 47464}, 47467, 47469,

  7925     {f: 2, c: 47476}, 47480, 47484, {f: 2, c: 47492}, 47495, {f: 2, c: 47497},

  7926     {f: 2, c: 47501}, {f: 2, c: 47532}, 47536, 47540, {f: 2, c: 47548}, 47551,

  7927     47553, {f: 2, c: 47560}, 47564, {f: 5, c: 47566}, {f: 2, c: 47576}, 47579,

  7928     {f: 2, c: 47581}, 47585, {f: 3, c: 47587}, 47592, 47596, {f: 2, c: 47604},

  7929     {f: 4, c: 47607}, {f: 2, c: 47616}, 47624, 47637, {f: 2, c: 47672}, 47676,

  7930     47680, 47682, {f: 2, c: 47688}, 47691, {f: 2, c: 47693}, {f: 3, c: 47699},

  7931     47704, 47708, {f: 2, c: 47716}, {f: 3, c: 47719}, {f: 2, c: 47728}, 47732,

  7932     47736, {f: 3, c: 47747}, 47751, 47756, {f: 2, c: 47784}, {f: 2, c: 47787},

  7933     47792, 47794, {f: 2, c: 47800}, 47803, 47805, 47812, 47816,

  7934     {f: 2, c: 47832}, 47868, 47872, 47876, 47885, 47887, 47889, 47896, 47900,

  7935     47904, 47913, 47915, {f: 3, c: 47924}, 47928, {f: 4, c: 47931},

  7936     {f: 2, c: 47940}, 47943, 47945, 47949, {f: 2, c: 47951}, 47956, 47960,

  7937     47969, 47971, 47980, 48008, 48012, 48016, 48036, 48040, 48044, 48052,

  7938     48055, 48064, 48068, 48072, 48080, 48083, {f: 2, c: 48120}, 48124,

  7939     {f: 2, c: 48127}, 48130, {f: 2, c: 48136}, {f: 3, c: 48139}, 48143, 48145,

  7940     {f: 5, c: 48148}, {f: 5, c: 48155}, {f: 2, c: 48164}, 48167, 48169, 48173,

  7941     {f: 2, c: 48176}, 48180, 48184, {f: 2, c: 48192}, {f: 3, c: 48195}, 48201,

  7942     {f: 2, c: 48204}, 48208, 48221, {f: 2, c: 48260}, 48264, {f: 2, c: 48267},

  7943     48270, {f: 2, c: 48276}, 48279, {f: 2, c: 48281}, {f: 2, c: 48288}, 48292,

  7944     {f: 2, c: 48295}, {f: 2, c: 48304}, {f: 3, c: 48307}, {f: 2, c: 48316},

  7945     48320, 48324, 48333, {f: 3, c: 48335}, 48341, 48344, 48348,

  7946     {f: 3, c: 48372}, 48376, 48380, {f: 2, c: 48388}, 48391, 48393, 48400,

  7947     48404, 48420, 48428, 48448, {f: 2, c: 48456}, 48460, 48464,

  7948     {f: 2, c: 48472}, 48484, 48488, {f: 2, c: 48512}, 48516, {f: 4, c: 48519},

  7949     {f: 2, c: 48528}, 48531, 48533, {f: 2, c: 48537}, 48540, 48548, 48560,

  7950     48568, {f: 2, c: 48596}, 48600, 48604, 48617, 48624, 48628, 48632, 48640,

  7951     48643, 48645, {f: 2, c: 48652}, 48656, 48660, {f: 2, c: 48668}, 48671,

  7952     {f: 2, c: 48708}, 48712, 48716, 48718, {f: 2, c: 48724}, 48727,

  7953     {f: 3, c: 48729}, {f: 2, c: 48736}, 48740, 48744, 48746, {f: 2, c: 48752},

  7954     {f: 3, c: 48755}, {f: 3, c: 48763}, 48768, 48772, {f: 2, c: 48780},

  7955     {f: 3, c: 48783}, {f: 2, c: 48792}, 48808, {f: 2, c: 48848}, 48852,

  7956     {f: 2, c: 48855}, 48864, {f: 3, c: 48867}, 48876, 48897, {f: 2, c: 48904},

  7957     {f: 2, c: 48920}, {f: 3, c: 48923}, {f: 2, c: 48960}, 48964, 48968,

  7958     {f: 2, c: 48976}, 48981, 49044, 49072, 49093, {f: 2, c: 49100}, 49104,

  7959     49108, 49116, 49119, 49121, 49212, 49233, 49240, 49244, 49248,

  7960     {f: 2, c: 49256}, {f: 2, c: 49296}, 49300, 49304, {f: 2, c: 49312}, 49315,

  7961     49317, {f: 2, c: 49324}, {f: 2, c: 49327}, {f: 4, c: 49331},

  7962     {f: 2, c: 49340}, {f: 3, c: 49343}, 49349, {f: 2, c: 49352}, 49356, 49360,

  7963     {f: 2, c: 49368}, {f: 3, c: 49371}, {f: 2, c: 49380}, 49384, 49388,

  7964     {f: 2, c: 49396}, 49399, 49401, 49408, 49412, 49416, 49424, 49429,

  7965     {f: 5, c: 49436}, {f: 2, c: 49443}, {f: 2, c: 49446}, {f: 2, c: 49452},

  7966     {f: 3, c: 49455}, 49462, {f: 2, c: 49464}, 49468, 49472, {f: 2, c: 49480},

  7967     {f: 3, c: 49483}, {f: 2, c: 49492}, 49496, 49500, {f: 2, c: 49508},

  7968     {f: 3, c: 49511}, 49520, 49524, 49528, 49541, {f: 3, c: 49548}, 49552,

  7969     49556, 49558, {f: 2, c: 49564}, 49567, 49569, 49573, {f: 2, c: 49576},

  7970     49580, 49584, 49597, 49604, 49608, 49612, 49620, {f: 2, c: 49623}, 49632,

  7971     49636, 49640, {f: 2, c: 49648}, 49651, {f: 2, c: 49660}, 49664, 49668,

  7972     {f: 2, c: 49676}, 49679, 49681, {f: 2, c: 49688}, 49692, {f: 2, c: 49695},

  7973     {f: 2, c: 49704}, 49707, 49709, 49711, {f: 2, c: 49713}, 49716, 49736,

  7974     {f: 2, c: 49744}, 49748, 49752, 49760, 49765, {f: 2, c: 49772}, 49776,

  7975     49780, {f: 2, c: 49788}, 49791, 49793, {f: 2, c: 49800}, 49808, 49816,

  7976     49819, 49821, {f: 2, c: 49828}, 49832, {f: 2, c: 49836}, {f: 2, c: 49844},

  7977     49847, 49849, {f: 2, c: 49884}, 49888, {f: 2, c: 49891}, {f: 3, c: 49899},

  7978     49903, 49905, 49910, {f: 2, c: 49912}, {f: 2, c: 49915}, 49920,

  7979     {f: 2, c: 49928}, {f: 2, c: 49932}, {f: 3, c: 49939}, 49944, 49948,

  7980     {f: 2, c: 49956}, {f: 2, c: 49960}, 49989, {f: 2, c: 50024}, 50028, 50032,

  7981     50034, {f: 2, c: 50040}, {f: 2, c: 50044}, 50052, 50056, 50060, 50112,

  7982     {f: 2, c: 50136}, 50140, {f: 2, c: 50143}, 50146, {f: 2, c: 50152}, 50157,

  7983     {f: 2, c: 50164}, 50168, 50184, 50192, 50212, 50220, 50224, 50228,

  7984     {f: 2, c: 50236}, 50248, {f: 2, c: 50276}, 50280, 50284, {f: 2, c: 50292},

  7985     50297, 50304, 50324, 50332, 50360, 50364, 50409, {f: 2, c: 50416}, 50420,

  7986     50424, 50426, {f: 3, c: 50431}, 50444, 50448, 50452, 50460,

  7987     {f: 2, c: 50472}, 50476, 50480, {f: 2, c: 50488}, 50491, 50493,

  7988     {f: 2, c: 50500}, {f: 3, c: 50504}, {f: 3, c: 50508}, {f: 3, c: 50515},

  7989     {f: 3, c: 50519}, {f: 2, c: 50525}, {f: 2, c: 50528}, 50532, 50536,

  7990     {f: 2, c: 50544}, {f: 3, c: 50547}, {f: 2, c: 50556}, 50560, 50564, 50567,

  7991     {f: 2, c: 50572}, 50575, 50577, 50581, {f: 2, c: 50583}, 50588, 50592,

  7992     50601, {f: 2, c: 50612}, {f: 2, c: 50616}, {f: 4, c: 50619},

  7993     {f: 7, c: 50628}, 50636, 50638, {f: 2, c: 50640}, 50644, 50648,

  7994     {f: 2, c: 50656}, 50659, 50661, {f: 3, c: 50668}, 50672, 50676,

  7995     {f: 2, c: 50678}, {f: 6, c: 50684}, {f: 4, c: 50693}, 50700, 50704,

  7996     {f: 2, c: 50712}, {f: 2, c: 50715}, {f: 2, c: 50724}, 50728,

  7997     {f: 3, c: 50732}, 50736, {f: 3, c: 50739}, 50743, 50745, 50747,

  7998     {f: 2, c: 50752}, 50756, 50760, {f: 2, c: 50768}, {f: 3, c: 50771},

  7999     {f: 2, c: 50780}, 50784, 50796, 50799, 50801, {f: 2, c: 50808}, 50812,

  8000     50816, {f: 2, c: 50824}, 50827, 50829, {f: 2, c: 50836}, 50840, 50844,

  8001     {f: 2, c: 50852}, 50855, 50857, {f: 2, c: 50864}, 50868, {f: 3, c: 50872},

  8002     {f: 2, c: 50880}, 50883, 50885, {f: 2, c: 50892}, 50896, 50900,

  8003     {f: 2, c: 50908}, {f: 2, c: 50912}, {f: 2, c: 50920}, 50924, 50928,

  8004     {f: 2, c: 50936}, 50941, {f: 2, c: 50948}, 50952, 50956, {f: 2, c: 50964},

  8005     50967, 50969, {f: 2, c: 50976}, 50980, 50984, {f: 2, c: 50992}, 50995,

  8006     50997, 50999, {f: 2, c: 51004}, 51008, 51012, 51018, {f: 2, c: 51020},

  8007     51023, {f: 8, c: 51025}, 51036, 51040, 51048, 51051, {f: 2, c: 51060},

  8008     51064, {f: 3, c: 51068}, {f: 3, c: 51075}, {f: 4, c: 51079}, 51086,

  8009     {f: 2, c: 51088}, 51092, {f: 3, c: 51094}, 51098, {f: 2, c: 51104},

  8010     {f: 4, c: 51107}, {f: 2, c: 51116}, 51120, 51124, {f: 2, c: 51132},

  8011     {f: 3, c: 51135}, {f: 2, c: 51144}, 51148, 51150, 51152, 51160, 51165,

  8012     51172, 51176, 51180, {f: 2, c: 51200}, 51204, 51208, 51210,

  8013     {f: 2, c: 51216}, 51219, {f: 2, c: 51221}, {f: 2, c: 51228}, 51232, 51236,

  8014     {f: 2, c: 51244}, 51247, 51249, 51256, 51260, 51264, {f: 2, c: 51272},

  8015     {f: 2, c: 51276}, 51284, {f: 2, c: 51312}, 51316, 51320, 51322,

  8016     {f: 2, c: 51328}, 51331, {f: 3, c: 51333}, {f: 3, c: 51339}, 51348, 51357,

  8017     51359, 51361, 51368, {f: 2, c: 51388}, 51396, 51400, 51404,

  8018     {f: 2, c: 51412}, 51415, 51417, {f: 2, c: 51424}, 51428, 51445,

  8019     {f: 2, c: 51452}, 51456, {f: 3, c: 51460}, {f: 2, c: 51468}, 51471, 51473,

  8020     51480, 51500, 51508, {f: 2, c: 51536}, 51540, 51544, {f: 2, c: 51552},

  8021     51555, 51564, 51568, 51572, 51580, {f: 2, c: 51592}, 51596, 51600,

  8022     {f: 2, c: 51608}, 51611, 51613, {f: 2, c: 51648}, 51652, {f: 2, c: 51655},

  8023     51658, {f: 2, c: 51664}, 51667, {f: 2, c: 51669}, {f: 2, c: 51673},

  8024     {f: 2, c: 51676}, 51680, 51682, 51684, 51687, {f: 2, c: 51692},

  8025     {f: 3, c: 51695}, {f: 2, c: 51704}, 51708, 51712, {f: 2, c: 51720},

  8026     {f: 3, c: 51723}, 51732, 51736, 51753, {f: 2, c: 51788}, 51792, 51796,

  8027     {f: 2, c: 51804}, {f: 3, c: 51807}, 51816, 51837, 51844, 51864,

  8028     {f: 2, c: 51900}, 51904, 51908, {f: 2, c: 51916}, 51919, 51921, 51923,

  8029     {f: 2, c: 51928}, 51936, 51948, 51956, 51976, 51984, 51988, 51992,

  8030     {f: 2, c: 52000}, 52033, {f: 2, c: 52040}, 52044, 52048, {f: 2, c: 52056},

  8031     52061, 52068, {f: 2, c: 52088}, 52124, 52152, 52180, 52196, 52199, 52201,

  8032     {f: 2, c: 52236}, 52240, 52244, {f: 2, c: 52252}, {f: 2, c: 52257},

  8033     {f: 3, c: 52263}, 52268, 52270, 52272, {f: 2, c: 52280}, {f: 4, c: 52283},

  8034     {f: 2, c: 52292}, 52296, 52300, {f: 2, c: 52308}, {f: 3, c: 52311}, 52320,

  8035     52324, 52326, 52328, 52336, 52341, {f: 2, c: 52376}, 52380, 52384,

  8036     {f: 2, c: 52392}, {f: 3, c: 52395}, {f: 2, c: 52404}, 52408, 52412,

  8037     {f: 2, c: 52420}, 52423, 52425, 52432, 52436, 52452, 52460, 52464, 52481,

  8038     {f: 2, c: 52488}, 52492, 52496, {f: 2, c: 52504}, 52507, 52509, 52516,

  8039     52520, 52524, 52537, 52572, 52576, 52580, {f: 2, c: 52588}, 52591, 52593,

  8040     52600, 52616, {f: 2, c: 52628}, 52632, 52636, {f: 2, c: 52644}, 52647,

  8041     52649, 52656, 52676, 52684, 52688, 52712, 52716, 52720, {f: 2, c: 52728},

  8042     52731, 52733, 52740, 52744, 52748, 52756, 52761, {f: 2, c: 52768}, 52772,

  8043     52776, {f: 2, c: 52784}, 52787, 52789, {f: 2, c: 52824}, 52828,

  8044     {f: 3, c: 52831}, {f: 2, c: 52840}, 52843, 52845, {f: 2, c: 52852}, 52856,

  8045     52860, {f: 2, c: 52868}, 52871, 52873, {f: 2, c: 52880}, 52884, 52888,

  8046     {f: 2, c: 52896}, {f: 3, c: 52899}, {f: 2, c: 52908}, 52929,

  8047     {f: 2, c: 52964}, 52968, {f: 2, c: 52971}, {f: 2, c: 52980},

  8048     {f: 3, c: 52983}, {f: 2, c: 52992}, 52996, 53000, {f: 2, c: 53008}, 53011,

  8049     53013, 53020, 53024, 53028, {f: 2, c: 53036}, {f: 3, c: 53039}, 53048,

  8050     {f: 2, c: 53076}, 53080, 53084, {f: 2, c: 53092}, 53095, 53097,

  8051     {f: 2, c: 53104}, 53108, 53112, 53120, 53125, 53132, 53153, 53160, 53168,

  8052     53188, {f: 2, c: 53216}, 53220, 53224, {f: 2, c: 53232}, 53235, 53237,

  8053     53244, 53248, 53252, 53265, 53272, 53293, {f: 2, c: 53300}, 53304, 53308,

  8054     {f: 2, c: 53316}, 53319, 53321, 53328, 53332, 53336, 53344,

  8055     {f: 2, c: 53356}, 53360, 53364, {f: 2, c: 53372}, 53377, {f: 2, c: 53412},

  8056     53416, 53420, {f: 2, c: 53428}, 53431, 53433, {f: 2, c: 53440}, 53444,

  8057     {f: 2, c: 53448}, {f: 2, c: 53456}, {f: 3, c: 53459}, {f: 2, c: 53468},

  8058     53472, 53476, {f: 2, c: 53484}, {f: 3, c: 53487}, 53496, 53517,

  8059     {f: 2, c: 53552}, 53556, 53560, 53562, {f: 2, c: 53568}, {f: 3, c: 53571},

  8060     {f: 2, c: 53580}, 53584, 53588, {f: 2, c: 53596}, 53599, 53601, 53608,

  8061     53612, 53628, 53636, 53640, {f: 2, c: 53664}, 53668, 53672,

  8062     {f: 2, c: 53680}, 53683, 53685, 53690, 53692, 53696, 53720, 53748, 53752,

  8063     53767, 53769, 53776, {f: 2, c: 53804}, 53808, 53812, {f: 2, c: 53820},

  8064     53823, 53825, 53832, 53852, 53860, {f: 2, c: 53888}, 53892, 53896,

  8065     {f: 2, c: 53904}, 53909, 53916, 53920, 53924, 53932, 53937,

  8066     {f: 2, c: 53944}, 53948, {f: 2, c: 53951}, 53954, {f: 2, c: 53960}, 53963,

  8067     53972, 53976, 53980, {f: 2, c: 53988}, {f: 2, c: 54000}, 54004, 54008,

  8068     {f: 2, c: 54016}, 54019, 54021, {f: 3, c: 54028}, 54032, 54036, 54038,

  8069     {f: 2, c: 54044}, {f: 3, c: 54047}, 54053, {f: 2, c: 54056}, 54060, 54064,

  8070     {f: 2, c: 54072}, {f: 3, c: 54075}, {f: 2, c: 54084}, {f: 2, c: 54140},

  8071     54144, 54148, {f: 2, c: 54156}, {f: 3, c: 54159}, {f: 2, c: 54168}, 54172,

  8072     54176, {f: 2, c: 54184}, 54187, 54189, 54196, 54200, 54204,

  8073     {f: 2, c: 54212}, {f: 2, c: 54216}, 54224, 54232, 54241, 54243,

  8074     {f: 2, c: 54252}, 54256, 54260, {f: 2, c: 54268}, 54271, 54273, 54280,

  8075     54301, 54336, 54340, 54364, 54368, 54372, 54381, 54383, {f: 2, c: 54392},

  8076     54396, {f: 2, c: 54399}, 54402, {f: 2, c: 54408}, 54411, 54413, 54420,

  8077     54441, 54476, 54480, 54484, 54492, 54495, 54504, 54508, 54512, 54520,

  8078     54523, 54525, 54532, 54536, 54540, {f: 2, c: 54548}, 54551,

  8079     {f: 2, c: 54588}, 54592, 54596, {f: 2, c: 54604}, 54607, 54609,

  8080     {f: 2, c: 54616}, 54620, 54624, 54629, {f: 2, c: 54632}, 54635, 54637,

  8081     {f: 2, c: 54644}, 54648, 54652, {f: 2, c: 54660}, {f: 3, c: 54663}, 54672,

  8082     54693, {f: 2, c: 54728}, 54732, 54736, 54738, {f: 2, c: 54744}, 54747,

  8083     54749, {f: 2, c: 54756}, 54760, 54764, {f: 2, c: 54772}, 54775, 54777,

  8084     {f: 2, c: 54784}, 54788, 54792, {f: 2, c: 54800}, {f: 3, c: 54803}, 54812,

  8085     54816, 54820, 54829, {f: 2, c: 54840}, 54844, 54848, 54853,

  8086     {f: 2, c: 54856}, 54859, 54861, 54865, {f: 2, c: 54868}, 54872, 54876,

  8087     54887, 54889, {f: 2, c: 54896}, 54900, 54915, 54917, {f: 2, c: 54924},

  8088     54928, 54932, 54941, 54943, 54945, 54952, 54956, 54960, 54969, 54971,

  8089     {f: 2, c: 54980}, 54984, 54988, 54993, 54996, 54999, 55001, 55008, 55012,

  8090     55016, 55024, 55029, {f: 2, c: 55036}, 55040, 55044, 55057,

  8091     {f: 2, c: 55064}, 55068, 55072, {f: 2, c: 55080}, 55083, 55085,

  8092     {f: 2, c: 55092}, 55096, 55100, 55108, 55111, 55113, {f: 2, c: 55120},

  8093     55124, {f: 4, c: 55126}, {f: 2, c: 55136}, 55139, 55141, 55145, 55148,

  8094     55152, 55156, {f: 2, c: 55164}, 55169, {f: 2, c: 55176}, 55180, 55184,

  8095     {f: 2, c: 55192}, 55195, 55197, 20285, 20339, 20551, 20729, 21152, 21487,

  8096     21621, 21733, 22025, 23233, 23478, 26247, {f: 2, c: 26550}, 26607, 27468,

  8097     29634, 30146, 31292, 33499, 33540, 34903, 34952, 35382, [36040, 63747],

  8098     36303, 36603, 36838, 39381, 21051, 21364, 21508, 24682, 24932, 27580,

  8099     29647, 33050, 35258, [12179, 35282], 38307, 20355, 21002, 22718, 22904,

  8100     23014, [12082, 24178], 24185, 25031, 25536, 26438, 26604, 26751, 28567,

  8101     30286, 30475, 30965, 31240, 31487, 31777, 32925, [12169, 33390], 33393,

  8102     35563, 38291, 20075, 21917, 26359, 28212, 30883, 31469, 33883, 35088,

  8103     34638, 38824, 21208, 22350, 22570, 23884, 24863, 25022, 25121, 25954,

  8104     26577, 27204, 28187, [12130, 29976], 30131, 30435, 30640, 32058, 37039,

  8105     {f: 2, c: 37969}, 40853, 21283, 23724, 30002, 32987, 37440, 38296, 21083,

  8106     22536, 23004, 23713, 23831, 24247, 24378, 24394, 24951, 27743, 30074,

  8107     30086, 31968, 32115, 32177, 32652, 33108, 33313, 34193, 35137, 35611,

  8108     37628, [38477, 64009], 40007, 20171, 20215, 20491, 20977, 22607, 24887,

  8109     24894, 24936, 25913, 27114, 28433, 30117, 30342, 30422, 31623, 33445,

  8110     33995, 37799, 38283, 21888, 23458, 22353, 31923, 32697, 37301, 20520,

  8111     21435, 23621, 24040, 25298, 25454, 25818, 25831, 28192, 28844, 31067,

  8112     36317, 36382, 36989, 37445, 37624, 20094, 20214, 20581, [12081, 24062],

  8113     24314, 24838, 26967, 33137, 34388, 36423, 37749, 39467, 20062, 20625,

  8114     26480, 26688, 20745, 21133, 21138, 27298, 30652, 37392, 40660, 21163,

  8115     24623, 36850, 20552, 25001, 25581, 25802, 26684, 27268, 28608, 33160,

  8116     35233, 38548, 22533, 29309, [12125, 29356], 29956, 32121, 32365, 32937,

  8117     [12178, 35211, 64010], 35700, 36963, 40273, 25225, 27770, 28500, 32080,

  8118     32570, 35363, 20860, 24906, 31645, 35609, 37463, 37772, 20140, 20435,

  8119     20510, 20670, 20742, 21185, 21197, 21375, 22384, 22659, 24218, 24465,

  8120     24950, 25004, 25806, 25964, 26223, 26299, [26356, 63745], 26775, 28039,

  8121     28805, 28913, 29855, 29861, 29898, 30169, 30828, 30956, 31455, 31478,

  8122     32069, 32147, 32789, 32831, 33051, 33686, 35686, 36629, 36885, 37857,

  8123     38915, 38968, 39514, 39912, 20418, 21843, 22586, [22865, 63753], 23395,

  8124     23622, 24760, 25106, 26690, 26800, 26856, 28330, 30028, 30328, 30926,

  8125     31293, 31995, 32363, 32380, 35336, 35489, 35903, 38542, 40388, 21476,

  8126     21481, 21578, 21617, 22266, 22993, 23396, 23611, 24235, 25335, 25911,

  8127     25925, 25970, 26272, 26543, 27073, 27837, 30204, 30352, 30590, 31295,

  8128     32660, 32771, 32929, 33167, 33510, 33533, 33776, 34241, 34865, 34996,

  8129     35493, 36764, 37678, 38599, 39015, [12220, 39640], [12238, 40723], 21741,

  8130     26011, 26354, 26767, 31296, [12181, 35895], 40288, 22256, 22372, 23825,

  8131     26118, 26801, 26829, 28414, 29736, 34974, 39908, 27752, [12219, 39592],

  8132     20379, 20844, 20849, 21151, 23380, [12079, 24037], 24656, 24685, 25329,

  8133     25511, 25915, 29657, 31354, 34467, 36002, 38799, [20018, 63749], 23521,

  8134     [12093, 25096], 26524, [12128, 29916], 31185, 33747, 35463, 35506, 36328,

  8135     36942, 37707, 38982, [24275, 64011], 27112, 34303, 37101, 20896, 23448,

  8136     23532, 24931, 26874, 27454, 28748, 29743, 29912, 31649, 32592, 33733,

  8137     35264, 36011, 38364, 39208, 21038, 24669, 25324, 36866, 20362, 20809,

  8138     21281, 22745, 24291, 26336, 27960, 28826, 29378, 29654, 31568, 33009,

  8139     37979, 21350, 25499, 32619, 20054, 20608, 22602, 22750, 24618, 24871,

  8140     25296, 27088, 39745, 23439, 32024, 32945, 36703, 20132, 20689, 21676,

  8141     21932, 23308, 23968, 24039, 25898, 25934, 26657, 27211, 29409, 30350,

  8142     30703, 32094, 32761, 33184, 34126, 34527, 36611, 36686, 37066, 39171,

  8143     39509, 39851, 19992, 20037, 20061, 20167, 20465, 20855, 21246, 21312,

  8144     [12061, 21475], [21477, 63750], 21646, 22036, 22389, 22434, 23495, 23943,

  8145     24272, 25084, 25304, 25937, 26552, 26601, 27083, 27472, 27590, 27628,

  8146     27714, 28317, 28792, 29399, 29590, 29699, 30655, 30697, 31350, 32127,

  8147     32777, [12165, 33276], 33285, 33290, 33503, 34914, 35635, 36092, 36544,

  8148     36881, 37041, 37476, 37558, 39378, 39493, 40169, 40407,

  8149     [12244, 40860, 63751, 63752], 22283, 23616, 33738, 38816, 38827, 40628,

  8150     21531, 31384, 32676, 35033, 36557, 37089, 22528, 23624, 25496, 31391,

  8151     23470, [12088, 24339], 31353, 31406, 33422, 36524, 20518, 21048, 21240,

  8152     21367, 22280, 25331, 25458, 27402, 28099, 30519, 21413, 29527, 34152,

  8153     36470, 38357, 26426, 27331, 28528, 35437, 36556, 39243, 26231, 27512,

  8154     36020, [12225, 39740], 21483, 22317, 22862, 25542, 27131, 29674, 30789,

  8155     31418, 31429, 31998, 33909, 35215, 36211, 36917, 38312, 21243, 22343,

  8156     30023, 31584, 33740, 37406, 27224, 20811, 21067, 21127, 25119, 26840,

  8157     26997, 38553, 20677, 21156, 21220, 25027, [12100, 26020], 26681, 27135,

  8158     29822, 31563, 33465, 33771, 35250, 35641, 36817, 39241, 20170, 22935,

  8159     25810, 26129, 27278, 29748, 31105, 31165, 33449, {f: 2, c: 34942}, 35167,

  8160     37670, 20235, 21450, 24613, 25201, 27762, 32026, 32102, 20120, 20834,

  8161     30684, 32943, 20225, 20238, 20854, 20864, 21980, 22120, 22331, 22522,

  8162     22524, 22804, 22855, 22931, 23492, 23696, 23822, [12080, 24049], 24190,

  8163     24524, 25216, 26071, 26083, {f: 2, c: 26398}, 26462, 26827, 26820, 27231,

  8164     27450, 27683, 27773, 27778, 28103, 29592, 29734, 29738, 29826, 29859,

  8165     30072, 30079, 30849, 30959, 31041, {f: 2, c: 31047}, 31098, 31637, 32000,

  8166     32186, 32648, 32774, 32813, 32908, 35352, 35663, [35912, 63744], 36215,

  8167     37665, 37668, 39138, 39249, {f: 2, c: 39438}, 39525, 40594, 32202, 20342,

  8168     21513, 25326, 26708, [12198, 37329, 63754], 21931, 20794, 23068, 25062,

  8169     [25295, 63835], 25343, 37027, [35582, 63837], 26262, 29014, 38627, 25423,

  8170     25466, 21335, 26511, 26976, 28275, 30007, 32013, 34930, 22218, 23064,

  8171     20035, 20839, [22856, 63756], 26608, 32784, [12069, 22899, 63873],

  8172     [24180, 63886], [25754, 63889], [31178, 63893], [24565, 63907], 24684,

  8173     25288, [25467, 63908], [23527, 63839, 63914], 23511, 21162, 22900, 24361,

  8174     [24594, 63840], 29785, 39377, 28611, 33215, 36786, 24817, 33126,

  8175     [23615, 63933], 23273, 35365, [26491, 63944], [32016, 63951], 33021, 23612,

  8176     [27877, 63971], [21311, 63979], [28346, 63980], 22810, [33590, 63998],

  8177     [20025, 63838], 20150, 20294, 21934, 22296, 22727, 24406, 26039, 26086,

  8178     27264, 27573, 28237, 30701, 31471, 31774, 32222, 34507, 34962, 37170,

  8179     37723, 25787, 28606, 29562, 30136, 36948, 21846, 22349, 25018, 25812,

  8180     26311, 28129, 28251, 28525, 28601, 30192, 32835, 33213, 34113, 35203,

  8181     35527, 35674, 37663, 27795, 30035, 31572, 36367, 36957, 21776, 22530,

  8182     22616, 24162, 25095, 25758, 26848, 30070, [31958, 64003], 34739, 40680,

  8183     20195, 22408, 22382, [12068, 22823], 23565, 23729, 24118, 24453, 25140,

  8184     25825, 29619, 33274, 34955, 36024, 38538, 40667, [23429, 64004], 24503,

  8185     24755, 20498, [12049, 20992], 21040, 22294, 22581, 22615, 23566, 23648,

  8186     23798, 23947, [24230, 64001], 24466, 24764, 25361, 25481, 25623, 26691,

  8187     26873, 27330, 28120, 28193, 28372, 28644, 29182, 30428, 30585, 31153,

  8188     31291, 33796, 35241, 36077, 36339, 36424, 36867, 36884, 36947, 37117,

  8189     37709, 38518, 38876, 27602, 28678, 29272, 29346, 29544, 30563, 31167,

  8190     31716, 32411, [35712, 63834], 22697, 24775, 25958, 26109, 26302, 27788,

  8191     28958, 29129, 35930, 38931, 20077, 31361, 20189, 20908, 20941, 21205,

  8192     21516, 24999, 26481, 26704, 26847, [27934, 64005], 28540, 30140, 30643,

  8193     31461, 33012, 33891, 37509, 20828, [12099, 26007], 26460, 26515, 30168,

  8194     31431, 33651, [12182, 35910], 36887, 38957, 23663, 33216, 33434, 36929,

  8195     36975, 37389, 24471, 23965, 27225, 29128, 30331, 31561, 34276, 35588,

  8196     37159, 39472, [21895, 63755], [25078, 63757], [30313, 63758],

  8197     [32645, 63759], [34367, 63760], [34746, 63761], [35064, 63762],

  8198     [37007, 63763], [27931, 63765], [28889, 63766], [29662, 63767], 32097,

  8199     [33853, 63768], [37226, 63769], [39409, 63770], [20098, 63771],

  8200     [21365, 63772], [27396, 63773], 27410, 28734, [29211, 63774],

  8201     [34349, 63775], [40478, 63776], 21068, 36771, [23888, 63777], 25829, 25900,

  8202     27414, [28651, 63778], 31811, 32412, [34253, 63779], [35172, 63780], 35261,

  8203     [25289, 63781], [33240, 63782], [34847, 63783], [24266, 63784],

  8204     [26391, 63785], [28010, 63786], [29436, 63787], 29701, 29807, 34690,

  8205     [37086, 63788], [20358, 63789], 23821, 24480, 33802, [20919, 63790],

  8206     [25504, 63861], [30053, 63862], [20142, 63863], 20486, [20841, 63864],

  8207     [20937, 63865], [26753, 63866], 27153, 31918, 31921, [31975, 63867],

  8208     [33391, 63868], [35538, 63869], 36635, [37327, 63870], 20406, 20791,

  8209     [21237, 63871], [21570, 63872], [24300, 63874], 24942, 25150,

  8210     [26053, 63875], 27354, [28670, 63876], [31018, 63877], 34268, 34851,

  8211     [38317, 63878], 39522, [39530, 63879], [40599, 63880], [40654, 63881],

  8212     [12050, 21147, 63882], [26310, 63883], [27511, 63884], 28701, 31019,

  8213     [36706, 63885], 38722, [24976, 63887], [25088, 63888], 25891,

  8214     [28451, 63890], [29001, 63891], [29833, 63892], [32244, 63894],

  8215     [32879, 63895], [34030, 63897], [36646, 63896], [36899, 63898],

  8216     [37706, 63899], 20925, [21015, 63900], [21155, 63901], 27916,

  8217     [28872, 63903], [35010, 63904], [24265, 63906], 25986, [27566, 63909],

  8218     28610, [31806, 63910], [29557, 63911], [20196, 63912], 20278,

  8219     [22265, 63913], 23738, [23994, 63915], [24604, 63916], [29618, 63917],

  8220     31533, [32666, 63919], 32718, [32838, 63920], 36894, [37428, 63921],

  8221     [38646, 63922], [38728, 63923], [38936, 63924], 40801, [20363, 63925],

  8222     28583, [31150, 63926], [37300, 63927], [38583, 63928], [21214, 63791],

  8223     25736, [25796, 63792], [27347, 63793], 28510, 28696, [29200, 63794],

  8224     [30439, 63795], [12156, 32769, 63796], [34310, 63797], [34396, 63798],

  8225     [36335, 63799], 36613, [38706, 63800], [39791, 63801], [40442, 63802],

  8226     [12228, 40565], [30860, 63803], [31103, 63804], [32160, 63805],

  8227     [33737, 63806], [37636, 63807], [12229, 40575, 63808], 40595,

  8228     [35542, 63809], [22751, 63810], [24324, 63811], 26407, 28711, 29903,

  8229     [31840, 63812], [32894, 63813], 20769, 28712, [29282, 63814],

  8230     [30922, 63815], [36034, 63816], 36058, 36084, [38647, 63817],

  8231     [20102, 63930], [20698, 63931], [23534, 63932], 24278, [26009, 63934],

  8232     [29134, 63936], [30274, 63937], 30637, 32842, [34044, 63938],

  8233     [36988, 63939], 39719, [12243, 40845, 63940], [22744, 63818], 23105,

  8234     [23650, 63819], [27155, 63820], [28122, 63821], [28431, 63822], 30267,

  8235     [32047, 63823], [32311, 63824], 34078, 35128, 37860, [38475, 63825],

  8236     [21129, 63943], 26066, [26611, 63945], 27060, [27969, 63946],

  8237     [28316, 63947], 28687, [29705, 63948], 29792, [30041, 63949], 30244,

  8238     [30827, 63950], 35628, [39006, 63952], [20845, 63953], [25134, 63954],

  8239     [38520, 63955], 20374, [20523, 63956], [23833, 63957], [28138, 63958],

  8240     32184, [36650, 63959], [24459, 63960], [24900, 63961], [26647, 63962],

  8241     [38534, 63964], [21202, 63826], [32907, 63827], [20956, 63828],

  8242     [20940, 63829], 26974, [31260, 63830], [32190, 63831], [33777, 63832],

  8243     [38517, 63833], 20442, [21033, 63965], 21400, [21519, 63966], 21774,

  8244     [23653, 63967], 24743, [26446, 63969], [26792, 63970], 28012, 29313, 29432,

  8245     [29702, 63972], 29827, [30178, 63973], 31852, [32633, 63974], 32696, 33673,

  8246     [35023, 63975], [35041, 63976], [12197, 37324, 63977], 37328,

  8247     [38626, 63978], 39881, [21533, 63981], 28542, [29136, 63982],

  8248     [29848, 63983], [34298, 63984], 36522, [38563, 63985], [40023, 63986],

  8249     [40607, 63987], [26519, 63988], [28107, 63989], 29747, [33256, 63990],

  8250     38678, 30764, [12148, 31435, 63991], [31520, 63992], [31890, 63993], 25705,

  8251     29802, 30194, 30908, 30952, [12218, 39340], 39764, [12231, 40635], 23518,

  8252     24149, 28448, 33180, 33707, 37000, 19975, 21325, 23081, 24018, 24398,

  8253     24930, 25405, 26217, 26364, 28415, 28459, 28771, 30622, 33836, 34067,

  8254     34875, 36627, 39237, 39995, 21788, 25273, 26411, 27819, 33545, 35178,

  8255     38778, 20129, 22916, {f: 2, c: 24536}, 26395, 32178, 32596, 33426, 33579,

  8256     33725, 36638, 37017, 22475, 22969, 23186, 23504, 26151, 26522, 26757,

  8257     27599, 29028, 32629, 36023, 36067, 36993, 39749, 33032, 35978, 38476,

  8258     39488, [12230, 40613], 23391, 27667, 29467, 30450, 30431, 33804, 20906,

  8259     35219, 20813, 20885, 21193, 26825, 27796, 30468, 30496, 32191, 32236,

  8260     [12207, 38754], 40629, 28357, 34065, 20901, 21517, 21629, 26126, 26269,

  8261     26919, 28319, [12139, 30399], 30609, 33559, 33986, 34719, 37225, 37528,

  8262     40180, 34946, 20398, 20882, 21215, 22982, 24125, 24917, {f: 2, c: 25720},

  8263     26286, 26576, 27169, 27597, [12113, 27611], 29279, 29281, 29761, 30520,

  8264     [12141, 30683], 32791, 33468, 33541, 35584, 35624, 35980, [12106, 26408],

  8265     27792, 29287, [12140, 30446], 30566, 31302, 40361, 27519, 27794, 22818,

  8266     26406, 33945, 21359, 22675, 22937, 24287, 25551, 26164, 26483, 28218,

  8267     29483, 31447, 33495, 37672, 21209, 24043, 25006, 25035, 25098, 25287,

  8268     25771, [12102, 26080], 26969, 27494, [12111, 27595], 28961, 29687, 30045,

  8269     32326, 33310, 33538, 34154, 35491, 36031, 38695, 40289, 22696, 40664,

  8270     20497, 21006, 21563, 21839, [12098, 25991], 27766, {f: 2, c: 32010}, 32862,

  8271     34442, [12200, 38272], 38639, 21247, 27797, 29289, 21619, 23194, 23614,

  8272     23883, 24396, 24494, 26410, 26806, 26979, 28220, 28228, 30473,

  8273     [12150, 31859], 32654, 34183, 35598, 36855, 38753, 40692, 23735, 24758,

  8274     24845, 25003, 25935, {f: 2, c: 26107}, 27665, 27887, 29599, 29641, 32225,

  8275     38292, 23494, 34588, 35600, 21085, 21338, 25293, 25615, 25778, 26420,

  8276     27192, 27850, 29632, 29854, 31636, 31893, 32283, 33162, 33334, 34180,

  8277     36843, 38649, 39361, 20276, 21322, 21453, 21467, 25292, 25644, 25856,

  8278     26001, 27075, 27886, 28504, 29677, 30036, 30242, 30436, 30460, 30928,

  8279     [30971, 63844], 31020, 32070, 33324, 34784, 36820, 38930, 39151, 21187,

  8280     25300, 25765, 28196, 28497, 30332, 36299, 37297, 37474, 39662, 39747,

  8281     20515, 20621, 22346, 22952, 23592, 24135, 24439, 25151, 25918,

  8282     [12101, 26041], 26049, 26121, 26507, 27036, 28354, 30917, 32033, 32938,

  8283     33152, 33323, 33459, 33953, 34444, 35370, 35607, 37030, 38450, 40848,

  8284     20493, 20467, 22521, 24472, 25308, 25490, 26479, 28227, 28953, 30403,

  8285     32972, 32986, {f: 2, c: 35060}, 35097, 36064, 36649, 37197, 38506, 20271,

  8286     20336, 24091, 26575, 26658, [12137, 30333], 30334, 39748, 24161, 27146,

  8287     29033, 29140, 30058, 32321, 34115, 34281, 39132, 20240, 31567, 32624,

  8288     38309, 20961, 24070, 26805, 27710, 27726, 27867, 29359, 31684, 33539,

  8289     27861, 29754, 20731, 21128, 22721, 25816, 27287, 29863, 30294, 30887,

  8290     34327, 38370, 38713, 21342, 24321, 35722, 36776, 36783, 37002, 21029,

  8291     30629, 40009, 40712, 19993, 20482, 20853, 23643, 24183, 26142, 26170,

  8292     26564, 26821, 28851, 29953, 30149, 31177, 31453, 36647, 39200, 39432,

  8293     20445, 22561, 22577, 23542, 26222, 27493, 27921, 28282, 28541, 29668,

  8294     29995, 33769, 35036, 35091, 35676, 36628, 20239, 20693, 21264,

  8295     [12056, 21340], 23443, [24489, 63846], 26381, 31119, 33145, 33583, 34068,

  8296     35079, 35206, 36665, [36667, 64007], 39333, 39954, 26412, 20086, 20472,

  8297     22857, 23553, {f: 2, c: 23791}, 25447, 26834, 28925, 29090, 29739, 32299,

  8298     34028, 34562, 36898, 37586, 40179, [19981, 63847], 20184, 20463, 20613,

  8299     21078, 21103, 21542, 21648, 22496, 22827, 23142, 23386, 23413, 23500,

  8300     24220, 25206, 25975, 26023, 28014, 28325, [12119, 29238], 31526, 31807,

  8301     [12152, 32566], {f: 2, c: 33104}, 33178, 33344, 33433, 33705, 35331, 36000,

  8302     36070, 36091, 36212, 36282, 37096, 37340, [12201, 38428], 38468, 39385,

  8303     40167, [21271, 63843], 20998, 21545, 22132, 22707, 22868, 22894, 24575,

  8304     24996, 25198, 26128, 27774, 28954, 30406, 31881, 31966, 32027, 33452,

  8305     36033, 38640, 20315, 24343, 24447, 25282, 23849, 26379, 26842, 30844,

  8306     32323, 40300, 19989, 20633, [12052, 21269], 21290, 21329, 22915, 23138,

  8307     24199, 24754, 24970, 25161, 25209, 26000, 26503, 27047, [12112, 27604],

  8308     {f: 3, c: 27606}, 27832, 29749, 30202, 30738, 30865, 31189, 31192, 31875,

  8309     32203, 32737, 32933, 33086, 33218, 33778, 34586, 35048, 35513, 35692,

  8310     36027, 37145, [12206, 38750], [12214, 39131], [12240, 40763], 22188, 23338,

  8311     24428, 25996, 27315, 27567, 27996, 28657, 28693, 29277, 29613, 36007,

  8312     36051, 38971, 24977, 27703, 32856, 39425, 20045, 20107, 20123, 20181,

  8313     20282, 20284, 20351, 20447, 20735, 21490, 21496, 21766, 21987, 22235,

  8314     [12064, 22763], 22882, 23057, 23531, 23546, 23556, 24051, 24107, 24473,

  8315     24605, 25448, 26012, 26031, 26614, 26619, 26797, 27515, 27801, 27863,

  8316     28195, 28681, 29509, 30722, 31038, 31040, 31072, 31169, 31721, 32023,

  8317     32114, 32902, 33293, 33678, 34001, 34503, 35039, 35408, 35422, 35613,

  8318     36060, 36198, 36781, 37034, 39164, 39391, 40605, 21066, 26388, 20632,

  8319     21034, [12077, 23665], 25955, 27733, 29642, 29987, 30109, 31639, 33948,

  8320     37240, 38704, 20087, 25746, [27578, 63856], 29022, 34217, 19977, 26441,

  8321     26862, 28183, 33439, 34072, 34923, 25591, 28545, 37394, 39087, 19978,

  8322     20663, 20687, 20767, 21830, 21930, 22039, 23360, 23577, 23776, 24120,

  8323     24202, 24224, 24258, 24819, 26705, 27233, 28248, 29245, 29248,

  8324     [29376, 63994], 30456, 31077, 31665, 32724, 35059, 35316, 35443, 35937,

  8325     36062, 38684, [22622, 63852], 29885, 36093, 21959, 31329, [32034, 63850],

  8326     [12170, 33394], 29298, [12131, 29983], 29989, 31513, 22661, 22779, 23996,

  8327     24207, 24246, 24464, 24661, 25234, 25471, 25933, 26257, 26329, 26360,

  8328     26646, 26866, 29312, 29790, 31598, 32110, 32214, 32626, 32997, 33298,

  8329     34223, 35199, 35475, 36893, 37604, [12233, 40653], [12239, 40736],

  8330     [12067, 22805], 22893, 24109, 24796, 26132, 26227, 26512, 27728, 28101,

  8331     28511, [12143, 30707], 30889, 33990, 37323, 37675, 20185, 20682, 20808,

  8332     21892, 23307, 23459, 25159, 25982, 26059, 28210, 29053, 29697, 29764,

  8333     29831, 29887, 30316, 31146, 32218, 32341, 32680, 33146, 33203, 33337,

  8334     34330, 34796, 35445, 36323, 36984, 37521, 37925, 39245, 39854, 21352,

  8335     23633, 26964, 27844, 27945, 28203, [12166, 33292], 34203, 35131, 35373,

  8336     [35498, 63855, 63905], 38634, 40807, 21089, 26297, 27570, 32406, 34814,

  8337     36109, 38275, 38493, 25885, 28041, 29166, 22478, 22995, 23468, 24615,

  8338     24826, 25104, 26143, 26207, 29481, 29689, 30427, [30465, 63853], 31596,

  8339     32854, 32882, 33125, 35488, 37266, 19990, 21218, 27506, 27927, 31237,

  8340     31545, 32048, 36016, 21484, 22063, 22609, 23477, [12073, 23567], 23569,

  8341     24034, 25152, 25475, 25620, 26157, 26803, 27836, 28040, 28335, 28703,

  8342     28836, 29138, 29990, 30095, 30094, 30233, 31505, 31712, 31787, 32032,

  8343     32057, 34092, 34157, 34311, 35380, 36877, 36961, 37045, 37559, 38902,

  8344     39479, 20439, 23660, 26463, 28049, 31903, 32396, 35606, 36118, 36895,

  8345     23403, 24061, 25613, 33984, 36956, 39137, [29575, 63841, 63963], 23435,

  8346     24730, 26494, 28126, 35359, 35494, 36865, 38924, 21047, 28753, 30862,

  8347     37782, 34928, 37335, 20462, 21463, 22013, 22234, 22402, 22781, 23234,

  8348     23432, 23723, 23744, 24101, 24833, 25101, [12095, 25163], 25480, 25628,

  8349     25910, [25976, 63849], 27193, 27530, [12116, 27700], 27929, 28465, 29159,

  8350     29417, 29560, 29703, 29874, 30246, 30561, 31168, 31319, 31466, 31929,

  8351     32143, 32172, 32353, 32670, 33065, 33585, 33936, 34010, 34282, 34966,

  8352     35504, 35728, 36664, 36930, 36995, 37228, 37526, 37561, 38539,

  8353     {f: 2, c: 38567}, 38614, 38656, 38920, [12216, 39318], 39635, 39706, 21460,

  8354     22654, 22809, 23408, 23487, 28113, 28506, 29087, 29729, 29881, 32901,

  8355     33789, 24033, 24455, 24490, 24642, 26092, 26642, 26991, 27219, 27529,

  8356     27957, 28147, 29667, 30462, 30636, 31565, 32020, 33059, 33308, 33600,

  8357     34036, 34147, 35426, 35524, 37255, 37662, 38918, 39348, 25100, 34899,

  8358     36848, 37477, 23815, 23847, 23913, 29791, 33181, 34664, 28629,

  8359     [25342, 63859], 32722, 35126, 35186, 19998, 20056, 20711, 21213, 21319,

  8360     25215, 26119, 32361, 34821, 38494, 20365, 21273, 22070, 22987, 23204,

  8361     [12075, 23608], 23630, 23629, 24066, 24337, 24643, 26045, 26159, 26178,

  8362     26558, 26612, 29468, [12142, 30690], [12144, 31034], 32709, 33940, 33997,

  8363     35222, 35430, 35433, 35553, [12183, 35925], 35962, 22516, 23508, 24335,

  8364     24687, 25325, 26893, 27542, 28252, 29060, 31698, 34645, [35672, 63996],

  8365     36606, [12215, 39135], 39166, 20280, 20353, 20449, 21627, 23072, 23480,

  8366     24892, 26032, 26216, 29180, 30003, 31070, 32051, 33102, [12162, 33251],

  8367     33688, 34218, 34254, 34563, 35338, [12189, 36523], [12191, 36763], 36805,

  8368     22833, 23460, 23526, 24713, 23529, 23563, [12092, 24515], 27777, 28145,

  8369     28683, 29978, 33455, 35574, [20160, 63997], [12055, 21313], 38617,

  8370     [12114, 27663], 20126, 20420, 20818, 21854, 23077, 23784, 25105,

  8371     [12123, 29273], 33469, 33706, 34558, 34905, 35357, 38463, 38597, 39187,

  8372     40201, 40285, 22538, 23731, 23997, 24132, [24801, 63929], 24853, 25569,

  8373     [27138, 63764, 63836, 63935], 28197, 37122, 37716, 38990, 39952, 40823,

  8374     23433, 23736, 25353, 26191, 26696, 30524, 38593, 38797, 38996, 39839,

  8375     26017, 35585, 36555, 38332, 21813, 23721, 24022, 24245, 26263, 30284,

  8376     33780, 38343, 22739, 25276, 29390, 40232, 20208, 22830, 24591, 26171,

  8377     27523, 31207, 40230, 21395, 21696, 22467, 23830, 24859, 26326, 28079,

  8378     30861, 33406, 38552, 38724, 21380, 25212, 25494, 28082, 32266, 33099,

  8379     38989, 27387, 32588, 40367, 40474, 20063, 20539, 20918, 22812, 24825,

  8380     25590, 26928, 29242, 32822, 37326, 24369, 32004, [33509, 63860], 33903,

  8381     33979, 34277, 36493, 20335, 22756, 23363, 24665, 25562, 25880, 25965,

  8382     26264, 26954, 27171, 27915, 28673, 29036, 30162, 30221, 31155, 31344,

  8383     [12154, 32650], 35140, 35731, 37312, 38525, 39178, 22276, 24481, 26044,

  8384     28417, 30208, 31142, 35486, 39341, [12226, 39770], 40812, 20740, 25014,

  8385     25233, 27277, 33222, 20547, 22576, 24422, 28937, [12180, 35328], 35578,

  8386     23420, 34326, 20474, 20796, 22196, 22852, 25513, 28153, 23978, 26989,

  8387     20870, 20104, 20313, 22914, 27487, 27741, 29877, 30998, 33287, 33349,

  8388     33593, 36671, 36701, 39192, 20134, 22495, 24441, [26131, 63968], 30123,

  8389     32377, 35695, 36870, 39515, 22181, 22567, 23032, 23071, 23476, 24310,

  8390     25424, 25403, 26941, 27783, 27839, 28046, 28051, 28149, 28436, 28895,

  8391     28982, 29017, 29123, 29141, 30799, 30831, 31605, 32227, 32303, 34893,

  8392     36575, 37467, 40182, 24709, 28037, 29105, 38321, 21421, 26579, 28814,

  8393     28976, 29744, 33398, 33490, 38331, 39653, 40573, 26308, 29121,

  8394     [33865, 63854], 22603, 23992, 24433, 26144, 26254, 27001, 27054, 27704,

  8395     27891, 28214, 28481, 28634, 28699, 28719, 29008, 29151, 29552, 29787,

  8396     29908, 30408, 31310, 32403, 33521, 35424, 36814, 37704, 38681, 20034,

  8397     20522, 21000, 21473, 26355, 27757, 28618, 29450, 30591, 31330, 33454,

  8398     34269, 34306, 35028, 35427, 35709, 35947, 37555, 38675, 38928, 20116,

  8399     20237, 20425, 20658, 21320, 21566, 21555, 21978, 22626, 22714, 22887,

  8400     23067, 23524, 24735, 25034, 25942, 26111, 26212, 26791, 27738, 28595,

  8401     28879, 29100, 29522, 31613, 34568, 35492, 39986, 40711, 23627, 27779,

  8402     29508, [12127, 29577], 37434, 28331, 29797, 30239, 31337, 32277, 34314,

  8403     20800, 22725, 25793, 29934, 29973, 30320, 32705, 37013, 38605, 39252,

  8404     28198, [12129, 29926], {f: 2, c: 31401}, 33253, 34521, 34680, 35355, 23113,

  8405     23436, 23451, 26785, 26880, 28003, 29609, 29715, 29740, 30871, 32233,

  8406     32747, 33048, 33109, 33694, 35916, [38446, 63942], 38929, [12104, 26352],

  8407     24448, 26106, 26505, 27754, 29579, 20525, 23043, 27498, 30702, 22806,

  8408     23916, 24013, 29477, 30031, 20709, 20985, 22575, 22829, 22934, 23002,

  8409     23525, 23970, 25303, 25622, 25747, 25854, 26332, 27208, 29183, 29796,

  8410     31368, 31407, 32327, 32350, 32768, 33136, 34799, 35201, 35616, 36953,

  8411     36992, 39250, 24958, 27442, 28020, 32287, 35109, 36785, 20433, 20653,

  8412     20887, 21191, 22471, 22665, 23481, 24248, 24898, 27029, 28044, 28263,

  8413     28342, 29076, 29794, [12132, 29992], 29996, 32883, 33592, 33993, 36362,

  8414     37780, 37854, 20110, 20305, 20598, 20778, [12060, 21448], 21451, 21491,

  8415     23431, 23507, 23588, 24858, 24962, 26100, [12124, 29275], 29591, 29760,

  8416     30402, 31056, 31121, 31161, 32006, [12155, 32701], 33419, 34261, 34398,

  8417     36802, 36935, 37109, 37354, 38533, [12204, 38632], 38633, 21206, 24423,

  8418     26093, 26161, 26671, 29020, 31286, 37057, 38922, 20113, 27218, 27550,

  8419     28560, 29065, 32792, 33464, 34131, 36939, 38549, 38642, 38907, 34074,

  8420     39729, 20112, 29066, 38596, 20803, 21407, 21729, 22291, 22290, 22435,

  8421     23195, 23236, 23491, 24616, 24895, 25588, 27781, 27961, 28274, 28304,

  8422     29232, 29503, 29783, 33489, 34945, 36677, 36960, 38498, 39000, 40219,

  8423     [12105, 26376], 36234, 37470, 20301, 20553, 20702, 21361, 22285, 22996,

  8424     23041, 23561, 24944, 26256, 28205, 29234, 29771, 32239, 32963, 33806,

  8425     33894, 34111, 34655, 34907, 35096, 35586, 36949, [12209, 38859], 39759,

  8426     20083, 20369, 20754, 20842, 21807, 21929, 23418, 23461, {f: 2, c: 24188},

  8427     24254, 24736, 24799, {f: 2, c: 24840}, 25540, 25912, 26377, 26580, 26586,

  8428     {f: 2, c: 26977}, 27833, 27943, 28216, 28641, {f: 2, c: 29494}, 29788,

  8429     30001, 30290, 32173, 33278, 33848, 35029, 35480, 35547, 35565, 36400,

  8430     36418, 36938, 36926, 36986, [12195, 37193], 37321, 37742, 22537, 27603,

  8431     [12161, 32905], 32946, 20801, 22891, 23609, 28516, 29607, 32996, 36103,

  8432     37399, 38287, [12160, 32895], 25102, 28700, 32104, 34701, 22432, 24681,

  8433     24903, 27575, 35518, 37504, 38577, [12036, 20057], 21535, 28139, 34093,

  8434     38512, [12211, 38899], 39150, 25558, 27875, [12194, 37009], 20957, 25033,

  8435     33210, 40441, 20381, 20506, 20736, 23452, 24847, 25087, 25836, 26885,

  8436     27589, 30097, 30691, 32681, 33380, 34191, 34811, [12176, 34915], 35516,

  8437     35696, 37291, [12038, 20108], 20197, 20234, 22839, 23016, 24050, 24347,

  8438     24411, 24609, 29246, 29669, [30064, 63842], 30157, 31227, [12157, 32780],

  8439     [12159, 32819], 32900, 33505, 33617, 36029, 36019, 36999, 39156, 39180,

  8440     28727, 30410, 32714, 32716, 32764, 35610, [12040, 20154], 20161, 20995,

  8441     21360, [21693, 63902], 22240, 23035, 23493, 24341, 24525, 28270, 32106,

  8442     33589, 34451, 35469, 38765, 38775, [12032, 19968], 20314, 20350, 22777,

  8443     [12103, 26085], 28322, 36920, 37808, 39353, 20219, 22764, 22922, 23001,

  8444     24641, 31252, 33615, 36035, [12042, 20837], 21316, 20173, 21097, 23381,

  8445     33471, 20180, [21050, 63999], 21672, 22985, 23039, [12070, 23376], 23383,

  8446     23388, 24675, 24904, 28363, [28825, 63995], 29038, 29574, 29943, 30133,

  8447     30913, 32043, 32773, [12163, 33258], 33576, 34071, 34249, 35566, 36039,

  8448     38604, 20316, 21242, 22204, 26027, 26152, 28796, 28856, 29237, 32189,

  8449     33421, 37196, 38592, 40306, 23409, 26855, 27544, 28538, 30430, 23697,

  8450     26283, 28507, 31668, 31786, 34870, 38620, 19976, 20183, 21280, 22580,

  8451     22715, 22767, 22892, 23559, 24115, 24196, 24373, 25484, 26290, 26454,

  8452     27167, 27299, 27404, 28479, 29254, 29520, 29835, 31456, 31911, 33144,

  8453     33247, 33255, 33674, 33900, 34083, 34196, 34255, 35037, 36115, 37292,

  8454     [12199, 38263], 38556, 20877, 21705, 22312, 23472, 25165, 26448, 26685,

  8455     26771, 28221, 28371, 28797, 32289, 35009, 36001, 36617, 40779, 40782,

  8456     29229, 31631, 35533, 37658, 20295, 20302, 20786, 21632, 22992, 24213,

  8457     25269, 26485, 26990, 27159, 27822, 28186, 29401, 29482, 30141, 31672,

  8458     32053, 33511, 33785, 33879, 34295, 35419, 36015, 36487, 36889, 37048,

  8459     38606, 40799, 21219, 21514, 23265, 23490, 25688, 25973, 28404, 29380,

  8460     30340, 31309, 31515, 31821, 32318, 32735, 33659, 35627, 36042,

  8461     [12186, 36196], 36321, 36447, 36842, 36857, 36969, 37841, 20291, 20346,

  8462     20659, 20840, 20856, 21069, 21098, 22625, 22652, 22880, 23560, 23637,

  8463     24283, 24731, 25136, 26643, 27583, 27656, 28593, 29006, 29728,

  8464     [12133, 30000], 30008, 30033, 30322, 31564, 31627, 31661, 31686, 32399,

  8465     35438, 36670, 36681, 37439, 37523, 37666, 37931, 38651, 39002, 39019,

  8466     39198, [20999, 64000], 25130, 25240, 27993, 30308, 31434, 31680, 32118,

  8467     21344, 23742, 24215, 28472, 28857, 31896, 38673, 39822, 40670, 25509,

  8468     25722, 34678, 19969, 20117, 20141, 20572, 20597, 21576, 22979, 23450,

  8469     24128, 24237, 24311, 24449, 24773, 25402, 25919, 25972, 26060, 26230,

  8470     26232, 26622, 26984, 27273, 27491, 27712, 28096, 28136, 28191, 28254,

  8471     28702, 28833, 29582, 29693, 30010, 30555, 30855, 31118, 31243, 31357,

  8472     31934, 32142, 33351, 35330, 35562, 35998, 37165, 37194, 37336, 37478,

  8473     37580, 37664, 38662, 38742, 38748, 38914, [12237, 40718], 21046, 21137,

  8474     21884, 22564, 24093, 24351, 24716, 25552, 26799, 28639, 31085, 31532,

  8475     33229, 34234, 35069, 35576, 36420, 37261, 38500, 38555, 38717, 38988,

  8476     [12241, 40778], 20430, 20806, 20939, 21161, 22066, 24340, 24427, 25514,

  8477     25805, 26089, 26177, 26362, 26361, 26397, 26781, 26839, 27133, 28437,

  8478     28526, 29031, 29157, [12118, 29226], 29866, 30522, 31062, 31066, 31199,

  8479     31264, 31381, 31895, 31967, 32068, 32368, 32903, 34299, 34468, 35412,

  8480     35519, 36249, 36481, 36896, 36973, 37347, 38459, 38613, [12227, 40165],

  8481     26063, 31751, [12188, 36275], 37827, 23384, 23562, 21330, 25305, 29469,

  8482     20519, 23447, 24478, 24752, 24939, 26837, 28121, 29742, 31278, 32066,

  8483     32156, 32305, 33131, 36394, 36405, 37758, 37912, 20304, 22352, 24038,

  8484     24231, 25387, 32618, 20027, 20303, 20367, 20570, 23005, 32964, 21610,

  8485     21608, 22014, 22863, 23449, 24030, 24282, 26205, 26417, 26609, 26666,

  8486     27880, 27954, 28234, 28557, 28855, 29664, 30087, 31820, 32002, 32044,

  8487     32162, [12168, 33311], 34523, 35387, 35461, [12187, 36208], 36490, 36659,

  8488     36913, 37198, 37202, 37956, 39376, [12149, 31481], 31909, 20426, 20737,

  8489     20934, 22472, 23535, 23803, 26201, 27197, 27994, 28310, 28652, 28940,

  8490     30063, 31459, 34850, 36897, 36981, 38603, 39423, 33537, 20013, 20210,

  8491     34886, 37325, 21373, 27355, 26987, 27713, 33914, 22686, 24974, 26366,

  8492     25327, 28893, 29969, 30151, 32338, 33976, 35657, 36104, 20043, 21482,

  8493     21675, 22320, 22336, 24535, 25345, 25351, 25711, [12096, 25903], 26088,

  8494     26234, 26525, 26547, [12108, 27490], 27744, 27802, 28460, 30693, 30757,

  8495     31049, 31063, 32025, 32930, 33026, [12164, 33267], 33437, 33463, 34584,

  8496     35468, 36100, 36286, 36978, 30452, 31257, 31287, 32340, 32887, 21767,

  8497     21972, 22645, 25391, 25634, 26185, 26187, 26733, 27035, 27524, 27941,

  8498     28337, 29645, 29800, 29857, 30043, 30137, 30433, 30494, 30603, 31206,

  8499     32265, 32285, 33275, 34095, 34967, 35386, 36049, 36587,

  8500     [12192, 36784, 63857], 36914, 37805, 38499, 38515, 38663, 20356, 21489,

  8501     23018, 23241, 24089, 26702, 29894, 30142, 31209, 31378, 33187, 34541,

  8502     36074, 36300, 36845, 26015, 26389, 22519, 28503, 32221, 36655, 37878,

  8503     38598, 24501, 25074, 28548, 19988, 20376, 20511, 21449, 21983, 23919,

  8504     24046, 27425, 27492, 30923, 31642, 36425, [12190, 36554, 63746], 36974,

  8505     25417, 25662, 30528, 31364, 37679, 38015, 40810, 25776, 28591, 29158,

  8506     29864, 29914, 31428, 31762, 32386, 31922, 32408, 35738, 36106, 38013,

  8507     39184, 39244, 21049, 23519, 25830, 26413, 32046, 20717, [21443, 63851],

  8508     22649, {f: 2, c: 24920}, 25082, 26028, 31449, 35730, 35734, 20489, 20513,

  8509     21109, 21809, 23100, 24288, 24432, 24884, 25950, 26124, 26166, 26274,

  8510     27085, 28356, 28466, 29462, 30241, 31379, 33081, 33369, 33750, 33980,

  8511     20661, 22512, 23488, 23528, 24425, 25505, 30758, 32181, 33756, 34081,

  8512     37319, 37365, 20874, 26613, 31574, 36012, 20932, 22971, 24765, 34389,

  8513     20508, 21076, 23610, 24957, 25114, [25299, 64002], 25842, 26021, 28364,

  8514     30240, 33034, 36448, 38495, 38587, 20191, 21315, 21912, 22825, 24029,

  8515     25797, 27849, 28154, 29588, 31359, [12167, 33307], 34214, 36068, 36368,

  8516     36983, 37351, 38369, 38433, 38854, 20984, 21746, 21894, 24505, 25764,

  8517     28552, 32180, 36639, 36685, 37941, 20681, 23574, 27838, 28155, 29979,

  8518     30651, 31805, 31844, 35449, 35522, 22558, 22974, 24086, 25463, 29266,

  8519     30090, 30571, 35548, 36028, 36626, 24307, 26228, 28152, 32893, 33729,

  8520     35531, [12205, 38737], 39894, 21059, 26367, 28053, 28399, 32224, 35558,

  8521     36910, 36958, 39636, 21021, 21119, 21736, 24980, 25220, 25307, 26786,

  8522     26898, 26970, 27189, 28818, 28966, 30813, 30977, 30990, 31186, 31245,

  8523     32918, [12171, 33400], 33493, 33609, 34121, 35970, 36229, 37218, 37259,

  8524     37294, 20419, 22225, 29165, 30679, 34560, 35320, [12072, 23544], 24534,

  8525     26449, 37032, 21474, 22618, 23541, 24740, 24961, 25696, 32317, 32880,

  8526     34085, 37507, 25774, 20652, 23828, 26368, 22684, 25277, 25512, 26894,

  8527     27000, 27166, 28267, 30394, 31179, 33467, 33833, 35535, 36264, 36861,

  8528     37138, 37195, 37276, 37648, 37656, 37786, 38619, 39478, 39949, 19985,

  8529     30044, 31069, 31482, 31569, 31689, 32302, 33988, 36441, 36468, 36600,

  8530     36880, 26149, 26943, 29763, 20986, 26414, 40668, 20805, 24544, 27798,

  8531     34802, 34909, 34935, 24756, 33205, 33795, 36101, 21462, 21561, 22068,

  8532     23094, 23601, 28810, 32736, 32858, 33030, 33261, 36259, 37257, 39519,

  8533     40434, 20596, 20164, 21408, 24827, 28204, 23652, 20360, 20516, 21988,

  8534     23769, 24159, 24677, 26772, 27835, 28100, 29118, 30164, 30196, 30305,

  8535     31258, 31305, 32199, 32251, 32622, 33268, 34473, 36636, 38601, 39347,

  8536     [12242, 40786], 21063, 21189, 39149, 35242, 19971, 26578, 28422, 20405,

  8537     23522, 26517, [27784, 63858], 28024, 29723, 30759, 37341, 37756, 34756,

  8538     31204, 31281, 24555, 20182, 21668, 21822, 22702, 22949, 24816, 25171,

  8539     25302, 26422, 26965, 33333, 38464, 39345, 39389, 20524, 21331, 21828,

  8540     22396, 25176, 25826, 26219, 26589, 28609, 28655, 29730, 29752, 35351,

  8541     37944, 21585, 22022, 22374, 24392, 24986, 27470, 28760, 28845, 32187,

  8542     35477, 22890, 33067, 25506, 30472, 32829, 36010, 22612, 25645, 27067,

  8543     23445, 24081, 28271, 34153, 20812, 21488, 22826, 24608, 24907, 27526,

  8544     27760, 27888, 31518, 32974, 33492, 36294, 37040, 39089, 25799, 28580,

  8545     25745, 25860, 20814, 21520, [12063, 22303], 35342, 24927, 26742, 30171,

  8546     31570, 32113, 36890, 22534, 27084, 33151, 35114, 36864, 38969, 20600,

  8547     22871, 22956, 25237, 36879, 39722, 24925, 29305, 38358, 22369, 23110,

  8548     24052, 25226, 25773, 25850, 26487, 27874, 27966, 29228, 29750, 30772,

  8549     32631, 33453, 36315, 38935, 21028, 22338, 26495, 29256, 29923, 36009,

  8550     36774, 37393, 38442, [12043, 20843], 21485, 25420, 20329, 21764, 24726,

  8551     25943, 27803, 28031, 29260, 29437, 31255, 35207, [12185, 35997], 24429,

  8552     28558, 28921, 33192, 24846, [20415, 63845], 20559, 25153, [12122, 29255],

  8553     31687, 32232, 32745, 36941, 38829, 39449, 36022, 22378, 24179, 26544,

  8554     33805, 35413, 21536, 23318, 24163, 24290, 24330, 25987, 32954, 34109,

  8555     38281, 38491, 20296, 21253, 21261, 21263, 21638, 21754, 22275, 24067,

  8556     24598, 25243, 25265, 25429, 27873, 28006, 30129, 30770, 32990, 33071,

  8557     33502, 33889, 33970, 34957, 35090, 36875, 37610, 39165, 39825, 24133,

  8558     [26292, 64006], 26333, 28689, 29190, 20469, 21117, 24426, 24915, 26451,

  8559     27161, 28418, 29922, 31080, 34920, 35961, 39111, 39108, 39491, 21697,

  8560     31263, 26963, 35575, 35914, [12213, 39080], 39342, 24444, 25259, 30130,

  8561     [12138, 30382], 34987, 36991, 38466, 21305, 24380, 24517, [27852, 63848],

  8562     29644, 30050, [12134, 30091], 31558, 33534, 39325, 20047, 36924, 19979,

  8563     20309, 21414, 22799, 24264, 26160, 27827, 29781, 33655, 34662, 36032,

  8564     36944, 38686, 39957, 22737, 23416, 34384, 35604, 40372, 23506, 24680,

  8565     24717, 26097, 27735, 28450, 28579, 28698, 32597, 32752, {f: 2, c: 38289},

  8566     38480, 38867, 21106, 36676, 20989, 21547, 21688, 21859, 21898, 27323,

  8567     28085, 32216, 33382, 37532, 38519, 40569, 21512, 21704, 30418, 34532,

  8568     38308, 38356, 38492, 20130, 20233, 23022, 23270, 24055, 24658, 25239,

  8569     26477, 26689, 27782, 28207, 32568, 32923, 33322, 38917, 20133, 20565,

  8570     21683, 22419, 22874, 23401, 23475, 25032, 26999, 28023, 28707, 34809,

  8571     35299, 35442, 35559, 36994, 39405, 39608, 21182, 26680, 20502, 24184,

  8572     26447, 33607, [12175, 34892, 64008], 20139, 21521, 22190, 29670, 37141,

  8573     38911, 39177, 39255, [12217, 39321], 22099, 22687, 34395, 35377, 25010,

  8574     27382, 29563, 36562, 27463, 38570, 39511, 22869, 29184, 36203,

  8575     [12208, 38761], 20436, 23796, 24358, 25080, 26203, 27883, 28843,

  8576     [12126, 29572], 29625, 29694, 30505, 30541, 32067, 32098, 32291, 33335,

  8577     34898, 36066, 37449, 39023, 23377, [12147, 31348], [12174, 34880],

  8578     [12212, 38913], 23244, 20448, 21332, 22846, 23805, 25406, 28025, 29433,

  8579     33029, 33031, 33698, 37583, 38960, 20136, 20804, 21009, 22411, 24418,

  8580     27842, 28366, 28677, 28752, 28847, 29074, 29673, [29801, 63918], 33610,

  8581     34722, 34913, 36872, 37026, 37795, 39336, 20846, 24407, 24800, 24935,

  8582     26291, 34137, 36426, 37295, 38795, 20046, 20114, 21628, 22741, 22778,

  8583     22909, 23733, 24359, [12094, 25142], 25160, 26122, 26215, 27627, 28009,

  8584     28111, 28246, 28408, 28564, 28640, 28649, 28765, 29392, 29733, 29786,

  8585     29920, 30355, 31068, 31946, 32286, 32993, 33446, 33899, 33983, 34382,

  8586     34399, 34676, 35703, 35946, 37804, 38912, 39013, 24785, 25110, 37239,

  8587     23130, 26127, 28151, 28222, 29759, 39746, 24573, 24794, 31503, 21700,

  8588     24344, 27742, 27859, 27946, 28888, 32005, 34425, 35340, 40251, 21270,

  8589     21644, 23301, 27194, [12117, 28779], 30069, 31117, [12146, 31166], 33457,

  8590     33775, 35441, 35649, 36008, 38772, 25844, 25899, {f: 2, c: 30906}, 31339,

  8591     20024, 21914, 22864, 23462, 24187, 24739, 25563, 27489, 26213, 26707,

  8592     28185, 29029, 29872, 32008, 36996, 39529, 39973, 27963, [28369, 63748],

  8593     29502, 35905, 38346, 20976, 24140, 24488, 24653, 24822, 24880, 24908,

  8594     {f: 2, c: 26179}, 27045, 27841, 28255, 28361, 28514, 29004, 29852, 30343,

  8595     31681, 31783, 33618, 34647, 36945, 38541, [12232, 40643], 21295, 22238,

  8596     24315, 24458, 24674, 24724, 25079, 26214, 26371, 27292, 28142, 28590,

  8597     28784, 29546, 32362, 33214, 33588, 34516, 35496, 36036, 21123, 29554,

  8598     23446, 27243, 37892, 21742, 22150, 23389, 25928, 25989, 26313, 26783,

  8599     28045, 28102, [12120, 29243], 32948, 37237, 39501, 20399, 20505, 21402,

  8600     21518, 21564, 21897, 21957, 24127, 24460, 26429, 29030, 29661, 36869,

  8601     21211, 21235, 22628, 22734, 28932, 29071, 29179, 34224, 35347,

  8602     [26248, 63941], 34216, 21927, 26244, 29002, 33841, 21321, 21913, 27585,

  8603     24409, 24509, 25582, 26249, 28999, 35569, 36637, 40638, 20241, 25658,

  8604     28875, 30054, 34407, 24676, 35662, 40440, 20807, 20982, 21256, 27958,

  8605     33016, [12234, 40657], 26133, 27427, 28824, 30165, 21507, 23673, 32007,

  8606     35350, [12107, 27424], 27453, 27462, 21560, 24688, 27965, 32725, 33288,

  8607     20694, 20958, 21916, 22123, 22221, 23020, 23305, 24076, 24985, 24984,

  8608     25137, 26206, 26342, 29081, {f: 2, c: 29113}, 29351, 31143, 31232, 32690,

  8609     35440, {s: 163}, {f: 4, c: 12310}, {s: 14}, 8223, 8219, {f: 2, c: 8314},

  8610     {s: 7}, 8316, 0, {f: 2, c: 8317}, {s: 23}, 700, {s: 44}, 8942, 8759,

  8611     {s: 20}, {f: 10, c: 10122}, {s: 36}, {f: 26, c: 9398}, {s: 61},

  8612     {f: 2, c: 8826}, {f: 2, c: 8910}, {f: 2, c: 8832}, {f: 4, c: 8816}, 0,

  8613     8842, 0, 8843, {f: 2, c: 8822}, 8825, {f: 2, c: 8922}, {s: 5}, 8773, 8771,

  8614     8776, 0, 8868, {s: 78}, 8244, {s: 11}, 9839, {s: 4}, 8258, {s: 4}, 10045,

  8615     0, 0, 8226, {s: 4}, {f: 2, c: 8249}, {s: 16}, 10010, 10006, 0, 9711,

  8616     {s: 3}, 10070, 0, 9676, {s: 24}, 9775, {s: 6}, 12320, 0, {f: 10, c: 10102},

  8617     {s: 17}, 12306, 12342, {s: 13}, 8710, 0, 8735, 0, {f: 2, c: 8741}, 0, 8787,

  8618     8785, {f: 2, c: 8806}, 8723, {f: 3, c: 8853}, 0, 8980, 0, 0, 8802, 0, 9649,

  8619     0, 8738, 8784, 0, 0, 8867, 0, 0, {f: 2, c: 8814}, 8837, 8836, 8713, 8716,

  8620     {f: 2, c: 8891}, 8794, 8966, {s: 6}, 12958, 0, 8252, {s: 11}, 9702, {s: 3},

  8621     9663, 9653, 9657, 9667, {s: 4}, 9674, 12849, 12857, 13259, {f: 5, c: 9327},

  8622     {s: 18}, 8656, 8655, 8653, {s: 37}, 8657, 8659, {s: 8}, 8626, 8625, 0,

  8623     8628, 8624, 8627, {s: 14}, 8636, 8640, {s: 10}, {f: 2, c: 8644}, {s: 144},

  8624     {f: 5, c: 9347}, {s: 33}, 12948, {s: 15}, 12965, {s: 93}, 8672, 8674, 8673,

  8625     8675, {s: 4}, 8678, 8680, 8679, 8681, {s: 20}, 9757, 9759, {s: 76}, 12944,

  8626     {f: 6, c: 12938}, {s: 15}, {f: 2, c: 12318}, 8246, 0, 8245, {s: 3}, 12540,

  8627     0, 0, {f: 2, c: 44034}, {f: 2, c: 44037}, {f: 5, c: 44043}, 44056,

  8628     {f: 2, c: 44062}, {f: 3, c: 44065}, {f: 7, c: 44069}, 44078,

  8629     {f: 6, c: 44082}, {f: 2, c: 44090}, {f: 3, c: 44093}, {f: 10, c: 44097},

  8630     44108, {f: 6, c: 44110}, {f: 3, c: 44117}, {f: 3, c: 44121},

  8631     {f: 19, c: 44125}, {f: 2, c: 44146}, {f: 2, c: 44149}, 44153,

  8632     {f: 5, c: 44155}, 44162, {f: 2, c: 44167}, {f: 3, c: 44173},

  8633     {f: 3, c: 44177}, {f: 7, c: 44181}, 44190, {f: 6, c: 44194}, 44203,

  8634     {f: 2, c: 44205}, {f: 7, c: 44209}, 44218, {f: 3, c: 44222},

  8635     {f: 2, c: 44226}, {f: 3, c: 44229}, {f: 3, c: 44233}, {f: 8, c: 44237},

  8636     44246, {f: 8, c: 44248}, {f: 2, c: 44258}, {f: 2, c: 44261}, 44265, 44267,

  8637     {f: 2, c: 44269}, 44274, 44276, {f: 5, c: 44279}, {f: 2, c: 44286},

  8638     {f: 3, c: 44289}, 44293, {f: 5, c: 44295}, 44302, 44304, {f: 6, c: 44306},

  8639     {f: 3, c: 44313}, {f: 3, c: 44317}, {f: 8, c: 44321}, {f: 2, c: 44330},

  8640     {f: 6, c: 44334}, {f: 2, c: 44342}, {f: 3, c: 44345}, {f: 7, c: 44349},

  8641     44358, 44360, {f: 6, c: 44362}, {f: 3, c: 44369}, {f: 3, c: 44373},

  8642     {f: 8, c: 44377}, 44386, {f: 8, c: 44388}, {f: 2, c: 44398},

  8643     {f: 2, c: 44401}, {f: 4, c: 44407}, 44414, 44416, {f: 5, c: 44419},

  8644     {f: 2, c: 44426}, {f: 3, c: 44429}, {f: 11, c: 44433}, {f: 6, c: 44446},

  8645     {f: 18, c: 44453}, {f: 8, c: 44472}, {f: 2, c: 44482}, {f: 3, c: 44485},

  8646     {f: 7, c: 44489}, 44498, {f: 8, c: 44500}, {f: 3, c: 44509},

  8647     {f: 3, c: 44513}, {f: 19, c: 44517}, {f: 2, c: 44538}, {f: 2, c: 44541},

  8648     {f: 6, c: 44546}, 44554, 44556, {f: 6, c: 44558}, {f: 27, c: 44565},

  8649     {f: 2, c: 44594}, {f: 2, c: 44597}, 44601, {f: 5, c: 44603}, 44610, 44612,

  8650     {f: 3, c: 44615}, 44619, 44623, {f: 3, c: 44625}, 44629, {f: 5, c: 44631},

  8651     44638, {f: 3, c: 44642}, {f: 2, c: 44646}, {f: 2, c: 44650},

  8652     {f: 3, c: 44653}, {f: 7, c: 44657}, 44666, {f: 6, c: 44670},

  8653     {f: 6, c: 44678}, {f: 47, c: 44685}, 44735, {f: 3, c: 44737},

  8654     {f: 7, c: 44741}, 44750, {f: 6, c: 44754}, {f: 2, c: 44762},

  8655     {f: 11, c: 44765}, {f: 2, c: 44777}, 44780, {f: 6, c: 44782},

  8656     {f: 3, c: 44789}, {f: 3, c: 44793}, {f: 10, c: 44797}, {f: 4, c: 44809},

  8657     {f: 2, c: 44814}, {f: 27, c: 44817}, {f: 2, c: 44846}, 44849, 44851,

  8658     {f: 7, c: 44853}, 44862, 44864, {f: 4, c: 44868}, {f: 6, c: 44874},

  8659     {f: 11, c: 44881}, {f: 6, c: 44894}, {f: 19, c: 44902}, {f: 6, c: 44922},

  8660     {f: 3, c: 44929}, {f: 3, c: 44933}, {f: 7, c: 44937}, {f: 3, c: 44946},

  8661     {f: 6, c: 44950}, {f: 27, c: 44957}, {f: 2, c: 44986}, {f: 3, c: 44989},

  8662     {f: 6, c: 44993}, 45002, 45004, {f: 5, c: 45007}, {f: 7, c: 45013},

  8663     {f: 11, c: 45021}, {f: 6, c: 45034}, {f: 2, c: 45042}, {f: 3, c: 45045},

  8664     {f: 7, c: 45049}, {f: 2, c: 45058}, {f: 7, c: 45061}, {f: 3, c: 45069},

  8665     {f: 3, c: 45073}, {f: 7, c: 45077}, {f: 10, c: 45086}, {f: 27, c: 45097},

  8666     {f: 2, c: 45126}, 45129, 45131, 45133, {f: 4, c: 45135}, 45142, 45144,

  8667     {f: 3, c: 45146}, {f: 30, c: 45150}, {f: 2, c: 45182}, {f: 3, c: 45185},

  8668     {f: 7, c: 45189}, 45198, 45200, {f: 6, c: 45202}, 45211, {f: 2, c: 45213},

  8669     {f: 5, c: 45219}, 45226, 45232, 45234, {f: 2, c: 45238}, {f: 3, c: 45241},

  8670     {f: 7, c: 45245}, 45254, {f: 6, c: 45258}, {f: 2, c: 45266},

  8671     {f: 3, c: 45269}, {f: 7, c: 45273}, {f: 4, c: 45281}, {f: 34, c: 45286},

  8672     45322, {f: 3, c: 45325}, 45329, {f: 4, c: 45332}, 45338, {f: 5, c: 45342},

  8673     {f: 2, c: 45350}, {f: 3, c: 45353}, {f: 7, c: 45357}, 45366,

  8674     {f: 6, c: 45370}, {f: 2, c: 45378}, {f: 3, c: 45381}, {f: 7, c: 45385},

  8675     {f: 2, c: 45394}, {f: 2, c: 45398}, {f: 3, c: 45401}, {f: 3, c: 45405},

  8676     {f: 23, c: 45409}, {f: 2, c: 45434}, {f: 3, c: 45437}, 45441,

  8677     {f: 5, c: 45443}, 45450, 45452, {f: 4, c: 45454}, {f: 3, c: 45461},

  8678     {f: 3, c: 45465}, {f: 11, c: 45469}, {f: 35, c: 45481}, {f: 3, c: 45517},

  8679     {f: 3, c: 45521}, {f: 7, c: 45525}, 45534, {f: 8, c: 45536},

  8680     {f: 2, c: 45546}, {f: 3, c: 45549}, {f: 8, c: 45553}, 45562, 45564,

  8681     {f: 6, c: 45566}, {f: 2, c: 45574}, {f: 2, c: 45577}, {f: 7, c: 45581},

  8682     45590, 45592, {f: 6, c: 45594}, {f: 19, c: 45601}, {f: 7, c: 45621},

  8683     {f: 27, c: 45629}, {f: 3, c: 45657}, {f: 3, c: 45661}, {f: 7, c: 45665},

  8684     {f: 10, c: 45674}, {f: 6, c: 45686}, {f: 7, c: 45693}, {f: 3, c: 45702},

  8685     {f: 6, c: 45706}, {f: 2, c: 45714}, {f: 3, c: 45717}, {f: 5, c: 45723},

  8686     45730, 45732, {f: 3, c: 45735}, 45739, {f: 3, c: 45741}, {f: 3, c: 45745},

  8687     {f: 19, c: 45749}, {f: 2, c: 45770}, {f: 3, c: 45773}, 45777,

  8688     {f: 5, c: 45779}, 45786, 45788, {f: 4, c: 45790}, 45795, 45799,

  8689     {f: 2, c: 45801}, {f: 3, c: 45808}, 45814, {f: 3, c: 45820},

  8690     {f: 2, c: 45826}, {f: 3, c: 45829}, {f: 7, c: 45833}, 45842,

  8691     {f: 6, c: 45846}, {f: 55, c: 45853}, 45911, {f: 2, c: 45913}, 45917,

  8692     {f: 4, c: 45920}, 45926, 45928, 45930, {f: 2, c: 45932}, 45935,

  8693     {f: 2, c: 45938}, {f: 3, c: 45941}, {f: 7, c: 45945}, 45954,

  8694     {f: 6, c: 45958}, {f: 3, c: 45965}, {f: 3, c: 45969}, {f: 11, c: 45973},

  8695     {f: 6, c: 45986}, {f: 3, c: 45993}, {f: 23, c: 45997}, {f: 2, c: 46022},

  8696     {f: 2, c: 46025}, 46029, 46031, {f: 3, c: 46033}, 46038, 46040, 46042,

  8697     46044, {f: 2, c: 46046}, {f: 3, c: 46049}, {f: 3, c: 46053},

  8698     {f: 19, c: 46057}, {f: 19, c: 46077}, {f: 7, c: 46097}, {f: 3, c: 46105},

  8699     {f: 3, c: 46109}, {f: 7, c: 46113}, 46122, {f: 8, c: 46124},

  8700     {f: 27, c: 46133}, {f: 2, c: 46162}, {f: 3, c: 46165}, {f: 7, c: 46169},

  8701     46178, 46180, {f: 6, c: 46182}, {f: 19, c: 46189}, {f: 7, c: 46209},

  8702     {f: 20, c: 46217}, {f: 6, c: 46238}, {f: 3, c: 46245}, {f: 3, c: 46249},

  8703     {f: 8, c: 46253}, 46262, 46264, {f: 6, c: 46266}, {f: 3, c: 46273},

  8704     {f: 3, c: 46277}, {f: 7, c: 46281}, {f: 4, c: 46289}, {f: 6, c: 46294},

  8705     {f: 2, c: 46302}, {f: 2, c: 46305}, 46309, {f: 5, c: 46311}, 46318, 46320,

  8706     {f: 6, c: 46322}, {f: 27, c: 46329}, {f: 2, c: 46358}, {f: 2, c: 46361},

  8707     {f: 7, c: 46365}, 46374, {f: 5, c: 46379}, {f: 2, c: 46386},

  8708     {f: 3, c: 46389}, {f: 7, c: 46393}, 46402, {f: 5, c: 46406},

  8709     {f: 2, c: 46414}, {f: 3, c: 46417}, {f: 7, c: 46421}, 46430,

  8710     {f: 62, c: 46434}, {f: 2, c: 46498}, {f: 3, c: 46501}, 46505,

  8711     {f: 4, c: 46508}, 46514, {f: 5, c: 46518}, {f: 2, c: 46526},

  8712     {f: 3, c: 46529}, {f: 7, c: 46533}, 46542, {f: 6, c: 46546},

  8713     {f: 19, c: 46553}, {f: 35, c: 46573}, {f: 2, c: 46610}, {f: 3, c: 46613},

  8714     {f: 12, c: 46617}, {f: 6, c: 46630}, {f: 7, c: 46637}, {f: 19, c: 46645},

  8715     {f: 27, c: 46665}, {f: 3, c: 46693}, {f: 51, c: 46697}, {f: 2, c: 46750},

  8716     {f: 3, c: 46753}, {f: 6, c: 46757}, {f: 4, c: 46765}, {f: 34, c: 46770},

  8717     {f: 27, c: 46805}, {f: 3, c: 46833}, {f: 3, c: 46837}, {f: 7, c: 46841},

  8718     {f: 3, c: 46850}, {f: 34, c: 46854}, {f: 2, c: 46890}, {f: 2, c: 46893},

  8719     {f: 7, c: 46897}, 46906, {f: 8, c: 46908}, {f: 3, c: 46917},

  8720     {f: 3, c: 46921}, {f: 7, c: 46925}, {f: 10, c: 46934}, {f: 3, c: 46945},

  8721     {f: 3, c: 46949}, {f: 7, c: 46953}, 46962, 46964, {f: 6, c: 46966},

  8722     {f: 2, c: 46974}, {f: 3, c: 46977}, {f: 7, c: 46981}, 46990,

  8723     {f: 3, c: 46995}, {f: 2, c: 47002}, {f: 3, c: 47005}, {f: 7, c: 47009},

  8724     47018, {f: 6, c: 47022}, {f: 2, c: 47030}, {f: 14, c: 47033}, 47048,

  8725     {f: 34, c: 47050}, {f: 2, c: 47086}, {f: 3, c: 47089}, {f: 7, c: 47093},

  8726     47102, {f: 5, c: 47106}, {f: 2, c: 47114}, {f: 3, c: 47117},

  8727     {f: 7, c: 47121}, 47130, 47132, {f: 6, c: 47134}, {f: 2, c: 47142},

  8728     {f: 3, c: 47145}, {f: 7, c: 47149}, 47158, {f: 6, c: 47162},

  8729     {f: 3, c: 47169}, {f: 12, c: 47173}, 47186, {f: 8, c: 47188},

  8730     {f: 2, c: 47198}, {f: 3, c: 47201}, {f: 7, c: 47205}, 47214, 47216,

  8731     {f: 6, c: 47218}, {f: 3, c: 47225}, {f: 16, c: 47229}, {f: 26, c: 47246},

  8732     {f: 7, c: 47273}, {f: 3, c: 47281}, {f: 3, c: 47285}, {f: 7, c: 47289},

  8733     47298, 47300, {f: 6, c: 47302}, {f: 3, c: 47309}, {f: 3, c: 47313},

  8734     {f: 8, c: 47317}, 47326, 47328, {f: 6, c: 47330}, {f: 2, c: 47338},

  8735     {f: 3, c: 47341}, {f: 7, c: 47345}, 47354, 47356, {f: 6, c: 47358},

  8736     {f: 19, c: 47365}, {f: 7, c: 47385}, {f: 27, c: 47393}, {f: 2, c: 47422},

  8737     {f: 3, c: 47425}, {f: 7, c: 47429}, {f: 2, c: 47437}, 47440,

  8738     {f: 6, c: 47442}, {f: 2, c: 47450}, {f: 3, c: 47453}, {f: 7, c: 47457},

  8739     47466, 47468, {f: 6, c: 47470}, {f: 2, c: 47478}, {f: 3, c: 47481},

  8740     {f: 7, c: 47485}, 47494, 47496, {f: 2, c: 47499}, {f: 29, c: 47503},

  8741     {f: 2, c: 47534}, {f: 3, c: 47537}, {f: 7, c: 47541}, 47550, 47552,

  8742     {f: 6, c: 47554}, {f: 2, c: 47562}, 47565, {f: 5, c: 47571}, 47578, 47580,

  8743     {f: 2, c: 47583}, 47586, {f: 2, c: 47590}, {f: 3, c: 47593},

  8744     {f: 7, c: 47597}, 47606, {f: 5, c: 47611}, {f: 6, c: 47618},

  8745     {f: 12, c: 47625}, {f: 34, c: 47638}, {f: 2, c: 47674}, {f: 3, c: 47677},

  8746     47681, {f: 5, c: 47683}, 47690, 47692, {f: 4, c: 47695}, {f: 2, c: 47702},

  8747     {f: 3, c: 47705}, {f: 7, c: 47709}, 47718, {f: 6, c: 47722},

  8748     {f: 2, c: 47730}, {f: 3, c: 47733}, {f: 10, c: 47737}, 47750,

  8749     {f: 4, c: 47752}, {f: 27, c: 47757}, 47786, {f: 3, c: 47789}, 47793,

  8750     {f: 5, c: 47795}, 47802, 47804, {f: 6, c: 47806}, {f: 3, c: 47813},

  8751     {f: 15, c: 47817}, {f: 34, c: 47834}, {f: 3, c: 47869}, {f: 3, c: 47873},

  8752     {f: 8, c: 47877}, 47886, 47888, {f: 6, c: 47890}, {f: 3, c: 47897},

  8753     {f: 3, c: 47901}, {f: 8, c: 47905}, 47914, {f: 8, c: 47916}, 47927,

  8754     {f: 2, c: 47929}, {f: 5, c: 47935}, 47942, 47944, {f: 3, c: 47946}, 47950,

  8755     {f: 3, c: 47953}, {f: 3, c: 47957}, {f: 8, c: 47961}, 47970,

  8756     {f: 8, c: 47972}, {f: 27, c: 47981}, {f: 3, c: 48009}, {f: 3, c: 48013},

  8757     {f: 19, c: 48017}, {f: 3, c: 48037}, {f: 3, c: 48041}, {f: 7, c: 48045},

  8758     {f: 2, c: 48053}, {f: 8, c: 48056}, {f: 3, c: 48065}, {f: 3, c: 48069},

  8759     {f: 7, c: 48073}, {f: 2, c: 48081}, {f: 36, c: 48084}, {f: 2, c: 48122},

  8760     {f: 2, c: 48125}, 48129, {f: 5, c: 48131}, 48138, 48142, 48144,

  8761     {f: 2, c: 48146}, {f: 2, c: 48153}, {f: 4, c: 48160}, 48166, 48168,

  8762     {f: 3, c: 48170}, {f: 2, c: 48174}, {f: 2, c: 48178}, {f: 3, c: 48181},

  8763     {f: 7, c: 48185}, 48194, {f: 3, c: 48198}, {f: 2, c: 48202},

  8764     {f: 2, c: 48206}, {f: 12, c: 48209}, {f: 38, c: 48222}, {f: 2, c: 48262},

  8765     {f: 2, c: 48265}, 48269, {f: 5, c: 48271}, 48278, 48280, {f: 5, c: 48283},

  8766     {f: 2, c: 48290}, {f: 2, c: 48293}, {f: 7, c: 48297}, 48306,

  8767     {f: 6, c: 48310}, {f: 2, c: 48318}, {f: 3, c: 48321}, {f: 8, c: 48325},

  8768     48334, {f: 3, c: 48338}, {f: 2, c: 48342}, {f: 3, c: 48345},

  8769     {f: 23, c: 48349}, 48375, {f: 3, c: 48377}, {f: 7, c: 48381}, 48390, 48392,

  8770     {f: 6, c: 48394}, {f: 3, c: 48401}, {f: 15, c: 48405}, {f: 7, c: 48421},

  8771     {f: 19, c: 48429}, {f: 7, c: 48449}, {f: 2, c: 48458}, {f: 3, c: 48461},

  8772     {f: 7, c: 48465}, {f: 10, c: 48474}, {f: 3, c: 48485}, {f: 23, c: 48489},

  8773     {f: 2, c: 48514}, {f: 2, c: 48517}, {f: 5, c: 48523}, 48530, 48532,

  8774     {f: 3, c: 48534}, 48539, {f: 7, c: 48541}, {f: 11, c: 48549},

  8775     {f: 7, c: 48561}, {f: 27, c: 48569}, {f: 2, c: 48598}, {f: 3, c: 48601},

  8776     {f: 12, c: 48605}, {f: 6, c: 48618}, {f: 3, c: 48625}, {f: 3, c: 48629},

  8777     {f: 7, c: 48633}, {f: 2, c: 48641}, 48644, {f: 6, c: 48646},

  8778     {f: 2, c: 48654}, {f: 3, c: 48657}, {f: 7, c: 48661}, 48670,

  8779     {f: 36, c: 48672}, {f: 2, c: 48710}, {f: 3, c: 48713}, 48717,

  8780     {f: 5, c: 48719}, 48726, 48728, {f: 4, c: 48732}, {f: 2, c: 48738},

  8781     {f: 3, c: 48741}, 48745, {f: 5, c: 48747}, 48754, {f: 5, c: 48758},

  8782     {f: 2, c: 48766}, {f: 3, c: 48769}, {f: 7, c: 48773}, 48782,

  8783     {f: 6, c: 48786}, {f: 14, c: 48794}, {f: 39, c: 48809}, {f: 2, c: 48850},

  8784     {f: 2, c: 48853}, {f: 7, c: 48857}, {f: 2, c: 48865}, {f: 6, c: 48870},

  8785     {f: 20, c: 48877}, {f: 6, c: 48898}, {f: 14, c: 48906}, 48922,

  8786     {f: 34, c: 48926}, {f: 2, c: 48962}, {f: 3, c: 48965}, {f: 7, c: 48969},

  8787     {f: 3, c: 48978}, {f: 62, c: 48982}, {f: 27, c: 49045}, {f: 20, c: 49073},

  8788     {f: 6, c: 49094}, {f: 2, c: 49102}, {f: 3, c: 49105}, {f: 7, c: 49109},

  8789     {f: 2, c: 49117}, 49120, {f: 90, c: 49122}, {f: 20, c: 49213},

  8790     {f: 6, c: 49234}, {f: 3, c: 49241}, {f: 3, c: 49245}, {f: 7, c: 49249},

  8791     {f: 38, c: 49258}, {f: 2, c: 49298}, {f: 3, c: 49301}, {f: 7, c: 49305},

  8792     49314, 49316, {f: 6, c: 49318}, 49326, {f: 2, c: 49329}, {f: 5, c: 49335},

  8793     49342, {f: 3, c: 49346}, {f: 2, c: 49350}, {f: 2, c: 49354},

  8794     {f: 3, c: 49357}, {f: 7, c: 49361}, 49370, {f: 6, c: 49374},

  8795     {f: 2, c: 49382}, {f: 3, c: 49385}, {f: 7, c: 49389}, 49398, 49400,

  8796     {f: 6, c: 49402}, {f: 3, c: 49409}, {f: 3, c: 49413}, {f: 7, c: 49417},

  8797     {f: 4, c: 49425}, {f: 6, c: 49430}, {f: 2, c: 49441}, 49445,

  8798     {f: 4, c: 49448}, 49454, {f: 4, c: 49458}, 49463, {f: 2, c: 49466},

  8799     {f: 3, c: 49469}, {f: 7, c: 49473}, 49482, {f: 6, c: 49486},

  8800     {f: 2, c: 49494}, {f: 3, c: 49497}, {f: 7, c: 49501}, 49510,

  8801     {f: 6, c: 49514}, {f: 3, c: 49521}, {f: 3, c: 49525}, {f: 12, c: 49529},

  8802     {f: 6, c: 49542}, 49551, {f: 3, c: 49553}, 49557, {f: 5, c: 49559}, 49566,

  8803     49568, {f: 3, c: 49570}, {f: 2, c: 49574}, {f: 2, c: 49578},

  8804     {f: 3, c: 49581}, {f: 12, c: 49585}, {f: 6, c: 49598}, {f: 3, c: 49605},

  8805     {f: 3, c: 49609}, {f: 7, c: 49613}, {f: 2, c: 49621}, {f: 7, c: 49625},

  8806     {f: 3, c: 49633}, {f: 3, c: 49637}, {f: 7, c: 49641}, 49650,

  8807     {f: 8, c: 49652}, {f: 2, c: 49662}, {f: 3, c: 49665}, {f: 7, c: 49669},

  8808     49678, 49680, {f: 6, c: 49682}, {f: 2, c: 49690}, {f: 2, c: 49693},

  8809     {f: 7, c: 49697}, 49706, 49708, 49710, 49712, 49715, {f: 19, c: 49717},

  8810     {f: 7, c: 49737}, {f: 2, c: 49746}, {f: 3, c: 49749}, {f: 7, c: 49753},

  8811     {f: 4, c: 49761}, {f: 6, c: 49766}, {f: 2, c: 49774}, {f: 3, c: 49777},

  8812     {f: 7, c: 49781}, 49790, 49792, {f: 6, c: 49794}, {f: 6, c: 49802},

  8813     {f: 7, c: 49809}, {f: 2, c: 49817}, 49820, {f: 6, c: 49822},

  8814     {f: 2, c: 49830}, {f: 3, c: 49833}, {f: 6, c: 49838}, 49846, 49848,

  8815     {f: 34, c: 49850}, {f: 2, c: 49886}, {f: 2, c: 49889}, {f: 6, c: 49893},

  8816     49902, 49904, {f: 4, c: 49906}, 49911, 49914, {f: 3, c: 49917},

  8817     {f: 7, c: 49921}, {f: 2, c: 49930}, {f: 5, c: 49934}, {f: 2, c: 49942},

  8818     {f: 3, c: 49945}, {f: 7, c: 49949}, {f: 2, c: 49958}, {f: 27, c: 49962},

  8819     {f: 34, c: 49990}, {f: 2, c: 50026}, {f: 3, c: 50029}, 50033,

  8820     {f: 5, c: 50035}, {f: 2, c: 50042}, {f: 6, c: 50046}, {f: 3, c: 50053},

  8821     {f: 3, c: 50057}, {f: 51, c: 50061}, {f: 23, c: 50113}, {f: 2, c: 50138},

  8822     {f: 2, c: 50141}, 50145, {f: 5, c: 50147}, {f: 3, c: 50154},

  8823     {f: 6, c: 50158}, {f: 2, c: 50166}, {f: 15, c: 50169}, {f: 7, c: 50185},

  8824     {f: 19, c: 50193}, {f: 7, c: 50213}, {f: 3, c: 50221}, {f: 3, c: 50225},

  8825     {f: 7, c: 50229}, {f: 10, c: 50238}, {f: 27, c: 50249}, {f: 2, c: 50278},

  8826     {f: 3, c: 50281}, {f: 7, c: 50285}, {f: 3, c: 50294}, {f: 6, c: 50298},

  8827     {f: 19, c: 50305}, {f: 7, c: 50325}, {f: 27, c: 50333}, {f: 3, c: 50361},

  8828     {f: 44, c: 50365}, {f: 6, c: 50410}, {f: 2, c: 50418}, {f: 3, c: 50421},

  8829     50425, {f: 4, c: 50427}, {f: 10, c: 50434}, {f: 3, c: 50445},

  8830     {f: 3, c: 50449}, {f: 7, c: 50453}, {f: 11, c: 50461}, {f: 2, c: 50474},

  8831     {f: 3, c: 50477}, {f: 7, c: 50481}, 50490, 50492, {f: 6, c: 50494},

  8832     {f: 2, c: 50502}, 50507, {f: 4, c: 50511}, 50518, {f: 3, c: 50522}, 50527,

  8833     {f: 2, c: 50530}, {f: 3, c: 50533}, {f: 7, c: 50537}, 50546,

  8834     {f: 6, c: 50550}, {f: 2, c: 50558}, {f: 3, c: 50561}, {f: 2, c: 50565},

  8835     {f: 4, c: 50568}, 50574, 50576, {f: 3, c: 50578}, 50582, {f: 3, c: 50585},

  8836     {f: 3, c: 50589}, {f: 8, c: 50593}, {f: 10, c: 50602}, {f: 2, c: 50614},

  8837     50618, {f: 5, c: 50623}, 50635, 50637, 50639, {f: 2, c: 50642},

  8838     {f: 3, c: 50645}, {f: 7, c: 50649}, 50658, 50660, {f: 6, c: 50662}, 50671,

  8839     {f: 3, c: 50673}, 50677, {f: 4, c: 50680}, {f: 3, c: 50690},

  8840     {f: 3, c: 50697}, {f: 3, c: 50701}, {f: 7, c: 50705}, 50714,

  8841     {f: 7, c: 50717}, {f: 2, c: 50726}, {f: 3, c: 50729}, 50735,

  8842     {f: 2, c: 50737}, 50742, 50744, 50746, {f: 4, c: 50748}, {f: 2, c: 50754},

  8843     {f: 3, c: 50757}, {f: 7, c: 50761}, 50770, {f: 6, c: 50774},

  8844     {f: 2, c: 50782}, {f: 11, c: 50785}, {f: 2, c: 50797}, 50800,

  8845     {f: 6, c: 50802}, {f: 2, c: 50810}, {f: 3, c: 50813}, {f: 7, c: 50817},

  8846     50826, 50828, {f: 6, c: 50830}, {f: 2, c: 50838}, {f: 3, c: 50841},

  8847     {f: 7, c: 50845}, 50854, 50856, {f: 6, c: 50858}, {f: 2, c: 50866},

  8848     {f: 3, c: 50869}, {f: 5, c: 50875}, 50882, 50884, {f: 6, c: 50886},

  8849     {f: 2, c: 50894}, {f: 3, c: 50897}, {f: 7, c: 50901}, {f: 2, c: 50910},

  8850     {f: 6, c: 50914}, {f: 2, c: 50922}, {f: 3, c: 50925}, {f: 7, c: 50929},

  8851     {f: 3, c: 50938}, {f: 6, c: 50942}, {f: 2, c: 50950}, {f: 3, c: 50953},

  8852     {f: 7, c: 50957}, 50966, 50968, {f: 6, c: 50970}, {f: 2, c: 50978},

  8853     {f: 3, c: 50981}, {f: 7, c: 50985}, 50994, 50996, 50998, {f: 4, c: 51000},

  8854     {f: 2, c: 51006}, {f: 3, c: 51009}, {f: 5, c: 51013}, 51019, 51022, 51024,

  8855     {f: 3, c: 51033}, {f: 3, c: 51037}, {f: 7, c: 51041}, {f: 2, c: 51049},

  8856     {f: 8, c: 51052}, {f: 2, c: 51062}, {f: 3, c: 51065}, {f: 4, c: 51071},

  8857     51078, {f: 3, c: 51083}, 51087, {f: 2, c: 51090}, 51093, 51097,

  8858     {f: 5, c: 51099}, 51106, {f: 5, c: 51111}, {f: 2, c: 51118},

  8859     {f: 3, c: 51121}, {f: 7, c: 51125}, 51134, {f: 6, c: 51138},

  8860     {f: 2, c: 51146}, 51149, 51151, {f: 7, c: 51153}, {f: 4, c: 51161},

  8861     {f: 6, c: 51166}, {f: 3, c: 51173}, {f: 3, c: 51177}, {f: 19, c: 51181},

  8862     {f: 2, c: 51202}, {f: 3, c: 51205}, 51209, {f: 5, c: 51211}, 51218, 51220,

  8863     {f: 5, c: 51223}, {f: 2, c: 51230}, {f: 3, c: 51233}, {f: 7, c: 51237},

  8864     51246, 51248, {f: 6, c: 51250}, {f: 3, c: 51257}, {f: 3, c: 51261},

  8865     {f: 7, c: 51265}, {f: 2, c: 51274}, {f: 6, c: 51278}, {f: 27, c: 51285},

  8866     {f: 2, c: 51314}, {f: 3, c: 51317}, 51321, {f: 5, c: 51323}, 51330, 51332,

  8867     {f: 3, c: 51336}, {f: 6, c: 51342}, {f: 8, c: 51349}, 51358, 51360,

  8868     {f: 6, c: 51362}, {f: 19, c: 51369}, {f: 6, c: 51390}, {f: 3, c: 51397},

  8869     {f: 3, c: 51401}, {f: 7, c: 51405}, 51414, 51416, {f: 6, c: 51418},

  8870     {f: 2, c: 51426}, {f: 16, c: 51429}, {f: 6, c: 51446}, {f: 2, c: 51454},

  8871     {f: 3, c: 51457}, {f: 5, c: 51463}, 51470, 51472, {f: 6, c: 51474},

  8872     {f: 19, c: 51481}, {f: 7, c: 51501}, {f: 27, c: 51509}, {f: 2, c: 51538},

  8873     {f: 3, c: 51541}, {f: 7, c: 51545}, 51554, {f: 8, c: 51556},

  8874     {f: 3, c: 51565}, {f: 3, c: 51569}, {f: 7, c: 51573}, {f: 11, c: 51581},

  8875     {f: 2, c: 51594}, {f: 3, c: 51597}, {f: 7, c: 51601}, 51610, 51612,

  8876     {f: 34, c: 51614}, {f: 2, c: 51650}, {f: 2, c: 51653}, 51657,

  8877     {f: 5, c: 51659}, 51666, 51668, {f: 2, c: 51671}, 51675, {f: 2, c: 51678},

  8878     51681, 51683, {f: 2, c: 51685}, {f: 4, c: 51688}, 51694, {f: 6, c: 51698},

  8879     {f: 2, c: 51706}, {f: 3, c: 51709}, {f: 7, c: 51713}, 51722,

  8880     {f: 6, c: 51726}, {f: 3, c: 51733}, {f: 16, c: 51737}, {f: 34, c: 51754},

  8881     {f: 2, c: 51790}, {f: 3, c: 51793}, {f: 7, c: 51797}, 51806,

  8882     {f: 6, c: 51810}, {f: 20, c: 51817}, {f: 6, c: 51838}, {f: 19, c: 51845},

  8883     {f: 35, c: 51865}, {f: 2, c: 51902}, {f: 3, c: 51905}, {f: 7, c: 51909},

  8884     51918, 51920, 51922, {f: 4, c: 51924}, {f: 6, c: 51930}, {f: 11, c: 51937},

  8885     {f: 7, c: 51949}, {f: 19, c: 51957}, {f: 7, c: 51977}, {f: 3, c: 51985},

  8886     {f: 3, c: 51989}, {f: 7, c: 51993}, {f: 31, c: 52002}, {f: 6, c: 52034},

  8887     {f: 2, c: 52042}, {f: 3, c: 52045}, {f: 7, c: 52049}, {f: 3, c: 52058},

  8888     {f: 6, c: 52062}, {f: 19, c: 52069}, {f: 34, c: 52090}, {f: 27, c: 52125},

  8889     {f: 27, c: 52153}, {f: 15, c: 52181}, {f: 2, c: 52197}, 52200,

  8890     {f: 34, c: 52202}, {f: 2, c: 52238}, {f: 3, c: 52241}, {f: 7, c: 52245},

  8891     {f: 3, c: 52254}, {f: 4, c: 52259}, {f: 2, c: 52266}, 52269, 52271,

  8892     {f: 7, c: 52273}, 52282, {f: 5, c: 52287}, {f: 2, c: 52294},

  8893     {f: 3, c: 52297}, {f: 7, c: 52301}, 52310, {f: 6, c: 52314},

  8894     {f: 3, c: 52321}, 52325, 52327, {f: 7, c: 52329}, {f: 4, c: 52337},

  8895     {f: 34, c: 52342}, {f: 2, c: 52378}, {f: 3, c: 52381}, {f: 7, c: 52385},

  8896     52394, {f: 6, c: 52398}, {f: 2, c: 52406}, {f: 3, c: 52409},

  8897     {f: 7, c: 52413}, 52422, 52424, {f: 6, c: 52426}, {f: 3, c: 52433},

  8898     {f: 15, c: 52437}, {f: 7, c: 52453}, {f: 3, c: 52461}, {f: 16, c: 52465},

  8899     {f: 6, c: 52482}, {f: 2, c: 52490}, {f: 3, c: 52493}, {f: 7, c: 52497},

  8900     52506, 52508, {f: 6, c: 52510}, {f: 3, c: 52517}, {f: 3, c: 52521},

  8901     {f: 12, c: 52525}, {f: 34, c: 52538}, {f: 3, c: 52573}, {f: 3, c: 52577},

  8902     {f: 7, c: 52581}, 52590, 52592, {f: 6, c: 52594}, {f: 15, c: 52601},

  8903     {f: 11, c: 52617}, {f: 2, c: 52630}, {f: 3, c: 52633}, {f: 7, c: 52637},

  8904     52646, 52648, {f: 6, c: 52650}, {f: 19, c: 52657}, {f: 7, c: 52677},

  8905     {f: 3, c: 52685}, {f: 23, c: 52689}, {f: 3, c: 52713}, {f: 3, c: 52717},

  8906     {f: 7, c: 52721}, 52730, 52732, {f: 6, c: 52734}, {f: 3, c: 52741},

  8907     {f: 3, c: 52745}, {f: 7, c: 52749}, {f: 4, c: 52757}, {f: 6, c: 52762},

  8908     {f: 2, c: 52770}, {f: 3, c: 52773}, {f: 7, c: 52777}, 52786, 52788,

  8909     {f: 34, c: 52790}, {f: 2, c: 52826}, {f: 2, c: 52829}, {f: 6, c: 52834},

  8910     52842, 52844, {f: 6, c: 52846}, {f: 2, c: 52854}, {f: 3, c: 52857},

  8911     {f: 7, c: 52861}, 52870, 52872, {f: 6, c: 52874}, {f: 2, c: 52882},

  8912     {f: 3, c: 52885}, {f: 7, c: 52889}, 52898, {f: 6, c: 52902},

  8913     {f: 19, c: 52910}, {f: 34, c: 52930}, {f: 2, c: 52966}, {f: 2, c: 52969},

  8914     {f: 7, c: 52973}, 52982, {f: 6, c: 52986}, {f: 2, c: 52994},

  8915     {f: 3, c: 52997}, {f: 7, c: 53001}, 53010, 53012, {f: 6, c: 53014},

  8916     {f: 3, c: 53021}, {f: 3, c: 53025}, {f: 7, c: 53029}, 53038,

  8917     {f: 6, c: 53042}, {f: 27, c: 53049}, {f: 2, c: 53078}, {f: 3, c: 53081},

  8918     {f: 7, c: 53085}, 53094, 53096, {f: 6, c: 53098}, {f: 2, c: 53106},

  8919     {f: 3, c: 53109}, {f: 7, c: 53113}, {f: 4, c: 53121}, {f: 6, c: 53126},

  8920     {f: 20, c: 53133}, {f: 6, c: 53154}, {f: 7, c: 53161}, {f: 19, c: 53169},

  8921     {f: 27, c: 53189}, {f: 2, c: 53218}, {f: 3, c: 53221}, {f: 7, c: 53225},

  8922     53234, 53236, {f: 6, c: 53238}, {f: 3, c: 53245}, {f: 3, c: 53249},

  8923     {f: 12, c: 53253}, {f: 6, c: 53266}, {f: 20, c: 53273}, {f: 6, c: 53294},

  8924     {f: 2, c: 53302}, {f: 3, c: 53305}, {f: 7, c: 53309}, 53318, 53320,

  8925     {f: 6, c: 53322}, {f: 3, c: 53329}, {f: 3, c: 53333}, {f: 7, c: 53337},

  8926     {f: 11, c: 53345}, {f: 2, c: 53358}, {f: 3, c: 53361}, {f: 7, c: 53365},

  8927     {f: 3, c: 53374}, {f: 34, c: 53378}, {f: 2, c: 53414}, {f: 3, c: 53417},

  8928     {f: 7, c: 53421}, 53430, 53432, {f: 6, c: 53434}, {f: 2, c: 53442},

  8929     {f: 3, c: 53445}, {f: 6, c: 53450}, 53458, {f: 6, c: 53462},

  8930     {f: 2, c: 53470}, {f: 3, c: 53473}, {f: 7, c: 53477}, 53486,

  8931     {f: 6, c: 53490}, {f: 20, c: 53497}, {f: 34, c: 53518}, {f: 2, c: 53554},

  8932     {f: 3, c: 53557}, 53561, {f: 5, c: 53563}, 53570, {f: 6, c: 53574},

  8933     {f: 2, c: 53582}, {f: 3, c: 53585}, {f: 7, c: 53589}, 53598, 53600,

  8934     {f: 6, c: 53602}, {f: 3, c: 53609}, {f: 15, c: 53613}, {f: 7, c: 53629},

  8935     {f: 3, c: 53637}, {f: 23, c: 53641}, {f: 2, c: 53666}, {f: 3, c: 53669},

  8936     {f: 7, c: 53673}, 53682, 53684, {f: 4, c: 53686}, 53691, {f: 3, c: 53693},

  8937     {f: 23, c: 53697}, {f: 27, c: 53721}, {f: 3, c: 53749}, {f: 14, c: 53753},

  8938     53768, {f: 6, c: 53770}, {f: 27, c: 53777}, {f: 2, c: 53806},

  8939     {f: 3, c: 53809}, {f: 7, c: 53813}, 53822, 53824, {f: 6, c: 53826},

  8940     {f: 19, c: 53833}, {f: 7, c: 53853}, {f: 27, c: 53861}, {f: 2, c: 53890},

  8941     {f: 3, c: 53893}, {f: 7, c: 53897}, {f: 3, c: 53906}, {f: 6, c: 53910},

  8942     {f: 3, c: 53917}, {f: 3, c: 53921}, {f: 7, c: 53925}, {f: 4, c: 53933},

  8943     {f: 6, c: 53938}, {f: 2, c: 53946}, {f: 2, c: 53949}, 53953,

  8944     {f: 5, c: 53955}, 53962, {f: 8, c: 53964}, {f: 3, c: 53973},

  8945     {f: 3, c: 53977}, {f: 7, c: 53981}, {f: 10, c: 53990}, {f: 2, c: 54002},

  8946     {f: 3, c: 54005}, {f: 7, c: 54009}, 54018, 54020, {f: 6, c: 54022}, 54031,

  8947     {f: 3, c: 54033}, 54037, {f: 5, c: 54039}, 54046, {f: 3, c: 54050},

  8948     {f: 2, c: 54054}, {f: 2, c: 54058}, {f: 3, c: 54061}, {f: 7, c: 54065},

  8949     54074, {f: 6, c: 54078}, {f: 54, c: 54086}, {f: 2, c: 54142},

  8950     {f: 3, c: 54145}, {f: 7, c: 54149}, 54158, {f: 6, c: 54162},

  8951     {f: 2, c: 54170}, {f: 3, c: 54173}, {f: 7, c: 54177}, 54186, 54188,

  8952     {f: 6, c: 54190}, {f: 3, c: 54197}, {f: 3, c: 54201}, {f: 7, c: 54205},

  8953     {f: 2, c: 54214}, {f: 6, c: 54218}, {f: 7, c: 54225}, {f: 8, c: 54233},

  8954     54242, {f: 8, c: 54244}, {f: 2, c: 54254}, {f: 3, c: 54257},

  8955     {f: 7, c: 54261}, 54270, 54272, {f: 6, c: 54274}, {f: 20, c: 54281},

  8956     {f: 34, c: 54302}, {f: 3, c: 54337}, {f: 23, c: 54341}, {f: 3, c: 54365},

  8957     {f: 3, c: 54369}, {f: 8, c: 54373}, 54382, {f: 8, c: 54384},

  8958     {f: 2, c: 54394}, {f: 2, c: 54397}, 54401, {f: 5, c: 54403}, 54410, 54412,

  8959     {f: 6, c: 54414}, {f: 20, c: 54421}, {f: 34, c: 54442}, {f: 3, c: 54477},

  8960     {f: 3, c: 54481}, {f: 7, c: 54485}, {f: 2, c: 54493}, {f: 8, c: 54496},

  8961     {f: 3, c: 54505}, {f: 3, c: 54509}, {f: 7, c: 54513}, {f: 2, c: 54521},

  8962     54524, {f: 6, c: 54526}, {f: 3, c: 54533}, {f: 3, c: 54537},

  8963     {f: 7, c: 54541}, 54550, {f: 36, c: 54552}, {f: 2, c: 54590},

  8964     {f: 3, c: 54593}, {f: 7, c: 54597}, 54606, 54608, {f: 6, c: 54610},

  8965     {f: 2, c: 54618}, {f: 3, c: 54621}, {f: 4, c: 54625}, {f: 2, c: 54630},

  8966     54634, 54636, {f: 6, c: 54638}, {f: 2, c: 54646}, {f: 3, c: 54649},

  8967     {f: 7, c: 54653}, 54662, {f: 6, c: 54666}, {f: 20, c: 54673},

  8968     {f: 34, c: 54694}, {f: 2, c: 54730}, {f: 3, c: 54733}, 54737,

  8969     {f: 5, c: 54739}, 54746, 54748, {f: 6, c: 54750}, {f: 2, c: 54758},

  8970     {f: 3, c: 54761}, {f: 7, c: 54765}, 54774, 54776, {f: 6, c: 54778},

  8971     {f: 2, c: 54786}, {f: 3, c: 54789}, {f: 7, c: 54793}, 54802,

  8972     {f: 6, c: 54806}, {f: 3, c: 54813}, {f: 3, c: 54817}, {f: 8, c: 54821},

  8973     {f: 10, c: 54830}, {f: 2, c: 54842}, {f: 3, c: 54845}, {f: 4, c: 54849},

  8974     {f: 2, c: 54854}, 54858, 54860, {f: 3, c: 54862}, {f: 2, c: 54866},

  8975     {f: 2, c: 54870}, {f: 3, c: 54873}, {f: 10, c: 54877}, 54888,

  8976     {f: 6, c: 54890}, {f: 2, c: 54898}, {f: 14, c: 54901}, 54916,

  8977     {f: 6, c: 54918}, {f: 2, c: 54926}, {f: 3, c: 54929}, {f: 8, c: 54933},

  8978     54942, 54944, {f: 6, c: 54946}, {f: 3, c: 54953}, {f: 3, c: 54957},

  8979     {f: 8, c: 54961}, 54970, {f: 8, c: 54972}, {f: 2, c: 54982},

  8980     {f: 3, c: 54985}, {f: 4, c: 54989}, {f: 2, c: 54994}, {f: 2, c: 54997},

  8981     55000, {f: 6, c: 55002}, {f: 3, c: 55009}, {f: 3, c: 55013},

  8982     {f: 7, c: 55017}, {f: 4, c: 55025}, {f: 6, c: 55030}, {f: 2, c: 55038},

  8983     {f: 3, c: 55041}, {f: 12, c: 55045}, {f: 6, c: 55058}, {f: 2, c: 55066},

  8984     {f: 3, c: 55069}, {f: 7, c: 55073}, 55082, 55084, {f: 6, c: 55086},

  8985     {f: 2, c: 55094}, {f: 3, c: 55097}, {f: 7, c: 55101}, {f: 2, c: 55109},

  8986     55112, {f: 6, c: 55114}, {f: 2, c: 55122}, 55125, {f: 6, c: 55130}, 55138,

  8987     55140, {f: 3, c: 55142}, {f: 2, c: 55146}, {f: 3, c: 55149},

  8988     {f: 3, c: 55153}, {f: 7, c: 55157}, {f: 3, c: 55166}, {f: 6, c: 55170},

  8989     {f: 2, c: 55178}, {f: 3, c: 55181}, {f: 7, c: 55185}, 55194, 55196,

  8990     {f: 6, c: 55198}],

  8991   'Adobe-CNS1': [{f: 95, c: 32}, {s: 3}, 12288, 65292, {f: 2, c: 12289}, 65294,

  8992     8226, 65307, 65306, 65311, 65281, 65072, 8230, 8229, 65104, 65380, 65106,

  8993     183, {f: 4, c: 65108}, 65372, 8211, 65073, 8212, {s: 4}, {f: 2, c: 65288},

  8994     {f: 2, c: 65077}, 65371, 65373, {f: 2, c: 65079}, {f: 2, c: 12308},

  8995     {f: 2, c: 65081}, {f: 2, c: 12304}, {f: 2, c: 65083}, {f: 2, c: 12298},

  8996     {f: 2, c: 65085}, {f: 2, c: 12296}, {f: 2, c: 65087}, {f: 2, c: 12300},

  8997     {f: 2, c: 65089}, {f: 2, c: 12302}, {f: 2, c: 65091}, {f: 6, c: 65113},

  8998     {f: 2, c: 8216}, {f: 2, c: 8220}, {f: 2, c: 12317}, 8245, 8242, 65283,

  8999     65286, 65290, 8251, 167, 12291, 9675, 9679, 9651, 9650, 9678, 9734, 9733,

  9000     9671, 9670, 9633, 9632, 9661, 9660, 12963, 8453, 8254, 0, 65343, 0,

  9001     {f: 2, c: 65097}, {f: 2, c: 65101}, {f: 2, c: 65099}, {f: 3, c: 65119},

  9002     65291, 65293, 215, 247, 177, 8730, 65308, 65310, 65309, {f: 2, c: 8806},

  9003     8800, 8734, 8786, 8801, {f: 5, c: 65122}, 8764, {f: 2, c: 8745}, 8869,

  9004     8736, 8735, 8895, 13266, 13265, 8747, 8750, 8757, 8756, 9792, 9794, 9793,

  9005     9737, 8593, 8595, 8594, 8592, {f: 2, c: 8598}, 8601, 8600, 8741, 8739, 0,

  9006     0, 65295, 65340, 65284, 165, 12306, {f: 2, c: 162}, 65285, 65312, 8451,

  9007     8457, {f: 3, c: 65129}, 13269, {f: 3, c: 13212}, 13262, 13217,

  9008     {f: 2, c: 13198}, 13252, 176, [20825, 58834], [20827, 58835],

  9009     [20830, 58837], [20829, 58836], 20833, 20835, 21991, [29929, 58044],

  9010     [31950, 58191], {f: 8, c: 9601}, 9615, 9614, 9613, 9612, 9611, 9610, 9609,

  9011     9532, 9524, 9516, 9508, 9500, 9620, 9472, 9474, 9621, 9484, 9488, 9492,

  9012     9496, {f: 2, c: 9581}, 9584, 9583, 9552, 9566, 9578, 9569, {f: 2, c: 9698},

  9013     9701, 9700, {f: 3, c: 9585}, {f: 10, c: 65296}, {f: 10, c: 8544},

  9014     {f: 9, c: 12321}, 0, [21316, 57443], 0, {f: 26, c: 65313},

  9015     {f: 26, c: 65345}, {f: 17, c: 913}, {f: 7, c: 931}, {f: 17, c: 945},

  9016     {f: 7, c: 963}, {f: 37, c: 12549}, 729, 714, 711, 715, [9312, 63153],

  9017     [9313, 63154], [9314, 63155], [9315, 63156], [9316, 63157], [9317, 63158],

  9018     [9318, 63159], [9319, 63160], [9320, 63161], [9321, 63162], [9332, 63163],

  9019     [9333, 63164], [9334, 63165], [9335, 63166], [9336, 63167], [9337, 63168],

  9020     [9338, 63169], [9339, 63170], [9340, 63171], [9341, 63172], [8560, 63173],

  9021     [8561, 63174], [8562, 63175], [8563, 63176], [8564, 63177], [8565, 63178],

  9022     [8566, 63179], [8567, 63180], [8568, 63181], [8569, 63182], [12033, 20008],

  9023     [12034, 20022, 63183], [12035, 20031, 63184], [12037, 20101, 63185],

  9024     [12039, 20128, 63186], [12044, 20866, 63187], [12045, 20886, 63188],

  9025     [12046, 20907, 63189], [12051, 21241, 63190], [12054, 21304, 63191],

  9026     [12057, 21353, 63192], [12059, 21430, 63193],

  9027     [12065, 12066, 22786, 22794, 63194], [12071, 23424, 63195],

  9028     [12078, 24027, 63196], [12083, 24186, 63197], [12084, 24191, 63198],

  9029     [12085, 24308], [12089, 24400, 63200], [12090, 24417, 63201],

  9030     [12097, 25908, 63202], [12102, 26080], [12135, 30098, 63204],

  9031     [12136, 30326], [12193, 36789, 63206], [12202, 38582], {f: 32, c: 9216},

  9032     9249, [12032, 19968], [12036, 20057], 19969, 19971, 20035, 20061, 20102,

  9033     [12038, 20108], [12040, 20154], [12041, 20799], [12042, 20837],

  9034     [12043, 20843], [12047, 20960], [12049, 20992], 20993, [12050, 21147],

  9035     [12052, 21269], [12055, 21313], [12056, 21340], [12060, 21448], 19977,

  9036     19979, 19976, 19978, 20011, 20024, 20961, 20037, 20040, 20063, 20062,

  9037     20110, 20129, [20800, 64012], 20995, 21242, 21315, 21449, [12061, 21475],

  9038     [12063, 22303], [12064, 22763], [12067, 22805], [12068, 22823],

  9039     [12069, 22899], [12070, 23376], 23377, 23379, [12072, 23544],

  9040     [12073, 23567], [12074, 23586], [12075, 23608], [12077, 23665], 24029,

  9041     [12079, 24037], [12080, 24049], {f: 2, c: 24050}, [12081, 24062],

  9042     [12082, 24178], [12086, 24318], [12087, 24331], [12088, 24339], 25165,

  9043     19985, 19984, 19981, 20013, 20016, 20025, 20043, 23609, 20104, 20113,

  9044     20117, 20114, 20116, 20130, 20161, 20160, 20163, {f: 2, c: 20166}, 20173,

  9045     {f: 2, c: 20170}, 20164, 20803, 20801, 20839, {f: 2, c: 20845}, 20844,

  9046     20887, 20982, {f: 3, c: 20998}, 21243, {f: 2, c: 21246}, 21270, 21305,

  9047     21320, 21319, 21317, 21342, 21380, 21451, 21450, 21453, 22764, 22825,

  9048     22827, 22826, 22829, 23380, 23569, 23588, 23610, 23663, 24052, 24187,

  9049     24319, {f: 2, c: 24340}, [12092, 24515], [12093, 25096], [12094, 25142],

  9050     [12095, 25163], 25166, [12096, 25903], [12098, 25991], [12099, 26007],

  9051     [12100, 26020], [12101, 26041], [12103, 26085], [12104, 26352],

  9052     [12105, 26376], [12106, 26408], [12107, 27424], [12108, 27490],

  9053     [12109, 27513], [12111, 27595], [12112, 27604], [12113, 27611],

  9054     [12114, 27663], [12116, 27700], [12117, 28779], [12118, 29226],

  9055     [12119, 29238], [12120, 29243], [12122, 29255], [12123, 29273],

  9056     [12124, 29275], [12125, 29356], 29579, 19993, 19990, 19989, 19988, 19992,

  9057     20027, 20045, 20047, 20046, 20197, 20184, {f: 4, c: 20180},

  9058     {f: 2, c: 20195}, 20185, 20190, 20805, 20804, {f: 2, c: 20873}, 20908,

  9059     {f: 2, c: 20985}, 20984, 21002, 21152, 21151, [21253, 57435], 21254, 21271,

  9060     21277, 20191, 21322, 21321, 21345, 21344, 21359, 21358, 21435, 21487,

  9061     21476, 21491, 21484, 21486, 21481, 21480, 21500, 21496, 21493, 21483,

  9062     21478, 21482, 21490, 21489, 21488, 21477, 21485, 21499, 22235, 22234,

  9063     22806, 22830, 22833, 22900, 22902, 23381, 23427, 23612, 24040, 24039,

  9064     24038, {f: 2, c: 24066}, 24179, 24188, 24321, 24344, 24343, 24517, 25098,

  9065     {f: 2, c: 25171}, 25170, 25169, 26021, 26086, 26414, 26412,

  9066     {f: 2, c: 26410}, 26413, 27491, 27597, 27665, 27664, 27704, 27713, 27712,

  9067     27710, 29359, [12126, 29572], [12127, 29577], [12128, 29916],

  9068     [12129, 29926], [12130, 29976], [12131, 29983], [12132, 29992], 29993,

  9069     [12133, 30000], {f: 3, c: 30001}, [12134, 30091], [12137, 30333],

  9070     [12138, 30382], [12139, 30399], [12140, 30446], [12141, 30683],

  9071     [12142, 30690], [12143, 30707], [12144, 31034], [12146, 31166],

  9072     [12147, 31348], [12148, 31435], {f: 2, c: 19998}, {f: 2, c: 20050}, 20073,

  9073     20121, 20132, 20134, 20133, 20223, 20233, 20249, 20234, 20245, 20237,

  9074     {f: 2, c: 20240}, 20239, 20210, 20214, 20219, 20208, 20211, 20221, 20225,

  9075     20235, 20809, 20807, 20806, 20808, 20840, 20849, 20877, 20912, 21015,

  9076     {f: 2, c: 21009}, 21006, 21014, 21155, 21256, 21281, 21280,

  9077     {f: 2, c: 21360}, 21513, 21519, 21516, 21514, 21520, 21505, 21515, 21508,

  9078     21521, 21517, 21512, 21507, 21518, 21510, 21522, 22240, 22238, 22237,

  9079     22323, 22320, 22312, 22317, 22316, 22319, 22313, {f: 2, c: 22809},

  9080     {f: 2, c: 22839}, 22916, 22904, 22915, 22909, 22905, 22914, 22913,

  9081     {f: 2, c: 23383}, {f: 2, c: 23431}, 23429, 23433, 23546, 23574, 23673,

  9082     24030, 24070, 24182, 24180, 24335, 24347, 24537, 24534, 25102,

  9083     {f: 2, c: 25100}, 25104, 25187, 25179, 25176, 25910, 26089, 26088,

  9084     {f: 2, c: 26092}, {f: 2, c: 26354}, 26377, 26429, 26420, 26417, 26421,

  9085     27425, 27492, 27515, 27670, 27741, 27735, 27737, {f: 2, c: 27743}, 27728,

  9086     27733, 27745, 27739, {f: 2, c: 27725}, 28784, 29279, 29277, 30334,

  9087     [12149, 31481], [12150, 31859], [12151, 31992], [12152, 32566],

  9088     [12154, 32650], [12155, 32701], [12156, 32769], 32771, [12157, 32780],

  9089     [12158, 32786], [12159, 32819], [12160, 32895], [12161, 32905],

  9090     {f: 2, c: 32907}, [12162, 33251], [12163, 33258], [12164, 33267],

  9091     [12165, 33276], [12166, 33292], [12167, 33307], [12168, 33311],

  9092     [12169, 33390], [12170, 33394], 33406, [12173, 34411], [12174, 34880],

  9093     [12175, 34892], [12176, 34915], 35199, 38433, 20018, 20136, 20301, 20303,

  9094     20295, 20311, 20318, 20276, 20315, 20309, 20272, {f: 2, c: 20304}, 20285,

  9095     20282, 20280, 20291, 20308, 20284, 20294, 20323, 20316, 20320, 20271,

  9096     20302, 20278, 20313, 20317, 20296, 20314, 20812, 20811, 20813, 20853,

  9097     {f: 2, c: 20918}, 21029, 21028, {f: 2, c: 21033}, 21032, 21163,

  9098     {f: 2, c: 21161}, 21164, 21283, 21363, 21365, 21533, 21549, 21534, 21566,

  9099     21542, 21582, 21543, 21574, 21571, 21555, 21576, 21570, 21531, 21545,

  9100     21578, 21561, 21563, 21560, 21550, {f: 2, c: 21557}, 21536, 21564, 21568,

  9101     21553, 21547, 21535, 21548, 22250, 22256, 22244, 22251, 22346, 22353,

  9102     22336, 22349, 22343, 22350, 22334, 22352, 22351, 22331, 22767, 22846,

  9103     22941, 22930, 22952, 22942, 22947, 22937, 22934, 22925, 22948, 22931,

  9104     22922, 22949, 23389, 23388, {f: 2, c: 23386}, 23436, 23435, 23439, 23596,

  9105     {f: 2, c: 23616}, 23615, 23614, {f: 2, c: 23696}, 23700, 23692, 24043,

  9106     24076, 24207, 24199, 24202, 24311, 24324, 24351, 24420, 24418, 24439,

  9107     24441, 24536, 24524, 24535, 24525, 24561, 24555, 24568, 24554, 25106,

  9108     25105, 25220, 25239, 25238, 25216, 25206, 25225, 25197, 25226, 25212,

  9109     25214, 25209, 25203, 25234, 25199, 25240, 25198, 25237, 25235, 25233,

  9110     25222, 25913, 25915, 25912, 26097, 26356, 26463, {f: 4, c: 26446}, 26460,

  9111     26454, [26462, 57801], 26441, 26438, 26464, 26451, 26455, 27493, 27599,

  9112     27714, 27742, 27801, 27777, {f: 2, c: 27784}, 27781, 27803, 27754, 27770,

  9113     27792, 27760, 27788, 27752, 27798, 27794, 27773, 27779, 27762, 27774,

  9114     27764, 27782, 27766, 27789, 27796, 27800, 27778, 28790, {f: 2, c: 28796},

  9115     28792, 29282, 29281, 29280, 29380, 29378, 29590, 29996, 29995,

  9116     {f: 2, c: 30007}, 30338, 30447, 30691, 31169, 31168, 31167, 31350, 31995,

  9117     32597, 32918, 32915, 32925, 32920, 32923, 32922, 32946, 33391, 33426,

  9118     33419, 33421, [12178, 35211], [12179, 35282], [12180, 35328],

  9119     [12181, 35895], [12182, 35910], [12183, 35925], [12185, 35997],

  9120     [12186, 36196], [12187, 36208], [12188, 36275], [12189, 36523],

  9121     [12190, 36554], [12191, 36763], [12192, 36784], 36802, 36806, 36805, 36804,

  9122     24033, [12194, 37009], 37026, 37034, 37030, 37027, [12195, 37193],

  9123     [12196, 37318], [12197, 37324], 38450, 38446, 38449, 38442, 38444, 20006,

  9124     20054, 20083, 20107, 20123, 20126, {f: 2, c: 20139}, 20335, 20381, 20365,

  9125     20339, 20351, 20332, 20379, 20363, 20358, 20355, 20336, 20341, 20360,

  9126     20329, 20347, 20374, 20350, 20367, 20369, 20346, 20820, 20818, 20821,

  9127     20841, 20855, 20854, 20856, 20925, 20989, 21051, 21048, 21047, 21050,

  9128     21040, 21038, 21046, 21057, 21182, 21179, 21330, 21332, 21331, 21329,

  9129     21350, {f: 3, c: 21367}, 21462, 21460, 21463, 21619, 21621, 21654, 21624,

  9130     21653, 21632, 21627, 21623, 21636, 21650, 21638, 21628, 21648, 21617,

  9131     21622, 21644, 21658, 21602, 21608, 21643, 21629, 21646, 22266, 22403,

  9132     22391, 22378, 22377, 22369, 22374, 22372, 22396, 22812, 22857,

  9133     {f: 2, c: 22855}, 22852, 22868, 22974, 22971, 22996, 22969, 22958, 22993,

  9134     22982, 22992, 22989, 22987, 22995, 22986, 22959, 22963, 22994, 22981,

  9135     23391, 23396, 23395, 23447, 23450, 23448, 23452, 23449, 23451, 23578,

  9136     23624, {f: 2, c: 23621}, 23735, 23713, 23736, 23721, 23723, 23729, 23731,

  9137     24088, 24090, 24086, 24085, 24091, 24081, 24184, 24218, 24215, 24220,

  9138     {f: 2, c: 24213}, 24310, {f: 2, c: 24358}, 24361, {f: 2, c: 24448}, 24447,

  9139     24444, 24541, 24544, 24573, 24565, 24575, 24591, 24596, 24623, 24629,

  9140     24598, 24618, 24597, 24609, 24615, 24617, 24619, 24603, 25110, 25109,

  9141     25151, 25150, 25152, 25215, 25289, 25292, 25284, 25279, 25282, 25273,

  9142     25298, 25307, 25259, {f: 2, c: 25299}, 25291, 25288, 25256, 25277, 25276,

  9143     [25296, 60582], 25305, 25287, 25293, 25269, 25306, 25265, 25304,

  9144     {f: 2, c: 25302}, 25286, 25260, [25294, 61010], 25918, 26023, 26044, 26106,

  9145     26132, 26131, 26124, 26118, 26114, 26126, 26112, 26127, 26133, 26122,

  9146     26119, 26381, 26379, 26477, 26507, 26517, 26481, 26524, 26483, 26487,

  9147     26503, 26525, 26519, {f: 2, c: 26479}, 26495, 26505, 26494, 26512, 26485,

  9148     26522, 26515, 26492, 26474, 26482, 27427, {f: 2, c: 27494}, 27519, 27667,

  9149     27675, 27875, 27880, 27891, 27825, 27852, 27877, 27827, {f: 2, c: 27837},

  9150     27836, 27874, 27819, 27861, 27859, 27832, 27844, 27833, 27841, 27822,

  9151     27863, 27845, 27889, 27839, 27835, 27873, 27867, 27850, 27820, 27887,

  9152     27868, 27862, 27872, 28821, 28814, 28818, 28810, 28825, {f: 2, c: 29228},

  9153     29240, 29256, 29287, 29289, 29376, 29390, 29401, 29399, 29392, 29609,

  9154     29608, 29599, 29611, 29605, 30013, 30109, {f: 2, c: 30105}, 30340, 30402,

  9155     30450, 30452, 30693, 30717, 31038, {f: 2, c: 31040}, 31177, 31176, 31354,

  9156     31353, 31482, 31998, 32596, 32652, 32651, [32773, 58236], 32954, 32933,

  9157     32930, 32945, 32929, 32939, 32937, 32948, 32938, 32943, 33253, 33278,

  9158     33293, 33459, 33437, 33433, 33453, 33469, 33439, 33465, 33457, 33452,

  9159     33445, 33455, 33464, 33443, 33456, 33470, 33463, 34382, 34417, 21021,

  9160     34920, 36555, 36814, 36820, 36817, 37045, 37048, 37041, 37046, 37319,

  9161     [12198, 37329], [12199, 38263], [12200, 38272], [12201, 38428], 38464,

  9162     38463, 38459, 38468, 38466, [12203, 38585], [12204, 38632], 38738,

  9163     [12206, 38750], 20127, {f: 2, c: 20141}, 20449, 20405, 20399, 20415, 20448,

  9164     20433, 20431, 20445, 20419, 20406, 20440, 20447, 20426, 20439, 20398,

  9165     20432, 20420, 20418, 20442, 20430, 20446, 20407, 20823, 20882, 20881,

  9166     20896, 21070, 21059, 21066, 21069, 21068, 21067, 21063, 21191, 21193,

  9167     21187, 21185, 21261, 21335, 21371, 21402, 21467, 21676, 21696, 21672,

  9168     21710, 21705, 21688, 21670, 21683, 21703, 21698, 21693, 21674, 21697,

  9169     21700, 21704, 21679, 21675, 21681, 21691, 21673, 21671, 21695, 22271,

  9170     22402, 22411, 22432, 22435, 22434, 22478, 22446, 22419, 22869, 22865,

  9171     22863, 22862, 22864, 23004, 23000, 23039, 23011, 23016, 23043, 23013,

  9172     23018, 23002, 23014, 23041, 23035, 23401, 23459, 23462, 23460, 23458,

  9173     23461, 23553, {f: 2, c: 23630}, 23629, 23627, 23769, 23762, 24055, 24093,

  9174     24101, 24095, 24189, 24224, 24230, 24314, 24328, 24365, 24421, 24456,

  9175     24453, {f: 2, c: 24458}, 24455, 24460, 24457, 24594, 24605, 24608, 24613,

  9176     24590, 24616, 24653, 24688, 24680, [24674, 60712], 24646, 24643, 24684,

  9177     24683, 24682, 24676, 25153, 25308, 25366, 25353, 25340, 25325, 25345,

  9178     25326, 25341, 25351, 25329, 25335, 25327, 25324, 25342, 25332, 25361,

  9179     25346, 25919, 25925, 26027, 26045, 26082, 26149, 26157, 26144, 26151,

  9180     26159, 26143, 26152, 26161, 26148, 26359, 26623, 26579, 26609, 26580,

  9181     26576, 26604, 26550, 26543, 26613, 26601, 26607, 26564, 26577, 26548,

  9182     26586, 26597, 26552, 26575, 26590, 26611, 26544, 26585, 26594, 26589,

  9183     26578, 27498, 27523, 27526, 27573, 27602, 27607, 27679, 27849, 27915,

  9184     27954, 27946, 27969, 27941, 27916, 27953, 27934, 27927, 27963,

  9185     {f: 2, c: 27965}, 27958, 27931, 27893, 27961, 27943, 27960, 27945, 27950,

  9186     27957, 27918, 27947, 28843, 28858, 28851, 28844, 28847, 28845, 28856,

  9187     28846, 28836, 29232, 29298, 29295, 29300, 29417, {f: 2, c: 29408}, 29623,

  9188     29642, 29627, 29618, 29645, 29632, 29619, 29978, 29997, 30031, 30028,

  9189     30030, 30027, 30123, {f: 2, c: 30116}, {f: 2, c: 30114}, 30328,

  9190     {f: 3, c: 30342}, 30408, 30406, 30403, 30405, 30465, 30457, 30456, 30473,

  9191     30475, 30462, 30460, 30471, 30684, 30722, 30740, {f: 2, c: 30732}, 31046,

  9192     31049, 31048, 31047, {f: 2, c: 31161}, {f: 2, c: 31185}, 31179, 31359,

  9193     31361, 31487, 31485, 31869, 32002, 32005, 32000, 32009, 32007, 32004,

  9194     32006, 32568, 32654, 32703, 32784, 32781, 32785, 32822, 32982, 32997,

  9195     32986, {f: 2, c: 32963}, 32972, 32993, 32987, 32974, 32990, 32996, 32989,

  9196     33268, 33314, 33511, 33539, 33541, 33507, 33499, 33510, 33540, 33509,

  9197     33538, 33545, 33490, 33495, 33521, 33537, 33500, 33492, 33489, 33502,

  9198     33491, 33503, 33519, 33542, 34384, 34425, 34427, 34426, 34893, 34923,

  9199     35201, 35284, 35336, {f: 2, c: 35330}, 35998, 36000, 36212, 36211, 36276,

  9200     36557, 36556, 36848, 36838, 36834, 36842, 36837, 36845, 36843, 36836,

  9201     36840, 37066, 37070, 37057, 37059, 37195, 37194, 37325, 38274, 38480,

  9202     {f: 3, c: 38475}, [12207, 38754], [12208, 38761], [12209, 38859],

  9203     [12210, 38893], [12211, 38899], [12212, 38913], [12213, 39080],

  9204     [12214, 39131], [12215, 39135], [12216, 39318], [12217, 39321], 20056,

  9205     20147, {f: 2, c: 20492}, 20515, 20463, 20518, 20517, 20472, [20521, 57375],

  9206     20502, 20486, 20540, 20511, 20506, 20498, 20497, 20474, 20480, 20500,

  9207     20520, 20465, 20513, 20491, 20505, 20504, 20467, 20462, 20525, 20522,

  9208     20478, 20523, 20489, 20860, {f: 2, c: 20900}, 20898, 20941, 20940, 20934,

  9209     20939, 21078, 21084, 21076, 21083, 21085, 21290, [21375, 57459], 21407,

  9210     21405, 21471, 21736, 21776, 21761, 21815, 21756, 21733, 21746, 21766,

  9211     21754, 21780, 21737, 21741, 21729, 21769, 21742, 21738, 21734, 21799,

  9212     21767, 21757, 21775, {f: 2, c: 22275}, 22466, 22484, 22475, 22467, 22537,

  9213     22799, {f: 2, c: 22871}, 22874, 23057, 23064, 23068, 23071, 23067, 23059,

  9214     23020, 23072, 23075, 23081, 23077, 23052, 23049, 23403, 23640, 23472,

  9215     23475, 23478, 23476, 23470, 23477, 23481, 23480, 23556, 23633, 23637,

  9216     23632, 23789, 23805, 23803, 23786, 23784, 23792, 23798, 23809, 23796,

  9217     24046, 24109, 24107, 24235, 24237, 24231, 24369, 24466, 24465, 24464,

  9218     24665, 24675, 24677, 24656, 24661, 24685, 24681, 24687, 24708, 24735,

  9219     24730, 24717, 24724, 24716, 24709, 24726, 25159, 25331, 25352, 25343,

  9220     25422, 25406, 25391, 25429, 25410, 25414, 25423, 25417, 25402, 25424,

  9221     25405, {f: 2, c: 25386}, 25384, 25421, 25420, {f: 2, c: 25928}, 26009,

  9222     26049, 26053, 26178, 26185, 26191, 26179, 26194, 26188, 26181, 26177,

  9223     26360, {f: 2, c: 26388}, 26391, 26657, 26680, 26696, 26694, 26707, 26681,

  9224     26690, 26708, 26665, 26803, 26647, 26700, 26705, 26685, 26612, 26704,

  9225     26688, 26684, 26691, 26666, 26693, 26643, 26648, 26689, 27530, 27529,

  9226     27575, 27683, {f: 2, c: 27687}, 27686, 27684, 27888, 28010, 28053, 28040,

  9227     28039, 28006, 28024, 28023, 27993, 28051, 28012, 28041, 28014, 27994,

  9228     28020, 28009, 28044, 28042, 28025, 28037, 28005, 28052, 28874, 28888,

  9229     28900, 28889, 28872, 28879, 29241, 29305, 29436, 29433, 29437, 29432,

  9230     29431, 29574, 29677, 29705, 29678, 29664, 29674, 29662, 30036, 30045,

  9231     30044, 30042, 30041, 30142, 30149, 30151, {f: 2, c: 30130}, 30141, 30140,

  9232     30137, 30146, 30136, 30347, 30384, 30410, {f: 2, c: 30413}, 30505,

  9233     {f: 2, c: 30495}, 30504, 30697, 30768, 30759, 30776, 30749, 30772, 30775,

  9234     30757, 30765, 30752, 30751, 30770, 31061, 31056, 31072, 31071, 31062,

  9235     31070, 31069, 31063, 31066, 31204, [31203, 60418], 31207, 31199, 31206,

  9236     31209, 31192, 31364, 31368, 31449, 31494, 31505, 31881, 32033, 32023,

  9237     32011, 32010, 32032, 32034, 32020, 32016, 32021, 32026, 32028, 32013,

  9238     32025, 32027, 32570, 32607, 32660, 32709, 32705, 32774, 32772, 32792,

  9239     32789, 32793, 32791, 32829, 32831, 33009, 33026, 33008, 33029, 33005,

  9240     33012, 33030, 33016, 33011, 33032, 33021, 33034, 33020, 33007, 33261,

  9241     33260, 33280, 33296, {f: 2, c: 33322}, 33320, 33324, 33467, 33579, 33618,

  9242     33620, 33610, 33592, 33616, 33609, 33589, 33588, 33615, 33586, 33593,

  9243     33590, 33559, 33600, 33585, 33576, 33603, 34388, 34442, 34474, 34451,

  9244     34468, 34473, 34444, 34467, 34460, 34928, 34935, {f: 2, c: 34945}, 34941,

  9245     34937, 35352, 35344, 35342, 35340, 35349, 35338, 35351, 35347, 35350,

  9246     35343, 35345, 35912, 35962, 35961, {f: 2, c: 36001}, [36215, 58442], 36524,

  9247     36562, 36564, 36559, 36785, 36865, 36870, 36855, 36864, 36858, 36852,

  9248     36867, 36861, 36869, 36856, 37013, 37089, 37085, 37090, 37202, 37197,

  9249     37196, 37336, 37341, 37335, 37340, 37337, 38275, {f: 2, c: 38498}, 38497,

  9250     38491, 38493, 38500, 38488, 38494, 38587, 39138, [12218, 39340],

  9251     [12219, 39592], [12220, 39640], [12222, 39717], [12224, 39730],

  9252     [12225, 39740], 20094, 20602, [20605, 57382], 20572, 20551, 20547, 20556,

  9253     20570, 20553, 20581, 20598, 20558, 20565, 20597, 20596, 20599, 20559,

  9254     20495, 20591, 20589, 20828, 20885, 20976, 21098, 21103, 21202, 21209,

  9255     21208, 21205, 21264, 21263, 21273, {f: 2, c: 21311}, 21310, 21443, 26364,

  9256     21830, 21866, 21862, 21828, 21854, 21857, 21827, 21834, 21809, 21846,

  9257     21839, 21845, 21807, 21860, 21816, 21806, 21852, 21804, 21859, 21811,

  9258     21825, 21847, 22280, 22283, 22281, 22495, 22533, 22538, 22534, 22496,

  9259     22500, 22522, 22530, 22581, 22519, 22521, 22816, 22882, 23094, 23105,

  9260     23113, 23142, 23146, 23104, 23100, 23138, 23130, 23110, 23114, 23408,

  9261     23495, 23493, 23492, 23490, 23487, 23494, 23561, 23560, 23559, 23648,

  9262     {f: 2, c: 23644}, 23815, 23814, 23822, 23835, 23830, 23842, 23825, 23849,

  9263     23828, 23833, 23844, 23847, 23831, 24034, 24120, 24118, 24115, 24119,

  9264     {f: 2, c: 24247}, 24246, 24245, 24254, 24373, 24375, 24407, 24428, 24425,

  9265     24427, 24471, 24473, 24478, 24472, 24481, 24480, 24476, 24703, 24739,

  9266     24713, 24736, 24744, 24779, 24756, 24806, 24765, 24773, 24763, 24757,

  9267     24796, 24764, 24792, 24789, 24774, 24799, 24760, 24794, 24775,

  9268     {f: 2, c: 25114}, 25160, 25504, 25511, 25458, 25494, 25506, 25509, 25463,

  9269     25447, 25496, 25514, 25457, 25513, 25481, 25475, 25499, 25451, 25512,

  9270     25476, 25480, 25497, 25505, 25516, 25490, 25487, 25472, 25467, 25449,

  9271     25448, 25466, 25949, 25942, 25937, 25945, 25943, 21855, 25935, 25944,

  9272     25941, 25940, 26012, 26011, 26028, 26063, {f: 2, c: 26059}, 26062, 26205,

  9273     26202, 26212, 26216, 26214, 26206, 26361, 21207, 26395, 26753, 26799,

  9274     26786, 26771, 26805, 26751, 26742, 26801, 26791, 26775, 26800, 26755,

  9275     26820, 26797, 26758, 26757, 26772, 26781, 26792, 26783, 26785, 26754,

  9276     27442, 27578, {f: 2, c: 27627}, 27691, 28046, 28092, 28147, 28121, 28082,

  9277     28129, 28108, 28132, 28155, 28154, 28165, 28103, 28107, 28079, 28113,

  9278     28078, 28126, 28153, 28088, 28151, 28149, 28101, 28114, 28186, 28085,

  9279     28122, 28139, 28120, 28138, 28145, 28142, 28136, 28102, 28100, 28074,

  9280     28140, 28095, 28134, 28921, {f: 2, c: 28937}, 28925, 28911, 29245, 29309,

  9281     29313, 29468, 29467, 29462, 29459, 29465, 29575, 29701, 29706, 29699,

  9282     29702, 29694, 29709, 29920, {f: 2, c: 29942}, 29980, 29986,

  9283     {f: 2, c: 30053}, 30050, 30064, 30095, {f: 2, c: 30164}, 30133, 30154,

  9284     30157, 30350, 30420, 30418, 30427, 30519, 30526, 30524, 30518, 30520,

  9285     30522, 30827, 30787, 30798, 31077, 31080, 31085, 31227, 31378, 31381,

  9286     31520, 31528, 31515, 31532, 31526, 31513, 31518, 31534, 31890, 31895,

  9287     31893, 32070, 32067, 32113, 32046, 32057, 32060, 32064, 32048, 32051,

  9288     32068, 32047, 32066, 32050, 32049, 32573, 32670, 32666, 32716, 32718,

  9289     32722, 32796, 32842, 32838, 33071, 33046, 33059, 33067, 33065, 33072,

  9290     33060, 33282, 33333, 33335, 33334, 33337, 33678, 33694, 33688, 33656,

  9291     33698, 33686, 33725, 33707, 33682, 33674, 33683, 33673, 33696, 33655,

  9292     {f: 2, c: 33659}, 33670, 33703, 34389, 24426, 34503, 34496, 34486, 34500,

  9293     34485, 34502, 34507, 34481, 34479, 34505, 34899, 34974, 34952, 34987,

  9294     34962, 34966, 34957, 34955, 35219, 35215, 35370, 35357, 35363, 35365,

  9295     35377, 35373, 35359, 35355, 35362, 35913, 35930, 36009, 36012, 36011,

  9296     36008, 36010, 36007, 36199, 36198, 36286, 36282, 36571, 36575, 36889,

  9297     36877, 36890, 36887, 36899, 36895, 36893, 36880, 36885, 36894, 36896,

  9298     36879, 36898, 36886, 36891, 36884, 37096, 37101, [37117, 58488], 37207,

  9299     37326, 37365, 37350, 37347, 37351, 37357, 37353, 38281, 38506, 38517,

  9300     38515, 38520, 38512, 38516, {f: 2, c: 38518}, 38508, 38592, 38634, 38633,

  9301     31456, 31455, {f: 2, c: 38914}, [12226, 39770], [12227, 40165],

  9302     [12228, 40565], [12229, 40575], [12230, 40613], [12231, 40635], 20642,

  9303     20621, 20613, 20633, 20625, 20608, 20630, 20632, 20634, 26368, 20977,

  9304     21106, {f: 2, c: 21108}, 21097, 21214, 21213, 21211, 21338, 21413, 21883,

  9305     21888, 21927, 21884, 21898, 21917, 21912, 21890, 21916, 21930, 21908,

  9306     21895, 21899, 21891, 21939, 21934, 21919, 21822, 21938, 21914, 21947,

  9307     21932, 21937, 21886, 21897, 21931, 21913, 22285, 22575, 22570, 22580,

  9308     22564, {f: 2, c: 22576}, 22561, 22557, 22560, {f: 2, c: 22777}, 22880,

  9309     [23159, 57587], 23194, 23167, 23186, 23195, 23207, 23411, 23409, 23506,

  9310     23500, 23507, 23504, {f: 2, c: 23562}, 23601, 23884, 23888, 23860, 23879,

  9311     24061, 24133, 24125, 24128, 24131, 24190, 24266, {f: 2, c: 24257}, 24260,

  9312     24380, 24429, {f: 2, c: 24489}, 24488, 24785, 24801, 24754, 24758, 24800,

  9313     24860, 24867, 24826, 24853, 24816, 24827, 24820, 24936, 24817, 24846,

  9314     24822, 24841, 24832, 24850, 25119, 25161, 25507, 25484, 25551, 25536,

  9315     25577, 25545, 25542, 25549, 25554, 25571, 25552, 25569, 25558,

  9316     {f: 2, c: 25581}, 25462, 25588, 25578, 25563, 25682, 25562, 25593, 25950,

  9317     25958, {f: 2, c: 25954}, 26001, 26000, 26031, 26222, 26224, [26228, 57786],

  9318     26230, 26223, 26257, 26234, 26238, 26231, {f: 2, c: 26366}, 26399, 26397,

  9319     26874, 26837, 26848, 26840, 26839, 26885, 26847, 26869, 26862, 26855,

  9320     26873, 26834, 26866, 26851, 26827, 26829, 26893, 26898, 26894, 26825,

  9321     26842, 26990, 26875, 27454, 27450, 27453, 27544, 27542, 27580, 27631,

  9322     {f: 2, c: 27694}, 27692, [28207, 57904], 28216, 28244, 28193, 28210, 28263,

  9323     28234, 28192, 28197, 28195, 28187, 28251, 28248, 28196, 28246, 28270,

  9324     28205, 28198, 28271, 28212, 28237, 28218, 28204, 28227, [28189, 57901],

  9325     28222, 28363, 28297, 28185, 28238, 28259, 28228, 28274, 28265, 28255,

  9326     {f: 2, c: 28953}, 28966, 28976, 28961, 28982, [29038, 57958], 28956, 29260,

  9327     29316, 29312, 29494, 29477, 29492, 29481, 29754, 29738, 29747, 29730,

  9328     29733, {f: 2, c: 29749}, 29748, 29743, 29723, 29734, 29736,

  9329     {f: 2, c: 29989}, 30059, 30058, 30178, 30171, 30179, 30169, 30168, 30174,

  9330     30176, {f: 2, c: 30331}, 30358, 30355, 30388, 30428, 30543, 30701, 30813,

  9331     30828, 30831, 31245, 31240, 31243, 31237, 31232, 31384, 31383, 31382,

  9332     31461, 31459, 31561, 31574, 31558, 31568, 31570, 31572, 31565, 31563,

  9333     31567, [31569, 60510], 31903, 31909, 32094, 32080, 32104, 32085, 32043,

  9334     32110, 32114, 32097, 32102, 32098, 32112, 32115, 21892, {f: 2, c: 32724},

  9335     32779, 32850, 32901, 33109, 33108, 33099, 33105, 33102, 33081, 33094,

  9336     33086, 33100, 33107, 33140, 33298, 33308, 33769, 33795, 33784, 33805,

  9337     33760, 33733, 33803, [33729, 58309], 33775, 33777, 33780, 33879, 33802,

  9338     33776, 33804, 33740, 33789, 33778, 33738, 33848, 33806, 33796, 33756,

  9339     33799, 33748, 33759, 34395, 34527, 34521, 34541, 34516, 34523, 34532,

  9340     34512, 34526, 34903, {f: 2, c: 35009}, 34993, 35203, 35222, 35387, 35424,

  9341     35413, 35422, 35388, 35393, 35412, 35419, 35408, 35398, 35380, 35386,

  9342     35382, 35414, 35937, 35970, 36015, 36028, 36019, 36029, 36033, 36027,

  9343     36032, 36020, 36023, 36022, 36031, 36024, 36234, 36229, 36225, 36302,

  9344     36317, 36299, 36314, 36305, 36300, 36315, 36294, 36603, 36600, 36604,

  9345     36764, 36910, 36917, 36913, 36920, 36914, 36918, 37122, 37109, 37129,

  9346     37118, 37219, 37221, 37327, {f: 2, c: 37396}, 37411, 37385, 37406, 37389,

  9347     37392, 37383, 37393, 38292, 38287, 38283, 38289, 38291, 38290, 38286,

  9348     38538, 38542, 38539, 38525, {f: 2, c: 38533}, 38541, 38514, 38532, 38593,

  9349     38597, 38596, {f: 2, c: 38598}, 38639, 38642, 38860, {f: 2, c: 38917},

  9350     38920, 39143, 39146, 39151, 39145, 39154, 39149, 39342, 39341,

  9351     [12232, 40643], [12233, 40653], [12234, 40657], 20098, 20653, 20661,

  9352     {f: 2, c: 20658}, 20677, 20670, 20652, 20663, 20667, 20655, 20679, 21119,

  9353     21111, 21117, 21215, 21222, 21220, {f: 2, c: 21218}, 21295, 21983, 21992,

  9354     21971, 21990, 21966, 21980, 21959, 21969, {f: 2, c: 21987}, 21999, 21978,

  9355     21985, {f: 2, c: 21957}, 21989, 21961, {f: 2, c: 22290}, 22622, 22609,

  9356     22616, 22615, 22618, 22612, 22635, 22604, 22637, 22602, 22626, 22610,

  9357     22603, 22887, 23233, 23241, 23244, 23230, 23229, 23228, 23219, 23234,

  9358     23218, 23913, 23919, 24140, 24185, 24265, 24264, 24338, 24409, 24492,

  9359     24494, 24858, 24847, 24904, 24863, 24819, 24859, 24825, 24833, 24840,

  9360     24910, 24908, 24900, 24909, 24894, 24884, 24871, 24845, 24838, 24887,

  9361     {f: 2, c: 25121}, 25619, 25662, 25630, 25642, 25645, 25661, 25644, 25615,

  9362     25628, 25620, 25613, 25654, {f: 2, c: 25622}, 25606, 25964, 26015, 26032,

  9363     26263, 26249, {f: 2, c: 26247}, 26262, 26244, 26264, 26253, 26371, 27028,

  9364     26989, 26970, 26999, 26976, 26964, 26997, 26928, 27010, 26954, 26984,

  9365     26987, 26974, 26963, 27001, 27014, 26973, 26979, 26971, 27463, 27506,

  9366     27584, 27583, 27603, 27645, 28322, 28335, 28371, 28342, 28354, 28304,

  9367     28317, 28359, 28357, 28325, 28312, 28348, 28346, 28331, 28369, 28310,

  9368     28316, 28356, 28372, 28330, 28327, 28340, 29006, 29017, 29033, 29028,

  9369     29001, 29031, 29020, 29036, 29030, 29004, 29029, 29022, 28998, 29032,

  9370     29014, 29242, 29266, 29495, 29509, 29503, 29502, 29807, 29786, 29781,

  9371     29791, 29790, 29761, 29759, 29785, 29787, [29788, 58019], 30070, 30072,

  9372     30208, 30192, 30209, 30194, 30193, 30202, 30207, 30196, 30195,

  9373     {f: 2, c: 30430}, 30555, 30571, 30566, 30558, 30563, 30585, 30570, 30572,

  9374     30556, 30565, 30568, 30562, 30702, 30862, 30896, {f: 2, c: 30871}, 30860,

  9375     30857, 30844, 30865, 30867, 30847, 31098, 31103, 31105, 33836, 31165,

  9376     31260, 31258, 31264, 31252, 31263, 31262, {f: 2, c: 31391}, 31607, 31680,

  9377     31584, 31598, 31591, 31921, 31923, 31925, 32147, 32121, 32145, 32129,

  9378     32143, 32091, 32622, {f: 2, c: 32617}, 32626, 32681, 32680, 32676, 32854,

  9379     32856, 32902, 32900, 33137, 33136, 33144, 33125, 33134, 33139, 33131,

  9380     {f: 2, c: 33145}, 33126, 33285, 33351, 33922, 33911, 33853, 33841, 33909,

  9381     33894, 33899, 33865, 33900, 33883, 33852, 33845, 33889, 33891, 33897,

  9382     33901, 33862, 34398, 34396, 34399, 34553, 34579, 34568, 34567, 34560,

  9383     34558, 34555, {f: 2, c: 34562}, 34566, 34570, 34905, 35039, 35028, 35033,

  9384     35036, 35032, 35037, 35041, 35018, 35029, 35026, 35228, 35299, 35435,

  9385     {f: 2, c: 35442}, 35430, 35433, 35440, 35463, 35452, 35427, 35488, 35441,

  9386     35461, 35437, 35426, 35438, 35436, 35449, 35451, 35390, 35432, 35938,

  9387     35978, 35977, 36042, {f: 2, c: 36039}, 36036, 36018, 36035, 36034, 36037,

  9388     36321, 36319, 36328, 36335, 36339, 36346, 36330, 36324, 36326, 36530,

  9389     36611, 36617, 36606, 36618, 36767, 36786, 36939, 36938, 36947, 36930,

  9390     36948, 36924, 36949, 36944, 36935, 36943, 36942, 36941, 36945, 36926,

  9391     36929, 37138, 37143, 37228, 37226, 37225, 37321, 37431, 37463, 37432,

  9392     37437, 37440, 37438, 37467, 37451, 37476, 37457, 37428, 37449, 37453,

  9393     37445, 37433, 37439, 37466, 38296, 38552, {f: 2, c: 38548}, 38605, 38603,

  9394     {f: 2, c: 38601}, 38647, 38651, 38649, 38646, 38742, 38772, 38774,

  9395     {f: 2, c: 38928}, 38931, 38922, 38930, 38924, 39164, 39156,

  9396     {f: 2, c: 39165}, 39347, 39345, 39348, 39649, 40169, 40578, [12237, 40718],

  9397     [12238, 40723], [12239, 40736], 20711, 20718, 20709, 20694, [20717, 60903],

  9398     20698, 20693, 20687, 20689, 20721, 20686, 20713, 20834, 20979, 21123,

  9399     21122, 21297, 21421, 22014, 22016, 22043, 22039, 22013, 22036, 22022,

  9400     22025, {f: 2, c: 22029}, 22007, 22038, 22047, 22024, 22032, 22006, 22296,

  9401     22294, 22645, 22654, 22659, 22675, 22666, 22649, 22661, 22653, 22781,

  9402     22821, 22818, 22820, 22890, 22889, 23265, 23270, 23273, 23255, 23254,

  9403     23256, 23267, 23413, 23518, 23527, 23521, {f: 2, c: 23525}, 23528, 23522,

  9404     23524, 23519, 23565, 23650, 23940, 23943, 24155, 24163, 24149, 24151,

  9405     24148, 24275, 24278, 24330, 24390, 24432, 24505, 24903, 24895, 24907,

  9406     24951, {f: 2, c: 24930}, 24927, 24922, 24920, 24949, 25130, 25735, 25688,

  9407     25684, 25764, 25720, 25695, 25722, 25681, 25703, 25652, 25709, 25723,

  9408     25970, 26017, 26071, 26070, 26274, 26280, 26269, 27036, 27048, 27029,

  9409     27073, 27054, 27091, 27083, 27035, 27063, 27067, 27051, 27060, 27088,

  9410     27085, 27053, 27084, 27046, 27075, 27043, 27465, 27468, 27699, 28467,

  9411     28436, 28414, 28435, 28404, 28457, 28478, 28448, 28460, 28431, 28418,

  9412     28450, 28415, 28399, 28422, 28465, 28472, 28466, 28451, 28437, 28459,

  9413     28463, 28552, 28458, 28396, 28417, 28402, 28364, 28407, 29076, 29081,

  9414     29053, 29066, 29060, 29074, 29246, 29330, 29334, 29508, 29520, 29796,

  9415     29795, 29802, 29808, 29805, 29956, 30097, 30247, 30221, 30219, 30217,

  9416     30227, 30433, 30435, 30596, 30589, 30591, 30561, 30913, 30879, 30887,

  9417     30899, 30889, 30883, {f: 2, c: 31118}, 31117, 31278, 31281, 31402, 31401,

  9418     31469, 31471, 31649, 31637, 31627, 31605, 31639, 31645, 31636, 31631,

  9419     [31672, 58170], 31623, 31620, 31929, {f: 2, c: 31933}, 32187, 32176, 32156,

  9420     {f: 2, c: 32189}, 32160, 32202, 32180, 32178, 32177, 32186, 32162, 32191,

  9421     32181, 32184, 32173, [32210, 58202], 32199, 32172, 32624, {f: 2, c: 32736},

  9422     32735, 32862, 32858, 32903, 33104, 33152, 33167, 33160, 33162, 33151,

  9423     33154, 33255, 33274, 33287, 33300, 33310, 33355, 33993, 33983, 33990,

  9424     33988, 33945, 33950, 33970, 33948, 33995, 33976, 33984, 34003, 33936,

  9425     33980, 34001, 33994, 34623, 34588, 34619, 34594, 34597, 34612, 34584,

  9426     34645, 34615, 34601, 35059, 35074, 35060, 35065, 35064, 35069, 35048,

  9427     35098, 35055, 35494, 35468, 35486, 35491, 35469, 35489, 35475, 35492,

  9428     35498, 35493, 35496, 35480, 35473, 35482, 35495, 35946, 35981, 35980,

  9429     36051, {f: 2, c: 36049}, 36203, 36249, 36245, 36348, 36628, 36626, 36629,

  9430     36627, 36771, 36960, 36952, 36956, 36963, 36953, 36958, 36962, 36957,

  9431     36955, 37145, 37144, 37150, 37237, 37240, 37239, 37236, 37496, 37548,

  9432     37504, 37509, 37528, 37526, 37499, 37523, 37532, 37544, 37500, 37521,

  9433     38305, {f: 2, c: 38312}, 38307, 38309, 38308, 38553, 38556, 38555, 38604,

  9434     38610, 38656, 38780, 38789, 38902, {f: 2, c: 38935}, 39087, 39089, 39171,

  9435     39173, 39180, 39177, 39361, {f: 2, c: 39599}, 39654, {f: 2, c: 39745},

  9436     40180, 40182, 40179, 40636, [12240, 40763], [12241, 40778], 20740, 20736,

  9437     20731, 20725, 20729, 20738, {f: 2, c: 20744}, 20741, 20956,

  9438     {f: 3, c: 21127}, 21133, 21130, 21232, 21426, 22062, 22075, 22073, 22066,

  9439     22079, 22068, 22057, 22099, 22094, 22103, 22132, 22070, {f: 2, c: 22063},

  9440     22656, 22687, 22686, 22707, 22684, 22702, 22697, 22694, 22893, 23305,

  9441     23291, 23307, 23285, 23308, 23304, 23534, 23532, 23529, 23531,

  9442     {f: 2, c: 23652}, 23965, 23956, 24162, 24159, 24161, 24290, 24282, 24287,

  9443     24285, 24291, 24288, 24392, 24433, 24503, 24501, 24950, 24935, 24942,

  9444     24925, 24917, 24962, 24956, 24944, 24939, 24958, 24999, 24976, 25003,

  9445     24974, 25004, 24986, 24996, 24980, 25006, 25134, 25705, 25711, 25721,

  9446     25758, 25778, 25736, [25744, 57745], 25776, 25765, 25747, 25749, 25769,

  9447     25746, 25774, 25773, 25771, 25754, 25772, 25753, 25762, 25779, 25973,

  9448     {f: 2, c: 25975}, 26286, 26283, 26292, 26289, 27171, 27167, 27112, 27137,

  9449     27166, 27161, 27133, 27169, 27155, 27146, 27123, 27138, 27141, 27117,

  9450     27153, 27472, 27470, 27556, {f: 2, c: 27589}, 28479, 28540, 28548, 28497,

  9451     28518, 28500, 28550, 28525, 28507, 28536, 28526, 28558, 28538, 28528,

  9452     28516, 28567, 28504, 28373, 28527, 28512, 28511, 29087, 29100, 29105,

  9453     29096, 29270, 29339, 29518, 29527, 29801, 29835, 29827, 29822, 29824,

  9454     30079, 30240, 30249, 30239, 30244, 30246, {f: 2, c: 30241}, 30362, 30394,

  9455     30436, 30606, 30599, 30604, 30609, 30603, 30923, 30917, 30906, 30922,

  9456     30910, 30933, 30908, 30928, 31295, 31292, 31296, 31293, 31287, 31291,

  9457     31407, 31406, 31661, 31665, 31684, 31668, {f: 2, c: 31686}, 31681, 31648,

  9458     31692, 31946, 32224, 32244, 32239, 32251, 32216, 32236, 32221, 32232,

  9459     32227, 32218, 32222, 32233, 32158, 32217, 32242, 32249, 32629, 32631,

  9460     32687, 32745, 32806, {f: 3, c: 33179}, 33184, 33178, 33176, 34071, 34109,

  9461     34074, 34030, {f: 2, c: 34092}, 34067, 34065, 34083, 34081, 34068, 34028,

  9462     34085, 34047, 34054, 34690, 34676, 34678, 34656, 34662, 34680, 34664,

  9463     34649, 34647, 34636, 34643, 34907, 34909, 35088, 35079, {f: 2, c: 35090},

  9464     35093, 35082, 35516, 35538, 35527, 35524, 35477, 35531, 35576, 35506,

  9465     35529, 35522, 35519, 35504, 35542, 35533, 35510, 35513, 35547, 35916,

  9466     35918, 35948, 36064, 36062, 36070, 36068, {f: 2, c: 36076},

  9467     {f: 2, c: 36066}, 36060, 36074, 36065, 36205, 36255, 36259, 36395, 36368,

  9468     36381, 36386, 36367, 36393, 36383, 36385, 36382, 36538, 36637, 36635,

  9469     36639, 36649, 36646, 36650, 36636, 36638, 36645, 36969, 36974, 36968,

  9470     36973, 36983, 37168, 37165, 37159, 37169, 37255, 37257, 37259, 37251,

  9471     37573, 37563, 37559, 37610, 37604, 37569, 37555, 37564, 37586, 37575,

  9472     37616, 37554, 38317, 38321, 38660, {f: 2, c: 38662}, 38665, 38752, 38797,

  9473     38795, 38799, 38945, 38955, 38940, 39091, 39178, 39187, 39186, 39192,

  9474     39389, 39376, 39391, 39387, 39377, 39381, 39378, 39385, 39607,

  9475     {f: 2, c: 39662}, 39719, 39749, 39748, 39799, 39791, 40198, 40201, 40195,

  9476     40617, 40638, 40654, 22696, [12242, 40786], 20754, 20760, 20756, 20752,

  9477     20757, 20864, 20906, 20957, 21137, 21139, 21235, 22105, 22123, 22137,

  9478     22121, 22116, 22136, 22122, 22120, 22117, 22129, 22127, 22124, 22114,

  9479     22134, 22721, 22718, 22727, 22725, 22894, 23325, 23348, 23416, 23536,

  9480     23566, 24394, 25010, 24977, 25001, 24970, 25037, 25014, 25022, 25034,

  9481     25032, 25136, 25797, 25793, 25803, {f: 2, c: 25787}, 25818, 25796, 25799,

  9482     25794, 25805, 25791, 25810, 25812, 25790, 25972, 26310, 26313, 26297,

  9483     26308, 26311, 26296, 27197, 27192, 27194, 27225, 27243, 27224, 27193,

  9484     27204, 27234, 27233, 27211, 27207, 27189, 27231, 27208, 27481, 27511,

  9485     27653, 28610, 28593, 28577, 28611, 28580, 28609, 28583, 28595, 28608,

  9486     28601, [28598, 60318], 28582, 28576, 28596, 29118, 29129, 29136, 29138,

  9487     29128, 29141, 29113, 29134, 29145, 29148, {f: 2, c: 29123}, 29544, 29852,

  9488     29859, 29848, 29855, 29854, 29922, {f: 2, c: 29964}, 30260, 30264, 30266,

  9489     30439, 30437, 30624, {f: 2, c: 30622}, 30629, 30952, 30938, 30956, 30951,

  9490     31142, {f: 2, c: 31309}, 31302, 31308, 31307, 31418, 31705, 31761, 31689,

  9491     31716, 31707, 31713, 31721, 31718, {f: 2, c: 31957}, 32266, 32273, 32264,

  9492     32283, 32291, 32286, [32285, 58211], 32265, 32272, 32633, 32690,

  9493     {f: 2, c: 32752}, 32750, [32808, 58239], 33203, 33193, 33192, 33275, 33288,

  9494     {f: 2, c: 33368}, 34122, 34137, 34120, {f: 2, c: 34152}, 34115, 34121,

  9495     34157, 34154, 34142, 34691, 34719, 34718, 34722, 34701, 34913, 35114,

  9496     35122, 35109, 35115, 35105, 35242, [35238, 58391], 35558, 35578, 35563,

  9497     35569, 35584, 35548, 35559, 35566, 35582, {f: 2, c: 35585}, 35575, 35565,

  9498     35571, 35574, 35580, 35947, 35949, 35987, 36084, 36420, 36401, 36404,

  9499     36418, 36409, 36405, 36667, 36655, 36664, 36659, 36776, 36774, 36981,

  9500     36980, 36984, 36978, 36988, 36986, 37172, 37266, 37664, 37686, 37624,

  9501     37683, 37679, 37666, 37628, 37675, 37636, 37658, 37648, 37670, 37665,

  9502     37653, 37678, 37657, 38331, {f: 2, c: 38567}, 38570, 38613, 38670, 38673,

  9503     38678, 38669, 38675, 38671, 38747, [38748, 58565], 38758, 38808, 38960,

  9504     38968, 38971, 38967, 38957, 38969, 38948, 39184, 39208, 39198, 39195,

  9505     39201, 39194, 39405, 39394, 39409, 39608, 39612, 39675, 39661, 39720,

  9506     39825, 40213, 40227, 40230, 40232, 40210, 40219, 40664, 40660,

  9507     [12243, 40845], [12244, 40860], 20778, 20767, 20769, 20786, 21237, 22158,

  9508     22144, 22160, 22149, 22151, 22159, 22741, 22739, 22737, 22734, 23344,

  9509     23338, 23332, 23418, 23607, 23656, 23996, 23994, 23997, 23992, 24171,

  9510     24396, 24509, 25033, 25026, 25031, 25062, 25035, 25138, 25140, 25806,

  9511     25802, 25816, 25824, 25840, 25830, 25836, 25841, 25826, 25837,

  9512     {f: 2, c: 25986}, 26329, 26326, 27264, 27284, 27268, 27298, 27292, 27355,

  9513     27299, 27262, 27287, 27280, 27296, 27484, 27566, 27610, 27656, 28632,

  9514     28657, {f: 2, c: 28639}, 28635, 28644, 28651, 28655, 28544, 28652, 28641,

  9515     28649, 28629, 28654, 28656, 29159, [29151, 60361], 29166, 29158, 29157,

  9516     29165, 29164, 29172, 29152, 29237, 29254, 29552, 29554, 29865, 29872,

  9517     29862, 29864, 30278, 30274, 30284, 30442, 30643, 30634, 30640, 30636,

  9518     30631, 30637, 30703, 30967, 30970, 30964, 30959, 30977, 31143, 31146,

  9519     31319, 31423, 31751, 31757, 31742, 31735, 31756, 31712, 31968, 31964,

  9520     31966, 31970, 31967, 31961, 31965, 32302, 32318, 32326, 32311, 32306,

  9521     32323, 32299, 32317, 32305, 32325, 32321, 32308, 32313, 32328, 32309,

  9522     32319, 32303, 32580, 32755, 32764, {f: 2, c: 32881}, 32880, 32879, 32883,

  9523     33222, 33219, 33210, 33218, 33216, 33215, 33213, 33225, 33214, 33256,

  9524     33289, 33393, 34218, 34180, 34174, 34204, 34193, 34196, 34223, 34203,

  9525     34183, 34216, 34186, 34214, 34407, 34752, 34769, 34739, 34770, 34758,

  9526     34731, 34747, 34746, 34760, 34763, 35131, 35126, 35140, 35128, 35133,

  9527     35244, 35598, 35607, 35609, 35611, 35594, 35616, 35613, 35588, 35600,

  9528     35905, 35903, 35955, 36090, 36093, 36092, 36088, 36091, 36264, 36425,

  9529     36427, 36424, 36426, 36676, 36670, 36674, 36677, 36671, 36991, 36989,

  9530     36996, {f: 2, c: 36993}, 36992, 37177, 37283, 37278, 37276, 37709, 37762,

  9531     37672, 37749, 37706, 37733, 37707, 37656, 37758, 37740, 37723, 37744,

  9532     37722, 37716, {f: 3, c: 38346}, 38344, 38342, 38577, 38584, 38614, 38684,

  9533     38686, 38816, 38867, 38982, 39094, 39221, 39425, 39423, 39854, 39851,

  9534     39850, 39853, 40251, 40255, 40587, 40655, 40670, {f: 2, c: 40668}, 40667,

  9535     40766, 40779, 21474, 22165, 22190, 22745, 22744, 23352, 24413, 25059,

  9536     25139, 25844, 25842, 25854, 25862, {f: 2, c: 25850}, 25847, 26039, 26332,

  9537     26406, 27315, 27308, 27331, 27323, 27320, 27330, {f: 2, c: 27310}, 27487,

  9538     27512, 27567, 28681, 28683, 28670, 28678, 28666, 28689, 28687,

  9539     {f: 2, c: 29179}, 29182, 29176, 29559, 29557, 29863, 29887, 29973, 30294,

  9540     30296, 30290, 30653, 30655, {f: 2, c: 30651}, 30990, 31150,

  9541     {f: 2, c: 31329}, 31328, {f: 2, c: 31428}, 31787, 31783, 31786, 31774,

  9542     31779, 31777, 31975, {f: 2, c: 32340}, 32350, 32346, 32353, 32338, 32345,

  9543     32584, 32761, 32763, 32887, 32886, 33229, 33231, 33290, 34255, 34217,

  9544     34253, 34256, 34249, 34224, 34234, 34233, 34799, 34796, 34802, 34784,

  9545     35206, 35250, 35316, 35624, 35641, 35628, 35627, 35920, 36101, 36441,

  9546     36451, 36454, 36452, 36447, 36437, 36544, 36681, 36685, 36999, 36995,

  9547     37000, {f: 2, c: 37291}, 37328, 37780, 37770, 37782, 37794, 37811, 37806,

  9548     37804, 37808, 37784, 37786, 37783, 38356, 38358, 38352, 38357, 38626,

  9549     38620, 38617, 38619, 38622, 38692, 38819, 38822, 38829, 38905, 38989,

  9550     38991, 38988, 38990, 38995, 39098, {f: 2, c: 39230}, 39229, 39214, 39333,

  9551     39438, 39617, 39683, 39686, 39759, 39758, 39757, 39882, 39881, 39933,

  9552     39880, 39872, 40273, 40285, 40288, 40672, 40725, 40748, 20787, 22181,

  9553     22184, {f: 2, c: 22750}, 22754, 23541, 40848, 24300, 25074, 25079, 25078,

  9554     25077, 25856, 25871, 26336, 26333, 27365, 27357, 27354, 27347, 28699,

  9555     28703, 28712, 28698, 28701, 28693, 28696, 29190, 29197, 29272, 29346,

  9556     29560, 29562, 29885, 29898, 29923, 30087, 30086, 30303, 30305, 30663,

  9557     31001, 31153, 31339, 31337, {f: 2, c: 31806}, 31800, 31805, 31799, 31808,

  9558     32363, 32365, 32377, {f: 2, c: 32361}, 32371, 32645, 32694, 32697, 32696,

  9559     33240, 34281, 34269, 34282, 34261, {f: 2, c: 34276}, 34295, 34811, 34821,

  9560     34829, 34809, 34814, 35168, 35167, 35158, 35166, 35649, 35676, 35672,

  9561     35657, 35674, {f: 2, c: 35662}, 35654, 35673, 36104, 36106, 36476, 36466,

  9562     36487, 36470, 36460, 36474, 36468, 36692, 36686, 36781, {f: 2, c: 37002},

  9563     37297, 37294, 37857, 37841, 37855, 37827, 37832, {f: 2, c: 37852}, 37846,

  9564     37858, 37837, 37848, 37860, 37847, 37864, 38364, 38580, 38627, 38698,

  9565     38695, 38753, 38876, 38907, 39006, 39000, 39003, 39100, 39237, 39241,

  9566     39446, 39449, 39693, 39912, 39911, 39894, 39899, 40329, 40289, 40306,

  9567     40298, 40300, 40594, 40599, 40595, 40628, 21240, 22199, 22198, 22196,

  9568     22204, 22756, 23360, 23363, 23421, 23542, 24009, 25080, 25082, 25880,

  9569     25876, 25881, 26342, 26407, 27372, 28734, 28720, 28722, 29200, 29563,

  9570     29903, 30306, 30309, 31014, 31018, 31020, 31019, 31431, 31478, 31820,

  9571     31811, 31821, {f: 2, c: 31983}, 36782, 32381, 32380, 32386, 32588, 32768,

  9572     33242, 33382, 34299, 34297, 34321, 34298, 34310, 34315, 34311, 34314,

  9573     {f: 2, c: 34836}, 35172, 35258, 35320, 35696, 35692, 35686, 35695, 35679,

  9574     35691, 36111, 36109, 36489, 36481, 36485, 36482, 37300, 37323, 37912,

  9575     37891, 37885, 38369, 38704, 39108, 39250, 39249, 39336, 39467, 39472,

  9576     39479, 39477, 39955, 39949, 40569, 40629, 40680, 40751, 40799, 40803,

  9577     40801, {f: 2, c: 20791}, 22209, 22208, 22210, 22804, 23660, 24013, 25084,

  9578     25086, 25885, 25884, 26005, 26345, 27387, 27396, 27386, 27570, 28748,

  9579     29211, 29351, 29910, 29908, 30313, 30675, 31824, 32399, 32396, 32700,

  9580     34327, 34349, 34330, 34851, 34850, 34849, 34847, 35178, 35180, 35261,

  9581     35700, 35703, 35709, 36115, 36490, 36493, 36491, 36703, 36783, 37306,

  9582     37934, 37939, 37941, 37946, 37944, 37938, 37931, 38370, {f: 2, c: 38712},

  9583     38706, [38911, 58586], 39015, 39013, 39255, 39493, 39491, 39488, 39486,

  9584     39631, 39764, 39761, 39981, 39973, 40367, 40372, 40386, 40376, 40605,

  9585     40687, 40729, 40796, {f: 2, c: 40806}, 20796, 20795, 22216, 22218, 22217,

  9586     23423, 24020, 24018, 24398, 25087, 25892, 27402, 27489, 28753, 28760,

  9587     29568, 29924, 30090, 30318, 30316, 31155, 31840, 31839, 32894, 32893,

  9588     33247, 35186, 35183, 35324, 35712, {f: 2, c: 36118}, 36497, 36499, 36705,

  9589     37192, 37956, {f: 2, c: 37969}, {f: 2, c: 38717}, 38851, 38849, 39019,

  9590     39253, 39509, 39501, 39634, 39706, 40009, 39985, 39998, 39995, 40403,

  9591     40407, 40756, 40812, 40810, 40852, 22220, 24022, 25088, 25891, 25899,

  9592     25898, 26348, 27408, 29914, 31434, 31844, 31843, 31845, 32403, 32406,

  9593     32404, 33250, 34360, 34367, 34865, 35722, 37008, 37007, 37987, 37984,

  9594     37988, 38760, 39023, 39260, {f: 2, c: 39514}, 39511, {f: 2, c: 39635},

  9595     39633, 40020, 40023, 40022, 40421, 40607, 40692, 22225, 22761, 25900,

  9596     28766, {f: 2, c: 30321}, [30679, 60226], 32592, 32648, 34870, 34873, 34914,

  9597     35731, 35730, 35734, 33399, 36123, 37312, 37994, 38722, 38728, 38724,

  9598     38854, 39024, 39519, 39714, 39768, 40031, {f: 2, c: 40441},

  9599     {f: 2, c: 40572}, 40711, 40823, 40818, 24307, 27414, 28771, 31852, 31854,

  9600     34875, 35264, 36513, 37313, 38002, 38000, 39025, 39262, 39638, 39715,

  9601     40652, 28772, 30682, 35738, 38007, 38857, 39522, 39525, 32412, 35740,

  9602     36522, 37317, {f: 2, c: 38013}, 38012, {f: 2, c: 40055}, 40695, 35924,

  9603     38015, 40474, 29224, 39530, 39729, 40475, 40478, 31858, 20034, 20060,

  9604     [12048, 20981], [12053, 21274], [12058, 21378], 19975, 19980, 20039, 20109,

  9605     [12062, 22231], [12076, 23662], [12091, 24435], 19983, 20871, 19982, 20014,

  9606     20115, 20162, 20169, 20168, 20888, 21244, 21356, 21433, 22304, 22787,

  9607     22828, [23568, 60417], 24063, 26081, [12110, 27571], 27596, [12115, 27668],

  9608     [12121, 29247], 20017, 20028, 20200, 20188, 20201, 20193, 20189, 20186,

  9609     21004, 21001, 21276, 21324, {f: 2, c: 22306}, 22807, 22831, 23425, 23428,

  9610     23570, 23611, 23668, 23667, 24068, 24192, 24194, 24521, 25097, 25168,

  9611     27669, 27702, 27715, 27711, 27707, 29358, 29360, 29578, [12145, 31160],

  9612     32906, 38430, 20238, 20248, 20268, 20213, 20244, 20209, 20224, 20215,

  9613     20232, 20253, 20226, 20229, 20258, 20243, 20228, 20212, 20242, 20913,

  9614     21011, 21008, 21158, 21282, 21279, 21325, 21386, 21511, 22241, 22239,

  9615     22318, 22314, 22324, 22844, 22912, 22908, 22917, 22907, 22910, 22903,

  9616     22911, 23382, 23573, 23589, 23676, {f: 2, c: 23674}, 23678, 24031,

  9617     [24181, 57646], 24196, 24322, 24346, 24436, 24533, 24532, 24527, 25180,

  9618     25182, 25188, 25185, 25190, 25186, 25177, 25184, 25178, 25189, 25911,

  9619     26095, 26094, 26430, 26425, 26424, 26427, 26426, 26431, 26428, 26419,

  9620     27672, 27718, 27730, 27740, 27727, [27722, 60796], 27732, {f: 2, c: 27723},

  9621     28785, 29278, {f: 2, c: 29364}, 29582, 29994, 30335, 31349, [12153, 32593],

  9622     [12171, 33400], 33404, 33408, 33405, 33407, [12172, 34381], [12177, 35198],

  9623     37017, [37015, 59347], 37016, 37019, 37012, 38434, 38436, 38432, 38435,

  9624     20310, 20283, 20322, 20297, 20307, 20324, 20286, 20327, 20306, 20319,

  9625     20289, 20312, 20269, 20275, 20287, 20321, 20879, 20921, 21020, 21022,

  9626     21025, {f: 2, c: 21165}, 21257, 21347, 21362, {f: 2, c: 21390}, 21552,

  9627     21559, 21546, 21588, 21573, 21529, 21532, 21541, 21528, 21565, 21583,

  9628     21569, 21544, 21540, 21575, 22254, 22247, 22245, 22337, 22341, 22348,

  9629     22345, 22347, 22354, 22790, 22848, 22950, 22936, 22944, 22935, 22926,

  9630     22946, 22928, 22927, 22951, 22945, 23438, 23442, 23592, 23594, 23693,

  9631     23695, 23688, 23691, 23689, 23698, 23690, 23686, 23699, 23701, 24032,

  9632     24074, 24078, 24203, 24201, 24204, 24200, 24205, 24325, 24349, 24440,

  9633     24438, 24530, 24529, 24528, 24557, 24552, 24558, 24563, 24545, 24548,

  9634     24547, 24570, 24559, 24567, 24571, 24576, 24564, 25146, 25219, 25228,

  9635     {f: 2, c: 25230}, 25236, 25223, 25201, 25211, 25210, 25200, 25217, 25224,

  9636     25207, 25213, 25202, 25204, 26096, 26100, 26099, 26098, 26101, 26437,

  9637     26439, 26457, 26453, 26444, 26440, 26461, 26445, 26458, 26443, 27600,

  9638     {f: 2, c: 27673}, 27768, 27751, 27755, 27780, 27787, 27791, 27761, 27759,

  9639     27753, 27802, 27757, 27783, 27797, [27804, 57900], 27750, 27763, 27749,

  9640     27771, 27790, 28788, 28794, 29283, 29375, 29373, 29379, 29382, 29377,

  9641     29370, 29381, 29589, 29591, {f: 2, c: 29587}, 29586, 30010, 30009,

  9642     {f: 2, c: 30100}, 30337, 31037, 32820, 32917, 32921, 32912, 32914, 32924,

  9643     33424, 33423, 33413, 33422, 33425, 33427, 33418, {f: 2, c: 33411},

  9644     [12184, 35960], 36809, 36799, 37023, 37025, 37029, 37022, 37031, 37024,

  9645     38448, 38440, 38447, 38445, 20019, 20376, 20348, 20357, 20349, 20352,

  9646     20359, 20342, 20340, 20361, 20356, 20343, 20300, 20375, 20330, 20378,

  9647     20345, 20353, 20344, 20368, 20380, 20372, 20382, 20370, 20354, 20373,

  9648     20331, 20334, 20894, 20924, 20926, 21045, {f: 2, c: 21042}, 21062, 21041,

  9649     21180, {f: 2, c: 21258}, 21308, 21394, 21396, 21639, 21631, 21633, 21649,

  9650     21634, 21640, 21611, 21626, 21630, 21605, 21612, 21620, 21606, 21645,

  9651     21615, 21601, 21600, 21656, 21603, 21607, 21604, 22263, 22265, 22383,

  9652     22386, 22381, 22379, 22385, 22384, 22390, 22400, 22389, 22395,

  9653     {f: 2, c: 22387}, 22370, 22376, 22397, 22796, 22853, 22965, 22970, 22991,

  9654     22990, 22962, 22988, 22977, 22966, 22972, 22979, 22998, 22961, 22973,

  9655     22976, 22984, 22964, 22983, 23394, 23397, 23443, 23445, 23620, 23623,

  9656     23726, 23716, 23712, 23733, 23727, 23720, 23724, 23711, 23715, 23725,

  9657     23714, 23722, 23719, 23709, 23717, 23734, 23728, 23718, 24087, 24084,

  9658     24089, 24360, {f: 3, c: 24354}, 24404, 24450, 24446, 24445, 24542, 24549,

  9659     24621, 24614, 24601, 24626, 24587, 24628, 24586, 24599, 24627, 24602,

  9660     24606, 24620, 24610, 24589, 24592, 24622, 24595, 24593, 24588, 24585,

  9661     24604, 25108, 25149, 25261, 25268, 25297, 25278, 25258, 25270, 25290,

  9662     25262, 25267, 25263, 25275, 25257, 25264, 25272, 25917, 26024, 26043,

  9663     26121, 26108, 26116, 26130, 26120, 26107, 26115, 26123, 26125, 26117,

  9664     26109, 26129, 26128, 26358, 26378, 26501, 26476, 26510, 26514, 26486,

  9665     26491, 26520, 26502, 26500, 26484, 26509, 26508, 26490, 26527, 26513,

  9666     26521, 26499, 26493, 26497, {f: 2, c: 26488}, 26516, 27429, 27520, 27518,

  9667     27614, 27677, 27795, 27884, 27883, 27886, 27865, 27830, 27860, 27821,

  9668     27879, 27831, 27856, 27842, 27834, 27843, 27846, 27885, 27890, 27858,

  9669     27869, 27828, 27786, 27805, 27776, 27870, 27840, 27952, 27853, 27847,

  9670     27824, 27897, 27855, 27881, 27857, 28820, 28824, 28805, 28819, 28806,

  9671     28804, 28817, 28822, 28802, 28826, 28803, 29290, 29398, 29387, 29400,

  9672     29385, 29404, 29394, 29396, 29402, 29388, 29393, 29604, 29601, 29613,

  9673     29606, 29602, 29600, 29612, 29597, 29917, 29928, {f: 2, c: 30015}, 30014,

  9674     30092, 30104, 30383, 30451, 30449, 30448, 30453, 30712, 30716, 30713,

  9675     30715, 30714, 30711, 31042, 31039, 31173, 31352, 31355, 31483, 31861,

  9676     31997, 32821, 32911, 32942, 32931, 32952, 32949, 32941, 33312, 33440,

  9677     33472, 33451, 33434, 33432, 33435, 33461, 33447, 33454, 33468, 33438,

  9678     33466, 33460, 33448, 33441, 33449, 33474, 33444, 33475, 33462, 33442,

  9679     34416, 34415, {f: 2, c: 34413}, 35926, 36818, 36811, 36819, 36813, 36822,

  9680     36821, 36823, 37042, 37044, 37039, 37043, 37040, 38457, 38461, 38460,

  9681     38458, 38467, 20429, 20421, 20435, 20402, 20425, 20427, 20417, 20436,

  9682     20444, 20441, [20411, 60346], 20403, 20443, 20423, 20438, 20410, 20416,

  9683     20409, 20460, 21060, 21065, 21184, 21186, 21309, 21372, 21399, 21398,

  9684     21401, 21400, 21690, 21665, 21677, 21669, 21711, 21699, 33549, 21687,

  9685     21678, 21718, 21686, {f: 2, c: 21701}, 21664, 21616, 21692, 21666, 21694,

  9686     21618, 21726, 21680, 22453, {f: 2, c: 22430}, 22436, 22412, 22423, 22429,

  9687     22427, 22420, 22424, 22415, 22425, 22437, 22426, 22421, 22772, 22797,

  9688     22867, 23009, 23006, 23022, 23040, 23025, 23005, 23034, 23037, 23036,

  9689     23030, 23012, 23026, 23031, 23003, 23017, 23027, 23029, 23008, 23038,

  9690     23028, 23021, 23464, 23628, 23760, 23768, 23756, 23767, 23755, 23771,

  9691     23774, 23770, 23753, 23751, 23754, 23766, {f: 2, c: 23763}, 23759, 23752,

  9692     23750, 23758, 23775, 23800, 24057, {f: 3, c: 24097}, 24096, 24100, 24240,

  9693     24228, 24226, 24219, 24227, 24229, 24327, 24366, 24406, 24454, 24631,

  9694     24633, 24660, 24690, 24670, 24645, 24659, 24647, 24649, 24667, 24652,

  9695     24640, 24642, 24671, 24612, 24644, 24664, 24678, 24686, {f: 2, c: 25154},

  9696     25295, 25357, 25355, 25333, 25358, 25347, 25323, 25337, 25359, 25356,

  9697     25336, 25334, 25344, {f: 2, c: 25363}, 25338, 25365, 25339, 25328, 25921,

  9698     25923, 26026, 26047, 26166, 26145, 26162, 26165, 26140, 26150, 26146,

  9699     26163, 26155, 26170, 26141, 26164, 26169, 26158, {f: 2, c: 26383}, 26561,

  9700     26610, 26568, 26554, 26588, 26555, 26616, 26584, 26560, 26551, 26565,

  9701     26603, 26596, 26591, 26549, 26573, 26547, 26615, 26614, 26606, 26595,

  9702     26562, 26553, 26574, 26599, 26608, 26546, 26620, 26566, 26605, 26572,

  9703     26542, 26598, 26587, 26618, {f: 2, c: 26569}, 26563, 26602, 26571, 27432,

  9704     27522, 27524, 27574, 27606, 27608, 27616, {f: 2, c: 27680}, 27944, 27956,

  9705     27949, 27935, 27964, 27967, 27922, 27914, 27866, 27955, 27908, 27929,

  9706     27962, 27930, 27921, 27904, 27933, 27970, 27905, 27928, 27959, 27907,

  9707     27919, 27968, 27911, 27936, 27948, 27912, 27938, 27913, 27920, 28855,

  9708     28831, 28862, 28849, 28848, 28833, {f: 2, c: 28852}, 28841, 29249,

  9709     {f: 2, c: 29257}, 29292, 29296, 29299, 29294, 29386, 29412, 29416, 29419,

  9710     29407, 29418, 29414, 29411, 29573, 29644, 29634, 29640, 29637, 29625,

  9711     29622, 29621, 29620, 29675, 29631, 29639, 29630, 29635, 29638, 29624,

  9712     29643, 29932, 29934, 29998, {f: 2, c: 30023}, 30119, 30122, 30329, 30404,

  9713     30472, {f: 3, c: 30467}, 30474, 30455, 30459, 30458, {f: 2, c: 30695},

  9714     30726, {f: 2, c: 30737}, 30725, 30736, 30735, 30734, [30729, 58095], 30723,

  9715     30739, 31050, 31052, 31051, 31045, 31044, 31189, 31181, 31183, 31190,

  9716     31182, 31360, 31358, 31441, {f: 2, c: 31488}, 31866, {f: 2, c: 31864},

  9717     {f: 3, c: 31871}, 32003, 32008, 32001, 32600, 32657, 32653, 32702, 32775,

  9718     {f: 2, c: 32782}, 32788, 32823, 32984, 32967, 32992, 32977, 32968, 32962,

  9719     32976, 32965, 32995, 32985, 32988, 32970, 32981, 32969, 32975, 32983,

  9720     32998, 32973, 33279, 33313, 33428, 33497, 33534, 33529, 33543, 33512,

  9721     33536, 33493, 33594, 33515, 33494, 33524, 33516, 33505, 33522, 33525,

  9722     33548, 33531, 33526, 33520, 33514, 33508, 33504, 33530, 33523, 33517,

  9723     34423, 34420, 34428, 34419, 34881, 34894, 34919, 34922, 34921, 35283,

  9724     35332, 35335, 36210, 36835, 36833, 36846, 36832, 37105, 37053, 37055,

  9725     37077, 37061, 37054, 37063, 37067, 37064, [37332, 60294], 37331, 38484,

  9726     38479, 38481, 38483, 38474, 38478, 20510, 20485, 20487, 20499, 20514,

  9727     20528, 20507, 20469, 20468, 20531, 20535, 20524, {f: 2, c: 20470}, 20503,

  9728     20508, 20512, 20519, 20533, 20527, 20529, 20494, 20826, 20884, 20883,

  9729     20938, {f: 2, c: 20932}, 20936, 20942, 21089, 21082, 21074,

  9730     {f: 2, c: 21086}, 21077, 21090, 21197, 21262, 21406, 21798, 21730, 21783,

  9731     21778, 21735, 21747, 21732, 21786, 21759, 21764, 21768, 21739, 21777,

  9732     21765, 21745, 21770, 21755, {f: 2, c: 21751}, 21728, 21774, 21763, 21771,

  9733     {f: 2, c: 22273}, 22476, 22578, 22485, 22482, 22458, 22470, 22461, 22460,

  9734     22456, 22454, 22463, 22471, 22480, 22457, 22465, 22798, 22858, 23065,

  9735     23062, {f: 2, c: 23085}, 23061, 23055, 23063, 23050, 23070, 23091, 23404,

  9736     23463, 23469, 23468, 23555, 23638, 23636, 23788, 23807, 23790, 23793,

  9737     23799, 23808, 23801, 24105, 24104, 24232, 24238, 24234, 24236, 24371,

  9738     24368, 24423, 24669, 24666, 24679, 24641, 24738, 24712, 24704, 24722,

  9739     24705, 24733, 24707, 24725, 24731, 24727, 24711, 24732, 24718, 25113,

  9740     25158, 25330, 25360, 25430, 25388, {f: 2, c: 25412}, 25398, 25411, 25572,

  9741     25401, 25419, 25418, 25404, 25385, 25409, 25396, 25432, 25428, 25433,

  9742     25389, 25415, 25395, 25434, 25425, 25400, 25431, 25408, 25416, 25930,

  9743     25926, 26054, {f: 2, c: 26051}, 26050, 26186, 26207, 26183, 26193,

  9744     {f: 2, c: 26386}, 26655, 26650, 26697, {f: 2, c: 26674}, 26683, 26699,

  9745     26703, 26646, 26673, 26652, 26677, 26667, 26669, 26671, 26702, 26692,

  9746     26676, 26653, 26642, 26644, 26662, 26664, 26670, 26701, 26682, 26661,

  9747     26656, 27436, 27439, 27437, 27441, 27444, 27501, 32898, 27528, 27622,

  9748     27620, 27624, 27619, 27618, 27623, 27685, 28026, {f: 2, c: 28003}, 28022,

  9749     27917, 28001, 28050, 27992, 28002, 28013, 28015, 28049, 28045, 28143,

  9750     28031, 28038, 27998, [28007, 59078], 28000, 28055, 28016, 28028, 27999,

  9751     28034, 28056, 27951, 28008, 28043, 28030, 28032, 28036, 27926, 28035,

  9752     28027, 28029, 28021, 28048, 28892, 28883, 28881, 28893, 28875, 32569,

  9753     28898, 28887, 28882, 28894, 28896, 28884, 28877, {f: 3, c: 28869}, 28890,

  9754     28878, 28897, 29250, 29304, 29303, 29302, 29440, 29434, 29428, 29438,

  9755     29430, 29427, 29435, 29441, 29651, 29657, 29669, 29654, 29628, 29671,

  9756     29667, 29673, 29660, 29650, 29659, 29652, 29661, 29658, {f: 2, c: 29655},

  9757     29672, {f: 2, c: 29918}, {f: 2, c: 29940}, 29985, 30043, 30047, 30128,

  9758     30145, 30139, 30148, 30144, 30143, 30134, 30138, 30346, 30409, 30493,

  9759     30491, 30480, 30483, 30482, 30499, 30481, 30485, {f: 2, c: 30489}, 30498,

  9760     30503, 30755, 30764, 30754, 30773, 30767, 30760, 30766, 30763, 30753,

  9761     30761, 30771, 30762, 30769, 31060, 31067, 31055, 31068, 31059, 31058,

  9762     31057, {f: 2, c: 31211}, 31200, 31214, 31213, 31210, 31196, 31198, 31197,

  9763     31366, 31369, 31365, {f: 2, c: 31371}, 31370, 31367, 31448, 31504, 31492,

  9764     31507, 31493, 31503, 31496, 31498, 31502, 31497, 31506, 31876, 31889,

  9765     31882, 31884, 31880, 31885, 31877, 32030, 32029, 32017, 32014, 32024,

  9766     32022, 32019, 32031, 32018, 32015, 32012, 32604, 32609, 32606, 32608,

  9767     32605, 32603, 32662, 32658, 32707, 32706, 32704, 32790, 32830, 32825,

  9768     33018, 33010, 33017, 33013, 33025, 33019, 33024, 33281, 33327, 33317,

  9769     33587, 33581, 33604, 33561, 33617, 33573, 33622, 33599, 33601, 33574,

  9770     33564, 33570, 33602, 33614, 33563, 33578, 33544, 33596, 33613, 33558,

  9771     33572, 33568, 33591, 33583, 33577, 33607, 33605, 33612, 33619, 33566,

  9772     33580, 33611, 33575, 33608, 34387, 34386, 34466, 34472, 34454, 34445,

  9773     34449, 34462, 34439, 34455, 34438, 34443, 34458, 34437, 34469, 34457,

  9774     34465, 34471, 34453, 34456, 34446, 34461, 34448, 34452, {f: 2, c: 34883},

  9775     34925, {f: 2, c: 34933}, 34930, 34944, 34929, 34943, 34927, 34947, 34942,

  9776     34932, 34940, 35346, 35911, 35927, 35963, 36004, 36003, 36214, 36216,

  9777     36277, 36279, 36278, 36561, 36563, 36862, 36853, 36866, 36863, 36859,

  9778     36868, 36860, 36854, 37078, 37088, {f: 2, c: 37081}, 37091, 37087, 37093,

  9779     37080, 37083, 37079, 37084, 37092, 37200, {f: 2, c: 37198}, 37333, 37346,

  9780     37338, 38492, 38495, 38588, 39139, [12221, 39647], [12223, 39727], 20095,

  9781     20592, 20586, 20577, 20574, 20576, 20563, 20555, 20573, 20594, 20552,

  9782     20557, 20545, 20571, 20554, 20578, 20501, 20549, 20575, 20585, 20587,

  9783     {f: 2, c: 20579}, 20550, 20544, 20590, 20595, 20567, 20561, 20944, 21099,

  9784     21101, 21100, 21102, 21206, 21203, 21293, 21404, {f: 2, c: 21877}, 21820,

  9785     21837, 21840, 21812, 21802, 21841, 21858, 21814, 21813, 21808, 21842,

  9786     21829, 21772, 21810, 21861, 21838, 21817, 21832, 21805, 21819, 21824,

  9787     21835, 22282, 22279, 22523, 22548, 22498, 22518, 22492, 22516, 22528,

  9788     22509, 22525, 22536, 22520, 22539, 22515, 22479, 22535, 22510, 22499,

  9789     22514, 22501, 22508, 22497, 22542, 22524, 22544, 22503, 22529, 22540,

  9790     22513, 22505, 22512, 22541, 22532, 22876, 23136, 23128, 23125,

  9791     [23143, 60437], 23134, 23096, 23093, 23149, 23120, 23135, 23141, 23148,

  9792     23123, 23140, 23127, 23107, 23133, 23122, 23108, 23131, 23112, 23182,

  9793     23102, 23117, 23097, 23116, 23152, 23145, 23111, 23121, 23126, 23106,

  9794     23132, 23410, 23406, 23489, 23488, 23641, 23838, 23819, 23837, 23834,

  9795     23840, 23820, 23848, 23821, 23846, 23845, 23823, 23856, 23826, 23843,

  9796     23839, 23854, 24126, 24116, 24241, 24244, 24249, {f: 2, c: 24242}, 24374,

  9797     24376, 24475, 24470, 24479, 24714, 24720, 24710, 24766, 24752, 24762,

  9798     {f: 2, c: 24787}, 24783, 24804, 24793, 24797, 24776, 24753, 24795, 24759,

  9799     24778, 24767, 24771, 24781, 24768, 25394, 25445, 25482, 25474, 25469,

  9800     25533, 25502, 25517, 25501, 25495, 25515, 25486, 25455, 25479, 25488,

  9801     25454, 25519, 25461, 25500, 25453, 25518, 25468, 25508, 25403, 25503,

  9802     25464, 25477, 25473, 25489, 25485, 25456, 25939, 26061, 26213, 26209,

  9803     26203, 26201, 26204, 26210, 26392, 26745, 26759, 26768, 26780,

  9804     {f: 2, c: 26733}, 26798, 26795, 26966, 26735, 26787, 26796, 26793, 26741,

  9805     26740, 26802, 26767, 26743, 26770, 26748, 26731, 26738, 26794, 26752,

  9806     26737, 26750, 26779, 26774, 26763, 26784, 26761, 26788, 26744, 26747,

  9807     26769, 26764, 26762, 26749, 27446, 27443, {f: 2, c: 27447}, 27537, 27535,

  9808     {f: 2, c: 27533}, 27532, 27690, 28096, 28075, 28084, 28083, 28276, 28076,

  9809     28137, 28130, 28087, 28150, 28116, 28160, 28104, 28128, 28127, 28118,

  9810     28094, 28133, {f: 2, c: 28124}, 28123, 28148, 28106, 28093, 28141, 28144,

  9811     28090, 28117, 28098, 28111, 28105, 28112, 28146, 28115, 28157, 28119,

  9812     28109, 28131, 28091, 28922, 28941, 28919, 28951, 28916, 28940, 28912,

  9813     28932, 28915, 28944, 28924, 28927, 28934, 28947, 28928, 28920, 28918,

  9814     28939, 28930, 28942, 29310, {f: 2, c: 29307}, 29311, 29469, 29463, 29447,

  9815     29457, 29464, 29450, 29448, 29439, 29455, 29470, 29576, 29686, 29688,

  9816     29685, 29700, 29697, 29693, 29703, 29696, 29690, 29692, 29695, 29708,

  9817     29707, 29684, 29704, 30052, 30051, 30158, 30162, 30159, {f: 2, c: 30155},

  9818     30161, 30160, 30351, 30345, 30419, 30521, 30511, 30509, {f: 2, c: 30513},

  9819     30516, 30515, 30525, 30501, 30523, 30517, 30792, 30802, 30793, 30797,

  9820     30794, 30796, 30758, 30789, 30800, 31076, 31079, {f: 2, c: 31081}, 31075,

  9821     31083, 31073, 31163, 31226, 31224, {f: 2, c: 31222}, 31375, 31380, 31376,

  9822     31541, 31547, 31540, 31525, 31536, 31522, 31524, 31539, 31512, 31530,

  9823     31517, 31537, 31531, 31533, 31535, 31538, 31544, 31514, 31523, 31892,

  9824     31896, 31894, 31907, 32053, 32061, 32056, 32054, 32058, 32069, 32044,

  9825     32041, 32065, 32071, {f: 2, c: 32062}, 32074, 32059, 32040, 32611, 32661,

  9826     {f: 2, c: 32668}, 32667, {f: 2, c: 32714}, 32717, {f: 2, c: 32720}, 32711,

  9827     32719, 32713, 32799, 32798, 32795, 32839, 32835, 32840, 33048, 33061,

  9828     33049, 33051, 33069, 33055, 33068, 33054, 33057, 33045, 33063, 33053,

  9829     33058, 33297, 33336, 33331, 33338, 33332, 33330, 33396, 33680, 33699,

  9830     33704, 33677, 33658, 33651, 33700, 33652, 33679, 33665, 33685, 33689,

  9831     33653, 33684, 33705, 33661, 33667, 33676, 33693, 33691, 33706, 33675,

  9832     33662, 33701, 33711, 33672, 33687, 33712, 33663, 33702, 33671, 33710,

  9833     33654, 34393, 34390, 34495, 34487, 34498, 34497, 34501, 34490, 34480,

  9834     34504, 34489, 34483, 34488, 34508, 34484, {f: 2, c: 34491}, 34499,

  9835     {f: 2, c: 34493}, 34898, 34953, 34965, 34984, 34978, 34986, 34970, 34961,

  9836     34977, 34975, 34968, 34983, 34969, 34971, 34967, 34980, 34988, 34956,

  9837     34963, 34958, 35202, 35286, 35289, 35285, 35376, 35367, 35372, 35358,

  9838     35897, 35899, {f: 2, c: 35932}, 35965, 36005, 36221, 36219, 36217, 36284,

  9839     36290, 36281, 36287, 36289, 36568, 36574, 36573, 36572, 36567,

  9840     {f: 2, c: 36576}, 36900, 36875, 36881, 36892, 36876, 36897, 37103, 37098,

  9841     37104, 37108, {f: 2, c: 37106}, 37076, {f: 2, c: 37099}, 37097, 37206,

  9842     37208, 37210, 37203, 37205, 37356, 37364, 37361, 37363, 37368, 37348,

  9843     37369, {f: 2, c: 37354}, 37367, 37352, 37358, 38266, 38278, 38280, 38524,

  9844     38509, 38507, 38513, 38511, 38591, 38762, 38916, 39141, 39319, 20635,

  9845     20629, 20628, 20638, 20619, 20643, 20611, 20620, 20622, 20637, 20584,

  9846     20636, 20626, 20610, 20615, 20831, 20948, 21266, 21265, 21412, 21415,

  9847     21905, 21928, 21925, 21933, 21879, 22085, 21922, 21907, 21896, 21903,

  9848     21941, 21889, 21923, 21906, 21924, 21885, 21900, 21926, 21887, 21909,

  9849     21921, 21902, 22284, 22569, 22583, 22553, 22558, 22567, 22563, 22568,

  9850     22517, 22600, 22565, 22556, 22555, 22579, 22591, 22582, 22574, 22585,

  9851     22584, 22573, 22572, 22587, 22881, 23215, 23188, 23199, 23162, 23202,

  9852     23198, 23160, 23206, 23164, 23205, 23212, 23189, 23214, 23095, 23172,

  9853     23178, 23191, 23171, 23179, 23209, 23163, 23165, 23180, 23196, 23183,

  9854     23187, 23197, 23530, 23501, 23499, 23508, 23505, 23498, 23502, 23564,

  9855     23600, 23863, 23875, 23915, 23873, 23883, 23871, 23861, 23889, 23886,

  9856     23893, 23859, 23866, 23890, 23869, 23857, 23897, 23874, 23865, 23881,

  9857     23864, 23868, 23858, 23862, 23872, 23877, 24132, 24129, [24408, 57673],

  9858     24486, 24485, 24491, 24777, 24761, 24780, 24802, 24782, 24772, 24852,

  9859     24818, 24842, 24854, 24837, 24821, 24851, 24824, 24828, 24830, 24769,

  9860     24835, 24856, 24861, 24848, 24831, 24836, 24843, 25162, 25492, 25521,

  9861     25520, 25550, 25573, 25576, 25583, 25539, 25757, 25587, 25546, 25568,

  9862     25590, 25557, 25586, 25589, 25697, 25567, 25534, 25565, 25564, 25540,

  9863     25560, 25555, 25538, 25543, 25548, 25547, 25544, 25584, 25559, 25561,

  9864     25906, 25959, 25962, 25956, 25948, 25960, 25957, 25996, {f: 2, c: 26013},

  9865     26030, 26064, 26066, 26236, 26220, 26235, 26240, 26225, 26233, 26218,

  9866     26226, 26369, 26892, 26835, 26884, 26844, 26922, 26860, 26858, 26865,

  9867     26895, 26838, 26871, 26859, 26852, 26870, 26899, 26896, 26867, 26849,

  9868     26887, 26828, 26888, 26992, 26804, 26897, 26863, 26822, 26900, 26872,

  9869     26832, 26877, 26876, 26856, 26891, 26890, 26903, 26830, 26824,

  9870     {f: 2, c: 26845}, 26854, 26868, 26833, 26886, 26836, 26857, 26901, 26917,

  9871     26823, 27449, 27451, 27455, 27452, 27540, 27543, 27545, 27541, 27581,

  9872     27632, {f: 2, c: 27634}, 27696, 28156, {f: 2, c: 28230}, 28191, 28233,

  9873     28296, {f: 2, c: 28220}, 28229, 28258, 28203, 28223, 28225, 28253, 28275,

  9874     28188, 28211, 28235, 28224, 28241, 28219, 28163, 28206, 28254, 28264,

  9875     28252, 28257, 28209, 28200, 28256, 28273, 28267, 28217, 28194, 28208,

  9876     28243, 28261, 28199, 28280, 28260, 28279, 28245, 28281, 28242, 28262,

  9877     {f: 2, c: 28213}, 28250, 28960, 28958, 28975, 28923, 28974, 28977, 28963,

  9878     28965, 28962, 28978, 28959, 28968, 28986, 28955, 29259, 29274,

  9879     {f: 2, c: 29320}, 29318, 29317, 29323, 29458, 29451, 29488, 29474, 29489,

  9880     29491, 29479, 29490, 29485, 29478, 29475, 29493, 29452, 29742, 29740,

  9881     29744, 29739, 29718, 29722, 29729, 29741, 29745, 29732, 29731, 29725,

  9882     29737, 29728, 29746, 29947, 29999, 30063, 30060, 30183, 30170, 30177,

  9883     30182, 30173, 30175, 30180, 30167, 30357, 30354, 30426, {f: 2, c: 30534},

  9884     30532, 30541, 30533, 30538, 30542, {f: 2, c: 30539}, 30686, 30700, 30816,

  9885     {f: 2, c: 30820}, 30812, 30829, 30833, 30826, 30830, 30832, 30825, 30824,

  9886     30814, 30818, 31092, 31091, 31090, 31088, 31234, 31242, 31235, 31244,

  9887     31236, 31385, 31462, 31460, 31562, 31559, 31556, 31560, 31564, 31566,

  9888     31552, 31576, 31557, 31906, 31902, 31912, 31905, 32088, 32111, 32099,

  9889     32083, 32086, 32103, 32106, 32079, 32109, 32092, 32107, 32082, 32084,

  9890     32105, 32081, 32095, 32078, {f: 2, c: 32574}, {f: 2, c: 32613}, 32674,

  9891     {f: 2, c: 32672}, 32727, 32849, {f: 2, c: 32847}, 33022, 32980, 33091,

  9892     33098, 33106, 33103, 33095, 33085, 33101, 33082, 33254, 33262,

  9893     {f: 3, c: 33271}, 33284, {f: 2, c: 33340}, 33343, 33397, 33595,

  9894     [33743, 60382], 33785, 33827, 33728, 33768, 33810, 33767, 33764, 33788,

  9895     33782, 33808, 33734, 33736, 33771, 33763, 33727, 33793, 33757, 33765,

  9896     33752, 33791, 33761, 33739, 33742, 33750, 33781, 33737, 33801,

  9897     [33807, 58332], 33758, 33809, 33798, 33730, 33779, 33749, 33786, 33735,

  9898     33745, 33770, 33811, 33690, 33731, 33772, 33774, 33732, 33787, 33751,

  9899     33762, 33819, 33755, 33790, 34520, 34530, 34534, 34515, 34531, 34522,

  9900     34538, 34525, 34539, 34524, 34540, 34537, 34519, 34536, 34513, 34888,

  9901     34902, 34901, 35002, 35031, 35001, 35000, 35008, 35006, 34998, 35004,

  9902     34999, 35005, 34994, 35073, 35017, 35221, 35224, 35223, 35293,

  9903     {f: 2, c: 35290}, 35406, 35405, 35385, 35417, 35392, {f: 2, c: 35415},

  9904     {f: 2, c: 35396}, 35410, 35400, 35409, 35402, 35404, 35407, 35935, 35969,

  9905     35968, 36026, 36030, 36016, 36025, 36021, 36228, 36224, 36233, 36312,

  9906     36307, 36301, 36295, 36310, 36316, 36303, 36309, 36313, 36296, 36311,

  9907     36293, 36591, 36599, 36602, 36601, 36582, 36590, 36581, 36597,

  9908     {f: 2, c: 36583}, 36598, 36587, 36593, 36588, 36596, 36585, 36909, 36916,

  9909     36911, 37126, 37164, [37124, 60367], 37119, 37116, 37128, 37113, 37115,

  9910     37121, 37120, 37127, 37125, 37123, 37217, 37220, 37215, 37218, 37216,

  9911     37377, 37386, 37413, 37379, 37402, 37414, 37391, 37388, 37376, 37394,

  9912     37375, 37373, 37382, 37380, 37415, 37378, 37404, 37412, 37401, 37399,

  9913     37381, 37398, 38267, 38285, 38284, 38288, 38535, 38526, {f: 2, c: 38536},

  9914     38531, 38528, 38594, 38600, 38595, 38641, 38640, 38764, 38768, 38766,

  9915     38919, 39081, 39147, 40166, [12235, 40697], {f: 2, c: 20099}, 20150, 20669,

  9916     20671, 20678, 20654, 20676, 20682, 20660, 20680, 20674, 20656, 20673,

  9917     20666, 20657, 20683, 20681, 20662, 20664, 20951, 21114, 21112,

  9918     {f: 2, c: 21115}, 21955, 21979, 21964, 21968, 21963, 21962, 21981,

  9919     [21952, 64013], 21972, 21956, 21993, 21951, 21970, 21901, 21967, 21973,

  9920     21986, 21974, 21960, 22002, 21965, 21977, 21954, 22292, 22611, 22632,

  9921     22628, 22607, 22605, 22601, 22639, 22613, 22606, 22621, 22617, 22629,

  9922     22619, 22589, 22627, 22641, 22780, 23239, 23236, 23243, 23226, 23224,

  9923     23217, 23221, 23216, 23231, 23240, 23227, 23238, 23223, 23232, 23242,

  9924     23220, 23222, 23245, 23225, 23184, 23510, {f: 2, c: 23512}, 23583, 23603,

  9925     23921, 23907, 23882, 23909, 23922, 23916, 23902, 23912, 23911, 23906,

  9926     24048, 24143, 24142, 24138, 24141, 24139, 24261, 24268, 24262, 24267,

  9927     24263, 24384, 24495, 24493, 24823, {f: 2, c: 24905}, 24875, 24901, 24886,

  9928     24882, 24878, 24902, 24879, 24911, 24873, 24896, 25120, 37224, 25123,

  9929     25125, 25124, 25541, 25585, 25579, 25616, 25618, 25609, 25632, 25636,

  9930     25651, 25667, 25631, 25621, 25624, 25657, 25655, {f: 2, c: 25634}, 25612,

  9931     25638, 25648, 25640, 25665, 25653, 25647, 25610, 25626, 25664, 25637,

  9932     25639, 25611, 25575, 25627, 25646, 25633, 25614, 25967, 26002, 26067,

  9933     26246, 26252, 26261, 26256, 26251, 26250, 26265, 26260, 26232, 26400,

  9934     26982, 26975, 26936, 26958, 26978, 26993, 26943, 26949, 26986, 26937,

  9935     26946, 26967, 26969, 27002, {f: 2, c: 26952}, 26933, 26988, 26931, 26941,

  9936     26981, 26864, 27000, 26932, 26985, 26944, 26991, 26948, 26998, 26968,

  9937     26945, 26996, 26956, 26939, 26955, 26935, 26972, 26959, 26961, 26930,

  9938     26962, 26927, 27003, 26940, 27462, 27461, 27459, 27458, 27464, 27457,

  9939     27547, {f: 2, c: 27643}, 27641, {f: 2, c: 27639}, 28315, 28374, 28360,

  9940     28303, 28352, 28319, {f: 2, c: 28307}, 28320, 28337, 28345, 28358, 28370,

  9941     28349, 28353, 28318, 28361, 28343, 28336, 28365, 28326, 28367, 28338,

  9942     28350, 28355, 28380, 28376, 28313, 28306, 28302, 28301, 28324, 28321,

  9943     28351, 28339, 28368, 28362, 28311, 28334, 28323, 28999, 29012, 29010,

  9944     29027, 29024, 28993, 29021, [29026, 61080], 29042, 29048, 29034, 29025,

  9945     28994, 29016, 28995, 29003, 29040, 29023, 29008, 29011, 28996, 29005,

  9946     29018, 29263, 29325, 29324, 29329, 29328, 29326, 29500, 29506, 29499,

  9947     29498, 29504, 29514, 29513, 29764, {f: 2, c: 29770}, 29778, 29777, 29783,

  9948     29760, {f: 2, c: 29775}, 29774, 29762, 29766, 29773, 29780, 29921, 29951,

  9949     29950, 29949, 29981, 30073, 30071, 27011, 30191, 30223, 30211, 30199,

  9950     30206, 30204, [30201, 60782], 30200, 30224, 30203, 30198, 30189, 30197,

  9951     30205, 30361, 30389, 30429, 30549, {f: 2, c: 30559}, 30546, 30550, 30554,

  9952     30569, 30567, 30548, 30553, 30573, 30688, 30855, 30874, 30868, 30863,

  9953     30852, 30869, {f: 2, c: 30853}, 30881, 30851, 30841, 30873, 30848, 30870,

  9954     30843, 31100, 31106, 31101, 31097, 31249, {f: 2, c: 31256}, 31250, 31255,

  9955     31253, 31266, 31251, 31259, 31248, 31395, 31394, 31390, 31467, 31590,

  9956     31588, 31597, 31604, 31593, 31602, 31589, 31603, 31601, 31600, 31585,

  9957     31608, 31606, 31587, 31922, 31924, 31919, 32136, 32134, 32128, 32141,

  9958     32127, 32133, 32122, 32142, 32123, 32131, 32124, 32140, 32148, 32132,

  9959     32125, 32146, 32621, 32619, {f: 2, c: 32615}, 32620, 32678, 32677, 32679,

  9960     {f: 2, c: 32731}, 32801, 33124, 33120, 33143, 33116, 33129, 33115, 33122,

  9961     33138, 26401, 33118, 33142, 33127, 33135, 33092, 33121, 33309, 33353,

  9962     33348, 33344, 33346, 33349, 34033, 33855, 33878, 33910, 33913, 33935,

  9963     33933, 33893, 33873, 33856, 33926, 33895, 33840, 33869, 33917, 33882,

  9964     33881, 33908, 33907, 33885, 34055, 33886, 33847, 33850, 33844, 33914,

  9965     33859, 33912, 33842, 33861, 33833, 33753, 33867, 33839, 33858, 33837,

  9966     33887, 33904, 33849, 33870, 33868, 33874, 33903, 33989, 33934, 33851,

  9967     33863, 33846, 33843, 33896, 33918, 33860, 33835, 33888, 33876, 33902,

  9968     33872, 34571, 34564, 34551, 34572, 34554, 34518, 34549, 34637, 34552,

  9969     34574, 34569, 34561, 34550, 34573, 34565, 35030, 35019, {f: 2, c: 35021},

  9970     35038, 35035, 35034, 35020, 35024, 35205, 35227, 35295, 35301, 35300,

  9971     35297, 35296, 35298, 35292, 35302, 35446, 35462, 35455, 35425, 35391,

  9972     35447, 35458, 35460, 35445, 35459, 35457, 35444, 35450, 35900, 35915,

  9973     35914, 35941, 35940, 35942, 35974, {f: 2, c: 35972}, 36044,

  9974     {f: 2, c: 36200}, 36241, 36236, {f: 2, c: 36238}, 36237, {f: 2, c: 36243},

  9975     36240, 36242, 36336, 36320, 36332, 36337, 36334, 36304, 36329, 36323,

  9976     36322, 36327, 36338, 36331, 36340, 36614, 36607, 36609, 36608, 36613,

  9977     {f: 2, c: 36615}, 36610, [36619, 60507], 36946, 36927, 36932, 36937, 36925,

  9978     37136, 37133, 37135, 37137, 37142, 37140, 37131, 37134, {f: 2, c: 37230},

  9979     37448, 37458, 37424, 37434, 37478, 37427, 37477, 37470, 37507, 37422,

  9980     37450, 37446, 37485, 37484, 37455, 37472, 37479, 37487, 37430, 37473,

  9981     37488, 37425, 37460, 37475, 37456, 37490, 37454, 37459, 37452, 37462,

  9982     37426, 38303, 38300, 38302, 38299, {f: 2, c: 38546}, 38545, 38551, 38606,

  9983     38650, 38653, 38648, 38645, 38771, {f: 2, c: 38775}, 38770, 38927,

  9984     {f: 2, c: 38925}, 39084, 39158, 39161, 39343, 39346, 39344, 39349, 39597,

  9985     39595, 39771, 40170, 40173, 40167, 40576, [12236, 40701], 20710, 20692,

  9986     20695, 20712, 20723, 20699, 20714, 20701, 20708, 20691, 20716, 20720,

  9987     20719, 20707, 20704, 20952, {f: 2, c: 21120}, 21225, 21227, 21296, 21420,

  9988     22055, 22037, 22028, 22034, 22012, 22031, 22044, 22017, 22035, 22018,

  9989     22010, 22045, 22020, 22015, 22009, 22665, 22652, 22672, 22680, 22662,

  9990     22657, 22655, 22644, 22667, 22650, 22663, 22673, 22670, 22646, 22658,

  9991     22664, 22651, 22676, 22671, 22782, 22891, 23260, 23278, 23269, 23253,

  9992     23274, 23258, 23277, 23275, 23283, 23266, 23264, 23259, 23276, 23262,

  9993     23261, 23257, 23272, 23263, 23415, 23520, 23523, 23651, 23938, 23936,

  9994     23933, 23942, 23930, 23937, 23927, 23946, 23945, 23944, 23934, 23932,

  9995     23949, 23929, 23935, {f: 2, c: 24152}, 24147, 24280, 24273, 24279, 24270,

  9996     24284, 24277, 24281, 24274, 24276, 24388, 24387, 24431, 24502, 24876,

  9997     24872, 24897, 24926, 24945, 24947, {f: 2, c: 24914}, 24946, 24940, 24960,

  9998     24948, 24916, 24954, 24923, 24933, 24891, 24938, 24929, 24918, 25129,

  9999     25127, 25131, 25643, 25677, 25691, 25693, 25716, 25718, {f: 2, c: 25714},

 10000     25725, 25717, 25702, 25766, 25678, 25730, 25694, 25692, 25675, 25683,

 10001     25696, 25680, 25727, 25663, 25708, 25707, 25689, 25701, 25719, 25971,

 10002     26016, 26273, 26272, 26271, 26373, 26372, 26402, 27057, 27062, 27081,

 10003     27040, 27086, 27030, 27056, 27052, 27068, 27025, 27033, 27022, 27047,

 10004     27021, 27049, 27070, 27055, 27071, 27076, 27069, 27044, 27092, 27065,

 10005     27082, 27034, 27087, 27059, 27027, 27050, 27041, 27038, 27097, 27031,

 10006     27024, 27074, 27061, 27045, 27078, 27466, 27469, 27467, {f: 3, c: 27550},

 10007     {f: 2, c: 27587}, 27646, 28366, 28405, 28401, 28419, 28453, 28408, 28471,

 10008     28411, 28462, 28425, 28494, {f: 2, c: 28441}, 28455, 28440, 28475, 28434,

 10009     28397, 28426, 28470, 28531, 28409, 28398, 28461, 28480, 28464, 28476,

 10010     28469, 28395, 28423, 28430, 28483, 28421, 28413, 28406, 28473, 28444,

 10011     28412, 28474, 28447, 28429, 28446, 28424, 28449, 29063, 29072, 29065,

 10012     29056, 29061, 29058, 29071, 29051, 29062, 29057, 29079, 29252, 29267,

 10013     29335, 29333, 29331, 29507, 29517, 29521, 29516, 29794, 29811, 29809,

 10014     29813, 29810, 29799, 29806, 29952, {f: 2, c: 29954}, 30077, 30096, 30230,

 10015     30216, 30220, 30229, 30225, 30218, 30228, 30392, 30593, 30588, 30597,

 10016     30594, 30574, 30592, 30575, 30590, 30595, 30898, 30890, 30900, 30893,

 10017     30888, 30846, 30891, 30878, 30885, 30880, 30892, 30882, 30884, 31128,

 10018     {f: 2, c: 31114}, 31126, 31125, 31124, 31123, 31127, 31112, 31122, 31120,

 10019     31275, 31306, 31280, 31279, 31272, 31270, 31400, {f: 2, c: 31403}, 31470,

 10020     31624, 31644, 31626, 31633, 31632, 31638, 31629, 31628, 31643, 31630,

 10021     31621, 31640, 21124, 31641, 31652, 31618, 31931, 31935, 31932, 31930,

 10022     32167, 32183, 32194, 32163, 32170, 32193, 32192, 32197, 32157, 32206,

 10023     32196, 32198, {f: 2, c: 32203}, 32175, 32185, 32150, 32188, 32159, 32166,

 10024     32174, 32169, 32161, 32201, 32627, {f: 2, c: 32738}, 32741, 32734, 32804,

 10025     32861, 32860, 33161, 33158, 33155, 33159, 33165, 33164, 33163, 33301,

 10026     33943, 33956, 33953, 33951, 33978, 33998, 33986, 33964, 33966, 33963,

 10027     33977, 33972, 33985, 33997, 33962, 33946, 33969, 34000, 33949, 33959,

 10028     33979, 33954, 33940, 33991, 33996, 33947, 33961, 33967, [33960, 58327],

 10029     34006, 33944, 33974, 33999, 33952, 34007, 34004, 34002, 34011, 33968,

 10030     33937, 34401, 34611, 34595, 34600, 34667, 34624, 34606, 34590, 34593,

 10031     34585, 34587, 34627, 34604, 34625, 34622, 34630, 34592, 34610, 34602,

 10032     34605, 34620, 34578, 34618, 34609, 34613, 34626, {f: 2, c: 34598}, 34616,

 10033     34596, 34586, 34608, 34577, 35063, 35047, {f: 2, c: 35057}, 35066, 35070,

 10034     35054, 35068, 35062, 35067, 35056, 35052, 35051, 35229, 35233, 35231,

 10035     35230, 35305, 35307, 35304, 35499, 35481, 35467, 35474, 35471, 35478,

 10036     35901, {f: 2, c: 35944}, 36053, 36047, 36055, 36246, 36361, 36354, 36351,

 10037     36365, 36349, 36362, 36355, 36359, 36358, 36357, 36350, 36352, 36356,

 10038     {f: 2, c: 36624}, 36622, 36621, 37155, 37148, 37152, 37154, 37151, 37149,

 10039     37146, 37156, 37153, 37147, 37242, 37234, 37241, 37235, 37541, 37540,

 10040     37494, 37531, 37498, 37536, 37524, 37546, 37517, 37542, 37530, 37547,

 10041     37497, 37527, 37503, 37539, 37614, 37518, 37506, 37525, 37538, 37501,

 10042     37512, 37537, 37514, 37510, 37516, 37529, 37543, 37502, 37511, 37545,

 10043     37533, 37515, 37421, 38558, 38561, 38655, 38744, 38781, 38778, 38782,

 10044     38787, 38784, 38786, 38779, 38788, 38785, 38783, 38862, 38861, 38934,

 10045     {f: 2, c: 39085}, 39170, 39168, 39175, 39325, 39324, 39363, 39353, 39355,

 10046     39354, 39362, 39357, 39367, 39601, 39651, 39655, {f: 2, c: 39742},

 10047     {f: 2, c: 39776}, 39775, {f: 2, c: 40177}, 40181, 40615, 20735, 20739,

 10048     20784, 20728, {f: 2, c: 20742}, 20726, 20734, {f: 2, c: 20747}, 20733,

 10049     20746, {f: 2, c: 21131}, 21233, 21231, 22088, 22082, 22092, 22069, 22081,

 10050     22090, 22089, 22086, 22104, 22106, 22080, 22067, 22077, 22060, 22078,

 10051     22072, 22058, 22074, 22298, 22699, 22685, 22705, 22688, 22691, 22703,

 10052     22700, 22693, 22689, 22783, 23295, 23284, 23293, 23287, 23286, 23299,

 10053     23288, 23298, 23289, 23297, 23303, 23301, 23311, 23655, 23961, 23959,

 10054     23967, 23954, 23970, 23955, 23957, 23968, 23964, 23969, 23962, 23966,

 10055     24169, 24157, 24160, 24156, 32243, 24283, 24286, 24289, 24393, 24498,

 10056     24971, 24963, 24953, 25009, 25008, 24994, 24969, 24987, 24979, 25007,

 10057     25005, 24991, 24978, 25002, 24993, 24973, 24934, 25011, 25133, 25710,

 10058     25712, 25750, 25760, 25733, 25751, 25756, 25743, 25739, 25738, 25740,

 10059     25763, 25759, 25704, 25777, 25752, 25974, 25978, 25977, 25979,

 10060     {f: 2, c: 26034}, 26293, 26288, 26281, 26290, 26295, 26282, 26287, 27136,

 10061     27142, 27159, 27109, 27128, 27157, 27121, 27108, 27168, 27135, 27116,

 10062     27106, 27163, 27165, 27134, 27175, 27122, 27118, 27156, 27127, 27111,

 10063     27200, 27144, 27110, 27131, 27149, 27132, 27115, 27145, 27140, 27160,

 10064     27173, 27151, 27126, 27174, 27143, 27124, 27158, 27473, 27557, 27555,

 10065     27554, 27558, 27649, 27648, 27647, 27650, 28481, 28454, 28542, 28551,

 10066     28614, 28562, 28557, 28553, 28556, 28514, 28495, 28549, 28506, 28566,

 10067     28534, 28524, 28546, 28501, 28530, 28498, 28496, 28503, 28564, 28563,

 10068     28509, 28416, 28513, 28523, 28541, 28519, 28560, 28499, 28555, 28521,

 10069     28543, 28565, 28515, 28535, 28522, 28539, 29106, 29103, 29083, 29104,

 10070     29088, 29082, 29097, 29109, 29085, 29093, 29086, 29092, 29089, 29098,

 10071     29084, 29095, 29107, 29336, 29338, 29528, 29522, {f: 3, c: 29534}, 29533,

 10072     29531, 29537, 29530, 29529, 29538, 29831, {f: 2, c: 29833}, 29830, 29825,

 10073     29821, 29829, 29832, 29820, [29817, 58868], 29960, 29959, 30078, 30245,

 10074     30238, 30233, 30237, 30236, 30243, 30234, 30248, 30235, {f: 3, c: 30364},

 10075     30363, 30605, 30607, 30601, 30600, 30925, 30907, 30927, 30924, 30929,

 10076     30926, 30932, 30920, {f: 2, c: 30915}, 30921, 31130, 31137, 31136, 31132,

 10077     31138, [31131, 59175], 27510, 31289, 31410, 31412, 31411, 31671, 31691,

 10078     31678, 31660, 31694, 31663, 31673, 31690, 31669, 31941, 31944, 31948,

 10079     31947, 32247, 32219, 32234, 32231, 32215, 32225, 32259, 32250, 32230,

 10080     32246, 32241, 32240, 32238, 32223, 32630, 32684, 32688, 32685, 32749,

 10081     32747, 32746, 32748, 32742, 32744, 32868, 32871, 33187, 33183, 33182,

 10082     33173, 33186, 33177, 33175, 33302, 33359, 33363, 33362, 33360, 33358,

 10083     33361, 34084, 34107, 34063, 34048, 34089, 34062, 34057, 34061, 34079,

 10084     34058, 34087, 34076, 34043, 34091, 34042, 34056, 34060, 34036, 34090,

 10085     34034, 34069, 34039, 34027, 34035, 34044, 34066, 34026, 34025, 34070,

 10086     34046, 34088, 34077, 34094, 34050, 34045, 34078, 34038, 34097, 34086,

 10087     {f: 2, c: 34023}, 34032, 34031, 34041, 34072, 34080, 34096, 34059, 34073,

 10088     34095, 34402, 34646, {f: 2, c: 34659}, 34679, 34785, 34675, 34648, 34644,

 10089     34651, 34642, 34657, 34650, 34641, 34654, 34669, 34666, 34640, 34638,

 10090     34655, 34653, 34671, 34668, 34682, 34670, 34652, 34661, 34639, 34683,

 10091     34677, 34658, 34663, 34665, 34906, 35077, 35084, 35092, 35083,

 10092     {f: 3, c: 35095}, 35078, 35094, 35089, 35086, 35081, 35234, 35236, 35235,

 10093     35309, 35312, 35308, 35535, 35526, 35512, 35539, 35537, {f: 2, c: 35540},

 10094     35515, 35543, 35518, 35520, 35525, 35544, 35523, 35514, 35517, 35545,

 10095     35902, 35917, 35983, 36069, 36063, 36057, 36072, 36058, 36061, 36071,

 10096     36256, 36252, 36257, 36251, 36384, 36387, 36389, 36388, 36398, 36373,

 10097     36379, 36374, 36369, 36377, {f: 2, c: 36390}, 36372, 36370, 36376, 36371,

 10098     36380, 36375, 36378, 36652, 36644, 36632, 36634, 36640, 36643,

 10099     {f: 2, c: 36630}, 36979, 36976, 36975, 36967, 36971, 37167, 37163,

 10100     {f: 2, c: 37161}, 37170, 37158, 37166, {f: 2, c: 37253}, 37258,

 10101     {f: 2, c: 37249}, 37252, 37248, 37584, {f: 2, c: 37571}, 37568, 37593,

 10102     37558, 37583, 37617, 37599, 37592, 37609, 37591, 37597, 37580, 37615,

 10103     37570, 37608, 37578, 37576, 37582, 37606, 37581, 37589, 37577, 37600,

 10104     37598, 37607, 37585, 37587, 37557, 37601, 37669, 37574, 37556, 38268,

 10105     38316, 38315, 38318, 38320, 38564, 38562, 38611, 38661, 38664, 38658,

 10106     38746, 38794, 38798, 38792, 38864, 38863, 38942, 38941, 38950, 38953,

 10107     38952, 38944, 38939, 38951, 39090, 39176, 39162, 39185, 39188,

 10108     {f: 2, c: 39190}, 39189, 39388, 39373, 39375, {f: 2, c: 39379}, 39374,

 10109     39369, [39382, 60270], 39384, 39371, 39383, 39372, 39603, 39660, 39659,

 10110     39667, 39666, 39665, 39750, 39747, 39783, 39796, 39793, 39782, 39798,

 10111     39797, 39792, 39784, 39780, 39788, 40188, 40186, 40189, 40191, 40183,

 10112     40199, 40192, 40185, 40187, 40200, 40197, 40196, 40579, 40659,

 10113     {f: 2, c: 40719}, 20764, 20755, 20759, 20762, 20753, 20958, 21300, 21473,

 10114     22128, 22112, 22126, 22131, 22118, 22115, 22125, 22130, 22110, 22135,

 10115     22300, 22299, 22728, 22717, 22729, 22719, 22714, 22722, 22716, 22726,

 10116     23319, 23321, 23323, 23329, 23316, 23315, 23312, 23318, [23336, 59539],

 10117     23322, 23328, 23326, 23535, 23980, 23985, 23977, 23975, 23989, 23984,

 10118     23982, 23978, 23976, 23986, 23981, 23983, 23988, {f: 2, c: 24167}, 24166,

 10119     24175, 24297, 24295, 24294, 24296, 24293, 24395, 24508, 24507, 24989,

 10120     25000, 24982, 25029, 25012, 25030, 25025, 25036, 25018, 25023, 25016,

 10121     24972, 25815, 25814, 25808, 25807, 25801, 25789, 25737, 25795, 25819,

 10122     25843, 25817, 25907, 25983, 25980, 26018, 26312, 26302, 26304,

 10123     {f: 2, c: 26314}, 26319, 26301, 26299, 26298, 26316, 26403, 27188, 27238,

 10124     27209, 27239, 27186, 27240, 27198, 27229, 27245, 27254, 27227, 27217,

 10125     27176, 27226, 27195, 27199, 27201, 27242, 27236, 27216, 27215, 27220,

 10126     27247, 27241, 27232, 27196, 27230, 27222, 27221, {f: 2, c: 27213}, 27206,

 10127     27477, 27476, 27478, 27559, {f: 2, c: 27562}, 27592, 27591, 27652, 27651,

 10128     27654, 28589, 28619, 28579, 28615, 28604, 28622, 28616, 28510, 28612,

 10129     28605, 28574, 28618, 28584, 28676, 28581, 28590, 28602, 28588, 28586,

 10130     28623, 28607, 28600, 28578, 28617, 28587, 28621, 28591, 28594, 28592,

 10131     29125, 29122, 29119, 29112, 29142, {f: 2, c: 29120}, 29131, 29140, 29130,

 10132     29127, 29135, 29117, 29144, 29116, 29126, {f: 2, c: 29146},

 10133     {f: 2, c: 29341}, 29545, {f: 2, c: 29542}, 29548, 29541, 29547, 29546,

 10134     29823, 29850, 29856, 29844, 29842, 29845, 29857, 29963, 30080, 30255,

 10135     30253, 30257, 30269, 30259, 30268, 30261, 30258, 30256, 30395, 30438,

 10136     30618, 30621, 30625, 30620, 30619, {f: 2, c: 30626}, 30613, 30617, 30615,

 10137     30941, 30953, 30949, 30954, 30942, 30947, 30939, {f: 2, c: 30945}, 30957,

 10138     {f: 2, c: 30943}, 31140, 31300, 31304, 31303, 31414, 31416, 31413, 31409,

 10139     31415, 31710, 31715, 31719, 31709, 31701, 31717, 31706, 31720, 31737,

 10140     31700, 31722, 31714, 31708, 31723, 31704, 31711, 31954, 31956, 31959,

 10141     {f: 2, c: 31952}, 32274, 32289, 32279, 32268, {f: 2, c: 32287}, 32275,

 10142     32270, 32284, 32277, 32282, 32290, 32267, 32271, 32278, 32269, 32276,

 10143     32293, 32292, 32579, {f: 2, c: 32635}, 32634, 32689, 32751, 32810, 32809,

 10144     32876, 33201, 33190, 33198, 33209, 33205, 33195, 33200, 33196, 33204,

 10145     33202, 33207, 33191, 33266, {f: 3, c: 33365}, 34134, 34117, 34155, 34125,

 10146     34131, 34145, 34136, 34112, 34118, 34148, 34113, 34146, 34116, 34129,

 10147     34119, 34147, 34110, 34139, 34161, 34126, 34158, 34165, 34133, 34151,

 10148     34144, 34188, 34150, 34141, 34132, 34149, 34156, 34403, 34405, 34404,

 10149     34724, 34715, 34703, 34711, 34707, 34706, 34696, 34689, 34710, 34712,

 10150     34681, 34695, 34723, 34693, {f: 2, c: 34704}, 34717, 34692, 34708, 34716,

 10151     34714, 34697, 35102, 35110, 35120, {f: 2, c: 35117}, 35111, 35121, 35106,

 10152     35113, 35107, 35119, 35116, 35103, 35313, 35552, 35554, 35570,

 10153     {f: 2, c: 35572}, 35549, 35604, 35556, 35551, 35568, 35528, 35550, 35553,

 10154     35560, 35583, 35567, 35579, {f: 2, c: 35985}, 35984, 36085, 36078, 36081,

 10155     36080, 36083, 36204, 36206, 36261, 36263, 36403, 36414, 36408, 36416,

 10156     36421, 36406, {f: 2, c: 36412}, 36417, 36400, 36415, 36541, [36662, 60329],

 10157     36654, 36661, 36658, 36665, 36663, 36660, 36982, 36985, 36987, 36998,

 10158     37114, 37171, {f: 2, c: 37173}, 37267, {f: 2, c: 37264}, 37261, 37263,

 10159     37671, 37662, 37640, 37663, 37638, 37647, 37754, 37688, 37692, 37659,

 10160     37667, 37650, 37633, 37702, 37677, 37646, 37645, 37579, 37661, 37626,

 10161     37651, 37625, 37623, 37684, 37634, 37668, 37631, 37673, 37689, 37685,

 10162     37674, 37652, 37644, 37643, 37630, 37641, 37632, 37627, 37654, 38332,

 10163     38349, 38334, {f: 2, c: 38329}, 38326, 38335, 38325, 38333, 38569, 38612,

 10164     38667, 38674, 38672, 38809, 38807, 38804, 38896, 38904, 38965, 38959,

 10165     38962, 39204, 39199, 39207, 39209, 39326, 39406, 39404, 39397, 39396,

 10166     39408, 39395, 39402, 39401, 39399, 39609, 39615, 39604, 39611, 39670,

 10167     39674, 39673, 39671, 39731, 39808, 39813, 39815, 39804, 39806, 39803,

 10168     39810, 39827, 39826, 39824, 39802, 39829, 39805, 39816, 40229, 40215,

 10169     40224, 40222, 40212, 40233, 40221, 40216, 40226, 40208, 40217, 40223,

 10170     40584, {f: 2, c: 40582}, 40622, 40621, {f: 2, c: 40661}, 40698, 40722,

 10171     40765, 20774, 20773, 20770, 20772, 20768, 20777, 21236, 22163,

 10172     {f: 2, c: 22156}, 22150, 22148, 22147, 22142, 22146, 22143, 22145, 22742,

 10173     22740, 22735, 22738, 23341, 23333, 23346, 23331, 23340, 23335, 23334,

 10174     23343, 23342, 23419, {f: 2, c: 23537}, 23991, 24172, 24170, 24510, 25027,

 10175     25013, 25020, 25063, 25056, 25061, 25060, 25064, 25054, 25839, 25833,

 10176     25827, 25835, 25828, 25832, 25985, 25984, 26038, 26074, 26322, 27277,

 10177     27286, 27265, 27301, 27273, 27295, 27291, 27297, 27294, 27271, 27283,

 10178     27278, 27285, 27267, 27304, 27300, 27281, 27263, 27302, 27290, 27269,

 10179     27276, 27282, 27483, 27565, 27657, 28620, 28585, 28660, 28628, 28643,

 10180     28636, 28653, 28647, 28646, 28638, 28658, 28637, 28642, 28648, 29153,

 10181     29169, 29160, 29170, 29156, 29168, 29154, 29555, {f: 2, c: 29550}, 29847,

 10182     29874, 29867, 29840, 29866, 29869, 29873, 29861, 29871, {f: 3, c: 29968},

 10183     29967, 30084, 30275, {f: 2, c: 30280}, 30279, 30372, 30441, 30645, 30635,

 10184     30642, 30647, 30646, 30644, 30641, 30632, 30704, 30963, 30973, 30978,

 10185     {f: 2, c: 30971}, 30975, 30962, 30981, 30969, 30974, 30980, 31147, 31144,

 10186     31324, 31323, 31318, 31320, 31316, 31322, 31422, {f: 2, c: 31424}, 31749,

 10187     31759, 31730, 31744, 31743, 31739, 31758, 31732, 31755, 31731, 31746,

 10188     31753, 31747, 31745, 31736, 31741, [31750, 58176], {f: 2, c: 31728}, 31760,

 10189     31754, 31976, 32301, 32316, 32322, 32307, 38984, 32312, 32298, 32329,

 10190     32320, 32327, 32297, 32332, 32304, 32315, 32310, 32324, 32314, 32581,

 10191     32639, 32638, 32637, 32756, 32754, 32812, 33211, 33220, 33228, 33226,

 10192     33221, 33223, 33212, 33257, 33371, 33370, 33372, 34179, 34176, 34191,

 10193     34215, 34197, 34208, 34187, 34211, 34171, 34212, 34202, 34206, 34167,

 10194     34172, 34185, 34209, 34170, 34168, 34135, 34190, 34198, 34182, 34189,

 10195     34201, 34205, 34177, 34210, 34178, 34184, 34181, 34169, 34166, 34200,

 10196     34192, 34207, 34408, 34750, 34730, 34733, 34757, 34736, 34732, 34745,

 10197     34741, 34748, 34734, 34761, 34755, 34754, 34764, 34743, 34735, 34756,

 10198     34762, 34740, 34742, 34751, 34744, 34749, 34782, 34738, 35125, 35123,

 10199     35132, 35134, 35137, 35154, 35127, 35138, 35245, 35247, 35246,

 10200     {f: 2, c: 35314}, 35614, 35608, 35606, 35601, 35589, 35595, 35618, 35599,

 10201     35602, 35605, 35591, 35597, 35592, 35590, 35612, 35603, 35610, 35919,

 10202     35952, 35954, 35953, 35951, 35989, 35988, 36089, 36207, 36430, 36429,

 10203     36435, 36432, 36428, 36423, 36675, 36672, 36997, 36990, 37176, 37274,

 10204     37282, 37275, 37273, 37279, 37281, 37277, 37280, 37793, 37763, 37807,

 10205     37732, 37718, 37703, 37756, 37720, 37724, 37750, 37705, {f: 2, c: 37712},

 10206     37728, 37741, 37775, 37708, 37738, 37753, 37719, 37717, 37714, 37711,

 10207     37745, 37751, 37755, 37729, 37726, 37731, 37735, 37710, 37721, 38343,

 10208     38336, 38345, 38339, 38341, 38327, 38574, 38576, 38572, 38688, 38687,

 10209     38680, 38685, 38681, 38810, 38817, 38812, 38814, 38813, 38869, 38868,

 10210     38897, 38977, 38980, 38986, 38985, 38981, 38979, 39205, {f: 2, c: 39211},

 10211     39210, 39219, 39218, 39215, 39213, 39217, 39216, 39320, 39331, 39329,

 10212     39426, 39418, 39412, 39415, 39417, 39416, 39414, 39419, {f: 2, c: 39421},

 10213     39420, 39427, 39614, 39678, 39677, 39681, 39676, 39752, 39834, 39848,

 10214     39838, 39835, 39846, 39841, 39845, 39844, 39814, 39842, 39840, 39855,

 10215     40243, 40257, 40295, 40246, {f: 2, c: 40238}, 40241, 40248, 40240, 40261,

 10216     {f: 2, c: 40258}, 40254, 40247, 40256, 40253, 32757, 40237, 40586, 40585,

 10217     40589, 40624, 40648, 40666, 40699, 40703, 40740, 40739, 40738, 40788,

 10218     [12245, 40864], 20785, {f: 2, c: 20781}, 22168, 22172, 22167, 22170, 22173,

 10219     22169, 22896, 23356, {f: 2, c: 23657}, 24000, {f: 2, c: 24173}, 25048,

 10220     25055, {f: 2, c: 25069}, 25073, 25066, 25072, 25067, 25046, 25065, 25855,

 10221     25860, 25853, 25848, 25857, 25859, 25852, 26004, 26075, {f: 2, c: 26330},

 10222     26328, 27333, 27321, 27325, 27361, 27334, 27322, {f: 2, c: 27318}, 27335,

 10223     27316, 27309, 27486, 27593, 27659, 28679, {f: 2, c: 28684}, 28673, 28677,

 10224     28692, 28686, {f: 2, c: 28671}, 28667, 28710, 28668, 28663, 28682,

 10225     [29185, 60224], 29183, 29177, 29187, 29181, 29558, 29880, 29888, 29877,

 10226     29889, 29886, 29878, 29883, 29890, 29972, 29971, 30300, 30308, 30297,

 10227     30288, 30291, 30295, 30298, 30374, 30397, 30444, 30658, 30650, 30988,

 10228     {f: 2, c: 30995}, 30985, 30992, 30994, 30993, 31149, 31148, 31327, 31772,

 10229     31785, 31769, 31776, 31775, 31789, 31773, 31782, 31784, 31778, 31781,

 10230     31792, 32348, 32336, 32342, 32355, 32344, 32354, 32351, 32337, 32352,

 10231     32343, 32339, 32693, 32691, {f: 2, c: 32759}, 32885, {f: 2, c: 33233},

 10232     33232, 33375, 33374, 34228, 34246, 34240, 34243, 34242, 34227, 34229,

 10233     34237, 34247, 34244, 34239, 34251, 34254, 34248, 34245, 34225, 34230,

 10234     34258, 34340, 34232, 34231, 34238, 34409, 34791, 34790, 34786, 34779,

 10235     34795, 34794, 34789, 34783, 34803, 34788, 34772, 34780, 34771, 34797,

 10236     34776, 34787, 34775, 34777, 34817, 34804, 34792, 34781, 35155, 35147,

 10237     35151, 35148, 35142, {f: 2, c: 35152}, 35145, 35626, 35623, 35619, 35635,

 10238     35632, 35637, 35655, 35631, 35644, 35646, 35633, 35621, 35639, 35622,

 10239     35638, 35630, 35620, 35643, 35645, 35642, 35906, 35957, 35993, 35992,

 10240     35991, 36094, 36100, 36098, 36096, 36444, 36450, 36448, 36439, 36438,

 10241     36446, 36453, 36455, 36443, 36442, 36449, 36445, 36457, 36436,

 10242     {f: 3, c: 36678}, 36683, 37160, {f: 2, c: 37178}, 37182, 37288, 37285,

 10243     37287, 37295, 37290, 37813, 37772, 37778, 37815, 37787, 37789, 37769,

 10244     37799, 37774, 37802, 37790, 37798, 37781, 37768, 37785, 37791, 37760,

 10245     37773, 37809, 37777, 37810, 37796, 37800, 37812, 37795, {f: 2, c: 38354},

 10246     38353, 38579, 38615, 38618, 24002, 38623, 38616, 38621, 38691, 38690,

 10247     38693, 38828, 38830, 38824, 38827, 38820, 38826, 38818, 38821, 38871,

 10248     38873, 38870, 38872, 38906, {f: 3, c: 38992}, 39096, 39233, 39228, 39226,

 10249     39439, 39435, 39433, 39437, 39428, 39441, 39434, 39429, 39431, 39430,

 10250     39616, 39644, 39688, {f: 2, c: 39684}, 39721, 39733, 39754, 39756, 39755,

 10251     39879, 39878, 39875, 39871, 39873, 39861, 39864, 39891, 39862, 39876,

 10252     39865, 39869, 40284, 40275, 40271, 40266, 40283, 40267, 40281, 40278,

 10253     40268, 40279, 40274, 40276, 40287, 40280, 40282, 40590, 40588, 40671,

 10254     40705, 40704, [40726, 58693], 40741, 40747, 40746, 40745, 40744, 40780,

 10255     40789, {f: 2, c: 20788}, 21142, 21239, 21428, 22187, 22189,

 10256     {f: 2, c: 22182}, 22186, 22188, 22746, 22749, 22747, 22802,

 10257     {f: 3, c: 23357}, 24003, 24176, 24511, 25083, 25863, 25872, 25869, 25865,

 10258     25868, 25870, 25988, 26078, 26077, 26334, 27367, 27360, 27340, 27345,

 10259     27353, 27339, 27359, 27356, 27344, 27371, 27343, 27341, 27358, 27488,

 10260     27568, 27660, 28697, 28711, 28704, 28694, 28715, {f: 3, c: 28705}, 28713,

 10261     28695, 28708, 28700, 29196, 29194, 29191, 29186, 29189, {f: 2, c: 29349},

 10262     29348, 29347, 29345, 29899, 29893, 29879, 29891, 29974, 30304,

 10263     {f: 2, c: 30665}, 30660, 30705, 31005, 31003, 31009, 31004, 30999, 31006,

 10264     31152, {f: 2, c: 31335}, 31795, 31804, 31801, 31788, 31803, 31980, 31978,

 10265     32374, 32373, 32376, 32368, 32375, 32367, 32378, 32370, 32372, 32360,

 10266     32587, 32586, 32643, 32646, 32695, {f: 2, c: 32765}, 32888, 33239, 33237,

 10267     33291, 33380, 33377, 33379, 34283, 34289, 34285, 34265, 34273, 34280,

 10268     34266, 34263, 34284, 34290, 34296, 34264, 34271, 34275, 34268, 34257,

 10269     34288, 34278, 34287, 34270, 34274, 34816, 34810, 34819, {f: 2, c: 34806},

 10270     34825, 34828, 34827, 34822, 34812, 34824, 34815, 34826, 34818, 35170,

 10271     {f: 2, c: 35162}, 35159, 35169, 35164, 35160, 35165, 35161, 35208, 35255,

 10272     35254, 35318, 35664, 35656, 35658, 35648, 35667, 35670, 35668, 35659,

 10273     35669, 35665, 35650, 35666, 35671, 35907, 35959, 35958, 35994,

 10274     {f: 2, c: 36102}, 36105, 36268, 36266, 36269, 36267, 36461, 36472, 36467,

 10275     36458, 36463, 36475, 36546, 36690, 36689, {f: 2, c: 36687}, 36691, 36788,

 10276     37184, 37183, 37296, 37293, 37854, 37831, 37839, 37826, 37850, 37840,

 10277     37881, 37868, 37836, 37849, 37801, 37862, 37834, 37844, 37870, 37859,

 10278     37845, 37828, 37838, 37824, 37842, 37797, 37863, 38269, {f: 2, c: 38362},

 10279     38625, 38697, {f: 2, c: 38699}, 38696, 38694, 38835, 38839, 38838,

 10280     {f: 3, c: 38877}, 39004, 39001, 39005, 38999, 39103, 39101, 39099, 39102,

 10281     39240, 39239, 39235, {f: 2, c: 39334}, 39450, 39445, 39461, 39453, 39460,

 10282     39451, 39458, 39456, 39463, 39459, 39454, 39452, 39444, 39618, 39691,

 10283     39690, 39694, 39692, 39735, {f: 2, c: 39914}, 39904, 39902, 39908, 39910,

 10284     39906, 39920, 39892, 39895, 39916, 39900, 39897, 39909, 39893, 39905,

 10285     39898, 40311, 40321, 40330, 40324, 40328, 40305, 40320, 40312, 40326,

 10286     {f: 2, c: 40331}, 40317, 40299, {f: 2, c: 40308}, 40304, 40297, 40325,

 10287     40307, 40315, 40322, 40303, 40313, 40319, 40327, 40296, 40596, 40593,

 10288     40640, 40700, 40749, {f: 2, c: 40768}, 40781, {f: 3, c: 40790}, 21303,

 10289     22194, 22197, 22195, 22755, 23365, {f: 2, c: 24006}, {f: 2, c: 24302},

 10290     {f: 2, c: 24512}, 25081, 25879, 25878, 25877, 25875, 26079, 26344,

 10291     {f: 2, c: 26339}, 27379, 27376, 27370, 27368, 27385, 27377,

 10292     {f: 2, c: 27374}, 28732, 28725, 28719, 28727, 28724, 28721, 28738, 28728,

 10293     28735, 28730, 28729, 28714, 28736, 28731, 28723, 28737, {f: 2, c: 29203},

 10294     29352, 29565, 29564, 29882, 30379, 30378, 30398, 30445, 30668,

 10295     {f: 2, c: 30670}, 30669, 30706, 31013, 31011, {f: 2, c: 31015}, 31012,

 10296     31017, 31154, 31342, {f: 2, c: 31340}, 31479, 31817, 31816, 31818, 31815,

 10297     31813, 31982, 32379, 32382, 32385, 32384, 32698, 32767, 32889, 33243,

 10298     33241, {f: 2, c: 33384}, 34338, 34303, 34305, 34302, 34331, 34304, 34294,

 10299     34308, 34313, 34309, 34316, 34301, 34841, {f: 2, c: 34832}, 34839, 34835,

 10300     34838, 35171, 35174, 35257, 35319, 35680, 35690, 35677, 35688, 35683,

 10301     35685, 35687, 35693, 36270, 36486, 36488, 36484, 36697, {f: 2, c: 36694},

 10302     36693, 36696, 36698, 37005, 37187, 37185, 37303, 37301, {f: 2, c: 37298},

 10303     37899, 37907, 37883, 37920, 37903, 37908, 37886, 37909, 37904, 37928,

 10304     37913, 37901, 37877, 37888, 37879, 37895, 37902, 37910, 37906, 37882,

 10305     37897, 37880, 37948, 37898, 37887, 37884, 37900, 37878, 37905, 37894,

 10306     38366, 38368, 38367, {f: 2, c: 38702}, 38841, 38843, {f: 2, c: 38909},

 10307     39008, {f: 2, c: 39010}, 39007, {f: 2, c: 39105}, 39248, 39246, 39257,

 10308     39244, 39243, 39251, 39474, 39476, 39473, 39468, 39466, 39478, 39465,

 10309     39470, 39480, 39469, 39623, 39626, 39622, 39696, 39698, 39697, 39947,

 10310     39944, 39927, 39941, 39954, 39928, 40000, 39943, 39950, 39942, 39959,

 10311     39956, 39945, 40351, 40345, 40356, 40349, 40338, 40344, 40336, 40347,

 10312     40352, 40340, 40348, 40362, 40343, 40353, 40346, 40354, 40360, 40350,

 10313     40355, 40383, 40361, 40342, {f: 2, c: 40358}, 40601, 40603, 40602, 40677,

 10314     40676, 40679, 40678, 40752, 40750, 40795, 40800, 40798, 40797, 40793,

 10315     40849, 20794, 20793, 21144, 21143, 22211, {f: 2, c: 22205}, 23368, 23367,

 10316     24011, 24015, 24305, 25085, 25883, 27394, 27388, 27395, 27384, 27392,

 10317     {f: 2, c: 28739}, 28746, {f: 2, c: 28744}, {f: 2, c: 28741}, 29213, 29210,

 10318     29209, 29566, 29975, 30314, 30672, 31021, 31025, 31023, 31828, 31827,

 10319     31986, 32394, [32391, 60229], 32392, 32395, 32390, 32397, 32589, 32699,

 10320     32816, 33245, 34328, 34346, 34342, 34335, 34339, 34332, 34329, 34343,

 10321     34350, 34337, 34336, 34345, 34334, 34341, 34857, 34845, 34843, 34848,

 10322     34852, 34844, 34859, 34890, 35181, 35177, 35182, 35179, 35322, 35705,

 10323     35704, 35653, {f: 2, c: 35706}, 36112, 36116, 36271, 36494, 36492, 36702,

 10324     36699, 36701, 37190, {f: 2, c: 37188}, 37305, 37951, 37947, 37942, 37929,

 10325     37949, 37936, 37945, 37930, 37943, 37932, 37952, 37937, 38373, 38372,

 10326     38371, 38709, 38714, 38847, 38881, 39012, 39113, 39110, 39104, 39256,

 10327     39254, 39481, 39485, 39494, 39492, 39490, 39489, 39482, 39487, 39629,

 10328     39701, {f: 2, c: 39703}, 39702, 39738, 39762, 39979, 39965, 39964, 39980,

 10329     39971, {f: 2, c: 39976}, 39972, 39969, 40375, 40374, 40380, 40385, 40391,

 10330     40394, 40399, 40382, 40389, 40387, 40379, 40373, 40398, {f: 2, c: 40377},

 10331     40364, 40392, 40369, 40365, 40396, 40371, 40397, 40370, 40570, 40604,

 10332     40683, 40686, 40685, 40731, 40728, 40730, 40753, 40782, 40805, 40804,

 10333     40850, 20153, 22214, 22213, 22219, 22897, {f: 2, c: 23371}, 24021, 24017,

 10334     24306, 25889, 25888, 25894, 25890, 27403, {f: 2, c: 27400}, 27661,

 10335     {f: 3, c: 28757}, 28754, {f: 2, c: 29214}, 29353, 29567, 29912, 29909,

 10336     29913, 29911, 30317, 30381, 31029, 31156, {f: 2, c: 31344}, 31831, 31836,

 10337     31833, 31835, 31834, 31988, 31985, 32401, 32591, 32647, 33246, 33387,

 10338     {f: 2, c: 34356}, 34355, 34348, 34354, 34358, 34860, 34856, 34854, 34858,

 10339     34853, 35185, 35263, 35262, 35323, 35710, 35716, 35714, 35718, 35717,

 10340     35711, 36117, 36501, 36500, 36506, 36498, 36496, {f: 2, c: 36502}, 36704,

 10341     36706, 37191, 37964, 37968, {f: 2, c: 37962}, 37967, 37959, 37957,

 10342     {f: 2, c: 37960}, 37958, 38719, 38883, 39018, 39017, 39115, 39252, 39259,

 10343     39502, {f: 2, c: 39507}, 39500, 39503, 39496, 39498, 39497, 39506, 39504,

 10344     39632, 39705, 39723, 39739, 39766, 39765, 40006, 40008, 39999, 40004,

 10345     39993, 39987, 40001, 39996, 39991, 39988, 39986, 39997, 39990, 40411,

 10346     40402, 40414, 40410, 40395, 40400, 40412, 40401, 40415, 40425, 40409,

 10347     40408, 40406, 40437, 40405, 40413, 40630, 40688, 40757, 40755, 40754,

 10348     40770, 40811, 40853, 40866, 20797, 21145, 22760, 22759, 22898, 23373,

 10349     24024, 34863, 24399, 25089, {f: 2, c: 25091}, 25897, 25893, 26006, 26347,

 10350     {f: 2, c: 27409}, 27407, 27594, 28763, 28762, 29218, 29570, 29569, 29571,

 10351     30320, 30676, 31847, 31846, 32405, 33388, 34362, 34368, 34361, 34364,

 10352     34353, 34363, 34366, 34864, 34866, 34862, 34867, 35190, 35188, 35187,

 10353     35326, 35724, 35726, 35723, 35720, 35909, 36121, 36504, 36708, 36707,

 10354     37308, 37986, 37973, 37981, 37975, 37982, {f: 2, c: 38852}, 38912, 39510,

 10355     39513, {f: 3, c: 39710}, 40018, 40024, 40016, 40010, 40013, 40011, 40021,

 10356     40025, 40012, 40014, 40443, 40439, 40431, 40419, 40427, 40440, 40420,

 10357     40438, 40417, 40430, 40422, 40434, [40432, 60370], 40418, 40428, 40436,

 10358     40435, 40424, 40429, 40642, 40656, {f: 2, c: 40690}, 40710, 40732, 40760,

 10359     40759, 40758, 40771, 40783, 40817, 40816, {f: 2, c: 40814}, 22227, 22221,

 10360     23374, 23661, 25901, {f: 2, c: 26349}, 27411, 28767, 28769, 28765, 28768,

 10361     29219, 29915, 29925, 30677, 31032, 31159, 31158, 31850, 32407, 32649,

 10362     33389, 34371, 34872, 34871, 34869, 34891, {f: 2, c: 35732},

 10363     {f: 3, c: 36510}, 36509, 37310, 37309, 37314, 37995, {f: 2, c: 37992},

 10364     38629, 38726, 38723, 38727, 38855, 38885, 39518, 39637, 39769, 40035,

 10365     40039, 40038, 40034, 40030, 40032, 40450, 40446, 40455, 40451, 40454,

 10366     40453, {f: 2, c: 40448}, 40457, 40447, 40445, 40452, 40608, 40734, 40774,

 10367     {f: 3, c: 40820}, 22228, 25902, 26040, {f: 2, c: 27416}, 27415, 27418,

 10368     28770, 29222, 29354, {f: 2, c: 30680}, 31033, 31849, 31851, 31990, 32410,

 10369     32408, 32411, 32409, {f: 2, c: 33248}, {f: 3, c: 34374}, {f: 2, c: 35193},

 10370     35196, 35195, 35327, {f: 2, c: 35736}, 36517, 36516, 36515, 37998, 37997,

 10371     37999, 38001, 38003, 38729, 39026, 39263, 40040, 40046, 40045, 40459,

 10372     40461, 40464, 40463, 40466, 40465, 40609, 40693, 40713, 40775, 40824,

 10373     40827, 40826, 40825, 22302, 28774, 31855, 34876, 36274, 36518, 37315,

 10374     38004, 38008, 38006, 38005, 39520, [39726, 60830], 40052, 40051, 40049,

 10375     40053, 40468, 40467, 40694, 40714, 40868, 28776, 28773, 31991, 34410,

 10376     34878, 34877, 34879, 35742, 35996, 36521, 36553, 38731, {f: 2, c: 39027},

 10377     39116, 39265, 39339, 39524, {f: 2, c: 39526}, 39716, 40469, 40471, 40776,

 10378     25095, 27422, 29223, 34380, 36520, 38018, {f: 2, c: 38016}, 39529, 39528,

 10379     40473, 34379, 35743, 38019, 40057, 40631, 30325, 39531, 40058, 40477,

 10380     {f: 2, c: 28777}, 29225, 40612, 40830, 40777, 40856, {s: 97}, 65075, 0,

 10381     65076, 65103, [168, 776, 63208], [710, 63209, 65342], [12541, 63210],

 10382     [12542, 63211], [12445, 63212], [12446, 63213], 0, [12293, 63216],

 10383     [12294, 63217], [12295, 63218], [12540, 63219], [63220, 65339],

 10384     [63221, 65341], [10045, 63222], [12353, 63223], [12354, 63224],

 10385     [12355, 63225], [12356, 63226], [12357, 63227], [12358, 63228],

 10386     [12359, 63229], [12360, 63230], [12361, 63231], [12362, 63232],

 10387     [12363, 63233], [12364, 63234], [12365, 63235], [12366, 63236],

 10388     [12367, 63237], [12368, 63238], [12369, 63239], [12370, 63240],

 10389     [12371, 63241], [12372, 63242], [12373, 63243], [12374, 63244],

 10390     [12375, 63245], [12376, 63246], [12377, 63247], [12378, 63248],

 10391     [12379, 63249], [12380, 63250], [12381, 63251], [12382, 63252],

 10392     [12383, 63253], [12384, 63254], [12385, 63255], [12386, 63256],

 10393     [12387, 63257], [12388, 63258], [12389, 63259], [12390, 63260],

 10394     [12391, 63261], [12392, 63262], [12393, 63263], [12394, 63264],

 10395     [12395, 63265], [12396, 63266], [12397, 63267], [12398, 63268],

 10396     [12399, 63269], [12400, 63270], [12401, 63271], [12402, 63272],

 10397     [12403, 63273], [12404, 63274], [12405, 63275], [12406, 63276],

 10398     [12407, 63277], [12408, 63278], [12409, 63279], [12410, 63280],

 10399     [12411, 63281], [12412, 63282], [12413, 63283], [12414, 63284],

 10400     [12415, 63285], [12416, 63286], [12417, 63287], [12418, 63288],

 10401     [12419, 63289], [12420, 63290], [12421, 63291], [12422, 63292],

 10402     [12423, 63293], [12424, 63294], [12425, 63295], [12426, 63296],

 10403     [12427, 63297], [12428, 63298], [12429, 63299], [12430, 63300],

 10404     [12431, 63301], [12432, 63302], [12433, 63303], [12434, 63304],

 10405     [12435, 63305], [12449, 63306], [12450, 63307], [12451, 63308],

 10406     [12452, 63309], [12453, 63310], [12454, 63311], [12455, 63312],

 10407     [12456, 63313], [12457, 63314], [12458, 63315], [12459, 63316],

 10408     [12460, 63317], [12461, 63318], [12462, 63319], [12463, 63320],

 10409     [12464, 63321], [12465, 63322], [12466, 63323], [12467, 63324],

 10410     [12468, 63325], [12469, 63326], [12470, 63327], [12471, 63328],

 10411     [12472, 63329], [12473, 63330], [12474, 63331], [12475, 63332],

 10412     [12476, 63333], [12477, 63334], [12478, 63335], [12479, 63336],

 10413     [12480, 63337], [12481, 63338], [12482, 63339], [12483, 63340],

 10414     [12484, 63341], [12485, 63342], [12486, 63343], [12487, 63344],

 10415     [12488, 63345], [12489, 63346], [12490, 63347], [12491, 63348],

 10416     [12492, 63349], [12493, 63350], [12494, 63351], [12495, 63352],

 10417     [12496, 63353], [12497, 63354], [12498, 63355], [12499, 63356],

 10418     [12500, 63357], [12501, 63358], [12502, 63359], [12503, 63360],

 10419     [12504, 63361], [12505, 63362], [12506, 63363], [12507, 63364],

 10420     [12508, 63365], [12509, 63366], [12510, 63367], [12511, 63368],

 10421     [12512, 63369], [12513, 63370], [12514, 63371], [12515, 63372],

 10422     [12516, 63373], [12517, 63374], [12518, 63375], [12519, 63376],

 10423     [12520, 63377], [12521, 63378], [12522, 63379], [12523, 63380],

 10424     [12524, 63381], [12525, 63382], [12526, 63383], [12527, 63384],

 10425     [12528, 63385], [12529, 63386], [12530, 63387], [12531, 63388],

 10426     [12532, 63389], [12533, 63390], [12534, 63391], [1040, 63392],

 10427     [1041, 63393], [1042, 63394], [1043, 63395], [1044, 63396], [1045, 63397],

 10428     [1025, 63398], [1046, 63399], [1047, 63400], [1048, 63401], [1049, 63402],

 10429     [1050, 63403], [1051, 63404], [1052, 63405], [1053, 63406], [1054, 63407],

 10430     [1055, 63408], [1056, 63409], [1057, 63410], [1058, 63411], [1059, 63412],

 10431     [1060, 63413], [1061, 63414], [1062, 63415], [1063, 63416], [1064, 63417],

 10432     [1065, 63418], [1066, 63419], [1067, 63420], [1068, 63421], [1069, 63422],

 10433     [1070, 63423], [1071, 63424], [1072, 63425], [1073, 63426], [1074, 63427],

 10434     [1075, 63428], [1076, 63429], [1077, 63430], [1105, 63431], [1078, 63432],

 10435     [1079, 63433], [1080, 63434], [1081, 63435], [1082, 63436], [1083, 63437],

 10436     [1084, 63438], [1085, 63439], [1086, 63440], [1087, 63441], [1088, 63442],

 10437     [1089, 63443], [1090, 63444], [1091, 63445], [1092, 63446], [1093, 63447],

 10438     [1094, 63448], [1095, 63449], [1096, 63450], [1097, 63451], [1098, 63452],

 10439     [1099, 63453], [1100, 63454], [1101, 63455], [1102, 63456], [1103, 63457],

 10440     [8679, 63458], [8632, 63459], [8633, 63460], [20033, 63461],

 10441     [63462, 131276], [20058, 63463], [63464, 131210], [20994, 63465],

 10442     [17553, 63466], 63467, [20872, 63468], [13853, 63469], [63470, 161287],

 10443     {s: 40}, [172, 63511, 65506], [63512, 65508], [63513, 65287],

 10444     [63514, 65282], [12849, 63515], [8470, 63516], [8481, 63517], 30849,

 10445     [37561, 58501], 35023, 22715, 24658, 31911, 23290, 9556, 9574, 9559, 9568,

 10446     9580, 9571, 9562, 9577, 9565, 9554, 9572, 9557, {s: 3}, 9560, 9575, 9563,

 10447     9555, 9573, 9558, 9567, 9579, 9570, 9561, 9576, 9564, 9553, {s: 5}, 9619,

 10448     {s: 26}, [58129, 147159], [22462, 58130], [58131, 159443], [28990, 58132],

 10449     [58133, 153568], [27042, 58135], [58136, 166889], [23412, 58137],

 10450     [31305, 58138], [58139, 153825], [58140, 169177], [31333, 58141],

 10451     [31357, 58142], [58143, 154028], [31419, 58144], [31408, 58145],

 10452     [31426, 58146], [31427, 58147], [29137, 58148], [58149, 156813],

 10453     [16842, 58150], [31450, 58151], [31453, 58152], [31466, 58153],

 10454     [16879, 58154], [21682, 58155], [58156, 154625], [31499, 58157],

 10455     [31573, 58158], [31529, 58159], [58160, 152334], [58161, 154878],

 10456     [31650, 58162], [31599, 58163], [33692, 58164], [58165, 154548],

 10457     [58166, 158847], [31696, 58167], [33825, 58168], [31634, 58169], 0,

 10458     [58171, 154912], 0, [33938, 58174], [31738, 58175], 0, [31797, 58177],

 10459     [58178, 154817], [31812, 58179], [31875, 58180], [58181, 149634],

 10460     [31910, 58182], [58184, 148856], [31945, 58185], [31943, 58186],

 10461     [31974, 58187], 0, [31987, 58189], [31989, 58190], [32359, 58192],

 10462     [17693, 58193], [58194, 159300], [32093, 58195], [58196, 159446],

 10463     [32137, 58198], [32171, 58199], [28981, 58200], [32179, 58201], 32214,

 10464     [58203, 147543], [58204, 155689], [32228, 58205], [15635, 58206],

 10465     [32245, 58207], [58208, 137209], [32229, 58209], [58210, 164717], 0,

 10466     [58212, 155937], [58213, 155994], [32366, 58214], 0, [17195, 58216],

 10467     [37996, 58217], [32295, 58218], [32576, 58219], [32577, 58220],

 10468     [32583, 58221], [31030, 58222], [58223, 156368], [39393, 58224],

 10469     [32663, 58225], [58226, 156497], [32675, 58227], [58228, 136801],

 10470     [58229, 131176], [17756, 58230], [58231, 145254], [58233, 164666],

 10471     [32762, 58234], [58235, 156809], 0, [32776, 58237], [32797, 58238], 0,

 10472     [32815, 58240], [58241, 172167], [58242, 158915], [32827, 58243],

 10473     [32828, 58244], [32865, 58245], [58246, 141076], [18825, 58247],

 10474     [58248, 157222], [58249, 146915], [58250, 157416], [26405, 58251],

 10475     [32935, 58252], [58253, 166472], [33031, 58254], [33050, 58255],

 10476     [22704, 58256], [58257, 141046], [27775, 58258], [58259, 156824],

 10477     [25831, 58261], [58262, 136330], [33304, 58263], [58264, 137310],

 10478     [27219, 58265], [58266, 150117], [58267, 150165], [17530, 58268],

 10479     [33321, 58269], [58271, 158290], [58272, 146814], [20473, 58273],

 10480     [58274, 136445], [34018, 58275], [33634, 58276], 0, [58278, 149927],

 10481     [58279, 144688], [58280, 137075], [58281, 146936], [33450, 58282],

 10482     [26907, 58283], [58284, 194964], [16859, 58285], [34123, 58286],

 10483     [33488, 58287], [33562, 58288], [58289, 134678], [58290, 137140],

 10484     [14017, 58291], [58292, 143741], [58293, 144730], [33403, 58294],

 10485     [33506, 58295], [33560, 58296], [58297, 147083], [58298, 159139],

 10486     [58299, 158469], [58300, 158615], [58301, 144846], [15807, 58302],

 10487     [33565, 58303], [21996, 58304], [33669, 58305], [17675, 58306],

 10488     [58307, 159141], [33708, 58308], 0, [33747, 58310], [58312, 159444],

 10489     [27223, 58313], [34138, 58314], [13462, 58315], [58316, 159298],

 10490     [33880, 58318], [58319, 154596], [33905, 58320], [15827, 58321],

 10491     [17636, 58322], [27303, 58323], [33866, 58324], [31064, 58326], 0,

 10492     [58328, 158614], [58329, 159351], [58330, 159299], [34014, 58331], 0,

 10493     [33681, 58333], [17568, 58334], [33939, 58335], [34020, 58336],

 10494     [58337, 154769], [16960, 58338], [58339, 154816], [17731, 58340],

 10495     [34100, 58341], [23282, 58342], 0, [17703, 58344], [34163, 58345],

 10496     [17686, 58346], [26559, 58347], [34326, 58348], [58349, 165413],

 10497     [58350, 165435], [34241, 58351], [58352, 159880], [34306, 58353],

 10498     [58354, 136578], [58355, 159949], [58356, 194994], [17770, 58357],

 10499     [34344, 58358], [13896, 58359], [58360, 137378], [21495, 58361],

 10500     [58362, 160666], [34430, 58363], 0, [58365, 172280], [34798, 58366],

 10501     [58367, 142375], [34737, 58368], [34778, 58369], [34831, 58370, 60990],

 10502     [22113, 58371], [34412, 58372], [26710, 58373], [17935, 58374],

 10503     [34885, 58375], [34886, 58376], [58377, 161248], [58378, 146873],

 10504     [58379, 161252], [34910, 58380], [34972, 58381], [18011, 58382],

 10505     [34996, 58383], [34997, 58384], [35013, 58386], [58388, 161551],

 10506     [35207, 58389], {s: 3}, [35239, 58393], [35260, 58394], [58395, 166437],

 10507     [35303, 58396], [58397, 162084], [58398, 162493], [35484, 58399],

 10508     [30611, 58400], [37374, 58401], [35472, 58402], [58403, 162393],

 10509     [31465, 58404], [58405, 162618], [18195, 58407], [58408, 162616],

 10510     [29052, 58409], [35596, 58410], [35615, 58411], [58412, 152624],

 10511     [58413, 152933], [35647, 58414], 0, [35661, 58416], [35497, 58417],

 10512     [58418, 150138], [35728, 58419], [35739, 58420], [35503, 58421],

 10513     [58422, 136927], [17941, 58423], [34895, 58424], [35995, 58425],

 10514     [58426, 163156], [58427, 163215], [58428, 195028], [14117, 58429],

 10515     [58430, 163155], [36054, 58431], [58432, 163224], [58433, 163261],

 10516     [36114, 58434], [36099, 58435], [58436, 137488], [36059, 58437],

 10517     [28764, 58438], [36113, 58439], [16080, 58441], 0, [36265, 58443],

 10518     [58444, 163842], [58445, 135188], [58446, 149898], [15228, 58447],

 10519     [58448, 164284], [58449, 160012], [31463, 58450], [36525, 58451],

 10520     [36534, 58452], [36547, 58453], [37588, 58454], [36633, 58455],

 10521     [36653, 58456], [58457, 164709], [58458, 164882], [36773, 58459],

 10522     [37635, 58460], [58461, 172703], [58462, 133712], [36787, 58463], 0,

 10523     [58465, 166366], [58466, 165181], [58467, 146875], [24312, 58468],

 10524     [58469, 143970], [36857, 58470], 0, [58474, 140069], [14720, 58475],

 10525     [58476, 159447], [36919, 58477], [58478, 165180], [58479, 162494],

 10526     [36961, 58480], [58481, 165228], [58482, 165387], [37032, 58483],

 10527     [58484, 165651], [37060, 58485], [58486, 165606], [37038, 58487], 0,

 10528     [37223, 58489], [37289, 58491], [37316, 58492], [31916, 58493],

 10529     [58494, 166195], [58495, 138889], [37390, 58496], [27807, 58497],

 10530     [37441, 58498], [37474, 58499], [58500, 153017], [58502, 166598],

 10531     [58503, 146587], [58504, 166668], [58505, 153051], [58506, 134449],

 10532     [37676, 58507], [37739, 58508], [58509, 166625], [58510, 166891],

 10533     [23235, 58512], [58513, 166626], [58514, 166629], [18789, 58515],

 10534     [37444, 58516], [58517, 166892], [58518, 166969], [58519, 166911],

 10535     [37747, 58520], [37979, 58521], [36540, 58522], [38277, 58523],

 10536     [38310, 58524], [37926, 58525], [38304, 58526], [28662, 58527],

 10537     [17081, 58528], [58530, 165592], [58531, 135804], [58532, 146990],

 10538     [18911, 58533], [27676, 58534], [38523, 58535], [38550, 58536],

 10539     [16748, 58537], [38563, 58538], [58539, 159445], [25050, 58540], 58541,

 10540     [30965, 58542], [58543, 166624], [38589, 58544], [21452, 58545],

 10541     [18849, 58546], [58547, 158904], [58548, 131700], [58549, 156688],

 10542     [58550, 168111], [58551, 168165], [58552, 150225], [58553, 137493],

 10543     [58554, 144138], [38705, 58555], [34370, 58556], [38710, 58557],

 10544     [18959, 58558], [17725, 58559], [17797, 58560], [58561, 150249],

 10545     [28789, 58562], [23361, 58563], [38683, 58564], 0, [58566, 168405],

 10546     [38743, 58567], [23370, 58568], [58569, 168427], [38751, 58570],

 10547     [37925, 58571], [20688, 58572], [58573, 143543], [58574, 143548],

 10548     [38793, 58575], [38815, 58576], [38833, 58577], [38846, 58578],

 10549     [38848, 58579], [38866, 58580], [38880, 58581], [58582, 152684],

 10550     [38894, 58583], [29724, 58584], [58585, 169011], 0, [38901, 58587],

 10551     [58588, 168989], [58589, 162170], [19153, 58590], [38964, 58591],

 10552     [38963, 58592], [38987, 58593], [39014, 58594], [15118, 58595],

 10553     [58596, 160117], [15697, 58597], [58598, 132656], [58599, 147804],

 10554     [58600, 153350], [39114, 58601], [39095, 58602], [39112, 58603],

 10555     [39111, 58604], [19199, 58605], [58606, 159015], [58607, 136915],

 10556     [21936, 58608], [39137, 58609], [39142, 58610], [39148, 58611],

 10557     [37752, 58612], [39225, 58613], [58614, 150057], [19314, 58615],

 10558     [58616, 170071], [58617, 170245], [39413, 58618], [39436, 58619],

 10559     [39483, 58620], [39440, 58621], [39512, 58622], [58623, 153381],

 10560     [14020, 58624], [58625, 168113], [58626, 170965], [39648, 58627],

 10561     [39650, 58628], [58629, 170757], [39668, 58630], [19470, 58631],

 10562     [39700, 58632], [39725, 58633], [58634, 165376], [20532, 58635],

 10563     [39732, 58636], [14531, 58638], [58639, 143485], [39760, 58640],

 10564     [39744, 58641], [58642, 171326], [23109, 58643], [58644, 137315],

 10565     [39822, 58645], [39938, 58647], [39935, 58648], [39948, 58649],

 10566     [58650, 171624], [40404, 58651], [58652, 171959], [58653, 172434],

 10567     [58654, 172459], [58655, 172257], [58656, 172323], [58657, 172511],

 10568     [40318, 58658], [40323, 58659], [58660, 172340], [40462, 58661],

 10569     [40388, 58663], [58665, 172435], [58666, 172576], [58667, 137531],

 10570     [58668, 172595], [40249, 58669], [58670, 172217], [58671, 172724],

 10571     [40592, 58672], [40597, 58673], [40606, 58674], [40610, 58675],

 10572     [19764, 58676], [40618, 58677], [40623, 58678], [58679, 148324],

 10573     [40641, 58680], [15200, 58681], [14821, 58682], [15645, 58683],

 10574     [20274, 58684], [14270, 58685], [58686, 166955], [40706, 58687],

 10575     [40712, 58688], [19350, 58689], [37924, 58690], [58691, 159138],

 10576     [40727, 58692, 60836], 0, [40761, 58694], [22175, 58695], [22154, 58696],

 10577     [40773, 58697], [39352, 58698], [58699, 168075], [38898, 58700],

 10578     [33919, 58701], 0, [40809, 58703], [31452, 58704], [40846, 58705],

 10579     [29206, 58706], [19390, 58707], [58708, 149877], [58709, 149947],

 10580     [29047, 58710], [58711, 150008], [58712, 148296], [58713, 150097],

 10581     [29598, 58714], [58715, 166874], [58716, 137466], [31135, 58717],

 10582     [58718, 166270], [58719, 167478], [37737, 58720], [37875, 58721],

 10583     [58722, 166468], [37612, 58723], [37761, 58724], [37835, 58725],

 10584     [58726, 166252], [58727, 148665], [29207, 58728], [16107, 58729],

 10585     [30578, 58730], [31299, 58731], [28880, 58732], [58733, 148595],

 10586     [58734, 148472], [29054, 58735], [58736, 137199], [28835, 58737],

 10587     [58738, 137406], [58739, 144793], [16071, 58740], [58741, 137349],

 10588     [58742, 152623], [58743, 137208], [14114, 58744], [58745, 136955],

 10589     [58746, 137273], [14049, 58747], [58748, 137076], [58749, 137425],

 10590     [58750, 155467], [14115, 58751], [58752, 136896], [22363, 58753],

 10591     [58754, 150053], [58755, 136190], [58756, 135848], [58757, 136134],

 10592     [58758, 136374], [34051, 58759, 58761], [58760, 145062], 0, [33877, 58762],

 10593     [58763, 149908], [58764, 160101], [58765, 146993], [58766, 152924],

 10594     [58767, 147195], [58768, 159826], [17652, 58769], [58770, 145134],

 10595     [58771, 170397], [58772, 159526], [26617, 58773], [14131, 58774],

 10596     [15381, 58775], [15847, 58776], [22636, 58777], [58778, 137506],

 10597     [26640, 58779], [16471, 58780], [58781, 145215], [58782, 147681],

 10598     [58783, 147595], [58784, 147727], [58785, 158753], [21707, 58786],

 10599     [22174, 58787], [58788, 157361], [22162, 58789], [58790, 135135],

 10600     [58791, 134056], [58792, 134669], 0, [58794, 166675], [37788, 58795],

 10601     [20216, 58796], [20779, 58797], [14361, 58798], [58799, 148534],

 10602     [20156, 58800], [58801, 132197], 0, [20299, 58803], [20362, 58804],

 10603     [58805, 153169], [23144, 58806], [58807, 131499], [58808, 132043],

 10604     [14745, 58809], [58810, 131850], [58811, 132116], [13365, 58812],

 10605     [20265, 58813], [58814, 131776], [58815, 167603], [58816, 131701],

 10606     [35546, 58817], [58818, 131596], [20120, 58819], [20685, 58820],

 10607     [20749, 58821], [20386, 58822], [20227, 58823], [58824, 150030],

 10608     [58825, 147082], [20290, 58826], [20526, 58827], [20588, 58828],

 10609     [20609, 58829], [20428, 58830], [20453, 58831], [20568, 58832],

 10610     [20732, 58833], [28278, 58838], [58839, 144789], [58840, 147001],

 10611     [58841, 147135], [28018, 58842], [58843, 137348], [58844, 147081],

 10612     [20904, 58845], [20931, 58846], [58847, 132576], [17629, 58848],

 10613     [58849, 132259], [58850, 132242], [58851, 132241], [36218, 58852],

 10614     [58853, 166556], [58854, 132878], [21081, 58855], [21156, 58856],

 10615     [58857, 133235], [21217, 58858], 0, [18042, 58860], [29068, 58861],

 10616     [58862, 148364], [58863, 134176], [58864, 149932], [58865, 135396],

 10617     [27089, 58866], [58867, 134685], 0, [16094, 58869], [29849, 58870],

 10618     [29716, 58871], [29782, 58872], [29592, 58873], [19342, 58874],

 10619     [58875, 150204], [58876, 147597], [21456, 58877], [13700, 58878],

 10620     [29199, 58879], [58880, 147657], [21940, 58881], [58882, 131909],

 10621     [21709, 58883], [58884, 134086], [22301, 58885], [37469, 58886],

 10622     [38644, 58887], [22493, 58889], [22413, 58890], [22399, 58891],

 10623     [13886, 58892], [22731, 58893], [23193, 58894], [58895, 166470],

 10624     [58896, 136954], [58897, 137071], [58898, 136976], [23084, 58899],

 10625     [22968, 58900], [23166, 58902], [23247, 58903], [23058, 58904],

 10626     [58905, 153926], [58906, 137715], [58907, 137313], [58908, 148117],

 10627     [14069, 58909], [27909, 58910], [29763, 58911], [23073, 58912],

 10628     [58913, 155267], [23169, 58914], [58915, 166871], [58916, 132115],

 10629     [37856, 58917], [29836, 58918], [58919, 135939], [28933, 58920],

 10630     [18802, 58921], [37896, 58922], [58923, 166395], [37821, 58924],

 10631     [14240, 58925], [23582, 58926], [23710, 58927], [24158, 58928],

 10632     [24136, 58929], [58930, 137622], [58931, 137596], [58932, 146158],

 10633     [24269, 58933], [23375, 58934], [58935, 137475], [58936, 137476],

 10634     [14081, 58937], [58938, 137376], [14045, 58939], [58940, 136958],

 10635     [14035, 58941], [33066, 58942], [58943, 166471], [58944, 138682],

 10636     [58945, 144498], [58946, 166312], [24332, 58947, 60916], [24334, 58948],

 10637     [58949, 137511], [58950, 137131], [23147, 58951], [58952, 137019],

 10638     [23364, 58953], [58955, 161277], [34912, 58956], [24702, 58957],

 10639     [58958, 141408], [58959, 140843], [24539, 58960], [16056, 58961],

 10640     [58962, 140719], [58963, 140734], [58964, 168072], [58965, 159603],

 10641     [25024, 58966], [58967, 131134], [58968, 131142], [58969, 140827],

 10642     [24985, 58970], [24984, 58971], [24693, 58972], [58973, 142491],

 10643     [58974, 142599], [58975, 149204], [58976, 168269], [25713, 58977],

 10644     [58978, 149093], [58979, 142186], [14889, 58980], [58981, 142114],

 10645     [58982, 144464], [58983, 170218], [58984, 142968], [25399, 58985],

 10646     [25782, 58987], [25393, 58988], [25553, 58989], [58990, 149987],

 10647     [58991, 142695], [25252, 58992], [58993, 142497], [25659, 58994],

 10648     [25963, 58995], [26994, 58996], [15348, 58997], [58998, 143502],

 10649     [58999, 144045], [59000, 149897], [59001, 144043], [21773, 59002],

 10650     [59003, 144096], [59004, 137433], [59005, 169023], [26318, 59006],

 10651     [59007, 144009], [59008, 143795], [15072, 59009], [59011, 152964],

 10652     [59012, 166690], [59013, 152975], [59014, 136956], [59015, 152923],

 10653     [59016, 152613], [30958, 59017], [59018, 143619], [59019, 137258],

 10654     [59020, 143924], [13412, 59021], [59022, 143887], [59023, 143746],

 10655     [59024, 148169], [26254, 59025], [59026, 159012], [26219, 59027],

 10656     [19347, 59028], [26160, 59029], [59030, 161904], [59031, 138731],

 10657     [26211, 59032], [59033, 144082], [59034, 144097], [26142, 59035],

 10658     [59036, 153714], [14545, 59037], [59038, 145466], [59039, 145340],

 10659     [15257, 59040], [59041, 145314], [59042, 144382], [29904, 59043],

 10660     [15254, 59044], [59046, 149034], [26806, 59047], 0, [15300, 59049],

 10661     [27326, 59050], [59052, 145365], [59053, 148615], [27187, 59054],

 10662     [27218, 59055], [27337, 59056], [27397, 59057], [59058, 137490],

 10663     [25873, 59059], [26776, 59060], [27212, 59061], [15319, 59062],

 10664     [27258, 59063], [27479, 59064], [59065, 147392], [59066, 146586],

 10665     [37792, 59067], [37618, 59068], [59069, 166890], [59070, 166603],

 10666     [37513, 59071], [59072, 163870], [59073, 166364], [37991, 59074],

 10667     [28069, 59075], [28427, 59076], 0, [59079, 147327], [15759, 59080],

 10668     [28164, 59081], [59082, 147516], [23101, 59083], [28170, 59084],

 10669     [22599, 59085], [27940, 59086], [30786, 59087], [28987, 59088],

 10670     [59089, 148250], [59090, 148086], [28913, 59091], [29264, 59092, 61085],

 10671     [29319, 59093], [29332, 59094], [59095, 149391], [59096, 149285],

 10672     [20857, 59097], [59098, 150180], [59099, 132587], [29818, 59100],

 10673     [59101, 147192], [59102, 144991], [59103, 150090], [59104, 149783],

 10674     [59105, 155617], [16134, 59106], [16049, 59107], [59108, 150239],

 10675     [59109, 166947], [59110, 147253], [24743, 59111], [16115, 59112],

 10676     [29900, 59113], [29756, 59114], [37767, 59115], [29751, 59116],

 10677     [17567, 59117], [59118, 159210], [17745, 59119], [30083, 59120],

 10678     [16227, 59121], [59122, 150745], [59123, 150790], [16216, 59124],

 10679     [30037, 59125], [30323, 59126], [59127, 173510], 0, [29800, 59129, 61070],

 10680     [59130, 166604], [59131, 149931], [59132, 149902], [15099, 59133],

 10681     [15821, 59134], [59135, 150094], [16127, 59136], [59137, 149957],

 10682     [59138, 149747], [37370, 59139], [22322, 59140], [37698, 59141],

 10683     [59142, 166627], [59143, 137316], [20703, 59144], [59145, 152097],

 10684     [59146, 152039], [30584, 59147], [59148, 143922], [30478, 59149],

 10685     [30479, 59150], [30587, 59151], [59152, 149143], [59153, 145281],

 10686     [14942, 59154], [59155, 149744], [29752, 59156], [29851, 59157],

 10687     [16063, 59158], [59159, 150202], [59160, 150215], [16584, 59161],

 10688     [59162, 150166], [59163, 156078], [37639, 59164], [59165, 152961],

 10689     [30750, 59166], [30861, 59167], [30856, 59168], [30930, 59169],

 10690     [29648, 59170], [31065, 59171], [59172, 161601], [59173, 153315],

 10691     [16654, 59174], 0, 0, [31141, 59177], [27181, 59178], [59179, 147194],

 10692     [31290, 59180], [31220, 59181], [16750, 59182], [59183, 136934],

 10693     [16690, 59184], [37429, 59185], [31217, 59186], [59187, 134476],

 10694     [59188, 149900], [59189, 131737], [59190, 146874], [59191, 137070],

 10695     [13719, 59192], [21867, 59193], [13680, 59194], [13994, 59195],

 10696     [59196, 131540], [59197, 134157], [31458, 59198], [23129, 59199],

 10697     [59200, 141045], [59201, 154287], [59202, 154268], [23053, 59203],

 10698     [59204, 131675], [30960, 59205], [23082, 59206], [59207, 154566],

 10699     [31486, 59208], [16889, 59209], [31837, 59210], [31853, 59211],

 10700     [16913, 59212], [59213, 154547], [59214, 155324], [59215, 155302],

 10701     [31949, 59216], [59217, 150009], [59218, 137136], [31886, 59219],

 10702     [31868, 59220], [31918, 59221], [27314, 59222], [32220, 59223],

 10703     [32263, 59224], [32211, 59225], [32590, 59226], [59227, 156257],

 10704     [59228, 155996], [59229, 162632], [32151, 59230], [59231, 155266],

 10705     [17002, 59232], [59233, 158581], [59234, 133398], [26582, 59235],

 10706     [59236, 131150], [59237, 144847], [22468, 59238], [59239, 156690],

 10707     [59240, 156664], [32733, 59242], [31527, 59243], [59244, 133164],

 10708     [59245, 154345], [59246, 154947], [31500, 59247], [59248, 155150],

 10709     [39398, 59249], [34373, 59250], [39523, 59251], [27164, 59252],

 10710     [59253, 144447], [59255, 150007], [59256, 157101], [39455, 59257],

 10711     [59258, 157088], 0, [59260, 160039], [59261, 158929], [17642, 59262],

 10712     [33079, 59263], [17410, 59264], [32966, 59265], [33033, 59266],

 10713     [33090, 59267], [59268, 157620], [39107, 59269], [59270, 158274],

 10714     [33378, 59271], [33381, 59272], [59273, 158289], [33875, 59274],

 10715     [59275, 159143], [34320, 59276], [59277, 160283], [23174, 59278],

 10716     [16767, 59279], [59280, 137280], [23339, 59281], [59282, 137377],

 10717     [23268, 59283], [59284, 137432], [34464, 59285], [59286, 195004],

 10718     [59287, 146831], [34861, 59288], [59289, 160802], [23042, 59290],

 10719     [34926, 59291], [20293, 59292], [34951, 59293], [35007, 59294],

 10720     [35046, 59295], [35173, 59296], [35149, 59297], [59298, 153219],

 10721     [35156, 59299], [59300, 161669], [59301, 161668], [59302, 166901],

 10722     [59303, 166873], [59304, 166812], [59305, 166393], [16045, 59306],

 10723     [33955, 59307], [18165, 59308], [18127, 59309], [14322, 59310],

 10724     [35389, 59311], [35356, 59312], [59313, 169032], [24397, 59314],

 10725     [37419, 59315], [59316, 148100], [26068, 59317], [28969, 59318],

 10726     [28868, 59319], [59320, 137285], [40301, 59321], [35999, 59322],

 10727     [36073, 59323], [59324, 163292], [22938, 59325], [30659, 59326],

 10728     [23024, 59327], [14036, 59329], [36394, 59330], [36519, 59331],

 10729     [59332, 150537], [36656, 59333], [36682, 59334], [17140, 59335],

 10730     [27736, 59336], [28603, 59337], [59338, 140065], [18587, 59339],

 10731     [28537, 59340], [28299, 59341], [59342, 137178], [39913, 59343],

 10732     [14005, 59344], [59345, 149807], [37051, 59346], 0, [21873, 59348],

 10733     [18694, 59349], [37307, 59350], [37892, 59351], [59352, 166475],

 10734     [16482, 59353], [59354, 166652], [37927, 59355], [59356, 166941],

 10735     [59357, 166971], [34021, 59358], [35371, 59359], [38297, 59360],

 10736     [38311, 59361], [38295, 59362], [38294, 59363], [59364, 167220],

 10737     [29765, 59365], [16066, 59366], [59367, 149759], [59368, 150082],

 10738     [59369, 148458], [16103, 59370], [59371, 143909], [38543, 59372],

 10739     [59373, 167655], [59374, 167526], [59375, 167525], [16076, 59376],

 10740     [59377, 149997], [59378, 150136], [59379, 147438], [29714, 59380],

 10741     [29803, 59381], [16124, 59382], [38721, 59383], [59384, 168112],

 10742     [26695, 59385], [18973, 59386], [59387, 168083], [59388, 153567], 0,

 10743     [37736, 59390], [59391, 166281], [59392, 166950], [59393, 166703],

 10744     [59394, 156606], [37562, 59395], [23313, 59396], [35689, 59397],

 10745     [18748, 59398], [29689, 59399], [59400, 147995], [38811, 59401], 0,

 10746     [39224, 59403], [59404, 134950], [24001, 59405], [59406, 166853],

 10747     [59407, 150194], [38943, 59408], [59409, 169178], [37622, 59410],

 10748     [59411, 169431], [37349, 59412], [17600, 59413], [59414, 166736],

 10749     [59415, 150119], [59416, 166756], [39132, 59417], [59418, 166469],

 10750     [16128, 59419], [37418, 59420], [18725, 59421], [33812, 59422],

 10751     [39227, 59423], [39245, 59424], [59425, 162566], [15869, 59426], 0,

 10752     [19311, 59428], [39338, 59429], [39516, 59430], [59431, 166757],

 10753     [59432, 153800], [27279, 59433], [39457, 59434], [23294, 59435],

 10754     [39471, 59436], [59437, 170225], [19344, 59438], [59439, 170312],

 10755     [39356, 59440], [19389, 59441], [19351, 59442], [37757, 59443],

 10756     [22642, 59444], [59445, 135938], [22562, 59446], [59447, 149944],

 10757     [59448, 136424], [30788, 59449], [59450, 141087], [59451, 146872],

 10758     [26821, 59452], [15741, 59453], [37976, 59454], [14631, 59455],

 10759     [24912, 59456], [59457, 141185], [59458, 141675], [24839, 59459],

 10760     [40015, 59460], [40019, 59461], [40059, 59462], [39989, 59463],

 10761     [39952, 59464], [39807, 59465], [39887, 59466], [59467, 171565],

 10762     [39839, 59468], [59469, 172533], [59470, 172286], [40225, 59471],

 10763     [19630, 59472], [59473, 147716], [40472, 59474], [19632, 59475],

 10764     [40204, 59476], [59477, 172468], [59478, 172269], [59479, 172275],

 10765     [59480, 170287], [40357, 59481], [33981, 59482], [59483, 159250],

 10766     [59484, 159711], [59485, 158594], [34300, 59486], [17715, 59487],

 10767     [59488, 159140], [59489, 159364], [59490, 159216], [33824, 59491],

 10768     [34286, 59492], [59493, 159232], [59494, 145367], [59495, 155748],

 10769     [31202, 59496], [59497, 144796], [59498, 144960], [59500, 149982],

 10770     [15714, 59501], [37851, 59502], [37566, 59503], [37704, 59504],

 10771     [59505, 131775], [30905, 59506], [37495, 59507], [37965, 59508],

 10772     [20452, 59509], [13376, 59510], [36964, 59511], [59512, 152925],

 10773     [30781, 59513], [30804, 59514], [30902, 59515], [30795, 59516],

 10774     [59517, 137047], [59518, 143817], [59519, 149825], [13978, 59520],

 10775     [20338, 59521], [28634, 59522], [28633, 59523], 0, [28702, 59524, 59525],

 10776     [21524, 59526], [59527, 147893], [22459, 59528], [22771, 59529],

 10777     [22410, 59530], [40214, 59531], [22487, 59532], [28980, 59533],

 10778     [13487, 59534], [59535, 147884], [29163, 59536], [59537, 158784],

 10779     [59538, 151447], 0, [59540, 137141], [59541, 166473], [24844, 59542],

 10780     [23246, 59543], [23051, 59544], [17084, 59545], [59546, 148616],

 10781     [14124, 59547], [19323, 59548], [59549, 166396], [37819, 59550],

 10782     [37816, 59551], [59552, 137430], [59553, 134941], [33906, 59554],

 10783     [59555, 158912], [59556, 136211], [59557, 148218], [59558, 142374],

 10784     [59559, 148417], [22932, 59560], [59561, 146871], [59562, 157505],

 10785     [32168, 59563], [59564, 155995], [59565, 155812], [59566, 149945],

 10786     [59567, 149899], [59568, 166394], [37605, 59569], [29666, 59570],

 10787     [16105, 59571], [29876, 59572], [59573, 166755], [59574, 137375],

 10788     [16097, 59575], [59576, 150195], [27352, 59577], [29683, 59578],

 10789     [29691, 59579], [16086, 59580], [59581, 150078], [59582, 150164],

 10790     [59583, 137177], [59584, 150118], [59585, 132007], [59586, 136228],

 10791     [59587, 149989], [29768, 59588], [59589, 149782], [28837, 59590],

 10792     [59591, 149878], [37508, 59592], [29670, 59593], [37727, 59594],

 10793     [59595, 132350], [37681, 59596], [59597, 166606], [59598, 166422],

 10794     [37766, 59599], [59600, 166887], [59601, 153045], [18741, 59602],

 10795     [59603, 166530], [29035, 59604], [59605, 149827], [59606, 134399],

 10796     [22180, 59607], [59608, 132634], [59609, 134123], [59610, 134328],

 10797     [21762, 59611], [31172, 59612], [59613, 137210], [32254, 59614],

 10798     [59615, 136898], [59616, 150096], [59617, 137298], [17710, 59618],

 10799     [37889, 59619], [14090, 59620], [59621, 166592], [59622, 149933],

 10800     [22960, 59623], [59624, 137407], [59625, 137347], [59626, 160900],

 10801     [23201, 59627], [14050, 59628], [59629, 146779], [14000, 59630],

 10802     [37471, 59631], [23161, 59632], [59633, 166529], [59634, 137314],

 10803     [37748, 59635], [15565, 59636], [59637, 133812], [19094, 59638],

 10804     [14730, 59639], [20724, 59640], [15721, 59641], [15692, 59642],

 10805     [59643, 136092], [29045, 59644], [17147, 59645], [59646, 164376],

 10806     [28175, 59647], [59648, 168164], [17643, 59649], [27991, 59650],

 10807     [59651, 163407], [28775, 59652], [27823, 59653], [15574, 59654],

 10808     [59655, 147437], [59656, 146989], [28162, 59657], [28428, 59658],

 10809     [15727, 59659], [59660, 132085], [30033, 59661], [14012, 59662],

 10810     [13512, 59663], [18048, 59664], [16090, 59665], [18545, 59666],

 10811     [22980, 59667], [37486, 59668], [18750, 59669], [36673, 59670],

 10812     [59671, 166940], [59672, 158656], [22546, 59673], [22472, 59674],

 10813     [14038, 59675], [59676, 136274], [28926, 59677], [59678, 148322],

 10814     [59679, 150129], [59680, 143331], [59681, 135856], [59682, 140221],

 10815     [26809, 59683], [26983, 59684], [59685, 136088], [59686, 144613],

 10816     [59687, 162804], [59688, 145119], [59689, 166531], [59690, 145366],

 10817     [59691, 144378], [59692, 150687], [27162, 59693], [59694, 145069],

 10818     [59695, 158903], [33854, 59696], [17631, 59697], [17614, 59698],

 10819     [59699, 159014], [59700, 159057], [59701, 158850], [59702, 159710], 0, 0,

 10820     [33597, 59705], [59706, 137018], [33773, 59707], [59708, 158848],

 10821     [59709, 159827], [59710, 137179], [22921, 59711], [23170, 59712],

 10822     [59713, 137139], [23137, 59714], [23153, 59715], [59716, 137477],

 10823     [59717, 147964], [14125, 59718], [23023, 59719], [59720, 137020],

 10824     [14023, 59721], [29070, 59722], [37776, 59723], [26266, 59724],

 10825     [59725, 148133], [23150, 59726], [23083, 59727], [59728, 148115],

 10826     [27179, 59729], [59730, 147193], [59731, 161590], [59732, 148571],

 10827     [59733, 148170], [28957, 59734], [59735, 148057], [59736, 166369],

 10828     [20400, 59737], [59738, 159016], [23746, 59739], [59740, 148686],

 10829     [59741, 163405], [59742, 148413], [27148, 59743], [59744, 148054],

 10830     [59745, 135940], 0, [28979, 59747], [59748, 148457], [15781, 59749],

 10831     [27871, 59750], [59751, 194597], [23019, 59754], [24412, 59757],

 10832     [59764, 144128], [31955, 59776], [59783, 162548], [59786, 153334],

 10833     [59790, 162584], [36972, 59791], [33270, 59795], [30476, 59797],

 10834     [27810, 59799], [22269, 59800], [22633, 59828], [26465, 59832],

 10835     [23646, 59838], [22770, 59841], [28857, 59843], [26627, 59853],

 10836     [36795, 59859], [36796, 59861], [20001, 59871], [31545, 59898],

 10837     [15820, 59902], [29482, 57990, 59909], [30048, 59912], [22586, 59920],

 10838     [33446, 59932], [27018, 59940], [24803, 59944], [20206, 59984],

 10839     [39364, 60002], [40639, 60023], [21249, 60025], [26528, 60038],

 10840     [24808, 60046], [20916, 60053], [31363, 60064], [39994, 60075],

 10841     [31432, 60093], [26906, 60098], [22956, 60100], [22592, 60102],

 10842     [21610, 60114], [24807, 60123], [22138, 60125], [26965, 60132],

 10843     [39983, 60133], [34725, 60134], [23584, 60141], [24075, 60143],

 10844     [26398, 60147], [33965, 60157], [35713, 60161], [20088, 60166],

 10845     [25283, 60176], [26709, 60180], 0, [33533, 60190], [35237, 60194],

 10846     [36768, 60196], [38840, 60198], [38983, 60200], [39613, 60201],

 10847     [24497, 60218], [26184, 60219], [26303, 60220], [60221, 162425], 0,

 10848     [60225, 149946], 0, 0, [60230, 131910], [26382, 60232], [26904, 60233],

 10849     [60235, 161367], [60236, 155618], [60239, 161278], [60240, 139418],

 10850     [18640, 60241], [19128, 60242], [60244, 166554], [60247, 147515],

 10851     [60250, 150085], [60251, 132554], [20946, 60252], [60253, 132625],

 10852     [22943, 60254], [60255, 138920], [15294, 60256], [60257, 146687],

 10853     [14747, 60262], [60264, 165352], [60265, 170441], [14178, 60266],

 10854     [60267, 139715], [35678, 60268], [60269, 166734], 0, [29193, 60274],

 10855     [60276, 134264], [60280, 132985], [36570, 60281], [21135, 60283],

 10856     [29041, 60285], [60288, 147274], [60289, 150183], [21948, 60290],

 10857     [60293, 158546], [13427, 60295], [60297, 161330], [18200, 60299],

 10858     [60303, 149823], [20582, 60305], [13563, 60306], [60307, 144332], 0,

 10859     [18300, 60310], [60311, 166216], [60315, 138640], 0, [60320, 162834],

 10860     [36950, 60321], [60323, 151450], [35682, 60324], [23899, 60327],

 10861     [60328, 158711], 0, [60331, 137500], [35562, 60332], [60333, 150006],

 10862     [60335, 147439], [19392, 60337], [60340, 141083], [37989, 60341],

 10863     [60342, 153569], [24981, 60343], [23079, 60344], [60345, 194765], 0,

 10864     [60348, 148769], [20074, 60350], [60351, 149812], [38486, 60352],

 10865     [28047, 60353], [60354, 158909], [35191, 60356], [60359, 156689], 0,

 10866     [31554, 60363], [60364, 168128], [60365, 133649], 0, [31301, 60369],

 10867     [39462, 60372], [13919, 60374], [60375, 156777], [60376, 131105],

 10868     [31107, 60377], [23852, 60380], [60381, 144665], 0, [18128, 60384],

 10869     [30011, 60386], [34917, 60387], [22710, 60389], [14108, 60390],

 10870     [60391, 140685], [15444, 60394], [37505, 60397], [60398, 139642],

 10871     [37680, 60400], [60402, 149968], [27705, 60403], [60406, 134904],

 10872     [34855, 60407], [35061, 60408], [60409, 141606], [60410, 164979],

 10873     [60411, 137137], [28344, 60412], [60413, 150058], [60414, 137248],

 10874     [14756, 60415], 0, 0, [17727, 60419], [26294, 60420], [60421, 171181],

 10875     [60422, 170148], [35139, 60423], [16607, 60427], [60428, 136714],

 10876     [14753, 60429], [60430, 145199], [60431, 164072], [60432, 136133],

 10877     [29101, 60433], [33638, 60434], [60436, 168360], 0, [19639, 60438],

 10878     [60439, 159919], [60440, 166315], [60445, 147834], [31555, 60446],

 10879     [31102, 60447], [28597, 60449], [60450, 172767], [27139, 60451],

 10880     [60452, 164632], [21410, 60453], [60454, 159239], [37823, 60455],

 10881     [26678, 60456], [38749, 59389, 60457], [60458, 164207], [60460, 158133],

 10882     [60461, 136173], [60462, 143919], [23941, 60464], [60465, 166960],

 10883     [22293, 60467], [38947, 60468], [60469, 166217], [23979, 60470],

 10884     [60471, 149896], [26046, 60472], [27093, 60473], [21458, 60474],

 10885     [60475, 150181], [60476, 147329], [15377, 60477], [26422, 60478],

 10886     [60482, 139169], [13770, 60490], [18682, 60493], 0, [30728, 60496],

 10887     [37461, 60497], [17394, 60499], [17375, 60501], [23032, 60505], 0,

 10888     [22155, 60518], [60520, 169449], [36882, 60541], [21953, 60546],

 10889     [17673, 60551], [32383, 60552], [28502, 60553], [27313, 60554],

 10890     [13540, 60556], [60558, 161949], [14138, 60559], 0, [60562, 163876],

 10891     [60565, 162366], [15851, 60567], [60569, 146615], [60574, 156248],

 10892     [22207, 60575], [36366, 60577], [23405, 60578], [25566, 60581], 0,

 10893     [25904, 60585], [22061, 60586], [21530, 60588], [60591, 171416],

 10894     [19581, 60592], [22050, 60593], [22046, 60594], [32585, 60595],

 10895     [22901, 60597], [60598, 146752], [34672, 60599], [33047, 60604],

 10896     [40286, 60605], [36120, 60606], [30267, 60607], [40005, 60608],

 10897     [30286, 60609], [30649, 60610], [37701, 60611], [21554, 60612],

 10898     [33096, 60613], [33527, 60614], [22053, 60615], [33074, 60616],

 10899     [33816, 60617], [32957, 60618], [21994, 60619], [31074, 60620],

 10900     [22083, 60621], [21526, 60622], [60623, 134813], [13774, 60624],

 10901     [22021, 57509, 60625], [22001, 60626], [26353, 60627], [60628, 164578],

 10902     [13869, 60629], [30004, 60630], [22000, 60631], [21946, 60632],

 10903     [21655, 60633], [21874, 60634], [60635, 134209], [60636, 134294],

 10904     [24272, 57652, 60637], [60639, 134774], [60640, 142434], [60641, 134818],

 10905     [40619, 60642], [32090, 60643], 0, [60645, 135285], [25245, 60646],

 10906     [38765, 60647], [21652, 60648], [36045, 60649], [29174, 60650],

 10907     [37238, 60651], [25596, 60652], [25529, 60653], [25598, 60654],

 10908     [21865, 60655], [60656, 142147], [40050, 60657], [60658, 143027],

 10909     [20890, 60659], [13535, 60660], [60661, 134567], [20903, 60662],

 10910     [21581, 60663], [21790, 60664], [21779, 60665], [30310, 60666],

 10911     [36397, 60667], [60668, 157834], [30129, 60669], [32950, 60670],

 10912     [34820, 60671], 0, [35015, 60673], [33206, 60674], [33820, 60675],

 10913     [17644, 60677], [29444, 60678], [33547, 60681], [22139, 60683],

 10914     [37232, 60690], [37384, 60692], [60696, 134905], [29286, 60697],

 10915     [18254, 60699], [60701, 163833], [16634, 60703], [40029, 60704],

 10916     [25887, 60705], [18675, 60707], [60708, 149472], [60709, 171388], 0,

 10917     [60713, 161187], 60715, [60716, 155720], [29091, 60718], [32398, 60719],

 10918     [40272, 60720], [13687, 60723], [27826, 60725], [21351, 60726],

 10919     [14812, 60728], [60731, 149016], [33325, 60734], [21579, 60735], 60739,

 10920     [14930, 60740], [29556, 60742], [60743, 171692], [19721, 60744],

 10921     [39917, 60745], 0, [19547, 60748], [60751, 171998], [33884, 60752],

 10922     [60754, 160434], [25390, 60757], [32037, 60758], [14890, 60761],

 10923     [36872, 60762], [21196, 60763], [15988, 60764], [13946, 60765],

 10924     [17897, 60766], [60767, 132238], [30272, 60768], [23280, 60769],

 10925     [60770, 134838], [30842, 60771], [18358, 60772], [22695, 60773],

 10926     [16575, 60774], [22140, 60775], [39819, 60776], [23924, 60777],

 10927     [30292, 60778], [60779, 173108], [40581, 60780], [19681, 60781], 0,

 10928     [14331, 60783], [24857, 60784], [60786, 148466], 60787, [22109, 60788],

 10929     [60792, 171526], [21044, 60793], [13741, 60795], 0, [40316, 60797],

 10930     [31830, 60798], [39737, 60799], [22494, 60800], [23635, 60802],

 10931     [25811, 60803], [60804, 169168], [60805, 156469], [34477, 60807],

 10932     [60808, 134440], [60811, 134513], 60812, [20990, 60813], [60814, 139023],

 10933     [23950, 60815], [38659, 60816], [60817, 138705], [40577, 60818],

 10934     [36940, 60819], [31519, 60820], [39682, 60821], [23761, 60822],

 10935     [31651, 60823], [25192, 60824], [25397, 60825], [39679, 60826],

 10936     [31695, 60827], [39722, 60828], [31870, 60829], 0, [31810, 60831],

 10937     [31878, 60832], [39957, 60833], [31740, 60834], [39689, 60835], 0, 39982,

 10938     [40794, 60839], [21875, 60840], [23491, 60841], [20477, 60842],

 10939     [40600, 60843], [20466, 60844], [21088, 60845], [21201, 60847],

 10940     [22375, 60848], [20566, 60849], [22967, 60850], [24082, 60851],

 10941     [38856, 60852], [40363, 60853], [36700, 60854], [21609, 60855],

 10942     [38836, 60856], [39232, 60857], [38842, 60858], [21292, 60859],

 10943     [24880, 60860], [26924, 60861], [21466, 60862], [39946, 60863],

 10944     [40194, 60864], [19515, 60865], [38465, 60866], [27008, 60867],

 10945     [20646, 60868], [30022, 60869], [60870, 137069], [39386, 60871],

 10946     [21107, 60872], 60873, [37209, 60874], [38529, 60875], [37212, 60876],

 10947     60877, [37201, 60878], [60879, 167575], [25471, 60880], [27338, 60882],

 10948     [22033, 60883], [37262, 60884], [30074, 60885], [25221, 60886],

 10949     [29519, 60888], [31856, 60889], [60890, 154657], 60892, [30422, 60894],

 10950     [39837, 60895], [20010, 60896], [60897, 134356], [33726, 60898],

 10951     [34882, 60899], 60900, [23626, 60901], [27072, 60902], 0, 0,

 10952     [21023, 60905], [24053, 60906], [20174, 60907], [27697, 60908],

 10953     [60909, 131570], [20281, 60910], [21660, 60911], 0, [21146, 60913],

 10954     [36226, 60914], [13822, 60915], 0, [13811, 60917], 60918, [27474, 60919],

 10955     [37244, 60920], [40869, 60921], [39831, 60922], [38958, 60923],

 10956     [39092, 60924], [39610, 60925], [40616, 60926], [40580, 60927],

 10957     [31508, 60929], 60930, [27642, 60931], [34840, 60932], [32632, 60933],

 10958     60934, [22048, 60935], [60936, 173642], [36471, 60937], [40787, 60938],

 10959     60939, [36308, 60940], [36431, 60941], [40476, 60942], [36353, 60943],

 10960     [25218, 60944], [60945, 164733], [36392, 60946], [36469, 60947],

 10961     [31443, 60948], [31294, 60950], [30936, 60951], [27882, 60952],

 10962     [35431, 60953], [30215, 60954], [40742, 60956], [27854, 60957],

 10963     [34774, 60958], [30147, 60959], [60960, 172722], [30803, 60961],

 10964     [36108, 60963], [29410, 60964], [29553, 60965], [35629, 60966],

 10965     [29442, 60967], [29937, 60968], [36075, 60969], [60970, 150203],

 10966     [34351, 60971], [24506, 60972], [34976, 60973], [17591, 60974], 60975,

 10967     [60977, 159237], 60978, [35454, 60979], [60980, 140571], 60981,

 10968     [24829, 60982], [30311, 60983], [39639, 60984], [40260, 60985],

 10969     [37742, 58859, 60986], [39823, 60987], [34805, 60988], 60989, 0,

 10970     [36087, 60991], [29484, 60992], [38689, 60993], [39856, 60994],

 10971     [13782, 60995], [29362, 60996], [19463, 60997], [31825, 60998],

 10972     [39242, 60999], [24921, 61001], [19460, 61002], [40598, 61003],

 10973     [24957, 61004], 61005, [22367, 61006], [24943, 61007], [25254, 61008],

 10974     [25145, 61009], 0, [14940, 61011], [25058, 61012], [21418, 61013],

 10975     [25444, 61015], [26626, 61016], [13778, 61017], [23895, 61018],

 10976     [36826, 61020], [61021, 167481], 61022, [20697, 61023], [30982, 61025],

 10977     [21298, 61026], [38456, 61027], [61028, 134971], [16485, 61029], 61030,

 10978     [30718, 61031], 61032, [31938, 61033], [61034, 155418], [31962, 61035],

 10979     [31277, 61036], [32870, 61037], [32867, 61038], [32077, 61039],

 10980     [29957, 61040], [29938, 61041], [35220, 61042], [33306, 61043],

 10981     [26380, 61044], [32866, 61045], [61046, 160902], [32859, 61047],

 10982     [29936, 61048], [33027, 61049], [30500, 61050], [35209, 61051],

 10983     [61052, 157644], [30035, 61053], [34729, 61055], [34766, 61056],

 10984     [33224, 61057], [34700, 61058], [35401, 61059], [36013, 61060],

 10985     [35651, 61061], [30507, 61062], [29944, 61063], [34010, 61064],

 10986     [27058, 61066], [36262, 61067], 61068, [35241, 58392, 61069], 0,

 10987     [28089, 61071], [34753, 61072], [61073, 147473], [29927, 61074],

 10988     [15835, 61075], [29046, 61076], [24740, 57702, 61077], [24988, 61078],

 10989     [15569, 61079], 0, [24695, 61081], 61082, [32625, 61083], 0,

 10990     [24809, 61086], [19326, 61087], [57344, 132423], [37595, 57345],

 10991     [57346, 132575], [57347, 147397], [34124, 57348], [17077, 57349],

 10992     [29679, 57350], [20917, 57351], [13897, 57352], [57353, 149826],

 10993     [57354, 166372], [37700, 57355], [57356, 137691], [33518, 57357],

 10994     [57358, 146632], [30780, 57359], [26436, 57360], [25311, 57361],

 10995     [57362, 149811], [57363, 166314], [57364, 131744], [57365, 158643],

 10996     [57366, 135941], [20395, 57367], [57368, 140525], [20488, 57369],

 10997     [57370, 159017], [57371, 162436], [57372, 144896], [57373, 150193],

 10998     [57374, 140563], 0, [57376, 131966], [24484, 57377], [57378, 131968],

 10999     [57379, 131911], [28379, 57380], [57381, 132127], 20702, [20737, 57383],

 11000     [13434, 57384], [20750, 57385], [39020, 57386], [14147, 57387],

 11001     [33814, 57388], [57389, 149924], [57390, 132231], [20832, 57391],

 11002     [57392, 144308], [20842, 57393], [57394, 134143], [57395, 139516],

 11003     [57396, 131813], [57397, 140592], [57398, 132494], [57399, 143923],

 11004     [57400, 137603], [23426, 57401], [34685, 57402], [57403, 132531],

 11005     [57404, 146585], [20914, 57405], [20920, 57406], [40244, 57407],

 11006     [20937, 57408], [20943, 57409], [20945, 57410], [15580, 57411],

 11007     [20947, 57412], [57413, 150182], [20915, 57414], 0, 0, [20973, 57417],

 11008     [33741, 57418], [26942, 57419], [57420, 145197], [24443, 57421],

 11009     [21003, 57422], [21030, 57423], [21052, 57424], [21173, 57425],

 11010     [21079, 57426], [21140, 57427], [21177, 57428], [21189, 57429],

 11011     [31765, 57430], [34114, 57431], [21216, 57432], [34317, 57433],

 11012     [57434, 158483], 0, [57436, 166622], [21833, 57437], [28377, 57438],

 11013     [57439, 147328], [57440, 133460], [57441, 147436], [21299, 57442], 0,

 11014     [57444, 134114], [27851, 57445], [57446, 136998], [26651, 57447],

 11015     [29653, 57448], [24650, 57449], [16042, 57450], [14540, 57451],

 11016     [57452, 136936], [29149, 57453], [17570, 57454], [21357, 57455],

 11017     [21364, 57456], [57457, 165547], [21374, 57458], 0, [57460, 136598],

 11018     [57461, 136723], [30694, 57462], [21395, 57463], [57464, 166555],

 11019     [21408, 57465], [21419, 57466], [21422, 57467], [29607, 57468],

 11020     [57469, 153458], [16217, 57470], [29596, 57471], [21441, 57472],

 11021     [21445, 57473], [27721, 57474], [20041, 57475], [22526, 57476],

 11022     [21465, 57477], [15019, 57478], [57479, 134031], [21472, 57480],

 11023     [57481, 147435], [57482, 142755], [21494, 57483], [57484, 134263],

 11024     [21523, 57485], [28793, 57486], [21803, 57487], [26199, 57488],

 11025     [27995, 57489], [21613, 57490], [57491, 158547], [57492, 134516],

 11026     [21853, 57493], [21647, 57494], [21668, 57495], [18342, 57496],

 11027     [57497, 136973], [57498, 134877], [15796, 57499], [57500, 134477],

 11028     [57501, 166332], [57502, 140952], [21831, 57503], [19693, 57504],

 11029     [21551, 57505], [29719, 57506], [21894, 57507], [21929, 57508], 0,

 11030     [57510, 137431], [57511, 147514], [17746, 57512], [57513, 148533],

 11031     [26291, 57514], [57515, 135348], [22071, 57516], [26317, 57517],

 11032     [57518, 144010], [26276, 57519], 0, [22093, 57521], [22095, 57522],

 11033     [30961, 57523], [22257, 57524], [38791, 57525], [21502, 57526],

 11034     [22272, 57527], [22255, 57528], [22253, 57529], [57530, 166758],

 11035     [13859, 57531], [57532, 135759], [22342, 57533], [57534, 147877],

 11036     [27758, 57535], [28811, 57536], [22338, 57537], [14001, 57538],

 11037     [57539, 158846], [22502, 57540], [57541, 136214], [22531, 57542],

 11038     [57543, 136276], [57544, 148323], [22566, 57545], [57546, 150517], 0,

 11039     [22698, 57548], [13665, 57549], [22752, 57550], [22748, 57551],

 11040     [57552, 135740], [22779, 57553], [23551, 57554], [22339, 57555],

 11041     [57556, 172368], [57557, 148088], [37843, 57558], [13729, 57559],

 11042     [22815, 57560], [26790, 57561], [14019, 57562], [28249, 57563],

 11043     [57564, 136766], [23076, 57565], 0, [57567, 136850], [34053, 57568],

 11044     [22985, 57569], [57570, 134478], [57571, 158849], [57572, 159018],

 11045     [57573, 137180], [23001, 57574], [57575, 137211], [57576, 137138],

 11046     [57577, 159142], [28017, 57578], [57579, 137256], [57580, 136917],

 11047     [23033, 57581], [57582, 159301], [23211, 57583], [23139, 57584],

 11048     [14054, 57585], [57586, 149929], 0, [14088, 57588], [23190, 57589],

 11049     [29797, 57590], [23251, 57591], [57592, 159649], [57593, 140628],

 11050     [57595, 137489], [14130, 57596], [57597, 136888], [24195, 57598],

 11051     [21200, 57599], [23414, 57600], [25992, 57601], [23420, 57602],

 11052     [57603, 162318], [16388, 57604], [18525, 57605], [57606, 131588],

 11053     [23509, 57607], [57609, 137780], [57610, 154060], [57611, 132517],

 11054     [23539, 57612], [23453, 57613], [19728, 57614], [23557, 57615],

 11055     [57616, 138052], [23571, 57617], [29646, 57618], [23572, 57619],

 11056     [57620, 138405], [57621, 158504], [23625, 57622], [18653, 57623],

 11057     [23685, 57624], [23785, 57625], [23791, 57626], [23947, 57627],

 11058     [57628, 138745], [57629, 138807], [23824, 57630], [23832, 57631],

 11059     [23878, 57632], [57633, 138916], [23738, 57634], [24023, 57635],

 11060     [33532, 57636], [14381, 57637], [57638, 149761], [57639, 139337],

 11061     [57640, 139635], [33415, 57641], [14390, 57642], [15298, 57643],

 11062     [24110, 57644], [27274, 57645], 0, 57647, [57648, 148668], [57649, 134355],

 11063     [21414, 57650], [20151, 57651], 0, [21416, 57653], [57654, 137073],

 11064     [24073, 57655], 57656, [57657, 164994], [24313, 57658], [24315, 57659],

 11065     [14496, 57660], [24316, 57661], [26686, 57662], [37915, 57663],

 11066     [24333, 57664], [57665, 131521], [57666, 194708], [15070, 57667],

 11067     [57669, 135994], [24378, 57670], [57671, 157832], [57672, 140240],

 11068     [57674, 140401], [24419, 57675], [57677, 159342], [24434, 57678],

 11069     [37696, 57679], [57680, 166454], [24487, 57681], [23990, 57682],

 11070     [15711, 57683], [57684, 152144], [57685, 139114], [57686, 159992],

 11071     [57687, 140904], [37334, 57688], [57689, 131742], [57690, 166441],

 11072     [24625, 57691], [26245, 57692], [14691, 57694], [15815, 57695],

 11073     [13881, 57696], [22416, 57697], [57698, 141236], [31089, 57699],

 11074     [15936, 57700], [24734, 57701], 0, 0, [57704, 149890], [57705, 149903],

 11075     [57706, 162387], [29860, 57707], [20705, 57708], [23200, 57709],

 11076     [24932, 57710], [24898, 57712], [57713, 194726], [57714, 159442],

 11077     [24961, 57715], [20980, 57716], [57717, 132694], [24967, 57718],

 11078     [23466, 57719], [57720, 147383], [57721, 141407], [25043, 57722],

 11079     [57723, 166813], [57724, 170333], [25040, 57725], [14642, 57726],

 11080     [57727, 141696], [57728, 141505], [24611, 57729], [24924, 57730],

 11081     [25886, 57731], [25483, 57732], [57733, 131352], [25285, 57734],

 11082     [57735, 137072], [25301, 57736], [57737, 142861], [25452, 57738],

 11083     [57739, 149983], [14871, 57740], [25656, 57741], [25592, 57742],

 11084     [57743, 136078], [57744, 137212], [28554, 57746], [57747, 142902], 0,

 11085     [57750, 153373], [25825, 57751], [25829, 57752], [38011, 57753],

 11086     [14950, 57754], [25658, 57755], [14935, 57756], [25933, 57757],

 11087     [28438, 57758], [57759, 150056], [57760, 150051], [25989, 57761],

 11088     [25965, 57762], [25951, 57763], 0, [26037, 57765], [57766, 149824],

 11089     [19255, 57767], [26065, 57768], [16600, 57769], [57770, 137257], 57771,

 11090     [26083, 57772], [24543, 57773], [57774, 144384], [26136, 57775],

 11091     [57776, 143863], [57777, 143864], [26180, 57778], [57779, 143780],

 11092     [57780, 143781], [26187, 57781], [57782, 134773], [26215, 57783],

 11093     [57784, 152038], [26227, 57785], 0, [57788, 143921], [57789, 165364],

 11094     [57790, 143816], [57791, 152339], [30661, 57792], [57793, 141559],

 11095     [39332, 57794], [26370, 57795], [57796, 148380], [57797, 150049],

 11096     [27130, 57799], [57800, 145346], 0, [26471, 57802], [26466, 57803],

 11097     [57804, 147917], [57805, 168173], [26583, 57806], [17641, 57807],

 11098     [26658, 57808], [28240, 57809], [37436, 57810], [26625, 57811],

 11099     [57812, 144358], [57813, 159136], [26717, 57814], [57815, 144495],

 11100     [27105, 57816], [27147, 57817], [57818, 166623], [26995, 57819],

 11101     [26819, 57820], [57821, 144845], [26881, 57822], [26880, 57823],

 11102     [14849, 57825], [57826, 144956], [15232, 57827], [26540, 57828],

 11103     [26977, 57829], [57830, 166474], [17148, 57831], [26934, 57832],

 11104     [27032, 57833], [15265, 57834], [57835, 132041], [33635, 57836],

 11105     [20624, 57837], [27129, 57838], [57839, 144985], [57840, 139562],

 11106     [27205, 57841], [57842, 145155], [27293, 57843], [15347, 57844],

 11107     [26545, 57845], [27336, 57846], [57847, 168348], [15373, 57848],

 11108     [27421, 57849], [57850, 133411], [24798, 57851, 60308], [27445, 57852],

 11109     [27508, 57853], [57854, 141261], [28341, 57855], [57856, 146139], 0,

 11110     [57858, 137560], [14144, 57859], [21537, 57860], [57861, 146266],

 11111     [27617, 57862], [57863, 147196], [27612, 57864], [27703, 57865],

 11112     [57866, 140427], [57867, 149745], [57868, 158545], [27738, 57869],

 11113     [33318, 57870], [27769, 57871], [57872, 146876], [17605, 57873],

 11114     [57874, 146877], [57875, 147876], [57876, 149772], [57877, 149760],

 11115     [57878, 146633], [14053, 57879], [15595, 57880], [57881, 134450],

 11116     [39811, 57882], [57883, 143865], [57884, 140433], [32655, 57885],

 11117     [26679, 57886], [57887, 159013], [57888, 159137], [57889, 159211],

 11118     [28054, 57890], [27996, 57891], [28284, 57892], [28420, 57893],

 11119     [57894, 149887], [57895, 147589], [57896, 159346], [34099, 57897],

 11120     [57898, 159604], [20935, 57899], 0, 0, [33838, 57902], [57903, 166689], 0,

 11121     [57905, 146991], [29779, 57906], [57907, 147330], [31180, 57908],

 11122     [28239, 57909], [23185, 57910], [57911, 143435], [28664, 57912],

 11123     [14093, 57913], [28573, 57914], [57915, 146992], [28410, 57916],

 11124     [57917, 136343], [57918, 147517], [17749, 57919], [37872, 57920],

 11125     [28484, 57921], [28508, 57922], [15694, 57923], [28532, 57924],

 11126     [57925, 168304], [15675, 57926], [28575, 57927], [57928, 147780],

 11127     [28627, 57929], [57930, 147601], [57931, 147797], [57932, 147513],

 11128     [57933, 147440], [57934, 147380], [57935, 147775], [20959, 57936],

 11129     [57937, 147798], [57938, 147799], [57939, 147776], [57940, 156125],

 11130     [28747, 57941], [28798, 57942], [28839, 57943], 0, [28876, 57945],

 11131     [28885, 57946], [28886, 57947], [28895, 57948], [16644, 57949],

 11132     [15848, 57950], [29108, 57951], [29078, 57952], [57953, 148087],

 11133     [28971, 57954], [28997, 57955], [23176, 57956], [29002, 57957], 0,

 11134     [57960, 148325], [29007, 57961], [37730, 57962], [57963, 148161],

 11135     [28972, 57964], [57965, 148570], [57966, 150055], [57967, 150050],

 11136     [29114, 57968], [57969, 166888], [28861, 57970], [29198, 57971],

 11137     [37954, 57972], [29205, 57973], [22801, 57974], [37955, 57975],

 11138     [29220, 57976], [37697, 57977], [57978, 153093], [29230, 57979],

 11139     [29248, 57980], [57981, 149876], [26813, 57982], [29269, 57983],

 11140     [29271, 57984], [15957, 57985], [57986, 143428], [26637, 57987],

 11141     [28477, 57988], [29314, 57989], 0, [29483, 57991], [57992, 149539],

 11142     [57993, 165931], [18669, 57994], [57995, 165892], [29480, 57996],

 11143     [29486, 57997], [29647, 57998], [29610, 57999], [58000, 134202],

 11144     [58001, 158254], [29641, 58002], [29769, 58003], [58004, 147938],

 11145     [58005, 136935], [58006, 150052], [26147, 58007], [14021, 58008],

 11146     [58009, 149943], [58010, 149901], [58011, 150011], [29687, 58012],

 11147     [29717, 58013], [26883, 58014], [58015, 150054], [29753, 58016],

 11148     [16087, 58018], 0, [58020, 141485], [29792, 58021], [58022, 167602],

 11149     [29767, 58023], [29668, 58024], [29814, 58025], [33721, 58026],

 11150     [29804, 58027], [29812, 58029], [37873, 58030], [27180, 58031],

 11151     [29826, 58032], [18771, 58033], [58034, 150156], [58035, 147807],

 11152     [58036, 150137], [58037, 166799], [23366, 58038], [58039, 166915],

 11153     [58040, 137374], [29896, 58041], [58042, 137608], [29966, 58043],

 11154     [29982, 58045], [58046, 167641], [58047, 137803], [23511, 58048],

 11155     [58049, 167596], [37765, 58050], [30029, 58051], [30026, 58052],

 11156     [30055, 58053], [30062, 58054], [58055, 151426], [16132, 58056],

 11157     [58057, 150803], [30094, 58058], [29789, 58059], [30110, 58060],

 11158     [30132, 58061], [30210, 58062], [30252, 58063], [30289, 58064],

 11159     [30287, 58065], [30319, 58066], 58067, [58068, 156661], [30352, 58069],

 11160     [33263, 58070], [14328, 58071], [58072, 157969], [58073, 157966],

 11161     [30369, 58074], [30373, 58075], [30391, 58076], [30412, 58077],

 11162     [58078, 159647], [33890, 58079], [58080, 151709], [58081, 151933],

 11163     [58082, 138780], [30494, 58083], [30502, 58084], [30528, 58085],

 11164     [25775, 58086], [58087, 152096], [30552, 58088], [58089, 144044],

 11165     [30639, 58090], [58091, 166244], [58092, 166248], [58093, 136897],

 11166     [30708, 58094], 0, [26826, 58098], [30895, 58099], [30919, 58100],

 11167     [30931, 58101], [38565, 58102], [31022, 58103], [58104, 153056],

 11168     [30935, 58105], [31028, 58106], [30897, 58107], [58108, 161292],

 11169     [36792, 58109], [34948, 58110], [58113, 140828], [31110, 58114],

 11170     [35072, 58115], [26882, 58116], [31104, 58117], [58118, 153687],

 11171     [31133, 58119], [58120, 162617], [31036, 58121], [31145, 58122],

 11172     [28202, 58123], [58124, 160038], [16040, 58125], [31174, 58126],

 11173     [58127, 168205], [31188, 58128], 0, [21797, 62526], 0, [62528, 134210],

 11174     [62529, 134421], [62530, 151851], [21904, 62531], [62532, 142534],

 11175     [14828, 62533], [62534, 131905], [36422, 62535], [62536, 150968],

 11176     [62537, 169189], 0, [62539, 164030], [30586, 62540], [62541, 142392],

 11177     [14900, 62542], [18389, 62543], [62544, 164189], [62545, 158194],

 11178     [62546, 151018], [25821, 62547], [62548, 134524], [62549, 135092],

 11179     [62550, 134357], 0, [25741, 62552], [36478, 62553], [62554, 134806], 0,

 11180     [62556, 135012], [62557, 142505], [62558, 164438], [62559, 148691], 0,

 11181     [62561, 134470], [62562, 170573], [62563, 164073], [18420, 62564],

 11182     [62565, 151207], [62566, 142530], [39602, 62567], [14951, 62568],

 11183     [62569, 169460], [16365, 62570], [13574, 62571], [62572, 152263],

 11184     [62573, 169940], 0, [62575, 142660], [40302, 62576], [38933, 62577], 0,

 11185     [17369, 62579], 0, [25780, 62581], [21731, 62582], 0, [62584, 142282], 0,

 11186     [14843, 62586], 0, [62588, 157402], [62589, 157462], [62590, 162208],

 11187     [25834, 62591], [62592, 151634], [62593, 134211], [36456, 62594], 0,

 11188     [62596, 166732], [62597, 132913], 0, [18443, 62599], [62600, 131497],

 11189     [16378, 62601], [22643, 62602], [62603, 142733], 0, [62605, 148936],

 11190     [62606, 132348], [62607, 155799], [62608, 134988], 0, [21881, 62610], 0,

 11191     [17338, 62612], 0, [19124, 62614], [62615, 141926], [62616, 135325],

 11192     [33194, 62617], [39157, 62618], [62619, 134556], [25465, 62620],

 11193     [14846, 62621], [62622, 141173], [36288, 62623], [22177, 62624],

 11194     [25724, 62625], [15939, 62626], 0, [62628, 173569], [62629, 134665],

 11195     [62630, 142031], 0, 0, [62633, 135368], [62634, 145858], [14738, 62635],

 11196     [14854, 62636], [62637, 164507], [13688, 62638], [62639, 155209],

 11197     [62640, 139463], 0, 0, [62643, 142514], [62644, 169760], [13500, 62645],

 11198     [27709, 62646], [62647, 151099], 0, 0, [62650, 161140], [62651, 142987],

 11199     [62652, 139784], [62653, 173659], [62654, 167117], [62655, 134778],

 11200     [62656, 134196], [62683, 161337], [62684, 142286], [62687, 142417],

 11201     [14872, 62689], [62691, 135367], [62693, 173618], [62695, 167122],

 11202     [62696, 167321], [62697, 167114], [38314, 62698], 0, [62706, 161630],

 11203     [28992, 62708], 0, [20822, 62385], 0, [20616, 62487], 0, [13459, 62489],

 11204     [20870, 62491], [24130, 63037], [20997, 62495], [21031, 62436],

 11205     [21113, 62497], 0, [13651, 62504], [21442, 62505], [21343, 62715], 0,

 11206     [21823, 62520], 0, [21976, 59986], [13789, 62722], [22049, 63067], 0,

 11207     [22100, 60044], [60148, 135291], 0, [60153, 135379], 0, [61095, 135934], 0,

 11208     0, [14265, 60104], [23745, 61099], [23829, 63066], [23894, 63030],

 11209     [14392, 63036], [20097, 62477], [24253, 63038], [14612, 63042],

 11210     [25017, 63050], [25232, 63054], [25368, 63056], [25690, 63063],

 11211     [25745, 62381], [33133, 62709], [33156, 59922], [33171, 59924],

 11212     [26624, 63080], [15292, 63093], [29327, 60517], [29389, 59781], 0,

 11213     [29497, 59785], [30018, 59811], [30172, 59817], [16320, 59818],

 11214     [60278, 151205], [16343, 59820], 0, 30336, [30348, 59824, 151388],

 11215     [16552, 59845], [30777, 59846], [16643, 59855], [31377, 59863],

 11216     [31771, 59876], [31981, 59884], [32659, 62658], [32686, 59892], 0,

 11217     [33535, 59936], [22623, 59981], [34482, 59960], 0, [34699, 59963],

 11218     [35143, 59969], 0, [35369, 59972], 0, [36465, 59988], [60484, 164233],

 11219     [36528, 59990], 0, [37214, 62443], [37260, 62441], [39182, 60051],

 11220     [39196, 60054], 0, 0, [39809, 60066], [40384, 60080], [40339, 60078],

 11221     [40620, 60085], [19857, 60540], 0, 37818, [40571, 60084], [28809, 63148],

 11222     [29512, 59788], 0, [31129, 59858], [36791, 59997], 0, [39234, 60056],

 11223     {s: 193}, 8364, {s: 4}, [12443, 63518], [12444, 63519], [11904, 63520],

 11224     {f: 5, c: 62211}, [62216, 131340], 62217, [62218, 131281], [62219, 131277],

 11225     {f: 2, c: 62220}, [62222, 131275], [62223, 139240], 62224, [62225, 131274],

 11226     {f: 4, c: 62226}, [62230, 131342], {f: 2, c: 62231}, {f: 2, c: 62776},

 11227     [62778, 138177], [62779, 194680], [12205, 38737, 62780], [62781, 131206],

 11228     [20059, 62782], [20155, 62783], [13630, 62784], [23587, 62785],

 11229     [24401, 62786], [24516, 62787], [14586, 62788], [25164, 62789],

 11230     [25909, 62790], [27514, 62791], [27701, 62792], [27706, 62793],

 11231     [28780, 62794], [29227, 62795], [20012, 62796], [29357, 62797],

 11232     [62798, 149737], [32594, 62799], [31035, 62800], [31993, 62801],

 11233     [32595, 62802], [62803, 156266], [13505, 62804], [62806, 156491],

 11234     [32770, 62807], [32896, 62808], [62809, 157202], [62810, 158033],

 11235     [21341, 62811], [34916, 62812], [35265, 62813], [62814, 161970],

 11236     [35744, 62815], [36125, 62816], [38021, 62817], [38264, 62818],

 11237     [38271, 62819], [38376, 62820], [62821, 167439], [38886, 62822],

 11238     [39029, 62823], [39118, 62824], [39134, 62825], [39267, 62826],

 11239     [62827, 170000], [40060, 62828], [40479, 62829], [40644, 62830],

 11240     [27503, 62831], [62832, 63751], [20023, 62833], [62834, 131207],

 11241     [38429, 62835], [25143, 62836], [38050, 62837], [11908, 63521],

 11242     [11910, 63522], [11911, 63523], [11912, 63524], [11914, 63525],

 11243     [11916, 63526], [11917, 63527], [11925, 63528], [11932, 63529],

 11244     [11941, 63531], [11943, 63532], [11946, 63533], [11948, 63534],

 11245     [11950, 63535], [11958, 63536], [11964, 63537], [11966, 63538],

 11246     [11978, 63540], [11980, 63541], [11981, 63542], [11983, 63543],

 11247     [11990, 63544], [11991, 63545], [11998, 63546], [62368, 172969],

 11248     [62369, 135493], [25866, 62371], [20029, 62374], [28381, 62375],

 11249     [40270, 62376], [37343, 62377], [62380, 161589], [20250, 62382],

 11250     [20264, 62383], [20392, 62384], [20852, 62386], [20892, 62387],

 11251     [20964, 62388], [21153, 62389], [21160, 62390], [21307, 62391],

 11252     [21326, 62392], [21457, 62393], [21464, 62394], [22242, 62395],

 11253     [22768, 62396], [22788, 62397], [22791, 62398], [22834, 62399],

 11254     [22836, 62400], [23398, 62401], [23454, 62402], [23455, 62403],

 11255     [23706, 62404], [24198, 62405], [24635, 62406], [25993, 62407],

 11256     [26622, 62408], [26628, 62409], [26725, 62410], [27982, 62411],

 11257     [28860, 62412], [30005, 62413], [32420, 62414], [32428, 62415],

 11258     [32442, 62416], [32455, 62417], [32463, 62418], [32479, 62419],

 11259     [32518, 62420], [32567, 62421], [33402, 62422], [33487, 62423],

 11260     [33647, 62424], [35270, 62425], [35774, 62426], [35810, 62427],

 11261     [36710, 62428], [36711, 62429], [36718, 62430], [29713, 62431],

 11262     [31996, 62432], [32205, 62433], [26950, 62434], [31433, 62435],

 11263     [30904, 62442], [32956, 62444], [36107, 62446], [33014, 62447],

 11264     [62448, 133607], [32927, 62451], [40647, 62452], [19661, 62453],

 11265     [40393, 62454], [40460, 62455], [19518, 62456], [62457, 171510],

 11266     [62458, 159758], [40458, 62459], [62460, 172339], [13761, 62461],

 11267     [28314, 62463], [33342, 62464], [29977, 62465], [18705, 62467],

 11268     [39532, 62468], [39567, 62469], [40857, 62470], [31111, 62471],

 11269     [62472, 164972], [62473, 138698], [62474, 132560], [62475, 142054],

 11270     [20004, 62476], [20096, 62478], [20103, 62479], [20159, 62480],

 11271     [20203, 62481], [20279, 62482], [13388, 62483], [20413, 62484],

 11272     [15944, 62485], [20483, 62486], [13437, 62488], [13477, 62490],

 11273     [22789, 62492], [20955, 62493], [20988, 62494], [20105, 62496],

 11274     [21136, 62498], [21287, 62499], [13767, 62500], [21417, 62501],

 11275     [13649, 62502], [21424, 62503], [21539, 62506], [13677, 62507],

 11276     [13682, 62508], [13953, 62509], [21651, 62510], [21667, 62511],

 11277     [21684, 62512], [21689, 62513], [21712, 62514], [21743, 62515],

 11278     [21784, 62516], [21795, 62517], [21800, 62518], [13720, 62519],

 11279     [13733, 62521], [13759, 62522], [21975, 62523], [13765, 62524],

 11280     [62525, 163204], [16467, 62538], [62551, 135412], [62555, 134155],

 11281     [62574, 161992], [62580, 155813], [62583, 142668], [62585, 135287],

 11282     [62587, 135279], [62595, 139681], [62609, 134550], [16571, 62611],

 11283     [62631, 142537], [22098, 62641], [62642, 134961], [62657, 157724],

 11284     [62659, 135375], [62660, 141315], [62661, 141625], [13819, 62662],

 11285     [62663, 152035], [62664, 134796], [62665, 135053], [62666, 134826],

 11286     [16275, 62667], [62668, 134960], [62669, 134471], [62670, 135503],

 11287     [62671, 134732], [62673, 134827], [62674, 134057], [62675, 134472],

 11288     [62676, 135360], [62677, 135485], [16377, 62678], [62679, 140950],

 11289     [25650, 62680], [62681, 135085], [62682, 144372], [62685, 134526],

 11290     [62686, 134527], [62688, 142421], [62690, 134808], [62692, 134958],

 11291     [62694, 158544], [21708, 62699], [33476, 62700], [21945, 62701],

 11292     [62703, 171715], [39974, 62704], [39606, 62705], [62707, 142830],

 11293     [33004, 62710], [23580, 62711], [62712, 157042], [33076, 62713],

 11294     [14231, 62714], [62716, 164029], [37302, 62717], [62718, 134906],

 11295     [62719, 134671], [62720, 134775], [62721, 134907], [62723, 151019],

 11296     [13833, 62724], [62725, 134358], [22191, 62726], [62727, 141237],

 11297     [62728, 135369], [62729, 134672], [62730, 134776], [62731, 135288],

 11298     [62732, 135496], [62733, 164359], [62734, 136277], [62735, 134777],

 11299     [62736, 151120], [62737, 142756], [23124, 62738], [62739, 135197],

 11300     [62740, 135198], [62741, 135413], [62742, 135414], [22428, 62743],

 11301     [62744, 134673], [62745, 161428], [62746, 164557], [62747, 135093],

 11302     [62748, 134779], [62749, 151934], [14083, 62750], [62751, 135094],

 11303     [62752, 135552], [62753, 152280], [62754, 172733], [62755, 149978],

 11304     [62756, 137274], [62757, 147831], [62758, 164476], [22681, 62759],

 11305     [21096, 62760], [13850, 62761], [62762, 153405], [31666, 62763],

 11306     [23400, 62764], [18432, 62765], [19244, 62766], [40743, 62767],

 11307     [18919, 62768], [39967, 62769], [39821, 62770], [62771, 154484],

 11308     [62772, 143677], [22011, 62773], [13810, 62774], [22153, 62775],

 11309     [23870, 63028], [23880, 63029], [15868, 63031], [14351, 63032],

 11310     [23972, 63033], [23993, 63034], [14368, 63035], [24357, 63039],

 11311     [24451, 63040], [14600, 63041], [14655, 63043], [14669, 63044],

 11312     [24791, 63045], [24893, 63046], [23781, 63047], [14729, 63048],

 11313     [25015, 63049], [25039, 63051], [14776, 63052], [25132, 63053],

 11314     [25317, 63055], [14840, 63057], [22193, 63058], [14851, 63059],

 11315     [25570, 63060], [25595, 63061], [25607, 63062], [14923, 63064],

 11316     [25792, 63065], [40863, 63068], [14999, 63069], [25990, 63070],

 11317     [15037, 63071], [26111, 63072], [26195, 63073], [15090, 63074],

 11318     [26258, 63075], [15138, 63076], [26390, 63077], [15170, 63078],

 11319     [26532, 63079], [15192, 63081], [26698, 63082], [26756, 63083],

 11320     [15218, 63084], [15217, 63085], [15227, 63086], [26889, 63087],

 11321     [26947, 63088], [29276, 63089], [26980, 63090], [27039, 63091],

 11322     [27013, 63092], [27094, 63094], [15325, 63095], [27237, 63096],

 11323     [27252, 63097], [27249, 63098], [27266, 63099], [15340, 63100],

 11324     [27289, 63101], [15346, 63102], [27307, 63103], [27317, 63104],

 11325     [27348, 63105], [27382, 63106], [27521, 63107], [27585, 63108],

 11326     [27626, 63109], [27765, 63110], [27818, 63111], [15563, 63112],

 11327     [27906, 63113], [27910, 63114], [27942, 63115], [28033, 63116],

 11328     [15599, 63117], [28068, 63118], [28081, 63119], [28181, 63120],

 11329     [28184, 63121], [28201, 63122], [28294, 63123], [63124, 166336],

 11330     [28347, 63125], [28386, 63126], [28378, 63127], [40831, 63128],

 11331     [28392, 63129], [28393, 63130], [28452, 63131], [28468, 63132],

 11332     [15686, 63133], [63134, 147265], [28545, 63135], [28606, 63136],

 11333     [15722, 63137], [15733, 63138], [29111, 63139], [23705, 63140],

 11334     [15754, 63141], [28716, 63142], [15761, 63143], [28752, 63144],

 11335     [28756, 63145], [28783, 63146], [28799, 63147], [63149, 131877],

 11336     [17345, 63150], [13809, 63151], [63152, 134872], [13902, 58134],

 11337     [15789, 58172], [58173, 154725], [26237, 58183], [31860, 58188],

 11338     [29837, 58197], [32402, 58215], [17667, 58232], [58260, 151480],

 11339     [58270, 133901], [58277, 158474], [13438, 58311], [58317, 143087],

 11340     [58325, 146613], [58343, 159385], [34673, 58364], [25537, 58385],

 11341     [30583, 58387], [35210, 58390], [58406, 147343], [35660, 58415],

 11342     [58440, 150729], [18730, 58464], [58471, 172052], [58472, 165564],

 11343     [58473, 165121], [15088, 58490], [28815, 58511], [58529, 140922],

 11344     [58637, 158120], [58646, 148043], [26760, 58662], [58664, 139611],

 11345     [40802, 58702], [37830, 58793], [58802, 131967], [37734, 58888],

 11346     [37519, 58901], [34324, 58954], [58986, 173147], [16784, 59010],

 11347     [26511, 59045], [26654, 59048], [14435, 59051], [59077, 149996],

 11348     [15129, 59128], [33942, 59176], [59241, 149858], [14818, 59254],

 11349     [33920, 59259], [17262, 59328], [38769, 59402], [39323, 59427],

 11350     [18733, 59499], [28439, 59703], [59704, 160009], [28838, 59746],

 11351     [59752, 150095], [32357, 59753], [23855, 59755], [15859, 59756],

 11352     [59758, 150109], [59759, 137183], [32164, 59760], [33830, 59761],

 11353     [21637, 59762], [59763, 146170], [59765, 131604], [22398, 59766],

 11354     [59767, 133333], [59768, 132633], [16357, 59769], [59770, 139166],

 11355     [59771, 172726], [28675, 59772], [59773, 168283], [23920, 59774],

 11356     [29583, 59775], [59777, 166489], [59778, 168992], [20424, 59779],

 11357     [32743, 59780], [29456, 59782], [29496, 59784], [29505, 59787],

 11358     [16041, 59789], [29173, 59792], [59793, 149746], [29665, 59794],

 11359     [16074, 59796], [16081, 59798], [29721, 59801], [29726, 59802],

 11360     [29727, 59803], [16098, 59804], [16112, 59805], [16116, 59806],

 11361     [16122, 59807], [29907, 59808], [16142, 59809], [16211, 59810],

 11362     [30061, 59812], [30066, 59813], [30093, 59814], [16252, 59815],

 11363     [30152, 59816], [30285, 59819], [30324, 59821], [16348, 59822],

 11364     [30330, 59823], [29064, 59825], [22051, 59826], [35200, 59827],

 11365     [16413, 59829], [30531, 59830], [16441, 59831], [16453, 59833],

 11366     [13787, 59834], [30616, 59835], [16490, 59836], [16495, 59837],

 11367     [30654, 59839], [30667, 59840], [30744, 59842], [30748, 59844],

 11368     [30791, 59847], [30801, 59848], [30822, 59849], [33864, 59850],

 11369     [59851, 152885], [31027, 59852], [31026, 59854], [16649, 59856],

 11370     [31121, 59857], [31238, 59860], [16743, 59862], [16818, 59864],

 11371     [31420, 59865], [33401, 59866], [16836, 59867], [31439, 59868],

 11372     [31451, 59869], [16847, 59870], [31586, 59872], [31596, 59873],

 11373     [31611, 59874], [31762, 59875], [16992, 59877], [17018, 59878],

 11374     [31867, 59879], [31900, 59880], [17036, 59881], [31928, 59882],

 11375     [17044, 59883], [36755, 59885], [28864, 59886], [59887, 134351],

 11376     [32207, 59888], [32212, 59889], [32208, 59890], [32253, 59891],

 11377     [32692, 59893], [29343, 59894], [17303, 59895], [32800, 59896],

 11378     [32805, 59897], [32814, 59899], [32817, 59900], [32852, 59901],

 11379     [22452, 59903], [28832, 59904], [32951, 59905], [33001, 59906],

 11380     [17389, 59907], [33036, 59908], [33038, 59910], [33042, 59911],

 11381     [33044, 59913], [17409, 59914], [15161, 59915], [33110, 59916],

 11382     [33113, 59917], [33114, 59918], [17427, 59919], [33148, 59921],

 11383     [17445, 59923], [17453, 59925], [33189, 59926], [22511, 59927],

 11384     [33217, 59928], [33252, 59929], [33364, 59930], [17551, 59931],

 11385     [33398, 59933], [33482, 59934], [33496, 59935], [17584, 59937],

 11386     [33623, 59938], [38505, 59939], [33797, 59941], [28917, 59942],

 11387     [33892, 59943], [33928, 59945], [17668, 59946], [33982, 59947],

 11388     [34017, 59948], [34040, 59949], [34064, 59950], [34104, 59951],

 11389     [34130, 59952], [17723, 59953], [34159, 59954], [34160, 59955],

 11390     [34272, 59956], [17783, 59957], [34418, 59958], [34450, 59959],

 11391     [34543, 59961], [38469, 59962], [17926, 59964], [17943, 59965],

 11392     [34990, 59966], [35071, 59967], [35108, 59968], [35217, 59970],

 11393     [59971, 162151], [35384, 59973], [35476, 59974], [35508, 59975],

 11394     [35921, 59976], [36052, 59977], [36082, 59978], [36124, 59979],

 11395     [18328, 59980], [36291, 59982], [18413, 59983], [36410, 59985],

 11396     [22356, 59987], [22005, 59989], [18487, 59991], [36558, 59992],

 11397     [36578, 59993], [36580, 59994], [36589, 59995], [36594, 59996],

 11398     [36801, 59998], [36810, 59999], [36812, 60000], [36915, 60001],

 11399     [18605, 60003], [39136, 60004], [37395, 60005], [18718, 60006],

 11400     [37416, 60007], [37464, 60008], [37483, 60009], [37553, 60010],

 11401     [37550, 60011], [37567, 60012], [37603, 60013], [37611, 60014],

 11402     [37619, 60015], [37620, 60016], [37629, 60017], [37699, 60018],

 11403     [37764, 60019], [37805, 60020], [18757, 60021], [18769, 60022],

 11404     [37911, 60024], [37917, 60026], [37933, 60027], [37950, 60028],

 11405     [18794, 60029], [37972, 60030], [38009, 60031], [38189, 60032],

 11406     [38306, 60033], [18855, 60034], [38388, 60035], [38451, 60036],

 11407     [18917, 60037], [18980, 60039], [38720, 60040], [18997, 60041],

 11408     [38834, 60042], [38850, 60043], [19172, 60045], [39097, 60047],

 11409     [19225, 60048], [39153, 60049], [22596, 60050], [39193, 60052],

 11410     [39223, 60055], [39261, 60057], [39266, 60058], [19312, 60059],

 11411     [39365, 60060], [19357, 60061], [39484, 60062], [39695, 60063],

 11412     [39785, 60065], [39901, 60067], [39921, 60068], [39924, 60069],

 11413     [19565, 60070], [39968, 60071], [14191, 60072], [60073, 138178],

 11414     [40265, 60074], [40702, 60076], [22096, 60077], [40381, 60079],

 11415     [40444, 60081], [38134, 60082], [36790, 60083], [40625, 60086],

 11416     [40637, 60087], [40646, 60088], [38108, 60089], [40674, 60090],

 11417     [40689, 60091], [40696, 60092], [40772, 60094], [60095, 131220],

 11418     [60096, 131767], [60097, 132000], [38083, 60099], [60101, 132311],

 11419     [38081, 60103], [60105, 132565], [60106, 132629], [60107, 132726],

 11420     [60108, 136890], [22359, 60109], [29043, 60110], [60111, 133826],

 11421     [60112, 133837], [60113, 134079], [60115, 194619], [60116, 134091],

 11422     [21662, 60117], [60118, 134139], [60119, 134203], [60120, 134227],

 11423     [60121, 134245], [60122, 134268], [60124, 134285], [60126, 134325],

 11424     [60127, 134365], [60128, 134381], [60129, 134511], [60130, 134578],

 11425     [60131, 134600], [60135, 134660], [60136, 134670], [60137, 134871],

 11426     [60138, 135056], [60139, 134957], [60140, 134771], [60142, 135100],

 11427     [60144, 135260], [60145, 135247], [60146, 135286], [60149, 135304],

 11428     [60150, 135318], [13895, 60151], [60152, 135359], [60154, 135471],

 11429     [60155, 135483], [21348, 60156], [60158, 135907], [60159, 136053],

 11430     [60160, 135990], [60162, 136567], [60163, 136729], [60164, 137155],

 11431     [60165, 137159], [28859, 60167], [60168, 137261], [60169, 137578],

 11432     [60170, 137773], [60171, 137797], [60172, 138282], [60173, 138352],

 11433     [60174, 138412], [60175, 138952], [60177, 138965], [60178, 139029],

 11434     [29080, 60179], [60181, 139333], [27113, 60182], [14024, 60183],

 11435     [60184, 139900], [60185, 140247], [60186, 140282], [60187, 141098],

 11436     [60188, 141425], [60189, 141647], [60191, 141671], [60192, 141715],

 11437     [60193, 142037], [60195, 142056], [60197, 142094], [60199, 142143],

 11438     [60202, 142412], [60204, 142472], [60205, 142519], [60206, 154600],

 11439     [60207, 142600], [60208, 142610], [60209, 142775], [60210, 142741],

 11440     [60211, 142914], [60212, 143220], [60213, 143308], [60214, 143411],

 11441     [60215, 143462], [60216, 144159], [60217, 144350], [60222, 144743],

 11442     [60223, 144883], [60227, 144922], [60228, 145174], [22709, 60231],

 11443     [60234, 146087], [60237, 146961], [60238, 147129], [60243, 147737],

 11444     [60245, 148206], [60246, 148237], [60248, 148276], [60249, 148374],

 11445     [60258, 148484], [60259, 148694], [22408, 60260], [60261, 149108],

 11446     [60263, 149295], [60271, 149522], [60272, 149755], [60273, 150037],

 11447     [60275, 150208], [22885, 60277], [60279, 151430], [60282, 151596],

 11448     [22335, 60284], [60286, 152217], [60287, 152601], [60291, 152646],

 11449     [60292, 152686], [60296, 152895], [60298, 152926], [60300, 152930],

 11450     [60301, 152934], [60302, 153543], [60304, 153693], [60309, 153859],

 11451     [60312, 154286], [60313, 154505], [60314, 154630], [22433, 60316],

 11452     [29009, 60317], [60319, 155906], [60322, 156082], [60325, 156674],

 11453     [60326, 156746], [60330, 156804], [60334, 156808], [60336, 156946],

 11454     [60338, 157119], [60339, 157365], [22201, 60347], [60349, 157436],

 11455     [13848, 60355], [60357, 157593], [60358, 157806], [60360, 157790],

 11456     [60362, 157895], [60366, 157990], [60368, 158009], [60371, 158202],

 11457     [60373, 158253], [60378, 158260], [60379, 158555], [60383, 158621],

 11458     [60385, 158884], [60388, 159150], [60392, 159819], [60393, 160205],

 11459     [60395, 160384], [60396, 160389], [60399, 160395], [60401, 160486],

 11460     [38047, 60404], [60405, 160848], [14009, 60416], [60424, 161740],

 11461     [60425, 161880], [22230, 60426], [60435, 162269], [60441, 162301],

 11462     [60442, 162314], [60443, 162571], [60444, 163174], [60448, 163849],

 11463     [60459, 163875], [60463, 163912], [60466, 163971], [60479, 163984],

 11464     [60480, 164084], [60481, 164142], [60483, 164175], [60485, 164271],

 11465     [60486, 164378], [60487, 164614], [60488, 164655], [60489, 164746],

 11466     [60491, 164968], [60492, 165546], [25574, 60494], [60495, 166230],

 11467     [60498, 166328], [60500, 166375], [60502, 166376], [60503, 166726],

 11468     [60504, 166868], [60506, 166921], [60508, 167877], [60509, 168172],

 11469     [60511, 168208], [60512, 168252], [15863, 60513], [60514, 168286],

 11470     [60515, 150218], [36816, 60516], [60519, 169191], [60521, 169392],

 11471     [60522, 169400], [60523, 169778], [60524, 170193], [60525, 170313],

 11472     [60526, 170346], [60527, 170435], [60528, 170536], [60529, 170766],

 11473     [60530, 171354], [60531, 171419], [32415, 60532], [60533, 171768],

 11474     [60534, 171811], [19620, 60535], [38215, 60536], [60537, 172691],

 11475     [29090, 60538], [60539, 172799], [60542, 173515], [19868, 60543],

 11476     [60544, 134300], [36798, 60545], [36794, 60547], [60548, 140464],

 11477     [36793, 60549], [60550, 150163], [20202, 60555], [60557, 166700],

 11478     [36480, 60560], [60561, 137205], [60563, 166764], [60564, 166809],

 11479     [60566, 157359], [60568, 161365], [60570, 153141], [60571, 153942],

 11480     [20122, 60572], [60573, 155265], [60576, 134765], [60579, 147080],

 11481     [60580, 150686], [60583, 137206], [60584, 137339], [60587, 154698],

 11482     [60589, 152337], [15814, 60590], [60596, 155352], [19996, 60600],

 11483     [60601, 135146], [60602, 134473], [60603, 145082], [60638, 151880],

 11484     [21982, 60644], [34694, 60672], [60676, 135361], [60679, 149254],

 11485     [23440, 60680], [60682, 157843], [60684, 141044], [60685, 163119],

 11486     [60686, 147875], [60687, 163187], [60688, 159440], [60689, 160438],

 11487     [60691, 135641], [60693, 146684], [60694, 173737], [60695, 134828],

 11488     [60698, 138402], [60700, 151490], [60702, 135147], [60706, 142752],

 11489     [60710, 135148], [60711, 134666], [60714, 135149], [60717, 135559],

 11490     [19994, 60721], [19972, 60722], [23309, 60724], [13996, 60727],

 11491     [21373, 60729], [13989, 60730], [22682, 60732], [60733, 150382],

 11492     [22442, 60736], [60737, 154261], [60738, 133497], [60741, 140389],

 11493     [60746, 146686], [60747, 171824], [60749, 151465], [60750, 169374],

 11494     [60753, 146870], [60755, 157619], [60756, 145184], [60759, 147191],

 11495     [60760, 146988], [60785, 143578], [60789, 135849], [22439, 60790],

 11496     [60791, 149859], [60794, 159918], [60801, 137068], [60806, 160100],

 11497     [60809, 159010], [60810, 150242], [39963, 60837], [60838, 149822],

 11498     [15878, 60846], [60881, 159011], [60887, 132092], [60891, 146685],

 11499     [60893, 149785], [22394, 60904], [21722, 60912], [29050, 60928],

 11500     [60949, 150135], [60955, 166490], [60962, 194624], [60976, 137275],

 11501     [61000, 155993], [61014, 144373], [61019, 166850], [61024, 138566],

 11502     [61054, 159441], [13877, 61065], [61084, 166701], [21024, 61088],

 11503     [15384, 61089], [61090, 146631], [61091, 155351], [61092, 161366],

 11504     [61093, 152881], [61094, 137540], [61096, 170243], [61097, 159196],

 11505     [61098, 159917], [61100, 156077], [61101, 166415], [61102, 145015],

 11506     [61103, 131310], [61104, 157766], [61105, 151310], [17762, 61106],

 11507     [23327, 61107], [61108, 156492], [40784, 61109], [40614, 61110],

 11508     [61111, 156267], [20962, 57415], [21314, 57416], [26285, 57520],

 11509     [22620, 57547], [21843, 57566], [15749, 57594], [24928, 57608],

 11510     [18606, 57668], [38845, 57676], [57693, 137335], [24755, 57703],

 11511     [33828, 57711], [38932, 57748], [57749, 147596], [57764, 143486],

 11512     [57787, 138813], [15147, 57798], [15666, 57824], [57857, 132021],

 11513     [28801, 57944], [23708, 57959], [58017, 132547], [14128, 58028],

 11514     [58096, 136054], [58097, 150034], [58111, 166699], [58112, 155779],

 11515     [256, 62233], [193, 62234], [461, 62235], [192, 62236], [274, 62237],

 11516     [201, 62238], [282, 62239], [200, 62240], [332, 62241], [211, 62242],

 11517     [465, 62243], [210, 62244], 62245, [7870, 62246], 62247, [7872, 62248],

 11518     [202, 62249], [257, 62250], [225, 62251], [462, 62252], [224, 62253],

 11519     [593, 62254], [275, 62255], [233, 62256], [283, 62257], [232, 62258],

 11520     [299, 62259], [237, 62260], [464, 62261], [236, 62262], [333, 62263],

 11521     [243, 62264], [466, 62265], [242, 62266], [363, 62267], [250, 62268],

 11522     [468, 62269], [249, 62270], [470, 62271], [472, 62272], [474, 62273],

 11523     [476, 62274], [252, 62275], 62276, [7871, 62277], 62278, [7873, 62279],

 11524     [234, 62280], [609, 62281], [643, 63551], [592, 63552], [603, 63553],

 11525     [596, 63554], [629, 63555], [339, 63556], [248, 63557], [331, 63558],

 11526     [650, 63559], [618, 63560], {f: 2, c: 62282}, [11933, 63530],

 11527     [11974, 63539], [12003, 63547], 20539, 28158, [62841, 171123], 62842,

 11528     [15817, 62843], 34959, [62845, 147790], 28791, 23797, [19232, 62848],

 11529     [62849, 152013], [13657, 62850], [62851, 154928], 24866, [62853, 166450],

 11530     36775, 37366, 29073, 26393, 29626, [62859, 144001], [62860, 172295],

 11531     [15499, 62861], [62862, 137600], [19216, 62863], 30948, 29698, 20910,

 11532     [62867, 165647], [16393, 62868], 27235, [62870, 172730], [16931, 62871],

 11533     34319, 31274, [62875, 170311], [62876, 166634], 38741, 28749, 21284,

 11534     [62880, 139390], 37876, 30425, [62883, 166371], 62884, 30685, 20131, 20464,

 11535     20668, 20015, 20247, 62891, 21556, 32139, 22674, 22736, [62896, 138678],

 11536     24210, 24217, 24514, [62900, 141074], 25995, [62902, 144377], 26905, 27203,

 11537     [62905, 146531], 27903, 29184, [62909, 148741], 29580, [16091, 62911],

 11538     [62912, 150035], 23317, 29881, 35715, [62916, 154788], [62917, 153237],

 11539     31379, 31724, 31939, 32364, 33528, 34199, 62924, 34960, 62926, 36537,

 11540     62928, 36815, 34143, 39392, 37409, 62933, [62934, 167353], [62935, 136255],

 11541     [16497, 62936], [17058, 62937], 23066, 39016, 26475, [17014, 62944], 22333,

 11542     34262, [62948, 149883], 33471, [62950, 160013], [19585, 62951],

 11543     [62952, 159092], 23931, [62954, 158485], [62955, 159678], {f: 2, c: 62956},

 11544     23446, 62959, 32347],

 11545   'Adobe-GB1': [{f: 95, c: 32}, {f: 3, c: 12288}, [183, 12539], 713, 711, 168,

 11546     12291, 12293, 8212, 65374, 8214, [8230, 8943], {f: 2, c: 8216},

 11547     {f: 2, c: 8220}, {f: 2, c: 12308}, {f: 8, c: 12296}, {f: 2, c: 12310},

 11548     {f: 2, c: 12304}, 177, 215, 247, 8758, {f: 2, c: 8743}, 8721, 8719, 8746,

 11549     8745, 8712, 8759, 8730, 8869, 8741, 8736, 8978, 8857, 8747, 8750, 8801,

 11550     8780, 8776, 8765, 8733, 8800, {f: 2, c: 8814}, {f: 2, c: 8804}, 8734, 8757,

 11551     8756, 9794, 9792, 176, {f: 2, c: 8242}, 8451, 65284, 164, {f: 2, c: 65504},

 11552     8240, 167, 8470, 9734, 9733, 9675, 9679, 9678, 9671, 9670, 9633, 9632,

 11553     9651, 9650, 8251, 8594, {f: 2, c: 8592}, 8595, 12307, {f: 20, c: 9352},

 11554     {f: 20, c: 9332}, {f: 10, c: 9312}, {f: 10, c: 12832}, {f: 12, c: 8544},

 11555     {f: 3, c: 65281}, 65509, {f: 89, c: 65285}, 65507, {f: 83, c: 12353},

 11556     {f: 86, c: 12449}, {f: 17, c: 913}, {f: 7, c: 931}, {f: 17, c: 945},

 11557     {f: 7, c: 963}, {f: 7, c: 59277}, {f: 2, c: 65077}, {f: 2, c: 65081},

 11558     {f: 2, c: 65087}, {f: 2, c: 65085}, {f: 4, c: 65089}, {f: 2, c: 59284},

 11559     {f: 2, c: 65083}, {f: 2, c: 65079}, 65073, 59286, {f: 2, c: 65075},

 11560     {f: 6, c: 1040}, 1025, {f: 32, c: 1046}, 1105, {f: 26, c: 1078}, 257, 225,

 11561     462, 224, 275, 233, 283, 232, 299, 237, 464, 236, 333, 243, 466, 242, 363,

 11562     250, 468, 249, 470, 472, 474, 476, 252, 234, 593, 7743, 324, 328, 505, 609,

 11563     {f: 37, c: 12549}, 0, {f: 76, c: 9472}, {s: 126}, 21834, 38463, 22467,

 11564     25384, 21710, 21769, 21696, 30353, 30284, 34108, 30702, 33406, 30861,

 11565     29233, 38552, 38797, 27688, 23433, 20474, 25353, 26263, 23736, 33018,

 11566     26696, 32942, 26114, 30414, 20985, 25942, 29100, 32753, 34948, 20658,

 11567     22885, 25034, 28595, 33453, 25420, 25170, 21485, 21543, 31494,

 11568     [12043, 20843], 30116, 24052, 25300, 36299, 38774, 25226, 32793, 22365,

 11569     38712, 32610, 29240, [12137, 30333], 26575, 30334, 25670, 20336, 36133,

 11570     25308, 31255, 26001, 29677, 25644, 25203, 33324, 39041, 26495, 29256,

 11571     25198, 25292, 20276, 29923, 21322, 21150, 32458, 37030, 24110, 26758,

 11572     27036, 33152, 32465, 26834, 30917, 34444, 38225, 20621, 35876, 33502,

 11573     32990, 21253, 35090, 21093, 34180, 38649, 20445, 22561, 39281, 23453,

 11574     25265, 25253, 26292, 35961, 40077, 29190, 26479, 30865, 24754, 21329,

 11575     21271, 36744, 32972, 36125, 38049, 20493, 29384, 22791, 24811, 28953,

 11576     34987, 22868, 33519, 26412, 31528, 23849, 32503, 29997, 27893, 36454,

 11577     36856, 36924, [12240, 40763], [12112, 27604], 37145, 31508, 24444, 30887,

 11578     34006, 34109, 27605, 27609, 27606, 24065, 24199, 30201, 38381, 25949,

 11579     24330, 24517, 36767, 22721, 33218, 36991, 38491, 38829, 36793, 32534,

 11580     36140, 25153, 20415, 21464, 21342, {f: 2, c: 36776}, 36779, 36941, 26631,

 11581     24426, 33176, 34920, 40150, 24971, 21035, 30250, 24428, 25996, 28626,

 11582     28392, 23486, 25672, 20853, 20912, 26564, 19993, 31177, 39292, 28851,

 11583     30149, 24182, 29627, 33760, 25773, 25320, 38069, 27874, 21338, 21187,

 11584     25615, 38082, 31636, 20271, 24091, 33334, 33046, 33162, 28196, 27850,

 11585     39539, 25429, [12056, 21340], 21754, 34917, 22496, 19981, 24067, 27493,

 11586     31807, 37096, 24598, 25830, 29468, 35009, 26448, 25165, 36130, 30572,

 11587     36393, 37319, 24425, 33756, 34081, 39184, 21442, 34453, 27531, 24813,

 11588     24808, 28799, 33485, 33329, 20179, 27815, 34255, 25805, 31961, 27133,

 11589     26361, 33609, 21397, 31574, 20391, 20876, 27979, 23618, 36461, 25554,

 11590     21449, 33580, 33590, 26597, 30900, 25661, 23519, 23700, 24046, 35815,

 11591     25286, 26612, 35962, 25600, 25530, 34633, 39307, 35863, 32544, 38130,

 11592     20135, 38416, 39076, 26124, 29462, 22330, 23581, 24120, 38271, 20607,

 11593     32928, [12058, 21378], 25950, 30021, 21809, 20513, 36229, 25220, 38046,

 11594     26397, 22066, 28526, 24034, 21557, 28818, 36710, 25199, 25764, 25507,

 11595     24443, 28552, 37108, [12162, 33251], [12192, 36784], 23576, 26216, 24561,

 11596     27785, 38472, 36225, 34924, 25745, 31216, 22478, 27225, 25104, 21576,

 11597     20056, 31243, 24809, 28548, 35802, 25215, 36894, 39563, 31204, 21507,

 11598     30196, 25345, 21273, 27744, 36831, 24347, 39536, 32827, 40831, 20360,

 11599     23610, [12186, 36196], 32709, 26021, 28861, 20805, 20914, [12173, 34411],

 11600     23815, 23456, 25277, 37228, 30068, 36364, 31264, 24833, 31609, 20167,

 11601     32504, 30597, 19985, 33261, 21021, 20986, 27249, 21416, 36487, 38148,

 11602     38607, 28353, 38500, 26970, 30784, 20648, 30679, 25616, 35302, 22788,

 11603     25571, 24029, 31359, 26941, 20256, 33337, 21912, 20018, 30126, 31383,

 11604     24162, 24202, 38383, 21019, 21561, 28810, 25462, 38180, 22402, 26149,

 11605     26943, 37255, 21767, 28147, 32431, 34850, 25139, 32496, 30133, 33576,

 11606     30913, 38604, 36766, 24904, 29943, 35789, 27492, 21050, 36176, 27425,

 11607     32874, 33905, 22257, 21254, 20174, 19995, 20945, 31895, 37259, 31751,

 11608     20419, 36479, 31713, 31388, 25703, 23828, 20652, 33030, 30209, 31929,

 11609     28140, 32736, 26449, 23384, [12072, 23544], 30923, 25774, 25619, 25514,

 11610     25387, 38169, 25645, 36798, 31572, 30249, 25171, [12068, 22823], 21574,

 11611     [12109, 27513], 20643, 25140, 24102, 27526, 20195, 36151, 34955, 24453,

 11612     36910, 24608, 32829, 25285, 20025, 21333, 37112, 25528, 32966, 26086,

 11613     27694, 20294, 24814, 28129, 35806, 24377, 34507, 24403, 25377, 20826,

 11614     33633, 26723, [12049, 20992], 25443, 36424, 20498, 23707, 31095, 23548,

 11615     21040, 31291, 24764, 36947, 30423, 24503, 24471, 30340, 36460, 28783,

 11616     30331, 31561, 30634, 20979, 37011, 22564, 20302, 28404, 36842, 25932,

 11617     31515, 29380, 28068, 32735, 23265, 25269, 24213, 22320, 33922, 31532,

 11618     24093, 24351, 36882, 32532, 39072, 25474, 28359, 30872, 28857, 20856,

 11619     38747, 22443, 30005, 20291, 30008, 24215, 24806, 22880, 28096, 27583,

 11620     30857, 21500, 38613, 20939, 20993, 25481, 21514, 38035, 35843, 36300,

 11621     29241, 30879, 34678, 36845, 35853, 21472, 19969, 30447, 21486, 38025,

 11622     39030, [12237, 40718], 38189, 23450, 35746, 20002, 19996, 20908, 33891,

 11623     25026, 21160, 26635, 20375, 24683, 20923, 27934, 20828, 25238,

 11624     [12099, 26007], 38497, [12182, 35910], 36887, 30168, 37117, 30563, 27602,

 11625     29322, 29420, 35835, 22581, 30585, 36172, 26460, 38208, 32922, 24230,

 11626     28193, 22930, 31471, 30701, 38203, 27573, 26029, 32526, 22534, 20817,

 11627     38431, 23545, 22697, 21544, 36466, 25958, 39039, 22244, 38045, 30462,

 11628     36929, 25479, 21702, 22810, 22842, 22427, 36530, 26421, 36346, 33333,

 11629     21057, 24816, 22549, 34558, 23784, 40517, 20420, 39069, 35769, 23077,

 11630     24694, 21380, 25212, 36943, 37122, 39295, 24681, [12157, 32780],

 11631     [12041, 20799], [12159, 32819], 23572, 39285, 27953, [12038, 20108], 36144,

 11632     21457, 32602, 31567, 20240, 20047, 38400, 27861, 29648, 34281, 24070,

 11633     30058, 32763, 27146, 30718, 38034, 32321, 20961, 28902, 21453, 36820,

 11634     33539, 36137, 29359, 39277, 27867, 22346, 33459, [12101, 26041], 32938,

 11635     25151, 38450, 22952, 20223, 35775, 32442, 25918, 33778, [12206, 38750],

 11636     21857, 39134, 32933, 21290, 35837, 21536, 32954, 24223, 27832, 36153,

 11637     33452, 37210, 21545, 27675, 20998, 32439, 22367, 28954, 27774, 31881,

 11638     22859, 20221, 24575, 24868, 31914, 20016, 23553, 26539, 34562, 23792,

 11639     38155, 39118, 30127, 28925, 36898, 20911, 32541, 35773, 22857, 20964,

 11640     20315, 21542, 22827, 25975, 32932, 23413, 25206, 25282, 36752, 24133,

 11641     27679, 31526, 20239, 20440, 26381, 28014, 28074, 31119, 34993, 24343,

 11642     29995, 25242, 36741, 20463, 37340, 26023, 33071, 33105, 24220, 33104,

 11643     36212, 21103, 35206, 36171, 22797, 20613, 20184, [12201, 38428],

 11644     [12119, 29238], 33145, 36127, 23500, 35747, 38468, 22919, 32538, 21648,

 11645     22134, 22030, 35813, 25913, 27010, 38041, 30422, 28297, [12082, 24178],

 11646     [12130, 29976], 26438, 26577, 31487, 32925, 36214, 24863, 31174, 25954,

 11647     36195, 20872, 21018, 38050, 32568, 32923, 32434, 23703, 28207, 26464,

 11648     31705, 30347, [12220, 39640], 33167, 32660, 31957, 25630, 38224, 31295,

 11649     21578, 21733, 27468, 25601, [12093, 25096], 40509, 33011, 30105, 21106,

 11650     [12208, 38761], 33883, 26684, 34532, 38401, 38548, 38124, 20010, 21508,

 11651     32473, 26681, 36319, 32789, 26356, 24218, 32697, 22466, 32831, 26775,

 11652     [12079, 24037], 25915, 21151, 24685, 40858, 20379, 36524, 20844, 23467,

 11653     [12088, 24339], 24041, 27742, 25329, 36129, 20849, 38057, 21246, 27807,

 11654     33503, 29399, 22434, 26500, 36141, 22815, 36764, 33735, 21653, 31629,

 11655     20272, 27837, 23396, 22993, [12238, 40723], 21476, 34506, [12219, 39592],

 11656     [12181, 35895], 32929, 25925, 39038, 22266, 38599, 21038, [12128, 29916],

 11657     21072, 23521, 25346, 35074, 20054, 25296, 24618, 26874, 20851, 23448,

 11658     20896, 35266, 31649, 39302, 32592, 24815, 28748, 36143, 20809,

 11659     [12084, 24191], 36891, 29808, 35268, 22317, 30789, 24402, 40863, 38394,

 11660     36712, [12225, 39740], 35809, 30328, 26690, 26588, 36330, 36149, 21053,

 11661     36746, 28378, 26829, 38149, 37101, 22269, 26524, 35065, 36807, 21704,

 11662     39608, 23401, 28023, 27686, 20133, 23475, 39559, 37219, 25000, 37039,

 11663     38889, 21547, 28085, 23506, 20989, 21898, 32597, 32752, 25788, 25421,

 11664     26097, 25022, 24717, 28938, 27735, 27721, 22831, 26477, 33322, 22741,

 11665     22158, 35946, 27627, 37085, 22909, 32791, 21495, 28009, 21621, 21917,

 11666     33655, 33743, 26680, [12146, 31166], 21644, 20309, 21512, 30418, 35977,

 11667     38402, 27827, 28088, 36203, 35088, 40548, 36154, 22079, [12234, 40657],

 11668     30165, 24456, 29408, 24680, 21756, 20136, 27178, 34913, 24658, 36720,

 11669     21700, 28888, 34425, 40511, 27946, 23439, 24344, 32418, 21897, 20399,

 11670     29492, 21564, 21402, 20505, 21518, 21628, 20046, 24573, 29786, 22774,

 11671     33899, 32993, 34676, 29392, 31946, 28246, 24359, 34382, 21804, 25252,

 11672     20114, 27818, 25143, 33457, 21719, 21326, 29502, 28369, 30011, 21010,

 11673     21270, 35805, 27088, 24458, 24576, 28142, 22351, 27426, 29615, 26707,

 11674     36824, 32531, 25442, 24739, 21796, 30186, 35938, 28949, 28067, 23462,

 11675     24187, 33618, 24908, 40644, 30970, 34647, 31783, 30343, 20976, 24822,

 11676     29004, 26179, 24140, 24653, 35854, 28784, 25381, 36745, 24509, 24674,

 11677     34516, 22238, 27585, 24724, 24935, 21321, 24800, 26214, 36159, 31229,

 11678     20250, 28905, 27719, 35763, 35826, 32472, 33636, 26127, 23130, 39746,

 11679     27985, 28151, 35905, 27963, 20249, [12117, 28779], 33719, 25110, 24785,

 11680     38669, 36135, 31096, 20987, 22334, 22522, 26426, 30072, 31293, 31215,

 11681     31637, 32908, 39269, 36857, 28608, 35749, 40481, 23020, 32489, 32521,

 11682     21513, 26497, 26840, 36753, 31821, 38598, 21450, 24613, 30142, 27762,

 11683     21363, 23241, 32423, 25380, [12047, 20960], 33034, [12080, 24049], 34015,

 11684     25216, 20864, 23395, 20238, 31085, 21058, 24760, 27982, 23492, 23490,

 11685     35745, 35760, 26082, 24524, 38469, 22931, 32487, 32426, 22025, 26551,

 11686     22841, 20339, 23478, 21152, 33626, 39050, 36158, 30002, 38078, 20551,

 11687     31292, 20215, 26550, 39550, 23233, 27516, 30417, 22362, 23574, 31546,

 11688     38388, 29006, 20860, 32937, 33392, 22904, 32516, 33575, 26816, 26604,

 11689     30897, 30839, 25315, 25441, 31616, 20461, 21098, 20943, 33616, 27099,

 11690     37492, 36341, 36145, 35265, 38190, 31661, 20214, 20581, 33328, 21073,

 11691     39279, 28176, 28293, 28071, 24314, 20725, 23004, 23558, 27974, 27743,

 11692     30086, 33931, 26728, 22870, 35762, 21280, 37233, 38477, 34121, 26898,

 11693     30977, 28966, 33014, 20132, 37066, 27975, 39556, 23047, 22204, 25605,

 11694     38128, 30699, 20389, 33050, 29409, [12179, 35282], 39290, 32564, 32478,

 11695     21119, 25945, 37237, 36735, 36739, 21483, 31382, 25581, 25509, 30342,

 11696     31224, 34903, 38454, 25130, 21163, 33410, 26708, 26480, 25463, 30571,

 11697     31469, 27905, 32467, 35299, 22992, 25106, 34249, 33445, 30028, 20511,

 11698     20171, 30117, 35819, 23626, [12081, 24062], 31563, [12100, 26020],

 11699     [12198, 37329], 20170, 27941, 35167, 32039, 38182, 20165, 35880, 36827,

 11700     38771, 26187, 31105, 36817, 28908, 28024, 23613, 21170, 33606, 20834,

 11701     33550, 30555, 26230, 40120, 20140, 24778, 31934, 31923, 32463, 20117,

 11702     35686, 26223, 39048, 38745, 22659, 25964, 38236, 24452, 30153, 38742,

 11703     31455, 31454, 20928, 28847, 31384, 25578, 31350, 32416, 29590,

 11704     [12210, 38893], 20037, 28792, 20061, 37202, 21417, 25937, 26087,

 11705     [12165, 33276], 33285, 21646, 23601, 30106, 38816, 25304, 29401, 30141,

 11706     23621, 39545, 33738, 23616, 21632, 30697, 20030, 27822, 32858, 25298,

 11707     25454, 24040, 20855, 36317, 36382, 38191, 20465, 21477, 24807, 28844,

 11708     21095, 25424, 40515, 23071, 20518, 30519, 21367, 32482, 25733, 25899,

 11709     25225, 25496, 20500, 29237, 35273, 20915, 35776, 32477, 22343, 33740,

 11710     38055, 20891, 21531, 23803, 20426, 31459, 27994, 37089, 39567, 21888,

 11711     21654, 21345, 21679, 24320, 25577, 26999, 20975, 24936, 21002, 22570,

 11712     21208, 22350, 30733, 30475, 24247, 24951, 31968, 25179, 25239, 20130,

 11713     28821, 32771, 25335, 28900, 38752, 22391, 33499, 26607, 26869, 30933,

 11714     39063, 31185, 22771, 21683, 21487, 28212, 20811, 21051, 23458, 35838,

 11715     32943, 21827, 22438, 24691, 22353, 21549, 31354, 24656, 23380, 25511,

 11716     25248, [12061, 21475], 25187, 23495, 26543, 21741, 31391, 33510, 37239,

 11717     24211, 35044, 22840, 22446, 25358, 36328, 33007, 22359, 31607, 20393,

 11718     24555, 23485, 27454, 21281, 31568, 29378, 26694, 30719, 30518, 26103,

 11719     20917, 20111, 30420, 23743, 31397, 33909, 22862, 39745, 20608, 39304,

 11720     24871, 28291, 22372, 26118, 25414, 22256, 25324, 25193, 24275, 38420,

 11721     22403, 25289, 21895, 34593, 33098, 36771, 21862, 33713, 26469, 36182,

 11722     34013, 23146, 26639, 25318, 31726, 38417, 20848, 28572, 35888, 25597,

 11723     35272, 25042, 32518, 28866, 28389, 29701, 27028, 29436, 24266, 37070,

 11724     26391, 28010, 25438, 21171, 29282, [12156, 32769], 20332, 23013, 37226,

 11725     28889, 28061, 21202, 20048, 38647, 38253, 34174, 30922, 32047, 20769,

 11726     22418, 25794, 32907, 31867, 27882, 26865, 26974, 20919, 21400, 26792,

 11727     29313, 40654, 31729, 29432, 31163, 28435, 29702, 26446, [12197, 37324],

 11728     40100, 31036, 33673, 33620, 21519, 26647, 20029, 21385, 21169, 30782,

 11729     21382, 21033, 20616, 20363, 20432, 30178, [12148, 31435], 31890, 27813,

 11730     [12202, 38582], [12050, 21147], 29827, 21737, 20457, 32852, 33714, 36830,

 11731     38256, 24265, 24604, 28063, 24088, 25947, 33080, 38142, 24651, 28860,

 11732     32451, 31918, 20937, 26753, 31921, 33391, 20004, 36742, 37327, 26238,

 11733     20142, 35845, 25769, 32842, 20698, 30103, 29134, 23525, 36797, 28518,

 11734     20102, 25730, 38243, 24278, 26009, 21015, 35010, 28872, 21155, 29454,

 11735     29747, 26519, 30967, 38678, 20020, 37051, 40158, 28107, 20955, 36161,

 11736     21533, 25294, 29618, 33777, 38646, 40836, 38083, 20278, 32666, 20940,

 11737     28789, 38517, 23725, 39046, 21478, 20196, 28316, 29705, 27060, 30827,

 11738     39311, 30041, 21016, 30244, 27969, 26611, 20845, 40857, 32843, 21657,

 11739     31548, 31423, 38534, 22404, 25314, 38471, 27004, 23044, 25602, 31699,

 11740     28431, 38475, 33446, 21346, 39045, 24208, 28809, 25523, 21348, 34383,

 11741     40065, 40595, 30860, 38706, 36335, 36162, [12229, 40575], 28510, 31108,

 11742     24405, 38470, 25134, 39540, 21525, 38109, 20387, 26053, 23653, 23649,

 11743     32533, 34385, 27695, 24459, 29575, 28388, 32511, 23782, 25371, 23402,

 11744     28390, 21365, 20081, 25504, 30053, 25249, 36718, 20262, 20177, 27814,

 11745     32438, 35770, 33821, 34746, 32599, 36923, 38179, 31657, 39585, 35064,

 11746     33853, 27931, 39558, 32476, 22920, [12231, 40635], 29595, 30721, 34434,

 11747     39532, 39554, 22043, 21527, 22475, 20080, 40614, 21334, 36808, 33033,

 11748     30610, 39314, 34542, 28385, 34067, 26364, 24930, 28459, 35881, 33426,

 11749     33579, 30450, 27667, 24537, 33725, 29483, 33541, 38170, [12113, 27611],

 11750     [12141, 30683], 38086, 21359, 33538, 20882, 24125, 35980, 36152, 20040,

 11751     29611, 26522, 26757, 37238, 38665, 29028, 27809, 30473, 23186, 38209,

 11752     27599, 32654, 26151, 23504, 22969, 23194, 38376, 38391, 20204, 33804,

 11753     33945, 27308, 30431, 38192, 29467, 26790, 23391, 30511, 37274, 38753,

 11754     31964, 36855, 35868, 24357, [12150, 31859], 31192, 35269, 27852, 34588,

 11755     23494, 24130, 26825, 30496, 32501, 20885, 20813, 21193, 23081, 32517,

 11756     [12207, 38754], 33495, 25551, 30596, 34256, 31186, 28218, 24217, 22937,

 11757     34065, 28781, 27665, 25279, [12139, 30399], 25935, 24751, 38397, 26126,

 11758     34719, 40483, 38125, 21517, 21629, 35884, {f: 2, c: 25720}, 34321, 27169,

 11759     33180, 30952, 25705, 39764, 25273, 26411, 33707, 22696, 40664, 27819,

 11760     28448, 23518, 38476, 35851, 29279, 26576, 25287, 29281, 20137, 22982,

 11761     27597, 22675, 26286, 24149, 21215, 24917, [12106, 26408], [12140, 30446],

 11762     30566, 29287, 31302, 25343, 21738, 21584, 38048, 37027, 23068, 32435,

 11763     27670, 20035, 22902, 32784, 22856, 21335, 30007, 38590, 22218, 25376,

 11764     33041, 24700, 38393, 28118, 21602, 39297, 20869, 23273, 33021, 22958,

 11765     38675, 20522, 27877, 23612, 25311, 20320, 21311, 33147, 36870, 28346,

 11766     34091, 25288, 24180, 30910, 25781, 25467, 24565, 23064, 37247, 40479,

 11767     23615, 25423, 32834, 23421, 21870, 38218, 38221, 28037, 24744, 26592,

 11768     29406, 20957, 23425, 25319, 27870, [12124, 29275], 25197, 38062, 32445,

 11769     33043, 27987, 20892, 24324, 22900, 21162, 24594, [12069, 22899], 26262,

 11770     34384, 30111, 25386, 25062, 31983, 35834, 21734, 27431, 40485, 27572,

 11771     34261, 21589, 20598, 27812, 21866, 36276, 29228, 24085, 24597, 29750,

 11772     25293, 25490, 29260, 24472, 28227, 27966, 25856, 28504, 30424, 30928,

 11773     30460, 30036, 21028, 21467, 20051, 24222, 26049, 32810, 32982, 25243,

 11774     21638, 21032, 28846, 34957, 36305, 27873, 21624, 32986, 22521, 35060,

 11775     36180, 38506, 37197, 20329, 27803, 21943, 30406, 30768, 25256, 28921,

 11776     28558, 24429, 34028, 26842, 30844, 31735, 33192, 26379, 40527, 25447,

 11777     30896, 22383, 30738, 38713, 25209, 25259, 21128, 29749, 27607, 21860,

 11778     33086, 30130, [12138, 30382], 21305, 30174, 20731, 23617, 35692, 31687,

 11779     20559, [12122, 29255], 39575, 39128, 28418, 29922, 31080, 25735, 30629,

 11780     25340, 39057, 36139, 21697, 32856, 20050, 22378, 33529, 33805, 24179,

 11781     20973, 29942, 35780, 23631, 22369, 27900, 39047, 23110, 30772, 39748,

 11782     36843, 31893, 21078, 25169, 38138, 20166, 33670, 33889, 33769, 33970,

 11783     22484, 26420, 22275, 26222, 28006, 35889, 26333, 28689, 26399, 27450,

 11784     26646, 25114, 22971, 19971, 20932, 28422, 26578, 27791, 20854, 26827,

 11785     22855, 27495, 30054, 23822, 33040, 40784, 26071, 31048, 31041, 39569,

 11786     36215, 23682, 20062, 20225, 21551, 22865, 30732, 22120, [12115, 27668],

 11787     36804, 24323, 27773, 27875, 35755, 25488, 24688, 27965, 29301, 25190,

 11788     38030, 38085, 21315, 36801, 31614, 20191, 35878, 20094, 40660, 38065,

 11789     38067, 21069, 28508, 36963, 27973, 35892, 22545, 23884, [12107, 27424],

 11790     27465, 26538, 21595, 33108, 32652, 22681, 34103, 24378, 25250, 27207,

 11791     38201, 25970, 24708, 26725, 30631, 20052, 20392, 24039, 38808, 25772,

 11792     32728, 23789, 20431, 31373, 20999, 33540, 19988, 24623, 31363, 38054,

 11793     20405, 20146, 31206, 29748, 21220, 33465, 25810, 31165, 23517, 27777,

 11794     38738, 36731, 27682, 20542, 21375, 28165, 25806, 26228, 27696, 24773,

 11795     39031, 35831, 24198, 29756, 31351, 31179, 19992, 37041, 29699, 27714,

 11796     22234, 37195, 27845, 36235, 21306, 34502, 26354, 36527, 23624, 39537,

 11797     28192, 21462, 23094, 40843, 36259, 21435, 22280, 39079, 26435, 37275,

 11798     27849, 20840, 30154, 25331, [12125, 29356], 21048, 21149, 32570, 28820,

 11799     30264, 21364, 40522, 27063, 30830, 38592, 35033, 32676, 28982, 29123,

 11800     20873, 26579, 29924, 22756, 25880, 22199, 35753, 39286, 25200, 32469,

 11801     24825, 28909, 22764, 20161, [12040, 20154], 24525, 38887, 20219, 35748,

 11802     20995, 22922, 32427, 25172, 20173, [12103, 26085], 25102, 33592, 33993,

 11803     33635, 34701, 29076, 28342, 23481, 32466, 20887, 25545, 26580,

 11804     [12161, 32905], 33593, 34837, 20754, 23418, 22914, 36785, 20083, 27741,

 11805     [12042, 20837], 35109, 36719, 38446, 34122, 29790, 38160, 38384, 28070,

 11806     33509, 24369, 25746, 27922, 33832, 33134, 40131, 22622, 36187, 19977,

 11807     21441, 20254, 25955, 26705, 21971, 20007, 25620, 39578, 25195, 23234,

 11808     29791, [12170, 33394], 28073, 26862, 20711, 33678, 30722, 26432, 21049,

 11809     27801, 32433, 20667, 21861, 29022, 31579, 26194, 29642, 33515, 26441,

 11810     [12077, 23665], 21024, 29053, 34923, 38378, 38485, 25797, 36193, 33203,

 11811     21892, 27733, 25159, 32558, 22674, 20260, 21830, 36175, 26188, 19978,

 11812     23578, 35059, 26786, 25422, 31245, 28903, 33421, 21242, 38902, 23569,

 11813     21736, 37045, 32461, 22882, 36170, 34503, [12166, 33292], 33293, 36198,

 11814     25668, 23556, 24913, 28041, 31038, 35774, 30775, 30003, 21627, 20280,

 11815     [12189, 36523], 28145, 23072, 32453, 31070, 27784, 23457, 23158, 29978,

 11816     32958, 24910, 28183, 22768, [12131, 29983], 29989, 29298, 21319, 32499,

 11817     30465, 30427, 21097, 32988, 22307, 24072, 22833, 29422, 26045, 28287,

 11818     35799, [12075, 23608], 34417, [12055, 21313], [12143, 30707], 25342, 26102,

 11819     20160, [12215, 39135], 34432, 23454, 35782, 21490, [12142, 30690], 20351,

 11820     23630, 39542, 22987, 24335, [12144, 31034], [12064, 22763], 19990, 26623,

 11821     20107, 25325, 35475, 36893, 21183, 26159, 21980, 22124, 36866, 20181,

 11822     20365, 37322, 39280, [12114, 27663], 24066, 24643, 23460, 35270, 35797,

 11823     25910, [12095, 25163], [12216, 39318], 23432, 23551, 25480, 21806, 21463,

 11824     30246, 20861, 34092, 26530, 26803, 27530, 25234, 36755, 21460, 33298,

 11825     28113, 30095, 20070, 36174, 23408, 29087, 34223, 26257, 26329, 32626,

 11826     34560, [12233, 40653], [12239, 40736], 23646, 26415, 36848, 26641, 26463,

 11827     25101, 31446, 22661, 24246, 25968, 28465, 24661, 21047, 32781, 25684,

 11828     34928, 29993, 24069, 26643, 25332, 38684, 21452, 29245, 35841,

 11829     [12116, 27700], 30561, 31246, 21550, 30636, 39034, 33308, 35828, 30805,

 11830     26388, 28865, 26031, 25749, 22070, 24605, 31169, 21496, 19997, 27515,

 11831     32902, 23546, 21987, 22235, 20282, 20284, 39282, 24051, 26494, 32824,

 11832     24578, 39042, 36865, 23435, 35772, 35829, 25628, 33368, 25822, 22013,

 11833     33487, 37221, 20439, 32032, 36895, 31903, 20723, 22609, 28335, 23487,

 11834     35785, 32899, 37240, 33948, 31639, 34429, 38539, 38543, 32485, 39635,

 11835     30862, 23681, 31319, 36930, 38567, 31071, 23385, 25439, 31499, 34001,

 11836     26797, 21766, 32553, 29712, 32034, 38145, 25152, 22604, 20182, 23427,

 11837     22905, 22612, 29549, 25374, 36427, 36367, 32974, 33492, 25260, 21488,

 11838     27888, 37214, 22826, 24577, 27760, 22349, 25674, 36138, 30251, 28393,

 11839     22363, 27264, 30192, 28525, 35885, 35848, 22374, 27631, 34962, 30899,

 11840     25506, 21497, 28845, 27748, 22616, 25642, 22530, 26848, 33179, 21776,

 11841     31958, 20504, 36538, 28108, 36255, 28907, 25487, 28059, 28372, 32486,

 11842     33796, 26691, 36867, 28120, 38518, 35752, 22871, 29305, 34276, 33150,

 11843     30140, 35466, 26799, 21076, 36386, 38161, 25552, 39064, 36420, 21884,

 11844     20307, 26367, 22159, 24789, 28053, 21059, 23625, 22825, 28155, 22635,

 11845     [12133, 30000], 29980, 24684, 33300, 33094, 25361, 26465, 36834, 30522,

 11846     36339, 36148, 38081, 24086, 21381, 21548, 28867, 27712, 24311, 20572,

 11847     20141, 24237, 25402, 33351, 36890, 26704, 37230, 30643, 21516, 38108,

 11848     24420, 31461, 26742, 25413, 31570, 32479, 30171, 20599, 25237, 22836,

 11849     36879, 20984, 31171, 31361, 22270, 24466, 36884, 28034, 23648,

 11850     [12063, 22303], 21520, 20820, 28237, 22242, 25512, 39059, 33151, 34581,

 11851     35114, 36864, 21534, 23663, 33216, 25302, 25176, 33073, 40501, 38464,

 11852     39534, 39548, 26925, 22949, 25299, 21822, 25366, 21703, 34521, 27964,

 11853     23043, [12129, 29926], 34972, 27498, 22806, 35916, 24367, 28286, 29609,

 11854     39037, 20024, 28919, 23436, 30871, 25405, 26202, 30358, 24779, 23451,

 11855     23113, 19975, 33109, 27754, 29579, 20129, 26505, [12153, 32593], 24448,

 11856     26106, 26395, 24536, 22916, 23041, 24013, 24494, 21361, 38886, 36829,

 11857     26693, 22260, 21807, 24799, 20026, 28493, 32500, 33479, 33806, 22996,

 11858     20255, 20266, 23614, 32428, 26410, 34074, 21619, 30031, 32963, 21890,

 11859     39759, 20301, 28205, 35859, 23561, 24944, 21355, 30239, 28201, 34442,

 11860     [12098, 25991], 38395, 32441, 21563, 31283, 32010, 38382, 21985, 32705,

 11861     29934, 25373, 34583, 28065, 31389, 25105, 26017, 21351, 25569, 27779,

 11862     24043, 21596, 38056, 20044, 27745, 35820, 23627, [12102, 26080], 33436,

 11863     26791, 21566, 21556, [12111, 27595], 27494, 20116, 25410, 21320, 33310,

 11864     20237, 20398, 22366, 25098, 38654, 26212, 29289, 21247, 21153, 24735,

 11865     35823, 26132, 29081, 26512, 35199, 30802, 30717, 26224, 22075, 21560,

 11866     38177, 29306, 31232, 24687, 24076, 24713, 33181, [12067, 22805], 24796,

 11867     29060, 28911, 28330, 27728, 29312, 27268, 34989, 24109, 20064, 23219,

 11868     21916, 38115, 27927, 31995, 38553, 25103, 32454, 30606, 34430, 21283,

 11869     38686, 36758, 26247, 23777, 20384, 29421, 19979, 21414, 22799, 21523,

 11870     25472, 38184, 20808, 20185, 40092, 32420, 21688, 36132, 34900, 33335,

 11871     38386, 28046, 24358, 23244, 26174, 38505, 29616, 29486, 21439, 33146,

 11872     39301, 32673, 23466, 38519, 38480, 32447, 30456, 21410, 38262,

 11873     [12217, 39321], 31665, 35140, 28248, 20065, 32724, 31077, 35814, 24819,

 11874     21709, 20139, 39033, 24055, 27233, 20687, 21521, 35937, 33831, 30813,

 11875     38660, 21066, 21742, 22179, 38144, 28040, 23477, 28102, 26195,

 11876     [12073, 23567], 23389, 26657, 32918, 21880, 31505, 25928, 26964, 20123,

 11877     27463, 34638, 38795, 21327, 25375, 25658, 37034, 26012, 32961, 35856,

 11878     20889, 26800, 21368, 34809, 25032, 27844, 27899, 35874, 23633, 34218,

 11879     33455, 38156, 27427, [12191, 36763], 26032, 24571, [12092, 24515], 20449,

 11880     34885, 26143, 33125, 29481, 24826, 20852, 21009, 22411, 24418, 37026,

 11881     [12175, 34892], 37266, 24184, 26447, 24615, 22995, 20804, 20982, 33016,

 11882     21256, 27769, 38596, 29066, 20241, 20462, 32670, 26429, 21957, 38152,

 11883     31168, 34966, 32483, 22687, 25100, 38656, 34394, 22040, 39035, 24464,

 11884     35768, 33988, 37207, 21465, 26093, 24207, 30044, 24676, 32110, 23167,

 11885     32490, 32493, 36713, 21927, 23459, 24748, 26059, [12126, 29572], 36873,

 11886     30307, 30505, 32474, 38772, 34203, 23398, [12147, 31348], 38634,

 11887     [12174, 34880], 21195, 29071, 24490, 26092, 35810, 23547, 39535, 24033,

 11888     27529, 27739, 35757, 35759, 36874, 36805, 21387, 25276, 40486, 40493,

 11889     21568, 20011, 33469, [12123, 29273], 34460, 23830, 34905, 28079, 38597,

 11890     21713, 20122, 35766, 28937, 21693, 38409, 28895, 28153, 30416, 20005,

 11891     30740, 34578, 23721, 24310, [12180, 35328], 39068, 38414, 28814, 27839,

 11892     22852, 25513, 30524, 34893, 28436, 33395, 22576, 29141, 21388, 30746,

 11893     38593, 21761, 24422, 28976, 23476, 35866, 39564, 27523, 22830, 40495,

 11894     31207, 26472, 25196, 20335, 30113, [12154, 32650], 27915, 38451, 27687,

 11895     20208, 30162, 20859, 26679, 28478, 36992, 33136, 22934, 29814, 25671,

 11896     23591, 36965, 31377, 35875, 23002, 21676, 33280, 33647, 35201, 32768,

 11897     26928, 22094, 32822, 29239, 37326, 20918, 20063, 39029, 25494, 19994,

 11898     21494, 26355, 33099, 22812, 28082, [12032, 19968], 22777, 21307, 25558,

 11899     38129, 20381, 20234, [12176, 34915], 39056, 22839, 36951, 31227, 20202,

 11900     33008, 30097, 27778, 23452, 23016, 24413, 26885, 34433, 20506, 24050,

 11901     [12036, 20057], 30691, 20197, 33402, 25233, 26131, [12194, 37009], 23673,

 11902     20159, 24441, 33222, 36920, 32900, 30123, 20134, 35028, 24847, 27589,

 11903     24518, 20041, 30410, 28322, 35811, 35758, 35850, 35793, 24322, 32764,

 11904     32716, 32462, 33589, 33643, 22240, 27575, [12211, 38899], 38452, 23035,

 11905     21535, 38134, 28139, 23493, 39278, 23609, 24341, 38544, 21360, 33521,

 11906     27185, 23156, 40560, 24212, 32552, 33721, {f: 2, c: 33828}, 33639, 34631,

 11907     36814, 36194, 30408, 24433, 39062, 30828, 26144, 21727, 25317, 20323,

 11908     33219, 30152, 24248, 38605, 36362, 34553, 21647, 27891, 28044, 27704,

 11909     24703, 21191, [12132, 29992], 24189, 20248, 24736, 24551, 23588, 30001,

 11910     37038, 38080, 29369, 27833, 28216, [12195, 37193], 26377, 21451, 21491,

 11911     20305, 37321, 35825, [12060, 21448], 24188, 36802, 28132, 20110, 30402,

 11912     27014, 34398, 24858, 33286, 20313, 20446, 36926, 40060, 24841, 28189,

 11913     28180, 38533, 20104, 23089, [12204, 38632], 19982, 23679, 31161, 23431,

 11914     35821, [12155, 32701], [12127, 29577], 22495, 33419, 37057, 21505, 36935,

 11915     21947, 23786, 24481, 24840, 27442, 29425, 32946, 35465, 28020, 23507,

 11916     35029, 39044, 35947, 39533, 40499, 28170, 20900, 20803, 22435, 34945,

 11917     21407, 25588, 36757, 22253, 21592, 22278, 29503, 28304, 32536, 36828,

 11918     33489, 24895, 24616, 38498, [12104, 26352], 32422, 36234, 36291, 38053,

 11919     23731, 31908, [12105, 26376], 24742, 38405, 32792, 20113, 37095, 21248,

 11920     38504, 20801, 36816, 34164, 37213, 26197, 38901, 23381, 21277, 30776,

 11921     26434, 26685, 21705, 28798, 23472, 36733, 20877, 22312, 21681, 25874,

 11922     26242, 36190, 36163, 33039, 33900, 36973, 31967, 20991, 34299, 26531,

 11923     26089, 28577, 34468, 36481, 22122, 36896, 30338, 28790, 29157, 36131,

 11924     25321, 21017, 27901, 36156, 24590, 22686, 24974, 26366, 36192, 25166,

 11925     21939, 28195, 26413, 36711, 38113, 38392, 30504, 26629, 27048, 21643,

 11926     20045, 28856, 35784, 25688, 25995, 23429, 31364, 20538, 23528, 30651,

 11927     27617, 35449, 31896, 27838, 30415, 26025, 36759, 23853, 23637, 34360,

 11928     26632, 21344, 25112, 31449, 28251, 32509, 27167, 31456, 24432, 28467,

 11929     24352, 25484, 28072, 26454, 19976, 24080, 36134, 20183, 32960, 30260,

 11930     38556, 25307, 26157, 25214, 27836, 36213, 29031, 32617, 20806, 32903,

 11931     21484, 36974, 25240, 21746, 34544, 36761, 32773, 38167, 34071, 36825,

 11932     27993, 29645, 26015, 30495, 29956, 30759, 33275, 36126, 38024, 20390,

 11933     26517, 30137, 35786, 38663, 25391, 38215, 38453, 33976, 25379, 30529,

 11934     24449, 29424, 20105, 24596, 25972, 25327, 27491, 25919, 24103, 30151,

 11935     37073, 35777, 33437, 26525, [12096, 25903], 21553, 34584, 30693, 32930,

 11936     33026, 27713, 20043, 32455, 32844, 30452, 26893, 27542, 25191, 20540,

 11937     20356, 22336, 25351, [12108, 27490], 36286, 21482, 26088, 32440, 24535,

 11938     25370, 25527, [12164, 33267], 33268, 32622, 24092, 23769, 21046, 26234,

 11939     31209, 31258, 36136, 28825, 30164, 28382, 27835, 31378, 20013, 30405,

 11940     24544, 38047, 34935, 32456, 31181, 32959, 37325, 20210, 20247,

 11941     [12168, 33311], 21608, 24030, 27954, 35788, 31909, 36724, 32920, 24090,

 11942     21650, 30385, 23449, 26172, 39588, 29664, 26666, 34523, 26417, 29482,

 11943     35832, 35803, 36880, [12149, 31481], 28891, 29038, 25284, 30633, 22065,

 11944     20027, 33879, 26609, 21161, 34496, 36142, 38136, 31569, 20303, 27880,

 11945     31069, 39547, 25235, [12118, 29226], 25341, 19987, 30742, 36716, 25776,

 11946     36186, 31686, 26729, 24196, 35013, 22918, 25758, 22766, 29366, 26894,

 11947     38181, 36861, 36184, 22368, 32512, 35846, 20934, 25417, 25305, 21331,

 11948     26700, 29730, 33537, 37196, 21828, 30528, 28796, 27978, 20857, 21672,

 11949     36164, 23039, 28363, 28100, 23388, 32043, 20180, 31869, 28371,

 11950     [12070, 23376], [12163, 33258], 28173, 23383, 39683, 26837, 36394, 23447,

 11951     32508, 24635, 32437, 37049, [12187, 36208], 22863, 25549, 31199,

 11952     [12188, 36275], 21330, 26063, 31062, 35781, 38459, 32452, 38075, 32386,

 11953     22068, 37257, 26368, 32618, 23562, 36981, 26152, 24038, 20304, 26590,

 11954     20570, 20316, 22352, 24231, 20109, 19980, 20800, 19984, 24319, 21317,

 11955     19989, 20120, 19998, [12224, 39730], 23404, 22121, [12033, 20008], 31162,

 11956     [12035, 20031], [12052, 21269], 20039, 22829, [12120, 29243], 21358, 27664,

 11957     22239, 32996, 39319, 27603, 30590, 40727, [12034, 20022], 20127, 40720,

 11958     20060, 20073, 20115, 33416, 23387, 21868, 22031, 20164, 21389, 21405,

 11959     21411, 21413, 21422, 38757, 36189, [12053, 21274], 21493, 21286, 21294,

 11960     21310, 36188, 21350, 21347, 20994, 21000, 21006, 21037, 21043,

 11961     {f: 2, c: 21055}, 21068, 21086, 21089, 21084, 33967, 21117, 21122, 21121,

 11962     21136, 21139, [12044, 20866], 32596, 20155, 20163, 20169, 20162, 20200,

 11963     20193, 20203, 20190, 20251, 20211, 20258, 20324, 20213, 20261, 20263,

 11964     20233, 20267, 20318, 20327, 25912, 20314, 20317, 20319, 20311, 20274,

 11965     20285, 20342, 20340, 20369, 20361, 20355, 20367, 20350, 20347, 20394,

 11966     20348, 20396, 20372, 20454, 20456, 20458, 20421, 20442, 20451, 20444,

 11967     20433, 20447, 20472, 20521, 20556, 20467, 20524, 20495, 20526, 20525,

 11968     20478, 20508, 20492, 20517, 20520, 20606, 20547, 20565, 20552, 20558,

 11969     20588, 20603, 20645, 20647, 20649, 20666, 20694, 20742, 20717, 20716,

 11970     20710, 20718, 20743, 20747, 20189, 27709, 20312, 20325, 20430,

 11971     [12245, 40864], 27718, 31860, 20846, 24061, 40649, 39320, 20865, 22804,

 11972     [12051, 21241], 21261, 35335, 21264, 20971, 22809, 20821, [12039, 20128],

 11973     20822, 20147, 34926, 34980, 20149, 33044, 35026, 31104, 23348, 34819,

 11974     32696, [12046, 20907], 20913, 20925, 20924, 20935, [12045, 20886], 20898,

 11975     20901, 35744, {f: 2, c: 35750}, 35754, {f: 2, c: 35764}, 35767,

 11976     {f: 2, c: 35778}, 35787, 35791, 35790, {f: 3, c: 35794}, 35798,

 11977     {f: 2, c: 35800}, 35804, {f: 2, c: 35807}, 35812, {f: 2, c: 35816}, 35822,

 11978     35824, 35827, 35830, 35833, 35836, {f: 2, c: 35839}, 35842, 35844, 35847,

 11979     35852, 35855, {f: 2, c: 35857}, {f: 3, c: 35860}, 35865, 35867, 35864,

 11980     35869, {f: 3, c: 35871}, 35877, 35879, {f: 2, c: 35882}, {f: 2, c: 35886},

 11981     {f: 2, c: 35890}, {f: 2, c: 35893}, [12057, 21353], 21370, 38429, 38434,

 11982     38433, 38449, 38442, 38461, 38460, 38466, 38473, 38484, 38495, 38503,

 11983     38508, 38514, 38516, 38536, 38541, 38551, 38576, 37015, 37019, 37021,

 11984     37017, 37036, 37025, 37044, 37043, 37046, 37050, 37048, 37040, 37071,

 11985     37061, 37054, 37072, 37060, 37063, 37075, 37094, 37090, 37084, 37079,

 11986     37083, 37099, 37103, 37118, 37124, 37154, 37150, 37155, 37169, 37167,

 11987     37177, 37187, 37190, 21005, 22850, 21154, {f: 2, c: 21164}, 21182, 21759,

 11988     21200, 21206, 21232, 21471, 29166, 30669, [12085, 24308], [12048, 20981],

 11989     20988, [12223, 39727], [12059, 21430], 24321, 30042, 24047, 22348, 22441,

 11990     22433, 22654, 22716, 22725, 22737, 22313, 22316, 22314, 22323, 22329,

 11991     {f: 2, c: 22318}, 22364, 22331, 22338, 22377, 22405, 22379, 22406, 22396,

 11992     22395, 22376, 22381, 22390, 22387, 22445, 22436, 22412, 22450, 22479,

 11993     22439, 22452, 22419, 22432, 22485, 22488, 22490, 22489, 22482, 22456,

 11994     22516, 22511, 22520, 22500, 22493, 22539, 22541, 22525, 22509, 22528,

 11995     22558, 22553, 22596, 22560, 22629, 22636, 22657, 22665, 22682, 22656,

 11996     39336, 40729, 25087, 33401, 33405, 33407, 33423, 33418, 33448, 33412,

 11997     33422, 33425, 33431, 33433, 33451, 33464, 33470, 33456, 33480, 33482,

 11998     33507, 33432, 33463, 33454, {f: 2, c: 33483}, 33473, 33449, 33460, 33441,

 11999     33450, 33439, 33476, 33486, 33444, 33505, 33545, 33527, 33508, 33551,

 12000     33543, 33500, 33524, 33490, 33496, 33548, 33531, 33491, 33553, 33562,

 12001     33542, {f: 2, c: 33556}, 33504, 33493, 33564, 33617, {f: 2, c: 33627},

 12002     33544, 33682, 33596, 33588, 33585, 33691, 33630, 33583, 33615, 33607,

 12003     33603, 33631, 33600, 33559, 33632, 33581, 33594, 33587, 33638, 33637,

 12004     33640, 33563, 33641, 33644, 33642, {f: 2, c: 33645}, 33712, 33656,

 12005     {f: 2, c: 33715}, 33696, 33706, 33683, 33692, 33669, 33660, 33718, 33705,

 12006     33661, 33720, 33659, 33688, 33694, 33704, 33722, 33724, 33729, 33793,

 12007     33765, 33752, 22535, 33816, 33803, 33757, 33789, 33750, 33820, 33848,

 12008     33809, 33798, 33748, 33759, 33807, 33795, {f: 2, c: 33784}, 33770, 33733,

 12009     33728, 33830, 33776, 33761, 33884, 33873, 33882, 33881, 33907,

 12010     {f: 2, c: 33927}, 33914, 33929, 33912, 33852, 33862, 33897, 33910, 33932,

 12011     33934, 33841, 33901, 33985, 33997, 34000, 34022, 33981, 34003, 33994,

 12012     33983, 33978, 34016, 33953, 33977, 33972, 33943, 34021, 34019, 34060,

 12013     29965, 34104, 34032, 34105, 34079, 34106, 34134, 34107, 34047, 34044,

 12014     34137, 34120, 34152, 34148, 34142, 34170, 30626, 34115, 34162, 34171,

 12015     34212, 34216, 34183, 34191, 34169, 34222, 34204, 34181, 34233, 34231,

 12016     34224, 34259, 34241, 34268, 34303, 34343, 34309, 34345, 34326, 34364,

 12017     [12086, 24318], 24328, 22844, 22849, 32823, 22869, 22874, 22872, 21263,

 12018     [12074, 23586], 23589, 23596, 23604, 25164, 25194, 25247, 25275, 25290,

 12019     25306, 25303, 25326, 25378, 25334, 25401, 25419, 25411, 25517, 25590,

 12020     25457, 25466, 25486, 25524, 25453, 25516, 25482, 25449, 25518, 25532,

 12021     25586, 25592, 25568, 25599, 25540, 25566, 25550, 25682, 25542, 25534,

 12022     25669, 25665, 25611, 25627, 25632, 25612, 25638, 25633, 25694, 25732,

 12023     25709, 25750, 25722, {f: 2, c: 25783}, 25753, 25786, 25792, 25808, 25815,

 12024     25828, 25826, 25865, 25893, 25902, [12087, 24331], 24530, 29977, 24337,

 12025     21343, 21489, 21501, 21481, 21480, 21499, 21522, 21526, 21510, 21579,

 12026     {f: 3, c: 21586}, 21590, 21571, 21537, 21591, 21593, 21539, 21554, 21634,

 12027     21652, 21623, 21617, 21604, {f: 2, c: 21658}, 21636, 21622, 21606, 21661,

 12028     21712, 21677, 21698, 21684, 21714, 21671, 21670, {f: 2, c: 21715}, 21618,

 12029     21667, 21717, 21691, 21695, 21708, {f: 2, c: 21721}, 21724,

 12030     {f: 2, c: 21673}, 21668, 21725, 21711, 21726, 21787, 21735, 21792, 21757,

 12031     21780, 21747, {f: 2, c: 21794}, 21775, 21777, 21799, 21802, 21863, 21903,

 12032     21941, 21833, 21869, 21825, 21845, 21823, 21840, 21820, 21815, 21846,

 12033     {f: 3, c: 21877}, 21811, 21808, 21852, 21899, 21970, 21891, 21937, 21945,

 12034     21896, 21889, 21919, 21886, 21974, 21905, 21883, 21983, {f: 2, c: 21949},

 12035     21908, 21913, 21994, 22007, 21961, 22047, 21969, {f: 2, c: 21995}, 21972,

 12036     21990, 21981, 21956, 21999, 21989, {f: 2, c: 22002}, {f: 2, c: 21964},

 12037     21992, 22005, 21988, 36756, 22046, 22024, 22028, 22017, 22052, 22051,

 12038     22014, 22016, 22055, 22061, 22104, 22073, 22103, 22060, 22093, 22114,

 12039     22105, 22108, 22092, 22100, 22150, 22116, 22129, 22123, {f: 2, c: 22139},

 12040     22149, 22163, 22191, 22228, [12062, 22231], 22237, 22241, 22261, 22251,

 12041     22265, 22271, 22276, 22282, 22281, 22300, 24079, 24089, 24084, 24081,

 12042     24113, {f: 2, c: 24123}, 24119, 24132, 24148, 24155, 24158, 24161, 23692,

 12043     23674, 23693, 23696, 23702, 23688, {f: 2, c: 23704}, 23697, 23706, 23708,

 12044     23733, 23714, 23741, 23724, 23723, 23729, 23715, 23745, 23735, 23748,

 12045     23762, 23780, 23755, 23781, {f: 2, c: 23810}, 23847, 23846, 23854, 23844,

 12046     23838, 23814, 23835, 23896, 23870, 23860, 23869, 23916, 23899, 23919,

 12047     23901, 23915, 23883, 23882, 23913, 23924, 23938, 23961, 23965, 35955,

 12048     23991, 24005, [12091, 24435], 24439, 24450, 24455, 24457, 24460, 24469,

 12049     24473, 24476, 24488, 24493, 24501, 24508, 34914, [12090, 24417], 29357,

 12050     29360, 29364, {f: 2, c: 29367}, 29379, 29377, 29390, 29389, 29394, 29416,

 12051     29423, 29417, 29426, 29428, 29431, 29441, 29427, 29443, {f: 2, c: 29434},

 12052     29463, 29459, 29473, 29450, 29470, 29469, 29461, 29474, 29497, 29477,

 12053     29484, 29496, 29489, 29520, 29517, 29527, 29536, 29548, 29551, 29566,

 12054     [12167, 33307], 22821, 39143, 22820, [12065, 22786], 39267,

 12055     {f: 6, c: 39271}, 39284, 39287, 39293, 39296, 39300, 39303, 39306, 39309,

 12056     {f: 2, c: 39312}, {f: 3, c: 39315}, 24192, 24209, 24203, 24214, 24229,

 12057     24224, 24249, 24245, 24254, 24243, 36179, 24274, 24273, 24283, 24296,

 12058     24298, 33210, 24516, 24521, 24534, 24527, 24579, 24558, 24580, 24545,

 12059     24548, 24574, {f: 2, c: 24581}, 24554, 24557, 24568, 24601, 24629, 24614,

 12060     24603, 24591, 24589, 24617, 24619, 24586, 24639, 24609, {f: 2, c: 24696},

 12061     24699, 24698, 24642, 24682, 24701, 24726, 24730, 24749, 24733, 24707,

 12062     24722, 24716, 24731, 24812, 24763, 24753, 24797, 24792, 24774, 24794,

 12063     24756, 24864, 24870, 24853, 24867, 24820, 24832, 24846, 24875, 24906,

 12064     24949, 25004, 24980, 24999, 25015, 25044, 25077, 24541, 38579, 38377,

 12065     38379, 38385, 38387, {f: 2, c: 38389}, 38396, 38398, {f: 2, c: 38403},

 12066     38406, 38408, {f: 4, c: 38410}, 38415, 38418, {f: 3, c: 38421},

 12067     {f: 2, c: 38425}, 20012, [12121, 29247], 25109, 27701, 27732, 27740, 27722,

 12068     27811, 27781, 27792, 27796, 27788, {f: 2, c: 27752}, 27764, 27766, 27782,

 12069     27817, 27856, 27860, 27821, {f: 2, c: 27895}, 27889, 27863, 27826, 27872,

 12070     27862, 27898, 27883, 27886, 27825, 27859, 27887, 27902, 27961, 27943,

 12071     27916, 27971, 27976, 27911, 27908, 27929, 27918, 27947, 27981, 27950,

 12072     27957, 27930, 27983, 27986, 27988, 27955, 28049, 28015, 28062, 28064,

 12073     27998, {f: 2, c: 28051}, 27996, 28000, 28028, 28003, 28186, 28103, 28101,

 12074     28126, 28174, 28095, 28128, 28177, 28134, 28125, 28121, 28182, 28075,

 12075     28172, 28078, 28203, 28270, 28238, 28267, 28338, 28255, 28294,

 12076     {f: 2, c: 28243}, 28210, 28197, 28228, 28383, 28337, 28312, 28384, 28461,

 12077     28386, 28325, 28327, 28349, 28347, 28343, 28375, 28340, 28367, 28303,

 12078     28354, 28319, 28514, {f: 2, c: 28486}, 28452, 28437, 28409, 28463, 28470,

 12079     28491, 28532, 28458, 28425, 28457, 28553, 28557, 28556, 28536, 28530,

 12080     28540, 28538, 28625, 28617, 28583, 28601, 28598, 28610, 28641, 28654,

 12081     28638, 28640, 28655, 28698, 28707, 28699, 28729, 28725, 28751, 28766,

 12082     [12071, 23424], 23428, 23445, 23443, 23461, 23480, 29999, 39582, 25652,

 12083     23524, 23534, 35120, 23536, 36423, 35591, 36790, 36819, 36821, 36837,

 12084     36846, 36836, 36841, 36838, 36851, 36840, 36869, 36868, 36875, 36902,

 12085     36881, 36877, 36886, 36897, {f: 2, c: 36917}, 36909, 36911, 36932,

 12086     {f: 2, c: 36945}, 36944, 36968, 36952, 36962, 36955, 26297, 36980, 36989,

 12087     36994, 37000, 36995, 37003, [12089, 24400], 24407, 24406, 24408, 23611,

 12088     21675, 23632, 23641, 23409, 23651, 23654, 32700, 24362, 24361, 24365,

 12089     33396, 24380, 39739, [12076, 23662], 22913, 22915, 22925, {f: 2, c: 22953},

 12090     22947, 22935, 22986, 22955, 22942, 22948, 22994, 22962, 22959, 22999,

 12091     22974, {f: 2, c: 23045}, 23005, 23048, 23011, 23000, 23033, 23052, 23049,

 12092     23090, 23092, 23057, 23075, 23059, 23104, 23143, 23114, 23125, 23100,

 12093     23138, 23157, 33004, 23210, 23195, 23159, 23162, 23230, 23275, 23218,

 12094     23250, 23252, 23224, 23264, 23267, 23281, 23254, 23270, 23256, 23260,

 12095     23305, 23319, 23318, 23346, 23351, 23360, 23573, 23580, 23386, 23397,

 12096     23411, 23377, 23379, 23394, 39541, {f: 2, c: 39543}, 39546, 39551, 39549,

 12097     {f: 2, c: 39552}, 39557, 39560, 39562, 39568, {f: 2, c: 39570}, 39574,

 12098     39576, {f: 3, c: 39579}, {f: 2, c: 39583}, {f: 2, c: 39586}, 39589, 39591,

 12099     32415, 32417, 32419, 32421, {f: 2, c: 32424}, 32429, 32432, 32446,

 12100     {f: 3, c: 32448}, 32457, {f: 2, c: 32459}, 32464, 32468, 32471, 32475,

 12101     {f: 2, c: 32480}, 32488, 32491, {f: 2, c: 32494}, {f: 2, c: 32497}, 32525,

 12102     32502, {f: 2, c: 32506}, 32510, {f: 3, c: 32513}, {f: 2, c: 32519},

 12103     {f: 2, c: 32523}, 32527, {f: 2, c: 32529}, 32535, 32537, 32540, 32539,

 12104     32543, {f: 7, c: 32545}, {f: 4, c: 32554}, {f: 5, c: 32559}, 32565,

 12105     [12083, 24186], 30079, [12078, 24027], 30014, 37013, 29582, 29585, 29614,

 12106     29602, 29599, 29647, 29634, 29649, 29623, 29619, 29632, 29641, 29640,

 12107     29669, 29657, 39036, 29706, 29673, 29671, 29662, 29626, 29682, 29711,

 12108     29738, 29787, 29734, 29733, 29736, 29744, 29742, 29740, 29723, 29722,

 12109     29761, 29788, 29783, 29781, 29785, 29815, 29805, 29822, 29852, 29838,

 12110     {f: 2, c: 29824}, 29831, 29835, 29854, {f: 2, c: 29864}, 29840, 29863,

 12111     29906, 29882, {f: 3, c: 38890}, 26444, 26451, 26462, 26440, 26473, 26533,

 12112     26503, 26474, 26483, 26520, 26535, 26485, 26536, 26526, 26541, 26507,

 12113     26487, 26492, 26608, 26633, 26584, 26634, 26601, 26544, 26636, 26585,

 12114     26549, 26586, 26547, 26589, 26624, 26563, 26552, 26594, 26638, 26561,

 12115     26621, {f: 2, c: 26674}, {f: 2, c: 26720}, 26702, 26722, 26692, 26724,

 12116     26755, 26653, 26709, 26726, 26689, 26727, 26688, 26686, 26698, 26697,

 12117     26665, 26805, 26767, 26740, 26743, 26771, 26731, 26818, 26990, 26876,

 12118     {f: 2, c: 26911}, 26873, 26916, 26864, 26891, 26881, 26967, 26851, 26896,

 12119     26993, 26937, 26976, 26946, 26973, 27012, 26987, 27008, 27032, 27000,

 12120     26932, 27084, {f: 2, c: 27015}, 27086, 27017, 26982, 26979, 27001, 27035,

 12121     27047, 27067, 27051, 27053, 27092, 27057, 27073, 27082, 27103, 27029,

 12122     27104, 27021, 27135, 27183, 27117, {f: 2, c: 27159}, 27237, 27122, 27204,

 12123     27198, 27296, 27216, 27227, 27189, 27278, 27257, 27197, 27176, 27224,

 12124     27260, 27281, 27280, 27305, 27287, 27307, 29495, 29522, {f: 2, c: 27521},

 12125     27527, 27524, {f: 2, c: 27538}, 27533, {f: 2, c: 27546}, 27553, 27562,

 12126     36715, 36717, {f: 3, c: 36721}, {f: 2, c: 36725}, 36728, 36727,

 12127     {f: 2, c: 36729}, 36732, 36734, {f: 2, c: 36737}, 36740, 36743, 36747,

 12128     {f: 3, c: 36749}, 36760, 36762, 36558, 25099, 25111, 25115, 25119, 25122,

 12129     25121, 25125, 25124, 25132, 33255, 29935, 29940, 29951, 29967, 29969,

 12130     29971, [12097, 25908], {f: 3, c: 26094}, 26122, 26137, 26482, 26115, 26133,

 12131     26112, 28805, 26359, 26141, 26164, 26161, 26166, 26165, 32774, 26207,

 12132     26196, 26177, 26191, 26198, 26209, 26199, 26231, 26244, 26252, 26279,

 12133     26269, 26302, {f: 2, c: 26331}, 26342, 26345, {f: 2, c: 36146}, 36150,

 12134     36155, 36157, 36160, {f: 2, c: 36165}, {f: 2, c: 36168}, 36167, 36173,

 12135     36181, 36185, 35271, {f: 3, c: 35274}, {f: 4, c: 35278}, 29294, 29343,

 12136     29277, 29286, 29295, {f: 2, c: 29310}, 29316, 29323, 29325, 29327, 29330,

 12137     25352, 25394, 25520, 25663, 25816, 32772, 27626, 27635, 27645, 27637,

 12138     27641, 27653, 27655, 27654, 27661, 27669, {f: 3, c: 27672}, 27681, 27689,

 12139     27684, 27690, 27698, 25909, 25941, 25963, 29261, 29266, 29270, 29232,

 12140     34402, 21014, 32927, 32924, 32915, 32956, 26378, 32957, 32945, 32939,

 12141     32941, 32948, 32951, {f: 4, c: 32999}, 32987, 32962, 32964, 32985, 32973,

 12142     32983, 26384, 32989, 33003, 33009, 33012, 33005, {f: 2, c: 33037}, 33010,

 12143     33020, 26389, 33042, 35930, 33078, 33054, 33068, 33048, 33074, 33096,

 12144     33100, 33107, 33140, {f: 2, c: 33113}, 33137, 33120, 33129,

 12145     {f: 2, c: 33148}, 33133, 33127, 22605, 23221, 33160, 33154, 33169, 28373,

 12146     33187, 33194, 33228, 26406, 33226, 33211, 33217, 33190, 27428, 27447,

 12147     27449, 27459, 27462, 27481, {f: 3, c: 39121}, 39125, {f: 2, c: 39129},

 12148     [12110, 27571], 24384, 27586, 35315, 26000, 40785, 26003, 26044, 26054,

 12149     26052, 26051, 26060, 26062, 26066, 26070, 28800, 28828, 28822, 28829,

 12150     28859, 28864, 28855, 28843, 28849, 28904, 28874, 28944, 28947, 28950,

 12151     28975, 28977, 29043, 29020, 29032, 28997, 29042, 29002, 29048, 29050,

 12152     29080, 29107, 29109, 29096, 29088, 29152, 29140, 29159, 29177, 29213,

 12153     29224, 28780, 28952, 29030, 29113, 25150, 25149, 25155, {f: 2, c: 25160},

 12154     31035, 31040, 31046, 31049, {f: 2, c: 31067}, 31059, 31066, 31074, 31063,

 12155     31072, 31087, 31079, 31098, 31109, 31114, 31130, 31143, 31155, 24529,

 12156     24528, 24636, 24669, 24666, 24679, 24641, 24665, 24675, 24747, 24838,

 12157     24845, 24925, 25001, 24989, 25035, 25041, 25094, 32896, [12160, 32895],

 12158     27795, 27894, 28156, 30710, 30712, 30720, 30729, {f: 2, c: 30743}, 30737,

 12159     26027, 30765, {f: 2, c: 30748}, {f: 3, c: 30777}, 30751, 30780, 30757,

 12160     30764, 30755, 30761, 30798, 30829, {f: 2, c: 30806}, 30758, 30800, 30791,

 12161     30796, 30826, 30875, 30867, 30874, 30855, 30876, 30881, 30883, 30898,

 12162     30905, 30885, 30932, 30937, 30921, 30956, 30962, 30981, 30964, 30995,

 12163     31012, 31006, 31028, 40859, [12235, 40697], {f: 2, c: 40699}, 30449, 30468,

 12164     30477, 30457, {f: 2, c: 30471}, 30490, 30498, 30489, 30509, 30502, 30517,

 12165     30520, {f: 2, c: 30544}, 30535, 30531, 30554, 30568, 30562, 30565, 30591,

 12166     30605, 30589, 30592, 30604, 30609, {f: 2, c: 30623}, 30640, 30645, 30653,

 12167     30010, 30016, 30030, 30027, 30024, 30043, 30066, 30073, 30083, 32600,

 12168     32609, 32607, 35400, 32616, 32628, 32625, 32633, 32641, 32638, 30413,

 12169     30437, 34866, {f: 3, c: 38021}, 38027, 38026, {f: 2, c: 38028},

 12170     {f: 2, c: 38031}, 38036, 38039, 38037, {f: 3, c: 38042}, {f: 2, c: 38051},

 12171     38059, 38058, 38061, 38060, {f: 2, c: 38063}, 38066, 38068,

 12172     {f: 5, c: 38070}, {f: 2, c: 38076}, 38079, 38084, {f: 7, c: 38088},

 12173     {f: 3, c: 38096}, {f: 3, c: 38101}, 38105, 38104, 38107, {f: 3, c: 38110},

 12174     38114, {f: 2, c: 38116}, {f: 2, c: 38119}, 38122, 38121, 38123,

 12175     {f: 2, c: 38126}, {f: 3, c: 38131}, 38135, 38137, {f: 2, c: 38140}, 38143,

 12176     38147, 38146, {f: 2, c: 38150}, {f: 2, c: 38153}, {f: 3, c: 38157},

 12177     {f: 5, c: 38162}, 38168, 38171, {f: 3, c: 38173}, 38178, {f: 2, c: 38186},

 12178     38185, 38188, {f: 2, c: 38193}, 38196, {f: 3, c: 38198}, 38204,

 12179     {f: 2, c: 38206}, 38210, 38197, {f: 3, c: 38212}, 38217, 38220,

 12180     {f: 2, c: 38222}, {f: 3, c: 38226}, {f: 4, c: 38230}, 38235,

 12181     {f: 2, c: 38238}, 38237, {f: 2, c: 38241}, {f: 9, c: 38244}, 38255,

 12182     {f: 3, c: 38257}, 38202, 30695, 30700, 38601, 31189, 31213, 31203, 31211,

 12183     31238, 23879, 31235, 31234, 31262, 31252, 31289, 31287, 31313, 40655,

 12184     39333, 31344, 30344, 30350, 30355, 30361, 30372, 29918, 29920, 29996,

 12185     40480, 40482, {f: 5, c: 40488}, 40498, 40497, 40502, 40504, 40503,

 12186     {f: 2, c: 40505}, 40510, {f: 2, c: 40513}, 40516, {f: 4, c: 40518},

 12187     {f: 2, c: 40523}, 40526, 40529, 40533, 40535, {f: 3, c: 40538}, 40542,

 12188     40547, {f: 7, c: 40550}, 40561, 40557, 40563, [12135, 30098], 30100, 30102,

 12189     30112, 30109, 30124, 30115, {f: 2, c: 30131}, 30136, 30148, 30129, 30128,

 12190     30147, 30146, 30166, 30157, 30179, 30184, 30182, 30180, 30187, 30183,

 12191     30211, 30193, 30204, 30207, 30224, 30208, 30213, 30220, 30231, 30218,

 12192     30245, 30232, 30229, 30233, 30235, 30268, 30242, 30240, 30272, 30253,

 12193     30256, 30271, 30261, 30275, 30270, 30259, 30285, 30302, 30292, 30300,

 12194     30294, 30315, 30319, 32714, 31462, {f: 2, c: 31352}, 31360, 31366, 31368,

 12195     31381, 31398, 31392, 31404, 31400, 31405, 31411, 34916, 34921, 34930,

 12196     34941, 34943, 34946, 34978, 35014, 34999, 35004, 35017, 35042, 35022,

 12197     35043, 35045, 35057, 35098, 35068, 35048, 35070, 35056, 35105, 35097,

 12198     35091, 35099, 35082, 35124, 35115, 35126, 35137, 35174, 35195,

 12199     [12134, 30091], 32997, 30386, 30388, 30684, [12158, 32786], 32788, 32790,

 12200     32796, 32800, 32802, {f: 3, c: 32805}, 32809, 32808, 32817, 32779, 32821,

 12201     32835, 32838, 32845, 32850, 32873, 32881, 35203, 39032, 39040, 39043,

 12202     39049, {f: 2, c: 39052}, 39055, 39060, {f: 2, c: 39066}, {f: 2, c: 39070},

 12203     {f: 2, c: 39073}, {f: 2, c: 39077}, [12172, 34381], 34388, 34412, 34414,

 12204     34431, 34426, 34428, 34427, 34472, 34445, 34443, 34476, 34461, 34471,

 12205     34467, 34474, 34451, 34473, 34486, 34500, 34485, 34510, 34480, 34490,

 12206     34481, 34479, 34505, 34511, 34484, 34537, {f: 2, c: 34545}, 34541, 34547,

 12207     34512, 34579, 34526, 34548, 34527, 34520, 34513, 34563, 34567, 34552,

 12208     34568, 34570, 34573, 34569, 34595, 34619, 34590, 34597, 34606, 34586,

 12209     34622, 34632, 34612, 34609, 34601, 34615, 34623, 34690, 34594,

 12210     {f: 2, c: 34685}, 34683, 34656, 34672, 34636, 34670, 34699, 34643, 34659,

 12211     34684, 34660, 34649, 34661, 34707, 34735, 34728, 34770, 34758, 34696,

 12212     34693, 34733, 34711, 34691, 34731, 34789, 34732, 34741, 34739, 34763,

 12213     34771, 34749, 34769, 34752, 34762, 34779, 34794, 34784, 34798, 34838,

 12214     34835, 34814, 34826, 34843, 34849, 34873, 34876, [12152, 32566], 32578,

 12215     {f: 2, c: 32580}, 33296, 31482, 31485, 31496, {f: 2, c: 31491}, 31509,

 12216     31498, 31531, 31503, 31559, 31544, 31530, 31513, 31534, 31537, 31520,

 12217     31525, 31524, 31539, 31550, 31518, 31576, 31578, 31557, 31605, 31564,

 12218     31581, 31584, 31598, 31611, 31586, 31602, 31601, 31632, {f: 2, c: 31654},

 12219     31672, 31660, 31645, 31656, 31621, 31658, 31644, 31650, 31659, 31668,

 12220     31697, 31681, 31692, 31709, 31706, {f: 2, c: 31717}, 31722, 31756, 31742,

 12221     31740, 31759, 31766, 31755, 31775, 31786, 31782, 31800, 31809, 31808,

 12222     33278, {f: 2, c: 33281}, 33284, 33260, 34884, {f: 3, c: 33313}, 33325,

 12223     33327, 33320, 33323, 33336, 33339, {f: 2, c: 33331}, 33342, 33348, 33353,

 12224     33355, 33359, 33370, 33375, 33384, 34942, 34949, 34952, 35032, 35039,

 12225     35166, 32669, 32671, 32679, {f: 2, c: 32687}, 32690, 31868, 25929, 31889,

 12226     31901, 31900, 31902, 31906, 31922, {f: 2, c: 31932}, 31937, 31943,

 12227     {f: 2, c: 31948}, 31944, 31941, 31959, 31976, [12169, 33390], 26280, 32703,

 12228     32718, 32725, 32741, 32737, 32742, 32745, 32750, 32755, [12151, 31992],

 12229     32119, 32166, 32174, 32327, 32411, 40632, 40628, 36211, 36228, 36244,

 12230     36241, 36273, 36199, 36205, 35911, 35913, 37194, 37200, {f: 2, c: 37198},

 12231     37220, 37218, 37217, 37232, 37225, 37231, {f: 2, c: 37245}, 37234, 37236,

 12232     37241, 37260, 37253, 37264, 37261, 37265, {f: 2, c: 37282}, 37290,

 12233     {f: 3, c: 37293}, 37301, 37300, 37306, [12183, 35925], 40574, 36280, 36331,

 12234     36357, 36441, 36457, 36277, 36287, 36284, 36282, 36292, {f: 2, c: 36310},

 12235     36314, 36318, {f: 2, c: 36302}, 36315, 36294, 36332, {f: 2, c: 36343},

 12236     36323, 36345, 36347, 36324, 36361, 36349, 36372, 36381, 36383, 36396,

 12237     36398, 36387, 36399, 36410, 36416, 36409, 36405, 36413, 36401, 36425,

 12238     {f: 2, c: 36417}, {f: 2, c: 36433}, 36426, 36464, 36470, 36476, 36463,

 12239     36468, 36485, 36495, 36500, 36496, 36508, 36510, [12184, 35960], 35970,

 12240     35978, 35973, 35992, 35988, 26011, 35286, 35294, 35290, 35292, 35301,

 12241     35307, 35311, 35390, 35622, 38739, 38633, 38643, 38639, 38662, 38657,

 12242     38664, 38671, 38670, 38698, 38701, 38704, 38718, 40832, 40835,

 12243     {f: 6, c: 40837}, 40844, 40702, 40715, 40717, [12203, 38585],

 12244     {f: 2, c: 38588}, 38606, 38610, 30655, 38624, 37518, 37550, 37576, 37694,

 12245     37738, 37834, 37775, 37950, 37995, 40063, 40066, {f: 4, c: 40069}, 31267,

 12246     40075, 40078, {f: 3, c: 40080}, {f: 2, c: 40084}, {f: 2, c: 40090},

 12247     {f: 6, c: 40094}, {f: 5, c: 40101}, 40107, {f: 2, c: 40109},

 12248     {f: 8, c: 40112}, {f: 4, c: 40122}, {f: 4, c: 40132}, {f: 7, c: 40138},

 12249     {f: 3, c: 40147}, {f: 3, c: 40151}, {f: 2, c: 40156}, 40159, 40162, 38780,

 12250     38789, {f: 2, c: 38801}, 38804, 38831, 38827, 38819, 38834, 38836, 39601,

 12251     39600, 39607, 40536, 39606, 39610, 39612, 39617, 39616, 39621, 39618,

 12252     {f: 2, c: 39627}, 39633, 39749, 39747, 39751, 39753, 39752, 39757, 39761,

 12253     39144, 39181, 39214, 39253, 39252, [12221, 39647], 39649, 39654, 39663,

 12254     39659, 39675, 39661, 39673, 39688, 39695, 39699, 39711, 39715,

 12255     {f: 2, c: 40637}, 32315, 40578, {f: 2, c: 40583}, 40587, 40594, 37846,

 12256     40605, 40607, {f: 3, c: 40667}, 40672, 40671, 40674, 40681, 40679, 40677,

 12257     40682, 40687, 40738, 40748, 40751, 40761, 40759, {f: 2, c: 40765}, 40772,

 12258     12295, {s: 13}, 30362, 34297, 31001, 24859, 39599, 35158, 22761, 32631,

 12259     25850, 25943, 38930, 36774, 32070, 24171, 32129, 37770, 35607, 39165,

 12260     23542, 22577, 39825, 36649, [12185, 35997], 37575, 29437, 20633, 24970,

 12261     32179, 31558, 30050, 25987, 24163, 38281, 37002, 32232, 36022, 35722,

 12262     36783, 36782, 27161, 40009, 30303, 28693, 28657, 36051, 25839, 39173,

 12263     25765, 37474, 37457, 39361, 35036, 36001, 21443, 34870, 27544, 24922,

 12264     24920, 29158, 33980, 33369, 20489, 28356, 21408, 20596, 28204, 23652,

 12265     35435, 25881, 25723, 34796, 39262, 35730, 32399, 37855, 29987, 38369,

 12266     39019, 22580, 22039, [12199, 38263], 20767, 33144, 24288, 26274, 37396,

 12267     [12190, 36554], 24505, 22645, 38515, 35183, 31281, 25074, 35488, 39425,

 12268     36978, 39347, [12242, 40786], 29118, 34909, 34802, 23541, 30087, 36490,

 12269     31820, 32162, 37276, 37604, 38619, 30990, 20786, 35320, 34389, 20659,

 12270     30241, 38358, 21109, 37656, 32020, 32189, 36781, 35422, 36060, 32880,

 12271     24478, 21474, 36517, 31428, 37679, 36948, 24118, 36024, 25812, 21934,

 12272     37170, 25763, 33213, 24986, 35477, 24392, 30070, 25803, 40680, 34153,

 12273     27284, 25623, 23798, 31153, 23566, 29128, 37159, 25973, 28364, 36958,

 12274     32224, 39003, 40670, 22666, 38651, 28593, 37347, 35519, 35548, 37336,

 12275     38914, 37664, 35330, 26481, 21205, 26847, 20941, [12222, 39717], 29346,

 12276     29544, 35712, 36077, 37709, 37723, 26039, 32222, 38538, 23565, 22136,

 12277     38931, 37389, 22890, 22702, 40285, 38989, 35355, 24801, 39187, 20818,

 12278     29246, 39180, 36019, 30332, 32624, 38309, 31020, 37353, 29033, 31684,

 12279     36009, 39151, 35370, 32033, [12214, 39131], 35513, 24290, 36027, 32027,

 12280     22707, 22894, 24996, 31966, 35920, 26963, 37586, [12213, 39080], 30219,

 12281     39342, 32299, 35575, 40179, 33178, 36667, 25771, 36628, 36070, 24489,

 12282     36000, 35331, 23142, 32283, 35442, 37411, 33995, 24185, 36245, 36123,

 12283     23713, 21083, 37628, 32177, 23831, 37804, 25841, 40255, 38307, 37499,

 12284     20491, 32102, 40852, 38799, 36002, 37390, 28317, 27083, 36092, 34865,

 12285     39015, 21102, 38364, 35264, 39208, 24931, 36011, 24291, 35215, 27512,

 12286     [12244, 40860], 38312, 36556, 35437, 27331, 36020, 21130, 36645, 37707,

 12287     22283, 36942, 39405, 38867, 28450, 34399, 38305, 40372, 36032, 36703,

 12288     40251, 32005, 22778, 35703, 28396, 22057, 33775, 30059, 21123, 35441,

 12289     25079, 22750, 27489, 29872, 36996, 32233, 35594, 25582, 36637, 36036,

 12290     31330, 26371, 29172, 21295, 35569, 35496, 32362, 33911, 28222, 29554,

 12291     36008, 31117, 25802, 27231, 31309, 39249, 35663, 40388, 32318, 32221,

 12292     26997, 36655, 32026, 25824, 24190, 34186, 21137, 28639, 35336, 35352,

 12293     38555, 32380, 32000, 22846, 33698, 38960, 36040, 37440, 20729, 39381,

 12294     27570, 30435, 22533, 31627, 38291, 33393, 32216, 32365, 27298, 40572,

 12295     25536, 25791, 31777, 20745, 34214, 27323, 37970, 36368, 36068,

 12296     [12178, 35211], 37749, 33382, 21133, 39198, 28472, 28666, 28567, 23559,

 12297     28479, 34083, 27123, 22892, 35611, 37292, 33184, 28550, 39509, 23308,

 12298     25898, 37496, 30703, 20709, 39171, 32371, 32094, 36686, 36611, 38542,

 12299     31680, 28500, 32080, 35489, 32202, 37670, 20677, 35641, 36914, 29180,

 12300     30433, 21185, 33686, 39912, 39514, 32147, 38968, 37857, 24465, 30169,

 12301     31478, 31998, 33290, 39378, 33289, 25818, 37624, 25084, 21127, 40273,

 12302     32121, 35258, 35363, 32118, 37406, 36557, 39423, 38283, 20977, 38982,

 12303     27579, 35506, 22718, 25031, 25715, 24235, 35122, 35463, 22602, 20744,

 12304     23532, 31014, 26336, 34407, 24011, 31418, 39243, 28528, 25844, 38346,

 12305     34847, 33240, 33802, 20358, 36084, 34253, 27396, 25876, 31811, 38348,

 12306     34349, 28734, 35733, 25900, 35261, 25078, 32412, 29211, 28651, 25736,

 12307     21214, 28551, 27138, 37939, 22744, 39006, 31852, 38626, 28757, 35023,

 12308     39881, 31150, 40599, 21426, 21237, 31019, 27511, 28701, 38584, 20486,

 12309     32879, 34030, 36899, 37934, 24976, 28451, 31806, 25986, 33225, 37832,

 12310     25088, 29001, 32244, 31975, 20841, 36635, 35538, 30274, 36988, 37904,

 12311     29557, 33256, 37168, 40023, 36035, 40801, 37428, 38728, 23994, 38936,

 12312     39230, 21129, [12243, 40845], 32894, 22184, 31840, 22751, 25871, 38580,

 12313     27155, 23105, 25695, 31757, 34310, 30439, 39025, 24300, 29200, 25796,

 12314     28407, 34396, 39791, 36034, 37682, 38520, 39522, 37569, 23650, 32311,

 12315     24942, 28670, 32209, 24018, 25891, 23423, 28772, 20098, 25476, 36650,

 12316     20523, 20374, 28138, 32184, 35542, 34367, 32645, 37007, 38012, 31854,

 12317     39486, 39409, 32097, 23229, 29802, 30908, 34718, [12218, 39340], 39393,

 12318     21966, 36023, [12230, 40613], 36067, 36993, 30622, 39237, 34875, 28415,

 12319     35646, 37672, 37466, 36031, 37762, [12200, 38272], 24758, 20497, 37683,

 12320     22818, 35598, 24396, 35219, 32191, 32236, 24287, 28357, 25003, 38313,

 12321     40180, 37528, 35628, 35584, 30045, 37385, 32013, 38627, 25747, 33126,

 12322     24817, 39719, 39186, 25836, 33193, 25862, 37312, [12227, 40165], 32886,

 12323     22169, 38007, 37811, 27320, 29552, 23527, 25840, 28632, 37397, 32016,

 12324     33215, 28611, 36786, 30247, 35582, 27472, 40407, 27590, 22036, 28442,

 12325     30436, 40848, 36064, 22132, 40300, 39449, 39108, 38971, 36007, 34315,

 12326     24977, 35413, 28497, 38935, 25778, 37610, 20693, 27192, 35676, 33229,

 12327     [12241, 40778], 39438, 35912, 21843, 27683, 35350, 29309, 37370, 37467,

 12328     36983, 31805, 35609, 37666, 37463, 28154, 35700, 22649, 27085, 21958,

 12329     22715, 34196, 25654, 37740, 27211, 21932, 20689, 32761, 31429, 31434,

 12330     27453, 35242, 23522, 36629, 27691, 20670, 38915, 35531, 24950, 29898,

 12331     31406, 36264, 21312, 36544, 39493, 40818, 39028, 27402, 21240, 40306,

 12332     30906, 35731, 39250, 25854, 32350, 29105, 38860, 35469, 32009, 27054,

 12333     32104, 36575, 37613, 38287, 28516, 28753, 34217, 39955, 36093, 20632,

 12334     21930, 39479, 25475, 28544, 27578, 32023, 31721, 26348, 38275, 38493,

 12335     36109, 32341, 20663, 36062, 29138, 32057, 36050, 25448, 25885, 25086,

 12336     35373, 32051, 23529, 23352, 33102, 28402, 32882, 32361, 21213, 32854,

 12337     24107, 29509, 28629, 35433, 26178, 34645, 23526, 35672, 39387, 21218,

 12338     36969, 37323, 39166, 35222, 35430, 22781, 29560, 27166, 36664, 26360,

 12339     36118, 23660, 34899, 27193, 31466, 25976, 24101, 38617, 35504, 38918,

 12340     35500, 30889, 29197, 32114, 39164, 39686, 32883, 24939, 38924, 35359,

 12341     35494, 25851, 34311, 35380, 32901, 38614, 38568, 32143, 27506, 23403,

 12342     25613, 32302, 29795, 37782, 29562, 25787, 33274, 24907, 25892, 36010,

 12343     30321, 28760, 22727, 35674, 35527, 22022, 28271, 29145, 28644, 32295,

 12344     35342, 39472, 35588, 37563, 38988, 39636, 26781, 36028, 37941, 24307,

 12345     32893, 28916, 37509, 32113, 38957, 22294, 22615, 22296, 38973, 40213,

 12346     39345, 39389, 27234, 31402, 35178, 24398, 28771, 38929, 33836, 32178,

 12347     [12209, 38859], 36949, 22285, 29234, 28656, 32173, 33894, 20553, 20702,

 12348     32239, 35586, 34907, 32862, 32011, 31337, 21839, 25790, 34680, 28198,

 12349     31401, 21978, 37794, 28879, 35491, 28961, 34154, 22626, 38695, 21209,

 12350     35492, 37675, 29351, 35186, 32722, 37521, 25138, 32048, 34662, 36676,

 12351     23805, 20448, 29433, 22151, 37697, 39854, 32406, 36066, 37532, 38289,

 12352     39023, 38570, 29694, 29563, 32291, 39201, 25010, 32171, 38002, 37129,

 12353     35443, 38911, 38917, 34157, 22210, 37559, 26313, 22063, 21332, 25406,

 12354     33029, 35559, 23531, 28681, 35613, 37573, 37313, 33288, 37561, 32137,

 12355     38920, 35377, 32210, 32396, 36562, 25080, 36984, 30316, 32098, 23416,

 12356     21211, 35426, 23563, 39348, 35347, 35338, 36956, 22739, 40201, 40232,

 12357     21854, 20126, 35357, 38329, 40573, 22196, 38996, 38331, 33399, 21421,

 12358     30831, 35578, 39511, 40230, 26954, 25562, 30221, 38525, 30306, 39178,

 12359     27171, 22575, 35617, 34277, 29242, [12212, 38913], 26989, 33865, 37291,

 12360     37541, 38948, 36986, 20736, 34811, 34269, 20740, 25014, 32681, 35427,

 12361     35696, 35516, 35695, 32377, 34093, 38512, 37504, 39154, 38577, 27387,

 12362     23344, 40441, 25033, 32403, 29801, 34722, 29151, 29074, 34821, 36111,

 12363     31310, 21938, 25793, 20653, 30320, 36404, 20778, 24962, 37109, 37438,

 12364     29494, 35480, 36671, 39192, [12226, 39770], 28417, 33287, 23996, 35486,

 12365     39729, 29508, 35709, 38928, 39341, 40219, 28149, 36677, 22290, 21729,

 12366     22291, 32227, 36960, 39000, 32004, 36493, 38000, 38322, 38642, 37142,

 12367     38549, 36939, 34292, 37270, 26248, 38620, 36617, 25890, 26283, 36106,

 12368     36124, 33247, 38015, 26839, 31432, 36012, 25799, 21063, 28580, 36042,

 12369     36104, 36555, 37720, 38296, 35408, 40779, 20661, 27656, 30430, 26028,

 12370     36670, 23940, 26855, 25136, 32187, 24373, 28466, 24115, 36076, 33081,

 12371     36249, 34756, 36685, 37754, 36889, 35998, 37341, 20597, 35386, 37806,

 12372     38499, 24128, 30309, 37165, 35657, 32340, 32887, 22519, 34937, 32025,

 12373     25711, 25842, 24159, 36074, 28399, 37912, 32066, 31278, 33131, 34886,

 12374     35589, 36600, 30394, 26205, 39519, 35576, 35461, 29165, 30682, 22225,

 12375     36015, 37956, 31689, 39376, 23560, 30938, 36681, 36090, 27137, 33674,

 12376     35037, 22941, 22767, 29376, 37648, 36101, 22684, 32180, 35524, 28310,

 12377     28609, 36039, 28460, 32156, 32317, 32305, 37138, 35419, 32068, 38013,

 12378     21959, 21401, 21428, 38760, 36107, 21293, 21297, 36094, 21060, 21132,

 12379     21108, 20660, 20480, 20630, 20757, 20738, 20756, 20796, 20791, 20712,

 12380     20674, 20795, 20752, 20794, 20681, 31988, 40652, 22213, 40172, 35131,

 12381     33248, 35329, 35344, 35340, 35349, 35635, 35406, 35365, 35393, 35382,

 12382     35398, 35412, 35416, 35410, 35462, 35460, 35455, 35440, 35452, 35445,

 12383     35436, 35438, 35533, 35554, 35425, 35482, 35493, {f: 2, c: 35473}, 35535,

 12384     35537, 35529, 35547, 35543, 35522, 35510, 35574, 35563, 35604, 35585,

 12385     35556, 35565, 35580, 35571, 35558, 35566, 35550, 35624, 35740, 35606,

 12386     35610, 35600, 35627, 35629, 35670, 35673, 35662, 35742, 35691, 35734,

 12387     38488, 37178, 37140, 37172, 37087, 37174, 37126, 37192, 33467, 21233,

 12388     24048, 22538, 22745, 22754, 22752, 22746, 22497, 22607, 22550, 22610,

 12389     22557, 22628, 34188, 34131, 34294, 33703, 33799, 34031, 33511, 34338,

 12390     34086, 22603, 29026, 34136, 34045, 34126, 34184, 34234, 29334, 28366,

 12391     34113, 34254, 34130, 33984, 33874, 33892, 33940, 33845, 34207, 34133,

 12392     40367, 33939, 32264, 34118, 34146, 34078, 39488, 34362, 37795, 34167,

 12393     34334, 34298, 34308, 34282, 34330, 22889, 23607, 25451, 25718, 25759,

 12394     25681, 25692, 25779, 25860, 25878, 25847, 25852, 25883, 22064, 22072,

 12395     22216, 22182, 21764, 21692, 22144, 22109, 22112, 22069, 22006, 22118,

 12396     22130, 22156, 22117, 22044, 22062, 21993, 22038, 22208, 22029, 22195,

 12397     22209, 22127, 36705, 22198, 22165, 22279, 24131, 24172, 24152, 24151,

 12398     23943, 23796, 23888, 23852, 23975, 23968, 23959, 23821, 23992, 23937,

 12399     24020, 24480, 29559, 29505, 29546, 29499, 29547, 29568, 29564, 39136,

 12400     39219, 39145, 39228, {f: 2, c: 39146}, 39149, 39156, 39177, 39185, 39195,

 12401     39223, 39231, 39235, {f: 3, c: 39240}, 39244, 39266, 24289, 36065, 25082,

 12402     25006, 24938, 24894, 24757, 24884, 25036, 24927, 25064, 24827, 24887,

 12403     24818, 24947, 24860, 24978, 38274, 38278, 38344, 38286, 38292, 38284,

 12404     38373, 38317, 38315, 39726, 38316, 38334, 38326, 39721, 38335, 38333,

 12405     38332, 38339, 38347, 38356, 38352, 38357, 38366, 28739, 28505, 28711,

 12406     28696, 28668, 28039, 28025, 28254, 28590, 28687, 28408, 28527, 28150,

 12407     28543, 28678, 28576, 28683, 28775, 28740, 28677, 28535, 28704, 28703,

 12408     28722, 28712, 28765, 39467, 36999, 36885, 37008, 23656, 24371, 23285,

 12409     23255, 23296, 23149, 23304, 23372, 23207, 23291, 23307, 23329, 23338,

 12410     23321, 39380, 39391, 39385, 39478, 39515, 39377, 39384, 39501, 39498,

 12411     39394, 39530, 39439, 39437, 39429, 39490, 39469, 39446, 39489, 39470,

 12412     39480, {f: 2, c: 39491}, 39503, 39525, 39524, 31993, 32006, 32002,

 12413     {f: 2, c: 32007}, 32394, 32028, 32021, 32019, 32058, 32050, 32049, 32272,

 12414     32060, 32064, 32063, 32093, 32078, 32115, 32134, 32131, 32136, 32190,

 12415     32186, 32203, 32212, 32196, 32158, 32172, 32185, 32163, 32176, 32199,

 12416     32217, 32215, 32249, 32242, 32354, 32230, 32246, 32241, 32267, 32225,

 12417     32265, 32285, 32287, 32286, 32301, 32266, 32273, 32381, 32313, 32309,

 12418     32306, 32326, 32325, 32392, 32346, 32338, 32366, 32382, 32368, 32367,

 12419     32408, 29859, 29771, 29903, 38922, 29885, 29759, 29833, 29862, 29908,

 12420     29914, 38873, 38878, 38876, 27050, 27370, 26776, 26838, 27141, 26783,

 12421     27355, 27379, 27368, 27359, 27273, 26895, 27208, 26984, 27071, 27194,

 12422     27292, 27410, 27422, 27357, 27111, 27407, 27414, 27372, 27354, 27384,

 12423     27315, 27367, 27299, 27347, 27358, 27556, 27550, 27566, 27563, 27567,

 12424     36564, 36571, 36594, 36603, 36708, 36601, 36604, 36587, 36580, 36706,

 12425     36602, 36606, 36618, 36615, 36613, 36626, 36646, {f: 2, c: 36638}, 36636,

 12426     36659, 36678, 36692, 25108, 25127, 29964, 26311, 26308, 26249, 26326,

 12427     36033, 36016, 36026, 36029, 36100, 36018, 36037, 36112, 36049, 36058,

 12428     36053, 36075, 36071, 36091, 35224, 35244, 35233, 35263, 35238, 35247,

 12429     35250, 35255, 27647, 27660, 27692, 29272, 26407, 33110, 33242, 33051,

 12430     33214, 33121, 33231, 27487, {f: 2, c: 39086}, 39094, 39100, 39110, 39112,

 12431     36674, 40783, 26005, 29036, 29010, 29079, 29121, 29148, 29182, 31152,

 12432     31118, 31146, 25055, 24932, 25059, 25095, 28585, 30959, 30893, 30824,

 12433     30904, 31018, 31025, 30820, 30973, 30951, 30947, 40853, 30616, 30558,

 12434     30652, 32646, 32648, {f: 3, c: 37330}, 37337, 37335, 37333, 37367, 37351,

 12435     37348, 37702, 37365, 37369, 37384, 37414, 37445, 37393, 37392, 37377,

 12436     37415, 37380, 37413, 37376, 37434, 37478, 37431, 37427, 37461, 37437,

 12437     37432, 37470, {f: 2, c: 37484}, 37439, 37984, 37424, 37449, 37448, 37453,

 12438     37422, 37433, 37944, 37548, 37536, 37498, 37546, 37614, 37583, 37891,

 12439     37603, 37946, 37553, 37542, 37799, 37526, 37580, 37545, 37877, 37523,

 12440     37503, 37801, 37530, 37658, 37547, 37507, 37899, 37544, 37539, 37906,

 12441     37688, 37617, 37847, 37605, 37616, 37615, 37608, 37564, 37597, 37622,

 12442     {f: 2, c: 37926}, 37571, 37599, 37606, 37650, 37638, 37737, 37659, 37696,

 12443     37633, 37653, 37678, 37699, {f: 2, c: 37639}, 37663, 37657, 37733, 37703,

 12444     37750, 37716, 37732, 37802, 37744, 37764, 37860, 37848, 37928, 37767,

 12445     37836, 37784, 37816, 37823, 37798, 37808, 37813, 37964, 37858,

 12446     {f: 2, c: 37852}, 37837, 37854, 37827, 37831, 37841, 37908, 37917, 37879,

 12447     37989, 37907, 37997, 37920, 38009, 37881, 37913, 37962, 37938, 37951,

 12448     37972, 37987, 37758, 31329, 40169, 40182, 40199, 40198, 40227, 40327,

 12449     40469, 40221, 40223, 40421, 40239, 40409, 40240, 40258, 40478, 40275,

 12450     40477, 40288, 40274, 40435, 40284, 40289, 40339, 40298, 40303, 40329,

 12451     40344, 40346, 40384, 40357, 40361, 40386, 40380, 40474, 40403, 40410,

 12452     40431, 40422, 40434, 40440, 40460, 40442, 40475, 30308, 30296, 30311,

 12453     30210, {f: 2, c: 30278}, 30281, 30238, 30267, {f: 2, c: 30317}, 30313,

 12454     30322, 31431, 31414, 35168, 35123, 35165, 35143, 35128, 35172, 30392,

 12455     32814, 32812, 32889, 32885, 38919, {f: 2, c: 38926}, 38945, 38940, 28481,

 12456     38950, 38967, 38990, 38995, 39027, 39010, 39001, 39013, 39020, 39024,

 12457     34787, 34822, 34566, 34851, 34806, 34554, 34799, 34692, 34832, 34760,

 12458     34833, 34747, 34766, 32588, 31716, 31591, 31849, 31731, 31744, 31691,

 12459     31836, 31774, 31787, 31779, 31850, 31839, 33380, 33387, 35018, 32677,

 12460     31986, 31990, 31965, 32310, 40617, 36274, 37317, 37315, 40570, 36489,

 12461     36428, 36498, 36474, 36437, 36506, 36491, 36499, 36497, 36513, 36451,

 12462     36522, 36518, 35316, 35318, 38746, 38722, 38717, 38724, 40788, 40799,

 12463     40793, 40800, 40796, 40806, 40812, 40810, 40823, [12236, 40701], 40703,

 12464     40713, 35726, 38014, 37864, 39799, 39796, 39809, 39811, 39822, 40056,

 12465     31308, 39826, 40031, 39824, 39853, 39834, 39850, 39838, 40045, 39851,

 12466     39837, 40024, 39873, 40058, 39985, 39993, 39971, 39991, 39872, 39882,

 12467     39879, 39933, 39894, {f: 2, c: 39914}, 39905, 39908, 39911, 39901, 39906,

 12468     39920, 39899, 39924, 39892, 40029, 39944, 39952, 39949, 39954, 39945,

 12469     39935, 39968, 39986, 39981, 39976, 39973, 39977, 39987, 39998, 40008,

 12470     39995, 39989, 40005, 40022, 40020, 40018, 40039, 38851, 38845, 38857,

 12471     40379, 39631, 39638, 39637, 39768, 39758, 39255, 39260, 39714, 40695,

 12472     40690, 35180, 38342, 37686, 24390, 34068, 32404, 40803, 22137, 40725,

 12473     22081, 39662, 35079, 31296, 39091, 38308, 39693, 36852, 24409, 31339,

 12474     39138, 20642, 34193, 20760, 25458, 21067, 30543, 32397, 26310, 30637,

 12475     [12228, 40565], 22217, 40692, 28635, 25054, 30663, 28720, 40629, 34890,

 12476     38370, 38854, 31844, 32308, 38822, 40623, 22220, 39089, 27311, 32590,

 12477     31984, 20418, 32363, 40569, 22190, 39706, 33903, 31142, 31858, 39634,

 12478     38587, 32251, 35069, 30787, {f: 10, c: 8560}, {f: 2, c: 714}, 729, 8211,

 12479     8213, 8229, 8245, 8453, 8457, {f: 4, c: 8598}, 8725, 8735, 8739, 8786,

 12480     {f: 2, c: 8806}, 8895, {f: 36, c: 9552}, {f: 15, c: 9601}, {f: 3, c: 9619},

 12481     {f: 2, c: 9660}, {f: 4, c: 9698}, 9737, 8853, 12306, {f: 2, c: 12317},

 12482     {f: 9, c: 12321}, 12963, {f: 2, c: 13198}, {f: 3, c: 13212}, 13217, 13252,

 12483     13262, {f: 2, c: 13265}, 13269, 65072, 65506, 65508, 8481, 12849, 8208,

 12484     12540, {f: 2, c: 12443}, {f: 2, c: 12541}, 12294, {f: 2, c: 12445},

 12485     {f: 10, c: 65097}, {f: 4, c: 65108}, {f: 14, c: 65113}, {f: 4, c: 65128},

 12486     12350, {f: 12, c: 12272}, 19970, {f: 3, c: 19972}, 19983, 19986, 19991,

 12487     {f: 3, c: 19999}, 20003, 20006, 20009, {f: 2, c: 20014}, 20017, 20019,

 12488     20021, 20023, 20028, {f: 3, c: 20032}, 20036, 20038, 20042, 20049, 20053,

 12489     20055, {f: 2, c: 20058}, {f: 4, c: 20066}, {f: 2, c: 20071},

 12490     {f: 6, c: 20074}, 20082, {f: 10, c: 20084}, {f: 3, c: 20095},

 12491     {f: 2, c: 20099}, [12037, 20101], 20103, 20106, 20112, {f: 2, c: 20118},

 12492     20121, {f: 2, c: 20124}, 20131, 20138, {f: 3, c: 20143}, 20148,

 12493     {f: 4, c: 20150}, {f: 3, c: 20156}, 20168, 20172, {f: 2, c: 20175}, 20178,

 12494     {f: 3, c: 20186}, 20192, 20194, {f: 2, c: 20198}, 20201, {f: 3, c: 20205},

 12495     20209, 20212, {f: 3, c: 20216}, 20220, 20222, 20224, {f: 7, c: 20226},

 12496     {f: 2, c: 20235}, {f: 5, c: 20242}, {f: 2, c: 20252}, 20257, 20259,

 12497     {f: 2, c: 20264}, {f: 3, c: 20268}, 20273, 20275, 20277, 20279, 20281,

 12498     20283, {f: 5, c: 20286}, {f: 2, c: 20292}, {f: 6, c: 20295}, 20306, 20308,

 12499     20310, {f: 2, c: 20321}, 20326, 20328, {f: 2, c: 20330}, {f: 2, c: 20333},

 12500     {f: 2, c: 20337}, 20341, {f: 4, c: 20343}, 20349, {f: 3, c: 20352}, 20357,

 12501     20359, 20362, 20364, 20366, 20368, {f: 2, c: 20370}, 20373,

 12502     {f: 3, c: 20376}, 20380, {f: 2, c: 20382}, {f: 2, c: 20385}, 20388, 20395,

 12503     20397, {f: 5, c: 20400}, {f: 9, c: 20406}, {f: 2, c: 20416},

 12504     {f: 4, c: 20422}, {f: 3, c: 20427}, {f: 5, c: 20434}, 20441, 20443, 20450,

 12505     {f: 2, c: 20452}, 20455, {f: 2, c: 20459}, 20464, 20466, {f: 4, c: 20468},

 12506     20473, {f: 3, c: 20475}, 20479, {f: 5, c: 20481}, {f: 2, c: 20487}, 20490,

 12507     20494, 20496, 20499, {f: 3, c: 20501}, 20507, {f: 2, c: 20509}, 20512,

 12508     {f: 3, c: 20514}, 20519, {f: 11, c: 20527}, 20539, 20541, {f: 4, c: 20543},

 12509     {f: 3, c: 20548}, {f: 2, c: 20554}, 20557, {f: 5, c: 20560},

 12510     {f: 4, c: 20566}, 20571, {f: 8, c: 20573}, {f: 6, c: 20582},

 12511     {f: 7, c: 20589}, {f: 3, c: 20600}, {f: 2, c: 20604}, {f: 4, c: 20609},

 12512     {f: 2, c: 20614}, {f: 4, c: 20617}, {f: 8, c: 20622}, 20631,

 12513     {f: 8, c: 20634}, 20644, 20646, {f: 2, c: 20650}, {f: 4, c: 20654}, 20662,

 12514     {f: 2, c: 20664}, {f: 2, c: 20668}, {f: 3, c: 20671}, {f: 2, c: 20675},

 12515     {f: 3, c: 20678}, {f: 5, c: 20682}, 20688, {f: 3, c: 20690},

 12516     {f: 3, c: 20695}, {f: 3, c: 20699}, {f: 6, c: 20703}, {f: 3, c: 20713},

 12517     {f: 4, c: 20719}, 20724, {f: 3, c: 20726}, 20730, {f: 4, c: 20732}, 20737,

 12518     20739, 20741, 20746, {f: 4, c: 20748}, 20753, 20755, {f: 2, c: 20758},

 12519     {f: 6, c: 20761}, 20768, {f: 8, c: 20770}, {f: 7, c: 20779},

 12520     {f: 4, c: 20787}, {f: 2, c: 20792}, {f: 2, c: 20797}, 20802, 20807, 20810,

 12521     20812, {f: 3, c: 20814}, 20819, {f: 3, c: 20823}, 20827, {f: 5, c: 20829},

 12522     {f: 2, c: 20835}, {f: 2, c: 20838}, 20842, 20847, 20850, 20858,

 12523     {f: 2, c: 20862}, {f: 2, c: 20867}, {f: 2, c: 20870}, {f: 2, c: 20874},

 12524     {f: 4, c: 20878}, {f: 2, c: 20883}, 20888, 20890, {f: 3, c: 20893}, 20897,

 12525     20899, {f: 5, c: 20902}, {f: 2, c: 20909}, 20916, {f: 3, c: 20920},

 12526     {f: 2, c: 20926}, {f: 3, c: 20929}, 20933, 20936, 20938, 20942, 20944,

 12527     {f: 9, c: 20946}, 20956, {f: 2, c: 20958}, {f: 2, c: 20962},

 12528     {f: 6, c: 20965}, 20972, 20974, 20978, 20980, 20983, 20990,

 12529     {f: 2, c: 20996}, 21001, {f: 2, c: 21003}, {f: 2, c: 21007},

 12530     {f: 3, c: 21011}, 21020, {f: 2, c: 21022}, {f: 3, c: 21025},

 12531     {f: 3, c: 21029}, 21034, 21036, 21039, {f: 2, c: 21041}, {f: 2, c: 21044},

 12532     21052, 21054, {f: 2, c: 21061}, {f: 2, c: 21064}, {f: 2, c: 21070},

 12533     {f: 2, c: 21074}, 21077, {f: 4, c: 21079}, 21085, {f: 2, c: 21087},

 12534     {f: 3, c: 21090}, 21094, 21096, {f: 3, c: 21099}, {f: 2, c: 21104}, 21107,

 12535     {f: 7, c: 21110}, 21118, 21120, {f: 3, c: 21124}, 21131, {f: 2, c: 21134},

 12536     21138, {f: 7, c: 21140}, 21148, {f: 4, c: 21156}, {f: 3, c: 21166},

 12537     {f: 10, c: 21172}, 21184, 21186, {f: 3, c: 21188}, 21192, 21194,

 12538     {f: 4, c: 21196}, 21201, {f: 2, c: 21203}, 21207, 21210, 21212,

 12539     {f: 2, c: 21216}, 21219, {f: 11, c: 21221}, {f: 3, c: 21234},

 12540     {f: 2, c: 21238}, {f: 3, c: 21243}, {f: 4, c: 21249}, 21255,

 12541     {f: 4, c: 21257}, 21262, {f: 4, c: 21265}, 21272, {f: 2, c: 21275},

 12542     {f: 2, c: 21278}, 21282, {f: 2, c: 21284}, {f: 3, c: 21287},

 12543     {f: 2, c: 21291}, 21296, {f: 6, c: 21298}, [12054, 21304],

 12544     {f: 2, c: 21308}, 21314, 21316, 21318, {f: 3, c: 21323}, 21328,

 12545     {f: 2, c: 21336}, 21339, 21341, 21349, 21352, 21354, {f: 2, c: 21356},

 12546     21362, 21366, 21369, {f: 4, c: 21371}, {f: 2, c: 21376}, 21379,

 12547     {f: 2, c: 21383}, 21386, {f: 7, c: 21390}, {f: 2, c: 21398},

 12548     {f: 2, c: 21403}, 21406, 21409, 21412, 21415, {f: 3, c: 21418},

 12549     {f: 3, c: 21423}, 21427, 21429, {f: 4, c: 21431}, {f: 3, c: 21436}, 21440,

 12550     {f: 4, c: 21444}, {f: 3, c: 21454}, {f: 2, c: 21458}, 21461, 21466,

 12551     {f: 3, c: 21468}, 21473, 21479, 21492, 21498, {f: 3, c: 21502}, 21506,

 12552     21509, 21511, 21515, 21524, {f: 3, c: 21528}, 21532, 21538,

 12553     {f: 2, c: 21540}, 21546, 21552, 21555, {f: 2, c: 21558}, 21562, 21565,

 12554     21567, {f: 2, c: 21569}, {f: 2, c: 21572}, 21575, 21577, {f: 4, c: 21580},

 12555     21585, 21594, {f: 5, c: 21597}, 21603, 21605, 21607, {f: 8, c: 21609},

 12556     21620, {f: 2, c: 21625}, {f: 2, c: 21630}, 21633, 21635, 21637,

 12557     {f: 4, c: 21639}, 21645, 21649, 21651, {f: 2, c: 21655}, 21660,

 12558     {f: 5, c: 21662}, 21669, 21678, 21680, 21682, {f: 3, c: 21685},

 12559     {f: 2, c: 21689}, 21694, 21699, 21701, {f: 2, c: 21706}, 21718, 21720,

 12560     21723, 21728, {f: 3, c: 21730}, {f: 2, c: 21739}, {f: 3, c: 21743},

 12561     {f: 6, c: 21748}, 21755, 21758, 21760, {f: 2, c: 21762}, 21765, 21768,

 12562     {f: 5, c: 21770}, {f: 2, c: 21778}, {f: 6, c: 21781}, {f: 4, c: 21788},

 12563     21793, {f: 2, c: 21797}, {f: 2, c: 21800}, 21803, 21805, 21810,

 12564     {f: 3, c: 21812}, {f: 4, c: 21816}, 21821, 21824, 21826, 21829,

 12565     {f: 2, c: 21831}, {f: 4, c: 21835}, {f: 2, c: 21841}, 21844,

 12566     {f: 5, c: 21847}, 21853, {f: 2, c: 21855}, {f: 2, c: 21858},

 12567     {f: 2, c: 21864}, 21867, {f: 6, c: 21871}, {f: 2, c: 21881}, 21885, 21887,

 12568     {f: 2, c: 21893}, {f: 3, c: 21900}, 21904, {f: 2, c: 21906},

 12569     {f: 3, c: 21909}, {f: 2, c: 21914}, 21918, {f: 7, c: 21920},

 12570     {f: 2, c: 21928}, 21931, 21933, {f: 2, c: 21935}, 21940, 21942, 21944,

 12571     21946, 21948, {f: 5, c: 21951}, 21960, {f: 2, c: 21962}, {f: 2, c: 21967},

 12572     21973, {f: 3, c: 21975}, 21979, 21982, 21984, 21986, 21991,

 12573     {f: 2, c: 21997}, {f: 2, c: 22000}, 22004, {f: 5, c: 22008}, 22015,

 12574     {f: 4, c: 22018}, 22023, {f: 2, c: 22026}, {f: 4, c: 22032}, 22037,

 12575     {f: 2, c: 22041}, 22045, {f: 3, c: 22048}, {f: 2, c: 22053}, 22056,

 12576     {f: 2, c: 22058}, 22067, 22071, 22074, {f: 3, c: 22076}, 22080,

 12577     {f: 10, c: 22082}, {f: 5, c: 22095}, {f: 2, c: 22101}, {f: 2, c: 22106},

 12578     {f: 2, c: 22110}, 22113, 22115, 22119, {f: 2, c: 22125}, 22128, 22131,

 12579     22133, 22135, 22138, {f: 3, c: 22141}, {f: 4, c: 22145}, {f: 4, c: 22152},

 12580     22157, {f: 3, c: 22160}, 22164, {f: 3, c: 22166}, {f: 9, c: 22170},

 12581     {f: 2, c: 22180}, 22183, {f: 5, c: 22185}, {f: 3, c: 22192}, 22197,

 12582     {f: 4, c: 22200}, {f: 3, c: 22205}, {f: 2, c: 22211}, {f: 2, c: 22214},

 12583     22219, {f: 4, c: 22221}, {f: 2, c: 22226}, {f: 2, c: 22229},

 12584     {f: 2, c: 22232}, 22236, 22243, {f: 6, c: 22245}, 22252, {f: 2, c: 22254},

 12585     {f: 2, c: 22258}, {f: 3, c: 22262}, {f: 2, c: 22267}, {f: 3, c: 22272},

 12586     22277, 22284, {f: 4, c: 22286}, {f: 2, c: 22292}, 22295, {f: 3, c: 22297},

 12587     {f: 2, c: 22301}, {f: 3, c: 22304}, {f: 4, c: 22308}, 22315,

 12588     {f: 2, c: 22321}, {f: 5, c: 22324}, {f: 2, c: 22332}, 22335, 22337,

 12589     {f: 4, c: 22339}, {f: 2, c: 22344}, 22347, {f: 5, c: 22354},

 12590     {f: 2, c: 22360}, {f: 2, c: 22370}, 22373, 22375, 22380, 22382,

 12591     {f: 3, c: 22384}, {f: 2, c: 22388}, {f: 3, c: 22392}, {f: 5, c: 22397},

 12592     {f: 4, c: 22407}, {f: 5, c: 22413}, {f: 7, c: 22420}, {f: 4, c: 22428},

 12593     22437, 22440, 22442, 22444, {f: 3, c: 22447}, 22451, {f: 3, c: 22453},

 12594     {f: 9, c: 22457}, {f: 7, c: 22468}, {f: 2, c: 22476}, {f: 2, c: 22480},

 12595     22483, {f: 2, c: 22486}, {f: 2, c: 22491}, 22494, {f: 2, c: 22498},

 12596     {f: 8, c: 22501}, 22510, {f: 4, c: 22512}, {f: 2, c: 22517},

 12597     {f: 2, c: 22523}, {f: 2, c: 22526}, 22529, {f: 2, c: 22531},

 12598     {f: 2, c: 22536}, 22540, {f: 3, c: 22542}, {f: 3, c: 22546},

 12599     {f: 2, c: 22551}, {f: 3, c: 22554}, 22559, {f: 2, c: 22562},

 12600     {f: 5, c: 22565}, {f: 4, c: 22571}, {f: 2, c: 22578}, {f: 14, c: 22582},

 12601     {f: 5, c: 22597}, 22606, 22608, 22611, {f: 2, c: 22613}, {f: 5, c: 22617},

 12602     {f: 3, c: 22623}, 22627, {f: 5, c: 22630}, {f: 8, c: 22637},

 12603     {f: 3, c: 22646}, {f: 4, c: 22650}, 22655, 22658, 22660, {f: 3, c: 22662},

 12604     {f: 7, c: 22667}, {f: 5, c: 22676}, 22683, 22685, {f: 8, c: 22688},

 12605     {f: 4, c: 22698}, {f: 4, c: 22703}, {f: 7, c: 22708}, 22717,

 12606     {f: 2, c: 22719}, {f: 3, c: 22722}, 22726, {f: 9, c: 22728}, 22738, 22740,

 12607     {f: 2, c: 22742}, {f: 3, c: 22747}, 22753, 22755, {f: 4, c: 22757}, 22762,

 12608     22765, {f: 2, c: 22769}, {f: 2, c: 22772}, {f: 2, c: 22775},

 12609     {f: 2, c: 22779}, {f: 4, c: 22782}, 22787, {f: 2, c: 22789},

 12610     {f: 2, c: 22792}, [12066, 22794], {f: 2, c: 22795}, 22798,

 12611     {f: 4, c: 22800}, {f: 2, c: 22807}, 22811, {f: 2, c: 22813},

 12612     {f: 2, c: 22816}, 22819, 22822, 22824, 22828, 22832, {f: 2, c: 22834},

 12613     {f: 2, c: 22837}, 22843, 22845, {f: 2, c: 22847}, 22851, {f: 2, c: 22853},

 12614     22858, {f: 2, c: 22860}, 22864, {f: 2, c: 22866}, 22873, {f: 5, c: 22875},

 12615     22881, {f: 2, c: 22883}, {f: 3, c: 22886}, 22891, 22893, {f: 4, c: 22895},

 12616     22901, 22903, {f: 3, c: 22906}, {f: 3, c: 22910}, 22917, 22921,

 12617     {f: 2, c: 22923}, {f: 4, c: 22926}, {f: 2, c: 22932}, 22936,

 12618     {f: 3, c: 22938}, {f: 4, c: 22943}, {f: 2, c: 22950}, {f: 2, c: 22956},

 12619     {f: 2, c: 22960}, {f: 6, c: 22963}, 22970, {f: 2, c: 22972},

 12620     {f: 7, c: 22975}, {f: 3, c: 22983}, {f: 4, c: 22988}, {f: 2, c: 22997},

 12621     23001, 23003, {f: 5, c: 23006}, 23012, {f: 2, c: 23014}, {f: 3, c: 23017},

 12622     {f: 12, c: 23021}, 23034, {f: 3, c: 23036}, 23040, 23042, {f: 2, c: 23050},

 12623     {f: 4, c: 23053}, 23058, {f: 4, c: 23060}, {f: 3, c: 23065},

 12624     {f: 2, c: 23069}, {f: 2, c: 23073}, 23076, {f: 3, c: 23078},

 12625     {f: 7, c: 23082}, 23091, 23093, {f: 5, c: 23095}, {f: 3, c: 23101},

 12626     {f: 4, c: 23106}, {f: 2, c: 23111}, {f: 10, c: 23115}, {f: 4, c: 23126},

 12627     {f: 7, c: 23131}, {f: 3, c: 23139}, {f: 2, c: 23144}, {f: 2, c: 23147},

 12628     {f: 6, c: 23150}, {f: 2, c: 23160}, {f: 4, c: 23163}, {f: 18, c: 23168},

 12629     {f: 7, c: 23187}, {f: 11, c: 23196}, {f: 2, c: 23208}, {f: 7, c: 23211},

 12630     23220, {f: 2, c: 23222}, {f: 4, c: 23225}, {f: 2, c: 23231},

 12631     {f: 6, c: 23235}, {f: 2, c: 23242}, {f: 5, c: 23245}, 23251, 23253,

 12632     {f: 3, c: 23257}, {f: 3, c: 23261}, 23266, {f: 2, c: 23268},

 12633     {f: 2, c: 23271}, 23274, {f: 5, c: 23276}, {f: 3, c: 23282},

 12634     {f: 5, c: 23286}, {f: 4, c: 23292}, {f: 7, c: 23297}, 23306,

 12635     {f: 9, c: 23309}, 23320, {f: 7, c: 23322}, {f: 8, c: 23330},

 12636     {f: 5, c: 23339}, 23345, 23347, {f: 2, c: 23349}, {f: 7, c: 23353},

 12637     {f: 11, c: 23361}, {f: 3, c: 23373}, 23378, 23382, 23390, {f: 2, c: 23392},

 12638     {f: 2, c: 23399}, {f: 3, c: 23405}, 23410, 23412, {f: 2, c: 23414}, 23417,

 12639     {f: 2, c: 23419}, 23422, 23426, 23430, 23434, {f: 2, c: 23437},

 12640     {f: 3, c: 23440}, 23444, 23446, 23455, {f: 3, c: 23463}, {f: 4, c: 23468},

 12641     {f: 2, c: 23473}, 23479, {f: 3, c: 23482}, {f: 2, c: 23488}, 23491,

 12642     {f: 4, c: 23496}, {f: 3, c: 23501}, 23505, {f: 9, c: 23508}, 23520, 23523,

 12643     23530, 23533, 23535, {f: 4, c: 23537}, 23543, {f: 2, c: 23549}, 23552,

 12644     {f: 2, c: 23554}, 23557, 23564, 23568, {f: 2, c: 23570}, 23575, 23577,

 12645     23579, {f: 4, c: 23582}, 23587, 23590, {f: 4, c: 23592}, {f: 4, c: 23597},

 12646     {f: 2, c: 23602}, {f: 2, c: 23605}, {f: 2, c: 23619}, {f: 2, c: 23622},

 12647     {f: 2, c: 23628}, {f: 3, c: 23634}, {f: 3, c: 23638}, {f: 4, c: 23642},

 12648     23647, 23655, {f: 3, c: 23657}, 23661, 23664, {f: 7, c: 23666},

 12649     {f: 4, c: 23675}, 23680, {f: 5, c: 23683}, {f: 3, c: 23689},

 12650     {f: 2, c: 23694}, {f: 2, c: 23698}, 23701, {f: 4, c: 23709},

 12651     {f: 5, c: 23716}, 23722, {f: 3, c: 23726}, 23730, 23732, 23734,

 12652     {f: 4, c: 23737}, 23742, 23744, {f: 2, c: 23746}, {f: 6, c: 23749},

 12653     {f: 6, c: 23756}, {f: 6, c: 23763}, {f: 7, c: 23770}, {f: 2, c: 23778},

 12654     23783, 23785, {f: 2, c: 23787}, {f: 2, c: 23790}, {f: 3, c: 23793}, 23797,

 12655     {f: 4, c: 23799}, 23804, {f: 4, c: 23806}, {f: 2, c: 23812},

 12656     {f: 5, c: 23816}, {f: 5, c: 23823}, 23829, {f: 3, c: 23832},

 12657     {f: 2, c: 23836}, {f: 5, c: 23839}, 23845, 23848, {f: 2, c: 23850},

 12658     {f: 5, c: 23855}, {f: 8, c: 23861}, {f: 8, c: 23871}, {f: 2, c: 23880},

 12659     {f: 3, c: 23885}, {f: 7, c: 23889}, {f: 2, c: 23897}, 23900,

 12660     {f: 11, c: 23902}, 23914, {f: 2, c: 23917}, {f: 4, c: 23920},

 12661     {f: 12, c: 23925}, 23939, {f: 2, c: 23941}, {f: 15, c: 23944}, 23960,

 12662     {f: 3, c: 23962}, {f: 2, c: 23966}, {f: 6, c: 23969}, {f: 15, c: 23976},

 12663     23993, 23995, {f: 8, c: 23997}, {f: 5, c: 24006}, 24012, {f: 4, c: 24014},

 12664     24019, {f: 6, c: 24021}, 24028, {f: 2, c: 24031}, {f: 2, c: 24035}, 24042,

 12665     {f: 2, c: 24044}, {f: 2, c: 24053}, {f: 5, c: 24056}, {f: 2, c: 24063},

 12666     24068, 24071, {f: 3, c: 24073}, {f: 2, c: 24077}, {f: 2, c: 24082}, 24087,

 12667     {f: 7, c: 24094}, {f: 3, c: 24104}, 24108, {f: 2, c: 24111}, 24114,

 12668     {f: 2, c: 24116}, {f: 2, c: 24121}, {f: 2, c: 24126}, 24129,

 12669     {f: 6, c: 24134}, {f: 7, c: 24141}, 24150, {f: 2, c: 24153},

 12670     {f: 2, c: 24156}, 24160, {f: 7, c: 24164}, {f: 5, c: 24173}, 24181, 24183,

 12671     {f: 3, c: 24193}, 24197, {f: 2, c: 24200}, {f: 3, c: 24204}, 24210, 24216,

 12672     24219, 24221, {f: 4, c: 24225}, {f: 3, c: 24232}, 24236, {f: 5, c: 24238},

 12673     24244, {f: 4, c: 24250}, {f: 10, c: 24255}, {f: 6, c: 24267},

 12674     {f: 2, c: 24276}, {f: 4, c: 24279}, {f: 3, c: 24284}, {f: 4, c: 24292},

 12675     24297, 24299, {f: 6, c: 24301}, 24309, {f: 2, c: 24312}, {f: 3, c: 24315},

 12676     {f: 3, c: 24325}, 24329, {f: 3, c: 24332}, 24336, 24338, 24340, 24342,

 12677     {f: 2, c: 24345}, {f: 3, c: 24348}, {f: 4, c: 24353}, 24360,

 12678     {f: 2, c: 24363}, 24366, 24368, 24370, 24372, {f: 3, c: 24374}, 24379,

 12679     {f: 3, c: 24381}, {f: 5, c: 24385}, 24391, {f: 3, c: 24393}, 24397, 24399,

 12680     24401, 24404, {f: 3, c: 24410}, {f: 3, c: 24414}, 24419, 24421,

 12681     {f: 2, c: 24423}, 24427, {f: 2, c: 24430}, 24434, {f: 3, c: 24436}, 24440,

 12682     24442, {f: 3, c: 24445}, 24451, 24454, {f: 3, c: 24461}, {f: 2, c: 24467},

 12683     24470, {f: 2, c: 24474}, 24477, 24479, {f: 6, c: 24482}, {f: 2, c: 24491},

 12684     {f: 6, c: 24495}, 24502, 24504, {f: 2, c: 24506}, {f: 5, c: 24510},

 12685     {f: 2, c: 24519}, {f: 2, c: 24522}, 24526, {f: 3, c: 24531},

 12686     {f: 3, c: 24538}, {f: 2, c: 24542}, {f: 2, c: 24546}, {f: 2, c: 24549},

 12687     {f: 2, c: 24552}, 24556, {f: 2, c: 24559}, {f: 3, c: 24562},

 12688     {f: 2, c: 24566}, {f: 2, c: 24569}, 24572, {f: 3, c: 24583},

 12689     {f: 2, c: 24587}, {f: 2, c: 24592}, 24595, {f: 2, c: 24599}, 24602,

 12690     {f: 2, c: 24606}, {f: 3, c: 24610}, {f: 3, c: 24620}, {f: 5, c: 24624},

 12691     {f: 5, c: 24630}, {f: 2, c: 24637}, 24640, {f: 7, c: 24644}, 24652,

 12692     {f: 2, c: 24654}, 24657, {f: 2, c: 24659}, {f: 3, c: 24662},

 12693     {f: 2, c: 24667}, {f: 4, c: 24670}, {f: 2, c: 24677}, 24686,

 12694     {f: 2, c: 24689}, {f: 2, c: 24692}, 24695, 24702, {f: 3, c: 24704},

 12695     {f: 4, c: 24709}, {f: 2, c: 24714}, {f: 4, c: 24718}, 24723, 24725,

 12696     {f: 3, c: 24727}, 24732, 24734, {f: 2, c: 24737}, {f: 2, c: 24740}, 24743,

 12697     {f: 2, c: 24745}, 24750, 24752, 24755, 24759, {f: 2, c: 24761},

 12698     {f: 8, c: 24765}, {f: 3, c: 24775}, {f: 5, c: 24780}, {f: 3, c: 24786},

 12699     {f: 2, c: 24790}, 24793, 24795, 24798, {f: 4, c: 24802}, 24810, 24821,

 12700     {f: 2, c: 24823}, {f: 4, c: 24828}, {f: 4, c: 24834}, 24839,

 12701     {f: 3, c: 24842}, {f: 5, c: 24848}, {f: 4, c: 24854}, {f: 2, c: 24861},

 12702     {f: 2, c: 24865}, 24869, {f: 3, c: 24872}, {f: 8, c: 24876},

 12703     {f: 2, c: 24885}, {f: 6, c: 24888}, {f: 8, c: 24896}, 24905, 24909,

 12704     {f: 2, c: 24911}, {f: 3, c: 24914}, {f: 2, c: 24918}, 24921,

 12705     {f: 2, c: 24923}, 24926, {f: 2, c: 24928}, {f: 2, c: 24933}, 24937,

 12706     {f: 2, c: 24940}, 24943, {f: 2, c: 24945}, 24948, {f: 10, c: 24952},

 12707     {f: 7, c: 24963}, {f: 2, c: 24972}, 24975, 24979, {f: 5, c: 24981},

 12708     {f: 2, c: 24987}, {f: 6, c: 24990}, {f: 2, c: 24997}, 25002, 25005,

 12709     {f: 3, c: 25007}, {f: 3, c: 25011}, {f: 6, c: 25016}, {f: 3, c: 25023},

 12710     {f: 4, c: 25027}, {f: 4, c: 25037}, 25043, {f: 9, c: 25045},

 12711     {f: 3, c: 25056}, {f: 2, c: 25060}, 25063, {f: 9, c: 25065},

 12712     {f: 2, c: 25075}, 25081, 25083, 25085, {f: 5, c: 25089}, 25097, 25107,

 12713     25113, {f: 3, c: 25116}, 25120, 25123, 25126, {f: 2, c: 25128}, 25131,

 12714     25133, 25135, 25137, 25141, [12094, 25142], {f: 5, c: 25144}, 25154,

 12715     {f: 3, c: 25156}, 25162, {f: 2, c: 25167}, {f: 3, c: 25173},

 12716     {f: 2, c: 25177}, {f: 7, c: 25180}, {f: 2, c: 25188}, 25192,

 12717     {f: 2, c: 25201}, {f: 2, c: 25204}, {f: 2, c: 25207}, {f: 2, c: 25210},

 12718     25213, {f: 3, c: 25217}, {f: 4, c: 25221}, {f: 6, c: 25227}, 25236, 25241,

 12719     {f: 3, c: 25244}, 25251, {f: 2, c: 25254}, {f: 2, c: 25257},

 12720     {f: 4, c: 25261}, {f: 3, c: 25266}, {f: 3, c: 25270}, 25274, 25278,

 12721     {f: 2, c: 25280}, 25283, 25291, 25295, 25297, 25301, {f: 2, c: 25309},

 12722     {f: 2, c: 25312}, 25316, {f: 2, c: 25322}, 25328, 25330, 25333,

 12723     {f: 4, c: 25336}, 25344, {f: 4, c: 25347}, {f: 4, c: 25354},

 12724     {f: 2, c: 25359}, {f: 4, c: 25362}, {f: 3, c: 25367}, 25372,

 12725     {f: 2, c: 25382}, 25385, {f: 3, c: 25388}, {f: 2, c: 25392},

 12726     {f: 6, c: 25395}, {f: 2, c: 25403}, {f: 3, c: 25407}, 25412,

 12727     {f: 2, c: 25415}, 25418, {f: 4, c: 25425}, {f: 8, c: 25430}, 25440,

 12728     {f: 3, c: 25444}, 25450, 25452, {f: 2, c: 25455}, {f: 3, c: 25459},

 12729     {f: 2, c: 25464}, {f: 4, c: 25468}, 25473, {f: 2, c: 25477}, 25483, 25485,

 12730     25489, {f: 3, c: 25491}, 25495, {f: 7, c: 25497}, 25505, 25508, 25510,

 12731     25515, 25519, {f: 2, c: 25521}, {f: 2, c: 25525}, 25529, 25531, 25533,

 12732     25535, {f: 3, c: 25537}, 25541, {f: 2, c: 25543}, {f: 3, c: 25546}, 25553,

 12733     {f: 3, c: 25555}, {f: 3, c: 25559}, {f: 3, c: 25563}, 25567, 25570,

 12734     {f: 5, c: 25572}, {f: 2, c: 25579}, {f: 3, c: 25583}, 25587, 25589, 25591,

 12735     {f: 4, c: 25593}, 25598, {f: 2, c: 25603}, {f: 5, c: 25606}, 25614,

 12736     {f: 2, c: 25617}, {f: 2, c: 25621}, {f: 3, c: 25624}, 25629, 25631,

 12737     {f: 4, c: 25634}, {f: 3, c: 25639}, 25643, {f: 6, c: 25646}, 25653,

 12738     {f: 3, c: 25655}, {f: 2, c: 25659}, 25662, 25664, {f: 2, c: 25666}, 25673,

 12739     {f: 6, c: 25675}, 25683, {f: 3, c: 25685}, {f: 3, c: 25689}, 25693,

 12740     {f: 7, c: 25696}, 25704, {f: 3, c: 25706}, 25710, {f: 3, c: 25712},

 12741     {f: 2, c: 25716}, 25719, {f: 6, c: 25724}, 25731, 25734, {f: 8, c: 25737},

 12742     25748, {f: 2, c: 25751}, {f: 4, c: 25754}, {f: 3, c: 25760},

 12743     {f: 3, c: 25766}, 25770, 25775, 25777, 25780, 25782, 25785, 25789, 25795,

 12744     25798, {f: 2, c: 25800}, 25804, 25807, 25809, 25811, {f: 2, c: 25813},

 12745     25817, {f: 3, c: 25819}, 25823, 25825, 25827, 25829, {f: 5, c: 25831},

 12746     {f: 2, c: 25837}, 25843, {f: 2, c: 25845}, {f: 2, c: 25848}, 25853, 25855,

 12747     {f: 3, c: 25857}, 25861, {f: 2, c: 25863}, {f: 5, c: 25866},

 12748     {f: 2, c: 25872}, 25875, 25877, 25879, 25882, 25884, {f: 4, c: 25886},

 12749     {f: 4, c: 25894}, 25901, {f: 4, c: 25904}, 25911, 25914, {f: 2, c: 25916},

 12750     {f: 5, c: 25920}, {f: 2, c: 25926}, {f: 2, c: 25930}, {f: 2, c: 25933},

 12751     25936, {f: 3, c: 25938}, 25944, 25946, 25948, {f: 3, c: 25951},

 12752     {f: 2, c: 25956}, {f: 4, c: 25959}, {f: 3, c: 25965}, 25969, 25971, 25974,

 12753     {f: 9, c: 25977}, {f: 3, c: 25988}, {f: 3, c: 25992}, {f: 3, c: 25997},

 12754     26002, 26004, 26006, 26008, 26010, {f: 2, c: 26013}, 26016,

 12755     {f: 2, c: 26018}, 26022, 26024, 26026, 26030, {f: 6, c: 26033}, 26040,

 12756     {f: 2, c: 26042}, {f: 3, c: 26046}, 26050, {f: 4, c: 26055}, 26061,

 12757     {f: 2, c: 26064}, {f: 3, c: 26067}, {f: 8, c: 26072}, 26081,

 12758     {f: 2, c: 26083}, {f: 2, c: 26090}, {f: 4, c: 26098}, {f: 2, c: 26104},

 12759     {f: 5, c: 26107}, 26113, {f: 2, c: 26116}, {f: 3, c: 26119}, 26123, 26125,

 12760     {f: 3, c: 26128}, {f: 3, c: 26134}, {f: 3, c: 26138}, 26142,

 12761     {f: 4, c: 26145}, 26150, {f: 4, c: 26153}, 26158, 26160, {f: 2, c: 26162},

 12762     {f: 5, c: 26167}, 26173, {f: 2, c: 26175}, {f: 7, c: 26180},

 12763     {f: 2, c: 26189}, {f: 2, c: 26192}, {f: 2, c: 26200}, {f: 2, c: 26203},

 12764     26206, 26208, {f: 2, c: 26210}, 26213, 26215, {f: 5, c: 26217},

 12765     {f: 3, c: 26225}, 26229, {f: 2, c: 26232}, {f: 3, c: 26235},

 12766     {f: 3, c: 26239}, 26243, {f: 2, c: 26245}, {f: 2, c: 26250},

 12767     {f: 4, c: 26253}, {f: 4, c: 26258}, {f: 5, c: 26264}, {f: 4, c: 26270},

 12768     {f: 4, c: 26275}, {f: 2, c: 26281}, {f: 2, c: 26284}, {f: 5, c: 26287},

 12769     {f: 4, c: 26293}, {f: 4, c: 26298}, {f: 5, c: 26303}, 26309, 26312,

 12770     {f: 12, c: 26314}, {f: 2, c: 26327}, 26330, {f: 2, c: 26334},

 12771     {f: 5, c: 26337}, {f: 2, c: 26343}, {f: 2, c: 26346}, {f: 3, c: 26349},

 12772     26353, {f: 2, c: 26357}, {f: 2, c: 26362}, 26365, {f: 2, c: 26369},

 12773     {f: 4, c: 26372}, 26380, {f: 2, c: 26382}, {f: 3, c: 26385}, 26390,

 12774     {f: 3, c: 26392}, 26396, 26398, {f: 6, c: 26400}, 26409, 26414, 26416,

 12775     {f: 2, c: 26418}, {f: 4, c: 26422}, {f: 2, c: 26427}, {f: 2, c: 26430},

 12776     26433, {f: 2, c: 26436}, 26439, {f: 2, c: 26442}, 26445, 26450,

 12777     {f: 2, c: 26452}, {f: 5, c: 26455}, 26461, {f: 3, c: 26466},

 12778     {f: 2, c: 26470}, {f: 2, c: 26475}, 26478, 26484, 26486, {f: 4, c: 26488},

 12779     26493, 26496, {f: 2, c: 26498}, {f: 2, c: 26501}, 26504, 26506,

 12780     {f: 4, c: 26508}, {f: 4, c: 26513}, 26518, 26521, 26523, {f: 3, c: 26527},

 12781     26532, 26534, 26537, 26540, 26542, {f: 2, c: 26545}, 26548,

 12782     {f: 8, c: 26553}, 26562, {f: 10, c: 26565}, {f: 3, c: 26581}, 26587, 26591,

 12783     26593, {f: 2, c: 26595}, {f: 3, c: 26598}, {f: 2, c: 26602},

 12784     {f: 2, c: 26605}, 26610, {f: 8, c: 26613}, 26622, {f: 4, c: 26625}, 26630,

 12785     26637, 26640, 26642, {f: 2, c: 26644}, {f: 5, c: 26648}, {f: 3, c: 26654},

 12786     {f: 7, c: 26658}, {f: 7, c: 26667}, {f: 3, c: 26676}, {f: 2, c: 26682},

 12787     26687, 26695, 26699, 26701, 26703, 26706, {f: 10, c: 26710}, 26730,

 12788     {f: 8, c: 26732}, 26741, {f: 9, c: 26744}, 26754, 26756, {f: 8, c: 26759},

 12789     {f: 3, c: 26768}, {f: 3, c: 26772}, {f: 4, c: 26777}, 26782,

 12790     {f: 2, c: 26784}, {f: 3, c: 26787}, {f: 4, c: 26793}, 26798,

 12791     {f: 2, c: 26801}, 26804, {f: 10, c: 26806}, 26817, {f: 6, c: 26819}, 26826,

 12792     26828, {f: 4, c: 26830}, {f: 2, c: 26835}, 26841, {f: 4, c: 26843},

 12793     {f: 2, c: 26849}, {f: 3, c: 26852}, {f: 6, c: 26856}, 26863,

 12794     {f: 3, c: 26866}, {f: 3, c: 26870}, 26875, {f: 4, c: 26877},

 12795     {f: 3, c: 26882}, {f: 5, c: 26886}, 26892, 26897, {f: 12, c: 26899},

 12796     {f: 3, c: 26913}, {f: 8, c: 26917}, {f: 2, c: 26926}, {f: 3, c: 26929},

 12797     {f: 4, c: 26933}, {f: 3, c: 26938}, 26942, {f: 2, c: 26944},

 12798     {f: 7, c: 26947}, {f: 8, c: 26955}, {f: 2, c: 26965}, {f: 2, c: 26968},

 12799     {f: 2, c: 26971}, 26975, {f: 2, c: 26977}, {f: 2, c: 26980}, 26983,

 12800     {f: 2, c: 26985}, 26988, {f: 2, c: 26991}, {f: 3, c: 26994}, 26998,

 12801     {f: 2, c: 27002}, {f: 3, c: 27005}, 27009, 27011, 27013, {f: 3, c: 27018},

 12802     {f: 6, c: 27022}, {f: 2, c: 27030}, {f: 2, c: 27033}, {f: 10, c: 27037},

 12803     27049, 27052, {f: 2, c: 27055}, {f: 2, c: 27058}, {f: 2, c: 27061},

 12804     {f: 3, c: 27064}, {f: 3, c: 27068}, 27072, {f: 8, c: 27074}, 27087,

 12805     {f: 3, c: 27089}, {f: 6, c: 27093}, {f: 3, c: 27100}, {f: 6, c: 27105},

 12806     {f: 5, c: 27112}, {f: 4, c: 27118}, {f: 9, c: 27124}, 27134, 27136,

 12807     {f: 2, c: 27139}, {f: 4, c: 27142}, {f: 8, c: 27147}, {f: 3, c: 27156},

 12808     {f: 4, c: 27162}, 27168, 27170, {f: 4, c: 27172}, 27177, {f: 4, c: 27179},

 12809     27184, {f: 3, c: 27186}, {f: 2, c: 27190}, {f: 2, c: 27195},

 12810     {f: 5, c: 27199}, {f: 2, c: 27205}, {f: 2, c: 27209}, {f: 4, c: 27212},

 12811     {f: 7, c: 27217}, 27226, {f: 3, c: 27228}, 27232, {f: 2, c: 27235},

 12812     {f: 11, c: 27238}, {f: 7, c: 27250}, {f: 2, c: 27258}, {f: 3, c: 27261},

 12813     {f: 3, c: 27265}, {f: 4, c: 27269}, {f: 4, c: 27274}, 27279,

 12814     {f: 2, c: 27282}, {f: 2, c: 27285}, {f: 4, c: 27288}, {f: 3, c: 27293},

 12815     27297, {f: 5, c: 27300}, 27306, {f: 2, c: 27309}, {f: 3, c: 27312},

 12816     {f: 4, c: 27316}, {f: 2, c: 27321}, {f: 7, c: 27324}, {f: 15, c: 27332},

 12817     {f: 6, c: 27348}, 27356, {f: 7, c: 27360}, 27369, 27371, {f: 6, c: 27373},

 12818     {f: 4, c: 27380}, {f: 2, c: 27385}, {f: 8, c: 27388}, {f: 5, c: 27397},

 12819     {f: 4, c: 27403}, {f: 2, c: 27408}, {f: 3, c: 27411}, {f: 7, c: 27415},

 12820     27423, {f: 2, c: 27429}, {f: 10, c: 27432}, {f: 4, c: 27443}, 27448,

 12821     {f: 2, c: 27451}, {f: 4, c: 27455}, {f: 2, c: 27460}, 27464,

 12822     {f: 2, c: 27466}, {f: 3, c: 27469}, {f: 8, c: 27473}, {f: 5, c: 27482},

 12823     27488, {f: 2, c: 27496}, {f: 7, c: 27499}, {f: 4, c: 27507}, 27514,

 12824     {f: 4, c: 27517}, 27525, 27528, 27532, {f: 4, c: 27534}, {f: 2, c: 27540},

 12825     27543, 27545, {f: 2, c: 27548}, {f: 2, c: 27551}, {f: 2, c: 27554},

 12826     {f: 5, c: 27557}, {f: 2, c: 27564}, {f: 2, c: 27568}, 27574,

 12827     {f: 2, c: 27576}, {f: 3, c: 27580}, 27584, {f: 2, c: 27587},

 12828     {f: 4, c: 27591}, 27596, 27598, {f: 2, c: 27600}, 27608, 27610,

 12829     {f: 5, c: 27612}, {f: 8, c: 27618}, {f: 3, c: 27628}, {f: 3, c: 27632},

 12830     27636, {f: 3, c: 27638}, {f: 3, c: 27642}, 27646, {f: 5, c: 27648},

 12831     {f: 3, c: 27657}, 27662, 27666, 27671, {f: 3, c: 27676}, 27680, 27685,

 12832     27693, 27697, 27699, {f: 2, c: 27702}, {f: 4, c: 27705}, {f: 2, c: 27710},

 12833     {f: 3, c: 27715}, 27720, {f: 5, c: 27723}, {f: 3, c: 27729}, 27734,

 12834     {f: 3, c: 27736}, {f: 2, c: 27746}, {f: 3, c: 27749}, {f: 5, c: 27755},

 12835     27761, 27763, 27765, {f: 2, c: 27767}, {f: 3, c: 27770}, {f: 2, c: 27775},

 12836     27780, 27783, {f: 2, c: 27786}, {f: 2, c: 27789}, {f: 2, c: 27793},

 12837     {f: 4, c: 27797}, 27802, {f: 3, c: 27804}, 27808, 27810, 27816, 27820,

 12838     {f: 2, c: 27823}, {f: 4, c: 27828}, 27834, {f: 4, c: 27840},

 12839     {f: 3, c: 27846}, 27851, {f: 3, c: 27853}, {f: 2, c: 27857},

 12840     {f: 3, c: 27864}, {f: 2, c: 27868}, 27871, 27876, {f: 2, c: 27878}, 27881,

 12841     {f: 2, c: 27884}, 27890, 27892, 27897, {f: 2, c: 27903}, {f: 2, c: 27906},

 12842     {f: 2, c: 27909}, {f: 3, c: 27912}, 27917, {f: 3, c: 27919},

 12843     {f: 4, c: 27923}, 27928, {f: 2, c: 27932}, {f: 6, c: 27935}, 27942,

 12844     {f: 2, c: 27944}, {f: 2, c: 27948}, {f: 2, c: 27951}, 27956,

 12845     {f: 3, c: 27958}, 27962, {f: 2, c: 27967}, 27970, 27972, 27977, 27980,

 12846     27984, {f: 4, c: 27989}, 27995, 27997, 27999, {f: 2, c: 28001},

 12847     {f: 2, c: 28004}, {f: 2, c: 28007}, {f: 3, c: 28011}, {f: 4, c: 28016},

 12848     {f: 2, c: 28021}, {f: 2, c: 28026}, {f: 5, c: 28029}, {f: 2, c: 28035},

 12849     28038, {f: 2, c: 28042}, 28045, {f: 2, c: 28047}, 28050, {f: 5, c: 28054},

 12850     28060, 28066, 28069, {f: 2, c: 28076}, {f: 2, c: 28080}, {f: 2, c: 28083},

 12851     {f: 2, c: 28086}, {f: 6, c: 28089}, {f: 3, c: 28097}, {f: 3, c: 28104},

 12852     {f: 4, c: 28109}, {f: 4, c: 28114}, 28119, {f: 3, c: 28122}, 28127,

 12853     {f: 2, c: 28130}, 28133, {f: 3, c: 28135}, 28141, {f: 2, c: 28143}, 28146,

 12854     28148, 28152, {f: 8, c: 28157}, {f: 4, c: 28166}, 28171, 28175,

 12855     {f: 2, c: 28178}, 28181, {f: 2, c: 28184}, {f: 2, c: 28187},

 12856     {f: 2, c: 28190}, 28194, {f: 2, c: 28199}, 28202, 28206, {f: 2, c: 28208},

 12857     28211, {f: 3, c: 28213}, 28217, {f: 3, c: 28219}, {f: 4, c: 28223},

 12858     {f: 8, c: 28229}, {f: 4, c: 28239}, 28245, 28247, {f: 2, c: 28249},

 12859     {f: 2, c: 28252}, {f: 11, c: 28256}, {f: 2, c: 28268}, {f: 14, c: 28272},

 12860     {f: 3, c: 28288}, 28292, {f: 2, c: 28295}, {f: 5, c: 28298},

 12861     {f: 5, c: 28305}, 28311, {f: 3, c: 28313}, 28318, {f: 2, c: 28320},

 12862     {f: 2, c: 28323}, 28326, {f: 2, c: 28328}, {f: 4, c: 28331}, 28336, 28339,

 12863     28341, {f: 2, c: 28344}, 28348, {f: 3, c: 28350}, 28355, 28358,

 12864     {f: 3, c: 28360}, 28365, 28368, 28370, 28374, {f: 2, c: 28376},

 12865     {f: 3, c: 28379}, 28387, 28391, {f: 2, c: 28394}, {f: 2, c: 28397},

 12866     {f: 2, c: 28400}, 28403, {f: 2, c: 28405}, {f: 5, c: 28410}, 28416,

 12867     {f: 3, c: 28419}, {f: 2, c: 28423}, {f: 5, c: 28426}, {f: 3, c: 28432},

 12868     {f: 4, c: 28438}, {f: 5, c: 28443}, 28449, {f: 4, c: 28453}, 28462, 28464,

 12869     {f: 2, c: 28468}, 28471, {f: 5, c: 28473}, 28480, {f: 4, c: 28482},

 12870     {f: 3, c: 28488}, 28492, {f: 3, c: 28494}, {f: 2, c: 28498},

 12871     {f: 3, c: 28501}, {f: 2, c: 28506}, 28509, {f: 3, c: 28511}, 28515, 28517,

 12872     {f: 6, c: 28519}, 28529, 28531, {f: 2, c: 28533}, 28537, 28539,

 12873     {f: 2, c: 28541}, {f: 3, c: 28545}, 28549, {f: 2, c: 28554},

 12874     {f: 8, c: 28559}, {f: 4, c: 28568}, {f: 3, c: 28573}, {f: 2, c: 28578},

 12875     {f: 2, c: 28581}, 28584, {f: 4, c: 28586}, {f: 2, c: 28591}, 28594,

 12876     {f: 2, c: 28596}, {f: 2, c: 28599}, {f: 6, c: 28602}, {f: 5, c: 28612},

 12877     {f: 7, c: 28618}, {f: 2, c: 28627}, {f: 2, c: 28630}, {f: 2, c: 28633},

 12878     {f: 2, c: 28636}, {f: 2, c: 28642}, {f: 6, c: 28645}, {f: 2, c: 28652},

 12879     {f: 8, c: 28658}, 28667, 28669, {f: 6, c: 28671}, {f: 2, c: 28679}, 28682,

 12880     {f: 3, c: 28684}, 28688, {f: 3, c: 28690}, {f: 2, c: 28694}, 28697, 28700,

 12881     28702, {f: 2, c: 28705}, {f: 3, c: 28708}, {f: 7, c: 28713}, 28721,

 12882     {f: 2, c: 28723}, {f: 3, c: 28726}, {f: 4, c: 28730}, {f: 4, c: 28735},

 12883     {f: 7, c: 28741}, {f: 2, c: 28749}, 28752, {f: 3, c: 28754},

 12884     {f: 2, c: 28758}, {f: 4, c: 28761}, {f: 4, c: 28767}, {f: 2, c: 28773},

 12885     {f: 3, c: 28776}, 28782, {f: 4, c: 28785}, 28791, {f: 3, c: 28793}, 28797,

 12886     {f: 4, c: 28801}, {f: 3, c: 28806}, {f: 3, c: 28811}, {f: 3, c: 28815},

 12887     28819, {f: 2, c: 28823}, {f: 2, c: 28826}, {f: 13, c: 28830}, 28848, 28850,

 12888     {f: 3, c: 28852}, 28858, {f: 2, c: 28862}, {f: 4, c: 28868}, 28873,

 12889     {f: 4, c: 28875}, {f: 8, c: 28880}, 28890, {f: 3, c: 28892},

 12890     {f: 4, c: 28896}, 28901, 28906, 28910, {f: 4, c: 28912}, {f: 2, c: 28917},

 12891     28920, {f: 3, c: 28922}, {f: 11, c: 28926}, {f: 5, c: 28939},

 12892     {f: 2, c: 28945}, 28948, 28951, {f: 6, c: 28955}, {f: 4, c: 28962},

 12893     {f: 8, c: 28967}, {f: 4, c: 28978}, {f: 14, c: 28983}, {f: 3, c: 28998},

 12894     29003, 29005, {f: 3, c: 29007}, {f: 9, c: 29011}, 29021, {f: 3, c: 29023},

 12895     29027, 29029, {f: 2, c: 29034}, 29037, {f: 3, c: 29039}, {f: 4, c: 29044},

 12896     29049, {f: 2, c: 29051}, {f: 6, c: 29054}, {f: 5, c: 29061},

 12897     {f: 4, c: 29067}, {f: 2, c: 29072}, 29075, {f: 2, c: 29077},

 12898     {f: 5, c: 29082}, {f: 7, c: 29089}, {f: 3, c: 29097}, {f: 4, c: 29101},

 12899     29106, 29108, {f: 3, c: 29110}, {f: 4, c: 29114}, {f: 2, c: 29119}, 29122,

 12900     {f: 4, c: 29124}, {f: 5, c: 29129}, {f: 3, c: 29135}, 29139,

 12901     {f: 3, c: 29142}, {f: 2, c: 29146}, {f: 2, c: 29149}, {f: 4, c: 29153},

 12902     {f: 5, c: 29160}, {f: 5, c: 29167}, {f: 4, c: 29173}, {f: 2, c: 29178},

 12903     29181, {f: 7, c: 29183}, {f: 6, c: 29191}, {f: 2, c: 29198},

 12904     {f: 10, c: 29201}, 29212, {f: 10, c: 29214}, 29225, 29227,

 12905     {f: 3, c: 29229}, {f: 2, c: 29235}, 29244, {f: 7, c: 29248},

 12906     {f: 3, c: 29257}, {f: 4, c: 29262}, {f: 3, c: 29267}, 29271, 29274, 29276,

 12907     29278, 29280, {f: 3, c: 29283}, 29288, {f: 4, c: 29290}, {f: 2, c: 29296},

 12908     {f: 2, c: 29299}, {f: 3, c: 29302}, {f: 2, c: 29307}, {f: 2, c: 29314},

 12909     {f: 5, c: 29317}, 29324, 29326, {f: 2, c: 29328}, {f: 3, c: 29331},

 12910     {f: 8, c: 29335}, {f: 2, c: 29344}, {f: 4, c: 29347}, {f: 4, c: 29352},

 12911     29358, {f: 3, c: 29361}, 29365, {f: 6, c: 29370}, {f: 3, c: 29381},

 12912     {f: 4, c: 29385}, 29391, 29393, {f: 4, c: 29395}, 29400, {f: 4, c: 29402},

 12913     29407, {f: 6, c: 29410}, {f: 2, c: 29418}, {f: 2, c: 29429},

 12914     {f: 3, c: 29438}, 29442, {f: 6, c: 29444}, {f: 3, c: 29451},

 12915     {f: 4, c: 29455}, 29460, {f: 3, c: 29464}, {f: 2, c: 29471},

 12916     {f: 2, c: 29475}, {f: 3, c: 29478}, 29485, {f: 2, c: 29487},

 12917     {f: 2, c: 29490}, 29493, 29498, {f: 2, c: 29500}, 29504, {f: 2, c: 29506},

 12918     {f: 7, c: 29510}, {f: 2, c: 29518}, 29521, {f: 4, c: 29523},

 12919     {f: 8, c: 29528}, {f: 7, c: 29537}, 29545, 29550, 29553, {f: 2, c: 29555},

 12920     29558, 29561, 29565, 29567, {f: 3, c: 29569}, {f: 2, c: 29573}, 29576,

 12921     29578, {f: 2, c: 29580}, {f: 2, c: 29583}, {f: 4, c: 29586},

 12922     {f: 4, c: 29591}, {f: 3, c: 29596}, {f: 2, c: 29600}, {f: 6, c: 29603},

 12923     29610, {f: 2, c: 29612}, 29617, {f: 3, c: 29620}, {f: 2, c: 29624},

 12924     {f: 4, c: 29628}, 29633, {f: 5, c: 29635}, {f: 2, c: 29643}, 29646,

 12925     {f: 7, c: 29650}, {f: 4, c: 29658}, 29663, {f: 4, c: 29665}, 29670, 29672,

 12926     {f: 3, c: 29674}, {f: 4, c: 29678}, {f: 11, c: 29683}, {f: 4, c: 29695},

 12927     29700, {f: 2, c: 29703}, {f: 4, c: 29707}, {f: 9, c: 29713},

 12928     {f: 6, c: 29724}, {f: 2, c: 29731}, 29735, 29737, 29739, 29741, 29743,

 12929     {f: 2, c: 29745}, {f: 5, c: 29751}, {f: 2, c: 29757}, 29760,

 12930     {f: 9, c: 29762}, {f: 9, c: 29772}, 29782, 29784, 29789, {f: 3, c: 29792},

 12931     {f: 5, c: 29796}, {f: 2, c: 29803}, {f: 2, c: 29806}, {f: 5, c: 29809},

 12932     {f: 6, c: 29816}, 29823, 29826, {f: 3, c: 29828}, 29832, 29834,

 12933     {f: 2, c: 29836}, 29839, {f: 11, c: 29841}, 29853, {f: 4, c: 29855},

 12934     {f: 2, c: 29860}, {f: 6, c: 29866}, {f: 9, c: 29873}, {f: 2, c: 29883},

 12935     {f: 12, c: 29886}, {f: 4, c: 29899}, {f: 2, c: 29904}, 29907,

 12936     {f: 5, c: 29909}, 29915, 29917, 29919, 29921, 29925, {f: 7, c: 29927},

 12937     {f: 4, c: 29936}, 29941, {f: 7, c: 29944}, {f: 4, c: 29952},

 12938     {f: 7, c: 29957}, 29966, 29968, 29970, {f: 4, c: 29972}, 29979,

 12939     {f: 2, c: 29981}, {f: 3, c: 29984}, 29988, {f: 2, c: 29990}, 29994, 29998,

 12940     30004, 30006, 30009, {f: 2, c: 30012}, 30015, {f: 4, c: 30017},

 12941     {f: 2, c: 30022}, {f: 2, c: 30025}, 30029, {f: 4, c: 30032},

 12942     {f: 4, c: 30037}, {f: 4, c: 30046}, {f: 2, c: 30051}, {f: 3, c: 30055},

 12943     {f: 6, c: 30060}, 30067, 30069, 30071, {f: 5, c: 30074}, {f: 3, c: 30080},

 12944     {f: 2, c: 30084}, {f: 3, c: 30088}, {f: 3, c: 30092}, 30096, 30099, 30101,

 12945     30104, {f: 2, c: 30107}, 30110, 30114, {f: 5, c: 30118}, 30125,

 12946     {f: 2, c: 30134}, {f: 2, c: 30138}, {f: 3, c: 30143}, 30150,

 12947     {f: 2, c: 30155}, {f: 4, c: 30158}, 30163, 30167, 30170, {f: 2, c: 30172},

 12948     {f: 3, c: 30175}, 30181, 30185, {f: 4, c: 30188}, {f: 2, c: 30194},

 12949     {f: 4, c: 30197}, {f: 2, c: 30202}, {f: 2, c: 30205}, 30212,

 12950     {f: 4, c: 30214}, {f: 2, c: 30222}, {f: 4, c: 30225}, 30230, 30234,

 12951     {f: 2, c: 30236}, 30243, 30248, 30252, {f: 2, c: 30254}, {f: 2, c: 30257},

 12952     {f: 2, c: 30262}, {f: 2, c: 30265}, 30269, 30273, {f: 2, c: 30276}, 30280,

 12953     {f: 2, c: 30282}, {f: 6, c: 30286}, 30293, 30295, {f: 3, c: 30297}, 30301,

 12954     {f: 2, c: 30304}, 30310, 30312, 30314, {f: 3, c: 30323}, [12136, 30326],

 12955     30327, {f: 2, c: 30329}, {f: 3, c: 30335}, 30339, 30341, {f: 2, c: 30345},

 12956     {f: 2, c: 30348}, {f: 2, c: 30351}, 30354, {f: 2, c: 30356},

 12957     {f: 2, c: 30359}, {f: 9, c: 30363}, {f: 9, c: 30373}, {f: 2, c: 30383},

 12958     30387, {f: 3, c: 30389}, 30393, {f: 4, c: 30395}, {f: 2, c: 30400},

 12959     {f: 2, c: 30403}, 30407, 30409, {f: 2, c: 30411}, 30419, 30421,

 12960     {f: 2, c: 30425}, {f: 2, c: 30428}, 30432, 30434, 30438, {f: 6, c: 30440},

 12961     30448, 30451, {f: 3, c: 30453}, {f: 2, c: 30458}, 30461, {f: 2, c: 30463},

 12962     {f: 2, c: 30466}, {f: 2, c: 30469}, 30474, 30476, {f: 11, c: 30478},

 12963     {f: 4, c: 30491}, 30497, {f: 3, c: 30499}, 30503, {f: 3, c: 30506}, 30510,

 12964     {f: 5, c: 30512}, 30521, 30523, {f: 3, c: 30525}, 30530, {f: 3, c: 30532},

 12965     {f: 7, c: 30536}, {f: 8, c: 30546}, {f: 2, c: 30556}, {f: 2, c: 30559},

 12966     30564, 30567, {f: 2, c: 30569}, {f: 12, c: 30573}, {f: 3, c: 30586},

 12967     {f: 3, c: 30593}, {f: 6, c: 30598}, {f: 2, c: 30607}, {f: 5, c: 30611},

 12968     {f: 5, c: 30617}, 30625, {f: 2, c: 30627}, 30630, 30632, 30635,

 12969     {f: 2, c: 30638}, {f: 2, c: 30641}, 30644, {f: 5, c: 30646}, 30654,

 12970     {f: 7, c: 30656}, {f: 5, c: 30664}, {f: 9, c: 30670}, {f: 2, c: 30680},

 12971     {f: 5, c: 30685}, 30692, 30694, 30696, 30698, {f: 3, c: 30704},

 12972     {f: 2, c: 30708}, 30711, {f: 4, c: 30713}, {f: 6, c: 30723},

 12973     {f: 2, c: 30730}, {f: 3, c: 30734}, 30739, 30741, 30745, 30747, 30750,

 12974     {f: 3, c: 30752}, 30756, 30760, {f: 2, c: 30762}, {f: 2, c: 30766},

 12975     {f: 3, c: 30769}, {f: 2, c: 30773}, 30781, 30783, {f: 2, c: 30785}, 30788,

 12976     30790, {f: 4, c: 30792}, 30797, 30799, 30801, {f: 2, c: 30803},

 12977     {f: 5, c: 30808}, {f: 6, c: 30814}, {f: 3, c: 30821}, 30825,

 12978     {f: 7, c: 30832}, {f: 4, c: 30840}, {f: 10, c: 30845}, 30856,

 12979     {f: 2, c: 30858}, {f: 2, c: 30863}, 30866, {f: 3, c: 30868}, 30873,

 12980     {f: 2, c: 30877}, 30880, 30882, 30884, 30886, 30888, {f: 3, c: 30890},

 12981     {f: 2, c: 30894}, {f: 3, c: 30901}, 30907, 30909, {f: 2, c: 30911},

 12982     {f: 3, c: 30914}, {f: 3, c: 30918}, {f: 4, c: 30924}, {f: 3, c: 30929},

 12983     {f: 3, c: 30934}, {f: 8, c: 30939}, {f: 3, c: 30948}, {f: 3, c: 30953},

 12984     {f: 2, c: 30957}, {f: 2, c: 30960}, 30963, {f: 2, c: 30965},

 12985     {f: 2, c: 30968}, {f: 2, c: 30971}, {f: 3, c: 30974}, {f: 3, c: 30978},

 12986     {f: 8, c: 30982}, {f: 4, c: 30991}, {f: 5, c: 30996}, {f: 4, c: 31002},

 12987     {f: 5, c: 31007}, 31013, {f: 3, c: 31015}, {f: 4, c: 31021},

 12988     {f: 2, c: 31026}, {f: 5, c: 31029}, 31037, 31039, {f: 4, c: 31042}, 31047,

 12989     {f: 9, c: 31050}, {f: 2, c: 31060}, {f: 2, c: 31064}, 31073,

 12990     {f: 2, c: 31075}, 31078, {f: 4, c: 31081}, 31086, {f: 7, c: 31088}, 31097,

 12991     {f: 5, c: 31099}, {f: 2, c: 31106}, {f: 4, c: 31110}, {f: 2, c: 31115},

 12992     {f: 10, c: 31120}, {f: 11, c: 31131}, {f: 2, c: 31144}, {f: 3, c: 31147},

 12993     31151, 31154, {f: 4, c: 31156}, [12145, 31160], 31164, 31167, 31170,

 12994     {f: 2, c: 31172}, {f: 2, c: 31175}, 31178, 31180, {f: 3, c: 31182},

 12995     {f: 2, c: 31187}, {f: 2, c: 31190}, {f: 6, c: 31193}, {f: 3, c: 31200},

 12996     31205, 31208, 31210, 31212, 31214, {f: 7, c: 31217}, {f: 2, c: 31225},

 12997     31228, {f: 2, c: 31230}, 31233, {f: 2, c: 31236}, {f: 4, c: 31239}, 31244,

 12998     {f: 5, c: 31247}, {f: 2, c: 31253}, {f: 2, c: 31256}, {f: 3, c: 31259},

 12999     31263, {f: 2, c: 31265}, {f: 10, c: 31268}, {f: 2, c: 31279}, 31282,

 13000     {f: 3, c: 31284}, 31288, 31290, 31294, {f: 5, c: 31297}, {f: 5, c: 31303},

 13001     {f: 2, c: 31311}, {f: 5, c: 31314}, {f: 9, c: 31320}, {f: 6, c: 31331},

 13002     31338, {f: 4, c: 31340}, {f: 3, c: 31345}, 31349, {f: 4, c: 31355}, 31362,

 13003     31365, 31367, {f: 4, c: 31369}, {f: 3, c: 31374}, {f: 2, c: 31379},

 13004     {f: 3, c: 31385}, 31390, {f: 4, c: 31393}, 31399, 31403, {f: 4, c: 31407},

 13005     {f: 2, c: 31412}, {f: 3, c: 31415}, {f: 4, c: 31419}, {f: 4, c: 31424},

 13006     31430, 31433, {f: 10, c: 31436}, {f: 2, c: 31447}, {f: 4, c: 31450},

 13007     {f: 2, c: 31457}, 31460, {f: 3, c: 31463}, {f: 2, c: 31467}, 31470,

 13008     {f: 6, c: 31472}, {f: 2, c: 31479}, {f: 2, c: 31483}, 31486,

 13009     {f: 3, c: 31488}, 31493, 31495, 31497, {f: 3, c: 31500}, 31504,

 13010     {f: 2, c: 31506}, {f: 3, c: 31510}, 31514, {f: 2, c: 31516}, 31519,

 13011     {f: 3, c: 31521}, 31527, 31529, 31533, {f: 2, c: 31535}, 31538,

 13012     {f: 4, c: 31540}, 31545, 31547, 31549, {f: 6, c: 31551}, 31560, 31562,

 13013     {f: 2, c: 31565}, 31571, 31573, 31575, 31577, 31580, {f: 2, c: 31582},

 13014     31585, {f: 4, c: 31587}, {f: 6, c: 31592}, {f: 2, c: 31599},

 13015     {f: 2, c: 31603}, 31606, 31608, 31610, {f: 2, c: 31612}, 31615,

 13016     {f: 4, c: 31617}, {f: 5, c: 31622}, 31628, {f: 2, c: 31630},

 13017     {f: 3, c: 31633}, 31638, {f: 4, c: 31640}, {f: 3, c: 31646},

 13018     {f: 3, c: 31651}, {f: 3, c: 31662}, {f: 2, c: 31666}, {f: 3, c: 31669},

 13019     {f: 7, c: 31673}, {f: 2, c: 31682}, 31685, 31688, 31690, {f: 4, c: 31693},

 13020     31698, {f: 5, c: 31700}, {f: 2, c: 31707}, {f: 3, c: 31710},

 13021     {f: 2, c: 31714}, {f: 2, c: 31719}, {f: 3, c: 31723}, {f: 2, c: 31727},

 13022     31730, {f: 3, c: 31732}, {f: 4, c: 31736}, 31741, 31743, {f: 6, c: 31745},

 13023     {f: 3, c: 31752}, 31758, {f: 6, c: 31760}, {f: 7, c: 31767}, 31776, 31778,

 13024     {f: 2, c: 31780}, {f: 2, c: 31784}, {f: 12, c: 31788}, {f: 4, c: 31801},

 13025     31810, {f: 8, c: 31812}, {f: 14, c: 31822}, {f: 2, c: 31837},

 13026     {f: 3, c: 31841}, {f: 4, c: 31845}, 31851, 31853, {f: 3, c: 31855},

 13027     {f: 6, c: 31861}, {f: 11, c: 31870}, {f: 7, c: 31882}, {f: 2, c: 31891},

 13028     31894, {f: 3, c: 31897}, {f: 2, c: 31904}, 31907, {f: 4, c: 31910},

 13029     {f: 3, c: 31915}, {f: 2, c: 31919}, {f: 5, c: 31924}, {f: 2, c: 31930},

 13030     {f: 2, c: 31935}, {f: 3, c: 31938}, 31942, 31945, 31947, {f: 7, c: 31950},

 13031     31960, {f: 2, c: 31962}, {f: 6, c: 31969}, {f: 6, c: 31977}, 31985, 31987,

 13032     31989, 31991, 31994, {f: 2, c: 31996}, 31999, 32001, 32003, 32012,

 13033     {f: 2, c: 32014}, {f: 2, c: 32017}, 32022, 32024, {f: 3, c: 32029},

 13034     {f: 4, c: 32035}, {f: 3, c: 32040}, {f: 3, c: 32044}, {f: 5, c: 32052},

 13035     32059, {f: 2, c: 32061}, 32065, 32067, 32069, {f: 7, c: 32071}, 32079,

 13036     {f: 12, c: 32081}, {f: 2, c: 32095}, {f: 3, c: 32099}, 32103,

 13037     {f: 5, c: 32105}, {f: 2, c: 32111}, {f: 2, c: 32116}, 32120,

 13038     {f: 7, c: 32122}, 32130, {f: 2, c: 32132}, 32135, {f: 5, c: 32138},

 13039     {f: 3, c: 32144}, {f: 8, c: 32148}, 32157, {f: 3, c: 32159},

 13040     {f: 2, c: 32164}, {f: 4, c: 32167}, 32175, {f: 3, c: 32181}, 32188,

 13041     {f: 4, c: 32192}, {f: 2, c: 32197}, {f: 2, c: 32200}, {f: 5, c: 32204},

 13042     32211, {f: 2, c: 32213}, {f: 3, c: 32218}, 32223, 32226, {f: 2, c: 32228},

 13043     32231, {f: 2, c: 32234}, {f: 2, c: 32237}, 32240, 32243, 32245,

 13044     {f: 2, c: 32247}, 32250, {f: 12, c: 32252}, {f: 4, c: 32268},

 13045     {f: 9, c: 32274}, 32284, {f: 3, c: 32288}, {f: 3, c: 32292},

 13046     {f: 3, c: 32296}, 32300, {f: 2, c: 32303}, 32307, 32312, 32314, 32316,

 13047     {f: 2, c: 32319}, {f: 3, c: 32322}, {f: 10, c: 32328}, 32339,

 13048     {f: 4, c: 32342}, {f: 3, c: 32347}, {f: 3, c: 32351}, {f: 6, c: 32355},

 13049     32364, {f: 2, c: 32369}, {f: 5, c: 32372}, {f: 2, c: 32378},

 13050     {f: 3, c: 32383}, {f: 5, c: 32387}, 32393, 32395, 32398, {f: 3, c: 32400},

 13051     32405, 32407, {f: 2, c: 32409}, {f: 2, c: 32413}, 32430, 32436,

 13052     {f: 2, c: 32443}, 32470, 32484, 32492, 32505, 32522, 32528, 32542, 32567,

 13053     32569, {f: 7, c: 32571}, 32579, {f: 6, c: 32582}, 32589, 32591,

 13054     {f: 2, c: 32594}, 32598, 32601, {f: 4, c: 32603}, 32608, {f: 5, c: 32611},

 13055     {f: 3, c: 32619}, 32623, 32627, {f: 2, c: 32629}, 32632, {f: 4, c: 32634},

 13056     {f: 2, c: 32639}, {f: 3, c: 32642}, 32647, 32649, 32651, 32653,

 13057     {f: 5, c: 32655}, {f: 5, c: 32661}, {f: 2, c: 32667}, 32672,

 13058     {f: 2, c: 32674}, 32678, 32680, {f: 5, c: 32682}, 32689, {f: 5, c: 32691},

 13059     {f: 2, c: 32698}, 32702, 32704, {f: 3, c: 32706}, {f: 4, c: 32710}, 32715,

 13060     32717, {f: 3, c: 32719}, 32723, {f: 2, c: 32726}, {f: 6, c: 32729},

 13061     {f: 3, c: 32738}, {f: 2, c: 32743}, {f: 4, c: 32746}, 32751, 32754,

 13062     {f: 5, c: 32756}, 32762, {f: 3, c: 32765}, 32770, {f: 4, c: 32775},

 13063     {f: 2, c: 32782}, 32785, 32787, {f: 2, c: 32794}, {f: 3, c: 32797}, 32801,

 13064     {f: 2, c: 32803}, 32811, 32813, {f: 2, c: 32815}, 32818, 32820,

 13065     {f: 2, c: 32825}, 32828, 32830, {f: 2, c: 32832}, {f: 2, c: 32836},

 13066     {f: 3, c: 32839}, {f: 4, c: 32846}, 32851, 32853, 32855, 32857,

 13067     {f: 3, c: 32859}, {f: 10, c: 32863}, {f: 4, c: 32875}, 32884, 32888,

 13068     {f: 3, c: 32890}, {f: 2, c: 32897}, 32904, 32906, {f: 6, c: 32909},

 13069     {f: 2, c: 32916}, 32919, 32921, 32926, 32931, {f: 3, c: 32934}, 32940,

 13070     32944, 32947, {f: 2, c: 32949}, {f: 2, c: 32952}, 32955, 32965,

 13071     {f: 5, c: 32967}, {f: 7, c: 32975}, 32984, {f: 2, c: 32991},

 13072     {f: 2, c: 32994}, 32998, 33006, 33013, 33015, 33017, 33019,

 13073     {f: 4, c: 33022}, {f: 2, c: 33027}, {f: 2, c: 33031}, {f: 2, c: 33035},

 13074     33045, 33047, 33049, {f: 2, c: 33052}, {f: 13, c: 33055}, {f: 2, c: 33069},

 13075     33072, {f: 3, c: 33075}, 33079, {f: 4, c: 33082}, {f: 7, c: 33087}, 33095,

 13076     33097, 33101, 33103, 33106, {f: 2, c: 33111}, {f: 5, c: 33115},

 13077     {f: 3, c: 33122}, 33128, 33130, 33132, 33135, {f: 2, c: 33138},

 13078     {f: 3, c: 33141}, 33153, {f: 5, c: 33155}, 33161, {f: 4, c: 33163}, 33168,

 13079     {f: 6, c: 33170}, 33177, {f: 2, c: 33182}, {f: 2, c: 33185},

 13080     {f: 2, c: 33188}, 33191, {f: 8, c: 33195}, {f: 6, c: 33204}, 33212,

 13081     {f: 2, c: 33220}, {f: 2, c: 33223}, 33227, 33230, {f: 8, c: 33232}, 33241,

 13082     {f: 4, c: 33243}, {f: 2, c: 33249}, {f: 3, c: 33252}, 33257, 33259,

 13083     {f: 5, c: 33262}, {f: 5, c: 33269}, 33277, 33279, 33283, 33291,

 13084     {f: 2, c: 33294}, 33297, 33299, {f: 6, c: 33301}, 33309, 33312,

 13085     {f: 4, c: 33316}, 33321, 33326, 33330, 33338, {f: 2, c: 33340},

 13086     {f: 5, c: 33343}, {f: 2, c: 33349}, 33352, 33354, {f: 3, c: 33356},

 13087     {f: 8, c: 33360}, {f: 4, c: 33371}, {f: 4, c: 33376}, 33381, 33383,

 13088     {f: 2, c: 33385}, {f: 2, c: 33388}, {f: 2, c: 33397}, [12171, 33400],

 13089     {f: 2, c: 33403}, {f: 2, c: 33408}, 33411, {f: 3, c: 33413}, 33417, 33420,

 13090     33424, {f: 4, c: 33427}, {f: 2, c: 33434}, 33438, 33440, {f: 2, c: 33442},

 13091     33447, 33458, {f: 2, c: 33461}, 33466, 33468, {f: 2, c: 33471},

 13092     {f: 2, c: 33474}, {f: 2, c: 33477}, 33481, 33488, 33494, {f: 2, c: 33497},

 13093     33501, 33506, {f: 3, c: 33512}, {f: 3, c: 33516}, 33520, {f: 2, c: 33522},

 13094     {f: 2, c: 33525}, 33528, 33530, {f: 5, c: 33532}, {f: 2, c: 33546}, 33549,

 13095     33552, {f: 2, c: 33554}, 33558, {f: 2, c: 33560}, {f: 10, c: 33565},

 13096     {f: 2, c: 33577}, 33582, 33584, 33586, 33591, 33595, {f: 3, c: 33597},

 13097     {f: 2, c: 33601}, {f: 2, c: 33604}, 33608, {f: 5, c: 33610}, 33619,

 13098     {f: 5, c: 33621}, 33629, 33634, {f: 7, c: 33648}, {f: 2, c: 33657},

 13099     {f: 7, c: 33662}, {f: 2, c: 33671}, {f: 3, c: 33675}, {f: 3, c: 33679},

 13100     {f: 2, c: 33684}, 33687, {f: 2, c: 33689}, 33693, 33695, 33697,

 13101     {f: 4, c: 33699}, {f: 4, c: 33708}, 33717, 33723, {f: 2, c: 33726},

 13102     {f: 3, c: 33730}, 33734, {f: 2, c: 33736}, 33739, {f: 2, c: 33741},

 13103     {f: 4, c: 33744}, 33749, 33751, {f: 3, c: 33753}, 33758, {f: 3, c: 33762},

 13104     {f: 3, c: 33766}, {f: 4, c: 33771}, {f: 5, c: 33779}, {f: 3, c: 33786},

 13105     {f: 3, c: 33790}, 33794, 33797, {f: 2, c: 33800}, 33808, {f: 6, c: 33810},

 13106     {f: 3, c: 33817}, {f: 6, c: 33822}, {f: 3, c: 33833}, {f: 4, c: 33837},

 13107     {f: 3, c: 33842}, {f: 2, c: 33846}, {f: 3, c: 33849}, {f: 8, c: 33854},

 13108     {f: 2, c: 33863}, {f: 7, c: 33866}, {f: 4, c: 33875}, 33880,

 13109     {f: 4, c: 33885}, 33890, 33893, {f: 2, c: 33895}, 33898, 33902, 33904,

 13110     33906, 33908, 33913, {f: 7, c: 33915}, {f: 4, c: 33923}, 33930, 33933,

 13111     {f: 4, c: 33935}, {f: 2, c: 33941}, 33944, {f: 2, c: 33946},

 13112     {f: 4, c: 33949}, {f: 13, c: 33954}, {f: 2, c: 33968}, 33971,

 13113     {f: 3, c: 33973}, 33979, 33982, {f: 2, c: 33986}, {f: 4, c: 33989}, 33996,

 13114     {f: 2, c: 33998}, 34002, {f: 2, c: 34004}, {f: 6, c: 34007}, 34014,

 13115     {f: 2, c: 34017}, 34020, {f: 5, c: 34023}, 34029, {f: 11, c: 34033}, 34046,

 13116     {f: 12, c: 34048}, {f: 4, c: 34061}, 34066, {f: 2, c: 34069},

 13117     {f: 2, c: 34072}, {f: 3, c: 34075}, 34080, 34082, {f: 2, c: 34084},

 13118     {f: 4, c: 34087}, {f: 9, c: 34094}, {f: 3, c: 34110}, 34114,

 13119     {f: 2, c: 34116}, 34119, {f: 3, c: 34123}, {f: 3, c: 34127}, 34132, 34135,

 13120     {f: 4, c: 34138}, {f: 3, c: 34143}, 34147, {f: 3, c: 34149},

 13121     {f: 2, c: 34155}, {f: 4, c: 34158}, 34163, {f: 2, c: 34165}, 34168,

 13122     {f: 2, c: 34172}, {f: 5, c: 34175}, 34182, 34185, 34187, {f: 2, c: 34189},

 13123     34192, {f: 2, c: 34194}, {f: 6, c: 34197}, {f: 2, c: 34205},

 13124     {f: 4, c: 34208}, 34213, 34215, {f: 3, c: 34219}, {f: 6, c: 34225}, 34232,

 13125     {f: 6, c: 34235}, {f: 7, c: 34242}, {f: 3, c: 34250}, {f: 2, c: 34257},

 13126     34260, {f: 6, c: 34262}, {f: 6, c: 34270}, {f: 3, c: 34278},

 13127     {f: 9, c: 34283}, 34293, {f: 2, c: 34295}, {f: 3, c: 34300},

 13128     {f: 4, c: 34304}, {f: 3, c: 34312}, {f: 5, c: 34316}, {f: 4, c: 34322},

 13129     {f: 3, c: 34327}, {f: 3, c: 34331}, {f: 3, c: 34335}, {f: 4, c: 34339},

 13130     34344, {f: 3, c: 34346}, {f: 10, c: 34350}, 34361, 34363, {f: 2, c: 34365},

 13131     {f: 13, c: 34368}, {f: 2, c: 34386}, {f: 4, c: 34390}, 34395, 34397,

 13132     {f: 2, c: 34400}, {f: 4, c: 34403}, {f: 3, c: 34408}, 34413,

 13133     {f: 2, c: 34415}, {f: 7, c: 34418}, {f: 7, c: 34435}, {f: 5, c: 34446},

 13134     34452, {f: 6, c: 34454}, {f: 5, c: 34462}, {f: 2, c: 34469}, 34475,

 13135     {f: 2, c: 34477}, {f: 2, c: 34482}, {f: 3, c: 34487}, {f: 5, c: 34491},

 13136     {f: 3, c: 34497}, 34501, 34504, {f: 2, c: 34508}, {f: 2, c: 34514},

 13137     {f: 3, c: 34517}, 34522, {f: 2, c: 34524}, {f: 4, c: 34528},

 13138     {f: 4, c: 34533}, {f: 3, c: 34538}, 34543, {f: 3, c: 34549},

 13139     {f: 3, c: 34555}, 34559, 34561, {f: 2, c: 34564}, {f: 2, c: 34571},

 13140     {f: 4, c: 34574}, 34580, 34582, 34585, 34587, 34589, {f: 2, c: 34591},

 13141     34596, {f: 3, c: 34598}, {f: 4, c: 34602}, {f: 2, c: 34607},

 13142     {f: 2, c: 34610}, {f: 2, c: 34613}, {f: 3, c: 34616}, {f: 2, c: 34620},

 13143     {f: 7, c: 34624}, {f: 2, c: 34634}, 34637, {f: 4, c: 34639}, 34644, 34646,

 13144     34648, {f: 6, c: 34650}, {f: 2, c: 34657}, {f: 7, c: 34663}, 34671,

 13145     {f: 3, c: 34673}, 34677, 34679, {f: 2, c: 34681}, {f: 3, c: 34687},

 13146     {f: 2, c: 34694}, {f: 2, c: 34697}, 34700, {f: 5, c: 34702},

 13147     {f: 3, c: 34708}, {f: 6, c: 34712}, {f: 2, c: 34720}, {f: 5, c: 34723},

 13148     {f: 2, c: 34729}, 34734, {f: 3, c: 34736}, 34740, {f: 4, c: 34742}, 34748,

 13149     {f: 2, c: 34750}, {f: 3, c: 34753}, 34757, 34759, 34761, {f: 2, c: 34764},

 13150     {f: 2, c: 34767}, {f: 7, c: 34772}, {f: 4, c: 34780}, {f: 2, c: 34785},

 13151     34788, {f: 4, c: 34790}, 34795, 34797, {f: 2, c: 34800}, {f: 3, c: 34803},

 13152     {f: 2, c: 34807}, 34810, {f: 2, c: 34812}, {f: 4, c: 34815}, 34820,

 13153     {f: 3, c: 34823}, {f: 5, c: 34827}, 34834, 34836, {f: 4, c: 34839},

 13154     {f: 3, c: 34844}, 34848, {f: 13, c: 34852}, {f: 3, c: 34867},

 13155     {f: 2, c: 34871}, 34874, {f: 3, c: 34877}, {f: 3, c: 34881},

 13156     {f: 3, c: 34887}, 34891, {f: 5, c: 34894}, {f: 2, c: 34901}, 34904, 34906,

 13157     34908, {f: 3, c: 34910}, {f: 2, c: 34918}, 34922, 34925, 34927, 34929,

 13158     {f: 4, c: 34931}, 34936, {f: 3, c: 34938}, 34944, 34947, {f: 2, c: 34950},

 13159     {f: 2, c: 34953}, 34956, {f: 4, c: 34958}, {f: 3, c: 34963},

 13160     {f: 5, c: 34967}, {f: 5, c: 34973}, 34979, {f: 6, c: 34981}, 34988,

 13161     {f: 3, c: 34990}, {f: 5, c: 34994}, {f: 4, c: 35000}, {f: 4, c: 35005},

 13162     {f: 2, c: 35011}, {f: 2, c: 35015}, {f: 3, c: 35019}, {f: 2, c: 35024},

 13163     35027, {f: 2, c: 35030}, {f: 2, c: 35034}, 35038, {f: 2, c: 35040},

 13164     {f: 2, c: 35046}, {f: 7, c: 35049}, 35058, {f: 3, c: 35061},

 13165     {f: 2, c: 35066}, {f: 3, c: 35071}, {f: 4, c: 35075}, {f: 2, c: 35080},

 13166     {f: 5, c: 35083}, 35089, {f: 5, c: 35092}, {f: 5, c: 35100},

 13167     {f: 3, c: 35106}, {f: 4, c: 35110}, {f: 4, c: 35116}, 35121, 35125, 35127,

 13168     {f: 2, c: 35129}, {f: 5, c: 35132}, {f: 2, c: 35138}, {f: 2, c: 35141},

 13169     {f: 14, c: 35144}, {f: 6, c: 35159}, {f: 3, c: 35169}, 35173,

 13170     {f: 3, c: 35175}, 35179, {f: 2, c: 35181}, {f: 2, c: 35184},

 13171     {f: 8, c: 35187}, {f: 2, c: 35196}, [12177, 35198], 35200, 35202,

 13172     {f: 2, c: 35204}, {f: 4, c: 35207}, {f: 3, c: 35212}, {f: 3, c: 35216},

 13173     {f: 2, c: 35220}, 35223, {f: 8, c: 35225}, {f: 4, c: 35234},

 13174     {f: 3, c: 35239}, 35243, {f: 2, c: 35245}, {f: 2, c: 35248},

 13175     {f: 4, c: 35251}, {f: 2, c: 35256}, {f: 2, c: 35259}, 35262, 35267, 35277,

 13176     {f: 3, c: 35283}, {f: 3, c: 35287}, 35291, 35293, {f: 4, c: 35295}, 35300,

 13177     {f: 4, c: 35303}, {f: 3, c: 35308}, {f: 3, c: 35312}, 35317, 35319,

 13178     {f: 7, c: 35321}, {f: 3, c: 35332}, 35337, 35339, 35341, 35343,

 13179     {f: 2, c: 35345}, 35348, 35351, {f: 2, c: 35353}, 35356, 35358,

 13180     {f: 3, c: 35360}, 35364, {f: 4, c: 35366}, {f: 2, c: 35371},

 13181     {f: 3, c: 35374}, {f: 2, c: 35378}, 35381, {f: 3, c: 35383},

 13182     {f: 3, c: 35387}, {f: 2, c: 35391}, {f: 4, c: 35394}, 35399,

 13183     {f: 5, c: 35401}, 35407, 35409, 35411, {f: 2, c: 35414}, {f: 2, c: 35417},

 13184     {f: 2, c: 35420}, {f: 2, c: 35423}, {f: 2, c: 35428}, {f: 2, c: 35431},

 13185     35434, 35439, 35444, {f: 3, c: 35446}, {f: 2, c: 35450}, {f: 2, c: 35453},

 13186     {f: 4, c: 35456}, 35464, {f: 2, c: 35467}, {f: 3, c: 35470}, 35476,

 13187     {f: 2, c: 35478}, 35481, {f: 3, c: 35483}, 35487, 35490, 35495,

 13188     {f: 3, c: 35497}, {f: 3, c: 35501}, 35505, {f: 3, c: 35507},

 13189     {f: 2, c: 35511}, {f: 2, c: 35514}, {f: 2, c: 35517}, {f: 2, c: 35520},

 13190     35523, {f: 2, c: 35525}, 35528, 35530, 35532, 35534, 35536,

 13191     {f: 3, c: 35539}, {f: 3, c: 35544}, 35549, {f: 3, c: 35551}, 35555, 35557,

 13192     {f: 3, c: 35560}, 35564, {f: 2, c: 35567}, 35570, {f: 2, c: 35572}, 35577,

 13193     35579, 35581, 35583, 35587, 35590, {f: 2, c: 35592}, {f: 3, c: 35595},

 13194     35599, {f: 3, c: 35601}, 35605, 35608, 35612, {f: 3, c: 35614},

 13195     {f: 4, c: 35618}, 35623, {f: 2, c: 35625}, {f: 5, c: 35630},

 13196     {f: 5, c: 35636}, {f: 4, c: 35642}, {f: 10, c: 35647}, {f: 4, c: 35658},

 13197     {f: 6, c: 35664}, 35671, 35675, {f: 9, c: 35677}, {f: 4, c: 35687},

 13198     {f: 2, c: 35693}, {f: 3, c: 35697}, {f: 2, c: 35701}, {f: 5, c: 35704},

 13199     {f: 2, c: 35710}, {f: 9, c: 35713}, {f: 3, c: 35723}, {f: 3, c: 35727},

 13200     35732, {f: 5, c: 35735}, 35741, 35743, 35756, 35761, 35771, 35783, 35792,

 13201     35818, 35849, 35870, {f: 9, c: 35896}, {f: 4, c: 35906}, {f: 2, c: 35914},

 13202     {f: 3, c: 35917}, {f: 4, c: 35921}, {f: 4, c: 35926}, {f: 6, c: 35931},

 13203     {f: 7, c: 35939}, {f: 7, c: 35948}, {f: 4, c: 35956}, {f: 7, c: 35963},

 13204     {f: 2, c: 35971}, {f: 3, c: 35974}, 35979, {f: 7, c: 35981},

 13205     {f: 3, c: 35989}, {f: 4, c: 35993}, 35999, {f: 4, c: 36003},

 13206     {f: 2, c: 36013}, 36017, 36021, 36025, 36030, 36038, 36041,

 13207     {f: 6, c: 36043}, 36052, {f: 4, c: 36054}, 36059, 36061, 36063, 36069,

 13208     {f: 2, c: 36072}, {f: 6, c: 36078}, {f: 5, c: 36085}, {f: 5, c: 36095},

 13209     {f: 2, c: 36102}, 36105, 36108, 36110, {f: 5, c: 36113}, {f: 4, c: 36119},

 13210     36128, {f: 2, c: 36177}, 36183, 36191, 36197, {f: 3, c: 36200}, 36204,

 13211     {f: 2, c: 36206}, {f: 2, c: 36209}, {f: 9, c: 36216}, {f: 2, c: 36226},

 13212     {f: 4, c: 36230}, {f: 5, c: 36236}, {f: 2, c: 36242}, {f: 3, c: 36246},

 13213     {f: 5, c: 36250}, {f: 3, c: 36256}, {f: 4, c: 36260}, {f: 8, c: 36265},

 13214     {f: 2, c: 36278}, 36281, 36283, 36285, {f: 3, c: 36288}, 36293,

 13215     {f: 4, c: 36295}, 36301, 36304, {f: 4, c: 36306}, {f: 2, c: 36312}, 36316,

 13216     {f: 3, c: 36320}, {f: 3, c: 36325}, 36329, {f: 2, c: 36333},

 13217     {f: 3, c: 36336}, 36340, 36342, 36348, {f: 7, c: 36350}, {f: 3, c: 36358},

 13218     36363, {f: 2, c: 36365}, {f: 3, c: 36369}, {f: 8, c: 36373},

 13219     {f: 2, c: 36384}, {f: 5, c: 36388}, 36395, 36397, 36400, {f: 2, c: 36402},

 13220     {f: 3, c: 36406}, {f: 2, c: 36411}, {f: 2, c: 36414}, 36419,

 13221     {f: 2, c: 36421}, {f: 4, c: 36429}, {f: 2, c: 36435}, {f: 3, c: 36438},

 13222     {f: 9, c: 36442}, {f: 2, c: 36452}, {f: 2, c: 36455}, {f: 2, c: 36458},

 13223     36462, 36465, 36467, 36469, {f: 3, c: 36471}, 36475, {f: 2, c: 36477},

 13224     36480, {f: 3, c: 36482}, 36486, 36488, 36492, 36494, {f: 5, c: 36501},

 13225     36507, 36509, {f: 2, c: 36511}, {f: 3, c: 36514}, {f: 3, c: 36519},

 13226     {f: 2, c: 36525}, {f: 2, c: 36528}, {f: 7, c: 36531}, {f: 5, c: 36539},

 13227     {f: 9, c: 36545}, {f: 3, c: 36559}, 36563, {f: 6, c: 36565},

 13228     {f: 3, c: 36572}, {f: 4, c: 36576}, {f: 6, c: 36581}, {f: 6, c: 36588},

 13229     {f: 5, c: 36595}, 36605, {f: 4, c: 36607}, 36612, 36614, 36616,

 13230     {f: 7, c: 36619}, 36627, {f: 5, c: 36630}, {f: 5, c: 36640},

 13231     {f: 2, c: 36647}, {f: 4, c: 36651}, {f: 3, c: 36656}, {f: 4, c: 36660},

 13232     {f: 2, c: 36665}, {f: 2, c: 36668}, {f: 2, c: 36672}, 36675,

 13233     {f: 2, c: 36679}, {f: 3, c: 36682}, {f: 5, c: 36687}, {f: 10, c: 36693},

 13234     36704, 36707, 36709, 36714, 36736, 36748, 36754, 36765, {f: 3, c: 36768},

 13235     {f: 2, c: 36772}, 36775, 36778, 36780, {f: 2, c: 36787}, [12193, 36789],

 13236     {f: 2, c: 36791}, {f: 3, c: 36794}, {f: 2, c: 36799}, 36803, 36806,

 13237     {f: 5, c: 36809}, 36815, 36818, {f: 2, c: 36822}, 36826, {f: 2, c: 36832},

 13238     36835, 36839, 36844, 36847, {f: 2, c: 36849}, {f: 2, c: 36853},

 13239     {f: 3, c: 36858}, {f: 2, c: 36862}, {f: 2, c: 36871}, 36876, 36878, 36883,

 13240     36888, 36892, {f: 2, c: 36900}, {f: 6, c: 36903}, {f: 2, c: 36912},

 13241     {f: 2, c: 36915}, 36919, {f: 2, c: 36921}, 36925, {f: 2, c: 36927}, 36931,

 13242     {f: 2, c: 36933}, {f: 3, c: 36936}, 36940, 36950, {f: 2, c: 36953}, 36957,

 13243     36959, 36961, 36964, {f: 2, c: 36966}, {f: 3, c: 36970}, {f: 3, c: 36975},

 13244     36979, 36982, 36985, 36987, 36990, {f: 2, c: 36997}, 37001,

 13245     {f: 3, c: 37004}, 37010, 37012, 37014, 37016, 37018, 37020,

 13246     {f: 3, c: 37022}, {f: 2, c: 37028}, {f: 3, c: 37031}, 37035, 37037, 37042,

 13247     37047, {f: 2, c: 37052}, {f: 2, c: 37055}, {f: 2, c: 37058}, 37062,

 13248     {f: 2, c: 37064}, {f: 3, c: 37067}, 37074, {f: 3, c: 37076},

 13249     {f: 3, c: 37080}, 37086, 37088, {f: 3, c: 37091}, {f: 2, c: 37097}, 37100,

 13250     37102, {f: 4, c: 37104}, {f: 2, c: 37110}, {f: 4, c: 37113},

 13251     {f: 3, c: 37119}, 37123, 37125, {f: 2, c: 37127}, {f: 8, c: 37130}, 37139,

 13252     37141, {f: 2, c: 37143}, {f: 4, c: 37146}, {f: 3, c: 37151},

 13253     {f: 3, c: 37156}, {f: 5, c: 37160}, 37166, 37171, 37173, {f: 2, c: 37175},

 13254     {f: 8, c: 37179}, {f: 2, c: 37188}, 37191, 37201, {f: 4, c: 37203},

 13255     {f: 2, c: 37208}, {f: 2, c: 37211}, {f: 2, c: 37215}, {f: 3, c: 37222},

 13256     37227, 37229, 37235, {f: 3, c: 37242}, {f: 5, c: 37248}, 37254, 37256,

 13257     37258, {f: 2, c: 37262}, {f: 3, c: 37267}, {f: 3, c: 37271},

 13258     {f: 5, c: 37277}, {f: 6, c: 37284}, {f: 4, c: 37296}, {f: 4, c: 37302},

 13259     {f: 5, c: 37307}, 37314, 37316, [12196, 37318], 37320, 37328, 37334,

 13260     {f: 2, c: 37338}, {f: 5, c: 37342}, {f: 2, c: 37349}, 37352,

 13261     {f: 11, c: 37354}, 37366, 37368, {f: 5, c: 37371}, {f: 2, c: 37378},

 13262     {f: 3, c: 37381}, {f: 3, c: 37386}, 37391, {f: 2, c: 37394},

 13263     {f: 8, c: 37398}, {f: 4, c: 37407}, 37412, {f: 6, c: 37416}, 37423,

 13264     {f: 2, c: 37425}, {f: 2, c: 37429}, {f: 2, c: 37435}, {f: 4, c: 37441},

 13265     {f: 2, c: 37446}, {f: 3, c: 37450}, {f: 3, c: 37454}, {f: 3, c: 37458},

 13266     37462, {f: 2, c: 37464}, {f: 2, c: 37468}, {f: 3, c: 37471},

 13267     {f: 3, c: 37475}, {f: 5, c: 37479}, {f: 6, c: 37486}, {f: 3, c: 37493},

 13268     37497, {f: 3, c: 37500}, {f: 2, c: 37505}, 37508, {f: 8, c: 37510},

 13269     {f: 2, c: 37519}, 37522, {f: 2, c: 37524}, 37527, 37529, 37531,

 13270     {f: 3, c: 37533}, {f: 2, c: 37537}, 37540, 37543, 37549, {f: 2, c: 37551},

 13271     {f: 5, c: 37554}, 37560, 37562, {f: 4, c: 37565}, 37570, 37572, 37574,

 13272     {f: 3, c: 37577}, {f: 2, c: 37581}, {f: 2, c: 37584}, {f: 10, c: 37587},

 13273     37598, {f: 3, c: 37600}, 37607, 37609, {f: 2, c: 37611}, {f: 4, c: 37618},

 13274     37623, {f: 3, c: 37625}, {f: 4, c: 37629}, {f: 4, c: 37634},

 13275     {f: 7, c: 37641}, 37649, {f: 2, c: 37651}, {f: 2, c: 37654},

 13276     {f: 3, c: 37660}, 37665, {f: 3, c: 37667}, 37671, {f: 2, c: 37673},

 13277     {f: 2, c: 37676}, {f: 2, c: 37680}, {f: 2, c: 37684}, 37687,

 13278     {f: 5, c: 37689}, 37695, 37698, {f: 2, c: 37700}, {f: 3, c: 37704}, 37708,

 13279     {f: 6, c: 37710}, {f: 3, c: 37717}, {f: 2, c: 37721}, {f: 8, c: 37724},

 13280     {f: 3, c: 37734}, 37739, {f: 3, c: 37741}, {f: 4, c: 37745},

 13281     {f: 3, c: 37751}, {f: 3, c: 37755}, {f: 3, c: 37759}, 37763,

 13282     {f: 2, c: 37765}, {f: 2, c: 37768}, {f: 4, c: 37771}, {f: 6, c: 37776},

 13283     37783, {f: 9, c: 37785}, {f: 2, c: 37796}, 37800, 37803, 37805, 37807,

 13284     {f: 2, c: 37809}, 37812, {f: 2, c: 37814}, {f: 6, c: 37817},

 13285     {f: 3, c: 37824}, {f: 3, c: 37828}, 37833, 37835, {f: 3, c: 37838},

 13286     {f: 4, c: 37842}, {f: 3, c: 37849}, 37856, 37859, {f: 3, c: 37861},

 13287     {f: 12, c: 37865}, 37878, 37880, {f: 9, c: 37882}, {f: 7, c: 37892},

 13288     {f: 4, c: 37900}, 37905, {f: 3, c: 37909}, {f: 3, c: 37914},

 13289     {f: 2, c: 37918}, {f: 5, c: 37921}, {f: 5, c: 37929}, {f: 3, c: 37935},

 13290     37940, {f: 2, c: 37942}, 37945, {f: 3, c: 37947}, {f: 4, c: 37952},

 13291     {f: 5, c: 37957}, 37963, {f: 5, c: 37965}, 37971, {f: 11, c: 37973},

 13292     {f: 2, c: 37985}, 37988, {f: 5, c: 37990}, 37996, {f: 2, c: 37998}, 38001,

 13293     {f: 4, c: 38003}, 38008, {f: 2, c: 38010}, {f: 5, c: 38016}, 38033, 38038,

 13294     38040, 38087, 38095, {f: 2, c: 38099}, 38106, 38118, 38139, 38172, 38176,

 13295     38183, 38195, 38205, 38211, 38216, 38219, 38229, 38234, 38240, 38254,

 13296     {f: 2, c: 38260}, {f: 7, c: 38264}, 38273, {f: 2, c: 38276},

 13297     {f: 2, c: 38279}, 38282, 38285, 38288, 38290, {f: 3, c: 38293},

 13298     {f: 8, c: 38297}, 38306, {f: 2, c: 38310}, 38314, {f: 4, c: 38318},

 13299     {f: 3, c: 38323}, {f: 2, c: 38327}, 38330, {f: 3, c: 38336},

 13300     {f: 2, c: 38340}, 38343, 38345, {f: 3, c: 38349}, {f: 3, c: 38353},

 13301     {f: 5, c: 38359}, 38365, {f: 2, c: 38367}, {f: 2, c: 38371},

 13302     {f: 2, c: 38374}, 38380, 38399, 38407, 38419, 38424, 38427, 38430, 38432,

 13303     {f: 7, c: 38435}, {f: 3, c: 38443}, {f: 2, c: 38447}, {f: 4, c: 38455},

 13304     38462, 38465, 38467, 38474, {f: 2, c: 38478}, {f: 3, c: 38481},

 13305     {f: 2, c: 38486}, {f: 2, c: 38489}, 38492, 38494, 38496, {f: 2, c: 38501},

 13306     38507, {f: 3, c: 38509}, 38513, {f: 4, c: 38521}, {f: 7, c: 38526}, 38535,

 13307     38537, 38540, {f: 3, c: 38545}, 38550, 38554, {f: 10, c: 38557}, 38569,

 13308     {f: 5, c: 38571}, 38578, 38581, 38583, 38586, 38591, {f: 2, c: 38594},

 13309     38600, {f: 2, c: 38602}, {f: 2, c: 38608}, {f: 2, c: 38611},

 13310     {f: 2, c: 38615}, 38618, {f: 3, c: 38621}, 38625, {f: 4, c: 38628},

 13311     {f: 4, c: 38635}, {f: 2, c: 38640}, {f: 2, c: 38644}, 38648, 38650,

 13312     {f: 2, c: 38652}, 38655, {f: 2, c: 38658}, 38661, {f: 3, c: 38666},

 13313     {f: 3, c: 38672}, {f: 2, c: 38676}, {f: 5, c: 38679}, 38685,

 13314     {f: 8, c: 38687}, {f: 2, c: 38696}, {f: 2, c: 38699}, {f: 2, c: 38702},

 13315     38705, {f: 5, c: 38707}, {f: 3, c: 38714}, {f: 3, c: 38719}, 38723,

 13316     {f: 3, c: 38725}, {f: 8, c: 38729}, [12205, 38737], {f: 2, c: 38740},

 13317     {f: 2, c: 38743}, {f: 2, c: 38748}, 38751, {f: 2, c: 38755},

 13318     {f: 2, c: 38758}, {f: 9, c: 38762}, 38773, {f: 5, c: 38775},

 13319     {f: 8, c: 38781}, {f: 5, c: 38790}, 38796, 38798, 38800, 38803,

 13320     {f: 3, c: 38805}, {f: 7, c: 38809}, {f: 2, c: 38817}, {f: 2, c: 38820},

 13321     {f: 4, c: 38823}, 38828, 38830, {f: 2, c: 38832}, 38835, {f: 8, c: 38837},

 13322     {f: 5, c: 38846}, {f: 2, c: 38852}, {f: 2, c: 38855}, 38858,

 13323     {f: 6, c: 38861}, {f: 5, c: 38868}, {f: 2, c: 38874}, 38877,

 13324     {f: 7, c: 38879}, 38888, {f: 5, c: 38894}, 38900, {f: 8, c: 38903}, 38912,

 13325     38916, 38921, 38923, 38925, {f: 3, c: 38932}, {f: 3, c: 38937},

 13326     {f: 4, c: 38941}, {f: 2, c: 38946}, 38949, {f: 6, c: 38951},

 13327     {f: 2, c: 38958}, {f: 6, c: 38961}, {f: 2, c: 38969}, 38972,

 13328     {f: 8, c: 38974}, {f: 5, c: 38983}, {f: 4, c: 38991}, {f: 3, c: 38997},

 13329     39002, {f: 2, c: 39004}, {f: 3, c: 39007}, {f: 2, c: 39011}, 39014,

 13330     {f: 3, c: 39016}, {f: 2, c: 39021}, 39026, 39051, 39054, 39058, 39061,

 13331     39065, 39075, {f: 5, c: 39081}, 39088, 39090, {f: 2, c: 39092},

 13332     {f: 5, c: 39095}, {f: 7, c: 39101}, 39109, 39111, {f: 5, c: 39113},

 13333     {f: 2, c: 39119}, 39124, {f: 2, c: 39126}, {f: 2, c: 39132}, 39137,

 13334     {f: 4, c: 39139}, 39148, 39150, {f: 2, c: 39152}, 39155, {f: 7, c: 39157},

 13335     {f: 4, c: 39167}, 39172, {f: 3, c: 39174}, 39179, {f: 2, c: 39182},

 13336     {f: 4, c: 39188}, {f: 2, c: 39193}, {f: 2, c: 39196}, {f: 2, c: 39199},

 13337     {f: 6, c: 39202}, {f: 5, c: 39209}, {f: 4, c: 39215}, {f: 3, c: 39220},

 13338     {f: 4, c: 39224}, 39229, {f: 3, c: 39232}, 39236, {f: 2, c: 39238},

 13339     {f: 4, c: 39245}, 39251, 39254, {f: 4, c: 39256}, 39261, {f: 3, c: 39263},

 13340     39268, 39270, 39283, {f: 2, c: 39288}, 39291, 39294, {f: 2, c: 39298},

 13341     39305, 39308, 39310, {f: 11, c: 39322}, {f: 2, c: 39334}, {f: 3, c: 39337},

 13342     {f: 2, c: 39343}, 39346, {f: 12, c: 39349}, {f: 14, c: 39362}, 39379,

 13343     {f: 2, c: 39382}, 39386, 39388, 39390, 39392, {f: 10, c: 39395},

 13344     {f: 3, c: 39406}, {f: 13, c: 39410}, 39424, {f: 3, c: 39426},

 13345     {f: 7, c: 39430}, {f: 6, c: 39440}, {f: 2, c: 39447}, {f: 17, c: 39450},

 13346     39468, 39471, {f: 5, c: 39473}, {f: 5, c: 39481}, 39487, {f: 4, c: 39494},

 13347     {f: 2, c: 39499}, 39502, {f: 5, c: 39504}, 39510, {f: 2, c: 39512},

 13348     {f: 3, c: 39516}, {f: 2, c: 39520}, 39523, {f: 4, c: 39526}, 39531, 39538,

 13349     39555, 39561, {f: 2, c: 39565}, {f: 2, c: 39572}, 39577, 39590,

 13350     {f: 6, c: 39593}, {f: 4, c: 39602}, 39609, 39611, {f: 3, c: 39613},

 13351     {f: 2, c: 39619}, {f: 5, c: 39622}, {f: 2, c: 39629}, 39632, 39639,

 13352     {f: 6, c: 39641}, 39648, {f: 4, c: 39650}, {f: 4, c: 39655}, 39660,

 13353     {f: 9, c: 39664}, 39674, {f: 7, c: 39676}, {f: 2, c: 39684}, 39687,

 13354     {f: 4, c: 39689}, 39694, {f: 3, c: 39696}, {f: 6, c: 39700},

 13355     {f: 4, c: 39707}, {f: 2, c: 39712}, 39716, 39718, 39720, {f: 4, c: 39722},

 13356     39728, {f: 8, c: 39731}, {f: 4, c: 39741}, 39750, {f: 3, c: 39754}, 39760,

 13357     {f: 2, c: 39762}, {f: 3, c: 39765}, 39769, {f: 20, c: 39771},

 13358     {f: 4, c: 39792}, {f: 2, c: 39797}, {f: 9, c: 39800}, 39810,

 13359     {f: 10, c: 39812}, 39823, {f: 7, c: 39827}, {f: 2, c: 39835},

 13360     {f: 11, c: 39839}, 39852, {f: 17, c: 39855}, {f: 5, c: 39874}, 39880,

 13361     {f: 9, c: 39883}, 39893, {f: 4, c: 39895}, 39900, {f: 3, c: 39902}, 39907,

 13362     {f: 2, c: 39909}, 39913, {f: 4, c: 39916}, {f: 3, c: 39921},

 13363     {f: 8, c: 39925}, 39934, {f: 8, c: 39936}, {f: 3, c: 39946},

 13364     {f: 2, c: 39950}, 39953, {f: 12, c: 39956}, {f: 2, c: 39969}, 39972,

 13365     {f: 2, c: 39974}, {f: 3, c: 39978}, {f: 3, c: 39982}, 39988, 39990, 39992,

 13366     39994, {f: 2, c: 39996}, {f: 6, c: 39999}, {f: 2, c: 40006},

 13367     {f: 8, c: 40010}, 40019, 40021, {f: 4, c: 40025}, 40030, {f: 7, c: 40032},

 13368     {f: 5, c: 40040}, {f: 10, c: 40046}, 40057, 40059, {f: 2, c: 40061}, 40064,

 13369     {f: 2, c: 40067}, {f: 2, c: 40073}, 40076, 40079, 40083, {f: 4, c: 40086},

 13370     40093, 40106, 40108, 40111, 40121, {f: 5, c: 40126}, {f: 2, c: 40136},

 13371     {f: 2, c: 40145}, {f: 2, c: 40154}, {f: 2, c: 40160}, {f: 2, c: 40163},

 13372     {f: 3, c: 40166}, {f: 2, c: 40170}, {f: 6, c: 40173}, 40181,

 13373     {f: 15, c: 40183}, 40200, {f: 11, c: 40202}, {f: 5, c: 40214}, 40220,

 13374     40222, {f: 3, c: 40224}, {f: 2, c: 40228}, 40231, {f: 6, c: 40233},

 13375     {f: 10, c: 40241}, {f: 3, c: 40252}, {f: 2, c: 40256}, {f: 14, c: 40259},

 13376     {f: 8, c: 40276}, {f: 2, c: 40286}, {f: 8, c: 40290}, 40299,

 13377     {f: 2, c: 40301}, {f: 2, c: 40304}, {f: 20, c: 40307}, 40328,

 13378     {f: 9, c: 40330}, {f: 4, c: 40340}, 40345, {f: 10, c: 40347},

 13379     {f: 3, c: 40358}, {f: 5, c: 40362}, {f: 4, c: 40368}, {f: 6, c: 40373},

 13380     {f: 3, c: 40381}, 40385, 40387, {f: 14, c: 40389}, {f: 3, c: 40404}, 40408,

 13381     {f: 10, c: 40411}, {f: 8, c: 40423}, {f: 2, c: 40432}, {f: 4, c: 40436},

 13382     {f: 17, c: 40443}, {f: 8, c: 40461}, {f: 4, c: 40470}, 40476, 40484, 40487,

 13383     40494, 40496, 40500, {f: 2, c: 40507}, 40512, 40525, 40528,

 13384     {f: 3, c: 40530}, 40534, 40537, 40541, {f: 4, c: 40543}, 40549,

 13385     {f: 2, c: 40558}, 40562, 40564, {f: 3, c: 40566}, 40571, {f: 2, c: 40576},

 13386     {f: 4, c: 40579}, {f: 2, c: 40585}, {f: 6, c: 40588}, {f: 3, c: 40596},

 13387     {f: 5, c: 40600}, 40606, {f: 5, c: 40608}, {f: 2, c: 40615},

 13388     {f: 5, c: 40618}, {f: 4, c: 40624}, {f: 2, c: 40630}, {f: 2, c: 40633},

 13389     40636, {f: 4, c: 40639}, [12232, 40643], {f: 4, c: 40645},

 13390     {f: 2, c: 40650}, 40656, {f: 2, c: 40658}, {f: 3, c: 40661},

 13391     {f: 2, c: 40665}, 40673, {f: 2, c: 40675}, 40678, {f: 4, c: 40683},

 13392     {f: 2, c: 40688}, 40691, {f: 2, c: 40693}, 40696, 40698, {f: 9, c: 40704},

 13393     40714, 40716, 40719, {f: 2, c: 40721}, 40724, 40726, 40728,

 13394     {f: 6, c: 40730}, 40737, {f: 9, c: 40739}, {f: 2, c: 40749},

 13395     {f: 7, c: 40752}, 40760, 40762, 40764, {f: 5, c: 40767}, {f: 5, c: 40773},

 13396     {f: 3, c: 40780}, 40787, {f: 4, c: 40789}, {f: 2, c: 40794},

 13397     {f: 2, c: 40797}, 40802, {f: 2, c: 40804}, {f: 3, c: 40807}, 40811,

 13398     {f: 5, c: 40813}, {f: 4, c: 40819}, {f: 7, c: 40824}, {f: 2, c: 40833},

 13399     {f: 2, c: 40846}, {f: 3, c: 40849}, {f: 3, c: 40854}, {f: 2, c: 40861},

 13400     {f: 5, c: 40865}, 63788, {f: 3, c: 64013}, 64017, {f: 2, c: 64019}, 64024,

 13401     {f: 3, c: 64031}, {f: 2, c: 64035}, {f: 3, c: 64039}, 11905,

 13402     [59414, 131207], [59415, 131209], [59416, 131276], 11908, 13427, 13383,

 13403     11912, 11915, 59422, 13726, 13850, 13838, 11916, 11927, 14702, 14616,

 13404     59430, 14799, 14815, 14963, 14800, {f: 2, c: 59435}, 15182, 15470, 15584,

 13405     11943, [59441, 136663], 59442, 11946, 16470, 16735, 11950, 17207, 11955,

 13406     {f: 2, c: 11958}, [59451, 141711], 17329, 17324, 11963, 17373, 17622,

 13407     18017, 17996, [59459, 132361], 18211, 18217, 18300, 18317, 11978, 18759,

 13408     18810, 18813, {f: 2, c: 18818}, {f: 2, c: 18821}, 18847, 18843, 18871,

 13409     18870, [59476, 133533], [59477, 147966], 19619, {f: 3, c: 19615}, 19575,

 13410     19618, {f: 7, c: 19731}, 19886, 59492, {s: 226}, 8364, 165, 0, 0, 12351,

 13411     {s: 17}, 12436, {s: 14}, 12535, 12537, 12536, 12538, 0, {f: 3, c: 12339},

 13412     {f: 3, c: 12344}, {f: 3, c: 12586}, {f: 24, c: 12704}, 11904,

 13413     {f: 2, c: 11906}, {f: 3, c: 11909}, {f: 2, c: 11913}, {f: 10, c: 11917},

 13414     {f: 2, c: 11928}, {f: 12, c: 11931}, {f: 2, c: 11944}, {f: 3, c: 11947},

 13415     {f: 4, c: 11951}, {f: 2, c: 11956}, {f: 3, c: 11960}, {f: 14, c: 11964},

 13416     {f: 41, c: 11979}, {f: 71, c: 13312}, {f: 43, c: 13384},

 13417     {f: 298, c: 13428}, {f: 111, c: 13727}, {f: 11, c: 13839},

 13418     {f: 765, c: 13851}, {f: 85, c: 14617}, {f: 96, c: 14703},

 13419     {f: 14, c: 14801}, {f: 147, c: 14816}, {f: 218, c: 14964},

 13420     {f: 287, c: 15183}, {f: 113, c: 15471}, {f: 885, c: 15585},

 13421     {f: 264, c: 16471}, {f: 471, c: 16736}, {f: 116, c: 17208},

 13422     {f: 4, c: 17325}, {f: 43, c: 17330}, {f: 248, c: 17374},

 13423     {f: 373, c: 17623}, {f: 20, c: 17997}, {f: 193, c: 18018},

 13424     {f: 5, c: 18212}, {f: 82, c: 18218}, {f: 16, c: 18301}, {f: 441, c: 18318},

 13425     {f: 50, c: 18760}, {f: 2, c: 18811}, {f: 4, c: 18814}, 18820,

 13426     {f: 20, c: 18823}, {f: 3, c: 18844}, {f: 22, c: 18848}, {f: 703, c: 18872},

 13427     {f: 39, c: 19576}, {f: 111, c: 19620}, {f: 148, c: 19738},

 13428     {f: 7, c: 19887}]

 13429 };

 13433 var ARCFourCipher = (function ARCFourCipherClosure() {

 13434   function ARCFourCipher(key) {

 13435     this.a = 0;

 13436     this.b = 0;

 13437     var s = new Uint8Array(256);

 13438     var i, j = 0, tmp, keyLength = key.length;

 13439     for (i = 0; i < 256; ++i) {

 13440       s[i] = i;

 13441     }

 13442     for (i = 0; i < 256; ++i) {

 13443       tmp = s[i];

 13444       j = (j + tmp + key[i % keyLength]) & 0xFF;

 13445       s[i] = s[j];

 13446       s[j] = tmp;

 13447     }

 13448     this.s = s;

 13449   }

 13451   ARCFourCipher.prototype = {

 13452     encryptBlock: function ARCFourCipher_encryptBlock(data) {

 13453       var i, n = data.length, tmp, tmp2;

 13454       var a = this.a, b = this.b, s = this.s;

 13455       var output = new Uint8Array(n);

 13456       for (i = 0; i < n; ++i) {

 13457         a = (a + 1) & 0xFF;

 13458         tmp = s[a];

 13459         b = (b + tmp) & 0xFF;

 13460         tmp2 = s[b];

 13461         s[a] = tmp2;

 13462         s[b] = tmp;

 13463         output[i] = data[i] ^ s[(tmp + tmp2) & 0xFF];

 13464       }

 13465       this.a = a;

 13466       this.b = b;

 13467       return output;

 13468     }

 13469   };

 13470   ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock;

 13472   return ARCFourCipher;

 13473 })();

 13475 var calculateMD5 = (function calculateMD5Closure() {

 13476   var r = new Uint8Array([

 13477     7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,

 13478     5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,

 13479     4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,

 13480     6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]);

 13482   var k = new Int32Array([

 13483     -680876936, -389564586, 606105819, -1044525330, -176418897, 1200080426,

 13484     -1473231341, -45705983, 1770035416, -1958414417, -42063, -1990404162,

 13485     1804603682, -40341101, -1502002290, 1236535329, -165796510, -1069501632,

 13486     643717713, -373897302, -701558691, 38016083, -660478335, -405537848,

 13487     568446438, -1019803690, -187363961, 1163531501, -1444681467, -51403784,

 13488     1735328473, -1926607734, -378558, -2022574463, 1839030562, -35309556,

 13489     -1530992060, 1272893353, -155497632, -1094730640, 681279174, -358537222,

 13490     -722521979, 76029189, -640364487, -421815835, 530742520, -995338651,

 13491     -198630844, 1126891415, -1416354905, -57434055, 1700485571, -1894986606,

 13492     -1051523, -2054922799, 1873313359, -30611744, -1560198380, 1309151649,

 13493     -145523070, -1120210379, 718787259, -343485551]);

 13495   function hash(data, offset, length) {

 13496     var h0 = 1732584193, h1 = -271733879, h2 = -1732584194, h3 = 271733878;

 13497     // pre-processing

 13498     var paddedLength = (length + 72) & ~63; // data + 9 extra bytes

 13499     var padded = new Uint8Array(paddedLength);

 13500     var i, j, n;

 13501     for (i = 0; i < length; ++i) {

 13502       padded[i] = data[offset++];

 13503     }

 13504     padded[i++] = 0x80;

 13505     n = paddedLength - 8;

 13506     while (i < n) {

 13507       padded[i++] = 0;

 13508     }

 13509     padded[i++] = (length << 3) & 0xFF;

 13510     padded[i++] = (length >> 5) & 0xFF;

 13511     padded[i++] = (length >> 13) & 0xFF;

 13512     padded[i++] = (length >> 21) & 0xFF;

 13513     padded[i++] = (length >>> 29) & 0xFF;

 13514     padded[i++] = 0;

 13515     padded[i++] = 0;

 13516     padded[i++] = 0;

 13517     // chunking

 13518     // TODO ArrayBuffer ?

 13519     var w = new Int32Array(16);

 13520     for (i = 0; i < paddedLength;) {

 13521       for (j = 0; j < 16; ++j, i += 4) {

 13522         w[j] = (padded[i] | (padded[i + 1] << 8) |

 13523                 (padded[i + 2] << 16) | (padded[i + 3] << 24));

 13524       }

 13525       var a = h0, b = h1, c = h2, d = h3, f, g;

 13526       for (j = 0; j < 64; ++j) {

 13527         if (j < 16) {

 13528           f = (b & c) | ((~b) & d);

 13529           g = j;

 13530         } else if (j < 32) {

 13531           f = (d & b) | ((~d) & c);

 13532           g = (5 * j + 1) & 15;

 13533         } else if (j < 48) {

 13534           f = b ^ c ^ d;

 13535           g = (3 * j + 5) & 15;

 13536         } else {

 13537           f = c ^ (b | (~d));

 13538           g = (7 * j) & 15;

 13539         }

 13540         var tmp = d, rotateArg = (a + f + k[j] + w[g]) | 0, rotate = r[j];

 13541         d = c;

 13542         c = b;

 13543         b = (b + ((rotateArg << rotate) | (rotateArg >>> (32 - rotate)))) | 0;

 13544         a = tmp;

 13545       }

 13546       h0 = (h0 + a) | 0;

 13547       h1 = (h1 + b) | 0;

 13548       h2 = (h2 + c) | 0;

 13549       h3 = (h3 + d) | 0;

 13550     }

 13551     return new Uint8Array([

 13552       h0 & 0xFF, (h0 >> 8) & 0xFF, (h0 >> 16) & 0xFF, (h0 >>> 24) & 0xFF,

 13553       h1 & 0xFF, (h1 >> 8) & 0xFF, (h1 >> 16) & 0xFF, (h1 >>> 24) & 0xFF,

 13554       h2 & 0xFF, (h2 >> 8) & 0xFF, (h2 >> 16) & 0xFF, (h2 >>> 24) & 0xFF,

 13555       h3 & 0xFF, (h3 >> 8) & 0xFF, (h3 >> 16) & 0xFF, (h3 >>> 24) & 0xFF

 13556     ]);

 13557   }

 13558   return hash;

 13559 })();

 13561 var NullCipher = (function NullCipherClosure() {

 13562   function NullCipher() {}

 13564   NullCipher.prototype = {

 13565     decryptBlock: function NullCipher_decryptBlock(data) {

 13566       return data;

 13567     }

 13568   };

 13570   return NullCipher;

 13571 })();

 13573 var AES128Cipher = (function AES128CipherClosure() {

 13574   var rcon = new Uint8Array([

 13575     0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,

 13576     0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,

 13577     0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,

 13578     0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,

 13579     0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,

 13580     0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6,

 13581     0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72,

 13582     0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,

 13583     0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10,

 13584     0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e,

 13585     0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5,

 13586     0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,

 13587     0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02,

 13588     0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d,

 13589     0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d,

 13590     0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,

 13591     0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb,

 13592     0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c,

 13593     0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a,

 13594     0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,

 13595     0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,

 13596     0x74, 0xe8, 0xcb, 0x8d]);

 13598   var s = new Uint8Array([

 13599     0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,

 13600     0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,

 13601     0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,

 13602     0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,

 13603     0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,

 13604     0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,

 13605     0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,

 13606     0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,

 13607     0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,

 13608     0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,

 13609     0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,

 13610     0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,

 13611     0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,

 13612     0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,

 13613     0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,

 13614     0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,

 13615     0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,

 13616     0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,

 13617     0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,

 13618     0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,

 13619     0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,

 13620     0xb0, 0x54, 0xbb, 0x16]);

 13622   var inv_s = new Uint8Array([

 13623     0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,

 13624     0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,

 13625     0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,

 13626     0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,

 13627     0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,

 13628     0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,

 13629     0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50,

 13630     0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,

 13631     0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,

 13632     0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,

 13633     0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41,

 13634     0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,

 13635     0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,

 13636     0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,

 13637     0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,

 13638     0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,

 13639     0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,

 13640     0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,

 13641     0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,

 13642     0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,

 13643     0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,

 13644     0x55, 0x21, 0x0c, 0x7d]);

 13646   var mix = new Uint32Array([

 13647     0x00000000, 0x0e090d0b, 0x1c121a16, 0x121b171d, 0x3824342c, 0x362d3927,

 13648     0x24362e3a, 0x2a3f2331, 0x70486858, 0x7e416553, 0x6c5a724e, 0x62537f45,

 13649     0x486c5c74, 0x4665517f, 0x547e4662, 0x5a774b69, 0xe090d0b0, 0xee99ddbb,

 13650     0xfc82caa6, 0xf28bc7ad, 0xd8b4e49c, 0xd6bde997, 0xc4a6fe8a, 0xcaaff381,

 13651     0x90d8b8e8, 0x9ed1b5e3, 0x8ccaa2fe, 0x82c3aff5, 0xa8fc8cc4, 0xa6f581cf,

 13652     0xb4ee96d2, 0xbae79bd9, 0xdb3bbb7b, 0xd532b670, 0xc729a16d, 0xc920ac66,

 13653     0xe31f8f57, 0xed16825c, 0xff0d9541, 0xf104984a, 0xab73d323, 0xa57ade28,

 13654     0xb761c935, 0xb968c43e, 0x9357e70f, 0x9d5eea04, 0x8f45fd19, 0x814cf012,

 13655     0x3bab6bcb, 0x35a266c0, 0x27b971dd, 0x29b07cd6, 0x038f5fe7, 0x0d8652ec,

 13656     0x1f9d45f1, 0x119448fa, 0x4be30393, 0x45ea0e98, 0x57f11985, 0x59f8148e,

 13657     0x73c737bf, 0x7dce3ab4, 0x6fd52da9, 0x61dc20a2, 0xad766df6, 0xa37f60fd,

 13658     0xb16477e0, 0xbf6d7aeb, 0x955259da, 0x9b5b54d1, 0x894043cc, 0x87494ec7,

 13659     0xdd3e05ae, 0xd33708a5, 0xc12c1fb8, 0xcf2512b3, 0xe51a3182, 0xeb133c89,

 13660     0xf9082b94, 0xf701269f, 0x4de6bd46, 0x43efb04d, 0x51f4a750, 0x5ffdaa5b,

 13661     0x75c2896a, 0x7bcb8461, 0x69d0937c, 0x67d99e77, 0x3daed51e, 0x33a7d815,

 13662     0x21bccf08, 0x2fb5c203, 0x058ae132, 0x0b83ec39, 0x1998fb24, 0x1791f62f,

 13663     0x764dd68d, 0x7844db86, 0x6a5fcc9b, 0x6456c190, 0x4e69e2a1, 0x4060efaa,

 13664     0x527bf8b7, 0x5c72f5bc, 0x0605bed5, 0x080cb3de, 0x1a17a4c3, 0x141ea9c8,

 13665     0x3e218af9, 0x302887f2, 0x223390ef, 0x2c3a9de4, 0x96dd063d, 0x98d40b36,

 13666     0x8acf1c2b, 0x84c61120, 0xaef93211, 0xa0f03f1a, 0xb2eb2807, 0xbce2250c,

 13667     0xe6956e65, 0xe89c636e, 0xfa877473, 0xf48e7978, 0xdeb15a49, 0xd0b85742,

 13668     0xc2a3405f, 0xccaa4d54, 0x41ecdaf7, 0x4fe5d7fc, 0x5dfec0e1, 0x53f7cdea,

 13669     0x79c8eedb, 0x77c1e3d0, 0x65daf4cd, 0x6bd3f9c6, 0x31a4b2af, 0x3fadbfa4,

 13670     0x2db6a8b9, 0x23bfa5b2, 0x09808683, 0x07898b88, 0x15929c95, 0x1b9b919e,

 13671     0xa17c0a47, 0xaf75074c, 0xbd6e1051, 0xb3671d5a, 0x99583e6b, 0x97513360,

 13672     0x854a247d, 0x8b432976, 0xd134621f, 0xdf3d6f14, 0xcd267809, 0xc32f7502,

 13673     0xe9105633, 0xe7195b38, 0xf5024c25, 0xfb0b412e, 0x9ad7618c, 0x94de6c87,

 13674     0x86c57b9a, 0x88cc7691, 0xa2f355a0, 0xacfa58ab, 0xbee14fb6, 0xb0e842bd,

 13675     0xea9f09d4, 0xe49604df, 0xf68d13c2, 0xf8841ec9, 0xd2bb3df8, 0xdcb230f3,

 13676     0xcea927ee, 0xc0a02ae5, 0x7a47b13c, 0x744ebc37, 0x6655ab2a, 0x685ca621,

 13677     0x42638510, 0x4c6a881b, 0x5e719f06, 0x5078920d, 0x0a0fd964, 0x0406d46f,

 13678     0x161dc372, 0x1814ce79, 0x322bed48, 0x3c22e043, 0x2e39f75e, 0x2030fa55,

 13679     0xec9ab701, 0xe293ba0a, 0xf088ad17, 0xfe81a01c, 0xd4be832d, 0xdab78e26,

 13680     0xc8ac993b, 0xc6a59430, 0x9cd2df59, 0x92dbd252, 0x80c0c54f, 0x8ec9c844,

 13681     0xa4f6eb75, 0xaaffe67e, 0xb8e4f163, 0xb6edfc68, 0x0c0a67b1, 0x02036aba,

 13682     0x10187da7, 0x1e1170ac, 0x342e539d, 0x3a275e96, 0x283c498b, 0x26354480,

 13683     0x7c420fe9, 0x724b02e2, 0x605015ff, 0x6e5918f4, 0x44663bc5, 0x4a6f36ce,

 13684     0x587421d3, 0x567d2cd8, 0x37a10c7a, 0x39a80171, 0x2bb3166c, 0x25ba1b67,

 13685     0x0f853856, 0x018c355d, 0x13972240, 0x1d9e2f4b, 0x47e96422, 0x49e06929,

 13686     0x5bfb7e34, 0x55f2733f, 0x7fcd500e, 0x71c45d05, 0x63df4a18, 0x6dd64713,

 13687     0xd731dcca, 0xd938d1c1, 0xcb23c6dc, 0xc52acbd7, 0xef15e8e6, 0xe11ce5ed,

 13688     0xf307f2f0, 0xfd0efffb, 0xa779b492, 0xa970b999, 0xbb6bae84, 0xb562a38f,

 13689     0x9f5d80be, 0x91548db5, 0x834f9aa8, 0x8d4697a3]);

 13691   function expandKey128(cipherKey) {

 13692     var b = 176, result = new Uint8Array(b);

 13693     result.set(cipherKey);

 13694     for (var j = 16, i = 1; j < b; ++i) {

 13695       // RotWord

 13696       var t1 = result[j - 3], t2 = result[j - 2],

 13697           t3 = result[j - 1], t4 = result[j - 4];

 13698       // SubWord

 13699       t1 = s[t1]; t2 = s[t2]; t3 = s[t3]; t4 = s[t4];

 13700       // Rcon

 13701       t1 = t1 ^ rcon[i];

 13702       for (var n = 0; n < 4; ++n) {

 13703         result[j] = (t1 ^= result[j - 16]); j++;

 13704         result[j] = (t2 ^= result[j - 16]); j++;

 13705         result[j] = (t3 ^= result[j - 16]); j++;

 13706         result[j] = (t4 ^= result[j - 16]); j++;

 13707       }

 13708     }

 13709     return result;

 13710   }

 13712   function decrypt128(input, key) {

 13713     var state = new Uint8Array(16);

 13714     state.set(input);

 13715     var i, j, k;

 13716     var t, u, v;

 13717     // AddRoundKey

 13718     for (j = 0, k = 160; j < 16; ++j, ++k) {

 13719       state[j] ^= key[k];

 13720     }

 13721     for (i = 9; i >= 1; --i) {

 13722       // InvShiftRows

 13723       t = state[13]; state[13] = state[9]; state[9] = state[5];

 13724       state[5] = state[1]; state[1] = t;

 13725       t = state[14]; u = state[10]; state[14] = state[6];

 13726       state[10] = state[2]; state[6] = t; state[2] = u;

 13727       t = state[15]; u = state[11]; v = state[7]; state[15] = state[3];

 13728       state[11] = t; state[7] = u; state[3] = v;

 13729       // InvSubBytes

 13730       for (j = 0; j < 16; ++j) {

 13731         state[j] = inv_s[state[j]];

 13732       }

 13733       // AddRoundKey

 13734       for (j = 0, k = i * 16; j < 16; ++j, ++k) {

 13735         state[j] ^= key[k];

 13736       }

 13737       // InvMixColumns

 13738       for (j = 0; j < 16; j += 4) {

 13739         var s0 = mix[state[j]], s1 = mix[state[j + 1]],

 13740             s2 = mix[state[j + 2]], s3 = mix[state[j + 3]];

 13741         t = (s0 ^ (s1 >>> 8) ^ (s1 << 24) ^ (s2 >>> 16) ^ (s2 << 16) ^

 13742             (s3 >>> 24) ^ (s3 << 8));

 13743         state[j] = (t >>> 24) & 0xFF;

 13744         state[j + 1] = (t >> 16) & 0xFF;

 13745         state[j + 2] = (t >> 8) & 0xFF;

 13746         state[j + 3] = t & 0xFF;

 13747       }

 13748     }

 13749     // InvShiftRows

 13750     t = state[13]; state[13] = state[9]; state[9] = state[5];

 13751     state[5] = state[1]; state[1] = t;

 13752     t = state[14]; u = state[10]; state[14] = state[6];

 13753     state[10] = state[2]; state[6] = t; state[2] = u;

 13754     t = state[15]; u = state[11]; v = state[7]; state[15] = state[3];

 13755     state[11] = t; state[7] = u; state[3] = v;

 13756     for (j = 0; j < 16; ++j) {

 13757       // InvSubBytes

 13758       state[j] = inv_s[state[j]];

 13759       // AddRoundKey

 13760       state[j] ^= key[j];

 13761     }

 13762     return state;

 13763   }

 13765   function AES128Cipher(key) {

 13766     this.key = expandKey128(key);

 13767     this.buffer = new Uint8Array(16);

 13768     this.bufferPosition = 0;

 13769   }

 13771   function decryptBlock2(data, finalize) {

 13772     var i, j, ii, sourceLength = data.length,

 13773         buffer = this.buffer, bufferLength = this.bufferPosition,

 13774         result = [], iv = this.iv;

 13775     for (i = 0; i < sourceLength; ++i) {

 13776       buffer[bufferLength] = data[i];

 13777       ++bufferLength;

 13778       if (bufferLength < 16) {

 13779         continue;

 13780       }

 13781       // buffer is full, decrypting

 13782       var plain = decrypt128(buffer, this.key);

 13783       // xor-ing the IV vector to get plain text

 13784       for (j = 0; j < 16; ++j) {

 13785         plain[j] ^= iv[j];

 13786       }

 13787       iv = buffer;

 13788       result.push(plain);

 13789       buffer = new Uint8Array(16);

 13790       bufferLength = 0;

 13791     }

 13792     // saving incomplete buffer

 13793     this.buffer = buffer;

 13794     this.bufferLength = bufferLength;

 13795     this.iv = iv;

 13796     if (result.length === 0) {

 13797       return new Uint8Array([]);

 13798     }

 13799     // combining plain text blocks into one

 13800     var outputLength = 16 * result.length;

 13801     if (finalize) {

 13802       // undo a padding that is described in RFC 2898

 13803       var lastBlock = result[result.length - 1];

 13804       outputLength -= lastBlock[15];

 13805       result[result.length - 1] = lastBlock.subarray(0, 16 - lastBlock[15]);

 13806     }

 13807     var output = new Uint8Array(outputLength);

 13808     for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {

 13809       output.set(result[i], j);

 13810     }

 13811     return output;

 13812   }

 13814   AES128Cipher.prototype = {

 13815     decryptBlock: function AES128Cipher_decryptBlock(data, finalize) {

 13816       var i, sourceLength = data.length;

 13817       var buffer = this.buffer, bufferLength = this.bufferPosition;

 13818       // waiting for IV values -- they are at the start of the stream

 13819       for (i = 0; bufferLength < 16 && i < sourceLength; ++i, ++bufferLength) {

 13820         buffer[bufferLength] = data[i];

 13821       }

 13822       if (bufferLength < 16) {

 13823         // need more data

 13824         this.bufferLength = bufferLength;

 13825         return new Uint8Array([]);

 13826       }

 13827       this.iv = buffer;

 13828       this.buffer = new Uint8Array(16);

 13829       this.bufferLength = 0;

 13830       // starting decryption

 13831       this.decryptBlock = decryptBlock2;

 13832       return this.decryptBlock(data.subarray(16), finalize);

 13833     }

 13834   };

 13836   return AES128Cipher;

 13837 })();

 13839 var CipherTransform = (function CipherTransformClosure() {

 13840   function CipherTransform(stringCipherConstructor, streamCipherConstructor) {

 13841     this.stringCipherConstructor = stringCipherConstructor;

 13842     this.streamCipherConstructor = streamCipherConstructor;

 13843   }

 13844   CipherTransform.prototype = {

 13845     createStream: function CipherTransform_createStream(stream, length) {

 13846       var cipher = new this.streamCipherConstructor();

 13847       return new DecryptStream(stream, length,

 13848         function cipherTransformDecryptStream(data, finalize) {

 13849           return cipher.decryptBlock(data, finalize);

 13850         }

 13851       );

 13852     },

 13853     decryptString: function CipherTransform_decryptString(s) {

 13854       var cipher = new this.stringCipherConstructor();

 13855       var data = stringToBytes(s);

 13856       data = cipher.decryptBlock(data, true);

 13857       return bytesToString(data);

 13858     }

 13859   };

 13860   return CipherTransform;

 13861 })();

 13863 var CipherTransformFactory = (function CipherTransformFactoryClosure() {

 13864   var defaultPasswordBytes = new Uint8Array([

 13865     0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41,

 13866     0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,

 13867     0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80,

 13868     0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A]);

 13870   function prepareKeyData(fileId, password, ownerPassword, userPassword,

 13871                           flags, revision, keyLength, encryptMetadata) {

 13872     var hashDataSize = 40 + ownerPassword.length + fileId.length;

 13873     var hashData = new Uint8Array(hashDataSize), i = 0, j, n;

 13874     if (password) {

 13875       n = Math.min(32, password.length);

 13876       for (; i < n; ++i) {

 13877         hashData[i] = password[i];

 13878       }

 13879     }

 13880     j = 0;

 13881     while (i < 32) {

 13882       hashData[i++] = defaultPasswordBytes[j++];

 13883     }

 13884     // as now the padded password in the hashData[0..i]

 13885     for (j = 0, n = ownerPassword.length; j < n; ++j) {

 13886       hashData[i++] = ownerPassword[j];

 13887     }

 13888     hashData[i++] = flags & 0xFF;

 13889     hashData[i++] = (flags >> 8) & 0xFF;

 13890     hashData[i++] = (flags >> 16) & 0xFF;

 13891     hashData[i++] = (flags >>> 24) & 0xFF;

 13892     for (j = 0, n = fileId.length; j < n; ++j) {

 13893       hashData[i++] = fileId[j];

 13894     }

 13895     if (revision >= 4 && !encryptMetadata) {

 13896       hashData[i++] = 0xFF;

 13897       hashData[i++] = 0xFF;

 13898       hashData[i++] = 0xFF;

 13899       hashData[i++] = 0xFF;

 13900     }

 13901     var hash = calculateMD5(hashData, 0, i);

 13902     var keyLengthInBytes = keyLength >> 3;

 13903     if (revision >= 3) {

 13904       for (j = 0; j < 50; ++j) {

 13905         hash = calculateMD5(hash, 0, keyLengthInBytes);

 13906       }

 13907     }

 13908     var encryptionKey = hash.subarray(0, keyLengthInBytes);

 13909     var cipher, checkData;

 13911     if (revision >= 3) {

 13912       for (i = 0; i < 32; ++i) {

 13913         hashData[i] = defaultPasswordBytes[i];

 13914       }

 13915       for (j = 0, n = fileId.length; j < n; ++j) {

 13916         hashData[i++] = fileId[j];

 13917       }

 13918       cipher = new ARCFourCipher(encryptionKey);

 13919       checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));

 13920       n = encryptionKey.length;

 13921       var derivedKey = new Uint8Array(n), k;

 13922       for (j = 1; j <= 19; ++j) {

 13923         for (k = 0; k < n; ++k) {

 13924           derivedKey[k] = encryptionKey[k] ^ j;

 13925         }

 13926         cipher = new ARCFourCipher(derivedKey);

 13927         checkData = cipher.encryptBlock(checkData);

 13928       }

 13929       for (j = 0, n = checkData.length; j < n; ++j) {

 13930         if (userPassword[j] != checkData[j]) {

 13931           return null;

 13932         }

 13933       }

 13934     } else {

 13935       cipher = new ARCFourCipher(encryptionKey);

 13936       checkData = cipher.encryptBlock(defaultPasswordBytes);

 13937       for (j = 0, n = checkData.length; j < n; ++j) {

 13938         if (userPassword[j] != checkData[j]) {

 13939           return null;

 13940         }

 13941       }

 13942     }

 13943     return encryptionKey;

 13944   }

 13946   function decodeUserPassword(password, ownerPassword, revision, keyLength) {

 13947     var hashData = new Uint8Array(32), i = 0, j, n;

 13948     n = Math.min(32, password.length);

 13949     for (; i < n; ++i) {

 13950       hashData[i] = password[i];

 13951     }

 13952     j = 0;

 13953     while (i < 32) {

 13954       hashData[i++] = defaultPasswordBytes[j++];

 13955     }

 13956     var hash = calculateMD5(hashData, 0, i);

 13957     var keyLengthInBytes = keyLength >> 3;

 13958     if (revision >= 3) {

 13959       for (j = 0; j < 50; ++j) {

 13960         hash = calculateMD5(hash, 0, hash.length);

 13961       }

 13962     }

 13964     var cipher, userPassword;

 13965     if (revision >= 3) {

 13966       userPassword = ownerPassword;

 13967       var derivedKey = new Uint8Array(keyLengthInBytes), k;

 13968       for (j = 19; j >= 0; j--) {

 13969         for (k = 0; k < keyLengthInBytes; ++k) {

 13970           derivedKey[k] = hash[k] ^ j;

 13971         }

 13972         cipher = new ARCFourCipher(derivedKey);

 13973         userPassword = cipher.encryptBlock(userPassword);

 13974       }

 13975     } else {

 13976       cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));

 13977       userPassword = cipher.encryptBlock(ownerPassword);

 13978     }

 13979     return userPassword;

 13980   }

 13982   var identityName = Name.get('Identity');

 13984   function CipherTransformFactory(dict, fileId, password) {

 13985     var filter = dict.get('Filter');

 13986     if (!isName(filter) || filter.name != 'Standard') {

 13987       error('unknown encryption method');

 13988     }

 13989     this.dict = dict;

 13990     var algorithm = dict.get('V');

 13991     if (!isInt(algorithm) ||

 13992         (algorithm != 1 && algorithm != 2 && algorithm != 4)) {

 13993       error('unsupported encryption algorithm');

 13994     }

 13995     this.algorithm = algorithm;

 13996     var keyLength = dict.get('Length') || 40;

 13997     if (!isInt(keyLength) ||

 13998         keyLength < 40 || (keyLength % 8) !== 0) {

 13999       error('invalid key length');

 14000     }

 14002     // prepare keys

 14003     var ownerPassword = stringToBytes(dict.get('O')).subarray(0, 32);

 14004     var userPassword = stringToBytes(dict.get('U')).subarray(0, 32);

 14005     var flags = dict.get('P');

 14006     var revision = dict.get('R');

 14007     var encryptMetadata = (algorithm == 4 &&  // meaningful when V is 4

 14008       dict.get('EncryptMetadata') !== false); // makes true as default value

 14009     this.encryptMetadata = encryptMetadata;

 14011     var fileIdBytes = stringToBytes(fileId);

 14012     var passwordBytes;

 14013     if (password) {

 14014       passwordBytes = stringToBytes(password);

 14015     }

 14017     var encryptionKey = prepareKeyData(fileIdBytes, passwordBytes,

 14018                                        ownerPassword, userPassword, flags,

 14019                                        revision, keyLength, encryptMetadata);

 14020     if (!encryptionKey && !password) {

 14021       throw new PasswordException('No password given',

 14022                                   PasswordResponses.NEED_PASSWORD);

 14023     } else if (!encryptionKey && password) {

 14024       // Attempting use the password as an owner password

 14025       var decodedPassword = decodeUserPassword(passwordBytes, ownerPassword,

 14026                                                revision, keyLength);

 14027       encryptionKey = prepareKeyData(fileIdBytes, decodedPassword,

 14028                                      ownerPassword, userPassword, flags,

 14029                                      revision, keyLength, encryptMetadata);

 14030     }

 14032     if (!encryptionKey) {

 14033       throw new PasswordException('Incorrect Password',

 14034                                   PasswordResponses.INCORRECT_PASSWORD);

 14035     }

 14037     this.encryptionKey = encryptionKey;

 14039     if (algorithm == 4) {

 14040       this.cf = dict.get('CF');

 14041       this.stmf = dict.get('StmF') || identityName;

 14042       this.strf = dict.get('StrF') || identityName;

 14043       this.eff = dict.get('EFF') || this.strf;

 14044     }

 14045   }

 14047   function buildObjectKey(num, gen, encryptionKey, isAes) {

 14048     var key = new Uint8Array(encryptionKey.length + 9), i, n;

 14049     for (i = 0, n = encryptionKey.length; i < n; ++i) {

 14050       key[i] = encryptionKey[i];

 14051     }

 14052     key[i++] = num & 0xFF;

 14053     key[i++] = (num >> 8) & 0xFF;

 14054     key[i++] = (num >> 16) & 0xFF;

 14055     key[i++] = gen & 0xFF;

 14056     key[i++] = (gen >> 8) & 0xFF;

 14057     if (isAes) {

 14058       key[i++] = 0x73;

 14059       key[i++] = 0x41;

 14060       key[i++] = 0x6C;

 14061       key[i++] = 0x54;

 14062     }

 14063     var hash = calculateMD5(key, 0, i);

 14064     return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));

 14065   }

 14067   function buildCipherConstructor(cf, name, num, gen, key) {

 14068     var cryptFilter = cf.get(name.name);

 14069     var cfm;

 14070     if (cryptFilter !== null && cryptFilter !== undefined) {

 14071       cfm = cryptFilter.get('CFM');

 14072     }

 14073     if (!cfm || cfm.name == 'None') {

 14074       return function cipherTransformFactoryBuildCipherConstructorNone() {

 14075         return new NullCipher();

 14076       };

 14077     }

 14078     if ('V2' == cfm.name) {

 14079       return function cipherTransformFactoryBuildCipherConstructorV2() {

 14080         return new ARCFourCipher(buildObjectKey(num, gen, key, false));

 14081       };

 14082     }

 14083     if ('AESV2' == cfm.name) {

 14084       return function cipherTransformFactoryBuildCipherConstructorAESV2() {

 14085         return new AES128Cipher(buildObjectKey(num, gen, key, true));

 14086       };

 14087     }

 14088     error('Unknown crypto method');

 14089   }

 14091   CipherTransformFactory.prototype = {

 14092     createCipherTransform:

 14093       function CipherTransformFactory_createCipherTransform(num, gen) {

 14094       if (this.algorithm == 4) {

 14095         return new CipherTransform(

 14096           buildCipherConstructor(this.cf, this.stmf,

 14097                                  num, gen, this.encryptionKey),

 14098           buildCipherConstructor(this.cf, this.strf,

 14099                                  num, gen, this.encryptionKey));

 14100       }

 14101       // algorithms 1 and 2

 14102       var key = buildObjectKey(num, gen, this.encryptionKey, false);

 14103       var cipherConstructor = function buildCipherCipherConstructor() {

 14104         return new ARCFourCipher(key);

 14105       };

 14106       return new CipherTransform(cipherConstructor, cipherConstructor);

 14107     }

 14108   };

 14110   return CipherTransformFactory;

 14111 })();

 14115 var PatternType = {

 14116   FUNCTION_BASED: 1,

 14117   AXIAL: 2,

 14118   RADIAL: 3,

 14119   FREE_FORM_MESH: 4,

 14120   LATTICE_FORM_MESH: 5,

 14121   COONS_PATCH_MESH: 6,

 14122   TENSOR_PATCH_MESH: 7

 14123 };

 14125 var Pattern = (function PatternClosure() {

 14126   // Constructor should define this.getPattern

 14127   function Pattern() {

 14128     error('should not call Pattern constructor');

 14129   }

 14131   Pattern.prototype = {

 14132     // Input: current Canvas context

 14133     // Output: the appropriate fillStyle or strokeStyle

 14134     getPattern: function Pattern_getPattern(ctx) {

 14135       error('Should not call Pattern.getStyle: ' + ctx);

 14136     }

 14137   };

 14139   Pattern.parseShading = function Pattern_parseShading(shading, matrix, xref,

 14140                                                        res) {

 14142     var dict = isStream(shading) ? shading.dict : shading;

 14143     var type = dict.get('ShadingType');

 14145     switch (type) {

 14146       case PatternType.AXIAL:

 14147       case PatternType.RADIAL:

 14148         // Both radial and axial shadings are handled by RadialAxial shading.

 14149         return new Shadings.RadialAxial(dict, matrix, xref, res);

 14150       case PatternType.FREE_FORM_MESH:

 14151       case PatternType.LATTICE_FORM_MESH:

 14152       case PatternType.COONS_PATCH_MESH:

 14153       case PatternType.TENSOR_PATCH_MESH:

 14154         return new Shadings.Mesh(shading, matrix, xref, res);

 14155       default:

 14156         UnsupportedManager.notify(UNSUPPORTED_FEATURES.shadingPattern);

 14157         return new Shadings.Dummy();

 14158     }

 14159   };

 14160   return Pattern;

 14161 })();

 14163 var Shadings = {};

 14165 // A small number to offset the first/last color stops so we can insert ones to

 14166 // support extend.  Number.MIN_VALUE appears to be too small and breaks the

 14167 // extend. 1e-7 works in FF but chrome seems to use an even smaller sized number

 14168 // internally so we have to go bigger.

 14169 Shadings.SMALL_NUMBER = 1e-2;

 14171 // Radial and axial shading have very similar implementations

 14172 // If needed, the implementations can be broken into two classes

 14173 Shadings.RadialAxial = (function RadialAxialClosure() {

 14174   function RadialAxial(dict, matrix, xref, res) {

 14175     this.matrix = matrix;

 14176     this.coordsArr = dict.get('Coords');

 14177     this.shadingType = dict.get('ShadingType');

 14178     this.type = 'Pattern';

 14179     var cs = dict.get('ColorSpace', 'CS');

 14180     cs = ColorSpace.parse(cs, xref, res);

 14181     this.cs = cs;

 14183     var t0 = 0.0, t1 = 1.0;

 14184     if (dict.has('Domain')) {

 14185       var domainArr = dict.get('Domain');

 14186       t0 = domainArr[0];

 14187       t1 = domainArr[1];

 14188     }

 14190     var extendStart = false, extendEnd = false;

 14191     if (dict.has('Extend')) {

 14192       var extendArr = dict.get('Extend');

 14193       extendStart = extendArr[0];

 14194       extendEnd = extendArr[1];

 14195     }

 14197     if (this.shadingType === PatternType.RADIAL &&

 14198        (!extendStart || !extendEnd)) {

 14199       // Radial gradient only currently works if either circle is fully within

 14200       // the other circle.

 14201       var x1 = this.coordsArr[0];

 14202       var y1 = this.coordsArr[1];

 14203       var r1 = this.coordsArr[2];

 14204       var x2 = this.coordsArr[3];

 14205       var y2 = this.coordsArr[4];

 14206       var r2 = this.coordsArr[5];

 14207       var distance = Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));

 14208       if (r1 <= r2 + distance &&

 14209           r2 <= r1 + distance) {

 14210         warn('Unsupported radial gradient.');

 14211       }

 14212     }

 14214     this.extendStart = extendStart;

 14215     this.extendEnd = extendEnd;

 14217     var fnObj = dict.get('Function');

 14218     var fn;

 14219     if (isArray(fnObj)) {

 14220       var fnArray = [];

 14221       for (var j = 0, jj = fnObj.length; j < jj; j++) {

 14222         var obj = xref.fetchIfRef(fnObj[j]);

 14223         if (!isPDFFunction(obj)) {

 14224           error('Invalid function');

 14225         }

 14226         fnArray.push(PDFFunction.parse(xref, obj));

 14227       }

 14228       fn = function radialAxialColorFunction(arg) {

 14229         var out = [];

 14230         for (var i = 0, ii = fnArray.length; i < ii; i++) {

 14231           out.push(fnArray[i](arg)[0]);

 14232         }

 14233         return out;

 14234       };

 14235     } else {

 14236       if (!isPDFFunction(fnObj)) {

 14237         error('Invalid function');

 14238       }

 14239       fn = PDFFunction.parse(xref, fnObj);

 14240     }

 14242     // 10 samples seems good enough for now, but probably won't work

 14243     // if there are sharp color changes. Ideally, we would implement

 14244     // the spec faithfully and add lossless optimizations.

 14245     var diff = t1 - t0;

 14246     var step = diff / 10;

 14248     var colorStops = this.colorStops = [];

 14250     // Protect against bad domains so we don't end up in an infinte loop below.

 14251     if (t0 >= t1 || step <= 0) {

 14252       // Acrobat doesn't seem to handle these cases so we'll ignore for

 14253       // now.

 14254       info('Bad shading domain.');

 14255       return;

 14256     }

 14258     var rgbColor;

 14259     for (var i = t0; i <= t1; i += step) {

 14260       rgbColor = cs.getRgb(fn([i]), 0);

 14261       var cssColor = Util.makeCssRgb(rgbColor);

 14262       colorStops.push([(i - t0) / diff, cssColor]);

 14263     }

 14265     var background = 'transparent';

 14266     if (dict.has('Background')) {

 14267       rgbColor = cs.getRgb(dict.get('Background'), 0);

 14268       background = Util.makeCssRgb(rgbColor);

 14269     }

 14271     if (!extendStart) {

 14272       // Insert a color stop at the front and offset the first real color stop

 14273       // so it doesn't conflict with the one we insert.

 14274       colorStops.unshift([0, background]);

 14275       colorStops[1][0] += Shadings.SMALL_NUMBER;

 14276     }

 14277     if (!extendEnd) {

 14278       // Same idea as above in extendStart but for the end.

 14279       colorStops[colorStops.length - 1][0] -= Shadings.SMALL_NUMBER;

 14280       colorStops.push([1, background]);

 14281     }

 14283     this.colorStops = colorStops;

 14284   }

 14286   RadialAxial.prototype = {

 14287     getIR: function RadialAxial_getIR() {

 14288       var coordsArr = this.coordsArr;

 14289       var shadingType = this.shadingType;

 14290       var type, p0, p1, r0, r1;

 14291       if (shadingType == PatternType.AXIAL) {

 14292         p0 = [coordsArr[0], coordsArr[1]];

 14293         p1 = [coordsArr[2], coordsArr[3]];

 14294         r0 = null;

 14295         r1 = null;

 14296         type = 'axial';

 14297       } else if (shadingType == PatternType.RADIAL) {

 14298         p0 = [coordsArr[0], coordsArr[1]];

 14299         p1 = [coordsArr[3], coordsArr[4]];

 14300         r0 = coordsArr[2];

 14301         r1 = coordsArr[5];

 14302         type = 'radial';

 14303       } else {

 14304         error('getPattern type unknown: ' + shadingType);

 14305       }

 14307       var matrix = this.matrix;

 14308       if (matrix) {

 14309         p0 = Util.applyTransform(p0, matrix);

 14310         p1 = Util.applyTransform(p1, matrix);

 14311       }

 14313       return ['RadialAxial', type, this.colorStops, p0, p1, r0, r1];

 14314     }

 14315   };

 14317   return RadialAxial;

 14318 })();

 14320 // All mesh shading. For now, they will be presented as set of the triangles

 14321 // to be drawn on the canvas and rgb color for each vertex.

 14322 Shadings.Mesh = (function MeshClosure() {

 14323   function MeshStreamReader(stream, context) {

 14324     this.stream = stream;

 14325     this.context = context;

 14326     this.buffer = 0;

 14327     this.bufferLength = 0;

 14328   }

 14329   MeshStreamReader.prototype = {

 14330     get hasData() {

 14331       if (this.stream.end) {

 14332         return this.stream.pos < this.stream.end;

 14333       }

 14334       if (this.bufferLength > 0) {

 14335         return true;

 14336       }

 14337       var nextByte = this.stream.getByte();

 14338       if (nextByte < 0) {

 14339         return false;

 14340       }

 14341       this.buffer = nextByte;

 14342       this.bufferLength = 8;

 14343       return true;

 14344     },

 14345     readBits: function MeshStreamReader_readBits(n) {

 14346       var buffer = this.buffer;

 14347       var bufferLength = this.bufferLength;

 14348       if (n === 32) {

 14349         if (bufferLength === 0) {

 14350           return ((this.stream.getByte() << 24) |

 14351             (this.stream.getByte() << 16) | (this.stream.getByte() << 8) |

 14352             this.stream.getByte()) >>> 0;

 14353         }

 14354         buffer = (buffer << 24) | (this.stream.getByte() << 16) |

 14355           (this.stream.getByte() << 8) | this.stream.getByte();

 14356         var nextByte = this.stream.getByte();

 14357         this.buffer = nextByte & ((1 << bufferLength) - 1);

 14358         return ((buffer << (8 - bufferLength)) |

 14359           ((nextByte & 0xFF) >> bufferLength)) >>> 0;

 14360       }

 14361       if (n === 8 && bufferLength === 0) {

 14362         return this.stream.getByte();

 14363       }

 14364       while (bufferLength < n) {

 14365         buffer = (buffer << 8) | this.stream.getByte();

 14366         bufferLength += 8;

 14367       }

 14368       bufferLength -= n;

 14369       this.bufferLength = bufferLength;

 14370       this.buffer = buffer & ((1 << bufferLength) - 1);

 14371       return buffer >> bufferLength;

 14372     },

 14373     align: function MeshStreamReader_align() {

 14374       this.buffer = 0;

 14375       this.bufferLength = 0;

 14376     },

 14377     readFlag: function MeshStreamReader_readFlag() {

 14378       return this.readBits(this.context.bitsPerFlag);

 14379     },

 14380     readCoordinate: function MeshStreamReader_readCoordinate() {

 14381       var bitsPerCoordinate = this.context.bitsPerCoordinate;

 14382       var xi = this.readBits(bitsPerCoordinate);

 14383       var yi = this.readBits(bitsPerCoordinate);

 14384       var decode = this.context.decode;

 14385       var scale = bitsPerCoordinate < 32 ? 1 / ((1 << bitsPerCoordinate) - 1) :

 14386         2.3283064365386963e-10; // 2 ^ -32

 14387       return [

 14388         xi * scale * (decode[1] - decode[0]) + decode[0],

 14389         yi * scale * (decode[3] - decode[2]) + decode[2]

 14390       ];

 14391     },

 14392     readComponents: function MeshStreamReader_readComponents() {

 14393       var numComps = this.context.numComps;

 14394       var bitsPerComponent = this.context.bitsPerComponent;

 14395       var scale = bitsPerComponent < 32 ? 1 / ((1 << bitsPerComponent) - 1) :

 14396         2.3283064365386963e-10; // 2 ^ -32

 14397       var decode = this.context.decode;

 14398       var components = [];

 14399       for (var i = 0, j = 4; i < numComps; i++, j += 2) {

 14400         var ci = this.readBits(bitsPerComponent);

 14401         components.push(ci * scale * (decode[j + 1] - decode[j]) + decode[j]);

 14402       }

 14403       if (this.context.colorFn) {

 14404         components = this.context.colorFn(components);

 14405       }

 14406       return this.context.colorSpace.getRgb(components, 0);

 14407     }

 14408   };

 14410   function decodeType4Shading(mesh, reader) {

 14411     var coords = mesh.coords;

 14412     var colors = mesh.colors;

 14413     var operators = [];

 14414     var ps = []; // not maintaining cs since that will match ps

 14415     var verticesLeft = 0; // assuming we have all data to start a new triangle

 14416     while (reader.hasData) {

 14417       var f = reader.readFlag();

 14418       var coord = reader.readCoordinate();

 14419       var color = reader.readComponents();

 14420       if (verticesLeft === 0) { // ignoring flags if we started a triangle

 14421         assert(0 <= f && f <= 2, 'Unknown type4 flag');

 14422         switch (f) {

 14423           case 0:

 14424             verticesLeft = 3;

 14425             break;

 14426           case 1:

 14427             ps.push(ps[ps.length - 2], ps[ps.length - 1]);

 14428             verticesLeft = 1;

 14429             break;

 14430           case 2:

 14431             ps.push(ps[ps.length - 3], ps[ps.length - 1]);

 14432             verticesLeft = 1;

 14433             break;

 14434         }

 14435         operators.push(f);

 14436       }

 14437       ps.push(coords.length);

 14438       coords.push(coord);

 14439       colors.push(color);

 14440       verticesLeft--;

 14442       reader.align();

 14443     }

 14445     var psPacked = new Int32Array(ps);

 14447     mesh.figures.push({

 14448       type: 'triangles',

 14449       coords: psPacked,

 14450       colors: psPacked

 14451     });

 14452   }

 14454   function decodeType5Shading(mesh, reader, verticesPerRow) {

 14455     var coords = mesh.coords;

 14456     var colors = mesh.colors;

 14457     var ps = []; // not maintaining cs since that will match ps

 14458     while (reader.hasData) {

 14459       var coord = reader.readCoordinate();

 14460       var color = reader.readComponents();

 14461       ps.push(coords.length);

 14462       coords.push(coord);

 14463       colors.push(color);

 14464     }

 14466     var psPacked = new Int32Array(ps);

 14468     mesh.figures.push({

 14469       type: 'lattice',

 14470       coords: psPacked,

 14471       colors: psPacked,

 14472       verticesPerRow: verticesPerRow

 14473     });

 14474   }

 14476   var MIN_SPLIT_PATCH_CHUNKS_AMOUNT = 3;

 14477   var MAX_SPLIT_PATCH_CHUNKS_AMOUNT = 20;

 14479   var TRIANGLE_DENSITY = 20; // count of triangles per entire mesh bounds

 14481   var getB = (function getBClosure() {

 14482     function buildB(count) {

 14483       var lut = [];

 14484       for (var i = 0; i <= count; i++) {

 14485         var t = i / count, t_ = 1 - t;

 14486         lut.push(new Float32Array([t_ * t_ * t_, 3 * t * t_ * t_,

 14487           3 * t * t * t_, t * t * t]));

 14488       }

 14489       return lut;

 14490     }

 14491     var cache = [];

 14492     return function getB(count) {

 14493       if (!cache[count]) {

 14494         cache[count] = buildB(count);

 14495       }

 14496       return cache[count];

 14497     };

 14498   })();

 14500   function buildFigureFromPatch(mesh, index) {

 14501     var figure = mesh.figures[index];

 14502     assert(figure.type === 'patch', 'Unexpected patch mesh figure');

 14504     var coords = mesh.coords, colors = mesh.colors;

 14505     var pi = figure.coords;

 14506     var ci = figure.colors;

 14508     var figureMinX = Math.min(coords[pi[0]][0], coords[pi[3]][0],

 14509                               coords[pi[12]][0], coords[pi[15]][0]);

 14510     var figureMinY = Math.min(coords[pi[0]][1], coords[pi[3]][1],

 14511                               coords[pi[12]][1], coords[pi[15]][1]);

 14512     var figureMaxX = Math.max(coords[pi[0]][0], coords[pi[3]][0],

 14513                               coords[pi[12]][0], coords[pi[15]][0]);

 14514     var figureMaxY = Math.max(coords[pi[0]][1], coords[pi[3]][1],

 14515                               coords[pi[12]][1], coords[pi[15]][1]);

 14516     var splitXBy = Math.ceil((figureMaxX - figureMinX) * TRIANGLE_DENSITY /

 14517                              (mesh.bounds[2] - mesh.bounds[0]));

 14518     splitXBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT,

 14519                Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitXBy));

 14520     var splitYBy = Math.ceil((figureMaxY - figureMinY) * TRIANGLE_DENSITY /

 14521                              (mesh.bounds[3] - mesh.bounds[1]));

 14522     splitYBy = Math.max(MIN_SPLIT_PATCH_CHUNKS_AMOUNT,

 14523                Math.min(MAX_SPLIT_PATCH_CHUNKS_AMOUNT, splitYBy));

 14525     var verticesPerRow = splitXBy + 1;

 14526     var figureCoords = new Int32Array((splitYBy + 1) * verticesPerRow);

 14527     var figureColors = new Int32Array((splitYBy + 1) * verticesPerRow);

 14528     var k = 0;

 14529     var cl = new Uint8Array(3), cr = new Uint8Array(3);

 14530     var c0 = colors[ci[0]], c1 = colors[ci[1]],

 14531       c2 = colors[ci[2]], c3 = colors[ci[3]];

 14532     var bRow = getB(splitYBy), bCol = getB(splitXBy);

 14533     for (var row = 0; row <= splitYBy; row++) {

 14534       cl[0] = ((c0[0] * (splitYBy - row) + c2[0] * row) / splitYBy) | 0;

 14535       cl[1] = ((c0[1] * (splitYBy - row) + c2[1] * row) / splitYBy) | 0;

 14536       cl[2] = ((c0[2] * (splitYBy - row) + c2[2] * row) / splitYBy) | 0;

 14538       cr[0] = ((c1[0] * (splitYBy - row) + c3[0] * row) / splitYBy) | 0;

 14539       cr[1] = ((c1[1] * (splitYBy - row) + c3[1] * row) / splitYBy) | 0;

 14540       cr[2] = ((c1[2] * (splitYBy - row) + c3[2] * row) / splitYBy) | 0;

 14542       for (var col = 0; col <= splitXBy; col++, k++) {

 14543         if ((row === 0 || row === splitYBy) &&

 14544             (col === 0 || col === splitXBy)) {

 14545           continue;

 14546         }

 14547         var x = 0, y = 0;

 14548         var q = 0;

 14549         for (var i = 0; i <= 3; i++) {

 14550           for (var j = 0; j <= 3; j++, q++) {

 14551             var m = bRow[row][i] * bCol[col][j];

 14552             x += coords[pi[q]][0] * m;

 14553             y += coords[pi[q]][1] * m;

 14554           }

 14555         }

 14556         figureCoords[k] = coords.length;

 14557         coords.push([x, y]);

 14558         figureColors[k] = colors.length;

 14559         var newColor = new Uint8Array(3);

 14560         newColor[0] = ((cl[0] * (splitXBy - col) + cr[0] * col) / splitXBy) | 0;

 14561         newColor[1] = ((cl[1] * (splitXBy - col) + cr[1] * col) / splitXBy) | 0;

 14562         newColor[2] = ((cl[2] * (splitXBy - col) + cr[2] * col) / splitXBy) | 0;

 14563         colors.push(newColor);

 14564       }

 14565     }

 14566     figureCoords[0] = pi[0];

 14567     figureColors[0] = ci[0];

 14568     figureCoords[splitXBy] = pi[3];

 14569     figureColors[splitXBy] = ci[1];

 14570     figureCoords[verticesPerRow * splitYBy] = pi[12];

 14571     figureColors[verticesPerRow * splitYBy] = ci[2];

 14572     figureCoords[verticesPerRow * splitYBy + splitXBy] = pi[15];

 14573     figureColors[verticesPerRow * splitYBy + splitXBy] = ci[3];

 14575     mesh.figures[index] = {

 14576       type: 'lattice',

 14577       coords: figureCoords,

 14578       colors: figureColors,

 14579       verticesPerRow: verticesPerRow

 14580     };

 14581   }

 14583   function decodeType6Shading(mesh, reader) {

 14584     // A special case of Type 7. The p11, p12, p21, p22 automatically filled

 14585     var coords = mesh.coords;

 14586     var colors = mesh.colors;

 14587     var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33

 14588     var cs = new Int32Array(4); // c00, c30, c03, c33

 14589     while (reader.hasData) {

 14590       var f = reader.readFlag();

 14591       assert(0 <= f && f <= 3, 'Unknown type6 flag');

 14592       var i, ii;

 14593       var pi = coords.length;

 14594       for (i = 0, ii = (f !== 0 ? 8 : 12); i < ii; i++) {

 14595         coords.push(reader.readCoordinate());

 14596       }

 14597       var ci = colors.length;

 14598       for (i = 0, ii = (f !== 0 ? 2 : 4); i < ii; i++) {

 14599         colors.push(reader.readComponents());

 14600       }

 14601       var tmp1, tmp2, tmp3, tmp4;

 14602       switch (f) {

 14603         case 0:

 14604           ps[12] = pi + 3; ps[13] = pi + 4;  ps[14] = pi + 5;  ps[15] = pi + 6;

 14605           ps[ 8] = pi + 2; /* values for 5, 6, 9, 10 are    */ ps[11] = pi + 7;

 14606           ps[ 4] = pi + 1; /* calculated below              */ ps[ 7] = pi + 8;

 14607           ps[ 0] = pi;     ps[ 1] = pi + 11; ps[ 2] = pi + 10; ps[ 3] = pi + 9;

 14608           cs[2] = ci + 1; cs[3] = ci + 2;

 14609           cs[0] = ci;     cs[1] = ci + 3;

 14610           break;

 14611         case 1:

 14612           tmp1 = ps[12]; tmp2 = ps[13]; tmp3 = ps[14]; tmp4 = ps[15];

 14613           ps[12] = pi + 5; ps[13] = pi + 4;  ps[14] = pi + 3;  ps[15] = pi + 2;

 14614           ps[ 8] = pi + 6; /* values for 5, 6, 9, 10 are    */ ps[11] = pi + 1;

 14615           ps[ 4] = pi + 7; /* calculated below              */ ps[ 7] = pi;

 14616           ps[ 0] = tmp1;   ps[ 1] = tmp2;    ps[ 2] = tmp3;    ps[ 3] = tmp4;

 14617           tmp1 = cs[2]; tmp2 = cs[3];

 14618           cs[2] = ci + 1; cs[3] = ci;

 14619           cs[0] = tmp1;   cs[1] = tmp2;

 14620           break;

 14621         case 2:

 14622           ps[12] = ps[15]; ps[13] = pi + 7; ps[14] = pi + 6;   ps[15] = pi + 5;

 14623           ps[ 8] = ps[11]; /* values for 5, 6, 9, 10 are    */ ps[11] = pi + 4;

 14624           ps[ 4] = ps[7];  /* calculated below              */ ps[ 7] = pi + 3;

 14625           ps[ 0] = ps[3];  ps[ 1] = pi;     ps[ 2] = pi + 1;   ps[ 3] = pi + 2;

 14626           cs[2] = cs[3]; cs[3] = ci + 1;

 14627           cs[0] = cs[1]; cs[1] = ci;

 14628           break;

 14629         case 3:

 14630           ps[12] = ps[0];  ps[13] = ps[1];   ps[14] = ps[2];   ps[15] = ps[3];

 14631           ps[ 8] = pi;     /* values for 5, 6, 9, 10 are    */ ps[11] = pi + 7;

 14632           ps[ 4] = pi + 1; /* calculated below              */ ps[ 7] = pi + 6;

 14633           ps[ 0] = pi + 2; ps[ 1] = pi + 3;  ps[ 2] = pi + 4;  ps[ 3] = pi + 5;

 14634           cs[2] = cs[0]; cs[3] = cs[1];

 14635           cs[0] = ci;    cs[1] = ci + 1;

 14636           break;

 14637       }

 14638       // set p11, p12, p21, p22

 14639       ps[5] = coords.length;

 14640       coords.push([

 14641         (-4 * coords[ps[0]][0] - coords[ps[15]][0] +

 14642           6 * (coords[ps[4]][0] + coords[ps[1]][0]) -

 14643           2 * (coords[ps[12]][0] + coords[ps[3]][0]) +

 14644           3 * (coords[ps[13]][0] + coords[ps[7]][0])) / 9,

 14645         (-4 * coords[ps[0]][1] - coords[ps[15]][1] +

 14646           6 * (coords[ps[4]][1] + coords[ps[1]][1]) -

 14647           2 * (coords[ps[12]][1] + coords[ps[3]][1]) +

 14648           3 * (coords[ps[13]][1] + coords[ps[7]][1])) / 9

 14649       ]);

 14650       ps[6] = coords.length;

 14651       coords.push([

 14652         (-4 * coords[ps[3]][0] - coords[ps[12]][0] +

 14653           6 * (coords[ps[2]][0] + coords[ps[7]][0]) -

 14654           2 * (coords[ps[0]][0] + coords[ps[15]][0]) +

 14655           3 * (coords[ps[4]][0] + coords[ps[14]][0])) / 9,

 14656         (-4 * coords[ps[3]][1] - coords[ps[12]][1] +

 14657           6 * (coords[ps[2]][1] + coords[ps[7]][1]) -

 14658           2 * (coords[ps[0]][1] + coords[ps[15]][1]) +

 14659           3 * (coords[ps[4]][1] + coords[ps[14]][1])) / 9

 14660       ]);

 14661       ps[9] = coords.length;

 14662       coords.push([

 14663         (-4 * coords[ps[12]][0] - coords[ps[3]][0] +

 14664           6 * (coords[ps[8]][0] + coords[ps[13]][0]) -

 14665           2 * (coords[ps[0]][0] + coords[ps[15]][0]) +

 14666           3 * (coords[ps[11]][0] + coords[ps[1]][0])) / 9,

 14667         (-4 * coords[ps[12]][1] - coords[ps[3]][1] +

 14668           6 * (coords[ps[8]][1] + coords[ps[13]][1]) -

 14669           2 * (coords[ps[0]][1] + coords[ps[15]][1]) +

 14670           3 * (coords[ps[11]][1] + coords[ps[1]][1])) / 9

 14671       ]);

 14672       ps[10] = coords.length;

 14673       coords.push([

 14674         (-4 * coords[ps[15]][0] - coords[ps[0]][0] +

 14675           6 * (coords[ps[11]][0] + coords[ps[14]][0]) -

 14676           2 * (coords[ps[12]][0] + coords[ps[3]][0]) +

 14677           3 * (coords[ps[2]][0] + coords[ps[8]][0])) / 9,

 14678         (-4 * coords[ps[15]][1] - coords[ps[0]][1] +

 14679           6 * (coords[ps[11]][1] + coords[ps[14]][1]) -

 14680           2 * (coords[ps[12]][1] + coords[ps[3]][1]) +

 14681           3 * (coords[ps[2]][1] + coords[ps[8]][1])) / 9

 14682       ]);

 14683       mesh.figures.push({

 14684         type: 'patch',

 14685         coords: new Int32Array(ps), // making copies of ps and cs

 14686         colors: new Int32Array(cs)

 14687       });

 14688     }

 14689   }

 14691   function decodeType7Shading(mesh, reader) {

 14692     var coords = mesh.coords;

 14693     var colors = mesh.colors;

 14694     var ps = new Int32Array(16); // p00, p10, ..., p30, p01, ..., p33

 14695     var cs = new Int32Array(4); // c00, c30, c03, c33

 14696     while (reader.hasData) {

 14697       var f = reader.readFlag();

 14698       assert(0 <= f && f <= 3, 'Unknown type7 flag');

 14699       var i, ii;

 14700       var pi = coords.length;

 14701       for (i = 0, ii = (f !== 0 ? 12 : 16); i < ii; i++) {

 14702         coords.push(reader.readCoordinate());

 14703       }

 14704       var ci = colors.length;

 14705       for (i = 0, ii = (f !== 0 ? 2 : 4); i < ii; i++) {

 14706         colors.push(reader.readComponents());

 14707       }

 14708       var tmp1, tmp2, tmp3, tmp4;

 14709       switch (f) {

 14710         case 0:

 14711           ps[12] = pi + 3; ps[13] = pi + 4;  ps[14] = pi + 5;  ps[15] = pi + 6;

 14712           ps[ 8] = pi + 2; ps[ 9] = pi + 13; ps[10] = pi + 14; ps[11] = pi + 7;

 14713           ps[ 4] = pi + 1; ps[ 5] = pi + 12; ps[ 6] = pi + 15; ps[ 7] = pi + 8;

 14714           ps[ 0] = pi;     ps[ 1] = pi + 11; ps[ 2] = pi + 10; ps[ 3] = pi + 9;

 14715           cs[2] = ci + 1; cs[3] = ci + 2;

 14716           cs[0] = ci;     cs[1] = ci + 3;

 14717           break;

 14718         case 1:

 14719           tmp1 = ps[12]; tmp2 = ps[13]; tmp3 = ps[14]; tmp4 = ps[15];

 14720           ps[12] = pi + 5; ps[13] = pi + 4;  ps[14] = pi + 3;  ps[15] = pi + 2;

 14721           ps[ 8] = pi + 6; ps[ 9] = pi + 11; ps[10] = pi + 10; ps[11] = pi + 1;

 14722           ps[ 4] = pi + 7; ps[ 5] = pi + 8;  ps[ 6] = pi + 9;  ps[ 7] = pi;

 14723           ps[ 0] = tmp1;   ps[ 1] = tmp2;    ps[ 2] = tmp3;    ps[ 3] = tmp4;

 14724           tmp1 = cs[2]; tmp2 = cs[3];

 14725           cs[2] = ci + 1; cs[3] = ci;

 14726           cs[0] = tmp1;   cs[1] = tmp2;

 14727           break;

 14728         case 2:

 14729           ps[12] = ps[15]; ps[13] = pi + 7; ps[14] = pi + 6;  ps[15] = pi + 5;

 14730           ps[ 8] = ps[11]; ps[ 9] = pi + 8; ps[10] = pi + 11; ps[11] = pi + 4;

 14731           ps[ 4] = ps[7];  ps[ 5] = pi + 9; ps[ 6] = pi + 10; ps[ 7] = pi + 3;

 14732           ps[ 0] = ps[3];  ps[ 1] = pi;     ps[ 2] = pi + 1;  ps[ 3] = pi + 2;

 14733           cs[2] = cs[3]; cs[3] = ci + 1;

 14734           cs[0] = cs[1]; cs[1] = ci;

 14735           break;

 14736         case 3:

 14737           ps[12] = ps[0];  ps[13] = ps[1];   ps[14] = ps[2];   ps[15] = ps[3];

 14738           ps[ 8] = pi;     ps[ 9] = pi + 9;  ps[10] = pi + 8;  ps[11] = pi + 7;

 14739           ps[ 4] = pi + 1; ps[ 5] = pi + 10; ps[ 6] = pi + 11; ps[ 7] = pi + 6;

 14740           ps[ 0] = pi + 2; ps[ 1] = pi + 3;  ps[ 2] = pi + 4;  ps[ 3] = pi + 5;

 14741           cs[2] = cs[0]; cs[3] = cs[1];

 14742           cs[0] = ci;    cs[1] = ci + 1;

 14743           break;

 14744       }

 14745       mesh.figures.push({

 14746         type: 'patch',

 14747         coords: new Int32Array(ps), // making copies of ps and cs

 14748         colors: new Int32Array(cs)

 14749       });

 14750     }

 14751   }

 14753   function updateBounds(mesh) {

 14754     var minX = mesh.coords[0][0], minY = mesh.coords[0][1],

 14755       maxX = minX, maxY = minY;

 14756     for (var i = 1, ii = mesh.coords.length; i < ii; i++) {

 14757       var x = mesh.coords[i][0], y = mesh.coords[i][1];

 14758       minX = minX > x ? x : minX;

 14759       minY = minY > y ? y : minY;

 14760       maxX = maxX < x ? x : maxX;

 14761       maxY = maxY < y ? y : maxY;

 14762     }

 14763     mesh.bounds = [minX, minY, maxX, maxY];

 14764   }

 14766   function packData(mesh) {

 14767     var i, ii, j, jj;

 14769     var coords = mesh.coords;

 14770     var coordsPacked = new Float32Array(coords.length * 2);

 14771     for (i = 0, j = 0, ii = coords.length; i < ii; i++) {

 14772       var xy = coords[i];

 14773       coordsPacked[j++] = xy[0];

 14774       coordsPacked[j++] = xy[1];

 14775     }

 14776     mesh.coords = coordsPacked;

 14778     var colors = mesh.colors;

 14779     var colorsPacked = new Uint8Array(colors.length * 3);

 14780     for (i = 0, j = 0, ii = colors.length; i < ii; i++) {

 14781       var c = colors[i];

 14782       colorsPacked[j++] = c[0];

 14783       colorsPacked[j++] = c[1];

 14784       colorsPacked[j++] = c[2];

 14785     }

 14786     mesh.colors = colorsPacked;

 14788     var figures = mesh.figures;

 14789     for (i = 0, ii = figures.length; i < ii; i++) {

 14790       var figure = figures[i], ps = figure.coords, cs = figure.colors;

 14791       for (j = 0, jj = ps.length; j < jj; j++) {

 14792         ps[j] *= 2;

 14793         cs[j] *= 3;

 14794       }

 14795     }

 14796   }

 14798   function Mesh(stream, matrix, xref, res) {

 14799     assert(isStream(stream), 'Mesh data is not a stream');

 14800     var dict = stream.dict;

 14801     this.matrix = matrix;

 14802     this.shadingType = dict.get('ShadingType');

 14803     this.type = 'Pattern';

 14804     this.bbox = dict.get('BBox');

 14805     var cs = dict.get('ColorSpace', 'CS');

 14806     cs = ColorSpace.parse(cs, xref, res);

 14807     this.cs = cs;

 14808     this.background = dict.has('Background') ?

 14809       cs.getRgb(dict.get('Background'), 0) : null;

 14811     var fnObj = dict.get('Function');

 14812     var fn;

 14813     if (!fnObj) {

 14814       fn = null;

 14815     } else if (isArray(fnObj)) {

 14816       var fnArray = [];

 14817       for (var j = 0, jj = fnObj.length; j < jj; j++) {

 14818         var obj = xref.fetchIfRef(fnObj[j]);

 14819         if (!isPDFFunction(obj)) {

 14820           error('Invalid function');

 14821         }

 14822         fnArray.push(PDFFunction.parse(xref, obj));

 14823       }

 14824       fn = function radialAxialColorFunction(arg) {

 14825         var out = [];

 14826         for (var i = 0, ii = fnArray.length; i < ii; i++) {

 14827           out.push(fnArray[i](arg)[0]);

 14828         }

 14829         return out;

 14830       };

 14831     } else {

 14832       if (!isPDFFunction(fnObj)) {

 14833         error('Invalid function');

 14834       }

 14835       fn = PDFFunction.parse(xref, fnObj);

 14836     }

 14838     this.coords = [];

 14839     this.colors = [];

 14840     this.figures = [];

 14842     var decodeContext = {

 14843       bitsPerCoordinate: dict.get('BitsPerCoordinate'),

 14844       bitsPerComponent: dict.get('BitsPerComponent'),

 14845       bitsPerFlag: dict.get('BitsPerFlag'),

 14846       decode: dict.get('Decode'),

 14847       colorFn: fn,

 14848       colorSpace: cs,

 14849       numComps: fn ? 1 : cs.numComps

 14850     };

 14851     var reader = new MeshStreamReader(stream, decodeContext);

 14853     var patchMesh = false;

 14854     switch (this.shadingType) {

 14855       case PatternType.FREE_FORM_MESH:

 14856         decodeType4Shading(this, reader);

 14857         break;

 14858       case PatternType.LATTICE_FORM_MESH:

 14859         var verticesPerRow = dict.get('VerticesPerRow') | 0;

 14860         assert(verticesPerRow >= 2, 'Invalid VerticesPerRow');

 14861         decodeType5Shading(this, reader, verticesPerRow);

 14862         break;

 14863       case PatternType.COONS_PATCH_MESH:

 14864         decodeType6Shading(this, reader);

 14865         patchMesh = true;

 14866         break;

 14867       case PatternType.TENSOR_PATCH_MESH:

 14868         decodeType7Shading(this, reader);

 14869         patchMesh = true;

 14870         break;

 14871       default:

 14872         error('Unsupported mesh type.');

 14873         break;

 14874     }

 14876     if (patchMesh) {

 14877       // dirty bounds calculation for determining, how dense shall be triangles

 14878       updateBounds(this);

 14879       for (var i = 0, ii = this.figures.length; i < ii; i++) {

 14880         buildFigureFromPatch(this, i);

 14881       }

 14882     }

 14883     // calculate bounds

 14884     updateBounds(this);

 14886     packData(this);

 14887   }

 14889   Mesh.prototype = {

 14890     getIR: function Mesh_getIR() {

 14891       return ['Mesh', this.shadingType, this.coords, this.colors, this.figures,

 14892         this.bounds, this.matrix, this.bbox, this.background];

 14893     }

 14894   };

 14896   return Mesh;

 14897 })();

 14899 Shadings.Dummy = (function DummyClosure() {

 14900   function Dummy() {

 14901     this.type = 'Pattern';

 14902   }

 14904   Dummy.prototype = {

 14905     getIR: function Dummy_getIR() {

 14906       return ['Dummy'];

 14907     }

 14908   };

 14909   return Dummy;

 14910 })();

 14912 function getTilingPatternIR(operatorList, dict, args) {

 14913   var matrix = dict.get('Matrix');

 14914   var bbox = dict.get('BBox');

 14915   var xstep = dict.get('XStep');

 14916   var ystep = dict.get('YStep');

 14917   var paintType = dict.get('PaintType');

 14918   var tilingType = dict.get('TilingType');

 14920   return [

 14921     'TilingPattern', args, operatorList, matrix, bbox, xstep, ystep,

 14922     paintType, tilingType

 14923   ];

 14924 }

 14927 var PartialEvaluator = (function PartialEvaluatorClosure() {

 14928   function PartialEvaluator(pdfManager, xref, handler, pageIndex,

 14929                             uniquePrefix, idCounters, fontCache) {

 14930     this.pdfManager = pdfManager;

 14931     this.xref = xref;

 14932     this.handler = handler;

 14933     this.pageIndex = pageIndex;

 14934     this.uniquePrefix = uniquePrefix;

 14935     this.idCounters = idCounters;

 14936     this.fontCache = fontCache;

 14937   }

 14939   var TILING_PATTERN = 1, SHADING_PATTERN = 2;

 14941   PartialEvaluator.prototype = {

 14942     hasBlendModes: function PartialEvaluator_hasBlendModes(resources) {

 14943       if (!isDict(resources)) {

 14944         return false;

 14945       }

 14947       var processed = Object.create(null);

 14948       if (resources.objId) {

 14949         processed[resources.objId] = true;

 14950       }

 14952       var nodes = [resources];

 14953       while (nodes.length) {

 14954         var key;

 14955         var node = nodes.shift();

 14956         // First check the current resources for blend modes.

 14957         var graphicStates = node.get('ExtGState');

 14958         if (isDict(graphicStates)) {

 14959           graphicStates = graphicStates.getAll();

 14960           for (key in graphicStates) {

 14961             var graphicState = graphicStates[key];

 14962             var bm = graphicState['BM'];

 14963             if (isName(bm) && bm.name !== 'Normal') {

 14964               return true;

 14965             }

 14966           }

 14967         }

 14968         // Descend into the XObjects to look for more resources and blend modes.

 14969         var xObjects = node.get('XObject');

 14970         if (!isDict(xObjects)) {

 14971           continue;

 14972         }

 14973         xObjects = xObjects.getAll();

 14974         for (key in xObjects) {

 14975           var xObject = xObjects[key];

 14976           if (!isStream(xObject)) {

 14977             continue;

 14978           }

 14979           var xResources = xObject.dict.get('Resources');

 14980           // Checking objId to detect an infinite loop.

 14981           if (isDict(xResources) &&

 14982               (!xResources.objId || !processed[xResources.objId])) {

 14983             nodes.push(xResources);

 14984             if (xResources.objId) {

 14985               processed[xResources.objId] = true;

 14986             }

 14987           }

 14988         }

 14989       }

 14990       return false;

 14991     },

 14993     buildFormXObject: function PartialEvaluator_buildFormXObject(resources,

 14994                                                                  xobj, smask,

 14995                                                                  operatorList,

 14996                                                                  initialState) {

 14997       var matrix = xobj.dict.get('Matrix');

 14998       var bbox = xobj.dict.get('BBox');

 14999       var group = xobj.dict.get('Group');

 15000       if (group) {

 15001         var groupOptions = {

 15002           matrix: matrix,

 15003           bbox: bbox,

 15004           smask: smask,

 15005           isolated: false,

 15006           knockout: false

 15007         };

 15009         var groupSubtype = group.get('S');

 15010         if (isName(groupSubtype) && groupSubtype.name === 'Transparency') {

 15011           groupOptions.isolated = (group.get('I') || false);

 15012           groupOptions.knockout = (group.get('K') || false);

 15013           var colorSpace = group.get('CS');

 15014           groupOptions.colorSpace = (colorSpace ?

 15015             ColorSpace.parseToIR(colorSpace, this.xref, resources) : null);

 15016         }

 15017         operatorList.addOp(OPS.beginGroup, [groupOptions]);

 15018       }

 15020       operatorList.addOp(OPS.paintFormXObjectBegin, [matrix, bbox]);

 15022       this.getOperatorList(xobj, (xobj.dict.get('Resources') || resources),

 15023                            operatorList, initialState);

 15024       operatorList.addOp(OPS.paintFormXObjectEnd, []);

 15026       if (group) {

 15027         operatorList.addOp(OPS.endGroup, [groupOptions]);

 15028       }

 15029     },

 15031     buildPaintImageXObject:

 15032         function PartialEvaluator_buildPaintImageXObject(resources, image,

 15033                                                          inline, operatorList,

 15034                                                          cacheKey, cache) {

 15035       var self = this;

 15036       var dict = image.dict;

 15037       var w = dict.get('Width', 'W');

 15038       var h = dict.get('Height', 'H');

 15040       if (!(w && isNum(w)) || !(h && isNum(h))) {

 15041         warn('Image dimensions are missing, or not numbers.');

 15042         return;

 15043       }

 15044       if (PDFJS.maxImageSize !== -1 && w * h > PDFJS.maxImageSize) {

 15045         warn('Image exceeded maximum allowed size and was removed.');

 15046         return;

 15047       }

 15049       var imageMask = (dict.get('ImageMask', 'IM') || false);

 15050       var imgData, args;

 15051       if (imageMask) {

 15052         // This depends on a tmpCanvas being filled with the

 15053         // current fillStyle, such that processing the pixel

 15054         // data can't be done here. Instead of creating a

 15055         // complete PDFImage, only read the information needed

 15056         // for later.

 15058         var width = dict.get('Width', 'W');

 15059         var height = dict.get('Height', 'H');

 15060         var bitStrideLength = (width + 7) >> 3;

 15061         var imgArray = image.getBytes(bitStrideLength * height);

 15062         var decode = dict.get('Decode', 'D');

 15063         var canTransfer = image instanceof DecodeStream;

 15064         var inverseDecode = (!!decode && decode[0] > 0);

 15066         imgData = PDFImage.createMask(imgArray, width, height,

 15067                                       canTransfer, inverseDecode);

 15068         imgData.cached = true;

 15069         args = [imgData];

 15070         operatorList.addOp(OPS.paintImageMaskXObject, args);

 15071         if (cacheKey) {

 15072           cache.key = cacheKey;

 15073           cache.fn = OPS.paintImageMaskXObject;

 15074           cache.args = args;

 15075         }

 15076         return;

 15077       }

 15079       var softMask = (dict.get('SMask', 'SM') || false);

 15080       var mask = (dict.get('Mask') || false);

 15082       var SMALL_IMAGE_DIMENSIONS = 200;

 15083       // Inlining small images into the queue as RGB data

 15084       if (inline && !softMask && !mask && !(image instanceof JpegStream) &&

 15085           (w + h) < SMALL_IMAGE_DIMENSIONS) {

 15086         var imageObj = new PDFImage(this.xref, resources, image,

 15087                                     inline, null, null);

 15088         // We force the use of RGBA_32BPP images here, because we can't handle

 15089         // any other kind.

 15090         imgData = imageObj.createImageData(/* forceRGBA = */ true);

 15091         operatorList.addOp(OPS.paintInlineImageXObject, [imgData]);

 15092         return;

 15093       }

 15095       // If there is no imageMask, create the PDFImage and a lot

 15096       // of image processing can be done here.

 15097       var uniquePrefix = (this.uniquePrefix || '');

 15098       var objId = 'img_' + uniquePrefix + (++this.idCounters.obj);

 15099       operatorList.addDependency(objId);

 15100       args = [objId, w, h];

 15102       if (!softMask && !mask && image instanceof JpegStream &&

 15103           image.isNativelySupported(this.xref, resources)) {

 15104         // These JPEGs don't need any more processing so we can just send it.

 15105         operatorList.addOp(OPS.paintJpegXObject, args);

 15106         this.handler.send('obj',

 15107           [objId, this.pageIndex, 'JpegStream', image.getIR()]);

 15108         return;

 15109       }

 15111       PDFImage.buildImage(self.handler, self.xref, resources, image, inline).

 15112         then(function(imageObj) {

 15113           var imgData = imageObj.createImageData(/* forceRGBA = */ false);

 15114           self.handler.send('obj', [objId, self.pageIndex, 'Image', imgData],

 15115             null, [imgData.data.buffer]);

 15116         }).then(null, function (reason) {

 15117           warn('Unable to decode image: ' + reason);

 15118           self.handler.send('obj', [objId, self.pageIndex, 'Image', null]);

 15119         });

 15121       operatorList.addOp(OPS.paintImageXObject, args);

 15122       if (cacheKey) {

 15123         cache.key = cacheKey;

 15124         cache.fn = OPS.paintImageXObject;

 15125         cache.args = args;

 15126       }

 15127     },

 15129     handleSMask: function PartialEvaluator_handleSmask(smask, resources,

 15130                                                        operatorList,

 15131                                                        stateManager) {

 15132       var smaskContent = smask.get('G');

 15133       var smaskOptions = {

 15134         subtype: smask.get('S').name,

 15135         backdrop: smask.get('BC')

 15136       };

 15137       this.buildFormXObject(resources, smaskContent, smaskOptions,

 15138                             operatorList, stateManager.state.clone());

 15139     },

 15141     handleTilingType:

 15142         function PartialEvaluator_handleTilingType(fn, args, resources,

 15143                                                    pattern, patternDict,

 15144                                                    operatorList) {

 15145       // Create an IR of the pattern code.

 15146       var tilingOpList = this.getOperatorList(pattern,

 15147         (patternDict.get('Resources') || resources));

 15148       // Add the dependencies to the parent operator list so they are resolved

 15149       // before sub operator list is executed synchronously.

 15150       operatorList.addDependencies(tilingOpList.dependencies);

 15151       operatorList.addOp(fn, getTilingPatternIR({

 15152                                fnArray: tilingOpList.fnArray,

 15153                                argsArray: tilingOpList.argsArray

 15154                              }, patternDict, args));

 15155     },

 15157     handleSetFont:

 15158         function PartialEvaluator_handleSetFont(resources, fontArgs, fontRef,

 15159                                                 operatorList, state) {

 15160       // TODO(mack): Not needed?

 15161       var fontName;

 15162       if (fontArgs) {

 15163         fontArgs = fontArgs.slice();

 15164         fontName = fontArgs[0].name;

 15165       }

 15166       var self = this;

 15167       var font = this.loadFont(fontName, fontRef, this.xref, resources,

 15168                                operatorList);

 15169       state.font = font;

 15170       var loadedName = font.loadedName;

 15171       if (!font.sent) {

 15172         var fontData = font.translated.exportData();

 15174         self.handler.send('commonobj', [

 15175           loadedName,

 15176           'Font',

 15177           fontData

 15178         ]);

 15179         font.sent = true;

 15180       }

 15182       return loadedName;

 15183     },

 15185     handleText: function PartialEvaluator_handleText(chars, state) {

 15186       var font = state.font.translated;

 15187       var glyphs = font.charsToGlyphs(chars);

 15188       var isAddToPathSet = !!(state.textRenderingMode &

 15189                               TextRenderingMode.ADD_TO_PATH_FLAG);

 15190       if (font.data && (isAddToPathSet || PDFJS.disableFontFace)) {

 15191         for (var i = 0; i < glyphs.length; i++) {

 15192           if (glyphs[i] === null) {

 15193             continue;

 15194           }

 15195           var fontChar = glyphs[i].fontChar;

 15196           if (!font.renderer.hasBuiltPath(fontChar)) {

 15197             var path = font.renderer.getPathJs(fontChar);

 15198             this.handler.send('commonobj', [

 15199               font.loadedName + '_path_' + fontChar,

 15200               'FontPath',

 15201               path

 15202             ]);

 15203           }

 15204         }

 15205       }

 15207       return glyphs;

 15208     },

 15210     setGState: function PartialEvaluator_setGState(resources, gState,

 15211                                                    operatorList, xref,

 15212                                                    stateManager) {

 15214       var self = this;

 15215       // TODO(mack): This should be rewritten so that this function returns

 15216       // what should be added to the queue during each iteration

 15217       function setGStateForKey(gStateObj, key, value) {

 15218         switch (key) {

 15219           case 'Type':

 15220             break;

 15221           case 'LW':

 15222           case 'LC':

 15223           case 'LJ':

 15224           case 'ML':

 15225           case 'D':

 15226           case 'RI':

 15227           case 'FL':

 15228           case 'CA':

 15229           case 'ca':

 15230             gStateObj.push([key, value]);

 15231             break;

 15232           case 'Font':

 15233             var loadedName = self.handleSetFont(resources, null, value[0],

 15234                                                 operatorList,

 15235                                                 stateManager.state);

 15236             operatorList.addDependency(loadedName);

 15237             gStateObj.push([key, [loadedName, value[1]]]);

 15238             break;

 15239           case 'BM':

 15240             gStateObj.push([key, value]);

 15241             break;

 15242           case 'SMask':

 15243             if (isName(value) && value.name === 'None') {

 15244               gStateObj.push([key, false]);

 15245               break;

 15246             }

 15247             var dict = xref.fetchIfRef(value);

 15248             if (isDict(dict)) {

 15249               self.handleSMask(dict, resources, operatorList, stateManager);

 15250               gStateObj.push([key, true]);

 15251             } else {

 15252               warn('Unsupported SMask type');

 15253             }

 15255             break;

 15256           // Only generate info log messages for the following since

 15257           // they are unlikey to have a big impact on the rendering.

 15258           case 'OP':

 15259           case 'op':

 15260           case 'OPM':

 15261           case 'BG':

 15262           case 'BG2':

 15263           case 'UCR':

 15264           case 'UCR2':

 15265           case 'TR':

 15266           case 'TR2':

 15267           case 'HT':

 15268           case 'SM':

 15269           case 'SA':

 15270           case 'AIS':

 15271           case 'TK':

 15272             // TODO implement these operators.

 15273             info('graphic state operator ' + key);

 15274             break;

 15275           default:

 15276             info('Unknown graphic state operator ' + key);

 15277             break;

 15278         }

 15279       }

 15281       // This array holds the converted/processed state data.

 15282       var gStateObj = [];

 15283       var gStateMap = gState.map;

 15284       for (var key in gStateMap) {

 15285         var value = gStateMap[key];

 15286         setGStateForKey(gStateObj, key, value);

 15287       }

 15289       operatorList.addOp(OPS.setGState, [gStateObj]);

 15290     },

 15292     loadFont: function PartialEvaluator_loadFont(fontName, font, xref,

 15293                                                  resources,

 15294                                                  parentOperatorList) {

 15296       function errorFont() {

 15297         return {

 15298           translated: new ErrorFont('Font ' + fontName + ' is not available'),

 15299           loadedName: 'g_font_error'

 15300         };

 15301       }

 15303       var fontRef;

 15304       if (font) { // Loading by ref.

 15305         assert(isRef(font));

 15306         fontRef = font;

 15307       } else { // Loading by name.

 15308         var fontRes = resources.get('Font');

 15309         if (fontRes) {

 15310           fontRef = fontRes.getRaw(fontName);

 15311         } else {

 15312           warn('fontRes not available');

 15313           return errorFont();

 15314         }

 15315       }

 15316       if (this.fontCache.has(fontRef)) {

 15317         return this.fontCache.get(fontRef);

 15318       }

 15320       font = xref.fetchIfRef(fontRef);

 15321       if (!isDict(font)) {

 15322         return errorFont();

 15323       }

 15325       var preEvaluatedFont = this.preEvaluateFont(font, xref);

 15326       var descriptor = preEvaluatedFont.descriptor;

 15327       var fontID = fontRef.num + '_' + fontRef.gen;

 15328       if (isDict(descriptor)) {

 15329         if (!descriptor.fontAliases) {

 15330           descriptor.fontAliases = Object.create(null);

 15331         }

 15333         var fontAliases = descriptor.fontAliases;

 15334         var hash = preEvaluatedFont.hash;

 15335         if (fontAliases[hash]) {

 15336           var aliasFontRef = fontAliases[hash].aliasRef;

 15337           if (aliasFontRef && this.fontCache.has(aliasFontRef)) {

 15338             this.fontCache.putAlias(fontRef, aliasFontRef);

 15339             var cachedFont = this.fontCache.get(fontRef);

 15340             return cachedFont;

 15341           }

 15342         }

 15344         if (!fontAliases[hash]) {

 15345           fontAliases[hash] = {

 15346             fontID: Font.getFontID()

 15347           };

 15348         }

 15350         fontAliases[hash].aliasRef = fontRef;

 15351         fontID = fontAliases[hash].fontID;

 15352       }

 15354       // Workaround for bad PDF generators that don't reference fonts

 15355       // properly, i.e. by not using an object identifier.

 15356       // Check if the fontRef is a Dict (as opposed to a standard object),

 15357       // in which case we don't cache the font and instead reference it by

 15358       // fontName in font.loadedName below.

 15359       var fontRefIsDict = isDict(fontRef);

 15360       if (!fontRefIsDict) {

 15361         this.fontCache.put(fontRef, font);

 15362       }

 15364       // Keep track of each font we translated so the caller can

 15365       // load them asynchronously before calling display on a page.

 15366       font.loadedName = 'g_font_' + (fontRefIsDict ?

 15367         fontName.replace(/\W/g, '') : fontID);

 15369       if (!font.translated) {

 15370         var translated;

 15371         try {

 15372           translated = this.translateFont(preEvaluatedFont, xref);

 15373         } catch (e) {

 15374           UnsupportedManager.notify(UNSUPPORTED_FEATURES.font);

 15375           translated = new ErrorFont(e instanceof Error ? e.message : e);

 15376         }

 15377         font.translated = translated;

 15378       }

 15380       if (font.translated.loadCharProcs) {

 15381         var charProcs = font.get('CharProcs').getAll();

 15382         var fontResources = (font.get('Resources') || resources);

 15383         var charProcKeys = Object.keys(charProcs);

 15384         var charProcOperatorList = {};

 15385         for (var i = 0, n = charProcKeys.length; i < n; ++i) {

 15386           var key = charProcKeys[i];

 15387           var glyphStream = charProcs[key];

 15388           var operatorList = this.getOperatorList(glyphStream, fontResources);

 15389           charProcOperatorList[key] = operatorList.getIR();

 15390           if (!parentOperatorList) {

 15391             continue;

 15392           }

 15393           // Add the dependencies to the parent operator list so they are

 15394           // resolved before sub operator list is executed synchronously.

 15395           parentOperatorList.addDependencies(charProcOperatorList.dependencies);

 15396         }

 15397         font.translated.charProcOperatorList = charProcOperatorList;

 15398       }

 15399       font.loaded = true;

 15400       return font;

 15401     },

 15403     getOperatorList: function PartialEvaluator_getOperatorList(stream,

 15404                                                                resources,

 15405                                                                operatorList,

 15406                                                                initialState) {

 15408       var self = this;

 15409       var xref = this.xref;

 15410       var imageCache = {};

 15412       operatorList = (operatorList || new OperatorList());

 15414       resources = (resources || Dict.empty);

 15415       var xobjs = (resources.get('XObject') || Dict.empty);

 15416       var patterns = (resources.get('Pattern') || Dict.empty);

 15417       var stateManager = new StateManager(initialState || new EvalState());

 15418       var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);

 15420       var operation, i, ii;

 15421       while ((operation = preprocessor.read())) {

 15422         var args = operation.args;

 15423         var fn = operation.fn;

 15424         var shading;

 15426         switch (fn) {

 15427           case OPS.setStrokeColorN:

 15428           case OPS.setFillColorN:

 15429             if (args[args.length - 1].code) {

 15430               break;

 15431             }

 15432             // compile tiling patterns

 15433             var patternName = args[args.length - 1];

 15434             // SCN/scn applies patterns along with normal colors

 15435             var pattern;

 15436             if (isName(patternName) &&

 15437                 (pattern = patterns.get(patternName.name))) {

 15438               var dict = (isStream(pattern) ? pattern.dict : pattern);

 15439               var typeNum = dict.get('PatternType');

 15441               if (typeNum == TILING_PATTERN) {

 15442                 self.handleTilingType(fn, args, resources, pattern, dict,

 15443                                       operatorList);

 15444                 args = [];

 15445                 continue;

 15446               } else if (typeNum == SHADING_PATTERN) {

 15447                 shading = dict.get('Shading');

 15448                 var matrix = dict.get('Matrix');

 15449                 pattern = Pattern.parseShading(shading, matrix, xref,

 15450                                                resources);

 15451                 args = pattern.getIR();

 15452               } else {

 15453                 error('Unkown PatternType ' + typeNum);

 15454               }

 15455             }

 15456             break;

 15457           case OPS.paintXObject:

 15458             if (args[0].code) {

 15459               break;

 15460             }

 15461             // eagerly compile XForm objects

 15462             var name = args[0].name;

 15463             if (imageCache.key === name) {

 15464               operatorList.addOp(imageCache.fn, imageCache.args);

 15465               args = [];

 15466               continue;

 15467             }

 15469             var xobj = xobjs.get(name);

 15470             if (xobj) {

 15471               assert(isStream(xobj), 'XObject should be a stream');

 15473               var type = xobj.dict.get('Subtype');

 15474               assert(isName(type),

 15475                 'XObject should have a Name subtype');

 15477               if ('Form' == type.name) {

 15478                 stateManager.save();

 15479                 self.buildFormXObject(resources, xobj, null, operatorList,

 15480                                       stateManager.state.clone());

 15481                 args = [];

 15482                 stateManager.restore();

 15483                 continue;

 15484               } else if ('Image' == type.name) {

 15485                 self.buildPaintImageXObject(resources, xobj, false,

 15486                                             operatorList, name, imageCache);

 15487                 args = [];

 15488                 continue;

 15489               } else {

 15490                 error('Unhandled XObject subtype ' + type.name);

 15491               }

 15492             }

 15493             break;

 15494           case OPS.setFont:

 15495             // eagerly collect all fonts

 15496             var loadedName = self.handleSetFont(resources, args, null,

 15497                                                 operatorList,

 15498                                                 stateManager.state);

 15499             operatorList.addDependency(loadedName);

 15500             args[0] = loadedName;

 15501             break;

 15502           case OPS.endInlineImage:

 15503             var cacheKey = args[0].cacheKey;

 15504             if (cacheKey && imageCache.key === cacheKey) {

 15505               operatorList.addOp(imageCache.fn, imageCache.args);

 15506               args = [];

 15507               continue;

 15508             }

 15509             self.buildPaintImageXObject(resources, args[0], true,

 15510                                         operatorList, cacheKey, imageCache);

 15511             args = [];

 15512             continue;

 15513           case OPS.showText:

 15514             args[0] = this.handleText(args[0], stateManager.state);

 15515             break;

 15516           case OPS.showSpacedText:

 15517             var arr = args[0];

 15518             var arrLength = arr.length;

 15519             for (i = 0; i < arrLength; ++i) {

 15520               if (isString(arr[i])) {

 15521                 arr[i] = this.handleText(arr[i], stateManager.state);

 15522               }

 15523             }

 15524             break;

 15525           case OPS.nextLineShowText:

 15526             args[0] = this.handleText(args[0], stateManager.state);

 15527             break;

 15528           case OPS.nextLineSetSpacingShowText:

 15529             args[2] = this.handleText(args[2], stateManager.state);

 15530             break;

 15531           case OPS.setTextRenderingMode:

 15532             stateManager.state.textRenderingMode = args[0];

 15533             break;

 15534           // Parse the ColorSpace data to a raw format.

 15535           case OPS.setFillColorSpace:

 15536           case OPS.setStrokeColorSpace:

 15537             args = [ColorSpace.parseToIR(args[0], xref, resources)];

 15538             break;

 15539           case OPS.shadingFill:

 15540             var shadingRes = resources.get('Shading');

 15541             if (!shadingRes) {

 15542               error('No shading resource found');

 15543             }

 15545             shading = shadingRes.get(args[0].name);

 15546             if (!shading) {

 15547               error('No shading object found');

 15548             }

 15550             var shadingFill = Pattern.parseShading(shading, null, xref,

 15551                                                    resources);

 15552             var patternIR = shadingFill.getIR();

 15553             args = [patternIR];

 15554             fn = OPS.shadingFill;

 15555             break;

 15556           case OPS.setGState:

 15557             var dictName = args[0];

 15558             var extGState = resources.get('ExtGState');

 15560             if (!isDict(extGState) || !extGState.has(dictName.name)) {

 15561               break;

 15562             }

 15564             var gState = extGState.get(dictName.name);

 15565             self.setGState(resources, gState, operatorList, xref,

 15566                            stateManager);

 15567             args = [];

 15568             continue;

 15569         }

 15570         operatorList.addOp(fn, args);

 15571       }

 15573       // Some PDFs don't close all restores inside object/form.

 15574       // Closing those for them.

 15575       for (i = 0, ii = preprocessor.savedStatesDepth; i < ii; i++) {

 15576         operatorList.addOp(OPS.restore, []);

 15577       }

 15579       return operatorList;

 15580     },

 15582     getTextContent: function PartialEvaluator_getTextContent(stream, resources,

 15583                                                              stateManager) {

 15585       stateManager = (stateManager || new StateManager(new TextState()));

 15587       var textContent = {

 15588         items: [],

 15589         styles: Object.create(null)

 15590       };

 15591       var bidiTexts = textContent.items;

 15592       var SPACE_FACTOR = 0.35;

 15593       var MULTI_SPACE_FACTOR = 1.5;

 15595       var self = this;

 15596       var xref = this.xref;

 15598       resources = (xref.fetchIfRef(resources) || Dict.empty);

 15600       // The xobj is parsed iff it's needed, e.g. if there is a `DO` cmd.

 15601       var xobjs = null;

 15602       var xobjsCache = {};

 15604       var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);

 15606       var operation;

 15607       var textState;

 15609       function newTextChunk() {

 15610         var font = textState.font;

 15611         if (!(font.loadedName in textContent.styles)) {

 15612           textContent.styles[font.loadedName] = {

 15613             fontFamily: font.fallbackName,

 15614             ascent: font.ascent,

 15615             descent: font.descent,

 15616             vertical: font.vertical

 15617           };

 15618         }

 15619         return {

 15620           str: '',

 15621           dir: null,

 15622           width: 0,

 15623           height: 0,

 15624           transform: null,

 15625           fontName: font.loadedName

 15626         };

 15627       }

 15629       function runBidi(textChunk) {

 15630         var bidiResult = PDFJS.bidi(textChunk.str, -1, textState.font.vertical);

 15631         textChunk.str = bidiResult.str;

 15632         textChunk.dir = bidiResult.dir;

 15633         return textChunk;

 15634       }

 15636       function handleSetFont(fontName, fontRef) {

 15637         var font = textState.font = self.loadFont(fontName, fontRef, xref,

 15638                                                   resources, null).translated;

 15639         textState.fontMatrix = font.fontMatrix ? font.fontMatrix :

 15640                                  FONT_IDENTITY_MATRIX;

 15641       }

 15643       function buildTextGeometry(chars, textChunk) {

 15644         var font = textState.font;

 15645         textChunk = textChunk || newTextChunk();

 15646         if (!textChunk.transform) {

 15647           // 9.4.4 Text Space Details

 15648           var tsm = [textState.fontSize * textState.textHScale, 0,

 15649                      0, textState.fontSize,

 15650                      0, textState.textRise];

 15651           var trm = textChunk.transform = Util.transform(textState.ctm,

 15652                                     Util.transform(textState.textMatrix, tsm));

 15653           if (!font.vertical) {

 15654             textChunk.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]);

 15655           } else {

 15656             textChunk.width = Math.sqrt(trm[0] * trm[0] + trm[1] * trm[1]);

 15657           }

 15658         }

 15659         var width = 0;

 15660         var height = 0;

 15661         var glyphs = font.charsToGlyphs(chars);

 15662         var defaultVMetrics = font.defaultVMetrics;

 15663         for (var i = 0; i < glyphs.length; i++) {

 15664           var glyph = glyphs[i];

 15665           if (!glyph) { // Previous glyph was a space.

 15666             width += textState.wordSpacing * textState.textHScale;

 15667             continue;

 15668           }

 15669           var vMetricX = null;

 15670           var vMetricY = null;

 15671           var glyphWidth = null;

 15672           if (font.vertical) {

 15673             if (glyph.vmetric) {

 15674               glyphWidth = glyph.vmetric[0];

 15675               vMetricX = glyph.vmetric[1];

 15676               vMetricY = glyph.vmetric[2];

 15677             } else {

 15678               glyphWidth = glyph.width;

 15679               vMetricX = glyph.width * 0.5;

 15680               vMetricY = defaultVMetrics[2];

 15681             }

 15682           } else {

 15683             glyphWidth = glyph.width;

 15684           }

 15686           var glyphUnicode = glyph.unicode;

 15687           if (glyphUnicode in NormalizedUnicodes) {

 15688             glyphUnicode = NormalizedUnicodes[glyphUnicode];

 15689           }

 15690           glyphUnicode = reverseIfRtl(glyphUnicode);

 15692           // The following will calculate the x and y of the individual glyphs.

 15693           // if (font.vertical) {

 15694           //   tsm[4] -= vMetricX * Math.abs(textState.fontSize) *

 15695           //             textState.fontMatrix[0];

 15696           //   tsm[5] -= vMetricY * textState.fontSize *

 15697           //             textState.fontMatrix[0];

 15698           // }

 15699           // var trm = Util.transform(textState.textMatrix, tsm);

 15700           // var pt = Util.applyTransform([trm[4], trm[5]], textState.ctm);

 15701           // var x = pt[0];

 15702           // var y = pt[1];

 15704           var tx = 0;

 15705           var ty = 0;

 15706           if (!font.vertical) {

 15707             var w0 = glyphWidth * textState.fontMatrix[0];

 15708             tx = (w0 * textState.fontSize + textState.charSpacing) *

 15709                  textState.textHScale;

 15710             width += tx;

 15711           } else {

 15712             var w1 = glyphWidth * textState.fontMatrix[0];

 15713             ty = w1 * textState.fontSize + textState.charSpacing;

 15714             height += ty;

 15715           }

 15716           textState.translateTextMatrix(tx, ty);

 15718           textChunk.str += glyphUnicode;

 15719         }

 15721         var a = textState.textLineMatrix[0];

 15722         var b = textState.textLineMatrix[1];

 15723         var scaleLineX = Math.sqrt(a * a + b * b);

 15724         a = textState.ctm[0];

 15725         b = textState.ctm[1];

 15726         var scaleCtmX = Math.sqrt(a * a + b * b);

 15727         if (!font.vertical) {

 15728           textChunk.width += width * scaleCtmX * scaleLineX;

 15729         } else {

 15730           textChunk.height += Math.abs(height * scaleCtmX * scaleLineX);

 15731         }

 15732         return textChunk;

 15733       }

 15735       while ((operation = preprocessor.read())) {

 15736         textState = stateManager.state;

 15737         var fn = operation.fn;

 15738         var args = operation.args;

 15739         switch (fn) {

 15740           case OPS.setFont:

 15741             handleSetFont(args[0].name);

 15742             textState.fontSize = args[1];

 15743             break;

 15744           case OPS.setTextRise:

 15745             textState.textRise = args[0];

 15746             break;

 15747           case OPS.setHScale:

 15748             textState.textHScale = args[0] / 100;

 15749             break;

 15750           case OPS.setLeading:

 15751             textState.leading = args[0];

 15752             break;

 15753           case OPS.moveText:

 15754             textState.translateTextLineMatrix(args[0], args[1]);

 15755             textState.textMatrix = textState.textLineMatrix.slice();

 15756             break;

 15757           case OPS.setLeadingMoveText:

 15758             textState.leading = -args[1];

 15759             textState.translateTextLineMatrix(args[0], args[1]);

 15760             textState.textMatrix = textState.textLineMatrix.slice();

 15761             break;

 15762           case OPS.nextLine:

 15763             textState.carriageReturn();

 15764             break;

 15765           case OPS.setTextMatrix:

 15766             textState.setTextMatrix(args[0], args[1], args[2], args[3],

 15767                                     args[4], args[5]);

 15768             textState.setTextLineMatrix(args[0], args[1], args[2], args[3],

 15769                                         args[4], args[5]);

 15770             break;

 15771           case OPS.setCharSpacing:

 15772             textState.charSpacing = args[0];

 15773             break;

 15774           case OPS.setWordSpacing:

 15775             textState.wordSpacing = args[0];

 15776             break;

 15777           case OPS.beginText:

 15778             textState.textMatrix = IDENTITY_MATRIX.slice();

 15779             textState.textLineMatrix = IDENTITY_MATRIX.slice();

 15780             break;

 15781           case OPS.showSpacedText:

 15782             var items = args[0];

 15783             var textChunk = newTextChunk();

 15784             var offset;

 15785             for (var j = 0, jj = items.length; j < jj; j++) {

 15786               if (typeof items[j] === 'string') {

 15787                 buildTextGeometry(items[j], textChunk);

 15788               } else {

 15789                 var val = items[j] / 1000;

 15790                 if (!textState.font.vertical) {

 15791                   offset = -val * textState.fontSize * textState.textHScale *

 15792                            textState.textMatrix[0];

 15793                   textState.translateTextMatrix(offset, 0);

 15794                   textChunk.width += offset;

 15795                 } else {

 15796                   offset = -val * textState.fontSize * textState.textMatrix[3];

 15797                   textState.translateTextMatrix(0, offset);

 15798                   textChunk.height += offset;

 15799                 }

 15800                 if (items[j] < 0 && textState.font.spaceWidth > 0) {

 15801                   var fakeSpaces = -items[j] / textState.font.spaceWidth;

 15802                   if (fakeSpaces > MULTI_SPACE_FACTOR) {

 15803                     fakeSpaces = Math.round(fakeSpaces);

 15804                     while (fakeSpaces--) {

 15805                       textChunk.str += ' ';

 15806                     }

 15807                   } else if (fakeSpaces > SPACE_FACTOR) {

 15808                     textChunk.str += ' ';

 15809                   }

 15810                 }

 15811               }

 15812             }

 15813             bidiTexts.push(runBidi(textChunk));

 15814             break;

 15815           case OPS.showText:

 15816             bidiTexts.push(runBidi(buildTextGeometry(args[0])));

 15817             break;

 15818           case OPS.nextLineShowText:

 15819             textState.carriageReturn();

 15820             bidiTexts.push(runBidi(buildTextGeometry(args[0])));

 15821             break;

 15822           case OPS.nextLineSetSpacingShowText:

 15823             textState.wordSpacing = args[0];

 15824             textState.charSpacing = args[1];

 15825             textState.carriageReturn();

 15826             bidiTexts.push(runBidi(buildTextGeometry(args[2])));

 15827             break;

 15828           case OPS.paintXObject:

 15829             if (args[0].code) {

 15830               break;

 15831             }

 15833             if (!xobjs) {

 15834               xobjs = (resources.get('XObject') || Dict.empty);

 15835             }

 15837             var name = args[0].name;

 15838             if (xobjsCache.key === name) {

 15839               if (xobjsCache.texts) {

 15840                 Util.concatenateToArray(bidiTexts, xobjsCache.texts.items);

 15841                 Util.extendObj(textContent.styles, xobjsCache.texts.styles);

 15842               }

 15843               break;

 15844             }

 15846             var xobj = xobjs.get(name);

 15847             if (!xobj) {

 15848               break;

 15849             }

 15850             assert(isStream(xobj), 'XObject should be a stream');

 15852             var type = xobj.dict.get('Subtype');

 15853             assert(isName(type),

 15854               'XObject should have a Name subtype');

 15856             if ('Form' !== type.name) {

 15857               xobjsCache.key = name;

 15858               xobjsCache.texts = null;

 15859               break;

 15860             }

 15862             stateManager.save();

 15863             var matrix = xobj.dict.get('Matrix');

 15864             if (isArray(matrix) && matrix.length === 6) {

 15865               stateManager.transform(matrix);

 15866             }

 15868             var formTextContent = this.getTextContent(

 15869               xobj,

 15870               xobj.dict.get('Resources') || resources,

 15871               stateManager

 15872             );

 15873             Util.concatenateToArray(bidiTexts, formTextContent.items);

 15874             Util.extendObj(textContent.styles, formTextContent.styles);

 15875             stateManager.restore();

 15877             xobjsCache.key = name;

 15878             xobjsCache.texts = formTextContent;

 15879             break;

 15880           case OPS.setGState:

 15881             var dictName = args[0];

 15882             var extGState = resources.get('ExtGState');

 15884             if (!isDict(extGState) || !extGState.has(dictName.name)) {

 15885               break;

 15886             }

 15888             var gsState = extGState.get(dictName.name);

 15890             for (var i = 0; i < gsState.length; i++) {

 15891               if (gsState[i] === 'Font') {

 15892                 handleSetFont(args[0].name);

 15893               }

 15894             }

 15895             break;

 15896         } // switch

 15897       } // while

 15899       return textContent;

 15900     },

 15902     extractDataStructures: function

 15903       partialEvaluatorExtractDataStructures(dict, baseDict,

 15904                                             xref, properties) {

 15905       // 9.10.2

 15906       var toUnicode = (dict.get('ToUnicode') || baseDict.get('ToUnicode'));

 15907       if (toUnicode) {

 15908         properties.toUnicode = this.readToUnicode(toUnicode, xref, properties);

 15909       }

 15910       if (properties.composite) {

 15911         // CIDSystemInfo helps to match CID to glyphs

 15912         var cidSystemInfo = dict.get('CIDSystemInfo');

 15913         if (isDict(cidSystemInfo)) {

 15914           properties.cidSystemInfo = {

 15915             registry: cidSystemInfo.get('Registry'),

 15916             ordering: cidSystemInfo.get('Ordering'),

 15917             supplement: cidSystemInfo.get('Supplement')

 15918           };

 15919         }

 15921         var cidToGidMap = dict.get('CIDToGIDMap');

 15922         if (isStream(cidToGidMap)) {

 15923           properties.cidToGidMap = this.readCidToGidMap(cidToGidMap);

 15924         }

 15925       }

 15927       // Based on 9.6.6 of the spec the encoding can come from multiple places

 15928       // and depends on the font type. The base encoding and differences are

 15929       // read here, but the encoding that is actually used is chosen during

 15930       // glyph mapping in the font.

 15931       // TODO: Loading the built in encoding in the font would allow the

 15932       // differences to be merged in here not require us to hold on to it.

 15933       var differences = [];

 15934       var baseEncodingName = null;

 15935       var encoding;

 15936       if (dict.has('Encoding')) {

 15937         encoding = dict.get('Encoding');

 15938         if (isDict(encoding)) {

 15939           baseEncodingName = encoding.get('BaseEncoding');

 15940           baseEncodingName = (isName(baseEncodingName) ?

 15941                               baseEncodingName.name : null);

 15942           // Load the differences between the base and original

 15943           if (encoding.has('Differences')) {

 15944             var diffEncoding = encoding.get('Differences');

 15945             var index = 0;

 15946             for (var j = 0, jj = diffEncoding.length; j < jj; j++) {

 15947               var data = diffEncoding[j];

 15948               if (isNum(data)) {

 15949                 index = data;

 15950               } else {

 15951                 differences[index++] = data.name;

 15952               }

 15953             }

 15954           }

 15955         } else if (isName(encoding)) {

 15956           baseEncodingName = encoding.name;

 15957         } else {

 15958           error('Encoding is not a Name nor a Dict');

 15959         }

 15960         // According to table 114 if the encoding is a named encoding it must be

 15961         // one of these predefined encodings.

 15962         if ((baseEncodingName !== 'MacRomanEncoding' &&

 15963              baseEncodingName !== 'MacExpertEncoding' &&

 15964              baseEncodingName !== 'WinAnsiEncoding')) {

 15965           baseEncodingName = null;

 15966         }

 15967       }

 15969       if (baseEncodingName) {

 15970         properties.defaultEncoding = Encodings[baseEncodingName].slice();

 15971       } else {

 15972         encoding = (properties.type === 'TrueType' ?

 15973                     Encodings.WinAnsiEncoding : Encodings.StandardEncoding);

 15974         // The Symbolic attribute can be misused for regular fonts

 15975         // Heuristic: we have to check if the font is a standard one also

 15976         if (!!(properties.flags & FontFlags.Symbolic)) {

 15977           encoding = (!properties.file && /Symbol/i.test(properties.name) ?

 15978                       Encodings.SymbolSetEncoding :

 15979                       Encodings.MacRomanEncoding);

 15980         }

 15981         properties.defaultEncoding = encoding;

 15982       }

 15984       properties.differences = differences;

 15985       properties.baseEncodingName = baseEncodingName;

 15986       properties.dict = dict;

 15987     },

 15989     readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) {

 15990       var cmapObj = toUnicode;

 15991       if (isName(cmapObj)) {

 15992         return CMapFactory.create(cmapObj).map;

 15993       } else if (isStream(cmapObj)) {

 15994         var cmap = CMapFactory.create(cmapObj).map;

 15995         // Convert UTF-16BE

 15996         // NOTE: cmap can be a sparse array, so use forEach instead of for(;;)

 15997         // to iterate over all keys.

 15998         cmap.forEach(function(token, i) {

 15999           var str = [];

 16000           for (var k = 0; k < token.length; k += 2) {

 16001             var w1 = (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1);

 16002             if ((w1 & 0xF800) !== 0xD800) { // w1 < 0xD800 || w1 > 0xDFFF

 16003               str.push(w1);

 16004               continue;

 16005             }

 16006             k += 2;

 16007             var w2 = (token.charCodeAt(k) << 8) | token.charCodeAt(k + 1);

 16008             str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000);

 16009           }

 16010           cmap[i] = String.fromCharCode.apply(String, str);

 16011         });

 16012         return cmap;

 16013       }

 16014       return null;

 16015     },

 16017     readCidToGidMap: function PartialEvaluator_readCidToGidMap(cidToGidStream) {

 16018       // Extract the encoding from the CIDToGIDMap

 16019       var glyphsData = cidToGidStream.getBytes();

 16021       // Set encoding 0 to later verify the font has an encoding

 16022       var result = [];

 16023       for (var j = 0, jj = glyphsData.length; j < jj; j++) {

 16024         var glyphID = (glyphsData[j++] << 8) | glyphsData[j];

 16025         if (glyphID === 0) {

 16026           continue;

 16027         }

 16028         var code = j >> 1;

 16029         result[code] = glyphID;

 16030       }

 16031       return result;

 16032     },

 16034     extractWidths: function PartialEvaluator_extractWidths(dict, xref,

 16035                                                            descriptor,

 16036                                                            properties) {

 16037       var glyphsWidths = [];

 16038       var defaultWidth = 0;

 16039       var glyphsVMetrics = [];

 16040       var defaultVMetrics;

 16041       var i, ii, j, jj, start, code, widths;

 16042       if (properties.composite) {

 16043         defaultWidth = dict.get('DW') || 1000;

 16045         widths = dict.get('W');

 16046         if (widths) {

 16047           for (i = 0, ii = widths.length; i < ii; i++) {

 16048             start = widths[i++];

 16049             code = xref.fetchIfRef(widths[i]);

 16050             if (isArray(code)) {

 16051               for (j = 0, jj = code.length; j < jj; j++) {

 16052                 glyphsWidths[start++] = code[j];

 16053               }

 16054             } else {

 16055               var width = widths[++i];

 16056               for (j = start; j <= code; j++) {

 16057                 glyphsWidths[j] = width;

 16058               }

 16059             }

 16060           }

 16061         }

 16063         if (properties.vertical) {

 16064           var vmetrics = (dict.get('DW2') || [880, -1000]);

 16065           defaultVMetrics = [vmetrics[1], defaultWidth * 0.5, vmetrics[0]];

 16066           vmetrics = dict.get('W2');

 16067           if (vmetrics) {

 16068             for (i = 0, ii = vmetrics.length; i < ii; i++) {

 16069               start = vmetrics[i++];

 16070               code = xref.fetchIfRef(vmetrics[i]);

 16071               if (isArray(code)) {

 16072                 for (j = 0, jj = code.length; j < jj; j++) {

 16073                   glyphsVMetrics[start++] = [code[j++], code[j++], code[j]];

 16074                 }

 16075               } else {

 16076                 var vmetric = [vmetrics[++i], vmetrics[++i], vmetrics[++i]];

 16077                 for (j = start; j <= code; j++) {

 16078                   glyphsVMetrics[j] = vmetric;

 16079                 }

 16080               }

 16081             }

 16082           }

 16083         }

 16084       } else {

 16085         var firstChar = properties.firstChar;

 16086         widths = dict.get('Widths');

 16087         if (widths) {

 16088           j = firstChar;

 16089           for (i = 0, ii = widths.length; i < ii; i++) {

 16090             glyphsWidths[j++] = widths[i];

 16091           }

 16092           defaultWidth = (parseFloat(descriptor.get('MissingWidth')) || 0);

 16093         } else {

 16094           // Trying get the BaseFont metrics (see comment above).

 16095           var baseFontName = dict.get('BaseFont');

 16096           if (isName(baseFontName)) {

 16097             var metrics = this.getBaseFontMetrics(baseFontName.name);

 16099             glyphsWidths = this.buildCharCodeToWidth(metrics.widths,

 16100                                                      properties);

 16101             defaultWidth = metrics.defaultWidth;

 16102           }

 16103         }

 16104       }

 16106       // Heuristic: detection of monospace font by checking all non-zero widths

 16107       var isMonospace = true;

 16108       var firstWidth = defaultWidth;

 16109       for (var glyph in glyphsWidths) {

 16110         var glyphWidth = glyphsWidths[glyph];

 16111         if (!glyphWidth) {

 16112           continue;

 16113         }

 16114         if (!firstWidth) {

 16115           firstWidth = glyphWidth;

 16116           continue;

 16117         }

 16118         if (firstWidth != glyphWidth) {

 16119           isMonospace = false;

 16120           break;

 16121         }

 16122       }

 16123       if (isMonospace) {

 16124         properties.flags |= FontFlags.FixedPitch;

 16125       }

 16127       properties.defaultWidth = defaultWidth;

 16128       properties.widths = glyphsWidths;

 16129       properties.defaultVMetrics = defaultVMetrics;

 16130       properties.vmetrics = glyphsVMetrics;

 16131     },

 16133     isSerifFont: function PartialEvaluator_isSerifFont(baseFontName) {

 16134       // Simulating descriptor flags attribute

 16135       var fontNameWoStyle = baseFontName.split('-')[0];

 16136       return (fontNameWoStyle in serifFonts) ||

 16137               (fontNameWoStyle.search(/serif/gi) !== -1);

 16138     },

 16140     getBaseFontMetrics: function PartialEvaluator_getBaseFontMetrics(name) {

 16141       var defaultWidth = 0;

 16142       var widths = [];

 16143       var monospace = false;

 16144       var lookupName = (stdFontMap[name] || name);

 16146       if (!(lookupName in Metrics)) {

 16147         // Use default fonts for looking up font metrics if the passed

 16148         // font is not a base font

 16149         if (this.isSerifFont(name)) {

 16150           lookupName = 'Times-Roman';

 16151         } else {

 16152           lookupName = 'Helvetica';

 16153         }

 16154       }

 16155       var glyphWidths = Metrics[lookupName];

 16157       if (isNum(glyphWidths)) {

 16158         defaultWidth = glyphWidths;

 16159         monospace = true;

 16160       } else {

 16161         widths = glyphWidths;

 16162       }

 16164       return {

 16165         defaultWidth: defaultWidth,

 16166         monospace: monospace,

 16167         widths: widths

 16168       };

 16169     },

 16171     buildCharCodeToWidth:

 16172         function PartialEvaluator_bulildCharCodeToWidth(widthsByGlyphName,

 16173                                                         properties) {

 16174       var widths = Object.create(null);

 16175       var differences = properties.differences;

 16176       var encoding = properties.defaultEncoding;

 16177       for (var charCode = 0; charCode < 256; charCode++) {

 16178         if (charCode in differences &&

 16179             widthsByGlyphName[differences[charCode]]) {

 16180           widths[charCode] = widthsByGlyphName[differences[charCode]];

 16181           continue;

 16182         }

 16183         if (charCode in encoding && widthsByGlyphName[encoding[charCode]]) {

 16184           widths[charCode] = widthsByGlyphName[encoding[charCode]];

 16185           continue;

 16186         }

 16187       }

 16188       return widths;

 16189     },

 16191     preEvaluateFont: function PartialEvaluator_preEvaluateFont(dict, xref) {

 16192       var baseDict = dict;

 16193       var type = dict.get('Subtype');

 16194       assert(isName(type), 'invalid font Subtype');

 16196       var composite = false;

 16197       var uint8array;

 16198       if (type.name == 'Type0') {

 16199         // If font is a composite

 16200         //  - get the descendant font

 16201         //  - set the type according to the descendant font

 16202         //  - get the FontDescriptor from the descendant font

 16203         var df = dict.get('DescendantFonts');

 16204         if (!df) {

 16205           error('Descendant fonts are not specified');

 16206         }

 16207         dict = (isArray(df) ? xref.fetchIfRef(df[0]) : df);

 16209         type = dict.get('Subtype');

 16210         assert(isName(type), 'invalid font Subtype');

 16211         composite = true;

 16212       }

 16214       var descriptor = dict.get('FontDescriptor');

 16215       if (descriptor) {

 16216         var hash = new MurmurHash3_64();

 16217         var encoding = baseDict.getRaw('Encoding');

 16218         if (isName(encoding)) {

 16219           hash.update(encoding.name);

 16220         } else if (isRef(encoding)) {

 16221           hash.update(encoding.num + '_' + encoding.gen);

 16222         }

 16224         var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');

 16225         if (isStream(toUnicode)) {

 16226           var stream = toUnicode.str || toUnicode;

 16227           uint8array = stream.buffer ?

 16228             new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) :

 16229             new Uint8Array(stream.bytes.buffer,

 16230                            stream.start, stream.end - stream.start);

 16231           hash.update(uint8array);

 16233         } else if (isName(toUnicode)) {

 16234           hash.update(toUnicode.name);

 16235         }

 16237         var widths = dict.get('Widths') || baseDict.get('Widths');

 16238         if (widths) {

 16239           uint8array = new Uint8Array(new Uint32Array(widths).buffer);

 16240           hash.update(uint8array);

 16241         }

 16242       }

 16244       return {

 16245         descriptor: descriptor,

 16246         dict: dict,

 16247         baseDict: baseDict,

 16248         composite: composite,

 16249         hash: hash ? hash.hexdigest() : ''

 16250       };

 16251     },

 16253     translateFont: function PartialEvaluator_translateFont(preEvaluatedFont,

 16254                                                            xref) {

 16255       var baseDict = preEvaluatedFont.baseDict;

 16256       var dict = preEvaluatedFont.dict;

 16257       var composite = preEvaluatedFont.composite;

 16258       var descriptor = preEvaluatedFont.descriptor;

 16259       var type = dict.get('Subtype');

 16260       var maxCharIndex = (composite ? 0xFFFF : 0xFF);

 16261       var properties;

 16263       if (!descriptor) {

 16264         if (type.name == 'Type3') {

 16265           // FontDescriptor is only required for Type3 fonts when the document

 16266           // is a tagged pdf. Create a barbebones one to get by.

 16267           descriptor = new Dict(null);

 16268           descriptor.set('FontName', Name.get(type.name));

 16269         } else {

 16270           // Before PDF 1.5 if the font was one of the base 14 fonts, having a

 16271           // FontDescriptor was not required.

 16272           // This case is here for compatibility.

 16273           var baseFontName = dict.get('BaseFont');

 16274           if (!isName(baseFontName)) {

 16275             error('Base font is not specified');

 16276           }

 16278           // Using base font name as a font name.

 16279           baseFontName = baseFontName.name.replace(/[,_]/g, '-');

 16280           var metrics = this.getBaseFontMetrics(baseFontName);

 16282           // Simulating descriptor flags attribute

 16283           var fontNameWoStyle = baseFontName.split('-')[0];

 16284           var flags =

 16285             (this.isSerifFont(fontNameWoStyle) ? FontFlags.Serif : 0) |

 16286             (metrics.monospace ? FontFlags.FixedPitch : 0) |

 16287             (symbolsFonts[fontNameWoStyle] ? FontFlags.Symbolic :

 16288                                              FontFlags.Nonsymbolic);

 16290           properties = {

 16291             type: type.name,

 16292             name: baseFontName,

 16293             widths: metrics.widths,

 16294             defaultWidth: metrics.defaultWidth,

 16295             flags: flags,

 16296             firstChar: 0,

 16297             lastChar: maxCharIndex

 16298           };

 16299           this.extractDataStructures(dict, dict, xref, properties);

 16300           properties.widths = this.buildCharCodeToWidth(metrics.widths,

 16301                                                         properties);

 16302           return new Font(baseFontName, null, properties);

 16303         }

 16304       }

 16306       // According to the spec if 'FontDescriptor' is declared, 'FirstChar',

 16307       // 'LastChar' and 'Widths' should exist too, but some PDF encoders seem

 16308       // to ignore this rule when a variant of a standart font is used.

 16309       // TODO Fill the width array depending on which of the base font this is

 16310       // a variant.

 16311       var firstChar = (dict.get('FirstChar') || 0);

 16312       var lastChar = (dict.get('LastChar') || maxCharIndex);

 16314       var fontName = descriptor.get('FontName');

 16315       var baseFont = dict.get('BaseFont');

 16316       // Some bad PDFs have a string as the font name.

 16317       if (isString(fontName)) {

 16318         fontName = Name.get(fontName);

 16319       }

 16320       if (isString(baseFont)) {

 16321         baseFont = Name.get(baseFont);

 16322       }

 16324       if (type.name !== 'Type3') {

 16325         var fontNameStr = fontName && fontName.name;

 16326         var baseFontStr = baseFont && baseFont.name;

 16327         if (fontNameStr !== baseFontStr) {

 16328           info('The FontDescriptor\'s FontName is "' + fontNameStr +

 16329                '" but should be the same as the Font\'s BaseFont "' +

 16330                baseFontStr + '"');

 16331           // Workaround for cases where e.g. fontNameStr = 'Arial' and

 16332           // baseFontStr = 'Arial,Bold' (needed when no font file is embedded).

 16333           if (fontNameStr && baseFontStr &&

 16334               baseFontStr.search(fontNameStr) === 0) {

 16335             fontName = baseFont;

 16336           }

 16337         }

 16338       }

 16339       fontName = (fontName || baseFont);

 16341       assert(isName(fontName), 'invalid font name');

 16343       var fontFile = descriptor.get('FontFile', 'FontFile2', 'FontFile3');

 16344       if (fontFile) {

 16345         if (fontFile.dict) {

 16346           var subtype = fontFile.dict.get('Subtype');

 16347           if (subtype) {

 16348             subtype = subtype.name;

 16349           }

 16350           var length1 = fontFile.dict.get('Length1');

 16351           var length2 = fontFile.dict.get('Length2');

 16352         }

 16353       }

 16355       properties = {

 16356         type: type.name,

 16357         name: fontName.name,

 16358         subtype: subtype,

 16359         file: fontFile,

 16360         length1: length1,

 16361         length2: length2,

 16362         loadedName: baseDict.loadedName,

 16363         composite: composite,

 16364         wideChars: composite,

 16365         fixedPitch: false,

 16366         fontMatrix: (dict.get('FontMatrix') || FONT_IDENTITY_MATRIX),

 16367         firstChar: firstChar || 0,

 16368         lastChar: (lastChar || maxCharIndex),

 16369         bbox: descriptor.get('FontBBox'),

 16370         ascent: descriptor.get('Ascent'),

 16371         descent: descriptor.get('Descent'),

 16372         xHeight: descriptor.get('XHeight'),

 16373         capHeight: descriptor.get('CapHeight'),

 16374         flags: descriptor.get('Flags'),

 16375         italicAngle: descriptor.get('ItalicAngle'),

 16376         coded: false

 16377       };

 16379       if (composite) {

 16380         var cidEncoding = baseDict.get('Encoding');

 16381         if (isName(cidEncoding)) {

 16382           properties.cidEncoding = cidEncoding.name;

 16383         }

 16384         properties.cMap = CMapFactory.create(cidEncoding,

 16385           { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);

 16386         properties.vertical = properties.cMap.vertical;

 16387       }

 16388       this.extractDataStructures(dict, baseDict, xref, properties);

 16389       this.extractWidths(dict, xref, descriptor, properties);

 16391       if (type.name === 'Type3') {

 16392         properties.coded = true;

 16393       }

 16395       return new Font(fontName.name, fontFile, properties);

 16396     }

 16397   };

 16399   return PartialEvaluator;

 16400 })();

 16402 var OperatorList = (function OperatorListClosure() {

 16403   var CHUNK_SIZE = 1000;

 16404   var CHUNK_SIZE_ABOUT = CHUNK_SIZE - 5; // close to chunk size

 16406   function getTransfers(queue) {

 16407     var transfers = [];

 16408     var fnArray = queue.fnArray, argsArray = queue.argsArray;

 16409     for (var i = 0, ii = queue.length; i < ii; i++) {

 16410       switch (fnArray[i]) {

 16411         case OPS.paintInlineImageXObject:

 16412         case OPS.paintInlineImageXObjectGroup:

 16413         case OPS.paintImageMaskXObject:

 16414           var arg = argsArray[i][0]; // first param in imgData

 16415           if (!arg.cached) {

 16416             transfers.push(arg.data.buffer);

 16417           }

 16418           break;

 16419       }

 16420     }

 16421     return transfers;

 16422   }

 16424   function OperatorList(intent, messageHandler, pageIndex) {

 16425     this.messageHandler = messageHandler;

 16426     this.fnArray = [];

 16427     this.argsArray = [];

 16428     this.dependencies = {};

 16429     this.pageIndex = pageIndex;

 16430     this.intent = intent;

 16431   }

 16433   OperatorList.prototype = {

 16434     get length() {

 16435       return this.argsArray.length;

 16436     },

 16438     addOp: function(fn, args) {

 16439       this.fnArray.push(fn);

 16440       this.argsArray.push(args);

 16441       if (this.messageHandler) {

 16442         if (this.fnArray.length >= CHUNK_SIZE) {

 16443           this.flush();

 16444         } else if (this.fnArray.length >= CHUNK_SIZE_ABOUT &&

 16445                    (fn === OPS.restore || fn === OPS.endText)) {

 16446           // heuristic to flush on boundary of restore or endText

 16447           this.flush();

 16448         }

 16449       }

 16450     },

 16452     addDependency: function(dependency) {

 16453       if (dependency in this.dependencies) {

 16454         return;

 16455       }

 16456       this.dependencies[dependency] = true;

 16457       this.addOp(OPS.dependency, [dependency]);

 16458     },

 16460     addDependencies: function(dependencies) {

 16461       for (var key in dependencies) {

 16462         this.addDependency(key);

 16463       }

 16464     },

 16466     addOpList: function(opList) {

 16467       Util.extendObj(this.dependencies, opList.dependencies);

 16468       for (var i = 0, ii = opList.length; i < ii; i++) {

 16469         this.addOp(opList.fnArray[i], opList.argsArray[i]);

 16470       }

 16471     },

 16473     getIR: function() {

 16474       return {

 16475         fnArray: this.fnArray,

 16476         argsArray: this.argsArray,

 16477         length: this.length

 16478       };

 16479     },

 16481     flush: function(lastChunk) {

 16482       new QueueOptimizer().optimize(this);

 16483       var transfers = getTransfers(this);

 16484       this.messageHandler.send('RenderPageChunk', {

 16485         operatorList: {

 16486           fnArray: this.fnArray,

 16487           argsArray: this.argsArray,

 16488           lastChunk: lastChunk,

 16489           length: this.length

 16490         },

 16491         pageIndex: this.pageIndex,

 16492         intent: this.intent

 16493       }, null, transfers);

 16494       this.dependencies = {};

 16495       this.fnArray.length = 0;

 16496       this.argsArray.length = 0;

 16497     }

 16498   };

 16500   return OperatorList;

 16501 })();

 16503 var StateManager = (function StateManagerClosure() {

 16504   function StateManager(initialState) {

 16505     this.state = initialState;

 16506     this.stateStack = [];

 16507   }

 16508   StateManager.prototype = {

 16509     save: function () {

 16510       var old = this.state;

 16511       this.stateStack.push(this.state);

 16512       this.state = old.clone();

 16513     },

 16514     restore: function () {

 16515       var prev = this.stateStack.pop();

 16516       if (prev) {

 16517         this.state = prev;

 16518       }

 16519     },

 16520     transform: function (args) {

 16521       this.state.ctm = Util.transform(this.state.ctm, args);

 16522     }

 16523   };

 16524   return StateManager;

 16525 })();

 16527 var TextState = (function TextStateClosure() {

 16528   function TextState() {

 16529     this.ctm = new Float32Array(IDENTITY_MATRIX);

 16530     this.fontSize = 0;

 16531     this.font = null;

 16532     this.fontMatrix = FONT_IDENTITY_MATRIX;

 16533     this.textMatrix = IDENTITY_MATRIX.slice();

 16534     this.textLineMatrix = IDENTITY_MATRIX.slice();

 16535     this.charSpacing = 0;

 16536     this.wordSpacing = 0;

 16537     this.leading = 0;

 16538     this.textHScale = 1;

 16539     this.textRise = 0;

 16540   }

 16542   TextState.prototype = {

 16543     setTextMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {

 16544       var m = this.textMatrix;

 16545       m[0] = a; m[1] = b; m[2] = c; m[3] = d; m[4] = e; m[5] = f;

 16546     },

 16547     setTextLineMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {

 16548       var m = this.textLineMatrix;

 16549       m[0] = a; m[1] = b; m[2] = c; m[3] = d; m[4] = e; m[5] = f;

 16550     },

 16551     translateTextMatrix: function TextState_translateTextMatrix(x, y) {

 16552       var m = this.textMatrix;

 16553       m[4] = m[0] * x + m[2] * y + m[4];

 16554       m[5] = m[1] * x + m[3] * y + m[5];

 16555     },

 16556     translateTextLineMatrix: function TextState_translateTextMatrix(x, y) {

 16557       var m = this.textLineMatrix;

 16558       m[4] = m[0] * x + m[2] * y + m[4];

 16559       m[5] = m[1] * x + m[3] * y + m[5];

 16560     },

 16561     calcRenderMatrix: function TextState_calcRendeMatrix(ctm) {

 16562       // 9.4.4 Text Space Details

 16563       var tsm = [this.fontSize * this.textHScale, 0,

 16564                 0, this.fontSize,

 16565                 0, this.textRise];

 16566       return Util.transform(ctm, Util.transform(this.textMatrix, tsm));

 16567     },

 16568     carriageReturn: function TextState_carriageReturn() {

 16569       this.translateTextLineMatrix(0, -this.leading);

 16570       this.textMatrix = this.textLineMatrix.slice();

 16571     },

 16572     clone: function TextState_clone() {

 16573       var clone = Object.create(this);

 16574       clone.textMatrix = this.textMatrix.slice();

 16575       clone.textLineMatrix = this.textLineMatrix.slice();

 16576       clone.fontMatrix = this.fontMatrix.slice();

 16577       return clone;

 16578     }

 16579   };

 16580   return TextState;

 16581 })();

 16583 var EvalState = (function EvalStateClosure() {

 16584   function EvalState() {

 16585     this.ctm = new Float32Array(IDENTITY_MATRIX);

 16586     this.font = null;

 16587     this.textRenderingMode = TextRenderingMode.FILL;

 16588   }

 16589   EvalState.prototype = {

 16590     clone: function CanvasExtraState_clone() {

 16591       return Object.create(this);

 16592     },

 16593   };

 16594   return EvalState;

 16595 })();

 16597 var EvaluatorPreprocessor = (function EvaluatorPreprocessorClosure() {

 16598   // Specifies properties for each command

 16599   //

 16600   // If variableArgs === true: [0, `numArgs`] expected

 16601   // If variableArgs === false: exactly `numArgs` expected

 16602   var OP_MAP = {

 16603     // Graphic state

 16604     w: { id: OPS.setLineWidth, numArgs: 1, variableArgs: false },

 16605     J: { id: OPS.setLineCap, numArgs: 1, variableArgs: false },

 16606     j: { id: OPS.setLineJoin, numArgs: 1, variableArgs: false },

 16607     M: { id: OPS.setMiterLimit, numArgs: 1, variableArgs: false },

 16608     d: { id: OPS.setDash, numArgs: 2, variableArgs: false },

 16609     ri: { id: OPS.setRenderingIntent, numArgs: 1, variableArgs: false },

 16610     i: { id: OPS.setFlatness, numArgs: 1, variableArgs: false },

 16611     gs: { id: OPS.setGState, numArgs: 1, variableArgs: false },

 16612     q: { id: OPS.save, numArgs: 0, variableArgs: false },

 16613     Q: { id: OPS.restore, numArgs: 0, variableArgs: false },

 16614     cm: { id: OPS.transform, numArgs: 6, variableArgs: false },

 16616     // Path

 16617     m: { id: OPS.moveTo, numArgs: 2, variableArgs: false },

 16618     l: { id: OPS.lineTo, numArgs: 2, variableArgs: false },

 16619     c: { id: OPS.curveTo, numArgs: 6, variableArgs: false },

 16620     v: { id: OPS.curveTo2, numArgs: 4, variableArgs: false },

 16621     y: { id: OPS.curveTo3, numArgs: 4, variableArgs: false },

 16622     h: { id: OPS.closePath, numArgs: 0, variableArgs: false },

 16623     re: { id: OPS.rectangle, numArgs: 4, variableArgs: false },

 16624     S: { id: OPS.stroke, numArgs: 0, variableArgs: false },

 16625     s: { id: OPS.closeStroke, numArgs: 0, variableArgs: false },

 16626     f: { id: OPS.fill, numArgs: 0, variableArgs: false },

 16627     F: { id: OPS.fill, numArgs: 0, variableArgs: false },

 16628     'f*': { id: OPS.eoFill, numArgs: 0, variableArgs: false },

 16629     B: { id: OPS.fillStroke, numArgs: 0, variableArgs: false },

 16630     'B*': { id: OPS.eoFillStroke, numArgs: 0, variableArgs: false },

 16631     b: { id: OPS.closeFillStroke, numArgs: 0, variableArgs: false },

 16632     'b*': { id: OPS.closeEOFillStroke, numArgs: 0, variableArgs: false },

 16633     n: { id: OPS.endPath, numArgs: 0, variableArgs: false },

 16635     // Clipping

 16636     W: { id: OPS.clip, numArgs: 0, variableArgs: false },

 16637     'W*': { id: OPS.eoClip, numArgs: 0, variableArgs: false },

 16639     // Text

 16640     BT: { id: OPS.beginText, numArgs: 0, variableArgs: false },

 16641     ET: { id: OPS.endText, numArgs: 0, variableArgs: false },

 16642     Tc: { id: OPS.setCharSpacing, numArgs: 1, variableArgs: false },

 16643     Tw: { id: OPS.setWordSpacing, numArgs: 1, variableArgs: false },

 16644     Tz: { id: OPS.setHScale, numArgs: 1, variableArgs: false },

 16645     TL: { id: OPS.setLeading, numArgs: 1, variableArgs: false },

 16646     Tf: { id: OPS.setFont, numArgs: 2, variableArgs: false },

 16647     Tr: { id: OPS.setTextRenderingMode, numArgs: 1, variableArgs: false },

 16648     Ts: { id: OPS.setTextRise, numArgs: 1, variableArgs: false },

 16649     Td: { id: OPS.moveText, numArgs: 2, variableArgs: false },

 16650     TD: { id: OPS.setLeadingMoveText, numArgs: 2, variableArgs: false },

 16651     Tm: { id: OPS.setTextMatrix, numArgs: 6, variableArgs: false },

 16652     'T*': { id: OPS.nextLine, numArgs: 0, variableArgs: false },

 16653     Tj: { id: OPS.showText, numArgs: 1, variableArgs: false },

 16654     TJ: { id: OPS.showSpacedText, numArgs: 1, variableArgs: false },

 16655     '\'': { id: OPS.nextLineShowText, numArgs: 1, variableArgs: false },

 16656     '"': { id: OPS.nextLineSetSpacingShowText, numArgs: 3,

 16657            variableArgs: false },

 16659     // Type3 fonts

 16660     d0: { id: OPS.setCharWidth, numArgs: 2, variableArgs: false },

 16661     d1: { id: OPS.setCharWidthAndBounds, numArgs: 6, variableArgs: false },

 16663     // Color

 16664     CS: { id: OPS.setStrokeColorSpace, numArgs: 1, variableArgs: false },

 16665     cs: { id: OPS.setFillColorSpace, numArgs: 1, variableArgs: false },

 16666     SC: { id: OPS.setStrokeColor, numArgs: 4, variableArgs: true },

 16667     SCN: { id: OPS.setStrokeColorN, numArgs: 33, variableArgs: true },

 16668     sc: { id: OPS.setFillColor, numArgs: 4, variableArgs: true },

 16669     scn: { id: OPS.setFillColorN, numArgs: 33, variableArgs: true },

 16670     G: { id: OPS.setStrokeGray, numArgs: 1, variableArgs: false },

 16671     g: { id: OPS.setFillGray, numArgs: 1, variableArgs: false },

 16672     RG: { id: OPS.setStrokeRGBColor, numArgs: 3, variableArgs: false },

 16673     rg: { id: OPS.setFillRGBColor, numArgs: 3, variableArgs: false },

 16674     K: { id: OPS.setStrokeCMYKColor, numArgs: 4, variableArgs: false },

 16675     k: { id: OPS.setFillCMYKColor, numArgs: 4, variableArgs: false },

 16677     // Shading

 16678     sh: { id: OPS.shadingFill, numArgs: 1, variableArgs: false },

 16680     // Images

 16681     BI: { id: OPS.beginInlineImage, numArgs: 0, variableArgs: false },

 16682     ID: { id: OPS.beginImageData, numArgs: 0, variableArgs: false },

 16683     EI: { id: OPS.endInlineImage, numArgs: 1, variableArgs: false },

 16685     // XObjects

 16686     Do: { id: OPS.paintXObject, numArgs: 1, variableArgs: false },

 16687     MP: { id: OPS.markPoint, numArgs: 1, variableArgs: false },

 16688     DP: { id: OPS.markPointProps, numArgs: 2, variableArgs: false },

 16689     BMC: { id: OPS.beginMarkedContent, numArgs: 1, variableArgs: false },

 16690     BDC: { id: OPS.beginMarkedContentProps, numArgs: 2,

 16691            variableArgs: false },

 16692     EMC: { id: OPS.endMarkedContent, numArgs: 0, variableArgs: false },

 16694     // Compatibility

 16695     BX: { id: OPS.beginCompat, numArgs: 0, variableArgs: false },

 16696     EX: { id: OPS.endCompat, numArgs: 0, variableArgs: false },

 16698     // (reserved partial commands for the lexer)

 16699     BM: null,

 16700     BD: null,

 16701     'true': null,

 16702     fa: null,

 16703     fal: null,

 16704     fals: null,

 16705     'false': null,

 16706     nu: null,

 16707     nul: null,

 16708     'null': null

 16709   };

 16711   function EvaluatorPreprocessor(stream, xref, stateManager) {

 16712     // TODO(mduan): pass array of knownCommands rather than OP_MAP

 16713     // dictionary

 16714     this.parser = new Parser(new Lexer(stream, OP_MAP), false, xref);

 16715     this.stateManager = stateManager;

 16716   }

 16718   EvaluatorPreprocessor.prototype = {

 16719     get savedStatesDepth() {

 16720       return this.stateManager.stateStack.length;

 16721     },

 16723     read: function EvaluatorPreprocessor_read() {

 16724       var args = [];

 16725       while (true) {

 16726         var obj = this.parser.getObj();

 16727         if (isEOF(obj)) {

 16728           return null; // no more commands

 16729         }

 16730         if (!isCmd(obj)) {

 16731           // argument

 16732           if (obj !== null && obj !== undefined) {

 16733             args.push((obj instanceof Dict ? obj.getAll() : obj));

 16734             assert(args.length <= 33, 'Too many arguments');

 16735           }

 16736           continue;

 16737         }

 16739         var cmd = obj.cmd;

 16740         // Check that the command is valid

 16741         var opSpec = OP_MAP[cmd];

 16742         if (!opSpec) {

 16743           warn('Unknown command "' + cmd + '"');

 16744           continue;

 16745         }

 16747         var fn = opSpec.id;

 16749         // Validate the number of arguments for the command

 16750         if (opSpec.variableArgs) {

 16751           if (args.length > opSpec.numArgs) {

 16752             info('Command ' + fn + ': expected [0,' + opSpec.numArgs +

 16753                  '] args, but received ' + args.length + ' args');

 16754           }

 16755         } else {

 16756           if (args.length < opSpec.numArgs) {

 16757             // If we receive too few args, it's not possible to possible

 16758             // to execute the command, so skip the command

 16759             info('Command ' + fn + ': because expected ' +

 16760                  opSpec.numArgs + ' args, but received ' + args.length +

 16761                  ' args; skipping');

 16762             args = [];

 16763             continue;

 16764           } else if (args.length > opSpec.numArgs) {

 16765             info('Command ' + fn + ': expected ' + opSpec.numArgs +

 16766                  ' args, but received ' + args.length + ' args');

 16767           }

 16768         }

 16770         // TODO figure out how to type-check vararg functions

 16771         this.preprocessCommand(fn, args);

 16773         return { fn: fn, args: args };

 16774       }

 16775     },

 16777     preprocessCommand:

 16778         function EvaluatorPreprocessor_preprocessCommand(fn, args) {

 16779       switch (fn | 0) {

 16780         case OPS.save:

 16781           this.stateManager.save();

 16782           break;

 16783         case OPS.restore:

 16784           this.stateManager.restore();

 16785           break;

 16786         case OPS.transform:

 16787           this.stateManager.transform(args);

 16788           break;

 16789       }

 16790     }

 16791   };

 16792   return EvaluatorPreprocessor;

 16793 })();

 16795 var QueueOptimizer = (function QueueOptimizerClosure() {

 16796   function addState(parentState, pattern, fn) {

 16797     var state = parentState;

 16798     for (var i = 0, ii = pattern.length - 1; i < ii; i++) {

 16799       var item = pattern[i];

 16800       state = (state[item] || (state[item] = []));

 16801     }

 16802     state[pattern[pattern.length - 1]] = fn;

 16803   }

 16805   function handlePaintSolidColorImageMask(index, count, fnArray, argsArray) {

 16806     // Handles special case of mainly LaTeX documents which

 16807     // use image masks to draw lines with the current fill style.

 16808     // 'count' groups of (save, transform, paintImageMaskXObject, restore)+

 16809     // have been found at index.

 16810     for (var i = 0; i < count; i++) {

 16811       var arg = argsArray[index + 4 * i + 2];

 16812       var imageMask = arg.length == 1 && arg[0];

 16813       if (imageMask && imageMask.width == 1 && imageMask.height == 1 &&

 16814           (!imageMask.data.length || (imageMask.data.length == 1 &&

 16815                                       imageMask.data[0] === 0))) {

 16816         fnArray[index + 4 * i + 2] = OPS.paintSolidColorImageMask;

 16817         continue;

 16818       }

 16819       break;

 16820     }

 16821     return count - i;

 16822   }

 16824   var InitialState = [];

 16826   addState(InitialState,

 16827     [OPS.save, OPS.transform, OPS.paintInlineImageXObject, OPS.restore],

 16828     function foundInlineImageGroup(context) {

 16829       // grouping paintInlineImageXObject's into paintInlineImageXObjectGroup

 16830       // searching for (save, transform, paintInlineImageXObject, restore)+

 16831       var MIN_IMAGES_IN_INLINE_IMAGES_BLOCK = 10;

 16832       var MAX_IMAGES_IN_INLINE_IMAGES_BLOCK = 200;

 16833       var MAX_WIDTH = 1000;

 16834       var IMAGE_PADDING = 1;

 16836       var fnArray = context.fnArray, argsArray = context.argsArray;

 16837       var j = context.currentOperation - 3, i = j + 4;

 16838       var ii = fnArray.length;

 16840       for (; i < ii && fnArray[i - 4] === fnArray[i]; i++) {}

 16841       var count = Math.min((i - j) >> 2, MAX_IMAGES_IN_INLINE_IMAGES_BLOCK);

 16842       if (count < MIN_IMAGES_IN_INLINE_IMAGES_BLOCK) {

 16843         context.currentOperation = i - 1;

 16844         return;

 16845       }

 16846       // assuming that heights of those image is too small (~1 pixel)

 16847       // packing as much as possible by lines

 16848       var maxX = 0;

 16849       var map = [], maxLineHeight = 0;

 16850       var currentX = IMAGE_PADDING, currentY = IMAGE_PADDING;

 16851       var q;

 16852       for (q = 0; q < count; q++) {

 16853         var transform = argsArray[j + (q << 2) + 1];

 16854         var img = argsArray[j + (q << 2) + 2][0];

 16855         if (currentX + img.width > MAX_WIDTH) {

 16856           // starting new line

 16857           maxX = Math.max(maxX, currentX);

 16858           currentY += maxLineHeight + 2 * IMAGE_PADDING;

 16859           currentX = 0;

 16860           maxLineHeight = 0;

 16861         }

 16862         map.push({

 16863           transform: transform,

 16864           x: currentX, y: currentY,

 16865           w: img.width, h: img.height

 16866         });

 16867         currentX += img.width + 2 * IMAGE_PADDING;

 16868         maxLineHeight = Math.max(maxLineHeight, img.height);

 16869       }

 16870       var imgWidth = Math.max(maxX, currentX) + IMAGE_PADDING;

 16871       var imgHeight = currentY + maxLineHeight + IMAGE_PADDING;

 16872       var imgData = new Uint8Array(imgWidth * imgHeight * 4);

 16873       var imgRowSize = imgWidth << 2;

 16874       for (q = 0; q < count; q++) {

 16875         var data = argsArray[j + (q << 2) + 2][0].data;

 16876         // copy image by lines and extends pixels into padding

 16877         var rowSize = map[q].w << 2;

 16878         var dataOffset = 0;

 16879         var offset = (map[q].x + map[q].y * imgWidth) << 2;

 16880         imgData.set(data.subarray(0, rowSize), offset - imgRowSize);

 16881         for (var k = 0, kk = map[q].h; k < kk; k++) {

 16882           imgData.set(data.subarray(dataOffset, dataOffset + rowSize), offset);

 16883           dataOffset += rowSize;

 16884           offset += imgRowSize;

 16885         }

 16886         imgData.set(data.subarray(dataOffset - rowSize, dataOffset), offset);

 16887         while (offset >= 0) {

 16888           data[offset - 4] = data[offset];

 16889           data[offset - 3] = data[offset + 1];

 16890           data[offset - 2] = data[offset + 2];

 16891           data[offset - 1] = data[offset + 3];

 16892           data[offset + rowSize] = data[offset + rowSize - 4];

 16893           data[offset + rowSize + 1] = data[offset + rowSize - 3];

 16894           data[offset + rowSize + 2] = data[offset + rowSize - 2];

 16895           data[offset + rowSize + 3] = data[offset + rowSize - 1];

 16896           offset -= imgRowSize;

 16897         }

 16898       }

 16899       // replacing queue items

 16900       fnArray.splice(j, count * 4, OPS.paintInlineImageXObjectGroup);

 16901       argsArray.splice(j, count * 4,

 16902         [{ width: imgWidth, height: imgHeight, kind: ImageKind.RGBA_32BPP,

 16903            data: imgData }, map]);

 16904       context.currentOperation = j;

 16905     });

 16907   addState(InitialState,

 16908     [OPS.save, OPS.transform, OPS.paintImageMaskXObject, OPS.restore],

 16909     function foundImageMaskGroup(context) {

 16910       // grouping paintImageMaskXObject's into paintImageMaskXObjectGroup

 16911       // searching for (save, transform, paintImageMaskXObject, restore)+

 16912       var MIN_IMAGES_IN_MASKS_BLOCK = 10;

 16913       var MAX_IMAGES_IN_MASKS_BLOCK = 100;

 16914       var MAX_SAME_IMAGES_IN_MASKS_BLOCK = 1000;

 16916       var fnArray = context.fnArray, argsArray = context.argsArray;

 16917       var j = context.currentOperation - 3, i = j + 4;

 16918       var ii = fnArray.length, q;

 16920       for (; i < ii && fnArray[i - 4] === fnArray[i]; i++) {}

 16921       var count = (i - j) >> 2;

 16922       count = handlePaintSolidColorImageMask(j, count, fnArray, argsArray);

 16923       if (count < MIN_IMAGES_IN_MASKS_BLOCK) {

 16924         context.currentOperation = i - 1;

 16925         return;

 16926       }

 16928       var isSameImage = false;

 16929       var transformArgs;

 16930       if (argsArray[j + 1][1] === 0 && argsArray[j + 1][2] === 0) {

 16931         i = j + 4;

 16932         isSameImage = true;

 16933         for (q = 1; q < count; q++, i += 4) {

 16934           var prevTransformArgs = argsArray[i - 3];

 16935           transformArgs = argsArray[i + 1];

 16936           if (argsArray[i - 2][0] !== argsArray[i + 2][0] ||

 16937               prevTransformArgs[0] !== transformArgs[0] ||

 16938               prevTransformArgs[1] !== transformArgs[1] ||

 16939               prevTransformArgs[2] !== transformArgs[2] ||

 16940               prevTransformArgs[3] !== transformArgs[3]) {

 16941             if (q < MIN_IMAGES_IN_MASKS_BLOCK) {

 16942               isSameImage = false;

 16943             } else {

 16944               count = q;

 16945             }

 16946             break; // different image or transform

 16947           }

 16948         }

 16949       }

 16951       if (isSameImage) {

 16952         count = Math.min(count, MAX_SAME_IMAGES_IN_MASKS_BLOCK);

 16953         var positions = new Float32Array(count * 2);

 16954         i = j + 1;

 16955         for (q = 0; q < count; q++) {

 16956           transformArgs = argsArray[i];

 16957           positions[(q << 1)] = transformArgs[4];

 16958           positions[(q << 1) + 1] = transformArgs[5];

 16959           i += 4;

 16960         }

 16962         // replacing queue items

 16963         fnArray.splice(j, count * 4, OPS.paintImageMaskXObjectRepeat);

 16964         argsArray.splice(j, count * 4, [argsArray[j + 2][0],

 16965                          argsArray[j + 1][0], argsArray[j + 1][3], positions]);

 16967         context.currentOperation = j;

 16968       } else {

 16969         count = Math.min(count, MAX_IMAGES_IN_MASKS_BLOCK);

 16970         var images = [];

 16971         for (q = 0; q < count; q++) {

 16972           transformArgs = argsArray[j + (q << 2) + 1];

 16973           var maskParams = argsArray[j + (q << 2) + 2][0];

 16974           images.push({ data: maskParams.data, width: maskParams.width,

 16975                         height: maskParams.height,

 16976                         transform: transformArgs });

 16977         }

 16979         // replacing queue items

 16980         fnArray.splice(j, count * 4, OPS.paintImageMaskXObjectGroup);

 16981         argsArray.splice(j, count * 4, [images]);

 16983         context.currentOperation = j;

 16984       }

 16985     });

 16987   addState(InitialState,

 16988     [OPS.save, OPS.transform, OPS.paintImageXObject, OPS.restore],

 16989     function (context) {

 16990       var MIN_IMAGES_IN_BLOCK = 3;

 16991       var MAX_IMAGES_IN_BLOCK = 1000;

 16993       var fnArray = context.fnArray, argsArray = context.argsArray;

 16994       var j = context.currentOperation - 3, i = j + 4;

 16995       if (argsArray[j + 1][1] !== 0 || argsArray[j + 1][2] !== 0) {

 16996         return;

 16997       }

 16998       var ii = fnArray.length;

 16999       var transformArgs;

 17000       for (; i + 3 < ii && fnArray[i - 4] === fnArray[i]; i += 4) {

 17001         if (fnArray[i - 3] !== fnArray[i + 1] ||

 17002             fnArray[i - 2] !== fnArray[i + 2] ||

 17003             fnArray[i - 1] !== fnArray[i + 3]) {

 17004           break;

 17005         }

 17006         if (argsArray[i - 2][0] !== argsArray[i + 2][0]) {

 17007           break; // different image

 17008         }

 17009         var prevTransformArgs = argsArray[i - 3];

 17010         transformArgs = argsArray[i + 1];

 17011         if (prevTransformArgs[0] !== transformArgs[0] ||

 17012             prevTransformArgs[1] !== transformArgs[1] ||

 17013             prevTransformArgs[2] !== transformArgs[2] ||

 17014             prevTransformArgs[3] !== transformArgs[3]) {

 17015           break; // different transform

 17016         }

 17017       }

 17018       var count = Math.min((i - j) >> 2, MAX_IMAGES_IN_BLOCK);

 17019       if (count < MIN_IMAGES_IN_BLOCK) {

 17020         context.currentOperation = i - 1;

 17021         return;

 17022       }

 17024       var positions = new Float32Array(count * 2);

 17025       i = j + 1;

 17026       for (var q = 0; q < count; q++) {

 17027         transformArgs = argsArray[i];

 17028         positions[(q << 1)] = transformArgs[4];

 17029         positions[(q << 1) + 1] = transformArgs[5];

 17030         i += 4;

 17031       }

 17032       var args = [argsArray[j + 2][0], argsArray[j + 1][0],

 17033                   argsArray[j + 1][3], positions];

 17034       // replacing queue items

 17035       fnArray.splice(j, count * 4, OPS.paintImageXObjectRepeat);

 17036       argsArray.splice(j, count * 4, args);

 17038       context.currentOperation = j;

 17039     });

 17041   addState(InitialState,

 17042     [OPS.beginText, OPS.setFont, OPS.setTextMatrix, OPS.showText, OPS.endText],

 17043     function (context) {

 17044       // moving single chars with same font into beginText/endText groups

 17045       // searching for (beginText, setFont, setTextMatrix, showText, endText)+

 17046       var MIN_CHARS_IN_BLOCK = 3;

 17047       var MAX_CHARS_IN_BLOCK = 1000;

 17049       var fnArray = context.fnArray, argsArray = context.argsArray;

 17050       var j = context.currentOperation - 4, i = j + 5;

 17051       var ii = fnArray.length;

 17053       for (; i < ii && fnArray[i - 5] === fnArray[i]; i++) {

 17054         if (fnArray[i] === OPS.setFont) {

 17055           if (argsArray[i - 5][0] !== argsArray[i][0] ||

 17056               argsArray[i - 5][1] !== argsArray[i][1]) {

 17057             break;

 17058           }

 17059         }

 17060       }

 17061       var count = Math.min(((i - j) / 5) | 0, MAX_CHARS_IN_BLOCK);

 17062       if (count < MIN_CHARS_IN_BLOCK) {

 17063         context.currentOperation = i - 1;

 17064         return;

 17065       }

 17066       if (j >= 4 && fnArray[j - 4] === fnArray[j + 1] &&

 17067           fnArray[j - 3] === fnArray[j + 2] &&

 17068           fnArray[j - 2] === fnArray[j + 3] &&

 17069           fnArray[j - 1] === fnArray[j + 4] &&

 17070           argsArray[j - 4][0] === argsArray[j + 1][0] &&

 17071           argsArray[j - 4][1] === argsArray[j + 1][1]) {

 17072         // extending one block ahead (very first block might have 'dependency')

 17073         count++;

 17074         j -= 5;

 17075       }

 17076       var k = j + 7;

 17077       i = j + 4;

 17078       for (var q = 1; q < count; q++) {

 17079         fnArray[i] = fnArray[k];

 17080         argsArray[i] = argsArray[k];

 17081         fnArray[i + 1] = fnArray[k + 1];

 17082         argsArray[i + 1] = argsArray[k + 1];

 17083         i += 2;

 17084         k += 5;

 17085       }

 17086       var removed = (count - 1) * 3;

 17087       fnArray.splice(i, removed);

 17088       argsArray.splice(i, removed);

 17090       context.currentOperation = i;

 17091     });

 17093   function QueueOptimizer() {}

 17095   QueueOptimizer.prototype = {

 17096     optimize: function QueueOptimizer_optimize(queue) {

 17097       var fnArray = queue.fnArray, argsArray = queue.argsArray;

 17098       var context = {

 17099         currentOperation: 0,

 17100         fnArray: fnArray,

 17101         argsArray: argsArray

 17102       };

 17103       var i, ii = argsArray.length;

 17104       var state;

 17105       for (i = 0; i < ii; i++) {

 17106         state = (state || InitialState)[fnArray[i]];

 17107         if (typeof state === 'function') { // we found some handler

 17108           context.currentOperation = i;

 17109           state = state(context);

 17110           i = context.currentOperation;

 17111           ii = context.fnArray.length;

 17112         }

 17113       }

 17114     }

 17115   };

 17116   return QueueOptimizer;

 17117 })();

 17120 var BUILT_IN_CMAPS = [

 17121 // << Start unicode maps.

 17122 'Adobe-GB1-UCS2',

 17123 'Adobe-CNS1-UCS2',

 17124 'Adobe-Japan1-UCS2',

 17125 'Adobe-Korea1-UCS2',

 17126 // >> End unicode maps.

 17127 '78-EUC-H',

 17128 '78-EUC-V',

 17129 '78-H',

 17130 '78-RKSJ-H',

 17131 '78-RKSJ-V',

 17132 '78-V',

 17133 '78ms-RKSJ-H',

 17134 '78ms-RKSJ-V',

 17135 '83pv-RKSJ-H',

 17136 '90ms-RKSJ-H',

 17137 '90ms-RKSJ-V',

 17138 '90msp-RKSJ-H',

 17139 '90msp-RKSJ-V',

 17140 '90pv-RKSJ-H',

 17141 '90pv-RKSJ-V',

 17142 'Add-H',

 17143 'Add-RKSJ-H',

 17144 'Add-RKSJ-V',

 17145 'Add-V',

 17146 'Adobe-CNS1-0',

 17147 'Adobe-CNS1-1',

 17148 'Adobe-CNS1-2',

 17149 'Adobe-CNS1-3',

 17150 'Adobe-CNS1-4',

 17151 'Adobe-CNS1-5',

 17152 'Adobe-CNS1-6',

 17153 'Adobe-GB1-0',

 17154 'Adobe-GB1-1',

 17155 'Adobe-GB1-2',

 17156 'Adobe-GB1-3',

 17157 'Adobe-GB1-4',

 17158 'Adobe-GB1-5',

 17159 'Adobe-Japan1-0',

 17160 'Adobe-Japan1-1',

 17161 'Adobe-Japan1-2',

 17162 'Adobe-Japan1-3',

 17163 'Adobe-Japan1-4',

 17164 'Adobe-Japan1-5',

 17165 'Adobe-Japan1-6',

 17166 'Adobe-Korea1-0',

 17167 'Adobe-Korea1-1',

 17168 'Adobe-Korea1-2',

 17169 'B5-H',

 17170 'B5-V',

 17171 'B5pc-H',

 17172 'B5pc-V',

 17173 'CNS-EUC-H',

 17174 'CNS-EUC-V',

 17175 'CNS1-H',

 17176 'CNS1-V',

 17177 'CNS2-H',

 17178 'CNS2-V',

 17179 'ETHK-B5-H',

 17180 'ETHK-B5-V',

 17181 'ETen-B5-H',

 17182 'ETen-B5-V',

 17183 'ETenms-B5-H',

 17184 'ETenms-B5-V',

 17185 'EUC-H',

 17186 'EUC-V',

 17187 'Ext-H',

 17188 'Ext-RKSJ-H',

 17189 'Ext-RKSJ-V',

 17190 'Ext-V',

 17191 'GB-EUC-H',

 17192 'GB-EUC-V',

 17193 'GB-H',

 17194 'GB-V',

 17195 'GBK-EUC-H',

 17196 'GBK-EUC-V',

 17197 'GBK2K-H',

 17198 'GBK2K-V',

 17199 'GBKp-EUC-H',

 17200 'GBKp-EUC-V',

 17201 'GBT-EUC-H',

 17202 'GBT-EUC-V',

 17203 'GBT-H',

 17204 'GBT-V',

 17205 'GBTpc-EUC-H',

 17206 'GBTpc-EUC-V',

 17207 'GBpc-EUC-H',

 17208 'GBpc-EUC-V',

 17209 'H',

 17210 'HKdla-B5-H',

 17211 'HKdla-B5-V',

 17212 'HKdlb-B5-H',

 17213 'HKdlb-B5-V',

 17214 'HKgccs-B5-H',

 17215 'HKgccs-B5-V',

 17216 'HKm314-B5-H',

 17217 'HKm314-B5-V',

 17218 'HKm471-B5-H',

 17219 'HKm471-B5-V',

 17220 'HKscs-B5-H',

 17221 'HKscs-B5-V',

 17222 'Hankaku',

 17223 'Hiragana',

 17224 'KSC-EUC-H',

 17225 'KSC-EUC-V',

 17226 'KSC-H',

 17227 'KSC-Johab-H',

 17228 'KSC-Johab-V',

 17229 'KSC-V',

 17230 'KSCms-UHC-H',

 17231 'KSCms-UHC-HW-H',

 17232 'KSCms-UHC-HW-V',

 17233 'KSCms-UHC-V',

 17234 'KSCpc-EUC-H',

 17235 'KSCpc-EUC-V',

 17236 'Katakana',

 17237 'NWP-H',

 17238 'NWP-V',

 17239 'RKSJ-H',

 17240 'RKSJ-V',

 17241 'Roman',

 17242 'UniCNS-UCS2-H',

 17243 'UniCNS-UCS2-V',

 17244 'UniCNS-UTF16-H',

 17245 'UniCNS-UTF16-V',

 17246 'UniCNS-UTF32-H',

 17247 'UniCNS-UTF32-V',

 17248 'UniCNS-UTF8-H',

 17249 'UniCNS-UTF8-V',

 17250 'UniGB-UCS2-H',

 17251 'UniGB-UCS2-V',

 17252 'UniGB-UTF16-H',

 17253 'UniGB-UTF16-V',

 17254 'UniGB-UTF32-H',

 17255 'UniGB-UTF32-V',

 17256 'UniGB-UTF8-H',

 17257 'UniGB-UTF8-V',

 17258 'UniJIS-UCS2-H',

 17259 'UniJIS-UCS2-HW-H',

 17260 'UniJIS-UCS2-HW-V',

 17261 'UniJIS-UCS2-V',

 17262 'UniJIS-UTF16-H',

 17263 'UniJIS-UTF16-V',

 17264 'UniJIS-UTF32-H',

 17265 'UniJIS-UTF32-V',

 17266 'UniJIS-UTF8-H',

 17267 'UniJIS-UTF8-V',

 17268 'UniJIS2004-UTF16-H',

 17269 'UniJIS2004-UTF16-V',

 17270 'UniJIS2004-UTF32-H',

 17271 'UniJIS2004-UTF32-V',

 17272 'UniJIS2004-UTF8-H',

 17273 'UniJIS2004-UTF8-V',

 17274 'UniJISPro-UCS2-HW-V',

 17275 'UniJISPro-UCS2-V',

 17276 'UniJISPro-UTF8-V',

 17277 'UniJISX0213-UTF32-H',

 17278 'UniJISX0213-UTF32-V',

 17279 'UniJISX02132004-UTF32-H',

 17280 'UniJISX02132004-UTF32-V',

 17281 'UniKS-UCS2-H',

 17282 'UniKS-UCS2-V',

 17283 'UniKS-UTF16-H',

 17284 'UniKS-UTF16-V',

 17285 'UniKS-UTF32-H',

 17286 'UniKS-UTF32-V',

 17287 'UniKS-UTF8-H',

 17288 'UniKS-UTF8-V',

 17289 'V',

 17290 'WP-Symbol'];

 17292 // CMap, not to be confused with TrueType's cmap.

 17293 var CMap = (function CMapClosure() {

 17294   function CMap(builtInCMap) {

 17295     // Codespace ranges are stored as follows:

 17296     // [[1BytePairs], [2BytePairs], [3BytePairs], [4BytePairs]]

 17297     // where nBytePairs are ranges e.g. [low1, high1, low2, high2, ...]

 17298     this.codespaceRanges = [[], [], [], []];

 17299     this.numCodespaceRanges = 0;

 17300     this.map = [];

 17301     this.vertical = false;

 17302     this.useCMap = null;

 17303     this.builtInCMap = builtInCMap;

 17304   }

 17305   CMap.prototype = {

 17306     addCodespaceRange: function(n, low, high) {

 17307       this.codespaceRanges[n - 1].push(low, high);

 17308       this.numCodespaceRanges++;

 17309     },

 17311     mapRange: function(low, high, dstLow) {

 17312       var lastByte = dstLow.length - 1;

 17313       while (low <= high) {

 17314         this.map[low] = dstLow;

 17315         // Only the last byte has to be incremented.

 17316         dstLow = dstLow.substr(0, lastByte) +

 17317                  String.fromCharCode(dstLow.charCodeAt(lastByte) + 1);

 17318         ++low;

 17319       }

 17320     },

 17322     mapRangeToArray: function(low, high, array) {

 17323       var i = 0;

 17324       while (low <= high) {

 17325         this.map[low] = array[i++];

 17326         ++low;

 17327       }

 17328     },

 17330     mapOne: function(src, dst) {

 17331       this.map[src] = dst;

 17332     },

 17334     lookup: function(code) {

 17335       return this.map[code];

 17336     },

 17338     readCharCode: function(str, offset) {

 17339       var c = 0;

 17340       var codespaceRanges = this.codespaceRanges;

 17341       var codespaceRangesLen = this.codespaceRanges.length;

 17342       // 9.7.6.2 CMap Mapping

 17343       // The code length is at most 4.

 17344       for (var n = 0; n < codespaceRangesLen; n++) {

 17345         c = ((c << 8) | str.charCodeAt(offset + n)) >>> 0;

 17346         // Check each codespace range to see if it falls within.

 17347         var codespaceRange = codespaceRanges[n];

 17348         for (var k = 0, kk = codespaceRange.length; k < kk;) {

 17349           var low = codespaceRange[k++];

 17350           var high = codespaceRange[k++];

 17351           if (c >= low && c <= high) {

 17352             return [c, n + 1];

 17353           }

 17354         }

 17355       }

 17357       return [0, 1];

 17358     }

 17360   };

 17361   return CMap;

 17362 })();

 17364 var IdentityCMap = (function IdentityCMapClosure() {

 17365   function IdentityCMap(vertical, n) {

 17366     CMap.call(this);

 17367     this.vertical = vertical;

 17368     this.addCodespaceRange(n, 0, 0xffff);

 17369     this.mapRange(0, 0xffff, '\u0000');

 17370   }

 17371   Util.inherit(IdentityCMap, CMap, {});

 17373   return IdentityCMap;

 17374 })();

 17376 var BinaryCMapReader = (function BinaryCMapReaderClosure() {

 17377   function fetchBinaryData(url) {

 17378     var nonBinaryRequest = PDFJS.disableWorker;

 17379     var request = new XMLHttpRequest();

 17380     request.open('GET', url, false);

 17381     if (!nonBinaryRequest) {

 17382       try {

 17383         request.responseType = 'arraybuffer';

 17384         nonBinaryRequest = request.responseType !== 'arraybuffer';

 17385       } catch (e) {

 17386         nonBinaryRequest = true;

 17387       }

 17388     }

 17389     if (nonBinaryRequest && request.overrideMimeType) {

 17390       request.overrideMimeType('text/plain; charset=x-user-defined');

 17391     }

 17392     request.send(null);

 17393     if (request.status === 0 && /^https?:/i.test(url)) {

 17394       error('Unable to get binary cMap at: ' + url);

 17395     }

 17396     if (nonBinaryRequest) {

 17397       var data = Array.prototype.map.call(request.responseText, function (ch) {

 17398         return ch.charCodeAt(0) & 255;

 17399       });

 17400       return new Uint8Array(data);

 17401     }

 17402     return new Uint8Array(request.response);

 17403   }

 17405   function hexToInt(a, size) {

 17406     var n = 0;

 17407     for (var i = 0; i <= size; i++) {

 17408       n = (n << 8) | a[i];

 17409     }

 17410     return n >>> 0;

 17411   }

 17413   function hexToStr(a, size) {

 17414     return String.fromCharCode.apply(null, a.subarray(0, size + 1));

 17415   }

 17417   function addHex(a, b, size) {

 17418     var c = 0;

 17419     for (var i = size; i >= 0; i--) {

 17420       c += a[i] + b[i];

 17421       a[i] = c & 255;

 17422       c >>= 8;

 17423     }

 17424   }

 17426   function incHex(a, size) {

 17427     var c = 1;

 17428     for (var i = size; i >= 0 && c > 0; i--) {

 17429       c += a[i];

 17430       a[i] = c & 255;

 17431       c >>= 8;

 17432     }

 17433   }

 17435   var MAX_NUM_SIZE = 16;

 17436   var MAX_ENCODED_NUM_SIZE = 19; // ceil(MAX_NUM_SIZE * 7 / 8)

 17438   function BinaryCMapStream(data) {

 17439     this.buffer = data;

 17440     this.pos = 0;

 17441     this.end = data.length;

 17442     this.tmpBuf = new Uint8Array(MAX_ENCODED_NUM_SIZE);

 17443   }

 17445   BinaryCMapStream.prototype = {

 17446     readByte: function () {

 17447       if (this.pos >= this.end) {

 17448         return -1;

 17449       }

 17450       return this.buffer[this.pos++];

 17451     },

 17452     readNumber: function () {

 17453       var n = 0;

 17454       var last;

 17455       do {

 17456         var b = this.readByte();

 17457         if (b < 0) {

 17458           error('unexpected EOF in bcmap');

 17459         }

 17460         last = !(b & 0x80);

 17461         n = (n << 7) | (b & 0x7F);

 17462       } while (!last);

 17463       return n;

 17464     },

 17465     readSigned: function () {

 17466       var n = this.readNumber();

 17467       return (n & 1) ? ~(n >>> 1) : n >>> 1;

 17468     },

 17469     readHex: function (num, size) {

 17470       num.set(this.buffer.subarray(this.pos,

 17471         this.pos + size + 1));

 17472       this.pos += size + 1;

 17473     },

 17474     readHexNumber: function (num, size) {

 17475       var last;

 17476       var stack = this.tmpBuf, sp = 0;

 17477       do {

 17478         var b = this.readByte();

 17479         if (b < 0) {

 17480           error('unexpected EOF in bcmap');

 17481         }

 17482         last = !(b & 0x80);

 17483         stack[sp++] = b & 0x7F;

 17484       } while (!last);

 17485       var i = size, buffer = 0, bufferSize = 0;

 17486       while (i >= 0) {

 17487         while (bufferSize < 8 && stack.length > 0) {

 17488           buffer = (stack[--sp] << bufferSize) | buffer;

 17489           bufferSize += 7;

 17490         }

 17491         num[i] = buffer & 255;

 17492         i--;

 17493         buffer >>= 8;

 17494         bufferSize -= 8;

 17495       }

 17496     },

 17497     readHexSigned: function (num, size) {

 17498       this.readHexNumber(num, size);

 17499       var sign = num[size] & 1 ? 255 : 0;

 17500       var c = 0;

 17501       for (var i = 0; i <= size; i++) {

 17502         c = ((c & 1) << 8) | num[i];

 17503         num[i] = (c >> 1) ^ sign;

 17504       }

 17505     },

 17506     readString: function () {

 17507       var len = this.readNumber();

 17508       var s = '';

 17509       for (var i = 0; i < len; i++) {

 17510         s += String.fromCharCode(this.readNumber());

 17511       }

 17512       return s;

 17513     }

 17514   };

 17516   function processBinaryCMap(url, cMap, extend) {

 17517     var data = fetchBinaryData(url);

 17518     var stream = new BinaryCMapStream(data);

 17520     var header = stream.readByte();

 17521     cMap.vertical = !!(header & 1);

 17523     var useCMap = null;

 17524     var start = new Uint8Array(MAX_NUM_SIZE);

 17525     var end = new Uint8Array(MAX_NUM_SIZE);

 17526     var char = new Uint8Array(MAX_NUM_SIZE);

 17527     var charCode = new Uint8Array(MAX_NUM_SIZE);

 17528     var tmp = new Uint8Array(MAX_NUM_SIZE);

 17529     var code;

 17531     var b;

 17532     while ((b = stream.readByte()) >= 0) {

 17533       var type = b >> 5;

 17534       if (type === 7) { // metadata, e.g. comment or usecmap

 17535         switch (b & 0x1F) {

 17536           case 0:

 17537             stream.readString(); // skipping comment

 17538             break;

 17539           case 1:

 17540             useCMap = stream.readString();

 17541             break;

 17542         }

 17543         continue;

 17544       }

 17545       var sequence = !!(b & 0x10);

 17546       var dataSize = b & 15;

 17548       assert(dataSize + 1 <= MAX_NUM_SIZE);

 17550       var ucs2DataSize = 1;

 17551       var subitemsCount = stream.readNumber();

 17552       var i;

 17553       switch (type) {

 17554         case 0: // codespacerange

 17555           stream.readHex(start, dataSize);

 17556           stream.readHexNumber(end, dataSize);

 17557           addHex(end, start, dataSize);

 17558           cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize),

 17559                                  hexToInt(end, dataSize));

 17560           for (i = 1; i < subitemsCount; i++) {

 17561             incHex(end, dataSize);

 17562             stream.readHexNumber(start, dataSize);

 17563             addHex(start, end, dataSize);

 17564             stream.readHexNumber(end, dataSize);

 17565             addHex(end, start, dataSize);

 17566             cMap.addCodespaceRange(dataSize + 1, hexToInt(start, dataSize),

 17567                                    hexToInt(end, dataSize));

 17568           }

 17569           break;

 17570         case 1: // notdefrange

 17571           stream.readHex(start, dataSize);

 17572           stream.readHexNumber(end, dataSize);

 17573           addHex(end, start, dataSize);

 17574           code = stream.readNumber();

 17575           // undefined range, skipping

 17576           for (i = 1; i < subitemsCount; i++) {

 17577             incHex(end, dataSize);

 17578             stream.readHexNumber(start, dataSize);

 17579             addHex(start, end, dataSize);

 17580             stream.readHexNumber(end, dataSize);

 17581             addHex(end, start, dataSize);

 17582             code = stream.readNumber();

 17583             // nop

 17584           }

 17585           break;

 17586         case 2: // cidchar

 17587           stream.readHex(char, dataSize);

 17588           code = stream.readNumber();

 17589           cMap.mapOne(hexToInt(char, dataSize), String.fromCharCode(code));

 17590           for (i = 1; i < subitemsCount; i++) {

 17591             incHex(char, dataSize);

 17592             if (!sequence) {

 17593               stream.readHexNumber(tmp, dataSize);

 17594               addHex(char, tmp, dataSize);

 17595             }

 17596             code = stream.readSigned() + (code + 1);

 17597             cMap.mapOne(hexToInt(char, dataSize), String.fromCharCode(code));

 17598           }

 17599           break;

 17600         case 3: // cidrange

 17601           stream.readHex(start, dataSize);

 17602           stream.readHexNumber(end, dataSize);

 17603           addHex(end, start, dataSize);

 17604           code = stream.readNumber();

 17605           cMap.mapRange(hexToInt(start, dataSize), hexToInt(end, dataSize),

 17606                         String.fromCharCode(code));

 17607           for (i = 1; i < subitemsCount; i++) {

 17608             incHex(end, dataSize);

 17609             if (!sequence) {

 17610               stream.readHexNumber(start, dataSize);

 17611               addHex(start, end, dataSize);

 17612             } else {

 17613               start.set(end);

 17614             }

 17615             stream.readHexNumber(end, dataSize);

 17616             addHex(end, start, dataSize);

 17617             code = stream.readNumber();

 17618             cMap.mapRange(hexToInt(start, dataSize), hexToInt(end, dataSize),

 17619                           String.fromCharCode(code));

 17620           }

 17621           break;

 17622         case 4: // bfchar

 17623           stream.readHex(char, ucs2DataSize);

 17624           stream.readHex(charCode, dataSize);

 17625           cMap.mapOne(hexToInt(char, ucs2DataSize),

 17626                       hexToStr(charCode, dataSize));

 17627           for (i = 1; i < subitemsCount; i++) {

 17628             incHex(char, ucs2DataSize);

 17629             if (!sequence) {

 17630               stream.readHexNumber(tmp, ucs2DataSize);

 17631               addHex(char, tmp, ucs2DataSize);

 17632             }

 17633             incHex(charCode, dataSize);

 17634             stream.readHexSigned(tmp, dataSize);

 17635             addHex(charCode, tmp, dataSize);

 17636             cMap.mapOne(hexToInt(char, ucs2DataSize),

 17637                         hexToStr(charCode, dataSize));

 17638           }

 17639           break;

 17640         case 5: // bfrange

 17641           stream.readHex(start, ucs2DataSize);

 17642           stream.readHexNumber(end, ucs2DataSize);

 17643           addHex(end, start, ucs2DataSize);

 17644           stream.readHex(charCode, dataSize);

 17645           cMap.mapRange(hexToInt(start, ucs2DataSize),

 17646                         hexToInt(end, ucs2DataSize),

 17647                         hexToStr(charCode, dataSize));

 17648           for (i = 1; i < subitemsCount; i++) {

 17649             incHex(end, ucs2DataSize);

 17650             if (!sequence) {

 17651               stream.readHexNumber(start, ucs2DataSize);

 17652               addHex(start, end, ucs2DataSize);

 17653             } else {

 17654               start.set(end);

 17655             }

 17656             stream.readHexNumber(end, ucs2DataSize);

 17657             addHex(end, start, ucs2DataSize);

 17658             stream.readHex(charCode, dataSize);

 17659             cMap.mapRange(hexToInt(start, ucs2DataSize),

 17660                           hexToInt(end, ucs2DataSize),

 17661                           hexToStr(charCode, dataSize));

 17662           }

 17663           break;

 17664         default:

 17665           error('Unknown type: ' + type);

 17666           break;

 17667       }

 17668     }

 17670     if (useCMap) {

 17671       extend(useCMap);

 17672     }

 17673     return cMap;

 17674   }

 17676   function BinaryCMapReader() {}

 17678   BinaryCMapReader.prototype = {

 17679     read: processBinaryCMap

 17680   };

 17682   return BinaryCMapReader;

 17683 })();

 17685 var CMapFactory = (function CMapFactoryClosure() {

 17686   function strToInt(str) {

 17687     var a = 0;

 17688     for (var i = 0; i < str.length; i++) {

 17689       a = (a << 8) | str.charCodeAt(i);

 17690     }

 17691     return a >>> 0;

 17692   }

 17694   function expectString(obj) {

 17695     if (!isString(obj)) {

 17696       error('Malformed CMap: expected string.');

 17697     }

 17698   }

 17700   function expectInt(obj) {

 17701     if (!isInt(obj)) {

 17702       error('Malformed CMap: expected int.');

 17703     }

 17704   }

 17706   function parseBfChar(cMap, lexer) {

 17707     while (true) {

 17708       var obj = lexer.getObj();

 17709       if (isEOF(obj)) {

 17710         break;

 17711       }

 17712       if (isCmd(obj, 'endbfchar')) {

 17713         return;

 17714       }

 17715       expectString(obj);

 17716       var src = strToInt(obj);

 17717       obj = lexer.getObj();

 17718       // TODO are /dstName used?

 17719       expectString(obj);

 17720       var dst = obj;

 17721       cMap.mapOne(src, dst);

 17722     }

 17723   }

 17725   function parseBfRange(cMap, lexer) {

 17726     while (true) {

 17727       var obj = lexer.getObj();

 17728       if (isEOF(obj)) {

 17729         break;

 17730       }

 17731       if (isCmd(obj, 'endbfrange')) {

 17732         return;

 17733       }

 17734       expectString(obj);

 17735       var low = strToInt(obj);

 17736       obj = lexer.getObj();

 17737       expectString(obj);

 17738       var high = strToInt(obj);

 17739       obj = lexer.getObj();

 17740       if (isInt(obj) || isString(obj)) {

 17741         var dstLow = isInt(obj) ? String.fromCharCode(obj) : obj;

 17742         cMap.mapRange(low, high, dstLow);

 17743       } else if (isCmd(obj, '[')) {

 17744         obj = lexer.getObj();

 17745         var array = [];

 17746         while (!isCmd(obj, ']') && !isEOF(obj)) {

 17747           array.push(obj);

 17748           obj = lexer.getObj();

 17749         }

 17750         cMap.mapRangeToArray(low, high, array);

 17751       } else {

 17752         break;

 17753       }

 17754     }

 17755     error('Invalid bf range.');

 17756   }

 17758   function parseCidChar(cMap, lexer) {

 17759     while (true) {

 17760       var obj = lexer.getObj();

 17761       if (isEOF(obj)) {

 17762         break;

 17763       }

 17764       if (isCmd(obj, 'endcidchar')) {

 17765         return;

 17766       }

 17767       expectString(obj);

 17768       var src = strToInt(obj);

 17769       obj = lexer.getObj();

 17770       expectInt(obj);

 17771       var dst = String.fromCharCode(obj);

 17772       cMap.mapOne(src, dst);

 17773     }

 17774   }

 17776   function parseCidRange(cMap, lexer) {

 17777     while (true) {

 17778       var obj = lexer.getObj();

 17779       if (isEOF(obj)) {

 17780         break;

 17781       }

 17782       if (isCmd(obj, 'endcidrange')) {

 17783         return;

 17784       }

 17785       expectString(obj);

 17786       var low = strToInt(obj);

 17787       obj = lexer.getObj();

 17788       expectString(obj);

 17789       var high = strToInt(obj);

 17790       obj = lexer.getObj();

 17791       expectInt(obj);

 17792       var dstLow = String.fromCharCode(obj);

 17793       cMap.mapRange(low, high, dstLow);

 17794     }

 17795   }

 17797   function parseCodespaceRange(cMap, lexer) {

 17798     while (true) {

 17799       var obj = lexer.getObj();

 17800       if (isEOF(obj)) {

 17801         break;

 17802       }

 17803       if (isCmd(obj, 'endcodespacerange')) {

 17804         return;

 17805       }

 17806       if (!isString(obj)) {

 17807         break;

 17808       }

 17809       var low = strToInt(obj);

 17810       obj = lexer.getObj();

 17811       if (!isString(obj)) {

 17812         break;

 17813       }

 17814       var high = strToInt(obj);

 17815       cMap.addCodespaceRange(obj.length, low, high);

 17816     }

 17817     error('Invalid codespace range.');

 17818   }

 17820   function parseWMode(cMap, lexer) {

 17821     var obj = lexer.getObj();

 17822     if (isInt(obj)) {

 17823       cMap.vertical = !!obj;

 17824     }

 17825   }

 17827   function parseCMap(cMap, lexer, builtInCMapParams, useCMap) {

 17828     var previous;

 17829     var embededUseCMap;

 17830     objLoop: while (true) {

 17831       var obj = lexer.getObj();

 17832       if (isEOF(obj)) {

 17833         break;

 17834       } else if (isName(obj)) {

 17835         if (obj.name === 'WMode') {

 17836           parseWMode(cMap, lexer);

 17837         }

 17838         previous = obj;

 17839       } else if (isCmd(obj)) {

 17840         switch (obj.cmd) {

 17841           case 'endcmap':

 17842             break objLoop;

 17843           case 'usecmap':

 17844             if (isName(previous)) {

 17845               embededUseCMap = previous.name;

 17846             }

 17847             break;

 17848           case 'begincodespacerange':

 17849             parseCodespaceRange(cMap, lexer);

 17850             break;

 17851           case 'beginbfchar':

 17852             parseBfChar(cMap, lexer);

 17853             break;

 17854           case 'begincidchar':

 17855             parseCidChar(cMap, lexer);

 17856             break;

 17857           case 'beginbfrange':

 17858             parseBfRange(cMap, lexer);

 17859             break;

 17860           case 'begincidrange':

 17861             parseCidRange(cMap, lexer);

 17862             break;

 17863         }

 17864       }

 17865     }

 17867     if (!useCMap && embededUseCMap) {

 17868       // Load the usecmap definition from the file only if there wasn't one

 17869       // specified.

 17870       useCMap = embededUseCMap;

 17871     }

 17872     if (useCMap) {

 17873       extendCMap(cMap, builtInCMapParams, useCMap);

 17874     }

 17875   }

 17877   function extendCMap(cMap, builtInCMapParams, useCMap) {

 17878     cMap.useCMap = createBuiltInCMap(useCMap, builtInCMapParams);

 17879     // If there aren't any code space ranges defined clone all the parent ones

 17880     // into this cMap.

 17881     if (cMap.numCodespaceRanges === 0) {

 17882       var useCodespaceRanges = cMap.useCMap.codespaceRanges;

 17883       for (var i = 0; i < useCodespaceRanges.length; i++) {

 17884         cMap.codespaceRanges[i] = useCodespaceRanges[i].slice();

 17885       }

 17886       cMap.numCodespaceRanges = cMap.useCMap.numCodespaceRanges;

 17887     }

 17888     // Merge the map into the current one, making sure not to override

 17889     // any previously defined entries.

 17890     for (var key in cMap.useCMap.map) {

 17891       if (key in cMap.map) {

 17892         continue;

 17893       }

 17894       cMap.map[key] = cMap.useCMap.map[key];

 17895     }

 17896   }

 17898   function parseBinaryCMap(name, builtInCMapParams) {

 17899     var url = builtInCMapParams.url + name + '.bcmap';

 17900     var cMap = new CMap(true);

 17901     new BinaryCMapReader().read(url, cMap, function (useCMap) {

 17902       extendCMap(cMap, builtInCMapParams, useCMap);

 17903     });

 17904     return cMap;

 17905   }

 17907   function createBuiltInCMap(name, builtInCMapParams) {

 17908     if (name === 'Identity-H') {

 17909       return new IdentityCMap(false, 2);

 17910     } else if (name === 'Identity-V') {

 17911       return new IdentityCMap(true, 2);

 17912     }

 17913     if (BUILT_IN_CMAPS.indexOf(name) === -1) {

 17914       error('Unknown cMap name: ' + name);

 17915     }

 17916     assert (builtInCMapParams, 'buildin cmap parameters are not provided');

 17918     if (builtInCMapParams.packed) {

 17919       return parseBinaryCMap(name, builtInCMapParams);

 17920     }

 17922     var request = new XMLHttpRequest();

 17923     var url = builtInCMapParams.url + name;

 17924     request.open('GET', url, false);

 17925     request.send(null);

 17926     if (request.status === 0 && /^https?:/i.test(url)) {

 17927       error('Unable to get cMap at: ' + url);

 17928     }

 17929     var cMap = new CMap(true);

 17930     var lexer = new Lexer(new StringStream(request.responseText));

 17931     parseCMap(cMap, lexer, builtInCMapParams, null);

 17932     return cMap;

 17933   }

 17935   return {

 17936     create: function (encoding, builtInCMapParams, useCMap) {

 17937       if (isName(encoding)) {

 17938         return createBuiltInCMap(encoding.name, builtInCMapParams);

 17939       } else if (isStream(encoding)) {

 17940         var cMap = new CMap();

 17941         var lexer = new Lexer(encoding);

 17942         try {

 17943           parseCMap(cMap, lexer, builtInCMapParams, useCMap);

 17944         } catch (e) {

 17945           warn('Invalid CMap data. ' + e);

 17946         }

 17947         return cMap;

 17948       }

 17949       error('Encoding required.');

 17950     }

 17951   };

 17952 })();

 17955 // Unicode Private Use Area

 17956 var PRIVATE_USE_OFFSET_START = 0xE000;

 17957 var PRIVATE_USE_OFFSET_END = 0xF8FF;

 17958 var SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = false;

 17960 // PDF Glyph Space Units are one Thousandth of a TextSpace Unit

 17961 // except for Type 3 fonts

 17962 var PDF_GLYPH_SPACE_UNITS = 1000;

 17964 // Hinting is currently disabled due to unknown problems on windows

 17965 // in tracemonkey and various other pdfs with type1 fonts.

 17966 var HINTING_ENABLED = false;

 17968 // Accented charactars are not displayed properly on windows, using this flag

 17969 // to control analysis of seac charstrings.

 17970 var SEAC_ANALYSIS_ENABLED = false;

 17972 var FontFlags = {

 17973   FixedPitch: 1,

 17974   Serif: 2,

 17975   Symbolic: 4,

 17976   Script: 8,

 17977   Nonsymbolic: 32,

 17978   Italic: 64,

 17979   AllCap: 65536,

 17980   SmallCap: 131072,

 17981   ForceBold: 262144

 17982 };

 17984 var Encodings = {

 17985   ExpertEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 17986     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 17987     'space', 'exclamsmall', 'Hungarumlautsmall', '', 'dollaroldstyle',

 17988     'dollarsuperior', 'ampersandsmall', 'Acutesmall', 'parenleftsuperior',

 17989     'parenrightsuperior', 'twodotenleader', 'onedotenleader', 'comma',

 17990     'hyphen', 'period', 'fraction', 'zerooldstyle', 'oneoldstyle',

 17991     'twooldstyle', 'threeoldstyle', 'fouroldstyle', 'fiveoldstyle',

 17992     'sixoldstyle', 'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'colon',

 17993     'semicolon', 'commasuperior', 'threequartersemdash', 'periodsuperior',

 17994     'questionsmall', '', 'asuperior', 'bsuperior', 'centsuperior', 'dsuperior',

 17995     'esuperior', '', '', 'isuperior', '', '', 'lsuperior', 'msuperior',

 17996     'nsuperior', 'osuperior', '', '', 'rsuperior', 'ssuperior', 'tsuperior',

 17997     '', 'ff', 'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', '',

 17998     'parenrightinferior', 'Circumflexsmall', 'hyphensuperior', 'Gravesmall',

 17999     'Asmall', 'Bsmall', 'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall',

 18000     'Hsmall', 'Ismall', 'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall',

 18001     'Osmall', 'Psmall', 'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall',

 18002     'Vsmall', 'Wsmall', 'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary',

 18003     'onefitted', 'rupiah', 'Tildesmall', '', '', '', '', '', '', '', '', '',

 18004     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18005     '', '', '', '', '', '', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall',

 18006     '', '', 'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall',

 18007     'Caronsmall', '', 'Dotaccentsmall', '', '', 'Macronsmall', '', '',

 18008     'figuredash', 'hypheninferior', '', '', 'Ogoneksmall', 'Ringsmall',

 18009     'Cedillasmall', '', '', '', 'onequarter', 'onehalf', 'threequarters',

 18010     'questiondownsmall', 'oneeighth', 'threeeighths', 'fiveeighths',

 18011     'seveneighths', 'onethird', 'twothirds', '', '', 'zerosuperior',

 18012     'onesuperior', 'twosuperior', 'threesuperior', 'foursuperior',

 18013     'fivesuperior', 'sixsuperior', 'sevensuperior', 'eightsuperior',

 18014     'ninesuperior', 'zeroinferior', 'oneinferior', 'twoinferior',

 18015     'threeinferior', 'fourinferior', 'fiveinferior', 'sixinferior',

 18016     'seveninferior', 'eightinferior', 'nineinferior', 'centinferior',

 18017     'dollarinferior', 'periodinferior', 'commainferior', 'Agravesmall',

 18018     'Aacutesmall', 'Acircumflexsmall', 'Atildesmall', 'Adieresissmall',

 18019     'Aringsmall', 'AEsmall', 'Ccedillasmall', 'Egravesmall', 'Eacutesmall',

 18020     'Ecircumflexsmall', 'Edieresissmall', 'Igravesmall', 'Iacutesmall',

 18021     'Icircumflexsmall', 'Idieresissmall', 'Ethsmall', 'Ntildesmall',

 18022     'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall', 'Otildesmall',

 18023     'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall', 'Uacutesmall',

 18024     'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall', 'Thornsmall',

 18025     'Ydieresissmall'],

 18026   MacExpertEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18027     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18028     'space', 'exclamsmall', 'Hungarumlautsmall', 'centoldstyle',

 18029     'dollaroldstyle', 'dollarsuperior', 'ampersandsmall', 'Acutesmall',

 18030     'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',

 18031     'onedotenleader', 'comma', 'hyphen', 'period', 'fraction', 'zerooldstyle',

 18032     'oneoldstyle', 'twooldstyle', 'threeoldstyle', 'fouroldstyle',

 18033     'fiveoldstyle', 'sixoldstyle', 'sevenoldstyle', 'eightoldstyle',

 18034     'nineoldstyle', 'colon', 'semicolon', '', 'threequartersemdash', '',

 18035     'questionsmall', '', '', '', '', 'Ethsmall', '', '', 'onequarter',

 18036     'onehalf', 'threequarters', 'oneeighth', 'threeeighths', 'fiveeighths',

 18037     'seveneighths', 'onethird', 'twothirds', '', '', '', '', '', '', 'ff',

 18038     'fi', 'fl', 'ffi', 'ffl', 'parenleftinferior', '', 'parenrightinferior',

 18039     'Circumflexsmall', 'hypheninferior', 'Gravesmall', 'Asmall', 'Bsmall',

 18040     'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall',

 18041     'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall',

 18042     'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall',

 18043     'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah',

 18044     'Tildesmall', '', '', 'asuperior', 'centsuperior', '', '', '', '',

 18045     'Aacutesmall', 'Agravesmall', 'Acircumflexsmall', 'Adieresissmall',

 18046     'Atildesmall', 'Aringsmall', 'Ccedillasmall', 'Eacutesmall', 'Egravesmall',

 18047     'Ecircumflexsmall', 'Edieresissmall', 'Iacutesmall', 'Igravesmall',

 18048     'Icircumflexsmall', 'Idieresissmall', 'Ntildesmall', 'Oacutesmall',

 18049     'Ogravesmall', 'Ocircumflexsmall', 'Odieresissmall', 'Otildesmall',

 18050     'Uacutesmall', 'Ugravesmall', 'Ucircumflexsmall', 'Udieresissmall', '',

 18051     'eightsuperior', 'fourinferior', 'threeinferior', 'sixinferior',

 18052     'eightinferior', 'seveninferior', 'Scaronsmall', '', 'centinferior',

 18053     'twoinferior', '', 'Dieresissmall', '', 'Caronsmall', 'osuperior',

 18054     'fiveinferior', '', 'commainferior', 'periodinferior', 'Yacutesmall', '',

 18055     'dollarinferior', '', 'Thornsmall', '', 'nineinferior', 'zeroinferior',

 18056     'Zcaronsmall', 'AEsmall', 'Oslashsmall', 'questiondownsmall',

 18057     'oneinferior', 'Lslashsmall', '', '', '', '', '', '', 'Cedillasmall', '',

 18058     '', '', '', '', 'OEsmall', 'figuredash', 'hyphensuperior', '', '', '', '',

 18059     'exclamdownsmall', '', 'Ydieresissmall', '', 'onesuperior', 'twosuperior',

 18060     'threesuperior', 'foursuperior', 'fivesuperior', 'sixsuperior',

 18061     'sevensuperior', 'ninesuperior', 'zerosuperior', '', 'esuperior',

 18062     'rsuperior', 'tsuperior', '', '', 'isuperior', 'ssuperior', 'dsuperior',

 18063     '', '', '', '', '', 'lsuperior', 'Ogoneksmall', 'Brevesmall',

 18064     'Macronsmall', 'bsuperior', 'nsuperior', 'msuperior', 'commasuperior',

 18065     'periodsuperior', 'Dotaccentsmall', 'Ringsmall'],

 18066   MacRomanEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18067     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18068     'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent',

 18069     'ampersand', 'quotesingle', 'parenleft', 'parenright', 'asterisk', 'plus',

 18070     'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three',

 18071     'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon',

 18072     'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F',

 18073     'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',

 18074     'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright',

 18075     'asciicircum', 'underscore', 'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g',

 18076     'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',

 18077     'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde', '',

 18078     'Adieresis', 'Aring', 'Ccedilla', 'Eacute', 'Ntilde', 'Odieresis',

 18079     'Udieresis', 'aacute', 'agrave', 'acircumflex', 'adieresis', 'atilde',

 18080     'aring', 'ccedilla', 'eacute', 'egrave', 'ecircumflex', 'edieresis',

 18081     'iacute', 'igrave', 'icircumflex', 'idieresis', 'ntilde', 'oacute',

 18082     'ograve', 'ocircumflex', 'odieresis', 'otilde', 'uacute', 'ugrave',

 18083     'ucircumflex', 'udieresis', 'dagger', 'degree', 'cent', 'sterling',

 18084     'section', 'bullet', 'paragraph', 'germandbls', 'registered', 'copyright',

 18085     'trademark', 'acute', 'dieresis', 'notequal', 'AE', 'Oslash', 'infinity',

 18086     'plusminus', 'lessequal', 'greaterequal', 'yen', 'mu', 'partialdiff',

 18087     'summation', 'product', 'pi', 'integral', 'ordfeminine', 'ordmasculine',

 18088     'Omega', 'ae', 'oslash', 'questiondown', 'exclamdown', 'logicalnot',

 18089     'radical', 'florin', 'approxequal', 'Delta', 'guillemotleft',

 18090     'guillemotright', 'ellipsis', 'space', 'Agrave', 'Atilde', 'Otilde', 'OE',

 18091     'oe', 'endash', 'emdash', 'quotedblleft', 'quotedblright', 'quoteleft',

 18092     'quoteright', 'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction',

 18093     'currency', 'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl',

 18094     'periodcentered', 'quotesinglbase', 'quotedblbase', 'perthousand',

 18095     'Acircumflex', 'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute',

 18096     'Icircumflex', 'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple',

 18097     'Ograve', 'Uacute', 'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex',

 18098     'tilde', 'macron', 'breve', 'dotaccent', 'ring', 'cedilla', 'hungarumlaut',

 18099     'ogonek', 'caron'],

 18100   StandardEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18101     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18102     'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent',

 18103     'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus',

 18104     'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three',

 18105     'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon',

 18106     'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F',

 18107     'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',

 18108     'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright',

 18109     'asciicircum', 'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f',

 18110     'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',

 18111     'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde',

 18112     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18113     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', 'exclamdown',

 18114     'cent', 'sterling', 'fraction', 'yen', 'florin', 'section', 'currency',

 18115     'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft',

 18116     'guilsinglright', 'fi', 'fl', '', 'endash', 'dagger', 'daggerdbl',

 18117     'periodcentered', '', 'paragraph', 'bullet', 'quotesinglbase',

 18118     'quotedblbase', 'quotedblright', 'guillemotright', 'ellipsis',

 18119     'perthousand', '', 'questiondown', '', 'grave', 'acute', 'circumflex',

 18120     'tilde', 'macron', 'breve', 'dotaccent', 'dieresis', '', 'ring', 'cedilla',

 18121     '', 'hungarumlaut', 'ogonek', 'caron', 'emdash', '', '', '', '', '', '',

 18122     '', '', '', '', '', '', '', '', '', '', 'AE', '', 'ordfeminine', '', '',

 18123     '', '', 'Lslash', 'Oslash', 'OE', 'ordmasculine', '', '', '', '', '', 'ae',

 18124     '', '', '', 'dotlessi', '', '', 'lslash', 'oslash', 'oe', 'germandbls'],

 18125   WinAnsiEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18126     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18127     'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent',

 18128     'ampersand', 'quotesingle', 'parenleft', 'parenright', 'asterisk', 'plus',

 18129     'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three',

 18130     'four', 'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon',

 18131     'less', 'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F',

 18132     'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',

 18133     'V', 'W', 'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright',

 18134     'asciicircum', 'underscore', 'grave', 'a', 'b', 'c', 'd', 'e', 'f', 'g',

 18135     'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',

 18136     'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright', 'asciitilde',

 18137     'bullet', 'Euro', 'bullet', 'quotesinglbase', 'florin', 'quotedblbase',

 18138     'ellipsis', 'dagger', 'daggerdbl', 'circumflex', 'perthousand', 'Scaron',

 18139     'guilsinglleft', 'OE', 'bullet', 'Zcaron', 'bullet', 'bullet', 'quoteleft',

 18140     'quoteright', 'quotedblleft', 'quotedblright', 'bullet', 'endash',

 18141     'emdash', 'tilde', 'trademark', 'scaron', 'guilsinglright', 'oe', 'bullet',

 18142     'zcaron', 'Ydieresis', 'space', 'exclamdown', 'cent', 'sterling',

 18143     'currency', 'yen', 'brokenbar', 'section', 'dieresis', 'copyright',

 18144     'ordfeminine', 'guillemotleft', 'logicalnot', 'hyphen', 'registered',

 18145     'macron', 'degree', 'plusminus', 'twosuperior', 'threesuperior', 'acute',

 18146     'mu', 'paragraph', 'periodcentered', 'cedilla', 'onesuperior',

 18147     'ordmasculine', 'guillemotright', 'onequarter', 'onehalf', 'threequarters',

 18148     'questiondown', 'Agrave', 'Aacute', 'Acircumflex', 'Atilde', 'Adieresis',

 18149     'Aring', 'AE', 'Ccedilla', 'Egrave', 'Eacute', 'Ecircumflex', 'Edieresis',

 18150     'Igrave', 'Iacute', 'Icircumflex', 'Idieresis', 'Eth', 'Ntilde', 'Ograve',

 18151     'Oacute', 'Ocircumflex', 'Otilde', 'Odieresis', 'multiply', 'Oslash',

 18152     'Ugrave', 'Uacute', 'Ucircumflex', 'Udieresis', 'Yacute', 'Thorn',

 18153     'germandbls', 'agrave', 'aacute', 'acircumflex', 'atilde', 'adieresis',

 18154     'aring', 'ae', 'ccedilla', 'egrave', 'eacute', 'ecircumflex', 'edieresis',

 18155     'igrave', 'iacute', 'icircumflex', 'idieresis', 'eth', 'ntilde', 'ograve',

 18156     'oacute', 'ocircumflex', 'otilde', 'odieresis', 'divide', 'oslash',

 18157     'ugrave', 'uacute', 'ucircumflex', 'udieresis', 'yacute', 'thorn',

 18158     'ydieresis'],

 18159   SymbolSetEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18160     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18161     'space', 'exclam', 'universal', 'numbersign', 'existential', 'percent',

 18162     'ampersand', 'suchthat', 'parenleft', 'parenright', 'asteriskmath', 'plus',

 18163     'comma', 'minus', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four',

 18164     'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less',

 18165     'equal', 'greater', 'question', 'congruent', 'Alpha', 'Beta', 'Chi',

 18166     'Delta', 'Epsilon', 'Phi', 'Gamma', 'Eta', 'Iota', 'theta1', 'Kappa',

 18167     'Lambda', 'Mu', 'Nu', 'Omicron', 'Pi', 'Theta', 'Rho', 'Sigma', 'Tau',

 18168     'Upsilon', 'sigma1', 'Omega', 'Xi', 'Psi', 'Zeta', 'bracketleft',

 18169     'therefore', 'bracketright', 'perpendicular', 'underscore', 'radicalex',

 18170     'alpha', 'beta', 'chi', 'delta', 'epsilon', 'phi', 'gamma', 'eta', 'iota',

 18171     'phi1', 'kappa', 'lambda', 'mu', 'nu', 'omicron', 'pi', 'theta', 'rho',

 18172     'sigma', 'tau', 'upsilon', 'omega1', 'omega', 'xi', 'psi', 'zeta',

 18173     'braceleft', 'bar', 'braceright', 'similar', '', '', '', '', '', '', '',

 18174     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18175     '', '', '', '', '', '', '', 'Euro', 'Upsilon1', 'minute', 'lessequal',

 18176     'fraction', 'infinity', 'florin', 'club', 'diamond', 'heart', 'spade',

 18177     'arrowboth', 'arrowleft', 'arrowup', 'arrowright', 'arrowdown', 'degree',

 18178     'plusminus', 'second', 'greaterequal', 'multiply', 'proportional',

 18179     'partialdiff', 'bullet', 'divide', 'notequal', 'equivalence',

 18180     'approxequal', 'ellipsis', 'arrowvertex', 'arrowhorizex', 'carriagereturn',

 18181     'aleph', 'Ifraktur', 'Rfraktur', 'weierstrass', 'circlemultiply',

 18182     'circleplus', 'emptyset', 'intersection', 'union', 'propersuperset',

 18183     'reflexsuperset', 'notsubset', 'propersubset', 'reflexsubset', 'element',

 18184     'notelement', 'angle', 'gradient', 'registerserif', 'copyrightserif',

 18185     'trademarkserif', 'product', 'radical', 'dotmath', 'logicalnot',

 18186     'logicaland', 'logicalor', 'arrowdblboth', 'arrowdblleft', 'arrowdblup',

 18187     'arrowdblright', 'arrowdbldown', 'lozenge', 'angleleft', 'registersans',

 18188     'copyrightsans', 'trademarksans', 'summation', 'parenlefttp',

 18189     'parenleftex', 'parenleftbt', 'bracketlefttp', 'bracketleftex',

 18190     'bracketleftbt', 'bracelefttp', 'braceleftmid', 'braceleftbt', 'braceex',

 18191     '', 'angleright', 'integral', 'integraltp', 'integralex', 'integralbt',

 18192     'parenrighttp', 'parenrightex', 'parenrightbt', 'bracketrighttp',

 18193     'bracketrightex', 'bracketrightbt', 'bracerighttp', 'bracerightmid',

 18194     'bracerightbt'],

 18195   zapfDingbatsEncoding: ['', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18196     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18197     'space', 'a1', 'a2', 'a202', 'a3', 'a4', 'a5', 'a119', 'a118', 'a117',

 18198     'a11', 'a12', 'a13', 'a14', 'a15', 'a16', 'a105', 'a17', 'a18', 'a19',

 18199     'a20', 'a21', 'a22', 'a23', 'a24', 'a25', 'a26', 'a27', 'a28', 'a6', 'a7',

 18200     'a8', 'a9', 'a10', 'a29', 'a30', 'a31', 'a32', 'a33', 'a34', 'a35', 'a36',

 18201     'a37', 'a38', 'a39', 'a40', 'a41', 'a42', 'a43', 'a44', 'a45', 'a46',

 18202     'a47', 'a48', 'a49', 'a50', 'a51', 'a52', 'a53', 'a54', 'a55', 'a56',

 18203     'a57', 'a58', 'a59', 'a60', 'a61', 'a62', 'a63', 'a64', 'a65', 'a66',

 18204     'a67', 'a68', 'a69', 'a70', 'a71', 'a72', 'a73', 'a74', 'a203', 'a75',

 18205     'a204', 'a76', 'a77', 'a78', 'a79', 'a81', 'a82', 'a83', 'a84', 'a97',

 18206     'a98', 'a99', 'a100', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18207     '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '',

 18208     '', '', 'a101', 'a102', 'a103', 'a104', 'a106', 'a107', 'a108', 'a112',

 18209     'a111', 'a110', 'a109', 'a120', 'a121', 'a122', 'a123', 'a124', 'a125',

 18210     'a126', 'a127', 'a128', 'a129', 'a130', 'a131', 'a132', 'a133', 'a134',

 18211     'a135', 'a136', 'a137', 'a138', 'a139', 'a140', 'a141', 'a142', 'a143',

 18212     'a144', 'a145', 'a146', 'a147', 'a148', 'a149', 'a150', 'a151', 'a152',

 18213     'a153', 'a154', 'a155', 'a156', 'a157', 'a158', 'a159', 'a160', 'a161',

 18214     'a163', 'a164', 'a196', 'a165', 'a192', 'a166', 'a167', 'a168', 'a169',

 18215     'a170', 'a171', 'a172', 'a173', 'a162', 'a174', 'a175', 'a176', 'a177',

 18216     'a178', 'a179', 'a193', 'a180', 'a199', 'a181', 'a200', 'a182', '', 'a201',

 18217     'a183', 'a184', 'a197', 'a185', 'a194', 'a198', 'a186', 'a195', 'a187',

 18218     'a188', 'a189', 'a190', 'a191']

 18219 };

 18221 /**

 18222  * Hold a map of decoded fonts and of the standard fourteen Type1

 18223  * fonts and their acronyms.

 18224  */

 18225 var stdFontMap = {

 18226   'ArialNarrow': 'Helvetica',

 18227   'ArialNarrow-Bold': 'Helvetica-Bold',

 18228   'ArialNarrow-BoldItalic': 'Helvetica-BoldOblique',

 18229   'ArialNarrow-Italic': 'Helvetica-Oblique',

 18230   'ArialBlack': 'Helvetica',

 18231   'ArialBlack-Bold': 'Helvetica-Bold',

 18232   'ArialBlack-BoldItalic': 'Helvetica-BoldOblique',

 18233   'ArialBlack-Italic': 'Helvetica-Oblique',

 18234   'Arial': 'Helvetica',

 18235   'Arial-Bold': 'Helvetica-Bold',

 18236   'Arial-BoldItalic': 'Helvetica-BoldOblique',

 18237   'Arial-Italic': 'Helvetica-Oblique',

 18238   'Arial-BoldItalicMT': 'Helvetica-BoldOblique',

 18239   'Arial-BoldMT': 'Helvetica-Bold',

 18240   'Arial-ItalicMT': 'Helvetica-Oblique',

 18241   'ArialMT': 'Helvetica',

 18242   'Courier-Bold': 'Courier-Bold',

 18243   'Courier-BoldItalic': 'Courier-BoldOblique',

 18244   'Courier-Italic': 'Courier-Oblique',

 18245   'CourierNew': 'Courier',

 18246   'CourierNew-Bold': 'Courier-Bold',

 18247   'CourierNew-BoldItalic': 'Courier-BoldOblique',

 18248   'CourierNew-Italic': 'Courier-Oblique',

 18249   'CourierNewPS-BoldItalicMT': 'Courier-BoldOblique',

 18250   'CourierNewPS-BoldMT': 'Courier-Bold',

 18251   'CourierNewPS-ItalicMT': 'Courier-Oblique',

 18252   'CourierNewPSMT': 'Courier',

 18253   'Helvetica-Bold': 'Helvetica-Bold',

 18254   'Helvetica-BoldItalic': 'Helvetica-BoldOblique',

 18255   'Helvetica-Italic': 'Helvetica-Oblique',

 18256   'Symbol-Bold': 'Symbol',

 18257   'Symbol-BoldItalic': 'Symbol',

 18258   'Symbol-Italic': 'Symbol',

 18259   'TimesNewRoman': 'Times-Roman',

 18260   'TimesNewRoman-Bold': 'Times-Bold',

 18261   'TimesNewRoman-BoldItalic': 'Times-BoldItalic',

 18262   'TimesNewRoman-Italic': 'Times-Italic',

 18263   'TimesNewRomanPS': 'Times-Roman',

 18264   'TimesNewRomanPS-Bold': 'Times-Bold',

 18265   'TimesNewRomanPS-BoldItalic': 'Times-BoldItalic',

 18266   'TimesNewRomanPS-BoldItalicMT': 'Times-BoldItalic',

 18267   'TimesNewRomanPS-BoldMT': 'Times-Bold',

 18268   'TimesNewRomanPS-Italic': 'Times-Italic',

 18269   'TimesNewRomanPS-ItalicMT': 'Times-Italic',

 18270   'TimesNewRomanPSMT': 'Times-Roman',

 18271   'TimesNewRomanPSMT-Bold': 'Times-Bold',

 18272   'TimesNewRomanPSMT-BoldItalic': 'Times-BoldItalic',

 18273   'TimesNewRomanPSMT-Italic': 'Times-Italic'

 18274 };

 18276 /**

 18277  * Holds the map of the non-standard fonts that might be included as a standard

 18278  * fonts without glyph data.

 18279  */

 18280 var nonStdFontMap = {

 18281   'ComicSansMS': 'Comic Sans MS',

 18282   'ComicSansMS-Bold': 'Comic Sans MS-Bold',

 18283   'ComicSansMS-BoldItalic': 'Comic Sans MS-BoldItalic',

 18284   'ComicSansMS-Italic': 'Comic Sans MS-Italic',

 18285   'LucidaConsole': 'Courier',

 18286   'LucidaConsole-Bold': 'Courier-Bold',

 18287   'LucidaConsole-BoldItalic': 'Courier-BoldOblique',

 18288   'LucidaConsole-Italic': 'Courier-Oblique',

 18289   'MS-Gothic': 'MS Gothic',

 18290   'MS-Gothic-Bold': 'MS Gothic-Bold',

 18291   'MS-Gothic-BoldItalic': 'MS Gothic-BoldItalic',

 18292   'MS-Gothic-Italic': 'MS Gothic-Italic',

 18293   'MS-Mincho': 'MS Mincho',

 18294   'MS-Mincho-Bold': 'MS Mincho-Bold',

 18295   'MS-Mincho-BoldItalic': 'MS Mincho-BoldItalic',

 18296   'MS-Mincho-Italic': 'MS Mincho-Italic',

 18297   'MS-PGothic': 'MS PGothic',

 18298   'MS-PGothic-Bold': 'MS PGothic-Bold',

 18299   'MS-PGothic-BoldItalic': 'MS PGothic-BoldItalic',

 18300   'MS-PGothic-Italic': 'MS PGothic-Italic',

 18301   'MS-PMincho': 'MS PMincho',

 18302   'MS-PMincho-Bold': 'MS PMincho-Bold',

 18303   'MS-PMincho-BoldItalic': 'MS PMincho-BoldItalic',

 18304   'MS-PMincho-Italic': 'MS PMincho-Italic'

 18305 };

 18307 var serifFonts = {

 18308   'Adobe Jenson': true, 'Adobe Text': true, 'Albertus': true,

 18309   'Aldus': true, 'Alexandria': true, 'Algerian': true,

 18310   'American Typewriter': true, 'Antiqua': true, 'Apex': true,

 18311   'Arno': true, 'Aster': true, 'Aurora': true,

 18312   'Baskerville': true, 'Bell': true, 'Bembo': true,

 18313   'Bembo Schoolbook': true, 'Benguiat': true, 'Berkeley Old Style': true,

 18314   'Bernhard Modern': true, 'Berthold City': true, 'Bodoni': true,

 18315   'Bauer Bodoni': true, 'Book Antiqua': true, 'Bookman': true,

 18316   'Bordeaux Roman': true, 'Californian FB': true, 'Calisto': true,

 18317   'Calvert': true, 'Capitals': true, 'Cambria': true,

 18318   'Cartier': true, 'Caslon': true, 'Catull': true,

 18319   'Centaur': true, 'Century Old Style': true, 'Century Schoolbook': true,

 18320   'Chaparral': true, 'Charis SIL': true, 'Cheltenham': true,

 18321   'Cholla Slab': true, 'Clarendon': true, 'Clearface': true,

 18322   'Cochin': true, 'Colonna': true, 'Computer Modern': true,

 18323   'Concrete Roman': true, 'Constantia': true, 'Cooper Black': true,

 18324   'Corona': true, 'Ecotype': true, 'Egyptienne': true,

 18325   'Elephant': true, 'Excelsior': true, 'Fairfield': true,

 18326   'FF Scala': true, 'Folkard': true, 'Footlight': true,

 18327   'FreeSerif': true, 'Friz Quadrata': true, 'Garamond': true,

 18328   'Gentium': true, 'Georgia': true, 'Gloucester': true,

 18329   'Goudy Old Style': true, 'Goudy Schoolbook': true, 'Goudy Pro Font': true,

 18330   'Granjon': true, 'Guardian Egyptian': true, 'Heather': true,

 18331   'Hercules': true, 'High Tower Text': true, 'Hiroshige': true,

 18332   'Hoefler Text': true, 'Humana Serif': true, 'Imprint': true,

 18333   'Ionic No. 5': true, 'Janson': true, 'Joanna': true,

 18334   'Korinna': true, 'Lexicon': true, 'Liberation Serif': true,

 18335   'Linux Libertine': true, 'Literaturnaya': true, 'Lucida': true,

 18336   'Lucida Bright': true, 'Melior': true, 'Memphis': true,

 18337   'Miller': true, 'Minion': true, 'Modern': true,

 18338   'Mona Lisa': true, 'Mrs Eaves': true, 'MS Serif': true,

 18339   'Museo Slab': true, 'New York': true, 'Nimbus Roman': true,

 18340   'NPS Rawlinson Roadway': true, 'Palatino': true, 'Perpetua': true,

 18341   'Plantin': true, 'Plantin Schoolbook': true, 'Playbill': true,

 18342   'Poor Richard': true, 'Rawlinson Roadway': true, 'Renault': true,

 18343   'Requiem': true, 'Rockwell': true, 'Roman': true,

 18344   'Rotis Serif': true, 'Sabon': true, 'Scala': true,

 18345   'Seagull': true, 'Sistina': true, 'Souvenir': true,

 18346   'STIX': true, 'Stone Informal': true, 'Stone Serif': true,

 18347   'Sylfaen': true, 'Times': true, 'Trajan': true,

 18348   'Trinité': true, 'Trump Mediaeval': true, 'Utopia': true,

 18349   'Vale Type': true, 'Bitstream Vera': true, 'Vera Serif': true,

 18350   'Versailles': true, 'Wanted': true, 'Weiss': true,

 18351   'Wide Latin': true, 'Windsor': true, 'XITS': true

 18352 };

 18354 var symbolsFonts = {

 18355   'Dingbats': true, 'Symbol': true, 'ZapfDingbats': true

 18356 };

 18358 // Glyph map for well-known standard fonts. Sometimes Ghostscript uses CID fonts

 18359 // but does not embed the CID to GID mapping. The mapping is incomplete for all

 18360 // glyphs, but common for some set of the standard fonts.

 18361 var GlyphMapForStandardFonts = {

 18362   '2': 10, '3': 32, '4': 33, '5': 34, '6': 35, '7': 36, '8': 37, '9': 38,

 18363   '10': 39, '11': 40, '12': 41, '13': 42, '14': 43, '15': 44, '16': 173,

 18364   '17': 46, '18': 47, '19': 48, '20': 49, '21': 50, '22': 51, '23': 52,

 18365   '24': 53, '25': 54, '26': 55, '27': 56, '28': 57, '29': 58, '30': 894,

 18366   '31': 60, '32': 61, '33': 62, '34': 63, '35': 64, '36': 65, '37': 66,

 18367   '38': 67, '39': 68, '40': 69, '41': 70, '42': 71, '43': 72, '44': 73,

 18368   '45': 74, '46': 75, '47': 76, '48': 77, '49': 78, '50': 79, '51': 80,

 18369   '52': 81, '53': 82, '54': 83, '55': 84, '56': 85, '57': 86, '58': 87,

 18370   '59': 88, '60': 89, '61': 90, '62': 91, '63': 92, '64': 93, '65': 94,

 18371   '66': 95, '67': 96, '68': 97, '69': 98, '70': 99, '71': 100, '72': 101,

 18372   '73': 102, '74': 103, '75': 104, '76': 105, '77': 106, '78': 107, '79': 108,

 18373   '80': 109, '81': 110, '82': 111, '83': 112, '84': 113, '85': 114, '86': 115,

 18374   '87': 116, '88': 117, '89': 118, '90': 119, '91': 120, '92': 121, '93': 122,

 18375   '94': 123, '95': 124, '96': 125, '97': 126, '98': 196, '99': 197, '100': 199,

 18376   '101': 201, '102': 209, '103': 214, '104': 220, '105': 225, '106': 224,

 18377   '107': 226, '108': 228, '109': 227, '110': 229, '111': 231, '112': 233,

 18378   '113': 232, '114': 234, '115': 235, '116': 237, '117': 236, '118': 238,

 18379   '119': 239, '120': 241, '121': 243, '122': 242, '123': 244, '124': 246,

 18380   '125': 245, '126': 250, '127': 249, '128': 251, '129': 252, '130': 8224,

 18381   '131': 176, '132': 162, '133': 163, '134': 167, '135': 8226, '136': 182,

 18382   '137': 223, '138': 174, '139': 169, '140': 8482, '141': 180, '142': 168,

 18383   '143': 8800, '144': 198, '145': 216, '146': 8734, '147': 177, '148': 8804,

 18384   '149': 8805, '150': 165, '151': 181, '152': 8706, '153': 8721, '154': 8719,

 18385   '156': 8747, '157': 170, '158': 186, '159': 8486, '160': 230, '161': 248,

 18386   '162': 191, '163': 161, '164': 172, '165': 8730, '166': 402, '167': 8776,

 18387   '168': 8710, '169': 171, '170': 187, '171': 8230, '210': 218, '305': 963,

 18388   '306': 964, '307': 966, '308': 8215, '309': 8252, '310': 8319, '311': 8359,

 18389   '312': 8592, '313': 8593, '337': 9552, '493': 1039, '494': 1040, '705': 1524,

 18390   '706': 8362, '710': 64288, '711': 64298, '759': 1617, '761': 1776,

 18391   '763': 1778, '775': 1652, '777': 1764, '778': 1780, '779': 1781, '780': 1782,

 18392   '782': 771, '783': 64726, '786': 8363, '788': 8532, '790': 768, '791': 769,

 18393   '792': 768, '795': 803, '797': 64336, '798': 64337, '799': 64342,

 18394   '800': 64343, '801': 64344, '802': 64345, '803': 64362, '804': 64363,

 18395   '805': 64364, '2424': 7821, '2425': 7822, '2426': 7823, '2427': 7824,

 18396   '2428': 7825, '2429': 7826, '2430': 7827, '2433': 7682, '2678': 8045,

 18397   '2679': 8046, '2830': 1552, '2838': 686, '2840': 751, '2842': 753,

 18398   '2843': 754, '2844': 755, '2846': 757, '2856': 767, '2857': 848, '2858': 849,

 18399   '2862': 853, '2863': 854, '2864': 855, '2865': 861, '2866': 862, '2906': 7460,

 18400   '2908': 7462, '2909': 7463, '2910': 7464, '2912': 7466, '2913': 7467,

 18401   '2914': 7468, '2916': 7470, '2917': 7471, '2918': 7472, '2920': 7474,

 18402   '2921': 7475, '2922': 7476, '2924': 7478, '2925': 7479, '2926': 7480,

 18403   '2928': 7482, '2929': 7483, '2930': 7484, '2932': 7486, '2933': 7487,

 18404   '2934': 7488, '2936': 7490, '2937': 7491, '2938': 7492, '2940': 7494,

 18405   '2941': 7495, '2942': 7496, '2944': 7498, '2946': 7500, '2948': 7502,

 18406   '2950': 7504, '2951': 7505, '2952': 7506, '2954': 7508, '2955': 7509,

 18407   '2956': 7510, '2958': 7512, '2959': 7513, '2960': 7514, '2962': 7516,

 18408   '2963': 7517, '2964': 7518, '2966': 7520, '2967': 7521, '2968': 7522,

 18409   '2970': 7524, '2971': 7525, '2972': 7526, '2974': 7528, '2975': 7529,

 18410   '2976': 7530, '2978': 1537, '2979': 1538, '2980': 1539, '2982': 1549,

 18411   '2983': 1551, '2984': 1552, '2986': 1554, '2987': 1555, '2988': 1556,

 18412   '2990': 1623, '2991': 1624, '2995': 1775, '2999': 1791, '3002': 64290,

 18413   '3003': 64291, '3004': 64292, '3006': 64294, '3007': 64295, '3008': 64296,

 18414   '3011': 1900, '3014': 8223, '3015': 8244, '3017': 7532, '3018': 7533,

 18415   '3019': 7534, '3075': 7590, '3076': 7591, '3079': 7594, '3080': 7595,

 18416   '3083': 7598, '3084': 7599, '3087': 7602, '3088': 7603, '3091': 7606,

 18417   '3092': 7607, '3095': 7610, '3096': 7611, '3099': 7614, '3100': 7615,

 18418   '3103': 7618, '3104': 7619, '3107': 8337, '3108': 8338, '3116': 1884,

 18419   '3119': 1885, '3120': 1885, '3123': 1886, '3124': 1886, '3127': 1887,

 18420   '3128': 1887, '3131': 1888, '3132': 1888, '3135': 1889, '3136': 1889,

 18421   '3139': 1890, '3140': 1890, '3143': 1891, '3144': 1891, '3147': 1892,

 18422   '3148': 1892, '3153': 580, '3154': 581, '3157': 584, '3158': 585, '3161': 588,

 18423   '3162': 589, '3165': 891, '3166': 892, '3169': 1274, '3170': 1275,

 18424   '3173': 1278, '3174': 1279, '3181': 7622, '3182': 7623, '3282': 11799,

 18425   '3316': 578, '3379': 42785, '3393': 1159, '3416': 8377

 18426 };

 18428 // Some characters, e.g. copyrightserif, mapped to the private use area and

 18429 // might not be displayed using standard fonts. Mapping/hacking well-known chars

 18430 // to the similar equivalents in the normal characters range.

 18431 function mapSpecialUnicodeValues(code) {

 18432   if (code >= 0xFFF0 && code <= 0xFFFF) { // Specials unicode block.

 18433     return 0;

 18434   }

 18435   switch (code) {

 18436     case 0xF8E9: // copyrightsans

 18437     case 0xF6D9: // copyrightserif

 18438       return 0x00A9; // copyright

 18440     case 0xF8E8: // registersans

 18441     case 0xF6DA: // registerserif

 18442       return 0x00AE; // registered

 18444     case 0xF8EA: // trademarksans

 18445     case 0xF6DB: // trademarkserif

 18446       return 0x2122; // trademark

 18448     default:

 18449       return code;

 18450   }

 18451 }

 18453 var UnicodeRanges = [

 18454   { 'begin': 0x0000, 'end': 0x007F }, // Basic Latin

 18455   { 'begin': 0x0080, 'end': 0x00FF }, // Latin-1 Supplement

 18456   { 'begin': 0x0100, 'end': 0x017F }, // Latin Extended-A

 18457   { 'begin': 0x0180, 'end': 0x024F }, // Latin Extended-B

 18458   { 'begin': 0x0250, 'end': 0x02AF }, // IPA Extensions

 18459   { 'begin': 0x02B0, 'end': 0x02FF }, // Spacing Modifier Letters

 18460   { 'begin': 0x0300, 'end': 0x036F }, // Combining Diacritical Marks

 18461   { 'begin': 0x0370, 'end': 0x03FF }, // Greek and Coptic

 18462   { 'begin': 0x2C80, 'end': 0x2CFF }, // Coptic

 18463   { 'begin': 0x0400, 'end': 0x04FF }, // Cyrillic

 18464   { 'begin': 0x0530, 'end': 0x058F }, // Armenian

 18465   { 'begin': 0x0590, 'end': 0x05FF }, // Hebrew

 18466   { 'begin': 0xA500, 'end': 0xA63F }, // Vai

 18467   { 'begin': 0x0600, 'end': 0x06FF }, // Arabic

 18468   { 'begin': 0x07C0, 'end': 0x07FF }, // NKo

 18469   { 'begin': 0x0900, 'end': 0x097F }, // Devanagari

 18470   { 'begin': 0x0980, 'end': 0x09FF }, // Bengali

 18471   { 'begin': 0x0A00, 'end': 0x0A7F }, // Gurmukhi

 18472   { 'begin': 0x0A80, 'end': 0x0AFF }, // Gujarati

 18473   { 'begin': 0x0B00, 'end': 0x0B7F }, // Oriya

 18474   { 'begin': 0x0B80, 'end': 0x0BFF }, // Tamil

 18475   { 'begin': 0x0C00, 'end': 0x0C7F }, // Telugu

 18476   { 'begin': 0x0C80, 'end': 0x0CFF }, // Kannada

 18477   { 'begin': 0x0D00, 'end': 0x0D7F }, // Malayalam

 18478   { 'begin': 0x0E00, 'end': 0x0E7F }, // Thai

 18479   { 'begin': 0x0E80, 'end': 0x0EFF }, // Lao

 18480   { 'begin': 0x10A0, 'end': 0x10FF }, // Georgian

 18481   { 'begin': 0x1B00, 'end': 0x1B7F }, // Balinese

 18482   { 'begin': 0x1100, 'end': 0x11FF }, // Hangul Jamo

 18483   { 'begin': 0x1E00, 'end': 0x1EFF }, // Latin Extended Additional

 18484   { 'begin': 0x1F00, 'end': 0x1FFF }, // Greek Extended

 18485   { 'begin': 0x2000, 'end': 0x206F }, // General Punctuation

 18486   { 'begin': 0x2070, 'end': 0x209F }, // Superscripts And Subscripts

 18487   { 'begin': 0x20A0, 'end': 0x20CF }, // Currency Symbol

 18488   { 'begin': 0x20D0, 'end': 0x20FF }, // Combining Diacritical Marks For Symbols

 18489   { 'begin': 0x2100, 'end': 0x214F }, // Letterlike Symbols

 18490   { 'begin': 0x2150, 'end': 0x218F }, // Number Forms

 18491   { 'begin': 0x2190, 'end': 0x21FF }, // Arrows

 18492   { 'begin': 0x2200, 'end': 0x22FF }, // Mathematical Operators

 18493   { 'begin': 0x2300, 'end': 0x23FF }, // Miscellaneous Technical

 18494   { 'begin': 0x2400, 'end': 0x243F }, // Control Pictures

 18495   { 'begin': 0x2440, 'end': 0x245F }, // Optical Character Recognition

 18496   { 'begin': 0x2460, 'end': 0x24FF }, // Enclosed Alphanumerics

 18497   { 'begin': 0x2500, 'end': 0x257F }, // Box Drawing

 18498   { 'begin': 0x2580, 'end': 0x259F }, // Block Elements

 18499   { 'begin': 0x25A0, 'end': 0x25FF }, // Geometric Shapes

 18500   { 'begin': 0x2600, 'end': 0x26FF }, // Miscellaneous Symbols

 18501   { 'begin': 0x2700, 'end': 0x27BF }, // Dingbats

 18502   { 'begin': 0x3000, 'end': 0x303F }, // CJK Symbols And Punctuation

 18503   { 'begin': 0x3040, 'end': 0x309F }, // Hiragana

 18504   { 'begin': 0x30A0, 'end': 0x30FF }, // Katakana

 18505   { 'begin': 0x3100, 'end': 0x312F }, // Bopomofo

 18506   { 'begin': 0x3130, 'end': 0x318F }, // Hangul Compatibility Jamo

 18507   { 'begin': 0xA840, 'end': 0xA87F }, // Phags-pa

 18508   { 'begin': 0x3200, 'end': 0x32FF }, // Enclosed CJK Letters And Months

 18509   { 'begin': 0x3300, 'end': 0x33FF }, // CJK Compatibility

 18510   { 'begin': 0xAC00, 'end': 0xD7AF }, // Hangul Syllables

 18511   { 'begin': 0xD800, 'end': 0xDFFF }, // Non-Plane 0 *

 18512   { 'begin': 0x10900, 'end': 0x1091F }, // Phoenicia

 18513   { 'begin': 0x4E00, 'end': 0x9FFF }, // CJK Unified Ideographs

 18514   { 'begin': 0xE000, 'end': 0xF8FF }, // Private Use Area (plane 0)

 18515   { 'begin': 0x31C0, 'end': 0x31EF }, // CJK Strokes

 18516   { 'begin': 0xFB00, 'end': 0xFB4F }, // Alphabetic Presentation Forms

 18517   { 'begin': 0xFB50, 'end': 0xFDFF }, // Arabic Presentation Forms-A

 18518   { 'begin': 0xFE20, 'end': 0xFE2F }, // Combining Half Marks

 18519   { 'begin': 0xFE10, 'end': 0xFE1F }, // Vertical Forms

 18520   { 'begin': 0xFE50, 'end': 0xFE6F }, // Small Form Variants

 18521   { 'begin': 0xFE70, 'end': 0xFEFF }, // Arabic Presentation Forms-B

 18522   { 'begin': 0xFF00, 'end': 0xFFEF }, // Halfwidth And Fullwidth Forms

 18523   { 'begin': 0xFFF0, 'end': 0xFFFF }, // Specials

 18524   { 'begin': 0x0F00, 'end': 0x0FFF }, // Tibetan

 18525   { 'begin': 0x0700, 'end': 0x074F }, // Syriac

 18526   { 'begin': 0x0780, 'end': 0x07BF }, // Thaana

 18527   { 'begin': 0x0D80, 'end': 0x0DFF }, // Sinhala

 18528   { 'begin': 0x1000, 'end': 0x109F }, // Myanmar

 18529   { 'begin': 0x1200, 'end': 0x137F }, // Ethiopic

 18530   { 'begin': 0x13A0, 'end': 0x13FF }, // Cherokee

 18531   { 'begin': 0x1400, 'end': 0x167F }, // Unified Canadian Aboriginal Syllabics

 18532   { 'begin': 0x1680, 'end': 0x169F }, // Ogham

 18533   { 'begin': 0x16A0, 'end': 0x16FF }, // Runic

 18534   { 'begin': 0x1780, 'end': 0x17FF }, // Khmer

 18535   { 'begin': 0x1800, 'end': 0x18AF }, // Mongolian

 18536   { 'begin': 0x2800, 'end': 0x28FF }, // Braille Patterns

 18537   { 'begin': 0xA000, 'end': 0xA48F }, // Yi Syllables

 18538   { 'begin': 0x1700, 'end': 0x171F }, // Tagalog

 18539   { 'begin': 0x10300, 'end': 0x1032F }, // Old Italic

 18540   { 'begin': 0x10330, 'end': 0x1034F }, // Gothic

 18541   { 'begin': 0x10400, 'end': 0x1044F }, // Deseret

 18542   { 'begin': 0x1D000, 'end': 0x1D0FF }, // Byzantine Musical Symbols

 18543   { 'begin': 0x1D400, 'end': 0x1D7FF }, // Mathematical Alphanumeric Symbols

 18544   { 'begin': 0xFF000, 'end': 0xFFFFD }, // Private Use (plane 15)

 18545   { 'begin': 0xFE00, 'end': 0xFE0F }, // Variation Selectors

 18546   { 'begin': 0xE0000, 'end': 0xE007F }, // Tags

 18547   { 'begin': 0x1900, 'end': 0x194F }, // Limbu

 18548   { 'begin': 0x1950, 'end': 0x197F }, // Tai Le

 18549   { 'begin': 0x1980, 'end': 0x19DF }, // New Tai Lue

 18550   { 'begin': 0x1A00, 'end': 0x1A1F }, // Buginese

 18551   { 'begin': 0x2C00, 'end': 0x2C5F }, // Glagolitic

 18552   { 'begin': 0x2D30, 'end': 0x2D7F }, // Tifinagh

 18553   { 'begin': 0x4DC0, 'end': 0x4DFF }, // Yijing Hexagram Symbols

 18554   { 'begin': 0xA800, 'end': 0xA82F }, // Syloti Nagri

 18555   { 'begin': 0x10000, 'end': 0x1007F }, // Linear B Syllabary

 18556   { 'begin': 0x10140, 'end': 0x1018F }, // Ancient Greek Numbers

 18557   { 'begin': 0x10380, 'end': 0x1039F }, // Ugaritic

 18558   { 'begin': 0x103A0, 'end': 0x103DF }, // Old Persian

 18559   { 'begin': 0x10450, 'end': 0x1047F }, // Shavian

 18560   { 'begin': 0x10480, 'end': 0x104AF }, // Osmanya

 18561   { 'begin': 0x10800, 'end': 0x1083F }, // Cypriot Syllabary

 18562   { 'begin': 0x10A00, 'end': 0x10A5F }, // Kharoshthi

 18563   { 'begin': 0x1D300, 'end': 0x1D35F }, // Tai Xuan Jing Symbols

 18564   { 'begin': 0x12000, 'end': 0x123FF }, // Cuneiform

 18565   { 'begin': 0x1D360, 'end': 0x1D37F }, // Counting Rod Numerals

 18566   { 'begin': 0x1B80, 'end': 0x1BBF }, // Sundanese

 18567   { 'begin': 0x1C00, 'end': 0x1C4F }, // Lepcha

 18568   { 'begin': 0x1C50, 'end': 0x1C7F }, // Ol Chiki

 18569   { 'begin': 0xA880, 'end': 0xA8DF }, // Saurashtra

 18570   { 'begin': 0xA900, 'end': 0xA92F }, // Kayah Li

 18571   { 'begin': 0xA930, 'end': 0xA95F }, // Rejang

 18572   { 'begin': 0xAA00, 'end': 0xAA5F }, // Cham

 18573   { 'begin': 0x10190, 'end': 0x101CF }, // Ancient Symbols

 18574   { 'begin': 0x101D0, 'end': 0x101FF }, // Phaistos Disc

 18575   { 'begin': 0x102A0, 'end': 0x102DF }, // Carian

 18576   { 'begin': 0x1F030, 'end': 0x1F09F }  // Domino Tiles

 18577 ];

 18579 var MacStandardGlyphOrdering = [

 18580   '.notdef', '.null', 'nonmarkingreturn', 'space', 'exclam', 'quotedbl',

 18581   'numbersign', 'dollar', 'percent', 'ampersand', 'quotesingle', 'parenleft',

 18582   'parenright', 'asterisk', 'plus', 'comma', 'hyphen', 'period', 'slash',

 18583   'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',

 18584   'nine', 'colon', 'semicolon', 'less', 'equal', 'greater', 'question', 'at',

 18585   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',

 18586   'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'bracketleft',

 18587   'backslash', 'bracketright', 'asciicircum', 'underscore', 'grave', 'a', 'b',

 18588   'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q',

 18589   'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'braceleft', 'bar', 'braceright',

 18590   'asciitilde', 'Adieresis', 'Aring', 'Ccedilla', 'Eacute', 'Ntilde',

 18591   'Odieresis', 'Udieresis', 'aacute', 'agrave', 'acircumflex', 'adieresis',

 18592   'atilde', 'aring', 'ccedilla', 'eacute', 'egrave', 'ecircumflex', 'edieresis',

 18593   'iacute', 'igrave', 'icircumflex', 'idieresis', 'ntilde', 'oacute', 'ograve',

 18594   'ocircumflex', 'odieresis', 'otilde', 'uacute', 'ugrave', 'ucircumflex',

 18595   'udieresis', 'dagger', 'degree', 'cent', 'sterling', 'section', 'bullet',

 18596   'paragraph', 'germandbls', 'registered', 'copyright', 'trademark', 'acute',

 18597   'dieresis', 'notequal', 'AE', 'Oslash', 'infinity', 'plusminus', 'lessequal',

 18598   'greaterequal', 'yen', 'mu', 'partialdiff', 'summation', 'product', 'pi',

 18599   'integral', 'ordfeminine', 'ordmasculine', 'Omega', 'ae', 'oslash',

 18600   'questiondown', 'exclamdown', 'logicalnot', 'radical', 'florin',

 18601   'approxequal', 'Delta', 'guillemotleft', 'guillemotright', 'ellipsis',

 18602   'nonbreakingspace', 'Agrave', 'Atilde', 'Otilde', 'OE', 'oe', 'endash',

 18603   'emdash', 'quotedblleft', 'quotedblright', 'quoteleft', 'quoteright',

 18604   'divide', 'lozenge', 'ydieresis', 'Ydieresis', 'fraction', 'currency',

 18605   'guilsinglleft', 'guilsinglright', 'fi', 'fl', 'daggerdbl', 'periodcentered',

 18606   'quotesinglbase', 'quotedblbase', 'perthousand', 'Acircumflex',

 18607   'Ecircumflex', 'Aacute', 'Edieresis', 'Egrave', 'Iacute', 'Icircumflex',

 18608   'Idieresis', 'Igrave', 'Oacute', 'Ocircumflex', 'apple', 'Ograve', 'Uacute',

 18609   'Ucircumflex', 'Ugrave', 'dotlessi', 'circumflex', 'tilde', 'macron',

 18610   'breve', 'dotaccent', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron',

 18611   'Lslash', 'lslash', 'Scaron', 'scaron', 'Zcaron', 'zcaron', 'brokenbar',

 18612   'Eth', 'eth', 'Yacute', 'yacute', 'Thorn', 'thorn', 'minus', 'multiply',

 18613   'onesuperior', 'twosuperior', 'threesuperior', 'onehalf', 'onequarter',

 18614   'threequarters', 'franc', 'Gbreve', 'gbreve', 'Idotaccent', 'Scedilla',

 18615   'scedilla', 'Cacute', 'cacute', 'Ccaron', 'ccaron', 'dcroat'];

 18617 function getUnicodeRangeFor(value) {

 18618   for (var i = 0, ii = UnicodeRanges.length; i < ii; i++) {

 18619     var range = UnicodeRanges[i];

 18620     if (value >= range.begin && value < range.end) {

 18621       return i;

 18622     }

 18623   }

 18624   return -1;

 18625 }

 18627 function isRTLRangeFor(value) {

 18628   var range = UnicodeRanges[13];

 18629   if (value >= range.begin && value < range.end) {

 18630     return true;

 18631   }

 18632   range = UnicodeRanges[11];

 18633   if (value >= range.begin && value < range.end) {

 18634     return true;

 18635   }

 18636   return false;

 18637 }

 18639 // The normalization table is obtained by filtering the Unicode characters

 18640 // database with <compat> entries.

 18641 var NormalizedUnicodes = {

 18642   '\u00A8': '\u0020\u0308',

 18643   '\u00AF': '\u0020\u0304',

 18644   '\u00B4': '\u0020\u0301',

 18645   '\u00B5': '\u03BC',

 18646   '\u00B8': '\u0020\u0327',

 18647   '\u0132': '\u0049\u004A',

 18648   '\u0133': '\u0069\u006A',

 18649   '\u013F': '\u004C\u00B7',

 18650   '\u0140': '\u006C\u00B7',

 18651   '\u0149': '\u02BC\u006E',

 18652   '\u017F': '\u0073',

 18653   '\u01C4': '\u0044\u017D',

 18654   '\u01C5': '\u0044\u017E',

 18655   '\u01C6': '\u0064\u017E',

 18656   '\u01C7': '\u004C\u004A',

 18657   '\u01C8': '\u004C\u006A',

 18658   '\u01C9': '\u006C\u006A',

 18659   '\u01CA': '\u004E\u004A',

 18660   '\u01CB': '\u004E\u006A',

 18661   '\u01CC': '\u006E\u006A',

 18662   '\u01F1': '\u0044\u005A',

 18663   '\u01F2': '\u0044\u007A',

 18664   '\u01F3': '\u0064\u007A',

 18665   '\u02D8': '\u0020\u0306',

 18666   '\u02D9': '\u0020\u0307',

 18667   '\u02DA': '\u0020\u030A',

 18668   '\u02DB': '\u0020\u0328',

 18669   '\u02DC': '\u0020\u0303',

 18670   '\u02DD': '\u0020\u030B',

 18671   '\u037A': '\u0020\u0345',

 18672   '\u0384': '\u0020\u0301',

 18673   '\u03D0': '\u03B2',

 18674   '\u03D1': '\u03B8',

 18675   '\u03D2': '\u03A5',

 18676   '\u03D5': '\u03C6',

 18677   '\u03D6': '\u03C0',

 18678   '\u03F0': '\u03BA',

 18679   '\u03F1': '\u03C1',

 18680   '\u03F2': '\u03C2',

 18681   '\u03F4': '\u0398',

 18682   '\u03F5': '\u03B5',

 18683   '\u03F9': '\u03A3',

 18684   '\u0587': '\u0565\u0582',

 18685   '\u0675': '\u0627\u0674',

 18686   '\u0676': '\u0648\u0674',

 18687   '\u0677': '\u06C7\u0674',

 18688   '\u0678': '\u064A\u0674',

 18689   '\u0E33': '\u0E4D\u0E32',

 18690   '\u0EB3': '\u0ECD\u0EB2',

 18691   '\u0EDC': '\u0EAB\u0E99',

 18692   '\u0EDD': '\u0EAB\u0EA1',

 18693   '\u0F77': '\u0FB2\u0F81',

 18694   '\u0F79': '\u0FB3\u0F81',

 18695   '\u1E9A': '\u0061\u02BE',

 18696   '\u1FBD': '\u0020\u0313',

 18697   '\u1FBF': '\u0020\u0313',

 18698   '\u1FC0': '\u0020\u0342',

 18699   '\u1FFE': '\u0020\u0314',

 18700   '\u2002': '\u0020',

 18701   '\u2003': '\u0020',

 18702   '\u2004': '\u0020',

 18703   '\u2005': '\u0020',

 18704   '\u2006': '\u0020',

 18705   '\u2008': '\u0020',

 18706   '\u2009': '\u0020',

 18707   '\u200A': '\u0020',

 18708   '\u2017': '\u0020\u0333',

 18709   '\u2024': '\u002E',

 18710   '\u2025': '\u002E\u002E',

 18711   '\u2026': '\u002E\u002E\u002E',

 18712   '\u2033': '\u2032\u2032',

 18713   '\u2034': '\u2032\u2032\u2032',

 18714   '\u2036': '\u2035\u2035',

 18715   '\u2037': '\u2035\u2035\u2035',

 18716   '\u203C': '\u0021\u0021',

 18717   '\u203E': '\u0020\u0305',

 18718   '\u2047': '\u003F\u003F',

 18719   '\u2048': '\u003F\u0021',

 18720   '\u2049': '\u0021\u003F',

 18721   '\u2057': '\u2032\u2032\u2032\u2032',

 18722   '\u205F': '\u0020',

 18723   '\u20A8': '\u0052\u0073',

 18724   '\u2100': '\u0061\u002F\u0063',

 18725   '\u2101': '\u0061\u002F\u0073',

 18726   '\u2103': '\u00B0\u0043',

 18727   '\u2105': '\u0063\u002F\u006F',

 18728   '\u2106': '\u0063\u002F\u0075',

 18729   '\u2107': '\u0190',

 18730   '\u2109': '\u00B0\u0046',

 18731   '\u2116': '\u004E\u006F',

 18732   '\u2121': '\u0054\u0045\u004C',

 18733   '\u2135': '\u05D0',

 18734   '\u2136': '\u05D1',

 18735   '\u2137': '\u05D2',

 18736   '\u2138': '\u05D3',

 18737   '\u213B': '\u0046\u0041\u0058',

 18738   '\u2160': '\u0049',

 18739   '\u2161': '\u0049\u0049',

 18740   '\u2162': '\u0049\u0049\u0049',

 18741   '\u2163': '\u0049\u0056',

 18742   '\u2164': '\u0056',

 18743   '\u2165': '\u0056\u0049',

 18744   '\u2166': '\u0056\u0049\u0049',

 18745   '\u2167': '\u0056\u0049\u0049\u0049',

 18746   '\u2168': '\u0049\u0058',

 18747   '\u2169': '\u0058',

 18748   '\u216A': '\u0058\u0049',

 18749   '\u216B': '\u0058\u0049\u0049',

 18750   '\u216C': '\u004C',

 18751   '\u216D': '\u0043',

 18752   '\u216E': '\u0044',

 18753   '\u216F': '\u004D',

 18754   '\u2170': '\u0069',

 18755   '\u2171': '\u0069\u0069',

 18756   '\u2172': '\u0069\u0069\u0069',

 18757   '\u2173': '\u0069\u0076',

 18758   '\u2174': '\u0076',

 18759   '\u2175': '\u0076\u0069',

 18760   '\u2176': '\u0076\u0069\u0069',

 18761   '\u2177': '\u0076\u0069\u0069\u0069',

 18762   '\u2178': '\u0069\u0078',

 18763   '\u2179': '\u0078',

 18764   '\u217A': '\u0078\u0069',

 18765   '\u217B': '\u0078\u0069\u0069',

 18766   '\u217C': '\u006C',

 18767   '\u217D': '\u0063',

 18768   '\u217E': '\u0064',

 18769   '\u217F': '\u006D',

 18770   '\u222C': '\u222B\u222B',

 18771   '\u222D': '\u222B\u222B\u222B',

 18772   '\u222F': '\u222E\u222E',

 18773   '\u2230': '\u222E\u222E\u222E',

 18774   '\u2474': '\u0028\u0031\u0029',

 18775   '\u2475': '\u0028\u0032\u0029',

 18776   '\u2476': '\u0028\u0033\u0029',

 18777   '\u2477': '\u0028\u0034\u0029',

 18778   '\u2478': '\u0028\u0035\u0029',

 18779   '\u2479': '\u0028\u0036\u0029',

 18780   '\u247A': '\u0028\u0037\u0029',

 18781   '\u247B': '\u0028\u0038\u0029',

 18782   '\u247C': '\u0028\u0039\u0029',

 18783   '\u247D': '\u0028\u0031\u0030\u0029',

 18784   '\u247E': '\u0028\u0031\u0031\u0029',

 18785   '\u247F': '\u0028\u0031\u0032\u0029',

 18786   '\u2480': '\u0028\u0031\u0033\u0029',

 18787   '\u2481': '\u0028\u0031\u0034\u0029',

 18788   '\u2482': '\u0028\u0031\u0035\u0029',

 18789   '\u2483': '\u0028\u0031\u0036\u0029',

 18790   '\u2484': '\u0028\u0031\u0037\u0029',

 18791   '\u2485': '\u0028\u0031\u0038\u0029',

 18792   '\u2486': '\u0028\u0031\u0039\u0029',

 18793   '\u2487': '\u0028\u0032\u0030\u0029',

 18794   '\u2488': '\u0031\u002E',

 18795   '\u2489': '\u0032\u002E',

 18796   '\u248A': '\u0033\u002E',

 18797   '\u248B': '\u0034\u002E',

 18798   '\u248C': '\u0035\u002E',

 18799   '\u248D': '\u0036\u002E',

 18800   '\u248E': '\u0037\u002E',

 18801   '\u248F': '\u0038\u002E',

 18802   '\u2490': '\u0039\u002E',

 18803   '\u2491': '\u0031\u0030\u002E',

 18804   '\u2492': '\u0031\u0031\u002E',

 18805   '\u2493': '\u0031\u0032\u002E',

 18806   '\u2494': '\u0031\u0033\u002E',

 18807   '\u2495': '\u0031\u0034\u002E',

 18808   '\u2496': '\u0031\u0035\u002E',

 18809   '\u2497': '\u0031\u0036\u002E',

 18810   '\u2498': '\u0031\u0037\u002E',

 18811   '\u2499': '\u0031\u0038\u002E',

 18812   '\u249A': '\u0031\u0039\u002E',

 18813   '\u249B': '\u0032\u0030\u002E',

 18814   '\u249C': '\u0028\u0061\u0029',

 18815   '\u249D': '\u0028\u0062\u0029',

 18816   '\u249E': '\u0028\u0063\u0029',

 18817   '\u249F': '\u0028\u0064\u0029',

 18818   '\u24A0': '\u0028\u0065\u0029',

 18819   '\u24A1': '\u0028\u0066\u0029',

 18820   '\u24A2': '\u0028\u0067\u0029',

 18821   '\u24A3': '\u0028\u0068\u0029',

 18822   '\u24A4': '\u0028\u0069\u0029',

 18823   '\u24A5': '\u0028\u006A\u0029',

 18824   '\u24A6': '\u0028\u006B\u0029',

 18825   '\u24A7': '\u0028\u006C\u0029',

 18826   '\u24A8': '\u0028\u006D\u0029',

 18827   '\u24A9': '\u0028\u006E\u0029',

 18828   '\u24AA': '\u0028\u006F\u0029',

 18829   '\u24AB': '\u0028\u0070\u0029',

 18830   '\u24AC': '\u0028\u0071\u0029',

 18831   '\u24AD': '\u0028\u0072\u0029',

 18832   '\u24AE': '\u0028\u0073\u0029',

 18833   '\u24AF': '\u0028\u0074\u0029',

 18834   '\u24B0': '\u0028\u0075\u0029',

 18835   '\u24B1': '\u0028\u0076\u0029',

 18836   '\u24B2': '\u0028\u0077\u0029',

 18837   '\u24B3': '\u0028\u0078\u0029',

 18838   '\u24B4': '\u0028\u0079\u0029',

 18839   '\u24B5': '\u0028\u007A\u0029',

 18840   '\u2A0C': '\u222B\u222B\u222B\u222B',

 18841   '\u2A74': '\u003A\u003A\u003D',

 18842   '\u2A75': '\u003D\u003D',

 18843   '\u2A76': '\u003D\u003D\u003D',

 18844   '\u2E9F': '\u6BCD',

 18845   '\u2EF3': '\u9F9F',

 18846   '\u2F00': '\u4E00',

 18847   '\u2F01': '\u4E28',

 18848   '\u2F02': '\u4E36',

 18849   '\u2F03': '\u4E3F',

 18850   '\u2F04': '\u4E59',

 18851   '\u2F05': '\u4E85',

 18852   '\u2F06': '\u4E8C',

 18853   '\u2F07': '\u4EA0',

 18854   '\u2F08': '\u4EBA',

 18855   '\u2F09': '\u513F',

 18856   '\u2F0A': '\u5165',

 18857   '\u2F0B': '\u516B',

 18858   '\u2F0C': '\u5182',

 18859   '\u2F0D': '\u5196',

 18860   '\u2F0E': '\u51AB',

 18861   '\u2F0F': '\u51E0',

 18862   '\u2F10': '\u51F5',

 18863   '\u2F11': '\u5200',

 18864   '\u2F12': '\u529B',

 18865   '\u2F13': '\u52F9',

 18866   '\u2F14': '\u5315',

 18867   '\u2F15': '\u531A',

 18868   '\u2F16': '\u5338',

 18869   '\u2F17': '\u5341',

 18870   '\u2F18': '\u535C',

 18871   '\u2F19': '\u5369',

 18872   '\u2F1A': '\u5382',

 18873   '\u2F1B': '\u53B6',

 18874   '\u2F1C': '\u53C8',

 18875   '\u2F1D': '\u53E3',

 18876   '\u2F1E': '\u56D7',

 18877   '\u2F1F': '\u571F',

 18878   '\u2F20': '\u58EB',

 18879   '\u2F21': '\u5902',

 18880   '\u2F22': '\u590A',

 18881   '\u2F23': '\u5915',

 18882   '\u2F24': '\u5927',

 18883   '\u2F25': '\u5973',

 18884   '\u2F26': '\u5B50',

 18885   '\u2F27': '\u5B80',

 18886   '\u2F28': '\u5BF8',

 18887   '\u2F29': '\u5C0F',

 18888   '\u2F2A': '\u5C22',

 18889   '\u2F2B': '\u5C38',

 18890   '\u2F2C': '\u5C6E',

 18891   '\u2F2D': '\u5C71',

 18892   '\u2F2E': '\u5DDB',

 18893   '\u2F2F': '\u5DE5',

 18894   '\u2F30': '\u5DF1',

 18895   '\u2F31': '\u5DFE',

 18896   '\u2F32': '\u5E72',

 18897   '\u2F33': '\u5E7A',

 18898   '\u2F34': '\u5E7F',

 18899   '\u2F35': '\u5EF4',

 18900   '\u2F36': '\u5EFE',

 18901   '\u2F37': '\u5F0B',

 18902   '\u2F38': '\u5F13',

 18903   '\u2F39': '\u5F50',

 18904   '\u2F3A': '\u5F61',

 18905   '\u2F3B': '\u5F73',

 18906   '\u2F3C': '\u5FC3',

 18907   '\u2F3D': '\u6208',

 18908   '\u2F3E': '\u6236',

 18909   '\u2F3F': '\u624B',

 18910   '\u2F40': '\u652F',

 18911   '\u2F41': '\u6534',

 18912   '\u2F42': '\u6587',

 18913   '\u2F43': '\u6597',

 18914   '\u2F44': '\u65A4',

 18915   '\u2F45': '\u65B9',

 18916   '\u2F46': '\u65E0',

 18917   '\u2F47': '\u65E5',

 18918   '\u2F48': '\u66F0',

 18919   '\u2F49': '\u6708',

 18920   '\u2F4A': '\u6728',

 18921   '\u2F4B': '\u6B20',

 18922   '\u2F4C': '\u6B62',

 18923   '\u2F4D': '\u6B79',

 18924   '\u2F4E': '\u6BB3',

 18925   '\u2F4F': '\u6BCB',

 18926   '\u2F50': '\u6BD4',

 18927   '\u2F51': '\u6BDB',

 18928   '\u2F52': '\u6C0F',

 18929   '\u2F53': '\u6C14',

 18930   '\u2F54': '\u6C34',

 18931   '\u2F55': '\u706B',

 18932   '\u2F56': '\u722A',

 18933   '\u2F57': '\u7236',

 18934   '\u2F58': '\u723B',

 18935   '\u2F59': '\u723F',

 18936   '\u2F5A': '\u7247',

 18937   '\u2F5B': '\u7259',

 18938   '\u2F5C': '\u725B',

 18939   '\u2F5D': '\u72AC',

 18940   '\u2F5E': '\u7384',

 18941   '\u2F5F': '\u7389',

 18942   '\u2F60': '\u74DC',

 18943   '\u2F61': '\u74E6',

 18944   '\u2F62': '\u7518',

 18945   '\u2F63': '\u751F',

 18946   '\u2F64': '\u7528',

 18947   '\u2F65': '\u7530',

 18948   '\u2F66': '\u758B',

 18949   '\u2F67': '\u7592',

 18950   '\u2F68': '\u7676',

 18951   '\u2F69': '\u767D',

 18952   '\u2F6A': '\u76AE',

 18953   '\u2F6B': '\u76BF',

 18954   '\u2F6C': '\u76EE',

 18955   '\u2F6D': '\u77DB',

 18956   '\u2F6E': '\u77E2',

 18957   '\u2F6F': '\u77F3',

 18958   '\u2F70': '\u793A',

 18959   '\u2F71': '\u79B8',

 18960   '\u2F72': '\u79BE',

 18961   '\u2F73': '\u7A74',

 18962   '\u2F74': '\u7ACB',

 18963   '\u2F75': '\u7AF9',

 18964   '\u2F76': '\u7C73',

 18965   '\u2F77': '\u7CF8',

 18966   '\u2F78': '\u7F36',

 18967   '\u2F79': '\u7F51',

 18968   '\u2F7A': '\u7F8A',

 18969   '\u2F7B': '\u7FBD',

 18970   '\u2F7C': '\u8001',

 18971   '\u2F7D': '\u800C',

 18972   '\u2F7E': '\u8012',

 18973   '\u2F7F': '\u8033',

 18974   '\u2F80': '\u807F',

 18975   '\u2F81': '\u8089',

 18976   '\u2F82': '\u81E3',

 18977   '\u2F83': '\u81EA',

 18978   '\u2F84': '\u81F3',

 18979   '\u2F85': '\u81FC',

 18980   '\u2F86': '\u820C',

 18981   '\u2F87': '\u821B',

 18982   '\u2F88': '\u821F',

 18983   '\u2F89': '\u826E',

 18984   '\u2F8A': '\u8272',

 18985   '\u2F8B': '\u8278',

 18986   '\u2F8C': '\u864D',

 18987   '\u2F8D': '\u866B',

 18988   '\u2F8E': '\u8840',

 18989   '\u2F8F': '\u884C',

 18990   '\u2F90': '\u8863',

 18991   '\u2F91': '\u897E',

 18992   '\u2F92': '\u898B',

 18993   '\u2F93': '\u89D2',

 18994   '\u2F94': '\u8A00',

 18995   '\u2F95': '\u8C37',

 18996   '\u2F96': '\u8C46',

 18997   '\u2F97': '\u8C55',

 18998   '\u2F98': '\u8C78',

 18999   '\u2F99': '\u8C9D',

 19000   '\u2F9A': '\u8D64',

 19001   '\u2F9B': '\u8D70',

 19002   '\u2F9C': '\u8DB3',

 19003   '\u2F9D': '\u8EAB',

 19004   '\u2F9E': '\u8ECA',

 19005   '\u2F9F': '\u8F9B',

 19006   '\u2FA0': '\u8FB0',

 19007   '\u2FA1': '\u8FB5',

 19008   '\u2FA2': '\u9091',

 19009   '\u2FA3': '\u9149',

 19010   '\u2FA4': '\u91C6',

 19011   '\u2FA5': '\u91CC',

 19012   '\u2FA6': '\u91D1',

 19013   '\u2FA7': '\u9577',

 19014   '\u2FA8': '\u9580',

 19015   '\u2FA9': '\u961C',

 19016   '\u2FAA': '\u96B6',

 19017   '\u2FAB': '\u96B9',

 19018   '\u2FAC': '\u96E8',

 19019   '\u2FAD': '\u9751',

 19020   '\u2FAE': '\u975E',

 19021   '\u2FAF': '\u9762',

 19022   '\u2FB0': '\u9769',

 19023   '\u2FB1': '\u97CB',

 19024   '\u2FB2': '\u97ED',

 19025   '\u2FB3': '\u97F3',

 19026   '\u2FB4': '\u9801',

 19027   '\u2FB5': '\u98A8',

 19028   '\u2FB6': '\u98DB',

 19029   '\u2FB7': '\u98DF',

 19030   '\u2FB8': '\u9996',

 19031   '\u2FB9': '\u9999',

 19032   '\u2FBA': '\u99AC',

 19033   '\u2FBB': '\u9AA8',

 19034   '\u2FBC': '\u9AD8',

 19035   '\u2FBD': '\u9ADF',

 19036   '\u2FBE': '\u9B25',

 19037   '\u2FBF': '\u9B2F',

 19038   '\u2FC0': '\u9B32',

 19039   '\u2FC1': '\u9B3C',

 19040   '\u2FC2': '\u9B5A',

 19041   '\u2FC3': '\u9CE5',

 19042   '\u2FC4': '\u9E75',

 19043   '\u2FC5': '\u9E7F',

 19044   '\u2FC6': '\u9EA5',

 19045   '\u2FC7': '\u9EBB',

 19046   '\u2FC8': '\u9EC3',

 19047   '\u2FC9': '\u9ECD',

 19048   '\u2FCA': '\u9ED1',

 19049   '\u2FCB': '\u9EF9',

 19050   '\u2FCC': '\u9EFD',

 19051   '\u2FCD': '\u9F0E',

 19052   '\u2FCE': '\u9F13',

 19053   '\u2FCF': '\u9F20',

 19054   '\u2FD0': '\u9F3B',

 19055   '\u2FD1': '\u9F4A',

 19056   '\u2FD2': '\u9F52',

 19057   '\u2FD3': '\u9F8D',

 19058   '\u2FD4': '\u9F9C',

 19059   '\u2FD5': '\u9FA0',

 19060   '\u3036': '\u3012',

 19061   '\u3038': '\u5341',

 19062   '\u3039': '\u5344',

 19063   '\u303A': '\u5345',

 19064   '\u309B': '\u0020\u3099',

 19065   '\u309C': '\u0020\u309A',

 19066   '\u3131': '\u1100',

 19067   '\u3132': '\u1101',

 19068   '\u3133': '\u11AA',

 19069   '\u3134': '\u1102',

 19070   '\u3135': '\u11AC',

 19071   '\u3136': '\u11AD',

 19072   '\u3137': '\u1103',

 19073   '\u3138': '\u1104',

 19074   '\u3139': '\u1105',

 19075   '\u313A': '\u11B0',

 19076   '\u313B': '\u11B1',

 19077   '\u313C': '\u11B2',

 19078   '\u313D': '\u11B3',

 19079   '\u313E': '\u11B4',

 19080   '\u313F': '\u11B5',

 19081   '\u3140': '\u111A',

 19082   '\u3141': '\u1106',

 19083   '\u3142': '\u1107',

 19084   '\u3143': '\u1108',

 19085   '\u3144': '\u1121',

 19086   '\u3145': '\u1109',

 19087   '\u3146': '\u110A',

 19088   '\u3147': '\u110B',

 19089   '\u3148': '\u110C',

 19090   '\u3149': '\u110D',

 19091   '\u314A': '\u110E',

 19092   '\u314B': '\u110F',

 19093   '\u314C': '\u1110',

 19094   '\u314D': '\u1111',

 19095   '\u314E': '\u1112',

 19096   '\u314F': '\u1161',

 19097   '\u3150': '\u1162',

 19098   '\u3151': '\u1163',

 19099   '\u3152': '\u1164',

 19100   '\u3153': '\u1165',

 19101   '\u3154': '\u1166',

 19102   '\u3155': '\u1167',

 19103   '\u3156': '\u1168',

 19104   '\u3157': '\u1169',

 19105   '\u3158': '\u116A',

 19106   '\u3159': '\u116B',

 19107   '\u315A': '\u116C',

 19108   '\u315B': '\u116D',

 19109   '\u315C': '\u116E',

 19110   '\u315D': '\u116F',

 19111   '\u315E': '\u1170',

 19112   '\u315F': '\u1171',

 19113   '\u3160': '\u1172',

 19114   '\u3161': '\u1173',

 19115   '\u3162': '\u1174',

 19116   '\u3163': '\u1175',

 19117   '\u3164': '\u1160',

 19118   '\u3165': '\u1114',

 19119   '\u3166': '\u1115',

 19120   '\u3167': '\u11C7',

 19121   '\u3168': '\u11C8',

 19122   '\u3169': '\u11CC',

 19123   '\u316A': '\u11CE',

 19124   '\u316B': '\u11D3',

 19125   '\u316C': '\u11D7',

 19126   '\u316D': '\u11D9',

 19127   '\u316E': '\u111C',

 19128   '\u316F': '\u11DD',

 19129   '\u3170': '\u11DF',

 19130   '\u3171': '\u111D',

 19131   '\u3172': '\u111E',

 19132   '\u3173': '\u1120',

 19133   '\u3174': '\u1122',

 19134   '\u3175': '\u1123',

 19135   '\u3176': '\u1127',

 19136   '\u3177': '\u1129',

 19137   '\u3178': '\u112B',

 19138   '\u3179': '\u112C',

 19139   '\u317A': '\u112D',

 19140   '\u317B': '\u112E',

 19141   '\u317C': '\u112F',

 19142   '\u317D': '\u1132',

 19143   '\u317E': '\u1136',

 19144   '\u317F': '\u1140',

 19145   '\u3180': '\u1147',

 19146   '\u3181': '\u114C',

 19147   '\u3182': '\u11F1',

 19148   '\u3183': '\u11F2',

 19149   '\u3184': '\u1157',

 19150   '\u3185': '\u1158',

 19151   '\u3186': '\u1159',

 19152   '\u3187': '\u1184',

 19153   '\u3188': '\u1185',

 19154   '\u3189': '\u1188',

 19155   '\u318A': '\u1191',

 19156   '\u318B': '\u1192',

 19157   '\u318C': '\u1194',

 19158   '\u318D': '\u119E',

 19159   '\u318E': '\u11A1',

 19160   '\u3200': '\u0028\u1100\u0029',

 19161   '\u3201': '\u0028\u1102\u0029',

 19162   '\u3202': '\u0028\u1103\u0029',

 19163   '\u3203': '\u0028\u1105\u0029',

 19164   '\u3204': '\u0028\u1106\u0029',

 19165   '\u3205': '\u0028\u1107\u0029',

 19166   '\u3206': '\u0028\u1109\u0029',

 19167   '\u3207': '\u0028\u110B\u0029',

 19168   '\u3208': '\u0028\u110C\u0029',

 19169   '\u3209': '\u0028\u110E\u0029',

 19170   '\u320A': '\u0028\u110F\u0029',

 19171   '\u320B': '\u0028\u1110\u0029',

 19172   '\u320C': '\u0028\u1111\u0029',

 19173   '\u320D': '\u0028\u1112\u0029',

 19174   '\u320E': '\u0028\u1100\u1161\u0029',

 19175   '\u320F': '\u0028\u1102\u1161\u0029',

 19176   '\u3210': '\u0028\u1103\u1161\u0029',

 19177   '\u3211': '\u0028\u1105\u1161\u0029',

 19178   '\u3212': '\u0028\u1106\u1161\u0029',

 19179   '\u3213': '\u0028\u1107\u1161\u0029',

 19180   '\u3214': '\u0028\u1109\u1161\u0029',

 19181   '\u3215': '\u0028\u110B\u1161\u0029',

 19182   '\u3216': '\u0028\u110C\u1161\u0029',

 19183   '\u3217': '\u0028\u110E\u1161\u0029',

 19184   '\u3218': '\u0028\u110F\u1161\u0029',

 19185   '\u3219': '\u0028\u1110\u1161\u0029',

 19186   '\u321A': '\u0028\u1111\u1161\u0029',

 19187   '\u321B': '\u0028\u1112\u1161\u0029',

 19188   '\u321C': '\u0028\u110C\u116E\u0029',

 19189   '\u321D': '\u0028\u110B\u1169\u110C\u1165\u11AB\u0029',

 19190   '\u321E': '\u0028\u110B\u1169\u1112\u116E\u0029',

 19191   '\u3220': '\u0028\u4E00\u0029',

 19192   '\u3221': '\u0028\u4E8C\u0029',

 19193   '\u3222': '\u0028\u4E09\u0029',

 19194   '\u3223': '\u0028\u56DB\u0029',

 19195   '\u3224': '\u0028\u4E94\u0029',

 19196   '\u3225': '\u0028\u516D\u0029',

 19197   '\u3226': '\u0028\u4E03\u0029',

 19198   '\u3227': '\u0028\u516B\u0029',

 19199   '\u3228': '\u0028\u4E5D\u0029',

 19200   '\u3229': '\u0028\u5341\u0029',

 19201   '\u322A': '\u0028\u6708\u0029',

 19202   '\u322B': '\u0028\u706B\u0029',

 19203   '\u322C': '\u0028\u6C34\u0029',

 19204   '\u322D': '\u0028\u6728\u0029',

 19205   '\u322E': '\u0028\u91D1\u0029',

 19206   '\u322F': '\u0028\u571F\u0029',

 19207   '\u3230': '\u0028\u65E5\u0029',

 19208   '\u3231': '\u0028\u682A\u0029',

 19209   '\u3232': '\u0028\u6709\u0029',

 19210   '\u3233': '\u0028\u793E\u0029',

 19211   '\u3234': '\u0028\u540D\u0029',

 19212   '\u3235': '\u0028\u7279\u0029',

 19213   '\u3236': '\u0028\u8CA1\u0029',

 19214   '\u3237': '\u0028\u795D\u0029',

 19215   '\u3238': '\u0028\u52B4\u0029',

 19216   '\u3239': '\u0028\u4EE3\u0029',

 19217   '\u323A': '\u0028\u547C\u0029',

 19218   '\u323B': '\u0028\u5B66\u0029',

 19219   '\u323C': '\u0028\u76E3\u0029',

 19220   '\u323D': '\u0028\u4F01\u0029',

 19221   '\u323E': '\u0028\u8CC7\u0029',

 19222   '\u323F': '\u0028\u5354\u0029',

 19223   '\u3240': '\u0028\u796D\u0029',

 19224   '\u3241': '\u0028\u4F11\u0029',

 19225   '\u3242': '\u0028\u81EA\u0029',

 19226   '\u3243': '\u0028\u81F3\u0029',

 19227   '\u32C0': '\u0031\u6708',

 19228   '\u32C1': '\u0032\u6708',

 19229   '\u32C2': '\u0033\u6708',

 19230   '\u32C3': '\u0034\u6708',

 19231   '\u32C4': '\u0035\u6708',

 19232   '\u32C5': '\u0036\u6708',

 19233   '\u32C6': '\u0037\u6708',

 19234   '\u32C7': '\u0038\u6708',

 19235   '\u32C8': '\u0039\u6708',

 19236   '\u32C9': '\u0031\u0030\u6708',

 19237   '\u32CA': '\u0031\u0031\u6708',

 19238   '\u32CB': '\u0031\u0032\u6708',

 19239   '\u3358': '\u0030\u70B9',

 19240   '\u3359': '\u0031\u70B9',

 19241   '\u335A': '\u0032\u70B9',

 19242   '\u335B': '\u0033\u70B9',

 19243   '\u335C': '\u0034\u70B9',

 19244   '\u335D': '\u0035\u70B9',

 19245   '\u335E': '\u0036\u70B9',

 19246   '\u335F': '\u0037\u70B9',

 19247   '\u3360': '\u0038\u70B9',

 19248   '\u3361': '\u0039\u70B9',

 19249   '\u3362': '\u0031\u0030\u70B9',

 19250   '\u3363': '\u0031\u0031\u70B9',

 19251   '\u3364': '\u0031\u0032\u70B9',

 19252   '\u3365': '\u0031\u0033\u70B9',

 19253   '\u3366': '\u0031\u0034\u70B9',

 19254   '\u3367': '\u0031\u0035\u70B9',

 19255   '\u3368': '\u0031\u0036\u70B9',

 19256   '\u3369': '\u0031\u0037\u70B9',

 19257   '\u336A': '\u0031\u0038\u70B9',

 19258   '\u336B': '\u0031\u0039\u70B9',

 19259   '\u336C': '\u0032\u0030\u70B9',

 19260   '\u336D': '\u0032\u0031\u70B9',

 19261   '\u336E': '\u0032\u0032\u70B9',

 19262   '\u336F': '\u0032\u0033\u70B9',

 19263   '\u3370': '\u0032\u0034\u70B9',

 19264   '\u33E0': '\u0031\u65E5',

 19265   '\u33E1': '\u0032\u65E5',

 19266   '\u33E2': '\u0033\u65E5',

 19267   '\u33E3': '\u0034\u65E5',

 19268   '\u33E4': '\u0035\u65E5',

 19269   '\u33E5': '\u0036\u65E5',

 19270   '\u33E6': '\u0037\u65E5',

 19271   '\u33E7': '\u0038\u65E5',

 19272   '\u33E8': '\u0039\u65E5',

 19273   '\u33E9': '\u0031\u0030\u65E5',

 19274   '\u33EA': '\u0031\u0031\u65E5',

 19275   '\u33EB': '\u0031\u0032\u65E5',

 19276   '\u33EC': '\u0031\u0033\u65E5',

 19277   '\u33ED': '\u0031\u0034\u65E5',

 19278   '\u33EE': '\u0031\u0035\u65E5',

 19279   '\u33EF': '\u0031\u0036\u65E5',

 19280   '\u33F0': '\u0031\u0037\u65E5',

 19281   '\u33F1': '\u0031\u0038\u65E5',

 19282   '\u33F2': '\u0031\u0039\u65E5',

 19283   '\u33F3': '\u0032\u0030\u65E5',

 19284   '\u33F4': '\u0032\u0031\u65E5',

 19285   '\u33F5': '\u0032\u0032\u65E5',

 19286   '\u33F6': '\u0032\u0033\u65E5',

 19287   '\u33F7': '\u0032\u0034\u65E5',

 19288   '\u33F8': '\u0032\u0035\u65E5',

 19289   '\u33F9': '\u0032\u0036\u65E5',

 19290   '\u33FA': '\u0032\u0037\u65E5',

 19291   '\u33FB': '\u0032\u0038\u65E5',

 19292   '\u33FC': '\u0032\u0039\u65E5',

 19293   '\u33FD': '\u0033\u0030\u65E5',

 19294   '\u33FE': '\u0033\u0031\u65E5',

 19295   '\uFB00': '\u0066\u0066',

 19296   '\uFB01': '\u0066\u0069',

 19297   '\uFB02': '\u0066\u006C',

 19298   '\uFB03': '\u0066\u0066\u0069',

 19299   '\uFB04': '\u0066\u0066\u006C',

 19300   '\uFB05': '\u017F\u0074',

 19301   '\uFB06': '\u0073\u0074',

 19302   '\uFB13': '\u0574\u0576',

 19303   '\uFB14': '\u0574\u0565',

 19304   '\uFB15': '\u0574\u056B',

 19305   '\uFB16': '\u057E\u0576',

 19306   '\uFB17': '\u0574\u056D',

 19307   '\uFB4F': '\u05D0\u05DC',

 19308   '\uFB50': '\u0671',

 19309   '\uFB51': '\u0671',

 19310   '\uFB52': '\u067B',

 19311   '\uFB53': '\u067B',

 19312   '\uFB54': '\u067B',

 19313   '\uFB55': '\u067B',

 19314   '\uFB56': '\u067E',

 19315   '\uFB57': '\u067E',

 19316   '\uFB58': '\u067E',

 19317   '\uFB59': '\u067E',

 19318   '\uFB5A': '\u0680',

 19319   '\uFB5B': '\u0680',

 19320   '\uFB5C': '\u0680',

 19321   '\uFB5D': '\u0680',

 19322   '\uFB5E': '\u067A',

 19323   '\uFB5F': '\u067A',

 19324   '\uFB60': '\u067A',

 19325   '\uFB61': '\u067A',

 19326   '\uFB62': '\u067F',

 19327   '\uFB63': '\u067F',

 19328   '\uFB64': '\u067F',

 19329   '\uFB65': '\u067F',

 19330   '\uFB66': '\u0679',

 19331   '\uFB67': '\u0679',

 19332   '\uFB68': '\u0679',

 19333   '\uFB69': '\u0679',

 19334   '\uFB6A': '\u06A4',

 19335   '\uFB6B': '\u06A4',

 19336   '\uFB6C': '\u06A4',

 19337   '\uFB6D': '\u06A4',

 19338   '\uFB6E': '\u06A6',

 19339   '\uFB6F': '\u06A6',

 19340   '\uFB70': '\u06A6',

 19341   '\uFB71': '\u06A6',

 19342   '\uFB72': '\u0684',

 19343   '\uFB73': '\u0684',

 19344   '\uFB74': '\u0684',

 19345   '\uFB75': '\u0684',

 19346   '\uFB76': '\u0683',

 19347   '\uFB77': '\u0683',

 19348   '\uFB78': '\u0683',

 19349   '\uFB79': '\u0683',

 19350   '\uFB7A': '\u0686',

 19351   '\uFB7B': '\u0686',

 19352   '\uFB7C': '\u0686',

 19353   '\uFB7D': '\u0686',

 19354   '\uFB7E': '\u0687',

 19355   '\uFB7F': '\u0687',

 19356   '\uFB80': '\u0687',

 19357   '\uFB81': '\u0687',

 19358   '\uFB82': '\u068D',

 19359   '\uFB83': '\u068D',

 19360   '\uFB84': '\u068C',

 19361   '\uFB85': '\u068C',

 19362   '\uFB86': '\u068E',

 19363   '\uFB87': '\u068E',

 19364   '\uFB88': '\u0688',

 19365   '\uFB89': '\u0688',

 19366   '\uFB8A': '\u0698',

 19367   '\uFB8B': '\u0698',

 19368   '\uFB8C': '\u0691',

 19369   '\uFB8D': '\u0691',

 19370   '\uFB8E': '\u06A9',

 19371   '\uFB8F': '\u06A9',

 19372   '\uFB90': '\u06A9',

 19373   '\uFB91': '\u06A9',

 19374   '\uFB92': '\u06AF',

 19375   '\uFB93': '\u06AF',

 19376   '\uFB94': '\u06AF',

 19377   '\uFB95': '\u06AF',

 19378   '\uFB96': '\u06B3',

 19379   '\uFB97': '\u06B3',

 19380   '\uFB98': '\u06B3',

 19381   '\uFB99': '\u06B3',

 19382   '\uFB9A': '\u06B1',

 19383   '\uFB9B': '\u06B1',

 19384   '\uFB9C': '\u06B1',

 19385   '\uFB9D': '\u06B1',

 19386   '\uFB9E': '\u06BA',

 19387   '\uFB9F': '\u06BA',

 19388   '\uFBA0': '\u06BB',

 19389   '\uFBA1': '\u06BB',

 19390   '\uFBA2': '\u06BB',

 19391   '\uFBA3': '\u06BB',

 19392   '\uFBA4': '\u06C0',

 19393   '\uFBA5': '\u06C0',

 19394   '\uFBA6': '\u06C1',

 19395   '\uFBA7': '\u06C1',

 19396   '\uFBA8': '\u06C1',

 19397   '\uFBA9': '\u06C1',

 19398   '\uFBAA': '\u06BE',

 19399   '\uFBAB': '\u06BE',

 19400   '\uFBAC': '\u06BE',

 19401   '\uFBAD': '\u06BE',

 19402   '\uFBAE': '\u06D2',

 19403   '\uFBAF': '\u06D2',

 19404   '\uFBB0': '\u06D3',

 19405   '\uFBB1': '\u06D3',

 19406   '\uFBD3': '\u06AD',

 19407   '\uFBD4': '\u06AD',

 19408   '\uFBD5': '\u06AD',

 19409   '\uFBD6': '\u06AD',

 19410   '\uFBD7': '\u06C7',

 19411   '\uFBD8': '\u06C7',

 19412   '\uFBD9': '\u06C6',

 19413   '\uFBDA': '\u06C6',

 19414   '\uFBDB': '\u06C8',

 19415   '\uFBDC': '\u06C8',

 19416   '\uFBDD': '\u0677',

 19417   '\uFBDE': '\u06CB',

 19418   '\uFBDF': '\u06CB',

 19419   '\uFBE0': '\u06C5',

 19420   '\uFBE1': '\u06C5',

 19421   '\uFBE2': '\u06C9',

 19422   '\uFBE3': '\u06C9',

 19423   '\uFBE4': '\u06D0',

 19424   '\uFBE5': '\u06D0',

 19425   '\uFBE6': '\u06D0',

 19426   '\uFBE7': '\u06D0',

 19427   '\uFBE8': '\u0649',

 19428   '\uFBE9': '\u0649',

 19429   '\uFBEA': '\u0626\u0627',

 19430   '\uFBEB': '\u0626\u0627',

 19431   '\uFBEC': '\u0626\u06D5',

 19432   '\uFBED': '\u0626\u06D5',

 19433   '\uFBEE': '\u0626\u0648',

 19434   '\uFBEF': '\u0626\u0648',

 19435   '\uFBF0': '\u0626\u06C7',

 19436   '\uFBF1': '\u0626\u06C7',

 19437   '\uFBF2': '\u0626\u06C6',

 19438   '\uFBF3': '\u0626\u06C6',

 19439   '\uFBF4': '\u0626\u06C8',

 19440   '\uFBF5': '\u0626\u06C8',

 19441   '\uFBF6': '\u0626\u06D0',

 19442   '\uFBF7': '\u0626\u06D0',

 19443   '\uFBF8': '\u0626\u06D0',

 19444   '\uFBF9': '\u0626\u0649',

 19445   '\uFBFA': '\u0626\u0649',

 19446   '\uFBFB': '\u0626\u0649',

 19447   '\uFBFC': '\u06CC',

 19448   '\uFBFD': '\u06CC',

 19449   '\uFBFE': '\u06CC',

 19450   '\uFBFF': '\u06CC',

 19451   '\uFC00': '\u0626\u062C',

 19452   '\uFC01': '\u0626\u062D',

 19453   '\uFC02': '\u0626\u0645',

 19454   '\uFC03': '\u0626\u0649',

 19455   '\uFC04': '\u0626\u064A',

 19456   '\uFC05': '\u0628\u062C',

 19457   '\uFC06': '\u0628\u062D',

 19458   '\uFC07': '\u0628\u062E',

 19459   '\uFC08': '\u0628\u0645',

 19460   '\uFC09': '\u0628\u0649',

 19461   '\uFC0A': '\u0628\u064A',

 19462   '\uFC0B': '\u062A\u062C',

 19463   '\uFC0C': '\u062A\u062D',

 19464   '\uFC0D': '\u062A\u062E',

 19465   '\uFC0E': '\u062A\u0645',

 19466   '\uFC0F': '\u062A\u0649',

 19467   '\uFC10': '\u062A\u064A',

 19468   '\uFC11': '\u062B\u062C',

 19469   '\uFC12': '\u062B\u0645',

 19470   '\uFC13': '\u062B\u0649',

 19471   '\uFC14': '\u062B\u064A',

 19472   '\uFC15': '\u062C\u062D',

 19473   '\uFC16': '\u062C\u0645',

 19474   '\uFC17': '\u062D\u062C',

 19475   '\uFC18': '\u062D\u0645',

 19476   '\uFC19': '\u062E\u062C',

 19477   '\uFC1A': '\u062E\u062D',

 19478   '\uFC1B': '\u062E\u0645',

 19479   '\uFC1C': '\u0633\u062C',

 19480   '\uFC1D': '\u0633\u062D',

 19481   '\uFC1E': '\u0633\u062E',

 19482   '\uFC1F': '\u0633\u0645',

 19483   '\uFC20': '\u0635\u062D',

 19484   '\uFC21': '\u0635\u0645',

 19485   '\uFC22': '\u0636\u062C',

 19486   '\uFC23': '\u0636\u062D',

 19487   '\uFC24': '\u0636\u062E',

 19488   '\uFC25': '\u0636\u0645',

 19489   '\uFC26': '\u0637\u062D',

 19490   '\uFC27': '\u0637\u0645',

 19491   '\uFC28': '\u0638\u0645',

 19492   '\uFC29': '\u0639\u062C',

 19493   '\uFC2A': '\u0639\u0645',

 19494   '\uFC2B': '\u063A\u062C',

 19495   '\uFC2C': '\u063A\u0645',

 19496   '\uFC2D': '\u0641\u062C',

 19497   '\uFC2E': '\u0641\u062D',

 19498   '\uFC2F': '\u0641\u062E',

 19499   '\uFC30': '\u0641\u0645',

 19500   '\uFC31': '\u0641\u0649',

 19501   '\uFC32': '\u0641\u064A',

 19502   '\uFC33': '\u0642\u062D',

 19503   '\uFC34': '\u0642\u0645',

 19504   '\uFC35': '\u0642\u0649',

 19505   '\uFC36': '\u0642\u064A',

 19506   '\uFC37': '\u0643\u0627',

 19507   '\uFC38': '\u0643\u062C',

 19508   '\uFC39': '\u0643\u062D',

 19509   '\uFC3A': '\u0643\u062E',

 19510   '\uFC3B': '\u0643\u0644',

 19511   '\uFC3C': '\u0643\u0645',

 19512   '\uFC3D': '\u0643\u0649',

 19513   '\uFC3E': '\u0643\u064A',

 19514   '\uFC3F': '\u0644\u062C',

 19515   '\uFC40': '\u0644\u062D',

 19516   '\uFC41': '\u0644\u062E',

 19517   '\uFC42': '\u0644\u0645',

 19518   '\uFC43': '\u0644\u0649',

 19519   '\uFC44': '\u0644\u064A',

 19520   '\uFC45': '\u0645\u062C',

 19521   '\uFC46': '\u0645\u062D',

 19522   '\uFC47': '\u0645\u062E',

 19523   '\uFC48': '\u0645\u0645',

 19524   '\uFC49': '\u0645\u0649',

 19525   '\uFC4A': '\u0645\u064A',

 19526   '\uFC4B': '\u0646\u062C',

 19527   '\uFC4C': '\u0646\u062D',

 19528   '\uFC4D': '\u0646\u062E',

 19529   '\uFC4E': '\u0646\u0645',

 19530   '\uFC4F': '\u0646\u0649',

 19531   '\uFC50': '\u0646\u064A',

 19532   '\uFC51': '\u0647\u062C',

 19533   '\uFC52': '\u0647\u0645',

 19534   '\uFC53': '\u0647\u0649',

 19535   '\uFC54': '\u0647\u064A',

 19536   '\uFC55': '\u064A\u062C',

 19537   '\uFC56': '\u064A\u062D',

 19538   '\uFC57': '\u064A\u062E',

 19539   '\uFC58': '\u064A\u0645',

 19540   '\uFC59': '\u064A\u0649',

 19541   '\uFC5A': '\u064A\u064A',

 19542   '\uFC5B': '\u0630\u0670',

 19543   '\uFC5C': '\u0631\u0670',

 19544   '\uFC5D': '\u0649\u0670',

 19545   '\uFC5E': '\u0020\u064C\u0651',

 19546   '\uFC5F': '\u0020\u064D\u0651',

 19547   '\uFC60': '\u0020\u064E\u0651',

 19548   '\uFC61': '\u0020\u064F\u0651',

 19549   '\uFC62': '\u0020\u0650\u0651',

 19550   '\uFC63': '\u0020\u0651\u0670',

 19551   '\uFC64': '\u0626\u0631',

 19552   '\uFC65': '\u0626\u0632',

 19553   '\uFC66': '\u0626\u0645',

 19554   '\uFC67': '\u0626\u0646',

 19555   '\uFC68': '\u0626\u0649',

 19556   '\uFC69': '\u0626\u064A',

 19557   '\uFC6A': '\u0628\u0631',

 19558   '\uFC6B': '\u0628\u0632',

 19559   '\uFC6C': '\u0628\u0645',

 19560   '\uFC6D': '\u0628\u0646',

 19561   '\uFC6E': '\u0628\u0649',

 19562   '\uFC6F': '\u0628\u064A',

 19563   '\uFC70': '\u062A\u0631',

 19564   '\uFC71': '\u062A\u0632',

 19565   '\uFC72': '\u062A\u0645',

 19566   '\uFC73': '\u062A\u0646',

 19567   '\uFC74': '\u062A\u0649',

 19568   '\uFC75': '\u062A\u064A',

 19569   '\uFC76': '\u062B\u0631',

 19570   '\uFC77': '\u062B\u0632',

 19571   '\uFC78': '\u062B\u0645',

 19572   '\uFC79': '\u062B\u0646',

 19573   '\uFC7A': '\u062B\u0649',

 19574   '\uFC7B': '\u062B\u064A',

 19575   '\uFC7C': '\u0641\u0649',

 19576   '\uFC7D': '\u0641\u064A',

 19577   '\uFC7E': '\u0642\u0649',

 19578   '\uFC7F': '\u0642\u064A',

 19579   '\uFC80': '\u0643\u0627',

 19580   '\uFC81': '\u0643\u0644',

 19581   '\uFC82': '\u0643\u0645',

 19582   '\uFC83': '\u0643\u0649',

 19583   '\uFC84': '\u0643\u064A',

 19584   '\uFC85': '\u0644\u0645',

 19585   '\uFC86': '\u0644\u0649',

 19586   '\uFC87': '\u0644\u064A',

 19587   '\uFC88': '\u0645\u0627',

 19588   '\uFC89': '\u0645\u0645',

 19589   '\uFC8A': '\u0646\u0631',

 19590   '\uFC8B': '\u0646\u0632',

 19591   '\uFC8C': '\u0646\u0645',

 19592   '\uFC8D': '\u0646\u0646',

 19593   '\uFC8E': '\u0646\u0649',

 19594   '\uFC8F': '\u0646\u064A',

 19595   '\uFC90': '\u0649\u0670',

 19596   '\uFC91': '\u064A\u0631',

 19597   '\uFC92': '\u064A\u0632',

 19598   '\uFC93': '\u064A\u0645',

 19599   '\uFC94': '\u064A\u0646',

 19600   '\uFC95': '\u064A\u0649',

 19601   '\uFC96': '\u064A\u064A',

 19602   '\uFC97': '\u0626\u062C',

 19603   '\uFC98': '\u0626\u062D',

 19604   '\uFC99': '\u0626\u062E',

 19605   '\uFC9A': '\u0626\u0645',

 19606   '\uFC9B': '\u0626\u0647',

 19607   '\uFC9C': '\u0628\u062C',

 19608   '\uFC9D': '\u0628\u062D',

 19609   '\uFC9E': '\u0628\u062E',

 19610   '\uFC9F': '\u0628\u0645',

 19611   '\uFCA0': '\u0628\u0647',

 19612   '\uFCA1': '\u062A\u062C',

 19613   '\uFCA2': '\u062A\u062D',

 19614   '\uFCA3': '\u062A\u062E',

 19615   '\uFCA4': '\u062A\u0645',

 19616   '\uFCA5': '\u062A\u0647',

 19617   '\uFCA6': '\u062B\u0645',

 19618   '\uFCA7': '\u062C\u062D',

 19619   '\uFCA8': '\u062C\u0645',

 19620   '\uFCA9': '\u062D\u062C',

 19621   '\uFCAA': '\u062D\u0645',

 19622   '\uFCAB': '\u062E\u062C',

 19623   '\uFCAC': '\u062E\u0645',

 19624   '\uFCAD': '\u0633\u062C',

 19625   '\uFCAE': '\u0633\u062D',

 19626   '\uFCAF': '\u0633\u062E',

 19627   '\uFCB0': '\u0633\u0645',

 19628   '\uFCB1': '\u0635\u062D',

 19629   '\uFCB2': '\u0635\u062E',

 19630   '\uFCB3': '\u0635\u0645',

 19631   '\uFCB4': '\u0636\u062C',

 19632   '\uFCB5': '\u0636\u062D',

 19633   '\uFCB6': '\u0636\u062E',

 19634   '\uFCB7': '\u0636\u0645',

 19635   '\uFCB8': '\u0637\u062D',

 19636   '\uFCB9': '\u0638\u0645',

 19637   '\uFCBA': '\u0639\u062C',

 19638   '\uFCBB': '\u0639\u0645',

 19639   '\uFCBC': '\u063A\u062C',

 19640   '\uFCBD': '\u063A\u0645',

 19641   '\uFCBE': '\u0641\u062C',

 19642   '\uFCBF': '\u0641\u062D',

 19643   '\uFCC0': '\u0641\u062E',

 19644   '\uFCC1': '\u0641\u0645',

 19645   '\uFCC2': '\u0642\u062D',

 19646   '\uFCC3': '\u0642\u0645',

 19647   '\uFCC4': '\u0643\u062C',

 19648   '\uFCC5': '\u0643\u062D',

 19649   '\uFCC6': '\u0643\u062E',

 19650   '\uFCC7': '\u0643\u0644',

 19651   '\uFCC8': '\u0643\u0645',

 19652   '\uFCC9': '\u0644\u062C',

 19653   '\uFCCA': '\u0644\u062D',

 19654   '\uFCCB': '\u0644\u062E',

 19655   '\uFCCC': '\u0644\u0645',

 19656   '\uFCCD': '\u0644\u0647',

 19657   '\uFCCE': '\u0645\u062C',

 19658   '\uFCCF': '\u0645\u062D',

 19659   '\uFCD0': '\u0645\u062E',

 19660   '\uFCD1': '\u0645\u0645',

 19661   '\uFCD2': '\u0646\u062C',

 19662   '\uFCD3': '\u0646\u062D',

 19663   '\uFCD4': '\u0646\u062E',

 19664   '\uFCD5': '\u0646\u0645',

 19665   '\uFCD6': '\u0646\u0647',

 19666   '\uFCD7': '\u0647\u062C',

 19667   '\uFCD8': '\u0647\u0645',

 19668   '\uFCD9': '\u0647\u0670',

 19669   '\uFCDA': '\u064A\u062C',

 19670   '\uFCDB': '\u064A\u062D',

 19671   '\uFCDC': '\u064A\u062E',

 19672   '\uFCDD': '\u064A\u0645',

 19673   '\uFCDE': '\u064A\u0647',

 19674   '\uFCDF': '\u0626\u0645',

 19675   '\uFCE0': '\u0626\u0647',

 19676   '\uFCE1': '\u0628\u0645',

 19677   '\uFCE2': '\u0628\u0647',

 19678   '\uFCE3': '\u062A\u0645',

 19679   '\uFCE4': '\u062A\u0647',

 19680   '\uFCE5': '\u062B\u0645',

 19681   '\uFCE6': '\u062B\u0647',

 19682   '\uFCE7': '\u0633\u0645',

 19683   '\uFCE8': '\u0633\u0647',

 19684   '\uFCE9': '\u0634\u0645',

 19685   '\uFCEA': '\u0634\u0647',

 19686   '\uFCEB': '\u0643\u0644',

 19687   '\uFCEC': '\u0643\u0645',

 19688   '\uFCED': '\u0644\u0645',

 19689   '\uFCEE': '\u0646\u0645',

 19690   '\uFCEF': '\u0646\u0647',

 19691   '\uFCF0': '\u064A\u0645',

 19692   '\uFCF1': '\u064A\u0647',

 19693   '\uFCF2': '\u0640\u064E\u0651',

 19694   '\uFCF3': '\u0640\u064F\u0651',

 19695   '\uFCF4': '\u0640\u0650\u0651',

 19696   '\uFCF5': '\u0637\u0649',

 19697   '\uFCF6': '\u0637\u064A',

 19698   '\uFCF7': '\u0639\u0649',

 19699   '\uFCF8': '\u0639\u064A',

 19700   '\uFCF9': '\u063A\u0649',

 19701   '\uFCFA': '\u063A\u064A',

 19702   '\uFCFB': '\u0633\u0649',

 19703   '\uFCFC': '\u0633\u064A',

 19704   '\uFCFD': '\u0634\u0649',

 19705   '\uFCFE': '\u0634\u064A',

 19706   '\uFCFF': '\u062D\u0649',

 19707   '\uFD00': '\u062D\u064A',

 19708   '\uFD01': '\u062C\u0649',

 19709   '\uFD02': '\u062C\u064A',

 19710   '\uFD03': '\u062E\u0649',

 19711   '\uFD04': '\u062E\u064A',

 19712   '\uFD05': '\u0635\u0649',

 19713   '\uFD06': '\u0635\u064A',

 19714   '\uFD07': '\u0636\u0649',

 19715   '\uFD08': '\u0636\u064A',

 19716   '\uFD09': '\u0634\u062C',

 19717   '\uFD0A': '\u0634\u062D',

 19718   '\uFD0B': '\u0634\u062E',

 19719   '\uFD0C': '\u0634\u0645',

 19720   '\uFD0D': '\u0634\u0631',

 19721   '\uFD0E': '\u0633\u0631',

 19722   '\uFD0F': '\u0635\u0631',

 19723   '\uFD10': '\u0636\u0631',

 19724   '\uFD11': '\u0637\u0649',

 19725   '\uFD12': '\u0637\u064A',

 19726   '\uFD13': '\u0639\u0649',

 19727   '\uFD14': '\u0639\u064A',

 19728   '\uFD15': '\u063A\u0649',

 19729   '\uFD16': '\u063A\u064A',

 19730   '\uFD17': '\u0633\u0649',

 19731   '\uFD18': '\u0633\u064A',

 19732   '\uFD19': '\u0634\u0649',

 19733   '\uFD1A': '\u0634\u064A',

 19734   '\uFD1B': '\u062D\u0649',

 19735   '\uFD1C': '\u062D\u064A',

 19736   '\uFD1D': '\u062C\u0649',

 19737   '\uFD1E': '\u062C\u064A',

 19738   '\uFD1F': '\u062E\u0649',

 19739   '\uFD20': '\u062E\u064A',

 19740   '\uFD21': '\u0635\u0649',

 19741   '\uFD22': '\u0635\u064A',

 19742   '\uFD23': '\u0636\u0649',

 19743   '\uFD24': '\u0636\u064A',

 19744   '\uFD25': '\u0634\u062C',

 19745   '\uFD26': '\u0634\u062D',

 19746   '\uFD27': '\u0634\u062E',

 19747   '\uFD28': '\u0634\u0645',

 19748   '\uFD29': '\u0634\u0631',

 19749   '\uFD2A': '\u0633\u0631',

 19750   '\uFD2B': '\u0635\u0631',

 19751   '\uFD2C': '\u0636\u0631',

 19752   '\uFD2D': '\u0634\u062C',

 19753   '\uFD2E': '\u0634\u062D',

 19754   '\uFD2F': '\u0634\u062E',

 19755   '\uFD30': '\u0634\u0645',

 19756   '\uFD31': '\u0633\u0647',

 19757   '\uFD32': '\u0634\u0647',

 19758   '\uFD33': '\u0637\u0645',

 19759   '\uFD34': '\u0633\u062C',

 19760   '\uFD35': '\u0633\u062D',

 19761   '\uFD36': '\u0633\u062E',

 19762   '\uFD37': '\u0634\u062C',

 19763   '\uFD38': '\u0634\u062D',

 19764   '\uFD39': '\u0634\u062E',

 19765   '\uFD3A': '\u0637\u0645',

 19766   '\uFD3B': '\u0638\u0645',

 19767   '\uFD3C': '\u0627\u064B',

 19768   '\uFD3D': '\u0627\u064B',

 19769   '\uFD50': '\u062A\u062C\u0645',

 19770   '\uFD51': '\u062A\u062D\u062C',

 19771   '\uFD52': '\u062A\u062D\u062C',

 19772   '\uFD53': '\u062A\u062D\u0645',

 19773   '\uFD54': '\u062A\u062E\u0645',

 19774   '\uFD55': '\u062A\u0645\u062C',

 19775   '\uFD56': '\u062A\u0645\u062D',

 19776   '\uFD57': '\u062A\u0645\u062E',

 19777   '\uFD58': '\u062C\u0645\u062D',

 19778   '\uFD59': '\u062C\u0645\u062D',

 19779   '\uFD5A': '\u062D\u0645\u064A',

 19780   '\uFD5B': '\u062D\u0645\u0649',

 19781   '\uFD5C': '\u0633\u062D\u062C',

 19782   '\uFD5D': '\u0633\u062C\u062D',

 19783   '\uFD5E': '\u0633\u062C\u0649',

 19784   '\uFD5F': '\u0633\u0645\u062D',

 19785   '\uFD60': '\u0633\u0645\u062D',

 19786   '\uFD61': '\u0633\u0645\u062C',

 19787   '\uFD62': '\u0633\u0645\u0645',

 19788   '\uFD63': '\u0633\u0645\u0645',

 19789   '\uFD64': '\u0635\u062D\u062D',

 19790   '\uFD65': '\u0635\u062D\u062D',

 19791   '\uFD66': '\u0635\u0645\u0645',

 19792   '\uFD67': '\u0634\u062D\u0645',

 19793   '\uFD68': '\u0634\u062D\u0645',

 19794   '\uFD69': '\u0634\u062C\u064A',

 19795   '\uFD6A': '\u0634\u0645\u062E',

 19796   '\uFD6B': '\u0634\u0645\u062E',

 19797   '\uFD6C': '\u0634\u0645\u0645',

 19798   '\uFD6D': '\u0634\u0645\u0645',

 19799   '\uFD6E': '\u0636\u062D\u0649',

 19800   '\uFD6F': '\u0636\u062E\u0645',

 19801   '\uFD70': '\u0636\u062E\u0645',

 19802   '\uFD71': '\u0637\u0645\u062D',

 19803   '\uFD72': '\u0637\u0645\u062D',

 19804   '\uFD73': '\u0637\u0645\u0645',

 19805   '\uFD74': '\u0637\u0645\u064A',

 19806   '\uFD75': '\u0639\u062C\u0645',

 19807   '\uFD76': '\u0639\u0645\u0645',

 19808   '\uFD77': '\u0639\u0645\u0645',

 19809   '\uFD78': '\u0639\u0645\u0649',

 19810   '\uFD79': '\u063A\u0645\u0645',

 19811   '\uFD7A': '\u063A\u0645\u064A',

 19812   '\uFD7B': '\u063A\u0645\u0649',

 19813   '\uFD7C': '\u0641\u062E\u0645',

 19814   '\uFD7D': '\u0641\u062E\u0645',

 19815   '\uFD7E': '\u0642\u0645\u062D',

 19816   '\uFD7F': '\u0642\u0645\u0645',

 19817   '\uFD80': '\u0644\u062D\u0645',

 19818   '\uFD81': '\u0644\u062D\u064A',

 19819   '\uFD82': '\u0644\u062D\u0649',

 19820   '\uFD83': '\u0644\u062C\u062C',

 19821   '\uFD84': '\u0644\u062C\u062C',

 19822   '\uFD85': '\u0644\u062E\u0645',

 19823   '\uFD86': '\u0644\u062E\u0645',

 19824   '\uFD87': '\u0644\u0645\u062D',

 19825   '\uFD88': '\u0644\u0645\u062D',

 19826   '\uFD89': '\u0645\u062D\u062C',

 19827   '\uFD8A': '\u0645\u062D\u0645',

 19828   '\uFD8B': '\u0645\u062D\u064A',

 19829   '\uFD8C': '\u0645\u062C\u062D',

 19830   '\uFD8D': '\u0645\u062C\u0645',

 19831   '\uFD8E': '\u0645\u062E\u062C',

 19832   '\uFD8F': '\u0645\u062E\u0645',

 19833   '\uFD92': '\u0645\u062C\u062E',

 19834   '\uFD93': '\u0647\u0645\u062C',

 19835   '\uFD94': '\u0647\u0645\u0645',

 19836   '\uFD95': '\u0646\u062D\u0645',

 19837   '\uFD96': '\u0646\u062D\u0649',

 19838   '\uFD97': '\u0646\u062C\u0645',

 19839   '\uFD98': '\u0646\u062C\u0645',

 19840   '\uFD99': '\u0646\u062C\u0649',

 19841   '\uFD9A': '\u0646\u0645\u064A',

 19842   '\uFD9B': '\u0646\u0645\u0649',

 19843   '\uFD9C': '\u064A\u0645\u0645',

 19844   '\uFD9D': '\u064A\u0645\u0645',

 19845   '\uFD9E': '\u0628\u062E\u064A',

 19846   '\uFD9F': '\u062A\u062C\u064A',

 19847   '\uFDA0': '\u062A\u062C\u0649',

 19848   '\uFDA1': '\u062A\u062E\u064A',

 19849   '\uFDA2': '\u062A\u062E\u0649',

 19850   '\uFDA3': '\u062A\u0645\u064A',

 19851   '\uFDA4': '\u062A\u0645\u0649',

 19852   '\uFDA5': '\u062C\u0645\u064A',

 19853   '\uFDA6': '\u062C\u062D\u0649',

 19854   '\uFDA7': '\u062C\u0645\u0649',

 19855   '\uFDA8': '\u0633\u062E\u0649',

 19856   '\uFDA9': '\u0635\u062D\u064A',

 19857   '\uFDAA': '\u0634\u062D\u064A',

 19858   '\uFDAB': '\u0636\u062D\u064A',

 19859   '\uFDAC': '\u0644\u062C\u064A',

 19860   '\uFDAD': '\u0644\u0645\u064A',

 19861   '\uFDAE': '\u064A\u062D\u064A',

 19862   '\uFDAF': '\u064A\u062C\u064A',

 19863   '\uFDB0': '\u064A\u0645\u064A',

 19864   '\uFDB1': '\u0645\u0645\u064A',

 19865   '\uFDB2': '\u0642\u0645\u064A',

 19866   '\uFDB3': '\u0646\u062D\u064A',

 19867   '\uFDB4': '\u0642\u0645\u062D',

 19868   '\uFDB5': '\u0644\u062D\u0645',

 19869   '\uFDB6': '\u0639\u0645\u064A',

 19870   '\uFDB7': '\u0643\u0645\u064A',

 19871   '\uFDB8': '\u0646\u062C\u062D',

 19872   '\uFDB9': '\u0645\u062E\u064A',

 19873   '\uFDBA': '\u0644\u062C\u0645',

 19874   '\uFDBB': '\u0643\u0645\u0645',

 19875   '\uFDBC': '\u0644\u062C\u0645',

 19876   '\uFDBD': '\u0646\u062C\u062D',

 19877   '\uFDBE': '\u062C\u062D\u064A',

 19878   '\uFDBF': '\u062D\u062C\u064A',

 19879   '\uFDC0': '\u0645\u062C\u064A',

 19880   '\uFDC1': '\u0641\u0645\u064A',

 19881   '\uFDC2': '\u0628\u062D\u064A',

 19882   '\uFDC3': '\u0643\u0645\u0645',

 19883   '\uFDC4': '\u0639\u062C\u0645',

 19884   '\uFDC5': '\u0635\u0645\u0645',

 19885   '\uFDC6': '\u0633\u062E\u064A',

 19886   '\uFDC7': '\u0646\u062C\u064A',

 19887   '\uFE49': '\u203E',

 19888   '\uFE4A': '\u203E',

 19889   '\uFE4B': '\u203E',

 19890   '\uFE4C': '\u203E',

 19891   '\uFE4D': '\u005F',

 19892   '\uFE4E': '\u005F',

 19893   '\uFE4F': '\u005F',

 19894   '\uFE80': '\u0621',

 19895   '\uFE81': '\u0622',

 19896   '\uFE82': '\u0622',

 19897   '\uFE83': '\u0623',

 19898   '\uFE84': '\u0623',

 19899   '\uFE85': '\u0624',

 19900   '\uFE86': '\u0624',

 19901   '\uFE87': '\u0625',

 19902   '\uFE88': '\u0625',

 19903   '\uFE89': '\u0626',

 19904   '\uFE8A': '\u0626',

 19905   '\uFE8B': '\u0626',

 19906   '\uFE8C': '\u0626',

 19907   '\uFE8D': '\u0627',

 19908   '\uFE8E': '\u0627',

 19909   '\uFE8F': '\u0628',

 19910   '\uFE90': '\u0628',

 19911   '\uFE91': '\u0628',

 19912   '\uFE92': '\u0628',

 19913   '\uFE93': '\u0629',

 19914   '\uFE94': '\u0629',

 19915   '\uFE95': '\u062A',

 19916   '\uFE96': '\u062A',

 19917   '\uFE97': '\u062A',

 19918   '\uFE98': '\u062A',

 19919   '\uFE99': '\u062B',

 19920   '\uFE9A': '\u062B',

 19921   '\uFE9B': '\u062B',

 19922   '\uFE9C': '\u062B',

 19923   '\uFE9D': '\u062C',

 19924   '\uFE9E': '\u062C',

 19925   '\uFE9F': '\u062C',

 19926   '\uFEA0': '\u062C',

 19927   '\uFEA1': '\u062D',

 19928   '\uFEA2': '\u062D',

 19929   '\uFEA3': '\u062D',

 19930   '\uFEA4': '\u062D',

 19931   '\uFEA5': '\u062E',

 19932   '\uFEA6': '\u062E',

 19933   '\uFEA7': '\u062E',

 19934   '\uFEA8': '\u062E',

 19935   '\uFEA9': '\u062F',

 19936   '\uFEAA': '\u062F',

 19937   '\uFEAB': '\u0630',

 19938   '\uFEAC': '\u0630',

 19939   '\uFEAD': '\u0631',

 19940   '\uFEAE': '\u0631',

 19941   '\uFEAF': '\u0632',

 19942   '\uFEB0': '\u0632',

 19943   '\uFEB1': '\u0633',

 19944   '\uFEB2': '\u0633',

 19945   '\uFEB3': '\u0633',

 19946   '\uFEB4': '\u0633',

 19947   '\uFEB5': '\u0634',

 19948   '\uFEB6': '\u0634',

 19949   '\uFEB7': '\u0634',

 19950   '\uFEB8': '\u0634',

 19951   '\uFEB9': '\u0635',

 19952   '\uFEBA': '\u0635',

 19953   '\uFEBB': '\u0635',

 19954   '\uFEBC': '\u0635',

 19955   '\uFEBD': '\u0636',

 19956   '\uFEBE': '\u0636',

 19957   '\uFEBF': '\u0636',

 19958   '\uFEC0': '\u0636',

 19959   '\uFEC1': '\u0637',

 19960   '\uFEC2': '\u0637',

 19961   '\uFEC3': '\u0637',

 19962   '\uFEC4': '\u0637',

 19963   '\uFEC5': '\u0638',

 19964   '\uFEC6': '\u0638',

 19965   '\uFEC7': '\u0638',

 19966   '\uFEC8': '\u0638',

 19967   '\uFEC9': '\u0639',

 19968   '\uFECA': '\u0639',

 19969   '\uFECB': '\u0639',

 19970   '\uFECC': '\u0639',

 19971   '\uFECD': '\u063A',

 19972   '\uFECE': '\u063A',

 19973   '\uFECF': '\u063A',

 19974   '\uFED0': '\u063A',

 19975   '\uFED1': '\u0641',

 19976   '\uFED2': '\u0641',

 19977   '\uFED3': '\u0641',

 19978   '\uFED4': '\u0641',

 19979   '\uFED5': '\u0642',

 19980   '\uFED6': '\u0642',

 19981   '\uFED7': '\u0642',

 19982   '\uFED8': '\u0642',

 19983   '\uFED9': '\u0643',

 19984   '\uFEDA': '\u0643',

 19985   '\uFEDB': '\u0643',

 19986   '\uFEDC': '\u0643',

 19987   '\uFEDD': '\u0644',

 19988   '\uFEDE': '\u0644',

 19989   '\uFEDF': '\u0644',

 19990   '\uFEE0': '\u0644',

 19991   '\uFEE1': '\u0645',

 19992   '\uFEE2': '\u0645',

 19993   '\uFEE3': '\u0645',

 19994   '\uFEE4': '\u0645',

 19995   '\uFEE5': '\u0646',

 19996   '\uFEE6': '\u0646',

 19997   '\uFEE7': '\u0646',

 19998   '\uFEE8': '\u0646',

 19999   '\uFEE9': '\u0647',

 20000   '\uFEEA': '\u0647',

 20001   '\uFEEB': '\u0647',

 20002   '\uFEEC': '\u0647',

 20003   '\uFEED': '\u0648',

 20004   '\uFEEE': '\u0648',

 20005   '\uFEEF': '\u0649',

 20006   '\uFEF0': '\u0649',

 20007   '\uFEF1': '\u064A',

 20008   '\uFEF2': '\u064A',

 20009   '\uFEF3': '\u064A',

 20010   '\uFEF4': '\u064A',

 20011   '\uFEF5': '\u0644\u0622',

 20012   '\uFEF6': '\u0644\u0622',

 20013   '\uFEF7': '\u0644\u0623',

 20014   '\uFEF8': '\u0644\u0623',

 20015   '\uFEF9': '\u0644\u0625',

 20016   '\uFEFA': '\u0644\u0625',

 20017   '\uFEFB': '\u0644\u0627',

 20018   '\uFEFC': '\u0644\u0627'

 20019 };

 20021 function reverseIfRtl(chars) {

 20022   var charsLength = chars.length;

 20023   //reverse an arabic ligature

 20024   if (charsLength <= 1 || !isRTLRangeFor(chars.charCodeAt(0))) {

 20025     return chars;

 20026   }

 20027   var s = '';

 20028   for (var ii = charsLength - 1; ii >= 0; ii--) {

 20029     s += chars[ii];

 20030   }

 20031   return s;

 20032 }

 20034 function adjustWidths(properties) {

 20035   if (properties.fontMatrix[0] === FONT_IDENTITY_MATRIX[0]) {

 20036     return;

 20037   }

 20038   // adjusting width to fontMatrix scale

 20039   var scale = 0.001 / properties.fontMatrix[0];

 20040   var glyphsWidths = properties.widths;

 20041   for (var glyph in glyphsWidths) {

 20042     glyphsWidths[glyph] *= scale;

 20043   }

 20044   properties.defaultWidth *= scale;

 20045 }

 20047 var Glyph = (function GlyphClosure() {

 20048   function Glyph(fontChar, unicode, accent, width, vmetric, operatorList) {

 20049     this.fontChar = fontChar;

 20050     this.unicode = unicode;

 20051     this.accent = accent;

 20052     this.width = width;

 20053     this.vmetric = vmetric;

 20054     this.operatorList = operatorList;

 20055   }

 20057   Glyph.prototype.matchesForCache =

 20058       function(fontChar, unicode, accent, width, vmetric, operatorList) {

 20059     return this.fontChar === fontChar &&

 20060            this.unicode === unicode &&

 20061            this.accent === accent &&

 20062            this.width === width &&

 20063            this.vmetric === vmetric &&

 20064            this.operatorList === operatorList;

 20065   };

 20067   return Glyph;

 20068 })();

 20070 /**

 20071  * 'Font' is the class the outside world should use, it encapsulate all the font

 20072  * decoding logics whatever type it is (assuming the font type is supported).

 20073  *

 20074  * For example to read a Type1 font and to attach it to the document:

 20075  *   var type1Font = new Font("MyFontName", binaryFile, propertiesObject);

 20076  *   type1Font.bind();

 20077  */

 20078 var Font = (function FontClosure() {

 20079   function Font(name, file, properties) {

 20080     var charCode;

 20082     this.name = name;

 20083     this.loadedName = properties.loadedName;

 20084     this.coded = properties.coded;

 20085     this.loadCharProcs = properties.coded;

 20086     this.sizes = [];

 20088     this.glyphCache = {};

 20090     var names = name.split('+');

 20091     names = names.length > 1 ? names[1] : names[0];

 20092     names = names.split(/[-,_]/g)[0];

 20093     this.isSerifFont = !!(properties.flags & FontFlags.Serif);

 20094     this.isSymbolicFont = !!(properties.flags & FontFlags.Symbolic);

 20095     this.isMonospace = !!(properties.flags & FontFlags.FixedPitch);

 20097     var type = properties.type;

 20098     this.type = type;

 20100     this.fallbackName = (this.isMonospace ? 'monospace' :

 20101                          (this.isSerifFont ? 'serif' : 'sans-serif'));

 20103     this.differences = properties.differences;

 20104     this.widths = properties.widths;

 20105     this.defaultWidth = properties.defaultWidth;

 20106     this.composite = properties.composite;

 20107     this.wideChars = properties.wideChars;

 20108     this.cMap = properties.cMap;

 20109     this.ascent = properties.ascent / PDF_GLYPH_SPACE_UNITS;

 20110     this.descent = properties.descent / PDF_GLYPH_SPACE_UNITS;

 20111     this.fontMatrix = properties.fontMatrix;

 20113     var unicode = this.buildToUnicode(properties);

 20114     this.toUnicode = properties.toUnicode = unicode.toUnicode;

 20115     this.isIdentityUnicode = properties.isIdentityUnicode = unicode.isIdentity;

 20117     this.toFontChar = [];

 20119     if (properties.type == 'Type3') {

 20120       for (charCode = 0; charCode < 256; charCode++) {

 20121         this.toFontChar[charCode] = (this.differences[charCode] ||

 20122                                      properties.defaultEncoding[charCode]);

 20123       }

 20124       return;

 20125     }

 20127     this.cidEncoding = properties.cidEncoding;

 20128     this.vertical = properties.vertical;

 20129     if (this.vertical) {

 20130       this.vmetrics = properties.vmetrics;

 20131       this.defaultVMetrics = properties.defaultVMetrics;

 20132     }

 20134     if (!file) {

 20135       this.missingFile = true;

 20136       // The file data is not specified. Trying to fix the font name

 20137       // to be used with the canvas.font.

 20138       var fontName = name.replace(/[,_]/g, '-');

 20139       var isStandardFont = fontName in stdFontMap;

 20140       fontName = stdFontMap[fontName] || nonStdFontMap[fontName] || fontName;

 20142       this.bold = (fontName.search(/bold/gi) != -1);

 20143       this.italic = ((fontName.search(/oblique/gi) != -1) ||

 20144                      (fontName.search(/italic/gi) != -1));

 20146       // Use 'name' instead of 'fontName' here because the original

 20147       // name ArialBlack for example will be replaced by Helvetica.

 20148       this.black = (name.search(/Black/g) != -1);

 20150       // if at least one width is present, remeasure all chars when exists

 20151       this.remeasure = Object.keys(this.widths).length > 0;

 20152       if (isStandardFont && type === 'CIDFontType2' &&

 20153           properties.cidEncoding.indexOf('Identity-') === 0) {

 20154         // Standard fonts might be embedded as CID font without glyph mapping.

 20155         // Building one based on GlyphMapForStandardFonts.

 20156         var map = [];

 20157         for (var code in GlyphMapForStandardFonts) {

 20158           map[+code] = GlyphMapForStandardFonts[code];

 20159         }

 20160         this.toFontChar = map;

 20161         this.toUnicode = map;

 20162       } else if (/Symbol/i.test(fontName)) {

 20163         var symbols = Encodings.SymbolSetEncoding;

 20164         for (charCode in symbols) {

 20165           var fontChar = GlyphsUnicode[symbols[charCode]];

 20166           if (!fontChar) {

 20167             continue;

 20168           }

 20169           this.toFontChar[charCode] = fontChar;

 20170         }

 20171       } else if (isStandardFont) {

 20172         this.toFontChar = [];

 20173         for (charCode in properties.defaultEncoding) {

 20174           var glyphName = properties.differences[charCode] ||

 20175                           properties.defaultEncoding[charCode];

 20176           this.toFontChar[charCode] = GlyphsUnicode[glyphName];

 20177         }

 20178       } else {

 20179         for (charCode in this.toUnicode) {

 20180           this.toFontChar[charCode] = this.toUnicode[charCode].charCodeAt(0);

 20181         }

 20182       }

 20183       this.loadedName = fontName.split('-')[0];

 20184       this.loading = false;

 20185       return;

 20186     }

 20188     // Some fonts might use wrong font types for Type1C or CIDFontType0C

 20189     var subtype = properties.subtype;

 20190     if (subtype == 'Type1C' && (type != 'Type1' && type != 'MMType1')) {

 20191       type = 'Type1';

 20192     }

 20193     if (subtype == 'CIDFontType0C' && type != 'CIDFontType0') {

 20194       type = 'CIDFontType0';

 20195     }

 20196     // XXX: Temporarily change the type for open type so we trigger a warning.

 20197     // This should be removed when we add support for open type.

 20198     if (subtype === 'OpenType') {

 20199       type = 'OpenType';

 20200     }

 20202     var data;

 20203     switch (type) {

 20204       case 'Type1':

 20205       case 'CIDFontType0':

 20206         this.mimetype = 'font/opentype';

 20208         var cff = (subtype == 'Type1C' || subtype == 'CIDFontType0C') ?

 20209           new CFFFont(file, properties) : new Type1Font(name, file, properties);

 20211         adjustWidths(properties);

 20213         // Wrap the CFF data inside an OTF font file

 20214         data = this.convert(name, cff, properties);

 20215         break;

 20217       case 'OpenType':

 20218       case 'TrueType':

 20219       case 'CIDFontType2':

 20220         this.mimetype = 'font/opentype';

 20222         // Repair the TrueType file. It is can be damaged in the point of

 20223         // view of the sanitizer

 20224         data = this.checkAndRepair(name, file, properties);

 20225         break;

 20227       default:

 20228         error('Font ' + type + ' is not supported');

 20229         break;

 20230     }

 20232     this.data = data;

 20234     // Transfer some properties again that could change during font conversion

 20235     this.fontMatrix = properties.fontMatrix;

 20236     this.widths = properties.widths;

 20237     this.defaultWidth = properties.defaultWidth;

 20238     this.encoding = properties.baseEncoding;

 20239     this.seacMap = properties.seacMap;

 20241     this.loading = true;

 20242   }

 20244   Font.getFontID = (function () {

 20245     var ID = 1;

 20246     return function Font_getFontID() {

 20247       return String(ID++);

 20248     };

 20249   })();

 20251   function int16(b0, b1) {

 20252     return (b0 << 8) + b1;

 20253   }

 20255   function int32(b0, b1, b2, b3) {

 20256     return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;

 20257   }

 20259   function getMaxPower2(number) {

 20260     var maxPower = 0;

 20261     var value = number;

 20262     while (value >= 2) {

 20263       value /= 2;

 20264       maxPower++;

 20265     }

 20267     value = 2;

 20268     for (var i = 1; i < maxPower; i++) {

 20269       value *= 2;

 20270     }

 20271     return value;

 20272   }

 20274   function string16(value) {

 20275     return String.fromCharCode((value >> 8) & 0xff, value & 0xff);

 20276   }

 20278   function safeString16(value) {

 20279     // clamp value to the 16-bit int range

 20280     value = (value > 0x7FFF ? 0x7FFF : (value < -0x8000 ? -0x8000 : value));

 20281     return String.fromCharCode((value >> 8) & 0xff, value & 0xff);

 20282   }

 20284   function createOpenTypeHeader(sfnt, file, numTables) {

 20285     // Windows hates the Mac TrueType sfnt version number

 20286     if (sfnt == 'true') {

 20287       sfnt = string32(0x00010000);

 20288     }

 20290     // sfnt version (4 bytes)

 20291     var header = sfnt;

 20293     // numTables (2 bytes)

 20294     header += string16(numTables);

 20296     // searchRange (2 bytes)

 20297     var tablesMaxPower2 = getMaxPower2(numTables);

 20298     var searchRange = tablesMaxPower2 * 16;

 20299     header += string16(searchRange);

 20301     // entrySelector (2 bytes)

 20302     header += string16(Math.log(tablesMaxPower2) / Math.log(2));

 20304     // rangeShift (2 bytes)

 20305     header += string16(numTables * 16 - searchRange);

 20307     file.file += header;

 20308     file.virtualOffset += header.length;

 20309   }

 20311   function createTableEntry(file, tag, data) {

 20312     // offset

 20313     var offset = file.virtualOffset;

 20315     // length

 20316     var length = data.length;

 20318     // Per spec tables must be 4-bytes align so add padding as needed

 20319     while (data.length & 3) {

 20320       data.push(0x00);

 20321     }

 20322     while (file.virtualOffset & 3) {

 20323       file.virtualOffset++;

 20324     }

 20326     // checksum

 20327     var checksum = 0, n = data.length;

 20328     for (var i = 0; i < n; i += 4) {

 20329       checksum = (checksum + int32(data[i], data[i + 1], data[i + 2],

 20330                                    data[i + 3])) | 0;

 20331     }

 20333     var tableEntry = (tag + string32(checksum) +

 20334                       string32(offset) + string32(length));

 20335     file.file += tableEntry;

 20336     file.virtualOffset += data.length;

 20337   }

 20339   /**

 20340    * Rebuilds the char code to glyph ID map by trying to replace the char codes

 20341    * with their unicode value. It also moves char codes that are in known

 20342    * problematic locations.

 20343    * @return {Object} Two properties:

 20344    * 'toFontChar' - maps original char codes(the value that will be read

 20345    * from commands such as show text) to the char codes that will be used in the

 20346    * font that we build

 20347    * 'charCodeToGlyphId' - maps the new font char codes to glyph ids

 20348    */

 20349   function adjustMapping(charCodeToGlyphId, properties) {

 20350     var toUnicode = properties.toUnicode;

 20351     var isSymbolic = !!(properties.flags & FontFlags.Symbolic);

 20352     var isIdentityUnicode = properties.isIdentityUnicode;

 20353     var newMap = Object.create(null);

 20354     var toFontChar = [];

 20355     var usedFontCharCodes = [];

 20356     var nextAvailableFontCharCode = PRIVATE_USE_OFFSET_START;

 20357     for (var originalCharCode in charCodeToGlyphId) {

 20358       originalCharCode |= 0;

 20359       var glyphId = charCodeToGlyphId[originalCharCode];

 20360       var fontCharCode = originalCharCode;

 20361       // First try to map the value to a unicode position if a non identity map

 20362       // was created.

 20363       if (!isIdentityUnicode && originalCharCode in toUnicode) {

 20364         var unicode = toUnicode[fontCharCode];

 20365         // TODO: Try to map ligatures to the correct spot.

 20366         if (unicode.length === 1) {

 20367           fontCharCode = unicode.charCodeAt(0);

 20368         }

 20369       }

 20370       // Try to move control characters, special characters and already mapped

 20371       // characters to the private use area since they will not be drawn by

 20372       // canvas if left in their current position. Also, move characters if the

 20373       // font was symbolic and there is only an identity unicode map since the

 20374       // characters probably aren't in the correct position (fixes an issue

 20375       // with firefox and thuluthfont).

 20376       if ((fontCharCode in usedFontCharCodes ||

 20377            fontCharCode <= 0x1f || // Control chars

 20378            fontCharCode === 0x7F || // Control char

 20379            fontCharCode === 0xAD || // Soft hyphen

 20380            (fontCharCode >= 0x80 && fontCharCode <= 0x9F) || // Control chars

 20381            (isSymbolic && isIdentityUnicode)) &&

 20382           nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END) { // Room left.

 20383         // Loop to try and find a free spot in the private use area.

 20384         do {

 20385           fontCharCode = nextAvailableFontCharCode++;

 20387           if (SKIP_PRIVATE_USE_RANGE_F000_TO_F01F && fontCharCode === 0xF000) {

 20388             fontCharCode = 0xF020;

 20389             nextAvailableFontCharCode = fontCharCode + 1;

 20390           }

 20392         } while (fontCharCode in usedFontCharCodes &&

 20393                  nextAvailableFontCharCode <= PRIVATE_USE_OFFSET_END);

 20394       }

 20396       newMap[fontCharCode] = glyphId;

 20397       toFontChar[originalCharCode] = fontCharCode;

 20398       usedFontCharCodes[fontCharCode] = true;

 20399     }

 20400     return {

 20401       toFontChar: toFontChar,

 20402       charCodeToGlyphId: newMap,

 20403       nextAvailableFontCharCode: nextAvailableFontCharCode

 20404     };

 20405   }

 20407   function getRanges(glyphs) {

 20408     // Array.sort() sorts by characters, not numerically, so convert to an

 20409     // array of characters.

 20410     var codes = [];

 20411     for (var charCode in glyphs) {

 20412       codes.push({ fontCharCode: charCode | 0, glyphId: glyphs[charCode] });

 20413     }

 20414     codes.sort(function fontGetRangesSort(a, b) {

 20415       return a.fontCharCode - b.fontCharCode;

 20416     });

 20418     // Split the sorted codes into ranges.

 20419     var ranges = [];

 20420     var length = codes.length;

 20421     for (var n = 0; n < length; ) {

 20422       var start = codes[n].fontCharCode;

 20423       var codeIndices = [codes[n].glyphId];

 20424       ++n;

 20425       var end = start;

 20426       while (n < length && end + 1 == codes[n].fontCharCode) {

 20427         codeIndices.push(codes[n].glyphId);

 20428         ++end;

 20429         ++n;

 20430         if (end === 0xFFFF) {

 20431           break;

 20432         }

 20433       }

 20434       ranges.push([start, end, codeIndices]);

 20435     }

 20437     return ranges;

 20438   }

 20440   function createCmapTable(glyphs) {

 20441     var ranges = getRanges(glyphs);

 20442     var numTables = ranges[ranges.length - 1][1] > 0xFFFF ? 2 : 1;

 20443     var cmap = '\x00\x00' + // version

 20444                string16(numTables) +  // numTables

 20445                '\x00\x03' + // platformID

 20446                '\x00\x01' + // encodingID

 20447                string32(4 + numTables * 8); // start of the table record

 20449     var i, ii, j, jj;

 20450     for (i = ranges.length - 1; i >= 0; --i) {

 20451       if (ranges[i][0] <= 0xFFFF) { break; }

 20452     }

 20453     var bmpLength = i + 1;

 20455     if (ranges[i][0] < 0xFFFF && ranges[i][1] === 0xFFFF) {

 20456       ranges[i][1] = 0xFFFE;

 20457     }

 20458     var trailingRangesCount = ranges[i][1] < 0xFFFF ? 1 : 0;

 20459     var segCount = bmpLength + trailingRangesCount;

 20460     var segCount2 = segCount * 2;

 20461     var searchRange = getMaxPower2(segCount) * 2;

 20462     var searchEntry = Math.log(segCount) / Math.log(2);

 20463     var rangeShift = 2 * segCount - searchRange;

 20465     // Fill up the 4 parallel arrays describing the segments.

 20466     var startCount = '';

 20467     var endCount = '';

 20468     var idDeltas = '';

 20469     var idRangeOffsets = '';

 20470     var glyphsIds = '';

 20471     var bias = 0;

 20473     var range, start, end, codes;

 20474     for (i = 0, ii = bmpLength; i < ii; i++) {

 20475       range = ranges[i];

 20476       start = range[0];

 20477       end = range[1];

 20478       startCount += string16(start);

 20479       endCount += string16(end);

 20480       codes = range[2];

 20481       var contiguous = true;

 20482       for (j = 1, jj = codes.length; j < jj; ++j) {

 20483         if (codes[j] !== codes[j - 1] + 1) {

 20484           contiguous = false;

 20485           break;

 20486         }

 20487       }

 20488       if (!contiguous) {

 20489         var offset = (segCount - i) * 2 + bias * 2;

 20490         bias += (end - start + 1);

 20492         idDeltas += string16(0);

 20493         idRangeOffsets += string16(offset);

 20495         for (j = 0, jj = codes.length; j < jj; ++j) {

 20496           glyphsIds += string16(codes[j]);

 20497         }

 20498       } else {

 20499         var startCode = codes[0];

 20501         idDeltas += string16((startCode - start) & 0xFFFF);

 20502         idRangeOffsets += string16(0);

 20503       }

 20504     }

 20506     if (trailingRangesCount > 0) {

 20507       endCount += '\xFF\xFF';

 20508       startCount += '\xFF\xFF';

 20509       idDeltas += '\x00\x01';

 20510       idRangeOffsets += '\x00\x00';

 20511     }

 20513     var format314 = '\x00\x00' + // language

 20514                     string16(segCount2) +

 20515                     string16(searchRange) +

 20516                     string16(searchEntry) +

 20517                     string16(rangeShift) +

 20518                     endCount + '\x00\x00' + startCount +

 20519                     idDeltas + idRangeOffsets + glyphsIds;

 20521     var format31012 = '';

 20522     var header31012 = '';

 20523     if (numTables > 1) {

 20524       cmap += '\x00\x03' + // platformID

 20525               '\x00\x0A' + // encodingID

 20526               string32(4 + numTables * 8 +

 20527                        4 + format314.length); // start of the table record

 20528       format31012 = '';

 20529       for (i = 0, ii = ranges.length; i < ii; i++) {

 20530         range = ranges[i];

 20531         start = range[0];

 20532         codes = range[2];

 20533         var code = codes[0];

 20534         for (j = 1, jj = codes.length; j < jj; ++j) {

 20535           if (codes[j] !== codes[j - 1] + 1) {

 20536             end = range[0] + j - 1;

 20537             format31012 += string32(start) + // startCharCode

 20538                            string32(end) + // endCharCode

 20539                            string32(code); // startGlyphID

 20540             start = end + 1;

 20541             code = codes[j];

 20542           }

 20543         }

 20544         format31012 += string32(start) + // startCharCode

 20545                        string32(range[1]) + // endCharCode

 20546                        string32(code); // startGlyphID

 20547       }

 20548       header31012 = '\x00\x0C' + // format

 20549                     '\x00\x00' + // reserved

 20550                     string32(format31012.length + 16) + // length

 20551                     '\x00\x00\x00\x00' + // language

 20552                     string32(format31012.length / 12); // nGroups

 20553     }

 20555     return stringToArray(cmap +

 20556                          '\x00\x04' + // format

 20557                          string16(format314.length + 4) + // length

 20558                          format314 + header31012 + format31012);

 20559   }

 20561   function validateOS2Table(os2) {

 20562     var stream = new Stream(os2.data);

 20563     var version = stream.getUint16();

 20564     // TODO verify all OS/2 tables fields, but currently we validate only those

 20565     // that give us issues

 20566     stream.getBytes(60); // skipping type, misc sizes, panose, unicode ranges

 20567     var selection = stream.getUint16();

 20568     if (version < 4 && (selection & 0x0300)) {

 20569       return false;

 20570     }

 20571     var firstChar = stream.getUint16();

 20572     var lastChar = stream.getUint16();

 20573     if (firstChar > lastChar) {

 20574       return false;

 20575     }

 20576     stream.getBytes(6); // skipping sTypoAscender/Descender/LineGap

 20577     var usWinAscent = stream.getUint16();

 20578     if (usWinAscent === 0) { // makes font unreadable by windows

 20579       return false;

 20580     }

 20582     // OS/2 appears to be valid, resetting some fields

 20583     os2.data[8] = os2.data[9] = 0; // IE rejects fonts if fsType != 0

 20584     return true;

 20585   }

 20587   function createOS2Table(properties, charstrings, override) {

 20588     override = override || {

 20589       unitsPerEm: 0,

 20590       yMax: 0,

 20591       yMin: 0,

 20592       ascent: 0,

 20593       descent: 0

 20594     };

 20596     var ulUnicodeRange1 = 0;

 20597     var ulUnicodeRange2 = 0;

 20598     var ulUnicodeRange3 = 0;

 20599     var ulUnicodeRange4 = 0;

 20601     var firstCharIndex = null;

 20602     var lastCharIndex = 0;

 20604     if (charstrings) {

 20605       for (var code in charstrings) {

 20606         code |= 0;

 20607         if (firstCharIndex > code || !firstCharIndex) {

 20608           firstCharIndex = code;

 20609         }

 20610         if (lastCharIndex < code) {

 20611           lastCharIndex = code;

 20612         }

 20614         var position = getUnicodeRangeFor(code);

 20615         if (position < 32) {

 20616           ulUnicodeRange1 |= 1 << position;

 20617         } else if (position < 64) {

 20618           ulUnicodeRange2 |= 1 << position - 32;

 20619         } else if (position < 96) {

 20620           ulUnicodeRange3 |= 1 << position - 64;

 20621         } else if (position < 123) {

 20622           ulUnicodeRange4 |= 1 << position - 96;

 20623         } else {

 20624           error('Unicode ranges Bits > 123 are reserved for internal usage');

 20625         }

 20626       }

 20627     } else {

 20628       // TODO

 20629       firstCharIndex = 0;

 20630       lastCharIndex = 255;

 20631     }

 20633     var bbox = properties.bbox || [0, 0, 0, 0];

 20634     var unitsPerEm = (override.unitsPerEm ||

 20635                       1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0]);

 20637     // if the font units differ to the PDF glyph space units

 20638     // then scale up the values

 20639     var scale = (properties.ascentScaled ? 1.0 :

 20640                  unitsPerEm / PDF_GLYPH_SPACE_UNITS);

 20642     var typoAscent = (override.ascent ||

 20643                       Math.round(scale * (properties.ascent || bbox[3])));

 20644     var typoDescent = (override.descent ||

 20645                        Math.round(scale * (properties.descent || bbox[1])));

 20646     if (typoDescent > 0 && properties.descent > 0 && bbox[1] < 0) {

 20647       typoDescent = -typoDescent; // fixing incorrect descent

 20648     }

 20649     var winAscent = override.yMax || typoAscent;

 20650     var winDescent = -override.yMin || -typoDescent;

 20652     return '\x00\x03' + // version

 20653            '\x02\x24' + // xAvgCharWidth

 20654            '\x01\xF4' + // usWeightClass

 20655            '\x00\x05' + // usWidthClass

 20656            '\x00\x00' + // fstype (0 to let the font loads via font-face on IE)

 20657            '\x02\x8A' + // ySubscriptXSize

 20658            '\x02\xBB' + // ySubscriptYSize

 20659            '\x00\x00' + // ySubscriptXOffset

 20660            '\x00\x8C' + // ySubscriptYOffset

 20661            '\x02\x8A' + // ySuperScriptXSize

 20662            '\x02\xBB' + // ySuperScriptYSize

 20663            '\x00\x00' + // ySuperScriptXOffset

 20664            '\x01\xDF' + // ySuperScriptYOffset

 20665            '\x00\x31' + // yStrikeOutSize

 20666            '\x01\x02' + // yStrikeOutPosition

 20667            '\x00\x00' + // sFamilyClass

 20668            '\x00\x00\x06' +

 20669            String.fromCharCode(properties.fixedPitch ? 0x09 : 0x00) +

 20670            '\x00\x00\x00\x00\x00\x00' + // Panose

 20671            string32(ulUnicodeRange1) + // ulUnicodeRange1 (Bits 0-31)

 20672            string32(ulUnicodeRange2) + // ulUnicodeRange2 (Bits 32-63)

 20673            string32(ulUnicodeRange3) + // ulUnicodeRange3 (Bits 64-95)

 20674            string32(ulUnicodeRange4) + // ulUnicodeRange4 (Bits 96-127)

 20675            '\x2A\x32\x31\x2A' + // achVendID

 20676            string16(properties.italicAngle ? 1 : 0) + // fsSelection

 20677            string16(firstCharIndex ||

 20678                     properties.firstChar) + // usFirstCharIndex

 20679            string16(lastCharIndex || properties.lastChar) +  // usLastCharIndex

 20680            string16(typoAscent) + // sTypoAscender

 20681            string16(typoDescent) + // sTypoDescender

 20682            '\x00\x64' + // sTypoLineGap (7%-10% of the unitsPerEM value)

 20683            string16(winAscent) + // usWinAscent

 20684            string16(winDescent) + // usWinDescent

 20685            '\x00\x00\x00\x00' + // ulCodePageRange1 (Bits 0-31)

 20686            '\x00\x00\x00\x00' + // ulCodePageRange2 (Bits 32-63)

 20687            string16(properties.xHeight) + // sxHeight

 20688            string16(properties.capHeight) + // sCapHeight

 20689            string16(0) + // usDefaultChar

 20690            string16(firstCharIndex || properties.firstChar) + // usBreakChar

 20691            '\x00\x03';  // usMaxContext

 20692   }

 20694   function createPostTable(properties) {

 20695     var angle = Math.floor(properties.italicAngle * (Math.pow(2, 16)));

 20696     return ('\x00\x03\x00\x00' + // Version number

 20697             string32(angle) + // italicAngle

 20698             '\x00\x00' + // underlinePosition

 20699             '\x00\x00' + // underlineThickness

 20700             string32(properties.fixedPitch) + // isFixedPitch

 20701             '\x00\x00\x00\x00' + // minMemType42

 20702             '\x00\x00\x00\x00' + // maxMemType42

 20703             '\x00\x00\x00\x00' + // minMemType1

 20704             '\x00\x00\x00\x00');  // maxMemType1

 20705   }

 20707   function createNameTable(name, proto) {

 20708     if (!proto) {

 20709       proto = [[], []]; // no strings and unicode strings

 20710     }

 20712     var strings = [

 20713       proto[0][0] || 'Original licence',  // 0.Copyright

 20714       proto[0][1] || name,                // 1.Font family

 20715       proto[0][2] || 'Unknown',           // 2.Font subfamily (font weight)

 20716       proto[0][3] || 'uniqueID',          // 3.Unique ID

 20717       proto[0][4] || name,                // 4.Full font name

 20718       proto[0][5] || 'Version 0.11',      // 5.Version

 20719       proto[0][6] || '',                  // 6.Postscript name

 20720       proto[0][7] || 'Unknown',           // 7.Trademark

 20721       proto[0][8] || 'Unknown',           // 8.Manufacturer

 20722       proto[0][9] || 'Unknown'            // 9.Designer

 20723     ];

 20725     // Mac want 1-byte per character strings while Windows want

 20726     // 2-bytes per character, so duplicate the names table

 20727     var stringsUnicode = [];

 20728     var i, ii, j, jj, str;

 20729     for (i = 0, ii = strings.length; i < ii; i++) {

 20730       str = proto[1][i] || strings[i];

 20732       var strBufUnicode = [];

 20733       for (j = 0, jj = str.length; j < jj; j++) {

 20734         strBufUnicode.push(string16(str.charCodeAt(j)));

 20735       }

 20736       stringsUnicode.push(strBufUnicode.join(''));

 20737     }

 20739     var names = [strings, stringsUnicode];

 20740     var platforms = ['\x00\x01', '\x00\x03'];

 20741     var encodings = ['\x00\x00', '\x00\x01'];

 20742     var languages = ['\x00\x00', '\x04\x09'];

 20744     var namesRecordCount = strings.length * platforms.length;

 20745     var nameTable =

 20746       '\x00\x00' +                           // format

 20747       string16(namesRecordCount) +           // Number of names Record

 20748       string16(namesRecordCount * 12 + 6);   // Storage

 20750     // Build the name records field

 20751     var strOffset = 0;

 20752     for (i = 0, ii = platforms.length; i < ii; i++) {

 20753       var strs = names[i];

 20754       for (j = 0, jj = strs.length; j < jj; j++) {

 20755         str = strs[j];

 20756         var nameRecord =

 20757           platforms[i] + // platform ID

 20758           encodings[i] + // encoding ID

 20759           languages[i] + // language ID

 20760           string16(j) + // name ID

 20761           string16(str.length) +

 20762           string16(strOffset);

 20763         nameTable += nameRecord;

 20764         strOffset += str.length;

 20765       }

 20766     }

 20768     nameTable += strings.join('') + stringsUnicode.join('');

 20769     return nameTable;

 20770   }

 20772   Font.prototype = {

 20773     name: null,

 20774     font: null,

 20775     mimetype: null,

 20776     encoding: null,

 20777     get renderer() {

 20778       var renderer = FontRendererFactory.create(this);

 20779       return shadow(this, 'renderer', renderer);

 20780     },

 20782     exportData: function Font_exportData() {

 20783       var data = {};

 20784       for (var i in this) {

 20785         if (this.hasOwnProperty(i)) {

 20786           data[i] = this[i];

 20787         }

 20788       }

 20789       return data;

 20790     },

 20792     checkAndRepair: function Font_checkAndRepair(name, font, properties) {

 20793       function readTableEntry(file) {

 20794         var tag = bytesToString(file.getBytes(4));

 20796         var checksum = file.getInt32();

 20797         var offset = file.getInt32() >>> 0;

 20798         var length = file.getInt32() >>> 0;

 20800         // Read the table associated data

 20801         var previousPosition = file.pos;

 20802         file.pos = file.start ? file.start : 0;

 20803         file.skip(offset);

 20804         var data = file.getBytes(length);

 20805         file.pos = previousPosition;

 20807         if (tag == 'head') {

 20808           // clearing checksum adjustment

 20809           data[8] = data[9] = data[10] = data[11] = 0;

 20810           data[17] |= 0x20; //Set font optimized for cleartype flag

 20811         }

 20813         return {

 20814           tag: tag,

 20815           checksum: checksum,

 20816           length: length,

 20817           offset: offset,

 20818           data: data

 20819         };

 20820       }

 20822       function readOpenTypeHeader(ttf) {

 20823         return {

 20824           version: bytesToString(ttf.getBytes(4)),

 20825           numTables: ttf.getUint16(),

 20826           searchRange: ttf.getUint16(),

 20827           entrySelector: ttf.getUint16(),

 20828           rangeShift: ttf.getUint16()

 20829         };

 20830       }

 20832       /**

 20833        * Read the appropriate subtable from the cmap according to 9.6.6.4 from

 20834        * PDF spec

 20835        */

 20836       function readCmapTable(cmap, font, isSymbolicFont) {

 20837         var segment;

 20838         var start = (font.start ? font.start : 0) + cmap.offset;

 20839         font.pos = start;

 20841         var version = font.getUint16();

 20842         var numTables = font.getUint16();

 20844         var potentialTable;

 20845         var canBreak = false;

 20846         // There's an order of preference in terms of which cmap subtable to

 20847         // use:

 20848         // - non-symbolic fonts the preference is a 3,1 table then a 1,0 table

 20849         // - symbolic fonts the preference is a 3,0 table then a 1,0 table

 20850         // The following takes advantage of the fact that the tables are sorted

 20851         // to work.

 20852         for (var i = 0; i < numTables; i++) {

 20853           var platformId = font.getUint16();

 20854           var encodingId = font.getUint16();

 20855           var offset = font.getInt32() >>> 0;

 20856           var useTable = false;

 20858           if (platformId == 1 && encodingId === 0) {

 20859             useTable = true;

 20860             // Continue the loop since there still may be a higher priority

 20861             // table.

 20862           } else if (!isSymbolicFont && platformId === 3 && encodingId === 1) {

 20863             useTable = true;

 20864             canBreak = true;

 20865           } else if (isSymbolicFont && platformId === 3 && encodingId === 0) {

 20866             useTable = true;

 20867             canBreak = true;

 20868           }

 20870           if (useTable) {

 20871             potentialTable = {

 20872               platformId: platformId,

 20873               encodingId: encodingId,

 20874               offset: offset

 20875             };

 20876           }

 20877           if (canBreak) {

 20878             break;

 20879           }

 20880         }

 20882         if (!potentialTable) {

 20883           warn('Could not find a preferred cmap table.');

 20884           return {

 20885             platformId: -1,

 20886             encodingId: -1,

 20887             mappings: [],

 20888             hasShortCmap: false

 20889           };

 20890         }

 20892         font.pos = start + potentialTable.offset;

 20893         var format = font.getUint16();

 20894         var length = font.getUint16();

 20895         var language = font.getUint16();

 20897         var hasShortCmap = false;

 20898         var mappings = [];

 20899         var j, glyphId;

 20901         // TODO(mack): refactor this cmap subtable reading logic out

 20902         if (format === 0) {

 20903           for (j = 0; j < 256; j++) {

 20904             var index = font.getByte();

 20905             if (!index) {

 20906               continue;

 20907             }

 20908             mappings.push({

 20909               charCode: j,

 20910               glyphId: index

 20911             });

 20912           }

 20913           hasShortCmap = true;

 20914         } else if (format === 4) {

 20915           // re-creating the table in format 4 since the encoding

 20916           // might be changed

 20917           var segCount = (font.getUint16() >> 1);

 20918           font.getBytes(6); // skipping range fields

 20919           var segIndex, segments = [];

 20920           for (segIndex = 0; segIndex < segCount; segIndex++) {

 20921             segments.push({ end: font.getUint16() });

 20922           }

 20923           font.getUint16();

 20924           for (segIndex = 0; segIndex < segCount; segIndex++) {

 20925             segments[segIndex].start = font.getUint16();

 20926           }

 20928           for (segIndex = 0; segIndex < segCount; segIndex++) {

 20929             segments[segIndex].delta = font.getUint16();

 20930           }

 20932           var offsetsCount = 0;

 20933           for (segIndex = 0; segIndex < segCount; segIndex++) {

 20934             segment = segments[segIndex];

 20935             var rangeOffset = font.getUint16();

 20936             if (!rangeOffset) {

 20937               segment.offsetIndex = -1;

 20938               continue;

 20939             }

 20941             var offsetIndex = (rangeOffset >> 1) - (segCount - segIndex);

 20942             segment.offsetIndex = offsetIndex;

 20943             offsetsCount = Math.max(offsetsCount, offsetIndex +

 20944                                     segment.end - segment.start + 1);

 20945           }

 20947           var offsets = [];

 20948           for (j = 0; j < offsetsCount; j++) {

 20949             offsets.push(font.getUint16());

 20950           }

 20952           for (segIndex = 0; segIndex < segCount; segIndex++) {

 20953             segment = segments[segIndex];

 20954             start = segment.start;

 20955             var end = segment.end;

 20956             var delta = segment.delta;

 20957             offsetIndex = segment.offsetIndex;

 20959             for (j = start; j <= end; j++) {

 20960               if (j == 0xFFFF) {

 20961                 continue;

 20962               }

 20964               glyphId = (offsetIndex < 0 ?

 20965                          j : offsets[offsetIndex + j - start]);

 20966               glyphId = (glyphId + delta) & 0xFFFF;

 20967               if (glyphId === 0) {

 20968                 continue;

 20969               }

 20970               mappings.push({

 20971                 charCode: j,

 20972                 glyphId: glyphId

 20973               });

 20974             }

 20975           }

 20976         } else if (format == 6) {

 20977           // Format 6 is a 2-bytes dense mapping, which means the font data

 20978           // lives glue together even if they are pretty far in the unicode

 20979           // table. (This looks weird, so I can have missed something), this

 20980           // works on Linux but seems to fails on Mac so let's rewrite the

 20981           // cmap table to a 3-1-4 style

 20982           var firstCode = font.getUint16();

 20983           var entryCount = font.getUint16();

 20985           for (j = 0; j < entryCount; j++) {

 20986             glyphId = font.getUint16();

 20987             var charCode = firstCode + j;

 20989             mappings.push({

 20990               charCode: charCode,

 20991               glyphId: glyphId

 20992             });

 20993           }

 20994         } else {

 20995           error('cmap table has unsupported format: ' + format);

 20996         }

 20998         // removing duplicate entries

 20999         mappings.sort(function (a, b) {

 21000           return a.charCode - b.charCode;

 21001         });

 21002         for (i = 1; i < mappings.length; i++) {

 21003           if (mappings[i - 1].charCode === mappings[i].charCode) {

 21004             mappings.splice(i, 1);

 21005             i--;

 21006           }

 21007         }

 21009         return {

 21010           platformId: potentialTable.platformId,

 21011           encodingId: potentialTable.encodingId,

 21012           mappings: mappings,

 21013           hasShortCmap: hasShortCmap

 21014         };

 21015       }

 21017       function sanitizeMetrics(font, header, metrics, numGlyphs) {

 21018         if (!header) {

 21019           if (metrics) {

 21020             metrics.data = null;

 21021           }

 21022           return;

 21023         }

 21025         font.pos = (font.start ? font.start : 0) + header.offset;

 21026         font.pos += header.length - 2;

 21027         var numOfMetrics = font.getUint16();

 21029         if (numOfMetrics > numGlyphs) {

 21030           info('The numOfMetrics (' + numOfMetrics + ') should not be ' +

 21031                'greater than the numGlyphs (' + numGlyphs + ')');

 21032           // Reduce numOfMetrics if it is greater than numGlyphs

 21033           numOfMetrics = numGlyphs;

 21034           header.data[34] = (numOfMetrics & 0xff00) >> 8;

 21035           header.data[35] = numOfMetrics & 0x00ff;

 21036         }

 21038         var numOfSidebearings = numGlyphs - numOfMetrics;

 21039         var numMissing = numOfSidebearings -

 21040           ((metrics.length - numOfMetrics * 4) >> 1);

 21042         var i, ii;

 21043         if (numMissing > 0) {

 21044           font.pos = (font.start ? font.start : 0) + metrics.offset;

 21045           var entries = '';

 21046           for (i = 0, ii = metrics.length; i < ii; i++) {

 21047             entries += String.fromCharCode(font.getByte());

 21048           }

 21049           for (i = 0; i < numMissing; i++) {

 21050             entries += '\x00\x00';

 21051           }

 21052           metrics.data = stringToArray(entries);

 21053         }

 21054       }

 21056       function sanitizeGlyph(source, sourceStart, sourceEnd, dest, destStart,

 21057                              hintsValid) {

 21058         if (sourceEnd - sourceStart <= 12) {

 21059           // glyph with data less than 12 is invalid one

 21060           return 0;

 21061         }

 21062         var glyf = source.subarray(sourceStart, sourceEnd);

 21063         var contoursCount = (glyf[0] << 8) | glyf[1];

 21064         if (contoursCount & 0x8000) {

 21065           // complex glyph, writing as is

 21066           dest.set(glyf, destStart);

 21067           return glyf.length;

 21068         }

 21070         var i, j = 10, flagsCount = 0;

 21071         for (i = 0; i < contoursCount; i++) {

 21072           var endPoint = (glyf[j] << 8) | glyf[j + 1];

 21073           flagsCount = endPoint + 1;

 21074           j += 2;

 21075         }

 21076         // skipping instructions

 21077         var instructionsStart = j;

 21078         var instructionsLength = (glyf[j] << 8) | glyf[j + 1];

 21079         j += 2 + instructionsLength;

 21080         var instructionsEnd = j;

 21081         // validating flags

 21082         var coordinatesLength = 0;

 21083         for (i = 0; i < flagsCount; i++) {

 21084           var flag = glyf[j++];

 21085           if (flag & 0xC0) {

 21086             // reserved flags must be zero, cleaning up

 21087             glyf[j - 1] = flag & 0x3F;

 21088           }

 21089           var xyLength = ((flag & 2) ? 1 : (flag & 16) ? 0 : 2) +

 21090                          ((flag & 4) ? 1 : (flag & 32) ? 0 : 2);

 21091           coordinatesLength += xyLength;

 21092           if (flag & 8) {

 21093             var repeat = glyf[j++];

 21094             i += repeat;

 21095             coordinatesLength += repeat * xyLength;

 21096           }

 21097         }

 21098         // glyph without coordinates will be rejected

 21099         if (coordinatesLength === 0) {

 21100           return 0;

 21101         }

 21102         var glyphDataLength = j + coordinatesLength;

 21103         if (glyphDataLength > glyf.length) {

 21104           // not enough data for coordinates

 21105           return 0;

 21106         }

 21107         if (!hintsValid && instructionsLength > 0) {

 21108           dest.set(glyf.subarray(0, instructionsStart), destStart);

 21109           dest.set([0, 0], destStart + instructionsStart);

 21110           dest.set(glyf.subarray(instructionsEnd, glyphDataLength),

 21111                    destStart + instructionsStart + 2);

 21112           glyphDataLength -= instructionsLength;

 21113           if (glyf.length - glyphDataLength > 3) {

 21114             glyphDataLength = (glyphDataLength + 3) & ~3;

 21115           }

 21116           return glyphDataLength;

 21117         }

 21118         if (glyf.length - glyphDataLength > 3) {

 21119           // truncating and aligning to 4 bytes the long glyph data

 21120           glyphDataLength = (glyphDataLength + 3) & ~3;

 21121           dest.set(glyf.subarray(0, glyphDataLength), destStart);

 21122           return glyphDataLength;

 21123         }

 21124         // glyph data is fine

 21125         dest.set(glyf, destStart);

 21126         return glyf.length;

 21127       }

 21129       function sanitizeHead(head, numGlyphs, locaLength) {

 21130         var data = head.data;

 21132         // Validate version:

 21133         // Should always be 0x00010000

 21134         var version = int32(data[0], data[1], data[2], data[3]);

 21135         if (version >> 16 !== 1) {

 21136           info('Attempting to fix invalid version in head table: ' + version);

 21137           data[0] = 0;

 21138           data[1] = 1;

 21139           data[2] = 0;

 21140           data[3] = 0;

 21141         }

 21143         var indexToLocFormat = int16(data[50], data[51]);

 21144         if (indexToLocFormat < 0 || indexToLocFormat > 1) {

 21145           info('Attempting to fix invalid indexToLocFormat in head table: ' +

 21146                indexToLocFormat);

 21148           // The value of indexToLocFormat should be 0 if the loca table

 21149           // consists of short offsets, and should be 1 if the loca table

 21150           // consists of long offsets.

 21151           //

 21152           // The number of entries in the loca table should be numGlyphs + 1.

 21153           //

 21154           // Using this information, we can work backwards to deduce if the

 21155           // size of each offset in the loca table, and thus figure out the

 21156           // appropriate value for indexToLocFormat.

 21158           var numGlyphsPlusOne = numGlyphs + 1;

 21159           if (locaLength === numGlyphsPlusOne << 1) {

 21160             // 0x0000 indicates the loca table consists of short offsets

 21161             data[50] = 0;

 21162             data[51] = 0;

 21163           } else if (locaLength === numGlyphsPlusOne << 2) {

 21164             // 0x0001 indicates the loca table consists of long offsets

 21165             data[50] = 0;

 21166             data[51] = 1;

 21167           } else {

 21168             warn('Could not fix indexToLocFormat: ' + indexToLocFormat);

 21169           }

 21170         }

 21171       }

 21173       function sanitizeGlyphLocations(loca, glyf, numGlyphs,

 21174                                       isGlyphLocationsLong, hintsValid,

 21175                                       dupFirstEntry) {

 21176         var itemSize, itemDecode, itemEncode;

 21177         if (isGlyphLocationsLong) {

 21178           itemSize = 4;

 21179           itemDecode = function fontItemDecodeLong(data, offset) {

 21180             return (data[offset] << 24) | (data[offset + 1] << 16) |

 21181                    (data[offset + 2] << 8) | data[offset + 3];

 21182           };

 21183           itemEncode = function fontItemEncodeLong(data, offset, value) {

 21184             data[offset] = (value >>> 24) & 0xFF;

 21185             data[offset + 1] = (value >> 16) & 0xFF;

 21186             data[offset + 2] = (value >> 8) & 0xFF;

 21187             data[offset + 3] = value & 0xFF;

 21188           };

 21189         } else {

 21190           itemSize = 2;

 21191           itemDecode = function fontItemDecode(data, offset) {

 21192             return (data[offset] << 9) | (data[offset + 1] << 1);

 21193           };

 21194           itemEncode = function fontItemEncode(data, offset, value) {

 21195             data[offset] = (value >> 9) & 0xFF;

 21196             data[offset + 1] = (value >> 1) & 0xFF;

 21197           };

 21198         }

 21199         var locaData = loca.data;

 21200         var locaDataSize = itemSize * (1 + numGlyphs);

 21201         // is loca.data too short or long?

 21202         if (locaData.length !== locaDataSize) {

 21203           locaData = new Uint8Array(locaDataSize);

 21204           locaData.set(loca.data.subarray(0, locaDataSize));

 21205           loca.data = locaData;

 21206         }

 21207         // removing the invalid glyphs

 21208         var oldGlyfData = glyf.data;

 21209         var oldGlyfDataLength = oldGlyfData.length;

 21210         var newGlyfData = new Uint8Array(oldGlyfDataLength);

 21211         var startOffset = itemDecode(locaData, 0);

 21212         var writeOffset = 0;

 21213         itemEncode(locaData, 0, writeOffset);

 21214         var i, j;

 21215         for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {

 21216           var endOffset = itemDecode(locaData, j);

 21217           if (endOffset > oldGlyfDataLength &&

 21218               ((oldGlyfDataLength + 3) & ~3) === endOffset) {

 21219             // Aspose breaks fonts by aligning the glyphs to the qword, but not

 21220             // the glyf table size, which makes last glyph out of range.

 21221             endOffset = oldGlyfDataLength;

 21222           }

 21223           if (endOffset > oldGlyfDataLength) {

 21224             // glyph end offset points outside glyf data, rejecting the glyph

 21225             itemEncode(locaData, j, writeOffset);

 21226             startOffset = endOffset;

 21227             continue;

 21228           }

 21230           var newLength = sanitizeGlyph(oldGlyfData, startOffset, endOffset,

 21231                                         newGlyfData, writeOffset, hintsValid);

 21232           writeOffset += newLength;

 21233           itemEncode(locaData, j, writeOffset);

 21234           startOffset = endOffset;

 21235         }

 21237         if (writeOffset === 0) {

 21238           // glyf table cannot be empty -- redoing the glyf and loca tables

 21239           // to have single glyph with one point

 21240           var simpleGlyph = new Uint8Array(

 21241             [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0]);

 21242           for (i = 0, j = itemSize; i < numGlyphs; i++, j += itemSize) {

 21243             itemEncode(locaData, j, simpleGlyph.length);

 21244           }

 21245           glyf.data = simpleGlyph;

 21246           return;

 21247         }

 21249         if (dupFirstEntry) {

 21250           var firstEntryLength = itemDecode(locaData, itemSize);

 21251           if (newGlyfData.length > firstEntryLength + writeOffset) {

 21252             glyf.data = newGlyfData.subarray(0, firstEntryLength + writeOffset);

 21253           } else {

 21254             glyf.data = new Uint8Array(firstEntryLength + writeOffset);

 21255             glyf.data.set(newGlyfData.subarray(0, writeOffset));

 21256           }

 21257           glyf.data.set(newGlyfData.subarray(0, firstEntryLength), writeOffset);

 21258           itemEncode(loca.data, locaData.length - itemSize,

 21259                      writeOffset + firstEntryLength);

 21260         } else {

 21261           glyf.data = newGlyfData.subarray(0, writeOffset);

 21262         }

 21263       }

 21265       function readPostScriptTable(post, properties, maxpNumGlyphs) {

 21266         var start = (font.start ? font.start : 0) + post.offset;

 21267         font.pos = start;

 21269         var length = post.length, end = start + length;

 21270         var version = font.getInt32();

 21271         // skip rest to the tables

 21272         font.getBytes(28);

 21274         var glyphNames;

 21275         var valid = true;

 21276         var i;

 21278         switch (version) {

 21279           case 0x00010000:

 21280             glyphNames = MacStandardGlyphOrdering;

 21281             break;

 21282           case 0x00020000:

 21283             var numGlyphs = font.getUint16();

 21284             if (numGlyphs != maxpNumGlyphs) {

 21285               valid = false;

 21286               break;

 21287             }

 21288             var glyphNameIndexes = [];

 21289             for (i = 0; i < numGlyphs; ++i) {

 21290               var index = font.getUint16();

 21291               if (index >= 32768) {

 21292                 valid = false;

 21293                 break;

 21294               }

 21295               glyphNameIndexes.push(index);

 21296             }

 21297             if (!valid) {

 21298               break;

 21299             }

 21300             var customNames = [];

 21301             while (font.pos < end) {

 21302               var stringLength = font.getByte();

 21303               var string = '';

 21304               for (i = 0; i < stringLength; ++i) {

 21305                 string += String.fromCharCode(font.getByte());

 21306               }

 21307               customNames.push(string);

 21308             }

 21309             glyphNames = [];

 21310             for (i = 0; i < numGlyphs; ++i) {

 21311               var j = glyphNameIndexes[i];

 21312               if (j < 258) {

 21313                 glyphNames.push(MacStandardGlyphOrdering[j]);

 21314                 continue;

 21315               }

 21316               glyphNames.push(customNames[j - 258]);

 21317             }

 21318             break;

 21319           case 0x00030000:

 21320             break;

 21321           default:

 21322             warn('Unknown/unsupported post table version ' + version);

 21323             valid = false;

 21324             break;

 21325         }

 21326         properties.glyphNames = glyphNames;

 21327         return valid;

 21328       }

 21330       function readNameTable(nameTable) {

 21331         var start = (font.start ? font.start : 0) + nameTable.offset;

 21332         font.pos = start;

 21334         var names = [[], []];

 21335         var length = nameTable.length, end = start + length;

 21336         var format = font.getUint16();

 21337         var FORMAT_0_HEADER_LENGTH = 6;

 21338         if (format !== 0 || length < FORMAT_0_HEADER_LENGTH) {

 21339           // unsupported name table format or table "too" small

 21340           return names;

 21341         }

 21342         var numRecords = font.getUint16();

 21343         var stringsStart = font.getUint16();

 21344         var records = [];

 21345         var NAME_RECORD_LENGTH = 12;

 21346         var i, ii;

 21348         for (i = 0; i < numRecords &&

 21349                         font.pos + NAME_RECORD_LENGTH <= end; i++) {

 21350           var r = {

 21351             platform: font.getUint16(),

 21352             encoding: font.getUint16(),

 21353             language: font.getUint16(),

 21354             name: font.getUint16(),

 21355             length: font.getUint16(),

 21356             offset: font.getUint16()

 21357           };

 21358           // using only Macintosh and Windows platform/encoding names

 21359           if ((r.platform == 1 && r.encoding === 0 && r.language === 0) ||

 21360               (r.platform == 3 && r.encoding == 1 && r.language == 0x409)) {

 21361             records.push(r);

 21362           }

 21363         }

 21364         for (i = 0, ii = records.length; i < ii; i++) {

 21365           var record = records[i];

 21366           var pos = start + stringsStart + record.offset;

 21367           if (pos + record.length > end) {

 21368             continue; // outside of name table, ignoring

 21369           }

 21370           font.pos = pos;

 21371           var nameIndex = record.name;

 21372           if (record.encoding) {

 21373             // unicode

 21374             var str = '';

 21375             for (var j = 0, jj = record.length; j < jj; j += 2) {

 21376               str += String.fromCharCode(font.getUint16());

 21377             }

 21378             names[1][nameIndex] = str;

 21379           } else {

 21380             names[0][nameIndex] = bytesToString(font.getBytes(record.length));

 21381           }

 21382         }

 21383         return names;

 21384       }

 21386       var TTOpsStackDeltas = [

 21387         0, 0, 0, 0, 0, 0, 0, 0, -2, -2, -2, -2, 0, 0, -2, -5,

 21388         -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, -1, -1,

 21389         1, -1, -999, 0, 1, 0, -1, -2, 0, -1, -2, -1, -1, 0, -1, -1,

 21390         0, 0, -999, -999, -1, -1, -1, -1, -2, -999, -2, -2, -999, 0, -2, -2,

 21391         0, 0, -2, 0, -2, 0, 0, 0, -2, -1, -1, 1, 1, 0, 0, -1,

 21392         -1, -1, -1, -1, -1, -1, 0, 0, -1, 0, -1, -1, 0, -999, -1, -1,

 21393         -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

 21394         -2, -999, -999, -999, -999, -999, -1, -1, -2, -2, 0, 0, 0, 0, -1, -1,

 21395         -999, -2, -2, 0, 0, -1, -2, -2, 0, 0, 0, -1, -1, -1, -2];

 21396         // 0xC0-DF == -1 and 0xE0-FF == -2

 21398       function sanitizeTTProgram(table, ttContext) {

 21399         var data = table.data;

 21400         var i = 0, j, n, b, funcId, pc, lastEndf = 0, lastDeff = 0;

 21401         var stack = [];

 21402         var callstack = [];

 21403         var functionsCalled = [];

 21404         var tooComplexToFollowFunctions =

 21405           ttContext.tooComplexToFollowFunctions;

 21406         var inFDEF = false, ifLevel = 0, inELSE = 0;

 21407         for (var ii = data.length; i < ii;) {

 21408           var op = data[i++];

 21409           // The TrueType instruction set docs can be found at

 21410           // https://developer.apple.com/fonts/TTRefMan/RM05/Chap5.html

 21411           if (op === 0x40) { // NPUSHB - pushes n bytes

 21412             n = data[i++];

 21413             if (inFDEF || inELSE) {

 21414               i += n;

 21415             } else {

 21416               for (j = 0; j < n; j++) {

 21417                 stack.push(data[i++]);

 21418               }

 21419             }

 21420           } else if (op === 0x41) { // NPUSHW - pushes n words

 21421             n = data[i++];

 21422             if (inFDEF || inELSE) {

 21423               i += n * 2;

 21424             } else {

 21425               for (j = 0; j < n; j++) {

 21426                 b = data[i++];

 21427                 stack.push((b << 8) | data[i++]);

 21428               }

 21429             }

 21430           } else if ((op & 0xF8) === 0xB0) { // PUSHB - pushes bytes

 21431             n = op - 0xB0 + 1;

 21432             if (inFDEF || inELSE) {

 21433               i += n;

 21434             } else {

 21435               for (j = 0; j < n; j++) {

 21436                 stack.push(data[i++]);

 21437               }

 21438             }

 21439           } else if ((op & 0xF8) === 0xB8) { // PUSHW - pushes words

 21440             n = op - 0xB8 + 1;

 21441             if (inFDEF || inELSE) {

 21442               i += n * 2;

 21443             } else {

 21444               for (j = 0; j < n; j++) {

 21445                 b = data[i++];

 21446                 stack.push((b << 8) | data[i++]);

 21447               }

 21448             }

 21449           } else if (op === 0x2B && !tooComplexToFollowFunctions) { // CALL

 21450             if (!inFDEF && !inELSE) {

 21451               // collecting inforamtion about which functions are used

 21452               funcId = stack[stack.length - 1];

 21453               ttContext.functionsUsed[funcId] = true;

 21454               if (funcId in ttContext.functionsStackDeltas) {

 21455                 stack.length += ttContext.functionsStackDeltas[funcId];

 21456               } else if (funcId in ttContext.functionsDefined &&

 21457                          functionsCalled.indexOf(funcId) < 0) {

 21458                 callstack.push({data: data, i: i, stackTop: stack.length - 1});

 21459                 functionsCalled.push(funcId);

 21460                 pc = ttContext.functionsDefined[funcId];

 21461                 if (!pc) {

 21462                   warn('TT: CALL non-existent function');

 21463                   ttContext.hintsValid = false;

 21464                   return;

 21465                 }

 21466                 data = pc.data;

 21467                 i = pc.i;

 21468               }

 21469             }

 21470           } else if (op === 0x2C && !tooComplexToFollowFunctions) { // FDEF

 21471             if (inFDEF || inELSE) {

 21472               warn('TT: nested FDEFs not allowed');

 21473               tooComplexToFollowFunctions = true;

 21474             }

 21475             inFDEF = true;

 21476             // collecting inforamtion about which functions are defined

 21477             lastDeff = i;

 21478             funcId = stack.pop();

 21479             ttContext.functionsDefined[funcId] = {data: data, i: i};

 21480           } else if (op === 0x2D) { // ENDF - end of function

 21481             if (inFDEF) {

 21482               inFDEF = false;

 21483               lastEndf = i;

 21484             } else {

 21485               pc = callstack.pop();

 21486               if (!pc) {

 21487                 warn('TT: ENDF bad stack');

 21488                 ttContext.hintsValid = false;

 21489                 return;

 21490               }

 21491               funcId = functionsCalled.pop();

 21492               data = pc.data;

 21493               i = pc.i;

 21494               ttContext.functionsStackDeltas[funcId] =

 21495                 stack.length - pc.stackTop;

 21496             }

 21497           } else if (op === 0x89) { // IDEF - instruction definition

 21498             if (inFDEF || inELSE) {

 21499               warn('TT: nested IDEFs not allowed');

 21500               tooComplexToFollowFunctions = true;

 21501             }

 21502             inFDEF = true;

 21503             // recording it as a function to track ENDF

 21504             lastDeff = i;

 21505           } else if (op === 0x58) { // IF

 21506             ++ifLevel;

 21507           } else if (op === 0x1B) { // ELSE

 21508             inELSE = ifLevel;

 21509           } else if (op === 0x59) { // EIF

 21510             if (inELSE === ifLevel) {

 21511               inELSE = 0;

 21512             }

 21513             --ifLevel;

 21514           } else if (op === 0x1C) { // JMPR

 21515             if (!inFDEF && !inELSE) {

 21516               var offset = stack[stack.length - 1];

 21517               // only jumping forward to prevent infinite loop

 21518               if (offset > 0) {

 21519                 i += offset - 1;

 21520               }

 21521             }

 21522           }

 21523           // Adjusting stack not extactly, but just enough to get function id

 21524           if (!inFDEF && !inELSE) {

 21525             var stackDelta = op <= 0x8E ? TTOpsStackDeltas[op] :

 21526               op >= 0xC0 && op <= 0xDF ? -1 : op >= 0xE0 ? -2 : 0;

 21527             if (op >= 0x71 && op <= 0x75) {

 21528               n = stack.pop();

 21529               if (n === n) {

 21530                 stackDelta = -n * 2;

 21531               }

 21532             }

 21533             while (stackDelta < 0 && stack.length > 0) {

 21534               stack.pop();

 21535               stackDelta++;

 21536             }

 21537             while (stackDelta > 0) {

 21538               stack.push(NaN); // pushing any number into stack

 21539               stackDelta--;

 21540             }

 21541           }

 21542         }

 21543         ttContext.tooComplexToFollowFunctions = tooComplexToFollowFunctions;

 21544         var content = [data];

 21545         if (i > data.length) {

 21546           content.push(new Uint8Array(i - data.length));

 21547         }

 21548         if (lastDeff > lastEndf) {

 21549           warn('TT: complementing a missing function tail');

 21550           // new function definition started, but not finished

 21551           // complete function by [CLEAR, ENDF]

 21552           content.push(new Uint8Array([0x22, 0x2D]));

 21553         }

 21554         foldTTTable(table, content);

 21555       }

 21557       function checkInvalidFunctions(ttContext, maxFunctionDefs) {

 21558         if (ttContext.tooComplexToFollowFunctions) {

 21559           return;

 21560         }

 21561         if (ttContext.functionsDefined.length > maxFunctionDefs) {

 21562           warn('TT: more functions defined than expected');

 21563           ttContext.hintsValid = false;

 21564           return;

 21565         }

 21566         for (var j = 0, jj = ttContext.functionsUsed.length; j < jj; j++) {

 21567           if (j > maxFunctionDefs) {

 21568             warn('TT: invalid function id: ' + j);

 21569             ttContext.hintsValid = false;

 21570             return;

 21571           }

 21572           if (ttContext.functionsUsed[j] && !ttContext.functionsDefined[j]) {

 21573             warn('TT: undefined function: ' + j);

 21574             ttContext.hintsValid = false;

 21575             return;

 21576           }

 21577         }

 21578       }

 21580       function foldTTTable(table, content) {

 21581         if (content.length > 1) {

 21582           // concatenating the content items

 21583           var newLength = 0;

 21584           var j, jj;

 21585           for (j = 0, jj = content.length; j < jj; j++) {

 21586             newLength += content[j].length;

 21587           }

 21588           newLength = (newLength + 3) & ~3;

 21589           var result = new Uint8Array(newLength);

 21590           var pos = 0;

 21591           for (j = 0, jj = content.length; j < jj; j++) {

 21592             result.set(content[j], pos);

 21593             pos += content[j].length;

 21594           }

 21595           table.data = result;

 21596           table.length = newLength;

 21597         }

 21598       }

 21600       function sanitizeTTPrograms(fpgm, prep, cvt) {

 21601         var ttContext = {

 21602           functionsDefined: [],

 21603           functionsUsed: [],

 21604           functionsStackDeltas: [],

 21605           tooComplexToFollowFunctions: false,

 21606           hintsValid: true

 21607         };

 21608         if (fpgm) {

 21609           sanitizeTTProgram(fpgm, ttContext);

 21610         }

 21611         if (prep) {

 21612           sanitizeTTProgram(prep, ttContext);

 21613         }

 21614         if (fpgm) {

 21615           checkInvalidFunctions(ttContext, maxFunctionDefs);

 21616         }

 21617         if (cvt && (cvt.length & 1)) {

 21618           var cvtData = new Uint8Array(cvt.length + 1);

 21619           cvtData.set(cvt.data);

 21620           cvt.data = cvtData;

 21621         }

 21622         return ttContext.hintsValid;

 21623       }

 21625       // The following steps modify the original font data, making copy

 21626       font = new Stream(new Uint8Array(font.getBytes()));

 21628       var VALID_TABLES = ['OS/2', 'cmap', 'head', 'hhea', 'hmtx', 'maxp',

 21629         'name', 'post', 'loca', 'glyf', 'fpgm', 'prep', 'cvt ', 'CFF '];

 21631       var header = readOpenTypeHeader(font);

 21632       var numTables = header.numTables;

 21633       var cff, cffFile;

 21635       var tables = { 'OS/2': null, cmap: null, head: null, hhea: null,

 21636                      hmtx: null, maxp: null, name: null, post: null };

 21637       var table, tableData;

 21638       for (var i = 0; i < numTables; i++) {

 21639         table = readTableEntry(font);

 21640         if (VALID_TABLES.indexOf(table.tag) < 0) {

 21641           continue; // skipping table if it's not a required or optional table

 21642         }

 21643         if (table.length === 0) {

 21644           continue; // skipping empty tables

 21645         }

 21646         tables[table.tag] = table;

 21647       }

 21649       var isTrueType = !tables['CFF '];

 21650       if (!isTrueType) {

 21651         // OpenType font

 21652         if (!tables.head || !tables.hhea || !tables.maxp || !tables.post) {

 21653           // no major tables: throwing everything at CFFFont

 21654           cffFile = new Stream(tables['CFF '].data);

 21655           cff = new CFFFont(cffFile, properties);

 21657           return this.convert(name, cff, properties);

 21658         }

 21660         delete tables.glyf;

 21661         delete tables.loca;

 21662         delete tables.fpgm;

 21663         delete tables.prep;

 21664         delete tables['cvt '];

 21665       } else {

 21666         if (!tables.glyf || !tables.loca) {

 21667           error('Required "glyf" or "loca" tables are not found');

 21668         }

 21669       }

 21671       if (!tables.maxp) {

 21672         error('Required "maxp" table is not found');

 21673       }

 21675       font.pos = (font.start || 0) + tables.maxp.offset;

 21676       var version = font.getInt32();

 21677       var numGlyphs = font.getUint16();

 21678       var maxFunctionDefs = 0;

 21679       if (version >= 0x00010000 && tables.maxp.length >= 22) {

 21680         // maxZones can be invalid

 21681         font.pos += 8;

 21682         var maxZones = font.getUint16();

 21683         if (maxZones > 2) { // reset to 2 if font has invalid maxZones

 21684           tables.maxp.data[14] = 0;

 21685           tables.maxp.data[15] = 2;

 21686         }

 21687         font.pos += 4;

 21688         maxFunctionDefs = font.getUint16();

 21689       }

 21691       var dupFirstEntry = false;

 21692       if (properties.type == 'CIDFontType2' && properties.toUnicode &&

 21693           properties.toUnicode[0] > '\u0000') {

 21694         // oracle's defect (see 3427), duplicating first entry

 21695         dupFirstEntry = true;

 21696         numGlyphs++;

 21697         tables.maxp.data[4] = numGlyphs >> 8;

 21698         tables.maxp.data[5] = numGlyphs & 255;

 21699       }

 21701       var hintsValid = sanitizeTTPrograms(tables.fpgm, tables.prep,

 21702                                           tables['cvt '], maxFunctionDefs);

 21703       if (!hintsValid) {

 21704         delete tables.fpgm;

 21705         delete tables.prep;

 21706         delete tables['cvt '];

 21707       }

 21709       // Tables needs to be written by ascendant alphabetic order

 21710       var tablesNames = Object.keys(tables);

 21711       tablesNames.sort();

 21713       numTables = tablesNames.length;

 21715       // header and new offsets. Table entry information is appended to the

 21716       // end of file. The virtualOffset represents where to put the actual

 21717       // data of a particular table;

 21718       var ttf = {

 21719         file: '',

 21720         virtualOffset: numTables * (4 * 4)

 21721       };

 21723       // The new numbers of tables will be the last one plus the num

 21724       // of missing tables

 21725       createOpenTypeHeader(header.version, ttf, numTables);

 21727       // Ensure the hmtx table contains the advance width and

 21728       // sidebearings information for numGlyphs in the maxp table

 21729       sanitizeMetrics(font, tables.hhea, tables.hmtx, numGlyphs);

 21731       if (!tables.head) {

 21732         error('Required "head" table is not found');

 21733       }

 21735       sanitizeHead(tables.head, numGlyphs, isTrueType ? tables.loca.length : 0);

 21737       if (isTrueType) {

 21738         var isGlyphLocationsLong = int16(tables.head.data[50],

 21739                                          tables.head.data[51]);

 21740         sanitizeGlyphLocations(tables.loca, tables.glyf, numGlyphs,

 21741                                isGlyphLocationsLong, hintsValid, dupFirstEntry);

 21742       }

 21744       if (!tables.hhea) {

 21745         error('Required "hhea" table is not found');

 21746       }

 21748       // Sanitizer reduces the glyph advanceWidth to the maxAdvanceWidth

 21749       // Sometimes it's 0. That needs to be fixed

 21750       if (tables.hhea.data[10] === 0 && tables.hhea.data[11] === 0) {

 21751         tables.hhea.data[10] = 0xFF;

 21752         tables.hhea.data[11] = 0xFF;

 21753       }

 21755       // The 'post' table has glyphs names.

 21756       if (tables.post) {

 21757         var valid = readPostScriptTable(tables.post, properties, numGlyphs);

 21758         if (!valid) {

 21759           tables.post = null;

 21760         }

 21761       }

 21763       var charCodeToGlyphId = [], charCode;

 21764       if (properties.type == 'CIDFontType2') {

 21765         var cidToGidMap = properties.cidToGidMap || [];

 21766         var cMap = properties.cMap.map;

 21767         for (charCode in cMap) {

 21768           charCode |= 0;

 21769           var cid = cMap[charCode];

 21770           assert(cid.length === 1, 'Max size of CID is 65,535');

 21771           cid = cid.charCodeAt(0);

 21772           var glyphId = -1;

 21773           if (cidToGidMap.length === 0) {

 21774             glyphId = charCode;

 21775           } else if (cid in cidToGidMap) {

 21776             glyphId = cidToGidMap[cid];

 21777           }

 21778           if (glyphId >= 0 && glyphId < numGlyphs) {

 21779             charCodeToGlyphId[charCode] = glyphId;

 21780           }

 21781         }

 21782         if (dupFirstEntry) {

 21783           charCodeToGlyphId[0] = numGlyphs - 1;

 21784         }

 21785       } else {

 21786         // Most of the following logic in this code branch is based on the

 21787         // 9.6.6.4 of the PDF spec.

 21788         var cmapTable = readCmapTable(tables.cmap, font, this.isSymbolicFont);

 21789         var cmapPlatformId = cmapTable.platformId;

 21790         var cmapEncodingId = cmapTable.encodingId;

 21791         var cmapMappings = cmapTable.mappings;

 21792         var cmapMappingsLength = cmapMappings.length;

 21793         var hasEncoding = properties.differences.length ||

 21794                           !!properties.baseEncodingName;

 21796         // The spec seems to imply that if the font is symbolic the encoding

 21797         // should be ignored, this doesn't appear to work for 'preistabelle.pdf'

 21798         // where the the font is symbolic and it has an encoding.

 21799         if (hasEncoding &&

 21800             (cmapPlatformId === 3 && cmapEncodingId === 1 ||

 21801              cmapPlatformId === 1 && cmapEncodingId === 0)) {

 21802           var baseEncoding = [];

 21803           if (properties.baseEncodingName === 'MacRomanEncoding' ||

 21804               properties.baseEncodingName === 'WinAnsiEncoding') {

 21805             baseEncoding = Encodings[properties.baseEncodingName];

 21806           }

 21807           for (charCode = 0; charCode < 256; charCode++) {

 21808             var glyphName;

 21809             if (this.differences && charCode in this.differences) {

 21810               glyphName = this.differences[charCode];

 21811             } else if (charCode in baseEncoding &&

 21812                        baseEncoding[charCode] !== '') {

 21813               glyphName = baseEncoding[charCode];

 21814             } else {

 21815               glyphName = Encodings.StandardEncoding[charCode];

 21816             }

 21817             if (!glyphName) {

 21818               continue;

 21819             }

 21820             var unicodeOrCharCode;

 21821             if (cmapPlatformId === 3 && cmapEncodingId === 1) {

 21822               unicodeOrCharCode = GlyphsUnicode[glyphName];

 21823             } else if (cmapPlatformId === 1 && cmapEncodingId === 0) {

 21824               // TODO: the encoding needs to be updated with mac os table.

 21825               unicodeOrCharCode = Encodings.MacRomanEncoding.indexOf(glyphName);

 21826             }

 21828             var found = false;

 21829             for (i = 0; i < cmapMappingsLength; ++i) {

 21830               if (cmapMappings[i].charCode === unicodeOrCharCode) {

 21831                 charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;

 21832                 found = true;

 21833                 break;

 21834               }

 21835             }

 21836             if (!found && properties.glyphNames) {

 21837               // Try to map using the post table. There are currently no known

 21838               // pdfs that this fixes.

 21839               glyphId = properties.glyphNames.indexOf(glyphName);

 21840               if (glyphId > 0) {

 21841                 charCodeToGlyphId[charCode] = glyphId;

 21842               }

 21843             }

 21844           }

 21845         } else {

 21846           // For (3, 0) cmap tables:

 21847           // The charcode key being stored in charCodeToGlyphId is the lower

 21848           // byte of the two-byte charcodes of the cmap table since according to

 21849           // the spec: 'each byte from the string shall be prepended with the

 21850           // high byte of the range [of charcodes in the cmap table], to form

 21851           // a two-byte character, which shall be used to select the

 21852           // associated glyph description from the subtable'.

 21853           //

 21854           // For (1, 0) cmap tables:

 21855           // 'single bytes from the string shall be used to look up the

 21856           // associated glyph descriptions from the subtable'. This means

 21857           // charcodes in the cmap will be single bytes, so no-op since

 21858           // glyph.charCode & 0xFF === glyph.charCode

 21859           for (i = 0; i < cmapMappingsLength; ++i) {

 21860             charCode = cmapMappings[i].charCode & 0xFF;

 21861             charCodeToGlyphId[charCode] = cmapMappings[i].glyphId;

 21862           }

 21863         }

 21864       }

 21866       if (charCodeToGlyphId.length === 0) {

 21867         // defines at least one glyph

 21868         charCodeToGlyphId[0] = 0;

 21869       }

 21871       // Converting glyphs and ids into font's cmap table

 21872       var newMapping = adjustMapping(charCodeToGlyphId, properties);

 21873       this.toFontChar = newMapping.toFontChar;

 21874       tables.cmap = {

 21875         tag: 'cmap',

 21876         data: createCmapTable(newMapping.charCodeToGlyphId)

 21877       };

 21879       if (!tables['OS/2'] || !validateOS2Table(tables['OS/2'])) {

 21880         // extract some more font properties from the OpenType head and

 21881         // hhea tables; yMin and descent value are always negative

 21882         var override = {

 21883           unitsPerEm: int16(tables.head.data[18], tables.head.data[19]),

 21884           yMax: int16(tables.head.data[42], tables.head.data[43]),

 21885           yMin: int16(tables.head.data[38], tables.head.data[39]) - 0x10000,

 21886           ascent: int16(tables.hhea.data[4], tables.hhea.data[5]),

 21887           descent: int16(tables.hhea.data[6], tables.hhea.data[7]) - 0x10000

 21888         };

 21890         tables['OS/2'] = {

 21891           tag: 'OS/2',

 21892           data: stringToArray(createOS2Table(properties,

 21893                                              newMapping.charCodeToGlyphId,

 21894                                              override))

 21895         };

 21896       }

 21898       // Rewrite the 'post' table if needed

 21899       if (!tables.post) {

 21900         tables.post = {

 21901           tag: 'post',

 21902           data: stringToArray(createPostTable(properties))

 21903         };

 21904       }

 21906       if (!isTrueType) {

 21907         try {

 21908           // Trying to repair CFF file

 21909           cffFile = new Stream(tables['CFF '].data);

 21910           var parser = new CFFParser(cffFile, properties);

 21911           cff = parser.parse();

 21912           var compiler = new CFFCompiler(cff);

 21913           tables['CFF '].data = compiler.compile();

 21914         } catch (e) {

 21915           warn('Failed to compile font ' + properties.loadedName);

 21916         }

 21917       }

 21919       // Re-creating 'name' table

 21920       if (!tables.name) {

 21921         tables.name = {

 21922           tag: 'name',

 21923           data: stringToArray(createNameTable(this.name))

 21924         };

 21925       } else {

 21926         // ... using existing 'name' table as prototype

 21927         var namePrototype = readNameTable(tables.name);

 21928         tables.name.data = stringToArray(createNameTable(name, namePrototype));

 21929       }

 21931       // rewrite the tables but tweak offsets

 21932       for (i = 0; i < numTables; i++) {

 21933         table = tables[tablesNames[i]];

 21934         var data = [];

 21936         tableData = table.data;

 21937         for (var j = 0, jj = tableData.length; j < jj; j++) {

 21938           data.push(tableData[j]);

 21939         }

 21940         createTableEntry(ttf, table.tag, data);

 21941       }

 21943       // Add the table datas

 21944       for (i = 0; i < numTables; i++) {

 21945         table = tables[tablesNames[i]];

 21946         tableData = table.data;

 21947         ttf.file += bytesToString(new Uint8Array(tableData));

 21949         // 4-byte aligned data

 21950         while (ttf.file.length & 3) {

 21951           ttf.file += String.fromCharCode(0);

 21952         }

 21953       }

 21955       return stringToArray(ttf.file);

 21956     },

 21958     convert: function Font_convert(fontName, font, properties) {

 21959       // The offsets object holds at the same time a representation of where

 21960       // to write the table entry information about a table and another offset

 21961       // representing the offset where to draw the actual data of a particular

 21962       // table

 21963       var otf = {

 21964         file: '',

 21965         virtualOffset: 9 * (4 * 4)

 21966       };

 21968       createOpenTypeHeader('\x4F\x54\x54\x4F', otf, 9);

 21970       // TODO: Check the charstring widths to determine this.

 21971       properties.fixedPitch = false;

 21973       var mapping = font.getGlyphMapping(properties);

 21974       var newMapping = adjustMapping(mapping, properties);

 21975       this.toFontChar = newMapping.toFontChar;

 21976       var numGlyphs = font.numGlyphs;

 21978       function getCharCode(charCodeToGlyphId, glyphId, addMap) {

 21979         for (var charCode in charCodeToGlyphId) {

 21980           if (glyphId === charCodeToGlyphId[charCode]) {

 21981             return charCode | 0;

 21982           }

 21983         }

 21984         if (addMap) {

 21985           newMapping.charCodeToGlyphId[newMapping.nextAvailableFontCharCode] =

 21986               glyphId;

 21987           return newMapping.nextAvailableFontCharCode++;

 21988         }

 21989         return null;

 21990       }

 21992       var seacs = font.seacs;

 21993       if (SEAC_ANALYSIS_ENABLED && seacs && seacs.length) {

 21994         var matrix = properties.fontMatrix || FONT_IDENTITY_MATRIX;

 21995         var charset = font.getCharset();

 21996         var seacMap = Object.create(null);

 21997         for (var glyphId in seacs) {

 21998           glyphId |= 0;

 21999           var seac = seacs[glyphId];

 22000           var baseGlyphName = Encodings.StandardEncoding[seac[2]];

 22001           var accentGlyphName = Encodings.StandardEncoding[seac[3]];

 22002           var baseGlyphId = charset.indexOf(baseGlyphName);

 22003           var accentGlyphId = charset.indexOf(accentGlyphName);

 22004           if (baseGlyphId < 0 || accentGlyphId < 0) {

 22005             continue;

 22006           }

 22007           var accentOffset = {

 22008             x: seac[0] * matrix[0] + seac[1] * matrix[2] + matrix[4],

 22009             y: seac[0] * matrix[1] + seac[1] * matrix[3] + matrix[5]

 22010           };

 22012           var charCode = getCharCode(mapping, glyphId);

 22013           if (charCode === null) {

 22014             // There's no point in mapping it if the char code was never mapped

 22015             // to begin with.

 22016             continue;

 22017           }

 22018           // Find a fontCharCode that maps to the base and accent glyphs. If one

 22019           // doesn't exists, create it.

 22020           var charCodeToGlyphId = newMapping.charCodeToGlyphId;

 22021           var baseFontCharCode = getCharCode(charCodeToGlyphId, baseGlyphId,

 22022                                              true);

 22023           var accentFontCharCode = getCharCode(charCodeToGlyphId, accentGlyphId,

 22024                                                true);

 22025           seacMap[charCode] = {

 22026             baseFontCharCode: baseFontCharCode,

 22027             accentFontCharCode: accentFontCharCode,

 22028             accentOffset: accentOffset

 22029           };

 22030         }

 22031         properties.seacMap = seacMap;

 22032       }

 22034       var unitsPerEm = 1 / (properties.fontMatrix || FONT_IDENTITY_MATRIX)[0];

 22036       var fields = {

 22037         // PostScript Font Program

 22038         'CFF ': font.data,

 22040         // OS/2 and Windows Specific metrics

 22041         'OS/2': stringToArray(createOS2Table(properties,

 22042                                              newMapping.charCodeToGlyphId)),

 22044         // Character to glyphs mapping

 22045         'cmap': createCmapTable(newMapping.charCodeToGlyphId),

 22047         // Font header

 22048         'head': (function fontFieldsHead() {

 22049           return stringToArray(

 22050             '\x00\x01\x00\x00' + // Version number

 22051             '\x00\x00\x10\x00' + // fontRevision

 22052             '\x00\x00\x00\x00' + // checksumAdjustement

 22053             '\x5F\x0F\x3C\xF5' + // magicNumber

 22054             '\x00\x00' + // Flags

 22055             safeString16(unitsPerEm) + // unitsPerEM

 22056             '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // creation date

 22057             '\x00\x00\x00\x00\x9e\x0b\x7e\x27' + // modifification date

 22058             '\x00\x00' + // xMin

 22059             safeString16(properties.descent) + // yMin

 22060             '\x0F\xFF' + // xMax

 22061             safeString16(properties.ascent) + // yMax

 22062             string16(properties.italicAngle ? 2 : 0) + // macStyle

 22063             '\x00\x11' + // lowestRecPPEM

 22064             '\x00\x00' + // fontDirectionHint

 22065             '\x00\x00' + // indexToLocFormat

 22066             '\x00\x00');  // glyphDataFormat

 22067         })(),

 22069         // Horizontal header

 22070         'hhea': (function fontFieldsHhea() {

 22071           return stringToArray(

 22072             '\x00\x01\x00\x00' + // Version number

 22073             safeString16(properties.ascent) + // Typographic Ascent

 22074             safeString16(properties.descent) + // Typographic Descent

 22075             '\x00\x00' + // Line Gap

 22076             '\xFF\xFF' + // advanceWidthMax

 22077             '\x00\x00' + // minLeftSidebearing

 22078             '\x00\x00' + // minRightSidebearing

 22079             '\x00\x00' + // xMaxExtent

 22080             safeString16(properties.capHeight) + // caretSlopeRise

 22081             safeString16(Math.tan(properties.italicAngle) *

 22082                          properties.xHeight) + // caretSlopeRun

 22083             '\x00\x00' + // caretOffset

 22084             '\x00\x00' + // -reserved-

 22085             '\x00\x00' + // -reserved-

 22086             '\x00\x00' + // -reserved-

 22087             '\x00\x00' + // -reserved-

 22088             '\x00\x00' + // metricDataFormat

 22089             string16(numGlyphs)); // Number of HMetrics

 22090         })(),

 22092         // Horizontal metrics

 22093         'hmtx': (function fontFieldsHmtx() {

 22094           var charstrings = font.charstrings;

 22095           var hmtx = '\x00\x00\x00\x00'; // Fake .notdef

 22096           for (var i = 1, ii = numGlyphs; i < ii; i++) {

 22097             // TODO: For CFF fonts the width should technically match th x in

 22098             // the glyph, but it doesn't seem to matter.

 22099             var charstring = charstrings ? charstrings[i - 1] : {};

 22100             var width = 'width' in charstring ? charstring.width : 0;

 22101             hmtx += string16(width) + string16(0);

 22102           }

 22103           return stringToArray(hmtx);

 22104         })(),

 22106         // Maximum profile

 22107         'maxp': (function fontFieldsMaxp() {

 22108           return stringToArray(

 22109             '\x00\x00\x50\x00' + // Version number

 22110             string16(numGlyphs)); // Num of glyphs

 22111         })(),

 22113         // Naming tables

 22114         'name': stringToArray(createNameTable(fontName)),

 22116         // PostScript informations

 22117         'post': stringToArray(createPostTable(properties))

 22118       };

 22120       var field;

 22121       for (field in fields) {

 22122         createTableEntry(otf, field, fields[field]);

 22123       }

 22124       for (field in fields) {

 22125         var table = fields[field];

 22126         otf.file += bytesToString(new Uint8Array(table));

 22127       }

 22129       return stringToArray(otf.file);

 22130     },

 22132     /**

 22133      * Builds a char code to unicode map based on section 9.10 of the spec.

 22134      * @param {Object} properties Font properties object.

 22135      * @return {Object} Has two properties: 'toUnicode' which maps char codes to

 22136      * unicode (string) values and 'isIdentity' which is true if an identity map

 22137      * is used.

 22138      */

 22139     buildToUnicode: function Font_buildToUnicode(properties) {

 22140       var map = {

 22141         isIdentity: false,

 22142         toUnicode: null

 22143       };

 22144       // Section 9.10.2 Mapping Character Codes to Unicode Values

 22145       if (properties.toUnicode && properties.toUnicode.length !== 0) {

 22146         map.toUnicode = properties.toUnicode;

 22147         return map;

 22148       }

 22149       // According to the spec if the font is a simple font we should only map

 22150       // to unicode if the base encoding is MacRoman, MacExpert, or WinAnsi or

 22151       // the differences array only contains adobe standard or symbol set names,

 22152       // in pratice it seems better to always try to create a toUnicode

 22153       // map based of the default encoding.

 22154       var toUnicode, charcode;

 22155       if (!properties.composite /* is simple font */) {

 22156         toUnicode = [];

 22157         var encoding = properties.defaultEncoding.slice();

 22158         // Merge in the differences array.

 22159         var differences = properties.differences;

 22160         for (charcode in differences) {

 22161           encoding[charcode] = differences[charcode];

 22162         }

 22163         for (charcode in encoding) {

 22164           // a) Map the character code to a character name.

 22165           var glyphName = encoding[charcode];

 22166           // b) Look up the character name in the Adobe Glyph List (see the

 22167           //    Bibliography) to obtain the corresponding Unicode value.

 22168           if (glyphName === '' || !(glyphName in GlyphsUnicode)) {

 22169             // (undocumented) c) Few heuristics to recognize unknown glyphs

 22170             // NOTE: Adobe Reader does not do this step, but OSX Preview does

 22171             var code;

 22172             // Gxx glyph

 22173             if (glyphName.length === 3 &&

 22174                 glyphName[0] === 'G' &&

 22175                 (code = parseInt(glyphName.substr(1), 16))) {

 22176               toUnicode[charcode] = String.fromCharCode(code);

 22177             }

 22178             // Cddd glyph

 22179             if (glyphName.length >= 3 &&

 22180                 glyphName[0] === 'C' &&

 22181                 (code = +glyphName.substr(1))) {

 22182               toUnicode[charcode] = String.fromCharCode(code);

 22183             }

 22184             continue;

 22185           }

 22186           toUnicode[charcode] = String.fromCharCode(GlyphsUnicode[glyphName]);

 22187         }

 22188         map.toUnicode = toUnicode;

 22189         return map;

 22190       }

 22191       // If the font is a composite font that uses one of the predefined CMaps

 22192       // listed in Table 118 (except Identity–H and Identity–V) or whose

 22193       // descendant CIDFont uses the Adobe-GB1, Adobe-CNS1, Adobe-Japan1, or

 22194       // Adobe-Korea1 character collection:

 22195       if (properties.composite && (

 22196            (properties.cMap.builtInCMap &&

 22197             !(properties.cMap instanceof IdentityCMap)) ||

 22198            (properties.cidSystemInfo.registry === 'Adobe' &&

 22199              (properties.cidSystemInfo.ordering === 'GB1' ||

 22200               properties.cidSystemInfo.ordering === 'CNS1' ||

 22201               properties.cidSystemInfo.ordering === 'Japan1' ||

 22202               properties.cidSystemInfo.ordering === 'Korea1')))) {

 22203         // Then:

 22204         // a) Map the character code to a character identifier (CID) according

 22205         // to the font’s CMap.

 22206         // b) Obtain the registry and ordering of the character collection used

 22207         // by the font’s CMap (for example, Adobe and Japan1) from its

 22208         // CIDSystemInfo dictionary.

 22209         var registry = properties.cidSystemInfo.registry;

 22210         var ordering = properties.cidSystemInfo.ordering;

 22211         // c) Construct a second CMap name by concatenating the registry and

 22212         // ordering obtained in step (b) in the format registry–ordering–UCS2

 22213         // (for example, Adobe–Japan1–UCS2).

 22214         var ucs2CMapName = new Name(registry + '-' + ordering + '-UCS2');

 22215         // d) Obtain the CMap with the name constructed in step (c) (available

 22216         // from the ASN Web site; see the Bibliography).

 22217         var ucs2CMap = CMapFactory.create(ucs2CMapName,

 22218           { url: PDFJS.cMapUrl, packed: PDFJS.cMapPacked }, null);

 22219         var cMap = properties.cMap;

 22220         toUnicode = [];

 22221         for (charcode in cMap.map) {

 22222           var cid = cMap.map[charcode];

 22223           assert(cid.length === 1, 'Max size of CID is 65,535');

 22224           // e) Map the CID obtained in step (a) according to the CMap obtained

 22225           // in step (d), producing a Unicode value.

 22226           var ucs2 = ucs2CMap.map[cid.charCodeAt(0)];

 22227           if (!ucs2) {

 22228             continue;

 22229           }

 22230           toUnicode[charcode] = String.fromCharCode((ucs2.charCodeAt(0) << 8) +

 22231                                                     ucs2.charCodeAt(1));

 22232         }

 22233         map.toUnicode = toUnicode;

 22234         return map;

 22235       }

 22237       // The viewer's choice, just use an identity map.

 22238       toUnicode = [];

 22239       var firstChar = properties.firstChar, lastChar = properties.lastChar;

 22240       for (var i = firstChar; i <= lastChar; i++) {

 22241         toUnicode[i] = String.fromCharCode(i);

 22242       }

 22243       map.isIdentity = true;

 22244       map.toUnicode = toUnicode;

 22245       return map;

 22246     },

 22248     get spaceWidth() {

 22249       if ('_shadowWidth' in this) {

 22250         return this._shadowWidth;

 22251       }

 22253       // trying to estimate space character width

 22254       var possibleSpaceReplacements = ['space', 'minus', 'one', 'i'];

 22255       var width;

 22256       for (var i = 0, ii = possibleSpaceReplacements.length; i < ii; i++) {

 22257         var glyphName = possibleSpaceReplacements[i];

 22258         // if possible, getting width by glyph name

 22259         if (glyphName in this.widths) {

 22260           width = this.widths[glyphName];

 22261           break;

 22262         }

 22263         var glyphUnicode = GlyphsUnicode[glyphName];

 22264         // finding the charcode via unicodeToCID map

 22265         var charcode = 0;

 22266         if (this.composite) {

 22267           if (glyphUnicode in this.cMap.map) {

 22268             charcode = this.cMap.lookup(glyphUnicode).charCodeAt(0);

 22269           }

 22270         }

 22271         // ... via toUnicode map

 22272         if (!charcode && 'toUnicode' in this) {

 22273           charcode = this.toUnicode.indexOf(glyphUnicode);

 22274         }

 22275         // setting it to unicode if negative or undefined

 22276         if (charcode <= 0) {

 22277           charcode = glyphUnicode;

 22278         }

 22279         // trying to get width via charcode

 22280         width = this.widths[charcode];

 22281         if (width) {

 22282           break; // the non-zero width found

 22283         }

 22284       }

 22285       width = width || this.defaultWidth;

 22286       // Do not shadow the property here. See discussion:

 22287       // https://github.com/mozilla/pdf.js/pull/2127#discussion_r1662280

 22288       this._shadowWidth = width;

 22289       return width;

 22290     },

 22292     charToGlyph: function Font_charToGlyph(charcode) {

 22293       var fontCharCode, width, operatorList;

 22295       var widthCode = charcode;

 22296       if (this.cMap && charcode in this.cMap.map) {

 22297         widthCode = this.cMap.map[charcode].charCodeAt(0);

 22298       }

 22299       width = this.widths[widthCode];

 22300       width = isNum(width) ? width : this.defaultWidth;

 22301       var vmetric = this.vmetrics && this.vmetrics[widthCode];

 22303       var unicode = this.toUnicode[charcode] || charcode;

 22304       if (typeof unicode === 'number') {

 22305         unicode = String.fromCharCode(unicode);

 22306       }

 22308       // First try the toFontChar map, if it's not there then try falling

 22309       // back to the char code.

 22310       fontCharCode = this.toFontChar[charcode] || charcode;

 22311       if (this.missingFile) {

 22312         fontCharCode = mapSpecialUnicodeValues(fontCharCode);

 22313       }

 22315       if (this.type === 'Type3') {

 22316         // Font char code in this case is actually a glyph name.

 22317         operatorList = this.charProcOperatorList[fontCharCode];

 22318       }

 22320       var accent = null;

 22321       if (this.seacMap && this.seacMap[charcode]) {

 22322         var seac = this.seacMap[charcode];

 22323         fontCharCode = seac.baseFontCharCode;

 22324         accent = {

 22325           fontChar: String.fromCharCode(seac.accentFontCharCode),

 22326           offset: seac.accentOffset

 22327         };

 22328       }

 22330       var fontChar = String.fromCharCode(fontCharCode);

 22332       var glyph = this.glyphCache[charcode];

 22333       if (!glyph ||

 22334           !glyph.matchesForCache(fontChar, unicode, accent, width, vmetric,

 22335                                  operatorList)) {

 22336         glyph = new Glyph(fontChar, unicode, accent, width, vmetric,

 22337                           operatorList);

 22338         this.glyphCache[charcode] = glyph;

 22339       }

 22340       return glyph;

 22341     },

 22343     charsToGlyphs: function Font_charsToGlyphs(chars) {

 22344       var charsCache = this.charsCache;

 22345       var glyphs, glyph, charcode;

 22347       // if we translated this string before, just grab it from the cache

 22348       if (charsCache) {

 22349         glyphs = charsCache[chars];

 22350         if (glyphs) {

 22351           return glyphs;

 22352         }

 22353       }

 22355       // lazily create the translation cache

 22356       if (!charsCache) {

 22357         charsCache = this.charsCache = Object.create(null);

 22358       }

 22360       glyphs = [];

 22361       var charsCacheKey = chars;

 22362       var i = 0, ii;

 22364       if (this.cMap) {

 22365         // composite fonts have multi-byte strings convert the string from

 22366         // single-byte to multi-byte

 22367         while (i < chars.length) {

 22368           var c = this.cMap.readCharCode(chars, i);

 22369           charcode = c[0];

 22370           var length = c[1];

 22371           i += length;

 22372           glyph = this.charToGlyph(charcode);

 22373           glyphs.push(glyph);

 22374           // placing null after each word break charcode (ASCII SPACE)

 22375           // Ignore occurences of 0x20 in multiple-byte codes.

 22376           if (length === 1 && chars.charCodeAt(i - 1) === 0x20) {

 22377             glyphs.push(null);

 22378           }

 22379         }

 22380       } else {

 22381         for (i = 0, ii = chars.length; i < ii; ++i) {

 22382           charcode = chars.charCodeAt(i);

 22383           glyph = this.charToGlyph(charcode);

 22384           glyphs.push(glyph);

 22385           if (charcode == 0x20) {

 22386             glyphs.push(null);

 22387           }

 22388         }

 22389       }

 22391       // Enter the translated string into the cache

 22392       return (charsCache[charsCacheKey] = glyphs);

 22393     }

 22394   };

 22396   return Font;

 22397 })();

 22399 var ErrorFont = (function ErrorFontClosure() {

 22400   function ErrorFont(error) {

 22401     this.error = error;

 22402   }

 22404   ErrorFont.prototype = {

 22405     charsToGlyphs: function ErrorFont_charsToGlyphs() {

 22406       return [];

 22407     },

 22408     exportData: function ErrorFont_exportData() {

 22409       return {error: this.error};

 22410     }

 22411   };

 22413   return ErrorFont;

 22414 })();

 22416 /**

 22417  * Shared logic for building a char code to glyph id mapping for Type1 and

 22418  * simple CFF fonts. See section 9.6.6.2 of the spec.

 22419  * @param {Object} properties Font properties object.

 22420  * @param {Object} builtInEncoding The encoding contained within the actual font

 22421  * data.

 22422  * @param {Array} Array of glyph names where the index is the glyph ID.

 22423  * @returns {Object} A char code to glyph ID map.

 22424  */

 22425 function type1FontGlyphMapping(properties, builtInEncoding, glyphNames) {

 22426   var charCodeToGlyphId = Object.create(null);

 22427   var glyphId, charCode, baseEncoding;

 22429   if (properties.baseEncodingName) {

 22430     // If a valid base encoding name was used, the mapping is initialized with

 22431     // that.

 22432     baseEncoding = Encodings[properties.baseEncodingName];

 22433     for (charCode = 0; charCode < baseEncoding.length; charCode++) {

 22434       glyphId = glyphNames.indexOf(baseEncoding[charCode]);

 22435       if (glyphId >= 0) {

 22436         charCodeToGlyphId[charCode] = glyphId;

 22437       }

 22438     }

 22439   } else if (!!(properties.flags & FontFlags.Symbolic)) {

 22440     // For a symbolic font the encoding should be the fonts built-in

 22441     // encoding.

 22442     for (charCode in builtInEncoding) {

 22443       charCodeToGlyphId[charCode] = builtInEncoding[charCode];

 22444     }

 22445   } else {

 22446     // For non-symbolic fonts that don't have a base encoding the standard

 22447     // encoding should be used.

 22448     baseEncoding = Encodings.StandardEncoding;

 22449     for (charCode = 0; charCode < baseEncoding.length; charCode++) {

 22450       glyphId = glyphNames.indexOf(baseEncoding[charCode]);

 22451       if (glyphId >= 0) {

 22452         charCodeToGlyphId[charCode] = glyphId;

 22453       }

 22454     }

 22455   }

 22457   // Lastly, merge in the differences.

 22458   var differences = properties.differences;

 22459   if (differences) {

 22460     for (charCode in differences) {

 22461       var glyphName = differences[charCode];

 22462       glyphId = glyphNames.indexOf(glyphName);

 22463       if (glyphId >= 0) {

 22464         charCodeToGlyphId[charCode] = glyphId;

 22465       }

 22466     }

 22467   }

 22468   return charCodeToGlyphId;

 22469 }

 22471 /*

 22472  * CharStrings are encoded following the the CharString Encoding sequence

 22473  * describe in Chapter 6 of the "Adobe Type1 Font Format" specification.

 22474  * The value in a byte indicates a command, a number, or subsequent bytes

 22475  * that are to be interpreted in a special way.

 22476  *

 22477  * CharString Number Encoding:

 22478  *  A CharString byte containing the values from 32 through 255 inclusive

 22479  *  indicate an integer. These values are decoded in four ranges.

 22480  *

 22481  * 1. A CharString byte containing a value, v, between 32 and 246 inclusive,

 22482  * indicate the integer v - 139. Thus, the integer values from -107 through

 22483  * 107 inclusive may be encoded in single byte.

 22484  *

 22485  * 2. A CharString byte containing a value, v, between 247 and 250 inclusive,

 22486  * indicates an integer involving the next byte, w, according to the formula:

 22487  * [(v - 247) x 256] + w + 108

 22488  *

 22489  * 3. A CharString byte containing a value, v, between 251 and 254 inclusive,

 22490  * indicates an integer involving the next byte, w, according to the formula:

 22491  * -[(v - 251) * 256] - w - 108

 22492  *

 22493  * 4. A CharString containing the value 255 indicates that the next 4 bytes

 22494  * are a two complement signed integer. The first of these bytes contains the

 22495  * highest order bits, the second byte contains the next higher order bits

 22496  * and the fourth byte contain the lowest order bits.

 22497  *

 22498  *

 22499  * CharString Command Encoding:

 22500  *  CharStrings commands are encoded in 1 or 2 bytes.

 22501  *

 22502  *  Single byte commands are encoded in 1 byte that contains a value between

 22503  *  0 and 31 inclusive.

 22504  *  If a command byte contains the value 12, then the value in the next byte

 22505  *  indicates a command. This "escape" mechanism allows many extra commands

 22506  * to be encoded and this encoding technique helps to minimize the length of

 22507  * the charStrings.

 22508  */

 22509 var Type1CharString = (function Type1CharStringClosure() {

 22510   var COMMAND_MAP = {

 22511     'hstem': [1],

 22512     'vstem': [3],

 22513     'vmoveto': [4],

 22514     'rlineto': [5],

 22515     'hlineto': [6],

 22516     'vlineto': [7],

 22517     'rrcurveto': [8],

 22518     'callsubr': [10],

 22519     'flex': [12, 35],

 22520     'drop' : [12, 18],

 22521     'endchar': [14],

 22522     'rmoveto': [21],

 22523     'hmoveto': [22],

 22524     'vhcurveto': [30],

 22525     'hvcurveto': [31]

 22526   };

 22528   function Type1CharString() {

 22529     this.width = 0;

 22530     this.lsb = 0;

 22531     this.flexing = false;

 22532     this.output = [];

 22533     this.stack = [];

 22534   }

 22536   Type1CharString.prototype = {

 22537     convert: function Type1CharString_convert(encoded, subrs) {

 22538       var count = encoded.length;

 22539       var error = false;

 22540       var wx, sbx, subrNumber;

 22541       for (var i = 0; i < count; i++) {

 22542         var value = encoded[i];

 22543         if (value < 32) {

 22544           if (value === 12) {

 22545             value = (value << 8) + encoded[++i];

 22546           }

 22547           switch (value) {

 22548             case 1: // hstem

 22549               if (!HINTING_ENABLED) {

 22550                 this.stack = [];

 22551                 break;

 22552               }

 22553               error = this.executeCommand(2, COMMAND_MAP.hstem);

 22554               break;

 22555             case 3: // vstem

 22556               if (!HINTING_ENABLED) {

 22557                 this.stack = [];

 22558                 break;

 22559               }

 22560               error = this.executeCommand(2, COMMAND_MAP.vstem);

 22561               break;

 22562             case 4: // vmoveto

 22563               if (this.flexing) {

 22564                 if (this.stack.length < 1) {

 22565                   error = true;

 22566                   break;

 22567                 }

 22568                 // Add the dx for flex and but also swap the values so they are

 22569                 // the right order.

 22570                 var dy = this.stack.pop();

 22571                 this.stack.push(0, dy);

 22572                 break;

 22573               }

 22574               error = this.executeCommand(1, COMMAND_MAP.vmoveto);

 22575               break;

 22576             case 5: // rlineto

 22577               error = this.executeCommand(2, COMMAND_MAP.rlineto);

 22578               break;

 22579             case 6: // hlineto

 22580               error = this.executeCommand(1, COMMAND_MAP.hlineto);

 22581               break;

 22582             case 7: // vlineto

 22583               error = this.executeCommand(1, COMMAND_MAP.vlineto);

 22584               break;

 22585             case 8: // rrcurveto

 22586               error = this.executeCommand(6, COMMAND_MAP.rrcurveto);

 22587               break;

 22588             case 9: // closepath

 22589               // closepath is a Type1 command that does not take argument and is

 22590               // useless in Type2 and it can simply be ignored.

 22591               this.stack = [];

 22592               break;

 22593             case 10: // callsubr

 22594               if (this.stack.length < 1) {

 22595                 error = true;

 22596                 break;

 22597               }

 22598               subrNumber = this.stack.pop();

 22599               error = this.convert(subrs[subrNumber], subrs);

 22600               break;

 22601             case 11: // return

 22602               return error;

 22603             case 13: // hsbw

 22604               if (this.stack.length < 2) {

 22605                 error = true;

 22606                 break;

 22607               }

 22608               // To convert to type2 we have to move the width value to the

 22609               // first part of the charstring and then use hmoveto with lsb.

 22610               wx = this.stack.pop();

 22611               sbx = this.stack.pop();

 22612               this.lsb = sbx;

 22613               this.width = wx;

 22614               this.stack.push(sbx);

 22615               error = this.executeCommand(1, COMMAND_MAP.hmoveto);

 22616               break;

 22617             case 14: // endchar

 22618               this.output.push(COMMAND_MAP.endchar[0]);

 22619               break;

 22620             case 21: // rmoveto

 22621               if (this.flexing) {

 22622                 break;

 22623               }

 22624               error = this.executeCommand(2, COMMAND_MAP.rmoveto);

 22625               break;

 22626             case 22: // hmoveto

 22627               if (this.flexing) {

 22628                 // Add the dy for flex.

 22629                 this.stack.push(0);

 22630                 break;

 22631               }

 22632               error = this.executeCommand(1, COMMAND_MAP.hmoveto);

 22633               break;

 22634             case 30: // vhcurveto

 22635               error = this.executeCommand(4, COMMAND_MAP.vhcurveto);

 22636               break;

 22637             case 31: // hvcurveto

 22638               error = this.executeCommand(4, COMMAND_MAP.hvcurveto);

 22639               break;

 22640             case (12 << 8) + 0: // dotsection

 22641               // dotsection is a Type1 command to specify some hinting feature

 22642               // for dots that do not take a parameter and it can safely be

 22643               // ignored for Type2.

 22644               this.stack = [];

 22645               break;

 22646             case (12 << 8) + 1: // vstem3

 22647               if (!HINTING_ENABLED) {

 22648                 this.stack = [];

 22649                 break;

 22650               }

 22651               // [vh]stem3 are Type1 only and Type2 supports [vh]stem with

 22652               // multiple parameters, so instead of returning [vh]stem3 take a

 22653               // shortcut and return [vhstem] instead.

 22654               error = this.executeCommand(2, COMMAND_MAP.vstem);

 22655               break;

 22656             case (12 << 8) + 2: // hstem3

 22657               if (!HINTING_ENABLED) {

 22658                  this.stack = [];

 22659                 break;

 22660               }

 22661               // See vstem3.

 22662               error = this.executeCommand(2, COMMAND_MAP.hstem);

 22663               break;

 22664             case (12 << 8) + 6: // seac

 22665               // seac is like type 2's special endchar but it doesn't use the

 22666               // first argument asb, so remove it.

 22667               if (SEAC_ANALYSIS_ENABLED) {

 22668                 this.seac = this.stack.splice(-4, 4);

 22669                 error = this.executeCommand(0, COMMAND_MAP.endchar);

 22670               } else {

 22671                 error = this.executeCommand(4, COMMAND_MAP.endchar);

 22672               }

 22673               break;

 22674             case (12 << 8) + 7: // sbw

 22675               if (this.stack.length < 4) {

 22676                 error = true;

 22677                 break;

 22678               }

 22679               // To convert to type2 we have to move the width value to the

 22680               // first part of the charstring and then use rmoveto with

 22681               // (dx, dy). The height argument will not be used for vmtx and

 22682               // vhea tables reconstruction -- ignoring it.

 22683               var wy = this.stack.pop();

 22684               wx = this.stack.pop();

 22685               var sby = this.stack.pop();

 22686               sbx = this.stack.pop();

 22687               this.lsb = sbx;

 22688               this.width = wx;

 22689               this.stack.push(sbx, sby);

 22690               error = this.executeCommand(2, COMMAND_MAP.rmoveto);

 22691               break;

 22692             case (12 << 8) + 12: // div

 22693               if (this.stack.length < 2) {

 22694                 error = true;

 22695                 break;

 22696               }

 22697               var num2 = this.stack.pop();

 22698               var num1 = this.stack.pop();

 22699               this.stack.push(num1 / num2);

 22700               break;

 22701             case (12 << 8) + 16: // callothersubr

 22702               if (this.stack.length < 2) {

 22703                 error = true;

 22704                 break;

 22705               }

 22706               subrNumber = this.stack.pop();

 22707               var numArgs = this.stack.pop();

 22708               if (subrNumber === 0 && numArgs === 3) {

 22709                 var flexArgs = this.stack.splice(this.stack.length - 17, 17);

 22710                 this.stack.push(

 22711                   flexArgs[2] + flexArgs[0], // bcp1x + rpx

 22712                   flexArgs[3] + flexArgs[1], // bcp1y + rpy

 22713                   flexArgs[4], // bcp2x

 22714                   flexArgs[5], // bcp2y

 22715                   flexArgs[6], // p2x

 22716                   flexArgs[7], // p2y

 22717                   flexArgs[8], // bcp3x

 22718                   flexArgs[9], // bcp3y

 22719                   flexArgs[10], // bcp4x

 22720                   flexArgs[11], // bcp4y

 22721                   flexArgs[12], // p3x

 22722                   flexArgs[13], // p3y

 22723                   flexArgs[14] // flexDepth

 22724                   // 15 = finalx unused by flex

 22725                   // 16 = finaly unused by flex

 22726                 );

 22727                 error = this.executeCommand(13, COMMAND_MAP.flex, true);

 22728                 this.flexing = false;

 22729                 this.stack.push(flexArgs[15], flexArgs[16]);

 22730               } else if (subrNumber === 1 && numArgs === 0) {

 22731                 this.flexing = true;

 22732               }

 22733               break;

 22734             case (12 << 8) + 17: // pop

 22735               // Ignore this since it is only used with othersubr.

 22736               break;

 22737             case (12 << 8) + 33: // setcurrentpoint

 22738               // Ignore for now.

 22739               this.stack = [];

 22740               break;

 22741             default:

 22742               warn('Unknown type 1 charstring command of "' + value + '"');

 22743               break;

 22744           }

 22745           if (error) {

 22746             break;

 22747           }

 22748           continue;

 22749         } else if (value <= 246) {

 22750           value = value - 139;

 22751         } else if (value <= 250) {

 22752           value = ((value - 247) * 256) + encoded[++i] + 108;

 22753         } else if (value <= 254) {

 22754           value = -((value - 251) * 256) - encoded[++i] - 108;

 22755         } else {

 22756           value = (encoded[++i] & 0xff) << 24 | (encoded[++i] & 0xff) << 16 |

 22757                   (encoded[++i] & 0xff) << 8 | (encoded[++i] & 0xff) << 0;

 22758         }

 22759         this.stack.push(value);

 22760       }

 22761       return error;

 22762     },

 22764     executeCommand: function(howManyArgs, command, keepStack) {

 22765       var stackLength = this.stack.length;

 22766       if (howManyArgs > stackLength) {

 22767         return true;

 22768       }

 22769       var start = stackLength - howManyArgs;

 22770       for (var i = start; i < stackLength; i++) {

 22771         var value = this.stack[i];

 22772         if (value === (value | 0)) { // int

 22773           this.output.push(28, (value >> 8) & 0xff, value & 0xff);

 22774         } else { // fixed point

 22775           value = (65536 * value) | 0;

 22776           this.output.push(255,

 22777                            (value >> 24) & 0xFF,

 22778                            (value >> 16) & 0xFF,

 22779                            (value >> 8) & 0xFF,

 22780                            value & 0xFF);

 22781         }

 22782       }

 22783       this.output.push.apply(this.output, command);

 22784       if (keepStack) {

 22785         this.stack.splice(start, howManyArgs);

 22786       } else {

 22787         this.stack.length = 0;

 22788       }

 22789       return false;

 22790     }

 22791   };

 22793   return Type1CharString;

 22794 })();

 22796 /*

 22797  * Type1Parser encapsulate the needed code for parsing a Type1 font

 22798  * program. Some of its logic depends on the Type2 charstrings

 22799  * structure.

 22800  * Note: this doesn't really parse the font since that would require evaluation

 22801  * of PostScript, but it is possible in most cases to extract what we need

 22802  * without a full parse.

 22803  */

 22804 var Type1Parser = (function Type1ParserClosure() {

 22805   /*

 22806    * Decrypt a Sequence of Ciphertext Bytes to Produce the Original Sequence

 22807    * of Plaintext Bytes. The function took a key as a parameter which can be

 22808    * for decrypting the eexec block of for decoding charStrings.

 22809    */

 22810   var EEXEC_ENCRYPT_KEY = 55665;

 22811   var CHAR_STRS_ENCRYPT_KEY = 4330;

 22813   function isHexDigit(code) {

 22814     return code >= 48 && code <= 57 || // '0'-'9'

 22815            code >= 65 && code <= 70 || // 'A'-'F'

 22816            code >= 97 && code <= 102;  // 'a'-'f'

 22817   }

 22819   function decrypt(data, key, discardNumber) {

 22820     var r = key | 0, c1 = 52845, c2 = 22719;

 22821     var count = data.length;

 22822     var decrypted = new Uint8Array(count);

 22823     for (var i = 0; i < count; i++) {

 22824       var value = data[i];

 22825       decrypted[i] = value ^ (r >> 8);

 22826       r = ((value + r) * c1 + c2) & ((1 << 16) - 1);

 22827     }

 22828     return Array.prototype.slice.call(decrypted, discardNumber);

 22829   }

 22831   function decryptAscii(data, key, discardNumber) {

 22832     var r = key | 0, c1 = 52845, c2 = 22719;

 22833     var count = data.length, maybeLength = count >>> 1;

 22834     var decrypted = new Uint8Array(maybeLength);

 22835     var i, j;

 22836     for (i = 0, j = 0; i < count; i++) {

 22837       var digit1 = data[i];

 22838       if (!isHexDigit(digit1)) {

 22839         continue;

 22840       }

 22841       i++;

 22842       var digit2;

 22843       while (i < count && !isHexDigit(digit2 = data[i])) {

 22844         i++;

 22845       }

 22846       if (i < count) {

 22847         var value = parseInt(String.fromCharCode(digit1, digit2), 16);

 22848         decrypted[j++] = value ^ (r >> 8);

 22849         r = ((value + r) * c1 + c2) & ((1 << 16) - 1);

 22850       }

 22851     }

 22852     return Array.prototype.slice.call(decrypted, discardNumber, j);

 22853   }

 22855   function isSpecial(c) {

 22856     return c === 0x2F || // '/'

 22857            c === 0x5B || c === 0x5D || // '[', ']'

 22858            c === 0x7B || c === 0x7D || // '{', '}'

 22859            c === 0x28 || c === 0x29; // '(', ')'

 22860   }

 22862   function Type1Parser(stream, encrypted) {

 22863     if (encrypted) {

 22864       var data = stream.getBytes();

 22865       var isBinary = !(isHexDigit(data[0]) && isHexDigit(data[1]) &&

 22866                        isHexDigit(data[2]) && isHexDigit(data[3]));

 22867       stream = new Stream(isBinary ? decrypt(data, EEXEC_ENCRYPT_KEY, 4) :

 22868                           decryptAscii(data, EEXEC_ENCRYPT_KEY, 4));

 22869     }

 22870     this.stream = stream;

 22871     this.nextChar();

 22872   }

 22874   Type1Parser.prototype = {

 22875     readNumberArray: function Type1Parser_readNumberArray() {

 22876       this.getToken(); // read '[' or '{' (arrays can start with either)

 22877       var array = [];

 22878       while (true) {

 22879         var token = this.getToken();

 22880         if (token === null || token === ']' || token === '}') {

 22881           break;

 22882         }

 22883         array.push(parseFloat(token || 0));

 22884       }

 22885       return array;

 22886     },

 22888     readNumber: function Type1Parser_readNumber() {

 22889       var token = this.getToken();

 22890       return parseFloat(token || 0);

 22891     },

 22893     readInt: function Type1Parser_readInt() {

 22894       // Use '| 0' to prevent setting a double into length such as the double

 22895       // does not flow into the loop variable.

 22896       var token = this.getToken();

 22897       return parseInt(token || 0, 10) | 0;

 22898     },

 22900     readBoolean: function Type1Parser_readBoolean() {

 22901       var token = this.getToken();

 22903       // Use 1 and 0 since that's what type2 charstrings use.

 22904       return token === 'true' ? 1 : 0;

 22905     },

 22907     nextChar : function Type1_nextChar() {

 22908       return (this.currentChar = this.stream.getByte());

 22909     },

 22911     getToken: function Type1Parser_getToken() {

 22912       // Eat whitespace and comments.

 22913       var comment = false;

 22914       var ch = this.currentChar;

 22915       while (true) {

 22916         if (ch === -1) {

 22917           return null;

 22918         }

 22920         if (comment) {

 22921           if (ch === 0x0A || ch === 0x0D) {

 22922             comment = false;

 22923           }

 22924         } else if (ch === 0x25) { // '%'

 22925           comment = true;

 22926         } else if (!Lexer.isSpace(ch)) {

 22927           break;

 22928         }

 22929         ch = this.nextChar();

 22930       }

 22931       if (isSpecial(ch)) {

 22932         this.nextChar();

 22933         return String.fromCharCode(ch);

 22934       }

 22935       var token = '';

 22936       do {

 22937         token += String.fromCharCode(ch);

 22938         ch = this.nextChar();

 22939       } while (ch >= 0 && !Lexer.isSpace(ch) && !isSpecial(ch));

 22940       return token;

 22941     },

 22943     /*

 22944      * Returns an object containing a Subrs array and a CharStrings

 22945      * array extracted from and eexec encrypted block of data

 22946      */

 22947     extractFontProgram: function Type1Parser_extractFontProgram() {

 22948       var stream = this.stream;

 22950       var subrs = [], charstrings = [];

 22951       var program = {

 22952         subrs: [],

 22953         charstrings: [],

 22954         properties: {

 22955           'privateData': {

 22956             'lenIV': 4

 22957           }

 22958         }

 22959       };

 22960       var token, length, data, lenIV, encoded;

 22961       while ((token = this.getToken()) !== null) {

 22962         if (token !== '/') {

 22963           continue;

 22964         }

 22965         token = this.getToken();

 22966         switch (token) {

 22967           case 'CharStrings':

 22968             // The number immediately following CharStrings must be greater or

 22969             // equal to the number of CharStrings.

 22970             this.getToken();

 22971             this.getToken(); // read in 'dict'

 22972             this.getToken(); // read in 'dup'

 22973             this.getToken(); // read in 'begin'

 22974             while(true) {

 22975               token = this.getToken();

 22976               if (token === null || token === 'end') {

 22977                 break;

 22978               }

 22980               if (token !== '/') {

 22981                 continue;

 22982               }

 22983               var glyph = this.getToken();

 22984               length = this.readInt();

 22985               this.getToken(); // read in 'RD' or '-|'

 22986               data = stream.makeSubStream(stream.pos, length);

 22987               lenIV = program.properties.privateData['lenIV'];

 22988               encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV);

 22989               // Skip past the required space and binary data.

 22990               stream.skip(length);

 22991               this.nextChar();

 22992               token = this.getToken(); // read in 'ND' or '|-'

 22993               if (token === 'noaccess') {

 22994                 this.getToken(); // read in 'def'

 22995               }

 22996               charstrings.push({

 22997                 glyph: glyph,

 22998                 encoded: encoded

 22999               });

 23000             }

 23001             break;

 23002           case 'Subrs':

 23003             var num = this.readInt();

 23004             this.getToken(); // read in 'array'

 23005             while ((token = this.getToken()) === 'dup') {

 23006               var index = this.readInt();

 23007               length = this.readInt();

 23008               this.getToken(); // read in 'RD' or '-|'

 23009               data = stream.makeSubStream(stream.pos, length);

 23010               lenIV = program.properties.privateData['lenIV'];

 23011               encoded = decrypt(data.getBytes(), CHAR_STRS_ENCRYPT_KEY, lenIV);

 23012               // Skip past the required space and binary data.

 23013               stream.skip(length);

 23014               this.nextChar();

 23015               token = this.getToken(); // read in 'NP' or '|'

 23016               if (token === 'noaccess') {

 23017                 this.getToken(); // read in 'put'

 23018               }

 23019               subrs[index] = encoded;

 23020             }

 23021             break;

 23022           case 'BlueValues':

 23023           case 'OtherBlues':

 23024           case 'FamilyBlues':

 23025           case 'FamilyOtherBlues':

 23026             var blueArray = this.readNumberArray();

 23027             // *Blue* values may contain invalid data: disables reading of

 23028             // those values when hinting is disabled.

 23029             if (blueArray.length > 0 && (blueArray.length % 2) === 0 &&

 23030                 HINTING_ENABLED) {

 23031               program.properties.privateData[token] = blueArray;

 23032             }

 23033             break;

 23034           case 'StemSnapH':

 23035           case 'StemSnapV':

 23036             program.properties.privateData[token] = this.readNumberArray();

 23037             break;

 23038           case 'StdHW':

 23039           case 'StdVW':

 23040             program.properties.privateData[token] =

 23041               this.readNumberArray()[0];

 23042             break;

 23043           case 'BlueShift':

 23044           case 'lenIV':

 23045           case 'BlueFuzz':

 23046           case 'BlueScale':

 23047           case 'LanguageGroup':

 23048           case 'ExpansionFactor':

 23049             program.properties.privateData[token] = this.readNumber();

 23050             break;

 23051           case 'ForceBold':

 23052             program.properties.privateData[token] = this.readBoolean();

 23053             break;

 23054         }

 23055       }

 23057       for (var i = 0; i < charstrings.length; i++) {

 23058         glyph = charstrings[i].glyph;

 23059         encoded = charstrings[i].encoded;

 23060         var charString = new Type1CharString();

 23061         var error = charString.convert(encoded, subrs);

 23062         var output = charString.output;

 23063         if (error) {

 23064           // It seems when FreeType encounters an error while evaluating a glyph

 23065           // that it completely ignores the glyph so we'll mimic that behaviour

 23066           // here and put an endchar to make the validator happy.

 23067           output = [14];

 23068         }

 23069         program.charstrings.push({

 23070           glyphName: glyph,

 23071           charstring: output,

 23072           width: charString.width,

 23073           lsb: charString.lsb,

 23074           seac: charString.seac

 23075         });

 23076       }

 23078       return program;

 23079     },

 23081     extractFontHeader: function Type1Parser_extractFontHeader(properties) {

 23082       var token;

 23083       while ((token = this.getToken()) !== null) {

 23084         if (token !== '/') {

 23085           continue;

 23086         }

 23087         token = this.getToken();

 23088         switch (token) {

 23089           case 'FontMatrix':

 23090             var matrix = this.readNumberArray();

 23091             properties.fontMatrix = matrix;

 23092             break;

 23093           case 'Encoding':

 23094             var encodingArg = this.getToken();

 23095             var encoding;

 23096             if (!/^\d+$/.test(encodingArg)) {

 23097               // encoding name is specified

 23098               encoding = Encodings[encodingArg];

 23099             } else {

 23100               encoding = [];

 23101               var size = parseInt(encodingArg, 10) | 0;

 23102               this.getToken(); // read in 'array'

 23104               for (var j = 0; j < size; j++) {

 23105                 token = this.getToken();

 23106                 // skipping till first dup or def (e.g. ignoring for statement)

 23107                 while (token !== 'dup' && token !== 'def') {

 23108                   token = this.getToken();

 23109                   if (token === null) {

 23110                     return; // invalid header

 23111                   }

 23112                 }

 23113                 if (token === 'def') {

 23114                   break; // read all array data

 23115                 }

 23116                 var index = this.readInt();

 23117                 this.getToken(); // read in '/'

 23118                 var glyph = this.getToken();

 23119                 encoding[index] = glyph;

 23120                 this.getToken(); // read the in 'put'

 23121               }

 23122             }

 23123             properties.builtInEncoding = encoding;

 23124             break;

 23125           case 'FontBBox':

 23126             var fontBBox = this.readNumberArray();

 23127             // adjusting ascent/descent

 23128             properties.ascent = fontBBox[3];

 23129             properties.descent = fontBBox[1];

 23130             properties.ascentScaled = true;

 23131             break;

 23132         }

 23133       }

 23134     }

 23135   };

 23137   return Type1Parser;

 23138 })();

 23140 /**

 23141  * The CFF class takes a Type1 file and wrap it into a

 23142  * 'Compact Font Format' which itself embed Type2 charstrings.

 23143  */

 23144 var CFFStandardStrings = [

 23145   '.notdef', 'space', 'exclam', 'quotedbl', 'numbersign', 'dollar', 'percent',

 23146   'ampersand', 'quoteright', 'parenleft', 'parenright', 'asterisk', 'plus',

 23147   'comma', 'hyphen', 'period', 'slash', 'zero', 'one', 'two', 'three', 'four',

 23148   'five', 'six', 'seven', 'eight', 'nine', 'colon', 'semicolon', 'less',

 23149   'equal', 'greater', 'question', 'at', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',

 23150   'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',

 23151   'X', 'Y', 'Z', 'bracketleft', 'backslash', 'bracketright', 'asciicircum',

 23152   'underscore', 'quoteleft', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',

 23153   'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',

 23154   'z', 'braceleft', 'bar', 'braceright', 'asciitilde', 'exclamdown', 'cent',

 23155   'sterling', 'fraction', 'yen', 'florin', 'section', 'currency',

 23156   'quotesingle', 'quotedblleft', 'guillemotleft', 'guilsinglleft',

 23157   'guilsinglright', 'fi', 'fl', 'endash', 'dagger', 'daggerdbl',

 23158   'periodcentered', 'paragraph', 'bullet', 'quotesinglbase', 'quotedblbase',

 23159   'quotedblright', 'guillemotright', 'ellipsis', 'perthousand', 'questiondown',

 23160   'grave', 'acute', 'circumflex', 'tilde', 'macron', 'breve', 'dotaccent',

 23161   'dieresis', 'ring', 'cedilla', 'hungarumlaut', 'ogonek', 'caron', 'emdash',

 23162   'AE', 'ordfeminine', 'Lslash', 'Oslash', 'OE', 'ordmasculine', 'ae',

 23163   'dotlessi', 'lslash', 'oslash', 'oe', 'germandbls', 'onesuperior',

 23164   'logicalnot', 'mu', 'trademark', 'Eth', 'onehalf', 'plusminus', 'Thorn',

 23165   'onequarter', 'divide', 'brokenbar', 'degree', 'thorn', 'threequarters',

 23166   'twosuperior', 'registered', 'minus', 'eth', 'multiply', 'threesuperior',

 23167   'copyright', 'Aacute', 'Acircumflex', 'Adieresis', 'Agrave', 'Aring',

 23168   'Atilde', 'Ccedilla', 'Eacute', 'Ecircumflex', 'Edieresis', 'Egrave',

 23169   'Iacute', 'Icircumflex', 'Idieresis', 'Igrave', 'Ntilde', 'Oacute',

 23170   'Ocircumflex', 'Odieresis', 'Ograve', 'Otilde', 'Scaron', 'Uacute',

 23171   'Ucircumflex', 'Udieresis', 'Ugrave', 'Yacute', 'Ydieresis', 'Zcaron',

 23172   'aacute', 'acircumflex', 'adieresis', 'agrave', 'aring', 'atilde',

 23173   'ccedilla', 'eacute', 'ecircumflex', 'edieresis', 'egrave', 'iacute',

 23174   'icircumflex', 'idieresis', 'igrave', 'ntilde', 'oacute', 'ocircumflex',

 23175   'odieresis', 'ograve', 'otilde', 'scaron', 'uacute', 'ucircumflex',

 23176   'udieresis', 'ugrave', 'yacute', 'ydieresis', 'zcaron', 'exclamsmall',

 23177   'Hungarumlautsmall', 'dollaroldstyle', 'dollarsuperior', 'ampersandsmall',

 23178   'Acutesmall', 'parenleftsuperior', 'parenrightsuperior', 'twodotenleader',

 23179   'onedotenleader', 'zerooldstyle', 'oneoldstyle', 'twooldstyle',

 23180   'threeoldstyle', 'fouroldstyle', 'fiveoldstyle', 'sixoldstyle',

 23181   'sevenoldstyle', 'eightoldstyle', 'nineoldstyle', 'commasuperior',

 23182   'threequartersemdash', 'periodsuperior', 'questionsmall', 'asuperior',

 23183   'bsuperior', 'centsuperior', 'dsuperior', 'esuperior', 'isuperior',

 23184   'lsuperior', 'msuperior', 'nsuperior', 'osuperior', 'rsuperior', 'ssuperior',

 23185   'tsuperior', 'ff', 'ffi', 'ffl', 'parenleftinferior', 'parenrightinferior',

 23186   'Circumflexsmall', 'hyphensuperior', 'Gravesmall', 'Asmall', 'Bsmall',

 23187   'Csmall', 'Dsmall', 'Esmall', 'Fsmall', 'Gsmall', 'Hsmall', 'Ismall',

 23188   'Jsmall', 'Ksmall', 'Lsmall', 'Msmall', 'Nsmall', 'Osmall', 'Psmall',

 23189   'Qsmall', 'Rsmall', 'Ssmall', 'Tsmall', 'Usmall', 'Vsmall', 'Wsmall',

 23190   'Xsmall', 'Ysmall', 'Zsmall', 'colonmonetary', 'onefitted', 'rupiah',

 23191   'Tildesmall', 'exclamdownsmall', 'centoldstyle', 'Lslashsmall',

 23192   'Scaronsmall', 'Zcaronsmall', 'Dieresissmall', 'Brevesmall', 'Caronsmall',

 23193   'Dotaccentsmall', 'Macronsmall', 'figuredash', 'hypheninferior',

 23194   'Ogoneksmall', 'Ringsmall', 'Cedillasmall', 'questiondownsmall', 'oneeighth',

 23195   'threeeighths', 'fiveeighths', 'seveneighths', 'onethird', 'twothirds',

 23196   'zerosuperior', 'foursuperior', 'fivesuperior', 'sixsuperior',

 23197   'sevensuperior', 'eightsuperior', 'ninesuperior', 'zeroinferior',

 23198   'oneinferior', 'twoinferior', 'threeinferior', 'fourinferior',

 23199   'fiveinferior', 'sixinferior', 'seveninferior', 'eightinferior',

 23200   'nineinferior', 'centinferior', 'dollarinferior', 'periodinferior',

 23201   'commainferior', 'Agravesmall', 'Aacutesmall', 'Acircumflexsmall',

 23202   'Atildesmall', 'Adieresissmall', 'Aringsmall', 'AEsmall', 'Ccedillasmall',

 23203   'Egravesmall', 'Eacutesmall', 'Ecircumflexsmall', 'Edieresissmall',

 23204   'Igravesmall', 'Iacutesmall', 'Icircumflexsmall', 'Idieresissmall',

 23205   'Ethsmall', 'Ntildesmall', 'Ogravesmall', 'Oacutesmall', 'Ocircumflexsmall',

 23206   'Otildesmall', 'Odieresissmall', 'OEsmall', 'Oslashsmall', 'Ugravesmall',

 23207   'Uacutesmall', 'Ucircumflexsmall', 'Udieresissmall', 'Yacutesmall',

 23208   'Thornsmall', 'Ydieresissmall', '001.000', '001.001', '001.002', '001.003',

 23209   'Black', 'Bold', 'Book', 'Light', 'Medium', 'Regular', 'Roman', 'Semibold'

 23210 ];

 23212 // Type1Font is also a CIDFontType0.

 23213 var Type1Font = function Type1Font(name, file, properties) {

 23214   // Some bad generators embed pfb file as is, we have to strip 6-byte headers.

 23215   // Also, length1 and length2 might be off by 6 bytes as well.

 23216   // http://www.math.ubc.ca/~cass/piscript/type1.pdf

 23217   var PFB_HEADER_SIZE = 6;

 23218   var headerBlockLength = properties.length1;

 23219   var eexecBlockLength = properties.length2;

 23220   var pfbHeader = file.peekBytes(PFB_HEADER_SIZE);

 23221   var pfbHeaderPresent = pfbHeader[0] == 0x80 && pfbHeader[1] == 0x01;

 23222   if (pfbHeaderPresent) {

 23223     file.skip(PFB_HEADER_SIZE);

 23224     headerBlockLength = (pfbHeader[5] << 24) | (pfbHeader[4] << 16) |

 23225                         (pfbHeader[3] << 8) | pfbHeader[2];

 23226   }

 23228   // Get the data block containing glyphs and subrs informations

 23229   var headerBlock = new Stream(file.getBytes(headerBlockLength));

 23230   var headerBlockParser = new Type1Parser(headerBlock);

 23231   headerBlockParser.extractFontHeader(properties);

 23233   if (pfbHeaderPresent) {

 23234     pfbHeader = file.getBytes(PFB_HEADER_SIZE);

 23235     eexecBlockLength = (pfbHeader[5] << 24) | (pfbHeader[4] << 16) |

 23236                        (pfbHeader[3] << 8) | pfbHeader[2];

 23237   }

 23239   // Decrypt the data blocks and retrieve it's content

 23240   var eexecBlock = new Stream(file.getBytes(eexecBlockLength));

 23241   var eexecBlockParser = new Type1Parser(eexecBlock, true);

 23242   var data = eexecBlockParser.extractFontProgram();

 23243   for (var info in data.properties) {

 23244     properties[info] = data.properties[info];

 23245   }

 23247   var charstrings = data.charstrings;

 23248   var type2Charstrings = this.getType2Charstrings(charstrings);

 23249   var subrs = this.getType2Subrs(data.subrs);

 23251   this.charstrings = charstrings;

 23252   this.data = this.wrap(name, type2Charstrings, this.charstrings,

 23253                         subrs, properties);

 23254   this.seacs = this.getSeacs(data.charstrings);

 23255 };

 23257 Type1Font.prototype = {

 23258   get numGlyphs() {

 23259     return this.charstrings.length + 1;

 23260   },

 23262   getCharset: function Type1Font_getCharset() {

 23263     var charset = ['.notdef'];

 23264     var charstrings = this.charstrings;

 23265     for (var glyphId = 0; glyphId < charstrings.length; glyphId++) {

 23266       charset.push(charstrings[glyphId].glyphName);

 23267     }

 23268     return charset;

 23269   },

 23271   getGlyphMapping: function Type1Font_getGlyphMapping(properties) {

 23272     var charstrings = this.charstrings;

 23273     var glyphNames = ['.notdef'], glyphId;

 23274     for (glyphId = 0; glyphId < charstrings.length; glyphId++) {

 23275       glyphNames.push(charstrings[glyphId].glyphName);

 23276     }

 23277     var encoding = properties.builtInEncoding;

 23278     if (encoding) {

 23279       var builtInEncoding = {};

 23280       for (var charCode in encoding) {

 23281         glyphId = glyphNames.indexOf(encoding[charCode]);

 23282         if (glyphId >= 0) {

 23283           builtInEncoding[charCode] = glyphId;

 23284         }

 23285       }

 23286     }

 23288     return type1FontGlyphMapping(properties, builtInEncoding, glyphNames);

 23289   },

 23291   getSeacs: function Type1Font_getSeacs(charstrings) {

 23292     var i, ii;

 23293     var seacMap = [];

 23294     for (i = 0, ii = charstrings.length; i < ii; i++) {

 23295       var charstring = charstrings[i];

 23296       if (charstring.seac) {

 23297         // Offset by 1 for .notdef

 23298         seacMap[i + 1] = charstring.seac;

 23299       }

 23300     }

 23301     return seacMap;

 23302   },

 23304   getType2Charstrings: function Type1Font_getType2Charstrings(

 23305                                   type1Charstrings) {

 23306     var type2Charstrings = [];

 23307     for (var i = 0, ii = type1Charstrings.length; i < ii; i++) {

 23308       type2Charstrings.push(type1Charstrings[i].charstring);

 23309     }

 23310     return type2Charstrings;

 23311   },

 23313   getType2Subrs: function Type1Font_getType2Subrs(type1Subrs) {

 23314     var bias = 0;

 23315     var count = type1Subrs.length;

 23316     if (count < 1133) {

 23317       bias = 107;

 23318     } else if (count < 33769) {

 23319       bias = 1131;

 23320     } else {

 23321       bias = 32768;

 23322     }

 23324     // Add a bunch of empty subrs to deal with the Type2 bias

 23325     var type2Subrs = [];

 23326     var i;

 23327     for (i = 0; i < bias; i++) {

 23328       type2Subrs.push([0x0B]);

 23329     }

 23331     for (i = 0; i < count; i++) {

 23332       type2Subrs.push(type1Subrs[i]);

 23333     }

 23335     return type2Subrs;

 23336   },

 23338   wrap: function Type1Font_wrap(name, glyphs, charstrings, subrs, properties) {

 23339     var cff = new CFF();

 23340     cff.header = new CFFHeader(1, 0, 4, 4);

 23342     cff.names = [name];

 23344     var topDict = new CFFTopDict();

 23345     // CFF strings IDs 0...390 are predefined names, so refering

 23346     // to entries in our own String INDEX starts at SID 391.

 23347     topDict.setByName('version', 391);

 23348     topDict.setByName('Notice', 392);

 23349     topDict.setByName('FullName', 393);

 23350     topDict.setByName('FamilyName', 394);

 23351     topDict.setByName('Weight', 395);

 23352     topDict.setByName('Encoding', null); // placeholder

 23353     topDict.setByName('FontMatrix', properties.fontMatrix);

 23354     topDict.setByName('FontBBox', properties.bbox);

 23355     topDict.setByName('charset', null); // placeholder

 23356     topDict.setByName('CharStrings', null); // placeholder

 23357     topDict.setByName('Private', null); // placeholder

 23358     cff.topDict = topDict;

 23360     var strings = new CFFStrings();

 23361     strings.add('Version 0.11'); // Version

 23362     strings.add('See original notice'); // Notice

 23363     strings.add(name); // FullName

 23364     strings.add(name); // FamilyName

 23365     strings.add('Medium'); // Weight

 23366     cff.strings = strings;

 23368     cff.globalSubrIndex = new CFFIndex();

 23370     var count = glyphs.length;

 23371     var charsetArray = [0];

 23372     var i, ii;

 23373     for (i = 0; i < count; i++) {

 23374       var index = CFFStandardStrings.indexOf(charstrings[i].glyphName);

 23375       // TODO: Insert the string and correctly map it.  Previously it was

 23376       // thought mapping names that aren't in the standard strings to .notdef

 23377       // was fine, however in issue818 when mapping them all to .notdef the

 23378       // adieresis glyph no longer worked.

 23379       if (index == -1) {

 23380         index = 0;

 23381       }

 23382       charsetArray.push((index >> 8) & 0xff, index & 0xff);

 23383     }

 23384     cff.charset = new CFFCharset(false, 0, [], charsetArray);

 23386     var charStringsIndex = new CFFIndex();

 23387     charStringsIndex.add([0x8B, 0x0E]); // .notdef

 23388     for (i = 0; i < count; i++) {

 23389       charStringsIndex.add(glyphs[i]);

 23390     }

 23391     cff.charStrings = charStringsIndex;

 23393     var privateDict = new CFFPrivateDict();

 23394     privateDict.setByName('Subrs', null); // placeholder

 23395     var fields = [

 23396       'BlueValues',

 23397       'OtherBlues',

 23398       'FamilyBlues',

 23399       'FamilyOtherBlues',

 23400       'StemSnapH',

 23401       'StemSnapV',

 23402       'BlueShift',

 23403       'BlueFuzz',

 23404       'BlueScale',

 23405       'LanguageGroup',

 23406       'ExpansionFactor',

 23407       'ForceBold',

 23408       'StdHW',

 23409       'StdVW'

 23410     ];

 23411     for (i = 0, ii = fields.length; i < ii; i++) {

 23412       var field = fields[i];

 23413       if (!properties.privateData.hasOwnProperty(field)) {

 23414         continue;

 23415       }

 23416       var value = properties.privateData[field];

 23417       if (isArray(value)) {

 23418         // All of the private dictionary array data in CFF must be stored as

 23419         // "delta-encoded" numbers.

 23420         for (var j = value.length - 1; j > 0; j--) {

 23421           value[j] -= value[j - 1]; // ... difference from previous value

 23422         }

 23423       }

 23424       privateDict.setByName(field, value);

 23425     }

 23426     cff.topDict.privateDict = privateDict;

 23428     var subrIndex = new CFFIndex();

 23429     for (i = 0, ii = subrs.length; i < ii; i++) {

 23430       subrIndex.add(subrs[i]);

 23431     }

 23432     privateDict.subrsIndex = subrIndex;

 23434     var compiler = new CFFCompiler(cff);

 23435     return compiler.compile();

 23436   }

 23437 };

 23439 var CFFFont = (function CFFFontClosure() {

 23440   function CFFFont(file, properties) {

 23441     this.properties = properties;

 23443     var parser = new CFFParser(file, properties);

 23444     this.cff = parser.parse();

 23445     var compiler = new CFFCompiler(this.cff);

 23446     this.seacs = this.cff.seacs;

 23447     try {

 23448       this.data = compiler.compile();

 23449     } catch (e) {

 23450       warn('Failed to compile font ' + properties.loadedName);

 23451       // There may have just been an issue with the compiler, set the data

 23452       // anyway and hope the font loaded.

 23453       this.data = file;

 23454     }

 23455   }

 23457   CFFFont.prototype = {

 23458     get numGlyphs() {

 23459       return this.cff.charStrings.count;

 23460     },

 23461     getCharset: function CFFFont_getCharset() {

 23462       return this.cff.charset.charset;

 23463     },

 23464     getGlyphMapping: function CFFFont_getGlyphMapping() {

 23465       var cff = this.cff;

 23466       var properties = this.properties;

 23467       var charsets = cff.charset.charset;

 23468       var charCodeToGlyphId;

 23469       var glyphId;

 23471       if (properties.composite) {

 23472         charCodeToGlyphId = Object.create(null);

 23473         if (cff.isCIDFont) {

 23474           // If the font is actually a CID font then we should use the charset

 23475           // to map CIDs to GIDs.

 23476           for (glyphId = 0; glyphId < charsets.length; glyphId++) {

 23477             var cidString = String.fromCharCode(charsets[glyphId]);

 23478             var charCode = properties.cMap.map.indexOf(cidString);

 23479             charCodeToGlyphId[charCode] = glyphId;

 23480           }

 23481         } else {

 23482           // If it is NOT actually a CID font then CIDs should be mapped

 23483           // directly to GIDs.

 23484           for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) {

 23485             charCodeToGlyphId[glyphId] = glyphId;

 23486           }

 23487         }

 23488         return charCodeToGlyphId;

 23489       }

 23491       var encoding = cff.encoding ? cff.encoding.encoding : null;

 23492       charCodeToGlyphId = type1FontGlyphMapping(properties, encoding, charsets);

 23493       return charCodeToGlyphId;

 23494     }

 23495   };

 23497   return CFFFont;

 23498 })();

 23500 var CFFParser = (function CFFParserClosure() {

 23501   var CharstringValidationData = [

 23502     null,

 23503     { id: 'hstem', min: 2, resetStack: true, stem: true },

 23504     null,

 23505     { id: 'vstem', min: 2, resetStack: true, stem: true },

 23506     { id: 'vmoveto', min: 1, resetStack: true },

 23507     { id: 'rlineto', min: 2, resetStack: true },

 23508     { id: 'hlineto', min: 1, resetStack: true },

 23509     { id: 'vlineto', min: 1, resetStack: true },

 23510     { id: 'rrcurveto', min: 6, resetStack: true },

 23511     null,

 23512     { id: 'callsubr', min: 1, undefStack: true },

 23513     { id: 'return', min: 0, undefStack: true },

 23514     null, // 12

 23515     null,

 23516     null, // endchar

 23517     null,

 23518     null,

 23519     null,

 23520     { id: 'hstemhm', min: 2, resetStack: true, stem: true },

 23521     null, // hintmask

 23522     null, // cntrmask

 23523     { id: 'rmoveto', min: 2, resetStack: true },

 23524     { id: 'hmoveto', min: 1, resetStack: true },

 23525     { id: 'vstemhm', min: 2, resetStack: true, stem: true },

 23526     { id: 'rcurveline', min: 8, resetStack: true },

 23527     { id: 'rlinecurve', min: 8, resetStack: true },

 23528     { id: 'vvcurveto', min: 4, resetStack: true },

 23529     { id: 'hhcurveto', min: 4, resetStack: true },

 23530     null, // shortint

 23531     { id: 'callgsubr', min: 1, undefStack: true },

 23532     { id: 'vhcurveto', min: 4, resetStack: true },

 23533     { id: 'hvcurveto', min: 4, resetStack: true }

 23534   ];

 23535   var CharstringValidationData12 = [

 23536     null,

 23537     null,

 23538     null,

 23539     { id: 'and', min: 2, stackDelta: -1 },

 23540     { id: 'or', min: 2, stackDelta: -1 },

 23541     { id: 'not', min: 1, stackDelta: 0 },

 23542     null,

 23543     null,

 23544     null,

 23545     { id: 'abs', min: 1, stackDelta: 0 },

 23546     { id: 'add', min: 2, stackDelta: -1,

 23547       stackFn: function stack_div(stack, index) {

 23548         stack[index - 2] = stack[index - 2] + stack[index - 1];

 23549       }

 23550     },

 23551     { id: 'sub', min: 2, stackDelta: -1,

 23552       stackFn: function stack_div(stack, index) {

 23553         stack[index - 2] = stack[index - 2] - stack[index - 1];

 23554       }

 23555     },

 23556     { id: 'div', min: 2, stackDelta: -1,

 23557       stackFn: function stack_div(stack, index) {

 23558         stack[index - 2] = stack[index - 2] / stack[index - 1];

 23559       }

 23560     },

 23561     null,

 23562     { id: 'neg', min: 1, stackDelta: 0,

 23563       stackFn: function stack_div(stack, index) {

 23564         stack[index - 1] = -stack[index - 1];

 23565       }

 23566     },

 23567     { id: 'eq', min: 2, stackDelta: -1 },

 23568     null,

 23569     null,

 23570     { id: 'drop', min: 1, stackDelta: -1 },

 23571     null,

 23572     { id: 'put', min: 2, stackDelta: -2 },

 23573     { id: 'get', min: 1, stackDelta: 0 },

 23574     { id: 'ifelse', min: 4, stackDelta: -3 },

 23575     { id: 'random', min: 0, stackDelta: 1 },

 23576     { id: 'mul', min: 2, stackDelta: -1,

 23577       stackFn: function stack_div(stack, index) {

 23578         stack[index - 2] = stack[index - 2] * stack[index - 1];

 23579       }

 23580     },

 23581     null,

 23582     { id: 'sqrt', min: 1, stackDelta: 0 },

 23583     { id: 'dup', min: 1, stackDelta: 1 },

 23584     { id: 'exch', min: 2, stackDelta: 0 },

 23585     { id: 'index', min: 2, stackDelta: 0 },

 23586     { id: 'roll', min: 3, stackDelta: -2 },

 23587     null,

 23588     null,

 23589     null,

 23590     { id: 'hflex', min: 7, resetStack: true },

 23591     { id: 'flex', min: 13, resetStack: true },

 23592     { id: 'hflex1', min: 9, resetStack: true },

 23593     { id: 'flex1', min: 11, resetStack: true }

 23594   ];

 23596   function CFFParser(file, properties) {

 23597     this.bytes = file.getBytes();

 23598     this.properties = properties;

 23599   }

 23600   CFFParser.prototype = {

 23601     parse: function CFFParser_parse() {

 23602       var properties = this.properties;

 23603       var cff = new CFF();

 23604       this.cff = cff;

 23606       // The first five sections must be in order, all the others are reached

 23607       // via offsets contained in one of the below.

 23608       var header = this.parseHeader();

 23609       var nameIndex = this.parseIndex(header.endPos);

 23610       var topDictIndex = this.parseIndex(nameIndex.endPos);

 23611       var stringIndex = this.parseIndex(topDictIndex.endPos);

 23612       var globalSubrIndex = this.parseIndex(stringIndex.endPos);

 23614       var topDictParsed = this.parseDict(topDictIndex.obj.get(0));

 23615       var topDict = this.createDict(CFFTopDict, topDictParsed, cff.strings);

 23617       cff.header = header.obj;

 23618       cff.names = this.parseNameIndex(nameIndex.obj);

 23619       cff.strings = this.parseStringIndex(stringIndex.obj);

 23620       cff.topDict = topDict;

 23621       cff.globalSubrIndex = globalSubrIndex.obj;

 23623       this.parsePrivateDict(cff.topDict);

 23625       cff.isCIDFont = topDict.hasName('ROS');

 23627       var charStringOffset = topDict.getByName('CharStrings');

 23628       var charStringsAndSeacs = this.parseCharStrings(charStringOffset);

 23629       cff.charStrings = charStringsAndSeacs.charStrings;

 23630       cff.seacs = charStringsAndSeacs.seacs;

 23632       var fontMatrix = topDict.getByName('FontMatrix');

 23633       if (fontMatrix) {

 23634         properties.fontMatrix = fontMatrix;

 23635       }

 23637       var fontBBox = topDict.getByName('FontBBox');

 23638       if (fontBBox) {

 23639         // adjusting ascent/descent

 23640         properties.ascent = fontBBox[3];

 23641         properties.descent = fontBBox[1];

 23642         properties.ascentScaled = true;

 23643       }

 23645       var charset, encoding;

 23646       if (cff.isCIDFont) {

 23647         var fdArrayIndex = this.parseIndex(topDict.getByName('FDArray')).obj;

 23648         for (var i = 0, ii = fdArrayIndex.count; i < ii; ++i) {

 23649           var dictRaw = fdArrayIndex.get(i);

 23650           var fontDict = this.createDict(CFFTopDict, this.parseDict(dictRaw),

 23651                                          cff.strings);

 23652           this.parsePrivateDict(fontDict);

 23653           cff.fdArray.push(fontDict);

 23654         }

 23655         // cid fonts don't have an encoding

 23656         encoding = null;

 23657         charset = this.parseCharsets(topDict.getByName('charset'),

 23658                                      cff.charStrings.count, cff.strings, true);

 23659         cff.fdSelect = this.parseFDSelect(topDict.getByName('FDSelect'),

 23660                                              cff.charStrings.count);

 23661       } else {

 23662         charset = this.parseCharsets(topDict.getByName('charset'),

 23663                                      cff.charStrings.count, cff.strings, false);

 23664         encoding = this.parseEncoding(topDict.getByName('Encoding'),

 23665                                       properties,

 23666                                       cff.strings, charset.charset);

 23667       }

 23668       cff.charset = charset;

 23669       cff.encoding = encoding;

 23671       return cff;

 23672     },

 23673     parseHeader: function CFFParser_parseHeader() {

 23674       var bytes = this.bytes;

 23675       var bytesLength = bytes.length;

 23676       var offset = 0;

 23678       // Prevent an infinite loop, by checking that the offset is within the

 23679       // bounds of the bytes array. Necessary in empty, or invalid, font files.

 23680       while (offset < bytesLength && bytes[offset] !== 1) {

 23681         ++offset;

 23682       }

 23683       if (offset >= bytesLength) {

 23684         error('Invalid CFF header');

 23685       } else if (offset !== 0) {

 23686         info('cff data is shifted');

 23687         bytes = bytes.subarray(offset);

 23688         this.bytes = bytes;

 23689       }

 23690       var major = bytes[0];

 23691       var minor = bytes[1];

 23692       var hdrSize = bytes[2];

 23693       var offSize = bytes[3];

 23694       var header = new CFFHeader(major, minor, hdrSize, offSize);

 23695       return { obj: header, endPos: hdrSize };

 23696     },

 23697     parseDict: function CFFParser_parseDict(dict) {

 23698       var pos = 0;

 23700       function parseOperand() {

 23701         var value = dict[pos++];

 23702         if (value === 30) {

 23703           return parseFloatOperand(pos);

 23704         } else if (value === 28) {

 23705           value = dict[pos++];

 23706           value = ((value << 24) | (dict[pos++] << 16)) >> 16;

 23707           return value;

 23708         } else if (value === 29) {

 23709           value = dict[pos++];

 23710           value = (value << 8) | dict[pos++];

 23711           value = (value << 8) | dict[pos++];

 23712           value = (value << 8) | dict[pos++];

 23713           return value;

 23714         } else if (value >= 32 && value <= 246) {

 23715           return value - 139;

 23716         } else if (value >= 247 && value <= 250) {

 23717           return ((value - 247) * 256) + dict[pos++] + 108;

 23718         } else if (value >= 251 && value <= 254) {

 23719           return -((value - 251) * 256) - dict[pos++] - 108;

 23720         } else {

 23721           error('255 is not a valid DICT command');

 23722         }

 23723         return -1;

 23724       }

 23726       function parseFloatOperand() {

 23727         var str = '';

 23728         var eof = 15;

 23729         var lookup = ['0', '1', '2', '3', '4', '5', '6', '7', '8',

 23730             '9', '.', 'E', 'E-', null, '-'];

 23731         var length = dict.length;

 23732         while (pos < length) {

 23733           var b = dict[pos++];

 23734           var b1 = b >> 4;

 23735           var b2 = b & 15;

 23737           if (b1 == eof) {

 23738             break;

 23739           }

 23740           str += lookup[b1];

 23742           if (b2 == eof) {

 23743             break;

 23744           }

 23745           str += lookup[b2];

 23746         }

 23747         return parseFloat(str);

 23748       }

 23750       var operands = [];

 23751       var entries = [];

 23753       pos = 0;

 23754       var end = dict.length;

 23755       while (pos < end) {

 23756         var b = dict[pos];

 23757         if (b <= 21) {

 23758           if (b === 12) {

 23759             b = (b << 8) | dict[++pos];

 23760           }

 23761           entries.push([b, operands]);

 23762           operands = [];

 23763           ++pos;

 23764         } else {

 23765           operands.push(parseOperand());

 23766         }

 23767       }

 23768       return entries;

 23769     },

 23770     parseIndex: function CFFParser_parseIndex(pos) {

 23771       var cffIndex = new CFFIndex();

 23772       var bytes = this.bytes;

 23773       var count = (bytes[pos++] << 8) | bytes[pos++];

 23774       var offsets = [];

 23775       var end = pos;

 23776       var i, ii;

 23778       if (count !== 0) {

 23779         var offsetSize = bytes[pos++];

 23780         // add 1 for offset to determine size of last object

 23781         var startPos = pos + ((count + 1) * offsetSize) - 1;

 23783         for (i = 0, ii = count + 1; i < ii; ++i) {

 23784           var offset = 0;

 23785           for (var j = 0; j < offsetSize; ++j) {

 23786             offset <<= 8;

 23787             offset += bytes[pos++];

 23788           }

 23789           offsets.push(startPos + offset);

 23790         }

 23791         end = offsets[count];

 23792       }

 23793       for (i = 0, ii = offsets.length - 1; i < ii; ++i) {

 23794         var offsetStart = offsets[i];

 23795         var offsetEnd = offsets[i + 1];

 23796         cffIndex.add(bytes.subarray(offsetStart, offsetEnd));

 23797       }

 23798       return {obj: cffIndex, endPos: end};

 23799     },

 23800     parseNameIndex: function CFFParser_parseNameIndex(index) {

 23801       var names = [];

 23802       for (var i = 0, ii = index.count; i < ii; ++i) {

 23803         var name = index.get(i);

 23804         // OTS doesn't allow names to be over 127 characters.

 23805         var length = Math.min(name.length, 127);

 23806         var data = [];

 23807         // OTS also only permits certain characters in the name.

 23808         for (var j = 0; j < length; ++j) {

 23809           var c = name[j];

 23810           if (j === 0 && c === 0) {

 23811             data[j] = c;

 23812             continue;

 23813           }

 23814           if ((c < 33 || c > 126) || c === 91 /* [ */ || c === 93 /* ] */ ||

 23815               c === 40 /* ( */ || c === 41 /* ) */ || c === 123 /* { */ ||

 23816               c === 125 /* } */ || c === 60 /* < */ || c === 62 /* > */ ||

 23817               c === 47 /* / */ || c === 37 /* % */ || c === 35 /* # */) {

 23818             data[j] = 95;

 23819             continue;

 23820           }

 23821           data[j] = c;

 23822         }

 23823         names.push(bytesToString(data));

 23824       }

 23825       return names;

 23826     },

 23827     parseStringIndex: function CFFParser_parseStringIndex(index) {

 23828       var strings = new CFFStrings();

 23829       for (var i = 0, ii = index.count; i < ii; ++i) {

 23830         var data = index.get(i);

 23831         strings.add(bytesToString(data));

 23832       }

 23833       return strings;

 23834     },

 23835     createDict: function CFFParser_createDict(Type, dict, strings) {

 23836       var cffDict = new Type(strings);

 23837       for (var i = 0, ii = dict.length; i < ii; ++i) {

 23838         var pair = dict[i];

 23839         var key = pair[0];

 23840         var value = pair[1];

 23841         cffDict.setByKey(key, value);

 23842       }

 23843       return cffDict;

 23844     },

 23845     parseCharStrings: function CFFParser_parseCharStrings(charStringOffset) {

 23846       var charStrings = this.parseIndex(charStringOffset).obj;

 23847       var seacs = [];

 23848       var count = charStrings.count;

 23849       for (var i = 0; i < count; i++) {

 23850         var charstring = charStrings.get(i);

 23852         var stackSize = 0;

 23853         var stack = [];

 23854         var undefStack = true;

 23855         var hints = 0;

 23856         var valid = true;

 23857         var data = charstring;

 23858         var length = data.length;

 23859         for (var j = 0; j < length;) {

 23860           var value = data[j++];

 23861           var validationCommand = null;

 23862           if (value == 12) {

 23863             var q = data[j++];

 23864             if (q === 0) {

 23865               // The CFF specification state that the 'dotsection' command

 23866               // (12, 0) is deprecated and treated as a no-op, but all Type2

 23867               // charstrings processors should support them. Unfortunately

 23868               // the font sanitizer don't. As a workaround the sequence (12, 0)

 23869               // is replaced by a useless (0, hmoveto).

 23870               data[j - 2] = 139;

 23871               data[j - 1] = 22;

 23872               stackSize = 0;

 23873             } else {

 23874               validationCommand = CharstringValidationData12[q];

 23875             }

 23876           } else if (value === 28) { // number (16 bit)

 23877             stack[stackSize] = ((data[j] << 24) | (data[j + 1] << 16)) >> 16;

 23878             j += 2;

 23879             stackSize++;

 23880           } else if (value == 14) {

 23881             if (stackSize >= 4) {

 23882               stackSize -= 4;

 23883               if (SEAC_ANALYSIS_ENABLED) {

 23884                 seacs[i] = stack.slice(stackSize, stackSize + 4);

 23885                 valid = false;

 23886               }

 23887             }

 23888           } else if (value >= 32 && value <= 246) {  // number

 23889             stack[stackSize] = value - 139;

 23890             stackSize++;

 23891           } else if (value >= 247 && value <= 254) {  // number (+1 bytes)

 23892             stack[stackSize] = (value < 251 ?

 23893                                 ((value - 247) << 8) + data[j] + 108 :

 23894                                 -((value - 251) << 8) - data[j] - 108);

 23895             j++;

 23896             stackSize++;

 23897           } else if (value == 255) {  // number (32 bit)

 23898             stack[stackSize] = ((data[j] << 24) | (data[j + 1] << 16) |

 23899                                 (data[j + 2] << 8) | data[j + 3]) / 65536;

 23900             j += 4;

 23901             stackSize++;

 23902           } else if (value == 19 || value == 20) {

 23903             hints += stackSize >> 1;

 23904             j += (hints + 7) >> 3; // skipping right amount of hints flag data

 23905             stackSize = 0;

 23906           } else {

 23907             validationCommand = CharstringValidationData[value];

 23908           }

 23909           if (validationCommand) {

 23910             if (validationCommand.stem) {

 23911               hints += stackSize >> 1;

 23912             }

 23913             if ('min' in validationCommand) {

 23914               if (!undefStack && stackSize < validationCommand.min) {

 23915                 warn('Not enough parameters for ' + validationCommand.id +

 23916                      '; actual: ' + stackSize +

 23917                      ', expected: ' + validationCommand.min);

 23918                 valid = false;

 23919                 break;

 23920               }

 23921             }

 23922             if ('stackDelta' in validationCommand) {

 23923               if ('stackFn' in validationCommand) {

 23924                 validationCommand.stackFn(stack, stackSize);

 23925               }

 23926               stackSize += validationCommand.stackDelta;

 23927             } else if (validationCommand.resetStack) {

 23928               stackSize = 0;

 23929               undefStack = false;

 23930             } else if (validationCommand.undefStack) {

 23931               stackSize = 0;

 23932               undefStack = true;

 23933             }

 23934           }

 23935         }

 23936         if (!valid) {

 23937           // resetting invalid charstring to single 'endchar'

 23938           charStrings.set(i, new Uint8Array([14]));

 23939         }

 23940       }

 23941       return { charStrings: charStrings, seacs: seacs };

 23942     },

 23943     emptyPrivateDictionary:

 23944       function CFFParser_emptyPrivateDictionary(parentDict) {

 23945       var privateDict = this.createDict(CFFPrivateDict, [],

 23946                                         parentDict.strings);

 23947       parentDict.setByKey(18, [0, 0]);

 23948       parentDict.privateDict = privateDict;

 23949     },

 23950     parsePrivateDict: function CFFParser_parsePrivateDict(parentDict) {

 23951       // no private dict, do nothing

 23952       if (!parentDict.hasName('Private')) {

 23953         this.emptyPrivateDictionary(parentDict);

 23954         return;

 23955       }

 23956       var privateOffset = parentDict.getByName('Private');

 23957       // make sure the params are formatted correctly

 23958       if (!isArray(privateOffset) || privateOffset.length !== 2) {

 23959         parentDict.removeByName('Private');

 23960         return;

 23961       }

 23962       var size = privateOffset[0];

 23963       var offset = privateOffset[1];

 23964       // remove empty dicts or ones that refer to invalid location

 23965       if (size === 0 || offset >= this.bytes.length) {

 23966         this.emptyPrivateDictionary(parentDict);

 23967         return;

 23968       }

 23970       var privateDictEnd = offset + size;

 23971       var dictData = this.bytes.subarray(offset, privateDictEnd);

 23972       var dict = this.parseDict(dictData);

 23973       var privateDict = this.createDict(CFFPrivateDict, dict,

 23974                                         parentDict.strings);

 23975       parentDict.privateDict = privateDict;

 23977       // Parse the Subrs index also since it's relative to the private dict.

 23978       if (!privateDict.getByName('Subrs')) {

 23979         return;

 23980       }

 23981       var subrsOffset = privateDict.getByName('Subrs');

 23982       var relativeOffset = offset + subrsOffset;

 23983       // Validate the offset.

 23984       if (subrsOffset === 0 || relativeOffset >= this.bytes.length) {

 23985         this.emptyPrivateDictionary(parentDict);

 23986         return;

 23987       }

 23988       var subrsIndex = this.parseIndex(relativeOffset);

 23989       privateDict.subrsIndex = subrsIndex.obj;

 23990     },

 23991     parseCharsets: function CFFParser_parseCharsets(pos, length, strings, cid) {

 23992       if (pos === 0) {

 23993         return new CFFCharset(true, CFFCharsetPredefinedTypes.ISO_ADOBE,

 23994                               ISOAdobeCharset);

 23995       } else if (pos == 1) {

 23996         return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT,

 23997                               ExpertCharset);

 23998       } else if (pos == 2) {

 23999         return new CFFCharset(true, CFFCharsetPredefinedTypes.EXPERT_SUBSET,

 24000                               ExpertSubsetCharset);

 24001       }

 24003       var bytes = this.bytes;

 24004       var start = pos;

 24005       var format = bytes[pos++];

 24006       var charset = ['.notdef'];

 24007       var id, count, i;

 24009       // subtract 1 for the .notdef glyph

 24010       length -= 1;

 24012       switch (format) {

 24013         case 0:

 24014           for (i = 0; i < length; i++) {

 24015             id = (bytes[pos++] << 8) | bytes[pos++];

 24016             charset.push(cid ? id : strings.get(id));

 24017           }

 24018           break;

 24019         case 1:

 24020           while (charset.length <= length) {

 24021             id = (bytes[pos++] << 8) | bytes[pos++];

 24022             count = bytes[pos++];

 24023             for (i = 0; i <= count; i++) {

 24024               charset.push(cid ? id++ : strings.get(id++));

 24025             }

 24026           }

 24027           break;

 24028         case 2:

 24029           while (charset.length <= length) {

 24030             id = (bytes[pos++] << 8) | bytes[pos++];

 24031             count = (bytes[pos++] << 8) | bytes[pos++];

 24032             for (i = 0; i <= count; i++) {

 24033               charset.push(cid ? id++ : strings.get(id++));

 24034             }

 24035           }

 24036           break;

 24037         default:

 24038           error('Unknown charset format');

 24039       }

 24040       // Raw won't be needed if we actually compile the charset.

 24041       var end = pos;

 24042       var raw = bytes.subarray(start, end);

 24044       return new CFFCharset(false, format, charset, raw);

 24045     },

 24046     parseEncoding: function CFFParser_parseEncoding(pos,

 24047                                                     properties,

 24048                                                     strings,

 24049                                                     charset) {

 24050       var encoding = {};

 24051       var bytes = this.bytes;

 24052       var predefined = false;

 24053       var hasSupplement = false;

 24054       var format, i, ii;

 24055       var raw = null;

 24057       function readSupplement() {

 24058         var supplementsCount = bytes[pos++];

 24059         for (i = 0; i < supplementsCount; i++) {

 24060           var code = bytes[pos++];

 24061           var sid = (bytes[pos++] << 8) + (bytes[pos++] & 0xff);

 24062           encoding[code] = charset.indexOf(strings.get(sid));

 24063         }

 24064       }

 24066       if (pos === 0 || pos == 1) {

 24067         predefined = true;

 24068         format = pos;

 24069         var baseEncoding = pos ? Encodings.ExpertEncoding :

 24070                                  Encodings.StandardEncoding;

 24071         for (i = 0, ii = charset.length; i < ii; i++) {

 24072           var index = baseEncoding.indexOf(charset[i]);

 24073           if (index != -1) {

 24074             encoding[index] = i;

 24075           }

 24076         }

 24077       } else {

 24078         var dataStart = pos;

 24079         format = bytes[pos++];

 24080         switch (format & 0x7f) {

 24081           case 0:

 24082             var glyphsCount = bytes[pos++];

 24083             for (i = 1; i <= glyphsCount; i++) {

 24084               encoding[bytes[pos++]] = i;

 24085             }

 24086             break;

 24088           case 1:

 24089             var rangesCount = bytes[pos++];

 24090             var gid = 1;

 24091             for (i = 0; i < rangesCount; i++) {

 24092               var start = bytes[pos++];

 24093               var left = bytes[pos++];

 24094               for (var j = start; j <= start + left; j++) {

 24095                 encoding[j] = gid++;

 24096               }

 24097             }

 24098             break;

 24100           default:

 24101             error('Unknow encoding format: ' + format + ' in CFF');

 24102             break;

 24103         }

 24104         var dataEnd = pos;

 24105         if (format & 0x80) {

 24106           // The font sanitizer does not support CFF encoding with a

 24107           // supplement, since the encoding is not really used to map

 24108           // between gid to glyph, let's overwrite what is declared in

 24109           // the top dictionary to let the sanitizer think the font use

 24110           // StandardEncoding, that's a lie but that's ok.

 24111           bytes[dataStart] &= 0x7f;

 24112           readSupplement();

 24113           hasSupplement = true;

 24114         }

 24115         raw = bytes.subarray(dataStart, dataEnd);

 24116       }

 24117       format = format & 0x7f;

 24118       return new CFFEncoding(predefined, format, encoding, raw);

 24119     },

 24120     parseFDSelect: function CFFParser_parseFDSelect(pos, length) {

 24121       var start = pos;

 24122       var bytes = this.bytes;

 24123       var format = bytes[pos++];

 24124       var fdSelect = [];

 24125       var i;

 24127       switch (format) {

 24128         case 0:

 24129           for (i = 0; i < length; ++i) {

 24130             var id = bytes[pos++];

 24131             fdSelect.push(id);

 24132           }

 24133           break;

 24134         case 3:

 24135           var rangesCount = (bytes[pos++] << 8) | bytes[pos++];

 24136           for (i = 0; i < rangesCount; ++i) {

 24137             var first = (bytes[pos++] << 8) | bytes[pos++];

 24138             var fdIndex = bytes[pos++];

 24139             var next = (bytes[pos] << 8) | bytes[pos + 1];

 24140             for (var j = first; j < next; ++j) {

 24141               fdSelect.push(fdIndex);

 24142             }

 24143           }

 24144           // Advance past the sentinel(next).

 24145           pos += 2;

 24146           break;

 24147         default:

 24148           error('Unknown fdselect format ' + format);

 24149           break;

 24150       }

 24151       var end = pos;

 24152       return new CFFFDSelect(fdSelect, bytes.subarray(start, end));

 24153     }

 24154   };

 24155   return CFFParser;

 24156 })();

 24158 // Compact Font Format

 24159 var CFF = (function CFFClosure() {

 24160   function CFF() {

 24161     this.header = null;

 24162     this.names = [];

 24163     this.topDict = null;

 24164     this.strings = new CFFStrings();

 24165     this.globalSubrIndex = null;

 24167     // The following could really be per font, but since we only have one font

 24168     // store them here.

 24169     this.encoding = null;

 24170     this.charset = null;

 24171     this.charStrings = null;

 24172     this.fdArray = [];

 24173     this.fdSelect = null;

 24175     this.isCIDFont = false;

 24176   }

 24177   return CFF;

 24178 })();

 24180 var CFFHeader = (function CFFHeaderClosure() {

 24181   function CFFHeader(major, minor, hdrSize, offSize) {

 24182     this.major = major;

 24183     this.minor = minor;

 24184     this.hdrSize = hdrSize;

 24185     this.offSize = offSize;

 24186   }

 24187   return CFFHeader;

 24188 })();

 24190 var CFFStrings = (function CFFStringsClosure() {

 24191   function CFFStrings() {

 24192     this.strings = [];

 24193   }

 24194   CFFStrings.prototype = {

 24195     get: function CFFStrings_get(index) {

 24196       if (index >= 0 && index <= 390) {

 24197         return CFFStandardStrings[index];

 24198       }

 24199       if (index - 391 <= this.strings.length) {

 24200         return this.strings[index - 391];

 24201       }

 24202       return CFFStandardStrings[0];

 24203     },

 24204     add: function CFFStrings_add(value) {

 24205       this.strings.push(value);

 24206     },

 24207     get count() {

 24208       return this.strings.length;

 24209     }

 24210   };

 24211   return CFFStrings;

 24212 })();

 24214 var CFFIndex = (function CFFIndexClosure() {

 24215   function CFFIndex() {

 24216     this.objects = [];

 24217     this.length = 0;

 24218   }

 24219   CFFIndex.prototype = {

 24220     add: function CFFIndex_add(data) {

 24221       this.length += data.length;

 24222       this.objects.push(data);

 24223     },

 24224     set: function CFFIndex_set(index, data) {

 24225       this.length += data.length - this.objects[index].length;

 24226       this.objects[index] = data;

 24227     },

 24228     get: function CFFIndex_get(index) {

 24229       return this.objects[index];

 24230     },

 24231     get count() {

 24232       return this.objects.length;

 24233     }

 24234   };

 24235   return CFFIndex;

 24236 })();

 24238 var CFFDict = (function CFFDictClosure() {

 24239   function CFFDict(tables, strings) {

 24240     this.keyToNameMap = tables.keyToNameMap;

 24241     this.nameToKeyMap = tables.nameToKeyMap;

 24242     this.defaults = tables.defaults;

 24243     this.types = tables.types;

 24244     this.opcodes = tables.opcodes;

 24245     this.order = tables.order;

 24246     this.strings = strings;

 24247     this.values = {};

 24248   }

 24249   CFFDict.prototype = {

 24250     // value should always be an array

 24251     setByKey: function CFFDict_setByKey(key, value) {

 24252       if (!(key in this.keyToNameMap)) {

 24253         return false;

 24254       }

 24255       // ignore empty values

 24256       if (value.length === 0) {

 24257         return true;

 24258       }

 24259       var type = this.types[key];

 24260       // remove the array wrapping these types of values

 24261       if (type === 'num' || type === 'sid' || type === 'offset') {

 24262         value = value[0];

 24263       }

 24264       this.values[key] = value;

 24265       return true;

 24266     },

 24267     setByName: function CFFDict_setByName(name, value) {

 24268       if (!(name in this.nameToKeyMap)) {

 24269         error('Invalid dictionary name "' + name + '"');

 24270       }

 24271       this.values[this.nameToKeyMap[name]] = value;

 24272     },

 24273     hasName: function CFFDict_hasName(name) {

 24274       return this.nameToKeyMap[name] in this.values;

 24275     },

 24276     getByName: function CFFDict_getByName(name) {

 24277       if (!(name in this.nameToKeyMap)) {

 24278         error('Invalid dictionary name "' + name + '"');

 24279       }

 24280       var key = this.nameToKeyMap[name];

 24281       if (!(key in this.values)) {

 24282         return this.defaults[key];

 24283       }

 24284       return this.values[key];

 24285     },

 24286     removeByName: function CFFDict_removeByName(name) {

 24287       delete this.values[this.nameToKeyMap[name]];

 24288     }

 24289   };

 24290   CFFDict.createTables = function CFFDict_createTables(layout) {

 24291     var tables = {

 24292       keyToNameMap: {},

 24293       nameToKeyMap: {},

 24294       defaults: {},

 24295       types: {},

 24296       opcodes: {},

 24297       order: []

 24298     };

 24299     for (var i = 0, ii = layout.length; i < ii; ++i) {

 24300       var entry = layout[i];

 24301       var key = isArray(entry[0]) ? (entry[0][0] << 8) + entry[0][1] : entry[0];

 24302       tables.keyToNameMap[key] = entry[1];

 24303       tables.nameToKeyMap[entry[1]] = key;

 24304       tables.types[key] = entry[2];

 24305       tables.defaults[key] = entry[3];

 24306       tables.opcodes[key] = isArray(entry[0]) ? entry[0] : [entry[0]];

 24307       tables.order.push(key);

 24308     }

 24309     return tables;

 24310   };

 24311   return CFFDict;

 24312 })();

 24314 var CFFTopDict = (function CFFTopDictClosure() {

 24315   var layout = [

 24316     [[12, 30], 'ROS', ['sid', 'sid', 'num'], null],

 24317     [[12, 20], 'SyntheticBase', 'num', null],

 24318     [0, 'version', 'sid', null],

 24319     [1, 'Notice', 'sid', null],

 24320     [[12, 0], 'Copyright', 'sid', null],

 24321     [2, 'FullName', 'sid', null],

 24322     [3, 'FamilyName', 'sid', null],

 24323     [4, 'Weight', 'sid', null],

 24324     [[12, 1], 'isFixedPitch', 'num', 0],

 24325     [[12, 2], 'ItalicAngle', 'num', 0],

 24326     [[12, 3], 'UnderlinePosition', 'num', -100],

 24327     [[12, 4], 'UnderlineThickness', 'num', 50],

 24328     [[12, 5], 'PaintType', 'num', 0],

 24329     [[12, 6], 'CharstringType', 'num', 2],

 24330     [[12, 7], 'FontMatrix', ['num', 'num', 'num', 'num', 'num', 'num'],

 24331                             [0.001, 0, 0, 0.001, 0, 0]],

 24332     [13, 'UniqueID', 'num', null],

 24333     [5, 'FontBBox', ['num', 'num', 'num', 'num'], [0, 0, 0, 0]],

 24334     [[12, 8], 'StrokeWidth', 'num', 0],

 24335     [14, 'XUID', 'array', null],

 24336     [15, 'charset', 'offset', 0],

 24337     [16, 'Encoding', 'offset', 0],

 24338     [17, 'CharStrings', 'offset', 0],

 24339     [18, 'Private', ['offset', 'offset'], null],

 24340     [[12, 21], 'PostScript', 'sid', null],

 24341     [[12, 22], 'BaseFontName', 'sid', null],

 24342     [[12, 23], 'BaseFontBlend', 'delta', null],

 24343     [[12, 31], 'CIDFontVersion', 'num', 0],

 24344     [[12, 32], 'CIDFontRevision', 'num', 0],

 24345     [[12, 33], 'CIDFontType', 'num', 0],

 24346     [[12, 34], 'CIDCount', 'num', 8720],

 24347     [[12, 35], 'UIDBase', 'num', null],

 24348     // XXX: CID Fonts on DirectWrite 6.1 only seem to work if FDSelect comes

 24349     // before FDArray.

 24350     [[12, 37], 'FDSelect', 'offset', null],

 24351     [[12, 36], 'FDArray', 'offset', null],

 24352     [[12, 38], 'FontName', 'sid', null]

 24353   ];

 24354   var tables = null;

 24355   function CFFTopDict(strings) {

 24356     if (tables === null) {

 24357       tables = CFFDict.createTables(layout);

 24358     }

 24359     CFFDict.call(this, tables, strings);

 24360     this.privateDict = null;

 24361   }

 24362   CFFTopDict.prototype = Object.create(CFFDict.prototype);

 24363   return CFFTopDict;

 24364 })();

 24366 var CFFPrivateDict = (function CFFPrivateDictClosure() {

 24367   var layout = [

 24368     [6, 'BlueValues', 'delta', null],

 24369     [7, 'OtherBlues', 'delta', null],

 24370     [8, 'FamilyBlues', 'delta', null],

 24371     [9, 'FamilyOtherBlues', 'delta', null],

 24372     [[12, 9], 'BlueScale', 'num', 0.039625],

 24373     [[12, 10], 'BlueShift', 'num', 7],

 24374     [[12, 11], 'BlueFuzz', 'num', 1],

 24375     [10, 'StdHW', 'num', null],

 24376     [11, 'StdVW', 'num', null],

 24377     [[12, 12], 'StemSnapH', 'delta', null],

 24378     [[12, 13], 'StemSnapV', 'delta', null],

 24379     [[12, 14], 'ForceBold', 'num', 0],

 24380     [[12, 17], 'LanguageGroup', 'num', 0],

 24381     [[12, 18], 'ExpansionFactor', 'num', 0.06],

 24382     [[12, 19], 'initialRandomSeed', 'num', 0],

 24383     [20, 'defaultWidthX', 'num', 0],

 24384     [21, 'nominalWidthX', 'num', 0],

 24385     [19, 'Subrs', 'offset', null]

 24386   ];

 24387   var tables = null;

 24388   function CFFPrivateDict(strings) {

 24389     if (tables === null) {

 24390       tables = CFFDict.createTables(layout);

 24391     }

 24392     CFFDict.call(this, tables, strings);

 24393     this.subrsIndex = null;

 24394   }

 24395   CFFPrivateDict.prototype = Object.create(CFFDict.prototype);

 24396   return CFFPrivateDict;

 24397 })();

 24399 var CFFCharsetPredefinedTypes = {

 24400   ISO_ADOBE: 0,

 24401   EXPERT: 1,

 24402   EXPERT_SUBSET: 2

 24403 };

 24404 var CFFCharset = (function CFFCharsetClosure() {

 24405   function CFFCharset(predefined, format, charset, raw) {

 24406     this.predefined = predefined;

 24407     this.format = format;

 24408     this.charset = charset;

 24409     this.raw = raw;

 24410   }

 24411   return CFFCharset;

 24412 })();

 24414 var CFFEncoding = (function CFFEncodingClosure() {

 24415   function CFFEncoding(predefined, format, encoding, raw) {

 24416     this.predefined = predefined;

 24417     this.format = format;

 24418     this.encoding = encoding;

 24419     this.raw = raw;

 24420   }

 24421   return CFFEncoding;

 24422 })();

 24424 var CFFFDSelect = (function CFFFDSelectClosure() {

 24425   function CFFFDSelect(fdSelect, raw) {

 24426     this.fdSelect = fdSelect;

 24427     this.raw = raw;

 24428   }

 24429   return CFFFDSelect;

 24430 })();

 24432 // Helper class to keep track of where an offset is within the data and helps

 24433 // filling in that offset once it's known.

 24434 var CFFOffsetTracker = (function CFFOffsetTrackerClosure() {

 24435   function CFFOffsetTracker() {

 24436     this.offsets = {};

 24437   }

 24438   CFFOffsetTracker.prototype = {

 24439     isTracking: function CFFOffsetTracker_isTracking(key) {

 24440       return key in this.offsets;

 24441     },

 24442     track: function CFFOffsetTracker_track(key, location) {

 24443       if (key in this.offsets) {

 24444         error('Already tracking location of ' + key);

 24445       }

 24446       this.offsets[key] = location;

 24447     },

 24448     offset: function CFFOffsetTracker_offset(value) {

 24449       for (var key in this.offsets) {

 24450         this.offsets[key] += value;

 24451       }

 24452     },

 24453     setEntryLocation: function CFFOffsetTracker_setEntryLocation(key,

 24454                                                                  values,

 24455                                                                  output) {

 24456       if (!(key in this.offsets)) {

 24457         error('Not tracking location of ' + key);

 24458       }

 24459       var data = output.data;

 24460       var dataOffset = this.offsets[key];

 24461       var size = 5;

 24462       for (var i = 0, ii = values.length; i < ii; ++i) {

 24463         var offset0 = i * size + dataOffset;

 24464         var offset1 = offset0 + 1;

 24465         var offset2 = offset0 + 2;

 24466         var offset3 = offset0 + 3;

 24467         var offset4 = offset0 + 4;

 24468         // It's easy to screw up offsets so perform this sanity check.

 24469         if (data[offset0] !== 0x1d || data[offset1] !== 0 ||

 24470             data[offset2] !== 0 || data[offset3] !== 0 || data[offset4] !== 0) {

 24471           error('writing to an offset that is not empty');

 24472         }

 24473         var value = values[i];

 24474         data[offset0] = 0x1d;

 24475         data[offset1] = (value >> 24) & 0xFF;

 24476         data[offset2] = (value >> 16) & 0xFF;

 24477         data[offset3] = (value >> 8) & 0xFF;

 24478         data[offset4] = value & 0xFF;

 24479       }

 24480     }

 24481   };

 24482   return CFFOffsetTracker;

 24483 })();

 24485 // Takes a CFF and converts it to the binary representation.

 24486 var CFFCompiler = (function CFFCompilerClosure() {

 24487   function CFFCompiler(cff) {

 24488     this.cff = cff;

 24489   }

 24490   CFFCompiler.prototype = {

 24491     compile: function CFFCompiler_compile() {

 24492       var cff = this.cff;

 24493       var output = {

 24494         data: [],

 24495         length: 0,

 24496         add: function CFFCompiler_add(data) {

 24497           this.data = this.data.concat(data);

 24498           this.length = this.data.length;

 24499         }

 24500       };

 24502       // Compile the five entries that must be in order.

 24503       var header = this.compileHeader(cff.header);

 24504       output.add(header);

 24506       var nameIndex = this.compileNameIndex(cff.names);

 24507       output.add(nameIndex);

 24509       if (cff.isCIDFont) {

 24510         // The spec is unclear on how font matrices should relate to each other

 24511         // when there is one in the main top dict and the sub top dicts.

 24512         // Windows handles this differently than linux and osx so we have to

 24513         // normalize to work on all.

 24514         // Rules based off of some mailing list discussions:

 24515         // - If main font has a matrix and subfont doesn't, use the main matrix.

 24516         // - If no main font matrix and there is a subfont matrix, use the

 24517         //   subfont matrix.

 24518         // - If both have matrices, concat together.

 24519         // - If neither have matrices, use default.

 24520         // To make this work on all platforms we move the top matrix into each

 24521         // sub top dict and concat if necessary.

 24522         if (cff.topDict.hasName('FontMatrix')) {

 24523           var base = cff.topDict.getByName('FontMatrix');

 24524           cff.topDict.removeByName('FontMatrix');

 24525           for (var i = 0, ii = cff.fdArray.length; i < ii; i++) {

 24526             var subDict = cff.fdArray[i];

 24527             var matrix = base.slice(0);

 24528             if (subDict.hasName('FontMatrix')) {

 24529               matrix = Util.transform(matrix, subDict.getByName('FontMatrix'));

 24530             }

 24531             subDict.setByName('FontMatrix', matrix);

 24532           }

 24533         }

 24534       }

 24536       var compiled = this.compileTopDicts([cff.topDict],

 24537                                           output.length,

 24538                                           cff.isCIDFont);

 24539       output.add(compiled.output);

 24540       var topDictTracker = compiled.trackers[0];

 24542       var stringIndex = this.compileStringIndex(cff.strings.strings);

 24543       output.add(stringIndex);

 24545       var globalSubrIndex = this.compileIndex(cff.globalSubrIndex);

 24546       output.add(globalSubrIndex);

 24548       // Now start on the other entries that have no specfic order.

 24549       if (cff.encoding && cff.topDict.hasName('Encoding')) {

 24550         if (cff.encoding.predefined) {

 24551           topDictTracker.setEntryLocation('Encoding', [cff.encoding.format],

 24552                                           output);

 24553         } else {

 24554           var encoding = this.compileEncoding(cff.encoding);

 24555           topDictTracker.setEntryLocation('Encoding', [output.length], output);

 24556           output.add(encoding);

 24557         }

 24558       }

 24560       if (cff.charset && cff.topDict.hasName('charset')) {

 24561         if (cff.charset.predefined) {

 24562           topDictTracker.setEntryLocation('charset', [cff.charset.format],

 24563                                           output);

 24564         } else {

 24565           var charset = this.compileCharset(cff.charset);

 24566           topDictTracker.setEntryLocation('charset', [output.length], output);

 24567           output.add(charset);

 24568         }

 24569       }

 24571       var charStrings = this.compileCharStrings(cff.charStrings);

 24572       topDictTracker.setEntryLocation('CharStrings', [output.length], output);

 24573       output.add(charStrings);

 24575       if (cff.isCIDFont) {

 24576         // For some reason FDSelect must be in front of FDArray on windows. OSX

 24577         // and linux don't seem to care.

 24578         topDictTracker.setEntryLocation('FDSelect', [output.length], output);

 24579         var fdSelect = this.compileFDSelect(cff.fdSelect.raw);

 24580         output.add(fdSelect);

 24581         // It is unclear if the sub font dictionary can have CID related

 24582         // dictionary keys, but the sanitizer doesn't like them so remove them.

 24583         compiled = this.compileTopDicts(cff.fdArray, output.length, true);

 24584         topDictTracker.setEntryLocation('FDArray', [output.length], output);

 24585         output.add(compiled.output);

 24586         var fontDictTrackers = compiled.trackers;

 24588         this.compilePrivateDicts(cff.fdArray, fontDictTrackers, output);

 24589       }

 24591       this.compilePrivateDicts([cff.topDict], [topDictTracker], output);

 24593       // If the font data ends with INDEX whose object data is zero-length,

 24594       // the sanitizer will bail out. Add a dummy byte to avoid that.

 24595       output.add([0]);

 24597       return output.data;

 24598     },

 24599     encodeNumber: function CFFCompiler_encodeNumber(value) {

 24600       if (parseFloat(value) == parseInt(value, 10) && !isNaN(value)) { // isInt

 24601         return this.encodeInteger(value);

 24602       } else {

 24603         return this.encodeFloat(value);

 24604       }

 24605     },

 24606     encodeFloat: function CFFCompiler_encodeFloat(num) {

 24607       var value = num.toString();

 24609       // rounding inaccurate doubles

 24610       var m = /\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(value);

 24611       if (m) {

 24612         var epsilon = parseFloat('1e' + ((m[2] ? +m[2] : 0) + m[1].length));

 24613         value = (Math.round(num * epsilon) / epsilon).toString();

 24614       }

 24616       var nibbles = '';

 24617       var i, ii;

 24618       for (i = 0, ii = value.length; i < ii; ++i) {

 24619         var a = value[i];

 24620         if (a === 'e') {

 24621           nibbles += value[++i] === '-' ? 'c' : 'b';

 24622         } else if (a === '.') {

 24623           nibbles += 'a';

 24624         } else if (a === '-') {

 24625           nibbles += 'e';

 24626         } else {

 24627           nibbles += a;

 24628         }

 24629       }

 24630       nibbles += (nibbles.length & 1) ? 'f' : 'ff';

 24631       var out = [30];

 24632       for (i = 0, ii = nibbles.length; i < ii; i += 2) {

 24633         out.push(parseInt(nibbles.substr(i, 2), 16));

 24634       }

 24635       return out;

 24636     },

 24637     encodeInteger: function CFFCompiler_encodeInteger(value) {

 24638       var code;

 24639       if (value >= -107 && value <= 107) {

 24640         code = [value + 139];

 24641       } else if (value >= 108 && value <= 1131) {

 24642         value = [value - 108];

 24643         code = [(value >> 8) + 247, value & 0xFF];

 24644       } else if (value >= -1131 && value <= -108) {

 24645         value = -value - 108;

 24646         code = [(value >> 8) + 251, value & 0xFF];

 24647       } else if (value >= -32768 && value <= 32767) {

 24648         code = [0x1c, (value >> 8) & 0xFF, value & 0xFF];

 24649       } else {

 24650         code = [0x1d,

 24651                 (value >> 24) & 0xFF,

 24652                 (value >> 16) & 0xFF,

 24653                 (value >> 8) & 0xFF,

 24654                  value & 0xFF];

 24655       }

 24656       return code;

 24657     },

 24658     compileHeader: function CFFCompiler_compileHeader(header) {

 24659       return [

 24660         header.major,

 24661         header.minor,

 24662         header.hdrSize,

 24663         header.offSize

 24664       ];

 24665     },

 24666     compileNameIndex: function CFFCompiler_compileNameIndex(names) {

 24667       var nameIndex = new CFFIndex();

 24668       for (var i = 0, ii = names.length; i < ii; ++i) {

 24669         nameIndex.add(stringToArray(names[i]));

 24670       }

 24671       return this.compileIndex(nameIndex);

 24672     },

 24673     compileTopDicts: function CFFCompiler_compileTopDicts(dicts,

 24674                                                           length,

 24675                                                           removeCidKeys) {

 24676       var fontDictTrackers = [];

 24677       var fdArrayIndex = new CFFIndex();

 24678       for (var i = 0, ii = dicts.length; i < ii; ++i) {

 24679         var fontDict = dicts[i];

 24680         if (removeCidKeys) {

 24681           fontDict.removeByName('CIDFontVersion');

 24682           fontDict.removeByName('CIDFontRevision');

 24683           fontDict.removeByName('CIDFontType');

 24684           fontDict.removeByName('CIDCount');

 24685           fontDict.removeByName('UIDBase');

 24686         }

 24687         var fontDictTracker = new CFFOffsetTracker();

 24688         var fontDictData = this.compileDict(fontDict, fontDictTracker);

 24689         fontDictTrackers.push(fontDictTracker);

 24690         fdArrayIndex.add(fontDictData);

 24691         fontDictTracker.offset(length);

 24692       }

 24693       fdArrayIndex = this.compileIndex(fdArrayIndex, fontDictTrackers);

 24694       return {

 24695         trackers: fontDictTrackers,

 24696         output: fdArrayIndex

 24697       };

 24698     },

 24699     compilePrivateDicts: function CFFCompiler_compilePrivateDicts(dicts,

 24700                                                                   trackers,

 24701                                                                   output) {

 24702       for (var i = 0, ii = dicts.length; i < ii; ++i) {

 24703         var fontDict = dicts[i];

 24704         assert(fontDict.privateDict && fontDict.hasName('Private'),

 24705                'There must be an private dictionary.');

 24706         var privateDict = fontDict.privateDict;

 24707         var privateDictTracker = new CFFOffsetTracker();

 24708         var privateDictData = this.compileDict(privateDict, privateDictTracker);

 24710         var outputLength = output.length;

 24711         privateDictTracker.offset(outputLength);

 24712         if (!privateDictData.length) {

 24713           // The private dictionary was empty, set the output length to zero to

 24714           // ensure the offset length isn't out of bounds in the eyes of the

 24715           // sanitizer.

 24716           outputLength = 0;

 24717         }

 24719         trackers[i].setEntryLocation('Private',

 24720                                      [privateDictData.length, outputLength],

 24721                                      output);

 24722         output.add(privateDictData);

 24724         if (privateDict.subrsIndex && privateDict.hasName('Subrs')) {

 24725           var subrs = this.compileIndex(privateDict.subrsIndex);

 24726           privateDictTracker.setEntryLocation('Subrs', [privateDictData.length],

 24727                                               output);

 24728           output.add(subrs);

 24729         }

 24730       }

 24731     },

 24732     compileDict: function CFFCompiler_compileDict(dict, offsetTracker) {

 24733       var out = [];

 24734       // The dictionary keys must be in a certain order.

 24735       var order = dict.order;

 24736       for (var i = 0; i < order.length; ++i) {

 24737         var key = order[i];

 24738         if (!(key in dict.values)) {

 24739           continue;

 24740         }

 24741         var values = dict.values[key];

 24742         var types = dict.types[key];

 24743         if (!isArray(types)) {

 24744           types = [types];

 24745         }

 24746         if (!isArray(values)) {

 24747           values = [values];

 24748         }

 24750         // Remove any empty dict values.

 24751         if (values.length === 0) {

 24752           continue;

 24753         }

 24755         for (var j = 0, jj = types.length; j < jj; ++j) {

 24756           var type = types[j];

 24757           var value = values[j];

 24758           switch (type) {

 24759             case 'num':

 24760             case 'sid':

 24761               out = out.concat(this.encodeNumber(value));

 24762               break;

 24763             case 'offset':

 24764               // For offsets we just insert a 32bit integer so we don't have to

 24765               // deal with figuring out the length of the offset when it gets

 24766               // replaced later on by the compiler.

 24767               var name = dict.keyToNameMap[key];

 24768               // Some offsets have the offset and the length, so just record the

 24769               // position of the first one.

 24770               if (!offsetTracker.isTracking(name)) {

 24771                 offsetTracker.track(name, out.length);

 24772               }

 24773               out = out.concat([0x1d, 0, 0, 0, 0]);

 24774               break;

 24775             case 'array':

 24776             case 'delta':

 24777               out = out.concat(this.encodeNumber(value));

 24778               for (var k = 1, kk = values.length; k < kk; ++k) {

 24779                 out = out.concat(this.encodeNumber(values[k]));

 24780               }

 24781               break;

 24782             default:

 24783               error('Unknown data type of ' + type);

 24784               break;

 24785           }

 24786         }

 24787         out = out.concat(dict.opcodes[key]);

 24788       }

 24789       return out;

 24790     },

 24791     compileStringIndex: function CFFCompiler_compileStringIndex(strings) {

 24792       var stringIndex = new CFFIndex();

 24793       for (var i = 0, ii = strings.length; i < ii; ++i) {

 24794         stringIndex.add(stringToArray(strings[i]));

 24795       }

 24796       return this.compileIndex(stringIndex);

 24797     },

 24798     compileGlobalSubrIndex: function CFFCompiler_compileGlobalSubrIndex() {

 24799       var globalSubrIndex = this.cff.globalSubrIndex;

 24800       this.out.writeByteArray(this.compileIndex(globalSubrIndex));

 24801     },

 24802     compileCharStrings: function CFFCompiler_compileCharStrings(charStrings) {

 24803       return this.compileIndex(charStrings);

 24804     },

 24805     compileCharset: function CFFCompiler_compileCharset(charset) {

 24806       return this.compileTypedArray(charset.raw);

 24807     },

 24808     compileEncoding: function CFFCompiler_compileEncoding(encoding) {

 24809       return this.compileTypedArray(encoding.raw);

 24810     },

 24811     compileFDSelect: function CFFCompiler_compileFDSelect(fdSelect) {

 24812       return this.compileTypedArray(fdSelect);

 24813     },

 24814     compileTypedArray: function CFFCompiler_compileTypedArray(data) {

 24815       var out = [];

 24816       for (var i = 0, ii = data.length; i < ii; ++i) {

 24817         out[i] = data[i];

 24818       }

 24819       return out;

 24820     },

 24821     compileIndex: function CFFCompiler_compileIndex(index, trackers) {

 24822       trackers = trackers || [];

 24823       var objects = index.objects;

 24824       // First 2 bytes contains the number of objects contained into this index

 24825       var count = objects.length;

 24827       // If there is no object, just create an index. This technically

 24828       // should just be [0, 0] but OTS has an issue with that.

 24829       if (count === 0) {

 24830         return [0, 0, 0];

 24831       }

 24833       var data = [(count >> 8) & 0xFF, count & 0xff];

 24835       var lastOffset = 1, i;

 24836       for (i = 0; i < count; ++i) {

 24837         lastOffset += objects[i].length;

 24838       }

 24840       var offsetSize;

 24841       if (lastOffset < 0x100) {

 24842         offsetSize = 1;

 24843       } else if (lastOffset < 0x10000) {

 24844         offsetSize = 2;

 24845       } else if (lastOffset < 0x1000000) {

 24846         offsetSize = 3;

 24847       } else {

 24848         offsetSize = 4;

 24849       }

 24851       // Next byte contains the offset size use to reference object in the file

 24852       data.push(offsetSize);

 24854       // Add another offset after this one because we need a new offset

 24855       var relativeOffset = 1;

 24856       for (i = 0; i < count + 1; i++) {

 24857         if (offsetSize === 1) {

 24858           data.push(relativeOffset & 0xFF);

 24859         } else if (offsetSize === 2) {

 24860           data.push((relativeOffset >> 8) & 0xFF,

 24861                      relativeOffset & 0xFF);

 24862         } else if (offsetSize === 3) {

 24863           data.push((relativeOffset >> 16) & 0xFF,

 24864                     (relativeOffset >> 8) & 0xFF,

 24865                      relativeOffset & 0xFF);

 24866         } else {

 24867           data.push((relativeOffset >>> 24) & 0xFF,

 24868                     (relativeOffset >> 16) & 0xFF,

 24869                     (relativeOffset >> 8) & 0xFF,

 24870                      relativeOffset & 0xFF);

 24871         }

 24873         if (objects[i]) {

 24874           relativeOffset += objects[i].length;

 24875         }

 24876       }

 24878       for (i = 0; i < count; i++) {

 24879         // Notify the tracker where the object will be offset in the data.

 24880         if (trackers[i]) {

 24881           trackers[i].offset(data.length);

 24882         }

 24883         for (var j = 0, jj = objects[i].length; j < jj; j++) {

 24884           data.push(objects[i][j]);

 24885         }

 24886       }

 24887       return data;

 24888     }

 24889   };

 24890   return CFFCompiler;

 24891 })();

 24893 // Workaround for seac on Windows.

 24894 (function checkSeacSupport() {

 24895   if (/Windows/.test(navigator.userAgent)) {

 24896     SEAC_ANALYSIS_ENABLED = true;

 24897   }

 24898 })();

 24900 // Workaround for Private Use Area characters in Chrome on Windows

 24901 // http://code.google.com/p/chromium/issues/detail?id=122465

 24902 // https://github.com/mozilla/pdf.js/issues/1689

 24903 (function checkChromeWindows() {

 24904   if (/Windows.*Chrome/.test(navigator.userAgent)) {

 24905     SKIP_PRIVATE_USE_RANGE_F000_TO_F01F = true;

 24906   }

 24907 })();

 24910 var FontRendererFactory = (function FontRendererFactoryClosure() {

 24911   function getLong(data, offset) {

 24912     return (data[offset] << 24) | (data[offset + 1] << 16) |

 24913            (data[offset + 2] << 8) | data[offset + 3];

 24914   }

 24916   function getUshort(data, offset) {

 24917     return (data[offset] << 8) | data[offset + 1];

 24918   }

 24920   function parseCmap(data, start, end) {

 24921     var offset = (getUshort(data, start + 2) === 1 ?

 24922                   getLong(data, start + 8) : getLong(data, start + 16));

 24923     var format = getUshort(data, start + offset);

 24924     var length, ranges, p, i;

 24925     if (format === 4) {

 24926       length = getUshort(data, start + offset + 2);

 24927       var segCount = getUshort(data, start + offset + 6) >> 1;

 24928       p = start + offset + 14;

 24929       ranges = [];

 24930       for (i = 0; i < segCount; i++, p += 2) {

 24931         ranges[i] = {end: getUshort(data, p)};

 24932       }

 24933       p += 2;

 24934       for (i = 0; i < segCount; i++, p += 2) {

 24935         ranges[i].start = getUshort(data, p);

 24936       }

 24937       for (i = 0; i < segCount; i++, p += 2) {

 24938         ranges[i].idDelta = getUshort(data, p);

 24939       }

 24940       for (i = 0; i < segCount; i++, p += 2) {

 24941         var idOffset = getUshort(data, p);

 24942         if (idOffset === 0) {

 24943           continue;

 24944         }

 24945         ranges[i].ids = [];

 24946         for (var j = 0, jj = ranges[i].end - ranges[i].start + 1; j < jj; j++) {

 24947           ranges[i].ids[j] = getUshort(data, p + idOffset);

 24948           idOffset += 2;

 24949         }

 24950       }

 24951       return ranges;

 24952     } else if (format === 12) {

 24953       length = getLong(data, start + offset + 4);

 24954       var groups = getLong(data, start + offset + 12);

 24955       p = start + offset + 16;

 24956       ranges = [];

 24957       for (i = 0; i < groups; i++) {

 24958         ranges.push({

 24959           start: getLong(data, p),

 24960           end: getLong(data, p + 4),

 24961           idDelta: getLong(data, p + 8) - getLong(data, p)

 24962         });

 24963         p += 12;

 24964       }

 24965       return ranges;

 24966     }

 24967     error('not supported cmap: ' + format);

 24968   }

 24970   function parseCff(data, start, end) {

 24971     var properties = {};

 24972     var parser = new CFFParser(new Stream(data, start, end - start),

 24973                                properties);

 24974     var cff = parser.parse();

 24975     return {

 24976       glyphs: cff.charStrings.objects,

 24977       subrs: (cff.topDict.privateDict && cff.topDict.privateDict.subrsIndex &&

 24978               cff.topDict.privateDict.subrsIndex.objects),

 24979       gsubrs: cff.globalSubrIndex && cff.globalSubrIndex.objects

 24980     };

 24981   }

 24983   function parseGlyfTable(glyf, loca, isGlyphLocationsLong) {

 24984     var itemSize, itemDecode;

 24985     if (isGlyphLocationsLong) {

 24986       itemSize = 4;

 24987       itemDecode = function fontItemDecodeLong(data, offset) {

 24988         return (data[offset] << 24) | (data[offset + 1] << 16) |

 24989                (data[offset + 2] << 8) | data[offset + 3];

 24990       };

 24991     } else {

 24992       itemSize = 2;

 24993       itemDecode = function fontItemDecode(data, offset) {

 24994         return (data[offset] << 9) | (data[offset + 1] << 1);

 24995       };

 24996     }

 24997     var glyphs = [];

 24998     var startOffset = itemDecode(loca, 0);

 24999     for (var j = itemSize; j < loca.length; j += itemSize) {

 25000       var endOffset = itemDecode(loca, j);

 25001       glyphs.push(glyf.subarray(startOffset, endOffset));

 25002       startOffset = endOffset;

 25003     }

 25004     return glyphs;

 25005   }

 25007   function lookupCmap(ranges, unicode) {

 25008     var code = unicode.charCodeAt(0);

 25009     var l = 0, r = ranges.length - 1;

 25010     while (l < r) {

 25011       var c = (l + r + 1) >> 1;

 25012       if (code < ranges[c].start) {

 25013         r = c - 1;

 25014       } else {

 25015         l = c;

 25016       }

 25017     }

 25018     if (ranges[l].start <= code && code <= ranges[l].end) {

 25019       return (ranges[l].idDelta + (ranges[l].ids ?

 25020         ranges[l].ids[code - ranges[l].start] : code)) & 0xFFFF;

 25021     }

 25022     return 0;

 25023   }

 25025   function compileGlyf(code, js, font) {

 25026     function moveTo(x, y) {

 25027       js.push('c.moveTo(' + x + ',' + y + ');');

 25028     }

 25029     function lineTo(x, y) {

 25030       js.push('c.lineTo(' + x + ',' + y + ');');

 25031     }

 25032     function quadraticCurveTo(xa, ya, x, y) {

 25033       js.push('c.quadraticCurveTo(' + xa + ',' + ya + ',' +

 25034                                    x + ',' + y + ');');

 25035     }

 25037     var i = 0;

 25038     var numberOfContours = ((code[i] << 24) | (code[i + 1] << 16)) >> 16;

 25039     var flags;

 25040     var x = 0, y = 0;

 25041     i += 10;

 25042     if (numberOfContours < 0) {

 25043       // composite glyph

 25044       do {

 25045         flags = (code[i] << 8) | code[i + 1];

 25046         var glyphIndex = (code[i + 2] << 8) | code[i + 3];

 25047         i += 4;

 25048         var arg1, arg2;

 25049         if ((flags & 0x01)) {

 25050           arg1 = ((code[i] << 24) | (code[i + 1] << 16)) >> 16;

 25051           arg2 = ((code[i + 2] << 24) | (code[i + 3] << 16)) >> 16;

 25052           i += 4;

 25053         } else {

 25054           arg1 = code[i++]; arg2 = code[i++];

 25055         }

 25056         if ((flags & 0x02)) {

 25057            x = arg1;

 25058            y = arg2;

 25059         } else {

 25060            x = 0; y = 0; // TODO "they are points" ?

 25061         }

 25062         var scaleX = 1, scaleY = 1, scale01 = 0, scale10 = 0;

 25063         if ((flags & 0x08)) {

 25064           scaleX =

 25065           scaleY = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;

 25066           i += 2;

 25067         } else if ((flags & 0x40)) {

 25068           scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;

 25069           scaleY = ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824;

 25070           i += 4;

 25071         } else if ((flags & 0x80)) {

 25072           scaleX = ((code[i] << 24) | (code[i + 1] << 16)) / 1073741824;

 25073           scale01 = ((code[i + 2] << 24) | (code[i + 3] << 16)) / 1073741824;

 25074           scale10 = ((code[i + 4] << 24) | (code[i + 5] << 16)) / 1073741824;

 25075           scaleY = ((code[i + 6] << 24) | (code[i + 7] << 16)) / 1073741824;

 25076           i += 8;

 25077         }

 25078         var subglyph = font.glyphs[glyphIndex];

 25079         if (subglyph) {

 25080           js.push('c.save();');

 25081           js.push('c.transform(' + scaleX + ',' + scale01 + ',' +

 25082                   scale10 + ',' + scaleY + ',' + x + ',' + y + ');');

 25083           compileGlyf(subglyph, js, font);

 25084           js.push('c.restore();');

 25085         }

 25086       } while ((flags & 0x20));

 25087     } else {

 25088       // simple glyph

 25089       var endPtsOfContours = [];

 25090       var j, jj;

 25091       for (j = 0; j < numberOfContours; j++) {

 25092         endPtsOfContours.push((code[i] << 8) | code[i + 1]);

 25093         i += 2;

 25094       }

 25095       var instructionLength = (code[i] << 8) | code[i + 1];

 25096       i += 2 + instructionLength; // skipping the instructions

 25097       var numberOfPoints = endPtsOfContours[endPtsOfContours.length - 1] + 1;

 25098       var points = [];

 25099       while (points.length < numberOfPoints) {

 25100         flags = code[i++];

 25101         var repeat = 1;

 25102         if ((flags & 0x08)) {

 25103           repeat += code[i++];

 25104         }

 25105         while (repeat-- > 0) {

 25106           points.push({flags: flags});

 25107         }

 25108       }

 25109       for (j = 0; j < numberOfPoints; j++) {

 25110         switch (points[j].flags & 0x12) {

 25111           case 0x00:

 25112             x += ((code[i] << 24) | (code[i + 1] << 16)) >> 16;

 25113             i += 2;

 25114             break;

 25115           case 0x02:

 25116             x -= code[i++];

 25117             break;

 25118           case 0x12:

 25119             x += code[i++];

 25120             break;

 25121         }

 25122         points[j].x = x;

 25123       }

 25124       for (j = 0; j < numberOfPoints; j++) {

 25125         switch (points[j].flags & 0x24) {

 25126           case 0x00:

 25127             y += ((code[i] << 24) | (code[i + 1] << 16)) >> 16;

 25128             i += 2;

 25129             break;

 25130           case 0x04:

 25131             y -= code[i++];

 25132             break;

 25133           case 0x24:

 25134             y += code[i++];

 25135             break;

 25136         }

 25137         points[j].y = y;

 25138       }

 25140       var startPoint = 0;

 25141       for (i = 0; i < numberOfContours; i++) {

 25142         var endPoint = endPtsOfContours[i];

 25143         // contours might have implicit points, which is located in the middle

 25144         // between two neighboring off-curve points

 25145         var contour = points.slice(startPoint, endPoint + 1);

 25146         if ((contour[0].flags & 1)) {

 25147           contour.push(contour[0]); // using start point at the contour end

 25148         } else if ((contour[contour.length - 1].flags & 1)) {

 25149           // first is off-curve point, trying to use one from the end

 25150           contour.unshift(contour[contour.length - 1]);

 25151         } else {

 25152           // start and end are off-curve points, creating implicit one

 25153           var p = {

 25154             flags: 1,

 25155             x: (contour[0].x + contour[contour.length - 1].x) / 2,

 25156             y: (contour[0].y + contour[contour.length - 1].y) / 2

 25157           };

 25158           contour.unshift(p);

 25159           contour.push(p);

 25160         }

 25161         moveTo(contour[0].x, contour[0].y);

 25162         for (j = 1, jj = contour.length; j < jj; j++) {

 25163           if ((contour[j].flags & 1)) {

 25164             lineTo(contour[j].x, contour[j].y);

 25165           } else if ((contour[j + 1].flags & 1)){

 25166             quadraticCurveTo(contour[j].x, contour[j].y,

 25167                              contour[j + 1].x, contour[j + 1].y);

 25168             j++;

 25169           } else {

 25170             quadraticCurveTo(contour[j].x, contour[j].y,

 25171               (contour[j].x + contour[j + 1].x) / 2,

 25172               (contour[j].y + contour[j + 1].y) / 2);

 25173           }

 25174         }

 25175         startPoint = endPoint + 1;

 25176       }

 25177     }

 25178   }

 25180   function compileCharString(code, js, font) {

 25181     var stack = [];

 25182     var x = 0, y = 0;

 25183     var stems = 0;

 25185     function moveTo(x, y) {

 25186       js.push('c.moveTo(' + x + ',' + y + ');');

 25187     }

 25188     function lineTo(x, y) {

 25189       js.push('c.lineTo(' + x + ',' + y + ');');

 25190     }

 25191     function bezierCurveTo(x1, y1, x2, y2, x, y) {

 25192       js.push('c.bezierCurveTo(' + x1 + ',' + y1 + ',' + x2 + ',' + y2 + ',' +

 25193                                    x + ',' + y + ');');

 25194     }

 25196     function parse(code) {

 25197       var i = 0;

 25198       while (i < code.length) {

 25199         var stackClean = false;

 25200         var v = code[i++];

 25201         var xa, xb, ya, yb, y1, y2, y3, n, subrCode;

 25202         switch (v) {

 25203           case 1: // hstem

 25204             stems += stack.length >> 1;

 25205             stackClean = true;

 25206             break;

 25207           case 3: // vstem

 25208             stems += stack.length >> 1;

 25209             stackClean = true;

 25210             break;

 25211           case 4: // vmoveto

 25212             y += stack.pop();

 25213             moveTo(x, y);

 25214             stackClean = true;

 25215             break;

 25216           case 5: // rlineto

 25217             while (stack.length > 0) {

 25218               x += stack.shift();

 25219               y += stack.shift();

 25220               lineTo(x, y);

 25221             }

 25222             break;

 25223           case 6: // hlineto

 25224             while (stack.length > 0) {

 25225               x += stack.shift();

 25226               lineTo(x, y);

 25227               if (stack.length === 0) {

 25228                 break;

 25229               }

 25230               y += stack.shift();

 25231               lineTo(x, y);

 25232             }

 25233             break;

 25234           case 7: // vlineto

 25235             while (stack.length > 0) {

 25236               y += stack.shift();

 25237               lineTo(x, y);

 25238               if (stack.length === 0) {

 25239                 break;

 25240               }

 25241               x += stack.shift();

 25242               lineTo(x, y);

 25243             }

 25244             break;

 25245           case 8: // rrcurveto

 25246             while (stack.length > 0) {

 25247               xa = x + stack.shift(); ya = y + stack.shift();

 25248               xb = xa + stack.shift(); yb = ya + stack.shift();

 25249               x = xb + stack.shift(); y = yb + stack.shift();

 25250               bezierCurveTo(xa, ya, xb, yb, x, y);

 25251             }

 25252             break;

 25253           case 10: // callsubr

 25254             n = stack.pop() + font.subrsBias;

 25255             subrCode = font.subrs[n];

 25256             if (subrCode) {

 25257               parse(subrCode);

 25258             }

 25259             break;

 25260           case 11: // return

 25261             return;

 25262           case 12:

 25263             v = code[i++];

 25264             switch (v) {

 25265               case 34: // flex

 25266                 xa = x + stack.shift();

 25267                 xb = xa + stack.shift(); y1 = y + stack.shift();

 25268                 x = xb + stack.shift();

 25269                 bezierCurveTo(xa, y, xb, y1, x, y1);

 25270                 xa = x + stack.shift();

 25271                 xb = xa + stack.shift();

 25272                 x = xb + stack.shift();

 25273                 bezierCurveTo(xa, y1, xb, y, x, y);

 25274                 break;

 25275               case 35: // flex

 25276                 xa = x + stack.shift(); ya = y + stack.shift();

 25277                 xb = xa + stack.shift(); yb = ya + stack.shift();

 25278                 x = xb + stack.shift(); y = yb + stack.shift();

 25279                 bezierCurveTo(xa, ya, xb, yb, x, y);

 25280                 xa = x + stack.shift(); ya = y + stack.shift();

 25281                 xb = xa + stack.shift(); yb = ya + stack.shift();

 25282                 x = xb + stack.shift(); y = yb + stack.shift();

 25283                 bezierCurveTo(xa, ya, xb, yb, x, y);

 25284                 stack.pop(); // fd

 25285                 break;

 25286               case 36: // hflex1

 25287                 xa = x + stack.shift(); y1 = y + stack.shift();

 25288                 xb = xa + stack.shift(); y2 = y1 + stack.shift();

 25289                 x = xb + stack.shift();

 25290                 bezierCurveTo(xa, y1, xb, y2, x, y2);

 25291                 xa = x + stack.shift();

 25292                 xb = xa + stack.shift(); y3 = y2 + stack.shift();

 25293                 x = xb + stack.shift();

 25294                 bezierCurveTo(xa, y2, xb, y3, x, y);

 25295                 break;

 25296               case 37: // flex1

 25297                 var x0 = x, y0 = y;

 25298                 xa = x + stack.shift(); ya = y + stack.shift();

 25299                 xb = xa + stack.shift(); yb = ya + stack.shift();

 25300                 x = xb + stack.shift(); y = yb + stack.shift();

 25301                 bezierCurveTo(xa, ya, xb, yb, x, y);

 25302                 xa = x + stack.shift(); ya = y + stack.shift();

 25303                 xb = xa + stack.shift(); yb = ya + stack.shift();

 25304                 x = xb; y = yb;

 25305                 if (Math.abs(x - x0) > Math.abs(y - y0)) {

 25306                   x += stack.shift();

 25307                 } else  {

 25308                   y += stack.shift();

 25309                 }

 25310                 bezierCurveTo(xa, ya, xb, yb, x, y);

 25311                 break;

 25312               default:

 25313                 error('unknown operator: 12 ' + v);

 25314             }

 25315             break;

 25316           case 14: // endchar

 25317             if (stack.length >= 4) {

 25318               var achar = stack.pop();

 25319               var bchar = stack.pop();

 25320               y = stack.pop();

 25321               x = stack.pop();

 25322               js.push('c.save();');

 25323               js.push('c.translate('+ x + ',' + y + ');');

 25324               var gid = lookupCmap(font.cmap, String.fromCharCode(

 25325                 font.glyphNameMap[Encodings.StandardEncoding[achar]]));

 25326               compileCharString(font.glyphs[gid], js, font);

 25327               js.push('c.restore();');

 25329               gid = lookupCmap(font.cmap, String.fromCharCode(

 25330                 font.glyphNameMap[Encodings.StandardEncoding[bchar]]));

 25331               compileCharString(font.glyphs[gid], js, font);

 25332             }

 25333             return;

 25334           case 18: // hstemhm

 25335             stems += stack.length >> 1;

 25336             stackClean = true;

 25337             break;

 25338           case 19: // hintmask

 25339             stems += stack.length >> 1;

 25340             i += (stems + 7) >> 3;

 25341             stackClean = true;

 25342             break;

 25343           case 20: // cntrmask

 25344             stems += stack.length >> 1;

 25345             i += (stems + 7) >> 3;

 25346             stackClean = true;

 25347             break;

 25348           case 21: // rmoveto

 25349             y += stack.pop();

 25350             x += stack.pop();

 25351             moveTo(x, y);

 25352             stackClean = true;

 25353             break;

 25354           case 22: // hmoveto

 25355             x += stack.pop();

 25356             moveTo(x, y);

 25357             stackClean = true;

 25358             break;

 25359           case 23: // vstemhm

 25360             stems += stack.length >> 1;

 25361             stackClean = true;

 25362             break;

 25363           case 24: // rcurveline

 25364             while (stack.length > 2) {

 25365               xa = x + stack.shift(); ya = y + stack.shift();

 25366               xb = xa + stack.shift(); yb = ya + stack.shift();

 25367               x = xb + stack.shift(); y = yb + stack.shift();

 25368               bezierCurveTo(xa, ya, xb, yb, x, y);

 25369             }

 25370             x += stack.shift();

 25371             y += stack.shift();

 25372             lineTo(x, y);

 25373             break;

 25374           case 25: // rlinecurve

 25375             while (stack.length > 6) {

 25376               x += stack.shift();

 25377               y += stack.shift();

 25378               lineTo(x, y);

 25379             }

 25380             xa = x + stack.shift(); ya = y + stack.shift();

 25381             xb = xa + stack.shift(); yb = ya + stack.shift();

 25382             x = xb + stack.shift(); y = yb + stack.shift();

 25383             bezierCurveTo(xa, ya, xb, yb, x, y);

 25384             break;

 25385           case 26: // vvcurveto

 25386             if (stack.length % 2) {

 25387               x += stack.shift();

 25388             }

 25389             while (stack.length > 0) {

 25390               xa = x; ya = y + stack.shift();

 25391               xb = xa + stack.shift(); yb = ya + stack.shift();

 25392               x = xb; y = yb + stack.shift();

 25393               bezierCurveTo(xa, ya, xb, yb, x, y);

 25394             }

 25395             break;

 25396           case 27: // hhcurveto

 25397             if (stack.length % 2) {

 25398               y += stack.shift();

 25399             }

 25400             while (stack.length > 0) {

 25401               xa = x + stack.shift(); ya = y;

 25402               xb = xa + stack.shift(); yb = ya + stack.shift();

 25403               x = xb + stack.shift(); y = yb;

 25404               bezierCurveTo(xa, ya, xb, yb, x, y);

 25405             }

 25406             break;

 25407           case 28:

 25408             stack.push(((code[i] << 24) | (code[i + 1] << 16)) >> 16);

 25409             i += 2;

 25410             break;

 25411           case 29: // callgsubr

 25412             n = stack.pop() + font.gsubrsBias;

 25413             subrCode = font.gsubrs[n];

 25414             if (subrCode) {

 25415               parse(subrCode);

 25416             }

 25417             break;

 25418           case 30: // vhcurveto

 25419             while (stack.length > 0) {

 25420               xa = x; ya = y + stack.shift();

 25421               xb = xa + stack.shift(); yb = ya + stack.shift();

 25422               x = xb + stack.shift();

 25423               y = yb + (stack.length === 1 ? stack.shift() : 0);

 25424               bezierCurveTo(xa, ya, xb, yb, x, y);

 25425               if (stack.length === 0) {

 25426                 break;

 25427               }

 25429               xa = x + stack.shift(); ya = y;

 25430               xb = xa + stack.shift(); yb = ya + stack.shift();

 25431               y = yb + stack.shift();

 25432               x = xb + (stack.length === 1 ? stack.shift() : 0);

 25433               bezierCurveTo(xa, ya, xb, yb, x, y);

 25434             }

 25435             break;

 25436           case 31: // hvcurveto

 25437             while (stack.length > 0) {

 25438               xa = x + stack.shift(); ya = y;

 25439               xb = xa + stack.shift(); yb = ya + stack.shift();

 25440               y = yb + stack.shift();

 25441               x = xb + (stack.length === 1 ? stack.shift() : 0);

 25442               bezierCurveTo(xa, ya, xb, yb, x, y);

 25443               if (stack.length === 0) {

 25444                 break;

 25445               }

 25447               xa = x; ya = y + stack.shift();

 25448               xb = xa + stack.shift(); yb = ya + stack.shift();

 25449               x = xb + stack.shift();

 25450               y = yb + (stack.length === 1 ? stack.shift() : 0);

 25451               bezierCurveTo(xa, ya, xb, yb, x, y);

 25452             }

 25453             break;

 25454           default:

 25455             if (v < 32) {

 25456               error('unknown operator: ' + v);

 25457             }

 25458             if (v < 247) {

 25459               stack.push(v - 139);

 25460             } else if (v < 251) {

 25461               stack.push((v - 247) * 256 + code[i++] + 108);

 25462             } else if (v < 255) {

 25463               stack.push(-(v - 251) * 256 - code[i++] - 108);

 25464             } else {

 25465               stack.push(((code[i] << 24) | (code[i + 1] << 16) |

 25466                          (code[i + 2] << 8) | code[i + 3]) / 65536);

 25467               i += 4;

 25468             }

 25469             break;

 25470         }

 25471         if (stackClean) {

 25472           stack.length = 0;

 25473         }

 25474       }

 25475     }

 25476     parse(code);

 25477   }

 25479   var noop = '';

 25481   function CompiledFont(fontMatrix) {

 25482     this.compiledGlyphs = {};

 25483     this.fontMatrix = fontMatrix;

 25484   }

 25485   CompiledFont.prototype = {

 25486     getPathJs: function (unicode) {

 25487       var gid = lookupCmap(this.cmap, unicode);

 25488       var fn = this.compiledGlyphs[gid];

 25489       if (!fn) {

 25490         this.compiledGlyphs[gid] = fn = this.compileGlyph(this.glyphs[gid]);

 25491       }

 25492       return fn;

 25493     },

 25495     compileGlyph: function (code) {

 25496       if (!code || code.length === 0 || code[0] === 14) {

 25497         return noop;

 25498       }

 25500       var js = [];

 25501       js.push('c.save();');

 25502       js.push('c.transform(' + this.fontMatrix.join(',') + ');');

 25503       js.push('c.scale(size, -size);');

 25505       this.compileGlyphImpl(code, js);

 25507       js.push('c.restore();');

 25509       return js.join('\n');

 25510     },

 25512     compileGlyphImpl: function () {

 25513       error('Children classes should implement this.');

 25514     },

 25516     hasBuiltPath: function (unicode) {

 25517       var gid = lookupCmap(this.cmap, unicode);

 25518       return gid in this.compiledGlyphs;

 25519     }

 25520   };

 25522   function TrueTypeCompiled(glyphs, cmap, fontMatrix) {

 25523     fontMatrix = fontMatrix || [0.000488, 0, 0, 0.000488, 0, 0];

 25524     CompiledFont.call(this, fontMatrix);

 25526     this.glyphs = glyphs;

 25527     this.cmap = cmap;

 25529     this.compiledGlyphs = [];

 25530   }

 25532   Util.inherit(TrueTypeCompiled, CompiledFont, {

 25533     compileGlyphImpl: function (code, js) {

 25534       compileGlyf(code, js, this);

 25535     }

 25536   });

 25538   function Type2Compiled(cffInfo, cmap, fontMatrix, glyphNameMap) {

 25539     fontMatrix = fontMatrix || [0.001, 0, 0, 0.001, 0, 0];

 25540     CompiledFont.call(this, fontMatrix);

 25541     this.glyphs = cffInfo.glyphs;

 25542     this.gsubrs = cffInfo.gsubrs || [];

 25543     this.subrs = cffInfo.subrs || [];

 25544     this.cmap = cmap;

 25545     this.glyphNameMap = glyphNameMap || GlyphsUnicode;

 25547     this.compiledGlyphs = [];

 25548     this.gsubrsBias = (this.gsubrs.length < 1240 ?

 25549                        107 : (this.gsubrs.length < 33900 ? 1131 : 32768));

 25550     this.subrsBias = (this.subrs.length < 1240 ?

 25551                       107 : (this.subrs.length < 33900 ? 1131 : 32768));

 25552   }

 25554   Util.inherit(Type2Compiled, CompiledFont, {

 25555     compileGlyphImpl: function (code, js) {

 25556       compileCharString(code, js, this);

 25557     }

 25558   });

 25561   return {

 25562     create: function FontRendererFactory_create(font) {

 25563       var data = new Uint8Array(font.data);

 25564       var cmap, glyf, loca, cff, indexToLocFormat, unitsPerEm;

 25565       var numTables = getUshort(data, 4);

 25566       for (var i = 0, p = 12; i < numTables; i++, p += 16) {

 25567         var tag = bytesToString(data.subarray(p, p + 4));

 25568         var offset = getLong(data, p + 8);

 25569         var length = getLong(data, p + 12);

 25570         switch (tag) {

 25571           case 'cmap':

 25572             cmap = parseCmap(data, offset, offset + length);

 25573             break;

 25574           case 'glyf':

 25575             glyf = data.subarray(offset, offset + length);

 25576             break;

 25577           case 'loca':

 25578             loca = data.subarray(offset, offset + length);

 25579             break;

 25580           case 'head':

 25581             unitsPerEm = getUshort(data, offset + 18);

 25582             indexToLocFormat = getUshort(data, offset + 50);

 25583             break;

 25584           case 'CFF ':

 25585             cff = parseCff(data, offset, offset + length);

 25586             break;

 25587         }

 25588       }

 25590       if (glyf) {

 25591         var fontMatrix = (!unitsPerEm ? font.fontMatrix :

 25592                           [1 / unitsPerEm, 0, 0, 1 / unitsPerEm, 0, 0]);

 25593         return new TrueTypeCompiled(

 25594           parseGlyfTable(glyf, loca, indexToLocFormat), cmap, fontMatrix);

 25595       } else {

 25596         return new Type2Compiled(cff, cmap, font.fontMatrix, font.glyphNameMap);

 25597       }

 25598     }

 25599   };

 25600 })();

 25604 var GlyphsUnicode = {

 25605   A: 0x0041,

 25606   AE: 0x00C6,

 25607   AEacute: 0x01FC,

 25608   AEmacron: 0x01E2,

 25609   AEsmall: 0xF7E6,

 25610   Aacute: 0x00C1,

 25611   Aacutesmall: 0xF7E1,

 25612   Abreve: 0x0102,

 25613   Abreveacute: 0x1EAE,

 25614   Abrevecyrillic: 0x04D0,

 25615   Abrevedotbelow: 0x1EB6,

 25616   Abrevegrave: 0x1EB0,

 25617   Abrevehookabove: 0x1EB2,

 25618   Abrevetilde: 0x1EB4,

 25619   Acaron: 0x01CD,

 25620   Acircle: 0x24B6,

 25621   Acircumflex: 0x00C2,

 25622   Acircumflexacute: 0x1EA4,

 25623   Acircumflexdotbelow: 0x1EAC,

 25624   Acircumflexgrave: 0x1EA6,

 25625   Acircumflexhookabove: 0x1EA8,

 25626   Acircumflexsmall: 0xF7E2,

 25627   Acircumflextilde: 0x1EAA,

 25628   Acute: 0xF6C9,

 25629   Acutesmall: 0xF7B4,

 25630   Acyrillic: 0x0410,

 25631   Adblgrave: 0x0200,

 25632   Adieresis: 0x00C4,

 25633   Adieresiscyrillic: 0x04D2,

 25634   Adieresismacron: 0x01DE,

 25635   Adieresissmall: 0xF7E4,

 25636   Adotbelow: 0x1EA0,

 25637   Adotmacron: 0x01E0,

 25638   Agrave: 0x00C0,

 25639   Agravesmall: 0xF7E0,

 25640   Ahookabove: 0x1EA2,

 25641   Aiecyrillic: 0x04D4,

 25642   Ainvertedbreve: 0x0202,

 25643   Alpha: 0x0391,

 25644   Alphatonos: 0x0386,

 25645   Amacron: 0x0100,

 25646   Amonospace: 0xFF21,

 25647   Aogonek: 0x0104,

 25648   Aring: 0x00C5,

 25649   Aringacute: 0x01FA,

 25650   Aringbelow: 0x1E00,

 25651   Aringsmall: 0xF7E5,

 25652   Asmall: 0xF761,

 25653   Atilde: 0x00C3,

 25654   Atildesmall: 0xF7E3,

 25655   Aybarmenian: 0x0531,

 25656   B: 0x0042,

 25657   Bcircle: 0x24B7,

 25658   Bdotaccent: 0x1E02,

 25659   Bdotbelow: 0x1E04,

 25660   Becyrillic: 0x0411,

 25661   Benarmenian: 0x0532,

 25662   Beta: 0x0392,

 25663   Bhook: 0x0181,

 25664   Blinebelow: 0x1E06,

 25665   Bmonospace: 0xFF22,

 25666   Brevesmall: 0xF6F4,

 25667   Bsmall: 0xF762,

 25668   Btopbar: 0x0182,

 25669   C: 0x0043,

 25670   Caarmenian: 0x053E,

 25671   Cacute: 0x0106,

 25672   Caron: 0xF6CA,

 25673   Caronsmall: 0xF6F5,

 25674   Ccaron: 0x010C,

 25675   Ccedilla: 0x00C7,

 25676   Ccedillaacute: 0x1E08,

 25677   Ccedillasmall: 0xF7E7,

 25678   Ccircle: 0x24B8,

 25679   Ccircumflex: 0x0108,

 25680   Cdot: 0x010A,

 25681   Cdotaccent: 0x010A,

 25682   Cedillasmall: 0xF7B8,

 25683   Chaarmenian: 0x0549,

 25684   Cheabkhasiancyrillic: 0x04BC,

 25685   Checyrillic: 0x0427,

 25686   Chedescenderabkhasiancyrillic: 0x04BE,

 25687   Chedescendercyrillic: 0x04B6,

 25688   Chedieresiscyrillic: 0x04F4,

 25689   Cheharmenian: 0x0543,

 25690   Chekhakassiancyrillic: 0x04CB,

 25691   Cheverticalstrokecyrillic: 0x04B8,

 25692   Chi: 0x03A7,

 25693   Chook: 0x0187,

 25694   Circumflexsmall: 0xF6F6,

 25695   Cmonospace: 0xFF23,

 25696   Coarmenian: 0x0551,

 25697   Csmall: 0xF763,

 25698   D: 0x0044,

 25699   DZ: 0x01F1,

 25700   DZcaron: 0x01C4,

 25701   Daarmenian: 0x0534,

 25702   Dafrican: 0x0189,

 25703   Dcaron: 0x010E,

 25704   Dcedilla: 0x1E10,

 25705   Dcircle: 0x24B9,

 25706   Dcircumflexbelow: 0x1E12,

 25707   Dcroat: 0x0110,

 25708   Ddotaccent: 0x1E0A,

 25709   Ddotbelow: 0x1E0C,

 25710   Decyrillic: 0x0414,

 25711   Deicoptic: 0x03EE,

 25712   Delta: 0x2206,

 25713   Deltagreek: 0x0394,

 25714   Dhook: 0x018A,

 25715   Dieresis: 0xF6CB,

 25716   DieresisAcute: 0xF6CC,

 25717   DieresisGrave: 0xF6CD,

 25718   Dieresissmall: 0xF7A8,

 25719   Digammagreek: 0x03DC,

 25720   Djecyrillic: 0x0402,

 25721   Dlinebelow: 0x1E0E,

 25722   Dmonospace: 0xFF24,

 25723   Dotaccentsmall: 0xF6F7,

 25724   Dslash: 0x0110,

 25725   Dsmall: 0xF764,

 25726   Dtopbar: 0x018B,

 25727   Dz: 0x01F2,

 25728   Dzcaron: 0x01C5,

 25729   Dzeabkhasiancyrillic: 0x04E0,

 25730   Dzecyrillic: 0x0405,

 25731   Dzhecyrillic: 0x040F,

 25732   E: 0x0045,

 25733   Eacute: 0x00C9,

 25734   Eacutesmall: 0xF7E9,

 25735   Ebreve: 0x0114,

 25736   Ecaron: 0x011A,

 25737   Ecedillabreve: 0x1E1C,

 25738   Echarmenian: 0x0535,

 25739   Ecircle: 0x24BA,

 25740   Ecircumflex: 0x00CA,

 25741   Ecircumflexacute: 0x1EBE,

 25742   Ecircumflexbelow: 0x1E18,

 25743   Ecircumflexdotbelow: 0x1EC6,

 25744   Ecircumflexgrave: 0x1EC0,

 25745   Ecircumflexhookabove: 0x1EC2,

 25746   Ecircumflexsmall: 0xF7EA,

 25747   Ecircumflextilde: 0x1EC4,

 25748   Ecyrillic: 0x0404,

 25749   Edblgrave: 0x0204,

 25750   Edieresis: 0x00CB,

 25751   Edieresissmall: 0xF7EB,

 25752   Edot: 0x0116,

 25753   Edotaccent: 0x0116,

 25754   Edotbelow: 0x1EB8,

 25755   Efcyrillic: 0x0424,

 25756   Egrave: 0x00C8,

 25757   Egravesmall: 0xF7E8,

 25758   Eharmenian: 0x0537,

 25759   Ehookabove: 0x1EBA,

 25760   Eightroman: 0x2167,

 25761   Einvertedbreve: 0x0206,

 25762   Eiotifiedcyrillic: 0x0464,

 25763   Elcyrillic: 0x041B,

 25764   Elevenroman: 0x216A,

 25765   Emacron: 0x0112,

 25766   Emacronacute: 0x1E16,

 25767   Emacrongrave: 0x1E14,

 25768   Emcyrillic: 0x041C,

 25769   Emonospace: 0xFF25,

 25770   Encyrillic: 0x041D,

 25771   Endescendercyrillic: 0x04A2,

 25772   Eng: 0x014A,

 25773   Enghecyrillic: 0x04A4,

 25774   Enhookcyrillic: 0x04C7,

 25775   Eogonek: 0x0118,

 25776   Eopen: 0x0190,

 25777   Epsilon: 0x0395,

 25778   Epsilontonos: 0x0388,

 25779   Ercyrillic: 0x0420,

 25780   Ereversed: 0x018E,

 25781   Ereversedcyrillic: 0x042D,

 25782   Escyrillic: 0x0421,

 25783   Esdescendercyrillic: 0x04AA,

 25784   Esh: 0x01A9,

 25785   Esmall: 0xF765,

 25786   Eta: 0x0397,

 25787   Etarmenian: 0x0538,

 25788   Etatonos: 0x0389,

 25789   Eth: 0x00D0,

 25790   Ethsmall: 0xF7F0,

 25791   Etilde: 0x1EBC,

 25792   Etildebelow: 0x1E1A,

 25793   Euro: 0x20AC,

 25794   Ezh: 0x01B7,

 25795   Ezhcaron: 0x01EE,

 25796   Ezhreversed: 0x01B8,

 25797   F: 0x0046,

 25798   Fcircle: 0x24BB,

 25799   Fdotaccent: 0x1E1E,

 25800   Feharmenian: 0x0556,

 25801   Feicoptic: 0x03E4,

 25802   Fhook: 0x0191,

 25803   Fitacyrillic: 0x0472,

 25804   Fiveroman: 0x2164,

 25805   Fmonospace: 0xFF26,

 25806   Fourroman: 0x2163,

 25807   Fsmall: 0xF766,

 25808   G: 0x0047,

 25809   GBsquare: 0x3387,

 25810   Gacute: 0x01F4,

 25811   Gamma: 0x0393,

 25812   Gammaafrican: 0x0194,

 25813   Gangiacoptic: 0x03EA,

 25814   Gbreve: 0x011E,

 25815   Gcaron: 0x01E6,

 25816   Gcedilla: 0x0122,

 25817   Gcircle: 0x24BC,

 25818   Gcircumflex: 0x011C,

 25819   Gcommaaccent: 0x0122,

 25820   Gdot: 0x0120,

 25821   Gdotaccent: 0x0120,

 25822   Gecyrillic: 0x0413,

 25823   Ghadarmenian: 0x0542,

 25824   Ghemiddlehookcyrillic: 0x0494,

 25825   Ghestrokecyrillic: 0x0492,

 25826   Gheupturncyrillic: 0x0490,

 25827   Ghook: 0x0193,

 25828   Gimarmenian: 0x0533,

 25829   Gjecyrillic: 0x0403,

 25830   Gmacron: 0x1E20,

 25831   Gmonospace: 0xFF27,

 25832   Grave: 0xF6CE,

 25833   Gravesmall: 0xF760,

 25834   Gsmall: 0xF767,

 25835   Gsmallhook: 0x029B,

 25836   Gstroke: 0x01E4,

 25837   H: 0x0048,

 25838   H18533: 0x25CF,

 25839   H18543: 0x25AA,

 25840   H18551: 0x25AB,

 25841   H22073: 0x25A1,

 25842   HPsquare: 0x33CB,

 25843   Haabkhasiancyrillic: 0x04A8,

 25844   Hadescendercyrillic: 0x04B2,

 25845   Hardsigncyrillic: 0x042A,

 25846   Hbar: 0x0126,

 25847   Hbrevebelow: 0x1E2A,

 25848   Hcedilla: 0x1E28,

 25849   Hcircle: 0x24BD,

 25850   Hcircumflex: 0x0124,

 25851   Hdieresis: 0x1E26,

 25852   Hdotaccent: 0x1E22,

 25853   Hdotbelow: 0x1E24,

 25854   Hmonospace: 0xFF28,

 25855   Hoarmenian: 0x0540,

 25856   Horicoptic: 0x03E8,

 25857   Hsmall: 0xF768,

 25858   Hungarumlaut: 0xF6CF,

 25859   Hungarumlautsmall: 0xF6F8,

 25860   Hzsquare: 0x3390,

 25861   I: 0x0049,

 25862   IAcyrillic: 0x042F,

 25863   IJ: 0x0132,

 25864   IUcyrillic: 0x042E,

 25865   Iacute: 0x00CD,

 25866   Iacutesmall: 0xF7ED,

 25867   Ibreve: 0x012C,

 25868   Icaron: 0x01CF,

 25869   Icircle: 0x24BE,

 25870   Icircumflex: 0x00CE,

 25871   Icircumflexsmall: 0xF7EE,

 25872   Icyrillic: 0x0406,

 25873   Idblgrave: 0x0208,

 25874   Idieresis: 0x00CF,

 25875   Idieresisacute: 0x1E2E,

 25876   Idieresiscyrillic: 0x04E4,

 25877   Idieresissmall: 0xF7EF,

 25878   Idot: 0x0130,

 25879   Idotaccent: 0x0130,

 25880   Idotbelow: 0x1ECA,

 25881   Iebrevecyrillic: 0x04D6,

 25882   Iecyrillic: 0x0415,

 25883   Ifraktur: 0x2111,

 25884   Igrave: 0x00CC,

 25885   Igravesmall: 0xF7EC,

 25886   Ihookabove: 0x1EC8,

 25887   Iicyrillic: 0x0418,

 25888   Iinvertedbreve: 0x020A,

 25889   Iishortcyrillic: 0x0419,

 25890   Imacron: 0x012A,

 25891   Imacroncyrillic: 0x04E2,

 25892   Imonospace: 0xFF29,

 25893   Iniarmenian: 0x053B,

 25894   Iocyrillic: 0x0401,

 25895   Iogonek: 0x012E,

 25896   Iota: 0x0399,

 25897   Iotaafrican: 0x0196,

 25898   Iotadieresis: 0x03AA,

 25899   Iotatonos: 0x038A,

 25900   Ismall: 0xF769,

 25901   Istroke: 0x0197,

 25902   Itilde: 0x0128,

 25903   Itildebelow: 0x1E2C,

 25904   Izhitsacyrillic: 0x0474,

 25905   Izhitsadblgravecyrillic: 0x0476,

 25906   J: 0x004A,

 25907   Jaarmenian: 0x0541,

 25908   Jcircle: 0x24BF,

 25909   Jcircumflex: 0x0134,

 25910   Jecyrillic: 0x0408,

 25911   Jheharmenian: 0x054B,

 25912   Jmonospace: 0xFF2A,

 25913   Jsmall: 0xF76A,

 25914   K: 0x004B,

 25915   KBsquare: 0x3385,

 25916   KKsquare: 0x33CD,

 25917   Kabashkircyrillic: 0x04A0,

 25918   Kacute: 0x1E30,

 25919   Kacyrillic: 0x041A,

 25920   Kadescendercyrillic: 0x049A,

 25921   Kahookcyrillic: 0x04C3,

 25922   Kappa: 0x039A,

 25923   Kastrokecyrillic: 0x049E,

 25924   Kaverticalstrokecyrillic: 0x049C,

 25925   Kcaron: 0x01E8,

 25926   Kcedilla: 0x0136,

 25927   Kcircle: 0x24C0,

 25928   Kcommaaccent: 0x0136,

 25929   Kdotbelow: 0x1E32,

 25930   Keharmenian: 0x0554,

 25931   Kenarmenian: 0x053F,

 25932   Khacyrillic: 0x0425,

 25933   Kheicoptic: 0x03E6,

 25934   Khook: 0x0198,

 25935   Kjecyrillic: 0x040C,

 25936   Klinebelow: 0x1E34,

 25937   Kmonospace: 0xFF2B,

 25938   Koppacyrillic: 0x0480,

 25939   Koppagreek: 0x03DE,

 25940   Ksicyrillic: 0x046E,

 25941   Ksmall: 0xF76B,

 25942   L: 0x004C,

 25943   LJ: 0x01C7,

 25944   LL: 0xF6BF,

 25945   Lacute: 0x0139,

 25946   Lambda: 0x039B,

 25947   Lcaron: 0x013D,

 25948   Lcedilla: 0x013B,

 25949   Lcircle: 0x24C1,

 25950   Lcircumflexbelow: 0x1E3C,

 25951   Lcommaaccent: 0x013B,

 25952   Ldot: 0x013F,

 25953   Ldotaccent: 0x013F,

 25954   Ldotbelow: 0x1E36,

 25955   Ldotbelowmacron: 0x1E38,

 25956   Liwnarmenian: 0x053C,

 25957   Lj: 0x01C8,

 25958   Ljecyrillic: 0x0409,

 25959   Llinebelow: 0x1E3A,

 25960   Lmonospace: 0xFF2C,

 25961   Lslash: 0x0141,

 25962   Lslashsmall: 0xF6F9,

 25963   Lsmall: 0xF76C,

 25964   M: 0x004D,

 25965   MBsquare: 0x3386,

 25966   Macron: 0xF6D0,

 25967   Macronsmall: 0xF7AF,

 25968   Macute: 0x1E3E,

 25969   Mcircle: 0x24C2,

 25970   Mdotaccent: 0x1E40,

 25971   Mdotbelow: 0x1E42,

 25972   Menarmenian: 0x0544,

 25973   Mmonospace: 0xFF2D,

 25974   Msmall: 0xF76D,

 25975   Mturned: 0x019C,

 25976   Mu: 0x039C,

 25977   N: 0x004E,

 25978   NJ: 0x01CA,

 25979   Nacute: 0x0143,

 25980   Ncaron: 0x0147,

 25981   Ncedilla: 0x0145,

 25982   Ncircle: 0x24C3,

 25983   Ncircumflexbelow: 0x1E4A,

 25984   Ncommaaccent: 0x0145,

 25985   Ndotaccent: 0x1E44,

 25986   Ndotbelow: 0x1E46,

 25987   Nhookleft: 0x019D,

 25988   Nineroman: 0x2168,

 25989   Nj: 0x01CB,

 25990   Njecyrillic: 0x040A,

 25991   Nlinebelow: 0x1E48,

 25992   Nmonospace: 0xFF2E,

 25993   Nowarmenian: 0x0546,

 25994   Nsmall: 0xF76E,

 25995   Ntilde: 0x00D1,

 25996   Ntildesmall: 0xF7F1,

 25997   Nu: 0x039D,

 25998   O: 0x004F,

 25999   OE: 0x0152,

 26000   OEsmall: 0xF6FA,

 26001   Oacute: 0x00D3,

 26002   Oacutesmall: 0xF7F3,

 26003   Obarredcyrillic: 0x04E8,

 26004   Obarreddieresiscyrillic: 0x04EA,

 26005   Obreve: 0x014E,

 26006   Ocaron: 0x01D1,

 26007   Ocenteredtilde: 0x019F,

 26008   Ocircle: 0x24C4,

 26009   Ocircumflex: 0x00D4,

 26010   Ocircumflexacute: 0x1ED0,

 26011   Ocircumflexdotbelow: 0x1ED8,

 26012   Ocircumflexgrave: 0x1ED2,

 26013   Ocircumflexhookabove: 0x1ED4,

 26014   Ocircumflexsmall: 0xF7F4,

 26015   Ocircumflextilde: 0x1ED6,

 26016   Ocyrillic: 0x041E,

 26017   Odblacute: 0x0150,

 26018   Odblgrave: 0x020C,

 26019   Odieresis: 0x00D6,

 26020   Odieresiscyrillic: 0x04E6,

 26021   Odieresissmall: 0xF7F6,

 26022   Odotbelow: 0x1ECC,

 26023   Ogoneksmall: 0xF6FB,

 26024   Ograve: 0x00D2,

 26025   Ogravesmall: 0xF7F2,

 26026   Oharmenian: 0x0555,

 26027   Ohm: 0x2126,

 26028   Ohookabove: 0x1ECE,

 26029   Ohorn: 0x01A0,

 26030   Ohornacute: 0x1EDA,

 26031   Ohorndotbelow: 0x1EE2,

 26032   Ohorngrave: 0x1EDC,

 26033   Ohornhookabove: 0x1EDE,

 26034   Ohorntilde: 0x1EE0,

 26035   Ohungarumlaut: 0x0150,

 26036   Oi: 0x01A2,

 26037   Oinvertedbreve: 0x020E,

 26038   Omacron: 0x014C,

 26039   Omacronacute: 0x1E52,

 26040   Omacrongrave: 0x1E50,

 26041   Omega: 0x2126,

 26042   Omegacyrillic: 0x0460,

 26043   Omegagreek: 0x03A9,

 26044   Omegaroundcyrillic: 0x047A,

 26045   Omegatitlocyrillic: 0x047C,

 26046   Omegatonos: 0x038F,

 26047   Omicron: 0x039F,

 26048   Omicrontonos: 0x038C,

 26049   Omonospace: 0xFF2F,

 26050   Oneroman: 0x2160,

 26051   Oogonek: 0x01EA,

 26052   Oogonekmacron: 0x01EC,

 26053   Oopen: 0x0186,

 26054   Oslash: 0x00D8,

 26055   Oslashacute: 0x01FE,

 26056   Oslashsmall: 0xF7F8,

 26057   Osmall: 0xF76F,

 26058   Ostrokeacute: 0x01FE,

 26059   Otcyrillic: 0x047E,

 26060   Otilde: 0x00D5,

 26061   Otildeacute: 0x1E4C,

 26062   Otildedieresis: 0x1E4E,

 26063   Otildesmall: 0xF7F5,

 26064   P: 0x0050,

 26065   Pacute: 0x1E54,

 26066   Pcircle: 0x24C5,

 26067   Pdotaccent: 0x1E56,

 26068   Pecyrillic: 0x041F,

 26069   Peharmenian: 0x054A,

 26070   Pemiddlehookcyrillic: 0x04A6,

 26071   Phi: 0x03A6,

 26072   Phook: 0x01A4,

 26073   Pi: 0x03A0,

 26074   Piwrarmenian: 0x0553,

 26075   Pmonospace: 0xFF30,

 26076   Psi: 0x03A8,

 26077   Psicyrillic: 0x0470,

 26078   Psmall: 0xF770,

 26079   Q: 0x0051,

 26080   Qcircle: 0x24C6,

 26081   Qmonospace: 0xFF31,

 26082   Qsmall: 0xF771,

 26083   R: 0x0052,

 26084   Raarmenian: 0x054C,

 26085   Racute: 0x0154,

 26086   Rcaron: 0x0158,

 26087   Rcedilla: 0x0156,

 26088   Rcircle: 0x24C7,

 26089   Rcommaaccent: 0x0156,

 26090   Rdblgrave: 0x0210,

 26091   Rdotaccent: 0x1E58,

 26092   Rdotbelow: 0x1E5A,

 26093   Rdotbelowmacron: 0x1E5C,

 26094   Reharmenian: 0x0550,

 26095   Rfraktur: 0x211C,

 26096   Rho: 0x03A1,

 26097   Ringsmall: 0xF6FC,

 26098   Rinvertedbreve: 0x0212,

 26099   Rlinebelow: 0x1E5E,

 26100   Rmonospace: 0xFF32,

 26101   Rsmall: 0xF772,

 26102   Rsmallinverted: 0x0281,

 26103   Rsmallinvertedsuperior: 0x02B6,

 26104   S: 0x0053,

 26105   SF010000: 0x250C,

 26106   SF020000: 0x2514,

 26107   SF030000: 0x2510,

 26108   SF040000: 0x2518,

 26109   SF050000: 0x253C,

 26110   SF060000: 0x252C,

 26111   SF070000: 0x2534,

 26112   SF080000: 0x251C,

 26113   SF090000: 0x2524,

 26114   SF100000: 0x2500,

 26115   SF110000: 0x2502,

 26116   SF190000: 0x2561,

 26117   SF200000: 0x2562,

 26118   SF210000: 0x2556,

 26119   SF220000: 0x2555,

 26120   SF230000: 0x2563,

 26121   SF240000: 0x2551,

 26122   SF250000: 0x2557,

 26123   SF260000: 0x255D,

 26124   SF270000: 0x255C,

 26125   SF280000: 0x255B,

 26126   SF360000: 0x255E,

 26127   SF370000: 0x255F,

 26128   SF380000: 0x255A,

 26129   SF390000: 0x2554,

 26130   SF400000: 0x2569,

 26131   SF410000: 0x2566,

 26132   SF420000: 0x2560,

 26133   SF430000: 0x2550,

 26134   SF440000: 0x256C,

 26135   SF450000: 0x2567,

 26136   SF460000: 0x2568,

 26137   SF470000: 0x2564,

 26138   SF480000: 0x2565,

 26139   SF490000: 0x2559,

 26140   SF500000: 0x2558,

 26141   SF510000: 0x2552,

 26142   SF520000: 0x2553,

 26143   SF530000: 0x256B,

 26144   SF540000: 0x256A,

 26145   Sacute: 0x015A,

 26146   Sacutedotaccent: 0x1E64,

 26147   Sampigreek: 0x03E0,

 26148   Scaron: 0x0160,

 26149   Scarondotaccent: 0x1E66,

 26150   Scaronsmall: 0xF6FD,

 26151   Scedilla: 0x015E,

 26152   Schwa: 0x018F,

 26153   Schwacyrillic: 0x04D8,

 26154   Schwadieresiscyrillic: 0x04DA,

 26155   Scircle: 0x24C8,

 26156   Scircumflex: 0x015C,

 26157   Scommaaccent: 0x0218,

 26158   Sdotaccent: 0x1E60,

 26159   Sdotbelow: 0x1E62,

 26160   Sdotbelowdotaccent: 0x1E68,

 26161   Seharmenian: 0x054D,

 26162   Sevenroman: 0x2166,

 26163   Shaarmenian: 0x0547,

 26164   Shacyrillic: 0x0428,

 26165   Shchacyrillic: 0x0429,

 26166   Sheicoptic: 0x03E2,

 26167   Shhacyrillic: 0x04BA,

 26168   Shimacoptic: 0x03EC,

 26169   Sigma: 0x03A3,

 26170   Sixroman: 0x2165,

 26171   Smonospace: 0xFF33,

 26172   Softsigncyrillic: 0x042C,

 26173   Ssmall: 0xF773,

 26174   Stigmagreek: 0x03DA,

 26175   T: 0x0054,

 26176   Tau: 0x03A4,

 26177   Tbar: 0x0166,

 26178   Tcaron: 0x0164,

 26179   Tcedilla: 0x0162,

 26180   Tcircle: 0x24C9,

 26181   Tcircumflexbelow: 0x1E70,

 26182   Tcommaaccent: 0x0162,

 26183   Tdotaccent: 0x1E6A,

 26184   Tdotbelow: 0x1E6C,

 26185   Tecyrillic: 0x0422,

 26186   Tedescendercyrillic: 0x04AC,

 26187   Tenroman: 0x2169,

 26188   Tetsecyrillic: 0x04B4,

 26189   Theta: 0x0398,

 26190   Thook: 0x01AC,

 26191   Thorn: 0x00DE,

 26192   Thornsmall: 0xF7FE,

 26193   Threeroman: 0x2162,

 26194   Tildesmall: 0xF6FE,

 26195   Tiwnarmenian: 0x054F,

 26196   Tlinebelow: 0x1E6E,

 26197   Tmonospace: 0xFF34,

 26198   Toarmenian: 0x0539,

 26199   Tonefive: 0x01BC,

 26200   Tonesix: 0x0184,

 26201   Tonetwo: 0x01A7,

 26202   Tretroflexhook: 0x01AE,

 26203   Tsecyrillic: 0x0426,

 26204   Tshecyrillic: 0x040B,

 26205   Tsmall: 0xF774,

 26206   Twelveroman: 0x216B,

 26207   Tworoman: 0x2161,

 26208   U: 0x0055,

 26209   Uacute: 0x00DA,

 26210   Uacutesmall: 0xF7FA,

 26211   Ubreve: 0x016C,

 26212   Ucaron: 0x01D3,

 26213   Ucircle: 0x24CA,

 26214   Ucircumflex: 0x00DB,

 26215   Ucircumflexbelow: 0x1E76,

 26216   Ucircumflexsmall: 0xF7FB,

 26217   Ucyrillic: 0x0423,

 26218   Udblacute: 0x0170,

 26219   Udblgrave: 0x0214,

 26220   Udieresis: 0x00DC,

 26221   Udieresisacute: 0x01D7,

 26222   Udieresisbelow: 0x1E72,

 26223   Udieresiscaron: 0x01D9,

 26224   Udieresiscyrillic: 0x04F0,

 26225   Udieresisgrave: 0x01DB,

 26226   Udieresismacron: 0x01D5,

 26227   Udieresissmall: 0xF7FC,

 26228   Udotbelow: 0x1EE4,

 26229   Ugrave: 0x00D9,

 26230   Ugravesmall: 0xF7F9,

 26231   Uhookabove: 0x1EE6,

 26232   Uhorn: 0x01AF,

 26233   Uhornacute: 0x1EE8,

 26234   Uhorndotbelow: 0x1EF0,

 26235   Uhorngrave: 0x1EEA,

 26236   Uhornhookabove: 0x1EEC,

 26237   Uhorntilde: 0x1EEE,

 26238   Uhungarumlaut: 0x0170,

 26239   Uhungarumlautcyrillic: 0x04F2,

 26240   Uinvertedbreve: 0x0216,

 26241   Ukcyrillic: 0x0478,

 26242   Umacron: 0x016A,

 26243   Umacroncyrillic: 0x04EE,

 26244   Umacrondieresis: 0x1E7A,

 26245   Umonospace: 0xFF35,

 26246   Uogonek: 0x0172,

 26247   Upsilon: 0x03A5,

 26248   Upsilon1: 0x03D2,

 26249   Upsilonacutehooksymbolgreek: 0x03D3,

 26250   Upsilonafrican: 0x01B1,

 26251   Upsilondieresis: 0x03AB,

 26252   Upsilondieresishooksymbolgreek: 0x03D4,

 26253   Upsilonhooksymbol: 0x03D2,

 26254   Upsilontonos: 0x038E,

 26255   Uring: 0x016E,

 26256   Ushortcyrillic: 0x040E,

 26257   Usmall: 0xF775,

 26258   Ustraightcyrillic: 0x04AE,

 26259   Ustraightstrokecyrillic: 0x04B0,

 26260   Utilde: 0x0168,

 26261   Utildeacute: 0x1E78,

 26262   Utildebelow: 0x1E74,

 26263   V: 0x0056,

 26264   Vcircle: 0x24CB,

 26265   Vdotbelow: 0x1E7E,

 26266   Vecyrillic: 0x0412,

 26267   Vewarmenian: 0x054E,

 26268   Vhook: 0x01B2,

 26269   Vmonospace: 0xFF36,

 26270   Voarmenian: 0x0548,

 26271   Vsmall: 0xF776,

 26272   Vtilde: 0x1E7C,

 26273   W: 0x0057,

 26274   Wacute: 0x1E82,

 26275   Wcircle: 0x24CC,

 26276   Wcircumflex: 0x0174,

 26277   Wdieresis: 0x1E84,

 26278   Wdotaccent: 0x1E86,

 26279   Wdotbelow: 0x1E88,

 26280   Wgrave: 0x1E80,

 26281   Wmonospace: 0xFF37,

 26282   Wsmall: 0xF777,

 26283   X: 0x0058,

 26284   Xcircle: 0x24CD,

 26285   Xdieresis: 0x1E8C,

 26286   Xdotaccent: 0x1E8A,

 26287   Xeharmenian: 0x053D,

 26288   Xi: 0x039E,

 26289   Xmonospace: 0xFF38,

 26290   Xsmall: 0xF778,

 26291   Y: 0x0059,

 26292   Yacute: 0x00DD,

 26293   Yacutesmall: 0xF7FD,

 26294   Yatcyrillic: 0x0462,

 26295   Ycircle: 0x24CE,

 26296   Ycircumflex: 0x0176,

 26297   Ydieresis: 0x0178,

 26298   Ydieresissmall: 0xF7FF,

 26299   Ydotaccent: 0x1E8E,

 26300   Ydotbelow: 0x1EF4,

 26301   Yericyrillic: 0x042B,

 26302   Yerudieresiscyrillic: 0x04F8,

 26303   Ygrave: 0x1EF2,

 26304   Yhook: 0x01B3,

 26305   Yhookabove: 0x1EF6,

 26306   Yiarmenian: 0x0545,

 26307   Yicyrillic: 0x0407,

 26308   Yiwnarmenian: 0x0552,

 26309   Ymonospace: 0xFF39,

 26310   Ysmall: 0xF779,

 26311   Ytilde: 0x1EF8,

 26312   Yusbigcyrillic: 0x046A,

 26313   Yusbigiotifiedcyrillic: 0x046C,

 26314   Yuslittlecyrillic: 0x0466,

 26315   Yuslittleiotifiedcyrillic: 0x0468,

 26316   Z: 0x005A,

 26317   Zaarmenian: 0x0536,

 26318   Zacute: 0x0179,

 26319   Zcaron: 0x017D,

 26320   Zcaronsmall: 0xF6FF,

 26321   Zcircle: 0x24CF,

 26322   Zcircumflex: 0x1E90,

 26323   Zdot: 0x017B,

 26324   Zdotaccent: 0x017B,

 26325   Zdotbelow: 0x1E92,

 26326   Zecyrillic: 0x0417,

 26327   Zedescendercyrillic: 0x0498,

 26328   Zedieresiscyrillic: 0x04DE,

 26329   Zeta: 0x0396,

 26330   Zhearmenian: 0x053A,

 26331   Zhebrevecyrillic: 0x04C1,

 26332   Zhecyrillic: 0x0416,

 26333   Zhedescendercyrillic: 0x0496,

 26334   Zhedieresiscyrillic: 0x04DC,

 26335   Zlinebelow: 0x1E94,

 26336   Zmonospace: 0xFF3A,

 26337   Zsmall: 0xF77A,

 26338   Zstroke: 0x01B5,

 26339   a: 0x0061,

 26340   aabengali: 0x0986,

 26341   aacute: 0x00E1,

 26342   aadeva: 0x0906,

 26343   aagujarati: 0x0A86,

 26344   aagurmukhi: 0x0A06,

 26345   aamatragurmukhi: 0x0A3E,

 26346   aarusquare: 0x3303,

 26347   aavowelsignbengali: 0x09BE,

 26348   aavowelsigndeva: 0x093E,

 26349   aavowelsigngujarati: 0x0ABE,

 26350   abbreviationmarkarmenian: 0x055F,

 26351   abbreviationsigndeva: 0x0970,

 26352   abengali: 0x0985,

 26353   abopomofo: 0x311A,

 26354   abreve: 0x0103,

 26355   abreveacute: 0x1EAF,

 26356   abrevecyrillic: 0x04D1,

 26357   abrevedotbelow: 0x1EB7,

 26358   abrevegrave: 0x1EB1,

 26359   abrevehookabove: 0x1EB3,

 26360   abrevetilde: 0x1EB5,

 26361   acaron: 0x01CE,

 26362   acircle: 0x24D0,

 26363   acircumflex: 0x00E2,

 26364   acircumflexacute: 0x1EA5,

 26365   acircumflexdotbelow: 0x1EAD,

 26366   acircumflexgrave: 0x1EA7,

 26367   acircumflexhookabove: 0x1EA9,

 26368   acircumflextilde: 0x1EAB,

 26369   acute: 0x00B4,

 26370   acutebelowcmb: 0x0317,

 26371   acutecmb: 0x0301,

 26372   acutecomb: 0x0301,

 26373   acutedeva: 0x0954,

 26374   acutelowmod: 0x02CF,

 26375   acutetonecmb: 0x0341,

 26376   acyrillic: 0x0430,

 26377   adblgrave: 0x0201,

 26378   addakgurmukhi: 0x0A71,

 26379   adeva: 0x0905,

 26380   adieresis: 0x00E4,

 26381   adieresiscyrillic: 0x04D3,

 26382   adieresismacron: 0x01DF,

 26383   adotbelow: 0x1EA1,

 26384   adotmacron: 0x01E1,

 26385   ae: 0x00E6,

 26386   aeacute: 0x01FD,

 26387   aekorean: 0x3150,

 26388   aemacron: 0x01E3,

 26389   afii00208: 0x2015,

 26390   afii08941: 0x20A4,

 26391   afii10017: 0x0410,

 26392   afii10018: 0x0411,

 26393   afii10019: 0x0412,

 26394   afii10020: 0x0413,

 26395   afii10021: 0x0414,

 26396   afii10022: 0x0415,

 26397   afii10023: 0x0401,

 26398   afii10024: 0x0416,

 26399   afii10025: 0x0417,

 26400   afii10026: 0x0418,

 26401   afii10027: 0x0419,

 26402   afii10028: 0x041A,

 26403   afii10029: 0x041B,

 26404   afii10030: 0x041C,

 26405   afii10031: 0x041D,

 26406   afii10032: 0x041E,

 26407   afii10033: 0x041F,

 26408   afii10034: 0x0420,

 26409   afii10035: 0x0421,

 26410   afii10036: 0x0422,

 26411   afii10037: 0x0423,

 26412   afii10038: 0x0424,

 26413   afii10039: 0x0425,

 26414   afii10040: 0x0426,

 26415   afii10041: 0x0427,

 26416   afii10042: 0x0428,

 26417   afii10043: 0x0429,

 26418   afii10044: 0x042A,

 26419   afii10045: 0x042B,

 26420   afii10046: 0x042C,

 26421   afii10047: 0x042D,

 26422   afii10048: 0x042E,

 26423   afii10049: 0x042F,

 26424   afii10050: 0x0490,

 26425   afii10051: 0x0402,

 26426   afii10052: 0x0403,

 26427   afii10053: 0x0404,

 26428   afii10054: 0x0405,

 26429   afii10055: 0x0406,

 26430   afii10056: 0x0407,

 26431   afii10057: 0x0408,

 26432   afii10058: 0x0409,

 26433   afii10059: 0x040A,

 26434   afii10060: 0x040B,

 26435   afii10061: 0x040C,

 26436   afii10062: 0x040E,

 26437   afii10063: 0xF6C4,

 26438   afii10064: 0xF6C5,

 26439   afii10065: 0x0430,

 26440   afii10066: 0x0431,

 26441   afii10067: 0x0432,

 26442   afii10068: 0x0433,

 26443   afii10069: 0x0434,

 26444   afii10070: 0x0435,

 26445   afii10071: 0x0451,

 26446   afii10072: 0x0436,

 26447   afii10073: 0x0437,

 26448   afii10074: 0x0438,

 26449   afii10075: 0x0439,

 26450   afii10076: 0x043A,

 26451   afii10077: 0x043B,

 26452   afii10078: 0x043C,

 26453   afii10079: 0x043D,

 26454   afii10080: 0x043E,

 26455   afii10081: 0x043F,

 26456   afii10082: 0x0440,

 26457   afii10083: 0x0441,

 26458   afii10084: 0x0442,

 26459   afii10085: 0x0443,

 26460   afii10086: 0x0444,

 26461   afii10087: 0x0445,

 26462   afii10088: 0x0446,

 26463   afii10089: 0x0447,

 26464   afii10090: 0x0448,

 26465   afii10091: 0x0449,

 26466   afii10092: 0x044A,

 26467   afii10093: 0x044B,

 26468   afii10094: 0x044C,

 26469   afii10095: 0x044D,

 26470   afii10096: 0x044E,

 26471   afii10097: 0x044F,

 26472   afii10098: 0x0491,

 26473   afii10099: 0x0452,

 26474   afii10100: 0x0453,

 26475   afii10101: 0x0454,

 26476   afii10102: 0x0455,

 26477   afii10103: 0x0456,

 26478   afii10104: 0x0457,

 26479   afii10105: 0x0458,

 26480   afii10106: 0x0459,

 26481   afii10107: 0x045A,

 26482   afii10108: 0x045B,

 26483   afii10109: 0x045C,

 26484   afii10110: 0x045E,

 26485   afii10145: 0x040F,

 26486   afii10146: 0x0462,

 26487   afii10147: 0x0472,

 26488   afii10148: 0x0474,

 26489   afii10192: 0xF6C6,

 26490   afii10193: 0x045F,

 26491   afii10194: 0x0463,

 26492   afii10195: 0x0473,

 26493   afii10196: 0x0475,

 26494   afii10831: 0xF6C7,

 26495   afii10832: 0xF6C8,

 26496   afii10846: 0x04D9,

 26497   afii299: 0x200E,

 26498   afii300: 0x200F,

 26499   afii301: 0x200D,

 26500   afii57381: 0x066A,

 26501   afii57388: 0x060C,

 26502   afii57392: 0x0660,

 26503   afii57393: 0x0661,

 26504   afii57394: 0x0662,

 26505   afii57395: 0x0663,

 26506   afii57396: 0x0664,

 26507   afii57397: 0x0665,

 26508   afii57398: 0x0666,

 26509   afii57399: 0x0667,

 26510   afii57400: 0x0668,

 26511   afii57401: 0x0669,

 26512   afii57403: 0x061B,

 26513   afii57407: 0x061F,

 26514   afii57409: 0x0621,

 26515   afii57410: 0x0622,

 26516   afii57411: 0x0623,

 26517   afii57412: 0x0624,

 26518   afii57413: 0x0625,

 26519   afii57414: 0x0626,

 26520   afii57415: 0x0627,

 26521   afii57416: 0x0628,

 26522   afii57417: 0x0629,

 26523   afii57418: 0x062A,

 26524   afii57419: 0x062B,

 26525   afii57420: 0x062C,

 26526   afii57421: 0x062D,

 26527   afii57422: 0x062E,

 26528   afii57423: 0x062F,

 26529   afii57424: 0x0630,

 26530   afii57425: 0x0631,

 26531   afii57426: 0x0632,

 26532   afii57427: 0x0633,

 26533   afii57428: 0x0634,

 26534   afii57429: 0x0635,

 26535   afii57430: 0x0636,

 26536   afii57431: 0x0637,

 26537   afii57432: 0x0638,

 26538   afii57433: 0x0639,

 26539   afii57434: 0x063A,

 26540   afii57440: 0x0640,

 26541   afii57441: 0x0641,

 26542   afii57442: 0x0642,

 26543   afii57443: 0x0643,

 26544   afii57444: 0x0644,

 26545   afii57445: 0x0645,

 26546   afii57446: 0x0646,

 26547   afii57448: 0x0648,

 26548   afii57449: 0x0649,

 26549   afii57450: 0x064A,

 26550   afii57451: 0x064B,

 26551   afii57452: 0x064C,

 26552   afii57453: 0x064D,

 26553   afii57454: 0x064E,

 26554   afii57455: 0x064F,

 26555   afii57456: 0x0650,

 26556   afii57457: 0x0651,

 26557   afii57458: 0x0652,

 26558   afii57470: 0x0647,

 26559   afii57505: 0x06A4,

 26560   afii57506: 0x067E,

 26561   afii57507: 0x0686,

 26562   afii57508: 0x0698,

 26563   afii57509: 0x06AF,

 26564   afii57511: 0x0679,

 26565   afii57512: 0x0688,

 26566   afii57513: 0x0691,

 26567   afii57514: 0x06BA,

 26568   afii57519: 0x06D2,

 26569   afii57534: 0x06D5,

 26570   afii57636: 0x20AA,

 26571   afii57645: 0x05BE,

 26572   afii57658: 0x05C3,

 26573   afii57664: 0x05D0,

 26574   afii57665: 0x05D1,

 26575   afii57666: 0x05D2,

 26576   afii57667: 0x05D3,

 26577   afii57668: 0x05D4,

 26578   afii57669: 0x05D5,

 26579   afii57670: 0x05D6,

 26580   afii57671: 0x05D7,

 26581   afii57672: 0x05D8,

 26582   afii57673: 0x05D9,

 26583   afii57674: 0x05DA,

 26584   afii57675: 0x05DB,

 26585   afii57676: 0x05DC,

 26586   afii57677: 0x05DD,

 26587   afii57678: 0x05DE,

 26588   afii57679: 0x05DF,

 26589   afii57680: 0x05E0,

 26590   afii57681: 0x05E1,

 26591   afii57682: 0x05E2,

 26592   afii57683: 0x05E3,

 26593   afii57684: 0x05E4,

 26594   afii57685: 0x05E5,

 26595   afii57686: 0x05E6,

 26596   afii57687: 0x05E7,

 26597   afii57688: 0x05E8,

 26598   afii57689: 0x05E9,

 26599   afii57690: 0x05EA,

 26600   afii57694: 0xFB2A,

 26601   afii57695: 0xFB2B,

 26602   afii57700: 0xFB4B,

 26603   afii57705: 0xFB1F,

 26604   afii57716: 0x05F0,

 26605   afii57717: 0x05F1,

 26606   afii57718: 0x05F2,

 26607   afii57723: 0xFB35,

 26608   afii57793: 0x05B4,

 26609   afii57794: 0x05B5,

 26610   afii57795: 0x05B6,

 26611   afii57796: 0x05BB,

 26612   afii57797: 0x05B8,

 26613   afii57798: 0x05B7,

 26614   afii57799: 0x05B0,

 26615   afii57800: 0x05B2,

 26616   afii57801: 0x05B1,

 26617   afii57802: 0x05B3,

 26618   afii57803: 0x05C2,

 26619   afii57804: 0x05C1,

 26620   afii57806: 0x05B9,

 26621   afii57807: 0x05BC,

 26622   afii57839: 0x05BD,

 26623   afii57841: 0x05BF,

 26624   afii57842: 0x05C0,

 26625   afii57929: 0x02BC,

 26626   afii61248: 0x2105,

 26627   afii61289: 0x2113,

 26628   afii61352: 0x2116,

 26629   afii61573: 0x202C,

 26630   afii61574: 0x202D,

 26631   afii61575: 0x202E,

 26632   afii61664: 0x200C,

 26633   afii63167: 0x066D,

 26634   afii64937: 0x02BD,

 26635   agrave: 0x00E0,

 26636   agujarati: 0x0A85,

 26637   agurmukhi: 0x0A05,

 26638   ahiragana: 0x3042,

 26639   ahookabove: 0x1EA3,

 26640   aibengali: 0x0990,

 26641   aibopomofo: 0x311E,

 26642   aideva: 0x0910,

 26643   aiecyrillic: 0x04D5,

 26644   aigujarati: 0x0A90,

 26645   aigurmukhi: 0x0A10,

 26646   aimatragurmukhi: 0x0A48,

 26647   ainarabic: 0x0639,

 26648   ainfinalarabic: 0xFECA,

 26649   aininitialarabic: 0xFECB,

 26650   ainmedialarabic: 0xFECC,

 26651   ainvertedbreve: 0x0203,

 26652   aivowelsignbengali: 0x09C8,

 26653   aivowelsigndeva: 0x0948,

 26654   aivowelsigngujarati: 0x0AC8,

 26655   akatakana: 0x30A2,

 26656   akatakanahalfwidth: 0xFF71,

 26657   akorean: 0x314F,

 26658   alef: 0x05D0,

 26659   alefarabic: 0x0627,

 26660   alefdageshhebrew: 0xFB30,

 26661   aleffinalarabic: 0xFE8E,

 26662   alefhamzaabovearabic: 0x0623,

 26663   alefhamzaabovefinalarabic: 0xFE84,

 26664   alefhamzabelowarabic: 0x0625,

 26665   alefhamzabelowfinalarabic: 0xFE88,

 26666   alefhebrew: 0x05D0,

 26667   aleflamedhebrew: 0xFB4F,

 26668   alefmaddaabovearabic: 0x0622,

 26669   alefmaddaabovefinalarabic: 0xFE82,

 26670   alefmaksuraarabic: 0x0649,

 26671   alefmaksurafinalarabic: 0xFEF0,

 26672   alefmaksurainitialarabic: 0xFEF3,

 26673   alefmaksuramedialarabic: 0xFEF4,

 26674   alefpatahhebrew: 0xFB2E,

 26675   alefqamatshebrew: 0xFB2F,

 26676   aleph: 0x2135,

 26677   allequal: 0x224C,

 26678   alpha: 0x03B1,

 26679   alphatonos: 0x03AC,

 26680   amacron: 0x0101,

 26681   amonospace: 0xFF41,

 26682   ampersand: 0x0026,

 26683   ampersandmonospace: 0xFF06,

 26684   ampersandsmall: 0xF726,

 26685   amsquare: 0x33C2,

 26686   anbopomofo: 0x3122,

 26687   angbopomofo: 0x3124,

 26688   angbracketleft: 0x3008, // This glyph is missing from Adobe's original list.

 26689   angbracketright: 0x3009, // This glyph is missing from Adobe's original list.

 26690   angkhankhuthai: 0x0E5A,

 26691   angle: 0x2220,

 26692   anglebracketleft: 0x3008,

 26693   anglebracketleftvertical: 0xFE3F,

 26694   anglebracketright: 0x3009,

 26695   anglebracketrightvertical: 0xFE40,

 26696   angleleft: 0x2329,

 26697   angleright: 0x232A,

 26698   angstrom: 0x212B,

 26699   anoteleia: 0x0387,

 26700   anudattadeva: 0x0952,

 26701   anusvarabengali: 0x0982,

 26702   anusvaradeva: 0x0902,

 26703   anusvaragujarati: 0x0A82,

 26704   aogonek: 0x0105,

 26705   apaatosquare: 0x3300,

 26706   aparen: 0x249C,

 26707   apostrophearmenian: 0x055A,

 26708   apostrophemod: 0x02BC,

 26709   apple: 0xF8FF,

 26710   approaches: 0x2250,

 26711   approxequal: 0x2248,

 26712   approxequalorimage: 0x2252,

 26713   approximatelyequal: 0x2245,

 26714   araeaekorean: 0x318E,

 26715   araeakorean: 0x318D,

 26716   arc: 0x2312,

 26717   arighthalfring: 0x1E9A,

 26718   aring: 0x00E5,

 26719   aringacute: 0x01FB,

 26720   aringbelow: 0x1E01,

 26721   arrowboth: 0x2194,

 26722   arrowdashdown: 0x21E3,

 26723   arrowdashleft: 0x21E0,

 26724   arrowdashright: 0x21E2,

 26725   arrowdashup: 0x21E1,

 26726   arrowdblboth: 0x21D4,

 26727   arrowdbldown: 0x21D3,

 26728   arrowdblleft: 0x21D0,

 26729   arrowdblright: 0x21D2,

 26730   arrowdblup: 0x21D1,

 26731   arrowdown: 0x2193,

 26732   arrowdownleft: 0x2199,

 26733   arrowdownright: 0x2198,

 26734   arrowdownwhite: 0x21E9,

 26735   arrowheaddownmod: 0x02C5,

 26736   arrowheadleftmod: 0x02C2,

 26737   arrowheadrightmod: 0x02C3,

 26738   arrowheadupmod: 0x02C4,

 26739   arrowhorizex: 0xF8E7,

 26740   arrowleft: 0x2190,

 26741   arrowleftdbl: 0x21D0,

 26742   arrowleftdblstroke: 0x21CD,

 26743   arrowleftoverright: 0x21C6,

 26744   arrowleftwhite: 0x21E6,

 26745   arrowright: 0x2192,

 26746   arrowrightdblstroke: 0x21CF,

 26747   arrowrightheavy: 0x279E,

 26748   arrowrightoverleft: 0x21C4,

 26749   arrowrightwhite: 0x21E8,

 26750   arrowtableft: 0x21E4,

 26751   arrowtabright: 0x21E5,

 26752   arrowup: 0x2191,

 26753   arrowupdn: 0x2195,

 26754   arrowupdnbse: 0x21A8,

 26755   arrowupdownbase: 0x21A8,

 26756   arrowupleft: 0x2196,

 26757   arrowupleftofdown: 0x21C5,

 26758   arrowupright: 0x2197,

 26759   arrowupwhite: 0x21E7,

 26760   arrowvertex: 0xF8E6,

 26761   asciicircum: 0x005E,

 26762   asciicircummonospace: 0xFF3E,

 26763   asciitilde: 0x007E,

 26764   asciitildemonospace: 0xFF5E,

 26765   ascript: 0x0251,

 26766   ascriptturned: 0x0252,

 26767   asmallhiragana: 0x3041,

 26768   asmallkatakana: 0x30A1,

 26769   asmallkatakanahalfwidth: 0xFF67,

 26770   asterisk: 0x002A,

 26771   asteriskaltonearabic: 0x066D,

 26772   asteriskarabic: 0x066D,

 26773   asteriskmath: 0x2217,

 26774   asteriskmonospace: 0xFF0A,

 26775   asterisksmall: 0xFE61,

 26776   asterism: 0x2042,

 26777   asuperior: 0xF6E9,

 26778   asymptoticallyequal: 0x2243,

 26779   at: 0x0040,

 26780   atilde: 0x00E3,

 26781   atmonospace: 0xFF20,

 26782   atsmall: 0xFE6B,

 26783   aturned: 0x0250,

 26784   aubengali: 0x0994,

 26785   aubopomofo: 0x3120,

 26786   audeva: 0x0914,

 26787   augujarati: 0x0A94,

 26788   augurmukhi: 0x0A14,

 26789   aulengthmarkbengali: 0x09D7,

 26790   aumatragurmukhi: 0x0A4C,

 26791   auvowelsignbengali: 0x09CC,

 26792   auvowelsigndeva: 0x094C,

 26793   auvowelsigngujarati: 0x0ACC,

 26794   avagrahadeva: 0x093D,

 26795   aybarmenian: 0x0561,

 26796   ayin: 0x05E2,

 26797   ayinaltonehebrew: 0xFB20,

 26798   ayinhebrew: 0x05E2,

 26799   b: 0x0062,

 26800   babengali: 0x09AC,

 26801   backslash: 0x005C,

 26802   backslashmonospace: 0xFF3C,

 26803   badeva: 0x092C,

 26804   bagujarati: 0x0AAC,

 26805   bagurmukhi: 0x0A2C,

 26806   bahiragana: 0x3070,

 26807   bahtthai: 0x0E3F,

 26808   bakatakana: 0x30D0,

 26809   bar: 0x007C,

 26810   barmonospace: 0xFF5C,

 26811   bbopomofo: 0x3105,

 26812   bcircle: 0x24D1,

 26813   bdotaccent: 0x1E03,

 26814   bdotbelow: 0x1E05,

 26815   beamedsixteenthnotes: 0x266C,

 26816   because: 0x2235,

 26817   becyrillic: 0x0431,

 26818   beharabic: 0x0628,

 26819   behfinalarabic: 0xFE90,

 26820   behinitialarabic: 0xFE91,

 26821   behiragana: 0x3079,

 26822   behmedialarabic: 0xFE92,

 26823   behmeeminitialarabic: 0xFC9F,

 26824   behmeemisolatedarabic: 0xFC08,

 26825   behnoonfinalarabic: 0xFC6D,

 26826   bekatakana: 0x30D9,

 26827   benarmenian: 0x0562,

 26828   bet: 0x05D1,

 26829   beta: 0x03B2,

 26830   betasymbolgreek: 0x03D0,

 26831   betdagesh: 0xFB31,

 26832   betdageshhebrew: 0xFB31,

 26833   bethebrew: 0x05D1,

 26834   betrafehebrew: 0xFB4C,

 26835   bhabengali: 0x09AD,

 26836   bhadeva: 0x092D,

 26837   bhagujarati: 0x0AAD,

 26838   bhagurmukhi: 0x0A2D,

 26839   bhook: 0x0253,

 26840   bihiragana: 0x3073,

 26841   bikatakana: 0x30D3,

 26842   bilabialclick: 0x0298,

 26843   bindigurmukhi: 0x0A02,

 26844   birusquare: 0x3331,

 26845   blackcircle: 0x25CF,

 26846   blackdiamond: 0x25C6,

 26847   blackdownpointingtriangle: 0x25BC,

 26848   blackleftpointingpointer: 0x25C4,

 26849   blackleftpointingtriangle: 0x25C0,

 26850   blacklenticularbracketleft: 0x3010,

 26851   blacklenticularbracketleftvertical: 0xFE3B,

 26852   blacklenticularbracketright: 0x3011,

 26853   blacklenticularbracketrightvertical: 0xFE3C,

 26854   blacklowerlefttriangle: 0x25E3,

 26855   blacklowerrighttriangle: 0x25E2,

 26856   blackrectangle: 0x25AC,

 26857   blackrightpointingpointer: 0x25BA,

 26858   blackrightpointingtriangle: 0x25B6,

 26859   blacksmallsquare: 0x25AA,

 26860   blacksmilingface: 0x263B,

 26861   blacksquare: 0x25A0,

 26862   blackstar: 0x2605,

 26863   blackupperlefttriangle: 0x25E4,

 26864   blackupperrighttriangle: 0x25E5,

 26865   blackuppointingsmalltriangle: 0x25B4,

 26866   blackuppointingtriangle: 0x25B2,

 26867   blank: 0x2423,

 26868   blinebelow: 0x1E07,

 26869   block: 0x2588,

 26870   bmonospace: 0xFF42,

 26871   bobaimaithai: 0x0E1A,

 26872   bohiragana: 0x307C,

 26873   bokatakana: 0x30DC,

 26874   bparen: 0x249D,

 26875   bqsquare: 0x33C3,

 26876   braceex: 0xF8F4,

 26877   braceleft: 0x007B,

 26878   braceleftbt: 0xF8F3,

 26879   braceleftmid: 0xF8F2,

 26880   braceleftmonospace: 0xFF5B,

 26881   braceleftsmall: 0xFE5B,

 26882   bracelefttp: 0xF8F1,

 26883   braceleftvertical: 0xFE37,

 26884   braceright: 0x007D,

 26885   bracerightbt: 0xF8FE,

 26886   bracerightmid: 0xF8FD,

 26887   bracerightmonospace: 0xFF5D,

 26888   bracerightsmall: 0xFE5C,

 26889   bracerighttp: 0xF8FC,

 26890   bracerightvertical: 0xFE38,

 26891   bracketleft: 0x005B,

 26892   bracketleftbt: 0xF8F0,

 26893   bracketleftex: 0xF8EF,

 26894   bracketleftmonospace: 0xFF3B,

 26895   bracketlefttp: 0xF8EE,

 26896   bracketright: 0x005D,

 26897   bracketrightbt: 0xF8FB,

 26898   bracketrightex: 0xF8FA,

 26899   bracketrightmonospace: 0xFF3D,

 26900   bracketrighttp: 0xF8F9,

 26901   breve: 0x02D8,

 26902   brevebelowcmb: 0x032E,

 26903   brevecmb: 0x0306,

 26904   breveinvertedbelowcmb: 0x032F,

 26905   breveinvertedcmb: 0x0311,

 26906   breveinverteddoublecmb: 0x0361,

 26907   bridgebelowcmb: 0x032A,

 26908   bridgeinvertedbelowcmb: 0x033A,

 26909   brokenbar: 0x00A6,

 26910   bstroke: 0x0180,

 26911   bsuperior: 0xF6EA,

 26912   btopbar: 0x0183,

 26913   buhiragana: 0x3076,

 26914   bukatakana: 0x30D6,

 26915   bullet: 0x2022,

 26916   bulletinverse: 0x25D8,

 26917   bulletoperator: 0x2219,

 26918   bullseye: 0x25CE,

 26919   c: 0x0063,

 26920   caarmenian: 0x056E,

 26921   cabengali: 0x099A,

 26922   cacute: 0x0107,

 26923   cadeva: 0x091A,

 26924   cagujarati: 0x0A9A,

 26925   cagurmukhi: 0x0A1A,

 26926   calsquare: 0x3388,

 26927   candrabindubengali: 0x0981,

 26928   candrabinducmb: 0x0310,

 26929   candrabindudeva: 0x0901,

 26930   candrabindugujarati: 0x0A81,

 26931   capslock: 0x21EA,

 26932   careof: 0x2105,

 26933   caron: 0x02C7,

 26934   caronbelowcmb: 0x032C,

 26935   caroncmb: 0x030C,

 26936   carriagereturn: 0x21B5,

 26937   cbopomofo: 0x3118,

 26938   ccaron: 0x010D,

 26939   ccedilla: 0x00E7,

 26940   ccedillaacute: 0x1E09,

 26941   ccircle: 0x24D2,

 26942   ccircumflex: 0x0109,

 26943   ccurl: 0x0255,

 26944   cdot: 0x010B,

 26945   cdotaccent: 0x010B,

 26946   cdsquare: 0x33C5,

 26947   cedilla: 0x00B8,

 26948   cedillacmb: 0x0327,

 26949   cent: 0x00A2,

 26950   centigrade: 0x2103,

 26951   centinferior: 0xF6DF,

 26952   centmonospace: 0xFFE0,

 26953   centoldstyle: 0xF7A2,

 26954   centsuperior: 0xF6E0,

 26955   chaarmenian: 0x0579,

 26956   chabengali: 0x099B,

 26957   chadeva: 0x091B,

 26958   chagujarati: 0x0A9B,

 26959   chagurmukhi: 0x0A1B,

 26960   chbopomofo: 0x3114,

 26961   cheabkhasiancyrillic: 0x04BD,

 26962   checkmark: 0x2713,

 26963   checyrillic: 0x0447,

 26964   chedescenderabkhasiancyrillic: 0x04BF,

 26965   chedescendercyrillic: 0x04B7,

 26966   chedieresiscyrillic: 0x04F5,

 26967   cheharmenian: 0x0573,

 26968   chekhakassiancyrillic: 0x04CC,

 26969   cheverticalstrokecyrillic: 0x04B9,

 26970   chi: 0x03C7,

 26971   chieuchacirclekorean: 0x3277,

 26972   chieuchaparenkorean: 0x3217,

 26973   chieuchcirclekorean: 0x3269,

 26974   chieuchkorean: 0x314A,

 26975   chieuchparenkorean: 0x3209,

 26976   chochangthai: 0x0E0A,

 26977   chochanthai: 0x0E08,

 26978   chochingthai: 0x0E09,

 26979   chochoethai: 0x0E0C,

 26980   chook: 0x0188,

 26981   cieucacirclekorean: 0x3276,

 26982   cieucaparenkorean: 0x3216,

 26983   cieuccirclekorean: 0x3268,

 26984   cieuckorean: 0x3148,

 26985   cieucparenkorean: 0x3208,

 26986   cieucuparenkorean: 0x321C,

 26987   circle: 0x25CB,

 26988   circlecopyrt: 0x00A9, // This glyph is missing from Adobe's original list.

 26989   circlemultiply: 0x2297,

 26990   circleot: 0x2299,

 26991   circleplus: 0x2295,

 26992   circlepostalmark: 0x3036,

 26993   circlewithlefthalfblack: 0x25D0,

 26994   circlewithrighthalfblack: 0x25D1,

 26995   circumflex: 0x02C6,

 26996   circumflexbelowcmb: 0x032D,

 26997   circumflexcmb: 0x0302,

 26998   clear: 0x2327,

 26999   clickalveolar: 0x01C2,

 27000   clickdental: 0x01C0,

 27001   clicklateral: 0x01C1,

 27002   clickretroflex: 0x01C3,

 27003   club: 0x2663,

 27004   clubsuitblack: 0x2663,

 27005   clubsuitwhite: 0x2667,

 27006   cmcubedsquare: 0x33A4,

 27007   cmonospace: 0xFF43,

 27008   cmsquaredsquare: 0x33A0,

 27009   coarmenian: 0x0581,

 27010   colon: 0x003A,

 27011   colonmonetary: 0x20A1,

 27012   colonmonospace: 0xFF1A,

 27013   colonsign: 0x20A1,

 27014   colonsmall: 0xFE55,

 27015   colontriangularhalfmod: 0x02D1,

 27016   colontriangularmod: 0x02D0,

 27017   comma: 0x002C,

 27018   commaabovecmb: 0x0313,

 27019   commaaboverightcmb: 0x0315,

 27020   commaaccent: 0xF6C3,

 27021   commaarabic: 0x060C,

 27022   commaarmenian: 0x055D,

 27023   commainferior: 0xF6E1,

 27024   commamonospace: 0xFF0C,

 27025   commareversedabovecmb: 0x0314,

 27026   commareversedmod: 0x02BD,

 27027   commasmall: 0xFE50,

 27028   commasuperior: 0xF6E2,

 27029   commaturnedabovecmb: 0x0312,

 27030   commaturnedmod: 0x02BB,

 27031   compass: 0x263C,

 27032   congruent: 0x2245,

 27033   contourintegral: 0x222E,

 27034   control: 0x2303,

 27035   controlACK: 0x0006,

 27036   controlBEL: 0x0007,

 27037   controlBS: 0x0008,

 27038   controlCAN: 0x0018,

 27039   controlCR: 0x000D,

 27040   controlDC1: 0x0011,

 27041   controlDC2: 0x0012,

 27042   controlDC3: 0x0013,

 27043   controlDC4: 0x0014,

 27044   controlDEL: 0x007F,

 27045   controlDLE: 0x0010,

 27046   controlEM: 0x0019,

 27047   controlENQ: 0x0005,

 27048   controlEOT: 0x0004,

 27049   controlESC: 0x001B,

 27050   controlETB: 0x0017,

 27051   controlETX: 0x0003,

 27052   controlFF: 0x000C,

 27053   controlFS: 0x001C,

 27054   controlGS: 0x001D,

 27055   controlHT: 0x0009,

 27056   controlLF: 0x000A,

 27057   controlNAK: 0x0015,

 27058   controlRS: 0x001E,

 27059   controlSI: 0x000F,

 27060   controlSO: 0x000E,

 27061   controlSOT: 0x0002,

 27062   controlSTX: 0x0001,

 27063   controlSUB: 0x001A,

 27064   controlSYN: 0x0016,

 27065   controlUS: 0x001F,

 27066   controlVT: 0x000B,

 27067   copyright: 0x00A9,

 27068   copyrightsans: 0xF8E9,

 27069   copyrightserif: 0xF6D9,

 27070   cornerbracketleft: 0x300C,

 27071   cornerbracketlefthalfwidth: 0xFF62,

 27072   cornerbracketleftvertical: 0xFE41,

 27073   cornerbracketright: 0x300D,

 27074   cornerbracketrighthalfwidth: 0xFF63,

 27075   cornerbracketrightvertical: 0xFE42,

 27076   corporationsquare: 0x337F,

 27077   cosquare: 0x33C7,

 27078   coverkgsquare: 0x33C6,

 27079   cparen: 0x249E,

 27080   cruzeiro: 0x20A2,

 27081   cstretched: 0x0297,

 27082   curlyand: 0x22CF,

 27083   curlyor: 0x22CE,

 27084   currency: 0x00A4,

 27085   cyrBreve: 0xF6D1,

 27086   cyrFlex: 0xF6D2,

 27087   cyrbreve: 0xF6D4,

 27088   cyrflex: 0xF6D5,

 27089   d: 0x0064,

 27090   daarmenian: 0x0564,

 27091   dabengali: 0x09A6,

 27092   dadarabic: 0x0636,

 27093   dadeva: 0x0926,

 27094   dadfinalarabic: 0xFEBE,

 27095   dadinitialarabic: 0xFEBF,

 27096   dadmedialarabic: 0xFEC0,

 27097   dagesh: 0x05BC,

 27098   dageshhebrew: 0x05BC,

 27099   dagger: 0x2020,

 27100   daggerdbl: 0x2021,

 27101   dagujarati: 0x0AA6,

 27102   dagurmukhi: 0x0A26,

 27103   dahiragana: 0x3060,

 27104   dakatakana: 0x30C0,

 27105   dalarabic: 0x062F,

 27106   dalet: 0x05D3,

 27107   daletdagesh: 0xFB33,

 27108   daletdageshhebrew: 0xFB33,

 27109   dalethebrew: 0x05D3,

 27110   dalfinalarabic: 0xFEAA,

 27111   dammaarabic: 0x064F,

 27112   dammalowarabic: 0x064F,

 27113   dammatanaltonearabic: 0x064C,

 27114   dammatanarabic: 0x064C,

 27115   danda: 0x0964,

 27116   dargahebrew: 0x05A7,

 27117   dargalefthebrew: 0x05A7,

 27118   dasiapneumatacyrilliccmb: 0x0485,

 27119   dblGrave: 0xF6D3,

 27120   dblanglebracketleft: 0x300A,

 27121   dblanglebracketleftvertical: 0xFE3D,

 27122   dblanglebracketright: 0x300B,

 27123   dblanglebracketrightvertical: 0xFE3E,

 27124   dblarchinvertedbelowcmb: 0x032B,

 27125   dblarrowleft: 0x21D4,

 27126   dblarrowright: 0x21D2,

 27127   dbldanda: 0x0965,

 27128   dblgrave: 0xF6D6,

 27129   dblgravecmb: 0x030F,

 27130   dblintegral: 0x222C,

 27131   dbllowline: 0x2017,

 27132   dbllowlinecmb: 0x0333,

 27133   dbloverlinecmb: 0x033F,

 27134   dblprimemod: 0x02BA,

 27135   dblverticalbar: 0x2016,

 27136   dblverticallineabovecmb: 0x030E,

 27137   dbopomofo: 0x3109,

 27138   dbsquare: 0x33C8,

 27139   dcaron: 0x010F,

 27140   dcedilla: 0x1E11,

 27141   dcircle: 0x24D3,

 27142   dcircumflexbelow: 0x1E13,

 27143   dcroat: 0x0111,

 27144   ddabengali: 0x09A1,

 27145   ddadeva: 0x0921,

 27146   ddagujarati: 0x0AA1,

 27147   ddagurmukhi: 0x0A21,

 27148   ddalarabic: 0x0688,

 27149   ddalfinalarabic: 0xFB89,

 27150   dddhadeva: 0x095C,

 27151   ddhabengali: 0x09A2,

 27152   ddhadeva: 0x0922,

 27153   ddhagujarati: 0x0AA2,

 27154   ddhagurmukhi: 0x0A22,

 27155   ddotaccent: 0x1E0B,

 27156   ddotbelow: 0x1E0D,

 27157   decimalseparatorarabic: 0x066B,

 27158   decimalseparatorpersian: 0x066B,

 27159   decyrillic: 0x0434,

 27160   degree: 0x00B0,

 27161   dehihebrew: 0x05AD,

 27162   dehiragana: 0x3067,

 27163   deicoptic: 0x03EF,

 27164   dekatakana: 0x30C7,

 27165   deleteleft: 0x232B,

 27166   deleteright: 0x2326,

 27167   delta: 0x03B4,

 27168   deltaturned: 0x018D,

 27169   denominatorminusonenumeratorbengali: 0x09F8,

 27170   dezh: 0x02A4,

 27171   dhabengali: 0x09A7,

 27172   dhadeva: 0x0927,

 27173   dhagujarati: 0x0AA7,

 27174   dhagurmukhi: 0x0A27,

 27175   dhook: 0x0257,

 27176   dialytikatonos: 0x0385,

 27177   dialytikatonoscmb: 0x0344,

 27178   diamond: 0x2666,

 27179   diamondsuitwhite: 0x2662,

 27180   dieresis: 0x00A8,

 27181   dieresisacute: 0xF6D7,

 27182   dieresisbelowcmb: 0x0324,

 27183   dieresiscmb: 0x0308,

 27184   dieresisgrave: 0xF6D8,

 27185   dieresistonos: 0x0385,

 27186   dihiragana: 0x3062,

 27187   dikatakana: 0x30C2,

 27188   dittomark: 0x3003,

 27189   divide: 0x00F7,

 27190   divides: 0x2223,

 27191   divisionslash: 0x2215,

 27192   djecyrillic: 0x0452,

 27193   dkshade: 0x2593,

 27194   dlinebelow: 0x1E0F,

 27195   dlsquare: 0x3397,

 27196   dmacron: 0x0111,

 27197   dmonospace: 0xFF44,

 27198   dnblock: 0x2584,

 27199   dochadathai: 0x0E0E,

 27200   dodekthai: 0x0E14,

 27201   dohiragana: 0x3069,

 27202   dokatakana: 0x30C9,

 27203   dollar: 0x0024,

 27204   dollarinferior: 0xF6E3,

 27205   dollarmonospace: 0xFF04,

 27206   dollaroldstyle: 0xF724,

 27207   dollarsmall: 0xFE69,

 27208   dollarsuperior: 0xF6E4,

 27209   dong: 0x20AB,

 27210   dorusquare: 0x3326,

 27211   dotaccent: 0x02D9,

 27212   dotaccentcmb: 0x0307,

 27213   dotbelowcmb: 0x0323,

 27214   dotbelowcomb: 0x0323,

 27215   dotkatakana: 0x30FB,

 27216   dotlessi: 0x0131,

 27217   dotlessj: 0xF6BE,

 27218   dotlessjstrokehook: 0x0284,

 27219   dotmath: 0x22C5,

 27220   dottedcircle: 0x25CC,

 27221   doubleyodpatah: 0xFB1F,

 27222   doubleyodpatahhebrew: 0xFB1F,

 27223   downtackbelowcmb: 0x031E,

 27224   downtackmod: 0x02D5,

 27225   dparen: 0x249F,

 27226   dsuperior: 0xF6EB,

 27227   dtail: 0x0256,

 27228   dtopbar: 0x018C,

 27229   duhiragana: 0x3065,

 27230   dukatakana: 0x30C5,

 27231   dz: 0x01F3,

 27232   dzaltone: 0x02A3,

 27233   dzcaron: 0x01C6,

 27234   dzcurl: 0x02A5,

 27235   dzeabkhasiancyrillic: 0x04E1,

 27236   dzecyrillic: 0x0455,

 27237   dzhecyrillic: 0x045F,

 27238   e: 0x0065,

 27239   eacute: 0x00E9,

 27240   earth: 0x2641,

 27241   ebengali: 0x098F,

 27242   ebopomofo: 0x311C,

 27243   ebreve: 0x0115,

 27244   ecandradeva: 0x090D,

 27245   ecandragujarati: 0x0A8D,

 27246   ecandravowelsigndeva: 0x0945,

 27247   ecandravowelsigngujarati: 0x0AC5,

 27248   ecaron: 0x011B,

 27249   ecedillabreve: 0x1E1D,

 27250   echarmenian: 0x0565,

 27251   echyiwnarmenian: 0x0587,

 27252   ecircle: 0x24D4,

 27253   ecircumflex: 0x00EA,

 27254   ecircumflexacute: 0x1EBF,

 27255   ecircumflexbelow: 0x1E19,

 27256   ecircumflexdotbelow: 0x1EC7,

 27257   ecircumflexgrave: 0x1EC1,

 27258   ecircumflexhookabove: 0x1EC3,

 27259   ecircumflextilde: 0x1EC5,

 27260   ecyrillic: 0x0454,

 27261   edblgrave: 0x0205,

 27262   edeva: 0x090F,

 27263   edieresis: 0x00EB,

 27264   edot: 0x0117,

 27265   edotaccent: 0x0117,

 27266   edotbelow: 0x1EB9,

 27267   eegurmukhi: 0x0A0F,

 27268   eematragurmukhi: 0x0A47,

 27269   efcyrillic: 0x0444,

 27270   egrave: 0x00E8,

 27271   egujarati: 0x0A8F,

 27272   eharmenian: 0x0567,

 27273   ehbopomofo: 0x311D,

 27274   ehiragana: 0x3048,

 27275   ehookabove: 0x1EBB,

 27276   eibopomofo: 0x311F,

 27277   eight: 0x0038,

 27278   eightarabic: 0x0668,

 27279   eightbengali: 0x09EE,

 27280   eightcircle: 0x2467,

 27281   eightcircleinversesansserif: 0x2791,

 27282   eightdeva: 0x096E,

 27283   eighteencircle: 0x2471,

 27284   eighteenparen: 0x2485,

 27285   eighteenperiod: 0x2499,

 27286   eightgujarati: 0x0AEE,

 27287   eightgurmukhi: 0x0A6E,

 27288   eighthackarabic: 0x0668,

 27289   eighthangzhou: 0x3028,

 27290   eighthnotebeamed: 0x266B,

 27291   eightideographicparen: 0x3227,

 27292   eightinferior: 0x2088,

 27293   eightmonospace: 0xFF18,

 27294   eightoldstyle: 0xF738,

 27295   eightparen: 0x247B,

 27296   eightperiod: 0x248F,

 27297   eightpersian: 0x06F8,

 27298   eightroman: 0x2177,

 27299   eightsuperior: 0x2078,

 27300   eightthai: 0x0E58,

 27301   einvertedbreve: 0x0207,

 27302   eiotifiedcyrillic: 0x0465,

 27303   ekatakana: 0x30A8,

 27304   ekatakanahalfwidth: 0xFF74,

 27305   ekonkargurmukhi: 0x0A74,

 27306   ekorean: 0x3154,

 27307   elcyrillic: 0x043B,

 27308   element: 0x2208,

 27309   elevencircle: 0x246A,

 27310   elevenparen: 0x247E,

 27311   elevenperiod: 0x2492,

 27312   elevenroman: 0x217A,

 27313   ellipsis: 0x2026,

 27314   ellipsisvertical: 0x22EE,

 27315   emacron: 0x0113,

 27316   emacronacute: 0x1E17,

 27317   emacrongrave: 0x1E15,

 27318   emcyrillic: 0x043C,

 27319   emdash: 0x2014,

 27320   emdashvertical: 0xFE31,

 27321   emonospace: 0xFF45,

 27322   emphasismarkarmenian: 0x055B,

 27323   emptyset: 0x2205,

 27324   enbopomofo: 0x3123,

 27325   encyrillic: 0x043D,

 27326   endash: 0x2013,

 27327   endashvertical: 0xFE32,

 27328   endescendercyrillic: 0x04A3,

 27329   eng: 0x014B,

 27330   engbopomofo: 0x3125,

 27331   enghecyrillic: 0x04A5,

 27332   enhookcyrillic: 0x04C8,

 27333   enspace: 0x2002,

 27334   eogonek: 0x0119,

 27335   eokorean: 0x3153,

 27336   eopen: 0x025B,

 27337   eopenclosed: 0x029A,

 27338   eopenreversed: 0x025C,

 27339   eopenreversedclosed: 0x025E,

 27340   eopenreversedhook: 0x025D,

 27341   eparen: 0x24A0,

 27342   epsilon: 0x03B5,

 27343   epsilontonos: 0x03AD,

 27344   equal: 0x003D,

 27345   equalmonospace: 0xFF1D,

 27346   equalsmall: 0xFE66,

 27347   equalsuperior: 0x207C,

 27348   equivalence: 0x2261,

 27349   erbopomofo: 0x3126,

 27350   ercyrillic: 0x0440,

 27351   ereversed: 0x0258,

 27352   ereversedcyrillic: 0x044D,

 27353   escyrillic: 0x0441,

 27354   esdescendercyrillic: 0x04AB,

 27355   esh: 0x0283,

 27356   eshcurl: 0x0286,

 27357   eshortdeva: 0x090E,

 27358   eshortvowelsigndeva: 0x0946,

 27359   eshreversedloop: 0x01AA,

 27360   eshsquatreversed: 0x0285,

 27361   esmallhiragana: 0x3047,

 27362   esmallkatakana: 0x30A7,

 27363   esmallkatakanahalfwidth: 0xFF6A,

 27364   estimated: 0x212E,

 27365   esuperior: 0xF6EC,

 27366   eta: 0x03B7,

 27367   etarmenian: 0x0568,

 27368   etatonos: 0x03AE,

 27369   eth: 0x00F0,

 27370   etilde: 0x1EBD,

 27371   etildebelow: 0x1E1B,

 27372   etnahtafoukhhebrew: 0x0591,

 27373   etnahtafoukhlefthebrew: 0x0591,

 27374   etnahtahebrew: 0x0591,

 27375   etnahtalefthebrew: 0x0591,

 27376   eturned: 0x01DD,

 27377   eukorean: 0x3161,

 27378   euro: 0x20AC,

 27379   evowelsignbengali: 0x09C7,

 27380   evowelsigndeva: 0x0947,

 27381   evowelsigngujarati: 0x0AC7,

 27382   exclam: 0x0021,

 27383   exclamarmenian: 0x055C,

 27384   exclamdbl: 0x203C,

 27385   exclamdown: 0x00A1,

 27386   exclamdownsmall: 0xF7A1,

 27387   exclammonospace: 0xFF01,

 27388   exclamsmall: 0xF721,

 27389   existential: 0x2203,

 27390   ezh: 0x0292,

 27391   ezhcaron: 0x01EF,

 27392   ezhcurl: 0x0293,

 27393   ezhreversed: 0x01B9,

 27394   ezhtail: 0x01BA,

 27395   f: 0x0066,

 27396   fadeva: 0x095E,

 27397   fagurmukhi: 0x0A5E,

 27398   fahrenheit: 0x2109,

 27399   fathaarabic: 0x064E,

 27400   fathalowarabic: 0x064E,

 27401   fathatanarabic: 0x064B,

 27402   fbopomofo: 0x3108,

 27403   fcircle: 0x24D5,

 27404   fdotaccent: 0x1E1F,

 27405   feharabic: 0x0641,

 27406   feharmenian: 0x0586,

 27407   fehfinalarabic: 0xFED2,

 27408   fehinitialarabic: 0xFED3,

 27409   fehmedialarabic: 0xFED4,

 27410   feicoptic: 0x03E5,

 27411   female: 0x2640,

 27412   ff: 0xFB00,

 27413   ffi: 0xFB03,

 27414   ffl: 0xFB04,

 27415   fi: 0xFB01,

 27416   fifteencircle: 0x246E,

 27417   fifteenparen: 0x2482,

 27418   fifteenperiod: 0x2496,

 27419   figuredash: 0x2012,

 27420   filledbox: 0x25A0,

 27421   filledrect: 0x25AC,

 27422   finalkaf: 0x05DA,

 27423   finalkafdagesh: 0xFB3A,

 27424   finalkafdageshhebrew: 0xFB3A,

 27425   finalkafhebrew: 0x05DA,

 27426   finalmem: 0x05DD,

 27427   finalmemhebrew: 0x05DD,

 27428   finalnun: 0x05DF,

 27429   finalnunhebrew: 0x05DF,

 27430   finalpe: 0x05E3,

 27431   finalpehebrew: 0x05E3,

 27432   finaltsadi: 0x05E5,

 27433   finaltsadihebrew: 0x05E5,

 27434   firsttonechinese: 0x02C9,

 27435   fisheye: 0x25C9,

 27436   fitacyrillic: 0x0473,

 27437   five: 0x0035,

 27438   fivearabic: 0x0665,

 27439   fivebengali: 0x09EB,

 27440   fivecircle: 0x2464,

 27441   fivecircleinversesansserif: 0x278E,

 27442   fivedeva: 0x096B,

 27443   fiveeighths: 0x215D,

 27444   fivegujarati: 0x0AEB,

 27445   fivegurmukhi: 0x0A6B,

 27446   fivehackarabic: 0x0665,

 27447   fivehangzhou: 0x3025,

 27448   fiveideographicparen: 0x3224,

 27449   fiveinferior: 0x2085,

 27450   fivemonospace: 0xFF15,

 27451   fiveoldstyle: 0xF735,

 27452   fiveparen: 0x2478,

 27453   fiveperiod: 0x248C,

 27454   fivepersian: 0x06F5,

 27455   fiveroman: 0x2174,

 27456   fivesuperior: 0x2075,

 27457   fivethai: 0x0E55,

 27458   fl: 0xFB02,

 27459   florin: 0x0192,

 27460   fmonospace: 0xFF46,

 27461   fmsquare: 0x3399,

 27462   fofanthai: 0x0E1F,

 27463   fofathai: 0x0E1D,

 27464   fongmanthai: 0x0E4F,

 27465   forall: 0x2200,

 27466   four: 0x0034,

 27467   fourarabic: 0x0664,

 27468   fourbengali: 0x09EA,

 27469   fourcircle: 0x2463,

 27470   fourcircleinversesansserif: 0x278D,

 27471   fourdeva: 0x096A,

 27472   fourgujarati: 0x0AEA,

 27473   fourgurmukhi: 0x0A6A,

 27474   fourhackarabic: 0x0664,

 27475   fourhangzhou: 0x3024,

 27476   fourideographicparen: 0x3223,

 27477   fourinferior: 0x2084,

 27478   fourmonospace: 0xFF14,

 27479   fournumeratorbengali: 0x09F7,

 27480   fouroldstyle: 0xF734,

 27481   fourparen: 0x2477,

 27482   fourperiod: 0x248B,

 27483   fourpersian: 0x06F4,

 27484   fourroman: 0x2173,

 27485   foursuperior: 0x2074,

 27486   fourteencircle: 0x246D,

 27487   fourteenparen: 0x2481,

 27488   fourteenperiod: 0x2495,

 27489   fourthai: 0x0E54,

 27490   fourthtonechinese: 0x02CB,

 27491   fparen: 0x24A1,

 27492   fraction: 0x2044,

 27493   franc: 0x20A3,

 27494   g: 0x0067,

 27495   gabengali: 0x0997,

 27496   gacute: 0x01F5,

 27497   gadeva: 0x0917,

 27498   gafarabic: 0x06AF,

 27499   gaffinalarabic: 0xFB93,

 27500   gafinitialarabic: 0xFB94,

 27501   gafmedialarabic: 0xFB95,

 27502   gagujarati: 0x0A97,

 27503   gagurmukhi: 0x0A17,

 27504   gahiragana: 0x304C,

 27505   gakatakana: 0x30AC,

 27506   gamma: 0x03B3,

 27507   gammalatinsmall: 0x0263,

 27508   gammasuperior: 0x02E0,

 27509   gangiacoptic: 0x03EB,

 27510   gbopomofo: 0x310D,

 27511   gbreve: 0x011F,

 27512   gcaron: 0x01E7,

 27513   gcedilla: 0x0123,

 27514   gcircle: 0x24D6,

 27515   gcircumflex: 0x011D,

 27516   gcommaaccent: 0x0123,

 27517   gdot: 0x0121,

 27518   gdotaccent: 0x0121,

 27519   gecyrillic: 0x0433,

 27520   gehiragana: 0x3052,

 27521   gekatakana: 0x30B2,

 27522   geometricallyequal: 0x2251,

 27523   gereshaccenthebrew: 0x059C,

 27524   gereshhebrew: 0x05F3,

 27525   gereshmuqdamhebrew: 0x059D,

 27526   germandbls: 0x00DF,

 27527   gershayimaccenthebrew: 0x059E,

 27528   gershayimhebrew: 0x05F4,

 27529   getamark: 0x3013,

 27530   ghabengali: 0x0998,

 27531   ghadarmenian: 0x0572,

 27532   ghadeva: 0x0918,

 27533   ghagujarati: 0x0A98,

 27534   ghagurmukhi: 0x0A18,

 27535   ghainarabic: 0x063A,

 27536   ghainfinalarabic: 0xFECE,

 27537   ghaininitialarabic: 0xFECF,

 27538   ghainmedialarabic: 0xFED0,

 27539   ghemiddlehookcyrillic: 0x0495,

 27540   ghestrokecyrillic: 0x0493,

 27541   gheupturncyrillic: 0x0491,

 27542   ghhadeva: 0x095A,

 27543   ghhagurmukhi: 0x0A5A,

 27544   ghook: 0x0260,

 27545   ghzsquare: 0x3393,

 27546   gihiragana: 0x304E,

 27547   gikatakana: 0x30AE,

 27548   gimarmenian: 0x0563,

 27549   gimel: 0x05D2,

 27550   gimeldagesh: 0xFB32,

 27551   gimeldageshhebrew: 0xFB32,

 27552   gimelhebrew: 0x05D2,

 27553   gjecyrillic: 0x0453,

 27554   glottalinvertedstroke: 0x01BE,

 27555   glottalstop: 0x0294,

 27556   glottalstopinverted: 0x0296,

 27557   glottalstopmod: 0x02C0,

 27558   glottalstopreversed: 0x0295,

 27559   glottalstopreversedmod: 0x02C1,

 27560   glottalstopreversedsuperior: 0x02E4,

 27561   glottalstopstroke: 0x02A1,

 27562   glottalstopstrokereversed: 0x02A2,

 27563   gmacron: 0x1E21,

 27564   gmonospace: 0xFF47,

 27565   gohiragana: 0x3054,

 27566   gokatakana: 0x30B4,

 27567   gparen: 0x24A2,

 27568   gpasquare: 0x33AC,

 27569   gradient: 0x2207,

 27570   grave: 0x0060,

 27571   gravebelowcmb: 0x0316,

 27572   gravecmb: 0x0300,

 27573   gravecomb: 0x0300,

 27574   gravedeva: 0x0953,

 27575   gravelowmod: 0x02CE,

 27576   gravemonospace: 0xFF40,

 27577   gravetonecmb: 0x0340,

 27578   greater: 0x003E,

 27579   greaterequal: 0x2265,

 27580   greaterequalorless: 0x22DB,

 27581   greatermonospace: 0xFF1E,

 27582   greaterorequivalent: 0x2273,

 27583   greaterorless: 0x2277,

 27584   greateroverequal: 0x2267,

 27585   greatersmall: 0xFE65,

 27586   gscript: 0x0261,

 27587   gstroke: 0x01E5,

 27588   guhiragana: 0x3050,

 27589   guillemotleft: 0x00AB,

 27590   guillemotright: 0x00BB,

 27591   guilsinglleft: 0x2039,

 27592   guilsinglright: 0x203A,

 27593   gukatakana: 0x30B0,

 27594   guramusquare: 0x3318,

 27595   gysquare: 0x33C9,

 27596   h: 0x0068,

 27597   haabkhasiancyrillic: 0x04A9,

 27598   haaltonearabic: 0x06C1,

 27599   habengali: 0x09B9,

 27600   hadescendercyrillic: 0x04B3,

 27601   hadeva: 0x0939,

 27602   hagujarati: 0x0AB9,

 27603   hagurmukhi: 0x0A39,

 27604   haharabic: 0x062D,

 27605   hahfinalarabic: 0xFEA2,

 27606   hahinitialarabic: 0xFEA3,

 27607   hahiragana: 0x306F,

 27608   hahmedialarabic: 0xFEA4,

 27609   haitusquare: 0x332A,

 27610   hakatakana: 0x30CF,

 27611   hakatakanahalfwidth: 0xFF8A,

 27612   halantgurmukhi: 0x0A4D,

 27613   hamzaarabic: 0x0621,

 27614   hamzalowarabic: 0x0621,

 27615   hangulfiller: 0x3164,

 27616   hardsigncyrillic: 0x044A,

 27617   harpoonleftbarbup: 0x21BC,

 27618   harpoonrightbarbup: 0x21C0,

 27619   hasquare: 0x33CA,

 27620   hatafpatah: 0x05B2,

 27621   hatafpatah16: 0x05B2,

 27622   hatafpatah23: 0x05B2,

 27623   hatafpatah2f: 0x05B2,

 27624   hatafpatahhebrew: 0x05B2,

 27625   hatafpatahnarrowhebrew: 0x05B2,

 27626   hatafpatahquarterhebrew: 0x05B2,

 27627   hatafpatahwidehebrew: 0x05B2,

 27628   hatafqamats: 0x05B3,

 27629   hatafqamats1b: 0x05B3,

 27630   hatafqamats28: 0x05B3,

 27631   hatafqamats34: 0x05B3,

 27632   hatafqamatshebrew: 0x05B3,

 27633   hatafqamatsnarrowhebrew: 0x05B3,

 27634   hatafqamatsquarterhebrew: 0x05B3,

 27635   hatafqamatswidehebrew: 0x05B3,

 27636   hatafsegol: 0x05B1,

 27637   hatafsegol17: 0x05B1,

 27638   hatafsegol24: 0x05B1,

 27639   hatafsegol30: 0x05B1,

 27640   hatafsegolhebrew: 0x05B1,

 27641   hatafsegolnarrowhebrew: 0x05B1,

 27642   hatafsegolquarterhebrew: 0x05B1,

 27643   hatafsegolwidehebrew: 0x05B1,

 27644   hbar: 0x0127,

 27645   hbopomofo: 0x310F,

 27646   hbrevebelow: 0x1E2B,

 27647   hcedilla: 0x1E29,

 27648   hcircle: 0x24D7,

 27649   hcircumflex: 0x0125,

 27650   hdieresis: 0x1E27,

 27651   hdotaccent: 0x1E23,

 27652   hdotbelow: 0x1E25,

 27653   he: 0x05D4,

 27654   heart: 0x2665,

 27655   heartsuitblack: 0x2665,

 27656   heartsuitwhite: 0x2661,

 27657   hedagesh: 0xFB34,

 27658   hedageshhebrew: 0xFB34,

 27659   hehaltonearabic: 0x06C1,

 27660   heharabic: 0x0647,

 27661   hehebrew: 0x05D4,

 27662   hehfinalaltonearabic: 0xFBA7,

 27663   hehfinalalttwoarabic: 0xFEEA,

 27664   hehfinalarabic: 0xFEEA,

 27665   hehhamzaabovefinalarabic: 0xFBA5,

 27666   hehhamzaaboveisolatedarabic: 0xFBA4,

 27667   hehinitialaltonearabic: 0xFBA8,

 27668   hehinitialarabic: 0xFEEB,

 27669   hehiragana: 0x3078,

 27670   hehmedialaltonearabic: 0xFBA9,

 27671   hehmedialarabic: 0xFEEC,

 27672   heiseierasquare: 0x337B,

 27673   hekatakana: 0x30D8,

 27674   hekatakanahalfwidth: 0xFF8D,

 27675   hekutaarusquare: 0x3336,

 27676   henghook: 0x0267,

 27677   herutusquare: 0x3339,

 27678   het: 0x05D7,

 27679   hethebrew: 0x05D7,

 27680   hhook: 0x0266,

 27681   hhooksuperior: 0x02B1,

 27682   hieuhacirclekorean: 0x327B,

 27683   hieuhaparenkorean: 0x321B,

 27684   hieuhcirclekorean: 0x326D,

 27685   hieuhkorean: 0x314E,

 27686   hieuhparenkorean: 0x320D,

 27687   hihiragana: 0x3072,

 27688   hikatakana: 0x30D2,

 27689   hikatakanahalfwidth: 0xFF8B,

 27690   hiriq: 0x05B4,

 27691   hiriq14: 0x05B4,

 27692   hiriq21: 0x05B4,

 27693   hiriq2d: 0x05B4,

 27694   hiriqhebrew: 0x05B4,

 27695   hiriqnarrowhebrew: 0x05B4,

 27696   hiriqquarterhebrew: 0x05B4,

 27697   hiriqwidehebrew: 0x05B4,

 27698   hlinebelow: 0x1E96,

 27699   hmonospace: 0xFF48,

 27700   hoarmenian: 0x0570,

 27701   hohipthai: 0x0E2B,

 27702   hohiragana: 0x307B,

 27703   hokatakana: 0x30DB,

 27704   hokatakanahalfwidth: 0xFF8E,

 27705   holam: 0x05B9,

 27706   holam19: 0x05B9,

 27707   holam26: 0x05B9,

 27708   holam32: 0x05B9,

 27709   holamhebrew: 0x05B9,

 27710   holamnarrowhebrew: 0x05B9,

 27711   holamquarterhebrew: 0x05B9,

 27712   holamwidehebrew: 0x05B9,

 27713   honokhukthai: 0x0E2E,

 27714   hookabovecomb: 0x0309,

 27715   hookcmb: 0x0309,

 27716   hookpalatalizedbelowcmb: 0x0321,

 27717   hookretroflexbelowcmb: 0x0322,

 27718   hoonsquare: 0x3342,

 27719   horicoptic: 0x03E9,

 27720   horizontalbar: 0x2015,

 27721   horncmb: 0x031B,

 27722   hotsprings: 0x2668,

 27723   house: 0x2302,

 27724   hparen: 0x24A3,

 27725   hsuperior: 0x02B0,

 27726   hturned: 0x0265,

 27727   huhiragana: 0x3075,

 27728   huiitosquare: 0x3333,

 27729   hukatakana: 0x30D5,

 27730   hukatakanahalfwidth: 0xFF8C,

 27731   hungarumlaut: 0x02DD,

 27732   hungarumlautcmb: 0x030B,

 27733   hv: 0x0195,

 27734   hyphen: 0x002D,

 27735   hypheninferior: 0xF6E5,

 27736   hyphenmonospace: 0xFF0D,

 27737   hyphensmall: 0xFE63,

 27738   hyphensuperior: 0xF6E6,

 27739   hyphentwo: 0x2010,

 27740   i: 0x0069,

 27741   iacute: 0x00ED,

 27742   iacyrillic: 0x044F,

 27743   ibengali: 0x0987,

 27744   ibopomofo: 0x3127,

 27745   ibreve: 0x012D,

 27746   icaron: 0x01D0,

 27747   icircle: 0x24D8,

 27748   icircumflex: 0x00EE,

 27749   icyrillic: 0x0456,

 27750   idblgrave: 0x0209,

 27751   ideographearthcircle: 0x328F,

 27752   ideographfirecircle: 0x328B,

 27753   ideographicallianceparen: 0x323F,

 27754   ideographiccallparen: 0x323A,

 27755   ideographiccentrecircle: 0x32A5,

 27756   ideographicclose: 0x3006,

 27757   ideographiccomma: 0x3001,

 27758   ideographiccommaleft: 0xFF64,

 27759   ideographiccongratulationparen: 0x3237,

 27760   ideographiccorrectcircle: 0x32A3,

 27761   ideographicearthparen: 0x322F,

 27762   ideographicenterpriseparen: 0x323D,

 27763   ideographicexcellentcircle: 0x329D,

 27764   ideographicfestivalparen: 0x3240,

 27765   ideographicfinancialcircle: 0x3296,

 27766   ideographicfinancialparen: 0x3236,

 27767   ideographicfireparen: 0x322B,

 27768   ideographichaveparen: 0x3232,

 27769   ideographichighcircle: 0x32A4,

 27770   ideographiciterationmark: 0x3005,

 27771   ideographiclaborcircle: 0x3298,

 27772   ideographiclaborparen: 0x3238,

 27773   ideographicleftcircle: 0x32A7,

 27774   ideographiclowcircle: 0x32A6,

 27775   ideographicmedicinecircle: 0x32A9,

 27776   ideographicmetalparen: 0x322E,

 27777   ideographicmoonparen: 0x322A,

 27778   ideographicnameparen: 0x3234,

 27779   ideographicperiod: 0x3002,

 27780   ideographicprintcircle: 0x329E,

 27781   ideographicreachparen: 0x3243,

 27782   ideographicrepresentparen: 0x3239,

 27783   ideographicresourceparen: 0x323E,

 27784   ideographicrightcircle: 0x32A8,

 27785   ideographicsecretcircle: 0x3299,

 27786   ideographicselfparen: 0x3242,

 27787   ideographicsocietyparen: 0x3233,

 27788   ideographicspace: 0x3000,

 27789   ideographicspecialparen: 0x3235,

 27790   ideographicstockparen: 0x3231,

 27791   ideographicstudyparen: 0x323B,

 27792   ideographicsunparen: 0x3230,

 27793   ideographicsuperviseparen: 0x323C,

 27794   ideographicwaterparen: 0x322C,

 27795   ideographicwoodparen: 0x322D,

 27796   ideographiczero: 0x3007,

 27797   ideographmetalcircle: 0x328E,

 27798   ideographmooncircle: 0x328A,

 27799   ideographnamecircle: 0x3294,

 27800   ideographsuncircle: 0x3290,

 27801   ideographwatercircle: 0x328C,

 27802   ideographwoodcircle: 0x328D,

 27803   ideva: 0x0907,

 27804   idieresis: 0x00EF,

 27805   idieresisacute: 0x1E2F,

 27806   idieresiscyrillic: 0x04E5,

 27807   idotbelow: 0x1ECB,

 27808   iebrevecyrillic: 0x04D7,

 27809   iecyrillic: 0x0435,

 27810   ieungacirclekorean: 0x3275,

 27811   ieungaparenkorean: 0x3215,

 27812   ieungcirclekorean: 0x3267,

 27813   ieungkorean: 0x3147,

 27814   ieungparenkorean: 0x3207,

 27815   igrave: 0x00EC,

 27816   igujarati: 0x0A87,

 27817   igurmukhi: 0x0A07,

 27818   ihiragana: 0x3044,

 27819   ihookabove: 0x1EC9,

 27820   iibengali: 0x0988,

 27821   iicyrillic: 0x0438,

 27822   iideva: 0x0908,

 27823   iigujarati: 0x0A88,

 27824   iigurmukhi: 0x0A08,

 27825   iimatragurmukhi: 0x0A40,

 27826   iinvertedbreve: 0x020B,

 27827   iishortcyrillic: 0x0439,

 27828   iivowelsignbengali: 0x09C0,

 27829   iivowelsigndeva: 0x0940,

 27830   iivowelsigngujarati: 0x0AC0,

 27831   ij: 0x0133,

 27832   ikatakana: 0x30A4,

 27833   ikatakanahalfwidth: 0xFF72,

 27834   ikorean: 0x3163,

 27835   ilde: 0x02DC,

 27836   iluyhebrew: 0x05AC,

 27837   imacron: 0x012B,

 27838   imacroncyrillic: 0x04E3,

 27839   imageorapproximatelyequal: 0x2253,

 27840   imatragurmukhi: 0x0A3F,

 27841   imonospace: 0xFF49,

 27842   increment: 0x2206,

 27843   infinity: 0x221E,

 27844   iniarmenian: 0x056B,

 27845   integral: 0x222B,

 27846   integralbottom: 0x2321,

 27847   integralbt: 0x2321,

 27848   integralex: 0xF8F5,

 27849   integraltop: 0x2320,

 27850   integraltp: 0x2320,

 27851   intersection: 0x2229,

 27852   intisquare: 0x3305,

 27853   invbullet: 0x25D8,

 27854   invcircle: 0x25D9,

 27855   invsmileface: 0x263B,

 27856   iocyrillic: 0x0451,

 27857   iogonek: 0x012F,

 27858   iota: 0x03B9,

 27859   iotadieresis: 0x03CA,

 27860   iotadieresistonos: 0x0390,

 27861   iotalatin: 0x0269,

 27862   iotatonos: 0x03AF,

 27863   iparen: 0x24A4,

 27864   irigurmukhi: 0x0A72,

 27865   ismallhiragana: 0x3043,

 27866   ismallkatakana: 0x30A3,

 27867   ismallkatakanahalfwidth: 0xFF68,

 27868   issharbengali: 0x09FA,

 27869   istroke: 0x0268,

 27870   isuperior: 0xF6ED,

 27871   iterationhiragana: 0x309D,

 27872   iterationkatakana: 0x30FD,

 27873   itilde: 0x0129,

 27874   itildebelow: 0x1E2D,

 27875   iubopomofo: 0x3129,

 27876   iucyrillic: 0x044E,

 27877   ivowelsignbengali: 0x09BF,

 27878   ivowelsigndeva: 0x093F,

 27879   ivowelsigngujarati: 0x0ABF,

 27880   izhitsacyrillic: 0x0475,

 27881   izhitsadblgravecyrillic: 0x0477,

 27882   j: 0x006A,

 27883   jaarmenian: 0x0571,

 27884   jabengali: 0x099C,

 27885   jadeva: 0x091C,

 27886   jagujarati: 0x0A9C,

 27887   jagurmukhi: 0x0A1C,

 27888   jbopomofo: 0x3110,

 27889   jcaron: 0x01F0,

 27890   jcircle: 0x24D9,

 27891   jcircumflex: 0x0135,

 27892   jcrossedtail: 0x029D,

 27893   jdotlessstroke: 0x025F,

 27894   jecyrillic: 0x0458,

 27895   jeemarabic: 0x062C,

 27896   jeemfinalarabic: 0xFE9E,

 27897   jeeminitialarabic: 0xFE9F,

 27898   jeemmedialarabic: 0xFEA0,

 27899   jeharabic: 0x0698,

 27900   jehfinalarabic: 0xFB8B,

 27901   jhabengali: 0x099D,

 27902   jhadeva: 0x091D,

 27903   jhagujarati: 0x0A9D,

 27904   jhagurmukhi: 0x0A1D,

 27905   jheharmenian: 0x057B,

 27906   jis: 0x3004,

 27907   jmonospace: 0xFF4A,

 27908   jparen: 0x24A5,

 27909   jsuperior: 0x02B2,

 27910   k: 0x006B,

 27911   kabashkircyrillic: 0x04A1,

 27912   kabengali: 0x0995,

 27913   kacute: 0x1E31,

 27914   kacyrillic: 0x043A,

 27915   kadescendercyrillic: 0x049B,

 27916   kadeva: 0x0915,

 27917   kaf: 0x05DB,

 27918   kafarabic: 0x0643,

 27919   kafdagesh: 0xFB3B,

 27920   kafdageshhebrew: 0xFB3B,

 27921   kaffinalarabic: 0xFEDA,

 27922   kafhebrew: 0x05DB,

 27923   kafinitialarabic: 0xFEDB,

 27924   kafmedialarabic: 0xFEDC,

 27925   kafrafehebrew: 0xFB4D,

 27926   kagujarati: 0x0A95,

 27927   kagurmukhi: 0x0A15,

 27928   kahiragana: 0x304B,

 27929   kahookcyrillic: 0x04C4,

 27930   kakatakana: 0x30AB,

 27931   kakatakanahalfwidth: 0xFF76,

 27932   kappa: 0x03BA,

 27933   kappasymbolgreek: 0x03F0,

 27934   kapyeounmieumkorean: 0x3171,

 27935   kapyeounphieuphkorean: 0x3184,

 27936   kapyeounpieupkorean: 0x3178,

 27937   kapyeounssangpieupkorean: 0x3179,

 27938   karoriisquare: 0x330D,

 27939   kashidaautoarabic: 0x0640,

 27940   kashidaautonosidebearingarabic: 0x0640,

 27941   kasmallkatakana: 0x30F5,

 27942   kasquare: 0x3384,

 27943   kasraarabic: 0x0650,

 27944   kasratanarabic: 0x064D,

 27945   kastrokecyrillic: 0x049F,

 27946   katahiraprolongmarkhalfwidth: 0xFF70,

 27947   kaverticalstrokecyrillic: 0x049D,

 27948   kbopomofo: 0x310E,

 27949   kcalsquare: 0x3389,

 27950   kcaron: 0x01E9,

 27951   kcedilla: 0x0137,

 27952   kcircle: 0x24DA,

 27953   kcommaaccent: 0x0137,

 27954   kdotbelow: 0x1E33,

 27955   keharmenian: 0x0584,

 27956   kehiragana: 0x3051,

 27957   kekatakana: 0x30B1,

 27958   kekatakanahalfwidth: 0xFF79,

 27959   kenarmenian: 0x056F,

 27960   kesmallkatakana: 0x30F6,

 27961   kgreenlandic: 0x0138,

 27962   khabengali: 0x0996,

 27963   khacyrillic: 0x0445,

 27964   khadeva: 0x0916,

 27965   khagujarati: 0x0A96,

 27966   khagurmukhi: 0x0A16,

 27967   khaharabic: 0x062E,

 27968   khahfinalarabic: 0xFEA6,

 27969   khahinitialarabic: 0xFEA7,

 27970   khahmedialarabic: 0xFEA8,

 27971   kheicoptic: 0x03E7,

 27972   khhadeva: 0x0959,

 27973   khhagurmukhi: 0x0A59,

 27974   khieukhacirclekorean: 0x3278,

 27975   khieukhaparenkorean: 0x3218,

 27976   khieukhcirclekorean: 0x326A,

 27977   khieukhkorean: 0x314B,

 27978   khieukhparenkorean: 0x320A,

 27979   khokhaithai: 0x0E02,

 27980   khokhonthai: 0x0E05,

 27981   khokhuatthai: 0x0E03,

 27982   khokhwaithai: 0x0E04,

 27983   khomutthai: 0x0E5B,

 27984   khook: 0x0199,

 27985   khorakhangthai: 0x0E06,

 27986   khzsquare: 0x3391,

 27987   kihiragana: 0x304D,

 27988   kikatakana: 0x30AD,

 27989   kikatakanahalfwidth: 0xFF77,

 27990   kiroguramusquare: 0x3315,

 27991   kiromeetorusquare: 0x3316,

 27992   kirosquare: 0x3314,

 27993   kiyeokacirclekorean: 0x326E,

 27994   kiyeokaparenkorean: 0x320E,

 27995   kiyeokcirclekorean: 0x3260,

 27996   kiyeokkorean: 0x3131,

 27997   kiyeokparenkorean: 0x3200,

 27998   kiyeoksioskorean: 0x3133,

 27999   kjecyrillic: 0x045C,

 28000   klinebelow: 0x1E35,

 28001   klsquare: 0x3398,

 28002   kmcubedsquare: 0x33A6,

 28003   kmonospace: 0xFF4B,

 28004   kmsquaredsquare: 0x33A2,

 28005   kohiragana: 0x3053,

 28006   kohmsquare: 0x33C0,

 28007   kokaithai: 0x0E01,

 28008   kokatakana: 0x30B3,

 28009   kokatakanahalfwidth: 0xFF7A,

 28010   kooposquare: 0x331E,

 28011   koppacyrillic: 0x0481,

 28012   koreanstandardsymbol: 0x327F,

 28013   koroniscmb: 0x0343,

 28014   kparen: 0x24A6,

 28015   kpasquare: 0x33AA,

 28016   ksicyrillic: 0x046F,

 28017   ktsquare: 0x33CF,

 28018   kturned: 0x029E,

 28019   kuhiragana: 0x304F,

 28020   kukatakana: 0x30AF,

 28021   kukatakanahalfwidth: 0xFF78,

 28022   kvsquare: 0x33B8,

 28023   kwsquare: 0x33BE,

 28024   l: 0x006C,

 28025   labengali: 0x09B2,

 28026   lacute: 0x013A,

 28027   ladeva: 0x0932,

 28028   lagujarati: 0x0AB2,

 28029   lagurmukhi: 0x0A32,

 28030   lakkhangyaothai: 0x0E45,

 28031   lamaleffinalarabic: 0xFEFC,

 28032   lamalefhamzaabovefinalarabic: 0xFEF8,

 28033   lamalefhamzaaboveisolatedarabic: 0xFEF7,

 28034   lamalefhamzabelowfinalarabic: 0xFEFA,

 28035   lamalefhamzabelowisolatedarabic: 0xFEF9,

 28036   lamalefisolatedarabic: 0xFEFB,

 28037   lamalefmaddaabovefinalarabic: 0xFEF6,

 28038   lamalefmaddaaboveisolatedarabic: 0xFEF5,

 28039   lamarabic: 0x0644,

 28040   lambda: 0x03BB,

 28041   lambdastroke: 0x019B,

 28042   lamed: 0x05DC,

 28043   lameddagesh: 0xFB3C,

 28044   lameddageshhebrew: 0xFB3C,

 28045   lamedhebrew: 0x05DC,

 28046   lamfinalarabic: 0xFEDE,

 28047   lamhahinitialarabic: 0xFCCA,

 28048   laminitialarabic: 0xFEDF,

 28049   lamjeeminitialarabic: 0xFCC9,

 28050   lamkhahinitialarabic: 0xFCCB,

 28051   lamlamhehisolatedarabic: 0xFDF2,

 28052   lammedialarabic: 0xFEE0,

 28053   lammeemhahinitialarabic: 0xFD88,

 28054   lammeeminitialarabic: 0xFCCC,

 28055   largecircle: 0x25EF,

 28056   lbar: 0x019A,

 28057   lbelt: 0x026C,

 28058   lbopomofo: 0x310C,

 28059   lcaron: 0x013E,

 28060   lcedilla: 0x013C,

 28061   lcircle: 0x24DB,

 28062   lcircumflexbelow: 0x1E3D,

 28063   lcommaaccent: 0x013C,

 28064   ldot: 0x0140,

 28065   ldotaccent: 0x0140,

 28066   ldotbelow: 0x1E37,

 28067   ldotbelowmacron: 0x1E39,

 28068   leftangleabovecmb: 0x031A,

 28069   lefttackbelowcmb: 0x0318,

 28070   less: 0x003C,

 28071   lessequal: 0x2264,

 28072   lessequalorgreater: 0x22DA,

 28073   lessmonospace: 0xFF1C,

 28074   lessorequivalent: 0x2272,

 28075   lessorgreater: 0x2276,

 28076   lessoverequal: 0x2266,

 28077   lesssmall: 0xFE64,

 28078   lezh: 0x026E,

 28079   lfblock: 0x258C,

 28080   lhookretroflex: 0x026D,

 28081   lira: 0x20A4,

 28082   liwnarmenian: 0x056C,

 28083   lj: 0x01C9,

 28084   ljecyrillic: 0x0459,

 28085   ll: 0xF6C0,

 28086   lladeva: 0x0933,

 28087   llagujarati: 0x0AB3,

 28088   llinebelow: 0x1E3B,

 28089   llladeva: 0x0934,

 28090   llvocalicbengali: 0x09E1,

 28091   llvocalicdeva: 0x0961,

 28092   llvocalicvowelsignbengali: 0x09E3,

 28093   llvocalicvowelsigndeva: 0x0963,

 28094   lmiddletilde: 0x026B,

 28095   lmonospace: 0xFF4C,

 28096   lmsquare: 0x33D0,

 28097   lochulathai: 0x0E2C,

 28098   logicaland: 0x2227,

 28099   logicalnot: 0x00AC,

 28100   logicalnotreversed: 0x2310,

 28101   logicalor: 0x2228,

 28102   lolingthai: 0x0E25,

 28103   longs: 0x017F,

 28104   lowlinecenterline: 0xFE4E,

 28105   lowlinecmb: 0x0332,

 28106   lowlinedashed: 0xFE4D,

 28107   lozenge: 0x25CA,

 28108   lparen: 0x24A7,

 28109   lslash: 0x0142,

 28110   lsquare: 0x2113,

 28111   lsuperior: 0xF6EE,

 28112   ltshade: 0x2591,

 28113   luthai: 0x0E26,

 28114   lvocalicbengali: 0x098C,

 28115   lvocalicdeva: 0x090C,

 28116   lvocalicvowelsignbengali: 0x09E2,

 28117   lvocalicvowelsigndeva: 0x0962,

 28118   lxsquare: 0x33D3,

 28119   m: 0x006D,

 28120   mabengali: 0x09AE,

 28121   macron: 0x00AF,

 28122   macronbelowcmb: 0x0331,

 28123   macroncmb: 0x0304,

 28124   macronlowmod: 0x02CD,

 28125   macronmonospace: 0xFFE3,

 28126   macute: 0x1E3F,

 28127   madeva: 0x092E,

 28128   magujarati: 0x0AAE,

 28129   magurmukhi: 0x0A2E,

 28130   mahapakhhebrew: 0x05A4,

 28131   mahapakhlefthebrew: 0x05A4,

 28132   mahiragana: 0x307E,

 28133   maichattawalowleftthai: 0xF895,

 28134   maichattawalowrightthai: 0xF894,

 28135   maichattawathai: 0x0E4B,

 28136   maichattawaupperleftthai: 0xF893,

 28137   maieklowleftthai: 0xF88C,

 28138   maieklowrightthai: 0xF88B,

 28139   maiekthai: 0x0E48,

 28140   maiekupperleftthai: 0xF88A,

 28141   maihanakatleftthai: 0xF884,

 28142   maihanakatthai: 0x0E31,

 28143   maitaikhuleftthai: 0xF889,

 28144   maitaikhuthai: 0x0E47,

 28145   maitholowleftthai: 0xF88F,

 28146   maitholowrightthai: 0xF88E,

 28147   maithothai: 0x0E49,

 28148   maithoupperleftthai: 0xF88D,

 28149   maitrilowleftthai: 0xF892,

 28150   maitrilowrightthai: 0xF891,

 28151   maitrithai: 0x0E4A,

 28152   maitriupperleftthai: 0xF890,

 28153   maiyamokthai: 0x0E46,

 28154   makatakana: 0x30DE,

 28155   makatakanahalfwidth: 0xFF8F,

 28156   male: 0x2642,

 28157   mansyonsquare: 0x3347,

 28158   maqafhebrew: 0x05BE,

 28159   mars: 0x2642,

 28160   masoracirclehebrew: 0x05AF,

 28161   masquare: 0x3383,

 28162   mbopomofo: 0x3107,

 28163   mbsquare: 0x33D4,

 28164   mcircle: 0x24DC,

 28165   mcubedsquare: 0x33A5,

 28166   mdotaccent: 0x1E41,

 28167   mdotbelow: 0x1E43,

 28168   meemarabic: 0x0645,

 28169   meemfinalarabic: 0xFEE2,

 28170   meeminitialarabic: 0xFEE3,

 28171   meemmedialarabic: 0xFEE4,

 28172   meemmeeminitialarabic: 0xFCD1,

 28173   meemmeemisolatedarabic: 0xFC48,

 28174   meetorusquare: 0x334D,

 28175   mehiragana: 0x3081,

 28176   meizierasquare: 0x337E,

 28177   mekatakana: 0x30E1,

 28178   mekatakanahalfwidth: 0xFF92,

 28179   mem: 0x05DE,

 28180   memdagesh: 0xFB3E,

 28181   memdageshhebrew: 0xFB3E,

 28182   memhebrew: 0x05DE,

 28183   menarmenian: 0x0574,

 28184   merkhahebrew: 0x05A5,

 28185   merkhakefulahebrew: 0x05A6,

 28186   merkhakefulalefthebrew: 0x05A6,

 28187   merkhalefthebrew: 0x05A5,

 28188   mhook: 0x0271,

 28189   mhzsquare: 0x3392,

 28190   middledotkatakanahalfwidth: 0xFF65,

 28191   middot: 0x00B7,

 28192   mieumacirclekorean: 0x3272,

 28193   mieumaparenkorean: 0x3212,

 28194   mieumcirclekorean: 0x3264,

 28195   mieumkorean: 0x3141,

 28196   mieumpansioskorean: 0x3170,

 28197   mieumparenkorean: 0x3204,

 28198   mieumpieupkorean: 0x316E,

 28199   mieumsioskorean: 0x316F,

 28200   mihiragana: 0x307F,

 28201   mikatakana: 0x30DF,

 28202   mikatakanahalfwidth: 0xFF90,

 28203   minus: 0x2212,

 28204   minusbelowcmb: 0x0320,

 28205   minuscircle: 0x2296,

 28206   minusmod: 0x02D7,

 28207   minusplus: 0x2213,

 28208   minute: 0x2032,

 28209   miribaarusquare: 0x334A,

 28210   mirisquare: 0x3349,

 28211   mlonglegturned: 0x0270,

 28212   mlsquare: 0x3396,

 28213   mmcubedsquare: 0x33A3,

 28214   mmonospace: 0xFF4D,

 28215   mmsquaredsquare: 0x339F,

 28216   mohiragana: 0x3082,

 28217   mohmsquare: 0x33C1,

 28218   mokatakana: 0x30E2,

 28219   mokatakanahalfwidth: 0xFF93,

 28220   molsquare: 0x33D6,

 28221   momathai: 0x0E21,

 28222   moverssquare: 0x33A7,

 28223   moverssquaredsquare: 0x33A8,

 28224   mparen: 0x24A8,

 28225   mpasquare: 0x33AB,

 28226   mssquare: 0x33B3,

 28227   msuperior: 0xF6EF,

 28228   mturned: 0x026F,

 28229   mu: 0x00B5,

 28230   mu1: 0x00B5,

 28231   muasquare: 0x3382,

 28232   muchgreater: 0x226B,

 28233   muchless: 0x226A,

 28234   mufsquare: 0x338C,

 28235   mugreek: 0x03BC,

 28236   mugsquare: 0x338D,

 28237   muhiragana: 0x3080,

 28238   mukatakana: 0x30E0,

 28239   mukatakanahalfwidth: 0xFF91,

 28240   mulsquare: 0x3395,

 28241   multiply: 0x00D7,

 28242   mumsquare: 0x339B,

 28243   munahhebrew: 0x05A3,

 28244   munahlefthebrew: 0x05A3,

 28245   musicalnote: 0x266A,

 28246   musicalnotedbl: 0x266B,

 28247   musicflatsign: 0x266D,

 28248   musicsharpsign: 0x266F,

 28249   mussquare: 0x33B2,

 28250   muvsquare: 0x33B6,

 28251   muwsquare: 0x33BC,

 28252   mvmegasquare: 0x33B9,

 28253   mvsquare: 0x33B7,

 28254   mwmegasquare: 0x33BF,

 28255   mwsquare: 0x33BD,

 28256   n: 0x006E,

 28257   nabengali: 0x09A8,

 28258   nabla: 0x2207,

 28259   nacute: 0x0144,

 28260   nadeva: 0x0928,

 28261   nagujarati: 0x0AA8,

 28262   nagurmukhi: 0x0A28,

 28263   nahiragana: 0x306A,

 28264   nakatakana: 0x30CA,

 28265   nakatakanahalfwidth: 0xFF85,

 28266   napostrophe: 0x0149,

 28267   nasquare: 0x3381,

 28268   nbopomofo: 0x310B,

 28269   nbspace: 0x00A0,

 28270   ncaron: 0x0148,

 28271   ncedilla: 0x0146,

 28272   ncircle: 0x24DD,

 28273   ncircumflexbelow: 0x1E4B,

 28274   ncommaaccent: 0x0146,

 28275   ndotaccent: 0x1E45,

 28276   ndotbelow: 0x1E47,

 28277   nehiragana: 0x306D,

 28278   nekatakana: 0x30CD,

 28279   nekatakanahalfwidth: 0xFF88,

 28280   newsheqelsign: 0x20AA,

 28281   nfsquare: 0x338B,

 28282   ngabengali: 0x0999,

 28283   ngadeva: 0x0919,

 28284   ngagujarati: 0x0A99,

 28285   ngagurmukhi: 0x0A19,

 28286   ngonguthai: 0x0E07,

 28287   nhiragana: 0x3093,

 28288   nhookleft: 0x0272,

 28289   nhookretroflex: 0x0273,

 28290   nieunacirclekorean: 0x326F,

 28291   nieunaparenkorean: 0x320F,

 28292   nieuncieuckorean: 0x3135,

 28293   nieuncirclekorean: 0x3261,

 28294   nieunhieuhkorean: 0x3136,

 28295   nieunkorean: 0x3134,

 28296   nieunpansioskorean: 0x3168,

 28297   nieunparenkorean: 0x3201,

 28298   nieunsioskorean: 0x3167,

 28299   nieuntikeutkorean: 0x3166,

 28300   nihiragana: 0x306B,

 28301   nikatakana: 0x30CB,

 28302   nikatakanahalfwidth: 0xFF86,

 28303   nikhahitleftthai: 0xF899,

 28304   nikhahitthai: 0x0E4D,

 28305   nine: 0x0039,

 28306   ninearabic: 0x0669,

 28307   ninebengali: 0x09EF,

 28308   ninecircle: 0x2468,

 28309   ninecircleinversesansserif: 0x2792,

 28310   ninedeva: 0x096F,

 28311   ninegujarati: 0x0AEF,

 28312   ninegurmukhi: 0x0A6F,

 28313   ninehackarabic: 0x0669,

 28314   ninehangzhou: 0x3029,

 28315   nineideographicparen: 0x3228,

 28316   nineinferior: 0x2089,

 28317   ninemonospace: 0xFF19,

 28318   nineoldstyle: 0xF739,

 28319   nineparen: 0x247C,

 28320   nineperiod: 0x2490,

 28321   ninepersian: 0x06F9,

 28322   nineroman: 0x2178,

 28323   ninesuperior: 0x2079,

 28324   nineteencircle: 0x2472,

 28325   nineteenparen: 0x2486,

 28326   nineteenperiod: 0x249A,

 28327   ninethai: 0x0E59,

 28328   nj: 0x01CC,

 28329   njecyrillic: 0x045A,

 28330   nkatakana: 0x30F3,

 28331   nkatakanahalfwidth: 0xFF9D,

 28332   nlegrightlong: 0x019E,

 28333   nlinebelow: 0x1E49,

 28334   nmonospace: 0xFF4E,

 28335   nmsquare: 0x339A,

 28336   nnabengali: 0x09A3,

 28337   nnadeva: 0x0923,

 28338   nnagujarati: 0x0AA3,

 28339   nnagurmukhi: 0x0A23,

 28340   nnnadeva: 0x0929,

 28341   nohiragana: 0x306E,

 28342   nokatakana: 0x30CE,

 28343   nokatakanahalfwidth: 0xFF89,

 28344   nonbreakingspace: 0x00A0,

 28345   nonenthai: 0x0E13,

 28346   nonuthai: 0x0E19,

 28347   noonarabic: 0x0646,

 28348   noonfinalarabic: 0xFEE6,

 28349   noonghunnaarabic: 0x06BA,

 28350   noonghunnafinalarabic: 0xFB9F,

 28351   nooninitialarabic: 0xFEE7,

 28352   noonjeeminitialarabic: 0xFCD2,

 28353   noonjeemisolatedarabic: 0xFC4B,

 28354   noonmedialarabic: 0xFEE8,

 28355   noonmeeminitialarabic: 0xFCD5,

 28356   noonmeemisolatedarabic: 0xFC4E,

 28357   noonnoonfinalarabic: 0xFC8D,

 28358   notcontains: 0x220C,

 28359   notelement: 0x2209,

 28360   notelementof: 0x2209,

 28361   notequal: 0x2260,

 28362   notgreater: 0x226F,

 28363   notgreaternorequal: 0x2271,

 28364   notgreaternorless: 0x2279,

 28365   notidentical: 0x2262,

 28366   notless: 0x226E,

 28367   notlessnorequal: 0x2270,

 28368   notparallel: 0x2226,

 28369   notprecedes: 0x2280,

 28370   notsubset: 0x2284,

 28371   notsucceeds: 0x2281,

 28372   notsuperset: 0x2285,

 28373   nowarmenian: 0x0576,

 28374   nparen: 0x24A9,

 28375   nssquare: 0x33B1,

 28376   nsuperior: 0x207F,

 28377   ntilde: 0x00F1,

 28378   nu: 0x03BD,

 28379   nuhiragana: 0x306C,

 28380   nukatakana: 0x30CC,

 28381   nukatakanahalfwidth: 0xFF87,

 28382   nuktabengali: 0x09BC,

 28383   nuktadeva: 0x093C,

 28384   nuktagujarati: 0x0ABC,

 28385   nuktagurmukhi: 0x0A3C,

 28386   numbersign: 0x0023,

 28387   numbersignmonospace: 0xFF03,

 28388   numbersignsmall: 0xFE5F,

 28389   numeralsigngreek: 0x0374,

 28390   numeralsignlowergreek: 0x0375,

 28391   numero: 0x2116,

 28392   nun: 0x05E0,

 28393   nundagesh: 0xFB40,

 28394   nundageshhebrew: 0xFB40,

 28395   nunhebrew: 0x05E0,

 28396   nvsquare: 0x33B5,

 28397   nwsquare: 0x33BB,

 28398   nyabengali: 0x099E,

 28399   nyadeva: 0x091E,

 28400   nyagujarati: 0x0A9E,

 28401   nyagurmukhi: 0x0A1E,

 28402   o: 0x006F,

 28403   oacute: 0x00F3,

 28404   oangthai: 0x0E2D,

 28405   obarred: 0x0275,

 28406   obarredcyrillic: 0x04E9,

 28407   obarreddieresiscyrillic: 0x04EB,

 28408   obengali: 0x0993,

 28409   obopomofo: 0x311B,

 28410   obreve: 0x014F,

 28411   ocandradeva: 0x0911,

 28412   ocandragujarati: 0x0A91,

 28413   ocandravowelsigndeva: 0x0949,

 28414   ocandravowelsigngujarati: 0x0AC9,

 28415   ocaron: 0x01D2,

 28416   ocircle: 0x24DE,

 28417   ocircumflex: 0x00F4,

 28418   ocircumflexacute: 0x1ED1,

 28419   ocircumflexdotbelow: 0x1ED9,

 28420   ocircumflexgrave: 0x1ED3,

 28421   ocircumflexhookabove: 0x1ED5,

 28422   ocircumflextilde: 0x1ED7,

 28423   ocyrillic: 0x043E,

 28424   odblacute: 0x0151,

 28425   odblgrave: 0x020D,

 28426   odeva: 0x0913,

 28427   odieresis: 0x00F6,

 28428   odieresiscyrillic: 0x04E7,

 28429   odotbelow: 0x1ECD,

 28430   oe: 0x0153,

 28431   oekorean: 0x315A,

 28432   ogonek: 0x02DB,

 28433   ogonekcmb: 0x0328,

 28434   ograve: 0x00F2,

 28435   ogujarati: 0x0A93,

 28436   oharmenian: 0x0585,

 28437   ohiragana: 0x304A,

 28438   ohookabove: 0x1ECF,

 28439   ohorn: 0x01A1,

 28440   ohornacute: 0x1EDB,

 28441   ohorndotbelow: 0x1EE3,

 28442   ohorngrave: 0x1EDD,

 28443   ohornhookabove: 0x1EDF,

 28444   ohorntilde: 0x1EE1,

 28445   ohungarumlaut: 0x0151,

 28446   oi: 0x01A3,

 28447   oinvertedbreve: 0x020F,

 28448   okatakana: 0x30AA,

 28449   okatakanahalfwidth: 0xFF75,

 28450   okorean: 0x3157,

 28451   olehebrew: 0x05AB,

 28452   omacron: 0x014D,

 28453   omacronacute: 0x1E53,

 28454   omacrongrave: 0x1E51,

 28455   omdeva: 0x0950,

 28456   omega: 0x03C9,

 28457   omega1: 0x03D6,

 28458   omegacyrillic: 0x0461,

 28459   omegalatinclosed: 0x0277,

 28460   omegaroundcyrillic: 0x047B,

 28461   omegatitlocyrillic: 0x047D,

 28462   omegatonos: 0x03CE,

 28463   omgujarati: 0x0AD0,

 28464   omicron: 0x03BF,

 28465   omicrontonos: 0x03CC,

 28466   omonospace: 0xFF4F,

 28467   one: 0x0031,

 28468   onearabic: 0x0661,

 28469   onebengali: 0x09E7,

 28470   onecircle: 0x2460,

 28471   onecircleinversesansserif: 0x278A,

 28472   onedeva: 0x0967,

 28473   onedotenleader: 0x2024,

 28474   oneeighth: 0x215B,

 28475   onefitted: 0xF6DC,

 28476   onegujarati: 0x0AE7,

 28477   onegurmukhi: 0x0A67,

 28478   onehackarabic: 0x0661,

 28479   onehalf: 0x00BD,

 28480   onehangzhou: 0x3021,

 28481   oneideographicparen: 0x3220,

 28482   oneinferior: 0x2081,

 28483   onemonospace: 0xFF11,

 28484   onenumeratorbengali: 0x09F4,

 28485   oneoldstyle: 0xF731,

 28486   oneparen: 0x2474,

 28487   oneperiod: 0x2488,

 28488   onepersian: 0x06F1,

 28489   onequarter: 0x00BC,

 28490   oneroman: 0x2170,

 28491   onesuperior: 0x00B9,

 28492   onethai: 0x0E51,

 28493   onethird: 0x2153,

 28494   oogonek: 0x01EB,

 28495   oogonekmacron: 0x01ED,

 28496   oogurmukhi: 0x0A13,

 28497   oomatragurmukhi: 0x0A4B,

 28498   oopen: 0x0254,

 28499   oparen: 0x24AA,

 28500   openbullet: 0x25E6,

 28501   option: 0x2325,

 28502   ordfeminine: 0x00AA,

 28503   ordmasculine: 0x00BA,

 28504   orthogonal: 0x221F,

 28505   oshortdeva: 0x0912,

 28506   oshortvowelsigndeva: 0x094A,

 28507   oslash: 0x00F8,

 28508   oslashacute: 0x01FF,

 28509   osmallhiragana: 0x3049,

 28510   osmallkatakana: 0x30A9,

 28511   osmallkatakanahalfwidth: 0xFF6B,

 28512   ostrokeacute: 0x01FF,

 28513   osuperior: 0xF6F0,

 28514   otcyrillic: 0x047F,

 28515   otilde: 0x00F5,

 28516   otildeacute: 0x1E4D,

 28517   otildedieresis: 0x1E4F,

 28518   oubopomofo: 0x3121,

 28519   overline: 0x203E,

 28520   overlinecenterline: 0xFE4A,

 28521   overlinecmb: 0x0305,

 28522   overlinedashed: 0xFE49,

 28523   overlinedblwavy: 0xFE4C,

 28524   overlinewavy: 0xFE4B,

 28525   overscore: 0x00AF,

 28526   ovowelsignbengali: 0x09CB,

 28527   ovowelsigndeva: 0x094B,

 28528   ovowelsigngujarati: 0x0ACB,

 28529   p: 0x0070,

 28530   paampssquare: 0x3380,

 28531   paasentosquare: 0x332B,

 28532   pabengali: 0x09AA,

 28533   pacute: 0x1E55,

 28534   padeva: 0x092A,

 28535   pagedown: 0x21DF,

 28536   pageup: 0x21DE,

 28537   pagujarati: 0x0AAA,

 28538   pagurmukhi: 0x0A2A,

 28539   pahiragana: 0x3071,

 28540   paiyannoithai: 0x0E2F,

 28541   pakatakana: 0x30D1,

 28542   palatalizationcyrilliccmb: 0x0484,

 28543   palochkacyrillic: 0x04C0,

 28544   pansioskorean: 0x317F,

 28545   paragraph: 0x00B6,

 28546   parallel: 0x2225,

 28547   parenleft: 0x0028,

 28548   parenleftaltonearabic: 0xFD3E,

 28549   parenleftbt: 0xF8ED,

 28550   parenleftex: 0xF8EC,

 28551   parenleftinferior: 0x208D,

 28552   parenleftmonospace: 0xFF08,

 28553   parenleftsmall: 0xFE59,

 28554   parenleftsuperior: 0x207D,

 28555   parenlefttp: 0xF8EB,

 28556   parenleftvertical: 0xFE35,

 28557   parenright: 0x0029,

 28558   parenrightaltonearabic: 0xFD3F,

 28559   parenrightbt: 0xF8F8,

 28560   parenrightex: 0xF8F7,

 28561   parenrightinferior: 0x208E,

 28562   parenrightmonospace: 0xFF09,

 28563   parenrightsmall: 0xFE5A,

 28564   parenrightsuperior: 0x207E,

 28565   parenrighttp: 0xF8F6,

 28566   parenrightvertical: 0xFE36,

 28567   partialdiff: 0x2202,

 28568   paseqhebrew: 0x05C0,

 28569   pashtahebrew: 0x0599,

 28570   pasquare: 0x33A9,

 28571   patah: 0x05B7,

 28572   patah11: 0x05B7,

 28573   patah1d: 0x05B7,

 28574   patah2a: 0x05B7,

 28575   patahhebrew: 0x05B7,

 28576   patahnarrowhebrew: 0x05B7,

 28577   patahquarterhebrew: 0x05B7,

 28578   patahwidehebrew: 0x05B7,

 28579   pazerhebrew: 0x05A1,

 28580   pbopomofo: 0x3106,

 28581   pcircle: 0x24DF,

 28582   pdotaccent: 0x1E57,

 28583   pe: 0x05E4,

 28584   pecyrillic: 0x043F,

 28585   pedagesh: 0xFB44,

 28586   pedageshhebrew: 0xFB44,

 28587   peezisquare: 0x333B,

 28588   pefinaldageshhebrew: 0xFB43,

 28589   peharabic: 0x067E,

 28590   peharmenian: 0x057A,

 28591   pehebrew: 0x05E4,

 28592   pehfinalarabic: 0xFB57,

 28593   pehinitialarabic: 0xFB58,

 28594   pehiragana: 0x307A,

 28595   pehmedialarabic: 0xFB59,

 28596   pekatakana: 0x30DA,

 28597   pemiddlehookcyrillic: 0x04A7,

 28598   perafehebrew: 0xFB4E,

 28599   percent: 0x0025,

 28600   percentarabic: 0x066A,

 28601   percentmonospace: 0xFF05,

 28602   percentsmall: 0xFE6A,

 28603   period: 0x002E,

 28604   periodarmenian: 0x0589,

 28605   periodcentered: 0x00B7,

 28606   periodhalfwidth: 0xFF61,

 28607   periodinferior: 0xF6E7,

 28608   periodmonospace: 0xFF0E,

 28609   periodsmall: 0xFE52,

 28610   periodsuperior: 0xF6E8,

 28611   perispomenigreekcmb: 0x0342,

 28612   perpendicular: 0x22A5,

 28613   perthousand: 0x2030,

 28614   peseta: 0x20A7,

 28615   pfsquare: 0x338A,

 28616   phabengali: 0x09AB,

 28617   phadeva: 0x092B,

 28618   phagujarati: 0x0AAB,

 28619   phagurmukhi: 0x0A2B,

 28620   phi: 0x03C6,

 28621   phi1: 0x03D5,

 28622   phieuphacirclekorean: 0x327A,

 28623   phieuphaparenkorean: 0x321A,

 28624   phieuphcirclekorean: 0x326C,

 28625   phieuphkorean: 0x314D,

 28626   phieuphparenkorean: 0x320C,

 28627   philatin: 0x0278,

 28628   phinthuthai: 0x0E3A,

 28629   phisymbolgreek: 0x03D5,

 28630   phook: 0x01A5,

 28631   phophanthai: 0x0E1E,

 28632   phophungthai: 0x0E1C,

 28633   phosamphaothai: 0x0E20,

 28634   pi: 0x03C0,

 28635   pieupacirclekorean: 0x3273,

 28636   pieupaparenkorean: 0x3213,

 28637   pieupcieuckorean: 0x3176,

 28638   pieupcirclekorean: 0x3265,

 28639   pieupkiyeokkorean: 0x3172,

 28640   pieupkorean: 0x3142,

 28641   pieupparenkorean: 0x3205,

 28642   pieupsioskiyeokkorean: 0x3174,

 28643   pieupsioskorean: 0x3144,

 28644   pieupsiostikeutkorean: 0x3175,

 28645   pieupthieuthkorean: 0x3177,

 28646   pieuptikeutkorean: 0x3173,

 28647   pihiragana: 0x3074,

 28648   pikatakana: 0x30D4,

 28649   pisymbolgreek: 0x03D6,

 28650   piwrarmenian: 0x0583,

 28651   plus: 0x002B,

 28652   plusbelowcmb: 0x031F,

 28653   pluscircle: 0x2295,

 28654   plusminus: 0x00B1,

 28655   plusmod: 0x02D6,

 28656   plusmonospace: 0xFF0B,

 28657   plussmall: 0xFE62,

 28658   plussuperior: 0x207A,

 28659   pmonospace: 0xFF50,

 28660   pmsquare: 0x33D8,

 28661   pohiragana: 0x307D,

 28662   pointingindexdownwhite: 0x261F,

 28663   pointingindexleftwhite: 0x261C,

 28664   pointingindexrightwhite: 0x261E,

 28665   pointingindexupwhite: 0x261D,

 28666   pokatakana: 0x30DD,

 28667   poplathai: 0x0E1B,

 28668   postalmark: 0x3012,

 28669   postalmarkface: 0x3020,

 28670   pparen: 0x24AB,

 28671   precedes: 0x227A,

 28672   prescription: 0x211E,

 28673   primemod: 0x02B9,

 28674   primereversed: 0x2035,

 28675   product: 0x220F,

 28676   projective: 0x2305,

 28677   prolongedkana: 0x30FC,

 28678   propellor: 0x2318,

 28679   propersubset: 0x2282,

 28680   propersuperset: 0x2283,

 28681   proportion: 0x2237,

 28682   proportional: 0x221D,

 28683   psi: 0x03C8,

 28684   psicyrillic: 0x0471,

 28685   psilipneumatacyrilliccmb: 0x0486,

 28686   pssquare: 0x33B0,

 28687   puhiragana: 0x3077,

 28688   pukatakana: 0x30D7,

 28689   pvsquare: 0x33B4,

 28690   pwsquare: 0x33BA,

 28691   q: 0x0071,

 28692   qadeva: 0x0958,

 28693   qadmahebrew: 0x05A8,

 28694   qafarabic: 0x0642,

 28695   qaffinalarabic: 0xFED6,

 28696   qafinitialarabic: 0xFED7,

 28697   qafmedialarabic: 0xFED8,

 28698   qamats: 0x05B8,

 28699   qamats10: 0x05B8,

 28700   qamats1a: 0x05B8,

 28701   qamats1c: 0x05B8,

 28702   qamats27: 0x05B8,

 28703   qamats29: 0x05B8,

 28704   qamats33: 0x05B8,

 28705   qamatsde: 0x05B8,

 28706   qamatshebrew: 0x05B8,

 28707   qamatsnarrowhebrew: 0x05B8,

 28708   qamatsqatanhebrew: 0x05B8,

 28709   qamatsqatannarrowhebrew: 0x05B8,

 28710   qamatsqatanquarterhebrew: 0x05B8,

 28711   qamatsqatanwidehebrew: 0x05B8,

 28712   qamatsquarterhebrew: 0x05B8,

 28713   qamatswidehebrew: 0x05B8,

 28714   qarneyparahebrew: 0x059F,

 28715   qbopomofo: 0x3111,

 28716   qcircle: 0x24E0,

 28717   qhook: 0x02A0,

 28718   qmonospace: 0xFF51,

 28719   qof: 0x05E7,

 28720   qofdagesh: 0xFB47,

 28721   qofdageshhebrew: 0xFB47,

 28722   qofhebrew: 0x05E7,

 28723   qparen: 0x24AC,

 28724   quarternote: 0x2669,

 28725   qubuts: 0x05BB,

 28726   qubuts18: 0x05BB,

 28727   qubuts25: 0x05BB,

 28728   qubuts31: 0x05BB,

 28729   qubutshebrew: 0x05BB,

 28730   qubutsnarrowhebrew: 0x05BB,

 28731   qubutsquarterhebrew: 0x05BB,

 28732   qubutswidehebrew: 0x05BB,

 28733   question: 0x003F,

 28734   questionarabic: 0x061F,

 28735   questionarmenian: 0x055E,

 28736   questiondown: 0x00BF,

 28737   questiondownsmall: 0xF7BF,

 28738   questiongreek: 0x037E,

 28739   questionmonospace: 0xFF1F,

 28740   questionsmall: 0xF73F,

 28741   quotedbl: 0x0022,

 28742   quotedblbase: 0x201E,

 28743   quotedblleft: 0x201C,

 28744   quotedblmonospace: 0xFF02,

 28745   quotedblprime: 0x301E,

 28746   quotedblprimereversed: 0x301D,

 28747   quotedblright: 0x201D,

 28748   quoteleft: 0x2018,

 28749   quoteleftreversed: 0x201B,

 28750   quotereversed: 0x201B,

 28751   quoteright: 0x2019,

 28752   quoterightn: 0x0149,

 28753   quotesinglbase: 0x201A,

 28754   quotesingle: 0x0027,

 28755   quotesinglemonospace: 0xFF07,

 28756   r: 0x0072,

 28757   raarmenian: 0x057C,

 28758   rabengali: 0x09B0,

 28759   racute: 0x0155,

 28760   radeva: 0x0930,

 28761   radical: 0x221A,

 28762   radicalex: 0xF8E5,

 28763   radoverssquare: 0x33AE,

 28764   radoverssquaredsquare: 0x33AF,

 28765   radsquare: 0x33AD,

 28766   rafe: 0x05BF,

 28767   rafehebrew: 0x05BF,

 28768   ragujarati: 0x0AB0,

 28769   ragurmukhi: 0x0A30,

 28770   rahiragana: 0x3089,

 28771   rakatakana: 0x30E9,

 28772   rakatakanahalfwidth: 0xFF97,

 28773   ralowerdiagonalbengali: 0x09F1,

 28774   ramiddlediagonalbengali: 0x09F0,

 28775   ramshorn: 0x0264,

 28776   ratio: 0x2236,

 28777   rbopomofo: 0x3116,

 28778   rcaron: 0x0159,

 28779   rcedilla: 0x0157,

 28780   rcircle: 0x24E1,

 28781   rcommaaccent: 0x0157,

 28782   rdblgrave: 0x0211,

 28783   rdotaccent: 0x1E59,

 28784   rdotbelow: 0x1E5B,

 28785   rdotbelowmacron: 0x1E5D,

 28786   referencemark: 0x203B,

 28787   reflexsubset: 0x2286,

 28788   reflexsuperset: 0x2287,

 28789   registered: 0x00AE,

 28790   registersans: 0xF8E8,

 28791   registerserif: 0xF6DA,

 28792   reharabic: 0x0631,

 28793   reharmenian: 0x0580,

 28794   rehfinalarabic: 0xFEAE,

 28795   rehiragana: 0x308C,

 28796   rekatakana: 0x30EC,

 28797   rekatakanahalfwidth: 0xFF9A,

 28798   resh: 0x05E8,

 28799   reshdageshhebrew: 0xFB48,

 28800   reshhebrew: 0x05E8,

 28801   reversedtilde: 0x223D,

 28802   reviahebrew: 0x0597,

 28803   reviamugrashhebrew: 0x0597,

 28804   revlogicalnot: 0x2310,

 28805   rfishhook: 0x027E,

 28806   rfishhookreversed: 0x027F,

 28807   rhabengali: 0x09DD,

 28808   rhadeva: 0x095D,

 28809   rho: 0x03C1,

 28810   rhook: 0x027D,

 28811   rhookturned: 0x027B,

 28812   rhookturnedsuperior: 0x02B5,

 28813   rhosymbolgreek: 0x03F1,

 28814   rhotichookmod: 0x02DE,

 28815   rieulacirclekorean: 0x3271,

 28816   rieulaparenkorean: 0x3211,

 28817   rieulcirclekorean: 0x3263,

 28818   rieulhieuhkorean: 0x3140,

 28819   rieulkiyeokkorean: 0x313A,

 28820   rieulkiyeoksioskorean: 0x3169,

 28821   rieulkorean: 0x3139,

 28822   rieulmieumkorean: 0x313B,

 28823   rieulpansioskorean: 0x316C,

 28824   rieulparenkorean: 0x3203,

 28825   rieulphieuphkorean: 0x313F,

 28826   rieulpieupkorean: 0x313C,

 28827   rieulpieupsioskorean: 0x316B,

 28828   rieulsioskorean: 0x313D,

 28829   rieulthieuthkorean: 0x313E,

 28830   rieultikeutkorean: 0x316A,

 28831   rieulyeorinhieuhkorean: 0x316D,

 28832   rightangle: 0x221F,

 28833   righttackbelowcmb: 0x0319,

 28834   righttriangle: 0x22BF,

 28835   rihiragana: 0x308A,

 28836   rikatakana: 0x30EA,

 28837   rikatakanahalfwidth: 0xFF98,

 28838   ring: 0x02DA,

 28839   ringbelowcmb: 0x0325,

 28840   ringcmb: 0x030A,

 28841   ringhalfleft: 0x02BF,

 28842   ringhalfleftarmenian: 0x0559,

 28843   ringhalfleftbelowcmb: 0x031C,

 28844   ringhalfleftcentered: 0x02D3,

 28845   ringhalfright: 0x02BE,

 28846   ringhalfrightbelowcmb: 0x0339,

 28847   ringhalfrightcentered: 0x02D2,

 28848   rinvertedbreve: 0x0213,

 28849   rittorusquare: 0x3351,

 28850   rlinebelow: 0x1E5F,

 28851   rlongleg: 0x027C,

 28852   rlonglegturned: 0x027A,

 28853   rmonospace: 0xFF52,

 28854   rohiragana: 0x308D,

 28855   rokatakana: 0x30ED,

 28856   rokatakanahalfwidth: 0xFF9B,

 28857   roruathai: 0x0E23,

 28858   rparen: 0x24AD,

 28859   rrabengali: 0x09DC,

 28860   rradeva: 0x0931,

 28861   rragurmukhi: 0x0A5C,

 28862   rreharabic: 0x0691,

 28863   rrehfinalarabic: 0xFB8D,

 28864   rrvocalicbengali: 0x09E0,

 28865   rrvocalicdeva: 0x0960,

 28866   rrvocalicgujarati: 0x0AE0,

 28867   rrvocalicvowelsignbengali: 0x09C4,

 28868   rrvocalicvowelsigndeva: 0x0944,

 28869   rrvocalicvowelsigngujarati: 0x0AC4,

 28870   rsuperior: 0xF6F1,

 28871   rtblock: 0x2590,

 28872   rturned: 0x0279,

 28873   rturnedsuperior: 0x02B4,

 28874   ruhiragana: 0x308B,

 28875   rukatakana: 0x30EB,

 28876   rukatakanahalfwidth: 0xFF99,

 28877   rupeemarkbengali: 0x09F2,

 28878   rupeesignbengali: 0x09F3,

 28879   rupiah: 0xF6DD,

 28880   ruthai: 0x0E24,

 28881   rvocalicbengali: 0x098B,

 28882   rvocalicdeva: 0x090B,

 28883   rvocalicgujarati: 0x0A8B,

 28884   rvocalicvowelsignbengali: 0x09C3,

 28885   rvocalicvowelsigndeva: 0x0943,

 28886   rvocalicvowelsigngujarati: 0x0AC3,

 28887   s: 0x0073,

 28888   sabengali: 0x09B8,

 28889   sacute: 0x015B,

 28890   sacutedotaccent: 0x1E65,

 28891   sadarabic: 0x0635,

 28892   sadeva: 0x0938,

 28893   sadfinalarabic: 0xFEBA,

 28894   sadinitialarabic: 0xFEBB,

 28895   sadmedialarabic: 0xFEBC,

 28896   sagujarati: 0x0AB8,

 28897   sagurmukhi: 0x0A38,

 28898   sahiragana: 0x3055,

 28899   sakatakana: 0x30B5,

 28900   sakatakanahalfwidth: 0xFF7B,

 28901   sallallahoualayhewasallamarabic: 0xFDFA,

 28902   samekh: 0x05E1,

 28903   samekhdagesh: 0xFB41,

 28904   samekhdageshhebrew: 0xFB41,

 28905   samekhhebrew: 0x05E1,

 28906   saraaathai: 0x0E32,

 28907   saraaethai: 0x0E41,

 28908   saraaimaimalaithai: 0x0E44,

 28909   saraaimaimuanthai: 0x0E43,

 28910   saraamthai: 0x0E33,

 28911   saraathai: 0x0E30,

 28912   saraethai: 0x0E40,

 28913   saraiileftthai: 0xF886,

 28914   saraiithai: 0x0E35,

 28915   saraileftthai: 0xF885,

 28916   saraithai: 0x0E34,

 28917   saraothai: 0x0E42,

 28918   saraueeleftthai: 0xF888,

 28919   saraueethai: 0x0E37,

 28920   saraueleftthai: 0xF887,

 28921   sarauethai: 0x0E36,

 28922   sarauthai: 0x0E38,

 28923   sarauuthai: 0x0E39,

 28924   sbopomofo: 0x3119,

 28925   scaron: 0x0161,

 28926   scarondotaccent: 0x1E67,

 28927   scedilla: 0x015F,

 28928   schwa: 0x0259,

 28929   schwacyrillic: 0x04D9,

 28930   schwadieresiscyrillic: 0x04DB,

 28931   schwahook: 0x025A,

 28932   scircle: 0x24E2,

 28933   scircumflex: 0x015D,

 28934   scommaaccent: 0x0219,

 28935   sdotaccent: 0x1E61,

 28936   sdotbelow: 0x1E63,

 28937   sdotbelowdotaccent: 0x1E69,

 28938   seagullbelowcmb: 0x033C,

 28939   second: 0x2033,

 28940   secondtonechinese: 0x02CA,

 28941   section: 0x00A7,

 28942   seenarabic: 0x0633,

 28943   seenfinalarabic: 0xFEB2,

 28944   seeninitialarabic: 0xFEB3,

 28945   seenmedialarabic: 0xFEB4,

 28946   segol: 0x05B6,

 28947   segol13: 0x05B6,

 28948   segol1f: 0x05B6,

 28949   segol2c: 0x05B6,

 28950   segolhebrew: 0x05B6,

 28951   segolnarrowhebrew: 0x05B6,

 28952   segolquarterhebrew: 0x05B6,

 28953   segoltahebrew: 0x0592,

 28954   segolwidehebrew: 0x05B6,

 28955   seharmenian: 0x057D,

 28956   sehiragana: 0x305B,

 28957   sekatakana: 0x30BB,

 28958   sekatakanahalfwidth: 0xFF7E,

 28959   semicolon: 0x003B,

 28960   semicolonarabic: 0x061B,

 28961   semicolonmonospace: 0xFF1B,

 28962   semicolonsmall: 0xFE54,

 28963   semivoicedmarkkana: 0x309C,

 28964   semivoicedmarkkanahalfwidth: 0xFF9F,

 28965   sentisquare: 0x3322,

 28966   sentosquare: 0x3323,

 28967   seven: 0x0037,

 28968   sevenarabic: 0x0667,

 28969   sevenbengali: 0x09ED,

 28970   sevencircle: 0x2466,

 28971   sevencircleinversesansserif: 0x2790,

 28972   sevendeva: 0x096D,

 28973   seveneighths: 0x215E,

 28974   sevengujarati: 0x0AED,

 28975   sevengurmukhi: 0x0A6D,

 28976   sevenhackarabic: 0x0667,

 28977   sevenhangzhou: 0x3027,

 28978   sevenideographicparen: 0x3226,

 28979   seveninferior: 0x2087,

 28980   sevenmonospace: 0xFF17,

 28981   sevenoldstyle: 0xF737,

 28982   sevenparen: 0x247A,

 28983   sevenperiod: 0x248E,

 28984   sevenpersian: 0x06F7,

 28985   sevenroman: 0x2176,

 28986   sevensuperior: 0x2077,

 28987   seventeencircle: 0x2470,

 28988   seventeenparen: 0x2484,

 28989   seventeenperiod: 0x2498,

 28990   seventhai: 0x0E57,

 28991   sfthyphen: 0x00AD,

 28992   shaarmenian: 0x0577,

 28993   shabengali: 0x09B6,

 28994   shacyrillic: 0x0448,

 28995   shaddaarabic: 0x0651,

 28996   shaddadammaarabic: 0xFC61,

 28997   shaddadammatanarabic: 0xFC5E,

 28998   shaddafathaarabic: 0xFC60,

 28999   shaddakasraarabic: 0xFC62,

 29000   shaddakasratanarabic: 0xFC5F,

 29001   shade: 0x2592,

 29002   shadedark: 0x2593,

 29003   shadelight: 0x2591,

 29004   shademedium: 0x2592,

 29005   shadeva: 0x0936,

 29006   shagujarati: 0x0AB6,

 29007   shagurmukhi: 0x0A36,

 29008   shalshelethebrew: 0x0593,

 29009   shbopomofo: 0x3115,

 29010   shchacyrillic: 0x0449,

 29011   sheenarabic: 0x0634,

 29012   sheenfinalarabic: 0xFEB6,

 29013   sheeninitialarabic: 0xFEB7,

 29014   sheenmedialarabic: 0xFEB8,

 29015   sheicoptic: 0x03E3,

 29016   sheqel: 0x20AA,

 29017   sheqelhebrew: 0x20AA,

 29018   sheva: 0x05B0,

 29019   sheva115: 0x05B0,

 29020   sheva15: 0x05B0,

 29021   sheva22: 0x05B0,

 29022   sheva2e: 0x05B0,

 29023   shevahebrew: 0x05B0,

 29024   shevanarrowhebrew: 0x05B0,

 29025   shevaquarterhebrew: 0x05B0,

 29026   shevawidehebrew: 0x05B0,

 29027   shhacyrillic: 0x04BB,

 29028   shimacoptic: 0x03ED,

 29029   shin: 0x05E9,

 29030   shindagesh: 0xFB49,

 29031   shindageshhebrew: 0xFB49,

 29032   shindageshshindot: 0xFB2C,

 29033   shindageshshindothebrew: 0xFB2C,

 29034   shindageshsindot: 0xFB2D,

 29035   shindageshsindothebrew: 0xFB2D,

 29036   shindothebrew: 0x05C1,

 29037   shinhebrew: 0x05E9,

 29038   shinshindot: 0xFB2A,

 29039   shinshindothebrew: 0xFB2A,

 29040   shinsindot: 0xFB2B,

 29041   shinsindothebrew: 0xFB2B,

 29042   shook: 0x0282,

 29043   sigma: 0x03C3,

 29044   sigma1: 0x03C2,

 29045   sigmafinal: 0x03C2,

 29046   sigmalunatesymbolgreek: 0x03F2,

 29047   sihiragana: 0x3057,

 29048   sikatakana: 0x30B7,

 29049   sikatakanahalfwidth: 0xFF7C,

 29050   siluqhebrew: 0x05BD,

 29051   siluqlefthebrew: 0x05BD,

 29052   similar: 0x223C,

 29053   sindothebrew: 0x05C2,

 29054   siosacirclekorean: 0x3274,

 29055   siosaparenkorean: 0x3214,

 29056   sioscieuckorean: 0x317E,

 29057   sioscirclekorean: 0x3266,

 29058   sioskiyeokkorean: 0x317A,

 29059   sioskorean: 0x3145,

 29060   siosnieunkorean: 0x317B,

 29061   siosparenkorean: 0x3206,

 29062   siospieupkorean: 0x317D,

 29063   siostikeutkorean: 0x317C,

 29064   six: 0x0036,

 29065   sixarabic: 0x0666,

 29066   sixbengali: 0x09EC,

 29067   sixcircle: 0x2465,

 29068   sixcircleinversesansserif: 0x278F,

 29069   sixdeva: 0x096C,

 29070   sixgujarati: 0x0AEC,

 29071   sixgurmukhi: 0x0A6C,

 29072   sixhackarabic: 0x0666,

 29073   sixhangzhou: 0x3026,

 29074   sixideographicparen: 0x3225,

 29075   sixinferior: 0x2086,

 29076   sixmonospace: 0xFF16,

 29077   sixoldstyle: 0xF736,

 29078   sixparen: 0x2479,

 29079   sixperiod: 0x248D,

 29080   sixpersian: 0x06F6,

 29081   sixroman: 0x2175,

 29082   sixsuperior: 0x2076,

 29083   sixteencircle: 0x246F,

 29084   sixteencurrencydenominatorbengali: 0x09F9,

 29085   sixteenparen: 0x2483,

 29086   sixteenperiod: 0x2497,

 29087   sixthai: 0x0E56,

 29088   slash: 0x002F,

 29089   slashmonospace: 0xFF0F,

 29090   slong: 0x017F,

 29091   slongdotaccent: 0x1E9B,

 29092   smileface: 0x263A,

 29093   smonospace: 0xFF53,

 29094   sofpasuqhebrew: 0x05C3,

 29095   softhyphen: 0x00AD,

 29096   softsigncyrillic: 0x044C,

 29097   sohiragana: 0x305D,

 29098   sokatakana: 0x30BD,

 29099   sokatakanahalfwidth: 0xFF7F,

 29100   soliduslongoverlaycmb: 0x0338,

 29101   solidusshortoverlaycmb: 0x0337,

 29102   sorusithai: 0x0E29,

 29103   sosalathai: 0x0E28,

 29104   sosothai: 0x0E0B,

 29105   sosuathai: 0x0E2A,

 29106   space: 0x0020,

 29107   spacehackarabic: 0x0020,

 29108   spade: 0x2660,

 29109   spadesuitblack: 0x2660,

 29110   spadesuitwhite: 0x2664,

 29111   sparen: 0x24AE,

 29112   squarebelowcmb: 0x033B,

 29113   squarecc: 0x33C4,

 29114   squarecm: 0x339D,

 29115   squarediagonalcrosshatchfill: 0x25A9,

 29116   squarehorizontalfill: 0x25A4,

 29117   squarekg: 0x338F,

 29118   squarekm: 0x339E,

 29119   squarekmcapital: 0x33CE,

 29120   squareln: 0x33D1,

 29121   squarelog: 0x33D2,

 29122   squaremg: 0x338E,

 29123   squaremil: 0x33D5,

 29124   squaremm: 0x339C,

 29125   squaremsquared: 0x33A1,

 29126   squareorthogonalcrosshatchfill: 0x25A6,

 29127   squareupperlefttolowerrightfill: 0x25A7,

 29128   squareupperrighttolowerleftfill: 0x25A8,

 29129   squareverticalfill: 0x25A5,

 29130   squarewhitewithsmallblack: 0x25A3,

 29131   srsquare: 0x33DB,

 29132   ssabengali: 0x09B7,

 29133   ssadeva: 0x0937,

 29134   ssagujarati: 0x0AB7,

 29135   ssangcieuckorean: 0x3149,

 29136   ssanghieuhkorean: 0x3185,

 29137   ssangieungkorean: 0x3180,

 29138   ssangkiyeokkorean: 0x3132,

 29139   ssangnieunkorean: 0x3165,

 29140   ssangpieupkorean: 0x3143,

 29141   ssangsioskorean: 0x3146,

 29142   ssangtikeutkorean: 0x3138,

 29143   ssuperior: 0xF6F2,

 29144   sterling: 0x00A3,

 29145   sterlingmonospace: 0xFFE1,

 29146   strokelongoverlaycmb: 0x0336,

 29147   strokeshortoverlaycmb: 0x0335,

 29148   subset: 0x2282,

 29149   subsetnotequal: 0x228A,

 29150   subsetorequal: 0x2286,

 29151   succeeds: 0x227B,

 29152   suchthat: 0x220B,

 29153   suhiragana: 0x3059,

 29154   sukatakana: 0x30B9,

 29155   sukatakanahalfwidth: 0xFF7D,

 29156   sukunarabic: 0x0652,

 29157   summation: 0x2211,

 29158   sun: 0x263C,

 29159   superset: 0x2283,

 29160   supersetnotequal: 0x228B,

 29161   supersetorequal: 0x2287,

 29162   svsquare: 0x33DC,

 29163   syouwaerasquare: 0x337C,

 29164   t: 0x0074,

 29165   tabengali: 0x09A4,

 29166   tackdown: 0x22A4,

 29167   tackleft: 0x22A3,

 29168   tadeva: 0x0924,

 29169   tagujarati: 0x0AA4,

 29170   tagurmukhi: 0x0A24,

 29171   taharabic: 0x0637,

 29172   tahfinalarabic: 0xFEC2,

 29173   tahinitialarabic: 0xFEC3,

 29174   tahiragana: 0x305F,

 29175   tahmedialarabic: 0xFEC4,

 29176   taisyouerasquare: 0x337D,

 29177   takatakana: 0x30BF,

 29178   takatakanahalfwidth: 0xFF80,

 29179   tatweelarabic: 0x0640,

 29180   tau: 0x03C4,

 29181   tav: 0x05EA,

 29182   tavdages: 0xFB4A,

 29183   tavdagesh: 0xFB4A,

 29184   tavdageshhebrew: 0xFB4A,

 29185   tavhebrew: 0x05EA,

 29186   tbar: 0x0167,

 29187   tbopomofo: 0x310A,

 29188   tcaron: 0x0165,

 29189   tccurl: 0x02A8,

 29190   tcedilla: 0x0163,

 29191   tcheharabic: 0x0686,

 29192   tchehfinalarabic: 0xFB7B,

 29193   tchehinitialarabic: 0xFB7C,

 29194   tchehmedialarabic: 0xFB7D,

 29195   tcircle: 0x24E3,

 29196   tcircumflexbelow: 0x1E71,

 29197   tcommaaccent: 0x0163,

 29198   tdieresis: 0x1E97,

 29199   tdotaccent: 0x1E6B,

 29200   tdotbelow: 0x1E6D,

 29201   tecyrillic: 0x0442,

 29202   tedescendercyrillic: 0x04AD,

 29203   teharabic: 0x062A,

 29204   tehfinalarabic: 0xFE96,

 29205   tehhahinitialarabic: 0xFCA2,

 29206   tehhahisolatedarabic: 0xFC0C,

 29207   tehinitialarabic: 0xFE97,

 29208   tehiragana: 0x3066,

 29209   tehjeeminitialarabic: 0xFCA1,

 29210   tehjeemisolatedarabic: 0xFC0B,

 29211   tehmarbutaarabic: 0x0629,

 29212   tehmarbutafinalarabic: 0xFE94,

 29213   tehmedialarabic: 0xFE98,

 29214   tehmeeminitialarabic: 0xFCA4,

 29215   tehmeemisolatedarabic: 0xFC0E,

 29216   tehnoonfinalarabic: 0xFC73,

 29217   tekatakana: 0x30C6,

 29218   tekatakanahalfwidth: 0xFF83,

 29219   telephone: 0x2121,

 29220   telephoneblack: 0x260E,

 29221   telishagedolahebrew: 0x05A0,

 29222   telishaqetanahebrew: 0x05A9,

 29223   tencircle: 0x2469,

 29224   tenideographicparen: 0x3229,

 29225   tenparen: 0x247D,

 29226   tenperiod: 0x2491,

 29227   tenroman: 0x2179,

 29228   tesh: 0x02A7,

 29229   tet: 0x05D8,

 29230   tetdagesh: 0xFB38,

 29231   tetdageshhebrew: 0xFB38,

 29232   tethebrew: 0x05D8,

 29233   tetsecyrillic: 0x04B5,

 29234   tevirhebrew: 0x059B,

 29235   tevirlefthebrew: 0x059B,

 29236   thabengali: 0x09A5,

 29237   thadeva: 0x0925,

 29238   thagujarati: 0x0AA5,

 29239   thagurmukhi: 0x0A25,

 29240   thalarabic: 0x0630,

 29241   thalfinalarabic: 0xFEAC,

 29242   thanthakhatlowleftthai: 0xF898,

 29243   thanthakhatlowrightthai: 0xF897,

 29244   thanthakhatthai: 0x0E4C,

 29245   thanthakhatupperleftthai: 0xF896,

 29246   theharabic: 0x062B,

 29247   thehfinalarabic: 0xFE9A,

 29248   thehinitialarabic: 0xFE9B,

 29249   thehmedialarabic: 0xFE9C,

 29250   thereexists: 0x2203,

 29251   therefore: 0x2234,

 29252   theta: 0x03B8,

 29253   theta1: 0x03D1,

 29254   thetasymbolgreek: 0x03D1,

 29255   thieuthacirclekorean: 0x3279,

 29256   thieuthaparenkorean: 0x3219,

 29257   thieuthcirclekorean: 0x326B,

 29258   thieuthkorean: 0x314C,

 29259   thieuthparenkorean: 0x320B,

 29260   thirteencircle: 0x246C,

 29261   thirteenparen: 0x2480,

 29262   thirteenperiod: 0x2494,

 29263   thonangmonthothai: 0x0E11,

 29264   thook: 0x01AD,

 29265   thophuthaothai: 0x0E12,

 29266   thorn: 0x00FE,

 29267   thothahanthai: 0x0E17,

 29268   thothanthai: 0x0E10,

 29269   thothongthai: 0x0E18,

 29270   thothungthai: 0x0E16,

 29271   thousandcyrillic: 0x0482,

 29272   thousandsseparatorarabic: 0x066C,

 29273   thousandsseparatorpersian: 0x066C,

 29274   three: 0x0033,

 29275   threearabic: 0x0663,

 29276   threebengali: 0x09E9,

 29277   threecircle: 0x2462,

 29278   threecircleinversesansserif: 0x278C,

 29279   threedeva: 0x0969,

 29280   threeeighths: 0x215C,

 29281   threegujarati: 0x0AE9,

 29282   threegurmukhi: 0x0A69,

 29283   threehackarabic: 0x0663,

 29284   threehangzhou: 0x3023,

 29285   threeideographicparen: 0x3222,

 29286   threeinferior: 0x2083,

 29287   threemonospace: 0xFF13,

 29288   threenumeratorbengali: 0x09F6,

 29289   threeoldstyle: 0xF733,

 29290   threeparen: 0x2476,

 29291   threeperiod: 0x248A,

 29292   threepersian: 0x06F3,

 29293   threequarters: 0x00BE,

 29294   threequartersemdash: 0xF6DE,

 29295   threeroman: 0x2172,

 29296   threesuperior: 0x00B3,

 29297   threethai: 0x0E53,

 29298   thzsquare: 0x3394,

 29299   tihiragana: 0x3061,

 29300   tikatakana: 0x30C1,

 29301   tikatakanahalfwidth: 0xFF81,

 29302   tikeutacirclekorean: 0x3270,

 29303   tikeutaparenkorean: 0x3210,

 29304   tikeutcirclekorean: 0x3262,

 29305   tikeutkorean: 0x3137,

 29306   tikeutparenkorean: 0x3202,

 29307   tilde: 0x02DC,

 29308   tildebelowcmb: 0x0330,

 29309   tildecmb: 0x0303,

 29310   tildecomb: 0x0303,

 29311   tildedoublecmb: 0x0360,

 29312   tildeoperator: 0x223C,

 29313   tildeoverlaycmb: 0x0334,

 29314   tildeverticalcmb: 0x033E,

 29315   timescircle: 0x2297,

 29316   tipehahebrew: 0x0596,

 29317   tipehalefthebrew: 0x0596,

 29318   tippigurmukhi: 0x0A70,

 29319   titlocyrilliccmb: 0x0483,

 29320   tiwnarmenian: 0x057F,

 29321   tlinebelow: 0x1E6F,

 29322   tmonospace: 0xFF54,

 29323   toarmenian: 0x0569,

 29324   tohiragana: 0x3068,

 29325   tokatakana: 0x30C8,

 29326   tokatakanahalfwidth: 0xFF84,

 29327   tonebarextrahighmod: 0x02E5,

 29328   tonebarextralowmod: 0x02E9,

 29329   tonebarhighmod: 0x02E6,

 29330   tonebarlowmod: 0x02E8,

 29331   tonebarmidmod: 0x02E7,

 29332   tonefive: 0x01BD,

 29333   tonesix: 0x0185,

 29334   tonetwo: 0x01A8,

 29335   tonos: 0x0384,

 29336   tonsquare: 0x3327,

 29337   topatakthai: 0x0E0F,

 29338   tortoiseshellbracketleft: 0x3014,

 29339   tortoiseshellbracketleftsmall: 0xFE5D,

 29340   tortoiseshellbracketleftvertical: 0xFE39,

 29341   tortoiseshellbracketright: 0x3015,

 29342   tortoiseshellbracketrightsmall: 0xFE5E,

 29343   tortoiseshellbracketrightvertical: 0xFE3A,

 29344   totaothai: 0x0E15,

 29345   tpalatalhook: 0x01AB,

 29346   tparen: 0x24AF,

 29347   trademark: 0x2122,

 29348   trademarksans: 0xF8EA,

 29349   trademarkserif: 0xF6DB,

 29350   tretroflexhook: 0x0288,

 29351   triagdn: 0x25BC,

 29352   triaglf: 0x25C4,

 29353   triagrt: 0x25BA,

 29354   triagup: 0x25B2,

 29355   ts: 0x02A6,

 29356   tsadi: 0x05E6,

 29357   tsadidagesh: 0xFB46,

 29358   tsadidageshhebrew: 0xFB46,

 29359   tsadihebrew: 0x05E6,

 29360   tsecyrillic: 0x0446,

 29361   tsere: 0x05B5,

 29362   tsere12: 0x05B5,

 29363   tsere1e: 0x05B5,

 29364   tsere2b: 0x05B5,

 29365   tserehebrew: 0x05B5,

 29366   tserenarrowhebrew: 0x05B5,

 29367   tserequarterhebrew: 0x05B5,

 29368   tserewidehebrew: 0x05B5,

 29369   tshecyrillic: 0x045B,

 29370   tsuperior: 0xF6F3,

 29371   ttabengali: 0x099F,

 29372   ttadeva: 0x091F,

 29373   ttagujarati: 0x0A9F,

 29374   ttagurmukhi: 0x0A1F,

 29375   tteharabic: 0x0679,

 29376   ttehfinalarabic: 0xFB67,

 29377   ttehinitialarabic: 0xFB68,

 29378   ttehmedialarabic: 0xFB69,

 29379   tthabengali: 0x09A0,

 29380   tthadeva: 0x0920,

 29381   tthagujarati: 0x0AA0,

 29382   tthagurmukhi: 0x0A20,

 29383   tturned: 0x0287,

 29384   tuhiragana: 0x3064,

 29385   tukatakana: 0x30C4,

 29386   tukatakanahalfwidth: 0xFF82,

 29387   tusmallhiragana: 0x3063,

 29388   tusmallkatakana: 0x30C3,

 29389   tusmallkatakanahalfwidth: 0xFF6F,

 29390   twelvecircle: 0x246B,

 29391   twelveparen: 0x247F,

 29392   twelveperiod: 0x2493,

 29393   twelveroman: 0x217B,

 29394   twentycircle: 0x2473,

 29395   twentyhangzhou: 0x5344,

 29396   twentyparen: 0x2487,

 29397   twentyperiod: 0x249B,

 29398   two: 0x0032,

 29399   twoarabic: 0x0662,

 29400   twobengali: 0x09E8,

 29401   twocircle: 0x2461,

 29402   twocircleinversesansserif: 0x278B,

 29403   twodeva: 0x0968,

 29404   twodotenleader: 0x2025,

 29405   twodotleader: 0x2025,

 29406   twodotleadervertical: 0xFE30,

 29407   twogujarati: 0x0AE8,

 29408   twogurmukhi: 0x0A68,

 29409   twohackarabic: 0x0662,

 29410   twohangzhou: 0x3022,

 29411   twoideographicparen: 0x3221,

 29412   twoinferior: 0x2082,

 29413   twomonospace: 0xFF12,

 29414   twonumeratorbengali: 0x09F5,

 29415   twooldstyle: 0xF732,

 29416   twoparen: 0x2475,

 29417   twoperiod: 0x2489,

 29418   twopersian: 0x06F2,

 29419   tworoman: 0x2171,

 29420   twostroke: 0x01BB,

 29421   twosuperior: 0x00B2,

 29422   twothai: 0x0E52,

 29423   twothirds: 0x2154,

 29424   u: 0x0075,

 29425   uacute: 0x00FA,

 29426   ubar: 0x0289,

 29427   ubengali: 0x0989,

 29428   ubopomofo: 0x3128,

 29429   ubreve: 0x016D,

 29430   ucaron: 0x01D4,

 29431   ucircle: 0x24E4,

 29432   ucircumflex: 0x00FB,

 29433   ucircumflexbelow: 0x1E77,

 29434   ucyrillic: 0x0443,

 29435   udattadeva: 0x0951,

 29436   udblacute: 0x0171,

 29437   udblgrave: 0x0215,

 29438   udeva: 0x0909,

 29439   udieresis: 0x00FC,

 29440   udieresisacute: 0x01D8,

 29441   udieresisbelow: 0x1E73,

 29442   udieresiscaron: 0x01DA,

 29443   udieresiscyrillic: 0x04F1,

 29444   udieresisgrave: 0x01DC,

 29445   udieresismacron: 0x01D6,

 29446   udotbelow: 0x1EE5,

 29447   ugrave: 0x00F9,

 29448   ugujarati: 0x0A89,

 29449   ugurmukhi: 0x0A09,

 29450   uhiragana: 0x3046,

 29451   uhookabove: 0x1EE7,

 29452   uhorn: 0x01B0,

 29453   uhornacute: 0x1EE9,

 29454   uhorndotbelow: 0x1EF1,

 29455   uhorngrave: 0x1EEB,

 29456   uhornhookabove: 0x1EED,

 29457   uhorntilde: 0x1EEF,

 29458   uhungarumlaut: 0x0171,

 29459   uhungarumlautcyrillic: 0x04F3,

 29460   uinvertedbreve: 0x0217,

 29461   ukatakana: 0x30A6,

 29462   ukatakanahalfwidth: 0xFF73,

 29463   ukcyrillic: 0x0479,

 29464   ukorean: 0x315C,

 29465   umacron: 0x016B,

 29466   umacroncyrillic: 0x04EF,

 29467   umacrondieresis: 0x1E7B,

 29468   umatragurmukhi: 0x0A41,

 29469   umonospace: 0xFF55,

 29470   underscore: 0x005F,

 29471   underscoredbl: 0x2017,

 29472   underscoremonospace: 0xFF3F,

 29473   underscorevertical: 0xFE33,

 29474   underscorewavy: 0xFE4F,

 29475   union: 0x222A,

 29476   universal: 0x2200,

 29477   uogonek: 0x0173,

 29478   uparen: 0x24B0,

 29479   upblock: 0x2580,

 29480   upperdothebrew: 0x05C4,

 29481   upsilon: 0x03C5,

 29482   upsilondieresis: 0x03CB,

 29483   upsilondieresistonos: 0x03B0,

 29484   upsilonlatin: 0x028A,

 29485   upsilontonos: 0x03CD,

 29486   uptackbelowcmb: 0x031D,

 29487   uptackmod: 0x02D4,

 29488   uragurmukhi: 0x0A73,

 29489   uring: 0x016F,

 29490   ushortcyrillic: 0x045E,

 29491   usmallhiragana: 0x3045,

 29492   usmallkatakana: 0x30A5,

 29493   usmallkatakanahalfwidth: 0xFF69,

 29494   ustraightcyrillic: 0x04AF,

 29495   ustraightstrokecyrillic: 0x04B1,

 29496   utilde: 0x0169,

 29497   utildeacute: 0x1E79,

 29498   utildebelow: 0x1E75,

 29499   uubengali: 0x098A,

 29500   uudeva: 0x090A,

 29501   uugujarati: 0x0A8A,

 29502   uugurmukhi: 0x0A0A,

 29503   uumatragurmukhi: 0x0A42,

 29504   uuvowelsignbengali: 0x09C2,

 29505   uuvowelsigndeva: 0x0942,

 29506   uuvowelsigngujarati: 0x0AC2,

 29507   uvowelsignbengali: 0x09C1,

 29508   uvowelsigndeva: 0x0941,

 29509   uvowelsigngujarati: 0x0AC1,

 29510   v: 0x0076,

 29511   vadeva: 0x0935,

 29512   vagujarati: 0x0AB5,

 29513   vagurmukhi: 0x0A35,

 29514   vakatakana: 0x30F7,

 29515   vav: 0x05D5,

 29516   vavdagesh: 0xFB35,

 29517   vavdagesh65: 0xFB35,

 29518   vavdageshhebrew: 0xFB35,

 29519   vavhebrew: 0x05D5,

 29520   vavholam: 0xFB4B,

 29521   vavholamhebrew: 0xFB4B,

 29522   vavvavhebrew: 0x05F0,

 29523   vavyodhebrew: 0x05F1,

 29524   vcircle: 0x24E5,

 29525   vdotbelow: 0x1E7F,

 29526   vecyrillic: 0x0432,

 29527   veharabic: 0x06A4,

 29528   vehfinalarabic: 0xFB6B,

 29529   vehinitialarabic: 0xFB6C,

 29530   vehmedialarabic: 0xFB6D,

 29531   vekatakana: 0x30F9,

 29532   venus: 0x2640,

 29533   verticalbar: 0x007C,

 29534   verticallineabovecmb: 0x030D,

 29535   verticallinebelowcmb: 0x0329,

 29536   verticallinelowmod: 0x02CC,

 29537   verticallinemod: 0x02C8,

 29538   vewarmenian: 0x057E,

 29539   vhook: 0x028B,

 29540   vikatakana: 0x30F8,

 29541   viramabengali: 0x09CD,

 29542   viramadeva: 0x094D,

 29543   viramagujarati: 0x0ACD,

 29544   visargabengali: 0x0983,

 29545   visargadeva: 0x0903,

 29546   visargagujarati: 0x0A83,

 29547   vmonospace: 0xFF56,

 29548   voarmenian: 0x0578,

 29549   voicediterationhiragana: 0x309E,

 29550   voicediterationkatakana: 0x30FE,

 29551   voicedmarkkana: 0x309B,

 29552   voicedmarkkanahalfwidth: 0xFF9E,

 29553   vokatakana: 0x30FA,

 29554   vparen: 0x24B1,

 29555   vtilde: 0x1E7D,

 29556   vturned: 0x028C,

 29557   vuhiragana: 0x3094,

 29558   vukatakana: 0x30F4,

 29559   w: 0x0077,

 29560   wacute: 0x1E83,

 29561   waekorean: 0x3159,

 29562   wahiragana: 0x308F,

 29563   wakatakana: 0x30EF,

 29564   wakatakanahalfwidth: 0xFF9C,

 29565   wakorean: 0x3158,

 29566   wasmallhiragana: 0x308E,

 29567   wasmallkatakana: 0x30EE,

 29568   wattosquare: 0x3357,

 29569   wavedash: 0x301C,

 29570   wavyunderscorevertical: 0xFE34,

 29571   wawarabic: 0x0648,

 29572   wawfinalarabic: 0xFEEE,

 29573   wawhamzaabovearabic: 0x0624,

 29574   wawhamzaabovefinalarabic: 0xFE86,

 29575   wbsquare: 0x33DD,

 29576   wcircle: 0x24E6,

 29577   wcircumflex: 0x0175,

 29578   wdieresis: 0x1E85,

 29579   wdotaccent: 0x1E87,

 29580   wdotbelow: 0x1E89,

 29581   wehiragana: 0x3091,

 29582   weierstrass: 0x2118,

 29583   wekatakana: 0x30F1,

 29584   wekorean: 0x315E,

 29585   weokorean: 0x315D,

 29586   wgrave: 0x1E81,

 29587   whitebullet: 0x25E6,

 29588   whitecircle: 0x25CB,

 29589   whitecircleinverse: 0x25D9,

 29590   whitecornerbracketleft: 0x300E,

 29591   whitecornerbracketleftvertical: 0xFE43,

 29592   whitecornerbracketright: 0x300F,

 29593   whitecornerbracketrightvertical: 0xFE44,

 29594   whitediamond: 0x25C7,

 29595   whitediamondcontainingblacksmalldiamond: 0x25C8,

 29596   whitedownpointingsmalltriangle: 0x25BF,

 29597   whitedownpointingtriangle: 0x25BD,

 29598   whiteleftpointingsmalltriangle: 0x25C3,

 29599   whiteleftpointingtriangle: 0x25C1,

 29600   whitelenticularbracketleft: 0x3016,

 29601   whitelenticularbracketright: 0x3017,

 29602   whiterightpointingsmalltriangle: 0x25B9,

 29603   whiterightpointingtriangle: 0x25B7,

 29604   whitesmallsquare: 0x25AB,

 29605   whitesmilingface: 0x263A,

 29606   whitesquare: 0x25A1,

 29607   whitestar: 0x2606,

 29608   whitetelephone: 0x260F,

 29609   whitetortoiseshellbracketleft: 0x3018,

 29610   whitetortoiseshellbracketright: 0x3019,

 29611   whiteuppointingsmalltriangle: 0x25B5,

 29612   whiteuppointingtriangle: 0x25B3,

 29613   wihiragana: 0x3090,

 29614   wikatakana: 0x30F0,

 29615   wikorean: 0x315F,

 29616   wmonospace: 0xFF57,

 29617   wohiragana: 0x3092,

 29618   wokatakana: 0x30F2,

 29619   wokatakanahalfwidth: 0xFF66,

 29620   won: 0x20A9,

 29621   wonmonospace: 0xFFE6,

 29622   wowaenthai: 0x0E27,

 29623   wparen: 0x24B2,

 29624   wring: 0x1E98,

 29625   wsuperior: 0x02B7,

 29626   wturned: 0x028D,

 29627   wynn: 0x01BF,

 29628   x: 0x0078,

 29629   xabovecmb: 0x033D,

 29630   xbopomofo: 0x3112,

 29631   xcircle: 0x24E7,

 29632   xdieresis: 0x1E8D,

 29633   xdotaccent: 0x1E8B,

 29634   xeharmenian: 0x056D,

 29635   xi: 0x03BE,

 29636   xmonospace: 0xFF58,

 29637   xparen: 0x24B3,

 29638   xsuperior: 0x02E3,

 29639   y: 0x0079,

 29640   yaadosquare: 0x334E,

 29641   yabengali: 0x09AF,

 29642   yacute: 0x00FD,

 29643   yadeva: 0x092F,

 29644   yaekorean: 0x3152,

 29645   yagujarati: 0x0AAF,

 29646   yagurmukhi: 0x0A2F,

 29647   yahiragana: 0x3084,

 29648   yakatakana: 0x30E4,

 29649   yakatakanahalfwidth: 0xFF94,

 29650   yakorean: 0x3151,

 29651   yamakkanthai: 0x0E4E,

 29652   yasmallhiragana: 0x3083,

 29653   yasmallkatakana: 0x30E3,

 29654   yasmallkatakanahalfwidth: 0xFF6C,

 29655   yatcyrillic: 0x0463,

 29656   ycircle: 0x24E8,

 29657   ycircumflex: 0x0177,

 29658   ydieresis: 0x00FF,

 29659   ydotaccent: 0x1E8F,

 29660   ydotbelow: 0x1EF5,

 29661   yeharabic: 0x064A,

 29662   yehbarreearabic: 0x06D2,

 29663   yehbarreefinalarabic: 0xFBAF,

 29664   yehfinalarabic: 0xFEF2,

 29665   yehhamzaabovearabic: 0x0626,

 29666   yehhamzaabovefinalarabic: 0xFE8A,

 29667   yehhamzaaboveinitialarabic: 0xFE8B,

 29668   yehhamzaabovemedialarabic: 0xFE8C,

 29669   yehinitialarabic: 0xFEF3,

 29670   yehmedialarabic: 0xFEF4,

 29671   yehmeeminitialarabic: 0xFCDD,

 29672   yehmeemisolatedarabic: 0xFC58,

 29673   yehnoonfinalarabic: 0xFC94,

 29674   yehthreedotsbelowarabic: 0x06D1,

 29675   yekorean: 0x3156,

 29676   yen: 0x00A5,

 29677   yenmonospace: 0xFFE5,

 29678   yeokorean: 0x3155,

 29679   yeorinhieuhkorean: 0x3186,

 29680   yerahbenyomohebrew: 0x05AA,

 29681   yerahbenyomolefthebrew: 0x05AA,

 29682   yericyrillic: 0x044B,

 29683   yerudieresiscyrillic: 0x04F9,

 29684   yesieungkorean: 0x3181,

 29685   yesieungpansioskorean: 0x3183,

 29686   yesieungsioskorean: 0x3182,

 29687   yetivhebrew: 0x059A,

 29688   ygrave: 0x1EF3,

 29689   yhook: 0x01B4,

 29690   yhookabove: 0x1EF7,

 29691   yiarmenian: 0x0575,

 29692   yicyrillic: 0x0457,

 29693   yikorean: 0x3162,

 29694   yinyang: 0x262F,

 29695   yiwnarmenian: 0x0582,

 29696   ymonospace: 0xFF59,

 29697   yod: 0x05D9,

 29698   yoddagesh: 0xFB39,

 29699   yoddageshhebrew: 0xFB39,

 29700   yodhebrew: 0x05D9,

 29701   yodyodhebrew: 0x05F2,

 29702   yodyodpatahhebrew: 0xFB1F,

 29703   yohiragana: 0x3088,

 29704   yoikorean: 0x3189,

 29705   yokatakana: 0x30E8,

 29706   yokatakanahalfwidth: 0xFF96,

 29707   yokorean: 0x315B,

 29708   yosmallhiragana: 0x3087,

 29709   yosmallkatakana: 0x30E7,

 29710   yosmallkatakanahalfwidth: 0xFF6E,

 29711   yotgreek: 0x03F3,

 29712   yoyaekorean: 0x3188,

 29713   yoyakorean: 0x3187,

 29714   yoyakthai: 0x0E22,

 29715   yoyingthai: 0x0E0D,

 29716   yparen: 0x24B4,

 29717   ypogegrammeni: 0x037A,

 29718   ypogegrammenigreekcmb: 0x0345,

 29719   yr: 0x01A6,

 29720   yring: 0x1E99,

 29721   ysuperior: 0x02B8,

 29722   ytilde: 0x1EF9,

 29723   yturned: 0x028E,

 29724   yuhiragana: 0x3086,

 29725   yuikorean: 0x318C,

 29726   yukatakana: 0x30E6,

 29727   yukatakanahalfwidth: 0xFF95,

 29728   yukorean: 0x3160,

 29729   yusbigcyrillic: 0x046B,

 29730   yusbigiotifiedcyrillic: 0x046D,

 29731   yuslittlecyrillic: 0x0467,

 29732   yuslittleiotifiedcyrillic: 0x0469,

 29733   yusmallhiragana: 0x3085,

 29734   yusmallkatakana: 0x30E5,

 29735   yusmallkatakanahalfwidth: 0xFF6D,

 29736   yuyekorean: 0x318B,

 29737   yuyeokorean: 0x318A,

 29738   yyabengali: 0x09DF,

 29739   yyadeva: 0x095F,

 29740   z: 0x007A,

 29741   zaarmenian: 0x0566,

 29742   zacute: 0x017A,

 29743   zadeva: 0x095B,

 29744   zagurmukhi: 0x0A5B,

 29745   zaharabic: 0x0638,

 29746   zahfinalarabic: 0xFEC6,

 29747   zahinitialarabic: 0xFEC7,

 29748   zahiragana: 0x3056,

 29749   zahmedialarabic: 0xFEC8,

 29750   zainarabic: 0x0632,

 29751   zainfinalarabic: 0xFEB0,

 29752   zakatakana: 0x30B6,

 29753   zaqefgadolhebrew: 0x0595,

 29754   zaqefqatanhebrew: 0x0594,

 29755   zarqahebrew: 0x0598,

 29756   zayin: 0x05D6,

 29757   zayindagesh: 0xFB36,

 29758   zayindageshhebrew: 0xFB36,

 29759   zayinhebrew: 0x05D6,

 29760   zbopomofo: 0x3117,

 29761   zcaron: 0x017E,

 29762   zcircle: 0x24E9,

 29763   zcircumflex: 0x1E91,

 29764   zcurl: 0x0291,

 29765   zdot: 0x017C,

 29766   zdotaccent: 0x017C,

 29767   zdotbelow: 0x1E93,

 29768   zecyrillic: 0x0437,

 29769   zedescendercyrillic: 0x0499,

 29770   zedieresiscyrillic: 0x04DF,

 29771   zehiragana: 0x305C,

 29772   zekatakana: 0x30BC,

 29773   zero: 0x0030,

 29774   zeroarabic: 0x0660,

 29775   zerobengali: 0x09E6,

 29776   zerodeva: 0x0966,

 29777   zerogujarati: 0x0AE6,

 29778   zerogurmukhi: 0x0A66,

 29779   zerohackarabic: 0x0660,

 29780   zeroinferior: 0x2080,

 29781   zeromonospace: 0xFF10,

 29782   zerooldstyle: 0xF730,

 29783   zeropersian: 0x06F0,

 29784   zerosuperior: 0x2070,

 29785   zerothai: 0x0E50,

 29786   zerowidthjoiner: 0xFEFF,

 29787   zerowidthnonjoiner: 0x200C,

 29788   zerowidthspace: 0x200B,

 29789   zeta: 0x03B6,

 29790   zhbopomofo: 0x3113,

 29791   zhearmenian: 0x056A,

 29792   zhebrevecyrillic: 0x04C2,

 29793   zhecyrillic: 0x0436,

 29794   zhedescendercyrillic: 0x0497,

 29795   zhedieresiscyrillic: 0x04DD,

 29796   zihiragana: 0x3058,

 29797   zikatakana: 0x30B8,

 29798   zinorhebrew: 0x05AE,

 29799   zlinebelow: 0x1E95,

 29800   zmonospace: 0xFF5A,

 29801   zohiragana: 0x305E,

 29802   zokatakana: 0x30BE,

 29803   zparen: 0x24B5,

 29804   zretroflexhook: 0x0290,

 29805   zstroke: 0x01B6,

 29806   zuhiragana: 0x305A,

 29807   zukatakana: 0x30BA,

 29808   '.notdef': 0x0000

 29809 };

 29813 var PDFImage = (function PDFImageClosure() {

 29814   /**

 29815    * Decode the image in the main thread if it supported. Resovles the promise

 29816    * when the image data is ready.

 29817    */

 29818   function handleImageData(handler, xref, res, image) {

 29819     if (image instanceof JpegStream && image.isNativelyDecodable(xref, res)) {

 29820       // For natively supported jpegs send them to the main thread for decoding.

 29821       var dict = image.dict;

 29822       var colorSpace = dict.get('ColorSpace', 'CS');

 29823       colorSpace = ColorSpace.parse(colorSpace, xref, res);

 29824       var numComps = colorSpace.numComps;

 29825       var resolvePromise;

 29826       handler.send('JpegDecode', [image.getIR(), numComps], function(message) {

 29827         var data = message.data;

 29828         var stream = new Stream(data, 0, data.length, image.dict);

 29829         resolvePromise(stream);

 29830       });

 29831       return new Promise(function (resolve) {

 29832         resolvePromise = resolve;

 29833       });

 29834     } else {

 29835       return Promise.resolve(image);

 29836     }

 29837   }

 29838   /**

 29839    * Decode and clamp a value. The formula is different from the spec because we

 29840    * don't decode to float range [0,1], we decode it in the [0,max] range.

 29841    */

 29842   function decodeAndClamp(value, addend, coefficient, max) {

 29843     value = addend + value * coefficient;

 29844     // Clamp the value to the range

 29845     return (value < 0 ? 0 : (value > max ? max : value));

 29846   }

 29847   function PDFImage(xref, res, image, inline, smask, mask, isMask) {

 29848     this.image = image;

 29849     var dict = image.dict;

 29850     if (dict.has('Filter')) {

 29851       var filter = dict.get('Filter').name;

 29852       if (filter === 'JPXDecode') {

 29853         var jpxImage = new JpxImage();

 29854         jpxImage.parseImageProperties(image.stream);

 29855         image.stream.reset();

 29856         image.bitsPerComponent = jpxImage.bitsPerComponent;

 29857         image.numComps = jpxImage.componentsCount;

 29858       } else if (filter === 'JBIG2Decode') {

 29859         image.bitsPerComponent = 1;

 29860         image.numComps = 1;

 29861       }

 29862     }

 29863     // TODO cache rendered images?

 29865     this.width = dict.get('Width', 'W');

 29866     this.height = dict.get('Height', 'H');

 29868     if (this.width < 1 || this.height < 1) {

 29869       error('Invalid image width: ' + this.width + ' or height: ' +

 29870             this.height);

 29871     }

 29873     this.interpolate = dict.get('Interpolate', 'I') || false;

 29874     this.imageMask = dict.get('ImageMask', 'IM') || false;

 29875     this.matte = dict.get('Matte') || false;

 29877     var bitsPerComponent = image.bitsPerComponent;

 29878     if (!bitsPerComponent) {

 29879       bitsPerComponent = dict.get('BitsPerComponent', 'BPC');

 29880       if (!bitsPerComponent) {

 29881         if (this.imageMask) {

 29882           bitsPerComponent = 1;

 29883         } else {

 29884           error('Bits per component missing in image: ' + this.imageMask);

 29885         }

 29886       }

 29887     }

 29888     this.bpc = bitsPerComponent;

 29890     if (!this.imageMask) {

 29891       var colorSpace = dict.get('ColorSpace', 'CS');

 29892       if (!colorSpace) {

 29893         info('JPX images (which do not require color spaces)');

 29894         switch (image.numComps) {

 29895           case 1:

 29896             colorSpace = Name.get('DeviceGray');

 29897             break;

 29898           case 3:

 29899             colorSpace = Name.get('DeviceRGB');

 29900             break;

 29901           case 4:

 29902             colorSpace = Name.get('DeviceCMYK');

 29903             break;

 29904           default:

 29905             error('JPX images with ' + this.numComps +

 29906                   ' color components not supported.');

 29907         }

 29908       }

 29909       this.colorSpace = ColorSpace.parse(colorSpace, xref, res);

 29910       this.numComps = this.colorSpace.numComps;

 29911     }

 29913     this.decode = dict.get('Decode', 'D');

 29914     this.needsDecode = false;

 29915     if (this.decode &&

 29916         ((this.colorSpace && !this.colorSpace.isDefaultDecode(this.decode)) ||

 29917          (isMask && !ColorSpace.isDefaultDecode(this.decode, 1)))) {

 29918       this.needsDecode = true;

 29919       // Do some preprocessing to avoid more math.

 29920       var max = (1 << bitsPerComponent) - 1;

 29921       this.decodeCoefficients = [];

 29922       this.decodeAddends = [];

 29923       for (var i = 0, j = 0; i < this.decode.length; i += 2, ++j) {

 29924         var dmin = this.decode[i];

 29925         var dmax = this.decode[i + 1];

 29926         this.decodeCoefficients[j] = dmax - dmin;

 29927         this.decodeAddends[j] = max * dmin;

 29928       }

 29929     }

 29931     if (smask) {

 29932       this.smask = new PDFImage(xref, res, smask, false);

 29933     } else if (mask) {

 29934       if (isStream(mask)) {

 29935         this.mask = new PDFImage(xref, res, mask, false, null, null, true);

 29936       } else {

 29937         // Color key mask (just an array).

 29938         this.mask = mask;

 29939       }

 29940     }

 29941   }

 29942   /**

 29943    * Handles processing of image data and returns the Promise that is resolved

 29944    * with a PDFImage when the image is ready to be used.

 29945    */

 29946   PDFImage.buildImage = function PDFImage_buildImage(handler, xref,

 29947                                                      res, image, inline) {

 29948     var imagePromise = handleImageData(handler, xref, res, image);

 29949     var smaskPromise;

 29950     var maskPromise;

 29952     var smask = image.dict.get('SMask');

 29953     var mask = image.dict.get('Mask');

 29955     if (smask) {

 29956       smaskPromise = handleImageData(handler, xref, res, smask);

 29957       maskPromise = Promise.resolve(null);

 29958     } else {

 29959       smaskPromise = Promise.resolve(null);

 29960       if (mask) {

 29961         if (isStream(mask)) {

 29962           maskPromise = handleImageData(handler, xref, res, mask);

 29963         } else if (isArray(mask)) {

 29964           maskPromise = Promise.resolve(mask);

 29965         } else {

 29966           warn('Unsupported mask format.');

 29967           maskPromise = Promise.resolve(null);

 29968         }

 29969       } else {

 29970         maskPromise = Promise.resolve(null);

 29971       }

 29972     }

 29973     return Promise.all([imagePromise, smaskPromise, maskPromise]).then(

 29974       function(results) {

 29975         var imageData = results[0];

 29976         var smaskData = results[1];

 29977         var maskData = results[2];

 29978         return new PDFImage(xref, res, imageData, inline, smaskData, maskData);

 29979       });

 29980   };

 29982   /**

 29983    * Resize an image using the nearest neighbor algorithm. Currently only

 29984    * supports one and three component images.

 29985    * @param {TypedArray} pixels The original image with one component.

 29986    * @param {Number} bpc Number of bits per component.

 29987    * @param {Number} components Number of color components, 1 or 3 is supported.

 29988    * @param {Number} w1 Original width.

 29989    * @param {Number} h1 Original height.

 29990    * @param {Number} w2 New width.

 29991    * @param {Number} h2 New height.

 29992    * @return {TypedArray} Resized image data.

 29993    */

 29994   PDFImage.resize = function PDFImage_resize(pixels, bpc, components,

 29995                                              w1, h1, w2, h2) {

 29996     var length = w2 * h2 * components;

 29997     var temp = (bpc <= 8 ? new Uint8Array(length) :

 29998         (bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length)));

 29999     var xRatio = w1 / w2;

 30000     var yRatio = h1 / h2;

 30001     var px, py, newIndex, oldIndex;

 30002     for (var i = 0; i < h2; i++) {

 30003       for (var j = 0; j < w2; j++) {

 30004         px = Math.floor(j * xRatio);

 30005         py = Math.floor(i * yRatio);

 30006         newIndex = (i * w2) + j;

 30007         oldIndex = ((py * w1) + px);

 30008         if (components === 1) {

 30009           temp[newIndex] = pixels[oldIndex];

 30010         } else if (components === 3) {

 30011           newIndex *= 3;

 30012           oldIndex *= 3;

 30013           temp[newIndex] = pixels[oldIndex];

 30014           temp[newIndex + 1] = pixels[oldIndex + 1];

 30015           temp[newIndex + 2] = pixels[oldIndex + 2];

 30016         }

 30017       }

 30018     }

 30019     return temp;

 30020   };

 30022   PDFImage.createMask =

 30023       function PDFImage_createMask(imgArray, width, height, canTransfer,

 30024                                    inverseDecode) {

 30025     // If imgArray came from a DecodeStream, we're safe to transfer it.

 30026     // Otherwise, copy it.

 30027     var actualLength = imgArray.byteLength;

 30028     var data;

 30029     if (canTransfer) {

 30030       data = imgArray;

 30031     } else {

 30032       data = new Uint8Array(actualLength);

 30033       data.set(imgArray);

 30034     }

 30035     // Invert if necessary. It's safe to modify the array -- whether it's the

 30036     // original or a copy, we're about to transfer it anyway, so nothing else

 30037     // in this thread can be relying on its contents.

 30038     if (inverseDecode) {

 30039       for (var i = 0; i < actualLength; i++) {

 30040         data[i] = ~data[i];

 30041       }

 30042     }

 30044     return {data: data, width: width, height: height};

 30045   };

 30047   PDFImage.prototype = {

 30048     get drawWidth() {

 30049       return Math.max(this.width,

 30050                       this.smask && this.smask.width || 0,

 30051                       this.mask && this.mask.width || 0);

 30052     },

 30053     get drawHeight() {

 30054       return Math.max(this.height,

 30055                       this.smask && this.smask.height || 0,

 30056                       this.mask && this.mask.height || 0);

 30057     },

 30058     decodeBuffer: function PDFImage_decodeBuffer(buffer) {

 30059       var bpc = this.bpc;

 30060       var numComps = this.numComps;

 30062       var decodeAddends = this.decodeAddends;

 30063       var decodeCoefficients = this.decodeCoefficients;

 30064       var max = (1 << bpc) - 1;

 30065       var i, ii;

 30067       if (bpc === 1) {

 30068         // If the buffer needed decode that means it just needs to be inverted.

 30069         for (i = 0, ii = buffer.length; i < ii; i++) {

 30070           buffer[i] = +!(buffer[i]);

 30071         }

 30072         return;

 30073       }

 30074       var index = 0;

 30075       for (i = 0, ii = this.width * this.height; i < ii; i++) {

 30076         for (var j = 0; j < numComps; j++) {

 30077           buffer[index] = decodeAndClamp(buffer[index], decodeAddends[j],

 30078                                          decodeCoefficients[j], max);

 30079           index++;

 30080         }

 30081       }

 30082     },

 30083     getComponents: function PDFImage_getComponents(buffer) {

 30084       var bpc = this.bpc;

 30086       // This image doesn't require any extra work.

 30087       if (bpc === 8) {

 30088         return buffer;

 30089       }

 30091       var width = this.width;

 30092       var height = this.height;

 30093       var numComps = this.numComps;

 30095       var length = width * height * numComps;

 30096       var bufferPos = 0;

 30097       var output = (bpc <= 8 ? new Uint8Array(length) :

 30098         (bpc <= 16 ? new Uint16Array(length) : new Uint32Array(length)));

 30099       var rowComps = width * numComps;

 30101       var max = (1 << bpc) - 1;

 30102       var i = 0, ii, buf;

 30104       if (bpc === 1) {

 30105         // Optimization for reading 1 bpc images.

 30106         var mask, loop1End, loop2End;

 30107         for (var j = 0; j < height; j++) {

 30108           loop1End = i + (rowComps & ~7);

 30109           loop2End = i + rowComps;

 30111           // unroll loop for all full bytes

 30112           while (i < loop1End) {

 30113             buf = buffer[bufferPos++];

 30114             output[i] = (buf >> 7) & 1;

 30115             output[i + 1] = (buf >> 6) & 1;

 30116             output[i + 2] = (buf >> 5) & 1;

 30117             output[i + 3] = (buf >> 4) & 1;

 30118             output[i + 4] = (buf >> 3) & 1;

 30119             output[i + 5] = (buf >> 2) & 1;

 30120             output[i + 6] = (buf >> 1) & 1;

 30121             output[i + 7] = buf & 1;

 30122             i += 8;

 30123           }

 30125           // handle remaing bits

 30126           if (i < loop2End) {

 30127             buf = buffer[bufferPos++];

 30128             mask = 128;

 30129             while (i < loop2End) {

 30130               output[i++] = +!!(buf & mask);

 30131               mask >>= 1;

 30132             }

 30133           }

 30134         }

 30135       } else {

 30136         // The general case that handles all other bpc values.

 30137         var bits = 0;

 30138         buf = 0;

 30139         for (i = 0, ii = length; i < ii; ++i) {

 30140           if (i % rowComps === 0) {

 30141             buf = 0;

 30142             bits = 0;

 30143           }

 30145           while (bits < bpc) {

 30146             buf = (buf << 8) | buffer[bufferPos++];

 30147             bits += 8;

 30148           }

 30150           var remainingBits = bits - bpc;

 30151           var value = buf >> remainingBits;

 30152           output[i] = (value < 0 ? 0 : (value > max ? max : value));

 30153           buf = buf & ((1 << remainingBits) - 1);

 30154           bits = remainingBits;

 30155         }

 30156       }

 30157       return output;

 30158     },

 30159     fillOpacity: function PDFImage_fillOpacity(rgbaBuf, width, height,

 30160                                                actualHeight, image) {

 30161       var smask = this.smask;

 30162       var mask = this.mask;

 30163       var alphaBuf, sw, sh, i, ii, j;

 30165       if (smask) {

 30166         sw = smask.width;

 30167         sh = smask.height;

 30168         alphaBuf = new Uint8Array(sw * sh);

 30169         smask.fillGrayBuffer(alphaBuf);

 30170         if (sw != width || sh != height) {

 30171           alphaBuf = PDFImage.resize(alphaBuf, smask.bpc, 1, sw, sh, width,

 30172                                      height);

 30173         }

 30174       } else if (mask) {

 30175         if (mask instanceof PDFImage) {

 30176           sw = mask.width;

 30177           sh = mask.height;

 30178           alphaBuf = new Uint8Array(sw * sh);

 30179           mask.numComps = 1;

 30180           mask.fillGrayBuffer(alphaBuf);

 30182           // Need to invert values in rgbaBuf

 30183           for (i = 0, ii = sw * sh; i < ii; ++i) {

 30184             alphaBuf[i] = 255 - alphaBuf[i];

 30185           }

 30187           if (sw != width || sh != height) {

 30188             alphaBuf = PDFImage.resize(alphaBuf, mask.bpc, 1, sw, sh, width,

 30189                                        height);

 30190           }

 30191         } else if (isArray(mask)) {

 30192           // Color key mask: if any of the compontents are outside the range

 30193           // then they should be painted.

 30194           alphaBuf = new Uint8Array(width * height);

 30195           var numComps = this.numComps;

 30196           for (i = 0, ii = width * height; i < ii; ++i) {

 30197             var opacity = 0;

 30198             var imageOffset = i * numComps;

 30199             for (j = 0; j < numComps; ++j) {

 30200               var color = image[imageOffset + j];

 30201               var maskOffset = j * 2;

 30202               if (color < mask[maskOffset] || color > mask[maskOffset + 1]) {

 30203                 opacity = 255;

 30204                 break;

 30205               }

 30206             }

 30207             alphaBuf[i] = opacity;

 30208           }

 30209         } else {

 30210           error('Unknown mask format.');

 30211         }

 30212       }

 30214       if (alphaBuf) {

 30215         for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {

 30216           rgbaBuf[j] = alphaBuf[i];

 30217         }

 30218       } else {

 30219         // No mask.

 30220         for (i = 0, j = 3, ii = width * actualHeight; i < ii; ++i, j += 4) {

 30221           rgbaBuf[j] = 255;

 30222         }

 30223       }

 30224     },

 30225     undoPreblend: function PDFImage_undoPreblend(buffer, width, height) {

 30226       var matte = this.smask && this.smask.matte;

 30227       if (!matte) {

 30228         return;

 30229       }

 30231       function clamp(value) {

 30232         return (value < 0 ? 0 : (value > 255 ? 255 : value)) | 0;

 30233       }

 30235       var matteRgb = this.colorSpace.getRgb(matte, 0);

 30236       var length = width * height * 4;

 30237       for (var i = 0; i < length; i += 4) {

 30238         var alpha = buffer[i + 3];

 30239         if (alpha === 0) {

 30240           // according formula we have to get Infinity in all components

 30241           // making it as white (tipical paper color) should be okay

 30242           buffer[i] = 255;

 30243           buffer[i + 1] = 255;

 30244           buffer[i + 2] = 255;

 30245           continue;

 30246         }

 30247         var k = 255 / alpha;

 30248         buffer[i] = clamp((buffer[i] - matteRgb[0]) * k + matteRgb[0]);

 30249         buffer[i + 1] = clamp((buffer[i + 1] - matteRgb[1]) * k + matteRgb[1]);

 30250         buffer[i + 2] = clamp((buffer[i + 2] - matteRgb[2]) * k + matteRgb[2]);

 30251       }

 30252     },

 30253     createImageData: function PDFImage_createImageData(forceRGBA) {

 30254       var drawWidth = this.drawWidth;

 30255       var drawHeight = this.drawHeight;

 30256       var imgData = { // other fields are filled in below

 30257         width: drawWidth,

 30258         height: drawHeight

 30259       };

 30261       var numComps = this.numComps;

 30262       var originalWidth = this.width;

 30263       var originalHeight = this.height;

 30264       var bpc = this.bpc;

 30266       // Rows start at byte boundary.

 30267       var rowBytes = (originalWidth * numComps * bpc + 7) >> 3;

 30268       var imgArray = this.getImageBytes(originalHeight * rowBytes);

 30270       if (!forceRGBA) {

 30271         // If it is a 1-bit-per-pixel grayscale (i.e. black-and-white) image

 30272         // without any complications, we pass a same-sized copy to the main

 30273         // thread rather than expanding by 32x to RGBA form. This saves *lots*

 30274         // of memory for many scanned documents. It's also much faster.

 30275         //

 30276         // Similarly, if it is a 24-bit-per pixel RGB image without any

 30277         // complications, we avoid expanding by 1.333x to RGBA form.

 30278         var kind;

 30279         if (this.colorSpace.name === 'DeviceGray' && bpc === 1) {

 30280           kind = ImageKind.GRAYSCALE_1BPP;

 30281         } else if (this.colorSpace.name === 'DeviceRGB' && bpc === 8) {

 30282           kind = ImageKind.RGB_24BPP;

 30283         }

 30284         if (kind && !this.smask && !this.mask && !this.needsDecode &&

 30285             drawWidth === originalWidth && drawHeight === originalHeight) {

 30286           imgData.kind = kind;

 30288           // If imgArray came from a DecodeStream, we're safe to transfer it

 30289           // (and thus neuter it) because it will constitute the entire

 30290           // DecodeStream's data.  But if it came from a Stream, we need to

 30291           // copy it because it'll only be a portion of the Stream's data, and

 30292           // the rest will be read later on.

 30293           if (this.image instanceof DecodeStream) {

 30294             imgData.data = imgArray;

 30295           } else {

 30296             var newArray = new Uint8Array(imgArray.length);

 30297             newArray.set(imgArray);

 30298             imgData.data = newArray;

 30299           }

 30300           return imgData;

 30301         }

 30302       }

 30304       // imgArray can be incomplete (e.g. after CCITT fax encoding).

 30305       var actualHeight = 0 | (imgArray.length / rowBytes *

 30306                          drawHeight / originalHeight);

 30308       var comps = this.getComponents(imgArray);

 30310       // If opacity data is present, use RGBA_32BPP form. Otherwise, use the

 30311       // more compact RGB_24BPP form if allowable.

 30312       var alpha01, maybeUndoPreblend;

 30313       if (!forceRGBA && !this.smask && !this.mask) {

 30314         imgData.kind = ImageKind.RGB_24BPP;

 30315         imgData.data = new Uint8Array(drawWidth * drawHeight * 3);

 30316         alpha01 = 0;

 30317         maybeUndoPreblend = false;

 30318       } else {

 30319         imgData.kind = ImageKind.RGBA_32BPP;

 30320         imgData.data = new Uint8Array(drawWidth * drawHeight * 4);

 30321         alpha01 = 1;

 30322         maybeUndoPreblend = true;

 30324         // Color key masking (opacity) must be performed before decoding.

 30325         this.fillOpacity(imgData.data, drawWidth, drawHeight, actualHeight,

 30326                          comps);

 30327       }

 30329       if (this.needsDecode) {

 30330         this.decodeBuffer(comps);

 30331       }

 30332       this.colorSpace.fillRgb(imgData.data, originalWidth, originalHeight,

 30333                               drawWidth, drawHeight, actualHeight, bpc, comps,

 30334                               alpha01);

 30335       if (maybeUndoPreblend) {

 30336         this.undoPreblend(imgData.data, drawWidth, actualHeight);

 30337       }

 30339       return imgData;

 30340     },

 30341     fillGrayBuffer: function PDFImage_fillGrayBuffer(buffer) {

 30342       var numComps = this.numComps;

 30343       if (numComps != 1) {

 30344         error('Reading gray scale from a color image: ' + numComps);

 30345       }

 30347       var width = this.width;

 30348       var height = this.height;

 30349       var bpc = this.bpc;

 30351       // rows start at byte boundary

 30352       var rowBytes = (width * numComps * bpc + 7) >> 3;

 30353       var imgArray = this.getImageBytes(height * rowBytes);

 30355       var comps = this.getComponents(imgArray);

 30356       var i, length;

 30358       if (bpc === 1) {

 30359         // inline decoding (= inversion) for 1 bpc images

 30360         length = width * height;

 30361         if (this.needsDecode) {

 30362           // invert and scale to {0, 255}

 30363           for (i = 0; i < length; ++i) {

 30364             buffer[i] = (comps[i] - 1) & 255;

 30365           }

 30366         } else {

 30367           // scale to {0, 255}

 30368           for (i = 0; i < length; ++i) {

 30369             buffer[i] = (-comps[i]) & 255;

 30370           }

 30371         }

 30372         return;

 30373       }

 30375       if (this.needsDecode) {

 30376         this.decodeBuffer(comps);

 30377       }

 30378       length = width * height;

 30379       // we aren't using a colorspace so we need to scale the value

 30380       var scale = 255 / ((1 << bpc) - 1);

 30381       for (i = 0; i < length; ++i) {

 30382         buffer[i] = (scale * comps[i]) | 0;

 30383       }

 30384     },

 30385     getImageBytes: function PDFImage_getImageBytes(length) {

 30386       this.image.reset();

 30387       return this.image.getBytes(length);

 30388     }

 30389   };

 30390   return PDFImage;

 30391 })();

 30394 // The Metrics object contains glyph widths (in glyph space units).

 30395 // As per PDF spec, for most fonts (Type 3 being an exception) a glyph

 30396 // space unit corresponds to 1/1000th of text space unit.

 30397 var Metrics = {

 30398   'Courier': 600,

 30399   'Courier-Bold': 600,

 30400   'Courier-BoldOblique': 600,

 30401   'Courier-Oblique': 600,

 30402   'Helvetica' : {

 30403     'space': 278,

 30404     'exclam': 278,

 30405     'quotedbl': 355,

 30406     'numbersign': 556,

 30407     'dollar': 556,

 30408     'percent': 889,

 30409     'ampersand': 667,

 30410     'quoteright': 222,

 30411     'parenleft': 333,

 30412     'parenright': 333,

 30413     'asterisk': 389,

 30414     'plus': 584,

 30415     'comma': 278,

 30416     'hyphen': 333,

 30417     'period': 278,

 30418     'slash': 278,

 30419     'zero': 556,

 30420     'one': 556,

 30421     'two': 556,

 30422     'three': 556,

 30423     'four': 556,

 30424     'five': 556,

 30425     'six': 556,

 30426     'seven': 556,

 30427     'eight': 556,

 30428     'nine': 556,

 30429     'colon': 278,

 30430     'semicolon': 278,

 30431     'less': 584,

 30432     'equal': 584,

 30433     'greater': 584,

 30434     'question': 556,

 30435     'at': 1015,

 30436     'A': 667,

 30437     'B': 667,

 30438     'C': 722,

 30439     'D': 722,

 30440     'E': 667,

 30441     'F': 611,

 30442     'G': 778,

 30443     'H': 722,

 30444     'I': 278,

 30445     'J': 500,

 30446     'K': 667,

 30447     'L': 556,

 30448     'M': 833,

 30449     'N': 722,

 30450     'O': 778,

 30451     'P': 667,

 30452     'Q': 778,

 30453     'R': 722,

 30454     'S': 667,

 30455     'T': 611,

 30456     'U': 722,

 30457     'V': 667,

 30458     'W': 944,

 30459     'X': 667,

 30460     'Y': 667,

 30461     'Z': 611,

 30462     'bracketleft': 278,

 30463     'backslash': 278,

 30464     'bracketright': 278,

 30465     'asciicircum': 469,

 30466     'underscore': 556,

 30467     'quoteleft': 222,

 30468     'a': 556,

 30469     'b': 556,

 30470     'c': 500,

 30471     'd': 556,

 30472     'e': 556,

 30473     'f': 278,

 30474     'g': 556,

 30475     'h': 556,

 30476     'i': 222,

 30477     'j': 222,

 30478     'k': 500,

 30479     'l': 222,

 30480     'm': 833,

 30481     'n': 556,

 30482     'o': 556,

 30483     'p': 556,

 30484     'q': 556,

 30485     'r': 333,

 30486     's': 500,

 30487     't': 278,

 30488     'u': 556,

 30489     'v': 500,

 30490     'w': 722,

 30491     'x': 500,

 30492     'y': 500,

 30493     'z': 500,

 30494     'braceleft': 334,

 30495     'bar': 260,

 30496     'braceright': 334,

 30497     'asciitilde': 584,

 30498     'exclamdown': 333,

 30499     'cent': 556,

 30500     'sterling': 556,

 30501     'fraction': 167,

 30502     'yen': 556,

 30503     'florin': 556,

 30504     'section': 556,

 30505     'currency': 556,

 30506     'quotesingle': 191,

 30507     'quotedblleft': 333,

 30508     'guillemotleft': 556,

 30509     'guilsinglleft': 333,

 30510     'guilsinglright': 333,

 30511     'fi': 500,

 30512     'fl': 500,

 30513     'endash': 556,

 30514     'dagger': 556,

 30515     'daggerdbl': 556,

 30516     'periodcentered': 278,

 30517     'paragraph': 537,

 30518     'bullet': 350,

 30519     'quotesinglbase': 222,

 30520     'quotedblbase': 333,

 30521     'quotedblright': 333,

 30522     'guillemotright': 556,

 30523     'ellipsis': 1000,

 30524     'perthousand': 1000,

 30525     'questiondown': 611,

 30526     'grave': 333,

 30527     'acute': 333,

 30528     'circumflex': 333,

 30529     'tilde': 333,

 30530     'macron': 333,

 30531     'breve': 333,

 30532     'dotaccent': 333,

 30533     'dieresis': 333,

 30534     'ring': 333,

 30535     'cedilla': 333,

 30536     'hungarumlaut': 333,

 30537     'ogonek': 333,

 30538     'caron': 333,

 30539     'emdash': 1000,

 30540     'AE': 1000,

 30541     'ordfeminine': 370,

 30542     'Lslash': 556,

 30543     'Oslash': 778,

 30544     'OE': 1000,

 30545     'ordmasculine': 365,

 30546     'ae': 889,

 30547     'dotlessi': 278,

 30548     'lslash': 222,

 30549     'oslash': 611,

 30550     'oe': 944,

 30551     'germandbls': 611,

 30552     'Idieresis': 278,

 30553     'eacute': 556,

 30554     'abreve': 556,

 30555     'uhungarumlaut': 556,

 30556     'ecaron': 556,

 30557     'Ydieresis': 667,

 30558     'divide': 584,

 30559     'Yacute': 667,

 30560     'Acircumflex': 667,

 30561     'aacute': 556,

 30562     'Ucircumflex': 722,

 30563     'yacute': 500,

 30564     'scommaaccent': 500,

 30565     'ecircumflex': 556,

 30566     'Uring': 722,

 30567     'Udieresis': 722,

 30568     'aogonek': 556,

 30569     'Uacute': 722,

 30570     'uogonek': 556,

 30571     'Edieresis': 667,

 30572     'Dcroat': 722,

 30573     'commaaccent': 250,

 30574     'copyright': 737,

 30575     'Emacron': 667,

 30576     'ccaron': 500,

 30577     'aring': 556,

 30578     'Ncommaaccent': 722,

 30579     'lacute': 222,

 30580     'agrave': 556,

 30581     'Tcommaaccent': 611,

 30582     'Cacute': 722,

 30583     'atilde': 556,

 30584     'Edotaccent': 667,

 30585     'scaron': 500,

 30586     'scedilla': 500,

 30587     'iacute': 278,

 30588     'lozenge': 471,

 30589     'Rcaron': 722,

 30590     'Gcommaaccent': 778,

 30591     'ucircumflex': 556,

 30592     'acircumflex': 556,

 30593     'Amacron': 667,

 30594     'rcaron': 333,

 30595     'ccedilla': 500,

 30596     'Zdotaccent': 611,

 30597     'Thorn': 667,

 30598     'Omacron': 778,

 30599     'Racute': 722,

 30600     'Sacute': 667,

 30601     'dcaron': 643,

 30602     'Umacron': 722,

 30603     'uring': 556,

 30604     'threesuperior': 333,

 30605     'Ograve': 778,

 30606     'Agrave': 667,

 30607     'Abreve': 667,

 30608     'multiply': 584,

 30609     'uacute': 556,

 30610     'Tcaron': 611,

 30611     'partialdiff': 476,

 30612     'ydieresis': 500,

 30613     'Nacute': 722,

 30614     'icircumflex': 278,

 30615     'Ecircumflex': 667,

 30616     'adieresis': 556,

 30617     'edieresis': 556,

 30618     'cacute': 500,

 30619     'nacute': 556,

 30620     'umacron': 556,

 30621     'Ncaron': 722,

 30622     'Iacute': 278,

 30623     'plusminus': 584,

 30624     'brokenbar': 260,

 30625     'registered': 737,

 30626     'Gbreve': 778,

 30627     'Idotaccent': 278,

 30628     'summation': 600,

 30629     'Egrave': 667,

 30630     'racute': 333,

 30631     'omacron': 556,

 30632     'Zacute': 611,

 30633     'Zcaron': 611,

 30634     'greaterequal': 549,

 30635     'Eth': 722,

 30636     'Ccedilla': 722,

 30637     'lcommaaccent': 222,

 30638     'tcaron': 317,

 30639     'eogonek': 556,

 30640     'Uogonek': 722,

 30641     'Aacute': 667,

 30642     'Adieresis': 667,

 30643     'egrave': 556,

 30644     'zacute': 500,

 30645     'iogonek': 222,

 30646     'Oacute': 778,

 30647     'oacute': 556,

 30648     'amacron': 556,

 30649     'sacute': 500,

 30650     'idieresis': 278,

 30651     'Ocircumflex': 778,

 30652     'Ugrave': 722,

 30653     'Delta': 612,

 30654     'thorn': 556,

 30655     'twosuperior': 333,

 30656     'Odieresis': 778,

 30657     'mu': 556,

 30658     'igrave': 278,

 30659     'ohungarumlaut': 556,

 30660     'Eogonek': 667,

 30661     'dcroat': 556,

 30662     'threequarters': 834,

 30663     'Scedilla': 667,

 30664     'lcaron': 299,

 30665     'Kcommaaccent': 667,

 30666     'Lacute': 556,

 30667     'trademark': 1000,

 30668     'edotaccent': 556,

 30669     'Igrave': 278,

 30670     'Imacron': 278,

 30671     'Lcaron': 556,

 30672     'onehalf': 834,

 30673     'lessequal': 549,

 30674     'ocircumflex': 556,

 30675     'ntilde': 556,

 30676     'Uhungarumlaut': 722,

 30677     'Eacute': 667,

 30678     'emacron': 556,

 30679     'gbreve': 556,

 30680     'onequarter': 834,

 30681     'Scaron': 667,

 30682     'Scommaaccent': 667,

 30683     'Ohungarumlaut': 778,

 30684     'degree': 400,

 30685     'ograve': 556,

 30686     'Ccaron': 722,

 30687     'ugrave': 556,

 30688     'radical': 453,

 30689     'Dcaron': 722,

 30690     'rcommaaccent': 333,

 30691     'Ntilde': 722,

 30692     'otilde': 556,

 30693     'Rcommaaccent': 722,

 30694     'Lcommaaccent': 556,

 30695     'Atilde': 667,

 30696     'Aogonek': 667,

 30697     'Aring': 667,

 30698     'Otilde': 778,

 30699     'zdotaccent': 500,

 30700     'Ecaron': 667,

 30701     'Iogonek': 278,

 30702     'kcommaaccent': 500,

 30703     'minus': 584,

 30704     'Icircumflex': 278,

 30705     'ncaron': 556,

 30706     'tcommaaccent': 278,

 30707     'logicalnot': 584,

 30708     'odieresis': 556,

 30709     'udieresis': 556,

 30710     'notequal': 549,

 30711     'gcommaaccent': 556,

 30712     'eth': 556,

 30713     'zcaron': 500,

 30714     'ncommaaccent': 556,

 30715     'onesuperior': 333,

 30716     'imacron': 278,

 30717     'Euro': 556

 30718   },

 30719   'Helvetica-Bold': {

 30720     'space': 278,

 30721     'exclam': 333,

 30722     'quotedbl': 474,

 30723     'numbersign': 556,

 30724     'dollar': 556,

 30725     'percent': 889,

 30726     'ampersand': 722,

 30727     'quoteright': 278,

 30728     'parenleft': 333,

 30729     'parenright': 333,

 30730     'asterisk': 389,

 30731     'plus': 584,

 30732     'comma': 278,

 30733     'hyphen': 333,

 30734     'period': 278,

 30735     'slash': 278,

 30736     'zero': 556,

 30737     'one': 556,

 30738     'two': 556,

 30739     'three': 556,

 30740     'four': 556,

 30741     'five': 556,

 30742     'six': 556,

 30743     'seven': 556,

 30744     'eight': 556,

 30745     'nine': 556,

 30746     'colon': 333,

 30747     'semicolon': 333,

 30748     'less': 584,

 30749     'equal': 584,

 30750     'greater': 584,

 30751     'question': 611,

 30752     'at': 975,

 30753     'A': 722,

 30754     'B': 722,

 30755     'C': 722,

 30756     'D': 722,

 30757     'E': 667,

 30758     'F': 611,

 30759     'G': 778,

 30760     'H': 722,

 30761     'I': 278,

 30762     'J': 556,

 30763     'K': 722,

 30764     'L': 611,

 30765     'M': 833,

 30766     'N': 722,

 30767     'O': 778,

 30768     'P': 667,

 30769     'Q': 778,

 30770     'R': 722,

 30771     'S': 667,

 30772     'T': 611,

 30773     'U': 722,

 30774     'V': 667,

 30775     'W': 944,

 30776     'X': 667,

 30777     'Y': 667,

 30778     'Z': 611,

 30779     'bracketleft': 333,

 30780     'backslash': 278,

 30781     'bracketright': 333,

 30782     'asciicircum': 584,

 30783     'underscore': 556,

 30784     'quoteleft': 278,

 30785     'a': 556,

 30786     'b': 611,

 30787     'c': 556,

 30788     'd': 611,

 30789     'e': 556,

 30790     'f': 333,

 30791     'g': 611,

 30792     'h': 611,

 30793     'i': 278,

 30794     'j': 278,

 30795     'k': 556,

 30796     'l': 278,

 30797     'm': 889,

 30798     'n': 611,

 30799     'o': 611,

 30800     'p': 611,

 30801     'q': 611,

 30802     'r': 389,

 30803     's': 556,

 30804     't': 333,

 30805     'u': 611,

 30806     'v': 556,

 30807     'w': 778,

 30808     'x': 556,

 30809     'y': 556,

 30810     'z': 500,

 30811     'braceleft': 389,

 30812     'bar': 280,

 30813     'braceright': 389,

 30814     'asciitilde': 584,

 30815     'exclamdown': 333,

 30816     'cent': 556,

 30817     'sterling': 556,

 30818     'fraction': 167,

 30819     'yen': 556,

 30820     'florin': 556,

 30821     'section': 556,

 30822     'currency': 556,

 30823     'quotesingle': 238,

 30824     'quotedblleft': 500,

 30825     'guillemotleft': 556,

 30826     'guilsinglleft': 333,

 30827     'guilsinglright': 333,

 30828     'fi': 611,

 30829     'fl': 611,

 30830     'endash': 556,

 30831     'dagger': 556,

 30832     'daggerdbl': 556,

 30833     'periodcentered': 278,

 30834     'paragraph': 556,

 30835     'bullet': 350,

 30836     'quotesinglbase': 278,

 30837     'quotedblbase': 500,

 30838     'quotedblright': 500,

 30839     'guillemotright': 556,

 30840     'ellipsis': 1000,

 30841     'perthousand': 1000,

 30842     'questiondown': 611,

 30843     'grave': 333,

 30844     'acute': 333,

 30845     'circumflex': 333,

 30846     'tilde': 333,

 30847     'macron': 333,

 30848     'breve': 333,

 30849     'dotaccent': 333,

 30850     'dieresis': 333,

 30851     'ring': 333,

 30852     'cedilla': 333,

 30853     'hungarumlaut': 333,

 30854     'ogonek': 333,

 30855     'caron': 333,

 30856     'emdash': 1000,

 30857     'AE': 1000,

 30858     'ordfeminine': 370,

 30859     'Lslash': 611,

 30860     'Oslash': 778,

 30861     'OE': 1000,

 30862     'ordmasculine': 365,

 30863     'ae': 889,

 30864     'dotlessi': 278,

 30865     'lslash': 278,

 30866     'oslash': 611,

 30867     'oe': 944,

 30868     'germandbls': 611,

 30869     'Idieresis': 278,

 30870     'eacute': 556,

 30871     'abreve': 556,

 30872     'uhungarumlaut': 611,

 30873     'ecaron': 556,

 30874     'Ydieresis': 667,

 30875     'divide': 584,

 30876     'Yacute': 667,

 30877     'Acircumflex': 722,

 30878     'aacute': 556,

 30879     'Ucircumflex': 722,

 30880     'yacute': 556,

 30881     'scommaaccent': 556,

 30882     'ecircumflex': 556,

 30883     'Uring': 722,

 30884     'Udieresis': 722,

 30885     'aogonek': 556,

 30886     'Uacute': 722,

 30887     'uogonek': 611,

 30888     'Edieresis': 667,

 30889     'Dcroat': 722,

 30890     'commaaccent': 250,

 30891     'copyright': 737,

 30892     'Emacron': 667,

 30893     'ccaron': 556,

 30894     'aring': 556,

 30895     'Ncommaaccent': 722,

 30896     'lacute': 278,

 30897     'agrave': 556,

 30898     'Tcommaaccent': 611,

 30899     'Cacute': 722,

 30900     'atilde': 556,

 30901     'Edotaccent': 667,

 30902     'scaron': 556,

 30903     'scedilla': 556,

 30904     'iacute': 278,

 30905     'lozenge': 494,

 30906     'Rcaron': 722,

 30907     'Gcommaaccent': 778,

 30908     'ucircumflex': 611,

 30909     'acircumflex': 556,

 30910     'Amacron': 722,

 30911     'rcaron': 389,

 30912     'ccedilla': 556,

 30913     'Zdotaccent': 611,

 30914     'Thorn': 667,

 30915     'Omacron': 778,

 30916     'Racute': 722,

 30917     'Sacute': 667,

 30918     'dcaron': 743,

 30919     'Umacron': 722,

 30920     'uring': 611,

 30921     'threesuperior': 333,

 30922     'Ograve': 778,

 30923     'Agrave': 722,

 30924     'Abreve': 722,

 30925     'multiply': 584,

 30926     'uacute': 611,

 30927     'Tcaron': 611,

 30928     'partialdiff': 494,

 30929     'ydieresis': 556,

 30930     'Nacute': 722,

 30931     'icircumflex': 278,

 30932     'Ecircumflex': 667,

 30933     'adieresis': 556,

 30934     'edieresis': 556,

 30935     'cacute': 556,

 30936     'nacute': 611,

 30937     'umacron': 611,

 30938     'Ncaron': 722,

 30939     'Iacute': 278,

 30940     'plusminus': 584,

 30941     'brokenbar': 280,

 30942     'registered': 737,

 30943     'Gbreve': 778,

 30944     'Idotaccent': 278,

 30945     'summation': 600,

 30946     'Egrave': 667,

 30947     'racute': 389,

 30948     'omacron': 611,

 30949     'Zacute': 611,

 30950     'Zcaron': 611,

 30951     'greaterequal': 549,

 30952     'Eth': 722,

 30953     'Ccedilla': 722,

 30954     'lcommaaccent': 278,

 30955     'tcaron': 389,

 30956     'eogonek': 556,

 30957     'Uogonek': 722,

 30958     'Aacute': 722,

 30959     'Adieresis': 722,

 30960     'egrave': 556,

 30961     'zacute': 500,

 30962     'iogonek': 278,

 30963     'Oacute': 778,

 30964     'oacute': 611,

 30965     'amacron': 556,

 30966     'sacute': 556,

 30967     'idieresis': 278,

 30968     'Ocircumflex': 778,

 30969     'Ugrave': 722,

 30970     'Delta': 612,

 30971     'thorn': 611,

 30972     'twosuperior': 333,

 30973     'Odieresis': 778,

 30974     'mu': 611,

 30975     'igrave': 278,

 30976     'ohungarumlaut': 611,

 30977     'Eogonek': 667,

 30978     'dcroat': 611,

 30979     'threequarters': 834,

 30980     'Scedilla': 667,

 30981     'lcaron': 400,

 30982     'Kcommaaccent': 722,

 30983     'Lacute': 611,

 30984     'trademark': 1000,

 30985     'edotaccent': 556,

 30986     'Igrave': 278,

 30987     'Imacron': 278,

 30988     'Lcaron': 611,

 30989     'onehalf': 834,

 30990     'lessequal': 549,

 30991     'ocircumflex': 611,

 30992     'ntilde': 611,

 30993     'Uhungarumlaut': 722,

 30994     'Eacute': 667,

 30995     'emacron': 556,

 30996     'gbreve': 611,

 30997     'onequarter': 834,

 30998     'Scaron': 667,

 30999     'Scommaaccent': 667,

 31000     'Ohungarumlaut': 778,

 31001     'degree': 400,

 31002     'ograve': 611,

 31003     'Ccaron': 722,

 31004     'ugrave': 611,

 31005     'radical': 549,

 31006     'Dcaron': 722,

 31007     'rcommaaccent': 389,

 31008     'Ntilde': 722,

 31009     'otilde': 611,

 31010     'Rcommaaccent': 722,

 31011     'Lcommaaccent': 611,

 31012     'Atilde': 722,

 31013     'Aogonek': 722,

 31014     'Aring': 722,

 31015     'Otilde': 778,

 31016     'zdotaccent': 500,

 31017     'Ecaron': 667,

 31018     'Iogonek': 278,

 31019     'kcommaaccent': 556,

 31020     'minus': 584,

 31021     'Icircumflex': 278,

 31022     'ncaron': 611,

 31023     'tcommaaccent': 333,

 31024     'logicalnot': 584,

 31025     'odieresis': 611,

 31026     'udieresis': 611,

 31027     'notequal': 549,

 31028     'gcommaaccent': 611,

 31029     'eth': 611,

 31030     'zcaron': 500,

 31031     'ncommaaccent': 611,

 31032     'onesuperior': 333,

 31033     'imacron': 278,

 31034     'Euro': 556

 31035   },

 31036   'Helvetica-BoldOblique': {

 31037     'space': 278,

 31038     'exclam': 333,

 31039     'quotedbl': 474,

 31040     'numbersign': 556,

 31041     'dollar': 556,

 31042     'percent': 889,

 31043     'ampersand': 722,

 31044     'quoteright': 278,

 31045     'parenleft': 333,

 31046     'parenright': 333,

 31047     'asterisk': 389,

 31048     'plus': 584,

 31049     'comma': 278,

 31050     'hyphen': 333,

 31051     'period': 278,

 31052     'slash': 278,

 31053     'zero': 556,

 31054     'one': 556,

 31055     'two': 556,

 31056     'three': 556,

 31057     'four': 556,

 31058     'five': 556,

 31059     'six': 556,

 31060     'seven': 556,

 31061     'eight': 556,

 31062     'nine': 556,

 31063     'colon': 333,

 31064     'semicolon': 333,

 31065     'less': 584,

 31066     'equal': 584,

 31067     'greater': 584,

 31068     'question': 611,

 31069     'at': 975,

 31070     'A': 722,

 31071     'B': 722,

 31072     'C': 722,

 31073     'D': 722,

 31074     'E': 667,

 31075     'F': 611,

 31076     'G': 778,

 31077     'H': 722,

 31078     'I': 278,

 31079     'J': 556,

 31080     'K': 722,

 31081     'L': 611,

 31082     'M': 833,

 31083     'N': 722,

 31084     'O': 778,

 31085     'P': 667,

 31086     'Q': 778,

 31087     'R': 722,

 31088     'S': 667,

 31089     'T': 611,

 31090     'U': 722,

 31091     'V': 667,

 31092     'W': 944,

 31093     'X': 667,

 31094     'Y': 667,

 31095     'Z': 611,

 31096     'bracketleft': 333,

 31097     'backslash': 278,

 31098     'bracketright': 333,

 31099     'asciicircum': 584,

 31100     'underscore': 556,

 31101     'quoteleft': 278,

 31102     'a': 556,

 31103     'b': 611,

 31104     'c': 556,

 31105     'd': 611,

 31106     'e': 556,

 31107     'f': 333,

 31108     'g': 611,

 31109     'h': 611,

 31110     'i': 278,

 31111     'j': 278,

 31112     'k': 556,

 31113     'l': 278,

 31114     'm': 889,

 31115     'n': 611,

 31116     'o': 611,

 31117     'p': 611,

 31118     'q': 611,

 31119     'r': 389,

 31120     's': 556,

 31121     't': 333,

 31122     'u': 611,

 31123     'v': 556,

 31124     'w': 778,

 31125     'x': 556,

 31126     'y': 556,

 31127     'z': 500,

 31128     'braceleft': 389,

 31129     'bar': 280,

 31130     'braceright': 389,

 31131     'asciitilde': 584,

 31132     'exclamdown': 333,

 31133     'cent': 556,

 31134     'sterling': 556,

 31135     'fraction': 167,

 31136     'yen': 556,

 31137     'florin': 556,

 31138     'section': 556,

 31139     'currency': 556,

 31140     'quotesingle': 238,

 31141     'quotedblleft': 500,

 31142     'guillemotleft': 556,

 31143     'guilsinglleft': 333,

 31144     'guilsinglright': 333,

 31145     'fi': 611,

 31146     'fl': 611,

 31147     'endash': 556,

 31148     'dagger': 556,

 31149     'daggerdbl': 556,

 31150     'periodcentered': 278,

 31151     'paragraph': 556,

 31152     'bullet': 350,

 31153     'quotesinglbase': 278,

 31154     'quotedblbase': 500,

 31155     'quotedblright': 500,

 31156     'guillemotright': 556,

 31157     'ellipsis': 1000,

 31158     'perthousand': 1000,

 31159     'questiondown': 611,

 31160     'grave': 333,

 31161     'acute': 333,

 31162     'circumflex': 333,

 31163     'tilde': 333,

 31164     'macron': 333,

 31165     'breve': 333,

 31166     'dotaccent': 333,

 31167     'dieresis': 333,

 31168     'ring': 333,

 31169     'cedilla': 333,

 31170     'hungarumlaut': 333,

 31171     'ogonek': 333,

 31172     'caron': 333,

 31173     'emdash': 1000,

 31174     'AE': 1000,

 31175     'ordfeminine': 370,

 31176     'Lslash': 611,

 31177     'Oslash': 778,

 31178     'OE': 1000,

 31179     'ordmasculine': 365,

 31180     'ae': 889,

 31181     'dotlessi': 278,

 31182     'lslash': 278,

 31183     'oslash': 611,

 31184     'oe': 944,

 31185     'germandbls': 611,

 31186     'Idieresis': 278,

 31187     'eacute': 556,

 31188     'abreve': 556,

 31189     'uhungarumlaut': 611,

 31190     'ecaron': 556,

 31191     'Ydieresis': 667,

 31192     'divide': 584,

 31193     'Yacute': 667,

 31194     'Acircumflex': 722,

 31195     'aacute': 556,

 31196     'Ucircumflex': 722,

 31197     'yacute': 556,

 31198     'scommaaccent': 556,

 31199     'ecircumflex': 556,

 31200     'Uring': 722,

 31201     'Udieresis': 722,

 31202     'aogonek': 556,

 31203     'Uacute': 722,

 31204     'uogonek': 611,

 31205     'Edieresis': 667,

 31206     'Dcroat': 722,

 31207     'commaaccent': 250,

 31208     'copyright': 737,

 31209     'Emacron': 667,

 31210     'ccaron': 556,

 31211     'aring': 556,

 31212     'Ncommaaccent': 722,

 31213     'lacute': 278,

 31214     'agrave': 556,

 31215     'Tcommaaccent': 611,

 31216     'Cacute': 722,

 31217     'atilde': 556,

 31218     'Edotaccent': 667,

 31219     'scaron': 556,

 31220     'scedilla': 556,

 31221     'iacute': 278,

 31222     'lozenge': 494,

 31223     'Rcaron': 722,

 31224     'Gcommaaccent': 778,

 31225     'ucircumflex': 611,

 31226     'acircumflex': 556,

 31227     'Amacron': 722,

 31228     'rcaron': 389,

 31229     'ccedilla': 556,

 31230     'Zdotaccent': 611,

 31231     'Thorn': 667,

 31232     'Omacron': 778,

 31233     'Racute': 722,

 31234     'Sacute': 667,

 31235     'dcaron': 743,

 31236     'Umacron': 722,

 31237     'uring': 611,

 31238     'threesuperior': 333,

 31239     'Ograve': 778,

 31240     'Agrave': 722,

 31241     'Abreve': 722,

 31242     'multiply': 584,

 31243     'uacute': 611,

 31244     'Tcaron': 611,

 31245     'partialdiff': 494,

 31246     'ydieresis': 556,

 31247     'Nacute': 722,

 31248     'icircumflex': 278,

 31249     'Ecircumflex': 667,

 31250     'adieresis': 556,

 31251     'edieresis': 556,

 31252     'cacute': 556,

 31253     'nacute': 611,

 31254     'umacron': 611,

 31255     'Ncaron': 722,

 31256     'Iacute': 278,

 31257     'plusminus': 584,

 31258     'brokenbar': 280,

 31259     'registered': 737,

 31260     'Gbreve': 778,

 31261     'Idotaccent': 278,

 31262     'summation': 600,

 31263     'Egrave': 667,

 31264     'racute': 389,

 31265     'omacron': 611,

 31266     'Zacute': 611,

 31267     'Zcaron': 611,

 31268     'greaterequal': 549,

 31269     'Eth': 722,

 31270     'Ccedilla': 722,

 31271     'lcommaaccent': 278,

 31272     'tcaron': 389,

 31273     'eogonek': 556,

 31274     'Uogonek': 722,

 31275     'Aacute': 722,

 31276     'Adieresis': 722,

 31277     'egrave': 556,

 31278     'zacute': 500,

 31279     'iogonek': 278,

 31280     'Oacute': 778,

 31281     'oacute': 611,

 31282     'amacron': 556,

 31283     'sacute': 556,

 31284     'idieresis': 278,

 31285     'Ocircumflex': 778,

 31286     'Ugrave': 722,

 31287     'Delta': 612,

 31288     'thorn': 611,

 31289     'twosuperior': 333,

 31290     'Odieresis': 778,

 31291     'mu': 611,

 31292     'igrave': 278,

 31293     'ohungarumlaut': 611,

 31294     'Eogonek': 667,

 31295     'dcroat': 611,

 31296     'threequarters': 834,

 31297     'Scedilla': 667,

 31298     'lcaron': 400,

 31299     'Kcommaaccent': 722,

 31300     'Lacute': 611,

 31301     'trademark': 1000,

 31302     'edotaccent': 556,

 31303     'Igrave': 278,

 31304     'Imacron': 278,

 31305     'Lcaron': 611,

 31306     'onehalf': 834,

 31307     'lessequal': 549,

 31308     'ocircumflex': 611,

 31309     'ntilde': 611,

 31310     'Uhungarumlaut': 722,

 31311     'Eacute': 667,

 31312     'emacron': 556,

 31313     'gbreve': 611,

 31314     'onequarter': 834,

 31315     'Scaron': 667,

 31316     'Scommaaccent': 667,

 31317     'Ohungarumlaut': 778,

 31318     'degree': 400,

 31319     'ograve': 611,

 31320     'Ccaron': 722,

 31321     'ugrave': 611,

 31322     'radical': 549,

 31323     'Dcaron': 722,

 31324     'rcommaaccent': 389,

 31325     'Ntilde': 722,

 31326     'otilde': 611,

 31327     'Rcommaaccent': 722,

 31328     'Lcommaaccent': 611,

 31329     'Atilde': 722,

 31330     'Aogonek': 722,

 31331     'Aring': 722,

 31332     'Otilde': 778,

 31333     'zdotaccent': 500,

 31334     'Ecaron': 667,

 31335     'Iogonek': 278,

 31336     'kcommaaccent': 556,

 31337     'minus': 584,

 31338     'Icircumflex': 278,

 31339     'ncaron': 611,

 31340     'tcommaaccent': 333,

 31341     'logicalnot': 584,

 31342     'odieresis': 611,

 31343     'udieresis': 611,

 31344     'notequal': 549,

 31345     'gcommaaccent': 611,

 31346     'eth': 611,

 31347     'zcaron': 500,

 31348     'ncommaaccent': 611,

 31349     'onesuperior': 333,

 31350     'imacron': 278,

 31351     'Euro': 556

 31352   },

 31353   'Helvetica-Oblique' : {

 31354     'space': 278,

 31355     'exclam': 278,

 31356     'quotedbl': 355,

 31357     'numbersign': 556,

 31358     'dollar': 556,

 31359     'percent': 889,

 31360     'ampersand': 667,

 31361     'quoteright': 222,

 31362     'parenleft': 333,

 31363     'parenright': 333,

 31364     'asterisk': 389,

 31365     'plus': 584,

 31366     'comma': 278,

 31367     'hyphen': 333,

 31368     'period': 278,

 31369     'slash': 278,

 31370     'zero': 556,

 31371     'one': 556,

 31372     'two': 556,

 31373     'three': 556,

 31374     'four': 556,

 31375     'five': 556,

 31376     'six': 556,

 31377     'seven': 556,

 31378     'eight': 556,

 31379     'nine': 556,

 31380     'colon': 278,

 31381     'semicolon': 278,

 31382     'less': 584,

 31383     'equal': 584,

 31384     'greater': 584,

 31385     'question': 556,

 31386     'at': 1015,

 31387     'A': 667,

 31388     'B': 667,

 31389     'C': 722,

 31390     'D': 722,

 31391     'E': 667,

 31392     'F': 611,

 31393     'G': 778,

 31394     'H': 722,

 31395     'I': 278,

 31396     'J': 500,

 31397     'K': 667,

 31398     'L': 556,

 31399     'M': 833,

 31400     'N': 722,

 31401     'O': 778,

 31402     'P': 667,

 31403     'Q': 778,

 31404     'R': 722,

 31405     'S': 667,

 31406     'T': 611,

 31407     'U': 722,

 31408     'V': 667,

 31409     'W': 944,

 31410     'X': 667,

 31411     'Y': 667,

 31412     'Z': 611,

 31413     'bracketleft': 278,

 31414     'backslash': 278,

 31415     'bracketright': 278,

 31416     'asciicircum': 469,

 31417     'underscore': 556,

 31418     'quoteleft': 222,

 31419     'a': 556,

 31420     'b': 556,

 31421     'c': 500,

 31422     'd': 556,

 31423     'e': 556,

 31424     'f': 278,

 31425     'g': 556,

 31426     'h': 556,

 31427     'i': 222,

 31428     'j': 222,

 31429     'k': 500,

 31430     'l': 222,

 31431     'm': 833,

 31432     'n': 556,

 31433     'o': 556,

 31434     'p': 556,

 31435     'q': 556,

 31436     'r': 333,

 31437     's': 500,

 31438     't': 278,

 31439     'u': 556,

 31440     'v': 500,

 31441     'w': 722,

 31442     'x': 500,

 31443     'y': 500,

 31444     'z': 500,

 31445     'braceleft': 334,

 31446     'bar': 260,

 31447     'braceright': 334,

 31448     'asciitilde': 584,

 31449     'exclamdown': 333,

 31450     'cent': 556,

 31451     'sterling': 556,

 31452     'fraction': 167,

 31453     'yen': 556,

 31454     'florin': 556,

 31455     'section': 556,

 31456     'currency': 556,

 31457     'quotesingle': 191,

 31458     'quotedblleft': 333,

 31459     'guillemotleft': 556,

 31460     'guilsinglleft': 333,

 31461     'guilsinglright': 333,

 31462     'fi': 500,

 31463     'fl': 500,

 31464     'endash': 556,

 31465     'dagger': 556,

 31466     'daggerdbl': 556,

 31467     'periodcentered': 278,

 31468     'paragraph': 537,

 31469     'bullet': 350,

 31470     'quotesinglbase': 222,

 31471     'quotedblbase': 333,

 31472     'quotedblright': 333,

 31473     'guillemotright': 556,

 31474     'ellipsis': 1000,

 31475     'perthousand': 1000,

 31476     'questiondown': 611,

 31477     'grave': 333,

 31478     'acute': 333,

 31479     'circumflex': 333,

 31480     'tilde': 333,

 31481     'macron': 333,

 31482     'breve': 333,

 31483     'dotaccent': 333,

 31484     'dieresis': 333,

 31485     'ring': 333,

 31486     'cedilla': 333,

 31487     'hungarumlaut': 333,

 31488     'ogonek': 333,

 31489     'caron': 333,

 31490     'emdash': 1000,

 31491     'AE': 1000,

 31492     'ordfeminine': 370,

 31493     'Lslash': 556,

 31494     'Oslash': 778,

 31495     'OE': 1000,

 31496     'ordmasculine': 365,

 31497     'ae': 889,

 31498     'dotlessi': 278,

 31499     'lslash': 222,

 31500     'oslash': 611,

 31501     'oe': 944,

 31502     'germandbls': 611,

 31503     'Idieresis': 278,

 31504     'eacute': 556,

 31505     'abreve': 556,

 31506     'uhungarumlaut': 556,

 31507     'ecaron': 556,

 31508     'Ydieresis': 667,

 31509     'divide': 584,

 31510     'Yacute': 667,

 31511     'Acircumflex': 667,

 31512     'aacute': 556,

 31513     'Ucircumflex': 722,

 31514     'yacute': 500,

 31515     'scommaaccent': 500,

 31516     'ecircumflex': 556,

 31517     'Uring': 722,

 31518     'Udieresis': 722,

 31519     'aogonek': 556,

 31520     'Uacute': 722,

 31521     'uogonek': 556,

 31522     'Edieresis': 667,

 31523     'Dcroat': 722,

 31524     'commaaccent': 250,

 31525     'copyright': 737,

 31526     'Emacron': 667,

 31527     'ccaron': 500,

 31528     'aring': 556,

 31529     'Ncommaaccent': 722,

 31530     'lacute': 222,

 31531     'agrave': 556,

 31532     'Tcommaaccent': 611,

 31533     'Cacute': 722,

 31534     'atilde': 556,

 31535     'Edotaccent': 667,

 31536     'scaron': 500,

 31537     'scedilla': 500,

 31538     'iacute': 278,

 31539     'lozenge': 471,

 31540     'Rcaron': 722,

 31541     'Gcommaaccent': 778,

 31542     'ucircumflex': 556,

 31543     'acircumflex': 556,

 31544     'Amacron': 667,

 31545     'rcaron': 333,

 31546     'ccedilla': 500,

 31547     'Zdotaccent': 611,

 31548     'Thorn': 667,

 31549     'Omacron': 778,

 31550     'Racute': 722,

 31551     'Sacute': 667,

 31552     'dcaron': 643,

 31553     'Umacron': 722,

 31554     'uring': 556,

 31555     'threesuperior': 333,

 31556     'Ograve': 778,

 31557     'Agrave': 667,

 31558     'Abreve': 667,

 31559     'multiply': 584,

 31560     'uacute': 556,

 31561     'Tcaron': 611,

 31562     'partialdiff': 476,

 31563     'ydieresis': 500,

 31564     'Nacute': 722,

 31565     'icircumflex': 278,

 31566     'Ecircumflex': 667,

 31567     'adieresis': 556,

 31568     'edieresis': 556,

 31569     'cacute': 500,

 31570     'nacute': 556,

 31571     'umacron': 556,

 31572     'Ncaron': 722,

 31573     'Iacute': 278,

 31574     'plusminus': 584,

 31575     'brokenbar': 260,

 31576     'registered': 737,

 31577     'Gbreve': 778,

 31578     'Idotaccent': 278,

 31579     'summation': 600,

 31580     'Egrave': 667,

 31581     'racute': 333,

 31582     'omacron': 556,

 31583     'Zacute': 611,

 31584     'Zcaron': 611,

 31585     'greaterequal': 549,

 31586     'Eth': 722,

 31587     'Ccedilla': 722,

 31588     'lcommaaccent': 222,

 31589     'tcaron': 317,

 31590     'eogonek': 556,

 31591     'Uogonek': 722,

 31592     'Aacute': 667,

 31593     'Adieresis': 667,

 31594     'egrave': 556,

 31595     'zacute': 500,

 31596     'iogonek': 222,

 31597     'Oacute': 778,

 31598     'oacute': 556,

 31599     'amacron': 556,

 31600     'sacute': 500,

 31601     'idieresis': 278,

 31602     'Ocircumflex': 778,

 31603     'Ugrave': 722,

 31604     'Delta': 612,

 31605     'thorn': 556,

 31606     'twosuperior': 333,

 31607     'Odieresis': 778,

 31608     'mu': 556,

 31609     'igrave': 278,

 31610     'ohungarumlaut': 556,

 31611     'Eogonek': 667,

 31612     'dcroat': 556,

 31613     'threequarters': 834,

 31614     'Scedilla': 667,

 31615     'lcaron': 299,

 31616     'Kcommaaccent': 667,

 31617     'Lacute': 556,

 31618     'trademark': 1000,

 31619     'edotaccent': 556,

 31620     'Igrave': 278,

 31621     'Imacron': 278,

 31622     'Lcaron': 556,

 31623     'onehalf': 834,

 31624     'lessequal': 549,

 31625     'ocircumflex': 556,

 31626     'ntilde': 556,

 31627     'Uhungarumlaut': 722,

 31628     'Eacute': 667,

 31629     'emacron': 556,

 31630     'gbreve': 556,

 31631     'onequarter': 834,

 31632     'Scaron': 667,

 31633     'Scommaaccent': 667,

 31634     'Ohungarumlaut': 778,

 31635     'degree': 400,

 31636     'ograve': 556,

 31637     'Ccaron': 722,

 31638     'ugrave': 556,

 31639     'radical': 453,

 31640     'Dcaron': 722,

 31641     'rcommaaccent': 333,

 31642     'Ntilde': 722,

 31643     'otilde': 556,

 31644     'Rcommaaccent': 722,

 31645     'Lcommaaccent': 556,

 31646     'Atilde': 667,

 31647     'Aogonek': 667,

 31648     'Aring': 667,

 31649     'Otilde': 778,

 31650     'zdotaccent': 500,

 31651     'Ecaron': 667,

 31652     'Iogonek': 278,

 31653     'kcommaaccent': 500,

 31654     'minus': 584,

 31655     'Icircumflex': 278,

 31656     'ncaron': 556,

 31657     'tcommaaccent': 278,

 31658     'logicalnot': 584,

 31659     'odieresis': 556,

 31660     'udieresis': 556,

 31661     'notequal': 549,

 31662     'gcommaaccent': 556,

 31663     'eth': 556,

 31664     'zcaron': 500,

 31665     'ncommaaccent': 556,

 31666     'onesuperior': 333,

 31667     'imacron': 278,

 31668     'Euro': 556

 31669   },

 31670   'Symbol': {

 31671     'space': 250,

 31672     'exclam': 333,

 31673     'universal': 713,

 31674     'numbersign': 500,

 31675     'existential': 549,

 31676     'percent': 833,

 31677     'ampersand': 778,

 31678     'suchthat': 439,

 31679     'parenleft': 333,

 31680     'parenright': 333,

 31681     'asteriskmath': 500,

 31682     'plus': 549,

 31683     'comma': 250,

 31684     'minus': 549,

 31685     'period': 250,

 31686     'slash': 278,

 31687     'zero': 500,

 31688     'one': 500,

 31689     'two': 500,

 31690     'three': 500,

 31691     'four': 500,

 31692     'five': 500,

 31693     'six': 500,

 31694     'seven': 500,

 31695     'eight': 500,

 31696     'nine': 500,

 31697     'colon': 278,

 31698     'semicolon': 278,

 31699     'less': 549,

 31700     'equal': 549,

 31701     'greater': 549,

 31702     'question': 444,

 31703     'congruent': 549,

 31704     'Alpha': 722,

 31705     'Beta': 667,

 31706     'Chi': 722,

 31707     'Delta': 612,

 31708     'Epsilon': 611,

 31709     'Phi': 763,

 31710     'Gamma': 603,

 31711     'Eta': 722,

 31712     'Iota': 333,

 31713     'theta1': 631,

 31714     'Kappa': 722,

 31715     'Lambda': 686,

 31716     'Mu': 889,

 31717     'Nu': 722,

 31718     'Omicron': 722,

 31719     'Pi': 768,

 31720     'Theta': 741,

 31721     'Rho': 556,

 31722     'Sigma': 592,

 31723     'Tau': 611,

 31724     'Upsilon': 690,

 31725     'sigma1': 439,

 31726     'Omega': 768,

 31727     'Xi': 645,

 31728     'Psi': 795,

 31729     'Zeta': 611,

 31730     'bracketleft': 333,

 31731     'therefore': 863,

 31732     'bracketright': 333,

 31733     'perpendicular': 658,

 31734     'underscore': 500,

 31735     'radicalex': 500,

 31736     'alpha': 631,

 31737     'beta': 549,

 31738     'chi': 549,

 31739     'delta': 494,

 31740     'epsilon': 439,

 31741     'phi': 521,

 31742     'gamma': 411,

 31743     'eta': 603,

 31744     'iota': 329,

 31745     'phi1': 603,

 31746     'kappa': 549,

 31747     'lambda': 549,

 31748     'mu': 576,

 31749     'nu': 521,

 31750     'omicron': 549,

 31751     'pi': 549,

 31752     'theta': 521,

 31753     'rho': 549,

 31754     'sigma': 603,

 31755     'tau': 439,

 31756     'upsilon': 576,

 31757     'omega1': 713,

 31758     'omega': 686,

 31759     'xi': 493,

 31760     'psi': 686,

 31761     'zeta': 494,

 31762     'braceleft': 480,

 31763     'bar': 200,

 31764     'braceright': 480,

 31765     'similar': 549,

 31766     'Euro': 750,

 31767     'Upsilon1': 620,

 31768     'minute': 247,

 31769     'lessequal': 549,

 31770     'fraction': 167,

 31771     'infinity': 713,

 31772     'florin': 500,

 31773     'club': 753,

 31774     'diamond': 753,

 31775     'heart': 753,

 31776     'spade': 753,

 31777     'arrowboth': 1042,

 31778     'arrowleft': 987,

 31779     'arrowup': 603,

 31780     'arrowright': 987,

 31781     'arrowdown': 603,

 31782     'degree': 400,

 31783     'plusminus': 549,

 31784     'second': 411,

 31785     'greaterequal': 549,

 31786     'multiply': 549,

 31787     'proportional': 713,

 31788     'partialdiff': 494,

 31789     'bullet': 460,

 31790     'divide': 549,

 31791     'notequal': 549,

 31792     'equivalence': 549,

 31793     'approxequal': 549,

 31794     'ellipsis': 1000,

 31795     'arrowvertex': 603,

 31796     'arrowhorizex': 1000,

 31797     'carriagereturn': 658,

 31798     'aleph': 823,

 31799     'Ifraktur': 686,

 31800     'Rfraktur': 795,

 31801     'weierstrass': 987,

 31802     'circlemultiply': 768,

 31803     'circleplus': 768,

 31804     'emptyset': 823,

 31805     'intersection': 768,

 31806     'union': 768,

 31807     'propersuperset': 713,

 31808     'reflexsuperset': 713,

 31809     'notsubset': 713,

 31810     'propersubset': 713,

 31811     'reflexsubset': 713,

 31812     'element': 713,

 31813     'notelement': 713,

 31814     'angle': 768,

 31815     'gradient': 713,

 31816     'registerserif': 790,

 31817     'copyrightserif': 790,

 31818     'trademarkserif': 890,

 31819     'product': 823,

 31820     'radical': 549,

 31821     'dotmath': 250,

 31822     'logicalnot': 713,

 31823     'logicaland': 603,

 31824     'logicalor': 603,

 31825     'arrowdblboth': 1042,

 31826     'arrowdblleft': 987,

 31827     'arrowdblup': 603,

 31828     'arrowdblright': 987,

 31829     'arrowdbldown': 603,

 31830     'lozenge': 494,

 31831     'angleleft': 329,

 31832     'registersans': 790,

 31833     'copyrightsans': 790,

 31834     'trademarksans': 786,

 31835     'summation': 713,

 31836     'parenlefttp': 384,

 31837     'parenleftex': 384,

 31838     'parenleftbt': 384,

 31839     'bracketlefttp': 384,

 31840     'bracketleftex': 384,

 31841     'bracketleftbt': 384,

 31842     'bracelefttp': 494,

 31843     'braceleftmid': 494,

 31844     'braceleftbt': 494,

 31845     'braceex': 494,

 31846     'angleright': 329,

 31847     'integral': 274,

 31848     'integraltp': 686,

 31849     'integralex': 686,

 31850     'integralbt': 686,

 31851     'parenrighttp': 384,

 31852     'parenrightex': 384,

 31853     'parenrightbt': 384,

 31854     'bracketrighttp': 384,

 31855     'bracketrightex': 384,

 31856     'bracketrightbt': 384,

 31857     'bracerighttp': 494,

 31858     'bracerightmid': 494,

 31859     'bracerightbt': 494,

 31860     'apple': 790

 31861   },

 31862   'Times-Roman': {

 31863     'space': 250,

 31864     'exclam': 333,

 31865     'quotedbl': 408,

 31866     'numbersign': 500,

 31867     'dollar': 500,

 31868     'percent': 833,

 31869     'ampersand': 778,

 31870     'quoteright': 333,

 31871     'parenleft': 333,

 31872     'parenright': 333,

 31873     'asterisk': 500,

 31874     'plus': 564,

 31875     'comma': 250,

 31876     'hyphen': 333,

 31877     'period': 250,

 31878     'slash': 278,

 31879     'zero': 500,

 31880     'one': 500,

 31881     'two': 500,

 31882     'three': 500,

 31883     'four': 500,

 31884     'five': 500,

 31885     'six': 500,

 31886     'seven': 500,

 31887     'eight': 500,

 31888     'nine': 500,

 31889     'colon': 278,

 31890     'semicolon': 278,

 31891     'less': 564,

 31892     'equal': 564,

 31893     'greater': 564,

 31894     'question': 444,

 31895     'at': 921,

 31896     'A': 722,

 31897     'B': 667,

 31898     'C': 667,

 31899     'D': 722,

 31900     'E': 611,

 31901     'F': 556,

 31902     'G': 722,

 31903     'H': 722,

 31904     'I': 333,

 31905     'J': 389,

 31906     'K': 722,

 31907     'L': 611,

 31908     'M': 889,

 31909     'N': 722,

 31910     'O': 722,

 31911     'P': 556,

 31912     'Q': 722,

 31913     'R': 667,

 31914     'S': 556,

 31915     'T': 611,

 31916     'U': 722,

 31917     'V': 722,

 31918     'W': 944,

 31919     'X': 722,

 31920     'Y': 722,

 31921     'Z': 611,

 31922     'bracketleft': 333,

 31923     'backslash': 278,

 31924     'bracketright': 333,

 31925     'asciicircum': 469,

 31926     'underscore': 500,

 31927     'quoteleft': 333,

 31928     'a': 444,

 31929     'b': 500,

 31930     'c': 444,

 31931     'd': 500,

 31932     'e': 444,

 31933     'f': 333,

 31934     'g': 500,

 31935     'h': 500,

 31936     'i': 278,

 31937     'j': 278,

 31938     'k': 500,

 31939     'l': 278,

 31940     'm': 778,

 31941     'n': 500,

 31942     'o': 500,

 31943     'p': 500,

 31944     'q': 500,

 31945     'r': 333,

 31946     's': 389,

 31947     't': 278,

 31948     'u': 500,

 31949     'v': 500,

 31950     'w': 722,

 31951     'x': 500,

 31952     'y': 500,

 31953     'z': 444,

 31954     'braceleft': 480,

 31955     'bar': 200,

 31956     'braceright': 480,

 31957     'asciitilde': 541,

 31958     'exclamdown': 333,

 31959     'cent': 500,

 31960     'sterling': 500,

 31961     'fraction': 167,

 31962     'yen': 500,

 31963     'florin': 500,

 31964     'section': 500,

 31965     'currency': 500,

 31966     'quotesingle': 180,

 31967     'quotedblleft': 444,

 31968     'guillemotleft': 500,

 31969     'guilsinglleft': 333,

 31970     'guilsinglright': 333,

 31971     'fi': 556,

 31972     'fl': 556,

 31973     'endash': 500,

 31974     'dagger': 500,

 31975     'daggerdbl': 500,

 31976     'periodcentered': 250,

 31977     'paragraph': 453,

 31978     'bullet': 350,

 31979     'quotesinglbase': 333,

 31980     'quotedblbase': 444,

 31981     'quotedblright': 444,

 31982     'guillemotright': 500,

 31983     'ellipsis': 1000,

 31984     'perthousand': 1000,

 31985     'questiondown': 444,

 31986     'grave': 333,

 31987     'acute': 333,

 31988     'circumflex': 333,

 31989     'tilde': 333,

 31990     'macron': 333,

 31991     'breve': 333,

 31992     'dotaccent': 333,

 31993     'dieresis': 333,

 31994     'ring': 333,

 31995     'cedilla': 333,

 31996     'hungarumlaut': 333,

 31997     'ogonek': 333,

 31998     'caron': 333,

 31999     'emdash': 1000,

 32000     'AE': 889,

 32001     'ordfeminine': 276,

 32002     'Lslash': 611,

 32003     'Oslash': 722,

 32004     'OE': 889,

 32005     'ordmasculine': 310,

 32006     'ae': 667,

 32007     'dotlessi': 278,

 32008     'lslash': 278,

 32009     'oslash': 500,

 32010     'oe': 722,

 32011     'germandbls': 500,

 32012     'Idieresis': 333,

 32013     'eacute': 444,

 32014     'abreve': 444,

 32015     'uhungarumlaut': 500,

 32016     'ecaron': 444,

 32017     'Ydieresis': 722,

 32018     'divide': 564,

 32019     'Yacute': 722,

 32020     'Acircumflex': 722,

 32021     'aacute': 444,

 32022     'Ucircumflex': 722,

 32023     'yacute': 500,

 32024     'scommaaccent': 389,

 32025     'ecircumflex': 444,

 32026     'Uring': 722,

 32027     'Udieresis': 722,

 32028     'aogonek': 444,

 32029     'Uacute': 722,

 32030     'uogonek': 500,

 32031     'Edieresis': 611,

 32032     'Dcroat': 722,

 32033     'commaaccent': 250,

 32034     'copyright': 760,

 32035     'Emacron': 611,

 32036     'ccaron': 444,

 32037     'aring': 444,

 32038     'Ncommaaccent': 722,

 32039     'lacute': 278,

 32040     'agrave': 444,

 32041     'Tcommaaccent': 611,

 32042     'Cacute': 667,

 32043     'atilde': 444,

 32044     'Edotaccent': 611,

 32045     'scaron': 389,

 32046     'scedilla': 389,

 32047     'iacute': 278,

 32048     'lozenge': 471,

 32049     'Rcaron': 667,

 32050     'Gcommaaccent': 722,

 32051     'ucircumflex': 500,

 32052     'acircumflex': 444,

 32053     'Amacron': 722,

 32054     'rcaron': 333,

 32055     'ccedilla': 444,

 32056     'Zdotaccent': 611,

 32057     'Thorn': 556,

 32058     'Omacron': 722,

 32059     'Racute': 667,

 32060     'Sacute': 556,

 32061     'dcaron': 588,

 32062     'Umacron': 722,

 32063     'uring': 500,

 32064     'threesuperior': 300,

 32065     'Ograve': 722,

 32066     'Agrave': 722,

 32067     'Abreve': 722,

 32068     'multiply': 564,

 32069     'uacute': 500,

 32070     'Tcaron': 611,

 32071     'partialdiff': 476,

 32072     'ydieresis': 500,

 32073     'Nacute': 722,

 32074     'icircumflex': 278,

 32075     'Ecircumflex': 611,

 32076     'adieresis': 444,

 32077     'edieresis': 444,

 32078     'cacute': 444,

 32079     'nacute': 500,

 32080     'umacron': 500,

 32081     'Ncaron': 722,

 32082     'Iacute': 333,

 32083     'plusminus': 564,

 32084     'brokenbar': 200,

 32085     'registered': 760,

 32086     'Gbreve': 722,

 32087     'Idotaccent': 333,

 32088     'summation': 600,

 32089     'Egrave': 611,

 32090     'racute': 333,

 32091     'omacron': 500,

 32092     'Zacute': 611,

 32093     'Zcaron': 611,

 32094     'greaterequal': 549,

 32095     'Eth': 722,

 32096     'Ccedilla': 667,

 32097     'lcommaaccent': 278,

 32098     'tcaron': 326,

 32099     'eogonek': 444,

 32100     'Uogonek': 722,

 32101     'Aacute': 722,

 32102     'Adieresis': 722,

 32103     'egrave': 444,

 32104     'zacute': 444,

 32105     'iogonek': 278,

 32106     'Oacute': 722,

 32107     'oacute': 500,

 32108     'amacron': 444,

 32109     'sacute': 389,

 32110     'idieresis': 278,

 32111     'Ocircumflex': 722,

 32112     'Ugrave': 722,

 32113     'Delta': 612,

 32114     'thorn': 500,

 32115     'twosuperior': 300,

 32116     'Odieresis': 722,

 32117     'mu': 500,

 32118     'igrave': 278,

 32119     'ohungarumlaut': 500,

 32120     'Eogonek': 611,

 32121     'dcroat': 500,

 32122     'threequarters': 750,

 32123     'Scedilla': 556,

 32124     'lcaron': 344,

 32125     'Kcommaaccent': 722,

 32126     'Lacute': 611,

 32127     'trademark': 980,

 32128     'edotaccent': 444,

 32129     'Igrave': 333,

 32130     'Imacron': 333,

 32131     'Lcaron': 611,

 32132     'onehalf': 750,

 32133     'lessequal': 549,

 32134     'ocircumflex': 500,

 32135     'ntilde': 500,

 32136     'Uhungarumlaut': 722,

 32137     'Eacute': 611,

 32138     'emacron': 444,

 32139     'gbreve': 500,

 32140     'onequarter': 750,

 32141     'Scaron': 556,

 32142     'Scommaaccent': 556,

 32143     'Ohungarumlaut': 722,

 32144     'degree': 400,

 32145     'ograve': 500,

 32146     'Ccaron': 667,

 32147     'ugrave': 500,

 32148     'radical': 453,

 32149     'Dcaron': 722,

 32150     'rcommaaccent': 333,

 32151     'Ntilde': 722,

 32152     'otilde': 500,

 32153     'Rcommaaccent': 667,

 32154     'Lcommaaccent': 611,

 32155     'Atilde': 722,

 32156     'Aogonek': 722,

 32157     'Aring': 722,

 32158     'Otilde': 722,

 32159     'zdotaccent': 444,

 32160     'Ecaron': 611,

 32161     'Iogonek': 333,

 32162     'kcommaaccent': 500,

 32163     'minus': 564,

 32164     'Icircumflex': 333,

 32165     'ncaron': 500,

 32166     'tcommaaccent': 278,

 32167     'logicalnot': 564,

 32168     'odieresis': 500,

 32169     'udieresis': 500,

 32170     'notequal': 549,

 32171     'gcommaaccent': 500,

 32172     'eth': 500,

 32173     'zcaron': 444,

 32174     'ncommaaccent': 500,

 32175     'onesuperior': 300,

 32176     'imacron': 278,

 32177     'Euro': 500

 32178   },

 32179   'Times-Bold': {

 32180     'space': 250,

 32181     'exclam': 333,

 32182     'quotedbl': 555,

 32183     'numbersign': 500,

 32184     'dollar': 500,

 32185     'percent': 1000,

 32186     'ampersand': 833,

 32187     'quoteright': 333,

 32188     'parenleft': 333,

 32189     'parenright': 333,

 32190     'asterisk': 500,

 32191     'plus': 570,

 32192     'comma': 250,

 32193     'hyphen': 333,

 32194     'period': 250,

 32195     'slash': 278,

 32196     'zero': 500,

 32197     'one': 500,

 32198     'two': 500,

 32199     'three': 500,

 32200     'four': 500,

 32201     'five': 500,

 32202     'six': 500,

 32203     'seven': 500,

 32204     'eight': 500,

 32205     'nine': 500,

 32206     'colon': 333,

 32207     'semicolon': 333,

 32208     'less': 570,

 32209     'equal': 570,

 32210     'greater': 570,

 32211     'question': 500,

 32212     'at': 930,

 32213     'A': 722,

 32214     'B': 667,

 32215     'C': 722,

 32216     'D': 722,

 32217     'E': 667,

 32218     'F': 611,

 32219     'G': 778,

 32220     'H': 778,

 32221     'I': 389,

 32222     'J': 500,

 32223     'K': 778,

 32224     'L': 667,

 32225     'M': 944,

 32226     'N': 722,

 32227     'O': 778,

 32228     'P': 611,

 32229     'Q': 778,

 32230     'R': 722,

 32231     'S': 556,

 32232     'T': 667,

 32233     'U': 722,

 32234     'V': 722,

 32235     'W': 1000,

 32236     'X': 722,

 32237     'Y': 722,

 32238     'Z': 667,

 32239     'bracketleft': 333,

 32240     'backslash': 278,

 32241     'bracketright': 333,

 32242     'asciicircum': 581,

 32243     'underscore': 500,

 32244     'quoteleft': 333,

 32245     'a': 500,

 32246     'b': 556,

 32247     'c': 444,

 32248     'd': 556,

 32249     'e': 444,

 32250     'f': 333,

 32251     'g': 500,

 32252     'h': 556,

 32253     'i': 278,

 32254     'j': 333,

 32255     'k': 556,

 32256     'l': 278,

 32257     'm': 833,

 32258     'n': 556,

 32259     'o': 500,

 32260     'p': 556,

 32261     'q': 556,

 32262     'r': 444,

 32263     's': 389,

 32264     't': 333,

 32265     'u': 556,

 32266     'v': 500,

 32267     'w': 722,

 32268     'x': 500,

 32269     'y': 500,

 32270     'z': 444,

 32271     'braceleft': 394,

 32272     'bar': 220,

 32273     'braceright': 394,

 32274     'asciitilde': 520,

 32275     'exclamdown': 333,

 32276     'cent': 500,

 32277     'sterling': 500,

 32278     'fraction': 167,

 32279     'yen': 500,

 32280     'florin': 500,

 32281     'section': 500,

 32282     'currency': 500,

 32283     'quotesingle': 278,

 32284     'quotedblleft': 500,

 32285     'guillemotleft': 500,

 32286     'guilsinglleft': 333,

 32287     'guilsinglright': 333,

 32288     'fi': 556,

 32289     'fl': 556,

 32290     'endash': 500,

 32291     'dagger': 500,

 32292     'daggerdbl': 500,

 32293     'periodcentered': 250,

 32294     'paragraph': 540,

 32295     'bullet': 350,

 32296     'quotesinglbase': 333,

 32297     'quotedblbase': 500,

 32298     'quotedblright': 500,

 32299     'guillemotright': 500,

 32300     'ellipsis': 1000,

 32301     'perthousand': 1000,

 32302     'questiondown': 500,

 32303     'grave': 333,

 32304     'acute': 333,

 32305     'circumflex': 333,

 32306     'tilde': 333,

 32307     'macron': 333,

 32308     'breve': 333,

 32309     'dotaccent': 333,

 32310     'dieresis': 333,

 32311     'ring': 333,

 32312     'cedilla': 333,

 32313     'hungarumlaut': 333,

 32314     'ogonek': 333,

 32315     'caron': 333,

 32316     'emdash': 1000,

 32317     'AE': 1000,

 32318     'ordfeminine': 300,

 32319     'Lslash': 667,

 32320     'Oslash': 778,

 32321     'OE': 1000,

 32322     'ordmasculine': 330,

 32323     'ae': 722,

 32324     'dotlessi': 278,

 32325     'lslash': 278,

 32326     'oslash': 500,

 32327     'oe': 722,

 32328     'germandbls': 556,

 32329     'Idieresis': 389,

 32330     'eacute': 444,

 32331     'abreve': 500,

 32332     'uhungarumlaut': 556,

 32333     'ecaron': 444,

 32334     'Ydieresis': 722,

 32335     'divide': 570,

 32336     'Yacute': 722,

 32337     'Acircumflex': 722,

 32338     'aacute': 500,

 32339     'Ucircumflex': 722,

 32340     'yacute': 500,

 32341     'scommaaccent': 389,

 32342     'ecircumflex': 444,

 32343     'Uring': 722,

 32344     'Udieresis': 722,

 32345     'aogonek': 500,

 32346     'Uacute': 722,

 32347     'uogonek': 556,

 32348     'Edieresis': 667,

 32349     'Dcroat': 722,

 32350     'commaaccent': 250,

 32351     'copyright': 747,

 32352     'Emacron': 667,

 32353     'ccaron': 444,

 32354     'aring': 500,

 32355     'Ncommaaccent': 722,

 32356     'lacute': 278,

 32357     'agrave': 500,

 32358     'Tcommaaccent': 667,

 32359     'Cacute': 722,

 32360     'atilde': 500,

 32361     'Edotaccent': 667,

 32362     'scaron': 389,

 32363     'scedilla': 389,

 32364     'iacute': 278,

 32365     'lozenge': 494,

 32366     'Rcaron': 722,

 32367     'Gcommaaccent': 778,

 32368     'ucircumflex': 556,

 32369     'acircumflex': 500,

 32370     'Amacron': 722,

 32371     'rcaron': 444,

 32372     'ccedilla': 444,

 32373     'Zdotaccent': 667,

 32374     'Thorn': 611,

 32375     'Omacron': 778,

 32376     'Racute': 722,

 32377     'Sacute': 556,

 32378     'dcaron': 672,

 32379     'Umacron': 722,

 32380     'uring': 556,

 32381     'threesuperior': 300,

 32382     'Ograve': 778,

 32383     'Agrave': 722,

 32384     'Abreve': 722,

 32385     'multiply': 570,

 32386     'uacute': 556,

 32387     'Tcaron': 667,

 32388     'partialdiff': 494,

 32389     'ydieresis': 500,

 32390     'Nacute': 722,

 32391     'icircumflex': 278,

 32392     'Ecircumflex': 667,

 32393     'adieresis': 500,

 32394     'edieresis': 444,

 32395     'cacute': 444,

 32396     'nacute': 556,

 32397     'umacron': 556,

 32398     'Ncaron': 722,

 32399     'Iacute': 389,

 32400     'plusminus': 570,

 32401     'brokenbar': 220,

 32402     'registered': 747,

 32403     'Gbreve': 778,

 32404     'Idotaccent': 389,

 32405     'summation': 600,

 32406     'Egrave': 667,

 32407     'racute': 444,

 32408     'omacron': 500,

 32409     'Zacute': 667,

 32410     'Zcaron': 667,

 32411     'greaterequal': 549,

 32412     'Eth': 722,

 32413     'Ccedilla': 722,

 32414     'lcommaaccent': 278,

 32415     'tcaron': 416,

 32416     'eogonek': 444,

 32417     'Uogonek': 722,

 32418     'Aacute': 722,

 32419     'Adieresis': 722,

 32420     'egrave': 444,

 32421     'zacute': 444,

 32422     'iogonek': 278,

 32423     'Oacute': 778,

 32424     'oacute': 500,

 32425     'amacron': 500,

 32426     'sacute': 389,

 32427     'idieresis': 278,

 32428     'Ocircumflex': 778,

 32429     'Ugrave': 722,

 32430     'Delta': 612,

 32431     'thorn': 556,

 32432     'twosuperior': 300,

 32433     'Odieresis': 778,

 32434     'mu': 556,

 32435     'igrave': 278,

 32436     'ohungarumlaut': 500,

 32437     'Eogonek': 667,

 32438     'dcroat': 556,

 32439     'threequarters': 750,

 32440     'Scedilla': 556,

 32441     'lcaron': 394,

 32442     'Kcommaaccent': 778,

 32443     'Lacute': 667,

 32444     'trademark': 1000,

 32445     'edotaccent': 444,

 32446     'Igrave': 389,

 32447     'Imacron': 389,

 32448     'Lcaron': 667,

 32449     'onehalf': 750,

 32450     'lessequal': 549,

 32451     'ocircumflex': 500,

 32452     'ntilde': 556,

 32453     'Uhungarumlaut': 722,

 32454     'Eacute': 667,

 32455     'emacron': 444,

 32456     'gbreve': 500,

 32457     'onequarter': 750,

 32458     'Scaron': 556,

 32459     'Scommaaccent': 556,

 32460     'Ohungarumlaut': 778,

 32461     'degree': 400,

 32462     'ograve': 500,

 32463     'Ccaron': 722,

 32464     'ugrave': 556,

 32465     'radical': 549,

 32466     'Dcaron': 722,

 32467     'rcommaaccent': 444,

 32468     'Ntilde': 722,

 32469     'otilde': 500,

 32470     'Rcommaaccent': 722,

 32471     'Lcommaaccent': 667,

 32472     'Atilde': 722,

 32473     'Aogonek': 722,

 32474     'Aring': 722,

 32475     'Otilde': 778,

 32476     'zdotaccent': 444,

 32477     'Ecaron': 667,

 32478     'Iogonek': 389,

 32479     'kcommaaccent': 556,

 32480     'minus': 570,

 32481     'Icircumflex': 389,

 32482     'ncaron': 556,

 32483     'tcommaaccent': 333,

 32484     'logicalnot': 570,

 32485     'odieresis': 500,

 32486     'udieresis': 556,

 32487     'notequal': 549,

 32488     'gcommaaccent': 500,

 32489     'eth': 500,

 32490     'zcaron': 444,

 32491     'ncommaaccent': 556,

 32492     'onesuperior': 300,

 32493     'imacron': 278,

 32494     'Euro': 500

 32495   },

 32496   'Times-BoldItalic': {

 32497     'space': 250,

 32498     'exclam': 389,

 32499     'quotedbl': 555,

 32500     'numbersign': 500,

 32501     'dollar': 500,

 32502     'percent': 833,

 32503     'ampersand': 778,

 32504     'quoteright': 333,

 32505     'parenleft': 333,

 32506     'parenright': 333,

 32507     'asterisk': 500,

 32508     'plus': 570,

 32509     'comma': 250,

 32510     'hyphen': 333,

 32511     'period': 250,

 32512     'slash': 278,

 32513     'zero': 500,

 32514     'one': 500,

 32515     'two': 500,

 32516     'three': 500,

 32517     'four': 500,

 32518     'five': 500,

 32519     'six': 500,

 32520     'seven': 500,

 32521     'eight': 500,

 32522     'nine': 500,

 32523     'colon': 333,

 32524     'semicolon': 333,

 32525     'less': 570,

 32526     'equal': 570,

 32527     'greater': 570,

 32528     'question': 500,

 32529     'at': 832,

 32530     'A': 667,

 32531     'B': 667,

 32532     'C': 667,

 32533     'D': 722,

 32534     'E': 667,

 32535     'F': 667,

 32536     'G': 722,

 32537     'H': 778,

 32538     'I': 389,

 32539     'J': 500,

 32540     'K': 667,

 32541     'L': 611,

 32542     'M': 889,

 32543     'N': 722,

 32544     'O': 722,

 32545     'P': 611,

 32546     'Q': 722,

 32547     'R': 667,

 32548     'S': 556,

 32549     'T': 611,

 32550     'U': 722,

 32551     'V': 667,

 32552     'W': 889,

 32553     'X': 667,

 32554     'Y': 611,

 32555     'Z': 611,

 32556     'bracketleft': 333,

 32557     'backslash': 278,

 32558     'bracketright': 333,

 32559     'asciicircum': 570,

 32560     'underscore': 500,

 32561     'quoteleft': 333,

 32562     'a': 500,

 32563     'b': 500,

 32564     'c': 444,

 32565     'd': 500,

 32566     'e': 444,

 32567     'f': 333,

 32568     'g': 500,

 32569     'h': 556,

 32570     'i': 278,

 32571     'j': 278,

 32572     'k': 500,

 32573     'l': 278,

 32574     'm': 778,

 32575     'n': 556,

 32576     'o': 500,

 32577     'p': 500,

 32578     'q': 500,

 32579     'r': 389,

 32580     's': 389,

 32581     't': 278,

 32582     'u': 556,

 32583     'v': 444,

 32584     'w': 667,

 32585     'x': 500,

 32586     'y': 444,

 32587     'z': 389,

 32588     'braceleft': 348,

 32589     'bar': 220,

 32590     'braceright': 348,

 32591     'asciitilde': 570,

 32592     'exclamdown': 389,

 32593     'cent': 500,

 32594     'sterling': 500,

 32595     'fraction': 167,

 32596     'yen': 500,

 32597     'florin': 500,

 32598     'section': 500,

 32599     'currency': 500,

 32600     'quotesingle': 278,

 32601     'quotedblleft': 500,

 32602     'guillemotleft': 500,

 32603     'guilsinglleft': 333,

 32604     'guilsinglright': 333,

 32605     'fi': 556,

 32606     'fl': 556,

 32607     'endash': 500,

 32608     'dagger': 500,

 32609     'daggerdbl': 500,

 32610     'periodcentered': 250,

 32611     'paragraph': 500,

 32612     'bullet': 350,

 32613     'quotesinglbase': 333,

 32614     'quotedblbase': 500,

 32615     'quotedblright': 500,

 32616     'guillemotright': 500,

 32617     'ellipsis': 1000,

 32618     'perthousand': 1000,

 32619     'questiondown': 500,

 32620     'grave': 333,

 32621     'acute': 333,

 32622     'circumflex': 333,

 32623     'tilde': 333,

 32624     'macron': 333,

 32625     'breve': 333,

 32626     'dotaccent': 333,

 32627     'dieresis': 333,

 32628     'ring': 333,

 32629     'cedilla': 333,

 32630     'hungarumlaut': 333,

 32631     'ogonek': 333,

 32632     'caron': 333,

 32633     'emdash': 1000,

 32634     'AE': 944,

 32635     'ordfeminine': 266,

 32636     'Lslash': 611,

 32637     'Oslash': 722,

 32638     'OE': 944,

 32639     'ordmasculine': 300,

 32640     'ae': 722,

 32641     'dotlessi': 278,

 32642     'lslash': 278,

 32643     'oslash': 500,

 32644     'oe': 722,

 32645     'germandbls': 500,

 32646     'Idieresis': 389,

 32647     'eacute': 444,

 32648     'abreve': 500,

 32649     'uhungarumlaut': 556,

 32650     'ecaron': 444,

 32651     'Ydieresis': 611,

 32652     'divide': 570,

 32653     'Yacute': 611,

 32654     'Acircumflex': 667,

 32655     'aacute': 500,

 32656     'Ucircumflex': 722,

 32657     'yacute': 444,

 32658     'scommaaccent': 389,

 32659     'ecircumflex': 444,

 32660     'Uring': 722,

 32661     'Udieresis': 722,

 32662     'aogonek': 500,

 32663     'Uacute': 722,

 32664     'uogonek': 556,

 32665     'Edieresis': 667,

 32666     'Dcroat': 722,

 32667     'commaaccent': 250,

 32668     'copyright': 747,

 32669     'Emacron': 667,

 32670     'ccaron': 444,

 32671     'aring': 500,

 32672     'Ncommaaccent': 722,

 32673     'lacute': 278,

 32674     'agrave': 500,

 32675     'Tcommaaccent': 611,

 32676     'Cacute': 667,

 32677     'atilde': 500,

 32678     'Edotaccent': 667,

 32679     'scaron': 389,

 32680     'scedilla': 389,

 32681     'iacute': 278,

 32682     'lozenge': 494,

 32683     'Rcaron': 667,

 32684     'Gcommaaccent': 722,

 32685     'ucircumflex': 556,

 32686     'acircumflex': 500,

 32687     'Amacron': 667,

 32688     'rcaron': 389,

 32689     'ccedilla': 444,

 32690     'Zdotaccent': 611,

 32691     'Thorn': 611,

 32692     'Omacron': 722,

 32693     'Racute': 667,

 32694     'Sacute': 556,

 32695     'dcaron': 608,

 32696     'Umacron': 722,

 32697     'uring': 556,

 32698     'threesuperior': 300,

 32699     'Ograve': 722,

 32700     'Agrave': 667,

 32701     'Abreve': 667,

 32702     'multiply': 570,

 32703     'uacute': 556,

 32704     'Tcaron': 611,

 32705     'partialdiff': 494,

 32706     'ydieresis': 444,

 32707     'Nacute': 722,

 32708     'icircumflex': 278,

 32709     'Ecircumflex': 667,

 32710     'adieresis': 500,

 32711     'edieresis': 444,

 32712     'cacute': 444,

 32713     'nacute': 556,

 32714     'umacron': 556,

 32715     'Ncaron': 722,

 32716     'Iacute': 389,

 32717     'plusminus': 570,

 32718     'brokenbar': 220,

 32719     'registered': 747,

 32720     'Gbreve': 722,

 32721     'Idotaccent': 389,

 32722     'summation': 600,

 32723     'Egrave': 667,

 32724     'racute': 389,

 32725     'omacron': 500,

 32726     'Zacute': 611,

 32727     'Zcaron': 611,

 32728     'greaterequal': 549,

 32729     'Eth': 722,

 32730     'Ccedilla': 667,

 32731     'lcommaaccent': 278,

 32732     'tcaron': 366,

 32733     'eogonek': 444,

 32734     'Uogonek': 722,

 32735     'Aacute': 667,

 32736     'Adieresis': 667,

 32737     'egrave': 444,

 32738     'zacute': 389,

 32739     'iogonek': 278,

 32740     'Oacute': 722,

 32741     'oacute': 500,

 32742     'amacron': 500,

 32743     'sacute': 389,

 32744     'idieresis': 278,

 32745     'Ocircumflex': 722,

 32746     'Ugrave': 722,

 32747     'Delta': 612,

 32748     'thorn': 500,

 32749     'twosuperior': 300,

 32750     'Odieresis': 722,

 32751     'mu': 576,

 32752     'igrave': 278,

 32753     'ohungarumlaut': 500,

 32754     'Eogonek': 667,

 32755     'dcroat': 500,

 32756     'threequarters': 750,

 32757     'Scedilla': 556,

 32758     'lcaron': 382,

 32759     'Kcommaaccent': 667,

 32760     'Lacute': 611,

 32761     'trademark': 1000,

 32762     'edotaccent': 444,

 32763     'Igrave': 389,

 32764     'Imacron': 389,

 32765     'Lcaron': 611,

 32766     'onehalf': 750,

 32767     'lessequal': 549,

 32768     'ocircumflex': 500,

 32769     'ntilde': 556,

 32770     'Uhungarumlaut': 722,

 32771     'Eacute': 667,

 32772     'emacron': 444,

 32773     'gbreve': 500,

 32774     'onequarter': 750,

 32775     'Scaron': 556,

 32776     'Scommaaccent': 556,

 32777     'Ohungarumlaut': 722,

 32778     'degree': 400,

 32779     'ograve': 500,

 32780     'Ccaron': 667,

 32781     'ugrave': 556,

 32782     'radical': 549,

 32783     'Dcaron': 722,

 32784     'rcommaaccent': 389,

 32785     'Ntilde': 722,

 32786     'otilde': 500,

 32787     'Rcommaaccent': 667,

 32788     'Lcommaaccent': 611,

 32789     'Atilde': 667,

 32790     'Aogonek': 667,

 32791     'Aring': 667,

 32792     'Otilde': 722,

 32793     'zdotaccent': 389,

 32794     'Ecaron': 667,

 32795     'Iogonek': 389,

 32796     'kcommaaccent': 500,

 32797     'minus': 606,

 32798     'Icircumflex': 389,

 32799     'ncaron': 556,

 32800     'tcommaaccent': 278,

 32801     'logicalnot': 606,

 32802     'odieresis': 500,

 32803     'udieresis': 556,

 32804     'notequal': 549,

 32805     'gcommaaccent': 500,

 32806     'eth': 500,

 32807     'zcaron': 389,

 32808     'ncommaaccent': 556,

 32809     'onesuperior': 300,

 32810     'imacron': 278,

 32811     'Euro': 500

 32812   },

 32813   'Times-Italic': {

 32814     'space': 250,

 32815     'exclam': 333,

 32816     'quotedbl': 420,

 32817     'numbersign': 500,

 32818     'dollar': 500,

 32819     'percent': 833,

 32820     'ampersand': 778,

 32821     'quoteright': 333,

 32822     'parenleft': 333,

 32823     'parenright': 333,

 32824     'asterisk': 500,

 32825     'plus': 675,

 32826     'comma': 250,

 32827     'hyphen': 333,

 32828     'period': 250,

 32829     'slash': 278,

 32830     'zero': 500,

 32831     'one': 500,

 32832     'two': 500,

 32833     'three': 500,

 32834     'four': 500,

 32835     'five': 500,

 32836     'six': 500,

 32837     'seven': 500,

 32838     'eight': 500,

 32839     'nine': 500,

 32840     'colon': 333,

 32841     'semicolon': 333,

 32842     'less': 675,

 32843     'equal': 675,

 32844     'greater': 675,

 32845     'question': 500,

 32846     'at': 920,

 32847     'A': 611,

 32848     'B': 611,

 32849     'C': 667,

 32850     'D': 722,

 32851     'E': 611,

 32852     'F': 611,

 32853     'G': 722,

 32854     'H': 722,

 32855     'I': 333,

 32856     'J': 444,

 32857     'K': 667,

 32858     'L': 556,

 32859     'M': 833,

 32860     'N': 667,

 32861     'O': 722,

 32862     'P': 611,

 32863     'Q': 722,

 32864     'R': 611,

 32865     'S': 500,

 32866     'T': 556,

 32867     'U': 722,

 32868     'V': 611,

 32869     'W': 833,

 32870     'X': 611,

 32871     'Y': 556,

 32872     'Z': 556,

 32873     'bracketleft': 389,

 32874     'backslash': 278,

 32875     'bracketright': 389,

 32876     'asciicircum': 422,

 32877     'underscore': 500,

 32878     'quoteleft': 333,

 32879     'a': 500,

 32880     'b': 500,

 32881     'c': 444,

 32882     'd': 500,

 32883     'e': 444,

 32884     'f': 278,

 32885     'g': 500,

 32886     'h': 500,

 32887     'i': 278,

 32888     'j': 278,

 32889     'k': 444,

 32890     'l': 278,

 32891     'm': 722,

 32892     'n': 500,

 32893     'o': 500,

 32894     'p': 500,

 32895     'q': 500,

 32896     'r': 389,

 32897     's': 389,

 32898     't': 278,

 32899     'u': 500,

 32900     'v': 444,

 32901     'w': 667,

 32902     'x': 444,

 32903     'y': 444,

 32904     'z': 389,

 32905     'braceleft': 400,

 32906     'bar': 275,

 32907     'braceright': 400,

 32908     'asciitilde': 541,

 32909     'exclamdown': 389,

 32910     'cent': 500,

 32911     'sterling': 500,

 32912     'fraction': 167,

 32913     'yen': 500,

 32914     'florin': 500,

 32915     'section': 500,

 32916     'currency': 500,

 32917     'quotesingle': 214,

 32918     'quotedblleft': 556,

 32919     'guillemotleft': 500,

 32920     'guilsinglleft': 333,

 32921     'guilsinglright': 333,

 32922     'fi': 500,

 32923     'fl': 500,

 32924     'endash': 500,

 32925     'dagger': 500,

 32926     'daggerdbl': 500,

 32927     'periodcentered': 250,

 32928     'paragraph': 523,

 32929     'bullet': 350,

 32930     'quotesinglbase': 333,

 32931     'quotedblbase': 556,

 32932     'quotedblright': 556,

 32933     'guillemotright': 500,

 32934     'ellipsis': 889,

 32935     'perthousand': 1000,

 32936     'questiondown': 500,

 32937     'grave': 333,

 32938     'acute': 333,

 32939     'circumflex': 333,

 32940     'tilde': 333,

 32941     'macron': 333,

 32942     'breve': 333,

 32943     'dotaccent': 333,

 32944     'dieresis': 333,

 32945     'ring': 333,

 32946     'cedilla': 333,

 32947     'hungarumlaut': 333,

 32948     'ogonek': 333,

 32949     'caron': 333,

 32950     'emdash': 889,

 32951     'AE': 889,

 32952     'ordfeminine': 276,

 32953     'Lslash': 556,

 32954     'Oslash': 722,

 32955     'OE': 944,

 32956     'ordmasculine': 310,

 32957     'ae': 667,

 32958     'dotlessi': 278,

 32959     'lslash': 278,

 32960     'oslash': 500,

 32961     'oe': 667,

 32962     'germandbls': 500,

 32963     'Idieresis': 333,

 32964     'eacute': 444,

 32965     'abreve': 500,

 32966     'uhungarumlaut': 500,

 32967     'ecaron': 444,

 32968     'Ydieresis': 556,

 32969     'divide': 675,

 32970     'Yacute': 556,

 32971     'Acircumflex': 611,

 32972     'aacute': 500,

 32973     'Ucircumflex': 722,

 32974     'yacute': 444,

 32975     'scommaaccent': 389,

 32976     'ecircumflex': 444,

 32977     'Uring': 722,

 32978     'Udieresis': 722,

 32979     'aogonek': 500,

 32980     'Uacute': 722,

 32981     'uogonek': 500,

 32982     'Edieresis': 611,

 32983     'Dcroat': 722,

 32984     'commaaccent': 250,

 32985     'copyright': 760,

 32986     'Emacron': 611,

 32987     'ccaron': 444,

 32988     'aring': 500,

 32989     'Ncommaaccent': 667,

 32990     'lacute': 278,

 32991     'agrave': 500,

 32992     'Tcommaaccent': 556,

 32993     'Cacute': 667,

 32994     'atilde': 500,

 32995     'Edotaccent': 611,

 32996     'scaron': 389,

 32997     'scedilla': 389,

 32998     'iacute': 278,

 32999     'lozenge': 471,

 33000     'Rcaron': 611,

 33001     'Gcommaaccent': 722,

 33002     'ucircumflex': 500,

 33003     'acircumflex': 500,

 33004     'Amacron': 611,

 33005     'rcaron': 389,

 33006     'ccedilla': 444,

 33007     'Zdotaccent': 556,

 33008     'Thorn': 611,

 33009     'Omacron': 722,

 33010     'Racute': 611,

 33011     'Sacute': 500,

 33012     'dcaron': 544,

 33013     'Umacron': 722,

 33014     'uring': 500,

 33015     'threesuperior': 300,

 33016     'Ograve': 722,

 33017     'Agrave': 611,

 33018     'Abreve': 611,

 33019     'multiply': 675,

 33020     'uacute': 500,

 33021     'Tcaron': 556,

 33022     'partialdiff': 476,

 33023     'ydieresis': 444,

 33024     'Nacute': 667,

 33025     'icircumflex': 278,

 33026     'Ecircumflex': 611,

 33027     'adieresis': 500,

 33028     'edieresis': 444,

 33029     'cacute': 444,

 33030     'nacute': 500,

 33031     'umacron': 500,

 33032     'Ncaron': 667,

 33033     'Iacute': 333,

 33034     'plusminus': 675,

 33035     'brokenbar': 275,

 33036     'registered': 760,

 33037     'Gbreve': 722,

 33038     'Idotaccent': 333,

 33039     'summation': 600,

 33040     'Egrave': 611,

 33041     'racute': 389,

 33042     'omacron': 500,

 33043     'Zacute': 556,

 33044     'Zcaron': 556,

 33045     'greaterequal': 549,

 33046     'Eth': 722,

 33047     'Ccedilla': 667,

 33048     'lcommaaccent': 278,

 33049     'tcaron': 300,

 33050     'eogonek': 444,

 33051     'Uogonek': 722,

 33052     'Aacute': 611,

 33053     'Adieresis': 611,

 33054     'egrave': 444,

 33055     'zacute': 389,

 33056     'iogonek': 278,

 33057     'Oacute': 722,

 33058     'oacute': 500,

 33059     'amacron': 500,

 33060     'sacute': 389,

 33061     'idieresis': 278,

 33062     'Ocircumflex': 722,

 33063     'Ugrave': 722,

 33064     'Delta': 612,

 33065     'thorn': 500,

 33066     'twosuperior': 300,

 33067     'Odieresis': 722,

 33068     'mu': 500,

 33069     'igrave': 278,

 33070     'ohungarumlaut': 500,

 33071     'Eogonek': 611,

 33072     'dcroat': 500,

 33073     'threequarters': 750,

 33074     'Scedilla': 500,

 33075     'lcaron': 300,

 33076     'Kcommaaccent': 667,

 33077     'Lacute': 556,

 33078     'trademark': 980,

 33079     'edotaccent': 444,

 33080     'Igrave': 333,

 33081     'Imacron': 333,

 33082     'Lcaron': 611,

 33083     'onehalf': 750,

 33084     'lessequal': 549,

 33085     'ocircumflex': 500,

 33086     'ntilde': 500,

 33087     'Uhungarumlaut': 722,

 33088     'Eacute': 611,

 33089     'emacron': 444,

 33090     'gbreve': 500,

 33091     'onequarter': 750,

 33092     'Scaron': 500,

 33093     'Scommaaccent': 500,

 33094     'Ohungarumlaut': 722,

 33095     'degree': 400,

 33096     'ograve': 500,

 33097     'Ccaron': 667,

 33098     'ugrave': 500,

 33099     'radical': 453,

 33100     'Dcaron': 722,

 33101     'rcommaaccent': 389,

 33102     'Ntilde': 667,

 33103     'otilde': 500,

 33104     'Rcommaaccent': 611,

 33105     'Lcommaaccent': 556,

 33106     'Atilde': 611,

 33107     'Aogonek': 611,

 33108     'Aring': 611,

 33109     'Otilde': 722,

 33110     'zdotaccent': 389,

 33111     'Ecaron': 611,

 33112     'Iogonek': 333,

 33113     'kcommaaccent': 444,

 33114     'minus': 675,

 33115     'Icircumflex': 333,

 33116     'ncaron': 500,

 33117     'tcommaaccent': 278,

 33118     'logicalnot': 675,

 33119     'odieresis': 500,

 33120     'udieresis': 500,

 33121     'notequal': 549,

 33122     'gcommaaccent': 500,

 33123     'eth': 500,

 33124     'zcaron': 389,

 33125     'ncommaaccent': 500,

 33126     'onesuperior': 300,

 33127     'imacron': 278,

 33128     'Euro': 500

 33129   },

 33130   'ZapfDingbats': {

 33131     'space': 278,

 33132     'a1': 974,

 33133     'a2': 961,

 33134     'a202': 974,

 33135     'a3': 980,

 33136     'a4': 719,

 33137     'a5': 789,

 33138     'a119': 790,

 33139     'a118': 791,

 33140     'a117': 690,

 33141     'a11': 960,

 33142     'a12': 939,

 33143     'a13': 549,

 33144     'a14': 855,

 33145     'a15': 911,

 33146     'a16': 933,

 33147     'a105': 911,

 33148     'a17': 945,

 33149     'a18': 974,

 33150     'a19': 755,

 33151     'a20': 846,

 33152     'a21': 762,

 33153     'a22': 761,

 33154     'a23': 571,

 33155     'a24': 677,

 33156     'a25': 763,

 33157     'a26': 760,

 33158     'a27': 759,

 33159     'a28': 754,

 33160     'a6': 494,

 33161     'a7': 552,

 33162     'a8': 537,

 33163     'a9': 577,

 33164     'a10': 692,

 33165     'a29': 786,

 33166     'a30': 788,

 33167     'a31': 788,

 33168     'a32': 790,

 33169     'a33': 793,

 33170     'a34': 794,

 33171     'a35': 816,

 33172     'a36': 823,

 33173     'a37': 789,

 33174     'a38': 841,

 33175     'a39': 823,

 33176     'a40': 833,

 33177     'a41': 816,

 33178     'a42': 831,

 33179     'a43': 923,

 33180     'a44': 744,

 33181     'a45': 723,

 33182     'a46': 749,

 33183     'a47': 790,

 33184     'a48': 792,

 33185     'a49': 695,

 33186     'a50': 776,

 33187     'a51': 768,

 33188     'a52': 792,

 33189     'a53': 759,

 33190     'a54': 707,

 33191     'a55': 708,

 33192     'a56': 682,

 33193     'a57': 701,

 33194     'a58': 826,

 33195     'a59': 815,

 33196     'a60': 789,

 33197     'a61': 789,

 33198     'a62': 707,

 33199     'a63': 687,

 33200     'a64': 696,

 33201     'a65': 689,

 33202     'a66': 786,

 33203     'a67': 787,

 33204     'a68': 713,

 33205     'a69': 791,

 33206     'a70': 785,

 33207     'a71': 791,

 33208     'a72': 873,

 33209     'a73': 761,

 33210     'a74': 762,

 33211     'a203': 762,

 33212     'a75': 759,

 33213     'a204': 759,

 33214     'a76': 892,

 33215     'a77': 892,

 33216     'a78': 788,

 33217     'a79': 784,

 33218     'a81': 438,

 33219     'a82': 138,

 33220     'a83': 277,

 33221     'a84': 415,

 33222     'a97': 392,

 33223     'a98': 392,

 33224     'a99': 668,

 33225     'a100': 668,

 33226     'a89': 390,

 33227     'a90': 390,

 33228     'a93': 317,

 33229     'a94': 317,

 33230     'a91': 276,

 33231     'a92': 276,

 33232     'a205': 509,

 33233     'a85': 509,

 33234     'a206': 410,

 33235     'a86': 410,

 33236     'a87': 234,

 33237     'a88': 234,

 33238     'a95': 334,

 33239     'a96': 334,

 33240     'a101': 732,

 33241     'a102': 544,

 33242     'a103': 544,

 33243     'a104': 910,

 33244     'a106': 667,

 33245     'a107': 760,

 33246     'a108': 760,

 33247     'a112': 776,

 33248     'a111': 595,

 33249     'a110': 694,

 33250     'a109': 626,

 33251     'a120': 788,

 33252     'a121': 788,

 33253     'a122': 788,

 33254     'a123': 788,

 33255     'a124': 788,

 33256     'a125': 788,

 33257     'a126': 788,

 33258     'a127': 788,

 33259     'a128': 788,

 33260     'a129': 788,

 33261     'a130': 788,

 33262     'a131': 788,

 33263     'a132': 788,

 33264     'a133': 788,

 33265     'a134': 788,

 33266     'a135': 788,

 33267     'a136': 788,

 33268     'a137': 788,

 33269     'a138': 788,

 33270     'a139': 788,

 33271     'a140': 788,

 33272     'a141': 788,

 33273     'a142': 788,

 33274     'a143': 788,

 33275     'a144': 788,

 33276     'a145': 788,

 33277     'a146': 788,

 33278     'a147': 788,

 33279     'a148': 788,

 33280     'a149': 788,

 33281     'a150': 788,

 33282     'a151': 788,

 33283     'a152': 788,

 33284     'a153': 788,

 33285     'a154': 788,

 33286     'a155': 788,

 33287     'a156': 788,

 33288     'a157': 788,

 33289     'a158': 788,

 33290     'a159': 788,

 33291     'a160': 894,

 33292     'a161': 838,

 33293     'a163': 1016,

 33294     'a164': 458,

 33295     'a196': 748,

 33296     'a165': 924,

 33297     'a192': 748,

 33298     'a166': 918,

 33299     'a167': 927,

 33300     'a168': 928,

 33301     'a169': 928,

 33302     'a170': 834,

 33303     'a171': 873,

 33304     'a172': 828,

 33305     'a173': 924,

 33306     'a162': 924,

 33307     'a174': 917,

 33308     'a175': 930,

 33309     'a176': 931,

 33310     'a177': 463,

 33311     'a178': 883,

 33312     'a179': 836,

 33313     'a193': 836,

 33314     'a180': 867,

 33315     'a199': 867,

 33316     'a181': 696,

 33317     'a200': 696,

 33318     'a182': 874,

 33319     'a201': 874,

 33320     'a183': 760,

 33321     'a184': 946,

 33322     'a197': 771,

 33323     'a185': 865,

 33324     'a194': 771,

 33325     'a198': 888,

 33326     'a186': 967,

 33327     'a195': 888,

 33328     'a187': 831,

 33329     'a188': 873,

 33330     'a189': 927,

 33331     'a190': 970,

 33332     'a191': 918

 33333   }

 33334 };

 33338 var EOF = {};

 33340 function isEOF(v) {

 33341   return (v == EOF);

 33342 }

 33344 var Parser = (function ParserClosure() {

 33345   function Parser(lexer, allowStreams, xref) {

 33346     this.lexer = lexer;

 33347     this.allowStreams = allowStreams;

 33348     this.xref = xref;

 33349     this.imageCache = {

 33350       length: 0,

 33351       adler32: 0,

 33352       stream: null

 33353     };

 33354     this.refill();

 33355   }

 33357   Parser.prototype = {

 33358     refill: function Parser_refill() {

 33359       this.buf1 = this.lexer.getObj();

 33360       this.buf2 = this.lexer.getObj();

 33361     },

 33362     shift: function Parser_shift() {

 33363       if (isCmd(this.buf2, 'ID')) {

 33364         this.buf1 = this.buf2;

 33365         this.buf2 = null;

 33366       } else {

 33367         this.buf1 = this.buf2;

 33368         this.buf2 = this.lexer.getObj();

 33369       }

 33370     },

 33371     getObj: function Parser_getObj(cipherTransform) {

 33372       if (isCmd(this.buf1, 'BI')) { // inline image

 33373         this.shift();

 33374         return this.makeInlineImage(cipherTransform);

 33375       }

 33376       if (isCmd(this.buf1, '[')) { // array

 33377         this.shift();

 33378         var array = [];

 33379         while (!isCmd(this.buf1, ']') && !isEOF(this.buf1)) {

 33380           array.push(this.getObj(cipherTransform));

 33381         }

 33382         if (isEOF(this.buf1)) {

 33383           error('End of file inside array');

 33384         }

 33385         this.shift();

 33386         return array;

 33387       }

 33388       if (isCmd(this.buf1, '<<')) { // dictionary or stream

 33389         this.shift();

 33390         var dict = new Dict(this.xref);

 33391         while (!isCmd(this.buf1, '>>') && !isEOF(this.buf1)) {

 33392           if (!isName(this.buf1)) {

 33393             info('Malformed dictionary: key must be a name object');

 33394             this.shift();

 33395             continue;

 33396           }

 33398           var key = this.buf1.name;

 33399           this.shift();

 33400           if (isEOF(this.buf1)) {

 33401             break;

 33402           }

 33403           dict.set(key, this.getObj(cipherTransform));

 33404         }

 33405         if (isEOF(this.buf1)) {

 33406           error('End of file inside dictionary');

 33407         }

 33409         // Stream objects are not allowed inside content streams or

 33410         // object streams.

 33411         if (isCmd(this.buf2, 'stream')) {

 33412           return (this.allowStreams ?

 33413                   this.makeStream(dict, cipherTransform) : dict);

 33414         }

 33415         this.shift();

 33416         return dict;

 33417       }

 33418       if (isInt(this.buf1)) { // indirect reference or integer

 33419         var num = this.buf1;

 33420         this.shift();

 33421         if (isInt(this.buf1) && isCmd(this.buf2, 'R')) {

 33422           var ref = new Ref(num, this.buf1);

 33423           this.shift();

 33424           this.shift();

 33425           return ref;

 33426         }

 33427         return num;

 33428       }

 33429       if (isString(this.buf1)) { // string

 33430         var str = this.buf1;

 33431         this.shift();

 33432         if (cipherTransform) {

 33433           str = cipherTransform.decryptString(str);

 33434         }

 33435         return str;

 33436       }

 33438       // simple object

 33439       var obj = this.buf1;

 33440       this.shift();

 33441       return obj;

 33442     },

 33443     makeInlineImage: function Parser_makeInlineImage(cipherTransform) {

 33444       var lexer = this.lexer;

 33445       var stream = lexer.stream;

 33447       // parse dictionary

 33448       var dict = new Dict(null);

 33449       while (!isCmd(this.buf1, 'ID') && !isEOF(this.buf1)) {

 33450         if (!isName(this.buf1)) {

 33451           error('Dictionary key must be a name object');

 33452         }

 33454         var key = this.buf1.name;

 33455         this.shift();

 33456         if (isEOF(this.buf1)) {

 33457           break;

 33458         }

 33459         dict.set(key, this.getObj(cipherTransform));

 33460       }

 33462       // parse image stream

 33463       var startPos = stream.pos;

 33465       // searching for the /EI\s/

 33466       var state = 0, ch, i, ii;

 33467       while (state != 4 && (ch = stream.getByte()) !== -1) {

 33468         switch (ch | 0) {

 33469           case 0x20:

 33470           case 0x0D:

 33471           case 0x0A:

 33472             // let's check next five bytes to be ASCII... just be sure

 33473             var followingBytes = stream.peekBytes(5);

 33474             for (i = 0, ii = followingBytes.length; i < ii; i++) {

 33475               ch = followingBytes[i];

 33476               if (ch !== 0x0A && ch !== 0x0D && (ch < 0x20 || ch > 0x7F)) {

 33477                 // not a LF, CR, SPACE or any visible ASCII character

 33478                 state = 0;

 33479                 break; // some binary stuff found, resetting the state

 33480               }

 33481             }

 33482             state = (state === 3 ? 4 : 0);

 33483             break;

 33484           case 0x45:

 33485             state = 2;

 33486             break;

 33487           case 0x49:

 33488             state = (state === 2 ? 3 : 0);

 33489             break;

 33490           default:

 33491             state = 0;

 33492             break;

 33493         }

 33494       }

 33496       var length = (stream.pos - 4) - startPos;

 33497       var imageStream = stream.makeSubStream(startPos, length, dict);

 33499       // trying to cache repeat images, first we are trying to "warm up" caching

 33500       // using length, then comparing adler32

 33501       var MAX_LENGTH_TO_CACHE = 1000;

 33502       var cacheImage = false, adler32;

 33503       if (length < MAX_LENGTH_TO_CACHE && this.imageCache.length === length) {

 33504         var imageBytes = imageStream.getBytes();

 33505         imageStream.reset();

 33507         var a = 1;

 33508         var b = 0;

 33509         for (i = 0, ii = imageBytes.length; i < ii; ++i) {

 33510           a = (a + (imageBytes[i] & 0xff)) % 65521;

 33511           b = (b + a) % 65521;

 33512         }

 33513         adler32 = (b << 16) | a;

 33515         if (this.imageCache.stream && this.imageCache.adler32 === adler32) {

 33516           this.buf2 = Cmd.get('EI');

 33517           this.shift();

 33519           this.imageCache.stream.reset();

 33520           return this.imageCache.stream;

 33521         }

 33522         cacheImage = true;

 33523       }

 33524       if (!cacheImage && !this.imageCache.stream) {

 33525         this.imageCache.length = length;

 33526         this.imageCache.stream = null;

 33527       }

 33529       if (cipherTransform) {

 33530         imageStream = cipherTransform.createStream(imageStream, length);

 33531       }

 33533       imageStream = this.filter(imageStream, dict, length);

 33534       imageStream.dict = dict;

 33535       if (cacheImage) {

 33536         imageStream.cacheKey = 'inline_' + length + '_' + adler32;

 33537         this.imageCache.adler32 = adler32;

 33538         this.imageCache.stream = imageStream;

 33539       }

 33541       this.buf2 = Cmd.get('EI');

 33542       this.shift();

 33544       return imageStream;

 33545     },

 33546     fetchIfRef: function Parser_fetchIfRef(obj) {

 33547       // not relying on the xref.fetchIfRef -- xref might not be set

 33548       return (isRef(obj) ? this.xref.fetch(obj) : obj);

 33549     },

 33550     makeStream: function Parser_makeStream(dict, cipherTransform) {

 33551       var lexer = this.lexer;

 33552       var stream = lexer.stream;

 33554       // get stream start position

 33555       lexer.skipToNextLine();

 33556       var pos = stream.pos - 1;

 33558       // get length

 33559       var length = this.fetchIfRef(dict.get('Length'));

 33560       if (!isInt(length)) {

 33561         info('Bad ' + length + ' attribute in stream');

 33562         length = 0;

 33563       }

 33565       // skip over the stream data

 33566       stream.pos = pos + length;

 33567       lexer.nextChar();

 33569       this.shift(); // '>>'

 33570       this.shift(); // 'stream'

 33571       if (!isCmd(this.buf1, 'endstream')) {

 33572         // bad stream length, scanning for endstream

 33573         stream.pos = pos;

 33574         var SCAN_BLOCK_SIZE = 2048;

 33575         var ENDSTREAM_SIGNATURE_LENGTH = 9;

 33576         var ENDSTREAM_SIGNATURE = [0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65,

 33577                                    0x61, 0x6D];

 33578         var skipped = 0, found = false, i, j;

 33579         while (stream.pos < stream.end) {

 33580           var scanBytes = stream.peekBytes(SCAN_BLOCK_SIZE);

 33581           var scanLength = scanBytes.length - ENDSTREAM_SIGNATURE_LENGTH;

 33582           found = false;

 33583           for (i = 0, j = 0; i < scanLength; i++) {

 33584             var b = scanBytes[i];

 33585             if (b !== ENDSTREAM_SIGNATURE[j]) {

 33586               i -= j;

 33587               j = 0;

 33588             } else {

 33589               j++;

 33590               if (j >= ENDSTREAM_SIGNATURE_LENGTH) {

 33591                 i++;

 33592                 found = true;

 33593                 break;

 33594               }

 33595             }

 33596           }

 33597           if (found) {

 33598             skipped += i - ENDSTREAM_SIGNATURE_LENGTH;

 33599             stream.pos += i - ENDSTREAM_SIGNATURE_LENGTH;

 33600             break;

 33601           }

 33602           skipped += scanLength;

 33603           stream.pos += scanLength;

 33604         }

 33605         if (!found) {

 33606           error('Missing endstream');

 33607         }

 33608         length = skipped;

 33610         lexer.nextChar();

 33611         this.shift();

 33612         this.shift();

 33613       }

 33614       this.shift(); // 'endstream'

 33616       stream = stream.makeSubStream(pos, length, dict);

 33617       if (cipherTransform) {

 33618         stream = cipherTransform.createStream(stream, length);

 33619       }

 33620       stream = this.filter(stream, dict, length);

 33621       stream.dict = dict;

 33622       return stream;

 33623     },

 33624     filter: function Parser_filter(stream, dict, length) {

 33625       var filter = this.fetchIfRef(dict.get('Filter', 'F'));

 33626       var params = this.fetchIfRef(dict.get('DecodeParms', 'DP'));

 33627       if (isName(filter)) {

 33628         return this.makeFilter(stream, filter.name, length, params);

 33629       }

 33631       var maybeLength = length;

 33632       if (isArray(filter)) {

 33633         var filterArray = filter;

 33634         var paramsArray = params;

 33635         for (var i = 0, ii = filterArray.length; i < ii; ++i) {

 33636           filter = filterArray[i];

 33637           if (!isName(filter)) {

 33638             error('Bad filter name: ' + filter);

 33639           }

 33641           params = null;

 33642           if (isArray(paramsArray) && (i in paramsArray)) {

 33643             params = paramsArray[i];

 33644           }

 33645           stream = this.makeFilter(stream, filter.name, maybeLength, params);

 33646           // after the first stream the length variable is invalid

 33647           maybeLength = null;

 33648         }

 33649       }

 33650       return stream;

 33651     },

 33652     makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) {

 33653       if (stream.dict.get('Length') === 0) {

 33654         return new NullStream(stream);

 33655       }

 33656       if (name == 'FlateDecode' || name == 'Fl') {

 33657         if (params) {

 33658           return new PredictorStream(new FlateStream(stream, maybeLength),

 33659                                      maybeLength, params);

 33660         }

 33661         return new FlateStream(stream, maybeLength);

 33662       }

 33663       if (name == 'LZWDecode' || name == 'LZW') {

 33664         var earlyChange = 1;

 33665         if (params) {

 33666           if (params.has('EarlyChange')) {

 33667             earlyChange = params.get('EarlyChange');

 33668           }

 33669           return new PredictorStream(

 33670             new LZWStream(stream, maybeLength, earlyChange),

 33671                           maybeLength, params);

 33672         }

 33673         return new LZWStream(stream, maybeLength, earlyChange);

 33674       }

 33675       if (name == 'DCTDecode' || name == 'DCT') {

 33676         return new JpegStream(stream, maybeLength, stream.dict, this.xref);

 33677       }

 33678       if (name == 'JPXDecode' || name == 'JPX') {

 33679         return new JpxStream(stream, maybeLength, stream.dict);

 33680       }

 33681       if (name == 'ASCII85Decode' || name == 'A85') {

 33682         return new Ascii85Stream(stream, maybeLength);

 33683       }

 33684       if (name == 'ASCIIHexDecode' || name == 'AHx') {

 33685         return new AsciiHexStream(stream, maybeLength);

 33686       }

 33687       if (name == 'CCITTFaxDecode' || name == 'CCF') {

 33688         return new CCITTFaxStream(stream, maybeLength, params);

 33689       }

 33690       if (name == 'RunLengthDecode' || name == 'RL') {

 33691         return new RunLengthStream(stream, maybeLength);

 33692       }

 33693       if (name == 'JBIG2Decode') {

 33694         return new Jbig2Stream(stream, maybeLength, stream.dict);

 33695       }

 33696       warn('filter "' + name + '" not supported yet');

 33697       return stream;

 33698     }

 33699   };

 33701   return Parser;

 33702 })();

 33704 var Lexer = (function LexerClosure() {

 33705   function Lexer(stream, knownCommands) {

 33706     this.stream = stream;

 33707     this.nextChar();

 33709     // While lexing, we build up many strings one char at a time. Using += for

 33710     // this can result in lots of garbage strings. It's better to build an

 33711     // array of single-char strings and then join() them together at the end.

 33712     // And reusing a single array (i.e. |this.strBuf|) over and over for this

 33713     // purpose uses less memory than using a new array for each string.

 33714     this.strBuf = [];

 33716     // The PDFs might have "glued" commands with other commands, operands or

 33717     // literals, e.g. "q1". The knownCommands is a dictionary of the valid

 33718     // commands and their prefixes. The prefixes are built the following way:

 33719     // if there a command that is a prefix of the other valid command or

 33720     // literal (e.g. 'f' and 'false') the following prefixes must be included,

 33721     // 'fa', 'fal', 'fals'. The prefixes are not needed, if the command has no

 33722     // other commands or literals as a prefix. The knowCommands is optional.

 33723     this.knownCommands = knownCommands;

 33724   }

 33726   Lexer.isSpace = function Lexer_isSpace(ch) {

 33727     // Space is one of the following characters: SPACE, TAB, CR or LF.

 33728     return (ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A);

 33729   };

 33731   // A '1' in this array means the character is white space. A '1' or

 33732   // '2' means the character ends a name or command.

 33733   var specialChars = [

 33734     1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, // 0x

 33735     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 1x

 33736     1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, // 2x

 33737     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, // 3x

 33738     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 4x

 33739     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, // 5x

 33740     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 6x

 33741     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, // 7x

 33742     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 8x

 33743     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 9x

 33744     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // ax

 33745     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // bx

 33746     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // cx

 33747     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // dx

 33748     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // ex

 33749     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0  // fx

 33750   ];

 33752   function toHexDigit(ch) {

 33753     if (ch >= 0x30 && ch <= 0x39) { // '0'-'9'

 33754       return ch & 0x0F;

 33755     }

 33756     if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {

 33757       // 'A'-'F', 'a'-'f'

 33758       return (ch & 0x0F) + 9;

 33759     }

 33760     return -1;

 33761   }

 33763   Lexer.prototype = {

 33764     nextChar: function Lexer_nextChar() {

 33765       return (this.currentChar = this.stream.getByte());

 33766     },

 33767     peekChar: function Lexer_peekChar() {

 33768       return this.stream.peekBytes(1)[0];

 33769     },

 33770     getNumber: function Lexer_getNumber() {

 33771       var ch = this.currentChar;

 33772       var eNotation = false;

 33773       var divideBy = 0; // different from 0 if it's a floating point value

 33774       var sign = 1;

 33776       if (ch === 0x2D) { // '-'

 33777         sign = -1;

 33778         ch = this.nextChar();

 33779       } else if (ch === 0x2B) { // '+'

 33780         ch = this.nextChar();

 33781       }

 33782       if (ch === 0x2E) { // '.'

 33783         divideBy = 10;

 33784         ch = this.nextChar();

 33785       }

 33786       if (ch < 0x30 || ch > 0x39) { // '0' - '9'

 33787         error('Invalid number: ' + String.fromCharCode(ch));

 33788         return 0;

 33789       }

 33791       var baseValue = ch - 0x30; // '0'

 33792       var powerValue = 0;

 33793       var powerValueSign = 1;

 33795       while ((ch = this.nextChar()) >= 0) {

 33796         if (0x30 <= ch && ch <= 0x39) { // '0' - '9'

 33797           var currentDigit = ch - 0x30; // '0'

 33798           if (eNotation) { // We are after an 'e' or 'E'

 33799             powerValue = powerValue * 10 + currentDigit;

 33800           } else {

 33801             if (divideBy !== 0) { // We are after a point

 33802               divideBy *= 10;

 33803             }

 33804             baseValue = baseValue * 10 + currentDigit;

 33805           }

 33806         } else if (ch === 0x2E) { // '.'

 33807           if (divideBy === 0) {

 33808             divideBy = 1;

 33809           } else {

 33810             // A number can have only one '.'

 33811             break;

 33812           }

 33813         } else if (ch === 0x2D) { // '-'

 33814           // ignore minus signs in the middle of numbers to match

 33815           // Adobe's behavior

 33816           warn('Badly formated number');

 33817         } else if (ch === 0x45 || ch === 0x65) { // 'E', 'e'

 33818           // 'E' can be either a scientific notation or the beginning of a new

 33819           // operator

 33820           ch = this.peekChar();

 33821           if (ch === 0x2B || ch === 0x2D) { // '+', '-'

 33822             powerValueSign = (ch === 0x2D) ? -1 : 1;

 33823             this.nextChar(); // Consume the sign character

 33824           } else if (ch < 0x30 || ch > 0x39) { // '0' - '9'

 33825             // The 'E' must be the beginning of a new operator

 33826             break;

 33827           }

 33828           eNotation = true;

 33829         } else {

 33830           // the last character doesn't belong to us

 33831           break;

 33832         }

 33833       }

 33835       if (divideBy !== 0) {

 33836         baseValue /= divideBy;

 33837       }

 33838       if (eNotation) {

 33839         baseValue *= Math.pow(10, powerValueSign * powerValue);

 33840       }

 33841       return sign * baseValue;

 33842     },

 33843     getString: function Lexer_getString() {

 33844       var numParen = 1;

 33845       var done = false;

 33846       var strBuf = this.strBuf;

 33847       strBuf.length = 0;

 33849       var ch = this.nextChar();

 33850       while (true) {

 33851         var charBuffered = false;

 33852         switch (ch | 0) {

 33853           case -1:

 33854             warn('Unterminated string');

 33855             done = true;

 33856             break;

 33857           case 0x28: // '('

 33858             ++numParen;

 33859             strBuf.push('(');

 33860             break;

 33861           case 0x29: // ')'

 33862             if (--numParen === 0) {

 33863               this.nextChar(); // consume strings ')'

 33864               done = true;

 33865             } else {

 33866               strBuf.push(')');

 33867             }

 33868             break;

 33869           case 0x5C: // '\\'

 33870             ch = this.nextChar();

 33871             switch (ch) {

 33872               case -1:

 33873                 warn('Unterminated string');

 33874                 done = true;

 33875                 break;

 33876               case 0x6E: // 'n'

 33877                 strBuf.push('\n');

 33878                 break;

 33879               case 0x72: // 'r'

 33880                 strBuf.push('\r');

 33881                 break;

 33882               case 0x74: // 't'

 33883                 strBuf.push('\t');

 33884                 break;

 33885               case 0x62: // 'b'

 33886                 strBuf.push('\b');

 33887                 break;

 33888               case 0x66: // 'f'

 33889                 strBuf.push('\f');

 33890                 break;

 33891               case 0x5C: // '\'

 33892               case 0x28: // '('

 33893               case 0x29: // ')'

 33894                 strBuf.push(String.fromCharCode(ch));

 33895                 break;

 33896               case 0x30: case 0x31: case 0x32: case 0x33: // '0'-'3'

 33897               case 0x34: case 0x35: case 0x36: case 0x37: // '4'-'7'

 33898                 var x = ch & 0x0F;

 33899                 ch = this.nextChar();

 33900                 charBuffered = true;

 33901                 if (ch >= 0x30 && ch <= 0x37) { // '0'-'7'

 33902                   x = (x << 3) + (ch & 0x0F);

 33903                   ch = this.nextChar();

 33904                   if (ch >= 0x30 && ch <= 0x37) {  // '0'-'7'

 33905                     charBuffered = false;

 33906                     x = (x << 3) + (ch & 0x0F);

 33907                   }

 33908                 }

 33909                 strBuf.push(String.fromCharCode(x));

 33910                 break;

 33911               case 0x0D: // CR

 33912                 if (this.peekChar() === 0x0A) { // LF

 33913                   this.nextChar();

 33914                 }

 33915                 break;

 33916               case 0x0A: // LF

 33917                 break;

 33918               default:

 33919                 strBuf.push(String.fromCharCode(ch));

 33920                 break;

 33921             }

 33922             break;

 33923           default:

 33924             strBuf.push(String.fromCharCode(ch));

 33925             break;

 33926         }

 33927         if (done) {

 33928           break;

 33929         }

 33930         if (!charBuffered) {

 33931           ch = this.nextChar();

 33932         }

 33933       }

 33934       return strBuf.join('');

 33935     },

 33936     getName: function Lexer_getName() {

 33937       var ch;

 33938       var strBuf = this.strBuf;

 33939       strBuf.length = 0;

 33940       while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {

 33941         if (ch === 0x23) { // '#'

 33942           ch = this.nextChar();

 33943           var x = toHexDigit(ch);

 33944           if (x != -1) {

 33945             var x2 = toHexDigit(this.nextChar());

 33946             if (x2 == -1) {

 33947               error('Illegal digit in hex char in name: ' + x2);

 33948             }

 33949             strBuf.push(String.fromCharCode((x << 4) | x2));

 33950           } else {

 33951             strBuf.push('#', String.fromCharCode(ch));

 33952           }

 33953         } else {

 33954           strBuf.push(String.fromCharCode(ch));

 33955         }

 33956       }

 33957       if (strBuf.length > 128) {

 33958         error('Warning: name token is longer than allowed by the spec: ' +

 33959               strBuf.length);

 33960       }

 33961       return Name.get(strBuf.join(''));

 33962     },

 33963     getHexString: function Lexer_getHexString() {

 33964       var strBuf = this.strBuf;

 33965       strBuf.length = 0;

 33966       var ch = this.currentChar;

 33967       var isFirstHex = true;

 33968       var firstDigit;

 33969       var secondDigit;

 33970       while (true) {

 33971         if (ch < 0) {

 33972           warn('Unterminated hex string');

 33973           break;

 33974         } else if (ch === 0x3E) { // '>'

 33975           this.nextChar();

 33976           break;

 33977         } else if (specialChars[ch] === 1) {

 33978           ch = this.nextChar();

 33979           continue;

 33980         } else {

 33981           if (isFirstHex) {

 33982             firstDigit = toHexDigit(ch);

 33983             if (firstDigit === -1) {

 33984               warn('Ignoring invalid character "' + ch + '" in hex string');

 33985               ch = this.nextChar();

 33986               continue;

 33987             }

 33988           } else {

 33989             secondDigit = toHexDigit(ch);

 33990             if (secondDigit === -1) {

 33991               warn('Ignoring invalid character "' + ch + '" in hex string');

 33992               ch = this.nextChar();

 33993               continue;

 33994             }

 33995             strBuf.push(String.fromCharCode((firstDigit << 4) | secondDigit));

 33996           }

 33997           isFirstHex = !isFirstHex;

 33998           ch = this.nextChar();

 33999         }

 34000       }

 34001       return strBuf.join('');

 34002     },

 34003     getObj: function Lexer_getObj() {

 34004       // skip whitespace and comments

 34005       var comment = false;

 34006       var ch = this.currentChar;

 34007       while (true) {

 34008         if (ch < 0) {

 34009           return EOF;

 34010         }

 34011         if (comment) {

 34012           if (ch === 0x0A || ch == 0x0D) { // LF, CR

 34013             comment = false;

 34014           }

 34015         } else if (ch === 0x25) { // '%'

 34016           comment = true;

 34017         } else if (specialChars[ch] !== 1) {

 34018           break;

 34019         }

 34020         ch = this.nextChar();

 34021       }

 34023       // start reading token

 34024       switch (ch | 0) {

 34025         case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: // '0'-'4'

 34026         case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: // '5'-'9'

 34027         case 0x2B: case 0x2D: case 0x2E: // '+', '-', '.'

 34028           return this.getNumber();

 34029         case 0x28: // '('

 34030           return this.getString();

 34031         case 0x2F: // '/'

 34032           return this.getName();

 34033         // array punctuation

 34034         case 0x5B: // '['

 34035           this.nextChar();

 34036           return Cmd.get('[');

 34037         case 0x5D: // ']'

 34038           this.nextChar();

 34039           return Cmd.get(']');

 34040         // hex string or dict punctuation

 34041         case 0x3C: // '<'

 34042           ch = this.nextChar();

 34043           if (ch === 0x3C) {

 34044             // dict punctuation

 34045             this.nextChar();

 34046             return Cmd.get('<<');

 34047           }

 34048           return this.getHexString();

 34049         // dict punctuation

 34050         case 0x3E: // '>'

 34051           ch = this.nextChar();

 34052           if (ch === 0x3E) {

 34053             this.nextChar();

 34054             return Cmd.get('>>');

 34055           }

 34056           return Cmd.get('>');

 34057         case 0x7B: // '{'

 34058           this.nextChar();

 34059           return Cmd.get('{');

 34060         case 0x7D: // '}'

 34061           this.nextChar();

 34062           return Cmd.get('}');

 34063         case 0x29: // ')'

 34064           error('Illegal character: ' + ch);

 34065           break;

 34066       }

 34068       // command

 34069       var str = String.fromCharCode(ch);

 34070       var knownCommands = this.knownCommands;

 34071       var knownCommandFound = knownCommands && (str in knownCommands);

 34072       while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {

 34073         // stop if known command is found and next character does not make

 34074         // the str a command

 34075         var possibleCommand = str + String.fromCharCode(ch);

 34076         if (knownCommandFound && !(possibleCommand in knownCommands)) {

 34077           break;

 34078         }

 34079         if (str.length == 128) {

 34080           error('Command token too long: ' + str.length);

 34081         }

 34082         str = possibleCommand;

 34083         knownCommandFound = knownCommands && (str in knownCommands);

 34084       }

 34085       if (str == 'true') {

 34086         return true;

 34087       }

 34088       if (str == 'false') {

 34089         return false;

 34090       }

 34091       if (str == 'null') {

 34092         return null;

 34093       }

 34094       return Cmd.get(str);

 34095     },

 34096     skipToNextLine: function Lexer_skipToNextLine() {

 34097       var ch = this.currentChar;

 34098       while (ch >= 0) {

 34099         if (ch === 0x0D) { // CR

 34100           ch = this.nextChar();

 34101           if (ch === 0x0A) { // LF

 34102             this.nextChar();

 34103           }

 34104           break;

 34105         } else if (ch === 0x0A) { // LF

 34106           this.nextChar();

 34107           break;

 34108         }

 34109         ch = this.nextChar();

 34110       }

 34111     }

 34112   };

 34114   return Lexer;

 34115 })();

 34117 var Linearization = (function LinearizationClosure() {

 34118   function Linearization(stream) {

 34119     this.parser = new Parser(new Lexer(stream), false, null);

 34120     var obj1 = this.parser.getObj();

 34121     var obj2 = this.parser.getObj();

 34122     var obj3 = this.parser.getObj();

 34123     this.linDict = this.parser.getObj();

 34124     if (isInt(obj1) && isInt(obj2) && isCmd(obj3, 'obj') &&

 34125         isDict(this.linDict)) {

 34126       var obj = this.linDict.get('Linearized');

 34127       if (!(isNum(obj) && obj > 0)) {

 34128         this.linDict = null;

 34129       }

 34130     }

 34131   }

 34133   Linearization.prototype = {

 34134     getInt: function Linearization_getInt(name) {

 34135       var linDict = this.linDict;

 34136       var obj;

 34137       if (isDict(linDict) && isInt(obj = linDict.get(name)) && obj > 0) {

 34138         return obj;

 34139       }

 34140       error('"' + name + '" field in linearization table is invalid');

 34141     },

 34142     getHint: function Linearization_getHint(index) {

 34143       var linDict = this.linDict;

 34144       var obj1, obj2;

 34145       if (isDict(linDict) && isArray(obj1 = linDict.get('H')) &&

 34146           obj1.length >= 2 && isInt(obj2 = obj1[index]) && obj2 > 0) {

 34147         return obj2;

 34148       }

 34149       error('Hints table in linearization table is invalid: ' + index);

 34150     },

 34151     get length() {

 34152       if (!isDict(this.linDict)) {

 34153         return 0;

 34154       }

 34155       return this.getInt('L');

 34156     },

 34157     get hintsOffset() {

 34158       return this.getHint(0);

 34159     },

 34160     get hintsLength() {

 34161       return this.getHint(1);

 34162     },

 34163     get hintsOffset2() {

 34164       return this.getHint(2);

 34165     },

 34166     get hintsLenth2() {

 34167       return this.getHint(3);

 34168     },

 34169     get objectNumberFirst() {

 34170       return this.getInt('O');

 34171     },

 34172     get endFirst() {

 34173       return this.getInt('E');

 34174     },

 34175     get numPages() {

 34176       return this.getInt('N');

 34177     },

 34178     get mainXRefEntriesOffset() {

 34179       return this.getInt('T');

 34180     },

 34181     get pageFirst() {

 34182       return this.getInt('P');

 34183     }

 34184   };

 34186   return Linearization;

 34187 })();

 34191 var PostScriptParser = (function PostScriptParserClosure() {

 34192   function PostScriptParser(lexer) {

 34193     this.lexer = lexer;

 34194     this.operators = [];

 34195     this.token = null;

 34196     this.prev = null;

 34197   }

 34198   PostScriptParser.prototype = {

 34199     nextToken: function PostScriptParser_nextToken() {

 34200       this.prev = this.token;

 34201       this.token = this.lexer.getToken();

 34202     },

 34203     accept: function PostScriptParser_accept(type) {

 34204       if (this.token.type == type) {

 34205         this.nextToken();

 34206         return true;

 34207       }

 34208       return false;

 34209     },

 34210     expect: function PostScriptParser_expect(type) {

 34211       if (this.accept(type)) {

 34212         return true;

 34213       }

 34214       error('Unexpected symbol: found ' + this.token.type + ' expected ' +

 34215         type + '.');

 34216     },

 34217     parse: function PostScriptParser_parse() {

 34218       this.nextToken();

 34219       this.expect(PostScriptTokenTypes.LBRACE);

 34220       this.parseBlock();

 34221       this.expect(PostScriptTokenTypes.RBRACE);

 34222       return this.operators;

 34223     },

 34224     parseBlock: function PostScriptParser_parseBlock() {

 34225       while (true) {

 34226         if (this.accept(PostScriptTokenTypes.NUMBER)) {

 34227           this.operators.push(this.prev.value);

 34228         } else if (this.accept(PostScriptTokenTypes.OPERATOR)) {

 34229           this.operators.push(this.prev.value);

 34230         } else if (this.accept(PostScriptTokenTypes.LBRACE)) {

 34231           this.parseCondition();

 34232         } else {

 34233           return;

 34234         }

 34235       }

 34236     },

 34237     parseCondition: function PostScriptParser_parseCondition() {

 34238       // Add two place holders that will be updated later

 34239       var conditionLocation = this.operators.length;

 34240       this.operators.push(null, null);

 34242       this.parseBlock();

 34243       this.expect(PostScriptTokenTypes.RBRACE);

 34244       if (this.accept(PostScriptTokenTypes.IF)) {

 34245         // The true block is right after the 'if' so it just falls through on

 34246         // true else it jumps and skips the true block.

 34247         this.operators[conditionLocation] = this.operators.length;

 34248         this.operators[conditionLocation + 1] = 'jz';

 34249       } else if (this.accept(PostScriptTokenTypes.LBRACE)) {

 34250         var jumpLocation = this.operators.length;

 34251         this.operators.push(null, null);

 34252         var endOfTrue = this.operators.length;

 34253         this.parseBlock();

 34254         this.expect(PostScriptTokenTypes.RBRACE);

 34255         this.expect(PostScriptTokenTypes.IFELSE);

 34256         // The jump is added at the end of the true block to skip the false

 34257         // block.

 34258         this.operators[jumpLocation] = this.operators.length;

 34259         this.operators[jumpLocation + 1] = 'j';

 34261         this.operators[conditionLocation] = endOfTrue;

 34262         this.operators[conditionLocation + 1] = 'jz';

 34263       } else {

 34264         error('PS Function: error parsing conditional.');

 34265       }

 34266     }

 34267   };

 34268   return PostScriptParser;

 34269 })();

 34271 var PostScriptTokenTypes = {

 34272   LBRACE: 0,

 34273   RBRACE: 1,

 34274   NUMBER: 2,

 34275   OPERATOR: 3,

 34276   IF: 4,

 34277   IFELSE: 5

 34278 };

 34280 var PostScriptToken = (function PostScriptTokenClosure() {

 34281   function PostScriptToken(type, value) {

 34282     this.type = type;

 34283     this.value = value;

 34284   }

 34286   var opCache = {};

 34288   PostScriptToken.getOperator = function PostScriptToken_getOperator(op) {

 34289     var opValue = opCache[op];

 34290     if (opValue) {

 34291       return opValue;

 34292     }

 34293     return opCache[op] = new PostScriptToken(PostScriptTokenTypes.OPERATOR, op);

 34294   };

 34296   PostScriptToken.LBRACE = new PostScriptToken(PostScriptTokenTypes.LBRACE,

 34297     '{');

 34298   PostScriptToken.RBRACE = new PostScriptToken(PostScriptTokenTypes.RBRACE,

 34299     '}');

 34300   PostScriptToken.IF = new PostScriptToken(PostScriptTokenTypes.IF, 'IF');

 34301   PostScriptToken.IFELSE = new PostScriptToken(PostScriptTokenTypes.IFELSE,

 34302     'IFELSE');

 34303   return PostScriptToken;

 34304 })();

 34306 var PostScriptLexer = (function PostScriptLexerClosure() {

 34307   function PostScriptLexer(stream) {

 34308     this.stream = stream;

 34309     this.nextChar();

 34310   }

 34311   PostScriptLexer.prototype = {

 34312     nextChar: function PostScriptLexer_nextChar() {

 34313       return (this.currentChar = this.stream.getByte());

 34314     },

 34315     getToken: function PostScriptLexer_getToken() {

 34316       var comment = false;

 34317       var ch = this.currentChar;

 34319       // skip comments

 34320       while (true) {

 34321         if (ch < 0) {

 34322           return EOF;

 34323         }

 34325         if (comment) {

 34326           if (ch === 0x0A || ch === 0x0D) {

 34327             comment = false;

 34328           }

 34329         } else if (ch == 0x25) { // '%'

 34330           comment = true;

 34331         } else if (!Lexer.isSpace(ch)) {

 34332           break;

 34333         }

 34334         ch = this.nextChar();

 34335       }

 34336       switch (ch | 0) {

 34337         case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: // '0'-'4'

 34338         case 0x35: case 0x36: case 0x37: case 0x38: case 0x39: // '5'-'9'

 34339         case 0x2B: case 0x2D: case 0x2E: // '+', '-', '.'

 34340           return new PostScriptToken(PostScriptTokenTypes.NUMBER,

 34341                                      this.getNumber());

 34342         case 0x7B: // '{'

 34343           this.nextChar();

 34344           return PostScriptToken.LBRACE;

 34345         case 0x7D: // '}'

 34346           this.nextChar();

 34347           return PostScriptToken.RBRACE;

 34348       }

 34349       // operator

 34350       var str = String.fromCharCode(ch);

 34351       while ((ch = this.nextChar()) >= 0 && // and 'A'-'Z', 'a'-'z'

 34352              ((ch >= 0x41 && ch <= 0x5A) || (ch >= 0x61 && ch <= 0x7A))) {

 34353         str += String.fromCharCode(ch);

 34354       }

 34355       switch (str.toLowerCase()) {

 34356         case 'if':

 34357           return PostScriptToken.IF;

 34358         case 'ifelse':

 34359           return PostScriptToken.IFELSE;

 34360         default:

 34361           return PostScriptToken.getOperator(str);

 34362       }

 34363     },

 34364     getNumber: function PostScriptLexer_getNumber() {

 34365       var ch = this.currentChar;

 34366       var str = String.fromCharCode(ch);

 34367       while ((ch = this.nextChar()) >= 0) {

 34368         if ((ch >= 0x30 && ch <= 0x39) || // '0'-'9'

 34369             ch === 0x2D || ch === 0x2E) { // '-', '.'

 34370           str += String.fromCharCode(ch);

 34371         } else {

 34372           break;

 34373         }

 34374       }

 34375       var value = parseFloat(str);

 34376       if (isNaN(value)) {

 34377         error('Invalid floating point number: ' + value);

 34378       }

 34379       return value;

 34380     }

 34381   };

 34382   return PostScriptLexer;

 34383 })();

 34386 var Stream = (function StreamClosure() {

 34387   function Stream(arrayBuffer, start, length, dict) {

 34388     this.bytes = (arrayBuffer instanceof Uint8Array ?

 34389                   arrayBuffer : new Uint8Array(arrayBuffer));

 34390     this.start = start || 0;

 34391     this.pos = this.start;

 34392     this.end = (start + length) || this.bytes.length;

 34393     this.dict = dict;

 34394   }

 34396   // required methods for a stream. if a particular stream does not

 34397   // implement these, an error should be thrown

 34398   Stream.prototype = {

 34399     get length() {

 34400       return this.end - this.start;

 34401     },

 34402     getByte: function Stream_getByte() {

 34403       if (this.pos >= this.end) {

 34404         return -1;

 34405       }

 34406       return this.bytes[this.pos++];

 34407     },

 34408     getUint16: function Stream_getUint16() {

 34409       var b0 = this.getByte();

 34410       var b1 = this.getByte();

 34411       return (b0 << 8) + b1;

 34412     },

 34413     getInt32: function Stream_getInt32() {

 34414       var b0 = this.getByte();

 34415       var b1 = this.getByte();

 34416       var b2 = this.getByte();

 34417       var b3 = this.getByte();

 34418       return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;

 34419     },

 34420     // returns subarray of original buffer

 34421     // should only be read

 34422     getBytes: function Stream_getBytes(length) {

 34423       var bytes = this.bytes;

 34424       var pos = this.pos;

 34425       var strEnd = this.end;

 34427       if (!length) {

 34428         return bytes.subarray(pos, strEnd);

 34429       }

 34430       var end = pos + length;

 34431       if (end > strEnd) {

 34432         end = strEnd;

 34433       }

 34434       this.pos = end;

 34435       return bytes.subarray(pos, end);

 34436     },

 34437     peekBytes: function Stream_peekBytes(length) {

 34438       var bytes = this.getBytes(length);

 34439       this.pos -= bytes.length;

 34440       return bytes;

 34441     },

 34442     skip: function Stream_skip(n) {

 34443       if (!n) {

 34444         n = 1;

 34445       }

 34446       this.pos += n;

 34447     },

 34448     reset: function Stream_reset() {

 34449       this.pos = this.start;

 34450     },

 34451     moveStart: function Stream_moveStart() {

 34452       this.start = this.pos;

 34453     },

 34454     makeSubStream: function Stream_makeSubStream(start, length, dict) {

 34455       return new Stream(this.bytes.buffer, start, length, dict);

 34456     },

 34457     isStream: true

 34458   };

 34460   return Stream;

 34461 })();

 34463 var StringStream = (function StringStreamClosure() {

 34464   function StringStream(str) {

 34465     var length = str.length;

 34466     var bytes = new Uint8Array(length);

 34467     for (var n = 0; n < length; ++n) {

 34468       bytes[n] = str.charCodeAt(n);

 34469     }

 34470     Stream.call(this, bytes);

 34471   }

 34473   StringStream.prototype = Stream.prototype;

 34475   return StringStream;

 34476 })();

 34478 // super class for the decoding streams

 34479 var DecodeStream = (function DecodeStreamClosure() {

 34480   function DecodeStream(maybeMinBufferLength) {

 34481     this.pos = 0;

 34482     this.bufferLength = 0;

 34483     this.eof = false;

 34484     this.buffer = null;

 34485     this.minBufferLength = 512;

 34486     if (maybeMinBufferLength) {

 34487       // Compute the first power of two that is as big as maybeMinBufferLength.

 34488       while (this.minBufferLength < maybeMinBufferLength) {

 34489         this.minBufferLength *= 2;

 34490       }

 34491     }

 34492   }

 34494   DecodeStream.prototype = {

 34495     ensureBuffer: function DecodeStream_ensureBuffer(requested) {

 34496       var buffer = this.buffer;

 34497       var current;

 34498       if (buffer) {

 34499         current = buffer.byteLength;

 34500         if (requested <= current) {

 34501           return buffer;

 34502         }

 34503       } else {

 34504         current = 0;

 34505       }

 34506       var size = this.minBufferLength;

 34507       while (size < requested) {

 34508         size *= 2;

 34509       }

 34510       var buffer2 = new Uint8Array(size);

 34511       for (var i = 0; i < current; ++i) {

 34512         buffer2[i] = buffer[i];

 34513       }

 34514       return (this.buffer = buffer2);

 34515     },

 34516     getByte: function DecodeStream_getByte() {

 34517       var pos = this.pos;

 34518       while (this.bufferLength <= pos) {

 34519         if (this.eof) {

 34520           return -1;

 34521         }

 34522         this.readBlock();

 34523       }

 34524       return this.buffer[this.pos++];

 34525     },

 34526     getUint16: function DecodeStream_getUint16() {

 34527       var b0 = this.getByte();

 34528       var b1 = this.getByte();

 34529       return (b0 << 8) + b1;

 34530     },

 34531     getInt32: function DecodeStream_getInt32() {

 34532       var b0 = this.getByte();

 34533       var b1 = this.getByte();

 34534       var b2 = this.getByte();

 34535       var b3 = this.getByte();

 34536       return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;

 34537     },

 34538     getBytes: function DecodeStream_getBytes(length) {

 34539       var end, pos = this.pos;

 34541       if (length) {

 34542         this.ensureBuffer(pos + length);

 34543         end = pos + length;

 34545         while (!this.eof && this.bufferLength < end) {

 34546           this.readBlock();

 34547         }

 34548         var bufEnd = this.bufferLength;

 34549         if (end > bufEnd) {

 34550           end = bufEnd;

 34551         }

 34552       } else {

 34553         while (!this.eof) {

 34554           this.readBlock();

 34555         }

 34556         end = this.bufferLength;

 34558         // checking if bufferLength is still 0 then

 34559         // the buffer has to be initialized

 34560         if (!end) {

 34561           this.buffer = new Uint8Array(0);

 34562         }

 34563       }

 34565       this.pos = end;

 34566       return this.buffer.subarray(pos, end);

 34567     },

 34568     peekBytes: function DecodeStream_peekBytes(length) {

 34569       var bytes = this.getBytes(length);

 34570       this.pos -= bytes.length;

 34571       return bytes;

 34572     },

 34573     makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {

 34574       var end = start + length;

 34575       while (this.bufferLength <= end && !this.eof) {

 34576         this.readBlock();

 34577       }

 34578       return new Stream(this.buffer, start, length, dict);

 34579     },

 34580     skip: function Stream_skip(n) {

 34581       if (!n) {

 34582         n = 1;

 34583       }

 34584       this.pos += n;

 34585     },

 34586     reset: function DecodeStream_reset() {

 34587       this.pos = 0;

 34588     },

 34589     getBaseStreams: function DecodeStream_getBaseStreams() {

 34590       if (this.str && this.str.getBaseStreams) {

 34591         return this.str.getBaseStreams();

 34592       }

 34593       return [];

 34594     }

 34595   };

 34597   return DecodeStream;

 34598 })();

 34600 var StreamsSequenceStream = (function StreamsSequenceStreamClosure() {

 34601   function StreamsSequenceStream(streams) {

 34602     this.streams = streams;

 34603     DecodeStream.call(this, /* maybeLength = */ null);

 34604   }

 34606   StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);

 34608   StreamsSequenceStream.prototype.readBlock =

 34609       function streamSequenceStreamReadBlock() {

 34611     var streams = this.streams;

 34612     if (streams.length === 0) {

 34613       this.eof = true;

 34614       return;

 34615     }

 34616     var stream = streams.shift();

 34617     var chunk = stream.getBytes();

 34618     var bufferLength = this.bufferLength;

 34619     var newLength = bufferLength + chunk.length;

 34620     var buffer = this.ensureBuffer(newLength);

 34621     buffer.set(chunk, bufferLength);

 34622     this.bufferLength = newLength;

 34623   };

 34625   StreamsSequenceStream.prototype.getBaseStreams =

 34626     function StreamsSequenceStream_getBaseStreams() {

 34628     var baseStreams = [];

 34629     for (var i = 0, ii = this.streams.length; i < ii; i++) {

 34630       var stream = this.streams[i];

 34631       if (stream.getBaseStreams) {

 34632         Util.concatenateToArray(baseStreams, stream.getBaseStreams());

 34633       }

 34634     }

 34635     return baseStreams;

 34636   };

 34638   return StreamsSequenceStream;

 34639 })();

 34641 var FlateStream = (function FlateStreamClosure() {

 34642   var codeLenCodeMap = new Uint32Array([

 34643     16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15

 34644   ]);

 34646   var lengthDecode = new Uint32Array([

 34647     0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a,

 34648     0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f,

 34649     0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073,

 34650     0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102

 34651   ]);

 34653   var distDecode = new Uint32Array([

 34654     0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d,

 34655     0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1,

 34656     0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01,

 34657     0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001

 34658   ]);

 34660   var fixedLitCodeTab = [new Uint32Array([

 34661     0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0,

 34662     0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0,

 34663     0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0,

 34664     0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0,

 34665     0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8,

 34666     0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8,

 34667     0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8,

 34668     0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8,

 34669     0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4,

 34670     0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4,

 34671     0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4,

 34672     0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4,

 34673     0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc,

 34674     0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec,

 34675     0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc,

 34676     0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc,

 34677     0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2,

 34678     0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2,

 34679     0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2,

 34680     0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2,

 34681     0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca,

 34682     0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea,

 34683     0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da,

 34684     0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa,

 34685     0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6,

 34686     0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6,

 34687     0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6,

 34688     0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6,

 34689     0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce,

 34690     0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee,

 34691     0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de,

 34692     0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe,

 34693     0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1,

 34694     0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1,

 34695     0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1,

 34696     0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1,

 34697     0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9,

 34698     0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9,

 34699     0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9,

 34700     0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9,

 34701     0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5,

 34702     0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5,

 34703     0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5,

 34704     0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5,

 34705     0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd,

 34706     0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed,

 34707     0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd,

 34708     0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd,

 34709     0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3,

 34710     0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3,

 34711     0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3,

 34712     0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3,

 34713     0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb,

 34714     0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb,

 34715     0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db,

 34716     0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb,

 34717     0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7,

 34718     0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7,

 34719     0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7,

 34720     0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7,

 34721     0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf,

 34722     0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef,

 34723     0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df,

 34724     0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff

 34725   ]), 9];

 34727   var fixedDistCodeTab = [new Uint32Array([

 34728     0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c,

 34729     0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000,

 34730     0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d,

 34731     0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000

 34732   ]), 5];

 34734   function FlateStream(str, maybeLength) {

 34735     this.str = str;

 34736     this.dict = str.dict;

 34738     var cmf = str.getByte();

 34739     var flg = str.getByte();

 34740     if (cmf == -1 || flg == -1) {

 34741       error('Invalid header in flate stream: ' + cmf + ', ' + flg);

 34742     }

 34743     if ((cmf & 0x0f) != 0x08) {

 34744       error('Unknown compression method in flate stream: ' + cmf + ', ' + flg);

 34745     }

 34746     if ((((cmf << 8) + flg) % 31) !== 0) {

 34747       error('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);

 34748     }

 34749     if (flg & 0x20) {

 34750       error('FDICT bit set in flate stream: ' + cmf + ', ' + flg);

 34751     }

 34753     this.codeSize = 0;

 34754     this.codeBuf = 0;

 34756     DecodeStream.call(this, maybeLength);

 34757   }

 34759   FlateStream.prototype = Object.create(DecodeStream.prototype);

 34761   FlateStream.prototype.getBits = function FlateStream_getBits(bits) {

 34762     var str = this.str;

 34763     var codeSize = this.codeSize;

 34764     var codeBuf = this.codeBuf;

 34766     var b;

 34767     while (codeSize < bits) {

 34768       if ((b = str.getByte()) === -1) {

 34769         error('Bad encoding in flate stream');

 34770       }

 34771       codeBuf |= b << codeSize;

 34772       codeSize += 8;

 34773     }

 34774     b = codeBuf & ((1 << bits) - 1);

 34775     this.codeBuf = codeBuf >> bits;

 34776     this.codeSize = codeSize -= bits;

 34778     return b;

 34779   };

 34781   FlateStream.prototype.getCode = function FlateStream_getCode(table) {

 34782     var str = this.str;

 34783     var codes = table[0];

 34784     var maxLen = table[1];

 34785     var codeSize = this.codeSize;

 34786     var codeBuf = this.codeBuf;

 34788     while (codeSize < maxLen) {

 34789       var b;

 34790       if ((b = str.getByte()) === -1) {

 34791         error('Bad encoding in flate stream');

 34792       }

 34793       codeBuf |= (b << codeSize);

 34794       codeSize += 8;

 34795     }

 34796     var code = codes[codeBuf & ((1 << maxLen) - 1)];

 34797     var codeLen = code >> 16;

 34798     var codeVal = code & 0xffff;

 34799     if (codeSize === 0 || codeSize < codeLen || codeLen === 0) {

 34800       error('Bad encoding in flate stream');

 34801     }

 34802     this.codeBuf = (codeBuf >> codeLen);

 34803     this.codeSize = (codeSize - codeLen);

 34804     return codeVal;

 34805   };

 34807   FlateStream.prototype.generateHuffmanTable =

 34808     function flateStreamGenerateHuffmanTable(lengths) {

 34809     var n = lengths.length;

 34811     // find max code length

 34812     var maxLen = 0;

 34813     var i;

 34814     for (i = 0; i < n; ++i) {

 34815       if (lengths[i] > maxLen) {

 34816         maxLen = lengths[i];

 34817       }

 34818     }

 34820     // build the table

 34821     var size = 1 << maxLen;

 34822     var codes = new Uint32Array(size);

 34823     for (var len = 1, code = 0, skip = 2;

 34824          len <= maxLen;

 34825          ++len, code <<= 1, skip <<= 1) {

 34826       for (var val = 0; val < n; ++val) {

 34827         if (lengths[val] == len) {

 34828           // bit-reverse the code

 34829           var code2 = 0;

 34830           var t = code;

 34831           for (i = 0; i < len; ++i) {

 34832             code2 = (code2 << 1) | (t & 1);

 34833             t >>= 1;

 34834           }

 34836           // fill the table entries

 34837           for (i = code2; i < size; i += skip) {

 34838             codes[i] = (len << 16) | val;

 34839           }

 34840           ++code;

 34841         }

 34842       }

 34843     }

 34845     return [codes, maxLen];

 34846   };

 34848   FlateStream.prototype.readBlock = function FlateStream_readBlock() {

 34849     var buffer, len;

 34850     var str = this.str;

 34851     // read block header

 34852     var hdr = this.getBits(3);

 34853     if (hdr & 1) {

 34854       this.eof = true;

 34855     }

 34856     hdr >>= 1;

 34858     if (hdr === 0) { // uncompressed block

 34859       var b;

 34861       if ((b = str.getByte()) === -1) {

 34862         error('Bad block header in flate stream');

 34863       }

 34864       var blockLen = b;

 34865       if ((b = str.getByte()) === -1) {

 34866         error('Bad block header in flate stream');

 34867       }

 34868       blockLen |= (b << 8);

 34869       if ((b = str.getByte()) === -1) {

 34870         error('Bad block header in flate stream');

 34871       }

 34872       var check = b;

 34873       if ((b = str.getByte()) === -1) {

 34874         error('Bad block header in flate stream');

 34875       }

 34876       check |= (b << 8);

 34877       if (check != (~blockLen & 0xffff) &&

 34878           (blockLen !== 0 || check !== 0)) {

 34879         // Ignoring error for bad "empty" block (see issue 1277)

 34880         error('Bad uncompressed block length in flate stream');

 34881       }

 34883       this.codeBuf = 0;

 34884       this.codeSize = 0;

 34886       var bufferLength = this.bufferLength;

 34887       buffer = this.ensureBuffer(bufferLength + blockLen);

 34888       var end = bufferLength + blockLen;

 34889       this.bufferLength = end;

 34890       if (blockLen === 0) {

 34891         if (str.peekBytes(1).length === 0) {

 34892           this.eof = true;

 34893         }

 34894       } else {

 34895         for (var n = bufferLength; n < end; ++n) {

 34896           if ((b = str.getByte()) === -1) {

 34897             this.eof = true;

 34898             break;

 34899           }

 34900           buffer[n] = b;

 34901         }

 34902       }

 34903       return;

 34904     }

 34906     var litCodeTable;

 34907     var distCodeTable;

 34908     if (hdr == 1) { // compressed block, fixed codes

 34909       litCodeTable = fixedLitCodeTab;

 34910       distCodeTable = fixedDistCodeTab;

 34911     } else if (hdr == 2) { // compressed block, dynamic codes

 34912       var numLitCodes = this.getBits(5) + 257;

 34913       var numDistCodes = this.getBits(5) + 1;

 34914       var numCodeLenCodes = this.getBits(4) + 4;

 34916       // build the code lengths code table

 34917       var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);

 34919       var i;

 34920       for (i = 0; i < numCodeLenCodes; ++i) {

 34921         codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);

 34922       }

 34923       var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);

 34925       // build the literal and distance code tables

 34926       len = 0;

 34927       i = 0;

 34928       var codes = numLitCodes + numDistCodes;

 34929       var codeLengths = new Uint8Array(codes);

 34930       var bitsLength, bitsOffset, what;

 34931       while (i < codes) {

 34932         var code = this.getCode(codeLenCodeTab);

 34933         if (code == 16) {

 34934           bitsLength = 2; bitsOffset = 3; what = len;

 34935         } else if (code == 17) {

 34936           bitsLength = 3; bitsOffset = 3; what = (len = 0);

 34937         } else if (code == 18) {

 34938           bitsLength = 7; bitsOffset = 11; what = (len = 0);

 34939         } else {

 34940           codeLengths[i++] = len = code;

 34941           continue;

 34942         }

 34944         var repeatLength = this.getBits(bitsLength) + bitsOffset;

 34945         while (repeatLength-- > 0) {

 34946           codeLengths[i++] = what;

 34947         }

 34948       }

 34950       litCodeTable =

 34951         this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));

 34952       distCodeTable =

 34953         this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));

 34954     } else {

 34955       error('Unknown block type in flate stream');

 34956     }

 34958     buffer = this.buffer;

 34959     var limit = buffer ? buffer.length : 0;

 34960     var pos = this.bufferLength;

 34961     while (true) {

 34962       var code1 = this.getCode(litCodeTable);

 34963       if (code1 < 256) {

 34964         if (pos + 1 >= limit) {

 34965           buffer = this.ensureBuffer(pos + 1);

 34966           limit = buffer.length;

 34967         }

 34968         buffer[pos++] = code1;

 34969         continue;

 34970       }

 34971       if (code1 == 256) {

 34972         this.bufferLength = pos;

 34973         return;

 34974       }

 34975       code1 -= 257;

 34976       code1 = lengthDecode[code1];

 34977       var code2 = code1 >> 16;

 34978       if (code2 > 0) {

 34979         code2 = this.getBits(code2);

 34980       }

 34981       len = (code1 & 0xffff) + code2;

 34982       code1 = this.getCode(distCodeTable);

 34983       code1 = distDecode[code1];

 34984       code2 = code1 >> 16;

 34985       if (code2 > 0) {

 34986         code2 = this.getBits(code2);

 34987       }

 34988       var dist = (code1 & 0xffff) + code2;

 34989       if (pos + len >= limit) {

 34990         buffer = this.ensureBuffer(pos + len);

 34991         limit = buffer.length;

 34992       }

 34993       for (var k = 0; k < len; ++k, ++pos) {

 34994         buffer[pos] = buffer[pos - dist];

 34995       }

 34996     }

 34997   };

 34999   return FlateStream;

 35000 })();

 35002 var PredictorStream = (function PredictorStreamClosure() {

 35003   function PredictorStream(str, maybeLength, params) {

 35004     var predictor = this.predictor = params.get('Predictor') || 1;

 35006     if (predictor <= 1) {

 35007       return str; // no prediction

 35008     }

 35009     if (predictor !== 2 && (predictor < 10 || predictor > 15)) {

 35010       error('Unsupported predictor: ' + predictor);

 35011     }

 35013     if (predictor === 2) {

 35014       this.readBlock = this.readBlockTiff;

 35015     } else {

 35016       this.readBlock = this.readBlockPng;

 35017     }

 35019     this.str = str;

 35020     this.dict = str.dict;

 35022     var colors = this.colors = params.get('Colors') || 1;

 35023     var bits = this.bits = params.get('BitsPerComponent') || 8;

 35024     var columns = this.columns = params.get('Columns') || 1;

 35026     this.pixBytes = (colors * bits + 7) >> 3;

 35027     this.rowBytes = (columns * colors * bits + 7) >> 3;

 35029     DecodeStream.call(this, maybeLength);

 35030     return this;

 35031   }

 35033   PredictorStream.prototype = Object.create(DecodeStream.prototype);

 35035   PredictorStream.prototype.readBlockTiff =

 35036       function predictorStreamReadBlockTiff() {

 35037     var rowBytes = this.rowBytes;

 35039     var bufferLength = this.bufferLength;

 35040     var buffer = this.ensureBuffer(bufferLength + rowBytes);

 35042     var bits = this.bits;

 35043     var colors = this.colors;

 35045     var rawBytes = this.str.getBytes(rowBytes);

 35046     this.eof = !rawBytes.length;

 35047     if (this.eof) {

 35048       return;

 35049     }

 35051     var inbuf = 0, outbuf = 0;

 35052     var inbits = 0, outbits = 0;

 35053     var pos = bufferLength;

 35054     var i;

 35056     if (bits === 1) {

 35057       for (i = 0; i < rowBytes; ++i) {

 35058         var c = rawBytes[i];

 35059         inbuf = (inbuf << 8) | c;

 35060         // bitwise addition is exclusive or

 35061         // first shift inbuf and then add

 35062         buffer[pos++] = (c ^ (inbuf >> colors)) & 0xFF;

 35063         // truncate inbuf (assumes colors < 16)

 35064         inbuf &= 0xFFFF;

 35065       }

 35066     } else if (bits === 8) {

 35067       for (i = 0; i < colors; ++i) {

 35068         buffer[pos++] = rawBytes[i];

 35069       }

 35070       for (; i < rowBytes; ++i) {

 35071         buffer[pos] = buffer[pos - colors] + rawBytes[i];

 35072         pos++;

 35073       }

 35074     } else {

 35075       var compArray = new Uint8Array(colors + 1);

 35076       var bitMask = (1 << bits) - 1;

 35077       var j = 0, k = bufferLength;

 35078       var columns = this.columns;

 35079       for (i = 0; i < columns; ++i) {

 35080         for (var kk = 0; kk < colors; ++kk) {

 35081           if (inbits < bits) {

 35082             inbuf = (inbuf << 8) | (rawBytes[j++] & 0xFF);

 35083             inbits += 8;

 35084           }

 35085           compArray[kk] = (compArray[kk] +

 35086                            (inbuf >> (inbits - bits))) & bitMask;

 35087           inbits -= bits;

 35088           outbuf = (outbuf << bits) | compArray[kk];

 35089           outbits += bits;

 35090           if (outbits >= 8) {

 35091             buffer[k++] = (outbuf >> (outbits - 8)) & 0xFF;

 35092             outbits -= 8;

 35093           }

 35094         }

 35095       }

 35096       if (outbits > 0) {

 35097         buffer[k++] = (outbuf << (8 - outbits)) +

 35098                       (inbuf & ((1 << (8 - outbits)) - 1));

 35099       }

 35100     }

 35101     this.bufferLength += rowBytes;

 35102   };

 35104   PredictorStream.prototype.readBlockPng =

 35105       function predictorStreamReadBlockPng() {

 35107     var rowBytes = this.rowBytes;

 35108     var pixBytes = this.pixBytes;

 35110     var predictor = this.str.getByte();

 35111     var rawBytes = this.str.getBytes(rowBytes);

 35112     this.eof = !rawBytes.length;

 35113     if (this.eof) {

 35114       return;

 35115     }

 35117     var bufferLength = this.bufferLength;

 35118     var buffer = this.ensureBuffer(bufferLength + rowBytes);

 35120     var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);

 35121     if (prevRow.length === 0) {

 35122       prevRow = new Uint8Array(rowBytes);

 35123     }

 35125     var i, j = bufferLength, up, c;

 35126     switch (predictor) {

 35127       case 0:

 35128         for (i = 0; i < rowBytes; ++i) {

 35129           buffer[j++] = rawBytes[i];

 35130         }

 35131         break;

 35132       case 1:

 35133         for (i = 0; i < pixBytes; ++i) {

 35134           buffer[j++] = rawBytes[i];

 35135         }

 35136         for (; i < rowBytes; ++i) {

 35137           buffer[j] = (buffer[j - pixBytes] + rawBytes[i]) & 0xFF;

 35138           j++;

 35139         }

 35140         break;

 35141       case 2:

 35142         for (i = 0; i < rowBytes; ++i) {

 35143           buffer[j++] = (prevRow[i] + rawBytes[i]) & 0xFF;

 35144         }

 35145         break;

 35146       case 3:

 35147         for (i = 0; i < pixBytes; ++i) {

 35148           buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];

 35149         }

 35150         for (; i < rowBytes; ++i) {

 35151           buffer[j] = (((prevRow[i] + buffer[j - pixBytes]) >> 1) +

 35152                            rawBytes[i]) & 0xFF;

 35153           j++;

 35154         }

 35155         break;

 35156       case 4:

 35157         // we need to save the up left pixels values. the simplest way

 35158         // is to create a new buffer

 35159         for (i = 0; i < pixBytes; ++i) {

 35160           up = prevRow[i];

 35161           c = rawBytes[i];

 35162           buffer[j++] = up + c;

 35163         }

 35164         for (; i < rowBytes; ++i) {

 35165           up = prevRow[i];

 35166           var upLeft = prevRow[i - pixBytes];

 35167           var left = buffer[j - pixBytes];

 35168           var p = left + up - upLeft;

 35170           var pa = p - left;

 35171           if (pa < 0) {

 35172             pa = -pa;

 35173           }

 35174           var pb = p - up;

 35175           if (pb < 0) {

 35176             pb = -pb;

 35177           }

 35178           var pc = p - upLeft;

 35179           if (pc < 0) {

 35180             pc = -pc;

 35181           }

 35183           c = rawBytes[i];

 35184           if (pa <= pb && pa <= pc) {

 35185             buffer[j++] = left + c;

 35186           } else if (pb <= pc) {

 35187             buffer[j++] = up + c;

 35188           } else {

 35189             buffer[j++] = upLeft + c;

 35190           }

 35191         }

 35192         break;

 35193       default:

 35194         error('Unsupported predictor: ' + predictor);

 35195     }

 35196     this.bufferLength += rowBytes;

 35197   };

 35199   return PredictorStream;

 35200 })();

 35202 /**

 35203  * Depending on the type of JPEG a JpegStream is handled in different ways. For

 35204  * JPEG's that are supported natively such as DeviceGray and DeviceRGB the image

 35205  * data is stored and then loaded by the browser.  For unsupported JPEG's we use

 35206  * a library to decode these images and the stream behaves like all the other

 35207  * DecodeStreams.

 35208  */

 35209 var JpegStream = (function JpegStreamClosure() {

 35210   function JpegStream(stream, maybeLength, dict, xref) {

 35211     // TODO: per poppler, some images may have 'junk' before that

 35212     // need to be removed

 35213     this.stream = stream;

 35214     this.maybeLength = maybeLength;

 35215     this.dict = dict;

 35217     DecodeStream.call(this, maybeLength);

 35218   }

 35220   JpegStream.prototype = Object.create(DecodeStream.prototype);

 35222   Object.defineProperty(JpegStream.prototype, 'bytes', {

 35223     get: function JpegStream_bytes() {

 35224       // If this.maybeLength is null, we'll get the entire stream.

 35225       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));

 35226     },

 35227     configurable: true

 35228   });

 35230   JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) {

 35231     if (this.bufferLength) {

 35232       return;

 35233     }

 35234     try {

 35235       var jpegImage = new JpegImage();

 35236       if (this.colorTransform != -1) {

 35237         jpegImage.colorTransform = this.colorTransform;

 35238       }

 35239       jpegImage.parse(this.bytes);

 35240       var width = jpegImage.width;

 35241       var height = jpegImage.height;

 35242       var data = jpegImage.getData(width, height);

 35243       this.buffer = data;

 35244       this.bufferLength = data.length;

 35245       this.eof = true;

 35246     } catch (e) {

 35247       error('JPEG error: ' + e);

 35248     }

 35249   };

 35250   JpegStream.prototype.getIR = function JpegStream_getIR() {

 35251     return PDFJS.createObjectURL(this.bytes, 'image/jpeg');

 35252   };

 35253   /**

 35254    * Checks if the image can be decoded and displayed by the browser without any

 35255    * further processing such as color space conversions.

 35256    */

 35257   JpegStream.prototype.isNativelySupported =

 35258       function JpegStream_isNativelySupported(xref, res) {

 35259     var cs = ColorSpace.parse(this.dict.get('ColorSpace', 'CS'), xref, res);

 35260     return cs.name === 'DeviceGray' || cs.name === 'DeviceRGB';

 35261   };

 35262   /**

 35263    * Checks if the image can be decoded by the browser.

 35264    */

 35265   JpegStream.prototype.isNativelyDecodable =

 35266       function JpegStream_isNativelyDecodable(xref, res) {

 35267     var cs = ColorSpace.parse(this.dict.get('ColorSpace', 'CS'), xref, res);

 35268     var numComps = cs.numComps;

 35269     return numComps == 1 || numComps == 3;

 35270   };

 35272   return JpegStream;

 35273 })();

 35275 /**

 35276  * For JPEG 2000's we use a library to decode these images and

 35277  * the stream behaves like all the other DecodeStreams.

 35278  */

 35279 var JpxStream = (function JpxStreamClosure() {

 35280   function JpxStream(stream, maybeLength, dict) {

 35281     this.stream = stream;

 35282     this.maybeLength = maybeLength;

 35283     this.dict = dict;

 35285     DecodeStream.call(this, maybeLength);

 35286   }

 35288   JpxStream.prototype = Object.create(DecodeStream.prototype);

 35290   Object.defineProperty(JpxStream.prototype, 'bytes', {

 35291     get: function JpxStream_bytes() {

 35292       // If this.maybeLength is null, we'll get the entire stream.

 35293       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));

 35294     },

 35295     configurable: true

 35296   });

 35298   JpxStream.prototype.ensureBuffer = function JpxStream_ensureBuffer(req) {

 35299     if (this.bufferLength) {

 35300       return;

 35301     }

 35303     var jpxImage = new JpxImage();

 35304     jpxImage.parse(this.bytes);

 35306     var width = jpxImage.width;

 35307     var height = jpxImage.height;

 35308     var componentsCount = jpxImage.componentsCount;

 35309     var tileCount = jpxImage.tiles.length;

 35310     if (tileCount === 1) {

 35311       this.buffer = jpxImage.tiles[0].items;

 35312     } else {

 35313       var data = new Uint8Array(width * height * componentsCount);

 35315       for (var k = 0; k < tileCount; k++) {

 35316         var tileComponents = jpxImage.tiles[k];

 35317         var tileWidth = tileComponents.width;

 35318         var tileHeight = tileComponents.height;

 35319         var tileLeft = tileComponents.left;

 35320         var tileTop = tileComponents.top;

 35322         var src = tileComponents.items;

 35323         var srcPosition = 0;

 35324         var dataPosition = (width * tileTop + tileLeft) * componentsCount;

 35325         var imgRowSize = width * componentsCount;

 35326         var tileRowSize = tileWidth * componentsCount;

 35328         for (var j = 0; j < tileHeight; j++) {

 35329           var rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);

 35330           data.set(rowBytes, dataPosition);

 35331           srcPosition += tileRowSize;

 35332           dataPosition += imgRowSize;

 35333         }

 35334       }

 35335       this.buffer = data;

 35336     }

 35337     this.bufferLength = this.buffer.length;

 35338     this.eof = true;

 35339   };

 35341   return JpxStream;

 35342 })();

 35344 /**

 35345  * For JBIG2's we use a library to decode these images and

 35346  * the stream behaves like all the other DecodeStreams.

 35347  */

 35348 var Jbig2Stream = (function Jbig2StreamClosure() {

 35349   function Jbig2Stream(stream, maybeLength, dict) {

 35350     this.stream = stream;

 35351     this.maybeLength = maybeLength;

 35352     this.dict = dict;

 35354     DecodeStream.call(this, maybeLength);

 35355   }

 35357   Jbig2Stream.prototype = Object.create(DecodeStream.prototype);

 35359   Object.defineProperty(Jbig2Stream.prototype, 'bytes', {

 35360     get: function Jbig2Stream_bytes() {

 35361       // If this.maybeLength is null, we'll get the entire stream.

 35362       return shadow(this, 'bytes', this.stream.getBytes(this.maybeLength));

 35363     },

 35364     configurable: true

 35365   });

 35367   Jbig2Stream.prototype.ensureBuffer = function Jbig2Stream_ensureBuffer(req) {

 35368     if (this.bufferLength) {

 35369       return;

 35370     }

 35372     var jbig2Image = new Jbig2Image();

 35374     var chunks = [], decodeParams = this.dict.get('DecodeParms');

 35376     // According to the PDF specification, DecodeParms can be either

 35377     // a dictionary, or an array whose elements are dictionaries.

 35378     if (isArray(decodeParams)) {

 35379       if (decodeParams.length > 1) {

 35380         warn('JBIG2 - \'DecodeParms\' array with multiple elements ' +

 35381              'not supported.');

 35382       }

 35383       decodeParams = decodeParams[0];

 35384     }

 35385     if (decodeParams && decodeParams.has('JBIG2Globals')) {

 35386       var globalsStream = decodeParams.get('JBIG2Globals');

 35387       var globals = globalsStream.getBytes();

 35388       chunks.push({data: globals, start: 0, end: globals.length});

 35389     }

 35390     chunks.push({data: this.bytes, start: 0, end: this.bytes.length});

 35391     var data = jbig2Image.parseChunks(chunks);

 35392     var dataLength = data.length;

 35394     // JBIG2 had black as 1 and white as 0, inverting the colors

 35395     for (var i = 0; i < dataLength; i++) {

 35396       data[i] ^= 0xFF;

 35397     }

 35399     this.buffer = data;

 35400     this.bufferLength = dataLength;

 35401     this.eof = true;

 35402   };

 35404   return Jbig2Stream;

 35405 })();

 35407 var DecryptStream = (function DecryptStreamClosure() {

 35408   function DecryptStream(str, maybeLength, decrypt) {

 35409     this.str = str;

 35410     this.dict = str.dict;

 35411     this.decrypt = decrypt;

 35412     this.nextChunk = null;

 35413     this.initialized = false;

 35415     DecodeStream.call(this, maybeLength);

 35416   }

 35418   var chunkSize = 512;

 35420   DecryptStream.prototype = Object.create(DecodeStream.prototype);

 35422   DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {

 35423     var chunk;

 35424     if (this.initialized) {

 35425       chunk = this.nextChunk;

 35426     } else {

 35427       chunk = this.str.getBytes(chunkSize);

 35428       this.initialized = true;

 35429     }

 35430     if (!chunk || chunk.length === 0) {

 35431       this.eof = true;

 35432       return;

 35433     }

 35434     this.nextChunk = this.str.getBytes(chunkSize);

 35435     var hasMoreData = this.nextChunk && this.nextChunk.length > 0;

 35437     var decrypt = this.decrypt;

 35438     chunk = decrypt(chunk, !hasMoreData);

 35440     var bufferLength = this.bufferLength;

 35441     var i, n = chunk.length;

 35442     var buffer = this.ensureBuffer(bufferLength + n);

 35443     for (i = 0; i < n; i++) {

 35444       buffer[bufferLength++] = chunk[i];

 35445     }

 35446     this.bufferLength = bufferLength;

 35447   };

 35449   return DecryptStream;

 35450 })();

 35452 var Ascii85Stream = (function Ascii85StreamClosure() {

 35453   function Ascii85Stream(str, maybeLength) {

 35454     this.str = str;

 35455     this.dict = str.dict;

 35456     this.input = new Uint8Array(5);

 35458     // Most streams increase in size when decoded, but Ascii85 streams

 35459     // typically shrink by ~20%.

 35460     if (maybeLength) {

 35461       maybeLength = 0.8 * maybeLength;

 35462     }

 35463     DecodeStream.call(this, maybeLength);

 35464   }

 35466   Ascii85Stream.prototype = Object.create(DecodeStream.prototype);

 35468   Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {

 35469     var TILDA_CHAR = 0x7E; // '~'

 35470     var Z_LOWER_CHAR = 0x7A; // 'z'

 35471     var EOF = -1;

 35473     var str = this.str;

 35475     var c = str.getByte();

 35476     while (Lexer.isSpace(c)) {

 35477       c = str.getByte();

 35478     }

 35480     if (c === EOF || c === TILDA_CHAR) {

 35481       this.eof = true;

 35482       return;

 35483     }

 35485     var bufferLength = this.bufferLength, buffer;

 35486     var i;

 35488     // special code for z

 35489     if (c == Z_LOWER_CHAR) {

 35490       buffer = this.ensureBuffer(bufferLength + 4);

 35491       for (i = 0; i < 4; ++i) {

 35492         buffer[bufferLength + i] = 0;

 35493       }

 35494       this.bufferLength += 4;

 35495     } else {

 35496       var input = this.input;

 35497       input[0] = c;

 35498       for (i = 1; i < 5; ++i) {

 35499         c = str.getByte();

 35500         while (Lexer.isSpace(c)) {

 35501           c = str.getByte();

 35502         }

 35504         input[i] = c;

 35506         if (c === EOF || c == TILDA_CHAR) {

 35507           break;

 35508         }

 35509       }

 35510       buffer = this.ensureBuffer(bufferLength + i - 1);

 35511       this.bufferLength += i - 1;

 35513       // partial ending;

 35514       if (i < 5) {

 35515         for (; i < 5; ++i) {

 35516           input[i] = 0x21 + 84;

 35517         }

 35518         this.eof = true;

 35519       }

 35520       var t = 0;

 35521       for (i = 0; i < 5; ++i) {

 35522         t = t * 85 + (input[i] - 0x21);

 35523       }

 35525       for (i = 3; i >= 0; --i) {

 35526         buffer[bufferLength + i] = t & 0xFF;

 35527         t >>= 8;

 35528       }

 35529     }

 35530   };

 35532   return Ascii85Stream;

 35533 })();

 35535 var AsciiHexStream = (function AsciiHexStreamClosure() {

 35536   function AsciiHexStream(str, maybeLength) {

 35537     this.str = str;

 35538     this.dict = str.dict;

 35540     this.firstDigit = -1;

 35542     // Most streams increase in size when decoded, but AsciiHex streams shrink

 35543     // by 50%.

 35544     if (maybeLength) {

 35545       maybeLength = 0.5 * maybeLength;

 35546     }

 35547     DecodeStream.call(this, maybeLength);

 35548   }

 35550   AsciiHexStream.prototype = Object.create(DecodeStream.prototype);

 35552   AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {

 35553     var UPSTREAM_BLOCK_SIZE = 8000;

 35554     var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);

 35555     if (!bytes.length) {

 35556       this.eof = true;

 35557       return;

 35558     }

 35560     var maxDecodeLength = (bytes.length + 1) >> 1;

 35561     var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);

 35562     var bufferLength = this.bufferLength;

 35564     var firstDigit = this.firstDigit;

 35565     for (var i = 0, ii = bytes.length; i < ii; i++) {

 35566       var ch = bytes[i], digit;

 35567       if (ch >= 0x30 && ch <= 0x39) { // '0'-'9'

 35568         digit = ch & 0x0F;

 35569       } else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {

 35570         // 'A'-'Z', 'a'-'z'

 35571         digit = (ch & 0x0F) + 9;

 35572       } else if (ch === 0x3E) { // '>'

 35573         this.eof = true;

 35574         break;

 35575       } else { // probably whitespace

 35576         continue; // ignoring

 35577       }

 35578       if (firstDigit < 0) {

 35579         firstDigit = digit;

 35580       } else {

 35581         buffer[bufferLength++] = (firstDigit << 4) | digit;

 35582         firstDigit = -1;

 35583       }

 35584     }

 35585     if (firstDigit >= 0 && this.eof) {

 35586       // incomplete byte

 35587       buffer[bufferLength++] = (firstDigit << 4);

 35588       firstDigit = -1;

 35589     }

 35590     this.firstDigit = firstDigit;

 35591     this.bufferLength = bufferLength;

 35592   };

 35594   return AsciiHexStream;

 35595 })();

 35597 var RunLengthStream = (function RunLengthStreamClosure() {

 35598   function RunLengthStream(str, maybeLength) {

 35599     this.str = str;

 35600     this.dict = str.dict;

 35602     DecodeStream.call(this, maybeLength);

 35603   }

 35605   RunLengthStream.prototype = Object.create(DecodeStream.prototype);

 35607   RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {

 35608     // The repeatHeader has following format. The first byte defines type of run

 35609     // and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes

 35610     // (in addition to the second byte from the header), n = 129 through 255 -

 35611     // duplicate the second byte from the header (257 - n) times, n = 128 - end.

 35612     var repeatHeader = this.str.getBytes(2);

 35613     if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] == 128) {

 35614       this.eof = true;

 35615       return;

 35616     }

 35618     var buffer;

 35619     var bufferLength = this.bufferLength;

 35620     var n = repeatHeader[0];

 35621     if (n < 128) {

 35622       // copy n bytes

 35623       buffer = this.ensureBuffer(bufferLength + n + 1);

 35624       buffer[bufferLength++] = repeatHeader[1];

 35625       if (n > 0) {

 35626         var source = this.str.getBytes(n);

 35627         buffer.set(source, bufferLength);

 35628         bufferLength += n;

 35629       }

 35630     } else {

 35631       n = 257 - n;

 35632       var b = repeatHeader[1];

 35633       buffer = this.ensureBuffer(bufferLength + n + 1);

 35634       for (var i = 0; i < n; i++) {

 35635         buffer[bufferLength++] = b;

 35636       }

 35637     }

 35638     this.bufferLength = bufferLength;

 35639   };

 35641   return RunLengthStream;

 35642 })();

 35644 var CCITTFaxStream = (function CCITTFaxStreamClosure() {

 35646   var ccittEOL = -2;

 35647   var twoDimPass = 0;

 35648   var twoDimHoriz = 1;

 35649   var twoDimVert0 = 2;

 35650   var twoDimVertR1 = 3;

 35651   var twoDimVertL1 = 4;

 35652   var twoDimVertR2 = 5;

 35653   var twoDimVertL2 = 6;

 35654   var twoDimVertR3 = 7;

 35655   var twoDimVertL3 = 8;

 35657   var twoDimTable = [

 35658     [-1, -1], [-1, -1],                   // 000000x

 35659     [7, twoDimVertL3],                    // 0000010

 35660     [7, twoDimVertR3],                    // 0000011

 35661     [6, twoDimVertL2], [6, twoDimVertL2], // 000010x

 35662     [6, twoDimVertR2], [6, twoDimVertR2], // 000011x

 35663     [4, twoDimPass], [4, twoDimPass],     // 0001xxx

 35664     [4, twoDimPass], [4, twoDimPass],

 35665     [4, twoDimPass], [4, twoDimPass],

 35666     [4, twoDimPass], [4, twoDimPass],

 35667     [3, twoDimHoriz], [3, twoDimHoriz],   // 001xxxx

 35668     [3, twoDimHoriz], [3, twoDimHoriz],

 35669     [3, twoDimHoriz], [3, twoDimHoriz],

 35670     [3, twoDimHoriz], [3, twoDimHoriz],

 35671     [3, twoDimHoriz], [3, twoDimHoriz],

 35672     [3, twoDimHoriz], [3, twoDimHoriz],

 35673     [3, twoDimHoriz], [3, twoDimHoriz],

 35674     [3, twoDimHoriz], [3, twoDimHoriz],

 35675     [3, twoDimVertL1], [3, twoDimVertL1], // 010xxxx

 35676     [3, twoDimVertL1], [3, twoDimVertL1],

 35677     [3, twoDimVertL1], [3, twoDimVertL1],

 35678     [3, twoDimVertL1], [3, twoDimVertL1],

 35679     [3, twoDimVertL1], [3, twoDimVertL1],

 35680     [3, twoDimVertL1], [3, twoDimVertL1],

 35681     [3, twoDimVertL1], [3, twoDimVertL1],

 35682     [3, twoDimVertL1], [3, twoDimVertL1],

 35683     [3, twoDimVertR1], [3, twoDimVertR1], // 011xxxx

 35684     [3, twoDimVertR1], [3, twoDimVertR1],

 35685     [3, twoDimVertR1], [3, twoDimVertR1],

 35686     [3, twoDimVertR1], [3, twoDimVertR1],

 35687     [3, twoDimVertR1], [3, twoDimVertR1],

 35688     [3, twoDimVertR1], [3, twoDimVertR1],

 35689     [3, twoDimVertR1], [3, twoDimVertR1],

 35690     [3, twoDimVertR1], [3, twoDimVertR1],

 35691     [1, twoDimVert0], [1, twoDimVert0],   // 1xxxxxx

 35692     [1, twoDimVert0], [1, twoDimVert0],

 35693     [1, twoDimVert0], [1, twoDimVert0],

 35694     [1, twoDimVert0], [1, twoDimVert0],

 35695     [1, twoDimVert0], [1, twoDimVert0],

 35696     [1, twoDimVert0], [1, twoDimVert0],

 35697     [1, twoDimVert0], [1, twoDimVert0],

 35698     [1, twoDimVert0], [1, twoDimVert0],

 35699     [1, twoDimVert0], [1, twoDimVert0],

 35700     [1, twoDimVert0], [1, twoDimVert0],

 35701     [1, twoDimVert0], [1, twoDimVert0],

 35702     [1, twoDimVert0], [1, twoDimVert0],

 35703     [1, twoDimVert0], [1, twoDimVert0],

 35704     [1, twoDimVert0], [1, twoDimVert0],

 35705     [1, twoDimVert0], [1, twoDimVert0],

 35706     [1, twoDimVert0], [1, twoDimVert0],

 35707     [1, twoDimVert0], [1, twoDimVert0],

 35708     [1, twoDimVert0], [1, twoDimVert0],

 35709     [1, twoDimVert0], [1, twoDimVert0],

 35710     [1, twoDimVert0], [1, twoDimVert0],

 35711     [1, twoDimVert0], [1, twoDimVert0],

 35712     [1, twoDimVert0], [1, twoDimVert0],

 35713     [1, twoDimVert0], [1, twoDimVert0],

 35714     [1, twoDimVert0], [1, twoDimVert0],

 35715     [1, twoDimVert0], [1, twoDimVert0],

 35716     [1, twoDimVert0], [1, twoDimVert0],

 35717     [1, twoDimVert0], [1, twoDimVert0],

 35718     [1, twoDimVert0], [1, twoDimVert0],

 35719     [1, twoDimVert0], [1, twoDimVert0],

 35720     [1, twoDimVert0], [1, twoDimVert0],

 35721     [1, twoDimVert0], [1, twoDimVert0],

 35722     [1, twoDimVert0], [1, twoDimVert0]

 35723   ];

 35725   var whiteTable1 = [

 35726     [-1, -1],                               // 00000

 35727     [12, ccittEOL],                         // 00001

 35728     [-1, -1], [-1, -1],                     // 0001x

 35729     [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 001xx

 35730     [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 010xx

 35731     [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 011xx

 35732     [11, 1792], [11, 1792],                 // 1000x

 35733     [12, 1984],                             // 10010

 35734     [12, 2048],                             // 10011

 35735     [12, 2112],                             // 10100

 35736     [12, 2176],                             // 10101

 35737     [12, 2240],                             // 10110

 35738     [12, 2304],                             // 10111

 35739     [11, 1856], [11, 1856],                 // 1100x

 35740     [11, 1920], [11, 1920],                 // 1101x

 35741     [12, 2368],                             // 11100

 35742     [12, 2432],                             // 11101

 35743     [12, 2496],                             // 11110

 35744     [12, 2560]                              // 11111

 35745   ];

 35747   var whiteTable2 = [

 35748     [-1, -1], [-1, -1], [-1, -1], [-1, -1],     // 0000000xx

 35749     [8, 29], [8, 29],                           // 00000010x

 35750     [8, 30], [8, 30],                           // 00000011x

 35751     [8, 45], [8, 45],                           // 00000100x

 35752     [8, 46], [8, 46],                           // 00000101x

 35753     [7, 22], [7, 22], [7, 22], [7, 22],         // 0000011xx

 35754     [7, 23], [7, 23], [7, 23], [7, 23],         // 0000100xx

 35755     [8, 47], [8, 47],                           // 00001010x

 35756     [8, 48], [8, 48],                           // 00001011x

 35757     [6, 13], [6, 13], [6, 13], [6, 13],         // 000011xxx

 35758     [6, 13], [6, 13], [6, 13], [6, 13],

 35759     [7, 20], [7, 20], [7, 20], [7, 20],         // 0001000xx

 35760     [8, 33], [8, 33],                           // 00010010x

 35761     [8, 34], [8, 34],                           // 00010011x

 35762     [8, 35], [8, 35],                           // 00010100x

 35763     [8, 36], [8, 36],                           // 00010101x

 35764     [8, 37], [8, 37],                           // 00010110x

 35765     [8, 38], [8, 38],                           // 00010111x

 35766     [7, 19], [7, 19], [7, 19], [7, 19],         // 0001100xx

 35767     [8, 31], [8, 31],                           // 00011010x

 35768     [8, 32], [8, 32],                           // 00011011x

 35769     [6, 1], [6, 1], [6, 1], [6, 1],             // 000111xxx

 35770     [6, 1], [6, 1], [6, 1], [6, 1],

 35771     [6, 12], [6, 12], [6, 12], [6, 12],         // 001000xxx

 35772     [6, 12], [6, 12], [6, 12], [6, 12],

 35773     [8, 53], [8, 53],                           // 00100100x

 35774     [8, 54], [8, 54],                           // 00100101x

 35775     [7, 26], [7, 26], [7, 26], [7, 26],         // 0010011xx

 35776     [8, 39], [8, 39],                           // 00101000x

 35777     [8, 40], [8, 40],                           // 00101001x

 35778     [8, 41], [8, 41],                           // 00101010x

 35779     [8, 42], [8, 42],                           // 00101011x

 35780     [8, 43], [8, 43],                           // 00101100x

 35781     [8, 44], [8, 44],                           // 00101101x

 35782     [7, 21], [7, 21], [7, 21], [7, 21],         // 0010111xx

 35783     [7, 28], [7, 28], [7, 28], [7, 28],         // 0011000xx

 35784     [8, 61], [8, 61],                           // 00110010x

 35785     [8, 62], [8, 62],                           // 00110011x

 35786     [8, 63], [8, 63],                           // 00110100x

 35787     [8, 0], [8, 0],                             // 00110101x

 35788     [8, 320], [8, 320],                         // 00110110x

 35789     [8, 384], [8, 384],                         // 00110111x

 35790     [5, 10], [5, 10], [5, 10], [5, 10],         // 00111xxxx

 35791     [5, 10], [5, 10], [5, 10], [5, 10],

 35792     [5, 10], [5, 10], [5, 10], [5, 10],

 35793     [5, 10], [5, 10], [5, 10], [5, 10],

 35794     [5, 11], [5, 11], [5, 11], [5, 11],         // 01000xxxx

 35795     [5, 11], [5, 11], [5, 11], [5, 11],

 35796     [5, 11], [5, 11], [5, 11], [5, 11],

 35797     [5, 11], [5, 11], [5, 11], [5, 11],

 35798     [7, 27], [7, 27], [7, 27], [7, 27],         // 0100100xx

 35799     [8, 59], [8, 59],                           // 01001010x

 35800     [8, 60], [8, 60],                           // 01001011x

 35801     [9, 1472],                                  // 010011000

 35802     [9, 1536],                                  // 010011001

 35803     [9, 1600],                                  // 010011010

 35804     [9, 1728],                                  // 010011011

 35805     [7, 18], [7, 18], [7, 18], [7, 18],         // 0100111xx

 35806     [7, 24], [7, 24], [7, 24], [7, 24],         // 0101000xx

 35807     [8, 49], [8, 49],                           // 01010010x

 35808     [8, 50], [8, 50],                           // 01010011x

 35809     [8, 51], [8, 51],                           // 01010100x

 35810     [8, 52], [8, 52],                           // 01010101x

 35811     [7, 25], [7, 25], [7, 25], [7, 25],         // 0101011xx

 35812     [8, 55], [8, 55],                           // 01011000x

 35813     [8, 56], [8, 56],                           // 01011001x

 35814     [8, 57], [8, 57],                           // 01011010x

 35815     [8, 58], [8, 58],                           // 01011011x

 35816     [6, 192], [6, 192], [6, 192], [6, 192],     // 010111xxx

 35817     [6, 192], [6, 192], [6, 192], [6, 192],

 35818     [6, 1664], [6, 1664], [6, 1664], [6, 1664], // 011000xxx

 35819     [6, 1664], [6, 1664], [6, 1664], [6, 1664],

 35820     [8, 448], [8, 448],                         // 01100100x

 35821     [8, 512], [8, 512],                         // 01100101x

 35822     [9, 704],                                   // 011001100

 35823     [9, 768],                                   // 011001101

 35824     [8, 640], [8, 640],                         // 01100111x

 35825     [8, 576], [8, 576],                         // 01101000x

 35826     [9, 832],                                   // 011010010

 35827     [9, 896],                                   // 011010011

 35828     [9, 960],                                   // 011010100

 35829     [9, 1024],                                  // 011010101

 35830     [9, 1088],                                  // 011010110

 35831     [9, 1152],                                  // 011010111

 35832     [9, 1216],                                  // 011011000

 35833     [9, 1280],                                  // 011011001

 35834     [9, 1344],                                  // 011011010

 35835     [9, 1408],                                  // 011011011

 35836     [7, 256], [7, 256], [7, 256], [7, 256],     // 0110111xx

 35837     [4, 2], [4, 2], [4, 2], [4, 2],             // 0111xxxxx

 35838     [4, 2], [4, 2], [4, 2], [4, 2],

 35839     [4, 2], [4, 2], [4, 2], [4, 2],

 35840     [4, 2], [4, 2], [4, 2], [4, 2],

 35841     [4, 2], [4, 2], [4, 2], [4, 2],

 35842     [4, 2], [4, 2], [4, 2], [4, 2],

 35843     [4, 2], [4, 2], [4, 2], [4, 2],

 35844     [4, 2], [4, 2], [4, 2], [4, 2],

 35845     [4, 3], [4, 3], [4, 3], [4, 3],             // 1000xxxxx

 35846     [4, 3], [4, 3], [4, 3], [4, 3],

 35847     [4, 3], [4, 3], [4, 3], [4, 3],

 35848     [4, 3], [4, 3], [4, 3], [4, 3],

 35849     [4, 3], [4, 3], [4, 3], [4, 3],

 35850     [4, 3], [4, 3], [4, 3], [4, 3],

 35851     [4, 3], [4, 3], [4, 3], [4, 3],

 35852     [4, 3], [4, 3], [4, 3], [4, 3],

 35853     [5, 128], [5, 128], [5, 128], [5, 128],     // 10010xxxx

 35854     [5, 128], [5, 128], [5, 128], [5, 128],

 35855     [5, 128], [5, 128], [5, 128], [5, 128],

 35856     [5, 128], [5, 128], [5, 128], [5, 128],

 35857     [5, 8], [5, 8], [5, 8], [5, 8],             // 10011xxxx

 35858     [5, 8], [5, 8], [5, 8], [5, 8],

 35859     [5, 8], [5, 8], [5, 8], [5, 8],

 35860     [5, 8], [5, 8], [5, 8], [5, 8],

 35861     [5, 9], [5, 9], [5, 9], [5, 9],             // 10100xxxx

 35862     [5, 9], [5, 9], [5, 9], [5, 9],

 35863     [5, 9], [5, 9], [5, 9], [5, 9],

 35864     [5, 9], [5, 9], [5, 9], [5, 9],

 35865     [6, 16], [6, 16], [6, 16], [6, 16],         // 101010xxx

 35866     [6, 16], [6, 16], [6, 16], [6, 16],

 35867     [6, 17], [6, 17], [6, 17], [6, 17],         // 101011xxx

 35868     [6, 17], [6, 17], [6, 17], [6, 17],

 35869     [4, 4], [4, 4], [4, 4], [4, 4],             // 1011xxxxx

 35870     [4, 4], [4, 4], [4, 4], [4, 4],

 35871     [4, 4], [4, 4], [4, 4], [4, 4],

 35872     [4, 4], [4, 4], [4, 4], [4, 4],

 35873     [4, 4], [4, 4], [4, 4], [4, 4],

 35874     [4, 4], [4, 4], [4, 4], [4, 4],

 35875     [4, 4], [4, 4], [4, 4], [4, 4],

 35876     [4, 4], [4, 4], [4, 4], [4, 4],

 35877     [4, 5], [4, 5], [4, 5], [4, 5],             // 1100xxxxx

 35878     [4, 5], [4, 5], [4, 5], [4, 5],

 35879     [4, 5], [4, 5], [4, 5], [4, 5],

 35880     [4, 5], [4, 5], [4, 5], [4, 5],

 35881     [4, 5], [4, 5], [4, 5], [4, 5],

 35882     [4, 5], [4, 5], [4, 5], [4, 5],

 35883     [4, 5], [4, 5], [4, 5], [4, 5],

 35884     [4, 5], [4, 5], [4, 5], [4, 5],

 35885     [6, 14], [6, 14], [6, 14], [6, 14],         // 110100xxx

 35886     [6, 14], [6, 14], [6, 14], [6, 14],

 35887     [6, 15], [6, 15], [6, 15], [6, 15],         // 110101xxx

 35888     [6, 15], [6, 15], [6, 15], [6, 15],

 35889     [5, 64], [5, 64], [5, 64], [5, 64],         // 11011xxxx

 35890     [5, 64], [5, 64], [5, 64], [5, 64],

 35891     [5, 64], [5, 64], [5, 64], [5, 64],

 35892     [5, 64], [5, 64], [5, 64], [5, 64],

 35893     [4, 6], [4, 6], [4, 6], [4, 6],             // 1110xxxxx

 35894     [4, 6], [4, 6], [4, 6], [4, 6],

 35895     [4, 6], [4, 6], [4, 6], [4, 6],

 35896     [4, 6], [4, 6], [4, 6], [4, 6],

 35897     [4, 6], [4, 6], [4, 6], [4, 6],

 35898     [4, 6], [4, 6], [4, 6], [4, 6],

 35899     [4, 6], [4, 6], [4, 6], [4, 6],

 35900     [4, 6], [4, 6], [4, 6], [4, 6],

 35901     [4, 7], [4, 7], [4, 7], [4, 7],             // 1111xxxxx

 35902     [4, 7], [4, 7], [4, 7], [4, 7],

 35903     [4, 7], [4, 7], [4, 7], [4, 7],

 35904     [4, 7], [4, 7], [4, 7], [4, 7],

 35905     [4, 7], [4, 7], [4, 7], [4, 7],

 35906     [4, 7], [4, 7], [4, 7], [4, 7],

 35907     [4, 7], [4, 7], [4, 7], [4, 7],

 35908     [4, 7], [4, 7], [4, 7], [4, 7]

 35909   ];

 35911   var blackTable1 = [

 35912     [-1, -1], [-1, -1],                             // 000000000000x

 35913     [12, ccittEOL], [12, ccittEOL],                 // 000000000001x

 35914     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000001xx

 35915     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000010xx

 35916     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000011xx

 35917     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000100xx

 35918     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000101xx

 35919     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000110xx

 35920     [-1, -1], [-1, -1], [-1, -1], [-1, -1],         // 00000000111xx

 35921     [11, 1792], [11, 1792], [11, 1792], [11, 1792], // 00000001000xx

 35922     [12, 1984], [12, 1984],                         // 000000010010x

 35923     [12, 2048], [12, 2048],                         // 000000010011x

 35924     [12, 2112], [12, 2112],                         // 000000010100x

 35925     [12, 2176], [12, 2176],                         // 000000010101x

 35926     [12, 2240], [12, 2240],                         // 000000010110x

 35927     [12, 2304], [12, 2304],                         // 000000010111x

 35928     [11, 1856], [11, 1856], [11, 1856], [11, 1856], // 00000001100xx

 35929     [11, 1920], [11, 1920], [11, 1920], [11, 1920], // 00000001101xx

 35930     [12, 2368], [12, 2368],                         // 000000011100x

 35931     [12, 2432], [12, 2432],                         // 000000011101x

 35932     [12, 2496], [12, 2496],                         // 000000011110x

 35933     [12, 2560], [12, 2560],                         // 000000011111x

 35934     [10, 18], [10, 18], [10, 18], [10, 18],         // 0000001000xxx

 35935     [10, 18], [10, 18], [10, 18], [10, 18],

 35936     [12, 52], [12, 52],                             // 000000100100x

 35937     [13, 640],                                      // 0000001001010

 35938     [13, 704],                                      // 0000001001011

 35939     [13, 768],                                      // 0000001001100

 35940     [13, 832],                                      // 0000001001101

 35941     [12, 55], [12, 55],                             // 000000100111x

 35942     [12, 56], [12, 56],                             // 000000101000x

 35943     [13, 1280],                                     // 0000001010010

 35944     [13, 1344],                                     // 0000001010011

 35945     [13, 1408],                                     // 0000001010100

 35946     [13, 1472],                                     // 0000001010101

 35947     [12, 59], [12, 59],                             // 000000101011x

 35948     [12, 60], [12, 60],                             // 000000101100x

 35949     [13, 1536],                                     // 0000001011010

 35950     [13, 1600],                                     // 0000001011011

 35951     [11, 24], [11, 24], [11, 24], [11, 24],         // 00000010111xx

 35952     [11, 25], [11, 25], [11, 25], [11, 25],         // 00000011000xx

 35953     [13, 1664],                                     // 0000001100100

 35954     [13, 1728],                                     // 0000001100101

 35955     [12, 320], [12, 320],                           // 000000110011x

 35956     [12, 384], [12, 384],                           // 000000110100x

 35957     [12, 448], [12, 448],                           // 000000110101x

 35958     [13, 512],                                      // 0000001101100

 35959     [13, 576],                                      // 0000001101101

 35960     [12, 53], [12, 53],                             // 000000110111x

 35961     [12, 54], [12, 54],                             // 000000111000x

 35962     [13, 896],                                      // 0000001110010

 35963     [13, 960],                                      // 0000001110011

 35964     [13, 1024],                                     // 0000001110100

 35965     [13, 1088],                                     // 0000001110101

 35966     [13, 1152],                                     // 0000001110110

 35967     [13, 1216],                                     // 0000001110111

 35968     [10, 64], [10, 64], [10, 64], [10, 64],         // 0000001111xxx

 35969     [10, 64], [10, 64], [10, 64], [10, 64]

 35970   ];

 35972   var blackTable2 = [

 35973     [8, 13], [8, 13], [8, 13], [8, 13],     // 00000100xxxx

 35974     [8, 13], [8, 13], [8, 13], [8, 13],

 35975     [8, 13], [8, 13], [8, 13], [8, 13],

 35976     [8, 13], [8, 13], [8, 13], [8, 13],

 35977     [11, 23], [11, 23],                     // 00000101000x

 35978     [12, 50],                               // 000001010010

 35979     [12, 51],                               // 000001010011

 35980     [12, 44],                               // 000001010100

 35981     [12, 45],                               // 000001010101

 35982     [12, 46],                               // 000001010110

 35983     [12, 47],                               // 000001010111

 35984     [12, 57],                               // 000001011000

 35985     [12, 58],                               // 000001011001

 35986     [12, 61],                               // 000001011010

 35987     [12, 256],                              // 000001011011

 35988     [10, 16], [10, 16], [10, 16], [10, 16], // 0000010111xx

 35989     [10, 17], [10, 17], [10, 17], [10, 17], // 0000011000xx

 35990     [12, 48],                               // 000001100100

 35991     [12, 49],                               // 000001100101

 35992     [12, 62],                               // 000001100110

 35993     [12, 63],                               // 000001100111

 35994     [12, 30],                               // 000001101000

 35995     [12, 31],                               // 000001101001

 35996     [12, 32],                               // 000001101010

 35997     [12, 33],                               // 000001101011

 35998     [12, 40],                               // 000001101100

 35999     [12, 41],                               // 000001101101

 36000     [11, 22], [11, 22],                     // 00000110111x

 36001     [8, 14], [8, 14], [8, 14], [8, 14],     // 00000111xxxx

 36002     [8, 14], [8, 14], [8, 14], [8, 14],

 36003     [8, 14], [8, 14], [8, 14], [8, 14],

 36004     [8, 14], [8, 14], [8, 14], [8, 14],

 36005     [7, 10], [7, 10], [7, 10], [7, 10],     // 0000100xxxxx

 36006     [7, 10], [7, 10], [7, 10], [7, 10],

 36007     [7, 10], [7, 10], [7, 10], [7, 10],

 36008     [7, 10], [7, 10], [7, 10], [7, 10],

 36009     [7, 10], [7, 10], [7, 10], [7, 10],

 36010     [7, 10], [7, 10], [7, 10], [7, 10],

 36011     [7, 10], [7, 10], [7, 10], [7, 10],

 36012     [7, 10], [7, 10], [7, 10], [7, 10],

 36013     [7, 11], [7, 11], [7, 11], [7, 11],     // 0000101xxxxx

 36014     [7, 11], [7, 11], [7, 11], [7, 11],

 36015     [7, 11], [7, 11], [7, 11], [7, 11],

 36016     [7, 11], [7, 11], [7, 11], [7, 11],

 36017     [7, 11], [7, 11], [7, 11], [7, 11],

 36018     [7, 11], [7, 11], [7, 11], [7, 11],

 36019     [7, 11], [7, 11], [7, 11], [7, 11],

 36020     [7, 11], [7, 11], [7, 11], [7, 11],

 36021     [9, 15], [9, 15], [9, 15], [9, 15],     // 000011000xxx

 36022     [9, 15], [9, 15], [9, 15], [9, 15],

 36023     [12, 128],                              // 000011001000

 36024     [12, 192],                              // 000011001001

 36025     [12, 26],                               // 000011001010

 36026     [12, 27],                               // 000011001011

 36027     [12, 28],                               // 000011001100

 36028     [12, 29],                               // 000011001101

 36029     [11, 19], [11, 19],                     // 00001100111x

 36030     [11, 20], [11, 20],                     // 00001101000x

 36031     [12, 34],                               // 000011010010

 36032     [12, 35],                               // 000011010011

 36033     [12, 36],                               // 000011010100

 36034     [12, 37],                               // 000011010101

 36035     [12, 38],                               // 000011010110

 36036     [12, 39],                               // 000011010111

 36037     [11, 21], [11, 21],                     // 00001101100x

 36038     [12, 42],                               // 000011011010

 36039     [12, 43],                               // 000011011011

 36040     [10, 0], [10, 0], [10, 0], [10, 0],     // 0000110111xx

 36041     [7, 12], [7, 12], [7, 12], [7, 12],     // 0000111xxxxx

 36042     [7, 12], [7, 12], [7, 12], [7, 12],

 36043     [7, 12], [7, 12], [7, 12], [7, 12],

 36044     [7, 12], [7, 12], [7, 12], [7, 12],

 36045     [7, 12], [7, 12], [7, 12], [7, 12],

 36046     [7, 12], [7, 12], [7, 12], [7, 12],

 36047     [7, 12], [7, 12], [7, 12], [7, 12],

 36048     [7, 12], [7, 12], [7, 12], [7, 12]

 36049   ];

 36051   var blackTable3 = [

 36052     [-1, -1], [-1, -1], [-1, -1], [-1, -1], // 0000xx

 36053     [6, 9],                                 // 000100

 36054     [6, 8],                                 // 000101

 36055     [5, 7], [5, 7],                         // 00011x

 36056     [4, 6], [4, 6], [4, 6], [4, 6],         // 0010xx

 36057     [4, 5], [4, 5], [4, 5], [4, 5],         // 0011xx

 36058     [3, 1], [3, 1], [3, 1], [3, 1],         // 010xxx

 36059     [3, 1], [3, 1], [3, 1], [3, 1],

 36060     [3, 4], [3, 4], [3, 4], [3, 4],         // 011xxx

 36061     [3, 4], [3, 4], [3, 4], [3, 4],

 36062     [2, 3], [2, 3], [2, 3], [2, 3],         // 10xxxx

 36063     [2, 3], [2, 3], [2, 3], [2, 3],

 36064     [2, 3], [2, 3], [2, 3], [2, 3],

 36065     [2, 3], [2, 3], [2, 3], [2, 3],

 36066     [2, 2], [2, 2], [2, 2], [2, 2],         // 11xxxx

 36067     [2, 2], [2, 2], [2, 2], [2, 2],

 36068     [2, 2], [2, 2], [2, 2], [2, 2],

 36069     [2, 2], [2, 2], [2, 2], [2, 2]

 36070   ];

 36072   function CCITTFaxStream(str, maybeLength, params) {

 36073     this.str = str;

 36074     this.dict = str.dict;

 36076     params = params || Dict.empty;

 36078     this.encoding = params.get('K') || 0;

 36079     this.eoline = params.get('EndOfLine') || false;

 36080     this.byteAlign = params.get('EncodedByteAlign') || false;

 36081     this.columns = params.get('Columns') || 1728;

 36082     this.rows = params.get('Rows') || 0;

 36083     var eoblock = params.get('EndOfBlock');

 36084     if (eoblock === null || eoblock === undefined) {

 36085       eoblock = true;

 36086     }

 36087     this.eoblock = eoblock;

 36088     this.black = params.get('BlackIs1') || false;

 36090     this.codingLine = new Uint32Array(this.columns + 1);

 36091     this.refLine = new Uint32Array(this.columns + 2);

 36093     this.codingLine[0] = this.columns;

 36094     this.codingPos = 0;

 36096     this.row = 0;

 36097     this.nextLine2D = this.encoding < 0;

 36098     this.inputBits = 0;

 36099     this.inputBuf = 0;

 36100     this.outputBits = 0;

 36102     var code1;

 36103     while ((code1 = this.lookBits(12)) === 0) {

 36104       this.eatBits(1);

 36105     }

 36106     if (code1 == 1) {

 36107       this.eatBits(12);

 36108     }

 36109     if (this.encoding > 0) {

 36110       this.nextLine2D = !this.lookBits(1);

 36111       this.eatBits(1);

 36112     }

 36114     DecodeStream.call(this, maybeLength);

 36115   }

 36117   CCITTFaxStream.prototype = Object.create(DecodeStream.prototype);

 36119   CCITTFaxStream.prototype.readBlock = function CCITTFaxStream_readBlock() {

 36120     while (!this.eof) {

 36121       var c = this.lookChar();

 36122       this.ensureBuffer(this.bufferLength + 1);

 36123       this.buffer[this.bufferLength++] = c;

 36124     }

 36125   };

 36127   CCITTFaxStream.prototype.addPixels =

 36128       function ccittFaxStreamAddPixels(a1, blackPixels) {

 36129     var codingLine = this.codingLine;

 36130     var codingPos = this.codingPos;

 36132     if (a1 > codingLine[codingPos]) {

 36133       if (a1 > this.columns) {

 36134         info('row is wrong length');

 36135         this.err = true;

 36136         a1 = this.columns;

 36137       }

 36138       if ((codingPos & 1) ^ blackPixels) {

 36139         ++codingPos;

 36140       }

 36142       codingLine[codingPos] = a1;

 36143     }

 36144     this.codingPos = codingPos;

 36145   };

 36147   CCITTFaxStream.prototype.addPixelsNeg =

 36148       function ccittFaxStreamAddPixelsNeg(a1, blackPixels) {

 36149     var codingLine = this.codingLine;

 36150     var codingPos = this.codingPos;

 36152     if (a1 > codingLine[codingPos]) {

 36153       if (a1 > this.columns) {

 36154         info('row is wrong length');

 36155         this.err = true;

 36156         a1 = this.columns;

 36157       }

 36158       if ((codingPos & 1) ^ blackPixels) {

 36159         ++codingPos;

 36160       }

 36162       codingLine[codingPos] = a1;

 36163     } else if (a1 < codingLine[codingPos]) {

 36164       if (a1 < 0) {

 36165         info('invalid code');

 36166         this.err = true;

 36167         a1 = 0;

 36168       }

 36169       while (codingPos > 0 && a1 < codingLine[codingPos - 1]) {

 36170         --codingPos;

 36171       }

 36172       codingLine[codingPos] = a1;

 36173     }

 36175     this.codingPos = codingPos;

 36176   };

 36178   CCITTFaxStream.prototype.lookChar = function CCITTFaxStream_lookChar() {

 36179     var refLine = this.refLine;

 36180     var codingLine = this.codingLine;

 36181     var columns = this.columns;

 36183     var refPos, blackPixels, bits, i;

 36185     if (this.outputBits === 0) {

 36186       if (this.eof) {

 36187         return null;

 36188       }

 36189       this.err = false;

 36191       var code1, code2, code3;

 36192       if (this.nextLine2D) {

 36193         for (i = 0; codingLine[i] < columns; ++i) {

 36194           refLine[i] = codingLine[i];

 36195         }

 36196         refLine[i++] = columns;

 36197         refLine[i] = columns;

 36198         codingLine[0] = 0;

 36199         this.codingPos = 0;

 36200         refPos = 0;

 36201         blackPixels = 0;

 36203         while (codingLine[this.codingPos] < columns) {

 36204           code1 = this.getTwoDimCode();

 36205           switch (code1) {

 36206             case twoDimPass:

 36207               this.addPixels(refLine[refPos + 1], blackPixels);

 36208               if (refLine[refPos + 1] < columns) {

 36209                 refPos += 2;

 36210               }

 36211               break;

 36212             case twoDimHoriz:

 36213               code1 = code2 = 0;

 36214               if (blackPixels) {

 36215                 do {

 36216                   code1 += (code3 = this.getBlackCode());

 36217                 } while (code3 >= 64);

 36218                 do {

 36219                   code2 += (code3 = this.getWhiteCode());

 36220                 } while (code3 >= 64);

 36221               } else {

 36222                 do {

 36223                   code1 += (code3 = this.getWhiteCode());

 36224                 } while (code3 >= 64);

 36225                 do {

 36226                   code2 += (code3 = this.getBlackCode());

 36227                 } while (code3 >= 64);

 36228               }

 36229               this.addPixels(codingLine[this.codingPos] +

 36230                              code1, blackPixels);

 36231               if (codingLine[this.codingPos] < columns) {

 36232                 this.addPixels(codingLine[this.codingPos] + code2,

 36233                                blackPixels ^ 1);

 36234               }

 36235               while (refLine[refPos] <= codingLine[this.codingPos] &&

 36236                      refLine[refPos] < columns) {

 36237                 refPos += 2;

 36238               }

 36239               break;

 36240             case twoDimVertR3:

 36241               this.addPixels(refLine[refPos] + 3, blackPixels);

 36242               blackPixels ^= 1;

 36243               if (codingLine[this.codingPos] < columns) {

 36244                 ++refPos;

 36245                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36246                        refLine[refPos] < columns) {

 36247                   refPos += 2;

 36248                 }

 36249               }

 36250               break;

 36251             case twoDimVertR2:

 36252               this.addPixels(refLine[refPos] + 2, blackPixels);

 36253               blackPixels ^= 1;

 36254               if (codingLine[this.codingPos] < columns) {

 36255                 ++refPos;

 36256                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36257                        refLine[refPos] < columns) {

 36258                   refPos += 2;

 36259                 }

 36260               }

 36261               break;

 36262             case twoDimVertR1:

 36263               this.addPixels(refLine[refPos] + 1, blackPixels);

 36264               blackPixels ^= 1;

 36265               if (codingLine[this.codingPos] < columns) {

 36266                 ++refPos;

 36267                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36268                        refLine[refPos] < columns) {

 36269                   refPos += 2;

 36270                 }

 36271               }

 36272               break;

 36273             case twoDimVert0:

 36274               this.addPixels(refLine[refPos], blackPixels);

 36275               blackPixels ^= 1;

 36276               if (codingLine[this.codingPos] < columns) {

 36277                 ++refPos;

 36278                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36279                        refLine[refPos] < columns) {

 36280                   refPos += 2;

 36281                 }

 36282               }

 36283               break;

 36284             case twoDimVertL3:

 36285               this.addPixelsNeg(refLine[refPos] - 3, blackPixels);

 36286               blackPixels ^= 1;

 36287               if (codingLine[this.codingPos] < columns) {

 36288                 if (refPos > 0) {

 36289                   --refPos;

 36290                 } else {

 36291                   ++refPos;

 36292                 }

 36293                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36294                        refLine[refPos] < columns) {

 36295                   refPos += 2;

 36296                 }

 36297               }

 36298               break;

 36299             case twoDimVertL2:

 36300               this.addPixelsNeg(refLine[refPos] - 2, blackPixels);

 36301               blackPixels ^= 1;

 36302               if (codingLine[this.codingPos] < columns) {

 36303                 if (refPos > 0) {

 36304                   --refPos;

 36305                 } else {

 36306                   ++refPos;

 36307                 }

 36308                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36309                        refLine[refPos] < columns) {

 36310                   refPos += 2;

 36311                 }

 36312               }

 36313               break;

 36314             case twoDimVertL1:

 36315               this.addPixelsNeg(refLine[refPos] - 1, blackPixels);

 36316               blackPixels ^= 1;

 36317               if (codingLine[this.codingPos] < columns) {

 36318                 if (refPos > 0) {

 36319                   --refPos;

 36320                 } else {

 36321                   ++refPos;

 36322                 }

 36323                 while (refLine[refPos] <= codingLine[this.codingPos] &&

 36324                        refLine[refPos] < columns) {

 36325                   refPos += 2;

 36326                 }

 36327               }

 36328               break;

 36329             case EOF:

 36330               this.addPixels(columns, 0);

 36331               this.eof = true;

 36332               break;

 36333             default:

 36334               info('bad 2d code');

 36335               this.addPixels(columns, 0);

 36336               this.err = true;

 36337           }

 36338         }

 36339       } else {

 36340         codingLine[0] = 0;

 36341         this.codingPos = 0;

 36342         blackPixels = 0;

 36343         while (codingLine[this.codingPos] < columns) {

 36344           code1 = 0;

 36345           if (blackPixels) {

 36346             do {

 36347               code1 += (code3 = this.getBlackCode());

 36348             } while (code3 >= 64);

 36349           } else {

 36350             do {

 36351               code1 += (code3 = this.getWhiteCode());

 36352             } while (code3 >= 64);

 36353           }

 36354           this.addPixels(codingLine[this.codingPos] + code1, blackPixels);

 36355           blackPixels ^= 1;

 36356         }

 36357       }

 36359       if (this.byteAlign) {

 36360         this.inputBits &= ~7;

 36361       }

 36363       var gotEOL = false;

 36365       if (!this.eoblock && this.row == this.rows - 1) {

 36366         this.eof = true;

 36367       } else {

 36368         code1 = this.lookBits(12);

 36369         while (code1 === 0) {

 36370           this.eatBits(1);

 36371           code1 = this.lookBits(12);

 36372         }

 36373         if (code1 == 1) {

 36374           this.eatBits(12);

 36375           gotEOL = true;

 36376         } else if (code1 == EOF) {

 36377           this.eof = true;

 36378         }

 36379       }

 36381       if (!this.eof && this.encoding > 0) {

 36382         this.nextLine2D = !this.lookBits(1);

 36383         this.eatBits(1);

 36384       }

 36386       if (this.eoblock && gotEOL) {

 36387         code1 = this.lookBits(12);

 36388         if (code1 == 1) {

 36389           this.eatBits(12);

 36390           if (this.encoding > 0) {

 36391             this.lookBits(1);

 36392             this.eatBits(1);

 36393           }

 36394           if (this.encoding >= 0) {

 36395             for (i = 0; i < 4; ++i) {

 36396               code1 = this.lookBits(12);

 36397               if (code1 != 1) {

 36398                 info('bad rtc code: ' + code1);

 36399               }

 36400               this.eatBits(12);

 36401               if (this.encoding > 0) {

 36402                 this.lookBits(1);

 36403                 this.eatBits(1);

 36404               }

 36405             }

 36406           }

 36407           this.eof = true;

 36408         }

 36409       } else if (this.err && this.eoline) {

 36410         while (true) {

 36411           code1 = this.lookBits(13);

 36412           if (code1 == EOF) {

 36413             this.eof = true;

 36414             return null;

 36415           }

 36416           if ((code1 >> 1) == 1) {

 36417             break;

 36418           }

 36419           this.eatBits(1);

 36420         }

 36421         this.eatBits(12);

 36422         if (this.encoding > 0) {

 36423           this.eatBits(1);

 36424           this.nextLine2D = !(code1 & 1);

 36425         }

 36426       }

 36428       if (codingLine[0] > 0) {

 36429         this.outputBits = codingLine[this.codingPos = 0];

 36430       } else {

 36431         this.outputBits = codingLine[this.codingPos = 1];

 36432       }

 36433       this.row++;

 36434     }

 36436     var c;

 36437     if (this.outputBits >= 8) {

 36438       c = (this.codingPos & 1) ? 0 : 0xFF;

 36439       this.outputBits -= 8;

 36440       if (this.outputBits === 0 && codingLine[this.codingPos] < columns) {

 36441         this.codingPos++;

 36442         this.outputBits = (codingLine[this.codingPos] -

 36443                            codingLine[this.codingPos - 1]);

 36444       }

 36445     } else {

 36446       bits = 8;

 36447       c = 0;

 36448       do {

 36449         if (this.outputBits > bits) {

 36450           c <<= bits;

 36451           if (!(this.codingPos & 1)) {

 36452             c |= 0xFF >> (8 - bits);

 36453           }

 36454           this.outputBits -= bits;

 36455           bits = 0;

 36456         } else {

 36457           c <<= this.outputBits;

 36458           if (!(this.codingPos & 1)) {

 36459             c |= 0xFF >> (8 - this.outputBits);

 36460           }

 36461           bits -= this.outputBits;

 36462           this.outputBits = 0;

 36463           if (codingLine[this.codingPos] < columns) {

 36464             this.codingPos++;

 36465             this.outputBits = (codingLine[this.codingPos] -

 36466                                codingLine[this.codingPos - 1]);

 36467           } else if (bits > 0) {

 36468             c <<= bits;

 36469             bits = 0;

 36470           }

 36471         }

 36472       } while (bits);

 36473     }

 36474     if (this.black) {

 36475       c ^= 0xFF;

 36476     }

 36477     return c;

 36478   };

 36480   // This functions returns the code found from the table.

 36481   // The start and end parameters set the boundaries for searching the table.

 36482   // The limit parameter is optional. Function returns an array with three

 36483   // values. The first array element indicates whether a valid code is being

 36484   // returned. The second array element is the actual code. The third array

 36485   // element indicates whether EOF was reached.

 36486   CCITTFaxStream.prototype.findTableCode =

 36487       function ccittFaxStreamFindTableCode(start, end, table, limit) {

 36489     var limitValue = limit || 0;

 36490     for (var i = start; i <= end; ++i) {

 36491       var code = this.lookBits(i);

 36492       if (code == EOF) {

 36493         return [true, 1, false];

 36494       }

 36495       if (i < end) {

 36496         code <<= end - i;

 36497       }

 36498       if (!limitValue || code >= limitValue) {

 36499         var p = table[code - limitValue];

 36500         if (p[0] == i) {

 36501           this.eatBits(i);

 36502           return [true, p[1], true];

 36503         }

 36504       }

 36505     }

 36506     return [false, 0, false];

 36507   };

 36509   CCITTFaxStream.prototype.getTwoDimCode =

 36510       function ccittFaxStreamGetTwoDimCode() {

 36512     var code = 0;

 36513     var p;

 36514     if (this.eoblock) {

 36515       code = this.lookBits(7);

 36516       p = twoDimTable[code];

 36517       if (p && p[0] > 0) {

 36518         this.eatBits(p[0]);

 36519         return p[1];

 36520       }

 36521     } else {

 36522       var result = this.findTableCode(1, 7, twoDimTable);

 36523       if (result[0] && result[2]) {

 36524         return result[1];

 36525       }

 36526     }

 36527     info('Bad two dim code');

 36528     return EOF;

 36529   };

 36531   CCITTFaxStream.prototype.getWhiteCode =

 36532       function ccittFaxStreamGetWhiteCode() {

 36534     var code = 0;

 36535     var p;

 36536     if (this.eoblock) {

 36537       code = this.lookBits(12);

 36538       if (code == EOF) {

 36539         return 1;

 36540       }

 36542       if ((code >> 5) === 0) {

 36543         p = whiteTable1[code];

 36544       } else {

 36545         p = whiteTable2[code >> 3];

 36546       }

 36548       if (p[0] > 0) {

 36549         this.eatBits(p[0]);

 36550         return p[1];

 36551       }

 36552     } else {

 36553       var result = this.findTableCode(1, 9, whiteTable2);

 36554       if (result[0]) {

 36555         return result[1];

 36556       }

 36558       result = this.findTableCode(11, 12, whiteTable1);

 36559       if (result[0]) {

 36560         return result[1];

 36561       }

 36562     }

 36563     info('bad white code');

 36564     this.eatBits(1);

 36565     return 1;

 36566   };

 36568   CCITTFaxStream.prototype.getBlackCode =

 36569       function ccittFaxStreamGetBlackCode() {

 36571     var code, p;

 36572     if (this.eoblock) {

 36573       code = this.lookBits(13);

 36574       if (code == EOF) {

 36575         return 1;

 36576       }

 36577       if ((code >> 7) === 0) {

 36578         p = blackTable1[code];

 36579       } else if ((code >> 9) === 0 && (code >> 7) !== 0) {

 36580         p = blackTable2[(code >> 1) - 64];

 36581       } else {

 36582         p = blackTable3[code >> 7];

 36583       }

 36585       if (p[0] > 0) {

 36586         this.eatBits(p[0]);

 36587         return p[1];

 36588       }

 36589     } else {

 36590       var result = this.findTableCode(2, 6, blackTable3);

 36591       if (result[0]) {

 36592         return result[1];

 36593       }

 36595       result = this.findTableCode(7, 12, blackTable2, 64);

 36596       if (result[0]) {

 36597         return result[1];

 36598       }

 36600       result = this.findTableCode(10, 13, blackTable1);

 36601       if (result[0]) {

 36602         return result[1];

 36603       }

 36604     }

 36605     info('bad black code');

 36606     this.eatBits(1);

 36607     return 1;

 36608   };

 36610   CCITTFaxStream.prototype.lookBits = function CCITTFaxStream_lookBits(n) {

 36611     var c;

 36612     while (this.inputBits < n) {

 36613       if ((c = this.str.getByte()) === -1) {

 36614         if (this.inputBits === 0) {

 36615           return EOF;

 36616         }

 36617         return ((this.inputBuf << (n - this.inputBits)) &

 36618                 (0xFFFF >> (16 - n)));

 36619       }

 36620       this.inputBuf = (this.inputBuf << 8) + c;

 36621       this.inputBits += 8;

 36622     }

 36623     return (this.inputBuf >> (this.inputBits - n)) & (0xFFFF >> (16 - n));

 36624   };

 36626   CCITTFaxStream.prototype.eatBits = function CCITTFaxStream_eatBits(n) {

 36627     if ((this.inputBits -= n) < 0) {

 36628       this.inputBits = 0;

 36629     }

 36630   };

 36632   return CCITTFaxStream;

 36633 })();

 36635 var LZWStream = (function LZWStreamClosure() {

 36636   function LZWStream(str, maybeLength, earlyChange) {

 36637     this.str = str;

 36638     this.dict = str.dict;

 36639     this.cachedData = 0;

 36640     this.bitsCached = 0;

 36642     var maxLzwDictionarySize = 4096;

 36643     var lzwState = {

 36644       earlyChange: earlyChange,

 36645       codeLength: 9,

 36646       nextCode: 258,

 36647       dictionaryValues: new Uint8Array(maxLzwDictionarySize),

 36648       dictionaryLengths: new Uint16Array(maxLzwDictionarySize),

 36649       dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),

 36650       currentSequence: new Uint8Array(maxLzwDictionarySize),

 36651       currentSequenceLength: 0

 36652     };

 36653     for (var i = 0; i < 256; ++i) {

 36654       lzwState.dictionaryValues[i] = i;

 36655       lzwState.dictionaryLengths[i] = 1;

 36656     }

 36657     this.lzwState = lzwState;

 36659     DecodeStream.call(this, maybeLength);

 36660   }

 36662   LZWStream.prototype = Object.create(DecodeStream.prototype);

 36664   LZWStream.prototype.readBits = function LZWStream_readBits(n) {

 36665     var bitsCached = this.bitsCached;

 36666     var cachedData = this.cachedData;

 36667     while (bitsCached < n) {

 36668       var c = this.str.getByte();

 36669       if (c === -1) {

 36670         this.eof = true;

 36671         return null;

 36672       }

 36673       cachedData = (cachedData << 8) | c;

 36674       bitsCached += 8;

 36675     }

 36676     this.bitsCached = (bitsCached -= n);

 36677     this.cachedData = cachedData;

 36678     this.lastCode = null;

 36679     return (cachedData >>> bitsCached) & ((1 << n) - 1);

 36680   };

 36682   LZWStream.prototype.readBlock = function LZWStream_readBlock() {

 36683     var blockSize = 512;

 36684     var estimatedDecodedSize = blockSize * 2, decodedSizeDelta = blockSize;

 36685     var i, j, q;

 36687     var lzwState = this.lzwState;

 36688     if (!lzwState) {

 36689       return; // eof was found

 36690     }

 36692     var earlyChange = lzwState.earlyChange;

 36693     var nextCode = lzwState.nextCode;

 36694     var dictionaryValues = lzwState.dictionaryValues;

 36695     var dictionaryLengths = lzwState.dictionaryLengths;

 36696     var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;

 36697     var codeLength = lzwState.codeLength;

 36698     var prevCode = lzwState.prevCode;

 36699     var currentSequence = lzwState.currentSequence;

 36700     var currentSequenceLength = lzwState.currentSequenceLength;

 36702     var decodedLength = 0;

 36703     var currentBufferLength = this.bufferLength;

 36704     var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);

 36706     for (i = 0; i < blockSize; i++) {

 36707       var code = this.readBits(codeLength);

 36708       var hasPrev = currentSequenceLength > 0;

 36709       if (code < 256) {

 36710         currentSequence[0] = code;

 36711         currentSequenceLength = 1;

 36712       } else if (code >= 258) {

 36713         if (code < nextCode) {

 36714           currentSequenceLength = dictionaryLengths[code];

 36715           for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {

 36716             currentSequence[j] = dictionaryValues[q];

 36717             q = dictionaryPrevCodes[q];

 36718           }

 36719         } else {

 36720           currentSequence[currentSequenceLength++] = currentSequence[0];

 36721         }

 36722       } else if (code == 256) {

 36723         codeLength = 9;

 36724         nextCode = 258;

 36725         currentSequenceLength = 0;

 36726         continue;

 36727       } else {

 36728         this.eof = true;

 36729         delete this.lzwState;

 36730         break;

 36731       }

 36733       if (hasPrev) {

 36734         dictionaryPrevCodes[nextCode] = prevCode;

 36735         dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;

 36736         dictionaryValues[nextCode] = currentSequence[0];

 36737         nextCode++;

 36738         codeLength = (nextCode + earlyChange) & (nextCode + earlyChange - 1) ?

 36739           codeLength : Math.min(Math.log(nextCode + earlyChange) /

 36740           0.6931471805599453 + 1, 12) | 0;

 36741       }

 36742       prevCode = code;

 36744       decodedLength += currentSequenceLength;

 36745       if (estimatedDecodedSize < decodedLength) {

 36746         do {

 36747           estimatedDecodedSize += decodedSizeDelta;

 36748         } while (estimatedDecodedSize < decodedLength);

 36749         buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);

 36750       }

 36751       for (j = 0; j < currentSequenceLength; j++) {

 36752         buffer[currentBufferLength++] = currentSequence[j];

 36753       }

 36754     }

 36755     lzwState.nextCode = nextCode;

 36756     lzwState.codeLength = codeLength;

 36757     lzwState.prevCode = prevCode;

 36758     lzwState.currentSequenceLength = currentSequenceLength;

 36760     this.bufferLength = currentBufferLength;

 36761   };

 36763   return LZWStream;

 36764 })();

 36766 var NullStream = (function NullStreamClosure() {

 36767   function NullStream() {

 36768     Stream.call(this, new Uint8Array(0));

 36769   }

 36771   NullStream.prototype = Stream.prototype;

 36773   return NullStream;

 36774 })();

 36777 var WorkerMessageHandler = PDFJS.WorkerMessageHandler = {

 36778   setup: function wphSetup(handler) {

 36779     var pdfManager;

 36781     function loadDocument(recoveryMode) {

 36782       var loadDocumentPromise = new LegacyPromise();

 36784       var parseSuccess = function parseSuccess() {

 36785         var numPagesPromise = pdfManager.ensureDoc('numPages');

 36786         var fingerprintPromise = pdfManager.ensureDoc('fingerprint');

 36787         var outlinePromise = pdfManager.ensureCatalog('documentOutline');

 36788         var infoPromise = pdfManager.ensureDoc('documentInfo');

 36789         var metadataPromise = pdfManager.ensureCatalog('metadata');

 36790         var encryptedPromise = pdfManager.ensureXRef('encrypt');

 36791         var javaScriptPromise = pdfManager.ensureCatalog('javaScript');

 36792         Promise.all([numPagesPromise, fingerprintPromise, outlinePromise,

 36793                      infoPromise, metadataPromise, encryptedPromise,

 36794                      javaScriptPromise]).then(function onDocReady(results) {

 36796           var doc = {

 36797             numPages: results[0],

 36798             fingerprint: results[1],

 36799             outline: results[2],

 36800             info: results[3],

 36801             metadata: results[4],

 36802             encrypted: !!results[5],

 36803             javaScript: results[6]

 36804           };

 36805           loadDocumentPromise.resolve(doc);

 36806         },

 36807         parseFailure);

 36808       };

 36810       var parseFailure = function parseFailure(e) {

 36811         loadDocumentPromise.reject(e);

 36812       };

 36814       pdfManager.ensureDoc('checkHeader', []).then(function() {

 36815         pdfManager.ensureDoc('parseStartXRef', []).then(function() {

 36816           pdfManager.ensureDoc('parse', [recoveryMode]).then(

 36817             parseSuccess, parseFailure);

 36818         }, parseFailure);

 36819       }, parseFailure);

 36821       return loadDocumentPromise;

 36822     }

 36824     function getPdfManager(data) {

 36825       var pdfManagerPromise = new LegacyPromise();

 36827       var source = data.source;

 36828       var disableRange = data.disableRange;

 36829       if (source.data) {

 36830         try {

 36831           pdfManager = new LocalPdfManager(source.data, source.password);

 36832           pdfManagerPromise.resolve();

 36833         } catch (ex) {

 36834           pdfManagerPromise.reject(ex);

 36835         }

 36836         return pdfManagerPromise;

 36837       } else if (source.chunkedViewerLoading) {

 36838         try {

 36839           pdfManager = new NetworkPdfManager(source, handler);

 36840           pdfManagerPromise.resolve();

 36841         } catch (ex) {

 36842           pdfManagerPromise.reject(ex);

 36843         }

 36844         return pdfManagerPromise;

 36845       }

 36847       var networkManager = new NetworkManager(source.url, {

 36848         httpHeaders: source.httpHeaders,

 36849         withCredentials: source.withCredentials

 36850       });

 36851       var fullRequestXhrId = networkManager.requestFull({

 36852         onHeadersReceived: function onHeadersReceived() {

 36853           if (disableRange) {

 36854             return;

 36855           }

 36857           var fullRequestXhr = networkManager.getRequestXhr(fullRequestXhrId);

 36858           if (fullRequestXhr.getResponseHeader('Accept-Ranges') !== 'bytes') {

 36859             return;

 36860           }

 36862           var contentEncoding =

 36863             fullRequestXhr.getResponseHeader('Content-Encoding') || 'identity';

 36864           if (contentEncoding !== 'identity') {

 36865             return;

 36866           }

 36868           var length = fullRequestXhr.getResponseHeader('Content-Length');

 36869           length = parseInt(length, 10);

 36870           if (!isInt(length)) {

 36871             return;

 36872           }

 36873           source.length = length;

 36874           if (length <= 2 * RANGE_CHUNK_SIZE) {

 36875             // The file size is smaller than the size of two chunks, so it does

 36876             // not make any sense to abort the request and retry with a range

 36877             // request.

 36878             return;

 36879           }

 36881           // NOTE: by cancelling the full request, and then issuing range

 36882           // requests, there will be an issue for sites where you can only

 36883           // request the pdf once. However, if this is the case, then the

 36884           // server should not be returning that it can support range requests.

 36885           networkManager.abortRequest(fullRequestXhrId);

 36887           try {

 36888             pdfManager = new NetworkPdfManager(source, handler);

 36889             pdfManagerPromise.resolve(pdfManager);

 36890           } catch (ex) {

 36891             pdfManagerPromise.reject(ex);

 36892           }

 36893         },

 36895         onDone: function onDone(args) {

 36896           // the data is array, instantiating directly from it

 36897           try {

 36898             pdfManager = new LocalPdfManager(args.chunk, source.password);

 36899             pdfManagerPromise.resolve();

 36900           } catch (ex) {

 36901             pdfManagerPromise.reject(ex);

 36902           }

 36903         },

 36905         onError: function onError(status) {

 36906           if (status == 404) {

 36907             var exception = new MissingPDFException('Missing PDF "' +

 36908                                                     source.url + '".');

 36909             handler.send('MissingPDF', { exception: exception });

 36910           } else {

 36911             handler.send('DocError', 'Unexpected server response (' +

 36912                          status + ') while retrieving PDF "' +

 36913                          source.url + '".');

 36914           }

 36915         },

 36917         onProgress: function onProgress(evt) {

 36918           handler.send('DocProgress', {

 36919             loaded: evt.loaded,

 36920             total: evt.lengthComputable ? evt.total : source.length

 36921           });

 36922         }

 36923       });

 36925       return pdfManagerPromise;

 36926     }

 36928     handler.on('test', function wphSetupTest(data) {

 36929       // check if Uint8Array can be sent to worker

 36930       if (!(data instanceof Uint8Array)) {

 36931         handler.send('test', false);

 36932         return;

 36933       }

 36934       // making sure postMessage transfers are working

 36935       var supportTransfers = data[0] === 255;

 36936       handler.postMessageTransfers = supportTransfers;

 36937       // check if the response property is supported by xhr

 36938       var xhr = new XMLHttpRequest();

 36939       var responseExists = 'response' in xhr;

 36940       // check if the property is actually implemented

 36941       try {

 36942         var dummy = xhr.responseType;

 36943       } catch (e) {

 36944         responseExists = false;

 36945       }

 36946       if (!responseExists) {

 36947         handler.send('test', false);

 36948         return;

 36949       }

 36950       handler.send('test', {

 36951         supportTypedArray: true,

 36952         supportTransfers: supportTransfers

 36953       });

 36954     });

 36956     handler.on('GetDocRequest', function wphSetupDoc(data) {

 36958       var onSuccess = function(doc) {

 36959         handler.send('GetDoc', { pdfInfo: doc });

 36960       };

 36962       var onFailure = function(e) {

 36963         if (e instanceof PasswordException) {

 36964           if (e.code === PasswordResponses.NEED_PASSWORD) {

 36965             handler.send('NeedPassword', {

 36966               exception: e

 36967             });

 36968           } else if (e.code === PasswordResponses.INCORRECT_PASSWORD) {

 36969             handler.send('IncorrectPassword', {

 36970               exception: e

 36971             });

 36972           }

 36973         } else if (e instanceof InvalidPDFException) {

 36974           handler.send('InvalidPDF', {

 36975             exception: e

 36976           });

 36977         } else if (e instanceof MissingPDFException) {

 36978           handler.send('MissingPDF', {

 36979             exception: e

 36980           });

 36981         } else {

 36982           handler.send('UnknownError', {

 36983             exception: new UnknownErrorException(e.message, e.toString())

 36984           });

 36985         }

 36986       };

 36988       PDFJS.maxImageSize = data.maxImageSize === undefined ?

 36989                            -1 : data.maxImageSize;

 36990       PDFJS.disableFontFace = data.disableFontFace;

 36991       PDFJS.disableCreateObjectURL = data.disableCreateObjectURL;

 36992       PDFJS.verbosity = data.verbosity;

 36993       PDFJS.cMapUrl = data.cMapUrl === undefined ?

 36994                            null : data.cMapUrl;

 36995       PDFJS.cMapPacked = data.cMapPacked === true;

 36997       getPdfManager(data).then(function () {

 36998         pdfManager.onLoadedStream().then(function(stream) {

 36999           handler.send('DataLoaded', { length: stream.bytes.byteLength });

 37000         });

 37001       }).then(function pdfManagerReady() {

 37002         loadDocument(false).then(onSuccess, function loadFailure(ex) {

 37003           // Try again with recoveryMode == true

 37004           if (!(ex instanceof XRefParseException)) {

 37005             if (ex instanceof PasswordException) {

 37006               // after password exception prepare to receive a new password

 37007               // to repeat loading

 37008               pdfManager.passwordChangedPromise = new LegacyPromise();

 37009               pdfManager.passwordChangedPromise.then(pdfManagerReady);

 37010             }

 37012             onFailure(ex);

 37013             return;

 37014           }

 37016           pdfManager.requestLoadedStream();

 37017           pdfManager.onLoadedStream().then(function() {

 37018             loadDocument(true).then(onSuccess, onFailure);

 37019           });

 37020         }, onFailure);

 37021       }, onFailure);

 37022     });

 37024     handler.on('GetPageRequest', function wphSetupGetPage(data) {

 37025       var pageIndex = data.pageIndex;

 37026       pdfManager.getPage(pageIndex).then(function(page) {

 37027         var rotatePromise = pdfManager.ensure(page, 'rotate');

 37028         var refPromise = pdfManager.ensure(page, 'ref');

 37029         var viewPromise = pdfManager.ensure(page, 'view');

 37031         Promise.all([rotatePromise, refPromise, viewPromise]).then(

 37032             function(results) {

 37033           var page = {

 37034             pageIndex: data.pageIndex,

 37035             rotate: results[0],

 37036             ref: results[1],

 37037             view: results[2]

 37038           };

 37040           handler.send('GetPage', { pageInfo: page });

 37041         });

 37042       });

 37043     });

 37045     handler.on('GetPageIndex', function wphSetupGetPageIndex(data, deferred) {

 37046       var ref = new Ref(data.ref.num, data.ref.gen);

 37047       var catalog = pdfManager.pdfDocument.catalog;

 37048       catalog.getPageIndex(ref).then(function (pageIndex) {

 37049         deferred.resolve(pageIndex);

 37050       }, deferred.reject);

 37051     });

 37053     handler.on('GetDestinations',

 37054       function wphSetupGetDestinations(data, deferred) {

 37055         pdfManager.ensureCatalog('destinations').then(function(destinations) {

 37056           deferred.resolve(destinations);

 37057         });

 37058       }

 37059     );

 37061     handler.on('GetAttachments',

 37062       function wphSetupGetAttachments(data, deferred) {

 37063         pdfManager.ensureCatalog('attachments').then(function(attachments) {

 37064           deferred.resolve(attachments);

 37065         }, deferred.reject);

 37066       }

 37067     );

 37069     handler.on('GetData', function wphSetupGetData(data, deferred) {

 37070       pdfManager.requestLoadedStream();

 37071       pdfManager.onLoadedStream().then(function(stream) {

 37072         deferred.resolve(stream.bytes);

 37073       });

 37074     });

 37076     handler.on('UpdatePassword', function wphSetupUpdatePassword(data) {

 37077       pdfManager.updatePassword(data);

 37078     });

 37080     handler.on('GetAnnotationsRequest', function wphSetupGetAnnotations(data) {

 37081       pdfManager.getPage(data.pageIndex).then(function(page) {

 37082         pdfManager.ensure(page, 'getAnnotationsData', []).then(

 37083           function(annotationsData) {

 37084             handler.send('GetAnnotations', {

 37085               pageIndex: data.pageIndex,

 37086               annotations: annotationsData

 37087             });

 37088           }

 37089         );

 37090       });

 37091     });

 37093     handler.on('RenderPageRequest', function wphSetupRenderPage(data) {

 37094       pdfManager.getPage(data.pageIndex).then(function(page) {

 37096         var pageNum = data.pageIndex + 1;

 37097         var start = Date.now();

 37098         // Pre compile the pdf page and fetch the fonts/images.

 37099         page.getOperatorList(handler, data.intent).then(function(operatorList) {

 37101           info('page=' + pageNum + ' - getOperatorList: time=' +

 37102                (Date.now() - start) + 'ms, len=' + operatorList.fnArray.length);

 37104         }, function(e) {

 37106           var minimumStackMessage =

 37107             'worker.js: while trying to getPage() and getOperatorList()';

 37109           var wrappedException;

 37111           // Turn the error into an obj that can be serialized

 37112           if (typeof e === 'string') {

 37113             wrappedException = {

 37114               message: e,

 37115               stack: minimumStackMessage

 37116             };

 37117           } else if (typeof e === 'object') {

 37118             wrappedException = {

 37119               message: e.message || e.toString(),

 37120               stack: e.stack || minimumStackMessage

 37121             };

 37122           } else {

 37123             wrappedException = {

 37124               message: 'Unknown exception type: ' + (typeof e),

 37125               stack: minimumStackMessage

 37126             };

 37127           }

 37129           handler.send('PageError', {

 37130             pageNum: pageNum,

 37131             error: wrappedException,

 37132             intent: data.intent

 37133           });

 37134         });

 37135       });

 37136     }, this);

 37138     handler.on('GetTextContent', function wphExtractText(data, deferred) {

 37139       pdfManager.getPage(data.pageIndex).then(function(page) {

 37140         var pageNum = data.pageIndex + 1;

 37141         var start = Date.now();

 37142         page.extractTextContent().then(function(textContent) {

 37143           deferred.resolve(textContent);

 37144           info('text indexing: page=' + pageNum + ' - time=' +

 37145                (Date.now() - start) + 'ms');

 37146         }, function (e) {

 37147           // Skip errored pages

 37148           deferred.reject(e);

 37149         });

 37150       });

 37151     });

 37153     handler.on('Cleanup', function wphCleanup(data, deferred) {

 37154       pdfManager.cleanup();

 37155       deferred.resolve(true);

 37156     });

 37158     handler.on('Terminate', function wphTerminate(data, deferred) {

 37159       pdfManager.terminate();

 37160       deferred.resolve();

 37161     });

 37162   }

 37163 };

 37165 var consoleTimer = {};

 37167 var workerConsole = {

 37168   log: function log() {

 37169     var args = Array.prototype.slice.call(arguments);

 37170     globalScope.postMessage({

 37171       action: 'console_log',

 37172       data: args

 37173     });

 37174   },

 37176   error: function error() {

 37177     var args = Array.prototype.slice.call(arguments);

 37178     globalScope.postMessage({

 37179       action: 'console_error',

 37180       data: args

 37181     });

 37182     throw 'pdf.js execution error';

 37183   },

 37185   time: function time(name) {

 37186     consoleTimer[name] = Date.now();

 37187   },

 37189   timeEnd: function timeEnd(name) {

 37190     var time = consoleTimer[name];

 37191     if (!time) {

 37192       error('Unknown timer name ' + name);

 37193     }

 37194     this.log('Timer:', name, Date.now() - time);

 37195   }

 37196 };

 37199 // Worker thread?

 37200 if (typeof window === 'undefined') {

 37201   if (!('console' in globalScope)) {

 37202     globalScope.console = workerConsole;

 37203   }

 37205   // Listen for unsupported features so we can pass them on to the main thread.

 37206   PDFJS.UnsupportedManager.listen(function (msg) {

 37207     globalScope.postMessage({

 37208       action: '_unsupported_feature',

 37209       data: msg

 37210     });

 37211   });

 37213   var handler = new MessageHandler('worker_processor', this);

 37214   WorkerMessageHandler.setup(handler);

 37215 }

 37218 /* This class implements the QM Coder decoding as defined in

 37219  *   JPEG 2000 Part I Final Committee Draft Version 1.0

 37220  *   Annex C.3 Arithmetic decoding procedure

 37221  * available at http://www.jpeg.org/public/fcd15444-1.pdf

 37222  *

 37223  * The arithmetic decoder is used in conjunction with context models to decode

 37224  * JPEG2000 and JBIG2 streams.

 37225  */

 37226 var ArithmeticDecoder = (function ArithmeticDecoderClosure() {

 37227   // Table C-2

 37228   var QeTable = [

 37229     {qe: 0x5601, nmps: 1, nlps: 1, switchFlag: 1},

 37230     {qe: 0x3401, nmps: 2, nlps: 6, switchFlag: 0},

 37231     {qe: 0x1801, nmps: 3, nlps: 9, switchFlag: 0},

 37232     {qe: 0x0AC1, nmps: 4, nlps: 12, switchFlag: 0},

 37233     {qe: 0x0521, nmps: 5, nlps: 29, switchFlag: 0},

 37234     {qe: 0x0221, nmps: 38, nlps: 33, switchFlag: 0},

 37235     {qe: 0x5601, nmps: 7, nlps: 6, switchFlag: 1},

 37236     {qe: 0x5401, nmps: 8, nlps: 14, switchFlag: 0},

 37237     {qe: 0x4801, nmps: 9, nlps: 14, switchFlag: 0},

 37238     {qe: 0x3801, nmps: 10, nlps: 14, switchFlag: 0},

 37239     {qe: 0x3001, nmps: 11, nlps: 17, switchFlag: 0},

 37240     {qe: 0x2401, nmps: 12, nlps: 18, switchFlag: 0},

 37241     {qe: 0x1C01, nmps: 13, nlps: 20, switchFlag: 0},

 37242     {qe: 0x1601, nmps: 29, nlps: 21, switchFlag: 0},

 37243     {qe: 0x5601, nmps: 15, nlps: 14, switchFlag: 1},

 37244     {qe: 0x5401, nmps: 16, nlps: 14, switchFlag: 0},

 37245     {qe: 0x5101, nmps: 17, nlps: 15, switchFlag: 0},

 37246     {qe: 0x4801, nmps: 18, nlps: 16, switchFlag: 0},

 37247     {qe: 0x3801, nmps: 19, nlps: 17, switchFlag: 0},

 37248     {qe: 0x3401, nmps: 20, nlps: 18, switchFlag: 0},

 37249     {qe: 0x3001, nmps: 21, nlps: 19, switchFlag: 0},

 37250     {qe: 0x2801, nmps: 22, nlps: 19, switchFlag: 0},

 37251     {qe: 0x2401, nmps: 23, nlps: 20, switchFlag: 0},

 37252     {qe: 0x2201, nmps: 24, nlps: 21, switchFlag: 0},

 37253     {qe: 0x1C01, nmps: 25, nlps: 22, switchFlag: 0},

 37254     {qe: 0x1801, nmps: 26, nlps: 23, switchFlag: 0},

 37255     {qe: 0x1601, nmps: 27, nlps: 24, switchFlag: 0},

 37256     {qe: 0x1401, nmps: 28, nlps: 25, switchFlag: 0},

 37257     {qe: 0x1201, nmps: 29, nlps: 26, switchFlag: 0},

 37258     {qe: 0x1101, nmps: 30, nlps: 27, switchFlag: 0},

 37259     {qe: 0x0AC1, nmps: 31, nlps: 28, switchFlag: 0},

 37260     {qe: 0x09C1, nmps: 32, nlps: 29, switchFlag: 0},

 37261     {qe: 0x08A1, nmps: 33, nlps: 30, switchFlag: 0},

 37262     {qe: 0x0521, nmps: 34, nlps: 31, switchFlag: 0},

 37263     {qe: 0x0441, nmps: 35, nlps: 32, switchFlag: 0},

 37264     {qe: 0x02A1, nmps: 36, nlps: 33, switchFlag: 0},

 37265     {qe: 0x0221, nmps: 37, nlps: 34, switchFlag: 0},

 37266     {qe: 0x0141, nmps: 38, nlps: 35, switchFlag: 0},

 37267     {qe: 0x0111, nmps: 39, nlps: 36, switchFlag: 0},

 37268     {qe: 0x0085, nmps: 40, nlps: 37, switchFlag: 0},

 37269     {qe: 0x0049, nmps: 41, nlps: 38, switchFlag: 0},

 37270     {qe: 0x0025, nmps: 42, nlps: 39, switchFlag: 0},

 37271     {qe: 0x0015, nmps: 43, nlps: 40, switchFlag: 0},

 37272     {qe: 0x0009, nmps: 44, nlps: 41, switchFlag: 0},

 37273     {qe: 0x0005, nmps: 45, nlps: 42, switchFlag: 0},

 37274     {qe: 0x0001, nmps: 45, nlps: 43, switchFlag: 0},

 37275     {qe: 0x5601, nmps: 46, nlps: 46, switchFlag: 0}

 37276   ];

 37278   // C.3.5 Initialisation of the decoder (INITDEC)

 37279   function ArithmeticDecoder(data, start, end) {

 37280     this.data = data;

 37281     this.bp = start;

 37282     this.dataEnd = end;

 37284     this.chigh = data[start];

 37285     this.clow = 0;

 37287     this.byteIn();

 37289     this.chigh = ((this.chigh << 7) & 0xFFFF) | ((this.clow >> 9) & 0x7F);

 37290     this.clow = (this.clow << 7) & 0xFFFF;

 37291     this.ct -= 7;

 37292     this.a = 0x8000;

 37293   }

 37295   ArithmeticDecoder.prototype = {

 37296     // C.3.4 Compressed data input (BYTEIN)

 37297     byteIn: function ArithmeticDecoder_byteIn() {

 37298       var data = this.data;

 37299       var bp = this.bp;

 37300       if (data[bp] == 0xFF) {

 37301         var b1 = data[bp + 1];

 37302         if (b1 > 0x8F) {

 37303           this.clow += 0xFF00;

 37304           this.ct = 8;

 37305         } else {

 37306           bp++;

 37307           this.clow += (data[bp] << 9);

 37308           this.ct = 7;

 37309           this.bp = bp;

 37310         }

 37311       } else {

 37312         bp++;

 37313         this.clow += bp < this.dataEnd ? (data[bp] << 8) : 0xFF00;

 37314         this.ct = 8;

 37315         this.bp = bp;

 37316       }

 37317       if (this.clow > 0xFFFF) {

 37318         this.chigh += (this.clow >> 16);

 37319         this.clow &= 0xFFFF;

 37320       }

 37321     },

 37322     // C.3.2 Decoding a decision (DECODE)

 37323     readBit: function ArithmeticDecoder_readBit(contexts, pos) {

 37324       // contexts are packed into 1 byte:

 37325       // highest 7 bits carry cx.index, lowest bit carries cx.mps

 37326       var cx_index = contexts[pos] >> 1, cx_mps = contexts[pos] & 1;

 37327       var qeTableIcx = QeTable[cx_index];

 37328       var qeIcx = qeTableIcx.qe;

 37329       var d;

 37330       var a = this.a - qeIcx;

 37332       if (this.chigh < qeIcx) {

 37333         // exchangeLps

 37334         if (a < qeIcx) {

 37335           a = qeIcx;

 37336           d = cx_mps;

 37337           cx_index = qeTableIcx.nmps;

 37338         } else {

 37339           a = qeIcx;

 37340           d = 1 ^ cx_mps;

 37341           if (qeTableIcx.switchFlag === 1) {

 37342             cx_mps = d;

 37343           }

 37344           cx_index = qeTableIcx.nlps;

 37345         }

 37346       } else {

 37347         this.chigh -= qeIcx;

 37348         if ((a & 0x8000) !== 0) {

 37349           this.a = a;

 37350           return cx_mps;

 37351         }

 37352         // exchangeMps

 37353         if (a < qeIcx) {

 37354           d = 1 ^ cx_mps;

 37355           if (qeTableIcx.switchFlag === 1) {

 37356             cx_mps = d;

 37357           }

 37358           cx_index = qeTableIcx.nlps;

 37359         } else {

 37360           d = cx_mps;

 37361           cx_index = qeTableIcx.nmps;

 37362         }

 37363       }

 37364       // C.3.3 renormD;

 37365       do {

 37366         if (this.ct === 0) {

 37367           this.byteIn();

 37368         }

 37370         a <<= 1;

 37371         this.chigh = ((this.chigh << 1) & 0xFFFF) | ((this.clow >> 15) & 1);

 37372         this.clow = (this.clow << 1) & 0xFFFF;

 37373         this.ct--;

 37374       } while ((a & 0x8000) === 0);

 37375       this.a = a;

 37377       contexts[pos] = cx_index << 1 | cx_mps;

 37378       return d;

 37379     }

 37380   };

 37382   return ArithmeticDecoder;

 37383 })();

 37386 var JpxImage = (function JpxImageClosure() {

 37387   // Table E.1

 37388   var SubbandsGainLog2 = {

 37389     'LL': 0,

 37390     'LH': 1,

 37391     'HL': 1,

 37392     'HH': 2

 37393   };

 37394   function JpxImage() {

 37395     this.failOnCorruptedImage = false;

 37396   }

 37397   JpxImage.prototype = {

 37398     load: function JpxImage_load(url) {

 37399       var xhr = new XMLHttpRequest();

 37400       xhr.open('GET', url, true);

 37401       xhr.responseType = 'arraybuffer';

 37402       xhr.onload = (function() {

 37403         // TODO catch parse error

 37404         var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);

 37405         this.parse(data);

 37406         if (this.onload) {

 37407           this.onload();

 37408         }

 37409       }).bind(this);

 37410       xhr.send(null);

 37411     },

 37412     parse: function JpxImage_parse(data) {

 37414       var head = readUint16(data, 0);

 37415       // No box header, immediate start of codestream (SOC)

 37416       if (head === 0xFF4F) {

 37417         this.parseCodestream(data, 0, data.length);

 37418         return;

 37419       }

 37421       var position = 0, length = data.length;

 37422       while (position < length) {

 37423         var headerSize = 8;

 37424         var lbox = readUint32(data, position);

 37425         var tbox = readUint32(data, position + 4);

 37426         position += headerSize;

 37427         if (lbox === 1) {

 37428           // XLBox: read UInt64 according to spec.

 37429           // JavaScript's int precision of 53 bit should be sufficient here.

 37430           lbox = readUint32(data, position) * 4294967296 +

 37431                  readUint32(data, position + 4);

 37432           position += 8;

 37433           headerSize += 8;

 37434         }

 37435         if (lbox === 0) {

 37436           lbox = length - position + headerSize;

 37437         }

 37438         if (lbox < headerSize) {

 37439           error('JPX error: Invalid box field size');

 37440         }

 37441         var dataLength = lbox - headerSize;

 37442         var jumpDataLength = true;

 37443         switch (tbox) {

 37444           case 0x6A501A1A: // 'jP\032\032'

 37445             // TODO

 37446             break;

 37447           case 0x6A703268: // 'jp2h'

 37448             jumpDataLength = false; // parsing child boxes

 37449             break;

 37450           case 0x636F6C72: // 'colr'

 37451             // TODO

 37452             break;

 37453           case 0x6A703263: // 'jp2c'

 37454             this.parseCodestream(data, position, position + dataLength);

 37455             break;

 37456         }

 37457         if (jumpDataLength) {

 37458           position += dataLength;

 37459         }

 37460       }

 37461     },

 37462     parseImageProperties: function JpxImage_parseImageProperties(stream) {

 37463       try {

 37464         var newByte = stream.getByte();

 37465         while (newByte >= 0) {

 37466           var oldByte = newByte;

 37467           newByte = stream.getByte();

 37468           var code = (oldByte << 8) | newByte;

 37469           // Image and tile size (SIZ)

 37470           if (code == 0xFF51) {

 37471             stream.skip(4);

 37472             var Xsiz = stream.getInt32() >>> 0; // Byte 4

 37473             var Ysiz = stream.getInt32() >>> 0; // Byte 8

 37474             var XOsiz = stream.getInt32() >>> 0; // Byte 12

 37475             var YOsiz = stream.getInt32() >>> 0; // Byte 16

 37476             stream.skip(16);

 37477             var Csiz = stream.getUint16(); // Byte 36

 37478             this.width = Xsiz - XOsiz;

 37479             this.height = Ysiz - YOsiz;

 37480             this.componentsCount = Csiz;

 37481             // Results are always returned as Uint8Arrays

 37482             this.bitsPerComponent = 8;

 37483             return;

 37484           }

 37485         }

 37486         throw 'No size marker found in JPX stream';

 37487       } catch (e) {

 37488         if (this.failOnCorruptedImage) {

 37489           error('JPX error: ' + e);

 37490         } else {

 37491           warn('JPX error: ' + e + '. Trying to recover');

 37492         }

 37493       }

 37494     },

 37495     parseCodestream: function JpxImage_parseCodestream(data, start, end) {

 37496       var context = {};

 37497       try {

 37498         var position = start;

 37499         while (position + 1 < end) {

 37500           var code = readUint16(data, position);

 37501           position += 2;

 37503           var length = 0, j, sqcd, spqcds, spqcdSize, scalarExpounded, tile;

 37504           switch (code) {

 37505             case 0xFF4F: // Start of codestream (SOC)

 37506               context.mainHeader = true;

 37507               break;

 37508             case 0xFFD9: // End of codestream (EOC)

 37509               break;

 37510             case 0xFF51: // Image and tile size (SIZ)

 37511               length = readUint16(data, position);

 37512               var siz = {};

 37513               siz.Xsiz = readUint32(data, position + 4);

 37514               siz.Ysiz = readUint32(data, position + 8);

 37515               siz.XOsiz = readUint32(data, position + 12);

 37516               siz.YOsiz = readUint32(data, position + 16);

 37517               siz.XTsiz = readUint32(data, position + 20);

 37518               siz.YTsiz = readUint32(data, position + 24);

 37519               siz.XTOsiz = readUint32(data, position + 28);

 37520               siz.YTOsiz = readUint32(data, position + 32);

 37521               var componentsCount = readUint16(data, position + 36);

 37522               siz.Csiz = componentsCount;

 37523               var components = [];

 37524               j = position + 38;

 37525               for (var i = 0; i < componentsCount; i++) {

 37526                 var component = {

 37527                   precision: (data[j] & 0x7F) + 1,

 37528                   isSigned: !!(data[j] & 0x80),

 37529                   XRsiz: data[j + 1],

 37530                   YRsiz: data[j + 1]

 37531                 };

 37532                 calculateComponentDimensions(component, siz);

 37533                 components.push(component);

 37534               }

 37535               context.SIZ = siz;

 37536               context.components = components;

 37537               calculateTileGrids(context, components);

 37538               context.QCC = [];

 37539               context.COC = [];

 37540               break;

 37541             case 0xFF5C: // Quantization default (QCD)

 37542               length = readUint16(data, position);

 37543               var qcd = {};

 37544               j = position + 2;

 37545               sqcd = data[j++];

 37546               switch (sqcd & 0x1F) {

 37547                 case 0:

 37548                   spqcdSize = 8;

 37549                   scalarExpounded = true;

 37550                   break;

 37551                 case 1:

 37552                   spqcdSize = 16;

 37553                   scalarExpounded = false;

 37554                   break;

 37555                 case 2:

 37556                   spqcdSize = 16;

 37557                   scalarExpounded = true;

 37558                   break;

 37559                 default:

 37560                   throw 'Invalid SQcd value ' + sqcd;

 37561               }

 37562               qcd.noQuantization = (spqcdSize == 8);

 37563               qcd.scalarExpounded = scalarExpounded;

 37564               qcd.guardBits = sqcd >> 5;

 37565               spqcds = [];

 37566               while (j < length + position) {

 37567                 var spqcd = {};

 37568                 if (spqcdSize == 8) {

 37569                   spqcd.epsilon = data[j++] >> 3;

 37570                   spqcd.mu = 0;

 37571                 } else {

 37572                   spqcd.epsilon = data[j] >> 3;

 37573                   spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];

 37574                   j += 2;

 37575                 }

 37576                 spqcds.push(spqcd);

 37577               }

 37578               qcd.SPqcds = spqcds;

 37579               if (context.mainHeader) {

 37580                 context.QCD = qcd;

 37581               } else {

 37582                 context.currentTile.QCD = qcd;

 37583                 context.currentTile.QCC = [];

 37584               }

 37585               break;

 37586             case 0xFF5D: // Quantization component (QCC)

 37587               length = readUint16(data, position);

 37588               var qcc = {};

 37589               j = position + 2;

 37590               var cqcc;

 37591               if (context.SIZ.Csiz < 257) {

 37592                 cqcc = data[j++];

 37593               } else {

 37594                 cqcc = readUint16(data, j);

 37595                 j += 2;

 37596               }

 37597               sqcd = data[j++];

 37598               switch (sqcd & 0x1F) {

 37599                 case 0:

 37600                   spqcdSize = 8;

 37601                   scalarExpounded = true;

 37602                   break;

 37603                 case 1:

 37604                   spqcdSize = 16;

 37605                   scalarExpounded = false;

 37606                   break;

 37607                 case 2:

 37608                   spqcdSize = 16;

 37609                   scalarExpounded = true;

 37610                   break;

 37611                 default:

 37612                   throw 'Invalid SQcd value ' + sqcd;

 37613               }

 37614               qcc.noQuantization = (spqcdSize == 8);

 37615               qcc.scalarExpounded = scalarExpounded;

 37616               qcc.guardBits = sqcd >> 5;

 37617               spqcds = [];

 37618               while (j < (length + position)) {

 37619                 spqcd = {};

 37620                 if (spqcdSize == 8) {

 37621                   spqcd.epsilon = data[j++] >> 3;

 37622                   spqcd.mu = 0;

 37623                 } else {

 37624                   spqcd.epsilon = data[j] >> 3;

 37625                   spqcd.mu = ((data[j] & 0x7) << 8) | data[j + 1];

 37626                   j += 2;

 37627                 }

 37628                 spqcds.push(spqcd);

 37629               }

 37630               qcc.SPqcds = spqcds;

 37631               if (context.mainHeader) {

 37632                 context.QCC[cqcc] = qcc;

 37633               } else {

 37634                 context.currentTile.QCC[cqcc] = qcc;

 37635               }

 37636               break;

 37637             case 0xFF52: // Coding style default (COD)

 37638               length = readUint16(data, position);

 37639               var cod = {};

 37640               j = position + 2;

 37641               var scod = data[j++];

 37642               cod.entropyCoderWithCustomPrecincts = !!(scod & 1);

 37643               cod.sopMarkerUsed = !!(scod & 2);

 37644               cod.ephMarkerUsed = !!(scod & 4);

 37645               cod.progressionOrder = data[j++];

 37646               cod.layersCount = readUint16(data, j);

 37647               j += 2;

 37648               cod.multipleComponentTransform = data[j++];

 37650               cod.decompositionLevelsCount = data[j++];

 37651               cod.xcb = (data[j++] & 0xF) + 2;

 37652               cod.ycb = (data[j++] & 0xF) + 2;

 37653               var blockStyle = data[j++];

 37654               cod.selectiveArithmeticCodingBypass = !!(blockStyle & 1);

 37655               cod.resetContextProbabilities = !!(blockStyle & 2);

 37656               cod.terminationOnEachCodingPass = !!(blockStyle & 4);

 37657               cod.verticalyStripe = !!(blockStyle & 8);

 37658               cod.predictableTermination = !!(blockStyle & 16);

 37659               cod.segmentationSymbolUsed = !!(blockStyle & 32);

 37660               cod.reversibleTransformation = data[j++];

 37661               if (cod.entropyCoderWithCustomPrecincts) {

 37662                 var precinctsSizes = [];

 37663                 while (j < length + position) {

 37664                   var precinctsSize = data[j++];

 37665                   precinctsSizes.push({

 37666                     PPx: precinctsSize & 0xF,

 37667                     PPy: precinctsSize >> 4

 37668                   });

 37669                 }

 37670                 cod.precinctsSizes = precinctsSizes;

 37671               }

 37673               if (cod.sopMarkerUsed || cod.ephMarkerUsed ||

 37674                   cod.selectiveArithmeticCodingBypass ||

 37675                   cod.resetContextProbabilities ||

 37676                   cod.terminationOnEachCodingPass ||

 37677                   cod.verticalyStripe || cod.predictableTermination) {

 37678                 throw 'Unsupported COD options: ' +

 37679                   globalScope.JSON.stringify(cod);

 37680               }

 37682               if (context.mainHeader) {

 37683                 context.COD = cod;

 37684               } else {

 37685                 context.currentTile.COD = cod;

 37686                 context.currentTile.COC = [];

 37687               }

 37688               break;

 37689             case 0xFF90: // Start of tile-part (SOT)

 37690               length = readUint16(data, position);

 37691               tile = {};

 37692               tile.index = readUint16(data, position + 2);

 37693               tile.length = readUint32(data, position + 4);

 37694               tile.dataEnd = tile.length + position - 2;

 37695               tile.partIndex = data[position + 8];

 37696               tile.partsCount = data[position + 9];

 37698               context.mainHeader = false;

 37699               if (tile.partIndex === 0) {

 37700                 // reset component specific settings

 37701                 tile.COD = context.COD;

 37702                 tile.COC = context.COC.slice(0); // clone of the global COC

 37703                 tile.QCD = context.QCD;

 37704                 tile.QCC = context.QCC.slice(0); // clone of the global COC

 37705               }

 37706               context.currentTile = tile;

 37707               break;

 37708             case 0xFF93: // Start of data (SOD)

 37709               tile = context.currentTile;

 37710               if (tile.partIndex === 0) {

 37711                 initializeTile(context, tile.index);

 37712                 buildPackets(context);

 37713               }

 37715               // moving to the end of the data

 37716               length = tile.dataEnd - position;

 37717               parseTilePackets(context, data, position, length);

 37718               break;

 37719             case 0xFF64: // Comment (COM)

 37720               length = readUint16(data, position);

 37721               // skipping content

 37722               break;

 37723             case 0xFF53: // Coding style component (COC)

 37724               throw 'Codestream code 0xFF53 (COC) is not implemented';

 37725             default:

 37726               throw 'Unknown codestream code: ' + code.toString(16);

 37727           }

 37728           position += length;

 37729         }

 37730       } catch (e) {

 37731         if (this.failOnCorruptedImage) {

 37732           error('JPX error: ' + e);

 37733         } else {

 37734           warn('JPX error: ' + e + '. Trying to recover');

 37735         }

 37736       }

 37737       this.tiles = transformComponents(context);

 37738       this.width = context.SIZ.Xsiz - context.SIZ.XOsiz;

 37739       this.height = context.SIZ.Ysiz - context.SIZ.YOsiz;

 37740       this.componentsCount = context.SIZ.Csiz;

 37741     }

 37742   };

 37743   function calculateComponentDimensions(component, siz) {

 37744     // Section B.2 Component mapping

 37745     component.x0 = Math.ceil(siz.XOsiz / component.XRsiz);

 37746     component.x1 = Math.ceil(siz.Xsiz / component.XRsiz);

 37747     component.y0 = Math.ceil(siz.YOsiz / component.YRsiz);

 37748     component.y1 = Math.ceil(siz.Ysiz / component.YRsiz);

 37749     component.width = component.x1 - component.x0;

 37750     component.height = component.y1 - component.y0;

 37751   }

 37752   function calculateTileGrids(context, components) {

 37753     var siz = context.SIZ;

 37754     // Section B.3 Division into tile and tile-components

 37755     var tile, tiles = [];

 37756     var numXtiles = Math.ceil((siz.Xsiz - siz.XTOsiz) / siz.XTsiz);

 37757     var numYtiles = Math.ceil((siz.Ysiz - siz.YTOsiz) / siz.YTsiz);

 37758     for (var q = 0; q < numYtiles; q++) {

 37759       for (var p = 0; p < numXtiles; p++) {

 37760         tile = {};

 37761         tile.tx0 = Math.max(siz.XTOsiz + p * siz.XTsiz, siz.XOsiz);

 37762         tile.ty0 = Math.max(siz.YTOsiz + q * siz.YTsiz, siz.YOsiz);

 37763         tile.tx1 = Math.min(siz.XTOsiz + (p + 1) * siz.XTsiz, siz.Xsiz);

 37764         tile.ty1 = Math.min(siz.YTOsiz + (q + 1) * siz.YTsiz, siz.Ysiz);

 37765         tile.width = tile.tx1 - tile.tx0;

 37766         tile.height = tile.ty1 - tile.ty0;

 37767         tile.components = [];

 37768         tiles.push(tile);

 37769       }

 37770     }

 37771     context.tiles = tiles;

 37773     var componentsCount = siz.Csiz;

 37774     for (var i = 0, ii = componentsCount; i < ii; i++) {

 37775       var component = components[i];

 37776       for (var j = 0, jj = tiles.length; j < jj; j++) {

 37777         var tileComponent = {};

 37778         tile = tiles[j];

 37779         tileComponent.tcx0 = Math.ceil(tile.tx0 / component.XRsiz);

 37780         tileComponent.tcy0 = Math.ceil(tile.ty0 / component.YRsiz);

 37781         tileComponent.tcx1 = Math.ceil(tile.tx1 / component.XRsiz);

 37782         tileComponent.tcy1 = Math.ceil(tile.ty1 / component.YRsiz);

 37783         tileComponent.width = tileComponent.tcx1 - tileComponent.tcx0;

 37784         tileComponent.height = tileComponent.tcy1 - tileComponent.tcy0;

 37785         tile.components[i] = tileComponent;

 37786       }

 37787     }

 37788   }

 37789   function getBlocksDimensions(context, component, r) {

 37790     var codOrCoc = component.codingStyleParameters;

 37791     var result = {};

 37792     if (!codOrCoc.entropyCoderWithCustomPrecincts) {

 37793       result.PPx = 15;

 37794       result.PPy = 15;

 37795     } else {

 37796       result.PPx = codOrCoc.precinctsSizes[r].PPx;

 37797       result.PPy = codOrCoc.precinctsSizes[r].PPy;

 37798     }

 37799     // calculate codeblock size as described in section B.7

 37800     result.xcb_ = (r > 0 ? Math.min(codOrCoc.xcb, result.PPx - 1) :

 37801                    Math.min(codOrCoc.xcb, result.PPx));

 37802     result.ycb_ = (r > 0 ? Math.min(codOrCoc.ycb, result.PPy - 1) :

 37803                    Math.min(codOrCoc.ycb, result.PPy));

 37804     return result;

 37805   }

 37806   function buildPrecincts(context, resolution, dimensions) {

 37807     // Section B.6 Division resolution to precincts

 37808     var precinctWidth = 1 << dimensions.PPx;

 37809     var precinctHeight = 1 << dimensions.PPy;

 37810     var numprecinctswide = (resolution.trx1 > resolution.trx0 ?

 37811       Math.ceil(resolution.trx1 / precinctWidth) -

 37812       Math.floor(resolution.trx0 / precinctWidth) : 0);

 37813     var numprecinctshigh = (resolution.try1 > resolution.try0 ?

 37814       Math.ceil(resolution.try1 / precinctHeight) -

 37815       Math.floor(resolution.try0 / precinctHeight) : 0);

 37816     var numprecincts = numprecinctswide * numprecinctshigh;

 37817     var precinctXOffset = Math.floor(resolution.trx0 / precinctWidth) *

 37818                           precinctWidth;

 37819     var precinctYOffset = Math.floor(resolution.try0 / precinctHeight) *

 37820                           precinctHeight;

 37821     resolution.precinctParameters = {

 37822       precinctXOffset: precinctXOffset,

 37823       precinctYOffset: precinctYOffset,

 37824       precinctWidth: precinctWidth,

 37825       precinctHeight: precinctHeight,

 37826       numprecinctswide: numprecinctswide,

 37827       numprecinctshigh: numprecinctshigh,

 37828       numprecincts: numprecincts

 37829     };

 37830   }

 37831   function buildCodeblocks(context, subband, dimensions) {

 37832     // Section B.7 Division sub-band into code-blocks

 37833     var xcb_ = dimensions.xcb_;

 37834     var ycb_ = dimensions.ycb_;

 37835     var codeblockWidth = 1 << xcb_;

 37836     var codeblockHeight = 1 << ycb_;

 37837     var cbx0 = subband.tbx0 >> xcb_;

 37838     var cby0 = subband.tby0 >> ycb_;

 37839     var cbx1 = (subband.tbx1 + codeblockWidth - 1) >> xcb_;

 37840     var cby1 = (subband.tby1 + codeblockHeight - 1) >> ycb_;

 37841     var precinctParameters = subband.resolution.precinctParameters;

 37842     var codeblocks = [];

 37843     var precincts = [];

 37844     var i, j, codeblock, precinctNumber;

 37845     for (j = cby0; j < cby1; j++) {

 37846       for (i = cbx0; i < cbx1; i++) {

 37847         codeblock = {

 37848           cbx: i,

 37849           cby: j,

 37850           tbx0: codeblockWidth * i,

 37851           tby0: codeblockHeight * j,

 37852           tbx1: codeblockWidth * (i + 1),

 37853           tby1: codeblockHeight * (j + 1)

 37854         };

 37855         // calculate precinct number

 37856         var pi = Math.floor((codeblock.tbx0 -

 37857                  precinctParameters.precinctXOffset) /

 37858                  precinctParameters.precinctWidth);

 37859         var pj = Math.floor((codeblock.tby0 -

 37860                  precinctParameters.precinctYOffset) /

 37861                  precinctParameters.precinctHeight);

 37862         precinctNumber = pj + pi * precinctParameters.numprecinctswide;

 37863         codeblock.tbx0_ = Math.max(subband.tbx0, codeblock.tbx0);

 37864         codeblock.tby0_ = Math.max(subband.tby0, codeblock.tby0);

 37865         codeblock.tbx1_ = Math.min(subband.tbx1, codeblock.tbx1);

 37866         codeblock.tby1_ = Math.min(subband.tby1, codeblock.tby1);

 37867         codeblock.precinctNumber = precinctNumber;

 37868         codeblock.subbandType = subband.type;

 37869         codeblock.Lblock = 3;

 37870         codeblocks.push(codeblock);

 37871         // building precinct for the sub-band

 37872         var precinct = precincts[precinctNumber];

 37873         if (precinct !== undefined) {

 37874           if (i < precinct.cbxMin) {

 37875             precinct.cbxMin = i;

 37876           } else if (i > precinct.cbxMax) {

 37877             precinct.cbxMax = i;

 37878           }

 37879           if (j < precinct.cbyMin) {

 37880             precinct.cbxMin = j;

 37881           } else if (j > precinct.cbyMax) {

 37882             precinct.cbyMax = j;

 37883           }

 37884         } else {

 37885           precincts[precinctNumber] = precinct = {

 37886             cbxMin: i,

 37887             cbyMin: j,

 37888             cbxMax: i,

 37889             cbyMax: j

 37890           };

 37891         }

 37892         codeblock.precinct = precinct;

 37893       }

 37894     }

 37895     subband.codeblockParameters = {

 37896       codeblockWidth: xcb_,

 37897       codeblockHeight: ycb_,

 37898       numcodeblockwide: cbx1 - cbx0 + 1,

 37899       numcodeblockhigh: cby1 - cby1 + 1

 37900     };

 37901     subband.codeblocks = codeblocks;

 37902     subband.precincts = precincts;

 37903   }

 37904   function createPacket(resolution, precinctNumber, layerNumber) {

 37905     var precinctCodeblocks = [];

 37906     // Section B.10.8 Order of info in packet

 37907     var subbands = resolution.subbands;

 37908     // sub-bands already ordered in 'LL', 'HL', 'LH', and 'HH' sequence

 37909     for (var i = 0, ii = subbands.length; i < ii; i++) {

 37910       var subband = subbands[i];

 37911       var codeblocks = subband.codeblocks;

 37912       for (var j = 0, jj = codeblocks.length; j < jj; j++) {

 37913         var codeblock = codeblocks[j];

 37914         if (codeblock.precinctNumber != precinctNumber) {

 37915           continue;

 37916         }

 37917         precinctCodeblocks.push(codeblock);

 37918       }

 37919     }

 37920     return {

 37921       layerNumber: layerNumber,

 37922       codeblocks: precinctCodeblocks

 37923     };

 37924   }

 37925   function LayerResolutionComponentPositionIterator(context) {

 37926     var siz = context.SIZ;

 37927     var tileIndex = context.currentTile.index;

 37928     var tile = context.tiles[tileIndex];

 37929     var layersCount = tile.codingStyleDefaultParameters.layersCount;

 37930     var componentsCount = siz.Csiz;

 37931     var maxDecompositionLevelsCount = 0;

 37932     for (var q = 0; q < componentsCount; q++) {

 37933       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount,

 37934         tile.components[q].codingStyleParameters.decompositionLevelsCount);

 37935     }

 37937     var l = 0, r = 0, i = 0, k = 0;

 37939     this.nextPacket = function JpxImage_nextPacket() {

 37940       // Section B.12.1.1 Layer-resolution-component-position

 37941       for (; l < layersCount; l++) {

 37942         for (; r <= maxDecompositionLevelsCount; r++) {

 37943           for (; i < componentsCount; i++) {

 37944             var component = tile.components[i];

 37945             if (r > component.codingStyleParameters.decompositionLevelsCount) {

 37946               continue;

 37947             }

 37949             var resolution = component.resolutions[r];

 37950             var numprecincts = resolution.precinctParameters.numprecincts;

 37951             for (; k < numprecincts;) {

 37952               var packet = createPacket(resolution, k, l);

 37953               k++;

 37954               return packet;

 37955             }

 37956             k = 0;

 37957           }

 37958           i = 0;

 37959         }

 37960         r = 0;

 37961       }

 37962       throw 'Out of packets';

 37963     };

 37964   }

 37965   function ResolutionLayerComponentPositionIterator(context) {

 37966     var siz = context.SIZ;

 37967     var tileIndex = context.currentTile.index;

 37968     var tile = context.tiles[tileIndex];

 37969     var layersCount = tile.codingStyleDefaultParameters.layersCount;

 37970     var componentsCount = siz.Csiz;

 37971     var maxDecompositionLevelsCount = 0;

 37972     for (var q = 0; q < componentsCount; q++) {

 37973       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount,

 37974         tile.components[q].codingStyleParameters.decompositionLevelsCount);

 37975     }

 37977     var r = 0, l = 0, i = 0, k = 0;

 37979     this.nextPacket = function JpxImage_nextPacket() {

 37980       // Section B.12.1.2 Resolution-layer-component-position

 37981       for (; r <= maxDecompositionLevelsCount; r++) {

 37982         for (; l < layersCount; l++) {

 37983           for (; i < componentsCount; i++) {

 37984             var component = tile.components[i];

 37985             if (r > component.codingStyleParameters.decompositionLevelsCount) {

 37986               continue;

 37987             }

 37989             var resolution = component.resolutions[r];

 37990             var numprecincts = resolution.precinctParameters.numprecincts;

 37991             for (; k < numprecincts;) {

 37992               var packet = createPacket(resolution, k, l);

 37993               k++;

 37994               return packet;

 37995             }

 37996             k = 0;

 37997           }

 37998           i = 0;

 37999         }

 38000         l = 0;

 38001       }

 38002       throw 'Out of packets';

 38003     };

 38004   }

 38005   function buildPackets(context) {

 38006     var siz = context.SIZ;

 38007     var tileIndex = context.currentTile.index;

 38008     var tile = context.tiles[tileIndex];

 38009     var componentsCount = siz.Csiz;

 38010     // Creating resolutions and sub-bands for each component

 38011     for (var c = 0; c < componentsCount; c++) {

 38012       var component = tile.components[c];

 38013       var decompositionLevelsCount =

 38014         component.codingStyleParameters.decompositionLevelsCount;

 38015       // Section B.5 Resolution levels and sub-bands

 38016       var resolutions = [];

 38017       var subbands = [];

 38018       for (var r = 0; r <= decompositionLevelsCount; r++) {

 38019         var blocksDimensions = getBlocksDimensions(context, component, r);

 38020         var resolution = {};

 38021         var scale = 1 << (decompositionLevelsCount - r);

 38022         resolution.trx0 = Math.ceil(component.tcx0 / scale);

 38023         resolution.try0 = Math.ceil(component.tcy0 / scale);

 38024         resolution.trx1 = Math.ceil(component.tcx1 / scale);

 38025         resolution.try1 = Math.ceil(component.tcy1 / scale);

 38026         buildPrecincts(context, resolution, blocksDimensions);

 38027         resolutions.push(resolution);

 38029         var subband;

 38030         if (r === 0) {

 38031           // one sub-band (LL) with last decomposition

 38032           subband = {};

 38033           subband.type = 'LL';

 38034           subband.tbx0 = Math.ceil(component.tcx0 / scale);

 38035           subband.tby0 = Math.ceil(component.tcy0 / scale);

 38036           subband.tbx1 = Math.ceil(component.tcx1 / scale);

 38037           subband.tby1 = Math.ceil(component.tcy1 / scale);

 38038           subband.resolution = resolution;

 38039           buildCodeblocks(context, subband, blocksDimensions);

 38040           subbands.push(subband);

 38041           resolution.subbands = [subband];

 38042         } else {

 38043           var bscale = 1 << (decompositionLevelsCount - r + 1);

 38044           var resolutionSubbands = [];

 38045           // three sub-bands (HL, LH and HH) with rest of decompositions

 38046           subband = {};

 38047           subband.type = 'HL';

 38048           subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);

 38049           subband.tby0 = Math.ceil(component.tcy0 / bscale);

 38050           subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);

 38051           subband.tby1 = Math.ceil(component.tcy1 / bscale);

 38052           subband.resolution = resolution;

 38053           buildCodeblocks(context, subband, blocksDimensions);

 38054           subbands.push(subband);

 38055           resolutionSubbands.push(subband);

 38057           subband = {};

 38058           subband.type = 'LH';

 38059           subband.tbx0 = Math.ceil(component.tcx0 / bscale);

 38060           subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);

 38061           subband.tbx1 = Math.ceil(component.tcx1 / bscale);

 38062           subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);

 38063           subband.resolution = resolution;

 38064           buildCodeblocks(context, subband, blocksDimensions);

 38065           subbands.push(subband);

 38066           resolutionSubbands.push(subband);

 38068           subband = {};

 38069           subband.type = 'HH';

 38070           subband.tbx0 = Math.ceil(component.tcx0 / bscale - 0.5);

 38071           subband.tby0 = Math.ceil(component.tcy0 / bscale - 0.5);

 38072           subband.tbx1 = Math.ceil(component.tcx1 / bscale - 0.5);

 38073           subband.tby1 = Math.ceil(component.tcy1 / bscale - 0.5);

 38074           subband.resolution = resolution;

 38075           buildCodeblocks(context, subband, blocksDimensions);

 38076           subbands.push(subband);

 38077           resolutionSubbands.push(subband);

 38079           resolution.subbands = resolutionSubbands;

 38080         }

 38081       }

 38082       component.resolutions = resolutions;

 38083       component.subbands = subbands;

 38084     }

 38085     // Generate the packets sequence

 38086     var progressionOrder = tile.codingStyleDefaultParameters.progressionOrder;

 38087     switch (progressionOrder) {

 38088       case 0:

 38089         tile.packetsIterator =

 38090           new LayerResolutionComponentPositionIterator(context);

 38091         break;

 38092       case 1:

 38093         tile.packetsIterator =

 38094           new ResolutionLayerComponentPositionIterator(context);

 38095         break;

 38096       default:

 38097         throw 'Unsupported progression order ' + progressionOrder;

 38098     }

 38099   }

 38100   function parseTilePackets(context, data, offset, dataLength) {

 38101     var position = 0;

 38102     var buffer, bufferSize = 0, skipNextBit = false;

 38103     function readBits(count) {

 38104       while (bufferSize < count) {

 38105         var b = data[offset + position];

 38106         position++;

 38107         if (skipNextBit) {

 38108           buffer = (buffer << 7) | b;

 38109           bufferSize += 7;

 38110           skipNextBit = false;

 38111         } else {

 38112           buffer = (buffer << 8) | b;

 38113           bufferSize += 8;

 38114         }

 38115         if (b == 0xFF) {

 38116           skipNextBit = true;

 38117         }

 38118       }

 38119       bufferSize -= count;

 38120       return (buffer >>> bufferSize) & ((1 << count) - 1);

 38121     }

 38122     function alignToByte() {

 38123       bufferSize = 0;

 38124       if (skipNextBit) {

 38125         position++;

 38126         skipNextBit = false;

 38127       }

 38128     }

 38129     function readCodingpasses() {

 38130       if (readBits(1) === 0) {

 38131         return 1;

 38132       }

 38133       if (readBits(1) === 0) {

 38134         return 2;

 38135       }

 38136       var value = readBits(2);

 38137       if (value < 3) {

 38138         return value + 3;

 38139       }

 38140       value = readBits(5);

 38141       if (value < 31) {

 38142         return value + 6;

 38143       }

 38144       value = readBits(7);

 38145       return value + 37;

 38146     }

 38147     var tileIndex = context.currentTile.index;

 38148     var tile = context.tiles[tileIndex];

 38149     var packetsIterator = tile.packetsIterator;

 38150     while (position < dataLength) {

 38151       var packet = packetsIterator.nextPacket();

 38152       if (!readBits(1)) {

 38153         alignToByte();

 38154         continue;

 38155       }

 38156       var layerNumber = packet.layerNumber;

 38157       var queue = [], codeblock;

 38158       for (var i = 0, ii = packet.codeblocks.length; i < ii; i++) {

 38159         codeblock = packet.codeblocks[i];

 38160         var precinct = codeblock.precinct;

 38161         var codeblockColumn = codeblock.cbx - precinct.cbxMin;

 38162         var codeblockRow = codeblock.cby - precinct.cbyMin;

 38163         var codeblockIncluded = false;

 38164         var firstTimeInclusion = false;

 38165         var valueReady;

 38166         if ('included' in codeblock) {

 38167           codeblockIncluded = !!readBits(1);

 38168         } else {

 38169           // reading inclusion tree

 38170           precinct = codeblock.precinct;

 38171           var inclusionTree, zeroBitPlanesTree;

 38172           if ('inclusionTree' in precinct) {

 38173             inclusionTree = precinct.inclusionTree;

 38174           } else {

 38175             // building inclusion and zero bit-planes trees

 38176             var width = precinct.cbxMax - precinct.cbxMin + 1;

 38177             var height = precinct.cbyMax - precinct.cbyMin + 1;

 38178             inclusionTree = new InclusionTree(width, height, layerNumber);

 38179             zeroBitPlanesTree = new TagTree(width, height);

 38180             precinct.inclusionTree = inclusionTree;

 38181             precinct.zeroBitPlanesTree = zeroBitPlanesTree;

 38182           }

 38184           if (inclusionTree.reset(codeblockColumn, codeblockRow, layerNumber)) {

 38185             while (true) {

 38186               if (readBits(1)) {

 38187                 valueReady = !inclusionTree.nextLevel();

 38188                 if (valueReady) {

 38189                   codeblock.included = true;

 38190                   codeblockIncluded = firstTimeInclusion = true;

 38191                   break;

 38192                 }

 38193               } else {

 38194                 inclusionTree.incrementValue(layerNumber);

 38195                 break;

 38196               }

 38197             }

 38198           }

 38199         }

 38200         if (!codeblockIncluded) {

 38201           continue;

 38202         }

 38203         if (firstTimeInclusion) {

 38204           zeroBitPlanesTree = precinct.zeroBitPlanesTree;

 38205           zeroBitPlanesTree.reset(codeblockColumn, codeblockRow);

 38206           while (true) {

 38207             if (readBits(1)) {

 38208               valueReady = !zeroBitPlanesTree.nextLevel();

 38209               if (valueReady) {

 38210                 break;

 38211               }

 38212             } else {

 38213               zeroBitPlanesTree.incrementValue();

 38214             }

 38215           }

 38216           codeblock.zeroBitPlanes = zeroBitPlanesTree.value;

 38217         }

 38218         var codingpasses = readCodingpasses();

 38219         while (readBits(1)) {

 38220           codeblock.Lblock++;

 38221         }

 38222         var codingpassesLog2 = log2(codingpasses);

 38223         // rounding down log2

 38224         var bits = ((codingpasses < (1 << codingpassesLog2)) ?

 38225           codingpassesLog2 - 1 : codingpassesLog2) + codeblock.Lblock;

 38226         var codedDataLength = readBits(bits);

 38227         queue.push({

 38228           codeblock: codeblock,

 38229           codingpasses: codingpasses,

 38230           dataLength: codedDataLength

 38231         });

 38232       }

 38233       alignToByte();

 38234       while (queue.length > 0) {

 38235         var packetItem = queue.shift();

 38236         codeblock = packetItem.codeblock;

 38237         if (!('data' in codeblock)) {

 38238           codeblock.data = [];

 38239         }

 38240         codeblock.data.push({

 38241           data: data,

 38242           start: offset + position,

 38243           end: offset + position + packetItem.dataLength,

 38244           codingpasses: packetItem.codingpasses

 38245         });

 38246         position += packetItem.dataLength;

 38247       }

 38248     }

 38249     return position;

 38250   }

 38251   function copyCoefficients(coefficients, levelWidth, levelHeight, subband,

 38252                             delta, mb, reversible, segmentationSymbolUsed) {

 38253     var x0 = subband.tbx0;

 38254     var y0 = subband.tby0;

 38255     var width = subband.tbx1 - subband.tbx0;

 38256     var codeblocks = subband.codeblocks;

 38257     var right = subband.type.charAt(0) === 'H' ? 1 : 0;

 38258     var bottom = subband.type.charAt(1) === 'H' ? levelWidth : 0;

 38260     for (var i = 0, ii = codeblocks.length; i < ii; ++i) {

 38261       var codeblock = codeblocks[i];

 38262       var blockWidth = codeblock.tbx1_ - codeblock.tbx0_;

 38263       var blockHeight = codeblock.tby1_ - codeblock.tby0_;

 38264       if (blockWidth === 0 || blockHeight === 0) {

 38265         continue;

 38266       }

 38267       if (!('data' in codeblock)) {

 38268         continue;

 38269       }

 38271       var bitModel, currentCodingpassType;

 38272       bitModel = new BitModel(blockWidth, blockHeight, codeblock.subbandType,

 38273                               codeblock.zeroBitPlanes, mb);

 38274       currentCodingpassType = 2; // first bit plane starts from cleanup

 38276       // collect data

 38277       var data = codeblock.data, totalLength = 0, codingpasses = 0;

 38278       var j, jj, dataItem;

 38279       for (j = 0, jj = data.length; j < jj; j++) {

 38280         dataItem = data[j];

 38281         totalLength += dataItem.end - dataItem.start;

 38282         codingpasses += dataItem.codingpasses;

 38283       }

 38284       var encodedData = new Uint8Array(totalLength);

 38285       var position = 0;

 38286       for (j = 0, jj = data.length; j < jj; j++) {

 38287         dataItem = data[j];

 38288         var chunk = dataItem.data.subarray(dataItem.start, dataItem.end);

 38289         encodedData.set(chunk, position);

 38290         position += chunk.length;

 38291       }

 38292       // decoding the item

 38293       var decoder = new ArithmeticDecoder(encodedData, 0, totalLength);

 38294       bitModel.setDecoder(decoder);

 38296       for (j = 0; j < codingpasses; j++) {

 38297         switch (currentCodingpassType) {

 38298           case 0:

 38299             bitModel.runSignificancePropogationPass();

 38300             break;

 38301           case 1:

 38302             bitModel.runMagnitudeRefinementPass();

 38303             break;

 38304           case 2:

 38305             bitModel.runCleanupPass();

 38306             if (segmentationSymbolUsed) {

 38307               bitModel.checkSegmentationSymbol();

 38308             }

 38309             break;

 38310         }

 38311         currentCodingpassType = (currentCodingpassType + 1) % 3;

 38312       }

 38314       var offset = (codeblock.tbx0_ - x0) + (codeblock.tby0_ - y0) * width;

 38315       var sign = bitModel.coefficentsSign;

 38316       var magnitude = bitModel.coefficentsMagnitude;

 38317       var bitsDecoded = bitModel.bitsDecoded;

 38318       var magnitudeCorrection = reversible ? 0 : 0.5;

 38319       var k, n, nb;

 38320       position = 0;

 38321       // Do the interleaving of Section F.3.3 here, so we do not need

 38322       // to copy later. LL level is not interleaved, just copied.

 38323       var interleave = (subband.type !== 'LL');

 38324       for (j = 0; j < blockHeight; j++) {

 38325         var row = (offset / width) | 0; // row in the non-interleaved subband

 38326         var levelOffset = 2 * row * (levelWidth - width) + right + bottom;

 38327         for (k = 0; k < blockWidth; k++) {

 38328           n = magnitude[position];

 38329           if (n !== 0) {

 38330             n = (n + magnitudeCorrection) * delta;

 38331             if (sign[position] !== 0) {

 38332               n = -n;

 38333             }

 38334             nb = bitsDecoded[position];

 38335             var pos = interleave ? (levelOffset + (offset << 1)) : offset;

 38336             if (reversible && (nb >= mb)) {

 38337               coefficients[pos] = n;

 38338             } else {

 38339               coefficients[pos] = n * (1 << (mb - nb));

 38340             }

 38341           }

 38342           offset++;

 38343           position++;

 38344         }

 38345         offset += width - blockWidth;

 38346       }

 38347     }

 38348   }

 38349   function transformTile(context, tile, c) {

 38350     var component = tile.components[c];

 38351     var codingStyleParameters = component.codingStyleParameters;

 38352     var quantizationParameters = component.quantizationParameters;

 38353     var decompositionLevelsCount =

 38354       codingStyleParameters.decompositionLevelsCount;

 38355     var spqcds = quantizationParameters.SPqcds;

 38356     var scalarExpounded = quantizationParameters.scalarExpounded;

 38357     var guardBits = quantizationParameters.guardBits;

 38358     var segmentationSymbolUsed = codingStyleParameters.segmentationSymbolUsed;

 38359     var precision = context.components[c].precision;

 38361     var reversible = codingStyleParameters.reversibleTransformation;

 38362     var transform = (reversible ? new ReversibleTransform() :

 38363                                   new IrreversibleTransform());

 38365     var subbandCoefficients = [];

 38366     var b = 0;

 38367     for (var i = 0; i <= decompositionLevelsCount; i++) {

 38368       var resolution = component.resolutions[i];

 38370       var width = resolution.trx1 - resolution.trx0;

 38371       var height = resolution.try1 - resolution.try0;

 38372       // Allocate space for the whole sublevel.

 38373       var coefficients = new Float32Array(width * height);

 38375       for (var j = 0, jj = resolution.subbands.length; j < jj; j++) {

 38376         var mu, epsilon;

 38377         if (!scalarExpounded) {

 38378           // formula E-5

 38379           mu = spqcds[0].mu;

 38380           epsilon = spqcds[0].epsilon + (i > 0 ? 1 - i : 0);

 38381         } else {

 38382           mu = spqcds[b].mu;

 38383           epsilon = spqcds[b].epsilon;

 38384           b++;

 38385         }

 38387         var subband = resolution.subbands[j];

 38388         var gainLog2 = SubbandsGainLog2[subband.type];

 38390         // calulate quantization coefficient (Section E.1.1.1)

 38391         var delta = (reversible ? 1 :

 38392           Math.pow(2, precision + gainLog2 - epsilon) * (1 + mu / 2048));

 38393         var mb = (guardBits + epsilon - 1);

 38395         // In the first resolution level, copyCoefficients will fill the

 38396         // whole array with coefficients. In the succeding passes,

 38397         // copyCoefficients will consecutively fill in the values that belong

 38398         // to the interleaved positions of the HL, LH, and HH coefficients.

 38399         // The LL coefficients will then be interleaved in Transform.iterate().

 38400         copyCoefficients(coefficients, width, height, subband, delta, mb,

 38401                          reversible, segmentationSymbolUsed);

 38402       }

 38403       subbandCoefficients.push({

 38404         width: width,

 38405         height: height,

 38406         items: coefficients

 38407       });

 38408     }

 38410     var result = transform.calculate(subbandCoefficients,

 38411                                      component.tcx0, component.tcy0);

 38412     return {

 38413       left: component.tcx0,

 38414       top: component.tcy0,

 38415       width: result.width,

 38416       height: result.height,

 38417       items: result.items

 38418     };

 38419   }

 38420   function transformComponents(context) {

 38421     var siz = context.SIZ;

 38422     var components = context.components;

 38423     var componentsCount = siz.Csiz;

 38424     var resultImages = [];

 38425     for (var i = 0, ii = context.tiles.length; i < ii; i++) {

 38426       var tile = context.tiles[i];

 38427       var transformedTiles = [];

 38428       var c;

 38429       for (c = 0; c < componentsCount; c++) {

 38430         transformedTiles[c] = transformTile(context, tile, c);

 38431       }

 38432       var tile0 = transformedTiles[0];

 38433       var out = new Uint8Array(tile0.items.length * componentsCount);

 38434       var result = {

 38435         left: tile0.left,

 38436         top: tile0.top,

 38437         width: tile0.width,

 38438         height: tile0.height,

 38439         items: out

 38440       };

 38442       // Section G.2.2 Inverse multi component transform

 38443       var shift, offset, max, min;

 38444       var pos = 0, j, jj, y0, y1, y2, r, g, b, k, val;

 38445       if (tile.codingStyleDefaultParameters.multipleComponentTransform) {

 38446         var fourComponents = componentsCount === 4;

 38447         var y0items = transformedTiles[0].items;

 38448         var y1items = transformedTiles[1].items;

 38449         var y2items = transformedTiles[2].items;

 38450         var y3items = fourComponents ? transformedTiles[3].items : null;

 38452         // HACK: The multiple component transform formulas below assume that

 38453         // all components have the same precision. With this in mind, we

 38454         // compute shift and offset only once.

 38455         shift = components[0].precision - 8;

 38456         offset = (128 << shift) + 0.5;

 38457         max = (127.5 * (1 << shift));

 38458         min = -max;

 38460         var component0 = tile.components[0];

 38461         if (!component0.codingStyleParameters.reversibleTransformation) {

 38462           // inverse irreversible multiple component transform

 38463           for (j = 0, jj = y0items.length; j < jj; ++j) {

 38464             y0 = y0items[j];

 38465             y1 = y1items[j];

 38466             y2 = y2items[j];

 38467             r = y0 + 1.402 * y2;

 38468             g = y0 - 0.34413 * y1 - 0.71414 * y2;

 38469             b = y0 + 1.772 * y1;

 38470             out[pos++] = r <= min ? 0 : r >= max ? 255 : (r + offset) >> shift;

 38471             out[pos++] = g <= min ? 0 : g >= max ? 255 : (g + offset) >> shift;

 38472             out[pos++] = b <= min ? 0 : b >= max ? 255 : (b + offset) >> shift;

 38473             if (fourComponents) {

 38474               k = y3items[j];

 38475               out[pos++] =

 38476                 k <= min ? 0 : k >= max ? 255 : (k + offset) >> shift;

 38477             }

 38478           }

 38479         } else {

 38480           // inverse reversible multiple component transform

 38481           for (j = 0, jj = y0items.length; j < jj; ++j) {

 38482             y0 = y0items[j];

 38483             y1 = y1items[j];

 38484             y2 = y2items[j];

 38485             g = y0 - ((y2 + y1) >> 2);

 38486             r = g + y2;

 38487             b = g + y1;

 38488             out[pos++] = r <= min ? 0 : r >= max ? 255 : (r + offset) >> shift;

 38489             out[pos++] = g <= min ? 0 : g >= max ? 255 : (g + offset) >> shift;

 38490             out[pos++] = b <= min ? 0 : b >= max ? 255 : (b + offset) >> shift;

 38491             if (fourComponents) {

 38492               k = y3items[j];

 38493               out[pos++] =

 38494                 k <= min ? 0 : k >= max ? 255 : (k + offset) >> shift;

 38495             }

 38496           }

 38497         }

 38498       } else { // no multi-component transform

 38499         for (c = 0; c < componentsCount; c++) {

 38500           var items = transformedTiles[c].items;

 38501           shift = components[c].precision - 8;

 38502           offset = (128 << shift) + 0.5;

 38503           max = (127.5 * (1 << shift));

 38504           min = -max;

 38505           for (pos = c, j = 0, jj = items.length; j < jj; j++) {

 38506             val = items[j];

 38507             out[pos] = val <= min ? 0 :

 38508                        val >= max ? 255 : (val + offset) >> shift;

 38509             pos += componentsCount;

 38510           }

 38511         }

 38512       }

 38513       resultImages.push(result);

 38514     }

 38515     return resultImages;

 38516   }

 38517   function initializeTile(context, tileIndex) {

 38518     var siz = context.SIZ;

 38519     var componentsCount = siz.Csiz;

 38520     var tile = context.tiles[tileIndex];

 38521     for (var c = 0; c < componentsCount; c++) {

 38522       var component = tile.components[c];

 38523       var qcdOrQcc = (c in context.currentTile.QCC ?

 38524         context.currentTile.QCC[c] : context.currentTile.QCD);

 38525       component.quantizationParameters = qcdOrQcc;

 38526       var codOrCoc = (c in context.currentTile.COC ?

 38527         context.currentTile.COC[c] : context.currentTile.COD);

 38528       component.codingStyleParameters = codOrCoc;

 38529     }

 38530     tile.codingStyleDefaultParameters = context.currentTile.COD;

 38531   }

 38533   // Section B.10.2 Tag trees

 38534   var TagTree = (function TagTreeClosure() {

 38535     function TagTree(width, height) {

 38536       var levelsLength = log2(Math.max(width, height)) + 1;

 38537       this.levels = [];

 38538       for (var i = 0; i < levelsLength; i++) {

 38539         var level = {

 38540           width: width,

 38541           height: height,

 38542           items: []

 38543         };

 38544         this.levels.push(level);

 38545         width = Math.ceil(width / 2);

 38546         height = Math.ceil(height / 2);

 38547       }

 38548     }

 38549     TagTree.prototype = {

 38550       reset: function TagTree_reset(i, j) {

 38551         var currentLevel = 0, value = 0, level;

 38552         while (currentLevel < this.levels.length) {

 38553           level = this.levels[currentLevel];

 38554           var index = i + j * level.width;

 38555           if (index in level.items) {

 38556             value = level.items[index];

 38557             break;

 38558           }

 38559           level.index = index;

 38560           i >>= 1;

 38561           j >>= 1;

 38562           currentLevel++;

 38563         }

 38564         currentLevel--;

 38565         level = this.levels[currentLevel];

 38566         level.items[level.index] = value;

 38567         this.currentLevel = currentLevel;

 38568         delete this.value;

 38569       },

 38570       incrementValue: function TagTree_incrementValue() {

 38571         var level = this.levels[this.currentLevel];

 38572         level.items[level.index]++;

 38573       },

 38574       nextLevel: function TagTree_nextLevel() {

 38575         var currentLevel = this.currentLevel;

 38576         var level = this.levels[currentLevel];

 38577         var value = level.items[level.index];

 38578         currentLevel--;

 38579         if (currentLevel < 0) {

 38580           this.value = value;

 38581           return false;

 38582         }

 38584         this.currentLevel = currentLevel;

 38585         level = this.levels[currentLevel];

 38586         level.items[level.index] = value;

 38587         return true;

 38588       }

 38589     };

 38590     return TagTree;

 38591   })();

 38593   var InclusionTree = (function InclusionTreeClosure() {

 38594     function InclusionTree(width, height,  defaultValue) {

 38595       var levelsLength = log2(Math.max(width, height)) + 1;

 38596       this.levels = [];

 38597       for (var i = 0; i < levelsLength; i++) {

 38598         var items = new Uint8Array(width * height);

 38599         for (var j = 0, jj = items.length; j < jj; j++) {

 38600           items[j] = defaultValue;

 38601         }

 38603         var level = {

 38604           width: width,

 38605           height: height,

 38606           items: items

 38607         };

 38608         this.levels.push(level);

 38610         width = Math.ceil(width / 2);

 38611         height = Math.ceil(height / 2);

 38612       }

 38613     }

 38614     InclusionTree.prototype = {

 38615       reset: function InclusionTree_reset(i, j, stopValue) {

 38616         var currentLevel = 0;

 38617         while (currentLevel < this.levels.length) {

 38618           var level = this.levels[currentLevel];

 38619           var index = i + j * level.width;

 38620           level.index = index;

 38621           var value = level.items[index];

 38623           if (value == 0xFF) {

 38624             break;

 38625           }

 38627           if (value > stopValue) {

 38628             this.currentLevel = currentLevel;

 38629             // already know about this one, propagating the value to top levels

 38630             this.propagateValues();

 38631             return false;

 38632           }

 38634           i >>= 1;

 38635           j >>= 1;

 38636           currentLevel++;

 38637         }

 38638         this.currentLevel = currentLevel - 1;

 38639         return true;

 38640       },

 38641       incrementValue: function InclusionTree_incrementValue(stopValue) {

 38642         var level = this.levels[this.currentLevel];

 38643         level.items[level.index] = stopValue + 1;

 38644         this.propagateValues();

 38645       },

 38646       propagateValues: function InclusionTree_propagateValues() {

 38647         var levelIndex = this.currentLevel;

 38648         var level = this.levels[levelIndex];

 38649         var currentValue = level.items[level.index];

 38650         while (--levelIndex >= 0) {

 38651           level = this.levels[levelIndex];

 38652           level.items[level.index] = currentValue;

 38653         }

 38654       },

 38655       nextLevel: function InclusionTree_nextLevel() {

 38656         var currentLevel = this.currentLevel;

 38657         var level = this.levels[currentLevel];

 38658         var value = level.items[level.index];

 38659         level.items[level.index] = 0xFF;

 38660         currentLevel--;

 38661         if (currentLevel < 0) {

 38662           return false;

 38663         }

 38665         this.currentLevel = currentLevel;

 38666         level = this.levels[currentLevel];

 38667         level.items[level.index] = value;

 38668         return true;

 38669       }

 38670     };

 38671     return InclusionTree;

 38672   })();

 38674   // Section D. Coefficient bit modeling

 38675   var BitModel = (function BitModelClosure() {

 38676     var UNIFORM_CONTEXT = 17;

 38677     var RUNLENGTH_CONTEXT = 18;

 38678     // Table D-1

 38679     // The index is binary presentation: 0dddvvhh, ddd - sum of Di (0..4),

 38680     // vv - sum of Vi (0..2), and hh - sum of Hi (0..2)

 38681     var LLAndLHContextsLabel = new Uint8Array([

 38682       0, 5, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 1, 6, 8, 0, 3, 7, 8, 0, 4,

 38683       7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6,

 38684       8, 0, 3, 7, 8, 0, 4, 7, 8, 0, 0, 0, 0, 0, 2, 6, 8, 0, 3, 7, 8, 0, 4, 7, 8

 38685     ]);

 38686     var HLContextLabel = new Uint8Array([

 38687       0, 3, 4, 0, 5, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 1, 3, 4, 0, 6, 7, 7, 0, 8,

 38688       8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3,

 38689       4, 0, 6, 7, 7, 0, 8, 8, 8, 0, 0, 0, 0, 0, 2, 3, 4, 0, 6, 7, 7, 0, 8, 8, 8

 38690     ]);

 38691     var HHContextLabel = new Uint8Array([

 38692       0, 1, 2, 0, 1, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0, 3, 4, 5, 0, 4, 5, 5, 0, 5,

 38693       5, 5, 0, 0, 0, 0, 0, 6, 7, 7, 0, 7, 7, 7, 0, 7, 7, 7, 0, 0, 0, 0, 0, 8, 8,

 38694       8, 0, 8, 8, 8, 0, 8, 8, 8, 0, 0, 0, 0, 0, 8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8

 38695     ]);

 38697     function BitModel(width, height, subband, zeroBitPlanes, mb) {

 38698       this.width = width;

 38699       this.height = height;

 38701       this.contextLabelTable = (subband == 'HH' ? HHContextLabel :

 38702         (subband == 'HL' ? HLContextLabel : LLAndLHContextsLabel));

 38704       var coefficientCount = width * height;

 38706       // coefficients outside the encoding region treated as insignificant

 38707       // add border state cells for significanceState

 38708       this.neighborsSignificance = new Uint8Array(coefficientCount);

 38709       this.coefficentsSign = new Uint8Array(coefficientCount);

 38710       this.coefficentsMagnitude = mb > 14 ? new Uint32Array(coefficientCount) :

 38711                                   mb > 6 ? new Uint16Array(coefficientCount) :

 38712                                   new Uint8Array(coefficientCount);

 38713       this.processingFlags = new Uint8Array(coefficientCount);

 38715       var bitsDecoded = new Uint8Array(coefficientCount);

 38716       if (zeroBitPlanes !== 0) {

 38717         for (var i = 0; i < coefficientCount; i++) {

 38718           bitsDecoded[i] = zeroBitPlanes;

 38719         }

 38720       }

 38721       this.bitsDecoded = bitsDecoded;

 38723       this.reset();

 38724     }

 38726     BitModel.prototype = {

 38727       setDecoder: function BitModel_setDecoder(decoder) {

 38728         this.decoder = decoder;

 38729       },

 38730       reset: function BitModel_reset() {

 38731         // We have 17 contexts that are accessed via context labels,

 38732         // plus the uniform and runlength context.

 38733         this.contexts = new Int8Array(19);

 38735         // Contexts are packed into 1 byte:

 38736         // highest 7 bits carry the index, lowest bit carries mps

 38737         this.contexts[0] = (4 << 1) | 0;

 38738         this.contexts[UNIFORM_CONTEXT] = (46 << 1) | 0;

 38739         this.contexts[RUNLENGTH_CONTEXT] = (3 << 1) | 0;

 38740       },

 38741       setNeighborsSignificance:

 38742         function BitModel_setNeighborsSignificance(row, column, index) {

 38743         var neighborsSignificance = this.neighborsSignificance;

 38744         var width = this.width, height = this.height;

 38745         var left = (column > 0);

 38746         var right = (column + 1 < width);

 38747         var i;

 38749         if (row > 0) {

 38750           i = index - width;

 38751           if (left) {

 38752             neighborsSignificance[i - 1] += 0x10;

 38753           }

 38754           if (right) {

 38755             neighborsSignificance[i + 1] += 0x10;

 38756           }

 38757           neighborsSignificance[i] += 0x04;

 38758         }

 38760         if (row + 1 < height) {

 38761           i = index + width;

 38762           if (left) {

 38763             neighborsSignificance[i - 1] += 0x10;

 38764           }

 38765           if (right) {

 38766             neighborsSignificance[i + 1] += 0x10;

 38767           }

 38768           neighborsSignificance[i] += 0x04;

 38769         }

 38771         if (left) {

 38772           neighborsSignificance[index - 1] += 0x01;

 38773         }

 38774         if (right) {

 38775           neighborsSignificance[index + 1] += 0x01;

 38776         }

 38777         neighborsSignificance[index] |= 0x80;

 38778       },

 38779       runSignificancePropogationPass:

 38780         function BitModel_runSignificancePropogationPass() {

 38781         var decoder = this.decoder;

 38782         var width = this.width, height = this.height;

 38783         var coefficentsMagnitude = this.coefficentsMagnitude;

 38784         var coefficentsSign = this.coefficentsSign;

 38785         var neighborsSignificance = this.neighborsSignificance;

 38786         var processingFlags = this.processingFlags;

 38787         var contexts = this.contexts;

 38788         var labels = this.contextLabelTable;

 38789         var bitsDecoded = this.bitsDecoded;

 38790         var processedInverseMask = ~1;

 38791         var processedMask = 1;

 38792         var firstMagnitudeBitMask = 2;

 38794         for (var i0 = 0; i0 < height; i0 += 4) {

 38795           for (var j = 0; j < width; j++) {

 38796             var index = i0 * width + j;

 38797             for (var i1 = 0; i1 < 4; i1++, index += width) {

 38798               var i = i0 + i1;

 38799               if (i >= height) {

 38800                 break;

 38801               }

 38802               // clear processed flag first

 38803               processingFlags[index] &= processedInverseMask;

 38805               if (coefficentsMagnitude[index] ||

 38806                   !neighborsSignificance[index]) {

 38807                 continue;

 38808               }

 38810               var contextLabel = labels[neighborsSignificance[index]];

 38811               var decision = decoder.readBit(contexts, contextLabel);

 38812               if (decision) {

 38813                 var sign = this.decodeSignBit(i, j, index);

 38814                 coefficentsSign[index] = sign;

 38815                 coefficentsMagnitude[index] = 1;

 38816                 this.setNeighborsSignificance(i, j, index);

 38817                 processingFlags[index] |= firstMagnitudeBitMask;

 38818               }

 38819               bitsDecoded[index]++;

 38820               processingFlags[index] |= processedMask;

 38821             }

 38822           }

 38823         }

 38824       },

 38825       decodeSignBit: function BitModel_decodeSignBit(row, column, index) {

 38826         var width = this.width, height = this.height;

 38827         var coefficentsMagnitude = this.coefficentsMagnitude;

 38828         var coefficentsSign = this.coefficentsSign;

 38829         var contribution, sign0, sign1, significance1;

 38830         var contextLabel, decoded;

 38832         // calculate horizontal contribution

 38833         significance1 = (column > 0 && coefficentsMagnitude[index - 1] !== 0);

 38834         if (column + 1 < width && coefficentsMagnitude[index + 1] !== 0) {

 38835           sign1 = coefficentsSign[index + 1];

 38836           if (significance1) {

 38837             sign0 = coefficentsSign[index - 1];

 38838             contribution = 1 - sign1 - sign0;

 38839           } else {

 38840             contribution = 1 - sign1 - sign1;

 38841           }

 38842         } else if (significance1) {

 38843           sign0 = coefficentsSign[index - 1];

 38844           contribution = 1 - sign0 - sign0;

 38845         } else {

 38846           contribution = 0;

 38847         }

 38848         var horizontalContribution = 3 * contribution;

 38850         // calculate vertical contribution and combine with the horizontal

 38851         significance1 = (row > 0 && coefficentsMagnitude[index - width] !== 0);

 38852         if (row + 1 < height && coefficentsMagnitude[index + width] !== 0) {

 38853           sign1 = coefficentsSign[index + width];

 38854           if (significance1) {

 38855             sign0 = coefficentsSign[index - width];

 38856             contribution = 1 - sign1 - sign0 + horizontalContribution;

 38857           } else {

 38858             contribution = 1 - sign1 - sign1 + horizontalContribution;

 38859           }

 38860         } else if (significance1) {

 38861           sign0 = coefficentsSign[index - width];

 38862           contribution = 1 - sign0 - sign0 + horizontalContribution;

 38863         } else {

 38864           contribution = horizontalContribution;

 38865         }

 38867         if (contribution >= 0) {

 38868           contextLabel = 9 + contribution;

 38869           decoded = this.decoder.readBit(this.contexts, contextLabel);

 38870         } else {

 38871           contextLabel = 9 - contribution;

 38872           decoded = this.decoder.readBit(this.contexts, contextLabel) ^ 1;

 38873         }

 38874         return decoded;

 38875       },

 38876       runMagnitudeRefinementPass:

 38877         function BitModel_runMagnitudeRefinementPass() {

 38878         var decoder = this.decoder;

 38879         var width = this.width, height = this.height;

 38880         var coefficentsMagnitude = this.coefficentsMagnitude;

 38881         var neighborsSignificance = this.neighborsSignificance;

 38882         var contexts = this.contexts;

 38883         var bitsDecoded = this.bitsDecoded;

 38884         var processingFlags = this.processingFlags;

 38885         var processedMask = 1;

 38886         var firstMagnitudeBitMask = 2;

 38887         var length = width * height;

 38888         var width4 = width * 4;

 38890         for (var index0 = 0, indexNext; index0 < length; index0 = indexNext) {

 38891           indexNext = Math.min(length, index0 + width4);

 38892           for (var j = 0; j < width; j++) {

 38893             for (var index = index0 + j; index < indexNext; index += width) {

 38895               // significant but not those that have just become

 38896               if (!coefficentsMagnitude[index] ||

 38897                 (processingFlags[index] & processedMask) !== 0) {

 38898                 continue;

 38899               }

 38901               var contextLabel = 16;

 38902               if ((processingFlags[index] & firstMagnitudeBitMask) !== 0) {

 38903                 processingFlags[index] ^= firstMagnitudeBitMask;

 38904                 // first refinement

 38905                var significance = neighborsSignificance[index] & 127;

 38906                contextLabel = significance === 0 ? 15 : 14;

 38907               }

 38909               var bit = decoder.readBit(contexts, contextLabel);

 38910               coefficentsMagnitude[index] =

 38911                 (coefficentsMagnitude[index] << 1) | bit;

 38912               bitsDecoded[index]++;

 38913               processingFlags[index] |= processedMask;

 38914             }

 38915           }

 38916         }

 38917       },

 38918       runCleanupPass: function BitModel_runCleanupPass() {

 38919         var decoder = this.decoder;

 38920         var width = this.width, height = this.height;

 38921         var neighborsSignificance = this.neighborsSignificance;

 38922         var coefficentsMagnitude = this.coefficentsMagnitude;

 38923         var coefficentsSign = this.coefficentsSign;

 38924         var contexts = this.contexts;

 38925         var labels = this.contextLabelTable;

 38926         var bitsDecoded = this.bitsDecoded;

 38927         var processingFlags = this.processingFlags;

 38928         var processedMask = 1;

 38929         var firstMagnitudeBitMask = 2;

 38930         var oneRowDown = width;

 38931         var twoRowsDown = width * 2;

 38932         var threeRowsDown = width * 3;

 38933         var iNext;

 38934         for (var i0 = 0; i0 < height; i0 = iNext) {

 38935           iNext = Math.min(i0 + 4, height);

 38936           var indexBase = i0 * width;

 38937           var checkAllEmpty = i0 + 3 < height;

 38938           for (var j = 0; j < width; j++) {

 38939             var index0 = indexBase + j;

 38940             // using the property: labels[neighborsSignificance[index]] == 0

 38941             // when neighborsSignificance[index] == 0

 38942             var allEmpty = (checkAllEmpty &&

 38943               processingFlags[index0] === 0 &&

 38944               processingFlags[index0 + oneRowDown] === 0 &&

 38945               processingFlags[index0 + twoRowsDown] === 0 &&

 38946               processingFlags[index0 + threeRowsDown] === 0 &&

 38947               neighborsSignificance[index0] === 0 &&

 38948               neighborsSignificance[index0 + oneRowDown] === 0 &&

 38949               neighborsSignificance[index0 + twoRowsDown] === 0 &&

 38950               neighborsSignificance[index0 + threeRowsDown] === 0);

 38951             var i1 = 0, index = index0;

 38952             var i = i0, sign;

 38953             if (allEmpty) {

 38954               var hasSignificantCoefficent =

 38955                 decoder.readBit(contexts, RUNLENGTH_CONTEXT);

 38956               if (!hasSignificantCoefficent) {

 38957                 bitsDecoded[index0]++;

 38958                 bitsDecoded[index0 + oneRowDown]++;

 38959                 bitsDecoded[index0 + twoRowsDown]++;

 38960                 bitsDecoded[index0 + threeRowsDown]++;

 38961                 continue; // next column

 38962               }

 38963               i1 = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |

 38964                     decoder.readBit(contexts, UNIFORM_CONTEXT);

 38965               if (i1 !== 0) {

 38966                 i = i0 + i1;

 38967                 index += i1 * width;

 38968               }

 38970               sign = this.decodeSignBit(i, j, index);

 38971               coefficentsSign[index] = sign;

 38972               coefficentsMagnitude[index] = 1;

 38973               this.setNeighborsSignificance(i, j, index);

 38974               processingFlags[index] |= firstMagnitudeBitMask;

 38976               index = index0;

 38977               for (var i2 = i0; i2 <= i; i2++, index += width) {

 38978                 bitsDecoded[index]++;

 38979               }

 38981               i1++;

 38982             }

 38983             for (i = i0 + i1; i < iNext; i++, index += width) {

 38984               if (coefficentsMagnitude[index] ||

 38985                 (processingFlags[index] & processedMask) !== 0) {

 38986                 continue;

 38987               }

 38989               var contextLabel = labels[neighborsSignificance[index]];

 38990               var decision = decoder.readBit(contexts, contextLabel);

 38991               if (decision === 1) {

 38992                 sign = this.decodeSignBit(i, j, index);

 38993                 coefficentsSign[index] = sign;

 38994                 coefficentsMagnitude[index] = 1;

 38995                 this.setNeighborsSignificance(i, j, index);

 38996                 processingFlags[index] |= firstMagnitudeBitMask;

 38997               }

 38998               bitsDecoded[index]++;

 38999             }

 39000           }

 39001         }

 39002       },

 39003       checkSegmentationSymbol: function BitModel_checkSegmentationSymbol() {

 39004         var decoder = this.decoder;

 39005         var contexts = this.contexts;

 39006         var symbol = (decoder.readBit(contexts, UNIFORM_CONTEXT) << 3) |

 39007                      (decoder.readBit(contexts, UNIFORM_CONTEXT) << 2) |

 39008                      (decoder.readBit(contexts, UNIFORM_CONTEXT) << 1) |

 39009                       decoder.readBit(contexts, UNIFORM_CONTEXT);

 39010         if (symbol != 0xA) {

 39011           throw 'Invalid segmentation symbol';

 39012         }

 39013       }

 39014     };

 39016     return BitModel;

 39017   })();

 39019   // Section F, Discrete wavelet transformation

 39020   var Transform = (function TransformClosure() {

 39021     function Transform() {}

 39023     Transform.prototype.calculate =

 39024       function transformCalculate(subbands, u0, v0) {

 39025       var ll = subbands[0];

 39026       for (var i = 1, ii = subbands.length; i < ii; i++) {

 39027         ll = this.iterate(ll, subbands[i], u0, v0);

 39028       }

 39029       return ll;

 39030     };

 39031     Transform.prototype.extend = function extend(buffer, offset, size) {

 39032       // Section F.3.7 extending... using max extension of 4

 39033       var i1 = offset - 1, j1 = offset + 1;

 39034       var i2 = offset + size - 2, j2 = offset + size;

 39035       buffer[i1--] = buffer[j1++];

 39036       buffer[j2++] = buffer[i2--];

 39037       buffer[i1--] = buffer[j1++];

 39038       buffer[j2++] = buffer[i2--];

 39039       buffer[i1--] = buffer[j1++];

 39040       buffer[j2++] = buffer[i2--];

 39041       buffer[i1] = buffer[j1];

 39042       buffer[j2] = buffer[i2];

 39043     };

 39044     Transform.prototype.iterate = function Transform_iterate(ll, hl_lh_hh,

 39045                                                              u0, v0) {

 39046       var llWidth = ll.width, llHeight = ll.height, llItems = ll.items;

 39047       var width = hl_lh_hh.width;

 39048       var height = hl_lh_hh.height;

 39049       var items = hl_lh_hh.items;

 39050       var i, j, k, l, u, v;

 39052       // Interleave LL according to Section F.3.3

 39053       for (k = 0, i = 0; i < llHeight; i++) {

 39054         l = i * 2 * width;

 39055         for (j = 0; j < llWidth; j++, k++, l += 2) {

 39056           items[l] = llItems[k];

 39057         }

 39058       }

 39059       // The LL band is not needed anymore.

 39060       llItems = ll.items = null;

 39062       var bufferPadding = 4;

 39063       var rowBuffer = new Float32Array(width + 2 * bufferPadding);

 39065       // Section F.3.4 HOR_SR

 39066       if (width === 1) {

 39067         // if width = 1, when u0 even keep items as is, when odd divide by 2

 39068         if ((u0 & 1) !== 0) {

 39069           for (v = 0, k = 0; v < height; v++, k += width) {

 39070             items[k] *= 0.5;

 39071           }

 39072         }

 39073       } else {

 39074         for (v = 0, k = 0; v < height; v++, k += width) {

 39075           rowBuffer.set(items.subarray(k, k + width), bufferPadding);

 39077           this.extend(rowBuffer, bufferPadding, width);

 39078           this.filter(rowBuffer, bufferPadding, width);

 39080           items.set(

 39081             rowBuffer.subarray(bufferPadding, bufferPadding + width),

 39082             k);

 39083         }

 39084       }

 39086       // Accesses to the items array can take long, because it may not fit into

 39087       // CPU cache and has to be fetched from main memory. Since subsequent

 39088       // accesses to the items array are not local when reading columns, we

 39089       // have a cache miss every time. To reduce cache misses, get up to

 39090       // 'numBuffers' items at a time and store them into the individual

 39091       // buffers. The colBuffers should be small enough to fit into CPU cache.

 39092       var numBuffers = 16;

 39093       var colBuffers = [];

 39094       for (i = 0; i < numBuffers; i++) {

 39095         colBuffers.push(new Float32Array(height + 2 * bufferPadding));

 39096       }

 39097       var b, currentBuffer = 0;

 39098       ll = bufferPadding + height;

 39100       // Section F.3.5 VER_SR

 39101       if (height === 1) {

 39102           // if height = 1, when v0 even keep items as is, when odd divide by 2

 39103         if ((v0 & 1) !== 0) {

 39104           for (u = 0; u < width; u++) {

 39105             items[u] *= 0.5;

 39106           }

 39107         }

 39108       } else {

 39109         for (u = 0; u < width; u++) {

 39110           // if we ran out of buffers, copy several image columns at once

 39111           if (currentBuffer === 0) {

 39112             numBuffers = Math.min(width - u, numBuffers);

 39113             for (k = u, l = bufferPadding; l < ll; k += width, l++) {

 39114               for (b = 0; b < numBuffers; b++) {

 39115                 colBuffers[b][l] = items[k + b];

 39116               }

 39117             }

 39118             currentBuffer = numBuffers;

 39119           }

 39121           currentBuffer--;

 39122           var buffer = colBuffers[currentBuffer];

 39123           this.extend(buffer, bufferPadding, height);

 39124           this.filter(buffer, bufferPadding, height);

 39126           // If this is last buffer in this group of buffers, flush all buffers.

 39127           if (currentBuffer === 0) {

 39128             k = u - numBuffers + 1;

 39129             for (l = bufferPadding; l < ll; k += width, l++) {

 39130               for (b = 0; b < numBuffers; b++) {

 39131                 items[k + b] = colBuffers[b][l];

 39132               }

 39133             }

 39134           }

 39135         }

 39136       }

 39138       return {

 39139         width: width,

 39140         height: height,

 39141         items: items

 39142       };

 39143     };

 39144     return Transform;

 39145   })();

 39147   // Section 3.8.2 Irreversible 9-7 filter

 39148   var IrreversibleTransform = (function IrreversibleTransformClosure() {

 39149     function IrreversibleTransform() {

 39150       Transform.call(this);

 39151     }

 39153     IrreversibleTransform.prototype = Object.create(Transform.prototype);

 39154     IrreversibleTransform.prototype.filter =

 39155       function irreversibleTransformFilter(x, offset, length) {

 39156       var len = length >> 1;

 39157       offset = offset | 0;

 39158       var j, n, current, next;

 39160       var alpha = -1.586134342059924;

 39161       var beta = -0.052980118572961;

 39162       var gamma = 0.882911075530934;

 39163       var delta = 0.443506852043971;

 39164       var K = 1.230174104914001;

 39165       var K_ = 1 / K;

 39167       // step 1 is combined with step 3

 39169       // step 2

 39170       j = offset - 3;

 39171       for (n = len + 4; n--; j += 2) {

 39172         x[j] *= K_;

 39173       }

 39175       // step 1 & 3

 39176       j = offset - 2;

 39177       current = delta * x[j -1];

 39178       for (n = len + 3; n--; j += 2) {

 39179         next = delta * x[j + 1];

 39180         x[j] = K * x[j] - current - next;

 39181         if (n--) {

 39182           j += 2;

 39183           current = delta * x[j + 1];

 39184           x[j] = K * x[j] - current - next;

 39185         } else {

 39186           break;

 39187         }

 39188       }

 39190       // step 4

 39191       j = offset - 1;

 39192       current = gamma * x[j - 1];

 39193       for (n = len + 2; n--; j += 2) {

 39194         next = gamma * x[j + 1];

 39195         x[j] -= current + next;

 39196         if (n--) {

 39197           j += 2;

 39198           current = gamma * x[j + 1];

 39199           x[j] -= current + next;

 39200         } else {

 39201           break;

 39202         }

 39203       }

 39205       // step 5

 39206       j = offset;

 39207       current = beta * x[j - 1];

 39208       for (n = len + 1; n--; j += 2) {

 39209         next = beta * x[j + 1];

 39210         x[j] -= current + next;

 39211         if (n--) {

 39212           j += 2;

 39213           current = beta * x[j + 1];

 39214           x[j] -= current + next;

 39215         } else {

 39216           break;

 39217         }

 39218       }

 39220       // step 6

 39221       if (len !== 0) {

 39222         j = offset + 1;

 39223         current = alpha * x[j - 1];

 39224         for (n = len; n--; j += 2) {

 39225           next = alpha * x[j + 1];

 39226           x[j] -= current + next;

 39227           if (n--) {

 39228             j += 2;

 39229             current = alpha * x[j + 1];

 39230             x[j] -= current + next;

 39231           } else {

 39232             break;

 39233           }

 39234         }

 39235       }

 39236     };

 39238     return IrreversibleTransform;

 39239   })();

 39241   // Section 3.8.1 Reversible 5-3 filter

 39242   var ReversibleTransform = (function ReversibleTransformClosure() {

 39243     function ReversibleTransform() {

 39244       Transform.call(this);

 39245     }

 39247     ReversibleTransform.prototype = Object.create(Transform.prototype);

 39248     ReversibleTransform.prototype.filter =

 39249       function reversibleTransformFilter(x, offset, length) {

 39250       var len = length >> 1;

 39251       offset = offset | 0;

 39252       var j, n;

 39254       for (j = offset, n = len + 1; n--; j += 2) {

 39255         x[j] -= (x[j - 1] + x[j + 1] + 2) >> 2;

 39256       }

 39258       for (j = offset + 1, n = len; n--; j += 2) {

 39259         x[j] += (x[j - 1] + x[j + 1]) >> 1;

 39260       }

 39261     };

 39263     return ReversibleTransform;

 39264   })();

 39266   return JpxImage;

 39267 })();

 39271 var Jbig2Image = (function Jbig2ImageClosure() {

 39272   // Utility data structures

 39273   function ContextCache() {}

 39275   ContextCache.prototype = {

 39276     getContexts: function(id) {

 39277       if (id in this) {

 39278         return this[id];

 39279       }

 39280       return (this[id] = new Int8Array(1<<16));

 39281     }

 39282   };

 39284   function DecodingContext(data, start, end) {

 39285     this.data = data;

 39286     this.start = start;

 39287     this.end = end;

 39288   }

 39290   DecodingContext.prototype = {

 39291     get decoder() {

 39292       var decoder = new ArithmeticDecoder(this.data, this.start, this.end);

 39293       return shadow(this, 'decoder', decoder);

 39294     },

 39295     get contextCache() {

 39296       var cache = new ContextCache();

 39297       return shadow(this, 'contextCache', cache);

 39298     }

 39299   };

 39301   // Annex A. Arithmetic Integer Decoding Procedure

 39302   // A.2 Procedure for decoding values

 39303   function decodeInteger(contextCache, procedure, decoder) {

 39304     var contexts = contextCache.getContexts(procedure);

 39306     var prev = 1;

 39307     var state = 1, v = 0, s;

 39308     var toRead = 32, offset = 4436; // defaults for state 7

 39309     while (state) {

 39310       var bit = decoder.readBit(contexts, prev);

 39311       prev = (prev < 256 ? (prev << 1) | bit :

 39312               (((prev << 1) | bit) & 511) | 256);

 39313       switch (state) {

 39314         case 1:

 39315           s = !!bit;

 39316           break;

 39317         case 2:

 39318           if (bit) {

 39319             break;

 39320           }

 39321           state = 7;

 39322           toRead = 2;

 39323           offset = 0;

 39324           break;

 39325         case 3:

 39326           if (bit) {

 39327             break;

 39328           }

 39329           state = 7;

 39330           toRead = 4;

 39331           offset = 4;

 39332           break;

 39333         case 4:

 39334           if (bit) {

 39335             break;

 39336           }

 39337           state = 7;

 39338           toRead = 6;

 39339           offset = 20;

 39340           break;

 39341         case 5:

 39342           if (bit) {

 39343             break;

 39344           }

 39345           state = 7;

 39346           toRead = 8;

 39347           offset = 84;

 39348           break;

 39349         case 6:

 39350           if (bit) {

 39351             break;

 39352           }

 39353           state = 7;

 39354           toRead = 12;

 39355           offset = 340;

 39356           break;

 39357         default:

 39358           v = ((v << 1) | bit) >>> 0;

 39359           if (--toRead === 0) {

 39360             state = 0;

 39361           }

 39362           continue;

 39363       }

 39364       state++;

 39365     }

 39366     v += offset;

 39367     return (!s ? v : (v > 0 ? -v : null));

 39368   }

 39370   // A.3 The IAID decoding procedure

 39371   function decodeIAID(contextCache, decoder, codeLength) {

 39372     var contexts = contextCache.getContexts('IAID');

 39374     var prev = 1;

 39375     for (var i = 0; i < codeLength; i++) {

 39376       var bit = decoder.readBit(contexts, prev);

 39377       prev = (prev << 1) | bit;

 39378     }

 39379     if (codeLength < 31) {

 39380       return prev & ((1 << codeLength) - 1);

 39381     }

 39382     return prev & 0x7FFFFFFF;

 39383   }

 39385   // 7.3 Segment types

 39386   var SegmentTypes = [

 39387     'SymbolDictionary', null, null, null, 'IntermediateTextRegion', null,

 39388     'ImmediateTextRegion', 'ImmediateLosslessTextRegion', null, null, null,

 39389     null, null, null, null, null, 'patternDictionary', null, null, null,

 39390     'IntermediateHalftoneRegion', null, 'ImmediateHalftoneRegion',

 39391     'ImmediateLosslessHalftoneRegion', null, null, null, null, null, null, null,

 39392     null, null, null, null, null, 'IntermediateGenericRegion', null,

 39393     'ImmediateGenericRegion', 'ImmediateLosslessGenericRegion',

 39394     'IntermediateGenericRefinementRegion', null,

 39395     'ImmediateGenericRefinementRegion',

 39396     'ImmediateLosslessGenericRefinementRegion', null, null, null, null,

 39397     'PageInformation', 'EndOfPage', 'EndOfStripe', 'EndOfFile', 'Profiles',

 39398     'Tables', null, null, null, null, null, null, null, null,

 39399     'Extension'

 39400   ];

 39402   var CodingTemplates = [

 39403     [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: -2, y: -1},

 39404      {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: 2, y: -1},

 39405      {x: -4, y: 0}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}],

 39406     [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: 2, y: -2},

 39407      {x: -2, y: -1}, {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1},

 39408      {x: 2, y: -1}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}],

 39409     [{x: -1, y: -2}, {x: 0, y: -2}, {x: 1, y: -2}, {x: -2, y: -1},

 39410      {x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: -2, y: 0},

 39411      {x: -1, y: 0}],

 39412     [{x: -3, y: -1}, {x: -2, y: -1}, {x: -1, y: -1}, {x: 0, y: -1},

 39413      {x: 1, y: -1}, {x: -4, y: 0}, {x: -3, y: 0}, {x: -2, y: 0}, {x: -1, y: 0}]

 39414   ];

 39416   var RefinementTemplates = [

 39417     {

 39418       coding: [{x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}],

 39419       reference: [{x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}, {x: 0, y: 0},

 39420                   {x: 1, y: 0}, {x: -1, y: 1}, {x: 0, y: 1}, {x: 1, y: 1}]

 39421     },

 39422     {

 39423       coding: [{x: -1, y: -1}, {x: 0, y: -1}, {x: 1, y: -1}, {x: -1, y: 0}],

 39424       reference: [{x: 0, y: -1}, {x: -1, y: 0}, {x: 0, y: 0}, {x: 1, y: 0},

 39425                   {x: 0, y: 1}, {x: 1, y: 1}]

 39426     }

 39427   ];

 39429   var ReusedContexts = [

 39430     0x1CD3, // '00111001101' (template) + '0011' (at),

 39431     0x079A, // '001111001101' + '0',

 39432     0x00E3, // '001110001' + '1',

 39433     0x018B  // '011000101' + '1'

 39434   ];

 39436   var RefinementReusedContexts = [

 39437     0x0020, // '000' + '0' (coding) + '00010000' + '0' (reference)

 39438     0x0008  // '0000' + '001000'

 39439   ];

 39441   // 6.2 Generic Region Decoding Procedure

 39442   function decodeBitmap(mmr, width, height, templateIndex, prediction, skip, at,

 39443                         decodingContext) {

 39444     if (mmr) {

 39445       error('JBIG2 error: MMR encoding is not supported');

 39446     }

 39448     var useskip = !!skip;

 39449     var template = CodingTemplates[templateIndex].concat(at);

 39451     // Sorting is non-standard, and it is not required. But sorting increases

 39452     // the number of template bits that can be reused from the previous

 39453     // contextLabel in the main loop.

 39454     template.sort(function (a, b) {

 39455       return (a.y - b.y) || (a.x - b.x);

 39456     });

 39458     var templateLength = template.length;

 39459     var templateX = new Int8Array(templateLength);

 39460     var templateY = new Int8Array(templateLength);

 39461     var changingTemplateEntries = [];

 39462     var reuseMask = 0, minX = 0, maxX = 0, minY = 0;

 39463     var c, k;

 39465     for (k = 0; k < templateLength; k++) {

 39466       templateX[k] = template[k].x;

 39467       templateY[k] = template[k].y;

 39468       minX = Math.min(minX, template[k].x);

 39469       maxX = Math.max(maxX, template[k].x);

 39470       minY = Math.min(minY, template[k].y);

 39471       // Check if the template pixel appears in two consecutive context labels,

 39472       // so it can be reused. Otherwise, we add it to the list of changing

 39473       // template entries.

 39474       if (k < templateLength - 1 &&

 39475           template[k].y === template[k + 1].y &&

 39476           template[k].x === template[k + 1].x - 1) {

 39477         reuseMask |= 1 << (templateLength - 1 - k);

 39478       } else {

 39479         changingTemplateEntries.push(k);

 39480       }

 39481     }

 39482     var changingEntriesLength = changingTemplateEntries.length;

 39484     var changingTemplateX = new Int8Array(changingEntriesLength);

 39485     var changingTemplateY = new Int8Array(changingEntriesLength);

 39486     var changingTemplateBit = new Uint16Array(changingEntriesLength);

 39487     for (c = 0; c < changingEntriesLength; c++) {

 39488       k = changingTemplateEntries[c];

 39489       changingTemplateX[c] = template[k].x;

 39490       changingTemplateY[c] = template[k].y;

 39491       changingTemplateBit[c] = 1 << (templateLength - 1 - k);

 39492     }

 39494     // Get the safe bounding box edges from the width, height, minX, maxX, minY

 39495     var sbb_left = -minX;

 39496     var sbb_top = -minY;

 39497     var sbb_right = width - maxX;

 39499     var pseudoPixelContext = ReusedContexts[templateIndex];

 39500     var row = new Uint8Array(width);

 39501     var bitmap = [];

 39503     var decoder = decodingContext.decoder;

 39504     var contexts = decodingContext.contextCache.getContexts('GB');

 39506     var ltp = 0, j, i0, j0, contextLabel = 0, bit, shift;

 39507     for (var i = 0; i < height; i++) {

 39508       if (prediction) {

 39509         var sltp = decoder.readBit(contexts, pseudoPixelContext);

 39510         ltp ^= sltp;

 39511         if (ltp) {

 39512           bitmap.push(row); // duplicate previous row

 39513           continue;

 39514         }

 39515       }

 39516       row = new Uint8Array(row);

 39517       bitmap.push(row);

 39518       for (j = 0; j < width; j++) {

 39519         if (useskip && skip[i][j]) {

 39520           row[j] = 0;

 39521           continue;

 39522         }

 39523         // Are we in the middle of a scanline, so we can reuse contextLabel

 39524         // bits?

 39525         if (j >= sbb_left && j < sbb_right && i >= sbb_top) {

 39526           // If yes, we can just shift the bits that are reusable and only

 39527           // fetch the remaining ones.

 39528           contextLabel = (contextLabel << 1) & reuseMask;

 39529           for (k = 0; k < changingEntriesLength; k++) {

 39530             i0 = i + changingTemplateY[k];

 39531             j0 = j + changingTemplateX[k];

 39532             bit = bitmap[i0][j0];

 39533             if (bit) {

 39534               bit = changingTemplateBit[k];

 39535               contextLabel |= bit;

 39536             }

 39537           }

 39538         } else {

 39539           // compute the contextLabel from scratch

 39540           contextLabel = 0;

 39541           shift = templateLength - 1;

 39542           for (k = 0; k < templateLength; k++, shift--) {

 39543             j0 = j + templateX[k];

 39544             if (j0 >= 0 && j0 < width) {

 39545               i0 = i + templateY[k];

 39546               if (i0 >= 0) {

 39547                 bit = bitmap[i0][j0];

 39548                 if (bit) {

 39549                   contextLabel |= bit << shift;

 39550                 }

 39551               }

 39552             }

 39553           }

 39554         }

 39555         var pixel = decoder.readBit(contexts, contextLabel);

 39556         row[j] = pixel;

 39557       }

 39558     }

 39559     return bitmap;

 39560   }

 39562   // 6.3.2 Generic Refinement Region Decoding Procedure

 39563   function decodeRefinement(width, height, templateIndex, referenceBitmap,

 39564                             offsetX, offsetY, prediction, at,

 39565                             decodingContext) {

 39566     var codingTemplate = RefinementTemplates[templateIndex].coding;

 39567     if (templateIndex === 0) {

 39568       codingTemplate = codingTemplate.concat([at[0]]);

 39569     }

 39570     var codingTemplateLength = codingTemplate.length;

 39571     var codingTemplateX = new Int32Array(codingTemplateLength);

 39572     var codingTemplateY = new Int32Array(codingTemplateLength);

 39573     var k;

 39574     for (k = 0; k < codingTemplateLength; k++) {

 39575       codingTemplateX[k] = codingTemplate[k].x;

 39576       codingTemplateY[k] = codingTemplate[k].y;

 39577     }

 39579     var referenceTemplate = RefinementTemplates[templateIndex].reference;

 39580     if (templateIndex === 0) {

 39581       referenceTemplate = referenceTemplate.concat([at[1]]);

 39582     }

 39583     var referenceTemplateLength = referenceTemplate.length;

 39584     var referenceTemplateX = new Int32Array(referenceTemplateLength);

 39585     var referenceTemplateY = new Int32Array(referenceTemplateLength);

 39586     for (k = 0; k < referenceTemplateLength; k++) {

 39587       referenceTemplateX[k] = referenceTemplate[k].x;

 39588       referenceTemplateY[k] = referenceTemplate[k].y;

 39589     }

 39590     var referenceWidth = referenceBitmap[0].length;

 39591     var referenceHeight = referenceBitmap.length;

 39593     var pseudoPixelContext = RefinementReusedContexts[templateIndex];

 39594     var bitmap = [];

 39596     var decoder = decodingContext.decoder;

 39597     var contexts = decodingContext.contextCache.getContexts('GR');

 39599     var ltp = 0;

 39600     for (var i = 0; i < height; i++) {

 39601       if (prediction) {

 39602         var sltp = decoder.readBit(contexts, pseudoPixelContext);

 39603         ltp ^= sltp;

 39604         if (ltp) {

 39605           error('JBIG2 error: prediction is not supported');

 39606         }

 39607       }

 39608       var row = new Uint8Array(width);

 39609       bitmap.push(row);

 39610       for (var j = 0; j < width; j++) {

 39611         var i0, j0;

 39612         var contextLabel = 0;

 39613         for (k = 0; k < codingTemplateLength; k++) {

 39614           i0 = i + codingTemplateY[k];

 39615           j0 = j + codingTemplateX[k];

 39616           if (i0 < 0 || j0 < 0 || j0 >= width) {

 39617             contextLabel <<= 1; // out of bound pixel

 39618           } else {

 39619             contextLabel = (contextLabel << 1) | bitmap[i0][j0];

 39620           }

 39621         }

 39622         for (k = 0; k < referenceTemplateLength; k++) {

 39623           i0 = i + referenceTemplateY[k] + offsetY;

 39624           j0 = j + referenceTemplateX[k] + offsetX;

 39625           if (i0 < 0 || i0 >= referenceHeight || j0 < 0 ||

 39626               j0 >= referenceWidth) {

 39627             contextLabel <<= 1; // out of bound pixel

 39628           } else {

 39629             contextLabel = (contextLabel << 1) | referenceBitmap[i0][j0];

 39630           }

 39631         }

 39632         var pixel = decoder.readBit(contexts, contextLabel);

 39633         row[j] = pixel;

 39634       }

 39635     }

 39637     return bitmap;

 39638   }

 39640   // 6.5.5 Decoding the symbol dictionary

 39641   function decodeSymbolDictionary(huffman, refinement, symbols,

 39642                                   numberOfNewSymbols, numberOfExportedSymbols,

 39643                                   huffmanTables, templateIndex, at,

 39644                                   refinementTemplateIndex, refinementAt,

 39645                                   decodingContext) {

 39646     if (huffman) {

 39647       error('JBIG2 error: huffman is not supported');

 39648     }

 39650     var newSymbols = [];

 39651     var currentHeight = 0;

 39652     var symbolCodeLength = log2(symbols.length + numberOfNewSymbols);

 39654     var decoder = decodingContext.decoder;

 39655     var contextCache = decodingContext.contextCache;

 39657     while (newSymbols.length < numberOfNewSymbols) {

 39658       var deltaHeight = decodeInteger(contextCache, 'IADH', decoder); // 6.5.6

 39659       currentHeight += deltaHeight;

 39660       var currentWidth = 0;

 39661       var totalWidth = 0;

 39662       while (true) {

 39663         var deltaWidth = decodeInteger(contextCache, 'IADW', decoder); // 6.5.7

 39664         if (deltaWidth === null) {

 39665           break; // OOB

 39666         }

 39667         currentWidth += deltaWidth;

 39668         totalWidth += currentWidth;

 39669         var bitmap;

 39670         if (refinement) {

 39671           // 6.5.8.2 Refinement/aggregate-coded symbol bitmap

 39672           var numberOfInstances = decodeInteger(contextCache, 'IAAI', decoder);

 39673           if (numberOfInstances > 1) {

 39674             bitmap = decodeTextRegion(huffman, refinement,

 39675                                       currentWidth, currentHeight, 0,

 39676                                       numberOfInstances, 1, //strip size

 39677                                       symbols.concat(newSymbols),

 39678                                       symbolCodeLength,

 39679                                       0, //transposed

 39680                                       0, //ds offset

 39681                                       1, //top left 7.4.3.1.1

 39682                                       0, //OR operator

 39683                                       huffmanTables,

 39684                                       refinementTemplateIndex, refinementAt,

 39685                                       decodingContext);

 39686           } else {

 39687             var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);

 39688             var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3

 39689             var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4

 39690             var symbol = (symbolId < symbols.length ? symbols[symbolId] :

 39691                           newSymbols[symbolId - symbols.length]);

 39692             bitmap = decodeRefinement(currentWidth, currentHeight,

 39693             refinementTemplateIndex, symbol, rdx, rdy, false, refinementAt,

 39694             decodingContext);

 39695           }

 39696         } else {

 39697           // 6.5.8.1 Direct-coded symbol bitmap

 39698           bitmap = decodeBitmap(false, currentWidth, currentHeight,

 39699             templateIndex, false, null, at, decodingContext);

 39700         }

 39701         newSymbols.push(bitmap);

 39702       }

 39703     }

 39704     // 6.5.10 Exported symbols

 39705     var exportedSymbols = [];

 39706     var flags = [], currentFlag = false;

 39707     var totalSymbolsLength = symbols.length + numberOfNewSymbols;

 39708     while (flags.length < totalSymbolsLength) {

 39709       var runLength = decodeInteger(contextCache, 'IAEX', decoder);

 39710       while (runLength--) {

 39711         flags.push(currentFlag);

 39712       }

 39713       currentFlag = !currentFlag;

 39714     }

 39715     for (var i = 0, ii = symbols.length; i < ii; i++) {

 39716       if (flags[i]) {

 39717         exportedSymbols.push(symbols[i]);

 39718       }

 39719     }

 39720     for (var j = 0; j < numberOfNewSymbols; i++, j++) {

 39721       if (flags[i]) {

 39722         exportedSymbols.push(newSymbols[j]);

 39723       }

 39724     }

 39725     return exportedSymbols;

 39726   }

 39728   function decodeTextRegion(huffman, refinement, width, height,

 39729                             defaultPixelValue, numberOfSymbolInstances,

 39730                             stripSize, inputSymbols, symbolCodeLength,

 39731                             transposed, dsOffset, referenceCorner,

 39732                             combinationOperator, huffmanTables,

 39733                             refinementTemplateIndex, refinementAt,

 39734                             decodingContext) {

 39735     if (huffman) {

 39736       error('JBIG2 error: huffman is not supported');

 39737     }

 39739     // Prepare bitmap

 39740     var bitmap = [];

 39741     var i, row;

 39742     for (i = 0; i < height; i++) {

 39743       row = new Uint8Array(width);

 39744       if (defaultPixelValue) {

 39745         for (var j = 0; j < width; j++) {

 39746           row[j] = defaultPixelValue;

 39747         }

 39748       }

 39749       bitmap.push(row);

 39750     }

 39752     var decoder = decodingContext.decoder;

 39753     var contextCache = decodingContext.contextCache;

 39754     var stripT = -decodeInteger(contextCache, 'IADT', decoder); // 6.4.6

 39755     var firstS = 0;

 39756     i = 0;

 39757     while (i < numberOfSymbolInstances) {

 39758       var deltaT = decodeInteger(contextCache, 'IADT', decoder); // 6.4.6

 39759       stripT += deltaT;

 39761       var deltaFirstS = decodeInteger(contextCache, 'IAFS', decoder); // 6.4.7

 39762       firstS += deltaFirstS;

 39763       var currentS = firstS;

 39764       do {

 39765         var currentT = (stripSize == 1 ? 0 :

 39766                         decodeInteger(contextCache, 'IAIT', decoder)); // 6.4.9

 39767         var t = stripSize * stripT + currentT;

 39768         var symbolId = decodeIAID(contextCache, decoder, symbolCodeLength);

 39769         var applyRefinement = (refinement &&

 39770                                decodeInteger(contextCache, 'IARI', decoder));

 39771         var symbolBitmap = inputSymbols[symbolId];

 39772         var symbolWidth = symbolBitmap[0].length;

 39773         var symbolHeight = symbolBitmap.length;

 39774         if (applyRefinement) {

 39775           var rdw = decodeInteger(contextCache, 'IARDW', decoder); // 6.4.11.1

 39776           var rdh = decodeInteger(contextCache, 'IARDH', decoder); // 6.4.11.2

 39777           var rdx = decodeInteger(contextCache, 'IARDX', decoder); // 6.4.11.3

 39778           var rdy = decodeInteger(contextCache, 'IARDY', decoder); // 6.4.11.4

 39779           symbolWidth += rdw;

 39780           symbolHeight += rdh;

 39781           symbolBitmap = decodeRefinement(symbolWidth, symbolHeight,

 39782             refinementTemplateIndex, symbolBitmap, (rdw >> 1) + rdx,

 39783             (rdh >> 1) + rdy, false, refinementAt,

 39784             decodingContext);

 39785         }

 39786         var offsetT = t - ((referenceCorner & 1) ? 0 : symbolHeight);

 39787         var offsetS = currentS - ((referenceCorner & 2) ? symbolWidth : 0);

 39788         var s2, t2, symbolRow;

 39789         if (transposed) {

 39790           // Place Symbol Bitmap from T1,S1

 39791           for (s2 = 0; s2 < symbolHeight; s2++) {

 39792             row = bitmap[offsetS + s2];

 39793             if (!row) {

 39794               continue;

 39795             }

 39796             symbolRow = symbolBitmap[s2];

 39797             // To ignore Parts of Symbol bitmap which goes

 39798             // outside bitmap region

 39799             var maxWidth = Math.min(width - offsetT, symbolWidth);

 39800             switch (combinationOperator) {

 39801               case 0: // OR

 39802                 for (t2 = 0; t2 < maxWidth; t2++) {

 39803                   row[offsetT + t2] |= symbolRow[t2];

 39804                 }

 39805                 break;

 39806               case 2: // XOR

 39807                 for (t2 = 0; t2 < maxWidth; t2++) {

 39808                   row[offsetT + t2] ^= symbolRow[t2];

 39809                 }

 39810                 break;

 39811               default:

 39812                 error('JBIG2 error: operator ' + combinationOperator +

 39813                       ' is not supported');

 39814             }

 39815           }

 39816           currentS += symbolHeight - 1;

 39817         } else {

 39818           for (t2 = 0; t2 < symbolHeight; t2++) {

 39819             row = bitmap[offsetT + t2];

 39820             if (!row) {

 39821               continue;

 39822             }

 39823             symbolRow = symbolBitmap[t2];

 39824             switch (combinationOperator) {

 39825               case 0: // OR

 39826                 for (s2 = 0; s2 < symbolWidth; s2++) {

 39827                   row[offsetS + s2] |= symbolRow[s2];

 39828                 }

 39829                 break;

 39830               case 2: // XOR

 39831                 for (s2 = 0; s2 < symbolWidth; s2++) {

 39832                   row[offsetS + s2] ^= symbolRow[s2];

 39833                 }

 39834                 break;

 39835               default:

 39836                 error('JBIG2 error: operator ' + combinationOperator +

 39837                       ' is not supported');

 39838             }

 39839           }

 39840           currentS += symbolWidth - 1;

 39841         }

 39842         i++;

 39843         var deltaS = decodeInteger(contextCache, 'IADS', decoder); // 6.4.8

 39844         if (deltaS === null) {

 39845           break; // OOB

 39846         }

 39847         currentS += deltaS + dsOffset;

 39848       } while (true);

 39849     }

 39850     return bitmap;

 39851   }

 39853   function readSegmentHeader(data, start) {

 39854     var segmentHeader = {};

 39855     segmentHeader.number = readUint32(data, start);

 39856     var flags = data[start + 4];

 39857     var segmentType = flags & 0x3F;

 39858     if (!SegmentTypes[segmentType]) {

 39859       error('JBIG2 error: invalid segment type: ' + segmentType);

 39860     }

 39861     segmentHeader.type = segmentType;

 39862     segmentHeader.typeName = SegmentTypes[segmentType];

 39863     segmentHeader.deferredNonRetain = !!(flags & 0x80);

 39865     var pageAssociationFieldSize = !!(flags & 0x40);

 39866     var referredFlags = data[start + 5];

 39867     var referredToCount = (referredFlags >> 5) & 7;

 39868     var retainBits = [referredFlags & 31];

 39869     var position = start + 6;

 39870     if (referredFlags == 7) {

 39871       referredToCount = readUint32(data, position - 1) & 0x1FFFFFFF;

 39872       position += 3;

 39873       var bytes = (referredToCount + 7) >> 3;

 39874       retainBits[0] = data[position++];

 39875       while (--bytes > 0) {

 39876         retainBits.push(data[position++]);

 39877       }

 39878     } else if (referredFlags == 5 || referredFlags == 6) {

 39879       error('JBIG2 error: invalid referred-to flags');

 39880     }

 39882     segmentHeader.retainBits = retainBits;

 39883     var referredToSegmentNumberSize = (segmentHeader.number <= 256 ? 1 :

 39884       (segmentHeader.number <= 65536 ? 2 : 4));

 39885     var referredTo = [];

 39886     var i, ii;

 39887     for (i = 0; i < referredToCount; i++) {

 39888       var number = (referredToSegmentNumberSize == 1 ? data[position] :

 39889         (referredToSegmentNumberSize == 2 ? readUint16(data, position) :

 39890         readUint32(data, position)));

 39891       referredTo.push(number);

 39892       position += referredToSegmentNumberSize;

 39893     }

 39894     segmentHeader.referredTo = referredTo;

 39895     if (!pageAssociationFieldSize) {

 39896       segmentHeader.pageAssociation = data[position++];

 39897     } else {

 39898       segmentHeader.pageAssociation = readUint32(data, position);

 39899       position += 4;

 39900     }

 39901     segmentHeader.length = readUint32(data, position);

 39902     position += 4;

 39904     if (segmentHeader.length == 0xFFFFFFFF) {

 39905       // 7.2.7 Segment data length, unknown segment length

 39906       if (segmentType === 38) { // ImmediateGenericRegion

 39907         var genericRegionInfo = readRegionSegmentInformation(data, position);

 39908         var genericRegionSegmentFlags = data[position +

 39909           RegionSegmentInformationFieldLength];

 39910         var genericRegionMmr = !!(genericRegionSegmentFlags & 1);

 39911         // searching for the segment end

 39912         var searchPatternLength = 6;

 39913         var searchPattern = new Uint8Array(searchPatternLength);

 39914         if (!genericRegionMmr) {

 39915           searchPattern[0] = 0xFF;

 39916           searchPattern[1] = 0xAC;

 39917         }

 39918         searchPattern[2] = (genericRegionInfo.height >>> 24) & 0xFF;

 39919         searchPattern[3] = (genericRegionInfo.height >> 16) & 0xFF;

 39920         searchPattern[4] = (genericRegionInfo.height >> 8) & 0xFF;

 39921         searchPattern[5] = genericRegionInfo.height & 0xFF;

 39922         for (i = position, ii = data.length; i < ii; i++) {

 39923           var j = 0;

 39924           while (j < searchPatternLength && searchPattern[j] === data[i + j]) {

 39925             j++;

 39926           }

 39927           if (j == searchPatternLength) {

 39928             segmentHeader.length = i + searchPatternLength;

 39929             break;

 39930           }

 39931         }

 39932         if (segmentHeader.length == 0xFFFFFFFF) {

 39933           error('JBIG2 error: segment end was not found');

 39934         }

 39935       } else {

 39936         error('JBIG2 error: invalid unknown segment length');

 39937       }

 39938     }

 39939     segmentHeader.headerEnd = position;

 39940     return segmentHeader;

 39941   }

 39943   function readSegments(header, data, start, end) {

 39944     var segments = [];

 39945     var position = start;

 39946     while (position < end) {

 39947       var segmentHeader = readSegmentHeader(data, position);

 39948       position = segmentHeader.headerEnd;

 39949       var segment = {

 39950         header: segmentHeader,

 39951         data: data

 39952       };

 39953       if (!header.randomAccess) {

 39954         segment.start = position;

 39955         position += segmentHeader.length;

 39956         segment.end = position;

 39957       }

 39958       segments.push(segment);

 39959       if (segmentHeader.type == 51) {

 39960         break; // end of file is found

 39961       }

 39962     }

 39963     if (header.randomAccess) {

 39964       for (var i = 0, ii = segments.length; i < ii; i++) {

 39965         segments[i].start = position;

 39966         position += segments[i].header.length;

 39967         segments[i].end = position;

 39968       }

 39969     }

 39970     return segments;

 39971   }

 39973   // 7.4.1 Region segment information field

 39974   function readRegionSegmentInformation(data, start) {

 39975     return {

 39976       width: readUint32(data, start),

 39977       height: readUint32(data, start + 4),

 39978       x: readUint32(data, start + 8),

 39979       y: readUint32(data, start + 12),

 39980       combinationOperator: data[start + 16] & 7

 39981     };

 39982   }

 39983   var RegionSegmentInformationFieldLength = 17;

 39985   function processSegment(segment, visitor) {

 39986     var header = segment.header;

 39988     var data = segment.data, position = segment.start, end = segment.end;

 39989     var args, at, i, atLength;

 39990     switch (header.type) {

 39991       case 0: // SymbolDictionary

 39992         // 7.4.2 Symbol dictionary segment syntax

 39993         var dictionary = {};

 39994         var dictionaryFlags = readUint16(data, position); // 7.4.2.1.1

 39995         dictionary.huffman = !!(dictionaryFlags & 1);

 39996         dictionary.refinement = !!(dictionaryFlags & 2);

 39997         dictionary.huffmanDHSelector = (dictionaryFlags >> 2) & 3;

 39998         dictionary.huffmanDWSelector = (dictionaryFlags >> 4) & 3;

 39999         dictionary.bitmapSizeSelector = (dictionaryFlags >> 6) & 1;

 40000         dictionary.aggregationInstancesSelector = (dictionaryFlags >> 7) & 1;

 40001         dictionary.bitmapCodingContextUsed = !!(dictionaryFlags & 256);

 40002         dictionary.bitmapCodingContextRetained = !!(dictionaryFlags & 512);

 40003         dictionary.template = (dictionaryFlags >> 10) & 3;

 40004         dictionary.refinementTemplate = (dictionaryFlags >> 12) & 1;

 40005         position += 2;

 40006         if (!dictionary.huffman) {

 40007           atLength = dictionary.template === 0 ? 4 : 1;

 40008           at = [];

 40009           for (i = 0; i < atLength; i++) {

 40010             at.push({

 40011               x: readInt8(data, position),

 40012               y: readInt8(data, position + 1)

 40013             });

 40014             position += 2;

 40015           }

 40016           dictionary.at = at;

 40017         }

 40018         if (dictionary.refinement && !dictionary.refinementTemplate) {

 40019           at = [];

 40020           for (i = 0; i < 2; i++) {

 40021             at.push({

 40022               x: readInt8(data, position),

 40023               y: readInt8(data, position + 1)

 40024             });

 40025             position += 2;

 40026           }

 40027           dictionary.refinementAt = at;

 40028         }

 40029         dictionary.numberOfExportedSymbols = readUint32(data, position);

 40030         position += 4;

 40031         dictionary.numberOfNewSymbols = readUint32(data, position);

 40032         position += 4;

 40033         args = [dictionary, header.number, header.referredTo,

 40034                 data, position, end];

 40035         break;

 40036       case 6: // ImmediateTextRegion

 40037       case 7: // ImmediateLosslessTextRegion

 40038         var textRegion = {};

 40039         textRegion.info = readRegionSegmentInformation(data, position);

 40040         position += RegionSegmentInformationFieldLength;

 40041         var textRegionSegmentFlags = readUint16(data, position);

 40042         position += 2;

 40043         textRegion.huffman = !!(textRegionSegmentFlags & 1);

 40044         textRegion.refinement = !!(textRegionSegmentFlags & 2);

 40045         textRegion.stripSize = 1 << ((textRegionSegmentFlags >> 2) & 3);

 40046         textRegion.referenceCorner = (textRegionSegmentFlags >> 4) & 3;

 40047         textRegion.transposed = !!(textRegionSegmentFlags & 64);

 40048         textRegion.combinationOperator = (textRegionSegmentFlags >> 7) & 3;

 40049         textRegion.defaultPixelValue = (textRegionSegmentFlags >> 9) & 1;

 40050         textRegion.dsOffset = (textRegionSegmentFlags << 17) >> 27;

 40051         textRegion.refinementTemplate = (textRegionSegmentFlags >> 15) & 1;

 40052         if (textRegion.huffman) {

 40053           var textRegionHuffmanFlags = readUint16(data, position);

 40054           position += 2;

 40055           textRegion.huffmanFS = (textRegionHuffmanFlags) & 3;

 40056           textRegion.huffmanDS = (textRegionHuffmanFlags >> 2) & 3;

 40057           textRegion.huffmanDT = (textRegionHuffmanFlags >> 4) & 3;

 40058           textRegion.huffmanRefinementDW = (textRegionHuffmanFlags >> 6) & 3;

 40059           textRegion.huffmanRefinementDH = (textRegionHuffmanFlags >> 8) & 3;

 40060           textRegion.huffmanRefinementDX = (textRegionHuffmanFlags >> 10) & 3;

 40061           textRegion.huffmanRefinementDY = (textRegionHuffmanFlags >> 12) & 3;

 40062           textRegion.huffmanRefinementSizeSelector =

 40063             !!(textRegionHuffmanFlags & 14);

 40064         }

 40065         if (textRegion.refinement && !textRegion.refinementTemplate) {

 40066           at = [];

 40067           for (i = 0; i < 2; i++) {

 40068             at.push({

 40069               x: readInt8(data, position),

 40070               y: readInt8(data, position + 1)

 40071             });

 40072             position += 2;

 40073           }

 40074           textRegion.refinementAt = at;

 40075         }

 40076         textRegion.numberOfSymbolInstances = readUint32(data, position);

 40077         position += 4;

 40078         // TODO 7.4.3.1.7 Symbol ID Huffman table decoding

 40079         if (textRegion.huffman) {

 40080           error('JBIG2 error: huffman is not supported');

 40081         }

 40082         args = [textRegion, header.referredTo, data, position, end];

 40083         break;

 40084       case 38: // ImmediateGenericRegion

 40085       case 39: // ImmediateLosslessGenericRegion

 40086         var genericRegion = {};

 40087         genericRegion.info = readRegionSegmentInformation(data, position);

 40088         position += RegionSegmentInformationFieldLength;

 40089         var genericRegionSegmentFlags = data[position++];

 40090         genericRegion.mmr = !!(genericRegionSegmentFlags & 1);

 40091         genericRegion.template = (genericRegionSegmentFlags >> 1) & 3;

 40092         genericRegion.prediction = !!(genericRegionSegmentFlags & 8);

 40093         if (!genericRegion.mmr) {

 40094           atLength = genericRegion.template === 0 ? 4 : 1;

 40095           at = [];

 40096           for (i = 0; i < atLength; i++) {

 40097             at.push({

 40098               x: readInt8(data, position),

 40099               y: readInt8(data, position + 1)

 40100             });

 40101             position += 2;

 40102           }

 40103           genericRegion.at = at;

 40104         }

 40105         args = [genericRegion, data, position, end];

 40106         break;

 40107       case 48: // PageInformation

 40108         var pageInfo = {

 40109           width: readUint32(data, position),

 40110           height: readUint32(data, position + 4),

 40111           resolutionX: readUint32(data, position + 8),

 40112           resolutionY: readUint32(data, position + 12)

 40113         };

 40114         if (pageInfo.height == 0xFFFFFFFF) {

 40115           delete pageInfo.height;

 40116         }

 40117         var pageSegmentFlags = data[position + 16];

 40118         var pageStripingInformatiom = readUint16(data, position + 17);

 40119         pageInfo.lossless = !!(pageSegmentFlags & 1);

 40120         pageInfo.refinement = !!(pageSegmentFlags & 2);

 40121         pageInfo.defaultPixelValue = (pageSegmentFlags >> 2) & 1;

 40122         pageInfo.combinationOperator = (pageSegmentFlags >> 3) & 3;

 40123         pageInfo.requiresBuffer = !!(pageSegmentFlags & 32);

 40124         pageInfo.combinationOperatorOverride = !!(pageSegmentFlags & 64);

 40125         args = [pageInfo];

 40126         break;

 40127       case 49: // EndOfPage

 40128         break;

 40129       case 50: // EndOfStripe

 40130         break;

 40131       case 51: // EndOfFile

 40132         break;

 40133       case 62: // 7.4.15 defines 2 extension types which

 40134                // are comments and can be ignored.

 40135         break;

 40136       default:

 40137         error('JBIG2 error: segment type ' + header.typeName + '(' +

 40138               header.type + ') is not implemented');

 40139     }

 40140     var callbackName = 'on' + header.typeName;

 40141     if (callbackName in visitor) {

 40142       visitor[callbackName].apply(visitor, args);

 40143     }

 40144   }

 40146   function processSegments(segments, visitor) {

 40147     for (var i = 0, ii = segments.length; i < ii; i++) {

 40148       processSegment(segments[i], visitor);

 40149     }

 40150   }

 40152   function parseJbig2(data, start, end) {

 40153     var position = start;

 40154     if (data[position] != 0x97 || data[position + 1] != 0x4A ||

 40155         data[position + 2] != 0x42 || data[position + 3] != 0x32 ||

 40156         data[position + 4] != 0x0D || data[position + 5] != 0x0A ||

 40157         data[position + 6] != 0x1A || data[position + 7] != 0x0A) {

 40158       error('JBIG2 error: invalid header');

 40159     }

 40160     var header = {};

 40161     position += 8;

 40162     var flags = data[position++];

 40163     header.randomAccess = !(flags & 1);

 40164     if (!(flags & 2)) {

 40165       header.numberOfPages = readUint32(data, position);

 40166       position += 4;

 40167     }

 40168     var segments = readSegments(header, data, position, end);

 40169     error('Not implemented');

 40170     // processSegments(segments, new SimpleSegmentVisitor());

 40171   }

 40173   function parseJbig2Chunks(chunks) {

 40174     var visitor = new SimpleSegmentVisitor();

 40175     for (var i = 0, ii = chunks.length; i < ii; i++) {

 40176       var chunk = chunks[i];

 40177       var segments = readSegments({}, chunk.data, chunk.start, chunk.end);

 40178       processSegments(segments, visitor);

 40179     }

 40180     return visitor.buffer;

 40181   }

 40183   function SimpleSegmentVisitor() {}

 40185   SimpleSegmentVisitor.prototype = {

 40186     onPageInformation: function SimpleSegmentVisitor_onPageInformation(info) {

 40187       this.currentPageInfo = info;

 40188       var rowSize = (info.width + 7) >> 3;

 40189       var buffer = new Uint8Array(rowSize * info.height);

 40190       // The contents of ArrayBuffers are initialized to 0.

 40191       // Fill the buffer with 0xFF only if info.defaultPixelValue is set

 40192       if (info.defaultPixelValue) {

 40193         for (var i = 0, ii = buffer.length; i < ii; i++) {

 40194           buffer[i] = 0xFF;

 40195         }

 40196       }

 40197       this.buffer = buffer;

 40198     },

 40199     drawBitmap: function SimpleSegmentVisitor_drawBitmap(regionInfo, bitmap) {

 40200       var pageInfo = this.currentPageInfo;

 40201       var width = regionInfo.width, height = regionInfo.height;

 40202       var rowSize = (pageInfo.width + 7) >> 3;

 40203       var combinationOperator = pageInfo.combinationOperatorOverride ?

 40204         regionInfo.combinationOperator : pageInfo.combinationOperator;

 40205       var buffer = this.buffer;

 40206       var mask0 =  128 >> (regionInfo.x & 7);

 40207       var offset0 = regionInfo.y * rowSize + (regionInfo.x >> 3);

 40208       var i, j, mask, offset;

 40209       switch (combinationOperator) {

 40210         case 0: // OR

 40211           for (i = 0; i < height; i++) {

 40212             mask = mask0;

 40213             offset = offset0;

 40214             for (j = 0; j < width; j++) {

 40215               if (bitmap[i][j]) {

 40216                 buffer[offset] |= mask;

 40217               }

 40218               mask >>= 1;

 40219               if (!mask) {

 40220                 mask = 128;

 40221                 offset++;

 40222               }

 40223             }

 40224             offset0 += rowSize;

 40225           }

 40226         break;

 40227         case 2: // XOR

 40228           for (i = 0; i < height; i++) {

 40229             mask = mask0;

 40230             offset = offset0;

 40231             for (j = 0; j < width; j++) {

 40232               if (bitmap[i][j]) {

 40233                 buffer[offset] ^= mask;

 40234               }

 40235               mask >>= 1;

 40236               if (!mask) {

 40237                 mask = 128;

 40238                 offset++;

 40239               }

 40240             }

 40241             offset0 += rowSize;

 40242           }

 40243           break;

 40244         default:

 40245           error('JBIG2 error: operator ' + combinationOperator +

 40246                 ' is not supported');

 40247       }

 40248     },

 40249     onImmediateGenericRegion:

 40250       function SimpleSegmentVisitor_onImmediateGenericRegion(region, data,

 40251                                                              start, end) {

 40252       var regionInfo = region.info;

 40253       var decodingContext = new DecodingContext(data, start, end);

 40254       var bitmap = decodeBitmap(region.mmr, regionInfo.width, regionInfo.height,

 40255                                 region.template, region.prediction, null,

 40256                                 region.at, decodingContext);

 40257       this.drawBitmap(regionInfo, bitmap);

 40258     },

 40259     onImmediateLosslessGenericRegion:

 40260       function SimpleSegmentVisitor_onImmediateLosslessGenericRegion() {

 40261       this.onImmediateGenericRegion.apply(this, arguments);

 40262     },

 40263     onSymbolDictionary:

 40264       function SimpleSegmentVisitor_onSymbolDictionary(dictionary,

 40265                                                        currentSegment,

 40266                                                        referredSegments,

 40267                                                        data, start, end) {

 40268       var huffmanTables;

 40269       if (dictionary.huffman) {

 40270         error('JBIG2 error: huffman is not supported');

 40271       }

 40273       // Combines exported symbols from all referred segments

 40274       var symbols = this.symbols;

 40275       if (!symbols) {

 40276         this.symbols = symbols = {};

 40277       }

 40279       var inputSymbols = [];

 40280       for (var i = 0, ii = referredSegments.length; i < ii; i++) {

 40281         inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]);

 40282       }

 40284       var decodingContext = new DecodingContext(data, start, end);

 40285       symbols[currentSegment] = decodeSymbolDictionary(dictionary.huffman,

 40286         dictionary.refinement, inputSymbols, dictionary.numberOfNewSymbols,

 40287         dictionary.numberOfExportedSymbols, huffmanTables,

 40288         dictionary.template, dictionary.at,

 40289         dictionary.refinementTemplate, dictionary.refinementAt,

 40290         decodingContext);

 40291     },

 40292     onImmediateTextRegion:

 40293       function SimpleSegmentVisitor_onImmediateTextRegion(region,

 40294                                                           referredSegments,

 40295                                                           data, start, end) {

 40296       var regionInfo = region.info;

 40297       var huffmanTables;

 40299       // Combines exported symbols from all referred segments

 40300       var symbols = this.symbols;

 40301       var inputSymbols = [];

 40302       for (var i = 0, ii = referredSegments.length; i < ii; i++) {

 40303         inputSymbols = inputSymbols.concat(symbols[referredSegments[i]]);

 40304       }

 40305       var symbolCodeLength = log2(inputSymbols.length);

 40307       var decodingContext = new DecodingContext(data, start, end);

 40308       var bitmap = decodeTextRegion(region.huffman, region.refinement,

 40309         regionInfo.width, regionInfo.height, region.defaultPixelValue,

 40310         region.numberOfSymbolInstances, region.stripSize, inputSymbols,

 40311         symbolCodeLength, region.transposed, region.dsOffset,

 40312         region.referenceCorner, region.combinationOperator, huffmanTables,

 40313         region.refinementTemplate, region.refinementAt, decodingContext);

 40314       this.drawBitmap(regionInfo, bitmap);

 40315     },

 40316     onImmediateLosslessTextRegion:

 40317       function SimpleSegmentVisitor_onImmediateLosslessTextRegion() {

 40318       this.onImmediateTextRegion.apply(this, arguments);

 40319     }

 40320   };

 40322   function Jbig2Image() {}

 40324   Jbig2Image.prototype = {

 40325     parseChunks: function Jbig2Image_parseChunks(chunks) {

 40326       return parseJbig2Chunks(chunks);

 40327     }

 40328   };

 40330   return Jbig2Image;

 40331 })();

 40334 var bidi = PDFJS.bidi = (function bidiClosure() {

 40335   // Character types for symbols from 0000 to 00FF.

 40336   var baseTypes = [

 40337     'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'S', 'B', 'S', 'WS',

 40338     'B', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',

 40339     'BN', 'BN', 'B', 'B', 'B', 'S', 'WS', 'ON', 'ON', 'ET', 'ET', 'ET', 'ON',

 40340     'ON', 'ON', 'ON', 'ON', 'ON', 'CS', 'ON', 'CS', 'ON', 'EN', 'EN', 'EN',

 40341     'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'EN', 'ON', 'ON', 'ON', 'ON', 'ON',

 40342     'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40343     'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'ON', 'ON',

 40344     'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40345     'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40346     'L', 'ON', 'ON', 'ON', 'ON', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'B', 'BN',

 40347     'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',

 40348     'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN', 'BN',

 40349     'BN', 'CS', 'ON', 'ET', 'ET', 'ET', 'ET', 'ON', 'ON', 'ON', 'ON', 'L', 'ON',

 40350     'ON', 'ON', 'ON', 'ON', 'ET', 'ET', 'EN', 'EN', 'ON', 'L', 'ON', 'ON', 'ON',

 40351     'EN', 'L', 'ON', 'ON', 'ON', 'ON', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40352     'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40353     'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40354     'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L',

 40355     'L', 'L', 'L', 'ON', 'L', 'L', 'L', 'L', 'L', 'L', 'L', 'L'

 40356   ];

 40358   // Character types for symbols from 0600 to 06FF

 40359   var arabicTypes = [

 40360     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40361     'CS', 'AL', 'ON', 'ON', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL',

 40362     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40363     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40364     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40365     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40366     'AL', 'AL', 'AL', 'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM',

 40367     'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL',

 40368     'AL', 'AL', 'AL', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN', 'AN',

 40369     'AN', 'ET', 'AN', 'AN', 'AL', 'AL', 'AL', 'NSM', 'AL', 'AL', 'AL', 'AL',

 40370     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40371     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40372     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40373     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40374     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40375     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40376     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40377     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40378     'AL', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM',

 40379     'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'NSM', 'ON', 'NSM',

 40380     'NSM', 'NSM', 'NSM', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL',

 40381     'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL', 'AL'

 40382   ];

 40384   function isOdd(i) {

 40385     return (i & 1) !== 0;

 40386   }

 40388   function isEven(i) {

 40389     return (i & 1) === 0;

 40390   }

 40392   function findUnequal(arr, start, value) {

 40393     for (var j = start, jj = arr.length; j < jj; ++j) {

 40394       if (arr[j] != value) {

 40395         return j;

 40396       }

 40397     }

 40398     return j;

 40399   }

 40401   function setValues(arr, start, end, value) {

 40402     for (var j = start; j < end; ++j) {

 40403       arr[j] = value;

 40404     }

 40405   }

 40407   function reverseValues(arr, start, end) {

 40408     for (var i = start, j = end - 1; i < j; ++i, --j) {

 40409       var temp = arr[i];

 40410       arr[i] = arr[j];

 40411       arr[j] = temp;

 40412     }

 40413   }

 40415   function createBidiText(str, isLTR, vertical) {

 40416     return {

 40417       str: str,

 40418       dir: (vertical ? 'ttb' : (isLTR ? 'ltr' : 'rtl'))

 40419     };

 40420   }

 40422   // These are used in bidi(), which is called frequently. We re-use them on

 40423   // each call to avoid unnecessary allocations.

 40424   var chars = [];

 40425   var types = [];

 40427   function bidi(str, startLevel, vertical) {

 40428     var isLTR = true;

 40429     var strLength = str.length;

 40430     if (strLength === 0 || vertical) {

 40431       return createBidiText(str, isLTR, vertical);

 40432     }

 40434     // Get types and fill arrays

 40435     chars.length = 0;

 40436     types.length = 0;

 40437     var numBidi = 0;

 40439     var i, ii;

 40440     for (i = 0; i < strLength; ++i) {

 40441       chars[i] = str.charAt(i);

 40443       var charCode = str.charCodeAt(i);

 40444       var charType = 'L';

 40445       if (charCode <= 0x00ff) {

 40446         charType = baseTypes[charCode];

 40447       } else if (0x0590 <= charCode && charCode <= 0x05f4) {

 40448         charType = 'R';

 40449       } else if (0x0600 <= charCode && charCode <= 0x06ff) {

 40450         charType = arabicTypes[charCode & 0xff];

 40451       } else if (0x0700 <= charCode && charCode <= 0x08AC) {

 40452         charType = 'AL';

 40453       }

 40454       if (charType == 'R' || charType == 'AL' || charType == 'AN') {

 40455         numBidi++;

 40456       }

 40457       types[i] = charType;

 40458     }

 40460     // Detect the bidi method

 40461     // - If there are no rtl characters then no bidi needed

 40462     // - If less than 30% chars are rtl then string is primarily ltr

 40463     // - If more than 30% chars are rtl then string is primarily rtl

 40464     if (numBidi === 0) {

 40465       isLTR = true;

 40466       return createBidiText(str, isLTR);

 40467     }

 40469     if (startLevel == -1) {

 40470       if ((strLength / numBidi) < 0.3) {

 40471         isLTR = true;

 40472         startLevel = 0;

 40473       } else {

 40474         isLTR = false;

 40475         startLevel = 1;

 40476       }

 40477     }

 40479     var levels = [];

 40480     for (i = 0; i < strLength; ++i) {

 40481       levels[i] = startLevel;

 40482     }

 40484     /*

 40485      X1-X10: skip most of this, since we are NOT doing the embeddings.

 40486      */

 40487     var e = (isOdd(startLevel) ? 'R' : 'L');

 40488     var sor = e;

 40489     var eor = sor;

 40491     /*

 40492      W1. Examine each non-spacing mark (NSM) in the level run, and change the

 40493      type of the NSM to the type of the previous character. If the NSM is at the

 40494      start of the level run, it will get the type of sor.

 40495      */

 40496     var lastType = sor;

 40497     for (i = 0; i < strLength; ++i) {

 40498       if (types[i] == 'NSM') {

 40499         types[i] = lastType;

 40500       } else {

 40501         lastType = types[i];

 40502       }

 40503     }

 40505     /*

 40506      W2. Search backwards from each instance of a European number until the

 40507      first strong type (R, L, AL, or sor) is found.  If an AL is found, change

 40508      the type of the European number to Arabic number.

 40509      */

 40510     lastType = sor;

 40511     var t;

 40512     for (i = 0; i < strLength; ++i) {

 40513       t = types[i];

 40514       if (t == 'EN') {

 40515         types[i] = (lastType == 'AL') ? 'AN' : 'EN';

 40516       } else if (t == 'R' || t == 'L' || t == 'AL') {

 40517         lastType = t;

 40518       }

 40519     }

 40521     /*

 40522      W3. Change all ALs to R.

 40523      */

 40524     for (i = 0; i < strLength; ++i) {

 40525       t = types[i];

 40526       if (t == 'AL') {

 40527         types[i] = 'R';

 40528       }

 40529     }

 40531     /*

 40532      W4. A single European separator between two European numbers changes to a

 40533      European number. A single common separator between two numbers of the same

 40534      type changes to that type:

 40535      */

 40536     for (i = 1; i < strLength - 1; ++i) {

 40537       if (types[i] == 'ES' && types[i - 1] == 'EN' && types[i + 1] == 'EN') {

 40538         types[i] = 'EN';

 40539       }

 40540       if (types[i] == 'CS' && (types[i - 1] == 'EN' || types[i - 1] == 'AN') &&

 40541           types[i + 1] == types[i - 1]) {

 40542         types[i] = types[i - 1];

 40543       }

 40544     }

 40546     /*

 40547      W5. A sequence of European terminators adjacent to European numbers changes

 40548      to all European numbers:

 40549      */

 40550     for (i = 0; i < strLength; ++i) {

 40551       if (types[i] == 'EN') {

 40552         // do before

 40553         var j;

 40554         for (j = i - 1; j >= 0; --j) {

 40555           if (types[j] != 'ET') {

 40556             break;

 40557           }

 40558           types[j] = 'EN';

 40559         }

 40560         // do after

 40561         for (j = i + 1; j < strLength; --j) {

 40562           if (types[j] != 'ET') {

 40563             break;

 40564           }

 40565           types[j] = 'EN';

 40566         }

 40567       }

 40568     }

 40570     /*

 40571      W6. Otherwise, separators and terminators change to Other Neutral:

 40572      */

 40573     for (i = 0; i < strLength; ++i) {

 40574       t = types[i];

 40575       if (t == 'WS' || t == 'ES' || t == 'ET' || t == 'CS') {

 40576         types[i] = 'ON';

 40577       }

 40578     }

 40580     /*

 40581      W7. Search backwards from each instance of a European number until the

 40582      first strong type (R, L, or sor) is found. If an L is found,  then change

 40583      the type of the European number to L.

 40584      */

 40585     lastType = sor;

 40586     for (i = 0; i < strLength; ++i) {

 40587       t = types[i];

 40588       if (t == 'EN') {

 40589         types[i] = ((lastType == 'L') ? 'L' : 'EN');

 40590       } else if (t == 'R' || t == 'L') {

 40591         lastType = t;

 40592       }

 40593     }

 40595     /*

 40596      N1. A sequence of neutrals takes the direction of the surrounding strong

 40597      text if the text on both sides has the same direction. European and Arabic

 40598      numbers are treated as though they were R. Start-of-level-run (sor) and

 40599      end-of-level-run (eor) are used at level run boundaries.

 40600      */

 40601     for (i = 0; i < strLength; ++i) {

 40602       if (types[i] == 'ON') {

 40603         var end = findUnequal(types, i + 1, 'ON');

 40604         var before = sor;

 40605         if (i > 0) {

 40606           before = types[i - 1];

 40607         }

 40609         var after = eor;

 40610         if (end + 1 < strLength) {

 40611           after = types[end + 1];

 40612         }

 40613         if (before != 'L') {

 40614           before = 'R';

 40615         }

 40616         if (after != 'L') {

 40617           after = 'R';

 40618         }

 40619         if (before == after) {

 40620           setValues(types, i, end, before);

 40621         }

 40622         i = end - 1; // reset to end (-1 so next iteration is ok)

 40623       }

 40624     }

 40626     /*

 40627      N2. Any remaining neutrals take the embedding direction.

 40628      */

 40629     for (i = 0; i < strLength; ++i) {

 40630       if (types[i] == 'ON') {

 40631         types[i] = e;

 40632       }

 40633     }

 40635     /*

 40636      I1. For all characters with an even (left-to-right) embedding direction,

 40637      those of type R go up one level and those of type AN or EN go up two

 40638      levels.

 40639      I2. For all characters with an odd (right-to-left) embedding direction,

 40640      those of type L, EN or AN go up one level.

 40641      */

 40642     for (i = 0; i < strLength; ++i) {

 40643       t = types[i];

 40644       if (isEven(levels[i])) {

 40645         if (t == 'R') {

 40646           levels[i] += 1;

 40647         } else if (t == 'AN' || t == 'EN') {

 40648           levels[i] += 2;

 40649         }

 40650       } else { // isOdd

 40651         if (t == 'L' || t == 'AN' || t == 'EN') {

 40652           levels[i] += 1;

 40653         }

 40654       }

 40655     }

 40657     /*

 40658      L1. On each line, reset the embedding level of the following characters to

 40659      the paragraph embedding level:

 40661      segment separators,

 40662      paragraph separators,

 40663      any sequence of whitespace characters preceding a segment separator or

 40664      paragraph separator, and any sequence of white space characters at the end

 40665      of the line.

 40666      */

 40668     // don't bother as text is only single line

 40670     /*

 40671      L2. From the highest level found in the text to the lowest odd level on

 40672      each line, reverse any contiguous sequence of characters that are at that

 40673      level or higher.

 40674      */

 40676     // find highest level & lowest odd level

 40677     var highestLevel = -1;

 40678     var lowestOddLevel = 99;

 40679     var level;

 40680     for (i = 0, ii = levels.length; i < ii; ++i) {

 40681       level = levels[i];

 40682       if (highestLevel < level) {

 40683         highestLevel = level;

 40684       }

 40685       if (lowestOddLevel > level && isOdd(level)) {

 40686         lowestOddLevel = level;

 40687       }

 40688     }

 40690     // now reverse between those limits

 40691     for (level = highestLevel; level >= lowestOddLevel; --level) {

 40692       // find segments to reverse

 40693       var start = -1;

 40694       for (i = 0, ii = levels.length; i < ii; ++i) {

 40695         if (levels[i] < level) {

 40696           if (start >= 0) {

 40697             reverseValues(chars, start, i);

 40698             start = -1;

 40699           }

 40700         } else if (start < 0) {

 40701           start = i;

 40702         }

 40703       }

 40704       if (start >= 0) {

 40705         reverseValues(chars, start, levels.length);

 40706       }

 40707     }

 40709     /*

 40710      L3. Combining marks applied to a right-to-left base character will at this

 40711      point precede their base character. If the rendering engine expects them to

 40712      follow the base characters in the final display process, then the ordering

 40713      of the marks and the base character must be reversed.

 40714      */

 40716     // don't bother for now

 40718     /*

 40719      L4. A character that possesses the mirrored property as specified by

 40720      Section 4.7, Mirrored, must be depicted by a mirrored glyph if the resolved

 40721      directionality of that character is R.

 40722      */

 40724     // don't mirror as characters are already mirrored in the pdf

 40726     // Finally, return string

 40727     var result = '';

 40728     for (i = 0, ii = chars.length; i < ii; ++i) {

 40729       var ch = chars[i];

 40730       if (ch != '<' && ch != '>') {

 40731         result += ch;

 40732       }

 40733     }

 40734     return createBidiText(result, isLTR);

 40735   }

 40737   return bidi;

 40738 })();

 40741 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 40742 /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

 40744 /* Copyright 2014 Opera Software ASA

 40745  *

 40746  * Licensed under the Apache License, Version 2.0 (the "License");

 40747  * you may not use this file except in compliance with the License.

 40748  * You may obtain a copy of the License at

 40749  *

 40750  *     http://www.apache.org/licenses/LICENSE-2.0

 40751  *

 40752  * Unless required by applicable law or agreed to in writing, software

 40753  * distributed under the License is distributed on an "AS IS" BASIS,

 40754  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 40755  * See the License for the specific language governing permissions and

 40756  * limitations under the License.

 40757  *

 40758  *

 40759  * Based on https://code.google.com/p/smhasher/wiki/MurmurHash3.

 40760  * Hashes roughly 100 KB per millisecond on i7 3.4 GHz.

 40761  */

 40762 /* globals Uint32ArrayView */

 40764 'use strict';

 40766 var MurmurHash3_64 = (function MurmurHash3_64Closure (seed) {

 40767   // Workaround for missing math precison in JS.

 40768   var MASK_HIGH = 0xffff0000;

 40769   var MASK_LOW = 0xffff;

 40771   function MurmurHash3_64 (seed) {

 40772     var SEED = 0xc3d2e1f0;

 40773     this.h1 = seed ? seed & 0xffffffff : SEED;

 40774     this.h2 = seed ? seed & 0xffffffff : SEED;

 40775   }

 40777   MurmurHash3_64.prototype = {

 40778     update: function MurmurHash3_64_update(input) {

 40779       var useUint32ArrayView = false;

 40780       var i;

 40781       if (typeof input == 'string') {

 40782         var data = new Uint8Array(input.length * 2);

 40783         var length = 0;

 40784         for (i = 0; i < input.length; i++) {

 40785           var code = input.charCodeAt(i);

 40786           if (code <= 0xff) {

 40787             data[length++] = code;

 40788           }

 40789           else {

 40790             data[length++] = code >>> 8;

 40791             data[length++] = code & 0xff;

 40792           }

 40793         }

 40794       } else if (input instanceof Uint8Array) {

 40795         data = input;

 40796         length = data.length;

 40797       } else if (typeof input === 'object' && ('length' in input)) {

 40798         // processing regular arrays as well, e.g. for IE9

 40799         data = input;

 40800         length = data.length;

 40801         useUint32ArrayView = true;

 40802       } else {

 40803         throw new Error('Wrong data format in MurmurHash3_64_update. ' +

 40804                         'Input must be a string or array.');

 40805       }

 40807       var blockCounts = length >> 2;

 40808       var tailLength = length - blockCounts * 4;

 40809       // we don't care about endianness here

 40810       var dataUint32 = useUint32ArrayView ?

 40811         new Uint32ArrayView(data, blockCounts) :

 40812         new Uint32Array(data.buffer, 0, blockCounts);

 40813       var k1 = 0;

 40814       var k2 = 0;

 40815       var h1 = this.h1;

 40816       var h2 = this.h2;

 40817       var C1 = 0xcc9e2d51;

 40818       var C2 = 0x1b873593;

 40819       var C1_LOW = C1 & MASK_LOW;

 40820       var C2_LOW = C2 & MASK_LOW;

 40822       for (i = 0; i < blockCounts; i++) {

 40823         if (i & 1) {

 40824           k1 = dataUint32[i];

 40825           k1 = (k1 * C1 & MASK_HIGH) | (k1 * C1_LOW & MASK_LOW);

 40826           k1 = k1 << 15 | k1 >>> 17;

 40827           k1 = (k1 * C2 & MASK_HIGH) | (k1 * C2_LOW & MASK_LOW);

 40828           h1 ^= k1;

 40829           h1 = h1 << 13 | h1 >>> 19;

 40830           h1 = h1 * 5 + 0xe6546b64;

 40831         } else {

 40832           k2 = dataUint32[i];

 40833           k2 = (k2 * C1 & MASK_HIGH) | (k2 * C1_LOW & MASK_LOW);

 40834           k2 = k2 << 15 | k2 >>> 17;

 40835           k2 = (k2 * C2 & MASK_HIGH) | (k2 * C2_LOW & MASK_LOW);

 40836           h2 ^= k2;

 40837           h2 = h2 << 13 | h2 >>> 19;

 40838           h2 = h2 * 5 + 0xe6546b64;

 40839         }

 40840       }

 40842       k1 = 0;

 40844       switch (tailLength) {

 40845         case 3:

 40846           k1 ^= data[blockCounts * 4 + 2] << 16;

 40847           /* falls through */

 40848         case 2:

 40849           k1 ^= data[blockCounts * 4 + 1] << 8;

 40850           /* falls through */

 40851         case 1:

 40852           k1 ^= data[blockCounts * 4];

 40853           /* falls through */

 40854         k1 = (k1 * C1 & MASK_HIGH) | (k1 * C1_LOW & MASK_LOW);

 40855         k1 = k1 << 15 | k1 >>> 17;

 40856         k1 = (k1 * C2 & MASK_HIGH) | (k1 * C2_LOW & MASK_LOW);

 40857         if (blockCounts & 1) {

 40858           h1 ^= k1;

 40859         } else {

 40860           h2 ^= k1;

 40861         }

 40862       }

 40864       this.h1 = h1;

 40865       this.h2 = h2;

 40866       return this;

 40867     },

 40869     hexdigest: function MurmurHash3_64_hexdigest () {

 40870       var h1 = this.h1;

 40871       var h2 = this.h2;

 40873       h1 ^= h2 >>> 1;

 40874       h1 = (h1 * 0xed558ccd & MASK_HIGH) | (h1 * 0x8ccd & MASK_LOW);

 40875       h2 = (h2 * 0xff51afd7 & MASK_HIGH) |

 40876            (((h2 << 16 | h1 >>> 16) * 0xafd7ed55 & MASK_HIGH) >>> 16);

 40877       h1 ^= h2 >>> 1;

 40878       h1 = (h1 * 0x1a85ec53 & MASK_HIGH) | (h1 * 0xec53 & MASK_LOW);

 40879       h2 = (h2 * 0xc4ceb9fe & MASK_HIGH) |

 40880            (((h2 << 16 | h1 >>> 16) * 0xb9fe1a85 & MASK_HIGH) >>> 16);

 40881       h1 ^= h2 >>> 1;

 40883       for (var i = 0, arr = [h1, h2], str = ''; i < arr.length; i++) {

 40884         var hex = (arr[i] >>> 0).toString(16);

 40885         while (hex.length < 8) {

 40886           hex = '0' + hex;

 40887         }

 40888         str += hex;

 40889       }

 40891       return str;

 40892     }

 40893   };

 40895   return MurmurHash3_64;

 40896 })();

 40897 /* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /

 40898 /* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */

 40899 /*

 40900    Copyright 2011 notmasteryet

 40902    Licensed under the Apache License, Version 2.0 (the "License");

 40903    you may not use this file except in compliance with the License.

 40904    You may obtain a copy of the License at

 40906        http://www.apache.org/licenses/LICENSE-2.0

 40908    Unless required by applicable law or agreed to in writing, software

 40909    distributed under the License is distributed on an "AS IS" BASIS,

 40910    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 40911    See the License for the specific language governing permissions and

 40912    limitations under the License.

 40913 */

 40915 // - The JPEG specification can be found in the ITU CCITT Recommendation T.81

 40916 //   (www.w3.org/Graphics/JPEG/itu-t81.pdf)

 40917 // - The JFIF specification can be found in the JPEG File Interchange Format

 40918 //   (www.w3.org/Graphics/JPEG/jfif3.pdf)

 40919 // - The Adobe Application-Specific JPEG markers in the Supporting the DCT Filters

 40920 //   in PostScript Level 2, Technical Note #5116

 40921 //   (partners.adobe.com/public/developer/en/ps/sdk/5116.DCT_Filter.pdf)

 40923 var JpegImage = (function jpegImage() {

 40924   "use strict";

 40925   var dctZigZag = new Int32Array([

 40926      0,

 40927      1,  8,

 40928     16,  9,  2,

 40929      3, 10, 17, 24,

 40930     32, 25, 18, 11, 4,

 40931      5, 12, 19, 26, 33, 40,

 40932     48, 41, 34, 27, 20, 13,  6,

 40933      7, 14, 21, 28, 35, 42, 49, 56,

 40934     57, 50, 43, 36, 29, 22, 15,

 40935     23, 30, 37, 44, 51, 58,

 40936     59, 52, 45, 38, 31,

 40937     39, 46, 53, 60,

 40938     61, 54, 47,

 40939     55, 62,

 40940     63

 40941   ]);

 40943   var dctCos1  =  4017   // cos(pi/16)

 40944   var dctSin1  =   799   // sin(pi/16)

 40945   var dctCos3  =  3406   // cos(3*pi/16)

 40946   var dctSin3  =  2276   // sin(3*pi/16)

 40947   var dctCos6  =  1567   // cos(6*pi/16)

 40948   var dctSin6  =  3784   // sin(6*pi/16)

 40949   var dctSqrt2 =  5793   // sqrt(2)

 40950   var dctSqrt1d2 = 2896  // sqrt(2) / 2

 40952   function constructor() {

 40953   }

 40955   function buildHuffmanTable(codeLengths, values) {

 40956     var k = 0, code = [], i, j, length = 16;

 40957     while (length > 0 && !codeLengths[length - 1])

 40958       length--;

 40959     code.push({children: [], index: 0});

 40960     var p = code[0], q;

 40961     for (i = 0; i < length; i++) {

 40962       for (j = 0; j < codeLengths[i]; j++) {

 40963         p = code.pop();

 40964         p.children[p.index] = values[k];

 40965         while (p.index > 0) {

 40966           p = code.pop();

 40967         }

 40968         p.index++;

 40969         code.push(p);

 40970         while (code.length <= i) {

 40971           code.push(q = {children: [], index: 0});

 40972           p.children[p.index] = q.children;

 40973           p = q;

 40974         }

 40975         k++;

 40976       }

 40977       if (i + 1 < length) {

 40978         // p here points to last code

 40979         code.push(q = {children: [], index: 0});

 40980         p.children[p.index] = q.children;

 40981         p = q;

 40982       }

 40983     }

 40984     return code[0].children;

 40985   }

 40987   function getBlockBufferOffset(component, row, col) {

 40988     return 64 * ((component.blocksPerLine + 1) * row + col);

 40989   }

 40991   function decodeScan(data, offset,

 40992                       frame, components, resetInterval,

 40993                       spectralStart, spectralEnd,

 40994                       successivePrev, successive) {

 40995     var precision = frame.precision;

 40996     var samplesPerLine = frame.samplesPerLine;

 40997     var scanLines = frame.scanLines;

 40998     var mcusPerLine = frame.mcusPerLine;

 40999     var progressive = frame.progressive;

 41000     var maxH = frame.maxH, maxV = frame.maxV;

 41002     var startOffset = offset, bitsData = 0, bitsCount = 0;

 41004     function readBit() {

 41005       if (bitsCount > 0) {

 41006         bitsCount--;

 41007         return (bitsData >> bitsCount) & 1;

 41008       }

 41009       bitsData = data[offset++];

 41010       if (bitsData == 0xFF) {

 41011         var nextByte = data[offset++];

 41012         if (nextByte) {

 41013           throw "unexpected marker: " + ((bitsData << 8) | nextByte).toString(16);

 41014         }

 41015         // unstuff 0

 41016       }

 41017       bitsCount = 7;

 41018       return bitsData >>> 7;

 41019     }

 41021     function decodeHuffman(tree) {

 41022       var node = tree;

 41023       var bit;

 41024       while ((bit = readBit()) !== null) {

 41025         node = node[bit];

 41026         if (typeof node === 'number')

 41027           return node;

 41028         if (typeof node !== 'object')

 41029           throw "invalid huffman sequence";

 41030       }

 41031       return null;

 41032     }

 41034     function receive(length) {

 41035       var n = 0;

 41036       while (length > 0) {

 41037         var bit = readBit();

 41038         if (bit === null) return;

 41039         n = (n << 1) | bit;

 41040         length--;

 41041       }

 41042       return n;

 41043     }

 41045     function receiveAndExtend(length) {

 41046       var n = receive(length);

 41047       if (n >= 1 << (length - 1))

 41048         return n;

 41049       return n + (-1 << length) + 1;

 41050     }

 41052     function decodeBaseline(component, offset) {

 41053       var t = decodeHuffman(component.huffmanTableDC);

 41054       var diff = t === 0 ? 0 : receiveAndExtend(t);

 41055       component.blockData[offset] = (component.pred += diff);

 41056       var k = 1;

 41057       while (k < 64) {

 41058         var rs = decodeHuffman(component.huffmanTableAC);

 41059         var s = rs & 15, r = rs >> 4;

 41060         if (s === 0) {

 41061           if (r < 15)

 41062             break;

 41063           k += 16;

 41064           continue;

 41065         }

 41066         k += r;

 41067         var z = dctZigZag[k];

 41068         component.blockData[offset + z] = receiveAndExtend(s);

 41069         k++;

 41070       }

 41071     }

 41073     function decodeDCFirst(component, offset) {

 41074       var t = decodeHuffman(component.huffmanTableDC);

 41075       var diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);

 41076       component.blockData[offset] = (component.pred += diff);

 41077     }

 41079     function decodeDCSuccessive(component, offset) {

 41080       component.blockData[offset] |= readBit() << successive;

 41081     }

 41083     var eobrun = 0;

 41084     function decodeACFirst(component, offset) {

 41085       if (eobrun > 0) {

 41086         eobrun--;

 41087         return;

 41088       }

 41089       var k = spectralStart, e = spectralEnd;

 41090       while (k <= e) {

 41091         var rs = decodeHuffman(component.huffmanTableAC);

 41092         var s = rs & 15, r = rs >> 4;

 41093         if (s === 0) {

 41094           if (r < 15) {

 41095             eobrun = receive(r) + (1 << r) - 1;

 41096             break;

 41097           }

 41098           k += 16;

 41099           continue;

 41100         }

 41101         k += r;

 41102         var z = dctZigZag[k];

 41103         component.blockData[offset + z] = receiveAndExtend(s) * (1 << successive);

 41104         k++;

 41105       }

 41106     }

 41108     var successiveACState = 0, successiveACNextValue;

 41109     function decodeACSuccessive(component, offset) {

 41110       var k = spectralStart, e = spectralEnd, r = 0;

 41111       while (k <= e) {

 41112         var z = dctZigZag[k];

 41113         switch (successiveACState) {

 41114         case 0: // initial state

 41115           var rs = decodeHuffman(component.huffmanTableAC);

 41116           var s = rs & 15, r = rs >> 4;

 41117           if (s === 0) {

 41118             if (r < 15) {

 41119               eobrun = receive(r) + (1 << r);

 41120               successiveACState = 4;

 41121             } else {

 41122               r = 16;

 41123               successiveACState = 1;

 41124             }

 41125           } else {

 41126             if (s !== 1)

 41127               throw "invalid ACn encoding";

 41128             successiveACNextValue = receiveAndExtend(s);

 41129             successiveACState = r ? 2 : 3;

 41130           }

 41131           continue;

 41132         case 1: // skipping r zero items

 41133         case 2:

 41134           if (component.blockData[offset + z]) {

 41135             component.blockData[offset + z] += (readBit() << successive);

 41136           } else {

 41137             r--;

 41138             if (r === 0)

 41139               successiveACState = successiveACState == 2 ? 3 : 0;

 41140           }

 41141           break;

 41142         case 3: // set value for a zero item

 41143           if (component.blockData[offset + z]) {

 41144             component.blockData[offset + z] += (readBit() << successive);

 41145           } else {

 41146             component.blockData[offset + z] = successiveACNextValue << successive;

 41147             successiveACState = 0;

 41148           }

 41149           break;

 41150         case 4: // eob

 41151           if (component.blockData[offset + z]) {

 41152             component.blockData[offset + z] += (readBit() << successive);

 41153           }

 41154           break;

 41155         }

 41156         k++;

 41157       }

 41158       if (successiveACState === 4) {

 41159         eobrun--;

 41160         if (eobrun === 0)

 41161           successiveACState = 0;

 41162       }

 41163     }

 41165     function decodeMcu(component, decode, mcu, row, col) {

 41166       var mcuRow = (mcu / mcusPerLine) | 0;

 41167       var mcuCol = mcu % mcusPerLine;

 41168       var blockRow = mcuRow * component.v + row;

 41169       var blockCol = mcuCol * component.h + col;

 41170       var offset = getBlockBufferOffset(component, blockRow, blockCol);

 41171       decode(component, offset);

 41172     }

 41174     function decodeBlock(component, decode, mcu) {

 41175       var blockRow = (mcu / component.blocksPerLine) | 0;

 41176       var blockCol = mcu % component.blocksPerLine;

 41177       var offset = getBlockBufferOffset(component, blockRow, blockCol);

 41178       decode(component, offset);

 41179     }

 41181     var componentsLength = components.length;

 41182     var component, i, j, k, n;

 41183     var decodeFn;

 41184     if (progressive) {

 41185       if (spectralStart === 0)

 41186         decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;

 41187       else

 41188         decodeFn = successivePrev === 0 ? decodeACFirst : decodeACSuccessive;

 41189     } else {

 41190       decodeFn = decodeBaseline;

 41191     }

 41193     var mcu = 0, marker;

 41194     var mcuExpected;

 41195     if (componentsLength == 1) {

 41196       mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;

 41197     } else {

 41198       mcuExpected = mcusPerLine * frame.mcusPerColumn;

 41199     }

 41200     if (!resetInterval) {

 41201       resetInterval = mcuExpected;

 41202     }

 41204     var h, v;

 41205     while (mcu < mcuExpected) {

 41206       // reset interval stuff

 41207       for (i = 0; i < componentsLength; i++) {

 41208         components[i].pred = 0;

 41209       }

 41210       eobrun = 0;

 41212       if (componentsLength == 1) {

 41213         component = components[0];

 41214         for (n = 0; n < resetInterval; n++) {

 41215           decodeBlock(component, decodeFn, mcu);

 41216           mcu++;

 41217         }

 41218       } else {

 41219         for (n = 0; n < resetInterval; n++) {

 41220           for (i = 0; i < componentsLength; i++) {

 41221             component = components[i];

 41222             h = component.h;

 41223             v = component.v;

 41224             for (j = 0; j < v; j++) {

 41225               for (k = 0; k < h; k++) {

 41226                 decodeMcu(component, decodeFn, mcu, j, k);

 41227               }

 41228             }

 41229           }

 41230           mcu++;

 41231         }

 41232       }

 41234       // find marker

 41235       bitsCount = 0;

 41236       marker = (data[offset] << 8) | data[offset + 1];

 41237       if (marker <= 0xFF00) {

 41238         throw "marker was not found";

 41239       }

 41241       if (marker >= 0xFFD0 && marker <= 0xFFD7) { // RSTx

 41242         offset += 2;

 41243       } else {

 41244         break;

 41245       }

 41246     }

 41248     return offset - startOffset;

 41249   }

 41251   // A port of poppler's IDCT method which in turn is taken from:

 41252   //   Christoph Loeffler, Adriaan Ligtenberg, George S. Moschytz,

 41253   //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",

 41254   //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,

 41255   //   988-991.

 41256   function quantizeAndInverse(component, blockBufferOffset, p) {

 41257     var qt = component.quantizationTable;

 41258     var v0, v1, v2, v3, v4, v5, v6, v7, t;

 41259     var i;

 41261     // dequant

 41262     for (i = 0; i < 64; i++) {

 41263       p[i] = component.blockData[blockBufferOffset + i] * qt[i];

 41264     }

 41266     // inverse DCT on rows

 41267     for (i = 0; i < 8; ++i) {

 41268       var row = 8 * i;

 41270       // check for all-zero AC coefficients

 41271       if (p[1 + row] == 0 && p[2 + row] == 0 && p[3 + row] == 0 &&

 41272           p[4 + row] == 0 && p[5 + row] == 0 && p[6 + row] == 0 &&

 41273           p[7 + row] == 0) {

 41274         t = (dctSqrt2 * p[0 + row] + 512) >> 10;

 41275         p[0 + row] = t;

 41276         p[1 + row] = t;

 41277         p[2 + row] = t;

 41278         p[3 + row] = t;

 41279         p[4 + row] = t;

 41280         p[5 + row] = t;

 41281         p[6 + row] = t;

 41282         p[7 + row] = t;

 41283         continue;

 41284       }

 41286       // stage 4

 41287       v0 = (dctSqrt2 * p[0 + row] + 128) >> 8;

 41288       v1 = (dctSqrt2 * p[4 + row] + 128) >> 8;

 41289       v2 = p[2 + row];

 41290       v3 = p[6 + row];

 41291       v4 = (dctSqrt1d2 * (p[1 + row] - p[7 + row]) + 128) >> 8;

 41292       v7 = (dctSqrt1d2 * (p[1 + row] + p[7 + row]) + 128) >> 8;

 41293       v5 = p[3 + row] << 4;

 41294       v6 = p[5 + row] << 4;

 41296       // stage 3

 41297       t = (v0 - v1+ 1) >> 1;

 41298       v0 = (v0 + v1 + 1) >> 1;

 41299       v1 = t;

 41300       t = (v2 * dctSin6 + v3 * dctCos6 + 128) >> 8;

 41301       v2 = (v2 * dctCos6 - v3 * dctSin6 + 128) >> 8;

 41302       v3 = t;

 41303       t = (v4 - v6 + 1) >> 1;

 41304       v4 = (v4 + v6 + 1) >> 1;

 41305       v6 = t;

 41306       t = (v7 + v5 + 1) >> 1;

 41307       v5 = (v7 - v5 + 1) >> 1;

 41308       v7 = t;

 41310       // stage 2

 41311       t = (v0 - v3 + 1) >> 1;

 41312       v0 = (v0 + v3 + 1) >> 1;

 41313       v3 = t;

 41314       t = (v1 - v2 + 1) >> 1;

 41315       v1 = (v1 + v2 + 1) >> 1;

 41316       v2 = t;

 41317       t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;

 41318       v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;

 41319       v7 = t;

 41320       t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;

 41321       v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;

 41322       v6 = t;

 41324       // stage 1

 41325       p[0 + row] = v0 + v7;

 41326       p[7 + row] = v0 - v7;

 41327       p[1 + row] = v1 + v6;

 41328       p[6 + row] = v1 - v6;

 41329       p[2 + row] = v2 + v5;

 41330       p[5 + row] = v2 - v5;

 41331       p[3 + row] = v3 + v4;

 41332       p[4 + row] = v3 - v4;

 41333     }

 41335     // inverse DCT on columns

 41336     for (i = 0; i < 8; ++i) {

 41337       var col = i;

 41339       // check for all-zero AC coefficients

 41340       if (p[1*8 + col] == 0 && p[2*8 + col] == 0 && p[3*8 + col] == 0 &&

 41341           p[4*8 + col] == 0 && p[5*8 + col] == 0 && p[6*8 + col] == 0 &&

 41342           p[7*8 + col] == 0) {

 41343         t = (dctSqrt2 * p[i+0] + 8192) >> 14;

 41344         p[0*8 + col] = t;

 41345         p[1*8 + col] = t;

 41346         p[2*8 + col] = t;

 41347         p[3*8 + col] = t;

 41348         p[4*8 + col] = t;

 41349         p[5*8 + col] = t;

 41350         p[6*8 + col] = t;

 41351         p[7*8 + col] = t;

 41352         continue;

 41353       }

 41355       // stage 4

 41356       v0 = (dctSqrt2 * p[0*8 + col] + 2048) >> 12;

 41357       v1 = (dctSqrt2 * p[4*8 + col] + 2048) >> 12;

 41358       v2 = p[2*8 + col];

 41359       v3 = p[6*8 + col];

 41360       v4 = (dctSqrt1d2 * (p[1*8 + col] - p[7*8 + col]) + 2048) >> 12;

 41361       v7 = (dctSqrt1d2 * (p[1*8 + col] + p[7*8 + col]) + 2048) >> 12;

 41362       v5 = p[3*8 + col];

 41363       v6 = p[5*8 + col];

 41365       // stage 3

 41366       t = (v0 - v1 + 1) >> 1;

 41367       v0 = (v0 + v1 + 1) >> 1;

 41368       v1 = t;

 41369       t = (v2 * dctSin6 + v3 * dctCos6 + 2048) >> 12;

 41370       v2 = (v2 * dctCos6 - v3 * dctSin6 + 2048) >> 12;

 41371       v3 = t;

 41372       t = (v4 - v6 + 1) >> 1;

 41373       v4 = (v4 + v6 + 1) >> 1;

 41374       v6 = t;

 41375       t = (v7 + v5 + 1) >> 1;

 41376       v5 = (v7 - v5 + 1) >> 1;

 41377       v7 = t;

 41379       // stage 2

 41380       t = (v0 - v3 + 1) >> 1;

 41381       v0 = (v0 + v3 + 1) >> 1;

 41382       v3 = t;

 41383       t = (v1 - v2 + 1) >> 1;

 41384       v1 = (v1 + v2 + 1) >> 1;

 41385       v2 = t;

 41386       t = (v4 * dctSin3 + v7 * dctCos3 + 2048) >> 12;

 41387       v4 = (v4 * dctCos3 - v7 * dctSin3 + 2048) >> 12;

 41388       v7 = t;

 41389       t = (v5 * dctSin1 + v6 * dctCos1 + 2048) >> 12;

 41390       v5 = (v5 * dctCos1 - v6 * dctSin1 + 2048) >> 12;

 41391       v6 = t;

 41393       // stage 1

 41394       p[0*8 + col] = v0 + v7;

 41395       p[7*8 + col] = v0 - v7;

 41396       p[1*8 + col] = v1 + v6;

 41397       p[6*8 + col] = v1 - v6;

 41398       p[2*8 + col] = v2 + v5;

 41399       p[5*8 + col] = v2 - v5;

 41400       p[3*8 + col] = v3 + v4;

 41401       p[4*8 + col] = v3 - v4;

 41402     }

 41404     // convert to 8-bit integers

 41405     for (i = 0; i < 64; ++i) {

 41406       var index = blockBufferOffset + i;

 41407       component.blockData[index] = clampTo8bitInt((p[i] + 2056) >> 4);

 41408     }

 41409   }

 41411   function buildComponentData(frame, component) {

 41412     var lines = [];

 41413     var blocksPerLine = component.blocksPerLine;

 41414     var blocksPerColumn = component.blocksPerColumn;

 41415     var samplesPerLine = blocksPerLine << 3;

 41416     var computationBuffer = new Int32Array(64);

 41418     var i, j, ll = 0;

 41419     for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {

 41420       for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {

 41421         var offset = getBlockBufferOffset(component, blockRow, blockCol)

 41422         quantizeAndInverse(component, offset, computationBuffer);

 41423       }

 41424     }

 41425     return component.blockData;

 41426   }

 41428   function clampTo8bitInt(a) {

 41429     return a <= 0 ? 0 : a >= 255 ? 255 : a | 0;

 41430   }

 41432   function clamp0to255(a) {

 41433     return a <= 0 ? 0 : a >= 255 ? 255 : a;

 41434   }

 41436   constructor.prototype = {

 41437     load: function load(path) {

 41438       var xhr = new XMLHttpRequest();

 41439       xhr.open("GET", path, true);

 41440       xhr.responseType = "arraybuffer";

 41441       xhr.onload = (function() {

 41442         // TODO catch parse error

 41443         var data = new Uint8Array(xhr.response || xhr.mozResponseArrayBuffer);

 41444         this.parse(data);

 41445         if (this.onload)

 41446           this.onload();

 41447       }).bind(this);

 41448       xhr.send(null);

 41449     },

 41451     parse: function parse(data) {

 41453       function readUint16() {

 41454         var value = (data[offset] << 8) | data[offset + 1];

 41455         offset += 2;

 41456         return value;

 41457       }

 41459       function readDataBlock() {

 41460         var length = readUint16();

 41461         var array = data.subarray(offset, offset + length - 2);

 41462         offset += array.length;

 41463         return array;

 41464       }

 41466       function prepareComponents(frame) {

 41467         var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);

 41468         var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);

 41469         for (var i = 0; i < frame.components.length; i++) {

 41470           component = frame.components[i];

 41471           var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / frame.maxH);

 41472           var blocksPerColumn = Math.ceil(Math.ceil(frame.scanLines  / 8) * component.v / frame.maxV);

 41473           var blocksPerLineForMcu = mcusPerLine * component.h;

 41474           var blocksPerColumnForMcu = mcusPerColumn * component.v;

 41476           var blocksBufferSize = 64 * blocksPerColumnForMcu

 41477                                     * (blocksPerLineForMcu + 1);

 41478           component.blockData = new Int16Array(blocksBufferSize);

 41479           component.blocksPerLine = blocksPerLine;

 41480           component.blocksPerColumn = blocksPerColumn;

 41481         }

 41482         frame.mcusPerLine = mcusPerLine;

 41483         frame.mcusPerColumn = mcusPerColumn;

 41484       }

 41486       var offset = 0, length = data.length;

 41487       var jfif = null;

 41488       var adobe = null;

 41489       var pixels = null;

 41490       var frame, resetInterval;

 41491       var quantizationTables = [];

 41492       var huffmanTablesAC = [], huffmanTablesDC = [];

 41493       var fileMarker = readUint16();

 41494       if (fileMarker != 0xFFD8) { // SOI (Start of Image)

 41495         throw "SOI not found";

 41496       }

 41498       fileMarker = readUint16();

 41499       while (fileMarker != 0xFFD9) { // EOI (End of image)

 41500         var i, j, l;

 41501         switch(fileMarker) {

 41502           case 0xFFE0: // APP0 (Application Specific)

 41503           case 0xFFE1: // APP1

 41504           case 0xFFE2: // APP2

 41505           case 0xFFE3: // APP3

 41506           case 0xFFE4: // APP4

 41507           case 0xFFE5: // APP5

 41508           case 0xFFE6: // APP6

 41509           case 0xFFE7: // APP7

 41510           case 0xFFE8: // APP8

 41511           case 0xFFE9: // APP9

 41512           case 0xFFEA: // APP10

 41513           case 0xFFEB: // APP11

 41514           case 0xFFEC: // APP12

 41515           case 0xFFED: // APP13

 41516           case 0xFFEE: // APP14

 41517           case 0xFFEF: // APP15

 41518           case 0xFFFE: // COM (Comment)

 41519             var appData = readDataBlock();

 41521             if (fileMarker === 0xFFE0) {

 41522               if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 &&

 41523                 appData[3] === 0x46 && appData[4] === 0) { // 'JFIF\x00'

 41524                 jfif = {

 41525                   version: { major: appData[5], minor: appData[6] },

 41526                   densityUnits: appData[7],

 41527                   xDensity: (appData[8] << 8) | appData[9],

 41528                   yDensity: (appData[10] << 8) | appData[11],

 41529                   thumbWidth: appData[12],

 41530                   thumbHeight: appData[13],

 41531                   thumbData: appData.subarray(14, 14 + 3 * appData[12] * appData[13])

 41532                 };

 41533               }

 41534             }

 41535             // TODO APP1 - Exif

 41536             if (fileMarker === 0xFFEE) {

 41537               if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F &&

 41538                 appData[3] === 0x62 && appData[4] === 0x65 && appData[5] === 0) { // 'Adobe\x00'

 41539                 adobe = {

 41540                   version: appData[6],

 41541                   flags0: (appData[7] << 8) | appData[8],

 41542                   flags1: (appData[9] << 8) | appData[10],

 41543                   transformCode: appData[11]

 41544                 };

 41545               }

 41546             }

 41547             break;

 41549           case 0xFFDB: // DQT (Define Quantization Tables)

 41550             var quantizationTablesLength = readUint16();

 41551             var quantizationTablesEnd = quantizationTablesLength + offset - 2;

 41552             while (offset < quantizationTablesEnd) {

 41553               var quantizationTableSpec = data[offset++];

 41554               var tableData = new Int32Array(64);

 41555               if ((quantizationTableSpec >> 4) === 0) { // 8 bit values

 41556                 for (j = 0; j < 64; j++) {

 41557                   var z = dctZigZag[j];

 41558                   tableData[z] = data[offset++];

 41559                 }

 41560               } else if ((quantizationTableSpec >> 4) === 1) { //16 bit

 41561                 for (j = 0; j < 64; j++) {

 41562                   var z = dctZigZag[j];

 41563                   tableData[z] = readUint16();

 41564                 }

 41565               } else

 41566                 throw "DQT: invalid table spec";

 41567               quantizationTables[quantizationTableSpec & 15] = tableData;

 41568             }

 41569             break;

 41571           case 0xFFC0: // SOF0 (Start of Frame, Baseline DCT)

 41572           case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)

 41573           case 0xFFC2: // SOF2 (Start of Frame, Progressive DCT)

 41574             if (frame) {

 41575               throw "Only single frame JPEGs supported";

 41576             }

 41577             readUint16(); // skip data length

 41578             frame = {};

 41579             frame.extended = (fileMarker === 0xFFC1);

 41580             frame.progressive = (fileMarker === 0xFFC2);

 41581             frame.precision = data[offset++];

 41582             frame.scanLines = readUint16();

 41583             frame.samplesPerLine = readUint16();

 41584             frame.components = [];

 41585             frame.componentIds = {};

 41586             var componentsCount = data[offset++], componentId;

 41587             var maxH = 0, maxV = 0;

 41588             for (i = 0; i < componentsCount; i++) {

 41589               componentId = data[offset];

 41590               var h = data[offset + 1] >> 4;

 41591               var v = data[offset + 1] & 15;

 41592               if (maxH < h) maxH = h;

 41593               if (maxV < v) maxV = v;

 41594               var qId = data[offset + 2];

 41595               var l = frame.components.push({

 41596                 h: h,

 41597                 v: v,

 41598                 quantizationTable: quantizationTables[qId]

 41599               });

 41600               frame.componentIds[componentId] = l - 1;

 41601               offset += 3;

 41602             }

 41603             frame.maxH = maxH;

 41604             frame.maxV = maxV;

 41605             prepareComponents(frame);

 41606             break;

 41608           case 0xFFC4: // DHT (Define Huffman Tables)

 41609             var huffmanLength = readUint16();

 41610             for (i = 2; i < huffmanLength;) {

 41611               var huffmanTableSpec = data[offset++];

 41612               var codeLengths = new Uint8Array(16);

 41613               var codeLengthSum = 0;

 41614               for (j = 0; j < 16; j++, offset++)

 41615                 codeLengthSum += (codeLengths[j] = data[offset]);

 41616               var huffmanValues = new Uint8Array(codeLengthSum);

 41617               for (j = 0; j < codeLengthSum; j++, offset++)

 41618                 huffmanValues[j] = data[offset];

 41619               i += 17 + codeLengthSum;

 41621               ((huffmanTableSpec >> 4) === 0 ?

 41622                 huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] =

 41623                 buildHuffmanTable(codeLengths, huffmanValues);

 41624             }

 41625             break;

 41627           case 0xFFDD: // DRI (Define Restart Interval)

 41628             readUint16(); // skip data length

 41629             resetInterval = readUint16();

 41630             break;

 41632           case 0xFFDA: // SOS (Start of Scan)

 41633             var scanLength = readUint16();

 41634             var selectorsCount = data[offset++];

 41635             var components = [], component;

 41636             for (i = 0; i < selectorsCount; i++) {

 41637               var componentIndex = frame.componentIds[data[offset++]];

 41638               component = frame.components[componentIndex];

 41639               var tableSpec = data[offset++];

 41640               component.huffmanTableDC = huffmanTablesDC[tableSpec >> 4];

 41641               component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];

 41642               components.push(component);

 41643             }

 41644             var spectralStart = data[offset++];

 41645             var spectralEnd = data[offset++];

 41646             var successiveApproximation = data[offset++];

 41647             var processed = decodeScan(data, offset,

 41648               frame, components, resetInterval,

 41649               spectralStart, spectralEnd,

 41650               successiveApproximation >> 4, successiveApproximation & 15);

 41651             offset += processed;

 41652             break;

 41653           default:

 41654             if (data[offset - 3] == 0xFF &&

 41655                 data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {

 41656               // could be incorrect encoding -- last 0xFF byte of the previous

 41657               // block was eaten by the encoder

 41658               offset -= 3;

 41659               break;

 41660             }

 41661             throw "unknown JPEG marker " + fileMarker.toString(16);

 41662         }

 41663         fileMarker = readUint16();

 41664       }

 41666       this.width = frame.samplesPerLine;

 41667       this.height = frame.scanLines;

 41668       this.jfif = jfif;

 41669       this.adobe = adobe;

 41670       this.components = [];

 41671       for (var i = 0; i < frame.components.length; i++) {

 41672         var component = frame.components[i];

 41673         this.components.push({

 41674           output: buildComponentData(frame, component),

 41675           scaleX: component.h / frame.maxH,

 41676           scaleY: component.v / frame.maxV,

 41677           blocksPerLine: component.blocksPerLine,

 41678           blocksPerColumn: component.blocksPerColumn

 41679         });

 41680       }

 41681     },

 41683     getData: function getData(width, height) {

 41684       var scaleX = this.width / width, scaleY = this.height / height;

 41686       var component, componentScaleX, componentScaleY;

 41687       var x, y, i;

 41688       var offset = 0;

 41689       var Y, Cb, Cr, K, C, M, Ye, R, G, B;

 41690       var colorTransform;

 41691       var numComponents = this.components.length;

 41692       var dataLength = width * height * numComponents;

 41693       var data = new Uint8Array(dataLength);

 41694       var componentLine;

 41696       // lineData is reused for all components. Assume first component is

 41697       // the biggest

 41698       var lineData = new Uint8Array((this.components[0].blocksPerLine << 3) *

 41699                                     this.components[0].blocksPerColumn * 8);

 41701       // First construct image data ...

 41702       for (i = 0; i < numComponents; i++) {

 41703         component = this.components[i];

 41704         var blocksPerLine = component.blocksPerLine;

 41705         var blocksPerColumn = component.blocksPerColumn;

 41706         var samplesPerLine = blocksPerLine << 3;

 41708         var j, k, ll = 0;

 41709         var lineOffset = 0;

 41710         for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {

 41711           var scanLine = blockRow << 3;

 41712           for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {

 41713             var bufferOffset = getBlockBufferOffset(component, blockRow, blockCol);

 41714             var offset = 0, sample = blockCol << 3;

 41715             for (j = 0; j < 8; j++) {

 41716               var lineOffset = (scanLine + j) * samplesPerLine;

 41717               for (k = 0; k < 8; k++) {

 41718                 lineData[lineOffset + sample + k] =

 41719                   component.output[bufferOffset + offset++];

 41720               }

 41721             }

 41722           }

 41723         }

 41725         componentScaleX = component.scaleX * scaleX;

 41726         componentScaleY = component.scaleY * scaleY;

 41727         offset = i;

 41729         var cx, cy;

 41730         var index;

 41731         for (y = 0; y < height; y++) {

 41732           for (x = 0; x < width; x++) {

 41733             cy = 0 | (y * componentScaleY);

 41734             cx = 0 | (x * componentScaleX);

 41735             index = cy * samplesPerLine + cx;

 41736             data[offset] = lineData[index];

 41737             offset += numComponents;

 41738           }

 41739         }

 41740       }

 41742       // ... then transform colors, if necessary

 41743       switch (numComponents) {

 41744         case 1: case 2: break;

 41745         // no color conversion for one or two compoenents

 41747         case 3:

 41748           // The default transform for three components is true

 41749           colorTransform = true;

 41750           // The adobe transform marker overrides any previous setting

 41751           if (this.adobe && this.adobe.transformCode)

 41752             colorTransform = true;

 41753           else if (typeof this.colorTransform !== 'undefined')

 41754             colorTransform = !!this.colorTransform;

 41756           if (colorTransform) {

 41757             for (i = 0; i < dataLength; i += numComponents) {

 41758               Y  = data[i    ];

 41759               Cb = data[i + 1];

 41760               Cr = data[i + 2];

 41762               R = clamp0to255(Y + 1.402 * (Cr - 128));

 41763               G = clamp0to255(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));

 41764               B = clamp0to255(Y + 1.772 * (Cb - 128));

 41766               data[i    ] = R;

 41767               data[i + 1] = G;

 41768               data[i + 2] = B;

 41769             }

 41770           }

 41771           break;

 41772         case 4:

 41773           // The default transform for four components is false

 41774           colorTransform = false;

 41775           // The adobe transform marker overrides any previous setting

 41776           if (this.adobe && this.adobe.transformCode)

 41777             colorTransform = true;

 41778           else if (typeof this.colorTransform !== 'undefined')

 41779             colorTransform = !!this.colorTransform;

 41781           if (colorTransform) {

 41782             for (i = 0; i < dataLength; i += numComponents) {

 41783               Y  = data[i];

 41784               Cb = data[i + 1];

 41785               Cr = data[i + 2];

 41787               C = 255 - clamp0to255(Y + 1.402 * (Cr - 128));

 41788               M = 255 - clamp0to255(Y - 0.3441363 * (Cb - 128) - 0.71413636 * (Cr - 128));

 41789               Ye = 255 - clamp0to255(Y + 1.772 * (Cb - 128));

 41791               data[i    ] = C;

 41792               data[i + 1] = M;

 41793               data[i + 2] = Ye;

 41794               // K is unchanged

 41795             }

 41796           }

 41797           break;

 41798         default:

 41799           throw 'Unsupported color mode';

 41800       }

 41801       return data;

 41802     },

 41803     copyToImageData: function copyToImageData(imageData) {

 41804       var width = imageData.width, height = imageData.height;

 41805       var imageDataBytes = width * height * 4;

 41806       var imageDataArray = imageData.data;

 41807       var data = this.getData(width, height);

 41808       var i = 0, j = 0;

 41809       var Y, K, C, M, R, G, B;

 41810       switch (this.components.length) {

 41811         case 1:

 41812           while (j < imageDataBytes) {

 41813             Y = data[i++];

 41815             imageDataArray[j++] = Y;

 41816             imageDataArray[j++] = Y;

 41817             imageDataArray[j++] = Y;

 41818             imageDataArray[j++] = 255;

 41819           }

 41820           break;

 41821         case 3:

 41822           while (j < imageDataBytes) {

 41823             R = data[i++];

 41824             G = data[i++];

 41825             B = data[i++];

 41827             imageDataArray[j++] = R;

 41828             imageDataArray[j++] = G;

 41829             imageDataArray[j++] = B;

 41830             imageDataArray[j++] = 255;

 41831           }

 41832           break;

 41833         case 4:

 41834           while (j < imageDataBytes) {

 41835             C = data[i++];

 41836             M = data[i++];

 41837             Y = data[i++];

 41838             K = data[i++];

 41840             R = 255 - clamp0to255(C * (1 - K / 255) + K);

 41841             G = 255 - clamp0to255(M * (1 - K / 255) + K);

 41842             B = 255 - clamp0to255(Y * (1 - K / 255) + K);

 41844             imageDataArray[j++] = R;

 41845             imageDataArray[j++] = G;

 41846             imageDataArray[j++] = B;

 41847             imageDataArray[j++] = 255;

 41848           }

 41849           break;

 41850         default:

 41851           throw 'Unsupported color mode';

 41852       }

 41853     }

 41854   };

 41856   return constructor;

 41857 })();

 41860 }).call((typeof window === 'undefined') ? this : window);

The Tor Browser / file revision

browser/extensions/pdfjs/content/build/pdf.worker.js@6474c204b198

browser/extensions/pdfjs/content/build/pdf.worker.js