@loaders.gl/scan 5.0.0-alpha.11 → 5.0.0-alpha.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/iceberg.cjs CHANGED
@@ -5,12 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
5
  var __getOwnPropNames = Object.getOwnPropertyNames;
6
6
  var __getProtoOf = Object.getPrototypeOf;
7
7
  var __hasOwnProp = Object.prototype.hasOwnProperty;
8
- var __esm = (fn, res, err2) => function __init() {
9
- if (err2) throw err2[0];
8
+ var __esm = (fn, res, err) => function __init() {
9
+ if (err) throw err[0];
10
10
  try {
11
11
  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
12
12
  } catch (e) {
13
- throw err2 = [e], e;
13
+ throw err = [e], e;
14
14
  }
15
15
  };
16
16
  var __export = (target, all) => {
@@ -124,19 +124,6 @@ function registerJSModules(modules) {
124
124
  globalThis.loaders.modules ||= {};
125
125
  Object.assign(globalThis.loaders.modules, modules);
126
126
  }
127
- function getJSModule(name, caller) {
128
- var _a, _b;
129
- const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
130
- if (!module2) {
131
- throw new Error(`${caller}: ${name} library not installed`);
132
- }
133
- return module2;
134
- }
135
- function getJSModuleOrNull(name) {
136
- var _a, _b;
137
- const module2 = (_b = (_a = globalThis.loaders) == null ? void 0 : _a.modules) == null ? void 0 : _b[name];
138
- return module2 || null;
139
- }
140
127
  var init_js_module_utils = __esm({
141
128
  "../loader-utils/src/lib/module-utils/js-module-utils.ts"() {
142
129
  "use strict";
@@ -1047,8 +1034,11 @@ var init_src = __esm({
1047
1034
 
1048
1035
  // ../loader-utils/src/lib/worker-loader-utils/parse-with-worker.ts
1049
1036
  function canParseWithWorker(loader, options) {
1050
- var _a, _b, _c;
1051
- if ((_b = (_a = options == null ? void 0 : options.core) == null ? void 0 : _a.credentials) == null ? void 0 : _b.some(
1037
+ var _a, _b, _c, _d, _e;
1038
+ const workerUrl = (_a = options == null ? void 0 : options[loader.id]) == null ? void 0 : _a.workerUrl;
1039
+ if (((_b = options == null ? void 0 : options.core) == null ? void 0 : _b.worker) === false || !(loader.worker || loader.loadWorker || workerUrl))
1040
+ return false;
1041
+ if ((_d = (_c = options == null ? void 0 : options.core) == null ? void 0 : _c.credentials) == null ? void 0 : _d.some(
1052
1042
  (credential) => credential.type === "request" || "token" in credential && typeof credential.token === "function"
1053
1043
  ))
1054
1044
  return false;
@@ -1057,7 +1047,7 @@ function canParseWithWorker(loader, options) {
1057
1047
  if (!isBrowser2 && !nodeWorkers) {
1058
1048
  return false;
1059
1049
  }
1060
- if (loader.id === "las" && (((_c = options == null ? void 0 : options.las) == null ? void 0 : _c.shape) ?? "arrow-table") === "arrow-table") {
1050
+ if (loader.id === "las" && (((_e = options == null ? void 0 : options.las) == null ? void 0 : _e.shape) ?? "arrow-table") === "arrow-table") {
1061
1051
  return false;
1062
1052
  }
1063
1053
  if (loader.id === "csv" && !shouldParseCSVWithWorker(options)) {
@@ -1135,12 +1125,14 @@ function resolveWorkerLoaders(loader, loaderIds, loaderIsArray, context, options
1135
1125
  }
1136
1126
  }
1137
1127
  function getWorkerOptions(options = {}, loader) {
1128
+ const optionsToSerialize = {
1129
+ ...options,
1130
+ ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
1131
+ };
1138
1132
  const serializedOptions = JSON.parse(
1139
- JSON.stringify({
1140
- ...options,
1141
- ...options.core ? { core: { ...options.core, authentications: void 0 } } : {}
1142
- })
1133
+ JSON.stringify(optionsToSerialize, (_key, value) => typeof value === "bigint" ? null : value)
1143
1134
  );
1135
+ restoreBigIntOptions(optionsToSerialize, serializedOptions);
1144
1136
  const workerOptions = {
1145
1137
  ...serializedOptions.core,
1146
1138
  ...serializedOptions
@@ -1153,6 +1145,14 @@ function getWorkerOptions(options = {}, loader) {
1153
1145
  }
1154
1146
  return workerOptions;
1155
1147
  }
1148
+ function restoreBigIntOptions(original, serialized) {
1149
+ if (!serialized || typeof serialized !== "object") return;
1150
+ for (const key of Object.keys(serialized)) {
1151
+ const value = original == null ? void 0 : original[key];
1152
+ if (typeof value === "bigint") serialized[key] = value;
1153
+ else restoreBigIntOptions(value, serialized[key]);
1154
+ }
1155
+ }
1156
1156
  function getSerializableLoaderContext(context) {
1157
1157
  if (!context) {
1158
1158
  return {};
@@ -2563,47 +2563,7 @@ var init_file_aliases = __esm({
2563
2563
  }
2564
2564
  });
2565
2565
 
2566
- // ../loader-utils/src/lib/node/buffer.browser.ts
2567
- function toArrayBuffer(buffer) {
2568
- return buffer;
2569
- }
2570
- var init_buffer_browser = __esm({
2571
- "../loader-utils/src/lib/node/buffer.browser.ts"() {
2572
- "use strict";
2573
- }
2574
- });
2575
-
2576
2566
  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
2577
- function isBuffer(value) {
2578
- return value && typeof value === "object" && value.isBuffer;
2579
- }
2580
- function toArrayBuffer2(data) {
2581
- if (isBuffer(data)) {
2582
- return toArrayBuffer(data);
2583
- }
2584
- if (data instanceof ArrayBuffer) {
2585
- return data;
2586
- }
2587
- if (isSharedArrayBuffer(data)) {
2588
- return copyToArrayBuffer2(data);
2589
- }
2590
- if (ArrayBuffer.isView(data)) {
2591
- const buffer = data.buffer;
2592
- if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
2593
- return buffer;
2594
- }
2595
- return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
2596
- }
2597
- if (typeof data === "string") {
2598
- const text = data;
2599
- const uint8Array = new TextEncoder().encode(text);
2600
- return uint8Array.buffer;
2601
- }
2602
- if (data && typeof data === "object" && data._toArrayBuffer) {
2603
- return data._toArrayBuffer();
2604
- }
2605
- throw new Error("toArrayBuffer");
2606
- }
2607
2567
  function ensureArrayBuffer(bufferSource) {
2608
2568
  if (bufferSource instanceof ArrayBuffer) {
2609
2569
  return bufferSource;
@@ -2627,19 +2587,6 @@ var init_memory_conversion_utils = __esm({
2627
2587
  "../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts"() {
2628
2588
  "use strict";
2629
2589
  init_is_type();
2630
- init_buffer_browser();
2631
- }
2632
- });
2633
-
2634
- // ../loader-utils/src/lib/node/promisify.ts
2635
- function promisify1(fn) {
2636
- return (args) => new Promise(
2637
- (resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs))
2638
- );
2639
- }
2640
- var init_promisify = __esm({
2641
- "../loader-utils/src/lib/node/promisify.ts"() {
2642
- "use strict";
2643
2590
  }
2644
2591
  });
2645
2592
 
@@ -3225,13 +3172,12 @@ var init_src2 = __esm({
3225
3172
  "use strict";
3226
3173
  init_globals();
3227
3174
  init_js_module_utils();
3228
- init_js_module_utils();
3229
3175
  init_parse_with_worker();
3176
+ init_array_buffer_utils();
3230
3177
  init_async_iteration();
3231
3178
  init_range_request_scheduler();
3232
3179
  init_range_request_cache();
3233
3180
  init_memory_conversion_utils();
3234
- init_promisify();
3235
3181
  init_blob_file();
3236
3182
  init_data_source();
3237
3183
  init_scan_executor();
@@ -3243,7 +3189,7 @@ var init_src2 = __esm({
3243
3189
  });
3244
3190
 
3245
3191
  // ../compression/src/lib/compression.ts
3246
- var CompressionTransform, Compressor, Decompressor, Compression;
3192
+ var CompressionTransform, Decompressor;
3247
3193
  var init_compression = __esm({
3248
3194
  "../compression/src/lib/compression.ts"() {
3249
3195
  "use strict";
@@ -3265,26 +3211,6 @@ var init_compression = __esm({
3265
3211
  return error;
3266
3212
  }
3267
3213
  };
3268
- Compressor = class extends CompressionTransform {
3269
- constructor(options) {
3270
- super();
3271
- this.compressBatches = this.compressBatches.bind(this);
3272
- }
3273
- /** Asynchronously compresses data. */
3274
- async compress(input) {
3275
- await this.preload();
3276
- return this.compressSync(input);
3277
- }
3278
- /** Synchronously compresses data. */
3279
- compressSync(input) {
3280
- throw new Error(`${this.name}: sync compression not supported`);
3281
- }
3282
- /** Compresses batches. */
3283
- async *compressBatches(asyncIterator) {
3284
- const input = await this.concatenate(asyncIterator);
3285
- yield this.compress(input);
3286
- }
3287
- };
3288
3214
  Decompressor = class extends CompressionTransform {
3289
3215
  constructor(options) {
3290
3216
  super();
@@ -3305,112 +3231,6 @@ var init_compression = __esm({
3305
3231
  yield this.decompress(input);
3306
3232
  }
3307
3233
  };
3308
- Compression = class extends Compressor {
3309
- constructor(options) {
3310
- super(options);
3311
- this.decompressBatches = this.decompressBatches.bind(this);
3312
- }
3313
- /** Asynchronously decompresses data. */
3314
- async decompress(input, size) {
3315
- await this.preload();
3316
- return this.decompressSync(input, size);
3317
- }
3318
- /** Synchronously decompresses data. */
3319
- decompressSync(input, size) {
3320
- throw new Error(`${this.name}: sync decompression not supported`);
3321
- }
3322
- /** Decompresses batches. */
3323
- async *decompressBatches(asyncIterator) {
3324
- const input = await this.concatenate(asyncIterator);
3325
- yield this.decompress(input);
3326
- }
3327
- };
3328
- }
3329
- });
3330
-
3331
- // ../compression/src/lib/compression-stream.ts
3332
- async function compressWithNativeCompressionStream(input, format) {
3333
- const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
3334
- return outputBatches ? await concatenateBatches(outputBatches) : null;
3335
- }
3336
- function compressBatchesWithNativeCompressionStream(inputBatches, format) {
3337
- const compressionStream = createNativeCompressionStream(format);
3338
- return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
3339
- }
3340
- function createNativeCompressionStream(format) {
3341
- if (typeof globalThis.CompressionStream === "undefined") {
3342
- return null;
3343
- }
3344
- try {
3345
- const CompressionStreamConstructor = globalThis.CompressionStream;
3346
- return new CompressionStreamConstructor(format);
3347
- } catch (error) {
3348
- if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
3349
- return null;
3350
- }
3351
- throw error;
3352
- }
3353
- }
3354
- async function* transformBatches(inputBatches, compressionStream) {
3355
- const writer = compressionStream.writable.getWriter();
3356
- const reader = compressionStream.readable.getReader();
3357
- const writePromise = writeBatches(inputBatches, writer);
3358
- writePromise.catch(() => {
3359
- });
3360
- let outputCompleted = false;
3361
- try {
3362
- while (true) {
3363
- const { done, value } = await reader.read();
3364
- if (done) {
3365
- outputCompleted = true;
3366
- break;
3367
- }
3368
- yield new Uint8Array(value).buffer;
3369
- }
3370
- await writePromise;
3371
- } finally {
3372
- if (!outputCompleted) {
3373
- await reader.cancel().catch(() => {
3374
- });
3375
- await writer.abort().catch(() => {
3376
- });
3377
- await writePromise.catch(() => {
3378
- });
3379
- }
3380
- reader.releaseLock();
3381
- }
3382
- }
3383
- async function writeBatches(inputBatches, writer) {
3384
- try {
3385
- for await (const inputBatch of inputBatches) {
3386
- await writer.write(new Uint8Array(inputBatch));
3387
- }
3388
- await writer.close();
3389
- } catch (error) {
3390
- await writer.abort(error).catch(() => {
3391
- });
3392
- throw error;
3393
- }
3394
- }
3395
- async function concatenateBatches(batches) {
3396
- const output = [];
3397
- let byteLength = 0;
3398
- for await (const batch of batches) {
3399
- const bytes = new Uint8Array(batch);
3400
- output.push(bytes);
3401
- byteLength += bytes.byteLength;
3402
- }
3403
- const result = new Uint8Array(byteLength);
3404
- let offset = 0;
3405
- for (const batch of output) {
3406
- result.set(batch, offset);
3407
- offset += batch.byteLength;
3408
- }
3409
- return result.buffer;
3410
- }
3411
- var init_compression_stream = __esm({
3412
- "../compression/src/lib/compression-stream.ts"() {
3413
- "use strict";
3414
3234
  }
3415
3235
  });
3416
3236
 
@@ -3607,8 +3427,8 @@ var init_lazy_compression = __esm({
3607
3427
  const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
3608
3428
  return new NativeDecompressor2(this, this.nativeFormat, options);
3609
3429
  }
3610
- const Decompressor2 = await this.loadFallback();
3611
- const implementation = new Decompressor2({ ...options, useNative: false });
3430
+ const Decompressor3 = await this.loadFallback();
3431
+ const implementation = new Decompressor3({ ...options, useNative: false });
3612
3432
  await implementation.preload(options.modules);
3613
3433
  return implementation;
3614
3434
  }
@@ -3631,2811 +3451,233 @@ var init_lazy_compression = __esm({
3631
3451
  }
3632
3452
  });
3633
3453
 
3634
- // ../compression/src/lib/fflate/index.ts
3635
- function inflateSync(data, out) {
3636
- return inflt(data, out);
3454
+ // ../compression/src/lib/compress-utils-compression.ts
3455
+ async function* transformBatches(stream, inputBatches) {
3456
+ try {
3457
+ for await (const input of inputBatches) {
3458
+ const output2 = stream.write(new Uint8Array(input));
3459
+ if (output2.byteLength > 0) yield copyArrayBuffer(output2);
3460
+ }
3461
+ const output = stream.finish();
3462
+ if (output.byteLength > 0) yield copyArrayBuffer(output);
3463
+ } finally {
3464
+ stream.destroy();
3465
+ }
3637
3466
  }
3638
- function gunzipSync(data, out) {
3639
- return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
3467
+ function copyArrayBuffer(bytes) {
3468
+ return bytes.slice().buffer;
3640
3469
  }
3641
- function unzlibSync(data, out) {
3642
- return inflt((zlv(data), data.subarray(2, -4)), out);
3470
+ function getDecompressOptions(options, size) {
3471
+ const decodeOptions = {
3472
+ ...options.compressUtils,
3473
+ ...size === void 0 ? {} : { expectedSize: size }
3474
+ };
3475
+ const capacity = decodeOptions.expectedSize;
3476
+ const maximum = options.maxOutputByteLength ?? 512 * 1024 * 1024;
3477
+ if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 2147483647)
3478
+ throw new RangeError("Invalid maxOutputByteLength");
3479
+ if (capacity !== void 0 && (!Number.isSafeInteger(capacity) || capacity < 0 || capacity > maximum)) {
3480
+ throw new RangeError("expectedSize exceeds the configured output capacity limit");
3481
+ }
3482
+ return decodeOptions;
3643
3483
  }
3644
- var u8, u16, u32, fleb, fdeb, clim, freb, fl, revfl, fd, revfd, rev, hMap, flt, fdt, flrm, fdrm, max, bits, bits16, shft, slc, ec, err, inflt, gzs, gzl, zlv, Inflate, Gunzip, Unzlib;
3645
- var init_fflate = __esm({
3646
- "../compression/src/lib/fflate/index.ts"() {
3484
+ var CompressUtilsDecompressor;
3485
+ var init_compress_utils_compression = __esm({
3486
+ "../compression/src/lib/compress-utils-compression.ts"() {
3647
3487
  "use strict";
3648
- u8 = Uint8Array;
3649
- u16 = Uint16Array;
3650
- u32 = Uint32Array;
3651
- fleb = new u8([
3652
- 0,
3653
- 0,
3654
- 0,
3655
- 0,
3656
- 0,
3657
- 0,
3658
- 0,
3659
- 0,
3660
- 1,
3661
- 1,
3662
- 1,
3663
- 1,
3664
- 2,
3665
- 2,
3666
- 2,
3667
- 2,
3668
- 3,
3669
- 3,
3670
- 3,
3671
- 3,
3672
- 4,
3673
- 4,
3674
- 4,
3675
- 4,
3676
- 5,
3677
- 5,
3678
- 5,
3679
- 5,
3680
- 0,
3681
- /* unused */
3682
- 0,
3683
- 0,
3684
- /* impossible */
3685
- 0
3686
- ]);
3687
- fdeb = new u8([
3688
- 0,
3689
- 0,
3690
- 0,
3691
- 0,
3692
- 1,
3693
- 1,
3694
- 2,
3695
- 2,
3696
- 3,
3697
- 3,
3698
- 4,
3699
- 4,
3700
- 5,
3701
- 5,
3702
- 6,
3703
- 6,
3704
- 7,
3705
- 7,
3706
- 8,
3707
- 8,
3708
- 9,
3709
- 9,
3710
- 10,
3711
- 10,
3712
- 11,
3713
- 11,
3714
- 12,
3715
- 12,
3716
- 13,
3717
- 13,
3718
- /* unused */
3719
- 0,
3720
- 0
3721
- ]);
3722
- clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
3723
- freb = (eb, start) => {
3724
- const b = new u16(31);
3725
- for (let i = 0; i < 31; ++i) {
3726
- b[i] = start += 1 << eb[i - 1];
3488
+ init_compression();
3489
+ CompressUtilsDecompressor = class extends Decompressor {
3490
+ name;
3491
+ extensions;
3492
+ contentEncodings;
3493
+ isSupported = true;
3494
+ options;
3495
+ loadModule;
3496
+ /** Module initialized for synchronous operations. */
3497
+ module = null;
3498
+ /** Shared import and WASM initialization for concurrent callers. */
3499
+ modulePromise = null;
3500
+ /** Creates a format-specific compress-utils decoder. */
3501
+ constructor(metadata, loadModule, options = {}) {
3502
+ super(options);
3503
+ this.name = metadata.name;
3504
+ this.extensions = metadata.extensions || [];
3505
+ this.contentEncodings = metadata.contentEncodings || [];
3506
+ this.loadModule = loadModule;
3507
+ this.options = options;
3727
3508
  }
3728
- const r = new u32(b[30]);
3729
- for (let i = 1; i < 30; ++i) {
3730
- for (let j = b[i]; j < b[i + 1]; ++j) {
3731
- r[j] = j - b[i] << 5 | i;
3509
+ /** Imports and initializes the codec without loading the opposite direction. */
3510
+ async preload(modules = {}) {
3511
+ await super.preload(modules);
3512
+ this.modulePromise ||= this.loadModule().then(async (module2) => {
3513
+ var _a;
3514
+ await ((_a = module2.preload) == null ? void 0 : _a.call(module2));
3515
+ this.module = module2;
3516
+ });
3517
+ try {
3518
+ await this.modulePromise;
3519
+ } catch (error) {
3520
+ this.modulePromise = null;
3521
+ throw error;
3732
3522
  }
3733
3523
  }
3734
- return [b, r];
3735
- };
3736
- [fl, revfl] = freb(fleb, 2);
3737
- fl[28] = 258, revfl[258] = 28;
3738
- [fd, revfd] = freb(fdeb, 0);
3739
- rev = new u16(32768);
3740
- for (let i = 0; i < 32768; ++i) {
3741
- let x = (i & 43690) >>> 1 | (i & 21845) << 1;
3742
- x = (x & 52428) >>> 2 | (x & 13107) << 2;
3743
- x = (x & 61680) >>> 4 | (x & 3855) << 4;
3744
- rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
3745
- }
3746
- hMap = (cd, mb, r) => {
3747
- const s = cd.length;
3748
- let i = 0;
3749
- const l = new u16(mb);
3750
- for (; i < s; ++i) {
3751
- if (cd[i]) ++l[cd[i] - 1];
3752
- }
3753
- const le = new u16(mb);
3754
- for (i = 0; i < mb; ++i) {
3755
- le[i] = le[i - 1] + l[i - 1] << 1;
3756
- }
3757
- let co;
3758
- if (r) {
3759
- co = new u16(1 << mb);
3760
- const rvb = 15 - mb;
3761
- for (i = 0; i < s; ++i) {
3762
- if (cd[i]) {
3763
- const sv = i << 4 | cd[i];
3764
- const r2 = mb - cd[i];
3765
- let v = le[cd[i] - 1]++ << r2;
3766
- for (const m = v | (1 << r2) - 1; v <= m; ++v) {
3767
- co[rev[v] >>> rvb] = sv;
3768
- }
3769
- }
3770
- }
3771
- } else {
3772
- co = new u16(s);
3773
- for (i = 0; i < s; ++i) {
3774
- if (cd[i]) {
3775
- co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
3776
- }
3524
+ /** Runs synchronously after preload has initialized the WASM codec. */
3525
+ decompressSync(input, size) {
3526
+ var _a;
3527
+ if (!((_a = this.module) == null ? void 0 : _a.decompressSync))
3528
+ throw new Error(`${this.name}: call preload() before decompressSync()`);
3529
+ return copyArrayBuffer(
3530
+ this.module.decompressSync(new Uint8Array(input), getDecompressOptions(this.options, size))
3531
+ );
3532
+ }
3533
+ /** Decompresses one buffer with the selected compress-utils decoder. */
3534
+ async decompress(input, size) {
3535
+ const decodeOptions = getDecompressOptions(this.options, size);
3536
+ await this.preload();
3537
+ const module2 = this.module;
3538
+ const output = await module2.decompress(new Uint8Array(input), decodeOptions);
3539
+ return copyArrayBuffer(output);
3540
+ }
3541
+ /** Incrementally decompresses input batches with compress-utils. */
3542
+ async *decompressBatches(inputBatches) {
3543
+ await this.preload();
3544
+ const module2 = this.module;
3545
+ if (!module2.createDecompressStream) {
3546
+ yield await this.decompress(await this.concatenate(inputBatches));
3547
+ return;
3777
3548
  }
3549
+ const stream = await module2.createDecompressStream();
3550
+ yield* transformBatches(stream, inputBatches);
3778
3551
  }
3779
- return co;
3780
- };
3781
- flt = new u8(288);
3782
- for (let i = 0; i < 144; ++i) flt[i] = 8;
3783
- for (let i = 144; i < 256; ++i) flt[i] = 9;
3784
- for (let i = 256; i < 280; ++i) flt[i] = 7;
3785
- for (let i = 280; i < 288; ++i) flt[i] = 8;
3786
- fdt = new u8(32);
3787
- for (let i = 0; i < 32; ++i) fdt[i] = 5;
3788
- flrm = /* @__PURE__ */ hMap(flt, 9, 1);
3789
- fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
3790
- max = (a) => {
3791
- let m = a[0];
3792
- for (let i = 1; i < a.length; ++i) {
3793
- if (a[i] > m) m = a[i];
3794
- }
3795
- return m;
3796
- };
3797
- bits = (d, p, m) => {
3798
- const o = p / 8 | 0;
3799
- return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
3800
- };
3801
- bits16 = (d, p) => {
3802
- const o = p / 8 | 0;
3803
- return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
3804
3552
  };
3805
- shft = (p) => (p + 7) / 8 | 0;
3806
- slc = (v, s, e) => {
3807
- if (s == null || s < 0) s = 0;
3808
- if (e == null || e > v.length) e = v.length;
3809
- const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
3810
- n.set(v.subarray(s, e));
3811
- return n;
3812
- };
3813
- ec = [
3814
- "unexpected EOF",
3815
- "invalid block type",
3816
- "invalid length/literal",
3817
- "invalid distance",
3818
- "stream finished",
3819
- "no stream handler",
3820
- ,
3821
- // determined by compression function
3822
- "no callback",
3823
- "invalid UTF-8 data",
3824
- "extra field too long",
3825
- "date not in range 1980-2099",
3826
- "filename too long",
3827
- "stream finishing",
3828
- "invalid zip data"
3829
- // determined by unknown compression method
3830
- ];
3831
- err = (ind, msg, nt) => {
3832
- const e = new Error(msg || ec[ind]);
3833
- e.code = ind;
3834
- if (Error.captureStackTrace) Error.captureStackTrace(e, err);
3835
- if (!nt) throw e;
3836
- return e;
3553
+ }
3554
+ });
3555
+
3556
+ // ../compression/src/deflate-decompressor-compress-utils.ts
3557
+ var DeflateCompressUtilsDecompressor;
3558
+ var init_deflate_decompressor_compress_utils = __esm({
3559
+ "../compression/src/deflate-decompressor-compress-utils.ts"() {
3560
+ "use strict";
3561
+ init_compress_utils_compression();
3562
+ DeflateCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
3563
+ constructor(options = {}) {
3564
+ super(
3565
+ { name: "deflate", contentEncodings: ["deflate"] },
3566
+ () => options.raw ? import("compress-utils/deflate/decompress") : import("compress-utils/zlib/decompress"),
3567
+ options
3568
+ );
3569
+ }
3837
3570
  };
3838
- inflt = (dat, buf, st) => {
3839
- const sl = dat.length;
3840
- if (!sl || st && st.f && !st.l) return buf || new u8(0);
3841
- const noBuf = !buf || st;
3842
- const noSt = !st || st.i;
3843
- if (!st) st = {};
3844
- if (!buf) buf = new u8(sl * 3);
3845
- const cbuf = (l) => {
3846
- let bl = buf.length;
3847
- if (l > bl) {
3848
- const nbuf = new u8(Math.max(bl * 2, l));
3849
- nbuf.set(buf);
3850
- buf = nbuf;
3571
+ }
3572
+ });
3573
+
3574
+ // ../compression/src/deflate-decompressor.ts
3575
+ var deflate_decompressor_exports = {};
3576
+ __export(deflate_decompressor_exports, {
3577
+ DeflateDecompressor: () => DeflateDecompressor
3578
+ });
3579
+ var DeflateDecompressor;
3580
+ var init_deflate_decompressor = __esm({
3581
+ "../compression/src/deflate-decompressor.ts"() {
3582
+ "use strict";
3583
+ init_deflate_decompressor_compress_utils();
3584
+ init_decompression_stream();
3585
+ DeflateDecompressor = class extends DeflateCompressUtilsDecompressor {
3586
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
3587
+ async decompress(input, size) {
3588
+ if (this.options.useNative !== false) {
3589
+ const output = await decompressWithNativeDecompressionStream(
3590
+ input,
3591
+ this.options.raw ? "deflate-raw" : "deflate"
3592
+ );
3593
+ if (output) return output;
3851
3594
  }
3852
- };
3853
- let final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
3854
- const tbts = sl * 8;
3855
- do {
3856
- if (!lm) {
3857
- final = bits(dat, pos, 1);
3858
- const type = bits(dat, pos + 1, 3);
3859
- pos += 3;
3860
- if (!type) {
3861
- const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
3862
- if (t > sl) {
3863
- if (noSt) err(0);
3864
- break;
3865
- }
3866
- if (noBuf) cbuf(bt + l);
3867
- buf.set(dat.subarray(s, t), bt);
3868
- st.b = bt += l, st.p = pos = t * 8, st.f = final;
3869
- continue;
3870
- } else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
3871
- else if (type == 2) {
3872
- const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
3873
- const tl = hLit + bits(dat, pos + 5, 31) + 1;
3874
- pos += 14;
3875
- const ldt = new u8(tl);
3876
- const clt = new u8(19);
3877
- for (let i = 0; i < hcLen; ++i) {
3878
- clt[clim[i]] = bits(dat, pos + i * 3, 7);
3879
- }
3880
- pos += hcLen * 3;
3881
- const clb = max(clt), clbmsk = (1 << clb) - 1;
3882
- const clm = hMap(clt, clb, 1);
3883
- for (let i = 0; i < tl; ) {
3884
- const r = clm[bits(dat, pos, clbmsk)];
3885
- pos += r & 15;
3886
- const s = r >>> 4;
3887
- if (s < 16) {
3888
- ldt[i++] = s;
3889
- } else {
3890
- let c = 0, n = 0;
3891
- if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
3892
- else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
3893
- else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
3894
- while (n--) ldt[i++] = c;
3895
- }
3896
- }
3897
- const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
3898
- lbt = max(lt);
3899
- dbt = max(dt);
3900
- lm = hMap(lt, lbt, 1);
3901
- dm = hMap(dt, dbt, 1);
3902
- } else err(1);
3903
- if (pos > tbts) {
3904
- if (noSt) err(0);
3905
- break;
3595
+ return super.decompress(input, size);
3596
+ }
3597
+ /** Streams native batches when available, otherwise uses the WASM stream. */
3598
+ async *decompressBatches(inputBatches) {
3599
+ if (this.options.useNative !== false) {
3600
+ const output = decompressBatchesWithNativeDecompressionStream(
3601
+ inputBatches,
3602
+ this.options.raw ? "deflate-raw" : "deflate"
3603
+ );
3604
+ if (output) {
3605
+ yield* output;
3606
+ return;
3906
3607
  }
3907
3608
  }
3908
- if (noBuf) cbuf(bt + 131072);
3909
- const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
3910
- let lpos = pos;
3911
- for (; ; lpos = pos) {
3912
- const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
3913
- pos += c & 15;
3914
- if (pos > tbts) {
3915
- if (noSt) err(0);
3916
- break;
3917
- }
3918
- if (!c) err(2);
3919
- if (sym < 256) buf[bt++] = sym;
3920
- else if (sym == 256) {
3921
- lpos = pos, lm = void 0;
3922
- break;
3923
- } else {
3924
- let add = sym - 254;
3925
- if (sym > 264) {
3926
- const i = sym - 257, b = fleb[i];
3927
- add = bits(dat, pos, (1 << b) - 1) + fl[i];
3928
- pos += b;
3929
- }
3930
- const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
3931
- if (!d) err(3);
3932
- pos += d & 15;
3933
- let dt = fd[dsym];
3934
- if (dsym > 3) {
3935
- const b = fdeb[dsym];
3936
- dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
3937
- }
3938
- if (pos > tbts) {
3939
- if (noSt) err(0);
3940
- break;
3941
- }
3942
- if (noBuf) cbuf(bt + 131072);
3943
- const end = bt + add;
3944
- for (; bt < end; bt += 4) {
3945
- buf[bt] = buf[bt - dt];
3946
- buf[bt + 1] = buf[bt + 1 - dt];
3947
- buf[bt + 2] = buf[bt + 2 - dt];
3948
- buf[bt + 3] = buf[bt + 3 - dt];
3949
- }
3950
- bt = end;
3951
- }
3952
- }
3953
- st.l = lm, st.p = lpos, st.b = bt, st.f = final;
3954
- if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
3955
- } while (!final);
3956
- return bt == buf.length ? buf : slc(buf, 0, bt);
3957
- };
3958
- gzs = (d) => {
3959
- if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
3960
- const flg = d[3];
3961
- let st = 10;
3962
- if (flg & 4) st += d[10] | (d[11] << 8) + 2;
3963
- for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
3964
- return st + (flg & 2);
3965
- };
3966
- gzl = (d) => {
3967
- const l = d.length;
3968
- return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
3969
- };
3970
- zlv = (d) => {
3971
- if ((d[0] & 15) != 8 || d[0] >>> 4 > 7 || (d[0] << 8 | d[1]) % 31) err(6, "invalid zlib data");
3972
- if (d[1] & 32) err(6, "invalid zlib data: preset dictionaries not supported");
3973
- };
3974
- Inflate = class {
3975
- /**
3976
- * Creates an inflation stream
3977
- * @param cb The callback to call whenever data is inflated
3978
- */
3979
- constructor(cb) {
3980
- this.ondata = cb;
3981
- }
3982
- /** Persistent bit-reader and Huffman decoding state. */
3983
- s = {};
3984
- /** Compression options or retained output window for this stream. */
3985
- o;
3986
- /** Compressed bytes pending decoding. */
3987
- p = new u8(0);
3988
- /** Whether the stream has received its final chunk. */
3989
- d;
3990
- /**
3991
- * The handler to call whenever data is available
3992
- */
3993
- ondata;
3994
- /** Appends pending input after checking stream lifecycle. */
3995
- e(c) {
3996
- if (!this.ondata) err(5);
3997
- if (this.d) err(4);
3998
- const l = this.p.length;
3999
- const n = new u8(l + c.length);
4000
- n.set(this.p), n.set(c, l), this.p = n;
4001
- }
4002
- /** Decodes pending input and retains the sliding window. */
4003
- c(final) {
4004
- this.d = this.s.i = final || false;
4005
- const bts = this.s.b;
4006
- const dt = inflt(this.p, this.o, this.s);
4007
- this.ondata(slc(dt, bts, this.s.b), this.d);
4008
- this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
4009
- this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
4010
- }
4011
- /**
4012
- * Pushes a chunk to be inflated
4013
- * @param chunk The chunk to push
4014
- * @param final Whether this is the final chunk
4015
- */
4016
- push(chunk, final) {
4017
- this.e(chunk), this.c(final);
4018
- }
4019
- };
4020
- Gunzip = class extends Inflate {
4021
- /** Whether the stream header still needs to be emitted or consumed. */
4022
- v = 1;
4023
- /**
4024
- * Creates a GUNZIP stream
4025
- * @param cb The callback to call whenever data is inflated
4026
- */
4027
- constructor(cb) {
4028
- super(cb);
4029
- }
4030
- /**
4031
- * Pushes a chunk to be GUNZIPped
4032
- * @param chunk The chunk to push
4033
- * @param final Whether this is the last chunk
4034
- */
4035
- push(chunk, final) {
4036
- Inflate.prototype.e.call(this, chunk);
4037
- if (this.v) {
4038
- const s = this.p.length > 3 ? gzs(this.p) : 4;
4039
- if (s >= this.p.length && !final) return;
4040
- this.p = this.p.subarray(s), this.v = 0;
4041
- }
4042
- if (final) {
4043
- if (this.p.length < 8) err(6, "invalid gzip data");
4044
- this.p = this.p.subarray(0, -8);
4045
- }
4046
- Inflate.prototype.c.call(this, final);
4047
- }
4048
- };
4049
- Unzlib = class extends Inflate {
4050
- /** Whether the stream header still needs to be emitted or consumed. */
4051
- v = 1;
4052
- /**
4053
- * Creates a Zlib decompression stream
4054
- * @param cb The callback to call whenever data is inflated
4055
- */
4056
- constructor(cb) {
4057
- super(cb);
4058
- }
4059
- /**
4060
- * Pushes a chunk to be unzlibbed
4061
- * @param chunk The chunk to push
4062
- * @param final Whether this is the last chunk
4063
- */
4064
- push(chunk, final) {
4065
- Inflate.prototype.e.call(this, chunk);
4066
- if (this.v) {
4067
- if (this.p.length < 2 && !final) return;
4068
- this.p = this.p.subarray(2), this.v = 0;
4069
- }
4070
- if (final) {
4071
- if (this.p.length < 4) err(6, "invalid zlib data");
4072
- this.p = this.p.subarray(0, -4);
4073
- }
4074
- Inflate.prototype.c.call(this, final);
4075
- }
4076
- };
4077
- }
4078
- });
4079
-
4080
- // ../compression/src/lib/fflate-stream.ts
4081
- async function* transformFflateBatches(processor, inputBatches) {
4082
- const chunks = [];
4083
- processor.ondata = (data) => {
4084
- chunks.push(data.slice().buffer);
4085
- };
4086
- for await (const batch of inputBatches) {
4087
- processor.push(new Uint8Array(batch), false);
4088
- yield* chunks.splice(0);
4089
- }
4090
- processor.push(new Uint8Array(0), true);
4091
- yield* chunks;
4092
- }
4093
- var init_fflate_stream = __esm({
4094
- "../compression/src/lib/fflate-stream.ts"() {
4095
- "use strict";
4096
- }
4097
- });
4098
-
4099
- // ../compression/src/deflate-decompressor-fflate.ts
4100
- var DeflateFflateDecompressor;
4101
- var init_deflate_decompressor_fflate = __esm({
4102
- "../compression/src/deflate-decompressor-fflate.ts"() {
4103
- "use strict";
4104
- init_fflate();
4105
- init_compression();
4106
- init_fflate_stream();
4107
- DeflateFflateDecompressor = class extends Decompressor {
4108
- name = "deflate";
4109
- extensions = [];
4110
- contentEncodings = ["deflate"];
4111
- isSupported = true;
4112
- options;
4113
- constructor(options = {}) {
4114
- super(options);
4115
- this.options = options;
4116
- }
4117
- /** Decompresses one zlib-wrapped DEFLATE payload synchronously. */
4118
- decompressSync(input) {
4119
- const bytes = new Uint8Array(input);
4120
- const output = this.options.raw ? inflateSync(bytes) : unzlibSync(bytes);
4121
- return output.slice().buffer;
4122
- }
4123
- /** Decompresses DEFLATE batches incrementally. */
4124
- async *decompressBatches(inputBatches) {
4125
- const processor = this.options.raw ? new Inflate() : new Unzlib();
4126
- yield* transformFflateBatches(processor, inputBatches);
4127
- }
4128
- };
4129
- }
4130
- });
4131
-
4132
- // ../compression/src/deflate-decompressor.ts
4133
- var deflate_decompressor_exports = {};
4134
- __export(deflate_decompressor_exports, {
4135
- DeflateDecompressor: () => DeflateDecompressor
4136
- });
4137
- var DeflateDecompressor;
4138
- var init_deflate_decompressor = __esm({
4139
- "../compression/src/deflate-decompressor.ts"() {
4140
- "use strict";
4141
- init_deflate_decompressor_fflate();
4142
- init_decompression_stream();
4143
- DeflateDecompressor = class extends DeflateFflateDecompressor {
4144
- constructor(options = {}) {
4145
- super(options);
4146
- }
4147
- /** Decompresses with the built-in stream when available, then falls back to fflate. */
4148
- async decompress(input) {
4149
- if (this.options.useNative !== false) {
4150
- const format = this.options.raw ? "deflate-raw" : "deflate";
4151
- const output = await decompressWithNativeDecompressionStream(input, format);
4152
- if (output) return output;
4153
- }
4154
- return this.decompressSync(input);
4155
- }
4156
- /** Decompresses batches with a built-in or fflate stream. */
4157
- async *decompressBatches(inputBatches) {
4158
- if (this.options.useNative !== false) {
4159
- const format = this.options.raw ? "deflate-raw" : "deflate";
4160
- const output = decompressBatchesWithNativeDecompressionStream(inputBatches, format);
4161
- if (output) {
4162
- yield* output;
4163
- return;
4164
- }
4165
- }
4166
- yield* super.decompressBatches(inputBatches);
4167
- }
4168
- };
4169
- }
4170
- });
4171
-
4172
- // ../compression/src/gzip-decompressor-fflate.ts
4173
- var GZipFflateDecompressor;
4174
- var init_gzip_decompressor_fflate = __esm({
4175
- "../compression/src/gzip-decompressor-fflate.ts"() {
4176
- "use strict";
4177
- init_fflate();
4178
- init_compression();
4179
- init_fflate_stream();
4180
- GZipFflateDecompressor = class extends Decompressor {
4181
- name = "gzip";
4182
- extensions = ["gz", "gzip"];
4183
- contentEncodings = ["gzip", "x-gzip"];
4184
- isSupported = true;
4185
- constructor(options = {}) {
4186
- super(options);
4187
- }
4188
- /** Decompresses one GZIP payload synchronously. */
4189
- decompressSync(input) {
4190
- return gunzipSync(new Uint8Array(input)).slice().buffer;
4191
- }
4192
- /** Decompresses GZIP batches incrementally. */
4193
- async *decompressBatches(inputBatches) {
4194
- yield* transformFflateBatches(new Gunzip(), inputBatches);
4195
- }
4196
- };
4197
- }
4198
- });
4199
-
4200
- // ../compression/src/gzip-decompressor.ts
4201
- var gzip_decompressor_exports = {};
4202
- __export(gzip_decompressor_exports, {
4203
- GZipDecompressor: () => GZipDecompressor
4204
- });
4205
- var GZipDecompressor;
4206
- var init_gzip_decompressor = __esm({
4207
- "../compression/src/gzip-decompressor.ts"() {
4208
- "use strict";
4209
- init_gzip_decompressor_fflate();
4210
- init_decompression_stream();
4211
- GZipDecompressor = class extends GZipFflateDecompressor {
4212
- options;
4213
- constructor(options = {}) {
4214
- super(options);
4215
- this.options = options;
4216
- }
4217
- /** Decompresses with the built-in stream when available, then falls back to fflate. */
4218
- async decompress(input) {
4219
- if (this.options.useNative !== false) {
4220
- const output = await decompressWithNativeDecompressionStream(input, "gzip");
4221
- if (output) return output;
4222
- }
4223
- return this.decompressSync(input);
4224
- }
4225
- /** Decompresses batches with a built-in or fflate stream. */
4226
- async *decompressBatches(inputBatches) {
4227
- if (this.options.useNative !== false) {
4228
- const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
4229
- if (output) {
4230
- yield* output;
4231
- return;
4232
- }
4233
- }
4234
- yield* super.decompressBatches(inputBatches);
4235
- }
4236
- };
4237
- }
4238
- });
4239
-
4240
- // ../compression/src/brotli/decode.ts
4241
- var makeBrotliDecode, BrotliDecode;
4242
- var init_decode = __esm({
4243
- "../compression/src/brotli/decode.ts"() {
4244
- "use strict";
4245
- makeBrotliDecode = () => {
4246
- function InputStream(bytes) {
4247
- this.data = bytes;
4248
- this.offset = 0;
4249
- }
4250
- let MAX_HUFFMAN_TABLE_SIZE = Int32Array.from([
4251
- 256,
4252
- 402,
4253
- 436,
4254
- 468,
4255
- 500,
4256
- 534,
4257
- 566,
4258
- 598,
4259
- 630,
4260
- 662,
4261
- 694,
4262
- 726,
4263
- 758,
4264
- 790,
4265
- 822,
4266
- 854,
4267
- 886,
4268
- 920,
4269
- 952,
4270
- 984,
4271
- 1016,
4272
- 1048,
4273
- 1080
4274
- ]);
4275
- let CODE_LENGTH_CODE_ORDER = Int32Array.from([
4276
- 1,
4277
- 2,
4278
- 3,
4279
- 4,
4280
- 0,
4281
- 5,
4282
- 17,
4283
- 6,
4284
- 16,
4285
- 7,
4286
- 8,
4287
- 9,
4288
- 10,
4289
- 11,
4290
- 12,
4291
- 13,
4292
- 14,
4293
- 15
4294
- ]);
4295
- let DISTANCE_SHORT_CODE_INDEX_OFFSET = Int32Array.from([
4296
- 0,
4297
- 3,
4298
- 2,
4299
- 1,
4300
- 0,
4301
- 0,
4302
- 0,
4303
- 0,
4304
- 0,
4305
- 0,
4306
- 3,
4307
- 3,
4308
- 3,
4309
- 3,
4310
- 3,
4311
- 3
4312
- ]);
4313
- let DISTANCE_SHORT_CODE_VALUE_OFFSET = Int32Array.from([
4314
- 0,
4315
- 0,
4316
- 0,
4317
- 0,
4318
- -1,
4319
- 1,
4320
- -2,
4321
- 2,
4322
- -3,
4323
- 3,
4324
- -1,
4325
- 1,
4326
- -2,
4327
- 2,
4328
- -3,
4329
- 3
4330
- ]);
4331
- let FIXED_TABLE = Int32Array.from([
4332
- 131072,
4333
- 131076,
4334
- 131075,
4335
- 196610,
4336
- 131072,
4337
- 131076,
4338
- 131075,
4339
- 262145,
4340
- 131072,
4341
- 131076,
4342
- 131075,
4343
- 196610,
4344
- 131072,
4345
- 131076,
4346
- 131075,
4347
- 262149
4348
- ]);
4349
- let BLOCK_LENGTH_OFFSET = Int32Array.from([
4350
- 1,
4351
- 5,
4352
- 9,
4353
- 13,
4354
- 17,
4355
- 25,
4356
- 33,
4357
- 41,
4358
- 49,
4359
- 65,
4360
- 81,
4361
- 97,
4362
- 113,
4363
- 145,
4364
- 177,
4365
- 209,
4366
- 241,
4367
- 305,
4368
- 369,
4369
- 497,
4370
- 753,
4371
- 1265,
4372
- 2289,
4373
- 4337,
4374
- 8433,
4375
- 16625
4376
- ]);
4377
- let BLOCK_LENGTH_N_BITS = Int32Array.from([
4378
- 2,
4379
- 2,
4380
- 2,
4381
- 2,
4382
- 3,
4383
- 3,
4384
- 3,
4385
- 3,
4386
- 4,
4387
- 4,
4388
- 4,
4389
- 4,
4390
- 5,
4391
- 5,
4392
- 5,
4393
- 5,
4394
- 6,
4395
- 6,
4396
- 7,
4397
- 8,
4398
- 9,
4399
- 10,
4400
- 11,
4401
- 12,
4402
- 13,
4403
- 24
4404
- ]);
4405
- let INSERT_LENGTH_N_BITS = Int16Array.from([
4406
- 0,
4407
- 0,
4408
- 0,
4409
- 0,
4410
- 0,
4411
- 0,
4412
- 1,
4413
- 1,
4414
- 2,
4415
- 2,
4416
- 3,
4417
- 3,
4418
- 4,
4419
- 4,
4420
- 5,
4421
- 5,
4422
- 6,
4423
- 7,
4424
- 8,
4425
- 9,
4426
- 10,
4427
- 12,
4428
- 14,
4429
- 24
4430
- ]);
4431
- let COPY_LENGTH_N_BITS = Int16Array.from([
4432
- 0,
4433
- 0,
4434
- 0,
4435
- 0,
4436
- 0,
4437
- 0,
4438
- 0,
4439
- 0,
4440
- 1,
4441
- 1,
4442
- 2,
4443
- 2,
4444
- 3,
4445
- 3,
4446
- 4,
4447
- 4,
4448
- 5,
4449
- 5,
4450
- 6,
4451
- 7,
4452
- 8,
4453
- 9,
4454
- 10,
4455
- 24
4456
- ]);
4457
- let CMD_LOOKUP = new Int16Array(2816);
4458
- {
4459
- unpackCommandLookupTable(CMD_LOOKUP);
4460
- }
4461
- function log2floor(i) {
4462
- let result = -1;
4463
- let step = 16;
4464
- while (step > 0) {
4465
- if (i >>> step !== 0) {
4466
- result += step;
4467
- i = i >>> step;
4468
- }
4469
- step = step >> 1;
4470
- }
4471
- return result + i;
4472
- }
4473
- function calculateDistanceAlphabetSize(npostfix, ndirect, maxndistbits) {
4474
- return 16 + ndirect + 2 * (maxndistbits << npostfix);
4475
- }
4476
- function calculateDistanceAlphabetLimit(maxDistance, npostfix, ndirect) {
4477
- if (maxDistance < ndirect + (2 << npostfix)) {
4478
- throw "maxDistance is too small";
4479
- }
4480
- let offset = (maxDistance - ndirect >> npostfix) + 4;
4481
- let ndistbits = log2floor(offset) - 1;
4482
- let group = ndistbits - 1 << 1 | offset >> ndistbits & 1;
4483
- return (group - 1 << npostfix) + (1 << npostfix) + ndirect + 16;
4484
- }
4485
- function unpackCommandLookupTable(cmdLookup) {
4486
- let insertLengthOffsets = new Int16Array(24);
4487
- let copyLengthOffsets = new Int16Array(24);
4488
- copyLengthOffsets[0] = 2;
4489
- for (let i = 0; i < 23; ++i) {
4490
- insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]);
4491
- copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]);
4492
- }
4493
- for (let cmdCode = 0; cmdCode < 704; ++cmdCode) {
4494
- let rangeIdx = cmdCode >>> 6;
4495
- let distanceContextOffset = -4;
4496
- if (rangeIdx >= 2) {
4497
- rangeIdx -= 2;
4498
- distanceContextOffset = 0;
4499
- }
4500
- let insertCode = (170064 >>> rangeIdx * 2 & 3) << 3 | cmdCode >>> 3 & 7;
4501
- let copyCode = (156228 >>> rangeIdx * 2 & 3) << 3 | cmdCode & 7;
4502
- let copyLengthOffset = copyLengthOffsets[copyCode];
4503
- let distanceContext = distanceContextOffset + (copyLengthOffset > 4 ? 3 : copyLengthOffset - 2);
4504
- let index = cmdCode * 4;
4505
- cmdLookup[index + 0] = INSERT_LENGTH_N_BITS[insertCode] | COPY_LENGTH_N_BITS[copyCode] << 8;
4506
- cmdLookup[index + 1] = insertLengthOffsets[insertCode];
4507
- cmdLookup[index + 2] = copyLengthOffsets[copyCode];
4508
- cmdLookup[index + 3] = distanceContext;
4509
- }
4510
- }
4511
- function decodeWindowBits(s) {
4512
- let largeWindowEnabled = s.isLargeWindow;
4513
- s.isLargeWindow = 0;
4514
- if (s.bitOffset >= 16) {
4515
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4516
- s.bitOffset -= 16;
4517
- }
4518
- if (readFewBits(s, 1) === 0) {
4519
- return 16;
4520
- }
4521
- let n = readFewBits(s, 3);
4522
- if (n !== 0) {
4523
- return 17 + n;
4524
- }
4525
- n = readFewBits(s, 3);
4526
- if (n !== 0) {
4527
- if (n === 1) {
4528
- if (largeWindowEnabled === 0) {
4529
- return -1;
4530
- }
4531
- s.isLargeWindow = 1;
4532
- if (readFewBits(s, 1) === 1) {
4533
- return -1;
4534
- }
4535
- n = readFewBits(s, 6);
4536
- if (n < 10 || n > 30) {
4537
- return -1;
4538
- }
4539
- return n;
4540
- } else {
4541
- return 8 + n;
4542
- }
4543
- }
4544
- return 17;
4545
- }
4546
- function _enableEagerOutput(s) {
4547
- if (s.runningState !== 1) {
4548
- throw "State MUST be freshly initialized";
4549
- }
4550
- s.isEager = 1;
4551
- }
4552
- function _enableLargeWindow(s) {
4553
- if (s.runningState !== 1) {
4554
- throw "State MUST be freshly initialized";
4555
- }
4556
- s.isLargeWindow = 1;
4557
- }
4558
- function attachDictionaryChunk(s, data2) {
4559
- if (s.runningState !== 1) {
4560
- throw "State MUST be freshly initialized";
4561
- }
4562
- if (s.cdNumChunks === 0) {
4563
- s.cdChunks = new Array(16);
4564
- s.cdChunkOffsets = new Int32Array(16);
4565
- s.cdBlockBits = -1;
4566
- }
4567
- if (s.cdNumChunks === 15) {
4568
- throw "Too many dictionary chunks";
4569
- }
4570
- s.cdChunks[s.cdNumChunks] = data2;
4571
- s.cdNumChunks++;
4572
- s.cdTotalSize += data2.length;
4573
- s.cdChunkOffsets[s.cdNumChunks] = s.cdTotalSize;
4574
- }
4575
- function initState(s, input) {
4576
- if (s.runningState !== 0) {
4577
- throw "State MUST be uninitialized";
4578
- }
4579
- s.blockTrees = new Int32Array(3091);
4580
- s.blockTrees[0] = 7;
4581
- s.distRbIdx = 3;
4582
- let maxDistanceAlphabetLimit = calculateDistanceAlphabetLimit(
4583
- 2147483644,
4584
- 3,
4585
- 15 << 3
4586
- );
4587
- s.distExtraBits = new Int8Array(maxDistanceAlphabetLimit);
4588
- s.distOffset = new Int32Array(maxDistanceAlphabetLimit);
4589
- s.input = input;
4590
- initBitReader(s);
4591
- s.runningState = 1;
4592
- }
4593
- function close(s) {
4594
- if (s.runningState === 0) {
4595
- throw "State MUST be initialized";
4596
- }
4597
- if (s.runningState === 11) {
4598
- return;
4599
- }
4600
- s.runningState = 11;
4601
- if (s.input != null) {
4602
- closeInput(s.input);
4603
- s.input = null;
4604
- }
4605
- }
4606
- function decodeVarLenUnsignedByte(s) {
4607
- if (s.bitOffset >= 16) {
4608
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4609
- s.bitOffset -= 16;
4610
- }
4611
- if (readFewBits(s, 1) !== 0) {
4612
- let n = readFewBits(s, 3);
4613
- if (n === 0) {
4614
- return 1;
4615
- } else {
4616
- return readFewBits(s, n) + (1 << n);
4617
- }
4618
- }
4619
- return 0;
4620
- }
4621
- function decodeMetaBlockLength(s) {
4622
- if (s.bitOffset >= 16) {
4623
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4624
- s.bitOffset -= 16;
4625
- }
4626
- s.inputEnd = readFewBits(s, 1);
4627
- s.metaBlockLength = 0;
4628
- s.isUncompressed = 0;
4629
- s.isMetadata = 0;
4630
- if (s.inputEnd !== 0 && readFewBits(s, 1) !== 0) {
4631
- return;
4632
- }
4633
- let sizeNibbles = readFewBits(s, 2) + 4;
4634
- if (sizeNibbles === 7) {
4635
- s.isMetadata = 1;
4636
- if (readFewBits(s, 1) !== 0) {
4637
- throw "Corrupted reserved bit";
4638
- }
4639
- let sizeBytes = readFewBits(s, 2);
4640
- if (sizeBytes === 0) {
4641
- return;
4642
- }
4643
- for (let i = 0; i < sizeBytes; i++) {
4644
- if (s.bitOffset >= 16) {
4645
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4646
- s.bitOffset -= 16;
4647
- }
4648
- let bits2 = readFewBits(s, 8);
4649
- if (bits2 === 0 && i + 1 === sizeBytes && sizeBytes > 1) {
4650
- throw "Exuberant nibble";
4651
- }
4652
- s.metaBlockLength |= bits2 << i * 8;
4653
- }
4654
- } else {
4655
- for (let i = 0; i < sizeNibbles; i++) {
4656
- if (s.bitOffset >= 16) {
4657
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4658
- s.bitOffset -= 16;
4659
- }
4660
- let bits2 = readFewBits(s, 4);
4661
- if (bits2 === 0 && i + 1 === sizeNibbles && sizeNibbles > 4) {
4662
- throw "Exuberant nibble";
4663
- }
4664
- s.metaBlockLength |= bits2 << i * 4;
4665
- }
4666
- }
4667
- s.metaBlockLength++;
4668
- if (s.inputEnd === 0) {
4669
- s.isUncompressed = readFewBits(s, 1);
4670
- }
4671
- }
4672
- function readSymbol(tableGroup, tableIdx, s) {
4673
- let offset = tableGroup[tableIdx];
4674
- let val = s.accumulator32 >>> s.bitOffset;
4675
- offset += val & 255;
4676
- let bits2 = tableGroup[offset] >> 16;
4677
- let sym = tableGroup[offset] & 65535;
4678
- if (bits2 <= 8) {
4679
- s.bitOffset += bits2;
4680
- return sym;
4681
- }
4682
- offset += sym;
4683
- let mask = (1 << bits2) - 1;
4684
- offset += (val & mask) >>> 8;
4685
- s.bitOffset += (tableGroup[offset] >> 16) + 8;
4686
- return tableGroup[offset] & 65535;
4687
- }
4688
- function readBlockLength(tableGroup, tableIdx, s) {
4689
- if (s.bitOffset >= 16) {
4690
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4691
- s.bitOffset -= 16;
4692
- }
4693
- let code = readSymbol(tableGroup, tableIdx, s);
4694
- let n = BLOCK_LENGTH_N_BITS[code];
4695
- if (s.bitOffset >= 16) {
4696
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4697
- s.bitOffset -= 16;
4698
- }
4699
- return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
4700
- }
4701
- function moveToFront(v, index) {
4702
- let value = v[index];
4703
- for (; index > 0; index--) {
4704
- v[index] = v[index - 1];
4705
- }
4706
- v[0] = value;
4707
- }
4708
- function inverseMoveToFrontTransform(v, vLen) {
4709
- let mtf = new Int32Array(256);
4710
- for (let i = 0; i < 256; i++) {
4711
- mtf[i] = i;
4712
- }
4713
- for (let i = 0; i < vLen; i++) {
4714
- let index = v[i] & 255;
4715
- v[i] = mtf[index];
4716
- if (index !== 0) {
4717
- moveToFront(mtf, index);
4718
- }
4719
- }
4720
- }
4721
- function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths, s) {
4722
- let symbol = 0;
4723
- let prevCodeLen = 8;
4724
- let repeat = 0;
4725
- let repeatCodeLen = 0;
4726
- let space = 32768;
4727
- let table = new Int32Array(32 + 1);
4728
- let tableIdx = table.length - 1;
4729
- buildHuffmanTable(table, tableIdx, 5, codeLengthCodeLengths, 18);
4730
- while (symbol < numSymbols && space > 0) {
4731
- if (s.halfOffset > 2030) {
4732
- doReadMoreInput(s);
4733
- }
4734
- if (s.bitOffset >= 16) {
4735
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4736
- s.bitOffset -= 16;
4737
- }
4738
- let p = s.accumulator32 >>> s.bitOffset & 31;
4739
- s.bitOffset += table[p] >> 16;
4740
- let codeLen = table[p] & 65535;
4741
- if (codeLen < 16) {
4742
- repeat = 0;
4743
- codeLengths[symbol++] = codeLen;
4744
- if (codeLen !== 0) {
4745
- prevCodeLen = codeLen;
4746
- space -= 32768 >> codeLen;
4747
- }
4748
- } else {
4749
- let extraBits = codeLen - 14;
4750
- let newLen = 0;
4751
- if (codeLen === 16) {
4752
- newLen = prevCodeLen;
4753
- }
4754
- if (repeatCodeLen !== newLen) {
4755
- repeat = 0;
4756
- repeatCodeLen = newLen;
4757
- }
4758
- let oldRepeat = repeat;
4759
- if (repeat > 0) {
4760
- repeat -= 2;
4761
- repeat <<= extraBits;
4762
- }
4763
- if (s.bitOffset >= 16) {
4764
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4765
- s.bitOffset -= 16;
4766
- }
4767
- repeat += readFewBits(s, extraBits) + 3;
4768
- let repeatDelta = repeat - oldRepeat;
4769
- if (symbol + repeatDelta > numSymbols) {
4770
- throw "symbol + repeatDelta > numSymbols";
4771
- }
4772
- for (let i = 0; i < repeatDelta; i++) {
4773
- codeLengths[symbol++] = repeatCodeLen;
4774
- }
4775
- if (repeatCodeLen !== 0) {
4776
- space -= repeatDelta << 15 - repeatCodeLen;
4777
- }
4778
- }
4779
- }
4780
- if (space !== 0) {
4781
- throw "Unused space";
4782
- }
4783
- codeLengths.fill(0, symbol, numSymbols);
4784
- }
4785
- function checkDupes(symbols, length) {
4786
- for (let i = 0; i < length - 1; ++i) {
4787
- for (let j = i + 1; j < length; ++j) {
4788
- if (symbols[i] === symbols[j]) {
4789
- throw "Duplicate simple Huffman code symbol";
4790
- }
4791
- }
4792
- }
4793
- }
4794
- function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
4795
- let codeLengths = new Int32Array(alphabetSizeLimit);
4796
- let symbols = new Int32Array(4);
4797
- let maxBits = 1 + log2floor(alphabetSizeMax - 1);
4798
- let numSymbols = readFewBits(s, 2) + 1;
4799
- for (let i = 0; i < numSymbols; i++) {
4800
- if (s.bitOffset >= 16) {
4801
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4802
- s.bitOffset -= 16;
4803
- }
4804
- let symbol = readFewBits(s, maxBits);
4805
- if (symbol >= alphabetSizeLimit) {
4806
- throw "Can't readHuffmanCode";
4807
- }
4808
- symbols[i] = symbol;
4809
- }
4810
- checkDupes(symbols, numSymbols);
4811
- let histogramId = numSymbols;
4812
- if (numSymbols === 4) {
4813
- histogramId += readFewBits(s, 1);
4814
- }
4815
- switch (histogramId) {
4816
- case 1:
4817
- codeLengths[symbols[0]] = 1;
4818
- break;
4819
- case 2:
4820
- codeLengths[symbols[0]] = 1;
4821
- codeLengths[symbols[1]] = 1;
4822
- break;
4823
- case 3:
4824
- codeLengths[symbols[0]] = 1;
4825
- codeLengths[symbols[1]] = 2;
4826
- codeLengths[symbols[2]] = 2;
4827
- break;
4828
- case 4:
4829
- codeLengths[symbols[0]] = 2;
4830
- codeLengths[symbols[1]] = 2;
4831
- codeLengths[symbols[2]] = 2;
4832
- codeLengths[symbols[3]] = 2;
4833
- break;
4834
- case 5:
4835
- codeLengths[symbols[0]] = 1;
4836
- codeLengths[symbols[1]] = 2;
4837
- codeLengths[symbols[2]] = 3;
4838
- codeLengths[symbols[3]] = 3;
4839
- break;
4840
- default:
4841
- break;
4842
- }
4843
- return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
4844
- }
4845
- function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
4846
- let codeLengths = new Int32Array(alphabetSizeLimit);
4847
- let codeLengthCodeLengths = new Int32Array(18);
4848
- let space = 32;
4849
- let numCodes = 0;
4850
- for (let i = skip; i < 18 && space > 0; i++) {
4851
- let codeLenIdx = CODE_LENGTH_CODE_ORDER[i];
4852
- if (s.bitOffset >= 16) {
4853
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4854
- s.bitOffset -= 16;
4855
- }
4856
- let p = s.accumulator32 >>> s.bitOffset & 15;
4857
- s.bitOffset += FIXED_TABLE[p] >> 16;
4858
- let v = FIXED_TABLE[p] & 65535;
4859
- codeLengthCodeLengths[codeLenIdx] = v;
4860
- if (v !== 0) {
4861
- space -= 32 >> v;
4862
- numCodes++;
4863
- }
4864
- }
4865
- if (space !== 0 && numCodes !== 1) {
4866
- throw "Corrupted Huffman code histogram";
4867
- }
4868
- readHuffmanCodeLengths(codeLengthCodeLengths, alphabetSizeLimit, codeLengths, s);
4869
- return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
4870
- }
4871
- function readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
4872
- if (s.halfOffset > 2030) {
4873
- doReadMoreInput(s);
4874
- }
4875
- if (s.bitOffset >= 16) {
4876
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4877
- s.bitOffset -= 16;
4878
- }
4879
- let simpleCodeOrSkip = readFewBits(s, 2);
4880
- if (simpleCodeOrSkip === 1) {
4881
- return readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s);
4882
- } else {
4883
- return readComplexHuffmanCode(alphabetSizeLimit, simpleCodeOrSkip, tableGroup, tableIdx, s);
4884
- }
4885
- }
4886
- function decodeContextMap(contextMapSize, contextMap, s) {
4887
- if (s.halfOffset > 2030) {
4888
- doReadMoreInput(s);
4889
- }
4890
- let numTrees = decodeVarLenUnsignedByte(s) + 1;
4891
- if (numTrees === 1) {
4892
- contextMap.fill(0, 0, contextMapSize);
4893
- return numTrees;
4894
- }
4895
- if (s.bitOffset >= 16) {
4896
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4897
- s.bitOffset -= 16;
4898
- }
4899
- let useRleForZeros = readFewBits(s, 1);
4900
- let maxRunLengthPrefix = 0;
4901
- if (useRleForZeros !== 0) {
4902
- maxRunLengthPrefix = readFewBits(s, 4) + 1;
4903
- }
4904
- let alphabetSize = numTrees + maxRunLengthPrefix;
4905
- let tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
4906
- let table = new Int32Array(tableSize + 1);
4907
- let tableIdx = table.length - 1;
4908
- readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
4909
- for (let i = 0; i < contextMapSize; ) {
4910
- if (s.halfOffset > 2030) {
4911
- doReadMoreInput(s);
4912
- }
4913
- if (s.bitOffset >= 16) {
4914
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4915
- s.bitOffset -= 16;
4916
- }
4917
- let code = readSymbol(table, tableIdx, s);
4918
- if (code === 0) {
4919
- contextMap[i] = 0;
4920
- i++;
4921
- } else if (code <= maxRunLengthPrefix) {
4922
- if (s.bitOffset >= 16) {
4923
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4924
- s.bitOffset -= 16;
4925
- }
4926
- let reps = (1 << code) + readFewBits(s, code);
4927
- while (reps !== 0) {
4928
- if (i >= contextMapSize) {
4929
- throw "Corrupted context map";
4930
- }
4931
- contextMap[i] = 0;
4932
- i++;
4933
- reps--;
4934
- }
4935
- } else {
4936
- contextMap[i] = code - maxRunLengthPrefix;
4937
- i++;
4938
- }
4939
- }
4940
- if (s.bitOffset >= 16) {
4941
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4942
- s.bitOffset -= 16;
4943
- }
4944
- if (readFewBits(s, 1) === 1) {
4945
- inverseMoveToFrontTransform(contextMap, contextMapSize);
4946
- }
4947
- return numTrees;
4948
- }
4949
- function decodeBlockTypeAndLength(s, treeType, numBlockTypes) {
4950
- let ringBuffers = s.rings;
4951
- let offset = 4 + treeType * 2;
4952
- if (s.bitOffset >= 16) {
4953
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
4954
- s.bitOffset -= 16;
4955
- }
4956
- let blockType = readSymbol(s.blockTrees, 2 * treeType, s);
4957
- let result = readBlockLength(s.blockTrees, 2 * treeType + 1, s);
4958
- if (blockType === 1) {
4959
- blockType = ringBuffers[offset + 1] + 1;
4960
- } else if (blockType === 0) {
4961
- blockType = ringBuffers[offset];
4962
- } else {
4963
- blockType -= 2;
4964
- }
4965
- if (blockType >= numBlockTypes) {
4966
- blockType -= numBlockTypes;
4967
- }
4968
- ringBuffers[offset] = ringBuffers[offset + 1];
4969
- ringBuffers[offset + 1] = blockType;
4970
- return result;
4971
- }
4972
- function decodeLiteralBlockSwitch(s) {
4973
- s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
4974
- let literalBlockType = s.rings[5];
4975
- s.contextMapSlice = literalBlockType << 6;
4976
- s.literalTreeIdx = s.contextMap[s.contextMapSlice] & 255;
4977
- let contextMode = s.contextModes[literalBlockType];
4978
- s.contextLookupOffset1 = contextMode << 9;
4979
- s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
4980
- }
4981
- function decodeCommandBlockSwitch(s) {
4982
- s.commandBlockLength = decodeBlockTypeAndLength(s, 1, s.numCommandBlockTypes);
4983
- s.commandTreeIdx = s.rings[7];
4984
- }
4985
- function decodeDistanceBlockSwitch(s) {
4986
- s.distanceBlockLength = decodeBlockTypeAndLength(s, 2, s.numDistanceBlockTypes);
4987
- s.distContextMapSlice = s.rings[9] << 2;
4988
- }
4989
- function maybeReallocateRingBuffer(s) {
4990
- let newSize = s.maxRingBufferSize;
4991
- if (newSize > s.expectedTotalSize) {
4992
- let minimalNewSize = s.expectedTotalSize;
4993
- while (newSize >> 1 > minimalNewSize) {
4994
- newSize >>= 1;
4995
- }
4996
- if (s.inputEnd === 0 && newSize < 16384 && s.maxRingBufferSize >= 16384) {
4997
- newSize = 16384;
4998
- }
4999
- }
5000
- if (newSize <= s.ringBufferSize) {
5001
- return;
5002
- }
5003
- let ringBufferSizeWithSlack = newSize + 37;
5004
- let newBuffer = new Int8Array(ringBufferSizeWithSlack);
5005
- if (s.ringBuffer.length !== 0) {
5006
- newBuffer.set(s.ringBuffer.subarray(0, 0 + s.ringBufferSize), 0);
5007
- }
5008
- s.ringBuffer = newBuffer;
5009
- s.ringBufferSize = newSize;
5010
- }
5011
- function readNextMetablockHeader(s) {
5012
- if (s.inputEnd !== 0) {
5013
- s.nextRunningState = 10;
5014
- s.runningState = 12;
5015
- return;
5016
- }
5017
- s.literalTreeGroup = new Int32Array(0);
5018
- s.commandTreeGroup = new Int32Array(0);
5019
- s.distanceTreeGroup = new Int32Array(0);
5020
- if (s.halfOffset > 2030) {
5021
- doReadMoreInput(s);
5022
- }
5023
- decodeMetaBlockLength(s);
5024
- if (s.metaBlockLength === 0 && s.isMetadata === 0) {
5025
- return;
5026
- }
5027
- if (s.isUncompressed !== 0 || s.isMetadata !== 0) {
5028
- jumpToByteBoundary(s);
5029
- s.runningState = s.isMetadata !== 0 ? 5 : 6;
5030
- } else {
5031
- s.runningState = 3;
5032
- }
5033
- if (s.isMetadata !== 0) {
5034
- return;
5035
- }
5036
- s.expectedTotalSize += s.metaBlockLength;
5037
- if (s.expectedTotalSize > 1 << 30) {
5038
- s.expectedTotalSize = 1 << 30;
5039
- }
5040
- if (s.ringBufferSize < s.maxRingBufferSize) {
5041
- maybeReallocateRingBuffer(s);
5042
- }
5043
- }
5044
- function readMetablockPartition(s, treeType, numBlockTypes) {
5045
- let offset = s.blockTrees[2 * treeType];
5046
- if (numBlockTypes <= 1) {
5047
- s.blockTrees[2 * treeType + 1] = offset;
5048
- s.blockTrees[2 * treeType + 2] = offset;
5049
- return 1 << 28;
5050
- }
5051
- let blockTypeAlphabetSize = numBlockTypes + 2;
5052
- offset += readHuffmanCode(
5053
- blockTypeAlphabetSize,
5054
- blockTypeAlphabetSize,
5055
- s.blockTrees,
5056
- 2 * treeType,
5057
- s
5058
- );
5059
- s.blockTrees[2 * treeType + 1] = offset;
5060
- let blockLengthAlphabetSize = 26;
5061
- offset += readHuffmanCode(
5062
- blockLengthAlphabetSize,
5063
- blockLengthAlphabetSize,
5064
- s.blockTrees,
5065
- 2 * treeType + 1,
5066
- s
5067
- );
5068
- s.blockTrees[2 * treeType + 2] = offset;
5069
- return readBlockLength(s.blockTrees, 2 * treeType + 1, s);
5070
- }
5071
- function calculateDistanceLut(s, alphabetSizeLimit) {
5072
- let distExtraBits = s.distExtraBits;
5073
- let distOffset = s.distOffset;
5074
- let npostfix = s.distancePostfixBits;
5075
- let ndirect = s.numDirectDistanceCodes;
5076
- let postfix = 1 << npostfix;
5077
- let bits2 = 1;
5078
- let half = 0;
5079
- let i = 16;
5080
- for (let j = 0; j < ndirect; ++j) {
5081
- distExtraBits[i] = 0;
5082
- distOffset[i] = j + 1;
5083
- ++i;
5084
- }
5085
- while (i < alphabetSizeLimit) {
5086
- let base = ndirect + ((2 + half << bits2) - 4 << npostfix) + 1;
5087
- for (let j = 0; j < postfix; ++j) {
5088
- distExtraBits[i] = bits2;
5089
- distOffset[i] = base + j;
5090
- ++i;
5091
- }
5092
- bits2 = bits2 + half;
5093
- half = half ^ 1;
5094
- }
5095
- }
5096
- function readMetablockHuffmanCodesAndContextMaps(s) {
5097
- s.numLiteralBlockTypes = decodeVarLenUnsignedByte(s) + 1;
5098
- s.literalBlockLength = readMetablockPartition(s, 0, s.numLiteralBlockTypes);
5099
- s.numCommandBlockTypes = decodeVarLenUnsignedByte(s) + 1;
5100
- s.commandBlockLength = readMetablockPartition(s, 1, s.numCommandBlockTypes);
5101
- s.numDistanceBlockTypes = decodeVarLenUnsignedByte(s) + 1;
5102
- s.distanceBlockLength = readMetablockPartition(s, 2, s.numDistanceBlockTypes);
5103
- if (s.halfOffset > 2030) {
5104
- doReadMoreInput(s);
5105
- }
5106
- if (s.bitOffset >= 16) {
5107
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5108
- s.bitOffset -= 16;
5109
- }
5110
- s.distancePostfixBits = readFewBits(s, 2);
5111
- s.numDirectDistanceCodes = readFewBits(s, 4) << s.distancePostfixBits;
5112
- s.contextModes = new Int8Array(s.numLiteralBlockTypes);
5113
- for (let i = 0; i < s.numLiteralBlockTypes; ) {
5114
- let limit = min(i + 96, s.numLiteralBlockTypes);
5115
- for (; i < limit; ++i) {
5116
- if (s.bitOffset >= 16) {
5117
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5118
- s.bitOffset -= 16;
5119
- }
5120
- s.contextModes[i] = readFewBits(s, 2);
5121
- }
5122
- if (s.halfOffset > 2030) {
5123
- doReadMoreInput(s);
5124
- }
5125
- }
5126
- s.contextMap = new Int8Array(s.numLiteralBlockTypes << 6);
5127
- let numLiteralTrees = decodeContextMap(
5128
- s.numLiteralBlockTypes << 6,
5129
- s.contextMap,
5130
- s
5131
- );
5132
- s.trivialLiteralContext = 1;
5133
- for (let j = 0; j < s.numLiteralBlockTypes << 6; j++) {
5134
- if (s.contextMap[j] !== j >> 6) {
5135
- s.trivialLiteralContext = 0;
5136
- break;
5137
- }
5138
- }
5139
- s.distContextMap = new Int8Array(s.numDistanceBlockTypes << 2);
5140
- let numDistTrees = decodeContextMap(
5141
- s.numDistanceBlockTypes << 2,
5142
- s.distContextMap,
5143
- s
5144
- );
5145
- s.literalTreeGroup = decodeHuffmanTreeGroup(256, 256, numLiteralTrees, s);
5146
- s.commandTreeGroup = decodeHuffmanTreeGroup(704, 704, s.numCommandBlockTypes, s);
5147
- let distanceAlphabetSizeMax = calculateDistanceAlphabetSize(
5148
- s.distancePostfixBits,
5149
- s.numDirectDistanceCodes,
5150
- 24
5151
- );
5152
- let distanceAlphabetSizeLimit = distanceAlphabetSizeMax;
5153
- if (s.isLargeWindow === 1) {
5154
- distanceAlphabetSizeMax = calculateDistanceAlphabetSize(
5155
- s.distancePostfixBits,
5156
- s.numDirectDistanceCodes,
5157
- 62
5158
- );
5159
- distanceAlphabetSizeLimit = calculateDistanceAlphabetLimit(
5160
- 2147483644,
5161
- s.distancePostfixBits,
5162
- s.numDirectDistanceCodes
5163
- );
5164
- }
5165
- s.distanceTreeGroup = decodeHuffmanTreeGroup(
5166
- distanceAlphabetSizeMax,
5167
- distanceAlphabetSizeLimit,
5168
- numDistTrees,
5169
- s
5170
- );
5171
- calculateDistanceLut(s, distanceAlphabetSizeLimit);
5172
- s.contextMapSlice = 0;
5173
- s.distContextMapSlice = 0;
5174
- s.contextLookupOffset1 = s.contextModes[0] * 512;
5175
- s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
5176
- s.literalTreeIdx = 0;
5177
- s.commandTreeIdx = 0;
5178
- s.rings[4] = 1;
5179
- s.rings[5] = 0;
5180
- s.rings[6] = 1;
5181
- s.rings[7] = 0;
5182
- s.rings[8] = 1;
5183
- s.rings[9] = 0;
5184
- }
5185
- function copyUncompressedData(s) {
5186
- let ringBuffer = s.ringBuffer;
5187
- if (s.metaBlockLength <= 0) {
5188
- reload(s);
5189
- s.runningState = 2;
5190
- return;
5191
- }
5192
- let chunkLength = min(s.ringBufferSize - s.pos, s.metaBlockLength);
5193
- copyRawBytes(s, ringBuffer, s.pos, chunkLength);
5194
- s.metaBlockLength -= chunkLength;
5195
- s.pos += chunkLength;
5196
- if (s.pos === s.ringBufferSize) {
5197
- s.nextRunningState = 6;
5198
- s.runningState = 12;
5199
- return;
5200
- }
5201
- reload(s);
5202
- s.runningState = 2;
5203
- }
5204
- function writeRingBuffer(s) {
5205
- let toWrite = min(
5206
- s.outputLength - s.outputUsed,
5207
- s.ringBufferBytesReady - s.ringBufferBytesWritten
5208
- );
5209
- if (toWrite !== 0) {
5210
- s.output.set(
5211
- s.ringBuffer.subarray(s.ringBufferBytesWritten, s.ringBufferBytesWritten + toWrite),
5212
- s.outputOffset + s.outputUsed
5213
- );
5214
- s.outputUsed += toWrite;
5215
- s.ringBufferBytesWritten += toWrite;
5216
- }
5217
- if (s.outputUsed < s.outputLength) {
5218
- return 1;
5219
- } else {
5220
- return 0;
5221
- }
5222
- }
5223
- function decodeHuffmanTreeGroup(alphabetSizeMax, alphabetSizeLimit, n, s) {
5224
- let maxTableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSizeLimit + 31 >> 5];
5225
- let group = new Int32Array(n + n * maxTableSize);
5226
- let next = n;
5227
- for (let i = 0; i < n; ++i) {
5228
- group[i] = next;
5229
- next += readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, group, i, s);
5230
- }
5231
- return group;
5232
- }
5233
- function calculateFence(s) {
5234
- let result = s.ringBufferSize;
5235
- if (s.isEager !== 0) {
5236
- result = min(result, s.ringBufferBytesWritten + s.outputLength - s.outputUsed);
5237
- }
5238
- return result;
5239
- }
5240
- function doUseDictionary(s, fence) {
5241
- if (s.distance > 2147483644) {
5242
- throw "Invalid backward reference";
5243
- }
5244
- let address = s.distance - s.maxDistance - 1 - s.cdTotalSize;
5245
- if (address < 0) {
5246
- initializeCompoundDictionaryCopy(s, -address - 1, s.copyLength);
5247
- s.runningState = 14;
5248
- } else {
5249
- let dictionaryData = (
5250
- /** @type{!Int8Array} */
5251
- data
5252
- );
5253
- let wordLength = s.copyLength;
5254
- if (wordLength > 31) {
5255
- throw "Invalid backward reference";
5256
- }
5257
- let shift = sizeBits[wordLength];
5258
- if (shift === 0) {
5259
- throw "Invalid backward reference";
5260
- }
5261
- let offset = offsets[wordLength];
5262
- let mask = (1 << shift) - 1;
5263
- let wordIdx = address & mask;
5264
- let transformIdx = address >>> shift;
5265
- offset += wordIdx * wordLength;
5266
- let transforms = RFC_TRANSFORMS;
5267
- if (transformIdx >= transforms.numTransforms) {
5268
- throw "Invalid backward reference";
5269
- }
5270
- let len = transformDictionaryWord(
5271
- s.ringBuffer,
5272
- s.pos,
5273
- dictionaryData,
5274
- offset,
5275
- wordLength,
5276
- transforms,
5277
- transformIdx
5278
- );
5279
- s.pos += len;
5280
- s.metaBlockLength -= len;
5281
- if (s.pos >= fence) {
5282
- s.nextRunningState = 4;
5283
- s.runningState = 12;
5284
- return;
5285
- }
5286
- s.runningState = 4;
5287
- }
5288
- }
5289
- function initializeCompoundDictionary(s) {
5290
- s.cdBlockMap = new Int8Array(256);
5291
- let blockBits = 8;
5292
- while (s.cdTotalSize - 1 >>> blockBits !== 0) {
5293
- blockBits++;
5294
- }
5295
- blockBits -= 8;
5296
- s.cdBlockBits = blockBits;
5297
- let cursor = 0;
5298
- let index = 0;
5299
- while (cursor < s.cdTotalSize) {
5300
- while (s.cdChunkOffsets[index + 1] < cursor) {
5301
- index++;
5302
- }
5303
- s.cdBlockMap[cursor >>> blockBits] = index;
5304
- cursor += 1 << blockBits;
5305
- }
5306
- }
5307
- function initializeCompoundDictionaryCopy(s, address, length) {
5308
- if (s.cdBlockBits === -1) {
5309
- initializeCompoundDictionary(s);
5310
- }
5311
- let index = s.cdBlockMap[address >>> s.cdBlockBits];
5312
- while (address >= s.cdChunkOffsets[index + 1]) {
5313
- index++;
5314
- }
5315
- if (s.cdTotalSize > address + length) {
5316
- throw "Invalid backward reference";
5317
- }
5318
- s.distRbIdx = s.distRbIdx + 1 & 3;
5319
- s.rings[s.distRbIdx] = s.distance;
5320
- s.metaBlockLength -= length;
5321
- s.cdBrIndex = index;
5322
- s.cdBrOffset = address - s.cdChunkOffsets[index];
5323
- s.cdBrLength = length;
5324
- s.cdBrCopied = 0;
5325
- }
5326
- function copyFromCompoundDictionary(s, fence) {
5327
- let pos = s.pos;
5328
- let origPos = pos;
5329
- while (s.cdBrLength !== s.cdBrCopied) {
5330
- let space = fence - pos;
5331
- let chunkLength = s.cdChunkOffsets[s.cdBrIndex + 1] - s.cdChunkOffsets[s.cdBrIndex];
5332
- let remChunkLength = chunkLength - s.cdBrOffset;
5333
- let length = s.cdBrLength - s.cdBrCopied;
5334
- if (length > remChunkLength) {
5335
- length = remChunkLength;
5336
- }
5337
- if (length > space) {
5338
- length = space;
5339
- }
5340
- copyBytes(s.ringBuffer, pos, s.cdChunks[s.cdBrIndex], s.cdBrOffset, s.cdBrOffset + length);
5341
- pos += length;
5342
- s.cdBrOffset += length;
5343
- s.cdBrCopied += length;
5344
- if (length === remChunkLength) {
5345
- s.cdBrIndex++;
5346
- s.cdBrOffset = 0;
5347
- }
5348
- if (pos >= fence) {
5349
- break;
5350
- }
5351
- }
5352
- return pos - origPos;
5353
- }
5354
- function decompress4(s) {
5355
- if (s.runningState === 0) {
5356
- throw "Can't decompress until initialized";
5357
- }
5358
- if (s.runningState === 11) {
5359
- throw "Can't decompress after close";
5360
- }
5361
- if (s.runningState === 1) {
5362
- let windowBits = decodeWindowBits(s);
5363
- if (windowBits === -1) {
5364
- throw "Invalid 'windowBits' code";
5365
- }
5366
- s.maxRingBufferSize = 1 << windowBits;
5367
- s.maxBackwardDistance = s.maxRingBufferSize - 16;
5368
- s.runningState = 2;
5369
- }
5370
- let fence = calculateFence(s);
5371
- let ringBufferMask = s.ringBufferSize - 1;
5372
- let ringBuffer = s.ringBuffer;
5373
- while (s.runningState !== 10) {
5374
- switch (s.runningState) {
5375
- case 2:
5376
- if (s.metaBlockLength < 0) {
5377
- throw "Invalid metablock length";
5378
- }
5379
- readNextMetablockHeader(s);
5380
- fence = calculateFence(s);
5381
- ringBufferMask = s.ringBufferSize - 1;
5382
- ringBuffer = s.ringBuffer;
5383
- continue;
5384
- case 3:
5385
- readMetablockHuffmanCodesAndContextMaps(s);
5386
- s.runningState = 4;
5387
- case 4:
5388
- if (s.metaBlockLength <= 0) {
5389
- s.runningState = 2;
5390
- continue;
5391
- }
5392
- if (s.halfOffset > 2030) {
5393
- doReadMoreInput(s);
5394
- }
5395
- if (s.commandBlockLength === 0) {
5396
- decodeCommandBlockSwitch(s);
5397
- }
5398
- s.commandBlockLength--;
5399
- if (s.bitOffset >= 16) {
5400
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5401
- s.bitOffset -= 16;
5402
- }
5403
- let cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
5404
- let insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
5405
- let insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
5406
- let copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
5407
- s.distanceCode = CMD_LOOKUP[cmdCode + 3];
5408
- if (s.bitOffset >= 16) {
5409
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5410
- s.bitOffset -= 16;
5411
- }
5412
- let insertLengthExtraBits = insertAndCopyExtraBits & 255;
5413
- s.insertLength = insertLengthOffset + (insertLengthExtraBits <= 16 ? readFewBits(s, insertLengthExtraBits) : readManyBits(s, insertLengthExtraBits));
5414
- if (s.bitOffset >= 16) {
5415
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5416
- s.bitOffset -= 16;
5417
- }
5418
- let copyLengthExtraBits = insertAndCopyExtraBits >> 8;
5419
- s.copyLength = copyLengthOffset + (copyLengthExtraBits <= 16 ? readFewBits(s, copyLengthExtraBits) : readManyBits(s, copyLengthExtraBits));
5420
- s.j = 0;
5421
- s.runningState = 7;
5422
- case 7:
5423
- if (s.trivialLiteralContext !== 0) {
5424
- while (s.j < s.insertLength) {
5425
- if (s.halfOffset > 2030) {
5426
- doReadMoreInput(s);
5427
- }
5428
- if (s.literalBlockLength === 0) {
5429
- decodeLiteralBlockSwitch(s);
5430
- }
5431
- s.literalBlockLength--;
5432
- if (s.bitOffset >= 16) {
5433
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5434
- s.bitOffset -= 16;
5435
- }
5436
- ringBuffer[s.pos] = readSymbol(s.literalTreeGroup, s.literalTreeIdx, s);
5437
- s.pos++;
5438
- s.j++;
5439
- if (s.pos >= fence) {
5440
- s.nextRunningState = 7;
5441
- s.runningState = 12;
5442
- break;
5443
- }
5444
- }
5445
- } else {
5446
- let prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask] & 255;
5447
- let prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask] & 255;
5448
- while (s.j < s.insertLength) {
5449
- if (s.halfOffset > 2030) {
5450
- doReadMoreInput(s);
5451
- }
5452
- if (s.literalBlockLength === 0) {
5453
- decodeLiteralBlockSwitch(s);
5454
- }
5455
- let literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
5456
- let literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 255;
5457
- s.literalBlockLength--;
5458
- prevByte2 = prevByte1;
5459
- if (s.bitOffset >= 16) {
5460
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5461
- s.bitOffset -= 16;
5462
- }
5463
- prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
5464
- ringBuffer[s.pos] = prevByte1;
5465
- s.pos++;
5466
- s.j++;
5467
- if (s.pos >= fence) {
5468
- s.nextRunningState = 7;
5469
- s.runningState = 12;
5470
- break;
5471
- }
5472
- }
5473
- }
5474
- if (s.runningState !== 7) {
5475
- continue;
5476
- }
5477
- s.metaBlockLength -= s.insertLength;
5478
- if (s.metaBlockLength <= 0) {
5479
- s.runningState = 4;
5480
- continue;
5481
- }
5482
- let distanceCode = s.distanceCode;
5483
- if (distanceCode < 0) {
5484
- s.distance = s.rings[s.distRbIdx];
5485
- } else {
5486
- if (s.halfOffset > 2030) {
5487
- doReadMoreInput(s);
5488
- }
5489
- if (s.distanceBlockLength === 0) {
5490
- decodeDistanceBlockSwitch(s);
5491
- }
5492
- s.distanceBlockLength--;
5493
- if (s.bitOffset >= 16) {
5494
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5495
- s.bitOffset -= 16;
5496
- }
5497
- let distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 255;
5498
- distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
5499
- if (distanceCode < 16) {
5500
- let index = s.distRbIdx + DISTANCE_SHORT_CODE_INDEX_OFFSET[distanceCode] & 3;
5501
- s.distance = s.rings[index] + DISTANCE_SHORT_CODE_VALUE_OFFSET[distanceCode];
5502
- if (s.distance < 0) {
5503
- throw "Negative distance";
5504
- }
5505
- } else {
5506
- let extraBits = s.distExtraBits[distanceCode];
5507
- let bits2;
5508
- if (s.bitOffset + extraBits <= 32) {
5509
- bits2 = readFewBits(s, extraBits);
5510
- } else {
5511
- if (s.bitOffset >= 16) {
5512
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5513
- s.bitOffset -= 16;
5514
- }
5515
- bits2 = extraBits <= 16 ? readFewBits(s, extraBits) : readManyBits(s, extraBits);
5516
- }
5517
- s.distance = s.distOffset[distanceCode] + (bits2 << s.distancePostfixBits);
5518
- }
5519
- }
5520
- if (s.maxDistance !== s.maxBackwardDistance && s.pos < s.maxBackwardDistance) {
5521
- s.maxDistance = s.pos;
5522
- } else {
5523
- s.maxDistance = s.maxBackwardDistance;
5524
- }
5525
- if (s.distance > s.maxDistance) {
5526
- s.runningState = 9;
5527
- continue;
5528
- }
5529
- if (distanceCode > 0) {
5530
- s.distRbIdx = s.distRbIdx + 1 & 3;
5531
- s.rings[s.distRbIdx] = s.distance;
5532
- }
5533
- if (s.copyLength > s.metaBlockLength) {
5534
- throw "Invalid backward reference";
5535
- }
5536
- s.j = 0;
5537
- s.runningState = 8;
5538
- case 8:
5539
- let src = s.pos - s.distance & ringBufferMask;
5540
- let dst = s.pos;
5541
- let copyLength = s.copyLength - s.j;
5542
- let srcEnd = src + copyLength;
5543
- let dstEnd = dst + copyLength;
5544
- if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
5545
- if (copyLength < 12 || srcEnd > dst && dstEnd > src) {
5546
- for (let k = 0; k < copyLength; k += 4) {
5547
- ringBuffer[dst++] = ringBuffer[src++];
5548
- ringBuffer[dst++] = ringBuffer[src++];
5549
- ringBuffer[dst++] = ringBuffer[src++];
5550
- ringBuffer[dst++] = ringBuffer[src++];
5551
- }
5552
- } else {
5553
- ringBuffer.copyWithin(dst, src, srcEnd);
5554
- }
5555
- s.j += copyLength;
5556
- s.metaBlockLength -= copyLength;
5557
- s.pos += copyLength;
5558
- } else {
5559
- for (; s.j < s.copyLength; ) {
5560
- ringBuffer[s.pos] = ringBuffer[s.pos - s.distance & ringBufferMask];
5561
- s.metaBlockLength--;
5562
- s.pos++;
5563
- s.j++;
5564
- if (s.pos >= fence) {
5565
- s.nextRunningState = 8;
5566
- s.runningState = 12;
5567
- break;
5568
- }
5569
- }
5570
- }
5571
- if (s.runningState === 8) {
5572
- s.runningState = 4;
5573
- }
5574
- continue;
5575
- case 9:
5576
- doUseDictionary(s, fence);
5577
- continue;
5578
- case 14:
5579
- s.pos += copyFromCompoundDictionary(s, fence);
5580
- if (s.pos >= fence) {
5581
- s.nextRunningState = 14;
5582
- s.runningState = 12;
5583
- return;
5584
- }
5585
- s.runningState = 4;
5586
- continue;
5587
- case 5:
5588
- while (s.metaBlockLength > 0) {
5589
- if (s.halfOffset > 2030) {
5590
- doReadMoreInput(s);
5591
- }
5592
- if (s.bitOffset >= 16) {
5593
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5594
- s.bitOffset -= 16;
5595
- }
5596
- readFewBits(s, 8);
5597
- s.metaBlockLength--;
5598
- }
5599
- s.runningState = 2;
5600
- continue;
5601
- case 6:
5602
- copyUncompressedData(s);
5603
- continue;
5604
- case 12:
5605
- s.ringBufferBytesReady = min(s.pos, s.ringBufferSize);
5606
- s.runningState = 13;
5607
- case 13:
5608
- if (writeRingBuffer(s) === 0) {
5609
- return;
5610
- }
5611
- if (s.pos >= s.maxBackwardDistance) {
5612
- s.maxDistance = s.maxBackwardDistance;
5613
- }
5614
- if (s.pos >= s.ringBufferSize) {
5615
- if (s.pos > s.ringBufferSize) {
5616
- ringBuffer.copyWithin(0, s.ringBufferSize, s.pos);
5617
- }
5618
- s.pos &= ringBufferMask;
5619
- s.ringBufferBytesWritten = 0;
5620
- }
5621
- s.runningState = s.nextRunningState;
5622
- continue;
5623
- default:
5624
- throw "Unexpected state " + s.runningState;
5625
- }
5626
- }
5627
- if (s.runningState === 10) {
5628
- if (s.metaBlockLength < 0) {
5629
- throw "Invalid metablock length";
5630
- }
5631
- jumpToByteBoundary(s);
5632
- checkHealth(s, 1);
5633
- }
5634
- }
5635
- function Transforms(numTransforms, prefixSuffixLen, prefixSuffixCount) {
5636
- this.numTransforms = 0;
5637
- this.triplets = new Int32Array(0);
5638
- this.prefixSuffixStorage = new Int8Array(0);
5639
- this.prefixSuffixHeads = new Int32Array(0);
5640
- this.params = new Int16Array(0);
5641
- this.numTransforms = numTransforms;
5642
- this.triplets = new Int32Array(numTransforms * 3);
5643
- this.params = new Int16Array(numTransforms);
5644
- this.prefixSuffixStorage = new Int8Array(prefixSuffixLen);
5645
- this.prefixSuffixHeads = new Int32Array(prefixSuffixCount + 1);
5646
- }
5647
- let RFC_TRANSFORMS = new Transforms(121, 167, 50);
5648
- function unpackTransforms(prefixSuffix, prefixSuffixHeads, transforms, prefixSuffixSrc, transformsSrc) {
5649
- let n = prefixSuffixSrc.length;
5650
- let index = 1;
5651
- let j = 0;
5652
- for (let i = 0; i < n; ++i) {
5653
- let c = prefixSuffixSrc.charCodeAt(i);
5654
- if (c === 35) {
5655
- prefixSuffixHeads[index++] = j;
5656
- } else {
5657
- prefixSuffix[j++] = c;
5658
- }
5659
- }
5660
- for (let i = 0; i < 363; ++i) {
5661
- transforms[i] = transformsSrc.charCodeAt(i) - 32;
5662
- }
5663
- }
5664
- {
5665
- unpackTransforms(
5666
- RFC_TRANSFORMS.prefixSuffixStorage,
5667
- RFC_TRANSFORMS.prefixSuffixHeads,
5668
- RFC_TRANSFORMS.triplets,
5669
- `# #s #, #e #.# the #.com/#\xC2\xA0# of # and # in # to #"#">#
5670
- #]# for # a # that #. # with #'# from # by #. The # on # as # is #ing #
5671
- #:#ed #(# at #ly #="# of the #. This #,# not #er #al #='#ful #ive #less #est #ize #ous #`,
5672
- ` !! ! , *! &! " ! ) * * - ! # ! #!*! + ,$ ! - % . / # 0 1 . " 2 3!* 4% ! # / 5 6 7 8 0 1 & $ 9 + : ; < ' != > ?! 4 @ 4 2 & A *# ( B C& ) % ) !*# *-% A +! *. D! %' & E *6 F G% ! *A *% H! D I!+! J!+ K +- *4! A L!*4 M N +6 O!*% +.! K *G P +%( ! G *D +D Q +# *K!*G!+D!+# +G +A +4!+% +K!+4!*D!+K!*K`
5673
- );
5674
- }
5675
- function transformDictionaryWord(dst, dstOffset, src, srcOffset, len, transforms, transformIndex) {
5676
- let offset = dstOffset;
5677
- let triplets = transforms.triplets;
5678
- let prefixSuffixStorage = transforms.prefixSuffixStorage;
5679
- let prefixSuffixHeads = transforms.prefixSuffixHeads;
5680
- let transformOffset = 3 * transformIndex;
5681
- let prefixIdx = triplets[transformOffset];
5682
- let transformType = triplets[transformOffset + 1];
5683
- let suffixIdx = triplets[transformOffset + 2];
5684
- let prefix = prefixSuffixHeads[prefixIdx];
5685
- let prefixEnd = prefixSuffixHeads[prefixIdx + 1];
5686
- let suffix = prefixSuffixHeads[suffixIdx];
5687
- let suffixEnd = prefixSuffixHeads[suffixIdx + 1];
5688
- let omitFirst = transformType - 11;
5689
- let omitLast = transformType - 0;
5690
- if (omitFirst < 1 || omitFirst > 9) {
5691
- omitFirst = 0;
5692
- }
5693
- if (omitLast < 1 || omitLast > 9) {
5694
- omitLast = 0;
5695
- }
5696
- while (prefix !== prefixEnd) {
5697
- dst[offset++] = prefixSuffixStorage[prefix++];
5698
- }
5699
- if (omitFirst > len) {
5700
- omitFirst = len;
5701
- }
5702
- srcOffset += omitFirst;
5703
- len -= omitFirst;
5704
- len -= omitLast;
5705
- let i = len;
5706
- while (i > 0) {
5707
- dst[offset++] = src[srcOffset++];
5708
- i--;
5709
- }
5710
- if (transformType === 10 || transformType === 11) {
5711
- let uppercaseOffset = offset - len;
5712
- if (transformType === 10) {
5713
- len = 1;
5714
- }
5715
- while (len > 0) {
5716
- let c0 = dst[uppercaseOffset] & 255;
5717
- if (c0 < 192) {
5718
- if (c0 >= 97 && c0 <= 122) {
5719
- dst[uppercaseOffset] ^= 32;
5720
- }
5721
- uppercaseOffset += 1;
5722
- len -= 1;
5723
- } else if (c0 < 224) {
5724
- dst[uppercaseOffset + 1] ^= 32;
5725
- uppercaseOffset += 2;
5726
- len -= 2;
5727
- } else {
5728
- dst[uppercaseOffset + 2] ^= 5;
5729
- uppercaseOffset += 3;
5730
- len -= 3;
5731
- }
5732
- }
5733
- } else if (transformType === 21 || transformType === 22) {
5734
- let shiftOffset = offset - len;
5735
- let param = transforms.params[transformIndex];
5736
- let scalar = (param & 32767) + (16777216 - (param & 32768));
5737
- while (len > 0) {
5738
- let step = 1;
5739
- let c0 = dst[shiftOffset] & 255;
5740
- if (c0 < 128) {
5741
- scalar += c0;
5742
- dst[shiftOffset] = scalar & 127;
5743
- } else if (c0 < 192) {
5744
- } else if (c0 < 224) {
5745
- if (len >= 2) {
5746
- let c1 = dst[shiftOffset + 1];
5747
- scalar += c1 & 63 | (c0 & 31) << 6;
5748
- dst[shiftOffset] = 192 | scalar >> 6 & 31;
5749
- dst[shiftOffset + 1] = c1 & 192 | scalar & 63;
5750
- step = 2;
5751
- } else {
5752
- step = len;
5753
- }
5754
- } else if (c0 < 240) {
5755
- if (len >= 3) {
5756
- let c1 = dst[shiftOffset + 1];
5757
- let c2 = dst[shiftOffset + 2];
5758
- scalar += c2 & 63 | (c1 & 63) << 6 | (c0 & 15) << 12;
5759
- dst[shiftOffset] = 224 | scalar >> 12 & 15;
5760
- dst[shiftOffset + 1] = c1 & 192 | scalar >> 6 & 63;
5761
- dst[shiftOffset + 2] = c2 & 192 | scalar & 63;
5762
- step = 3;
5763
- } else {
5764
- step = len;
5765
- }
5766
- } else if (c0 < 248) {
5767
- if (len >= 4) {
5768
- let c1 = dst[shiftOffset + 1];
5769
- let c2 = dst[shiftOffset + 2];
5770
- let c3 = dst[shiftOffset + 3];
5771
- scalar += c3 & 63 | (c2 & 63) << 6 | (c1 & 63) << 12 | (c0 & 7) << 18;
5772
- dst[shiftOffset] = 240 | scalar >> 18 & 7;
5773
- dst[shiftOffset + 1] = c1 & 192 | scalar >> 12 & 63;
5774
- dst[shiftOffset + 2] = c2 & 192 | scalar >> 6 & 63;
5775
- dst[shiftOffset + 3] = c3 & 192 | scalar & 63;
5776
- step = 4;
5777
- } else {
5778
- step = len;
5779
- }
5780
- }
5781
- shiftOffset += step;
5782
- len -= step;
5783
- if (transformType === 21) {
5784
- len = 0;
5785
- }
5786
- }
5787
- }
5788
- while (suffix !== suffixEnd) {
5789
- dst[offset++] = prefixSuffixStorage[suffix++];
5790
- }
5791
- return offset - dstOffset;
5792
- }
5793
- function getNextKey(key, len) {
5794
- let step = 1 << len - 1;
5795
- while ((key & step) !== 0) {
5796
- step >>= 1;
5797
- }
5798
- return (key & step - 1) + step;
5799
- }
5800
- function replicateValue(table, offset, step, end, item) {
5801
- do {
5802
- end -= step;
5803
- table[offset + end] = item;
5804
- } while (end > 0);
5805
- }
5806
- function nextTableBitSize(count, len, rootBits) {
5807
- let left = 1 << len - rootBits;
5808
- while (len < 15) {
5809
- left -= count[len];
5810
- if (left <= 0) {
5811
- break;
5812
- }
5813
- len++;
5814
- left <<= 1;
5815
- }
5816
- return len - rootBits;
5817
- }
5818
- function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
5819
- let tableOffset = tableGroup[tableIdx];
5820
- let key;
5821
- let sorted = new Int32Array(codeLengthsSize);
5822
- let count = new Int32Array(16);
5823
- let offset = new Int32Array(16);
5824
- let symbol;
5825
- for (symbol = 0; symbol < codeLengthsSize; symbol++) {
5826
- count[codeLengths[symbol]]++;
5827
- }
5828
- offset[1] = 0;
5829
- for (let len = 1; len < 15; len++) {
5830
- offset[len + 1] = offset[len] + count[len];
5831
- }
5832
- for (symbol = 0; symbol < codeLengthsSize; symbol++) {
5833
- if (codeLengths[symbol] !== 0) {
5834
- sorted[offset[codeLengths[symbol]]++] = symbol;
5835
- }
5836
- }
5837
- let tableBits = rootBits;
5838
- let tableSize = 1 << tableBits;
5839
- let totalSize = tableSize;
5840
- if (offset[15] === 1) {
5841
- for (key = 0; key < totalSize; key++) {
5842
- tableGroup[tableOffset + key] = sorted[0];
5843
- }
5844
- return totalSize;
5845
- }
5846
- key = 0;
5847
- symbol = 0;
5848
- for (let len = 1, step = 2; len <= rootBits; len++, step <<= 1) {
5849
- for (; count[len] > 0; count[len]--) {
5850
- replicateValue(
5851
- tableGroup,
5852
- tableOffset + key,
5853
- step,
5854
- tableSize,
5855
- len << 16 | sorted[symbol++]
5856
- );
5857
- key = getNextKey(key, len);
5858
- }
5859
- }
5860
- let mask = totalSize - 1;
5861
- let low = -1;
5862
- let currentOffset = tableOffset;
5863
- for (let len = rootBits + 1, step = 2; len <= 15; len++, step <<= 1) {
5864
- for (; count[len] > 0; count[len]--) {
5865
- if ((key & mask) !== low) {
5866
- currentOffset += tableSize;
5867
- tableBits = nextTableBitSize(count, len, rootBits);
5868
- tableSize = 1 << tableBits;
5869
- totalSize += tableSize;
5870
- low = key & mask;
5871
- tableGroup[tableOffset + low] = tableBits + rootBits << 16 | currentOffset - tableOffset - low;
5872
- }
5873
- replicateValue(
5874
- tableGroup,
5875
- currentOffset + (key >> rootBits),
5876
- step,
5877
- tableSize,
5878
- len - rootBits << 16 | sorted[symbol++]
5879
- );
5880
- key = getNextKey(key, len);
5881
- }
5882
- }
5883
- return totalSize;
5884
- }
5885
- function doReadMoreInput(s) {
5886
- if (s.endOfStreamReached !== 0) {
5887
- if (halfAvailable(s) >= -2) {
5888
- return;
5889
- }
5890
- throw "No more input";
5891
- }
5892
- let readOffset = s.halfOffset << 1;
5893
- let bytesInBuffer = 4096 - readOffset;
5894
- s.byteBuffer.copyWithin(0, readOffset, 4096);
5895
- s.halfOffset = 0;
5896
- while (bytesInBuffer < 4096) {
5897
- let spaceLeft = 4096 - bytesInBuffer;
5898
- let len = readInput(s.input, s.byteBuffer, bytesInBuffer, spaceLeft);
5899
- if (len <= 0) {
5900
- s.endOfStreamReached = 1;
5901
- s.tailBytes = bytesInBuffer;
5902
- bytesInBuffer += 1;
5903
- break;
5904
- }
5905
- bytesInBuffer += len;
5906
- }
5907
- bytesToNibbles(s, bytesInBuffer);
5908
- }
5909
- function checkHealth(s, endOfStream) {
5910
- if (s.endOfStreamReached === 0) {
5911
- return;
5912
- }
5913
- let byteOffset = (s.halfOffset << 1) + (s.bitOffset + 7 >> 3) - 4;
5914
- if (byteOffset > s.tailBytes) {
5915
- throw "Read after end";
5916
- }
5917
- if (endOfStream !== 0 && byteOffset !== s.tailBytes) {
5918
- throw "Unused bytes after end";
5919
- }
5920
- }
5921
- function _assertAccumulatorHealthy(s) {
5922
- if (s.bitOffset > 32) {
5923
- throw "Accumulator underloaded: " + s.bitOffset;
5924
- }
5925
- }
5926
- function readFewBits(s, n) {
5927
- let val = s.accumulator32 >>> s.bitOffset & (1 << n) - 1;
5928
- s.bitOffset += n;
5929
- return val;
5930
- }
5931
- function readManyBits(s, n) {
5932
- let low = readFewBits(s, 16);
5933
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5934
- s.bitOffset -= 16;
5935
- return low | readFewBits(s, n - 16) << 16;
5936
- }
5937
- function initBitReader(s) {
5938
- s.byteBuffer = new Int8Array(4160);
5939
- s.accumulator32 = 0;
5940
- s.shortBuffer = new Int16Array(2080);
5941
- s.bitOffset = 32;
5942
- s.halfOffset = 2048;
5943
- s.endOfStreamReached = 0;
5944
- prepare(s);
5945
- }
5946
- function prepare(s) {
5947
- if (s.halfOffset > 2030) {
5948
- doReadMoreInput(s);
5949
- }
5950
- checkHealth(s, 0);
5951
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5952
- s.bitOffset -= 16;
5953
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
5954
- s.bitOffset -= 16;
5955
- }
5956
- function reload(s) {
5957
- if (s.bitOffset === 32) {
5958
- prepare(s);
5959
- }
5960
- }
5961
- function jumpToByteBoundary(s) {
5962
- let padding = 32 - s.bitOffset & 7;
5963
- if (padding !== 0) {
5964
- let paddingBits = readFewBits(s, padding);
5965
- if (paddingBits !== 0) {
5966
- throw "Corrupted padding bits";
5967
- }
5968
- }
5969
- }
5970
- function halfAvailable(s) {
5971
- let limit = 2048;
5972
- if (s.endOfStreamReached !== 0) {
5973
- limit = s.tailBytes + 1 >> 1;
5974
- }
5975
- return limit - s.halfOffset;
5976
- }
5977
- function copyRawBytes(s, data2, offset, length) {
5978
- if ((s.bitOffset & 7) !== 0) {
5979
- throw "Unaligned copyBytes";
5980
- }
5981
- while (s.bitOffset !== 32 && length !== 0) {
5982
- data2[offset++] = s.accumulator32 >>> s.bitOffset;
5983
- s.bitOffset += 8;
5984
- length--;
5985
- }
5986
- if (length === 0) {
5987
- return;
5988
- }
5989
- let copyNibbles = min(halfAvailable(s), length >> 1);
5990
- if (copyNibbles > 0) {
5991
- let readOffset = s.halfOffset << 1;
5992
- let delta = copyNibbles << 1;
5993
- data2.set(s.byteBuffer.subarray(readOffset, readOffset + delta), offset);
5994
- offset += delta;
5995
- length -= delta;
5996
- s.halfOffset += copyNibbles;
5997
- }
5998
- if (length === 0) {
5999
- return;
6000
- }
6001
- if (halfAvailable(s) > 0) {
6002
- if (s.bitOffset >= 16) {
6003
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
6004
- s.bitOffset -= 16;
6005
- }
6006
- while (length !== 0) {
6007
- data2[offset++] = s.accumulator32 >>> s.bitOffset;
6008
- s.bitOffset += 8;
6009
- length--;
6010
- }
6011
- checkHealth(s, 0);
6012
- return;
6013
- }
6014
- while (length > 0) {
6015
- let len = readInput(s.input, data2, offset, length);
6016
- if (len === -1) {
6017
- throw "Unexpected end of input";
6018
- }
6019
- offset += len;
6020
- length -= len;
6021
- }
6022
- }
6023
- function bytesToNibbles(s, byteLen) {
6024
- let byteBuffer = s.byteBuffer;
6025
- let halfLen = byteLen >> 1;
6026
- let shortBuffer = s.shortBuffer;
6027
- for (let i = 0; i < halfLen; ++i) {
6028
- shortBuffer[i] = byteBuffer[i * 2] & 255 | (byteBuffer[i * 2 + 1] & 255) << 8;
6029
- }
6030
- }
6031
- let LOOKUP = new Int32Array(2048);
6032
- function unpackLookupTable(lookup, map, rle) {
6033
- for (let i = 0; i < 256; ++i) {
6034
- lookup[i] = i & 63;
6035
- lookup[512 + i] = i >> 2;
6036
- lookup[1792 + i] = 2 + (i >> 6);
6037
- }
6038
- for (let i = 0; i < 128; ++i) {
6039
- lookup[1024 + i] = 4 * (map.charCodeAt(i) - 32);
6040
- }
6041
- for (let i = 0; i < 64; ++i) {
6042
- lookup[1152 + i] = i & 1;
6043
- lookup[1216 + i] = 2 + (i & 1);
6044
- }
6045
- let offset = 1280;
6046
- for (let k = 0; k < 19; ++k) {
6047
- let value = k & 3;
6048
- let rep = rle.charCodeAt(k) - 32;
6049
- for (let i = 0; i < rep; ++i) {
6050
- lookup[offset++] = value;
6051
- }
6052
- }
6053
- for (let i = 0; i < 16; ++i) {
6054
- lookup[1792 + i] = 1;
6055
- lookup[2032 + i] = 6;
6056
- }
6057
- lookup[1792] = 0;
6058
- lookup[2047] = 7;
6059
- for (let i = 0; i < 256; ++i) {
6060
- lookup[1536 + i] = lookup[1792 + i] << 3;
6061
- }
6062
- }
6063
- {
6064
- unpackLookupTable(
6065
- LOOKUP,
6066
- ` !! ! "#$##%#$&'##(#)#++++++++++((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# `,
6067
- "A/* ': & : $ \x81 @"
6068
- );
6069
- }
6070
- function State() {
6071
- this.ringBuffer = new Int8Array(0);
6072
- this.contextModes = new Int8Array(0);
6073
- this.contextMap = new Int8Array(0);
6074
- this.distContextMap = new Int8Array(0);
6075
- this.distExtraBits = new Int8Array(0);
6076
- this.output = new Int8Array(0);
6077
- this.byteBuffer = new Int8Array(0);
6078
- this.shortBuffer = new Int16Array(0);
6079
- this.intBuffer = new Int32Array(0);
6080
- this.rings = new Int32Array(0);
6081
- this.blockTrees = new Int32Array(0);
6082
- this.literalTreeGroup = new Int32Array(0);
6083
- this.commandTreeGroup = new Int32Array(0);
6084
- this.distanceTreeGroup = new Int32Array(0);
6085
- this.distOffset = new Int32Array(0);
6086
- this.runningState = 0;
6087
- this.nextRunningState = 0;
6088
- this.accumulator32 = 0;
6089
- this.bitOffset = 0;
6090
- this.halfOffset = 0;
6091
- this.tailBytes = 0;
6092
- this.endOfStreamReached = 0;
6093
- this.metaBlockLength = 0;
6094
- this.inputEnd = 0;
6095
- this.isUncompressed = 0;
6096
- this.isMetadata = 0;
6097
- this.literalBlockLength = 0;
6098
- this.numLiteralBlockTypes = 0;
6099
- this.commandBlockLength = 0;
6100
- this.numCommandBlockTypes = 0;
6101
- this.distanceBlockLength = 0;
6102
- this.numDistanceBlockTypes = 0;
6103
- this.pos = 0;
6104
- this.maxDistance = 0;
6105
- this.distRbIdx = 0;
6106
- this.trivialLiteralContext = 0;
6107
- this.literalTreeIdx = 0;
6108
- this.commandTreeIdx = 0;
6109
- this.j = 0;
6110
- this.insertLength = 0;
6111
- this.contextMapSlice = 0;
6112
- this.distContextMapSlice = 0;
6113
- this.contextLookupOffset1 = 0;
6114
- this.contextLookupOffset2 = 0;
6115
- this.distanceCode = 0;
6116
- this.numDirectDistanceCodes = 0;
6117
- this.distancePostfixBits = 0;
6118
- this.distance = 0;
6119
- this.copyLength = 0;
6120
- this.maxBackwardDistance = 0;
6121
- this.maxRingBufferSize = 0;
6122
- this.ringBufferSize = 0;
6123
- this.expectedTotalSize = 0;
6124
- this.outputOffset = 0;
6125
- this.outputLength = 0;
6126
- this.outputUsed = 0;
6127
- this.ringBufferBytesWritten = 0;
6128
- this.ringBufferBytesReady = 0;
6129
- this.isEager = 0;
6130
- this.isLargeWindow = 0;
6131
- this.cdNumChunks = 0;
6132
- this.cdTotalSize = 0;
6133
- this.cdBrIndex = 0;
6134
- this.cdBrOffset = 0;
6135
- this.cdBrLength = 0;
6136
- this.cdBrCopied = 0;
6137
- this.cdChunks = new Array(0);
6138
- this.cdChunkOffsets = new Int32Array(0);
6139
- this.cdBlockBits = 0;
6140
- this.cdBlockMap = new Int8Array(0);
6141
- this.input = null;
6142
- this.ringBuffer = new Int8Array(0);
6143
- this.rings = new Int32Array(10);
6144
- this.rings[0] = 16;
6145
- this.rings[1] = 15;
6146
- this.rings[2] = 11;
6147
- this.rings[3] = 4;
6148
- }
6149
- let data = null;
6150
- let offsets = new Int32Array(32);
6151
- let sizeBits = new Int32Array(32);
6152
- function setData(newData, newSizeBits) {
6153
- if (isDirect(newData) === 0 || isReadOnly(newData) === 0) {
6154
- throw "newData must be a direct read-only byte buffer";
6155
- }
6156
- if (newSizeBits.length > 31) {
6157
- throw "sizeBits length must be at most 31";
6158
- }
6159
- for (let i = 0; i < 4; ++i) {
6160
- if (newSizeBits[i] !== 0) {
6161
- throw "first 4 must be 0";
6162
- }
6163
- }
6164
- let dictionaryOffsets = offsets;
6165
- let dictionarySizeBits = sizeBits;
6166
- dictionarySizeBits.set(newSizeBits.subarray(0, 0 + newSizeBits.length), 0);
6167
- let pos = 0;
6168
- let limit = newData.length;
6169
- for (let i = 0; i < newSizeBits.length; ++i) {
6170
- dictionaryOffsets[i] = pos;
6171
- let bits2 = dictionarySizeBits[i];
6172
- if (bits2 !== 0) {
6173
- if (bits2 >= 31) {
6174
- throw "newSizeBits values must be less than 31";
6175
- }
6176
- pos += i << bits2;
6177
- if (pos <= 0 || pos > limit) {
6178
- throw "newSizeBits is inconsistent: overflow";
6179
- }
6180
- }
6181
- }
6182
- for (let i = newSizeBits.length; i < 32; ++i) {
6183
- dictionaryOffsets[i] = pos;
6184
- }
6185
- if (pos !== limit) {
6186
- throw "newSizeBits is inconsistent: underflow";
6187
- }
6188
- data = newData;
6189
- }
6190
- function unpackDictionaryData(dictionary, data0, data1, skipFlip, sizeBits2, sizeBitsData) {
6191
- let dict = toUsAsciiBytes(data0 + data1);
6192
- if (dict.length !== dictionary.length) {
6193
- throw "Corrupted brotli dictionary";
6194
- }
6195
- let offset = 0;
6196
- let n = skipFlip.length;
6197
- for (let i = 0; i < n; i += 2) {
6198
- let skip = skipFlip.charCodeAt(i) - 36;
6199
- let flip = skipFlip.charCodeAt(i + 1) - 36;
6200
- for (let j = 0; j < skip; ++j) {
6201
- dict[offset] ^= 3;
6202
- offset++;
6203
- }
6204
- for (let j = 0; j < flip; ++j) {
6205
- dict[offset] ^= 236;
6206
- offset++;
6207
- }
6208
- }
6209
- for (let i = 0; i < sizeBitsData.length; ++i) {
6210
- sizeBits2[i] = sizeBitsData.charCodeAt(i) - 65;
6211
- }
6212
- dictionary.set(dict);
6213
- }
6214
- {
6215
- let dictionaryData = new Int8Array(122784);
6216
- let dictionarySizeBits = new Int32Array(25);
6217
- unpackDictionaryData(
6218
- dictionaryData,
6219
- 'wjnfgltmojefofewab`h`lgfgbwbpkltlmozpjwf`jwzlsfmivpwojhfeqfftlqhwf{wzfbqlufqalgzolufelqnallhsobzojufojmfkfosklnfpjgfnlqftlqgolmdwkfnujftejmgsbdfgbzpevookfbgwfqnfb`kbqfbeqlnwqvfnbqhbaofvslmkjdkgbwfobmgmftpfufmmf{w`bpfalwkslpwvpfgnbgfkbmgkfqftkbwmbnfOjmhaoldpjyfabpfkfognbhfnbjmvpfq$*#(klogfmgptjwkMftpqfbgtfqfpjdmwbhfkbufdbnfpffm`boosbwktfoosovpnfmvejonsbqwiljmwkjpojpwdllgmffgtbzptfpwilapnjmgboploldlqj`kvpfpobpwwfbnbqnzellghjmdtjoofbpwtbqgafpwejqfSbdfhmltbtbz-smdnlufwkbmolbgdjufpfoemlwfnv`keffgnbmzql`hj`lmlm`follhkjgfgjfgKlnfqvofklpwbib{jmel`ovaobtpofppkboeplnfpv`kylmf233&lmfp`bqfWjnfqb`faovfelvqtffheb`fklsfdbufkbqgolpwtkfmsbqhhfswsbpppkjsqllnKWNOsobmWzsfglmfpbufhffseobdojmhplogejufwllhqbwfwltmivnswkvpgbqh`bqgejofefbqpwbzhjoowkbweboobvwlfufq-`lnwbohpklsulwfgffsnlgfqfpwwvqmalqmabmgefooqlpfvqo+phjmqlof`lnfb`wpbdfpnffwdlog-isdjwfnubqzefowwkfmpfmggqlsUjft`lsz2-3!?,b=pwlsfopfojfpwlvqsb`h-djesbpw`pp<dqbznfbm%dw8qjgfpklwobwfpbjgqlbgubq#effoilkmqj`hslqwebpw$VB.gfbg?,a=sllqajoowzsfV-P-tllgnvpw1s{8JmelqbmhtjgftbmwtbooofbgX3^8sbvotbufpvqf\'+$ tbjwnbppbqnpdlfpdbjmobmdsbjg"..#ol`hvmjwqllwtbohejqntjef{no!plmdwfpw13s{hjmgqltpwlloelmwnbjopbefpwbqnbsp`lqfqbjmeoltabazpsbmpbzp7s{85s{8bqwpellwqfbotjhjkfbwpwfswqjslqd,obhftfbhwlogElqn`bpwebmpabmhufqzqvmpivozwbph2s{8dlbodqftpoltfgdfjg>!pfwp6s{8-ip<73s{je#+pllmpfbwmlmfwvafyfqlpfmwqffgeb`wjmwldjewkbqn2;s{`bnfkjooalogyllnuljgfbpzqjmdejoosfbhjmjw`lpw0s{8ib`hwbdpajwpqloofgjwhmftmfbq?"..dqltIPLMgvwzMbnfpbofzlv#olwpsbjmibyy`logfzfpejpkttt-qjphwbapsqfu23s{qjpf16s{Aovfgjmd033/abooelqgfbqmtjogal{-ebjqob`hufqpsbjqivmfwf`kje+"sj`hfujo\'+! tbqnolqgglfpsvoo/333jgfbgqbtkvdfpslwevmgavqmkqfe`foohfzpwj`hklvqolppevfo21s{pvjwgfboQPP!bdfgdqfzDFW!fbpfbjnpdjqobjgp;s{8mbuzdqjgwjsp :::tbqpobgz`bqp*8#~sks<kfoowbootklnyk9 ), #233kboo- B4s{8svpk`kbw3s{8`qft),?,kbpk46s{eobwqbqf#%%#wfoo`bnslmwlobjgnjppphjswfmwejmfnbofdfwpsolw733/  `lloeffw-sks?aq=fqj`nlpwdvjgafoogfp`kbjqnbwkbwln,jnd% ;1ov`h`fmw3338wjmzdlmfkwnopfoogqvdEQFFmlgfmj`h<jg>olpfmvooubpwtjmgQPP#tfbqqfozaffmpbnfgvhfmbpb`bsftjpkdvoeW109kjwppolwdbwfhj`haovqwkfz26s{$$*8*8!=npjftjmpajqgplqwafwbpffhW2;9lqgpwqffnboo53s{ebqnlupalzpX3^-$*8!SLPWafbqhjgp*8~~nbqzwfmg+VH*rvbgyk9\n.pjy....sqls$*8ojewW2:9uj`fbmgzgfaw=QPPsllomf`haoltW259gllqfuboW249ofwpebjolqbosloomlub`lopdfmf#lxplewqlnfwjooqlpp?k0=slvqebgfsjmh?wq=njmj*\x7F"+njmfyk9abqpkfbq33*8njoh#..=jqlmeqfggjphtfmwpljosvwp,ip,klozW119JPAMW139bgbnpffp?k1=iplm$/#$`lmwW129#QPPollsbpjbnllm?,s=plvoOJMFelqw`bqwW279?k2=;3s{"..?:s{8W379njhf975Ymj`fjm`kZlqhqj`fyk9\b$**8svqfnbdfsbqbwlmfalmg904Y\\le\\$^*8333/yk9\vwbmhzbqgaltoavpk965YIbub03s{ \x7F~ &@0&907YifeeF[SJ`bpkujpbdloepmltyk9rvfq-`pppj`hnfbwnjm-ajmggfookjqfsj`pqfmw905YKWWS.132elwltloeFMG#{al{967YALGZgj`h8 ~ f{jw906Yubqpafbw$~*8gjfw:::8bmmf~~?,Xj^-Obmdhn.^tjqfwlzpbggppfbobof{8 \n~f`klmjmf-lqd336*wlmziftppbmgofdpqlle333*#133tjmfdfbqgldpallwdbqz`vwpwzofwfnswjlm-{no`l`hdbmd\'+$-63s{Sk-Gnjp`bobmolbmgfphnjofqzbmvmj{gjp`*8~ gvpw`ojs*- 43s{.133GUGp4^=?wbsfgfnlj((*tbdffvqlskjolswpklofEBRpbpjm.15WobapsfwpVQO#avoh`llh8~ KFBGX3^*baaqivbm+2:;ofpkwtjm?,j=plmzdvzpev`hsjsf\x7F. "331*mgltX2^8X^8 Old#pbow \n\nabmdwqjnabwk*x 33s{ ~*8hl9\0effpbg=p9,,#X^8wloosovd+*x x #-ip$133sgvboalbw-ISD*8 ~rvlw*8 $*8  ~1327132613251324132;132:13131312131113101317131613151314131;131:130313021301130013071306130513041320132113221323133:133;133413351336133713301331133213332:::2::;2::42::52::62::72::02::12::22::32:;:2:;;2:;42:;52:;62:;72:;02:;12:;22:;32:4:2:4;2:442:452:462:472:402:412:422:432:5:2:5;2:542:552:562:572:502:512:522:532:6:2:6;2:642:652:662:672:602:612:622:632333231720:73333::::`lnln/Mpfpwffpwbsfqlwlglkb`f`bgbb/]lajfmg/Abbp/Aujgb`bpllwqlelqlplollwqb`vbogjilpjgldqbmwjslwfnbgfafbodlrv/Efpwlmbgbwqfpsl`l`bpbabilwlgbpjmlbdvbsvfpvmlpbmwfgj`fovjpfoobnbzlylmbbnlqsjpllaqb`oj`foolgjlpklqb`bpj<[<\\<Q<\\<R<P=l<\\=l=o=n<\\<Q<Y<S<R<R=n<T<[<Q<R<X<R=n<R<Z<Y<R<Q<T=i<q<\\<Y<Y<]=g<P=g<~=g=m<R<^=g<^<R<q<R<R<]<s<R<W<T<Q<T<L<H<q<Y<p=g=n=g<r<Q<T<P<X<\\<{<\\<x<\\<q=o<r<]=n<Y<t<[<Y<U<Q=o<P<P<N=g=o<Z5m5f4O5j5i4K5i4U5o5h4O5d4]4C5f4K5m5e5k5d5h5i5h5o4K5d5h5k4D4_4K5h4I5j5k5f4O5f5n4C5k5h4G5i4D5k5h5d5h5f4D5h4K5f4D5o4X5f4K5i4O5i5j4F4D5f5h5j4A4D5k5i5i4X5d4Xejqpwujgflojdkwtlqognfgjbtkjwf`olpfaob`hqjdkwpnbooallhpsob`fnvpj`ejfoglqgfqsljmwubovfofufowbaofalbqgklvpfdqlvstlqhpzfbqppwbwfwlgbztbwfqpwbqwpwzofgfbwksltfqsklmfmjdkwfqqlqjmsvwbalvwwfqnpwjwofwllopfufmwol`bowjnfpobqdftlqgpdbnfppklqwpsb`fel`vp`ofbqnlgfoaol`hdvjgfqbgjlpkbqftlnfmbdbjmnlmfzjnbdfmbnfpzlvmdojmfpobwfq`lolqdqffmeqlmw%bns8tbw`kelq`fsqj`fqvofpafdjmbewfqujpjwjppvfbqfbpafoltjmgf{wlwboklvqpobafosqjmwsqfppavjowojmhppsffgpwvgzwqbgfelvmgpfmpfvmgfqpkltmelqnpqbmdfbggfgpwjoonlufgwbhfmbalufeobpkej{fglewfmlwkfqujftp`kf`hofdboqjufqjwfnprvj`hpkbsfkvnbmf{jpwdljmdnlujfwkjqgabpj`sfb`fpwbdftjgwkoldjmjgfbptqlwfsbdfpvpfqpgqjufpwlqfaqfbhplvwkulj`fpjwfpnlmwktkfqfavjogtkj`kfbqwkelqvnwkqffpslqwsbqwz@oj`holtfqojufp`obppobzfqfmwqzpwlqzvpbdfplvmg`lvqwzlvq#ajqwkslsvswzsfpbssozJnbdfafjmdvssfqmlwfpfufqzpkltpnfbmpf{wqbnbw`kwqb`hhmltmfbqozafdbmpvsfqsbsfqmlqwkofbqmdjufmmbnfgfmgfgWfqnpsbqwpDqlvsaqbmgvpjmdtlnbmebopfqfbgzbvgjlwbhfptkjof-`ln,ojufg`bpfpgbjoz`kjogdqfbwivgdfwklpfvmjwpmfufqaqlbg`lbpw`lufqbssofejofp`z`ofp`fmfsobmp`oj`htqjwfrvffmsjf`ffnbjoeqbnflogfqsklwlojnjw`b`kf`jujop`boffmwfqwkfnfwkfqfwlv`kalvmgqlzbobphfgtklofpjm`fpwl`h#mbnfebjwkkfbqwfnswzleefqp`lsfltmfgnjdkwboavnwkjmhaollgbqqbznbilqwqvpw`bmlmvmjlm`lvmwubojgpwlmfPwzofOldjmkbsszl``vqofew9eqfpkrvjwfejonpdqbgfmffgpvqabmejdkwabpjpklufqbvwl8qlvwf-kwnonj{fgejmboZlvq#pojgfwlsj`aqltmbolmfgqbtmpsojwqfb`kQjdkwgbwfpnbq`krvlwfdllgpOjmhpglvawbpzm`wkvnaboolt`kjfezlvwkmlufo23s{8pfqufvmwjokbmgp@kf`hPsb`frvfqzibnfpfrvbowtj`f3/333Pwbqwsbmfoplmdpqlvmgfjdkwpkjewtlqwkslpwpofbgptffhpbuljgwkfpfnjofpsobmfpnbqwboskbsobmwnbqhpqbwfpsobzp`objnpbofpwf{wppwbqptqlmd?,k0=wkjmd-lqd,nvowjkfbqgSltfqpwbmgwlhfmplojg+wkjpaqjmdpkjsppwbeewqjfg`boopevoozeb`wpbdfmwWkjp#,,..=bgnjmfdzswFufmw26s{8Fnbjowqvf!`qlpppsfmwaoldpal{!=mlwfgofbuf`kjmbpjyfpdvfpw?,k7=qlalwkfbuzwqvf/pfufmdqbmg`qjnfpjdmpbtbqfgbm`fskbpf=?"..fm\\VP% 0:8133s{\\mbnfobwjmfmilzbib{-bwjlmpnjwkV-P-#klogpsfwfqjmgjbmbu!=`kbjmp`lqf`lnfpgljmdsqjlqPkbqf2::3pqlnbmojpwpibsbmeboopwqjboltmfqbdqff?,k1=bavpfbofqwlsfqb!.,,T`bqgpkjoopwfbnpSklwlwqvwk`ofbm-sks<pbjmwnfwboolvjpnfbmwsqlleaqjfeqlt!=dfmqfwqv`hollhpUbovfEqbnf-mfw,..= ?wqz#x ubq#nbhfp`lpwpsobjmbgvowrvfpwwqbjmobalqkfosp`bvpfnbdj`nlwlqwkfjq163s{ofbpwpwfsp@lvmw`lvogdobpppjgfpevmgpklwfobtbqgnlvwknlufpsbqjpdjufpgvw`kwf{bpeqvjwmvoo/\x7F\x7FX^8wls!= ?"..SLPW!l`fbm?aq,=eollqpsfbhgfswk#pjyfabmhp`bw`k`kbqw13s{8bojdmgfboptlvog63s{8vqo>!sbqhpnlvpfNlpw#---?,bnlmdaqbjmalgz#mlmf8abpfg`bqqzgqbewqfefqsbdf\\klnf-nfwfqgfobzgqfbnsqlufiljmw?,wq=gqvdp?"..#bsqjojgfboboofmf{b`welqwk`lgfpoldj`Ujft#pffnpaobmhslqwp#+133pbufg\\ojmhdlbopdqbmwdqffhklnfpqjmdpqbwfg03s{8tklpfsbqpf+*8!#Aol`hojmv{ilmfpsj{fo$*8!=*8je+.ofewgbujgklqpfEl`vpqbjpfal{fpWqb`hfnfmw?,fn=abq!=-pq`>wltfqbow>!`baofkfmqz17s{8pfwvsjwbozpkbqsnjmlqwbpwftbmwpwkjp-qfpfwtkffodjqop,`pp,233&8`ovappwveeajaofulwfp#2333hlqfb~*8 abmgprvfvf>#x~8;3s{8`hjmdx \n\nbkfbg`ol`hjqjpkojhf#qbwjlpwbwpElqn!zbkll*X3^8Balvwejmgp?,k2=gfavdwbphpVQO#>`foop~*+*821s{8sqjnfwfoopwvqmp3{533-isd!psbjmafb`kwb{fpnj`qlbmdfo..=?,djewppwfuf.ojmhalgz-~*8 \nnlvmw#+2::EBR?,qldfqeqbmh@obpp1;s{8effgp?k2=?p`lwwwfpwp11s{8gqjmh*#\x7F\x7F#oftjppkboo 30:8#elq#olufgtbpwf33s{8ib9npjnlm?elmwqfsoznffwpvmwfq`kfbswjdkwAqbmg*#">#gqfpp`ojspqllnplmhfznlajonbjm-Mbnf#sobwfevmmzwqffp`ln,!2-isdtnlgfsbqbnPWBQWofew#jggfm/#132*8 ~ elqn-ujqvp`kbjqwqbmptlqpwSbdfpjwjlmsbw`k?".. l.`b`ejqnpwlvqp/333#bpjbmj((*xbglaf$*X3^jg>23alwk8nfmv#-1-nj-smd!hfujm`lb`k@kjogaqv`f1-isdVQO*(-isd\x7Fpvjwfpoj`fkbqqz213!#ptffwwq= mbnf>gjfdlsbdf#ptjpp..= eee8!=Old-`ln!wqfbwpkffw*#%%#27s{8poffsmwfmwejofgib9ojg>!`Mbnf!tlqpfpklwp.al{.gfowb %ow8afbqp97;Y?gbwb.qvqbo?,b=#psfmgabhfqpklsp>#!!8sks!=`wjlm20s{8aqjbmkfoolpjyf>l>&1E#iljmnbzaf?jnd#jnd!=/#eipjnd!#!*X3^NWlsAWzsf!mftozGbmph`yf`kwqbjohmltp?,k6=ebr!=yk.`m23*8 .2!*8wzsf>aovfpwqvozgbujp-ip$8= ?"pwffo#zlv#k1= elqn#ifpvp233&#nfmv- \n tbofpqjphpvnfmwggjmda.ojhwfb`kdje!#ufdbpgbmphffpwjpkrjspvlnjplaqfgfpgffmwqfwlglpsvfgfb/]lpfpw/Mwjfmfkbpwblwqlpsbqwfglmgfmvfulkb`fqelqnbnjpnlnfilqnvmglbrv/Ag/Abpp/_olbzvgbef`kbwlgbpwbmwlnfmlpgbwlplwqbppjwjlnv`klbklqbovdbqnbzlqfpwlpklqbpwfmfqbmwfpelwlpfpwbpsb/Apmvfubpbovgelqlpnfgjlrvjfmnfpfpslgfq`kjofpfq/Muf`fpgf`jqilp/Efpwbqufmwbdqvslkf`klfoolpwfmdlbnjdl`lpbpmjufodfmwfnjpnbbjqfpivojlwfnbpkb`jbebulqivmjlojaqfsvmwlavfmlbvwlqbaqjoavfmbwf{wlnbqylpbafqojpwbovfdl`/_nlfmfqlivfdlsfq/Vkbafqfpwlzmvm`bnvifqubolqevfqbojaqldvpwbjdvboulwlp`bplpdv/Absvfglplnlpbujplvpwfggfafmml`kfavp`bebowbfvqlppfqjfgj`kl`vqpl`obuf`bpbpof/_msobylobqdllaqbpujpwbbslzlivmwlwqbwbujpwl`qfbq`bnslkfnlp`jm`l`bqdlsjplplqgfmkb`fm/Mqfbgjp`lsfgql`fq`bsvfgbsbsfonfmlq/Vwjo`obqlilqdf`boofslmfqwbqgfmbgjfnbq`bpjdvffoobppjdol`l`kfnlwlpnbgqf`obpfqfpwlmj/]lrvfgbsbpbqabm`lkjilpujbifsbaol/Epwfujfmfqfjmlgfibqelmgl`bmbomlqwfofwqb`bvpbwlnbqnbmlpovmfpbvwlpujoobufmglsfpbqwjslpwfmdbnbq`loofubsbgqfvmjglubnlpylmbpbnalpabmgbnbqjbbavplnv`kbpvajqqjlibujujqdqbgl`kj`bboo/Ailufmgj`kbfpwbmwbofppbojqpvfolsfplpejmfpoobnbavp`l/Epwboofdbmfdqlsobybkvnlqsbdbqivmwbglaofjpobpalopbab/]lkbaobov`kb/mqfbgj`fmivdbqmlwbpuboofboo/M`bqdbglolqbabilfpw/Edvpwlnfmwfnbqjlejqnb`lpwlej`kbsobwbkldbqbqwfpofzfpbrvfonvpflabpfpsl`lpnjwbg`jfol`kj`lnjfgldbmbqpbmwlfwbsbgfafpsobzbqfgfppjfwf`lqwf`lqfbgvgbpgfpflujfilgfpfbbdvbp%rvlw8glnbjm`lnnlmpwbwvpfufmwpnbpwfqpzpwfnb`wjlmabmmfqqfnlufp`qloovsgbwfdolabonfgjvnejowfqmvnafq`kbmdfqfpvowsvaoj`p`qffm`kllpfmlqnbowqbufojppvfpplvq`fwbqdfwpsqjmdnlgvofnlajofptjw`ksklwlpalqgfqqfdjlmjwpfoepl`jbob`wjuf`lovnmqf`lqgelooltwjwof=fjwkfqofmdwkebnjozeqjfmgobzlvwbvwklq`qfbwfqfujftpvnnfqpfqufqsobzfgsobzfqf{sbmgsloj`zelqnbwglvaofsljmwppfqjfpsfqplmojujmdgfpjdmnlmwkpelq`fpvmjrvftfjdkwsflsoffmfqdzmbwvqfpfbq`kejdvqfkbujmd`vpwlnleepfwofwwfqtjmgltpvanjwqfmgfqdqlvspvsolbgkfbowknfwklgujgflpp`klloevwvqfpkbgltgfabwfubovfpLaif`wlwkfqpqjdkwpofbdvf`kqlnfpjnsofmlwj`fpkbqfgfmgjmdpfbplmqfslqwlmojmfprvbqfavwwlmjnbdfpfmbaofnlujmdobwfpwtjmwfqEqbm`fsfqjlgpwqlmdqfsfbwOlmglmgfwbjoelqnfggfnbmgpf`vqfsbppfgwlddofsob`fpgfuj`fpwbwj``jwjfppwqfbnzfooltbwwb`hpwqffweojdkwkjggfmjmel!=lsfmfgvpfevouboofz`bvpfpofbgfqpf`qfwpf`lmggbnbdfpslqwpf{`fswqbwjmdpjdmfgwkjmdpfeef`wejfogppwbwfpleej`fujpvbofgjwlqulovnfQfslqwnvpfvnnlujfpsbqfmwb``fppnlpwoznlwkfq!#jg>!nbqhfwdqlvmg`kbm`fpvqufzafelqfpznalonlnfmwpsff`knlwjlmjmpjgfnbwwfq@fmwfqlaif`wf{jpwpnjggofFvqlsfdqltwkofdb`znbmmfqfmlvdk`bqffqbmptfqlqjdjmslqwbo`ojfmwpfof`wqbmgln`olpfgwlsj`p`lnjmdebwkfqlswjlmpjnsozqbjpfgfp`bsf`klpfm`kvq`kgfejmfqfbplm`lqmfqlvwsvwnfnlqzjeqbnfsloj`fnlgfopMvnafqgvqjmdleefqppwzofphjoofgojpwfg`boofgpjoufqnbqdjmgfofwfafwwfqaqltpfojnjwpDolabopjmdoftjgdfw`fmwfqavgdfwmltqbs`qfgjw`objnpfmdjmfpbefwz`klj`fpsjqjw.pwzofpsqfbgnbhjmdmffgfgqvppjbsofbpff{wfmwP`qjswaqlhfmbooltp`kbqdfgjujgfeb`wlqnfnafq.abpfgwkflqz`lmejdbqlvmgtlqhfgkfosfg@kvq`kjnsb`wpklvogbotbzpoldl!#alwwlnojpw!=*xubq#sqfej{lqbmdfKfbgfq-svpk+`lvsofdbqgfmaqjgdfobvm`kQfujftwbhjmdujpjlmojwwofgbwjmdAvwwlmafbvwzwkfnfpelqdlwPfbq`kbm`klqbonlpwolbgfg@kbmdfqfwvqmpwqjmdqfolbgNlajofjm`lnfpvssozPlvq`flqgfqpujftfg%maps8`lvqpfBalvw#jpobmg?kwno#`llhjfmbnf>!bnbylmnlgfqmbguj`fjm?,b=9#Wkf#gjboldklvpfpAFDJM#Nf{j`lpwbqwp`fmwqfkfjdkwbggjmdJpobmgbppfwpFnsjqfP`kllofeelqwgjqf`wmfbqoznbmvboPfof`w- Lmfiljmfgnfmv!=SkjojsbtbqgpkbmgofjnslqwLeej`fqfdbqgphjoopmbwjlmPslqwpgfdqfftffhoz#+f-d-afkjmggl`wlqolddfgvmjwfg?,a=?,afdjmpsobmwpbppjpwbqwjpwjppvfg033s{\x7F`bmbgbbdfm`zp`kfnfqfnbjmAqbyjopbnsofoldl!=afzlmg.p`bofb``fswpfqufgnbqjmfEllwfq`bnfqb?,k2= \\elqn!ofbufppwqfpp!#,= -dje!#lmolbgolbgfqL{elqgpjpwfqpvqujuojpwfmefnbofGfpjdmpjyf>!bssfbowf{w!=ofufopwkbmhpkjdkfqelq`fgbmjnbobmzlmfBeqj`bbdqffgqf`fmwSflsof?aq#,=tlmgfqsqj`fpwvqmfg\x7F\x7F#x~8nbjm!=jmojmfpvmgbztqbs!=ebjofg`fmpvpnjmvwfafb`lmrvlwfp263s{\x7Ffpwbwfqfnlwffnbjo!ojmhfgqjdkw8pjdmboelqnbo2-kwnopjdmvssqjm`feolbw9-smd!#elqvn-B``fppsbsfqpplvmgpf{wfmgKfjdkwpojgfqVWE.;!%bns8#Afelqf-#TjwkpwvgjlltmfqpnbmbdfsqlejwiRvfqzbmmvbosbqbnpalvdkwebnlvpdlldofolmdfqj((*#xjpqbfopbzjmdgf`jgfklnf!=kfbgfqfmpvqfaqbm`ksjf`fpaol`h8pwbwfgwls!=?qb`jmdqfpjyf..%dw8sb`jwzpf{vboavqfbv-isd!#23/333lawbjmwjwofpbnlvmw/#Jm`-`lnfgznfmv!#ozqj`pwlgbz-jmgffg`lvmwz\\oldl-EbnjozollhfgNbqhfwopf#jeSobzfqwvqhfz*8ubq#elqfpwdjujmdfqqlqpGlnbjm~fopfxjmpfqwAold?,ellwfqoldjm-ebpwfqbdfmwp?algz#23s{#3sqbdnbeqjgbzivmjlqgloobqsob`fg`lufqpsovdjm6/333#sbdf!=alpwlm-wfpw+bubwbqwfpwfg\\`lvmwelqvnpp`kfnbjmgf{/ejoofgpkbqfpqfbgfqbofqw+bssfbqPvanjwojmf!=algz!= )#WkfWklvdkpffjmdifqpfzMftp?,ufqjezf{sfqwjmivqztjgwk>@llhjfPWBQW#b`qlpp\\jnbdfwkqfbgmbwjufsl`hfwal{!= Pzpwfn#Gbujg`bm`fqwbaofpsqlufgBsqjo#qfboozgqjufqjwfn!=nlqf!=albqgp`lolqp`bnsvpejqpw#\x7F\x7F#X^8nfgjb-dvjwbqejmjpktjgwk9pkltfgLwkfq#-sks!#bppvnfobzfqptjoplmpwlqfpqfojfeptfgfm@vpwlnfbpjoz#zlvq#Pwqjmd Tkjowbzolq`ofbq9qfplqweqfm`kwklvdk!*#(#!?algz=avzjmdaqbmgpNfnafqmbnf!=lssjmdpf`wlq6s{8!=upsb`fslpwfqnbilq#`leeffnbqwjmnbwvqfkbssfm?,mbu=hbmpbpojmh!=Jnbdfp>ebopftkjof#kpsb`f3%bns8# Jm##sltfqSlophj.`lolqilqgbmAlwwlnPwbqw#.`lvmw1-kwnomftp!=32-isdLmojmf.qjdkwnjoofqpfmjlqJPAM#33/333#dvjgfpubovf*f`wjlmqfsbjq-{no!##qjdkwp-kwno.aol`hqfdF{s9klufqtjwkjmujqdjmsklmfp?,wq=vpjmd# \nubq#=$*8 \n?,wg= ?,wq= abkbpbaqbpjodbofdlnbdzbqslophjpqsphj4]4C5d\bTA\nzk\vBl\bQ\x7F\vUmGx\bSM\nmC\bTA wQ\nd}\bW@\bTl\bTF i@ cT\vBM\v|jBV qw cC\bWI\npa fM\n{Z{X\bTF\bVV\bVK \x7FmkF []\bPm\bTv\nsI\vpg [I\bQpmx\v_W\n^M\npe\vQ}\vGu\nel\npeChBV\bTA So\nzk\vGL\vxD\nd[JzMY\bQpli\nfl\npC{BNt\vwT i_\bTgQQ\n|p\vXN\bQS\vxDQC\bWZ pD\vVS\bTWNtYh\nzuKjN} wr Ha\n_D j`\vQ}\vWp\nxZ{c ji BU\nbDa| Tn pV\nZd\nmC\vEV{X c} To\bWl\bUd IQ cg\vxs\nXW wR\vek c} ]y Jn\nrp\neg\npV\nz\\{W\npl\nz\\\nzU Pc `{\bV@\nc|\bRw i_\bVb\nwX HvSu\bTF\v_W\vWs\vsIm\x7F\nTT\ndc US }f iZ\bWz c}MD Be iD\v@@\bTl\bPv }tSwM`\vnU kW\ved\nqo\vxY A|\bTz\vy`BRBM iaXU\nyun^ fL iI\nXW fD\bWz\bW@ yj \x7Fm av BN\vb\\ pD\bTf\nY[ Jn\bQy [^\vWc\vyuDlCJ\vWj\vHR `V\vuW Qy\np@\vGuplJm\bW[\nLP\nxC\n`m wQui\x7FR\nbI wQ BZ WVBR\npg cgtiCW\n_y Rg\bQa\vQB\vWc\nYble\ngESu\nL[ Q\x7F ea dj\v]W\nb~M` wL\bTV\bVH\nt\x7F\npl |bs_\bU|\bTaoQlvSkM`\bTv\vK}\nfl cCoQBR Hk |d\bQp HK BZ\vHR\bPv\vLx\vEZ\bT\x7F\bTv iDoDMU\vwBSuk`St\ntC Pl Kg\noi jY\vxYh}\nzk\bWZ \x7Fm\ve` TB fE\nzk `zYh\nV| HK AJ AJ\bUL p\\ ql\nYcKd\nfyYh [I\vDgJm\n]n\nlb\bUd\n{Z lu fsoQ\bTWJm\vwB eaYhBC sb Tn\nzU\n_y\vxY Q]\ngwmt O\\\ntb\bWW\bQy mI V[\ny\\\naB\vRb wQ\n]QQJ\bWg\vWa\bQj\ntC\bVH\nYm\vxs\bVK\nel\bWI\vxYCq\ntR\vHV\bTl\bVw ay\bQa\bVV }t dj\nr| p\\ wR\n{i\nTT [I i[ AJ\vxs\v_W d{\vQ} cg Tz A| Cj\vLmN}m\x7F\nbK dZ p\\ `V sV\np@ iD wQ\vQ}\bTfkaJm\v@@\bV` zp\n@NSw iI cg\noiSu\bVwloCy c}\vb\\ sUBA\bWI\bTf\nxS Vp\nd|\bTV\vbC NoJu\nTC |`\n{Z D]\bU| c}lm\bTl Bv Pl c}\bQp \x7Fm\nLk kj\n@NSbKO j_ p\\\nzU\bTl\bTg\bWI cfXO\bWW\ndzli BN\nd[\bWOMD\vKC dj I_\bVV\ny\\\vLmxl xB kV\vb\\\vJW\vVS Vx\vxD d{MD\bTa |`\vPzR}\vWsBM\nsICN\bTaJm\npe i_\npV\nrh Rd Hv\n~A\nxR\vWh\vWk\nxS\vAz\vwX\nbIoQ fw\nqI\nV|\nunz\x7F\vpg d\\\voA{D i_xB\bT\x7F `Vqr TTg]CA\vuR VJ T`\npw\vRb I_\nCxRo\vsICjKh Bv WVBBoD{D\nhcKm\v^R QE\n{I\np@\nc|Gt c}Dl\nzUqN sVk} Hh\v|j\nqou| Q]\vek\x7FZM`St\npe dj\bVG\veE \x7Fm\vWc|I\n[W fL\bT\x7F BZSu\vKaCqNtY[\nqI\bTv fM i@ }fB\\ Qy\vBl\bWgXDkc\vx[\bVV Q] \x7Fa Py\vxD\nfI }foD dj SGls ~DCN\n{Z \\v\n_D\nhc\vx_C[ AJ\nLM VxCI bj c^ cF\ntCSx wrXA\bU\\ |a\vK\\\bTV\bVj\nd| fsCX\ntb\bRw Vx AE A|\bT\x7FNt\vDg Vc\bTld@\npo \x7FM cF\npe iZ Bo\bSq\nfHl`\bTx\bWf HE\vF{ cO fD\nlm\vfZ\nlm\veU dGBH\bTV SiMW\nwX\nz\\ \\cCX\nd} l}\bQp\bTV F~\bQ\x7F `i\ng@nO\bUd\bTl\nL[ wQ ji\ntC |J\nLU\naB\vxYKj AJuN i[\npeSk\vDg\vx]\bVb\bVV\nea kV\nqI\bTaSk\nAO pD\ntb\nts\nyi\bVg i_\v_W\nLkNt yj fMR\x7F iI\bTl\vwX sV\vMl\nyu AJ\bVjKO WV\vA}\vW\x7F\nrp iD\v|olv\vsIBM d~ CU\bVbeV\npC\vwT j` c}\vxs\vps\vvh WV\vGg\vAe\vVK\v]W rg\vWcF` Br\vb\\ dZ\bQp\nqIkF\nLk\vAR\bWI\bTg bs dw\n{L\n_y iZ\bTA lg\bVV\bTl dk\n`k a{ i_{Awj wN\v@@\bTe i_\n_D wL\nAH\viK\vek\n[] p_ yj\bTv US [r\n{I\npsGt\vVK\nplS}\vWP |dMD\vHV\bT\x7FR}M`\bTV\bVHlvCh\bW[Ke R{\v^R ab BZ VA B`\nd|\nhsKe BeOi R{ d\\nB\bWZ dZ VJOs \x7FmuQ\vhZQ@QQ\nfI\bW[B\\li\nzU\nMdM`\nxS\bVV\n\\}\vxD \x7Fm\bTpIS\nc| kVi~ V{\vhZ |b\bWt\n@R\voA\vnU\bWI ea B` iD c} TzBR\vQBNj CP [I\bTv `WuN\vpg\vpg\vWc iT bs wL U_ c\\ |h\vKa Nr fL\nq|\nzu\nz\\ Nr\bUg |bm`\bTv\nyd\nrp\bWf UXBV\nzk\nd} wQ }fCe\ved\bTW\bSB\nxU cn\bTb\ne\x7F a\\ SG\bU|\npV\nN\\Kn\vnU At pD\v^R\vIrb[ R{ dE\vxD\vWK\vWA\bQL\bW@Su\bUd\nDM PcCADloQ Hswiub\n\x7Fa\bQpOb\nLP\bTlY[\vK} AJ\bQ\x7Fn^\vsA\bSM\nqM\bWZ\n^W\vz{S| fD\bVK\bTv\bPvBB CPdF id\vxsmx\vws cC\ntC ycM`\vW\x7F\nrh\bQp\vxD\\o\nsI_k\nzukF fDXsXO jp\bTvBS{B Br\nzQ\nbI c{BDBVnO\bTF caJd fL PV I_\nlK`o wX\npa gu\bP}{^\bWf\n{I BN\npaKl\vpg cn fL\vvhCq\bTl\vnU\bSqCm wR\bUJ\npe\nyd\nYgCy\vKW fD\neaoQ j_ BvnM\vID\bTa\nzApl\n]n\bTa R{ fr\n_y\bUg{Xkk\vxD|Ixl\nfyCe\vwB\nLk\vd]\noi\n}h Q]\npe\bVwHkOQ\nzk AJ\npV\bPv\ny\\ A{Oi\bSBXA\veE jp\nq} iDqN\v^R \x7Fm iZ Br\bVg\noi\n\\X U_\nc|\vHV\bTf Tn\\N\\N\nuBlv\nyu Td\bTf\bPL\v]W dG\nA`\nw^\ngI\npe dw\nz\\ia\bWZ cFJm\n{Z\bWO_kDfRR d\\\bVV\vxsBNtilm Td ]y\vHV So\v|jXX A|\vZ^\vGu\bTWM`kF\vhZ\vVK dG\vBl ay\nxUqEnO\bVw\nqICX\ne\x7F Pl\bWO\vLm dLuHCm dTfn\vwBka\vnU\n@M\nyT Hv \\}Kh d~Yhk}\neR d\\\bWI |b HK iD\bTWMY\npl\bQ_ wr\vAx HE\bTg\bSqvp\vb\\\bWO\nOl\nsI\nfy\vID \\c\n{Z\n^~\npe\nAO TT\vxvk_\bWO\v|j\vwB Qy i@ Pl Ha dZk}ra UT\vJc\ved\np@ QN\nd| kj HkM`\noi wr d\\\nlq\no_\nlb\nL[ acBBBHCm\npl IQ\bVK\vxs\n`e\viK\npaOi US\bTp fD\nPGkkXA\nz\\\neg\vWh wRqN\nqS cnlo\nxS\n^W BU\nt\x7F HE p\\ fF fw\bVV\bW@ ak\vVKls VJ\bVV\veE\\o\nyX\nYmM`lL\nd|\nzk A{sE wQXT\nt\x7F Pl ]y\vwT{pMD\vb\\ Q]Kj Jn\nAH\vRb BU HK \\c\nfIm\x7F\nqM\n@R So\noiBT Hv\n_yKh BZ ]i\bUJ V{Sr\nbI\vGg a_\bTR\nfI\nfl [K IIS|\vuW iI\bWI\nqI\v|jBV\bVg\bWZkF\vx]\bTA ab fr i@ Jd Jd\vps\nAO\bTaxu iD\nzk |d |`\bW[ lP dG\bVV\vw}\vqO i[\bQ\x7F\bTz\vVF wNts dw\bTv\neS\ngi NryS\npe\bVV\bSq\n`m yj BZ\vWX\bSB c\\\nUR [J c_nM\bWQ\vAx\nMd Brui\vxY\bSM\vWc\v|j\vxs }Q BO\bPL\bWW fM\nAO Pc\veUe^\bTg\nqI ac\bPv cFoQ Q\x7F\vhZka\nz\\ iK BU\n`k CPS|M`\n{I S{_O BZZiSk ps p\\\nYu\n]s\nxC\bWt\nbD kV\vGuyS\nqA [r\neKM` dZlL\bUg\bTl\nbD US\vb\\ pV\nccS\\ ct `z\bPL\vWs\nA`\neg\bSquECR\vDg `W\vz{\vWcSkSk bW\bUg ea\nxZ iI UX VJ\nqn S{\vRb\bTQ\nplGt\vuWuj\npF\nqI fL [I iaXO\nyu\vDg\ved q{VG\bQ\x7Fka Vj kV xB\nd|\np@ QN Pc ps]j kV oU\bTp\nzUnB\vB] a{\bV@\n]nm` cz R{m`\bQa\vwT\bSMMYqN dj~s\vQ}MY\vMB Bv wR\bRg\vQ} ql\vKC\nrmxuCC\vwB\vvh BqXq\npV i_ObuE\nbd\nqo\v{i\nC~ BL\veEuH\bVjEyGz\vzR\v{i cf\n{Z\n]nXA\vGu\vnU hS\vGI\nCc HE\bTA HBBHCj\nCc\bTF HE\nXI A{\bQ\x7F c\\\vmO\vWX\nfH\np@MY\bTF\nlK Bt\nzU TTKm\vwT\npV\ndt\vyI Vx Q\x7F Rg Td\nzU\bRS\nLM wAnM Tn\ndS ]g\nLc\vwB }t [I CPkX\vFm\vhZm\x7F i[\np@\vQ}\vW\x7F |d\nMO\nMd f_ fD cJ Hz\vRb io PyY[\nxU ct\v@@ ww\bPvBMFF\ntbv|\vKm Bq BqKh`o\nZdXU i] |` StB\\\bQ\x7F\v_W TJ\nqI |a A{\vuPMD Pl\nxR fL\vws c{ d\\\bV`\neg HKkc\nd|\bVV\ny\\kc i]\bVG `V ss I_ AE bs du\nel pD\vW\x7F\nqslv\bSMZi\vVKia\vQB Q\x7F\n{Z\bPt\vKl\nlK\nhs\ndS\bVKmf\nd^ kV cO\nc|\bVH \\]\bTv\bSq mI\vDg VJ cn\ny\\\bVg\bTv\nyX\bTF ]]\bTp\noi\nhs\veU\nBf djMr\n|p \\g ]r\bVb{D\nd[XN fM O\\s_ cf iZXN\vWc qv\n`m U^oD\nd|\vGg dE\vwflou}\nd|oQ `iOi\vxD\ndZ\nCxYw\nzk\ntb\ngw yj B`\nyX\vps\ntC\vpP\vqw\bPu\bPX Dm\npwNj ss aG\vxs\bPt\noLGz Ok i@ i]eC IQ ii dj\v@J |duh\bWZ\veU\vnU\bTa cCg]\nzkYh\bVK\nLU\np@\ntb\ntR Cj\vNP i@\bP{\n\\}\n{c\nwX fL\bVG c{ |` AJ |C fDln |d bs\nqI{B\vAx\np@\nzk\vRbOs\vWSe^\vD_ Bv\vWd\bVb\vxs\veE\bRw\n]n\n|p\vg| fwkc\bTIka\n\\TSp ju\vps\npeu|\vGr\bVe CU]MXU\vxD\bTa IQ\vWq CU am dj\bSoSw\vnUCh Q]s_\bPt fS\bTa \\}\n@OYc UZ\bTx\npe\vnU\nzU |} iD\nz\\\bSM\vxDBR\nzQ QN]MYh\nLP\vFm\vLXvc\vqlka HK\bVb\ntC\nCy\bTv\nuVoQ `z [I B`\vRb yj sb\vWs\bTl kV\ved\ne\x7FlL\vxN \x7Fm\nJn jY\vxD\bVb\bSq\vyu wL\vXL\bTA pg At nDXX wR\npl\nhwyS\nps cO\bW[\v|jXN sV p\\ Be\nb~\nAJ\n]ek`qN dw WV HE\vEVJz id B` zhE] fD\bTgqN\bTa jaCv\bSM\nhc\bUet_ ieg] wQ\nPn\bVB jw\bVg\vbE BZ\vRH\bP{ jp\n\\} a_ cC |a\vD] BZ i[ fD\vxW\no_ d\\\n_D\ntb \\c AJ\nlKoQlo\vLx\vM@\bWZKn\vpg\nTi\nIv\n|r\v@}JzLmWhk}ln\vxD\n]sgc\vps Br\bTW\vBMtZ\nBYDW jf\vSWC}\nqo dE mv IQ\bPP\bUblvBC\nzQ [I\vgl\nig\bUsBT\vbC\bSq sU iW\nJn SY HK rg\npV\vID\v|jKO `S |a`vbmglfmujbqnbgqjgavp`bqjmj`jlwjfnslslqrvf`vfmwbfpwbglsvfgfmivfdlp`lmwqbfpw/Mmmlnaqfwjfmfmsfqejonbmfqbbnjdlp`jvgbg`fmwqlbvmrvfsvfgfpgfmwqlsqjnfqsqf`jlpfd/Vmavfmlpuloufqsvmwlppfnbmbkba/Abbdlpwlmvfulpvmjglp`bqolpfrvjslmj/]lpnv`klpbodvmb`lqqfljnbdfmsbqwjqbqqjabnbq/Abklnaqffnsoflufqgbg`bnajlnv`kbpevfqlmsbpbglo/Amfbsbqf`fmvfubp`vqplpfpwbabrvjfqlojaqlp`vbmwlb``fplnjdvfoubqjlp`vbwqlwjfmfpdqvslppfq/Mmfvqlsbnfgjlpeqfmwfb`fq`bgfn/Mplefqwb`l`kfpnlgfoljwbojbofwqbpbod/Vm`lnsqb`vbofpf{jpwf`vfqslpjfmglsqfmpboofdbqujbifpgjmfqlnvq`jbslgq/Msvfpwlgjbqjlsvfaolrvjfqfnbmvfosqlsjl`qjpjp`jfqwlpfdvqlnvfqwfevfmwf`fqqbqdqbmgffef`wlsbqwfpnfgjgbsqlsjbleqf`fwjfqqbf.nbjoubqjbpelqnbpevwvqllaifwlpfdvjqqjfpdlmlqnbpnjpnlp/Vmj`l`bnjmlpjwjlpqby/_mgfajglsqvfabwlofglwfm/Abifp/Vpfpsfql`l`jmblqjdfmwjfmgb`jfmwl`/Mgjykbaobqpfq/Abobwjmbevfqybfpwjoldvfqqbfmwqbq/E{jwlo/_sfybdfmgbu/Agflfujwbqsbdjmbnfwqlpibujfqsbgqfpe/M`jo`bafyb/Mqfbppbojgbfmu/Alibs/_mbavplpajfmfpwf{wlpoofubqsvfgbmevfqwf`ln/Vm`obpfpkvnbmlwfmjglajoablvmjgbgfpw/Mpfgjwbq`qfbgl<X<W=c=k=n<R<V<\\<V<T<W<T=a=n<R<^=m<Y<Y<_<R<S=l<T=n<\\<V<Y=e<Y=o<Z<Y<v<\\<V<]<Y<[<]=g<W<R<Q<T<~=m<Y<S<R<X<A=n<R=n<R<P=k<Y<P<Q<Y=n<W<Y=n=l<\\<[<R<Q<\\<_<X<Y<P<Q<Y<x<W=c<s=l<T<Q<\\=m<Q<T=i=n<Y<P<V=n<R<_<R<X<^<R=n=n<\\<P<M<D<|<P<\\=c<K=n<R<^<\\=m<^<\\<P<Y<P=o<N<\\<V<X<^<\\<Q<\\<P=a=n<T=a=n=o<~<\\<P=n<Y=i<S=l<R=n=o=n<Q<\\<X<X<Q=c<~<R=n=n=l<T<Q<Y<U<~<\\=m<Q<T<P=m<\\<P=n<R=n=l=o<]<r<Q<T<P<T=l<Q<Y<Y<r<r<r<W<T=j=a=n<\\<r<Q<\\<Q<Y<P<X<R<P<P<R<U<X<^<Y<R<Q<R=m=o<X\fHy\fIk\fHU\fId\fHy\fIl\fHT\fIk\fHy\fHR\fHy\fIg\fHx\fH\\\fHF\fH\\\fHD\fIk\fHc\fHy\fHy\fHS\fHA\fIl\fHk\fHT\fHy\fH\\\fHH\fIg\fHU\fIg\fHj\fHF\fHU\fIl\fHC\fHU\fHC\fHR\fHH\fHy\fHI\fHRibdqbm\fHj\fHp\fHp\fIg\fHi\fH@\fHJ\fIg\fH{\fHd\fHp\fHR\fH{\fHc\fHU\fHB\fHk\fHD\fHY\fHU\fHC\fIk\fHI\fIk\fHI\fIl\fHt\fH\\\fHp\fH@\fHJ\fIl\fHy\fHd\fHp\fIl\fHY\fIk\fHD\fHd\fHD\fHc\fHU\fH\\\fHe\fHT\fHB\fIk\fHy\fHB\fHY\fIg\fH^\fIk\fHT\fH@\fHB\fHd\fHJ\fIk\fH\x7F\fH\\\fHj\fHB\fH@\fHT\fHA\fH\\\fH@\fHD\fHv\fH^\fHB\fHD\fHj\fH{\fHT\fIl\fH^\fIl4U5h5e4I5h5e5k4\\4K4N4B4]4U4C4C4K5h5e5k4\\5k4Y5d4]4V5f4]5o4K5j5d5h4K4D5f5j4U4]4Z4\\5h5o5k5j4K5f5d5i5n4K5h4U5h5f4K5j4K5h5o5j4A4F5e5n4D5h5d4A4E4K4B4]5m5n4[4U4D4C4]5o5j4I4\\4K5o5i4K4K4A4C4I5h4K5m5f5k4D4U4Z5o5f5m4D4A4G5d5i5j5d5k5d4O5j4K4@4C4K5h5k4K4_5h5i4U5j4C5h5f4_4U4D4]4Y5h5e5i5j4\\4D5k4K4O5j5k5i4G5h5o5j4F4K5h4K4A5f4G5i4Y4]4X4]4A4A5d5h5d5m5f4K4\\4K5h5o5h5i4]4E4K5j4F4K5h5m4O4D5d4B4K4Y4O5j4F4K5j5k4K5h5f4U4Z5d5d5n4C4K4D5j4B5f4]4D5j4F5h5o5i4X4K4M5d5k5f4K4D5d5n4Y4Y5d5i4K4]5n5i4O4A4C5j4A5j4U4C5i4]4O5f4K4A4E5o4F4D4C5d5j5f4@4D5i5j5k4F4A4F4@5k4E4_5j4E5f4F5i5o4]4E4V4^4E5j5m4_4D5f4F5h5h5k5h5j4K4F5h5o5n5h4D5h5i4K4U5j5k4O5d5h4X5f4M5j5d4]4O5i4K5m5f5o4D5o5h4\\4K4F4]4F4D4D4O5j5k5i4_4K5j5o4D5f4U5m5n4C4A4_5j5h5k5i4X4U4]4O5k5h4X5k4]5n4[4]4[5h4Dsqlejofpfquj`fgfebvowkjnpfoegfwbjop`lmwfmwpvsslqwpwbqwfgnfppbdfpv``fppebpkjlm?wjwof=`lvmwqzb``lvmw`qfbwfgpwlqjfpqfpvowpqvmmjmdsql`fpptqjwjmdlaif`wpujpjaoftfo`lnfbqwj`ofvmhmltmmfwtlqh`lnsbmzgzmbnj`aqltpfqsqjub`zsqlaofnPfquj`fqfpsf`wgjpsobzqfrvfpwqfpfquftfapjwfkjpwlqzeqjfmgplswjlmptlqhjmdufqpjlmnjoojlm`kbmmfotjmglt-bggqfppujpjwfgtfbwkfq`lqqf`wsqlgv`wfgjqf`welqtbqgzlv#`bmqfnlufgpvaif`w`lmwqlobq`kjuf`vqqfmwqfbgjmdojaqbqzojnjwfgnbmbdfqevqwkfqpvnnbqznb`kjmfnjmvwfpsqjubwf`lmwf{wsqldqbnpl`jfwzmvnafqptqjwwfmfmbaofgwqjddfqplvq`fpolbgjmdfofnfmwsbqwmfqejmboozsfqef`wnfbmjmdpzpwfnphffsjmd`vowvqf%rvlw8/ilvqmbosqlif`wpvqeb`fp%rvlw8f{sjqfpqfujftpabobm`fFmdojpk@lmwfmwwkqlvdkSofbpf#lsjmjlm`lmwb`wbufqbdfsqjnbqzujoobdfPsbmjpkdboofqzgf`ojmfnffwjmdnjppjlmslsvobqrvbojwznfbpvqfdfmfqbopsf`jfppfppjlmpf`wjlmtqjwfqp`lvmwfqjmjwjboqfslqwpejdvqfpnfnafqpklogjmdgjpsvwffbqojfqf{sqfppgjdjwbosj`wvqfBmlwkfqnbqqjfgwqbeej`ofbgjmd`kbmdfg`fmwqbouj`wlqzjnbdfp,qfbplmppwvgjfpefbwvqfojpwjmdnvpw#afp`kllopUfqpjlmvpvboozfsjplgfsobzjmddqltjmdlaujlvplufqobzsqfpfmwb`wjlmp?,vo= tqbssfqboqfbgz`fqwbjmqfbojwzpwlqbdfbmlwkfqgfphwlsleefqfgsbwwfqmvmvpvboGjdjwbo`bsjwboTfapjwfebjovqf`lmmf`wqfgv`fgBmgqljggf`bgfpqfdvobq#%bns8#bmjnbopqfofbpfBvwlnbwdfwwjmdnfwklgpmlwkjmdSlsvobq`bswjlmofwwfqp`bswvqfp`jfm`foj`fmpf`kbmdfpFmdobmg>2%bns8Kjpwlqz#>#mft#@fmwqbovsgbwfgPsf`jboMfwtlqhqfrvjqf`lnnfmwtbqmjmd@loofdfwlloabqqfnbjmpaf`bvpffof`wfgGfvwp`kejmbm`ftlqhfqprvj`hozafwtffmf{b`wozpfwwjmdgjpfbpfPl`jfwztfbslmpf{kjajw%ow8"..@lmwqlo`obppfp`lufqfglvwojmfbwwb`hpgfuj`fp+tjmgltsvqslpfwjwof>!Nlajof#hjoojmdpkltjmdJwbojbmgqlssfgkfbujozfeef`wp.2$^*8 `lmejqn@vqqfmwbgubm`fpkbqjmdlsfmjmdgqbtjmdajoojlmlqgfqfgDfqnbmzqfobwfg?,elqn=jm`ovgftkfwkfqgfejmfgP`jfm`f`bwboldBqwj`ofavwwlmpobqdfpwvmjelqnilvqmfzpjgfabq@kj`bdlklojgbzDfmfqbosbppbdf/%rvlw8bmjnbwfeffojmdbqqjufgsbppjmdmbwvqboqlvdkoz- Wkf#avw#mlwgfmpjwzAqjwbjm@kjmfpfob`h#lewqjavwfJqfobmg!#gbwb.eb`wlqpqf`fjufwkbw#jpOjaqbqzkvpabmgjm#eb`wbeebjqp@kbqofpqbgj`boaqlvdkwejmgjmdobmgjmd9obmd>!qfwvqm#ofbgfqpsobmmfgsqfnjvnsb`hbdfBnfqj`bFgjwjlm^%rvlw8Nfppbdfmffg#wlubovf>!`lnsof{ollhjmdpwbwjlmafojfufpnboofq.nlajofqf`lqgptbmw#wlhjmg#leEjqfel{zlv#bqfpjnjobqpwvgjfgnb{jnvnkfbgjmdqbsjgoz`ojnbwfhjmdglnfnfqdfgbnlvmwpelvmgfgsjlmffqelqnvobgzmbpwzklt#wl#Pvsslqwqfufmvff`lmlnzQfpvowpaqlwkfqplogjfqobqdfoz`boojmd-%rvlw8B``lvmwFgtbqg#pfdnfmwQlafqw#feelqwpSb`jej`ofbqmfgvs#tjwkkfjdkw9tf#kbufBmdfofpmbwjlmp\\pfbq`kbssojfgb`rvjqfnbppjufdqbmwfg9#ebopfwqfbwfgajddfpwafmfejwgqjujmdPwvgjfpnjmjnvnsfqkbspnlqmjmdpfoojmdjp#vpfgqfufqpfubqjbmw#qlof>!njppjmdb`kjfufsqlnlwfpwvgfmwplnflmff{wqfnfqfpwlqfalwwln9fuloufgboo#wkfpjwfnbsfmdojpktbz#wl##Bvdvpwpznalop@lnsbmznbwwfqpnvpj`bobdbjmpwpfqujmd~*+*8 sbznfmwwqlvaof`lm`fsw`lnsbqfsbqfmwpsobzfqpqfdjlmpnlmjwlq#$$Wkf#tjmmjmdf{solqfbgbswfgDboofqzsqlgv`fbajojwzfmkbm`f`bqffqp*-#Wkf#`loof`wPfbq`k#bm`jfmwf{jpwfgellwfq#kbmgofqsqjmwfg`lmplofFbpwfqmf{slqwptjmgltp@kbmmfojoofdbomfvwqbopvddfpw\\kfbgfqpjdmjmd-kwno!=pfwwofgtfpwfqm`bvpjmd.tfahjw`objnfgIvpwj`f`kbswfquj`wjnpWklnbp#nlyjoobsqlnjpfsbqwjfpfgjwjlmlvwpjgf9ebopf/kvmgqfgLoznsj`\\avwwlmbvwklqpqfb`kfg`kqlmj`gfnbmgppf`lmgpsqlwf`wbglswfgsqfsbqfmfjwkfqdqfbwozdqfbwfqlufqboojnsqluf`lnnbmgpsf`jbopfbq`k-tlqpkjsevmgjmdwklvdkwkjdkfpwjmpwfbgvwjojwzrvbqwfq@vowvqfwfpwjmd`ofbqozf{slpfgAqltpfqojafqbo~#`bw`kSqlif`wf{bnsofkjgf+*8EolqjgbbmptfqpbooltfgFnsfqlqgfefmpfpfqjlvpeqffglnPfufqbo.avwwlmEvqwkfqlvw#le#">#mvoowqbjmfgGfmnbqhuljg+3*,boo-ipsqfufmwQfrvfpwPwfskfm Tkfm#lapfquf?,k1= Nlgfqm#sqlujgf!#bow>!alqgfqp- Elq# Nbmz#bqwjpwpsltfqfgsfqelqnej`wjlmwzsf#lenfgj`bowj`hfwplsslpfg@lvm`jotjwmfppivpwj`fDflqdf#Afodjvn---?,b=wtjwwfqmlwbaoztbjwjmdtbqebqf#Lwkfq#qbmhjmdskqbpfpnfmwjlmpvqujufp`klobq?,s= #@lvmwqzjdmlqfgolpp#leivpw#bpDflqdjbpwqbmdf?kfbg=?pwlssfg2$^*8 jpobmgpmlwbaofalqgfq9ojpw#le`bqqjfg233/333?,k0= #pfufqboaf`lnfppfof`w#tfggjmd33-kwnonlmbq`klee#wkfwfb`kfqkjdkoz#ajloldzojef#lelq#fufmqjpf#le%qbrvl8sovplmfkvmwjmd+wklvdkGlvdobpiljmjmd`jq`ofpElq#wkfBm`jfmwUjfwmbnufkj`ofpv`k#bp`qzpwboubovf#>Tjmgltpfmilzfgb#pnboobppvnfg?b#jg>!elqfjdm#Boo#qjklt#wkfGjpsobzqfwjqfgkltfufqkjggfm8abwwofppffhjmd`bajmfwtbp#mlwollh#bw`lmgv`wdfw#wkfIbmvbqzkbssfmpwvqmjmdb9klufqLmojmf#Eqfm`k#ob`hjmdwzsj`bof{wqb`wfmfnjfpfufm#jedfmfqbwgf`jgfgbqf#mlw,pfbq`kafojfep.jnbdf9ol`bwfgpwbwj`-oldjm!=`lmufqwujlofmwfmwfqfgejqpw!=`jq`vjwEjmobmg`kfnjpwpkf#tbp23s{8!=bp#pv`kgjujgfg?,psbm=tjoo#afojmf#leb#dqfbwnzpwfqz,jmgf{-eboojmdgvf#wl#qbjotbz`loofdfnlmpwfqgfp`fmwjw#tjwkmv`ofbqIftjpk#sqlwfpwAqjwjpkeoltfqpsqfgj`wqfelqnpavwwlm#tkl#tbpof`wvqfjmpwbmwpvj`jgfdfmfqj`sfqjlgpnbqhfwpPl`jbo#ejpkjmd`lnajmfdqbskj`tjmmfqp?aq#,=?az#wkf#MbwvqboSqjub`z`llhjfplvw`lnfqfploufPtfgjpkaqjfeozSfqpjbmpl#nv`k@fmwvqzgfsj`wp`lovnmpklvpjmdp`qjswpmf{w#wlafbqjmdnbssjmdqfujpfgiRvfqz+.tjgwk9wjwof!=wllowjsPf`wjlmgfpjdmpWvqhjpkzlvmdfq-nbw`k+~*+*8 avqmjmdlsfqbwfgfdqffpplvq`f>Qj`kbqg`olpfozsobpwj`fmwqjfp?,wq= `lolq9 vo#jg>!slppfppqloojmdskzpj`pebjojmdf{f`vwf`lmwfpwojmh#wlGfebvow?aq#,= 9#wqvf/`kbqwfqwlvqjpn`obppj`sql`ffgf{sobjm?,k2= lmojmf-<{no#ufkfosjmdgjbnlmgvpf#wkfbjqojmffmg#..=*-bwwq+qfbgfqpklpwjmd eeeeeeqfbojyfUjm`fmwpjdmbop#pq`>!,Sqlgv`wgfpsjwfgjufqpfwfoojmdSvaoj`#kfog#jmIlpfsk#wkfbwqfbeef`wp?pwzof=b#obqdfglfpm$wobwfq/#Fofnfmwebuj`lm`qfbwlqKvmdbqzBjqslqwpff#wkfpl#wkbwNj`kbfoPzpwfnpSqldqbnp/#bmg##tjgwk>f%rvlw8wqbgjmdofew!= sfqplmpDlogfm#Beebjqpdqbnnbqelqnjmdgfpwqlzjgfb#le`bpf#lelogfpw#wkjp#jp-pq`#>#`bqwllmqfdjpwq@lnnlmpNvpojnpTkbw#jpjm#nbmznbqhjmdqfufbopJmgffg/frvbooz,pklt\\blvwgllqfp`bsf+Bvpwqjbdfmfwj`pzpwfn/Jm#wkf#pjwwjmdKf#boplJpobmgpB`bgfnz \n\n?"..Gbmjfo#ajmgjmdaol`h!=jnslpfgvwjojyfBaqbkbn+f{`fswxtjgwk9svwwjmd*-kwno+\x7F\x7F#X^8 GBWBX#)hjw`kfmnlvmwfgb`wvbo#gjbof`wnbjmoz#\\aobmh$jmpwboof{sfqwpje+wzsfJw#bopl%`lsz8#!=Wfqnpalqm#jmLswjlmpfbpwfqmwbohjmd`lm`fqmdbjmfg#lmdljmdivpwjez`qjwj`peb`wlqzjwp#ltmbppbvowjmujwfgobpwjmdkjp#ltmkqfe>!,!#qfo>!gfufols`lm`fqwgjbdqbngloobqp`ovpwfqsks<jg>bo`lklo*8~*+*8vpjmd#b=?psbm=ufppfopqfujuboBggqfppbnbwfvqbmgqljgboofdfgjoomfpptbohjmd`fmwfqprvbojeznbw`kfpvmjejfgf{wjm`wGfefmpfgjfg#jm \n?"..#`vpwlnpojmhjmdOjwwof#Allh#lefufmjmdnjm-ip<bqf#wkfhlmwbhwwlgbz$p-kwno!#wbqdfw>tfbqjmdBoo#Qjd8 ~*+*8qbjpjmd#Bopl/#`qv`jbobalvw!=gf`obqf..= ?p`ejqfel{bp#nv`kbssojfpjmgf{/#p/#avw#wzsf#>#  ?"..wltbqgpQf`lqgpSqjubwfElqfjdmSqfnjfq`klj`fpUjqwvboqfwvqmp@lnnfmwSltfqfgjmojmf8slufqwz`kbnafqOjujmd#ulovnfpBmwklmzoldjm!#QfobwfgF`lmlnzqfb`kfp`vwwjmddqbujwzojef#jm@kbswfq.pkbgltMlwbaof?,wg= #qfwvqmpwbgjvntjgdfwpubqzjmdwqbufopkfog#aztkl#bqftlqh#jmeb`vowzbmdvobqtkl#kbgbjqslqwwltm#le Plnf#$`oj`h$`kbqdfphfztlqgjw#tjoo`jwz#le+wkjp*8Bmgqft#vmjrvf#`kf`hfglq#nlqf033s{8#qfwvqm8qpjlm>!sovdjmptjwkjm#kfqpfoePwbwjlmEfgfqboufmwvqfsvaojpkpfmw#wlwfmpjlmb`wqfpp`lnf#wlejmdfqpGvhf#lesflsof/f{soljwtkbw#jpkbqnlmzb#nbilq!9!kwwsjm#kjp#nfmv!= nlmwkozleej`fq`lvm`jodbjmjmdfufm#jmPvnnbqzgbwf#leolzbowzejwmfppbmg#tbpfnsfqlqpvsqfnfPf`lmg#kfbqjmdQvppjbmolmdfpwBoafqwbobwfqbopfw#le#pnboo!=-bssfmggl#tjwkefgfqboabmh#leafmfbwkGfpsjwf@bsjwbodqlvmgp*/#bmg#sfq`fmwjw#eqln`olpjmd`lmwbjmJmpwfbgejewffmbp#tfoo-zbkll-qfpslmgejdkwfqlap`vqfqfeof`wlqdbmj`>#Nbwk-fgjwjmdlmojmf#sbggjmdb#tkloflmfqqlqzfbq#lefmg#le#abqqjfqtkfm#jwkfbgfq#klnf#leqfpvnfgqfmbnfgpwqlmd=kfbwjmdqfwbjmp`olvgeqtbz#le#Nbq`k#2hmltjmdjm#sbqwAfwtffmofpplmp`olpfpwujqwvboojmhp!=`qlppfgFMG#..=ebnlvp#btbqgfgOj`fmpfKfbowk#ebjqoz#tfbowkznjmjnboBeqj`bm`lnsfwfobafo!=pjmdjmdebqnfqpAqbpjo*gjp`vppqfsob`fDqfdlqzelmw#`lsvqpvfgbssfbqpnbhf#vsqlvmgfgalwk#leaol`hfgpbt#wkfleej`fp`lolvqpje+gl`vtkfm#kffmelq`fsvpk+evBvdvpw#VWE.;!=Ebmwbpzjm#nlpwjmivqfgVpvboozebqnjmd`olpvqflaif`w#gfefm`fvpf#le#Nfgj`bo?algz= fujgfmwaf#vpfghfz@lgfpj{wffmJpobnj` 333333fmwjqf#tjgfoz#b`wjuf#+wzsflelmf#`bm`lolq#>psfbhfqf{wfmgpSkzpj`pwfqqbjm?walgz=evmfqboujftjmdnjggof#`qj`hfwsqlskfwpkjewfggl`wlqpQvppfoo#wbqdfw`lnsb`wbodfaqbpl`jbo.avoh#lenbm#bmg?,wg= #kf#ofew*-ubo+*ebopf*8oldj`boabmhjmdklnf#wlmbnjmd#Bqjylmb`qfgjwp*8 ~*8 elvmgfqjm#wvqm@loojmpafelqf#Avw#wkf`kbqdfgWjwof!=@bswbjmpsfoofgdlggfppWbd#..=Bggjmd9avw#tbpQf`fmw#sbwjfmwab`h#jm>ebopf%Ojm`lomtf#hmlt@lvmwfqIvgbjpnp`qjsw#bowfqfg$^*8 ##kbp#wkfvm`ofbqFufmw$/alwk#jmmlw#boo ?"..#sob`jmdkbqg#wl#`fmwfqplqw#le`ojfmwppwqffwpAfqmbqgbppfqwpwfmg#wlebmwbpzgltm#jmkbqalvqEqffglniftfoqz,balvw--pfbq`kofdfmgpjp#nbgfnlgfqm#lmoz#lmlmoz#wljnbdf!#ojmfbq#sbjmwfqbmg#mlwqbqfoz#b`qlmzngfojufqpklqwfq33%bns8bp#nbmztjgwk>!,)#?"X@wjwof#>le#wkf#oltfpw#sj`hfg#fp`bsfgvpfp#lesflsofp#Svaoj`Nbwwkftwb`wj`pgbnbdfgtbz#elqobtp#lefbpz#wl#tjmgltpwqlmd##pjnsof~`bw`k+pfufmwkjmelal{tfmw#wlsbjmwfg`jwjyfmJ#glm$wqfwqfbw-#Plnf#tt-!*8 alnajmdnbjowl9nbgf#jm-#Nbmz#`bqqjfp\x7F\x7Fx~8tjtlqh#lepzmlmzngfefbwpebulqfglswj`bosbdfWqbvmofpp#pfmgjmdofew!=?`lnP`lqBoo#wkfiRvfqz-wlvqjpw@obppj`ebopf!#Tjokfonpvavqapdfmvjmfajpklsp-psojw+dolabo#elooltpalgz#lemlnjmbo@lmwb`wpf`vobqofew#wl`kjfeoz.kjggfm.abmmfq?,oj= -#Tkfm#jm#alwkgjpnjppF{solqfbotbzp#ujb#wkfpsb/]lotfoebqfqvojmd#bqqbmdf`bswbjmkjp#plmqvof#lekf#wllhjwpfoe/>3%bns8+`boofgpbnsofpwl#nbhf`ln,sbdNbqwjm#Hfmmfgzb``fswpevoo#lekbmgofgAfpjgfp,,..=?,baof#wlwbqdfwpfppfm`fkjn#wl#jwp#az#`lnnlm-njmfqbowl#wbhftbzp#wlp-lqd,obgujpfgsfmbowzpjnsof9je#wkfzOfwwfqpb#pklqwKfqafqwpwqjhfp#dqlvsp-ofmdwkeojdkwplufqobspoltoz#ofppfq#pl`jbo#?,s= \n\njw#jmwlqbmhfg#qbwf#levo= ##bwwfnswsbjq#lenbhf#jwHlmwbhwBmwlmjlkbujmd#qbwjmdp#b`wjufpwqfbnpwqbssfg!*-`pp+klpwjofofbg#wlojwwof#dqlvsp/Sj`wvqf..=  #qltp>!#laif`wjmufqpf?ellwfq@vpwlnU=?_,p`qploujmd@kbnafqpobufqztlvmgfgtkfqfbp">#$vmgelq#boosbqwoz#.qjdkw9Bqbajbmab`hfg#`fmwvqzvmjw#lenlajof.Fvqlsf/jp#klnfqjph#legfpjqfg@ojmwlm`lpw#lebdf#le#af`lnf#mlmf#les%rvlw8Njggof#fbg$*X3@qjwj`ppwvgjlp=%`lsz8dqlvs!=bppfnaonbhjmd#sqfppfgtjgdfw-sp9!#<#qfavjowaz#plnfElqnfq#fgjwlqpgfobzfg@bmlmj`kbg#wkfsvpkjmd`obpp>!avw#bqfsbqwjboAbazolmalwwln#`bqqjfq@lnnbmgjwp#vpfBp#tjwk`lvqpfpb#wkjqggfmlwfpbopl#jmKlvpwlm13s{8!=b``vpfgglvaof#dlbo#leEbnlvp#*-ajmg+sqjfpwp#Lmojmfjm#Ivozpw#(#!d`lmpvowgf`jnbokfosevoqfujufgjp#ufqzq$($jswolpjmd#efnbofpjp#boplpwqjmdpgbzp#lebqqjuboevwvqf#?laif`welq`jmdPwqjmd+!#,= \n\nkfqf#jpfm`lgfg-##Wkf#aboollmglmf#az,`lnnlmad`lolqobt#le#Jmgjbmbbuljgfgavw#wkf1s{#0s{irvfqz-bewfq#bsloj`z-nfm#bmgellwfq.>#wqvf8elq#vpfp`qffm-Jmgjbm#jnbdf#>ebnjoz/kwws9,,#%maps8gqjufqpfwfqmbopbnf#bpmlwj`fgujftfqp~*+*8 #jp#nlqfpfbplmpelqnfq#wkf#mftjp#ivpw`lmpfmw#Pfbq`ktbp#wkftkz#wkfpkjssfgaq=?aq=tjgwk9#kfjdkw>nbgf#le`vjpjmfjp#wkbwb#ufqz#Bgnjqbo#ej{fg8mlqnbo#NjppjlmSqfpp/#lmwbqjl`kbqpfwwqz#wl#jmubgfg>!wqvf!psb`jmdjp#nlpwb#nlqf#wlwboozeboo#le~*8 ##jnnfmpfwjnf#jmpfw#lvwpbwjpezwl#ejmggltm#wlolw#le#Sobzfqpjm#Ivmfrvbmwvnmlw#wkfwjnf#wlgjpwbmwEjmmjpkpq`#>#+pjmdof#kfos#leDfqnbm#obt#bmgobafofgelqfpwp`llhjmdpsb`f!=kfbgfq.tfoo#bpPwbmofzaqjgdfp,dolabo@qlbwjb#Balvw#X3^8 ##jw/#bmgdqlvsfgafjmd#b*xwkqltkf#nbgfojdkwfqfwkj`boEEEEEE!alwwln!ojhf#b#fnsolzpojuf#jmbp#pffmsqjmwfqnlpw#leva.ojmhqfif`wpbmg#vpfjnbdf!=pv``ffgeffgjmdMv`ofbqjmelqnbwl#kfosTlnfm$pMfjwkfqNf{j`bmsqlwfjm?wbaof#az#nbmzkfbowkzobtpvjwgfujpfg-svpk+xpfoofqppjnsoz#Wkqlvdk-`llhjf#Jnbdf+logfq!=vp-ip!=#Pjm`f#vmjufqpobqdfq#lsfm#wl"..#fmgojfp#jm$^*8 ##nbqhfwtkl#jp#+!GLN@lnbmbdfglmf#elqwzsfle#Hjmdglnsqlejwpsqlslpfwl#pklt`fmwfq8nbgf#jwgqfppfgtfqf#jmnj{wvqfsqf`jpfbqjpjmdpq`#>#$nbhf#b#pf`vqfgAbswjpwulwjmd# \n\nubq#Nbq`k#1dqft#vs@ojnbwf-qfnlufphjoofgtbz#wkf?,kfbg=eb`f#leb`wjmd#qjdkw!=wl#tlqhqfgv`fpkbp#kbgfqf`wfgpklt+*8b`wjlm>allh#lebm#bqfb>>#!kww?kfbgfq ?kwno=`lmelqneb`jmd#`llhjf-qfoz#lmklpwfg#-`vpwlnkf#tfmwavw#elqpsqfbg#Ebnjoz#b#nfbmplvw#wkfelqvnp-ellwbdf!=Nlajo@ofnfmwp!#jg>!bp#kjdkjmwfmpf..=?"..efnbof#jp#pffmjnsojfgpfw#wkfb#pwbwfbmg#kjpebpwfpwafpjgfpavwwlm\\alvmgfg!=?jnd#Jmelal{fufmwp/b#zlvmdbmg#bqfMbwjuf#`kfbsfqWjnflvwbmg#kbpfmdjmfptlm#wkf+nlpwozqjdkw9#ejmg#b#.alwwlnSqjm`f#bqfb#lenlqf#lepfbq`k\\mbwvqf/ofdboozsfqjlg/obmg#lelq#tjwkjmgv`fgsqlujmdnjppjofol`boozBdbjmpwwkf#tbzh%rvlw8s{8!= svpkfg#babmglmmvnfqbo@fqwbjmJm#wkjpnlqf#jmlq#plnfmbnf#jpbmg/#jm`qltmfgJPAM#3.`qfbwfpL`wlafqnbz#mlw`fmwfq#obwf#jmGfefm`ffmb`wfgtjpk#wlaqlbgoz`llojmdlmolbg>jw-#Wkfqf`lufqNfnafqpkfjdkw#bppvnfp?kwno= sflsof-jm#lmf#>tjmgltellwfq\\b#dllg#qfhobnblwkfqp/wl#wkjp\\`llhjfsbmfo!=Olmglm/gfejmfp`qvpkfgabswjpn`lbpwbopwbwvp#wjwof!#nluf#wlolpw#jmafwwfq#jnsojfpqjuboqzpfqufqp#PzpwfnSfqkbspfp#bmg#`lmwfmgeoltjmdobpwfg#qjpf#jmDfmfpjpujft#leqjpjmd#pffn#wlavw#jm#ab`hjmdkf#tjoodjufm#bdjujmd#`jwjfp-eolt#le#Obwfq#boo#avwKjdktbzlmoz#azpjdm#lekf#glfpgjeefqpabwwfqz%bns8obpjmdofpwkqfbwpjmwfdfqwbhf#lmqfevpfg`boofg#>VP%bnsPff#wkfmbwjufpaz#wkjppzpwfn-kfbg#le9klufq/ofpajbmpvqmbnfbmg#boo`lnnlm,kfbgfq\\\\sbqbnpKbqubqg,sj{fo-qfnlubopl#olmdqlof#leiljmwozphzp`qbVmj`lgfaq#,= Bwobmwbmv`ofvp@lvmwz/svqfoz#`lvmw!=fbpjoz#avjog#blm`oj`hb#djufmsljmwfqk%rvlw8fufmwp#fopf#x gjwjlmpmlt#wkf/#tjwk#nbm#tkllqd,Tfalmf#bmg`buboqzKf#gjfgpfbwwof33/333#xtjmgltkbuf#wlje+tjmgbmg#jwpplofoz#n%rvlw8qfmftfgGfwqljwbnlmdpwfjwkfq#wkfn#jmPfmbwlqVp?,b=?Hjmd#leEqbm`jp.sqlgv`kf#vpfgbqw#bmgkjn#bmgvpfg#azp`lqjmdbw#klnfwl#kbufqfobwfpjajojwzeb`wjlmAveebolojmh!=?tkbw#kfeqff#wl@jwz#le`lnf#jmpf`wlqp`lvmwfglmf#gbzmfqulvpprvbqf#~8je+dljm#tkbwjnd!#bojp#lmozpfbq`k,wvfpgbzollpfozPlolnlmpf{vbo#.#?b#kqnfgjvn!GL#MLW#Eqbm`f/tjwk#b#tbq#bmgpf`lmg#wbhf#b#=   nbqhfw-kjdktbzglmf#jm`wjujwz!obpw!=laojdfgqjpf#wl!vmgfejnbgf#wl#Fbqoz#sqbjpfgjm#jwp#elq#kjpbwkofwfIvsjwfqZbkll"#wfqnfg#pl#nbmzqfbooz#p-#Wkf#b#tlnbm<ubovf>gjqf`w#qjdkw!#aj`z`ofb`jmd>!gbz#bmgpwbwjmdQbwkfq/kjdkfq#Leej`f#bqf#mltwjnfp/#tkfm#b#sbz#elqlm#wkjp.ojmh!=8alqgfqbqlvmg#bmmvbo#wkf#Mftsvw#wkf-`ln!#wbhjm#wlb#aqjfe+jm#wkfdqlvsp-8#tjgwkfmyznfppjnsof#jm#obwfxqfwvqmwkfqbszb#sljmwabmmjmdjmhp!= +*8!#qfb#sob`f_v330@bbalvw#bwq= \n\n``lvmw#djufp#b?P@QJSWQbjotbzwkfnfp,wlloal{AzJg+!{kvnbmp/tbw`kfpjm#plnf#je#+tj`lnjmd#elqnbwp#Vmgfq#avw#kbpkbmgfg#nbgf#azwkbm#jmefbq#legfmlwfg,jeqbnfofew#jmulowbdfjm#fb`kb%rvlw8abpf#leJm#nbmzvmgfqdlqfdjnfpb`wjlm#?,s= ?vpwlnUb8%dw8?,jnslqwplq#wkbwnlpwoz#%bns8qf#pjyf>!?,b=?,kb#`obppsbppjufKlpw#>#TkfwkfqefqwjofUbqjlvp>X^8+ev`bnfqbp,=?,wg=b`wp#bpJm#plnf=  ?"lqdbmjp#?aq#,=Afjijmd`bwbo/Lgfvwp`kfvqlsfvfvphbqbdbfjodfpufmphbfpsb/]bnfmpbifvpvbqjlwqbabiln/E{j`ls/Mdjmbpjfnsqfpjpwfnbl`wvaqfgvqbmwfb/]bgjqfnsqfpbnlnfmwlmvfpwqlsqjnfqbwqbu/Epdqb`jbpmvfpwqbsql`fplfpwbglp`bojgbgsfqplmbm/Vnfqlb`vfqgln/Vpj`bnjfnaqllefqwbpbodvmlpsb/Apfpfifnsolgfqf`klbgfn/Mpsqjubglbdqfdbqfmob`fpslpjaofklwfofppfujoobsqjnfql/Vowjnlfufmwlpbq`kjul`vowvqbnvifqfpfmwqbgbbmvm`jlfnabqdlnfq`bgldqbmgfpfpwvgjlnfilqfpefaqfqlgjpf/]lwvqjpnl`/_gjdlslqwbgbfpsb`jlebnjojbbmwlmjlsfqnjwfdvbqgbqbodvmbpsqf`jlpbodvjfmpfmwjglujpjwbpw/Awvol`lml`fqpfdvmgl`lmpfileqbm`jbnjmvwlppfdvmgbwfmfnlpfef`wlpn/Mobdbpfpj/_mqfujpwbdqbmbgb`lnsqbqjmdqfpldbq`/Abb``j/_mf`vbglqrvjfmfpjm`ovplgfafq/Mnbwfqjbklnaqfpnvfpwqbslgq/Abnb/]bmb/Vowjnbfpwbnlplej`jbowbnajfmmjmd/Vmpbovglpslgfnlpnfilqbqslpjwjlmavpjmfppklnfsbdfpf`vqjwzobmdvbdfpwbmgbqg`bnsbjdmefbwvqfp`bwfdlqzf{wfqmbo`kjogqfmqfpfqufgqfpfbq`kf{`kbmdfebulqjwfwfnsobwfnjojwbqzjmgvpwqzpfquj`fpnbwfqjbosqlgv`wpy.jmgf{9`lnnfmwpplewtbqf`lnsofwf`bofmgbqsobwelqnbqwj`ofpqfrvjqfgnlufnfmwrvfpwjlmavjogjmdslojwj`pslppjaofqfojdjlmskzpj`boeffgab`hqfdjpwfqsj`wvqfpgjpbaofgsqlwl`lobvgjfm`fpfwwjmdpb`wjujwzfofnfmwpofbqmjmdbmzwkjmdbapwqb`wsqldqfpplufqujftnbdbyjmff`lmlnj`wqbjmjmdsqfppvqfubqjlvp#?pwqlmd=sqlsfqwzpklssjmdwldfwkfqbgubm`fgafkbujlqgltmolbgefbwvqfgellwaboopfof`wfgObmdvbdfgjpwbm`fqfnfnafqwqb`hjmdsbpptlqgnlgjejfgpwvgfmwpgjqf`wozejdkwjmdmlqwkfqmgbwbabpfefpwjuboaqfbhjmdol`bwjlmjmwfqmfwgqlsgltmsqb`wj`ffujgfm`fevm`wjlmnbqqjbdfqfpslmpfsqlaofnpmfdbwjufsqldqbnpbmbozpjpqfofbpfgabmmfq!=svq`kbpfsloj`jfpqfdjlmbo`qfbwjufbqdvnfmwallhnbqhqfefqqfq`kfnj`bogjujpjlm`booab`hpfsbqbwfsqlif`wp`lmeoj`wkbqgtbqfjmwfqfpwgfojufqznlvmwbjmlawbjmfg>#ebopf8elq+ubq#b``fswfg`bsb`jwz`lnsvwfqjgfmwjwzbjq`qbewfnsolzfgsqlslpfgglnfpwj`jm`ovgfpsqlujgfgklpsjwboufqwj`bo`loobspfbssqlb`ksbqwmfqpoldl!=?bgbvdkwfqbvwklq!#`vowvqboebnjojfp,jnbdfp,bppfnaozsltfqevowfb`kjmdejmjpkfggjpwqj`w`qjwj`bo`dj.ajm,svqslpfpqfrvjqfpfof`wjlmaf`lnjmdsqlujgfpb`bgfnj`f{fq`jpfb`wvbooznfgj`jmf`lmpwbmwb``jgfmwNbdbyjmfgl`vnfmwpwbqwjmdalwwln!=lapfqufg9#%rvlw8f{wfmgfgsqfujlvpPlewtbqf`vpwlnfqgf`jpjlmpwqfmdwkgfwbjofgpojdkwozsobmmjmdwf{wbqfb`vqqfm`zfufqzlmfpwqbjdkwwqbmpefqslpjwjufsqlgv`fgkfqjwbdfpkjssjmdbaplovwfqf`fjufgqfofubmwavwwlm!#ujlofm`fbmztkfqfafmfejwpobvm`kfgqf`fmwozboojbm`felooltfgnvowjsofavoofwjmjm`ovgfgl``vqqfgjmwfqmbo\'+wkjp*-qfsvaoj`=?wq=?wg`lmdqfppqf`lqgfgvowjnbwfplovwjlm?vo#jg>!gjp`lufqKlnf?,b=tfapjwfpmfwtlqhpbowklvdkfmwjqfoznfnlqjbonfppbdfp`lmwjmvfb`wjuf!=plnftkbwuj`wlqjbTfpwfqm##wjwof>!Ol`bwjlm`lmwqb`wujpjwlqpGltmolbgtjwklvw#qjdkw!= nfbpvqfptjgwk#>#ubqjbaofjmuloufgujqdjmjbmlqnboozkbssfmfgb``lvmwppwbmgjmdmbwjlmboQfdjpwfqsqfsbqfg`lmwqlopb``vqbwfajqwkgbzpwqbwfdzleej`jbodqbskj`p`qjnjmboslppjaoz`lmpvnfqSfqplmbopsfbhjmdubojgbwfb`kjfufg-isd!#,=nb`kjmfp?,k1= ##hfztlqgpeqjfmgozaqlwkfqp`lnajmfglqjdjmbo`lnslpfgf{sf`wfgbgfrvbwfsbhjpwbmeloolt!#ubovbaof?,obafo=qfobwjufaqjmdjmdjm`qfbpfdlufqmlqsovdjmp,Ojpw#le#Kfbgfq!=!#mbnf>!#+%rvlw8dqbgvbwf?,kfbg= `lnnfq`fnbobzpjbgjqf`wlqnbjmwbjm8kfjdkw9p`kfgvof`kbmdjmdab`h#wl#`bwkloj`sbwwfqmp`lolq9# dqfbwfpwpvssojfpqfojbaof?,vo= \n\n?pfof`w#`jwjyfmp`olwkjmdtbw`kjmd?oj#jg>!psf`jej``bqqzjmdpfmwfm`f?`fmwfq=`lmwqbpwwkjmhjmd`bw`k+f*plvwkfqmNj`kbfo#nfq`kbmw`bqlvpfosbggjmd9jmwfqjlq-psojw+!ojybwjlmL`wlafq#*xqfwvqmjnsqlufg..%dw8 `lufqbdf`kbjqnbm-smd!#,=pvaif`wpQj`kbqg#tkbwfufqsqlabaozqf`lufqzabpfabooivgdnfmw`lmmf`w--`pp!#,=#tfapjwfqfslqwfggfebvow!,=?,b= fof`wqj`p`lwobmg`qfbwjlmrvbmwjwz-#JPAM#3gjg#mlw#jmpwbm`f.pfbq`k.!#obmd>!psfbhfqp@lnsvwfq`lmwbjmpbq`kjufpnjmjpwfqqfb`wjlmgjp`lvmwJwbojbml`qjwfqjbpwqlmdoz9#$kwws9$p`qjsw$`lufqjmdleefqjmdbssfbqfgAqjwjpk#jgfmwjezEb`fallhmvnfqlvpufkj`ofp`lm`fqmpBnfqj`bmkbmgojmdgju#jg>!Tjoojbn#sqlujgfq\\`lmwfmwb``vqb`zpf`wjlm#bmgfqplmeof{jaof@bwfdlqzobtqfm`f?p`qjsw=obzlvw>!bssqlufg#nb{jnvnkfbgfq!=?,wbaof=Pfquj`fpkbnjowlm`vqqfmw#`bmbgjbm`kbmmfop,wkfnfp,,bqwj`oflswjlmboslqwvdboubovf>!!jmwfqubotjqfofppfmwjwofgbdfm`jfpPfbq`k!#nfbpvqfgwklvpbmgpsfmgjmd%kfoojs8mft#Gbwf!#pjyf>!sbdfMbnfnjggof!#!#,=?,b=kjggfm!=pfrvfm`fsfqplmbolufqeoltlsjmjlmpjoojmljpojmhp!= \n?wjwof=ufqpjlmppbwvqgbzwfqnjmbojwfnsqlsfmdjmffqpf`wjlmpgfpjdmfqsqlslpbo>!ebopf!Fpsb/]loqfofbpfppvanjw!#fq%rvlw8bggjwjlmpznswlnplqjfmwfgqfplvq`fqjdkw!=?sofbpvqfpwbwjlmpkjpwlqz-ofbujmd##alqgfq>`lmwfmwp`fmwfq!=- Plnf#gjqf`wfgpvjwbaofavodbqjb-pklt+*8gfpjdmfgDfmfqbo#`lm`fswpF{bnsofptjoojbnpLqjdjmbo!=?psbm=pfbq`k!=lsfqbwlqqfrvfpwpb#%rvlw8booltjmdGl`vnfmwqfujpjlm-# Wkf#zlvqpfoe@lmwb`w#nj`kjdbmFmdojpk#`lovnajbsqjlqjwzsqjmwjmdgqjmhjmdeb`jojwzqfwvqmfg@lmwfmw#leej`fqpQvppjbm#dfmfqbwf.;;6:.2!jmgj`bwfebnjojbq#rvbojwznbqdjm93#`lmwfmwujftslqw`lmwb`wp.wjwof!=slqwbaof-ofmdwk#fojdjaofjmuloufpbwobmwj`lmolbg>!gfebvow-pvssojfgsbznfmwpdolppbqz Bewfq#dvjgbm`f?,wg=?wgfm`lgjmdnjggof!=`bnf#wl#gjpsobzpp`lwwjpkilmbwkbmnbilqjwztjgdfwp-`ojmj`bowkbjobmgwfb`kfqp?kfbg= \nbeef`wfgpvsslqwpsljmwfq8wlPwqjmd?,pnboo=lhobklnbtjoo#af#jmufpwlq3!#bow>!klojgbzpQfplvq`foj`fmpfg#+tkj`k#-#Bewfq#`lmpjgfqujpjwjmdf{solqfqsqjnbqz#pfbq`k!#bmgqljg!rvj`hoz#nffwjmdpfpwjnbwf8qfwvqm#8`lolq9 #kfjdkw>bssqlubo/#%rvlw8#`kf`hfg-njm-ip!nbdmfwj`=?,b=?,kelqf`bpw-#Tkjof#wkvqpgbzgufqwjpf%fb`vwf8kbp@obppfubovbwflqgfqjmdf{jpwjmdsbwjfmwp#Lmojmf#`lolqbglLswjlmp!`bnsafoo?"..#fmg?,psbm=??aq#,= \\slsvsp\x7Fp`jfm`fp/%rvlw8#rvbojwz#Tjmgltp#bppjdmfgkfjdkw9#?a#`obppof%rvlw8#ubovf>!#@lnsbmzf{bnsofp?jeqbnf#afojfufpsqfpfmwpnbqpkboosbqw#le#sqlsfqoz*- Wkf#wb{lmlnznv`k#le#?,psbm= !#gbwb.pqwvdv/Fpp`qlooWl#sqlif`w?kfbg= bwwlqmfzfnskbpjppslmplqpebm`zal{tlqog$p#tjogojef`kf`hfg>pfppjlmpsqldqbnns{8elmw.#Sqlif`wilvqmbopafojfufgub`bwjlmwklnsplmojdkwjmdbmg#wkf#psf`jbo#alqgfq>3`kf`hjmd?,walgz=?avwwlm#@lnsofwf`ofbqej{ ?kfbg= bqwj`of#?pf`wjlmejmgjmdpqlof#jm#slsvobq##L`wlafqtfapjwf#f{slpvqfvpfg#wl##`kbmdfplsfqbwfg`oj`hjmdfmwfqjmd`lnnbmgpjmelqnfg#mvnafqp##?,gju=`qfbwjmdlmPvanjwnbqzobmg`loofdfpbmbozwj`ojpwjmdp`lmwb`w-olddfgJmbgujplqzpjaojmdp`lmwfmw!p%rvlw8*p-#Wkjp#sb`hbdfp`kf`hal{pvddfpwpsqfdmbmwwlnlqqltpsb`jmd>j`lm-smdibsbmfpf`lgfabpfavwwlm!=dbnaojmdpv`k#bp#/#tkjof#?,psbm=#njpplvqjpslqwjmdwls92s{#-?,psbm=wfmpjlmptjgwk>!1obyzolbgmlufnafqvpfg#jm#kfjdkw>!`qjsw!= %maps8?,?wq=?wg#kfjdkw91,sqlgv`w`lvmwqz#jm`ovgf#ellwfq!#%ow8"..#wjwof!=?,irvfqz-?,elqn= +\vBl\bQ\x7F*+\vUmGx*kqubwphjjwbojbmlqln/Nm(ow/Pqh/Kf4K4]4C5dwbnaj/Emmlwj`jbpnfmpbifpsfqplmbpgfqf`klpmb`jlmbopfquj`jl`lmwb`wlvpvbqjlpsqldqbnbdlajfqmlfnsqfpbpbmvm`jlpubofm`jb`lolnajbgfpsv/Epgfslqwfpsqlzf`wlsqlgv`wls/Vaoj`lmlplwqlpkjpwlqjbsqfpfmwfnjoolmfpnfgjbmwfsqfdvmwbbmwfqjlqqf`vqplpsqlaofnbpbmwjbdlmvfpwqlplsjmj/_mjnsqjnjqnjfmwqbpbn/Eqj`bufmgfglqpl`jfgbgqfpsf`wlqfbojybqqfdjpwqlsbobaqbpjmwfq/Epfmwlm`fpfpsf`jbonjfnaqlpqfbojgbg`/_qglabybqbdlybs/Mdjmbppl`jbofpaolrvfbqdfpwj/_mborvjofqpjpwfnbp`jfm`jbp`lnsofwlufqpj/_m`lnsofwbfpwvgjlps/Vaoj`blaifwjulboj`bmwfavp`bglq`bmwjgbgfmwqbgbpb``jlmfpbq`kjulppvsfqjlqnbzlq/Abbofnbmjbevm`j/_m/Vowjnlpkb`jfmglbrvfoolpfgj`j/_mefqmbmglbnajfmwfeb`fallhmvfpwqbp`ojfmwfpsql`fplpabpwbmwfsqfpfmwbqfslqwbq`lmdqfplsvaoj`bq`lnfq`jl`lmwqbwli/_ufmfpgjpwqjwlw/E`mj`b`lmivmwlfmfqd/Abwqbabibqbpwvqjbpqf`jfmwfvwjojybqalofw/Ampboubglq`lqqf`wbwqbabilpsqjnfqlpmfdl`jlpojafqwbggfwboofpsbmwboobsq/_{jnlbonfq/Abbmjnbofprvj/Emfp`lqby/_mpf``j/_mavp`bmglls`jlmfpf{wfqjlq`lm`fswlwlgbu/Abdbofq/Abfp`qjajqnfgj`jmboj`fm`jb`lmpvowbbpsf`wlp`q/Awj`bg/_obqfpivpwj`jbgfafq/Mmsfq/Alglmf`fpjwbnbmwfmfqsfrvf/]lqf`jajgbwqjavmbowfmfqjef`bm`j/_m`bmbqjbpgfp`bqdbgjufqplpnboolq`bqfrvjfqfw/E`mj`lgfafq/Abujujfmgbejmbmybpbgfobmwfevm`jlmb`lmpfilpgje/A`jo`jvgbgfpbmwjdvbpbubmybgbw/Eqnjmlvmjgbgfpp/Mm`kfy`bnsb/]bplewlmj`qfujpwbp`lmwjfmfpf`wlqfpnlnfmwlpeb`vowbg`q/Egjwlgjufqpbppvsvfpwleb`wlqfppfdvmglpsfrvf/]b<_<R<X<\\<Y=m<W<T<Y=m=n=`<]=g<W<R<]=g=n=`=a=n<R<P<y=m<W<T=n<R<_<R<P<Y<Q=c<^=m<Y=i=a=n<R<U<X<\\<Z<Y<]=g<W<T<_<R<X=o<X<Y<Q=`=a=n<R=n<]=g<W<\\=m<Y<]=c<R<X<T<Q=m<Y<]<Y<Q<\\<X<R=m<\\<U=n=h<R=n<R<Q<Y<_<R=m<^<R<T=m<^<R<U<T<_=l=g=n<R<Z<Y<^=m<Y<P=m<^<R=b<W<T=d=`=a=n<T=i<S<R<V<\\<X<Q<Y<U<X<R<P<\\<P<T=l<\\<W<T<]<R=n<Y<P=o=i<R=n=c<X<^=o=i=m<Y=n<T<W=b<X<T<X<Y<W<R<P<T=l<Y=n<Y<]=c=m<^<R<Y<^<T<X<Y=k<Y<_<R=a=n<T<P=m=k<Y=n=n<Y<P=g=j<Y<Q=g=m=n<\\<W<^<Y<X=`=n<Y<P<Y<^<R<X=g=n<Y<]<Y<^=g=d<Y<Q<\\<P<T=n<T<S<\\=n<R<P=o<S=l<\\<^<W<T=j<\\<R<X<Q<\\<_<R<X=g<[<Q<\\=b<P<R<_=o<X=l=o<_<^=m<Y<U<T<X<Y=n<V<T<Q<R<R<X<Q<R<X<Y<W<\\<X<Y<W<Y=m=l<R<V<T=b<Q=c<^<Y=m=`<y=m=n=`=l<\\<[<\\<Q<\\=d<T4K5h5h5k4K5h4F5f4@5i5f4U4B4K4Y4E4K5h4\\5f4U5h5f5k4@4C5f4C4K5h4N5j4K5h4]4C4F4A5o5i4Y5m4A4E5o4K5j4F4K5h5h5f5f5o5d5j4X4D5o4E5m5f5k4K4D5j4K4F4A5d4K4M4O5o4G4]4B5h4K5h4K5h4A4D4C5h5f5h4C4]5d4_4K4Z4V4[4F5o5d5j5k5j4K5o4_4K4A4E5j4K4C5f4K5h4[4D4U5h5f5o4X5o4]4K5f5i5o5j5i5j5k4K4X4]5o4E4]4J5f4_5j4X5f4[5i4K4\\4K4K5h5m5j4X4D4K4D4F4U4D4]4]4A5i4E5o4K5m4E5f5n5d5h5i4]5o4^5o5h5i4E4O4A5i4C5n5h4D5f5f4U5j5f4Y5d4]4E4[4]5f5n4X4K4]5o4@5d4K5h4O4B4]5e5i4U5j4K4K4D4A4G4U4]5d4Z4D4X5o5h5i4_4@5h4D5j4K5j4B4K5h4C5o4F4K4D5o5h5f4E4D4C5d5j4O5f4Z4K5f5d4@4C5m4]5f5n5o4F4D4F4O5m4Z5h5i4[4D4B4K5o4G4]4D4K4]5o4K5m4Z5h4K4A5h5e5j5m4_5k4O5f4K5i4]4C5d4C4O5j5k4K4C5f5j4K4K5h4K5j5i4U4]4Z4F4U5h5i4C4K4B5h5i5i5o5j\x07\x07\x07\x07\0\x07\x07\0\v\n \b\r\f\f\r\b \n\v\x1B\x1B\0\v\v\v\v\0\x07qfplvq`fp`lvmwqjfprvfpwjlmpfrvjsnfmw`lnnvmjwzbubjobaofkjdkojdkwGWG,{kwnonbqhfwjmdhmltofgdfplnfwkjmd`lmwbjmfqgjqf`wjlmpvap`qjafbgufqwjpf`kbqb`wfq!#ubovf>!?,pfof`w=Bvpwqbojb!#`obpp>!pjwvbwjlmbvwklqjwzelooltjmdsqjnbqjozlsfqbwjlm`kboofmdfgfufolsfgbmlmznlvpevm`wjlm#evm`wjlmp`lnsbmjfppwqv`wvqfbdqffnfmw!#wjwof>!slwfmwjbofgv`bwjlmbqdvnfmwppf`lmgbqz`lszqjdkwobmdvbdfpf{`ovpjuf`lmgjwjlm?,elqn= pwbwfnfmwbwwfmwjlmAjldqbskz~#fopf#x plovwjlmptkfm#wkf#Bmbozwj`pwfnsobwfpgbmdfqlvppbwfoojwfgl`vnfmwpsvaojpkfqjnslqwbmwsqlwlwzsfjmeovfm`f%qbrvl8?,feef`wjufdfmfqboozwqbmpelqnafbvwjevowqbmpslqwlqdbmjyfgsvaojpkfgsqlnjmfmwvmwjo#wkfwkvnambjoMbwjlmbo#-el`vp+*8lufq#wkf#njdqbwjlmbmmlvm`fgellwfq!= f{`fswjlmofpp#wkbmf{sfmpjufelqnbwjlmeqbnftlqhwfqqjwlqzmgj`bwjlm`vqqfmwoz`obppMbnf`qjwj`jpnwqbgjwjlmfopftkfqfBof{bmgfqbssljmwfgnbwfqjbopaqlbg`bpwnfmwjlmfgbeejojbwf?,lswjlm=wqfbwnfmwgjeefqfmw,gfebvow-Sqfpjgfmwlm`oj`h>!ajldqbskzlwkfqtjpfsfqnbmfmwEqbm/KbjpKlooztllgf{sbmpjlmpwbmgbqgp?,pwzof= qfgv`wjlmGf`fnafq#sqfefqqfg@bnaqjgdflsslmfmwpAvpjmfpp#`lmevpjlm= ?wjwof=sqfpfmwfgf{sobjmfgglfp#mlw#tlqogtjgfjmwfqeb`fslpjwjlmpmftpsbsfq?,wbaof= nlvmwbjmpojhf#wkf#fppfmwjboejmbm`jbopfof`wjlmb`wjlm>!,babmglmfgFgv`bwjlmsbqpfJmw+pwbajojwzvmbaof#wl?,wjwof= qfobwjlmpMlwf#wkbwfeej`jfmwsfqelqnfgwtl#zfbqpPjm`f#wkfwkfqfelqftqbssfq!=bowfqmbwfjm`qfbpfgAbwwof#lesfq`fjufgwqzjmd#wlmf`fppbqzslqwqbzfgfof`wjlmpFojybafwk?,jeqbnf=gjp`lufqzjmpvqbm`fp-ofmdwk8ofdfmgbqzDfldqbskz`bmgjgbwf`lqslqbwfplnfwjnfppfquj`fp-jmkfqjwfg?,pwqlmd=@lnnvmjwzqfojdjlvpol`bwjlmp@lnnjwwffavjogjmdpwkf#tlqogml#olmdfqafdjmmjmdqfefqfm`f`bmmlw#afeqfrvfm`zwzsj`boozjmwl#wkf#qfobwjuf8qf`lqgjmdsqfpjgfmwjmjwjboozwf`kmjrvfwkf#lwkfqjw#`bm#aff{jpwfm`fvmgfqojmfwkjp#wjnfwfofsklmfjwfnp`lsfsqb`wj`fpbgubmwbdf*8qfwvqm#Elq#lwkfqsqlujgjmdgfnl`qb`zalwk#wkf#f{wfmpjufpveefqjmdpvsslqwfg`lnsvwfqp#evm`wjlmsqb`wj`bopbjg#wkbwjw#nbz#afFmdojpk?,eqln#wkf#p`kfgvofggltmolbgp?,obafo= pvpsf`wfgnbqdjm9#3psjqjwvbo?,kfbg= nj`qlplewdqbgvboozgjp`vppfgkf#af`bnff{f`vwjufirvfqz-ipklvpfklog`lmejqnfgsvq`kbpfgojwfqboozgfpwqlzfgvs#wl#wkfubqjbwjlmqfnbjmjmdjw#jp#mlw`fmwvqjfpIbsbmfpf#bnlmd#wkf`lnsofwfgbodlqjwknjmwfqfpwpqfafoojlmvmgfejmfgfm`lvqbdfqfpjybaofjmuloujmdpfmpjwjufvmjufqpbosqlujpjlm+bowklvdkefbwvqjmd`lmgv`wfg*/#tkj`k#`lmwjmvfg.kfbgfq!=Efaqvbqz#mvnfqlvp#lufqeolt9`lnslmfmweqbdnfmwpf{`foofmw`lopsbm>!wf`kmj`bomfbq#wkf#Bgubm`fg#plvq`f#lef{sqfppfgKlmd#Hlmd#Eb`fallhnvowjsof#nf`kbmjpnfofubwjlmleefmpjuf?,elqn= \npslmplqfggl`vnfmw-lq#%rvlw8wkfqf#bqfwklpf#tklnlufnfmwpsql`fppfpgjeej`vowpvanjwwfgqf`lnnfmg`lmujm`fgsqlnlwjmd!#tjgwk>!-qfsob`f+`obppj`bo`lbojwjlmkjp#ejqpwgf`jpjlmpbppjpwbmwjmgj`bwfgfulovwjlm.tqbssfq!fmlvdk#wlbolmd#wkfgfojufqfg..= ?"..Bnfqj`bm#sqlwf`wfgMlufnafq#?,pwzof=?evqmjwvqfJmwfqmfw##lmaovq>!pvpsfmgfgqf`jsjfmwabpfg#lm#Nlqflufq/balojpkfg`loof`wfgtfqf#nbgffnlwjlmbofnfqdfm`zmbqqbwjufbgul`bwfps{8alqgfq`lnnjwwfggjq>!owq!fnsolzffpqfpfbq`k-#pfof`wfgpv``fpplq`vpwlnfqpgjpsobzfgPfswfnafqbgg@obpp+Eb`fallh#pvddfpwfgbmg#obwfqlsfqbwjmdfobalqbwfPlnfwjnfpJmpwjwvwf`fqwbjmozjmpwboofgelooltfqpIfqvpbofnwkfz#kbuf`lnsvwjmddfmfqbwfgsqlujm`fpdvbqbmwffbqajwqbqzqf`ldmjyftbmwfg#wls{8tjgwk9wkflqz#leafkbujlvqTkjof#wkffpwjnbwfgafdbm#wl#jw#af`bnfnbdmjwvgfnvpw#kbufnlqf#wkbmGjqf`wlqzf{wfmpjlmpf`qfwbqzmbwvqboozl``vqqjmdubqjbaofpdjufm#wkfsobwelqn-?,obafo=?ebjofg#wl`lnslvmgphjmgp#le#pl`jfwjfpbolmdpjgf#..%dw8 plvwktfpwwkf#qjdkwqbgjbwjlmnbz#kbuf#vmfp`bsf+pslhfm#jm!#kqfe>!,sqldqbnnflmoz#wkf#`lnf#eqlngjqf`wlqzavqjfg#jmb#pjnjobqwkfz#tfqf?,elmw=?,Mlqtfdjbmpsf`jejfgsqlgv`jmdsbppfmdfq+mft#Gbwfwfnslqbqzej`wjlmboBewfq#wkffrvbwjlmpgltmolbg-qfdvobqozgfufolsfqbaluf#wkfojmhfg#wlskfmlnfmbsfqjlg#lewllowjs!=pvapwbm`fbvwlnbwj`bpsf`w#leBnlmd#wkf`lmmf`wfgfpwjnbwfpBjq#Elq`fpzpwfn#lelaif`wjufjnnfgjbwfnbhjmd#jwsbjmwjmdp`lmrvfqfgbqf#pwjoosql`fgvqfdqltwk#lekfbgfg#azFvqlsfbm#gjujpjlmpnlof`vofpeqbm`kjpfjmwfmwjlmbwwqb`wfg`kjogkllgbopl#vpfggfgj`bwfgpjmdbslqfgfdqff#leebwkfq#le`lmeoj`wp?,b=?,s= `bnf#eqlntfqf#vpfgmlwf#wkbwqf`fjujmdF{f`vwjuffufm#nlqfb``fpp#wl`lnnbmgfqSlojwj`bonvpj`jbmpgfoj`jlvpsqjplmfqpbgufmw#leVWE.;!#,=?"X@GBWBX!=@lmwb`wPlvwkfqm#ad`lolq>!pfqjfp#le-#Jw#tbp#jm#Fvqlsfsfqnjwwfgubojgbwf-bssfbqjmdleej`jboppfqjlvpoz.obmdvbdfjmjwjbwfgf{wfmgjmdolmd.wfqnjmeobwjlmpv`k#wkbwdfw@llhjfnbqhfg#az?,avwwlm=jnsofnfmwavw#jw#jpjm`qfbpfpgltm#wkf#qfrvjqjmdgfsfmgfmw..= ?"..#jmwfqujftTjwk#wkf#`lsjfp#le`lmpfmpvptbp#avjowUfmfyvfob+elqnfqozwkf#pwbwfsfqplmmfopwqbwfdj`ebulvq#lejmufmwjlmTjhjsfgjb`lmwjmfmwujqwvbooztkj`k#tbpsqjm`jsof@lnsofwf#jgfmwj`bopklt#wkbwsqjnjwjufbtbz#eqlnnlof`vobqsqf`jpfozgjpploufgVmgfq#wkfufqpjlm>!=%maps8?,Jw#jp#wkf#Wkjp#jp#tjoo#kbuflqdbmjpnpplnf#wjnfEqjfgqj`ktbp#ejqpwwkf#lmoz#eb`w#wkbwelqn#jg>!sqf`fgjmdWf`kmj`boskzpj`jpwl``vqp#jmmbujdbwlqpf`wjlm!=psbm#jg>!plvdkw#wlafolt#wkfpvqujujmd~?,pwzof=kjp#gfbwkbp#jm#wkf`bvpfg#azsbqwjboozf{jpwjmd#vpjmd#wkftbp#djufmb#ojpw#leofufop#lemlwjlm#leLeej`jbo#gjpnjppfgp`jfmwjpwqfpfnaofpgvsoj`bwff{solpjufqf`lufqfgboo#lwkfqdboofqjfpxsbggjmd9sflsof#leqfdjlm#lebggqfppfpbppl`jbwfjnd#bow>!jm#nlgfqmpklvog#afnfwklg#leqfslqwjmdwjnfpwbnsmffgfg#wlwkf#Dqfbwqfdbqgjmdpffnfg#wlujftfg#bpjnsb`w#lmjgfb#wkbwwkf#Tlqogkfjdkw#lef{sbmgjmdWkfpf#bqf`vqqfmw!=`bqfevooznbjmwbjmp`kbqdf#le@obppj`bobggqfppfgsqfgj`wfgltmfqpkjs?gju#jg>!qjdkw!= qfpjgfm`fofbuf#wkf`lmwfmw!=bqf#lewfm##~*+*8 sqlabaoz#Sqlefpplq.avwwlm!#qfpslmgfgpbzp#wkbwkbg#wl#afsob`fg#jmKvmdbqjbmpwbwvp#lepfqufp#bpVmjufqpbof{f`vwjlmbddqfdbwfelq#tkj`kjmef`wjlmbdqffg#wlkltfufq/#slsvobq!=sob`fg#lm`lmpwqv`wfof`wlqbopznalo#lejm`ovgjmdqfwvqm#wlbq`kjwf`w@kqjpwjbmsqfujlvp#ojujmd#jmfbpjfq#wlsqlefpplq %ow8"..#feef`w#lebmbozwj`ptbp#wbhfmtkfqf#wkfwllh#lufqafojfe#jmBeqjhbbmpbp#ebq#bpsqfufmwfgtlqh#tjwkb#psf`jbo?ejfogpfw@kqjpwnbpQfwqjfufg Jm#wkf#ab`h#jmwlmlqwkfbpwnbdbyjmfp=?pwqlmd=`lnnjwwffdlufqmjmddqlvsp#lepwlqfg#jmfpwbaojpkb#dfmfqbojwp#ejqpwwkfjq#ltmslsvobwfgbm#laif`w@bqjaafbmboolt#wkfgjpwqj`wptjp`lmpjmol`bwjlm-8#tjgwk9#jmkbajwfgPl`jbojpwIbmvbqz#2?,ellwfq=pjnjobqoz`klj`f#lewkf#pbnf#psf`jej`#avpjmfpp#Wkf#ejqpw-ofmdwk8#gfpjqf#wlgfbo#tjwkpjm`f#wkfvpfqBdfmw`lm`fjufgjmgf{-sksbp#%rvlw8fmdbdf#jmqf`fmwoz/eft#zfbqptfqf#bopl ?kfbg= ?fgjwfg#azbqf#hmltm`jwjfp#jmb``fpphfz`lmgfnmfgbopl#kbufpfquj`fp/ebnjoz#leP`kllo#le`lmufqwfgmbwvqf#le#obmdvbdfnjmjpwfqp?,laif`w=wkfqf#jp#b#slsvobqpfrvfm`fpbgul`bwfgWkfz#tfqfbmz#lwkfqol`bwjlm>fmwfq#wkfnv`k#nlqfqfeof`wfgtbp#mbnfglqjdjmbo#b#wzsj`botkfm#wkfzfmdjmffqp`lvog#mlwqfpjgfmwptfgmfpgbzwkf#wkjqg#sqlgv`wpIbmvbqz#1tkbw#wkfzb#`fqwbjmqfb`wjlmpsql`fpplqbewfq#kjpwkf#obpw#`lmwbjmfg!=?,gju= ?,b=?,wg=gfsfmg#lmpfbq`k!= sjf`fp#le`lnsfwjmdQfefqfm`fwfmmfppfftkj`k#kbp#ufqpjlm>?,psbm=#??,kfbgfq=djufp#wkfkjpwlqjbmubovf>!!=sbggjmd93ujft#wkbwwldfwkfq/wkf#nlpw#tbp#elvmgpvapfw#lebwwb`h#lm`kjogqfm/sljmwp#lesfqplmbo#slpjwjlm9boofdfgoz@ofufobmgtbp#obwfqbmg#bewfqbqf#djufmtbp#pwjoop`qloojmdgfpjdm#lenbhfp#wkfnv`k#ofppBnfqj`bmp- Bewfq#/#avw#wkfNvpfvn#leolvjpjbmb+eqln#wkfnjmmfplwbsbqwj`ofpb#sql`fppGlnjmj`bmulovnf#leqfwvqmjmdgfefmpjuf33s{\x7Fqjdknbgf#eqlnnlvpflufq!#pwzof>!pwbwfp#le+tkj`k#jp`lmwjmvfpEqbm`jp`lavjogjmd#tjwklvw#btjwk#plnftkl#tlvogb#elqn#leb#sbqw#leafelqf#jwhmltm#bp##Pfquj`fpol`bwjlm#bmg#lewfmnfbpvqjmdbmg#jw#jpsbsfqab`hubovfp#le ?wjwof=>#tjmglt-gfwfqnjmffq%rvlw8#sobzfg#azbmg#fbqoz?,`fmwfq=eqln#wkjpwkf#wkqffsltfq#bmgle#%rvlw8jmmfqKWNO?b#kqfe>!z9jmojmf8@kvq`k#lewkf#fufmwufqz#kjdkleej`jbo#.kfjdkw9#`lmwfmw>!,`dj.ajm,wl#`qfbwfbeqjhbbmpfpsfqbmwleqbm/Kbjpobwujf)Mvojfwvuj)_(`f)Mwjmb(af)Mwjmb\fUh\fT{\fTN\n{I\np@Fr\vBl\bQ\x7F A{\vUmGx A{ypYA\0zX\bTV\bWl\bUdBM\vB{\npV\v@xB\\\np@DbGz al\npa fM uD\bV~mx\vQ}\ndS p\\\bVK\bS]\bU|oD kV\ved\vHR\nb~M`\nJpoD|Q\nLPSw\bTl\nAI\nxC\bWt BqF`Cm\vLm Kx }t\bPv\ny\\\naB V\x7F\nZdXUli fr i@ BHBDBV `V\n[] p_ Tn\n~A\nxR uD `{\bV@ Tn HK AJ\vxsZf\nqIZf\vBM\v|j }t\bSM\nmC\vQ}pfquj`jlpbqw/A`volbqdfmwjmbabq`folmb`vborvjfqsvaoj`bglsqlgv`wlpslo/Awj`bqfpsvfpwbtjhjsfgjbpjdvjfmwfa/Vprvfgb`lnvmjgbgpfdvqjgbgsqjm`jsbosqfdvmwbp`lmwfmjglqfpslmgfqufmfyvfobsqlaofnbpgj`jfnaqfqfob`j/_mmlujfnaqfpjnjobqfpsqlzf`wlpsqldqbnbpjmpwjwvwlb`wjujgbgfm`vfmwqbf`lmln/Abjn/Mdfmfp`lmwb`wbqgfp`bqdbqmf`fpbqjlbwfm`j/_mwfo/Eelml`lnjpj/_m`bm`jlmfp`bsb`jgbgfm`lmwqbqbm/Mojpjpebulqjwlpw/Eqnjmlpsqlujm`jbfwjrvfwbpfofnfmwlpevm`jlmfpqfpvowbgl`bq/M`wfqsqlsjfgbgsqjm`jsjlmf`fpjgbgnvmj`jsbo`qfb`j/_mgfp`bqdbpsqfpfm`jb`lnfq`jbolsjmjlmfpfifq`j`jlfgjwlqjbopbobnbm`bdlmy/Mofygl`vnfmwlsfo/A`vobqf`jfmwfpdfmfqbofpwbqqbdlmbsq/M`wj`bmlufgbgfpsqlsvfpwbsb`jfmwfpw/E`mj`bplaifwjulp`lmwb`wlp\fHB\fIk\fHn\fH^\fHS\fHc\fHU\fId\fHn\fH{\fHC\fHR\fHT\fHR\fHI\fHc\fHY\fHn\fH\\\fHU\fIk\fHy\fIg\fHd\fHy\fIm\fHw\fH\\\fHU\fHR\fH@\fHR\fHJ\fHy\fHU\fHR\fHT\fHA\fIl\fHU\fIm\fHc\fH\\\fHU\fIl\fHB\fId\fHn\fHJ\fHS\fHD\fH@\fHR\fHHgjsolgl`p\fHT\fHB\fHC\fH\\\fIn\fHF\fHD\fHR\fHB\fHF\fHH\fHR\fHG\fHS\fH\\\fHx\fHT\fHH\fHH\fH\\\fHU\fH^\fIg\fH{\fHU\fIm\fHj\fH@\fHR\fH\\\fHJ\fIk\fHZ\fHU\fIm\fHd\fHz\fIk\fH^\fHC\fHJ\fHS\fHy\fHR\fHB\fHY\fIk\fH@\fHH\fIl\fHD\fH@\fIl\fHv\fHB\fI`\fHH\fHT\fHR\fH^\fH^\fIk\fHz\fHp\fIe\fH@\fHB\fHJ\fHJ\fHH\fHI\fHR\fHD\fHU\fIl\fHZ\fHU\fH\\\fHi\fH^\fH{\fHy\fHA\fIl\fHD\fH{\fH\\\fHF\fHR\fHT\fH\\\fHR\fHH\fHy\fHS\fHc\fHe\fHT\fIk\fH{\fHC\fIl\fHU\fIn\fHm\fHj\fH{\fIk\fHs\fIl\fHB\fHz\fIg\fHp\fHy\fHR\fH\\\fHi\fHA\fIl\fH{\fHC\fIk\fHH\fIm\fHB\fHY\fIg\fHs\fHJ\fIk\fHn\fHi\fH{\fH\\\fH|\fHT\fIk\fHB\fIk\fH^\fH^\fH{\fHR\fHU\fHR\fH^\fHf\fHF\fH\\\fHv\fHR\fH\\\fH|\fHT\fHR\fHJ\fIk\fH\\\fHp\fHS\fHT\fHJ\fHS\fH^\fH@\fHn\fHJ\fH@\fHD\fHR\fHU\fIn\fHn\fH^\fHR\fHz\fHp\fIl\fHH\fH@\fHs\fHD\fHB\fHS\fH^\fHk\fHT\fIk\fHj\fHD\fIk\fHD\fHC\fHR\fHy\fIm\fH^\fH^\fIe\fH{\fHA\fHR\fH{\fH\\\fIk\fH^\fHp\fH{\fHU\fH\\\fHR\fHB\fH^\fH{\fIk\fHF\fIk\fHp\fHU\fHR\fHI\fHk\fHT\fIl\fHT\fHU\fIl\fHy\fH^\fHR\fHL\fIl\fHy\fHU\fHR\fHm\fHJ\fIn\fH\\\fHH\fHU\fHH\fHT\fHR\fHH\fHC\fHR\fHJ\fHj\fHC\fHR\fHF\fHR\fHy\fHy\fI`\fHD\fHZ\fHR\fHB\fHJ\fIk\fHz\fHC\fHU\fIl\fH\\\fHR\fHC\fHz\fIm\fHJ\fH^\fH{\fIl`bwfdlqjfpf{sfqjfm`f?,wjwof= @lszqjdkw#ibubp`qjsw`lmgjwjlmpfufqzwkjmd?s#`obpp>!wf`kmloldzab`hdqlvmg?b#`obpp>!nbmbdfnfmw%`lsz8#132ibubP`qjsw`kbqb`wfqpaqfbg`qvnawkfnpfoufpklqjylmwbodlufqmnfmw@bojelqmjbb`wjujwjfpgjp`lufqfgMbujdbwjlmwqbmpjwjlm`lmmf`wjlmmbujdbwjlmbssfbqbm`f?,wjwof=?n`kf`hal{!#wf`kmjrvfpsqlwf`wjlmbssbqfmwozbp#tfoo#bpvmw$/#$VB.qfplovwjlmlsfqbwjlmpwfofujpjlmwqbmpobwfgTbpkjmdwlmmbujdbwlq-#>#tjmglt-jnsqfppjlm%ow8aq%dw8ojwfqbwvqfslsvobwjlmad`lolq>! fpsf`jbooz#`lmwfmw>!sqlgv`wjlmmftpofwwfqsqlsfqwjfpgfejmjwjlmofbgfqpkjsWf`kmloldzSbqojbnfmw`lnsbqjplmvo#`obpp>!-jmgf{Le+!`lm`ovpjlmgjp`vppjlm`lnslmfmwpajloldj`boQfulovwjlm\\`lmwbjmfqvmgfqpwllgmlp`qjsw=?sfqnjppjlmfb`k#lwkfqbwnlpskfqf#lmel`vp>!?elqn#jg>!sql`fppjmdwkjp-ubovfdfmfqbwjlm@lmefqfm`fpvapfrvfmwtfoo.hmltmubqjbwjlmpqfsvwbwjlmskfmlnfmlmgjp`jsojmfoldl-smd!#+gl`vnfmw/alvmgbqjfpf{sqfppjlmpfwwofnfmwAb`hdqlvmglvw#le#wkffmwfqsqjpf+!kwwsp9!#vmfp`bsf+!sbpptlqg!#gfnl`qbwj`?b#kqfe>!,tqbssfq!= nfnafqpkjsojmdvjpwj`s{8sbggjmdskjolplskzbppjpwbm`fvmjufqpjwzeb`jojwjfpqf`ldmjyfgsqfefqfm`fje#+wzsflenbjmwbjmfgul`bavobqzkzslwkfpjp-pvanjw+*8%bns8maps8bmmlwbwjlmafkjmg#wkfElvmgbwjlmsvaojpkfq!bppvnswjlmjmwqlgv`fg`lqqvswjlmp`jfmwjpwpf{soj`jwozjmpwfbg#legjnfmpjlmp#lm@oj`h>!`lmpjgfqfggfsbqwnfmwl``vsbwjlmpllm#bewfqjmufpwnfmwsqlmlvm`fgjgfmwjejfgf{sfqjnfmwNbmbdfnfmwdfldqbskj`!#kfjdkw>!ojmh#qfo>!-qfsob`f+,gfsqfppjlm`lmefqfm`fsvmjpknfmwfojnjmbwfgqfpjpwbm`fbgbswbwjlmlsslpjwjlmtfoo#hmltmpvssofnfmwgfwfqnjmfgk2#`obpp>!3s{8nbqdjmnf`kbmj`bopwbwjpwj`p`fofaqbwfgDlufqmnfmw Gvqjmd#wgfufolsfqpbqwjej`jbofrvjubofmwlqjdjmbwfg@lnnjppjlmbwwb`knfmw?psbm#jg>!wkfqf#tfqfMfgfqobmgpafzlmg#wkfqfdjpwfqfgilvqmbojpweqfrvfmwozboo#le#wkfobmd>!fm!#?,pwzof= baplovwf8#pvsslqwjmdf{wqfnfoz#nbjmpwqfbn?,pwqlmd=#slsvobqjwzfnsolznfmw?,wbaof= #`lopsbm>!?,elqn= ##`lmufqpjlmbalvw#wkf#?,s=?,gju=jmwfdqbwfg!#obmd>!fmSlqwvdvfpfpvapwjwvwfjmgjujgvbojnslppjaofnvowjnfgjbbonlpw#boos{#plojg# bsbqw#eqlnpvaif`w#wljm#Fmdojpk`qjwj`jyfgf{`fsw#elqdvjgfojmfplqjdjmboozqfnbqhbaofwkf#pf`lmgk1#`obpp>!?b#wjwof>!+jm`ovgjmdsbqbnfwfqpsqlkjajwfg>#!kwws9,,gj`wjlmbqzsfq`fswjlmqfulovwjlmelvmgbwjlms{8kfjdkw9pv``fppevopvsslqwfqpnjoofmmjvnkjp#ebwkfqwkf#%rvlw8ml.qfsfbw8`lnnfq`jbojmgvpwqjbofm`lvqbdfgbnlvmw#le#vmleej`jbofeej`jfm`zQfefqfm`fp`llqgjmbwfgjp`objnfqf{sfgjwjlmgfufolsjmd`bo`vobwfgpjnsojejfgofdjwjnbwfpvapwqjmd+3!#`obpp>!`lnsofwfozjoovpwqbwfejuf#zfbqpjmpwqvnfmwSvaojpkjmd2!#`obpp>!spz`kloldz`lmejgfm`fmvnafq#le#bapfm`f#leel`vpfg#lmiljmfg#wkfpwqv`wvqfpsqfujlvpoz=?,jeqbnf=lm`f#bdbjmavw#qbwkfqjnnjdqbmwple#`lvqpf/b#dqlvs#leOjwfqbwvqfVmojhf#wkf?,b=%maps8 evm`wjlm#jw#tbp#wkf@lmufmwjlmbvwlnlajofSqlwfpwbmwbddqfppjufbewfq#wkf#Pjnjobqoz/!#,=?,gju=`loof`wjlm evm`wjlmujpjajojwzwkf#vpf#leulovmwffqpbwwqb`wjlmvmgfq#wkf#wkqfbwfmfg)?"X@GBWBXjnslqwbm`fjm#dfmfqbowkf#obwwfq?,elqn= ?,-jmgf{Le+$j#>#38#j#?gjeefqfm`fgfulwfg#wlwqbgjwjlmppfbq`k#elqvowjnbwfozwlvqmbnfmwbwwqjavwfppl.`boofg#~ ?,pwzof=fubovbwjlmfnskbpjyfgb``fppjaof?,pf`wjlm=pv``fppjlmbolmd#tjwkNfbmtkjof/jmgvpwqjfp?,b=?aq#,=kbp#af`lnfbpsf`wp#leWfofujpjlmpveej`jfmwabphfwabooalwk#pjgfp`lmwjmvjmdbm#bqwj`of?jnd#bow>!bgufmwvqfpkjp#nlwkfqnbm`kfpwfqsqjm`jsofpsbqwj`vobq`lnnfmwbqzfeef`wp#legf`jgfg#wl!=?pwqlmd=svaojpkfqpIlvqmbo#legjeej`vowzeb`jojwbwfb``fswbaofpwzof-`pp!\nevm`wjlm#jmmlubwjlm=@lszqjdkwpjwvbwjlmptlvog#kbufavpjmfppfpGj`wjlmbqzpwbwfnfmwplewfm#vpfgsfqpjpwfmwjm#Ibmvbqz`lnsqjpjmd?,wjwof= \ngjsolnbwj``lmwbjmjmdsfqelqnjmdf{wfmpjlmpnbz#mlw#af`lm`fsw#le#lm`oj`h>!Jw#jp#boplejmbm`jbo#nbhjmd#wkfOv{fnalvqdbggjwjlmbobqf#`boofgfmdbdfg#jm!p`qjsw!*8avw#jw#tbpfof`wqlmj`lmpvanjw>! ?"..#Fmg#fof`wqj`boleej`jboozpvddfpwjlmwls#le#wkfvmojhf#wkfBvpwqbojbmLqjdjmboozqfefqfm`fp ?,kfbg= qf`ldmjpfgjmjwjbojyfojnjwfg#wlBof{bmgqjbqfwjqfnfmwBgufmwvqfpelvq#zfbqp %ow8"..#jm`qfbpjmdgf`lqbwjlmk0#`obpp>!lqjdjmp#lelaojdbwjlmqfdvobwjlm`obppjejfg+evm`wjlm+bgubmwbdfpafjmd#wkf#kjpwlqjbmp?abpf#kqfeqfsfbwfgoztjoojmd#wl`lnsbqbaofgfpjdmbwfgmlnjmbwjlmevm`wjlmbojmpjgf#wkfqfufobwjlmfmg#le#wkfp#elq#wkf#bvwklqjyfgqfevpfg#wlwbhf#sob`fbvwlmlnlvp`lnsqlnjpfslojwj`bo#qfpwbvqbmwwtl#le#wkfEfaqvbqz#1rvbojwz#leptelaif`w-vmgfqpwbmgmfbqoz#bootqjwwfm#azjmwfqujftp!#tjgwk>!2tjwkgqbtboeolbw9ofewjp#vpvbooz`bmgjgbwfpmftpsbsfqpnzpwfqjlvpGfsbqwnfmwafpw#hmltmsbqojbnfmwpvssqfppfg`lmufmjfmwqfnfnafqfggjeefqfmw#pzpwfnbwj`kbp#ofg#wlsqlsbdbmgb`lmwqloofgjmeovfm`fp`fqfnlmjbosql`objnfgSqlwf`wjlmoj#`obpp>!P`jfmwjej``obpp>!ml.wqbgfnbqhpnlqf#wkbm#tjgfpsqfbgOjafqbwjlmwllh#sob`fgbz#le#wkfbp#olmd#bpjnsqjplmfgBggjwjlmbo ?kfbg= ?nObalqbwlqzMlufnafq#1f{`fswjlmpJmgvpwqjboubqjfwz#leeolbw9#ofeGvqjmd#wkfbppfppnfmwkbuf#affm#gfbop#tjwkPwbwjpwj`pl``vqqfm`f,vo=?,gju=`ofbqej{!=wkf#svaoj`nbmz#zfbqptkj`k#tfqflufq#wjnf/pzmlmznlvp`lmwfmw!= sqfpvnbaozkjp#ebnjozvpfqBdfmw-vmf{sf`wfgjm`ovgjmd#`kboofmdfgb#njmlqjwzvmgfejmfg!afolmdp#wlwbhfm#eqlnjm#L`wlafqslpjwjlm9#pbjg#wl#afqfojdjlvp#Efgfqbwjlm#qltpsbm>!lmoz#b#eftnfbmw#wkbwofg#wl#wkf..= ?gju#?ejfogpfw=Bq`kajpkls#`obpp>!mlafjmd#vpfgbssqlb`kfpsqjujofdfpmlp`qjsw= qfpvowp#jmnbz#af#wkfFbpwfq#fddnf`kbmjpnpqfbplmbaofSlsvobwjlm@loof`wjlmpfof`wfg!=mlp`qjsw=,jmgf{-sksbqqjubo#le.ippgh$**8nbmbdfg#wljm`lnsofwf`bpvbowjfp`lnsofwjlm@kqjpwjbmpPfswfnafq#bqjwknfwj`sql`fgvqfpnjdkw#kbufSqlgv`wjlmjw#bssfbqpSkjolplskzeqjfmgpkjsofbgjmd#wldjujmd#wkfwltbqg#wkfdvbqbmwffggl`vnfmwfg`lolq9 333ujgfl#dbnf`lnnjppjlmqfeof`wjmd`kbmdf#wkfbppl`jbwfgpbmp.pfqjelmhfzsqfpp8#sbggjmd9Kf#tbp#wkfvmgfqozjmdwzsj`booz#/#bmg#wkf#pq`Fofnfmwpv``fppjufpjm`f#wkf#pklvog#af#mfwtlqhjmdb``lvmwjmdvpf#le#wkfoltfq#wkbmpkltp#wkbw?,psbm= \n\n`lnsobjmwp`lmwjmvlvprvbmwjwjfpbpwqlmlnfqkf#gjg#mlwgvf#wl#jwpbssojfg#wlbm#bufqbdffeelqwp#wlwkf#evwvqfbwwfnsw#wlWkfqfelqf/`bsbajojwzQfsvaoj`bmtbp#elqnfgFof`wqlmj`hjolnfwfqp`kboofmdfpsvaojpkjmdwkf#elqnfqjmgjdfmlvpgjqf`wjlmppvapjgjbqz`lmpsjqb`zgfwbjop#lebmg#jm#wkfbeelqgbaofpvapwbm`fpqfbplm#elq`lmufmwjlmjwfnwzsf>!baplovwfozpvsslpfgozqfnbjmfg#bbwwqb`wjufwqbufoojmdpfsbqbwfozel`vpfp#lmfofnfmwbqzbssoj`baofelvmg#wkbwpwzofpkffwnbmvp`qjswpwbmgp#elq#ml.qfsfbw+plnfwjnfp@lnnfq`jbojm#Bnfqj`bvmgfqwbhfmrvbqwfq#lebm#f{bnsofsfqplmboozjmgf{-sks<?,avwwlm= sfq`fmwbdfafpw.hmltm`qfbwjmd#b!#gjq>!owqOjfvwfmbmw ?gju#jg>!wkfz#tlvogbajojwz#lenbgf#vs#lemlwfg#wkbw`ofbq#wkbwbqdvf#wkbwwl#bmlwkfq`kjogqfm$psvqslpf#leelqnvobwfgabpfg#vslmwkf#qfdjlmpvaif`w#lesbppfmdfqpslppfppjlm- Jm#wkf#Afelqf#wkfbewfqtbqgp`vqqfmwoz#b`qlpp#wkfp`jfmwjej``lnnvmjwz-`bsjwbojpnjm#Dfqnbmzqjdkw.tjmdwkf#pzpwfnPl`jfwz#leslojwj`jbmgjqf`wjlm9tfmw#lm#wlqfnlubo#le#Mft#Zlqh#bsbqwnfmwpjmgj`bwjlmgvqjmd#wkfvmofpp#wkfkjpwlqj`bokbg#affm#bgfejmjwjufjmdqfgjfmwbwwfmgbm`f@fmwfq#elqsqlnjmfm`fqfbgzPwbwfpwqbwfdjfpavw#jm#wkfbp#sbqw#le`lmpwjwvwf`objn#wkbwobalqbwlqz`lnsbwjaofebjovqf#le/#pv`k#bp#afdbm#tjwkvpjmd#wkf#wl#sqlujgfefbwvqf#leeqln#tkj`k,!#`obpp>!dfloldj`bopfufqbo#legfojafqbwfjnslqwbmw#klogp#wkbwjmd%rvlw8#ubojdm>wlswkf#Dfqnbmlvwpjgf#lemfdlwjbwfgkjp#`bqffqpfsbqbwjlmjg>!pfbq`ktbp#`boofgwkf#elvqwkqf`qfbwjlmlwkfq#wkbmsqfufmwjlmtkjof#wkf#fgv`bwjlm/`lmmf`wjmdb``vqbwfoztfqf#avjowtbp#hjoofgbdqffnfmwpnv`k#nlqf#Gvf#wl#wkftjgwk9#233plnf#lwkfqHjmdgln#lewkf#fmwjqfebnlvp#elqwl#`lmmf`wlaif`wjufpwkf#Eqfm`ksflsof#bmgefbwvqfg!=jp#pbjg#wlpwqv`wvqboqfefqfmgvnnlpw#lewfmb#pfsbqbwf.= ?gju#jg#Leej`jbo#tlqogtjgf-bqjb.obafowkf#sobmfwbmg#jw#tbpg!#ubovf>!ollhjmd#bwafmfej`jbobqf#jm#wkfnlmjwlqjmdqfslqwfgozwkf#nlgfqmtlqhjmd#lmbooltfg#wltkfqf#wkf#jmmlubwjuf?,b=?,gju=plvmgwqb`hpfbq`kElqnwfmg#wl#afjmsvw#jg>!lsfmjmd#leqfpwqj`wfgbglswfg#azbggqfppjmdwkfloldjbmnfwklgp#leubqjbmw#le@kqjpwjbm#ufqz#obqdfbvwlnlwjufaz#ebq#wkfqbmdf#eqlnsvqpvjw#leeloolt#wkfaqlvdkw#wljm#Fmdobmgbdqff#wkbwb``vpfg#le`lnfp#eqlnsqfufmwjmdgju#pwzof>kjp#lq#kfqwqfnfmglvpeqffgln#le`lm`fqmjmd3#2fn#2fn8Abphfwaboo,pwzof-`ppbm#fbqojfqfufm#bewfq,!#wjwof>!-`ln,jmgf{wbhjmd#wkfsjwwpavqdk`lmwfmw!=?p`qjsw=+ewvqmfg#lvwkbujmd#wkf?,psbm= #l``bpjlmboaf`bvpf#jwpwbqwfg#wlskzpj`booz=?,gju= ##`qfbwfg#az@vqqfmwoz/#ad`lolq>!wbajmgf{>!gjpbpwqlvpBmbozwj`p#bopl#kbp#b=?gju#jg>!?,pwzof= ?`boofg#elqpjmdfq#bmg-pq`#>#!,,ujlobwjlmpwkjp#sljmw`lmpwbmwozjp#ol`bwfgqf`lqgjmdpg#eqln#wkfmfgfqobmgpslqwvdv/Fp;N;};D;u;F5m4K4]4_7`gfpbqqlool`lnfmwbqjlfgv`b`j/_mpfswjfnaqfqfdjpwqbglgjqf``j/_mvaj`b`j/_msvaoj`jgbgqfpsvfpwbpqfpvowbglpjnslqwbmwfqfpfqubglpbqw/A`volpgjefqfmwfppjdvjfmwfpqfs/Vaoj`bpjwvb`j/_mnjmjpwfqjlsqjub`jgbggjqf`wlqjlelqnb`j/_mslaob`j/_msqfpjgfmwf`lmw',
6220
- 'fmjglpb``fplqjlpwf`kmlqbwjsfqplmbofp`bwfdlq/Abfpsf`jbofpgjpslmjaofb`wvbojgbgqfefqfm`jbuboobglojgajaojlwf`bqfob`jlmfp`bofmgbqjlslo/Awj`bpbmwfqjlqfpgl`vnfmwlpmbwvqbofybnbwfqjbofpgjefqfm`jbf`lm/_nj`bwqbmpslqwfqlgq/Advfysbqwj`jsbqfm`vfmwqbmgjp`vpj/_mfpwqv`wvqbevmgb`j/_meqf`vfmwfpsfqnbmfmwfwlwbonfmwf<P<R<Z<Q<R<]=o<X<Y=n<P<R<Z<Y=n<^=l<Y<P=c=n<\\<V<Z<Y=k=n<R<]=g<]<R<W<Y<Y<R=k<Y<Q=`=a=n<R<_<R<V<R<_<X<\\<S<R=m<W<Y<^=m<Y<_<R=m<\\<U=n<Y=k<Y=l<Y<[<P<R<_=o=n=m<\\<U=n<\\<Z<T<[<Q<T<P<Y<Z<X=o<]=o<X=o=n<s<R<T=m<V<[<X<Y=m=`<^<T<X<Y<R=m<^=c<[<T<Q=o<Z<Q<R=m<^<R<Y<U<W=b<X<Y<U<S<R=l<Q<R<P<Q<R<_<R<X<Y=n<Y<U=m<^<R<T=i<S=l<\\<^<\\=n<\\<V<R<U<P<Y=m=n<R<T<P<Y<Y=n<Z<T<[<Q=`<R<X<Q<R<U<W=o=k=d<Y<S<Y=l<Y<X=k<\\=m=n<T=k<\\=m=n=`=l<\\<]<R=n<Q<R<^=g=i<S=l<\\<^<R=m<R<]<R<U<S<R=n<R<P<P<Y<Q<Y<Y=k<T=m<W<Y<Q<R<^=g<Y=o=m<W=o<_<R<V<R<W<R<Q<\\<[<\\<X=n<\\<V<R<Y=n<R<_<X<\\<S<R=k=n<T<s<R=m<W<Y=n<\\<V<T<Y<Q<R<^=g<U=m=n<R<T=n=n<\\<V<T=i=m=l<\\<[=o<M<\\<Q<V=n=h<R=l=o<P<v<R<_<X<\\<V<Q<T<_<T=m<W<R<^<\\<Q<\\=d<Y<U<Q<\\<U=n<T=m<^<R<T<P=m<^=c<[=`<W=b<]<R<U=k<\\=m=n<R=m=l<Y<X<T<v=l<R<P<Y<H<R=l=o<P=l=g<Q<V<Y=m=n<\\<W<T<S<R<T=m<V=n=g=m=c=k<P<Y=m=c=j=j<Y<Q=n=l=n=l=o<X<\\=m<\\<P=g=i=l=g<Q<V<\\<q<R<^=g<U=k<\\=m<R<^<P<Y=m=n<\\=h<T<W=`<P<P<\\=l=n<\\=m=n=l<\\<Q<P<Y=m=n<Y=n<Y<V=m=n<Q<\\=d<T=i<P<T<Q=o=n<T<P<Y<Q<T<T<P<Y=b=n<Q<R<P<Y=l<_<R=l<R<X=m<\\<P<R<P=a=n<R<P=o<V<R<Q=j<Y=m<^<R<Y<P<V<\\<V<R<U<|=l=i<T<^5i5j4F4C5e4I4]4_4K5h4]4_4K5h4E4K5h4U4K5i5o4F4D5k4K4D4]4K5i4@4K5h5f5d5i4K5h4Y5d4]4@4C5f4C4E4K5h4U4Z5d4I4Z4K5m4E4K5h5n4_5i4K5h4U4K4D4F4A5i5f5h5i5h5m4K4F5i5h4F5n5e4F4U4C5f5h4K5h4X4U4]4O4B4D4K4]4F4[5d5f4]4U5h5f5o5i4I4]5m4K5n4[5h4D4K4F4K5h5h4V4E4F4]4F5f4D4K5h5j4K4_4K5h4X5f4B5i5j4F4C5f4K5h4U4]4D4K5h5n4Y4Y4K5m5h4K5i4U5h5f5k4K4F4A4C5f4G4K5h5h5k5i4K5h4U5i5h5i5o4F4D4E5f5i5o5j5o4K5h4[5m5h5m5f4C5f5d4I4C4K4]4E4F4K4]5f4B4K5h4Y4A4E4F4_4@5f5h4K5h5d5n4F4U5j4C5i4K5i4C5f5j4E4F4Y5i5f5i4O4]4X5f5m4K5h4\\5f5j4U4]4D5f4E4D5d4K4D4E4O5h4U4K4D4K5h4_5m4]5i4X4K5o5h4F4U4K5h5e4K5h4O5d5h4K5h4_5j4E4@4K5i4U4E4K5h4Y4A5m4K5h4C5f5j5o5h5i4K4F4K5h4B4K4Y4K5h5i5h5m4O4U4Z4K4M5o4F4K4D4E4K5h4B5f4]4]4_4K4J5h4K5h5n5h4D4K5h4O4C4D5i5n4K4[4U5i4]4K4_5h5i5j4[5n4E4K5h5o4F4D4K5h4]4@5h4K4X4F4]5o4K5h5n4C5i5f4U4[5f5opAzWbdMbnf+-isd!#bow>!2s{#plojg# -dje!#bow>!wqbmpsbqfmwjmelqnbwjlmbssoj`bwjlm!#lm`oj`h>!fpwbaojpkfgbgufqwjpjmd-smd!#bow>!fmujqlmnfmwsfqelqnbm`fbssqlsqjbwf%bns8ngbpk8jnnfgjbwfoz?,pwqlmd=?,qbwkfq#wkbmwfnsfqbwvqfgfufolsnfmw`lnsfwjwjlmsob`fklogfqujpjajojwz9`lszqjdkw!=3!#kfjdkw>!fufm#wklvdkqfsob`fnfmwgfpwjmbwjlm@lqslqbwjlm?vo#`obpp>!Bppl`jbwjlmjmgjujgvbopsfqpsf`wjufpfwWjnflvw+vqo+kwws9,,nbwkfnbwj`pnbqdjm.wls9fufmwvbooz#gfp`qjswjlm*#ml.qfsfbw`loof`wjlmp-ISD\x7Fwkvna\x7Fsbqwj`jsbwf,kfbg=?algzeolbw9ofew8?oj#`obpp>!kvmgqfgp#le Kltfufq/#`lnslpjwjlm`ofbq9alwk8`llsfqbwjlmtjwkjm#wkf#obafo#elq>!alqgfq.wls9Mft#Yfbobmgqf`lnnfmgfgsklwldqbskzjmwfqfpwjmd%ow8pvs%dw8`lmwqlufqpzMfwkfqobmgpbowfqmbwjufnb{ofmdwk>!ptjwyfqobmgGfufolsnfmwfppfmwjbooz Bowklvdk#?,wf{wbqfb=wkvmgfqajqgqfsqfpfmwfg%bns8mgbpk8psf`vobwjlm`lnnvmjwjfpofdjpobwjlmfof`wqlmj`p \n?gju#jg>!joovpwqbwfgfmdjmffqjmdwfqqjwlqjfpbvwklqjwjfpgjpwqjavwfg5!#kfjdkw>!pbmp.pfqje8`bsbaof#le#gjpbssfbqfgjmwfqb`wjufollhjmd#elqjw#tlvog#afBedkbmjpwbmtbp#`qfbwfgNbwk-eollq+pvqqlvmgjmd`bm#bopl#aflapfqubwjlmnbjmwfmbm`ffm`lvmwfqfg?k1#`obpp>!nlqf#qf`fmwjw#kbp#affmjmubpjlm#le*-dfwWjnf+*evmgbnfmwboGfpsjwf#wkf!=?gju#jg>!jmpsjqbwjlmf{bnjmbwjlmsqfsbqbwjlmf{sobmbwjlm?jmsvw#jg>!?,b=?,psbm=ufqpjlmp#lejmpwqvnfmwpafelqf#wkf##>#$kwws9,,Gfp`qjswjlmqfobwjufoz#-pvapwqjmd+fb`k#le#wkff{sfqjnfmwpjmeovfmwjbojmwfdqbwjlmnbmz#sflsofgvf#wl#wkf#`lnajmbwjlmgl#mlw#kbufNjggof#Fbpw?mlp`qjsw=?`lszqjdkw!#sfqkbsp#wkfjmpwjwvwjlmjm#Gf`fnafqbqqbmdfnfmwnlpw#ebnlvpsfqplmbojwz`qfbwjlm#leojnjwbwjlmpf{`ovpjufozplufqfjdmwz.`lmwfmw!= ?wg#`obpp>!vmgfqdqlvmgsbqboofo#wlgl`wqjmf#lel``vsjfg#azwfqnjmloldzQfmbjppbm`fb#mvnafq#lepvsslqw#elqf{solqbwjlmqf`ldmjwjlmsqfgf`fpplq?jnd#pq`>!,?k2#`obpp>!svaoj`bwjlmnbz#bopl#afpsf`jbojyfg?,ejfogpfw=sqldqfppjufnjoojlmp#lepwbwfp#wkbwfmelq`fnfmwbqlvmg#wkf#lmf#bmlwkfq-sbqfmwMlgfbdqj`vowvqfBowfqmbwjufqfpfbq`kfqpwltbqgp#wkfNlpw#le#wkfnbmz#lwkfq#+fpsf`jbooz?wg#tjgwk>!8tjgwk9233&jmgfsfmgfmw?k0#`obpp>!#lm`kbmdf>!*-bgg@obpp+jmwfqb`wjlmLmf#le#wkf#gbvdkwfq#leb``fpplqjfpaqbm`kfp#le ?gju#jg>!wkf#obqdfpwgf`obqbwjlmqfdvobwjlmpJmelqnbwjlmwqbmpobwjlmgl`vnfmwbqzjm#lqgfq#wl!= ?kfbg= ?!#kfjdkw>!2b`qlpp#wkf#lqjfmwbwjlm*8?,p`qjsw=jnsofnfmwfg`bm#af#pffmwkfqf#tbp#bgfnlmpwqbwf`lmwbjmfq!=`lmmf`wjlmpwkf#Aqjwjpktbp#tqjwwfm"jnslqwbmw8s{8#nbqdjm.elooltfg#azbajojwz#wl#`lnsoj`bwfggvqjmd#wkf#jnnjdqbwjlmbopl#`boofg?k7#`obpp>!gjpwjm`wjlmqfsob`fg#azdlufqmnfmwpol`bwjlm#lejm#Mlufnafqtkfwkfq#wkf?,s= ?,gju=b`rvjpjwjlm`boofg#wkf#sfqpf`vwjlmgfpjdmbwjlmxelmw.pjyf9bssfbqfg#jmjmufpwjdbwff{sfqjfm`fgnlpw#ojhfoztjgfoz#vpfggjp`vppjlmpsqfpfm`f#le#+gl`vnfmw-f{wfmpjufozJw#kbp#affmjw#glfp#mlw`lmwqbqz#wljmkbajwbmwpjnsqlufnfmwp`klobqpkjs`lmpvnswjlmjmpwqv`wjlmelq#f{bnsoflmf#lq#nlqfs{8#sbggjmdwkf#`vqqfmwb#pfqjfp#lebqf#vpvboozqlof#jm#wkfsqfujlvpoz#gfqjubwjufpfujgfm`f#lef{sfqjfm`fp`lolqp`kfnfpwbwfg#wkbw`fqwjej`bwf?,b=?,gju= #pfof`wfg>!kjdk#p`klloqfpslmpf#wl`lnelqwbaofbglswjlm#lewkqff#zfbqpwkf#`lvmwqzjm#Efaqvbqzpl#wkbw#wkfsflsof#tkl#sqlujgfg#az?sbqbn#mbnfbeef`wfg#azjm#wfqnp#lebssljmwnfmwJPL.;;6:.2!tbp#alqm#jmkjpwlqj`bo#qfdbqgfg#bpnfbpvqfnfmwjp#abpfg#lm#bmg#lwkfq#9#evm`wjlm+pjdmjej`bmw`fofaqbwjlmwqbmpnjwwfg,ip,irvfqz-jp#hmltm#bpwkflqfwj`bo#wbajmgf{>!jw#`lvog#af?mlp`qjsw= kbujmd#affm ?kfbg= ?#%rvlw8Wkf#`lnsjobwjlmkf#kbg#affmsqlgv`fg#azskjolplskfq`lmpwqv`wfgjmwfmgfg#wlbnlmd#lwkfq`lnsbqfg#wlwl#pbz#wkbwFmdjmffqjmdb#gjeefqfmwqfefqqfg#wlgjeefqfm`fpafojfe#wkbwsklwldqbskpjgfmwjezjmdKjpwlqz#le#Qfsvaoj`#lemf`fppbqjozsqlabajojwzwf`kmj`boozofbujmd#wkfpsf`wb`vobqeqb`wjlm#lefof`wqj`jwzkfbg#le#wkfqfpwbvqbmwpsbqwmfqpkjsfnskbpjp#lmnlpw#qf`fmwpkbqf#tjwk#pbzjmd#wkbwejoofg#tjwkgfpjdmfg#wljw#jp#lewfm!=?,jeqbnf=bp#elooltp9nfqdfg#tjwkwkqlvdk#wkf`lnnfq`jbo#sljmwfg#lvwlsslqwvmjwzujft#le#wkfqfrvjqfnfmwgjujpjlm#lesqldqbnnjmdkf#qf`fjufgpfwJmwfqubo!=?,psbm=?,jm#Mft#Zlqhbggjwjlmbo#`lnsqfppjlm ?gju#jg>!jm`lqslqbwf8?,p`qjsw=?bwwb`kFufmwaf`bnf#wkf#!#wbqdfw>!\\`bqqjfg#lvwPlnf#le#wkfp`jfm`f#bmgwkf#wjnf#le@lmwbjmfq!=nbjmwbjmjmd@kqjpwlskfqNv`k#le#wkftqjwjmdp#le!#kfjdkw>!1pjyf#le#wkfufqpjlm#le#nj{wvqf#le#afwtffm#wkfF{bnsofp#lefgv`bwjlmbo`lnsfwjwjuf#lmpvanjw>!gjqf`wlq#legjpwjm`wjuf,GWG#[KWNO#qfobwjmd#wlwfmgfm`z#wlsqlujm`f#letkj`k#tlvoggfpsjwf#wkfp`jfmwjej`#ofdjpobwvqf-jmmfqKWNO#boofdbwjlmpBdqj`vowvqftbp#vpfg#jmbssqlb`k#wljmwfoojdfmwzfbqp#obwfq/pbmp.pfqjegfwfqnjmjmdSfqelqnbm`fbssfbqbm`fp/#tkj`k#jp#elvmgbwjlmpbaaqfujbwfgkjdkfq#wkbmp#eqln#wkf#jmgjujgvbo#`lnslpfg#lepvsslpfg#wl`objnp#wkbwbwwqjavwjlmelmw.pjyf92fofnfmwp#leKjpwlqj`bo#kjp#aqlwkfqbw#wkf#wjnfbmmjufqpbqzdlufqmfg#azqfobwfg#wl#vowjnbwfoz#jmmlubwjlmpjw#jp#pwjoo`bm#lmoz#afgfejmjwjlmpwlDNWPwqjmdB#mvnafq#lejnd#`obpp>!Fufmwvbooz/tbp#`kbmdfgl``vqqfg#jmmfjdkalqjmdgjpwjmdvjpktkfm#kf#tbpjmwqlgv`jmdwfqqfpwqjboNbmz#le#wkfbqdvfp#wkbwbm#Bnfqj`bm`lmrvfpw#letjgfpsqfbg#tfqf#hjoofgp`qffm#bmg#Jm#lqgfq#wlf{sf`wfg#wlgfp`fmgbmwpbqf#ol`bwfgofdjpobwjufdfmfqbwjlmp#ab`hdqlvmgnlpw#sflsofzfbqp#bewfqwkfqf#jp#mlwkf#kjdkfpweqfrvfmwoz#wkfz#gl#mlwbqdvfg#wkbwpkltfg#wkbwsqfglnjmbmwwkfloldj`boaz#wkf#wjnf`lmpjgfqjmdpklqw.ojufg?,psbm=?,b=`bm#af#vpfgufqz#ojwwoflmf#le#wkf#kbg#boqfbgzjmwfqsqfwfg`lnnvmj`bwfefbwvqfp#ledlufqmnfmw/?,mlp`qjsw=fmwfqfg#wkf!#kfjdkw>!0Jmgfsfmgfmwslsvobwjlmpobqdf.p`bof-#Bowklvdk#vpfg#jm#wkfgfpwqv`wjlmslppjajojwzpwbqwjmd#jmwtl#lq#nlqff{sqfppjlmppvalqgjmbwfobqdfq#wkbmkjpwlqz#bmg?,lswjlm= @lmwjmfmwbofojnjmbwjmdtjoo#mlw#afsqb`wj`f#lejm#eqlmw#lepjwf#le#wkffmpvqf#wkbwwl#`qfbwf#bnjppjppjssjslwfmwjboozlvwpwbmgjmdafwwfq#wkbmtkbw#jp#mltpjwvbwfg#jmnfwb#mbnf>!WqbgjwjlmbopvddfpwjlmpWqbmpobwjlmwkf#elqn#lebwnlpskfqj`jgfloldj`bofmwfqsqjpfp`bo`vobwjmdfbpw#le#wkfqfnmbmwp#lesovdjmpsbdf,jmgf{-sks<qfnbjmfg#jmwqbmpelqnfgKf#tbp#bopltbp#boqfbgzpwbwjpwj`bojm#ebulq#leNjmjpwqz#lenlufnfmw#leelqnvobwjlmjp#qfrvjqfg?ojmh#qfo>!Wkjp#jp#wkf#?b#kqfe>!,slsvobqjyfgjmuloufg#jmbqf#vpfg#wlbmg#pfufqbonbgf#az#wkfpffnp#wl#afojhfoz#wkbwSbofpwjmjbmmbnfg#bewfqjw#kbg#affmnlpw#`lnnlmwl#qfefq#wlavw#wkjp#jp`lmpf`vwjufwfnslqbqjozJm#dfmfqbo/`lmufmwjlmpwbhfp#sob`fpvagjujpjlmwfqqjwlqjbolsfqbwjlmbosfqnbmfmwoztbp#obqdfozlvwaqfbh#lejm#wkf#sbpwelooltjmd#b#{nomp9ld>!=?b#`obpp>!`obpp>!wf{w@lmufqpjlm#nbz#af#vpfgnbmveb`wvqfbewfq#afjmd`ofbqej{!= rvfpwjlm#letbp#fof`wfgwl#af`lnf#baf`bvpf#le#plnf#sflsofjmpsjqfg#azpv``fppevo#b#wjnf#tkfmnlqf#`lnnlmbnlmdpw#wkfbm#leej`jbotjgwk9233&8wf`kmloldz/tbp#bglswfgwl#hffs#wkfpfwwofnfmwpojuf#ajqwkpjmgf{-kwno!@lmmf`wj`vwbppjdmfg#wl%bns8wjnfp8b``lvmw#elqbojdm>qjdkwwkf#`lnsbmzbotbzp#affmqfwvqmfg#wljmuloufnfmwAf`bvpf#wkfwkjp#sfqjlg!#mbnf>!r!#`lmejmfg#wlb#qfpvow#leubovf>!!#,=jp#b`wvboozFmujqlmnfmw ?,kfbg= @lmufqpfoz/= ?gju#jg>!3!#tjgwk>!2jp#sqlabaozkbuf#af`lnf`lmwqloojmdwkf#sqlaofn`jwjyfmp#leslojwj`jbmpqfb`kfg#wkfbp#fbqoz#bp9mlmf8#lufq?wbaof#`fooubojgjwz#legjqf`woz#wllmnlvpfgltmtkfqf#jw#jptkfm#jw#tbpnfnafqp#le#qfobwjlm#wlb``lnnlgbwfbolmd#tjwk#Jm#wkf#obwfwkf#Fmdojpkgfoj`jlvp!=wkjp#jp#mlwwkf#sqfpfmwje#wkfz#bqfbmg#ejmboozb#nbwwfq#le \n?,gju=  ?,p`qjsw=ebpwfq#wkbmnbilqjwz#lebewfq#tkj`k`lnsbqbwjufwl#nbjmwbjmjnsqluf#wkfbtbqgfg#wkffq!#`obpp>!eqbnfalqgfqqfpwlqbwjlmjm#wkf#pbnfbmbozpjp#lewkfjq#ejqpwGvqjmd#wkf#`lmwjmfmwbopfrvfm`f#leevm`wjlm+*xelmw.pjyf9#tlqh#lm#wkf?,p`qjsw= ?afdjmp#tjwkibubp`qjsw9`lmpwjwvfmwtbp#elvmgfgfrvjojaqjvnbppvnf#wkbwjp#djufm#azmffgp#wl#af`llqgjmbwfpwkf#ubqjlvpbqf#sbqw#lelmoz#jm#wkfpf`wjlmp#lejp#b#`lnnlmwkflqjfp#legjp`lufqjfpbppl`jbwjlmfgdf#le#wkfpwqfmdwk#leslpjwjlm#jmsqfpfmw.gbzvmjufqpboozwl#elqn#wkfavw#jmpwfbg`lqslqbwjlmbwwb`kfg#wljp#`lnnlmozqfbplmp#elq#%rvlw8wkf#`bm#af#nbgftbp#baof#wltkj`k#nfbmpavw#gjg#mlwlmNlvpfLufqbp#slppjaoflsfqbwfg#az`lnjmd#eqlnwkf#sqjnbqzbggjwjlm#leelq#pfufqbowqbmpefqqfgb#sfqjlg#lebqf#baof#wlkltfufq/#jwpklvog#kbufnv`k#obqdfq \n?,p`qjsw=bglswfg#wkfsqlsfqwz#legjqf`wfg#azfeef`wjufoztbp#aqlvdkw`kjogqfm#leSqldqbnnjmdolmdfq#wkbmnbmvp`qjswptbq#bdbjmpwaz#nfbmp#lebmg#nlpw#lepjnjobq#wl#sqlsqjfwbqzlqjdjmbwjmdsqfpwjdjlvpdqbnnbwj`bof{sfqjfm`f-wl#nbhf#wkfJw#tbp#bopljp#elvmg#jm`lnsfwjwlqpjm#wkf#V-P-qfsob`f#wkfaqlvdkw#wkf`bo`vobwjlmeboo#le#wkfwkf#dfmfqbosqb`wj`boozjm#klmlq#leqfofbpfg#jmqfpjgfmwjbobmg#plnf#lehjmd#le#wkfqfb`wjlm#wl2pw#Fbqo#le`vowvqf#bmgsqjm`jsbooz?,wjwof= ##wkfz#`bm#afab`h#wl#wkfplnf#le#kjpf{slpvqf#wlbqf#pjnjobqelqn#le#wkfbggEbulqjwf`jwjyfmpkjssbqw#jm#wkfsflsof#tjwkjm#sqb`wj`fwl#`lmwjmvf%bns8njmvp8bssqlufg#az#wkf#ejqpw#booltfg#wkfbmg#elq#wkfevm`wjlmjmdsobzjmd#wkfplovwjlm#wlkfjdkw>!3!#jm#kjp#allhnlqf#wkbm#belooltp#wkf`qfbwfg#wkfsqfpfm`f#jm%maps8?,wg=mbwjlmbojpwwkf#jgfb#leb#`kbqb`wfqtfqf#elq`fg#`obpp>!awmgbzp#le#wkfefbwvqfg#jmpkltjmd#wkfjmwfqfpw#jmjm#sob`f#lewvqm#le#wkfwkf#kfbg#leOlqg#le#wkfslojwj`boozkbp#jwp#ltmFgv`bwjlmbobssqlubo#leplnf#le#wkffb`k#lwkfq/afkbujlq#lebmg#af`bvpfbmg#bmlwkfqbssfbqfg#lmqf`lqgfg#jmaob`h%rvlw8nbz#jm`ovgfwkf#tlqog$p`bm#ofbg#wlqfefqp#wl#balqgfq>!3!#dlufqmnfmw#tjmmjmd#wkfqfpvowfg#jm#tkjof#wkf#Tbpkjmdwlm/wkf#pvaif`w`jwz#jm#wkf=?,gju= \n\nqfeof`w#wkfwl#`lnsofwfaf`bnf#nlqfqbgjlb`wjufqfif`wfg#aztjwklvw#bmzkjp#ebwkfq/tkj`k#`lvog`lsz#le#wkfwl#jmgj`bwfb#slojwj`bob``lvmwp#le`lmpwjwvwfptlqhfg#tjwkfq?,b=?,oj=le#kjp#ojefb``lnsbmjfg`ojfmwTjgwksqfufmw#wkfOfdjpobwjufgjeefqfmwozwldfwkfq#jmkbp#pfufqboelq#bmlwkfqwf{w#le#wkfelvmgfg#wkff#tjwk#wkf#jp#vpfg#elq`kbmdfg#wkfvpvbooz#wkfsob`f#tkfqftkfqfbp#wkf=#?b#kqfe>!!=?b#kqfe>!wkfnpfoufp/bowklvdk#kfwkbw#`bm#afwqbgjwjlmboqlof#le#wkfbp#b#qfpvowqfnluf@kjoggfpjdmfg#aztfpw#le#wkfPlnf#sflsofsqlgv`wjlm/pjgf#le#wkfmftpofwwfqpvpfg#az#wkfgltm#wl#wkfb``fswfg#azojuf#jm#wkfbwwfnswp#wllvwpjgf#wkfeqfrvfm`jfpKltfufq/#jmsqldqbnnfqpbw#ofbpw#jmbssql{jnbwfbowklvdk#jwtbp#sbqw#lebmg#ubqjlvpDlufqmlq#lewkf#bqwj`ofwvqmfg#jmwl=?b#kqfe>!,wkf#f`lmlnzjp#wkf#nlpwnlpw#tjgfoztlvog#obwfqbmg#sfqkbspqjpf#wl#wkfl``vqp#tkfmvmgfq#tkj`k`lmgjwjlmp-wkf#tfpwfqmwkflqz#wkbwjp#sqlgv`fgwkf#`jwz#lejm#tkj`k#kfpffm#jm#wkfwkf#`fmwqboavjogjmd#lenbmz#le#kjpbqfb#le#wkfjp#wkf#lmoznlpw#le#wkfnbmz#le#wkfwkf#TfpwfqmWkfqf#jp#mlf{wfmgfg#wlPwbwjpwj`bo`lopsbm>1#\x7Fpklqw#pwlqzslppjaof#wlwlsloldj`bo`qjwj`bo#leqfslqwfg#wlb#@kqjpwjbmgf`jpjlm#wljp#frvbo#wlsqlaofnp#leWkjp#`bm#afnfq`kbmgjpfelq#nlpw#leml#fujgfm`ffgjwjlmp#lefofnfmwp#jm%rvlw8-#Wkf`ln,jnbdfp,tkj`k#nbhfpwkf#sql`fppqfnbjmp#wkfojwfqbwvqf/jp#b#nfnafqwkf#slsvobqwkf#bm`jfmwsqlaofnp#jmwjnf#le#wkfgfefbwfg#azalgz#le#wkfb#eft#zfbqpnv`k#le#wkfwkf#tlqh#le@bojelqmjb/pfqufg#bp#bdlufqmnfmw-`lm`fswp#lenlufnfmw#jm\n\n?gju#jg>!jw!#ubovf>!obmdvbdf#lebp#wkfz#bqfsqlgv`fg#jmjp#wkbw#wkff{sobjm#wkfgju=?,gju= Kltfufq#wkfofbg#wl#wkf\n?b#kqfe>!,tbp#dqbmwfgsflsof#kbuf`lmwjmvbooztbp#pffm#bpbmg#qfobwfgwkf#qlof#lesqlslpfg#azle#wkf#afpwfb`k#lwkfq-@lmpwbmwjmfsflsof#eqlngjbof`wp#lewl#qfujpjlmtbp#qfmbnfgb#plvq`f#lewkf#jmjwjboobvm`kfg#jmsqlujgf#wkfwl#wkf#tfpwtkfqf#wkfqfbmg#pjnjobqafwtffm#wtljp#bopl#wkfFmdojpk#bmg`lmgjwjlmp/wkbw#jw#tbpfmwjwofg#wlwkfnpfoufp-rvbmwjwz#leqbmpsbqfm`zwkf#pbnf#bpwl#iljm#wkf`lvmwqz#bmgwkjp#jp#wkfWkjp#ofg#wlb#pwbwfnfmw`lmwqbpw#wlobpwJmgf{Lewkqlvdk#kjpjp#gfpjdmfgwkf#wfqn#jpjp#sqlujgfgsqlwf`w#wkfmd?,b=?,oj=Wkf#`vqqfmwwkf#pjwf#lepvapwbmwjbof{sfqjfm`f/jm#wkf#Tfpwwkfz#pklvogpolufm(ajmb`lnfmwbqjlpvmjufqpjgbg`lmgj`jlmfpb`wjujgbgfpf{sfqjfm`jbwf`mlold/Absqlgv``j/_msvmwvb`j/_mbsoj`b`j/_m`lmwqbpf/]b`bwfdlq/Abpqfdjpwqbqpfsqlefpjlmbowqbwbnjfmwlqfd/Apwqbwfpf`qfwbq/Absqjm`jsbofpsqlwf``j/_mjnslqwbmwfpjnslqwbm`jbslpjajojgbgjmwfqfpbmwf`qf`jnjfmwlmf`fpjgbgfppvp`qjajqpfbpl`jb`j/_mgjpslmjaofpfubovb`j/_mfpwvgjbmwfpqfpslmpbaofqfplov`j/_mdvbgbobibqbqfdjpwqbglplslqwvmjgbg`lnfq`jbofpelwldqbe/Abbvwlqjgbgfpjmdfmjfq/Abwfofujpj/_m`lnsfwfm`jblsfqb`jlmfpfpwbaof`jglpjnsofnfmwfb`wvbonfmwfmbufdb`j/_m`lmelqnjgbgojmf.kfjdkw9elmw.ebnjoz9!#9#!kwws9,,bssoj`bwjlmpojmh!#kqfe>!psf`jej`booz,,?"X@GBWBX Lqdbmjybwjlmgjpwqjavwjlm3s{8#kfjdkw9qfobwjlmpkjsgfuj`f.tjgwk?gju#`obpp>!?obafo#elq>!qfdjpwqbwjlm?,mlp`qjsw= ,jmgf{-kwno!tjmglt-lsfm+#"jnslqwbmw8bssoj`bwjlm,jmgfsfmgfm`f,,ttt-dlldoflqdbmjybwjlmbvwl`lnsofwfqfrvjqfnfmwp`lmpfqubwjuf?elqn#mbnf>!jmwfoof`wvbonbqdjm.ofew92;wk#`fmwvqzbm#jnslqwbmwjmpwjwvwjlmpbaaqfujbwjlm?jnd#`obpp>!lqdbmjpbwjlm`jujojybwjlm2:wk#`fmwvqzbq`kjwf`wvqfjm`lqslqbwfg13wk#`fmwvqz.`lmwbjmfq!=nlpw#mlwbaoz,=?,b=?,gju=mlwjej`bwjlm$vmgfejmfg$*Evqwkfqnlqf/afojfuf#wkbwjmmfqKWNO#>#sqjlq#wl#wkfgqbnbwj`boozqfefqqjmd#wlmfdlwjbwjlmpkfbgrvbqwfqpPlvwk#Beqj`bvmpv``fppevoSfmmpzoubmjbBp#b#qfpvow/?kwno#obmd>!%ow8,pvs%dw8gfbojmd#tjwkskjobgfoskjbkjpwlqj`booz*8?,p`qjsw= sbggjmd.wls9f{sfqjnfmwbodfwBwwqjavwfjmpwqv`wjlmpwf`kmloldjfpsbqw#le#wkf#>evm`wjlm+*xpvap`qjswjlmo-gwg!= ?kwdfldqbskj`bo@lmpwjwvwjlm$/#evm`wjlm+pvsslqwfg#azbdqj`vowvqbo`lmpwqv`wjlmsvaoj`bwjlmpelmw.pjyf9#2b#ubqjfwz#le?gju#pwzof>!Fm`z`olsfgjbjeqbnf#pq`>!gfnlmpwqbwfgb``lnsojpkfgvmjufqpjwjfpGfnldqbskj`p*8?,p`qjsw=?gfgj`bwfg#wlhmltofgdf#lepbwjpeb`wjlmsbqwj`vobqoz?,gju=?,gju=Fmdojpk#+VP*bssfmg@kjog+wqbmpnjppjlmp-#Kltfufq/#jmwfoojdfm`f!#wbajmgf{>!eolbw9qjdkw8@lnnlmtfbowkqbmdjmd#eqlnjm#tkj`k#wkfbw#ofbpw#lmfqfsqlgv`wjlmfm`z`olsfgjb8elmw.pjyf92ivqjpgj`wjlmbw#wkbw#wjnf!=?b#`obpp>!Jm#bggjwjlm/gfp`qjswjlm(`lmufqpbwjlm`lmwb`w#tjwkjp#dfmfqboozq!#`lmwfmw>!qfsqfpfmwjmd%ow8nbwk%dw8sqfpfmwbwjlml``bpjlmbooz?jnd#tjgwk>!mbujdbwjlm!=`lnsfmpbwjlm`kbnsjlmpkjsnfgjb>!boo!#ujlobwjlm#leqfefqfm`f#wlqfwvqm#wqvf8Pwqj`w,,FM!#wqbmpb`wjlmpjmwfqufmwjlmufqjej`bwjlmJmelqnbwjlm#gjeej`vowjfp@kbnsjlmpkjs`bsbajojwjfp?"Xfmgje^..=~ ?,p`qjsw= @kqjpwjbmjwzelq#f{bnsof/Sqlefppjlmboqfpwqj`wjlmppvddfpw#wkbwtbp#qfofbpfg+pv`k#bp#wkfqfnluf@obpp+vmfnsolznfmwwkf#Bnfqj`bmpwqv`wvqf#le,jmgf{-kwno#svaojpkfg#jmpsbm#`obpp>!!=?b#kqfe>!,jmwqlgv`wjlmafolmdjmd#wl`objnfg#wkbw`lmpfrvfm`fp?nfwb#mbnf>!Dvjgf#wl#wkflufqtkfonjmdbdbjmpw#wkf#`lm`fmwqbwfg/ -mlmwlv`k#lapfqubwjlmp?,b= ?,gju= e#+gl`vnfmw-alqgfq9#2s{#xelmw.pjyf92wqfbwnfmw#le3!#kfjdkw>!2nlgjej`bwjlmJmgfsfmgfm`fgjujgfg#jmwldqfbwfq#wkbmb`kjfufnfmwpfpwbaojpkjmdIbubP`qjsw!#mfufqwkfofpppjdmjej`bm`fAqlbg`bpwjmd=%maps8?,wg=`lmwbjmfq!= pv`k#bp#wkf#jmeovfm`f#leb#sbqwj`vobqpq`>$kwws9,,mbujdbwjlm!#kboe#le#wkf#pvapwbmwjbo#%maps8?,gju=bgubmwbdf#legjp`lufqz#leevmgbnfmwbo#nfwqlslojwbmwkf#lsslpjwf!#{no9obmd>!gfojafqbwfozbojdm>`fmwfqfulovwjlm#lesqfpfqubwjlmjnsqlufnfmwpafdjmmjmd#jmIfpvp#@kqjpwSvaoj`bwjlmpgjpbdqffnfmwwf{w.bojdm9q/#evm`wjlm+*pjnjobqjwjfpalgz=?,kwno=jp#`vqqfmwozboskbafwj`bojp#plnfwjnfpwzsf>!jnbdf,nbmz#le#wkf#eolt9kjggfm8bubjobaof#jmgfp`qjaf#wkff{jpwfm`f#leboo#lufq#wkfwkf#Jmwfqmfw\n?vo#`obpp>!jmpwboobwjlmmfjdkalqkllgbqnfg#elq`fpqfgv`jmd#wkf`lmwjmvfp#wlMlmfwkfofpp/wfnsfqbwvqfp \n\n?b#kqfe>!`olpf#wl#wkff{bnsofp#le#jp#balvw#wkf+pff#afolt*-!#jg>!pfbq`ksqlefppjlmbojp#bubjobaofwkf#leej`jbo\n\n?,p`qjsw= \n\n?gju#jg>!b``fofqbwjlmwkqlvdk#wkf#Kboo#le#Ebnfgfp`qjswjlmpwqbmpobwjlmpjmwfqefqfm`f#wzsf>$wf{w,qf`fmw#zfbqpjm#wkf#tlqogufqz#slsvobqxab`hdqlvmg9wqbgjwjlmbo#plnf#le#wkf#`lmmf`wfg#wlf{soljwbwjlmfnfqdfm`f#le`lmpwjwvwjlmB#Kjpwlqz#lepjdmjej`bmw#nbmveb`wvqfgf{sf`wbwjlmp=?mlp`qjsw=?`bm#af#elvmgaf`bvpf#wkf#kbp#mlw#affmmfjdkalvqjmdtjwklvw#wkf#bggfg#wl#wkf\n?oj#`obpp>!jmpwqvnfmwboPlujfw#Vmjlmb`hmltofgdfgtkj`k#`bm#afmbnf#elq#wkfbwwfmwjlm#wlbwwfnswp#wl#gfufolsnfmwpJm#eb`w/#wkf?oj#`obpp>!bjnsoj`bwjlmppvjwbaof#elqnv`k#le#wkf#`lolmjybwjlmsqfpjgfmwjbo`bm`foAvaaof#Jmelqnbwjlmnlpw#le#wkf#jp#gfp`qjafgqfpw#le#wkf#nlqf#lq#ofppjm#PfswfnafqJmwfoojdfm`fpq`>!kwws9,,s{8#kfjdkw9#bubjobaof#wlnbmveb`wvqfqkvnbm#qjdkwpojmh#kqfe>!,bubjobajojwzsqlslqwjlmbolvwpjgf#wkf#bpwqlmlnj`bokvnbm#afjmdpmbnf#le#wkf#bqf#elvmg#jmbqf#abpfg#lmpnboofq#wkbmb#sfqplm#tklf{sbmpjlm#lebqdvjmd#wkbwmlt#hmltm#bpJm#wkf#fbqozjmwfqnfgjbwfgfqjufg#eqlnP`bmgjmbujbm?,b=?,gju= `lmpjgfq#wkfbm#fpwjnbwfgwkf#Mbwjlmbo?gju#jg>!sbdqfpvowjmd#jm`lnnjppjlmfgbmboldlvp#wlbqf#qfrvjqfg,vo= ?,gju= tbp#abpfg#lmbmg#af`bnf#b%maps8%maps8w!#ubovf>!!#tbp#`bswvqfgml#nlqf#wkbmqfpsf`wjufoz`lmwjmvf#wl#= ?kfbg= ?tfqf#`qfbwfgnlqf#dfmfqbojmelqnbwjlm#vpfg#elq#wkfjmgfsfmgfmw#wkf#Jnsfqjbo`lnslmfmw#lewl#wkf#mlqwkjm`ovgf#wkf#@lmpwqv`wjlmpjgf#le#wkf#tlvog#mlw#afelq#jmpwbm`fjmufmwjlm#lenlqf#`lnsof{`loof`wjufozab`hdqlvmg9#wf{w.bojdm9#jwp#lqjdjmbojmwl#b``lvmwwkjp#sql`fppbm#f{wfmpjufkltfufq/#wkfwkfz#bqf#mlwqfif`wfg#wkf`qjwj`jpn#legvqjmd#tkj`ksqlabaoz#wkfwkjp#bqwj`of+evm`wjlm+*xJw#pklvog#afbm#bdqffnfmwb``jgfmwboozgjeefqp#eqlnBq`kjwf`wvqfafwwfq#hmltmbqqbmdfnfmwpjmeovfm`f#lmbwwfmgfg#wkfjgfmwj`bo#wlplvwk#le#wkfsbpp#wkqlvdk{no!#wjwof>!tfjdkw9alog8`qfbwjmd#wkfgjpsobz9mlmfqfsob`fg#wkf?jnd#pq`>!,jkwwsp9,,ttt-Tlqog#Tbq#JJwfpwjnlmjbopelvmg#jm#wkfqfrvjqfg#wl#bmg#wkbw#wkfafwtffm#wkf#tbp#gfpjdmfg`lmpjpwp#le#`lmpjgfqbaozsvaojpkfg#azwkf#obmdvbdf@lmpfqubwjlm`lmpjpwfg#leqfefq#wl#wkfab`h#wl#wkf#`pp!#nfgjb>!Sflsof#eqln#bubjobaof#lmsqlufg#wl#afpvddfpwjlmp!tbp#hmltm#bpubqjfwjfp#leojhfoz#wl#af`lnsqjpfg#lepvsslqw#wkf#kbmgp#le#wkf`lvsofg#tjwk`lmmf`w#bmg#alqgfq9mlmf8sfqelqnbm`fpafelqf#afjmdobwfq#af`bnf`bo`vobwjlmplewfm#`boofgqfpjgfmwp#lenfbmjmd#wkbw=?oj#`obpp>!fujgfm`f#elqf{sobmbwjlmpfmujqlmnfmwp!=?,b=?,gju=tkj`k#booltpJmwqlgv`wjlmgfufolsfg#azb#tjgf#qbmdflm#afkboe#leubojdm>!wls!sqjm`jsof#lebw#wkf#wjnf/?,mlp`qjsw=pbjg#wl#kbufjm#wkf#ejqpwtkjof#lwkfqpkzslwkfwj`boskjolplskfqpsltfq#le#wkf`lmwbjmfg#jmsfqelqnfg#azjmbajojwz#wltfqf#tqjwwfmpsbm#pwzof>!jmsvw#mbnf>!wkf#rvfpwjlmjmwfmgfg#elqqfif`wjlm#lejnsojfp#wkbwjmufmwfg#wkfwkf#pwbmgbqgtbp#sqlabaozojmh#afwtffmsqlefpplq#lejmwfqb`wjlmp`kbmdjmd#wkfJmgjbm#L`fbm#`obpp>!obpwtlqhjmd#tjwk$kwws9,,ttt-zfbqp#afelqfWkjp#tbp#wkfqf`qfbwjlmbofmwfqjmd#wkfnfbpvqfnfmwpbm#f{wqfnfozubovf#le#wkfpwbqw#le#wkf ?,p`qjsw= bm#feelqw#wljm`qfbpf#wkfwl#wkf#plvwkpsb`jmd>!3!=pveej`jfmwozwkf#Fvqlsfbm`lmufqwfg#wl`ofbqWjnflvwgjg#mlw#kbuf`lmpfrvfmwozelq#wkf#mf{wf{wfmpjlm#lef`lmlnj`#bmgbowklvdk#wkfbqf#sqlgv`fgbmg#tjwk#wkfjmpveej`jfmwdjufm#az#wkfpwbwjmd#wkbwf{sfmgjwvqfp?,psbm=?,b= wklvdkw#wkbwlm#wkf#abpjp`foosbggjmd>jnbdf#le#wkfqfwvqmjmd#wljmelqnbwjlm/pfsbqbwfg#azbppbppjmbwfgp!#`lmwfmw>!bvwklqjwz#lemlqwktfpwfqm?,gju= ?gju#!=?,gju= ##`lmpvowbwjlm`lnnvmjwz#lewkf#mbwjlmbojw#pklvog#afsbqwj`jsbmwp#bojdm>!ofewwkf#dqfbwfpwpfof`wjlm#lepvsfqmbwvqbogfsfmgfmw#lmjp#nfmwjlmfgbooltjmd#wkftbp#jmufmwfgb``lnsbmzjmdkjp#sfqplmbobubjobaof#bwpwvgz#le#wkflm#wkf#lwkfqf{f`vwjlm#leKvnbm#Qjdkwpwfqnp#le#wkfbppl`jbwjlmpqfpfbq`k#bmgpv``ffgfg#azgfefbwfg#wkfbmg#eqln#wkfavw#wkfz#bqf`lnnbmgfq#lepwbwf#le#wkfzfbqp#le#bdfwkf#pwvgz#le?vo#`obpp>!psob`f#jm#wkftkfqf#kf#tbp?oj#`obpp>!ewkfqf#bqf#mltkj`k#af`bnfkf#svaojpkfgf{sqfppfg#jmwl#tkj`k#wkf`lnnjppjlmfqelmw.tfjdkw9wfqqjwlqz#lef{wfmpjlmp!=Qlnbm#Fnsjqffrvbo#wl#wkfJm#`lmwqbpw/kltfufq/#bmgjp#wzsj`boozbmg#kjp#tjef+bopl#`boofg=?vo#`obpp>!feef`wjufoz#fuloufg#jmwlpffn#wl#kbuftkj`k#jp#wkfwkfqf#tbp#mlbm#f{`foofmwboo#le#wkfpfgfp`qjafg#azJm#sqb`wj`f/aqlbg`bpwjmd`kbqdfg#tjwkqfeof`wfg#jmpvaif`wfg#wlnjojwbqz#bmgwl#wkf#sljmwf`lmlnj`boozpfwWbqdfwjmdbqf#b`wvboozuj`wlqz#lufq+*8?,p`qjsw=`lmwjmvlvpozqfrvjqfg#elqfulovwjlmbqzbm#feef`wjufmlqwk#le#wkf/#tkj`k#tbp#eqlmw#le#wkflq#lwkfqtjpfplnf#elqn#lekbg#mlw#affmdfmfqbwfg#azjmelqnbwjlm-sfqnjwwfg#wljm`ovgfp#wkfgfufolsnfmw/fmwfqfg#jmwlwkf#sqfujlvp`lmpjpwfmwozbqf#hmltm#bpwkf#ejfog#lewkjp#wzsf#ledjufm#wl#wkfwkf#wjwof#le`lmwbjmp#wkfjmpwbm`fp#lejm#wkf#mlqwkgvf#wl#wkfjqbqf#gfpjdmfg`lqslqbwjlmptbp#wkbw#wkflmf#le#wkfpfnlqf#slsvobqpv``ffgfg#jmpvsslqw#eqlnjm#gjeefqfmwglnjmbwfg#azgfpjdmfg#elqltmfqpkjs#lebmg#slppjaozpwbmgbqgjyfgqfpslmpfWf{wtbp#jmwfmgfgqf`fjufg#wkfbppvnfg#wkbwbqfbp#le#wkfsqjnbqjoz#jmwkf#abpjp#lejm#wkf#pfmpfb``lvmwp#elqgfpwqlzfg#azbw#ofbpw#wtltbp#gf`obqfg`lvog#mlw#afPf`qfwbqz#lebssfbq#wl#afnbqdjm.wls92,]_p(\x7F_p(\',df*xwkqlt#f~8wkf#pwbqw#lewtl#pfsbqbwfobmdvbdf#bmgtkl#kbg#affmlsfqbwjlm#legfbwk#le#wkfqfbo#mvnafqp\n?ojmh#qfo>!sqlujgfg#wkfwkf#pwlqz#le`lnsfwjwjlmpfmdojpk#+VH*fmdojpk#+VP*<p<R<Q<_<R<W<M=l<S=m<V<T=m=l<S=m<V<T=m=l<S=m<V<R5h4U4]4D5f4E\nAOGx\bTA\nzk\vBl\bQ\x7F\bTA\nzk\vUm\bQ\x7F\bTA\nzk\npeu| i@ cT\bVV\n\\}\nxS VptSk` [X [X\vHR\bPv\bTW\bUe\n\x7Fa\bQp\v_W\vWs\nxS\vAz\n_yKhjmelqnb`j/_mkfqqbnjfmwbpfof`wq/_mj`lgfp`qjs`j/_m`obpjej`bglp`lml`jnjfmwlsvaoj`b`j/_mqfob`jlmbgbpjmelqn/Mwj`bqfob`jlmbglpgfsbqwbnfmwlwqbabibglqfpgjqf`wbnfmwfbzvmwbnjfmwlnfq`bglOjaqf`lmw/M`wfmlpkbajwb`jlmfp`vnsojnjfmwlqfpwbvqbmwfpgjpslpj`j/_m`lmpf`vfm`jbfof`wq/_mj`bbsoj`b`jlmfpgfp`lmf`wbgljmpwbob`j/_mqfbojyb`j/_mvwjojyb`j/_mfm`j`olsfgjbfmefqnfgbgfpjmpwqvnfmwlpf{sfqjfm`jbpjmpwjwv`j/_msbqwj`vobqfppva`bwfdlqjb=n<R<W=`<V<R<L<R=m=m<T<T=l<\\<]<R=n=g<]<R<W=`=d<Y<S=l<R=m=n<R<P<R<Z<Y=n<Y<X=l=o<_<T=i=m<W=o=k<\\<Y=m<Y<U=k<\\=m<^=m<Y<_<X<\\<L<R=m=m<T=c<p<R=m<V<^<Y<X=l=o<_<T<Y<_<R=l<R<X<\\<^<R<S=l<R=m<X<\\<Q<Q=g=i<X<R<W<Z<Q=g<T<P<Y<Q<Q<R<p<R=m<V<^=g=l=o<]<W<Y<U<p<R=m<V<^<\\=m=n=l<\\<Q=g<Q<T=k<Y<_<R=l<\\<]<R=n<Y<X<R<W<Z<Y<Q=o=m<W=o<_<T=n<Y<S<Y=l=`<r<X<Q<\\<V<R<S<R=n<R<P=o=l<\\<]<R=n=o<\\<S=l<Y<W=c<^<R<R<]=e<Y<R<X<Q<R<_<R=m<^<R<Y<_<R=m=n<\\=n=`<T<X=l=o<_<R<U=h<R=l=o<P<Y=i<R=l<R=d<R<S=l<R=n<T<^=m=m=g<W<V<\\<V<\\<Z<X=g<U<^<W<\\=m=n<T<_=l=o<S<S=g<^<P<Y=m=n<Y=l<\\<]<R=n<\\=m<V<\\<[<\\<W<S<Y=l<^=g<U<X<Y<W<\\=n=`<X<Y<Q=`<_<T<S<Y=l<T<R<X<]<T<[<Q<Y=m<R=m<Q<R<^<Y<P<R<P<Y<Q=n<V=o<S<T=n=`<X<R<W<Z<Q<\\=l<\\<P<V<\\=i<Q<\\=k<\\<W<R<L<\\<]<R=n<\\<N<R<W=`<V<R=m<R<^=m<Y<P<^=n<R=l<R<U<Q<\\=k<\\<W<\\=m<S<T=m<R<V=m<W=o<Z<]=g=m<T=m=n<Y<P<S<Y=k<\\=n<T<Q<R<^<R<_<R<S<R<P<R=e<T=m<\\<U=n<R<^<S<R=k<Y<P=o<S<R<P<R=e=`<X<R<W<Z<Q<R=m=m=g<W<V<T<]=g=m=n=l<R<X<\\<Q<Q=g<Y<P<Q<R<_<T<Y<S=l<R<Y<V=n<M<Y<U=k<\\=m<P<R<X<Y<W<T=n<\\<V<R<_<R<R<Q<W<\\<U<Q<_<R=l<R<X<Y<^<Y=l=m<T=c=m=n=l<\\<Q<Y=h<T<W=`<P=g=o=l<R<^<Q=c=l<\\<[<Q=g=i<T=m<V<\\=n=`<Q<Y<X<Y<W=b=c<Q<^<\\=l=c<P<Y<Q=`=d<Y<P<Q<R<_<T=i<X<\\<Q<Q<R<U<[<Q<\\=k<T=n<Q<Y<W=`<[=c=h<R=l=o<P<\\<N<Y<S<Y=l=`<P<Y=m=c=j<\\<[<\\=e<T=n=g<w=o=k=d<T<Y\fHD\fHU\fIl\fHn\fHy\fH\\\fHD\fIk\fHi\fHF\fHD\fIk\fHy\fHS\fHC\fHR\fHy\fH\\\fIk\fHn\fHi\fHD\fIa\fHC\fHy\fIa\fHC\fHR\fH{\fHR\fHk\fHM\fH@\fHR\fH\\\fIk\fHy\fHS\fHT\fIl\fHJ\fHS\fHC\fHR\fHF\fHU\fH^\fIk\fHT\fHS\fHn\fHU\fHA\fHR\fH\\\fHH\fHi\fHF\fHD\fIl\fHY\fHR\fH^\fIk\fHT\fIk\fHY\fHR\fHy\fH\\\fHH\fIk\fHB\fIk\fH\\\fIk\fHU\fIg\fHD\fIk\fHT\fHy\fHH\fIk\fH@\fHU\fIm\fHH\fHT\fHR\fHk\fHs\fHU\fIg\fH{\fHR\fHp\fHR\fHD\fIk\fHB\fHS\fHD\fHs\fHy\fH\\\fHH\fHR\fHy\fH\\\fHD\fHR\fHe\fHD\fHy\fIk\fHC\fHU\fHR\fHm\fHT\fH@\fHT\fIk\fHA\fHR\fH[\fHR\fHj\fHF\fHy\fIk\fH^\fHS\fHC\fIk\fHZ\fIm\fH\\\fIn\fHk\fHT\fHy\fIk\fHt\fHn\fHs\fIk\fHB\fIk\fH\\\fIl\fHT\fHy\fHH\fHR\fHB\fIk\fH\\\fHR\fH^\fIk\fHy\fH\\\fHi\fHK\fHS\fHy\fHi\fHF\fHD\fHR\fHT\fHB\fHR\fHp\fHB\fIm\fHq\fIk\fHy\fHR\fH\\\fHO\fHU\fIg\fHH\fHR\fHy\fHM\fHP\fIl\fHC\fHU\fHR\fHn\fHU\fIg\fHs\fH^\fHZ\fH@\fIa\fHJ\fH^\fHS\fHC\fHR\fHp\fIl\fHY\fHD\fHp\fHR\fHH\fHR\fHy\fId\fHT\fIk\fHj\fHF\fHy\fHR\fHY\fHR\fH^\fIl\fHJ\fIk\fHD\fIk\fHF\fIn\fH\\\fIl\fHF\fHR\fHD\fIl\fHe\fHT\fHy\fIk\fHU\fIg\fH{\fIl\fH@\fId\fHL\fHy\fHj\fHF\fHy\fIl\fHY\fH\\\fIa\fH[\fH{\fHR\fHn\fHY\fHj\fHF\fHy\fIg\fHp\fHS\fH^\fHR\fHp\fHR\fHD\fHR\fHT\fHU\fHB\fHH\fHU\fHB\fIk\fHn\fHe\fHD\fHy\fIl\fHC\fHR\fHU\fIn\fHJ\fH\\\fIa\fHp\fHT\fIn\fHv\fIl\fHF\fHT\fHn\fHJ\fHT\fHY\fHR\fH^\fHU\fIg\fHD\fHR\fHU\fIg\fHH\fIl\fHp\fId\fHT\fIk\fHY\fHR\fHF\fHT\fHp\fHD\fHH\fHR\fHD\fIk\fHH\fHR\fHp\fHR\fH\\\fIl\fHt\fHR\fHC\fH^\fHp\fHS\fH^\fIk\fHD\fIl\fHv\fIk\fHp\fHR\fHn\fHv\fHF\fHH\fIa\fH\\\fH{\fIn\fH{\fH^\fHp\fHR\fHH\fIk\fH@\fHR\fHU\fH\\\fHj\fHF\fHD\fIk\fHY\fHR\fHU\fHD\fHk\fHT\fHy\fHR\fHT\fIm\fH@\fHU\fH\\\fHU\fHD\fIk\fHk\fHT\fHT\fIk\fHT\fHU\fHS\fHH\fH@\fHM\fHP\fIk\fHt\fHs\fHD\fHR\fHH\fH^\fHR\fHZ\fHF\fHR\fHn\fHv\fHZ\fIa\fH\\\fIl\fH@\fHM\fHP\fIl\fHU\fIg\fHH\fIk\fHT\fHR\fHd\fHs\fHZ\fHR\fHC\fHJ\fHT\fHy\fHH\fIl\fHp\fHR\fHH\fIl\fHY\fHR\fH^\fHR\fHU\fHp\fHR\fH\\\fHF\fHs\fHD\fHR\fH\\\fHz\fHD\fIk\fHT\fHM\fHP\fHy\fHB\fHS\fH^\fHR\fHe\fHT\fHy\fIl\fHy\fIk\fHY\fH^\fH^\fH{\fHH\fHR\fHz\fHR\fHD\fHR\fHi\fH\\\fIa\fHI\fHp\fHU\fHR\fHn\fHJ\fIk\fHz\fHR\fHF\fHU\fH^\fIl\fHD\fHS\fHC\fHB\fH@\fHS\fHD\fHR\fH@\fId\fHn\fHy\fHy\fHU\fIl\fHn\fHy\fHU\fHD\fHR\fHJ\fIk\fHH\fHR\fHU\fHB\fH^\fIk\fHy\fHR\fHG\fIl\fHp\fH@\fHy\fHS\fHH\fIm\fH\\\fHH\fHB\fHR\fHn\fH{\fHY\fHU\fIl\fHn\fH\\\fIg\fHp\fHP\fHB\fHS\fH^\fIl\fHj\fH\\\fIg\fHF\fHT\fIk\fHD\fHR\fHC\fHR\fHJ\fHY\fH^\fIk\fHD\fIk\fHz\fHR\fHH\fHR\fHy\fH\\\fIl\fH@\fHe\fHD\fHy\fHR\fHp\fHY\fHR\fH@\fHF\fIn\fH\\\fHR\fH@\fHM\fHP\fHR\fHT\fI`\fHJ\fHR\fHZ\fIk\fHC\fH\\\fHy\fHS\fHC\fIk\fHy\fHU\fHR\fHn\fHi\fHy\fHT\fH\\\fH@\fHD\fHR\fHc\fHY\fHU\fHR\fHn\fHT\fIa\fHI\fH^\fHB\fHS\fH^\fIk\fH^\fIk\fHz\fHy\fHY\fHS\fH[\fHC\fHy\fIa\fH\\\fHn\fHT\fHB\fIn\fHU\fHI\fHR\fHD\fHR4F4_4F4[5f4U5i4X4K4]5o4E4D5d4K4_4[4E4K5h4Y5m4A4E5i5d4K4Z5f4U4K5h4B4K4Y4E4K5h5i4^5f4C4K5h4U4K5i4E4K5h5o4K4F4D4K5h4]4C5d4C4D4]5j4K5i4@4K5h4C5d5h4E4K5h4U4K5h5i4K5h5i5d5n4U4K5h4U4]4D5f4K5h4_4]5f4U4K5h4@5d4K5h4K5h4\\5k4K4D4K5h4A5f4K4E4K5h4A5n5d5n4K5h5o4]5f5i4K5h4U4]4K5n5i4A5m5d4T4E4K5h4G4K5j5f5i4X4K5k4C4E4K5h5i4]4O4E4K5h5n4]4N5j4K5h4X4D4K4D4K5h4A5d4K4]4K5h4@4C5f4C4K5h4O4_4]4E4K5h4U5h5d5i5i4@5i5d4U4E4K5h4]4A5i5j4K5h5j5n4K4[5m5h4_4[5f5j4K5h5o5d5f4F4K5h4C5j5f4K4D4]5o4K4F5k4K5h4]5f4K4Z4F4A5f4K4F5f4D4F5d5n5f4F4K5h4O5d5h5e4K5h4D4]5f4C4K5h5o5h4K5i4K5h4]4K4D4[4K5h4X4B4Y5f4_5f4K4]4K4F4K5h4G4K5h4G4K5h4Y5h4K4E4K5h4A4C5f4G4K5h4^5d4K4]4K5h4B5h5f4@4K5h4@5i5f4U4K5h4U4K5i5k4K5h4@5i4K5h4K5h4_4K4U4E5i4X4K5k4C5k4K5h4]4J5f4_4K5h4C4B5d5h4K5h5m5j5f4E4K5h5o4F4K4D4K5h4C5d4]5f4K5h4C4]5d4_4K4_4F4V4]5n4F4Y4K5i5f5i4K5h4D5j4K4F4K5h4U4T5f5ifmwfqwbjmnfmwvmgfqpwbmgjmd#>#evm`wjlm+*-isd!#tjgwk>!`lmejdvqbwjlm-smd!#tjgwk>!?algz#`obpp>!Nbwk-qbmgln+*`lmwfnslqbqz#Vmjwfg#Pwbwfp`jq`vnpwbm`fp-bssfmg@kjog+lqdbmjybwjlmp?psbm#`obpp>!!=?jnd#pq`>!,gjpwjmdvjpkfgwklvpbmgp#le#`lnnvmj`bwjlm`ofbq!=?,gju=jmufpwjdbwjlmebuj`lm-j`l!#nbqdjm.qjdkw9abpfg#lm#wkf#Nbppb`kvpfwwpwbaof#alqgfq>jmwfqmbwjlmbobopl#hmltm#bpsqlmvm`jbwjlmab`hdqlvmg9 esbggjmd.ofew9Elq#f{bnsof/#njp`foobmflvp%ow8,nbwk%dw8spz`kloldj`bojm#sbqwj`vobqfbq`k!#wzsf>!elqn#nfwklg>!bp#lsslpfg#wlPvsqfnf#@lvqwl``bpjlmbooz#Bggjwjlmbooz/Mlqwk#Bnfqj`bs{8ab`hdqlvmglsslqwvmjwjfpFmwfqwbjmnfmw-wlOltfq@bpf+nbmveb`wvqjmdsqlefppjlmbo#`lnajmfg#tjwkElq#jmpwbm`f/`lmpjpwjmd#le!#nb{ofmdwk>!qfwvqm#ebopf8`lmp`jlvpmfppNfgjwfqqbmfbmf{wqblqgjmbqzbppbppjmbwjlmpvapfrvfmwoz#avwwlm#wzsf>!wkf#mvnafq#lewkf#lqjdjmbo#`lnsqfkfmpjufqfefqp#wl#wkf?,vo= ?,gju= skjolplskj`bool`bwjlm-kqfetbp#svaojpkfgPbm#Eqbm`jp`l+evm`wjlm+*x ?gju#jg>!nbjmplskjpwj`bwfgnbwkfnbwj`bo#,kfbg= ?algzpvddfpwp#wkbwgl`vnfmwbwjlm`lm`fmwqbwjlmqfobwjlmpkjspnbz#kbuf#affm+elq#f{bnsof/Wkjp#bqwj`of#jm#plnf#`bpfpsbqwp#le#wkf#gfejmjwjlm#leDqfbw#Aqjwbjm#`foosbggjmd>frvjubofmw#wlsob`fklogfq>!8#elmw.pjyf9#ivpwjej`bwjlmafojfufg#wkbwpveefqfg#eqlnbwwfnswfg#wl#ofbgfq#le#wkf`qjsw!#pq`>!,+evm`wjlm+*#xbqf#bubjobaof \n?ojmh#qfo>!#pq`>$kwws9,,jmwfqfpwfg#jm`lmufmwjlmbo#!#bow>!!#,=?,bqf#dfmfqboozkbp#bopl#affmnlpw#slsvobq#`lqqfpslmgjmd`qfgjwfg#tjwkwzof>!alqgfq9?,b=?,psbm=?,-dje!#tjgwk>!?jeqbnf#pq`>!wbaof#`obpp>!jmojmf.aol`h8b``lqgjmd#wl#wldfwkfq#tjwkbssql{jnbwfozsbqojbnfmwbqznlqf#bmg#nlqfgjpsobz9mlmf8wqbgjwjlmboozsqfglnjmbmwoz%maps8\x7F%maps8%maps8?,psbm=#`foopsb`jmd>?jmsvw#mbnf>!lq!#`lmwfmw>!`lmwqlufqpjbosqlsfqwz>!ld9,{.pkl`htbuf.gfnlmpwqbwjlmpvqqlvmgfg#azMfufqwkfofpp/tbp#wkf#ejqpw`lmpjgfqbaof#Bowklvdk#wkf#`loobalqbwjlmpklvog#mlw#afsqlslqwjlm#le?psbm#pwzof>!hmltm#bp#wkf#pklqwoz#bewfqelq#jmpwbm`f/gfp`qjafg#bp#,kfbg= ?algz#pwbqwjmd#tjwkjm`qfbpjmdoz#wkf#eb`w#wkbwgjp`vppjlm#lenjggof#le#wkfbm#jmgjujgvbogjeej`vow#wl#sljmw#le#ujftklnlpf{vbojwzb``fswbm`f#le?,psbm=?,gju=nbmveb`wvqfqplqjdjm#le#wkf`lnnlmoz#vpfgjnslqwbm`f#legfmlnjmbwjlmpab`hdqlvmg9# ofmdwk#le#wkfgfwfqnjmbwjlmb#pjdmjej`bmw!#alqgfq>!3!=qfulovwjlmbqzsqjm`jsofp#lejp#`lmpjgfqfgtbp#gfufolsfgJmgl.Fvqlsfbmuvomfqbaof#wlsqlslmfmwp#lebqf#plnfwjnfp`olpfq#wl#wkfMft#Zlqh#@jwz#mbnf>!pfbq`kbwwqjavwfg#wl`lvqpf#le#wkfnbwkfnbwj`jbmaz#wkf#fmg#lebw#wkf#fmg#le!#alqgfq>!3!#wf`kmloldj`bo-qfnluf@obpp+aqbm`k#le#wkffujgfm`f#wkbw"Xfmgje^..= Jmpwjwvwf#le#jmwl#b#pjmdofqfpsf`wjufoz-bmg#wkfqfelqfsqlsfqwjfp#lejp#ol`bwfg#jmplnf#le#tkj`kWkfqf#jp#bopl`lmwjmvfg#wl#bssfbqbm`f#le#%bns8mgbpk8#gfp`qjafp#wkf`lmpjgfqbwjlmbvwklq#le#wkfjmgfsfmgfmwozfrvjssfg#tjwkglfp#mlw#kbuf?,b=?b#kqfe>!`lmevpfg#tjwk?ojmh#kqfe>!,bw#wkf#bdf#lebssfbq#jm#wkfWkfpf#jm`ovgfqfdbqgofpp#le`lvog#af#vpfg#pwzof>%rvlw8pfufqbo#wjnfpqfsqfpfmw#wkfalgz= ?,kwno=wklvdkw#wl#afslsvobwjlm#leslppjajojwjfpsfq`fmwbdf#leb``fpp#wl#wkfbm#bwwfnsw#wlsqlgv`wjlm#leirvfqz,irvfqzwtl#gjeefqfmwafolmd#wl#wkffpwbaojpknfmwqfsob`jmd#wkfgfp`qjswjlm!#gfwfqnjmf#wkfbubjobaof#elqB``lqgjmd#wl#tjgf#qbmdf#le\n?gju#`obpp>!nlqf#`lnnlmozlqdbmjpbwjlmpevm`wjlmbojwztbp#`lnsofwfg#%bns8ngbpk8#sbqwj`jsbwjlmwkf#`kbqb`wfqbm#bggjwjlmbobssfbqp#wl#afeb`w#wkbw#wkfbm#f{bnsof#lepjdmjej`bmwozlmnlvpflufq>!af`bvpf#wkfz#bpzm`#>#wqvf8sqlaofnp#tjwkpffnp#wl#kbufwkf#qfpvow#le#pq`>!kwws9,,ebnjojbq#tjwkslppfppjlm#leevm`wjlm#+*#xwllh#sob`f#jmbmg#plnfwjnfppvapwbmwjbooz?psbm=?,psbm=jp#lewfm#vpfgjm#bm#bwwfnswdqfbw#gfbo#leFmujqlmnfmwbopv``fppevooz#ujqwvbooz#boo13wk#`fmwvqz/sqlefppjlmbopmf`fppbqz#wl#gfwfqnjmfg#az`lnsbwjajojwzaf`bvpf#jw#jpGj`wjlmbqz#lenlgjej`bwjlmpWkf#elooltjmdnbz#qfefq#wl9@lmpfrvfmwoz/Jmwfqmbwjlmbobowklvdk#plnfwkbw#tlvog#aftlqog$p#ejqpw`obppjejfg#bpalwwln#le#wkf+sbqwj`vobqozbojdm>!ofew!#nlpw#`lnnlmozabpjp#elq#wkfelvmgbwjlm#le`lmwqjavwjlmpslsvobqjwz#le`fmwfq#le#wkfwl#qfgv`f#wkfivqjpgj`wjlmpbssql{jnbwjlm#lmnlvpflvw>!Mft#Wfpwbnfmw`loof`wjlm#le?,psbm=?,b=?,jm#wkf#Vmjwfgejon#gjqf`wlq.pwqj`w-gwg!=kbp#affm#vpfgqfwvqm#wl#wkfbowklvdk#wkjp`kbmdf#jm#wkfpfufqbo#lwkfqavw#wkfqf#bqfvmsqf`fgfmwfgjp#pjnjobq#wlfpsf`jbooz#jmtfjdkw9#alog8jp#`boofg#wkf`lnsvwbwjlmbojmgj`bwf#wkbwqfpwqj`wfg#wl\n?nfwb#mbnf>!bqf#wzsj`booz`lmeoj`w#tjwkKltfufq/#wkf#Bm#f{bnsof#le`lnsbqfg#tjwkrvbmwjwjfp#leqbwkfq#wkbm#b`lmpwfoobwjlmmf`fppbqz#elqqfslqwfg#wkbwpsf`jej`bwjlmslojwj`bo#bmg%maps8%maps8?qfefqfm`fp#wlwkf#pbnf#zfbqDlufqmnfmw#ledfmfqbwjlm#lekbuf#mlw#affmpfufqbo#zfbqp`lnnjwnfmw#wl\n\n?vo#`obpp>!ujpvbojybwjlm2:wk#`fmwvqz/sqb`wjwjlmfqpwkbw#kf#tlvogbmg#`lmwjmvfgl``vsbwjlm#lejp#gfejmfg#bp`fmwqf#le#wkfwkf#bnlvmw#le=?gju#pwzof>!frvjubofmw#legjeefqfmwjbwfaqlvdkw#balvwnbqdjm.ofew9#bvwlnbwj`boozwklvdkw#le#bpPlnf#le#wkfpf ?gju#`obpp>!jmsvw#`obpp>!qfsob`fg#tjwkjp#lmf#le#wkffgv`bwjlm#bmgjmeovfm`fg#azqfsvwbwjlm#bp ?nfwb#mbnf>!b``lnnlgbwjlm?,gju= ?,gju=obqdf#sbqw#leJmpwjwvwf#elqwkf#pl.`boofg#bdbjmpw#wkf#Jm#wkjp#`bpf/tbp#bssljmwfg`objnfg#wl#afKltfufq/#wkjpGfsbqwnfmw#lewkf#qfnbjmjmdfeef`w#lm#wkfsbqwj`vobqoz#gfbo#tjwk#wkf ?gju#pwzof>!bonlpw#botbzpbqf#`vqqfmwozf{sqfppjlm#leskjolplskz#leelq#nlqf#wkbm`jujojybwjlmplm#wkf#jpobmgpfof`wfgJmgf{`bm#qfpvow#jm!#ubovf>!!#,=wkf#pwqv`wvqf#,=?,b=?,gju=Nbmz#le#wkfpf`bvpfg#az#wkfle#wkf#Vmjwfgpsbm#`obpp>!n`bm#af#wqb`fgjp#qfobwfg#wlaf`bnf#lmf#lejp#eqfrvfmwozojujmd#jm#wkfwkflqfwj`boozElooltjmd#wkfQfulovwjlmbqzdlufqmnfmw#jmjp#gfwfqnjmfgwkf#slojwj`bojmwqlgv`fg#jmpveej`jfmw#wlgfp`qjswjlm!=pklqw#pwlqjfppfsbqbwjlm#lebp#wl#tkfwkfqhmltm#elq#jwptbp#jmjwjboozgjpsobz9aol`hjp#bm#f{bnsofwkf#sqjm`jsbo`lmpjpwp#le#bqf`ldmjyfg#bp,algz=?,kwno=b#pvapwbmwjboqf`lmpwqv`wfgkfbg#le#pwbwfqfpjpwbm`f#wlvmgfqdqbgvbwfWkfqf#bqf#wtldqbujwbwjlmbobqf#gfp`qjafgjmwfmwjlmboozpfqufg#bp#wkf`obpp>!kfbgfqlsslpjwjlm#wlevmgbnfmwboozglnjmbwfg#wkfbmg#wkf#lwkfqboojbm`f#tjwktbp#elq`fg#wlqfpsf`wjufoz/bmg#slojwj`bojm#pvsslqw#lesflsof#jm#wkf13wk#`fmwvqz-bmg#svaojpkfgolbg@kbqwafbwwl#vmgfqpwbmgnfnafq#pwbwfpfmujqlmnfmwboejqpw#kboe#le`lvmwqjfp#bmgbq`kjwf`wvqboaf#`lmpjgfqfg`kbqb`wfqjyfg`ofbqJmwfqubobvwklqjwbwjufEfgfqbwjlm#letbp#pv``ffgfgbmg#wkfqf#bqfb#`lmpfrvfm`fwkf#Sqfpjgfmwbopl#jm`ovgfgeqff#plewtbqfpv``fppjlm#legfufolsfg#wkftbp#gfpwqlzfgbtbz#eqln#wkf8 ?,p`qjsw= ?bowklvdk#wkfzelooltfg#az#bnlqf#sltfqevoqfpvowfg#jm#bVmjufqpjwz#leKltfufq/#nbmzwkf#sqfpjgfmwKltfufq/#plnfjp#wklvdkw#wlvmwjo#wkf#fmgtbp#bmmlvm`fgbqf#jnslqwbmwbopl#jm`ovgfp=?jmsvw#wzsf>wkf#`fmwfq#le#GL#MLW#BOWFQvpfg#wl#qfefqwkfnfp,<plqw>wkbw#kbg#affmwkf#abpjp#elqkbp#gfufolsfgjm#wkf#pvnnfq`lnsbqbwjufozgfp`qjafg#wkfpv`k#bp#wklpfwkf#qfpvowjmdjp#jnslppjaofubqjlvp#lwkfqPlvwk#Beqj`bmkbuf#wkf#pbnffeef`wjufmfppjm#tkj`k#`bpf8#wf{w.bojdm9pwqv`wvqf#bmg8#ab`hdqlvmg9qfdbqgjmd#wkfpvsslqwfg#wkfjp#bopl#hmltmpwzof>!nbqdjmjm`ovgjmd#wkfabkbpb#Nfobzvmlqph#alhn/Iomlqph#mzmlqphpolufm)M(ajmbjmwfqmb`jlmbo`bojej`b`j/_m`lnvmj`b`j/_m`lmpwqv``j/_m!=?gju#`obpp>!gjpbnajdvbwjlmGlnbjmMbnf$/#$bgnjmjpwqbwjlmpjnvowbmflvpozwqbmpslqwbwjlmJmwfqmbwjlmbo#nbqdjm.alwwln9qfpslmpjajojwz?"Xfmgje^..= ?,=?nfwb#mbnf>!jnsofnfmwbwjlmjmeqbpwqv`wvqfqfsqfpfmwbwjlmalqgfq.alwwln9?,kfbg= ?algz=>kwws&0B&1E&1E?elqn#nfwklg>!nfwklg>!slpw!#,ebuj`lm-j`l!#~*8 ?,p`qjsw= -pfwBwwqjavwf+Bgnjmjpwqbwjlm>#mft#Bqqbz+*8?"Xfmgje^..= gjpsobz9aol`h8Vmelqwvmbwfoz/!=%maps8?,gju=,ebuj`lm-j`l!=>$pwzofpkffw$#jgfmwjej`bwjlm/#elq#f{bnsof/?oj=?b#kqfe>!,bm#bowfqmbwjufbp#b#qfpvow#lesw!=?,p`qjsw= wzsf>!pvanjw!# +evm`wjlm+*#xqf`lnnfmgbwjlmelqn#b`wjlm>!,wqbmpelqnbwjlmqf`lmpwqv`wjlm-pwzof-gjpsobz#B``lqgjmd#wl#kjggfm!#mbnf>!bolmd#tjwk#wkfgl`vnfmw-algz-bssql{jnbwfoz#@lnnvmj`bwjlmpslpw!#b`wjlm>!nfbmjmd#%rvlw8..?"Xfmgje^..=Sqjnf#Njmjpwfq`kbqb`wfqjpwj`?,b=#?b#`obpp>wkf#kjpwlqz#le#lmnlvpflufq>!wkf#dlufqmnfmwkqfe>!kwwsp9,,tbp#lqjdjmbooztbp#jmwqlgv`fg`obppjej`bwjlmqfsqfpfmwbwjufbqf#`lmpjgfqfg?"Xfmgje^..= gfsfmgp#lm#wkfVmjufqpjwz#le#jm#`lmwqbpw#wl#sob`fklogfq>!jm#wkf#`bpf#lejmwfqmbwjlmbo#`lmpwjwvwjlmbopwzof>!alqgfq.9#evm`wjlm+*#xAf`bvpf#le#wkf.pwqj`w-gwg!= ?wbaof#`obpp>!b``lnsbmjfg#azb``lvmw#le#wkf?p`qjsw#pq`>!,mbwvqf#le#wkf#wkf#sflsof#jm#jm#bggjwjlm#wlp*8#ip-jg#>#jg!#tjgwk>!233&!qfdbqgjmd#wkf#Qlnbm#@bwkloj`bm#jmgfsfmgfmwelooltjmd#wkf#-dje!#tjgwk>!2wkf#elooltjmd#gjp`qjnjmbwjlmbq`kbfloldj`bosqjnf#njmjpwfq-ip!=?,p`qjsw=`lnajmbwjlm#le#nbqdjmtjgwk>!`qfbwfFofnfmw+t-bwwb`kFufmw+?,b=?,wg=?,wq=pq`>!kwwsp9,,bJm#sbqwj`vobq/#bojdm>!ofew!#@yf`k#Qfsvaoj`Vmjwfg#Hjmdgln`lqqfpslmgfm`f`lm`ovgfg#wkbw-kwno!#wjwof>!+evm`wjlm#+*#x`lnfp#eqln#wkfbssoj`bwjlm#le?psbm#`obpp>!pafojfufg#wl#affnfmw+$p`qjsw$?,b= ?,oj= ?ojufqz#gjeefqfmw=?psbm#`obpp>!lswjlm#ubovf>!+bopl#hmltm#bp\n?oj=?b#kqfe>!=?jmsvw#mbnf>!pfsbqbwfg#eqlnqfefqqfg#wl#bp#ubojdm>!wls!=elvmgfq#le#wkfbwwfnswjmd#wl#`bqalm#gjl{jgf ?gju#`obpp>!`obpp>!pfbq`k.,algz= ?,kwno=lsslqwvmjwz#wl`lnnvmj`bwjlmp?,kfbg= ?algz#pwzof>!tjgwk9Wj\rVSmd#Uj\rWkw`kbmdfp#jm#wkfalqgfq.`lolq9 3!#alqgfq>!3!#?,psbm=?,gju=?tbp#gjp`lufqfg!#wzsf>!wf{w!#*8 ?,p`qjsw= Gfsbqwnfmw#le#f``ofpjbpwj`bowkfqf#kbp#affmqfpvowjmd#eqln?,algz=?,kwno=kbp#mfufq#affmwkf#ejqpw#wjnfjm#qfpslmpf#wlbvwlnbwj`booz#?,gju= ?gju#jtbp#`lmpjgfqfgsfq`fmw#le#wkf!#,=?,b=?,gju=`loof`wjlm#le#gfp`fmgfg#eqlnpf`wjlm#le#wkfb``fsw.`kbqpfwwl#af#`lmevpfgnfnafq#le#wkf#sbggjmd.qjdkw9wqbmpobwjlm#lejmwfqsqfwbwjlm#kqfe>$kwws9,,tkfwkfq#lq#mlwWkfqf#bqf#boplwkfqf#bqf#nbmzb#pnboo#mvnafqlwkfq#sbqwp#lejnslppjaof#wl##`obpp>!avwwlmol`bwfg#jm#wkf-#Kltfufq/#wkfbmg#fufmwvboozBw#wkf#fmg#le#af`bvpf#le#jwpqfsqfpfmwp#wkf?elqn#b`wjlm>!#nfwklg>!slpw!jw#jp#slppjaofnlqf#ojhfoz#wlbm#jm`qfbpf#jmkbuf#bopl#affm`lqqfpslmgp#wlbmmlvm`fg#wkbwbojdm>!qjdkw!=nbmz#`lvmwqjfpelq#nbmz#zfbqpfbqojfpw#hmltmaf`bvpf#jw#tbpsw!=?,p`qjsw=#ubojdm>!wls!#jmkbajwbmwp#leelooltjmd#zfbq ?gju#`obpp>!njoojlm#sflsof`lmwqlufqpjbo#`lm`fqmjmd#wkfbqdvf#wkbw#wkfdlufqmnfmw#bmgb#qfefqfm`f#wlwqbmpefqqfg#wlgfp`qjajmd#wkf#pwzof>!`lolq9bowklvdk#wkfqfafpw#hmltm#elqpvanjw!#mbnf>!nvowjsoj`bwjlmnlqf#wkbm#lmf#qf`ldmjwjlm#le@lvm`jo#le#wkffgjwjlm#le#wkf##?nfwb#mbnf>!Fmwfqwbjmnfmw#btbz#eqln#wkf#8nbqdjm.qjdkw9bw#wkf#wjnf#lejmufpwjdbwjlmp`lmmf`wfg#tjwkbmg#nbmz#lwkfqbowklvdk#jw#jpafdjmmjmd#tjwk#?psbm#`obpp>!gfp`fmgbmwp#le?psbm#`obpp>!j#bojdm>!qjdkw!?,kfbg= ?algz#bpsf`wp#le#wkfkbp#pjm`f#affmFvqlsfbm#Vmjlmqfnjmjp`fmw#lenlqf#gjeej`vowUj`f#Sqfpjgfmw`lnslpjwjlm#lesbppfg#wkqlvdknlqf#jnslqwbmwelmw.pjyf922s{f{sobmbwjlm#lewkf#`lm`fsw#letqjwwfm#jm#wkf\n?psbm#`obpp>!jp#lmf#le#wkf#qfpfnaobm`f#wllm#wkf#dqlvmgptkj`k#`lmwbjmpjm`ovgjmd#wkf#gfejmfg#az#wkfsvaoj`bwjlm#lenfbmp#wkbw#wkflvwpjgf#le#wkfpvsslqw#le#wkf?jmsvw#`obpp>!?psbm#`obpp>!w+Nbwk-qbmgln+*nlpw#sqlnjmfmwgfp`qjswjlm#le@lmpwbmwjmlsoftfqf#svaojpkfg?gju#`obpp>!pfbssfbqp#jm#wkf2!#kfjdkw>!2!#nlpw#jnslqwbmwtkj`k#jm`ovgfptkj`k#kbg#affmgfpwqv`wjlm#lewkf#slsvobwjlm \n?gju#`obpp>!slppjajojwz#leplnfwjnfp#vpfgbssfbq#wl#kbufpv``fpp#le#wkfjmwfmgfg#wl#afsqfpfmw#jm#wkfpwzof>!`ofbq9a ?,p`qjsw= ?tbp#elvmgfg#jmjmwfqujft#tjwk\\jg!#`lmwfmw>!`bsjwbo#le#wkf ?ojmh#qfo>!pqfofbpf#le#wkfsljmw#lvw#wkbw{NOKwwsQfrvfpwbmg#pvapfrvfmwpf`lmg#obqdfpwufqz#jnslqwbmwpsf`jej`bwjlmppvqeb`f#le#wkfbssojfg#wl#wkfelqfjdm#sloj`z\\pfwGlnbjmMbnffpwbaojpkfg#jmjp#afojfufg#wlJm#bggjwjlm#wlnfbmjmd#le#wkfjp#mbnfg#bewfqwl#sqlwf`w#wkfjp#qfsqfpfmwfgGf`obqbwjlm#lenlqf#feej`jfmw@obppjej`bwjlmlwkfq#elqnp#lekf#qfwvqmfg#wl?psbm#`obpp>!`sfqelqnbm`f#le+evm`wjlm+*#xje#bmg#lmoz#jeqfdjlmp#le#wkfofbgjmd#wl#wkfqfobwjlmp#tjwkVmjwfg#Mbwjlmppwzof>!kfjdkw9lwkfq#wkbm#wkfzsf!#`lmwfmw>!Bppl`jbwjlm#le ?,kfbg= ?algzol`bwfg#lm#wkfjp#qfefqqfg#wl+jm`ovgjmd#wkf`lm`fmwqbwjlmpwkf#jmgjujgvbobnlmd#wkf#nlpwwkbm#bmz#lwkfq,= ?ojmh#qfo>!#qfwvqm#ebopf8wkf#svqslpf#lewkf#bajojwz#wl8`lolq9 eee~ - ?psbm#`obpp>!wkf#pvaif`w#legfejmjwjlmp#le= ?ojmh#qfo>!`objn#wkbw#wkfkbuf#gfufolsfg?wbaof#tjgwk>!`fofaqbwjlm#leElooltjmd#wkf#wl#gjpwjmdvjpk?psbm#`obpp>!awbhfp#sob`f#jmvmgfq#wkf#mbnfmlwfg#wkbw#wkf=?"Xfmgje^..= pwzof>!nbqdjm.jmpwfbg#le#wkfjmwqlgv`fg#wkfwkf#sql`fpp#lejm`qfbpjmd#wkfgjeefqfm`fp#jmfpwjnbwfg#wkbwfpsf`jbooz#wkf,gju=?gju#jg>!tbp#fufmwvboozwkqlvdklvw#kjpwkf#gjeefqfm`fplnfwkjmd#wkbwpsbm=?,psbm=?,pjdmjej`bmwoz#=?,p`qjsw=  fmujqlmnfmwbo#wl#sqfufmw#wkfkbuf#affm#vpfgfpsf`jbooz#elqvmgfqpwbmg#wkfjp#fppfmwjbooztfqf#wkf#ejqpwjp#wkf#obqdfpwkbuf#affm#nbgf!#pq`>!kwws9,,jmwfqsqfwfg#bppf`lmg#kboe#le`qloojmd>!ml!#jp#`lnslpfg#leJJ/#Kloz#Qlnbmjp#f{sf`wfg#wlkbuf#wkfjq#ltmgfejmfg#bp#wkfwqbgjwjlmbooz#kbuf#gjeefqfmwbqf#lewfm#vpfgwl#fmpvqf#wkbwbdqffnfmw#tjwk`lmwbjmjmd#wkfbqf#eqfrvfmwozjmelqnbwjlm#lmf{bnsof#jp#wkfqfpvowjmd#jm#b?,b=?,oj=?,vo=#`obpp>!ellwfqbmg#fpsf`jboozwzsf>!avwwlm!#?,psbm=?,psbm=tkj`k#jm`ovgfg= ?nfwb#mbnf>!`lmpjgfqfg#wkf`bqqjfg#lvw#azKltfufq/#jw#jpaf`bnf#sbqw#lejm#qfobwjlm#wlslsvobq#jm#wkfwkf#`bsjwbo#letbp#leej`jbooztkj`k#kbp#affmwkf#Kjpwlqz#lebowfqmbwjuf#wlgjeefqfmw#eqlnwl#pvsslqw#wkfpvddfpwfg#wkbwjm#wkf#sql`fpp##?gju#`obpp>!wkf#elvmgbwjlmaf`bvpf#le#kjp`lm`fqmfg#tjwkwkf#vmjufqpjwzlsslpfg#wl#wkfwkf#`lmwf{w#le?psbm#`obpp>!swf{w!#mbnf>!r!\n\n?gju#`obpp>!wkf#p`jfmwjej`qfsqfpfmwfg#aznbwkfnbwj`jbmpfof`wfg#az#wkfwkbw#kbuf#affm=?gju#`obpp>!`gju#jg>!kfbgfqjm#sbqwj`vobq/`lmufqwfg#jmwl*8 ?,p`qjsw= ?skjolplskj`bo#pqsphlkqubwphjwj\rVSmd#Uj\rWkw<L=o=m=m<V<T<U=l=o=m=m<V<T<Ujmufpwjdb`j/_msbqwj`jsb`j/_m<V<R=n<R=l=g<Y<R<]<W<\\=m=n<T<V<R=n<R=l=g<U=k<Y<W<R<^<Y<V=m<T=m=n<Y<P=g<q<R<^<R=m=n<T<V<R=n<R=l=g=i<R<]<W<\\=m=n=`<^=l<Y<P<Y<Q<T<V<R=n<R=l<\\=c=m<Y<_<R<X<Q=c=m<V<\\=k<\\=n=`<Q<R<^<R=m=n<T<O<V=l<\\<T<Q=g<^<R<S=l<R=m=g<V<R=n<R=l<R<U=m<X<Y<W<\\=n=`<S<R<P<R=e=`=b=m=l<Y<X=m=n<^<R<]=l<\\<[<R<P=m=n<R=l<R<Q=g=o=k<\\=m=n<T<Y=n<Y=k<Y<Q<T<Y<\x7F<W<\\<^<Q<\\=c<T=m=n<R=l<T<T=m<T=m=n<Y<P<\\=l<Y=d<Y<Q<T=c<M<V<\\=k<\\=n=`<S<R=a=n<R<P=o=m<W<Y<X=o<Y=n=m<V<\\<[<\\=n=`=n<R<^<\\=l<R<^<V<R<Q<Y=k<Q<R=l<Y=d<Y<Q<T<Y<V<R=n<R=l<R<Y<R=l<_<\\<Q<R<^<V<R=n<R=l<R<P<L<Y<V<W<\\<P<\\4K5h5i5j4F4C5e5i5j4F4C5f4K4F4K5h5i5d4Z5d4U4K5h4D4]4K5i4@4K5h5i5d4K5n4U4K5h4]4_4K4J5h5i4X4K4]5o4K4F4K5h4O4U4Z4K4M4K5h4]5f4K4Z4E4K5h4F4Y5i5f5i4K5h4K4U4Z4K4M4K5h5j4F4K4J4@4K5h4O5h4U4K4D4K5h4F4_4@5f5h4K5h4O5n4_4K5i4K5h4Z4V4[4K4F4K5h5m5f4C5f5d4K5h4F4]4A5f4D4K5h4@4C5f4C4E4K5h4F4U5h5f5i4K5h4O4B4D4K4]4K5h4K5m5h4K5i4K5h4O5m5h4K5i4K5h4F4K4]5f4B4K5h4F5n5j5f4E4K5h4K5h4U4K4D4K5h4B5d4K4[4]4K5h5i4@4F5i4U4K5h4C5f5o5d4]4K5h4_5f4K4A4E4U4D4C4K5h5h5k4K5h4F4]4D5f4E4K5h4]5d4K4D4[4K5h4O4C4D5f4E4K5h4K4B4D4K4]4K5h5i4F4A4C4E4K5h4K4V4K5j5f`vqplq9sljmwfq8?,wjwof= ?nfwb#!#kqfe>!kwws9,,!=?psbm#`obpp>!nfnafqp#le#wkf#tjmglt-ol`bwjlmufqwj`bo.bojdm9,b=#\x7F#?b#kqfe>!?"gl`wzsf#kwno=nfgjb>!p`qffm!#?lswjlm#ubovf>!ebuj`lm-j`l!#,= \n\n?gju#`obpp>!`kbqb`wfqjpwj`p!#nfwklg>!dfw!#,algz= ?,kwno= pklqw`vw#j`lm!#gl`vnfmw-tqjwf+sbggjmd.alwwln9qfsqfpfmwbwjufppvanjw!#ubovf>!bojdm>!`fmwfq!#wkqlvdklvw#wkf#p`jfm`f#ej`wjlm ##?gju#`obpp>!pvanjw!#`obpp>!lmf#le#wkf#nlpw#ubojdm>!wls!=?tbp#fpwbaojpkfg*8 ?,p`qjsw= qfwvqm#ebopf8!=*-pwzof-gjpsobzaf`bvpf#le#wkf#gl`vnfmw-`llhjf?elqn#b`wjlm>!,~algzxnbqdjm938Fm`z`olsfgjb#leufqpjlm#le#wkf#-`qfbwfFofnfmw+mbnf!#`lmwfmw>!?,gju= ?,gju= bgnjmjpwqbwjuf#?,algz= ?,kwno=kjpwlqz#le#wkf#!=?jmsvw#wzsf>!slqwjlm#le#wkf#bp#sbqw#le#wkf#%maps8?b#kqfe>!lwkfq#`lvmwqjfp!= ?gju#`obpp>!?,psbm=?,psbm=?Jm#lwkfq#tlqgp/gjpsobz9#aol`h8`lmwqlo#le#wkf#jmwqlgv`wjlm#le,= ?nfwb#mbnf>!bp#tfoo#bp#wkf#jm#qf`fmw#zfbqp \n?gju#`obpp>!?,gju= \n?,gju= jmpsjqfg#az#wkfwkf#fmg#le#wkf#`lnsbwjaof#tjwkaf`bnf#hmltm#bp#pwzof>!nbqdjm9-ip!=?,p`qjsw=?#Jmwfqmbwjlmbo#wkfqf#kbuf#affmDfqnbm#obmdvbdf#pwzof>!`lolq9 @lnnvmjpw#Sbqwz`lmpjpwfmw#tjwkalqgfq>!3!#`foo#nbqdjmkfjdkw>!wkf#nbilqjwz#le!#bojdm>!`fmwfqqfobwfg#wl#wkf#nbmz#gjeefqfmw#Lqwklgl{#@kvq`kpjnjobq#wl#wkf#,= ?ojmh#qfo>!ptbp#lmf#le#wkf#vmwjo#kjp#gfbwk~*+*8 ?,p`qjsw=lwkfq#obmdvbdfp`lnsbqfg#wl#wkfslqwjlmp#le#wkfwkf#Mfwkfqobmgpwkf#nlpw#`lnnlmab`hdqlvmg9vqo+bqdvfg#wkbw#wkfp`qloojmd>!ml!#jm`ovgfg#jm#wkfMlqwk#Bnfqj`bm#wkf#mbnf#le#wkfjmwfqsqfwbwjlmpwkf#wqbgjwjlmbogfufolsnfmw#le#eqfrvfmwoz#vpfgb#`loof`wjlm#leufqz#pjnjobq#wlpvqqlvmgjmd#wkff{bnsof#le#wkjpbojdm>!`fmwfq!=tlvog#kbuf#affmjnbdf\\`bswjlm#>bwwb`kfg#wl#wkfpvddfpwjmd#wkbwjm#wkf#elqn#le#jmuloufg#jm#wkfjp#gfqjufg#eqlnmbnfg#bewfq#wkfJmwqlgv`wjlm#wlqfpwqj`wjlmp#lm#pwzof>!tjgwk9#`bm#af#vpfg#wl#wkf#`qfbwjlm#lenlpw#jnslqwbmw#jmelqnbwjlm#bmgqfpvowfg#jm#wkf`loobspf#le#wkfWkjp#nfbmp#wkbwfofnfmwp#le#wkftbp#qfsob`fg#azbmbozpjp#le#wkfjmpsjqbwjlm#elqqfdbqgfg#bp#wkfnlpw#pv``fppevohmltm#bp#%rvlw8b#`lnsqfkfmpjufKjpwlqz#le#wkf#tfqf#`lmpjgfqfgqfwvqmfg#wl#wkfbqf#qfefqqfg#wlVmplvq`fg#jnbdf= \n?gju#`obpp>!`lmpjpwp#le#wkfpwlsSqlsbdbwjlmjmwfqfpw#jm#wkfbubjobajojwz#lebssfbqp#wl#kbuffof`wqlnbdmfwj`fmbaofPfquj`fp+evm`wjlm#le#wkfJw#jp#jnslqwbmw?,p`qjsw=?,gju=evm`wjlm+*xubq#qfobwjuf#wl#wkfbp#b#qfpvow#le#wkf#slpjwjlm#leElq#f{bnsof/#jm#nfwklg>!slpw!#tbp#elooltfg#az%bns8ngbpk8#wkfwkf#bssoj`bwjlmip!=?,p`qjsw= vo=?,gju=?,gju=bewfq#wkf#gfbwktjwk#qfpsf`w#wlpwzof>!sbggjmd9jp#sbqwj`vobqozgjpsobz9jmojmf8#wzsf>!pvanjw!#jp#gjujgfg#jmwl\bTA\nzk#+\vBl\bQ\x7F*qfpslmpbajojgbgbgnjmjpwqb`j/_mjmwfqmb`jlmbofp`lqqfpslmgjfmwf\fHe\fHF\fHC\fIg\fH{\fHF\fIn\fH\\\fIa\fHY\fHU\fHB\fHR\fH\\\fIk\fH^\fIg\fH{\fIg\fHn\fHv\fIm\fHD\fHR\fHY\fH^\fIk\fHy\fHS\fHD\fHT\fH\\\fHy\fHR\fH\\\fHF\fIm\fH^\fHS\fHT\fHz\fIg\fHp\fIk\fHn\fHv\fHR\fHU\fHS\fHc\fHA\fIk\fHp\fIk\fHn\fHZ\fHR\fHB\fHS\fH^\fHU\fHB\fHR\fH\\\fIl\fHp\fHR\fH{\fH\\\fHO\fH@\fHD\fHR\fHD\fIk\fHy\fIm\fHB\fHR\fH\\\fH@\fIa\fH^\fIe\fH{\fHB\fHR\fH^\fHS\fHy\fHB\fHU\fHS\fH^\fHR\fHF\fIo\fH[\fIa\fHL\fH@\fHN\fHP\fHH\fIk\fHA\fHR\fHp\fHF\fHR\fHy\fIa\fH^\fHS\fHy\fHs\fIa\fH\\\fIk\fHD\fHz\fHS\fH^\fHR\fHG\fHJ\fI`\fH\\\fHR\fHD\fHB\fHR\fHB\fH^\fIk\fHB\fHH\fHJ\fHR\fHD\fH@\fHR\fHp\fHR\fH\\\fHY\fHS\fHy\fHR\fHT\fHy\fIa\fHC\fIg\fHn\fHv\fHR\fHU\fHH\fIk\fHF\fHU\fIm\fHm\fHv\fH@\fHH\fHR\fHC\fHR\fHT\fHn\fHY\fHR\fHJ\fHJ\fIk\fHz\fHD\fIk\fHF\fHS\fHw\fH^\fIk\fHY\fHS\fHZ\fIk\fH[\fH\\\fHR\fHp\fIa\fHC\fHe\fHH\fIa\fHH\fH\\\fHB\fIm\fHn\fH@\fHd\fHJ\fIg\fHD\fIg\fHn\fHe\fHF\fHy\fH\\\fHO\fHF\fHN\fHP\fIk\fHn\fHT\fIa\fHI\fHS\fHH\fHG\fHS\fH^\fIa\fHB\fHB\fIm\fHz\fIa\fHC\fHi\fHv\fIa\fHw\fHR\fHw\fIn\fHs\fHH\fIl\fHT\fHn\fH{\fIl\fHH\fHp\fHR\fHc\fH{\fHR\fHY\fHS\fHA\fHR\fH{\fHt\fHO\fIa\fHs\fIk\fHJ\fIn\fHT\fH\\\fIk\fHJ\fHS\fHD\fIg\fHn\fHU\fHH\fIa\fHC\fHR\fHT\fIk\fHy\fIa\fHT\fH{\fHR\fHn\fHK\fIl\fHY\fHS\fHZ\fIa\fHY\fH\\\fHR\fHH\fIk\fHn\fHJ\fId\fHs\fIa\fHT\fHD\fHy\fIa\fHZ\fHR\fHT\fHR\fHB\fHD\fIk\fHi\fHJ\fHR\fH^\fHH\fH@\fHS\fHp\fH^\fIl\fHF\fIm\fH\\\fIn\fH[\fHU\fHS\fHn\fHJ\fIl\fHB\fHS\fHH\fIa\fH\\\fHy\fHY\fHS\fHH\fHR\fH\\\fIm\fHF\fHC\fIk\fHT\fIa\fHI\fHR\fHD\fHy\fH\\\fIg\fHM\fHP\fHB\fIm\fHy\fIa\fHH\fHC\fIg\fHp\fHD\fHR\fHy\fIo\fHF\fHC\fHR\fHF\fIg\fHT\fIa\fHs\fHt\fH\\\fIk\fH^\fIn\fHy\fHR\fH\\\fIa\fHC\fHY\fHS\fHv\fHR\fH\\\fHT\fIn\fHv\fHD\fHR\fHB\fIn\fH^\fIa\fHC\fHJ\fIk\fHz\fIk\fHn\fHU\fHB\fIk\fHZ\fHR\fHT\fIa\fHy\fIn\fH^\fHB\fId\fHn\fHD\fIk\fHH\fId\fHC\fHR\fH\\\fHp\fHS\fHT\fHy\fIkqpp({no!#wjwof>!.wzsf!#`lmwfmw>!wjwof!#`lmwfmw>!bw#wkf#pbnf#wjnf-ip!=?,p`qjsw= ?!#nfwklg>!slpw!#?,psbm=?,b=?,oj=ufqwj`bo.bojdm9w,irvfqz-njm-ip!=-`oj`h+evm`wjlm+#pwzof>!sbggjmd.~*+*8 ?,p`qjsw= ?,psbm=?b#kqfe>!?b#kqfe>!kwws9,,*8#qfwvqm#ebopf8wf{w.gf`lqbwjlm9#p`qloojmd>!ml!#alqgfq.`loobspf9bppl`jbwfg#tjwk#Abkbpb#JmglmfpjbFmdojpk#obmdvbdf?wf{w#{no9psb`f>-dje!#alqgfq>!3!?,algz= ?,kwno= lufqeolt9kjggfm8jnd#pq`>!kwws9,,bggFufmwOjpwfmfqqfpslmpjaof#elq#p-ip!=?,p`qjsw= ,ebuj`lm-j`l!#,=lsfqbwjmd#pzpwfn!#pwzof>!tjgwk92wbqdfw>!\\aobmh!=Pwbwf#Vmjufqpjwzwf{w.bojdm9ofew8 gl`vnfmw-tqjwf+/#jm`ovgjmd#wkf#bqlvmg#wkf#tlqog*8 ?,p`qjsw= ?!#pwzof>!kfjdkw98lufqeolt9kjggfmnlqf#jmelqnbwjlmbm#jmwfqmbwjlmbob#nfnafq#le#wkf#lmf#le#wkf#ejqpw`bm#af#elvmg#jm#?,gju= \n\n?,gju= gjpsobz9#mlmf8!=!#,= ?ojmh#qfo>! ##+evm`wjlm+*#xwkf#26wk#`fmwvqz-sqfufmwGfebvow+obqdf#mvnafq#le#Azybmwjmf#Fnsjqf-isd\x7Fwkvna\x7Fofew\x7Fubpw#nbilqjwz#lenbilqjwz#le#wkf##bojdm>!`fmwfq!=Vmjufqpjwz#Sqfppglnjmbwfg#az#wkfPf`lmg#Tlqog#Tbqgjpwqjavwjlm#le#pwzof>!slpjwjlm9wkf#qfpw#le#wkf#`kbqb`wfqjyfg#az#qfo>!mleloolt!=gfqjufp#eqln#wkfqbwkfq#wkbm#wkf#b#`lnajmbwjlm#lepwzof>!tjgwk9233Fmdojpk.psfbhjmd`lnsvwfq#p`jfm`falqgfq>!3!#bow>!wkf#f{jpwfm`f#leGfnl`qbwj`#Sbqwz!#pwzof>!nbqdjm.Elq#wkjp#qfbplm/-ip!=?,p`qjsw= \npAzWbdMbnf+p*X3^ip!=?,p`qjsw= ?-ip!=?,p`qjsw= ojmh#qfo>!j`lm!#$#bow>$$#`obpp>$elqnbwjlm#le#wkfufqpjlmp#le#wkf#?,b=?,gju=?,gju=,sbdf= ##?sbdf= ?gju#`obpp>!`lmwaf`bnf#wkf#ejqpwabkbpb#Jmglmfpjbfmdojpk#+pjnsof*"y"W"W"["Q"U"V"@=i=l<^<\\=n=m<V<T<V<R<P<S<\\<Q<T<T=c<^<W=c<Y=n=m=c<x<R<]<\\<^<T=n=`=k<Y<W<R<^<Y<V<\\=l<\\<[<^<T=n<T=c<t<Q=n<Y=l<Q<Y=n<r=n<^<Y=n<T=n=`<Q<\\<S=l<T<P<Y=l<T<Q=n<Y=l<Q<Y=n<V<R=n<R=l<R<_<R=m=n=l<\\<Q<T=j=g<V<\\=k<Y=m=n<^<Y=o=m<W<R<^<T=c=i<S=l<R<]<W<Y<P=g<S<R<W=o=k<T=n=`=c<^<W=c=b=n=m=c<Q<\\<T<]<R<W<Y<Y<V<R<P<S<\\<Q<T=c<^<Q<T<P<\\<Q<T<Y=m=l<Y<X=m=n<^<\\4K5h5i5d4K4Z5f4U4K5h4]4J5f4_5f4E4K5h4K5j4F5n4K5h5i4X4K4]5o4K4F5o4K5h4_5f4K4]4K4F4K5h5i5o4F5d4D4E4K5h4_4U5d4C5f4E4K4A4Y4K4J5f4K4F4K5h4U4K5h5i5f4E4K5h4Y5d4F5f4K4F4K5h4K5j4F4]5j4F4K5h4F4Y4K5i5f5i4K5h4I4_5h4K5i5f4K5h5i4X4K4]5o4E4K5h5i4]4J5f4K4Fqlalwp!#`lmwfmw>!?gju#jg>!ellwfq!=wkf#Vmjwfg#Pwbwfp?jnd#pq`>!kwws9,,-isd\x7Fqjdkw\x7Fwkvna\x7F-ip!=?,p`qjsw= ?ol`bwjlm-sqlwl`loeqbnfalqgfq>!3!#p!#,= ?nfwb#mbnf>!?,b=?,gju=?,gju=?elmw.tfjdkw9alog8%rvlw8#bmg#%rvlw8gfsfmgjmd#lm#wkf#nbqdjm938sbggjmd9!#qfo>!mleloolt!#Sqfpjgfmw#le#wkf#wtfmwjfwk#`fmwvqzfujpjlm= ##?,sbdfJmwfqmfw#F{solqfqb-bpzm`#>#wqvf8 jmelqnbwjlm#balvw?gju#jg>!kfbgfq!=!#b`wjlm>!kwws9,,?b#kqfe>!kwwsp9,,?gju#jg>!`lmwfmw!?,gju= ?,gju= ?gfqjufg#eqln#wkf#?jnd#pq`>$kwws9,,b``lqgjmd#wl#wkf# ?,algz= ?,kwno= pwzof>!elmw.pjyf9p`qjsw#obmdvbdf>!Bqjbo/#Kfoufwj`b/?,b=?psbm#`obpp>!?,p`qjsw=?p`qjsw#slojwj`bo#sbqwjfpwg=?,wq=?,wbaof=?kqfe>!kwws9,,ttt-jmwfqsqfwbwjlm#leqfo>!pwzofpkffw!#gl`vnfmw-tqjwf+$?`kbqpfw>!vwe.;!= afdjmmjmd#le#wkf#qfufbofg#wkbw#wkfwfofujpjlm#pfqjfp!#qfo>!mleloolt!=#wbqdfw>!\\aobmh!=`objnjmd#wkbw#wkfkwws&0B&1E&1Ettt-nbmjefpwbwjlmp#leSqjnf#Njmjpwfq#lejmeovfm`fg#az#wkf`obpp>!`ofbqej{!=,gju= ?,gju=  wkqff.gjnfmpjlmbo@kvq`k#le#Fmdobmgle#Mlqwk#@bqlojmbprvbqf#hjolnfwqfp-bggFufmwOjpwfmfqgjpwjm`w#eqln#wkf`lnnlmoz#hmltm#bpSklmfwj`#Boskbafwgf`obqfg#wkbw#wkf`lmwqloofg#az#wkfAfmibnjm#Eqbmhojmqlof.sobzjmd#dbnfwkf#Vmjufqpjwz#lejm#Tfpwfqm#Fvqlsfsfqplmbo#`lnsvwfqSqlif`w#Dvwfmafqdqfdbqgofpp#le#wkfkbp#affm#sqlslpfgwldfwkfq#tjwk#wkf=?,oj=?oj#`obpp>!jm#plnf#`lvmwqjfpnjm-ip!=?,p`qjsw=le#wkf#slsvobwjlmleej`jbo#obmdvbdf?jnd#pq`>!jnbdfp,jgfmwjejfg#az#wkfmbwvqbo#qfplvq`fp`obppjej`bwjlm#le`bm#af#`lmpjgfqfgrvbmwvn#nf`kbmj`pMfufqwkfofpp/#wkfnjoojlm#zfbqp#bdl?,algz= ?,kwno="y"W"W"["Q"U"V"@ wbhf#bgubmwbdf#lebmg/#b``lqgjmd#wlbwwqjavwfg#wl#wkfNj`qlplew#Tjmgltpwkf#ejqpw#`fmwvqzvmgfq#wkf#`lmwqlogju#`obpp>!kfbgfqpklqwoz#bewfq#wkfmlwbaof#f{`fswjlmwfmp#le#wklvpbmgppfufqbo#gjeefqfmwbqlvmg#wkf#tlqog-qfb`kjmd#njojwbqzjplobwfg#eqln#wkflsslpjwjlm#wl#wkfwkf#Log#WfpwbnfmwBeqj`bm#Bnfqj`bmpjmpfqwfg#jmwl#wkfpfsbqbwf#eqln#wkfnfwqlslojwbm#bqfbnbhfp#jw#slppjaofb`hmltofgdfg#wkbwbqdvbaoz#wkf#nlpwwzsf>!wf{w,`pp!= wkf#JmwfqmbwjlmboB``lqgjmd#wl#wkf#sf>!wf{w,`pp!#,= `ljm`jgf#tjwk#wkfwtl.wkjqgp#le#wkfGvqjmd#wkjp#wjnf/gvqjmd#wkf#sfqjlgbmmlvm`fg#wkbw#kfwkf#jmwfqmbwjlmbobmg#nlqf#qf`fmwozafojfufg#wkbw#wkf`lmp`jlvpmfpp#bmgelqnfqoz#hmltm#bppvqqlvmgfg#az#wkfejqpw#bssfbqfg#jml``bpjlmbooz#vpfgslpjwjlm9baplovwf8!#wbqdfw>!\\aobmh!#slpjwjlm9qfobwjuf8wf{w.bojdm9`fmwfq8ib{,ojap,irvfqz,2-ab`hdqlvmg.`lolq9 wzsf>!bssoj`bwjlm,bmdvbdf!#`lmwfmw>!?nfwb#kwws.frvju>!Sqjub`z#Sloj`z?,b=f+!&0@p`qjsw#pq`>$!#wbqdfw>!\\aobmh!=Lm#wkf#lwkfq#kbmg/-isd\x7Fwkvna\x7Fqjdkw\x7F1?,gju=?gju#`obpp>!?gju#pwzof>!eolbw9mjmfwffmwk#`fmwvqz?,algz= ?,kwno= ?jnd#pq`>!kwws9,,p8wf{w.bojdm9`fmwfqelmw.tfjdkw9#alog8#B``lqgjmd#wl#wkf#gjeefqfm`f#afwtffm!#eqbnfalqgfq>!3!#!#pwzof>!slpjwjlm9ojmh#kqfe>!kwws9,,kwno7,ollpf-gwg!= gvqjmd#wkjp#sfqjlg?,wg=?,wq=?,wbaof=`olpfoz#qfobwfg#wlelq#wkf#ejqpw#wjnf8elmw.tfjdkw9alog8jmsvw#wzsf>!wf{w!#?psbm#pwzof>!elmw.lmqfbgzpwbwf`kbmdf\n?gju#`obpp>!`ofbqgl`vnfmw-ol`bwjlm-#Elq#f{bnsof/#wkf#b#tjgf#ubqjfwz#le#?"GL@WZSF#kwno= ?%maps8%maps8%maps8!=?b#kqfe>!kwws9,,pwzof>!eolbw9ofew8`lm`fqmfg#tjwk#wkf>kwws&0B&1E&1Ettt-jm#slsvobq#`vowvqfwzsf>!wf{w,`pp!#,=jw#jp#slppjaof#wl#Kbqubqg#Vmjufqpjwzwzofpkffw!#kqfe>!,wkf#nbjm#`kbqb`wfqL{elqg#Vmjufqpjwz##mbnf>!hfztlqgp!#`pwzof>!wf{w.bojdm9wkf#Vmjwfg#Hjmdglnefgfqbo#dlufqmnfmw?gju#pwzof>!nbqdjm#gfsfmgjmd#lm#wkf#gfp`qjswjlm#le#wkf?gju#`obpp>!kfbgfq-njm-ip!=?,p`qjsw=gfpwqv`wjlm#le#wkfpojdkwoz#gjeefqfmwjm#b``lqgbm`f#tjwkwfof`lnnvmj`bwjlmpjmgj`bwfp#wkbw#wkfpklqwoz#wkfqfbewfqfpsf`jbooz#jm#wkf#Fvqlsfbm#`lvmwqjfpKltfufq/#wkfqf#bqfpq`>!kwws9,,pwbwj`pvddfpwfg#wkbw#wkf!#pq`>!kwws9,,ttt-b#obqdf#mvnafq#le#Wfof`lnnvmj`bwjlmp!#qfo>!mleloolt!#wKloz#Qlnbm#Fnsfqlqbonlpw#f{`ovpjufoz!#alqgfq>!3!#bow>!Pf`qfwbqz#le#Pwbwf`vonjmbwjmd#jm#wkf@JB#Tlqog#Eb`wallhwkf#nlpw#jnslqwbmwbmmjufqpbqz#le#wkfpwzof>!ab`hdqlvmg.?oj=?fn=?b#kqfe>!,wkf#Bwobmwj`#L`fbmpwqj`woz#psfbhjmd/pklqwoz#afelqf#wkfgjeefqfmw#wzsfp#lewkf#Lwwlnbm#Fnsjqf=?jnd#pq`>!kwws9,,Bm#Jmwqlgv`wjlm#wl`lmpfrvfm`f#le#wkfgfsbqwvqf#eqln#wkf@lmefgfqbwf#Pwbwfpjmgjdfmlvp#sflsofpSql`ffgjmdp#le#wkfjmelqnbwjlm#lm#wkfwkflqjfp#kbuf#affmjmuloufnfmw#jm#wkfgjujgfg#jmwl#wkqffbgib`fmw#`lvmwqjfpjp#qfpslmpjaof#elqgjpplovwjlm#le#wkf`loobalqbwjlm#tjwktjgfoz#qfdbqgfg#bpkjp#`lmwfnslqbqjfpelvmgjmd#nfnafq#leGlnjmj`bm#Qfsvaoj`dfmfqbooz#b``fswfgwkf#slppjajojwz#lebqf#bopl#bubjobaofvmgfq#`lmpwqv`wjlmqfpwlqbwjlm#le#wkfwkf#dfmfqbo#svaoj`jp#bonlpw#fmwjqfozsbppfp#wkqlvdk#wkfkbp#affm#pvddfpwfg`lnsvwfq#bmg#ujgflDfqnbmj`#obmdvbdfp#b``lqgjmd#wl#wkf#gjeefqfmw#eqln#wkfpklqwoz#bewfqtbqgpkqfe>!kwwsp9,,ttt-qf`fmw#gfufolsnfmwAlbqg#le#Gjqf`wlqp?gju#`obpp>!pfbq`k\x7F#?b#kqfe>!kwws9,,Jm#sbqwj`vobq/#wkfNvowjsof#ellwmlwfplq#lwkfq#pvapwbm`fwklvpbmgp#le#zfbqpwqbmpobwjlm#le#wkf?,gju= ?,gju=  ?b#kqfe>!jmgf{-skstbp#fpwbaojpkfg#jmnjm-ip!=?,p`qjsw= sbqwj`jsbwf#jm#wkfb#pwqlmd#jmeovfm`fpwzof>!nbqdjm.wls9qfsqfpfmwfg#az#wkfdqbgvbwfg#eqln#wkfWqbgjwjlmbooz/#wkfFofnfmw+!p`qjsw!*8Kltfufq/#pjm`f#wkf,gju= ?,gju= ?gju#ofew8#nbqdjm.ofew9sqlwf`wjlm#bdbjmpw38#ufqwj`bo.bojdm9Vmelqwvmbwfoz/#wkfwzsf>!jnbdf,{.j`lm,gju= ?gju#`obpp>!#`obpp>!`ofbqej{!=?gju#`obpp>!ellwfq\n\n?,gju= \n\n?,gju= wkf#nlwjlm#sj`wvqf<}=f<W<_<\\=l=m<V<T<]=f<W<_<\\=l=m<V<T<H<Y<X<Y=l<\\=j<T<T<Q<Y=m<V<R<W=`<V<R=m<R<R<]=e<Y<Q<T<Y=m<R<R<]=e<Y<Q<T=c<S=l<R<_=l<\\<P<P=g<r=n<S=l<\\<^<T=n=`<]<Y=m<S<W<\\=n<Q<R<P<\\=n<Y=l<T<\\<W=g<S<R<[<^<R<W=c<Y=n<S<R=m<W<Y<X<Q<T<Y=l<\\<[<W<T=k<Q=g=i<S=l<R<X=o<V=j<T<T<S=l<R<_=l<\\<P<P<\\<S<R<W<Q<R=m=n=`=b<Q<\\=i<R<X<T=n=m=c<T<[<]=l<\\<Q<Q<R<Y<Q<\\=m<Y<W<Y<Q<T=c<T<[<P<Y<Q<Y<Q<T=c<V<\\=n<Y<_<R=l<T<T<|<W<Y<V=m<\\<Q<X=l\fHJ\fIa\fHY\fHR\fH\\\fHR\fHB\fId\fHD\fIm\fHi\fH^\fHF\fIa\fH\\\fHJ\fHR\fHD\fHA\fHR\fH\\\fHH\fIl\fHC\fHi\fHD\fIm\fHJ\fIk\fHZ\fHU\fHS\fHD\fIa\fHJ\fIl\fHk\fHn\fHM\fHS\fHC\fHR\fHJ\fHS\fH^\fIa\fH^\fIl\fHi\fHK\fHS\fHy\fHR\fH\\\fHY\fIl\fHM\fHS\fHC\fIg\fHv\fHS\fHs\fIa\fHL\fIk\fHT\fHB\fHR\fHv\fHR\fH\\\fHp\fHn\fHy\fIa\fHZ\fHD\fHJ\fIm\fHD\fHS\fHC\fHR\fHF\fIa\fH\\\fHC\fIg\fH{\fHi\fHD\fIm\fHT\fHR\fH\\\fH}\fHD\fH^\fHR\fHk\fHD\fHF\fHR\fH\\\fIa\fHs\fIl\fHZ\fH\\\fIa\fHH\fIg\fHn\fH^\fIg\fHy\fHT\fHA\fHR\fHG\fHP\fIa\fH^\fId\fHZ\fHZ\fH\\\fIa\fHH\fIk\fHn\fHF\fIa\fH\\\fHJ\fIk\fHZ\fHF\fIa\fH^\fIk\fHC\fH\\\fHy\fIk\fHn\fHJ\fIa\fH\\\fHT\fIa\fHI\fHS\fHH\fHS\fHe\fHH\fIa\fHF\fHR\fHJ\fHe\fHD\fIa\fHU\fIk\fHn\fHv\fHS\fHs\fIa\fHL\fHR\fHC\fHR\fHH\fIa\fH\\\fHR\fHp\fIa\fHC\fHR\fHJ\fHR\fHF\fIm\fH\\\fHR\fHD\fIk\fHp\fIg\fHM\fHP\fIk\fHn\fHi\fHD\fIm\fHY\fHR\fHJ\fHZ\fIa\fH\\\fIk\fHO\fIl\fHZ\fHS\fHy\fIa\fH[\fHR\fHT\fH\\\fHy\fHR\fH\\\fIl\fHT\fHn\fH{\fIa\fH\\\fHU\fHF\fH\\\fHS\fHO\fHR\fHB\fH@\fIa\fH\\\fHR\fHn\fHM\fH@\fHv\fIa\fHv\fIg\fHn\fHe\fHF\fH^\fH@\fIa\fHK\fHB\fHn\fHH\fIa\fH\\\fIl\fHT\fHn\fHF\fH\\\fIa\fHy\fHe\fHB\fIa\fHB\fIl\fHJ\fHB\fHR\fHK\fIa\fHC\fHB\fHT\fHU\fHR\fHC\fHH\fHR\fHZ\fH@\fIa\fHJ\fIg\fHn\fHB\fIl\fHM\fHS\fHC\fHR\fHj\fHd\fHF\fIl\fHc\fH^\fHB\fIg\fH@\fHR\fHk\fH^\fHT\fHn\fHz\fIa\fHC\fHR\fHj\fHF\fH\\\fIk\fHZ\fHD\fHi\fHD\fIm\fH@\fHn\fHK\fH@\fHR\fHp\fHP\fHR\fH\\\fHD\fHY\fIl\fHD\fHH\fHB\fHF\fIa\fH\\\fHB\fIm\fHz\fHF\fIa\fH\\\fHZ\fIa\fHD\fHF\fH\\\fHS\fHY\fHR\fH\\\fHD\fIm\fHy\fHT\fHR\fHD\fHT\fHB\fH\\\fIa\fHI\fHD\fHj\fHC\fIg\fHp\fHS\fHH\fHT\fIg\fHB\fHY\fHR\fH\\4K5h5i4X4K4]5o4K4F4K5h5i5j4F4C5f4K4F4K5h5o5i4D5f5d4F4]4K5h5i4X4K5k4C4K4F4U4C4C4K5h4^5d4K4]4U4C4C4K5h4]4C5d4C4K5h4I4_5h4K5i5f4E4K5h5m5d4F5d4X5d4D4K5h5i4_4K4D5n4K4F4K5h5i4U5h5d5i4K4F4K5h5i4_5h4_5h4K4F4K5h4@4]4K5m5f5o4_4K5h4K4_5h4K5i5f4E4K5h4K4F4Y4K5h4K4Fhfztlqgp!#`lmwfmw>!t0-lqd,2:::,{kwno!=?b#wbqdfw>!\\aobmh!#wf{w,kwno8#`kbqpfw>!#wbqdfw>!\\aobmh!=?wbaof#`foosbggjmd>!bvwl`lnsofwf>!lee!#wf{w.bojdm9#`fmwfq8wl#obpw#ufqpjlm#az#ab`hdqlvmg.`lolq9# !#kqfe>!kwws9,,ttt-,gju=?,gju=?gju#jg>?b#kqfe>! !#`obpp>!!=?jnd#pq`>!kwws9,,`qjsw!#pq`>!kwws9,, ?p`qjsw#obmdvbdf>!,,FM!#!kwws9,,ttt-tfm`lgfVQJ@lnslmfmw+!#kqfe>!ibubp`qjsw9?gju#`obpp>!`lmwfmwgl`vnfmw-tqjwf+$?p`slpjwjlm9#baplovwf8p`qjsw#pq`>!kwws9,,#pwzof>!nbqdjm.wls9-njm-ip!=?,p`qjsw= ?,gju= ?gju#`obpp>!t0-lqd,2:::,{kwno!#  ?,algz= ?,kwno=gjpwjm`wjlm#afwtffm,!#wbqdfw>!\\aobmh!=?ojmh#kqfe>!kwws9,,fm`lgjmd>!vwe.;!<= t-bggFufmwOjpwfmfq<b`wjlm>!kwws9,,ttt-j`lm!#kqfe>!kwws9,,#pwzof>!ab`hdqlvmg9wzsf>!wf{w,`pp!#,= nfwb#sqlsfqwz>!ld9w?jmsvw#wzsf>!wf{w!##pwzof>!wf{w.bojdm9wkf#gfufolsnfmw#le#wzofpkffw!#wzsf>!wfkwno8#`kbqpfw>vwe.;jp#`lmpjgfqfg#wl#afwbaof#tjgwk>!233&!#Jm#bggjwjlm#wl#wkf#`lmwqjavwfg#wl#wkf#gjeefqfm`fp#afwtffmgfufolsnfmw#le#wkf#Jw#jp#jnslqwbmw#wl#?,p`qjsw= ?p`qjsw##pwzof>!elmw.pjyf92=?,psbm=?psbm#jg>daOjaqbqz#le#@lmdqfpp?jnd#pq`>!kwws9,,jnFmdojpk#wqbmpobwjlmB`bgfnz#le#P`jfm`fpgju#pwzof>!gjpsobz9`lmpwqv`wjlm#le#wkf-dfwFofnfmwAzJg+jg*jm#`lmivm`wjlm#tjwkFofnfmw+$p`qjsw$*8#?nfwb#sqlsfqwz>!ld9<}=f<W<_<\\=l=m<V<T #wzsf>!wf{w!#mbnf>!=Sqjub`z#Sloj`z?,b=bgnjmjpwfqfg#az#wkffmbaofPjmdofQfrvfpwpwzof>%rvlw8nbqdjm9?,gju=?,gju=?,gju=?=?jnd#pq`>!kwws9,,j#pwzof>%rvlw8eolbw9qfefqqfg#wl#bp#wkf#wlwbo#slsvobwjlm#lejm#Tbpkjmdwlm/#G-@-#pwzof>!ab`hdqlvmg.bnlmd#lwkfq#wkjmdp/lqdbmjybwjlm#le#wkfsbqwj`jsbwfg#jm#wkfwkf#jmwqlgv`wjlm#lejgfmwjejfg#tjwk#wkfej`wjlmbo#`kbqb`wfq#L{elqg#Vmjufqpjwz#njpvmgfqpwbmgjmd#leWkfqf#bqf/#kltfufq/pwzofpkffw!#kqfe>!,@lovnajb#Vmjufqpjwzf{sbmgfg#wl#jm`ovgfvpvbooz#qfefqqfg#wljmgj`bwjmd#wkbw#wkfkbuf#pvddfpwfg#wkbwbeejojbwfg#tjwk#wkf`lqqfobwjlm#afwtffmmvnafq#le#gjeefqfmw=?,wg=?,wq=?,wbaof=Qfsvaoj`#le#Jqfobmg ?,p`qjsw= ?p`qjsw#vmgfq#wkf#jmeovfm`f`lmwqjavwjlm#wl#wkfLeej`jbo#tfapjwf#lekfbgrvbqwfqp#le#wkf`fmwfqfg#bqlvmg#wkfjnsoj`bwjlmp#le#wkfkbuf#affm#gfufolsfgEfgfqbo#Qfsvaoj`#leaf`bnf#jm`qfbpjmdoz`lmwjmvbwjlm#le#wkfMlwf/#kltfufq/#wkbwpjnjobq#wl#wkbw#le#`bsbajojwjfp#le#wkfb``lqgbm`f#tjwk#wkfsbqwj`jsbmwp#jm#wkfevqwkfq#gfufolsnfmwvmgfq#wkf#gjqf`wjlmjp#lewfm#`lmpjgfqfgkjp#zlvmdfq#aqlwkfq?,wg=?,wq=?,wbaof=?b#kwws.frvju>![.VB.skzpj`bo#sqlsfqwjfple#Aqjwjpk#@lovnajbkbp#affm#`qjwj`jyfg+tjwk#wkf#f{`fswjlmrvfpwjlmp#balvw#wkfsbppjmd#wkqlvdk#wkf3!#`foosbggjmd>!3!#wklvpbmgp#le#sflsofqfgjqf`wp#kfqf-#Elqkbuf#`kjogqfm#vmgfq&0F&0@,p`qjsw&0F!**8?b#kqfe>!kwws9,,ttt-?oj=?b#kqfe>!kwws9,,pjwf\\mbnf!#`lmwfmw>!wf{w.gf`lqbwjlm9mlmfpwzof>!gjpsobz9#mlmf?nfwb#kwws.frvju>![.mft#Gbwf+*-dfwWjnf+*#wzsf>!jnbdf,{.j`lm!?,psbm=?psbm#`obpp>!obmdvbdf>!ibubp`qjswtjmglt-ol`bwjlm-kqfe?b#kqfe>!ibubp`qjsw9..= ?p`qjsw#wzsf>!w?b#kqfe>$kwws9,,ttt-klqw`vw#j`lm!#kqfe>!?,gju= ?gju#`obpp>!?p`qjsw#pq`>!kwws9,,!#qfo>!pwzofpkffw!#w?,gju= ?p`qjsw#wzsf>,b=#?b#kqfe>!kwws9,,#booltWqbmpsbqfm`z>![.VB.@lnsbwjaof!#`lmqfobwjlmpkjs#afwtffm ?,p`qjsw= ?p`qjsw#?,b=?,oj=?,vo=?,gju=bppl`jbwfg#tjwk#wkf#sqldqbnnjmd#obmdvbdf?,b=?b#kqfe>!kwws9,,?,b=?,oj=?oj#`obpp>!elqn#b`wjlm>!kwws9,,?gju#pwzof>!gjpsobz9wzsf>!wf{w!#mbnf>!r!?wbaof#tjgwk>!233&!#ab`hdqlvmg.slpjwjlm9!#alqgfq>!3!#tjgwk>!qfo>!pklqw`vw#j`lm!#k5=?vo=?oj=?b#kqfe>!##?nfwb#kwws.frvju>!`pp!#nfgjb>!p`qffm!#qfpslmpjaof#elq#wkf#!#wzsf>!bssoj`bwjlm,!#pwzof>!ab`hdqlvmg.kwno8#`kbqpfw>vwe.;!#booltwqbmpsbqfm`z>!pwzofpkffw!#wzsf>!wf ?nfwb#kwws.frvju>!=?,psbm=?psbm#`obpp>!3!#`foopsb`jmd>!3!=8 ?,p`qjsw= ?p`qjsw#plnfwjnfp#`boofg#wkfglfp#mlw#mf`fppbqjozElq#nlqf#jmelqnbwjlmbw#wkf#afdjmmjmd#le#?"GL@WZSF#kwno=?kwnosbqwj`vobqoz#jm#wkf#wzsf>!kjggfm!#mbnf>!ibubp`qjsw9uljg+3*8!feef`wjufmfpp#le#wkf#bvwl`lnsofwf>!lee!#dfmfqbooz#`lmpjgfqfg=?jmsvw#wzsf>!wf{w!#!=?,p`qjsw= ?p`qjswwkqlvdklvw#wkf#tlqog`lnnlm#njp`lm`fswjlmbppl`jbwjlm#tjwk#wkf?,gju= ?,gju= ?gju#`gvqjmd#kjp#ojefwjnf/`lqqfpslmgjmd#wl#wkfwzsf>!jnbdf,{.j`lm!#bm#jm`qfbpjmd#mvnafqgjsolnbwj`#qfobwjlmpbqf#lewfm#`lmpjgfqfgnfwb#`kbqpfw>!vwe.;!#?jmsvw#wzsf>!wf{w!#f{bnsofp#jm`ovgf#wkf!=?jnd#pq`>!kwws9,,jsbqwj`jsbwjlm#jm#wkfwkf#fpwbaojpknfmw#le ?,gju= ?gju#`obpp>!%bns8maps8%bns8maps8wl#gfwfqnjmf#tkfwkfqrvjwf#gjeefqfmw#eqlnnbqhfg#wkf#afdjmmjmdgjpwbm`f#afwtffm#wkf`lmwqjavwjlmp#wl#wkf`lmeoj`w#afwtffm#wkftjgfoz#`lmpjgfqfg#wltbp#lmf#le#wkf#ejqpwtjwk#ubqzjmd#gfdqffpkbuf#psf`vobwfg#wkbw+gl`vnfmw-dfwFofnfmwsbqwj`jsbwjmd#jm#wkflqjdjmbooz#gfufolsfgfwb#`kbqpfw>!vwe.;!=#wzsf>!wf{w,`pp!#,= jmwfq`kbmdfbaoz#tjwknlqf#`olpfoz#qfobwfgpl`jbo#bmg#slojwj`bowkbw#tlvog#lwkfqtjpfsfqsfmgj`vobq#wl#wkfpwzof#wzsf>!wf{w,`ppwzsf>!pvanjw!#mbnf>!ebnjojfp#qfpjgjmd#jmgfufolsjmd#`lvmwqjfp`lnsvwfq#sqldqbnnjmdf`lmlnj`#gfufolsnfmwgfwfqnjmbwjlm#le#wkfelq#nlqf#jmelqnbwjlmlm#pfufqbo#l``bpjlmpslqwvdv/Fp#+Fvqlsfv*<O<V=l<\\={<Q=m=`<V<\\=o<V=l<\\={<Q=m=`<V<\\<L<R=m=m<T<U=m<V<R<U<P<\\=n<Y=l<T<\\<W<R<^<T<Q=h<R=l<P<\\=j<T<T=o<S=l<\\<^<W<Y<Q<T=c<Q<Y<R<]=i<R<X<T<P<R<T<Q=h<R=l<P<\\=j<T=c<t<Q=h<R=l<P<\\=j<T=c<L<Y=m<S=o<]<W<T<V<T<V<R<W<T=k<Y=m=n<^<R<T<Q=h<R=l<P<\\=j<T=b=n<Y=l=l<T=n<R=l<T<T<X<R=m=n<\\=n<R=k<Q<R4K5h5i4F5d4K4@4C5d5j4K5h4K4X4F4]4K5o4K4F4K5h4K5n4F4]4K4A4K4Fkwno8#`kbqpfw>VWE.;!#pfwWjnflvw+evm`wjlm+*gjpsobz9jmojmf.aol`h8?jmsvw#wzsf>!pvanjw!#wzsf#>#$wf{w,ibubp`qj?jnd#pq`>!kwws9,,ttt-!#!kwws9,,ttt-t0-lqd,pklqw`vw#j`lm!#kqfe>!!#bvwl`lnsofwf>!lee!#?,b=?,gju=?gju#`obpp>?,b=?,oj= ?oj#`obpp>!`pp!#wzsf>!wf{w,`pp!#?elqn#b`wjlm>!kwws9,,{w,`pp!#kqfe>!kwws9,,ojmh#qfo>!bowfqmbwf!# ?p`qjsw#wzsf>!wf{w,#lm`oj`h>!ibubp`qjsw9+mft#Gbwf*-dfwWjnf+*~kfjdkw>!2!#tjgwk>!2!#Sflsof$p#Qfsvaoj`#le##?b#kqfe>!kwws9,,ttt-wf{w.gf`lqbwjlm9vmgfqwkf#afdjmmjmd#le#wkf#?,gju= ?,gju= ?,gju= fpwbaojpknfmw#le#wkf#?,gju=?,gju=?,gju=?,g ujftslqwxnjm.kfjdkw9 ?p`qjsw#pq`>!kwws9,,lswjlm=?lswjlm#ubovf>lewfm#qfefqqfg#wl#bp#,lswjlm= ?lswjlm#ubov?"GL@WZSF#kwno= ?"..XJmwfqmbwjlmbo#Bjqslqw= ?b#kqfe>!kwws9,,ttt?,b=?b#kqfe>!kwws9,,t\fTL\fT^\fTE\fT^\fUh\fT{\fTN\roI\ro|\roL\ro{\roO\rov\rot\nAOGx\bTA\nzk#+\vUmGx*\fHD\fHS\fH\\\fIa\fHJ\fIk\fHZ\fHM\fHR\fHe\fHD\fH^\fIg\fHM\fHy\fIa\fH[\fIk\fHH\fIa\fH\\\fHp\fHR\fHD\fHy\fHR\fH\\\fIl\fHT\fHn\fH@\fHn\fHK\fHS\fHH\fHT\fIa\fHI\fHR\fHF\fHD\fHR\fHT\fIa\fHY\fIl\fHy\fHR\fH\\\fHT\fHn\fHT\fIa\fHy\fH\\\fHO\fHT\fHR\fHB\fH{\fIa\fH\\\fIl\fHv\fHS\fHs\fIa\fHL\fIg\fHn\fHY\fHS\fHp\fIa\fHr\fHR\fHD\fHi\fHB\fIk\fH\\\fHS\fHy\fHR\fHY\fHS\fHA\fHS\fHD\fIa\fHD\fH{\fHR\fHM\fHS\fHC\fHR\fHm\fHy\fIa\fHC\fIg\fHn\fHy\fHS\fHT\fIm\fH\\\fHy\fIa\fH[\fHR\fHF\fHU\fIm\fHm\fHv\fHH\fIl\fHF\fIa\fH\\\fH@\fHn\fHK\fHD\fHs\fHS\fHF\fIa\fHF\fHO\fIl\fHy\fIa\fH\\\fHS\fHy\fIk\fHs\fHF\fIa\fH\\\fHR\fH\\\fHn\fHA\fHF\fIa\fH\\\fHR\fHF\fIa\fHH\fHB\fHR\fH^\fHS\fHy\fIg\fHn\fH\\\fHG\fHP\fIa\fHH\fHR\fH\\\fHD\fHS\fH\\\fIa\fHB\fHR\fHO\fH^\fHS\fHB\fHS\fHs\fIk\fHMgfp`qjswjlm!#`lmwfmw>!gl`vnfmw-ol`bwjlm-sqlw-dfwFofnfmwpAzWbdMbnf+?"GL@WZSF#kwno= ?kwno#?nfwb#`kbqpfw>!vwe.;!=9vqo!#`lmwfmw>!kwws9,,-`pp!#qfo>!pwzofpkffw!pwzof#wzsf>!wf{w,`pp!=wzsf>!wf{w,`pp!#kqfe>!t0-lqd,2:::,{kwno!#{nowzsf>!wf{w,ibubp`qjsw!#nfwklg>!dfw!#b`wjlm>!ojmh#qfo>!pwzofpkffw!##>#gl`vnfmw-dfwFofnfmwwzsf>!jnbdf,{.j`lm!#,=`foosbggjmd>!3!#`foops-`pp!#wzsf>!wf{w,`pp!#?,b=?,oj=?oj=?b#kqfe>!!#tjgwk>!2!#kfjdkw>!2!!=?b#kqfe>!kwws9,,ttt-pwzof>!gjpsobz9mlmf8!=bowfqmbwf!#wzsf>!bssoj.,,T0@,,GWG#[KWNO#2-3#foopsb`jmd>!3!#`foosbg#wzsf>!kjggfm!#ubovf>!,b=%maps8?psbm#qlof>!p ?jmsvw#wzsf>!kjggfm!#obmdvbdf>!IbubP`qjsw!##gl`vnfmw-dfwFofnfmwpAd>!3!#`foopsb`jmd>!3!#zsf>!wf{w,`pp!#nfgjb>!wzsf>$wf{w,ibubp`qjsw$tjwk#wkf#f{`fswjlm#le#zsf>!wf{w,`pp!#qfo>!pw#kfjdkw>!2!#tjgwk>!2!#>$(fm`lgfVQJ@lnslmfmw+?ojmh#qfo>!bowfqmbwf!# algz/#wq/#jmsvw/#wf{wnfwb#mbnf>!qlalwp!#`lmnfwklg>!slpw!#b`wjlm>!= ?b#kqfe>!kwws9,,ttt-`pp!#qfo>!pwzofpkffw!#?,gju=?,gju=?gju#`obppobmdvbdf>!ibubp`qjsw!=bqjb.kjggfm>!wqvf!=.[?qjsw!#wzsf>!wf{w,ibubpo>38~*+*8 +evm`wjlm+*xab`hdqlvmg.jnbdf9#vqo+,b=?,oj=?oj=?b#kqfe>!k\n\n?oj=?b#kqfe>!kwws9,,bwlq!#bqjb.kjggfm>!wqv=#?b#kqfe>!kwws9,,ttt-obmdvbdf>!ibubp`qjsw!#,lswjlm= ?lswjlm#ubovf,gju=?,gju=?gju#`obpp>qbwlq!#bqjb.kjggfm>!wqf>+mft#Gbwf*-dfwWjnf+*slqwvdv/Fp#+gl#Aqbpjo*<R=l<_<\\<Q<T<[<\\=j<T<T<^<R<[<P<R<Z<Q<R=m=n=`<R<]=l<\\<[<R<^<\\<Q<T=c=l<Y<_<T=m=n=l<\\=j<T<T<^<R<[<P<R<Z<Q<R=m=n<T<R<]=c<[<\\=n<Y<W=`<Q<\\?"GL@WZSF#kwno#SVAOJ@#!mw.Wzsf!#`lmwfmw>!wf{w,?nfwb#kwws.frvju>!@lmwfqbmpjwjlmbo,,FM!#!kwws9?kwno#{nomp>!kwws9,,ttt.,,T0@,,GWG#[KWNO#2-3#WGWG,{kwno2.wqbmpjwjlmbo,,ttt-t0-lqd,WQ,{kwno2,sf#>#$wf{w,ibubp`qjsw$8?nfwb#mbnf>!gfp`qjswjlmsbqfmwMlgf-jmpfqwAfelqf?jmsvw#wzsf>!kjggfm!#mbip!#wzsf>!wf{w,ibubp`qj+gl`vnfmw*-qfbgz+evm`wjp`qjsw#wzsf>!wf{w,ibubpjnbdf!#`lmwfmw>!kwws9,,VB.@lnsbwjaof!#`lmwfmw>wno8#`kbqpfw>vwe.;!#,= ojmh#qfo>!pklqw`vw#j`lm?ojmh#qfo>!pwzofpkffw!#?,p`qjsw= ?p`qjsw#wzsf>>#gl`vnfmw-`qfbwfFofnfm?b#wbqdfw>!\\aobmh!#kqfe>#gl`vnfmw-dfwFofnfmwpAjmsvw#wzsf>!wf{w!#mbnf>b-wzsf#>#$wf{w,ibubp`qjmsvw#wzsf>!kjggfm!#mbnfkwno8#`kbqpfw>vwe.;!#,=gwg!= ?kwno#{nomp>!kwws.,,T0@,,GWG#KWNO#7-32#WfmwpAzWbdMbnf+$p`qjsw$*jmsvw#wzsf>!kjggfm!#mbn?p`qjsw#wzsf>!wf{w,ibubp!#pwzof>!gjpsobz9mlmf8!=gl`vnfmw-dfwFofnfmwAzJg+>gl`vnfmw-`qfbwfFofnfmw+$#wzsf>$wf{w,ibubp`qjsw$jmsvw#wzsf>!wf{w!#mbnf>!g-dfwFofnfmwpAzWbdMbnf+pmj`bo!#kqfe>!kwws9,,ttt-@,,GWG#KWNO#7-32#Wqbmpjw?pwzof#wzsf>!wf{w,`pp!= ?pwzof#wzsf>!wf{w,`pp!=jlmbo-gwg!= ?kwno#{nomp>kwws.frvju>!@lmwfmw.Wzsfgjmd>!3!#`foopsb`jmd>!3!kwno8#`kbqpfw>vwe.;!#,= #pwzof>!gjpsobz9mlmf8!=??oj=?b#kqfe>!kwws9,,ttt-#wzsf>$wf{w,ibubp`qjsw$=<X<Y=c=n<Y<W=`<Q<R=m=n<T=m<R<R=n<^<Y=n=m=n<^<T<T<S=l<R<T<[<^<R<X=m=n<^<\\<]<Y<[<R<S<\\=m<Q<R=m=n<T\fHF\fIm\fHT\fIa\fHH\fHS\fHy\fHR\fHy\fHR\fHn\fH{\fIa\fH\\\fIk\fHT\fHe\fHD\fIa\fHU\fIg\fHn\fHD\fIk\fHY\fHS\fHK\fHR\fHD\fHT\fHA\fHR\fHG\fHS\fHy\fIa\fHT\fHS\fHn\fH{\fHT\fIm\fH\\\fHy\fIa\fH[\fHS\fHH\fHy\fIe\fHF\fIl\fH\\\fHR\fHk\fHs\fHY\fHS\fHp\fIa\fHr\fHR\fHF\fHD\fHy\fHR\fH\\\fIa\fH\\\fHY\fHR\fHd\fHT\fHy\fIa\fH\\\fHS\fHC\fHH\fHR',
6221
- "\u06F7%\u018C'T%\x85'W%\xD7%O%g%\xA6&\u0193%\u01E5&>&*&'&^&\x88\u0178\u0C3E&\u01AD&\u0192&)&^&%&'&\x82&P&1&\xB1&3&]&m&u&E&t&C&\xCF&V&V&/&>&6&\u0F76\u177Co&p&@&E&M&P&x&@&F&e&\xCC&7&:&(&D&0&C&)&.&F&-&1&(&L&F&1\u025E*\u03EA\u21F3&\u1372&K&;&)&E&H&P&0&?&9&V&\x81&-&v&a&,&E&)&?&=&'&'&B&\u0D2E&\u0503&\u0316*&*8&%&%&&&%,)&\x9A&>&\x86&7&]&F&2&>&J&6&n&2&%&?&\x8E&2&6&J&g&-&0&,&*&J&*&O&)&6&(&<&B&N&.&P&@&2&.&W&M&%\u053C\x84(,(<&,&\u03DA&\u18C7&-&,(%&(&%&(\u013B0&X&D&\x81&j&'&J&(&.&B&3&Z&R&h&3&E&E&<\xC6-\u0360\u1EF3&%8?&@&,&Z&@&0&J&,&^&x&_&6&C&6&C\u072C\u2A25&f&-&-&-&-&,&J&2&8&z&8&C&Y&8&-&d&\u1E78\xCC-&7&1&F&7&t&W&7&I&.&.&^&=\u0F9C\u19D3&8(>&/&/&\u077B')'\u1065')'%@/&0&%\u043E\u09C0*&*@&C\u053D\u05D4\u0274\u05EB4\u0DD7\u071A\u04D16\u0D84&/\u0178\u0303Z&*%\u0246\u03FF&\u0134&1\xA8\u04B4\u0174",
6222
- dictionarySizeBits,
6223
- "AAAAKKLLKKKKKJJIHHIHHGGFF"
6224
- );
6225
- flipBuffer(dictionaryData);
6226
- setData(asReadOnlyBuffer(dictionaryData), dictionarySizeBits);
6227
- }
6228
- function min(a, b) {
6229
- return a <= b ? a : b;
6230
- }
6231
- function copyBytes(dst, target, src, start, end) {
6232
- dst.set(src.slice(start, end), target);
6233
- }
6234
- function readInput(src, dst, offset, length) {
6235
- if (src == null) return -1;
6236
- let end = min(src.offset + length, src.data.length);
6237
- let bytesRead = end - src.offset;
6238
- dst.set(src.data.subarray(src.offset, end), offset);
6239
- src.offset += bytesRead;
6240
- return bytesRead;
6241
- }
6242
- function closeInput(src) {
6243
- return 0;
6244
- }
6245
- function asReadOnlyBuffer(src) {
6246
- return src;
6247
- }
6248
- function isReadOnly(src) {
6249
- return 1;
6250
- }
6251
- function isDirect(src) {
6252
- return 1;
6253
- }
6254
- function flipBuffer(buffer) {
6255
- }
6256
- function toUsAsciiBytes(src) {
6257
- let n = src.length;
6258
- let result = new Int8Array(n);
6259
- for (let i = 0; i < n; ++i) {
6260
- result[i] = src.charCodeAt(i);
6261
- }
6262
- return result;
6263
- }
6264
- function decode(bytes, options) {
6265
- let s = new State();
6266
- initState(s, new InputStream(bytes));
6267
- if (options) {
6268
- let customDictionary = (
6269
- /** @type {?Int8Array} */
6270
- options["customDictionary"]
6271
- );
6272
- if (customDictionary) attachDictionaryChunk(s, customDictionary);
6273
- }
6274
- let totalOutput = 0;
6275
- let chunks = [];
6276
- while (true) {
6277
- let chunk = new Int8Array(16384);
6278
- chunks.push(chunk);
6279
- s.output = chunk;
6280
- s.outputOffset = 0;
6281
- s.outputLength = 16384;
6282
- s.outputUsed = 0;
6283
- decompress4(s);
6284
- totalOutput += s.outputUsed;
6285
- if (s.outputUsed < 16384) break;
6286
- }
6287
- close(s);
6288
- let result = new Int8Array(totalOutput);
6289
- let offset = 0;
6290
- for (let i = 0; i < chunks.length; ++i) {
6291
- let chunk = chunks[i];
6292
- let end = min(totalOutput, offset + 16384);
6293
- let len = end - offset;
6294
- if (len < 16384) {
6295
- result.set(chunk.subarray(0, len), offset);
6296
- } else {
6297
- result.set(chunk, offset);
6298
- }
6299
- offset += len;
6300
- }
6301
- return result;
3609
+ yield* super.decompressBatches(inputBatches);
6302
3610
  }
6303
- return decode;
6304
3611
  };
6305
- BrotliDecode = makeBrotliDecode();
6306
3612
  }
6307
3613
  });
6308
3614
 
6309
- // ../compression/src/brotli-decode.ts
6310
- var brotli_decode_exports = {};
6311
- __export(brotli_decode_exports, {
6312
- BrotliDecode: () => BrotliDecode
6313
- });
6314
- var init_brotli_decode = __esm({
6315
- "../compression/src/brotli-decode.ts"() {
3615
+ // ../compression/src/gzip-decompressor-compress-utils.ts
3616
+ var GZipCompressUtilsDecompressor;
3617
+ var init_gzip_decompressor_compress_utils = __esm({
3618
+ "../compression/src/gzip-decompressor-compress-utils.ts"() {
6316
3619
  "use strict";
6317
- init_decode();
3620
+ init_compress_utils_compression();
3621
+ GZipCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
3622
+ constructor(options = {}) {
3623
+ super(
3624
+ { name: "gzip", extensions: ["gz", "gzip"], contentEncodings: ["gzip", "x-gzip"] },
3625
+ () => import("compress-utils/gzip/decompress"),
3626
+ options
3627
+ );
3628
+ }
3629
+ };
6318
3630
  }
6319
3631
  });
6320
3632
 
6321
- // ../compression/src/lib/brotli-compression.ts
6322
- var brotli_compression_exports = {};
6323
- __export(brotli_compression_exports, {
6324
- BrotliCompression: () => BrotliCompression
3633
+ // ../compression/src/gzip-decompressor.ts
3634
+ var gzip_decompressor_exports = {};
3635
+ __export(gzip_decompressor_exports, {
3636
+ GZipDecompressor: () => GZipDecompressor
6325
3637
  });
6326
- var import_zlib, DEFAULT_BROTLI_OPTIONS, BrotliCompression;
6327
- var init_brotli_compression = __esm({
6328
- "../compression/src/lib/brotli-compression.ts"() {
3638
+ var GZipDecompressor;
3639
+ var init_gzip_decompressor = __esm({
3640
+ "../compression/src/gzip-decompressor.ts"() {
6329
3641
  "use strict";
6330
- init_compression();
6331
- init_src2();
6332
- import_zlib = __toESM(require("zlib"), 1);
6333
- init_compression_stream();
3642
+ init_gzip_decompressor_compress_utils();
6334
3643
  init_decompression_stream();
6335
- DEFAULT_BROTLI_OPTIONS = {
6336
- brotli: {
6337
- mode: 0,
6338
- quality: 8,
6339
- lgwin: 22
6340
- }
6341
- };
6342
- BrotliCompression = class extends Compression {
6343
- name = "brotli";
6344
- extensions = ["br"];
6345
- contentEncodings = ["br"];
6346
- isSupported = true;
6347
- options;
6348
- constructor(options = {}) {
6349
- super(options);
6350
- this.options = options;
6351
- registerJSModules(options == null ? void 0 : options.modules);
6352
- }
6353
- /**
6354
- * brotli is an injectable dependency due to big size
6355
- * @param options
6356
- */
6357
- async preload(modules = {}) {
6358
- registerJSModules(modules);
6359
- if (!getJSModuleOrNull("brotli")) {
6360
- const { BrotliDecode: BrotliDecode2 } = await Promise.resolve().then(() => (init_brotli_decode(), brotli_decode_exports));
6361
- registerJSModules({
6362
- brotli: {
6363
- compress: () => {
6364
- throw new Error("Brotli compression requires an injected encoder");
6365
- },
6366
- decompress: (input) => BrotliDecode2(input, void 0)
6367
- }
6368
- });
6369
- }
6370
- }
6371
- async compress(input) {
6372
- var _a;
6373
- const nativeOutput = await compressWithNativeCompressionStream(input, "brotli");
6374
- if (nativeOutput) return nativeOutput;
6375
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
6376
- const buffer = await promisify1(import_zlib.default.brotliCompress)(input);
6377
- return toArrayBuffer2(buffer);
6378
- }
6379
- return this.compressSync(input);
6380
- }
6381
- compressSync(input) {
6382
- var _a, _b;
6383
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
6384
- const buffer = import_zlib.default.brotliCompressSync(input);
6385
- return toArrayBuffer2(buffer);
6386
- }
6387
- const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
6388
- const inputArray = new Uint8Array(input);
6389
- const brotli = getJSModule("brotli", this.name);
6390
- const outputArray = brotli.compress(inputArray, brotliOptions);
6391
- if (!outputArray) {
6392
- throw new Error("Brotli compression failed");
6393
- }
6394
- return toArrayBuffer2(outputArray.buffer);
6395
- }
6396
- async decompress(input) {
6397
- var _a;
6398
- if (!getJSModuleOrNull("brotli")) {
6399
- const nativeOutput = await decompressWithNativeDecompressionStream(input, "brotli");
6400
- if (nativeOutput) return nativeOutput;
6401
- }
6402
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
6403
- const buffer = await promisify1(import_zlib.default.brotliDecompress)(input);
6404
- return toArrayBuffer2(buffer);
6405
- }
6406
- await this.preload();
6407
- return this.decompressSync(input);
6408
- }
6409
- decompressSync(input) {
6410
- var _a, _b;
6411
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
6412
- const buffer = import_zlib.default.brotliDecompressSync(input);
6413
- return toArrayBuffer2(buffer);
6414
- }
6415
- const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
6416
- const inputArray = new Uint8Array(input);
6417
- const brotli = getJSModuleOrNull("brotli");
6418
- if (brotli) {
6419
- const outputArray = brotli.decompress(inputArray, brotliOptions);
6420
- return toArrayBuffer2(outputArray.buffer);
3644
+ GZipDecompressor = class extends GZipCompressUtilsDecompressor {
3645
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
3646
+ async decompress(input, size) {
3647
+ if (this.options.useNative !== false) {
3648
+ const output = await decompressWithNativeDecompressionStream(input, "gzip");
3649
+ if (output) return output;
6421
3650
  }
6422
- throw new Error(`${this.name}: synchronous fallback is unavailable; preload a brotli module`);
3651
+ return super.decompress(input, size);
6423
3652
  }
3653
+ /** Streams native batches when available, otherwise uses the WASM stream. */
6424
3654
  async *decompressBatches(inputBatches) {
6425
- const nativeBatches = decompressBatchesWithNativeDecompressionStream(inputBatches, "brotli");
6426
- if (nativeBatches) {
6427
- yield* nativeBatches;
6428
- return;
3655
+ if (this.options.useNative !== false) {
3656
+ const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
3657
+ if (output) {
3658
+ yield* output;
3659
+ return;
3660
+ }
6429
3661
  }
6430
- yield this.decompress(await this.concatenate(inputBatches));
3662
+ yield* super.decompressBatches(inputBatches);
6431
3663
  }
6432
- async *compressBatches(inputBatches) {
6433
- const nativeBatches = compressBatchesWithNativeCompressionStream(inputBatches, "brotli");
6434
- if (nativeBatches) {
6435
- yield* nativeBatches;
6436
- return;
6437
- }
6438
- yield this.compress(await this.concatenate(inputBatches));
3664
+ };
3665
+ }
3666
+ });
3667
+
3668
+ // ../compression/src/brotli-decompressor-compress-utils.ts
3669
+ var BrotliCompressUtilsDecompressor;
3670
+ var init_brotli_decompressor_compress_utils = __esm({
3671
+ "../compression/src/brotli-decompressor-compress-utils.ts"() {
3672
+ "use strict";
3673
+ init_compress_utils_compression();
3674
+ BrotliCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
3675
+ constructor(options = {}) {
3676
+ super(
3677
+ { name: "brotli", extensions: ["br"], contentEncodings: ["br"] },
3678
+ () => import("compress-utils/brotli/decompress"),
3679
+ options
3680
+ );
6439
3681
  }
6440
3682
  };
6441
3683
  }
@@ -6450,42 +3692,18 @@ var BrotliDecompressor;
6450
3692
  var init_brotli_decompressor = __esm({
6451
3693
  "../compression/src/brotli-decompressor.ts"() {
6452
3694
  "use strict";
6453
- init_compression();
3695
+ init_brotli_decompressor_compress_utils();
6454
3696
  init_decompression_stream();
6455
- BrotliDecompressor = class extends Decompressor {
6456
- name = "brotli";
6457
- extensions = ["br"];
6458
- contentEncodings = ["br"];
6459
- isSupported = true;
6460
- options;
6461
- fallback = null;
6462
- constructor(options = {}) {
6463
- super(options);
6464
- this.options = options;
6465
- }
6466
- /** Loads the injected or bundled JavaScript fallback. */
6467
- async preload(modules = {}) {
6468
- const fallback = await this.getFallback();
6469
- await fallback.preload({ ...this.options.modules, ...modules });
6470
- }
6471
- /** Decompresses with the built-in stream when available, then loads the bundled fallback. */
6472
- async decompress(input) {
3697
+ BrotliDecompressor = class extends BrotliCompressUtilsDecompressor {
3698
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
3699
+ async decompress(input, size) {
6473
3700
  if (this.options.useNative !== false) {
6474
3701
  const output = await decompressWithNativeDecompressionStream(input, "brotli");
6475
3702
  if (output) return output;
6476
3703
  }
6477
- const fallback = await this.getFallback();
6478
- await fallback.preload(this.options.modules);
6479
- return fallback.decompressSync(input);
6480
- }
6481
- /** Decompresses synchronously after the fallback has been preloaded. */
6482
- decompressSync(input) {
6483
- if (!this.fallback) {
6484
- throw new Error("brotli: call preload() before synchronous decompression");
6485
- }
6486
- return this.fallback.decompressSync(input);
3704
+ return super.decompress(input, size);
6487
3705
  }
6488
- /** Decompresses batches with a built-in stream or the bundled fallback. */
3706
+ /** Streams native batches when available, otherwise uses the WASM stream. */
6489
3707
  async *decompressBatches(inputBatches) {
6490
3708
  if (this.options.useNative !== false) {
6491
3709
  const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "brotli");
@@ -6494,46 +3712,21 @@ var init_brotli_decompressor = __esm({
6494
3712
  return;
6495
3713
  }
6496
3714
  }
6497
- yield this.decompress(await this.concatenate(inputBatches));
6498
- }
6499
- async getFallback() {
6500
- if (!this.fallback) {
6501
- const { BrotliCompression: BrotliCompression2 } = await Promise.resolve().then(() => (init_brotli_compression(), brotli_compression_exports));
6502
- this.fallback = new BrotliCompression2(this.options);
6503
- }
6504
- return this.fallback;
3715
+ yield* super.decompressBatches(inputBatches);
6505
3716
  }
6506
3717
  };
6507
3718
  }
6508
3719
  });
6509
3720
 
6510
- // ../compression/src/snappy-decompressor-snappyjs.ts
6511
- var SnappyJSDecompressor;
6512
- var init_snappy_decompressor_snappyjs = __esm({
6513
- "../compression/src/snappy-decompressor-snappyjs.ts"() {
3721
+ // ../compression/src/snappy-decompressor-compress-utils.ts
3722
+ var SnappyCompressUtilsDecompressor;
3723
+ var init_snappy_decompressor_compress_utils = __esm({
3724
+ "../compression/src/snappy-decompressor-compress-utils.ts"() {
6514
3725
  "use strict";
6515
- init_compression();
6516
- init_src2();
6517
- SnappyJSDecompressor = class extends Decompressor {
6518
- name = "snappy";
6519
- extensions = [];
6520
- contentEncodings = [];
6521
- isSupported = true;
3726
+ init_compress_utils_compression();
3727
+ SnappyCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
6522
3728
  constructor(options = {}) {
6523
- super(options);
6524
- registerJSModules(options.modules);
6525
- }
6526
- /** Loads snappyjs when it has not been injected. */
6527
- async preload(modules = {}) {
6528
- registerJSModules(modules);
6529
- if (!getJSModuleOrNull("snappyjs")) {
6530
- const snappy = await import("snappyjs");
6531
- registerJSModules({ snappyjs: snappy.default || snappy });
6532
- }
6533
- }
6534
- /** Decompresses one Snappy payload synchronously after preload. */
6535
- decompressSync(input) {
6536
- return getJSModule("snappyjs", this.name).uncompress(input);
3729
+ super({ name: "snappy" }, () => import("compress-utils/snappy/decompress"), options);
6537
3730
  }
6538
3731
  };
6539
3732
  }
@@ -6548,179 +3741,25 @@ var SnappyDecompressor;
6548
3741
  var init_snappy_decompressor = __esm({
6549
3742
  "../compression/src/snappy-decompressor.ts"() {
6550
3743
  "use strict";
6551
- init_snappy_decompressor_snappyjs();
6552
- SnappyDecompressor = class extends SnappyJSDecompressor {
3744
+ init_snappy_decompressor_compress_utils();
3745
+ SnappyDecompressor = class extends SnappyCompressUtilsDecompressor {
6553
3746
  };
6554
3747
  }
6555
3748
  });
6556
3749
 
6557
- // ../compression/src/lib/lz4-compression.ts
6558
- function readUInt32BE(data, offset) {
6559
- return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
6560
- }
6561
- var LZ4_MAGIC_NUMBER, LZ4Compression;
6562
- var init_lz4_compression = __esm({
6563
- "../compression/src/lib/lz4-compression.ts"() {
3750
+ // ../compression/src/lz4-decompressor-compress-utils.ts
3751
+ var LZ4CompressUtilsDecompressor;
3752
+ var init_lz4_decompressor_compress_utils = __esm({
3753
+ "../compression/src/lz4-decompressor-compress-utils.ts"() {
6564
3754
  "use strict";
6565
- init_src2();
6566
- init_compression();
6567
- LZ4_MAGIC_NUMBER = 407708164;
6568
- LZ4Compression = class extends Compression {
6569
- name = "lz4";
6570
- extensions = ["lz4"];
6571
- contentEncodings = ["x-lz4"];
6572
- isSupported = true;
6573
- options;
3755
+ init_compress_utils_compression();
3756
+ LZ4CompressUtilsDecompressor = class extends CompressUtilsDecompressor {
6574
3757
  constructor(options = {}) {
6575
- super(options);
6576
- this.options = options;
6577
- registerJSModules(options == null ? void 0 : options.modules);
6578
- }
6579
- async preload(modules = {}) {
6580
- registerJSModules(modules);
6581
- if (!getJSModuleOrNull("lz4js")) {
6582
- const lz4 = await import("lz4js");
6583
- registerJSModules({ lz4js: lz4.default || lz4 });
6584
- }
6585
- }
6586
- compressSync(input) {
6587
- const lz4js = getJSModule("lz4js", this.name);
6588
- const inputArray = new Uint8Array(input);
6589
- return lz4js.compress(inputArray).buffer;
6590
- }
6591
- async compress(input) {
6592
- await this.preload();
6593
- return this.compressSync(input);
6594
- }
6595
- /**
6596
- * Decompresses an ArrayBuffer containing an Lz4 frame. maxSize is optional; if not
6597
- * provided, a maximum size will be determined by examining the data. The
6598
- * returned ArrayBuffer will always be perfectly sized.
6599
- * If data provided without magic number we will parse it as block
6600
- */
6601
- decompressSync(data, maxSize) {
6602
- try {
6603
- const isMagicNumberExists = this.checkMagicNumber(data);
6604
- const inputArray = new Uint8Array(data);
6605
- if (isMagicNumberExists) {
6606
- const lz4js = getJSModule("lz4js", this.name);
6607
- return lz4js.decompress(inputArray, maxSize).buffer;
6608
- }
6609
- if (!maxSize) {
6610
- const error = new Error("Need to provide maxSize");
6611
- throw this.improveError(error);
6612
- }
6613
- let uncompressed = new Uint8Array(maxSize);
6614
- const hadoopSize = this.decodeHadoopBlocks(inputArray, uncompressed);
6615
- if (hadoopSize !== null) {
6616
- return toArrayBuffer2(
6617
- hadoopSize === uncompressed.byteLength ? uncompressed : uncompressed.subarray(0, hadoopSize)
6618
- );
6619
- }
6620
- const uncompressedSize = this.decodeBlock(inputArray, uncompressed);
6621
- if (uncompressedSize < 0 || uncompressedSize > maxSize) {
6622
- throw new Error(`Invalid LZ4 block at byte ${Math.abs(uncompressedSize)}`);
6623
- }
6624
- return toArrayBuffer2(
6625
- uncompressedSize === uncompressed.byteLength ? uncompressed : uncompressed.subarray(0, uncompressedSize)
6626
- );
6627
- } catch (error) {
6628
- throw this.improveError(error);
6629
- }
6630
- }
6631
- async decompress(data, maxSize) {
6632
- const isMagicNumberExists = this.checkMagicNumber(data);
6633
- if (!isMagicNumberExists) {
6634
- return this.decompressSync(data, maxSize);
6635
- }
6636
- await this.preload();
6637
- return this.decompressSync(data, maxSize);
6638
- }
6639
- /**
6640
- * Decodes the legacy Hadoop LZ4 block stream used by older Parquet writers.
6641
- * Returns null when the input is not a valid Hadoop-framed stream.
6642
- */
6643
- decodeHadoopBlocks(data, output) {
6644
- let inputOffset = 0;
6645
- let outputOffset = 0;
6646
- while (inputOffset < data.length) {
6647
- if (data.length - inputOffset < 8) {
6648
- return null;
6649
- }
6650
- const uncompressedByteLength = readUInt32BE(data, inputOffset);
6651
- const compressedByteLength = readUInt32BE(data, inputOffset + 4);
6652
- inputOffset += 8;
6653
- if (uncompressedByteLength === 0 || compressedByteLength === 0 || inputOffset + compressedByteLength > data.length || outputOffset + uncompressedByteLength > output.length) {
6654
- return null;
6655
- }
6656
- const compressedBlock = data.subarray(inputOffset, inputOffset + compressedByteLength);
6657
- const outputBlock = output.subarray(outputOffset, outputOffset + uncompressedByteLength);
6658
- const decodedByteLength = this.decodeBlock(compressedBlock, outputBlock);
6659
- if (decodedByteLength !== uncompressedByteLength) {
6660
- return null;
6661
- }
6662
- inputOffset += compressedByteLength;
6663
- outputOffset += uncompressedByteLength;
6664
- }
6665
- return outputOffset;
6666
- }
6667
- /**
6668
- * Decode lz4 file as block
6669
- * Solution taken from here
6670
- * https://github.com/pierrec/node-lz4/blob/0dac687262403fd34f905b963da7220692f2a4a1/lib/binding.js#L25
6671
- * @param input
6672
- * @param output
6673
- * @param startIndex
6674
- * @param endIndex
6675
- */
6676
- decodeBlock(data, output, startIndex, endIndex) {
6677
- startIndex = startIndex || 0;
6678
- endIndex = endIndex || data.length - startIndex;
6679
- let uncompressedSize = 0;
6680
- for (let index = startIndex; index < endIndex; ) {
6681
- const token = data[index++];
6682
- let literalsLength = token >> 4;
6683
- if (literalsLength > 0) {
6684
- let length2 = literalsLength + 240;
6685
- while (length2 === 255) {
6686
- length2 = data[index++];
6687
- literalsLength += length2;
6688
- }
6689
- const end2 = index + literalsLength;
6690
- while (index < end2) {
6691
- output[uncompressedSize++] = data[index++];
6692
- }
6693
- if (index === endIndex) {
6694
- return uncompressedSize;
6695
- }
6696
- }
6697
- const offset = data[index++] | data[index++] << 8;
6698
- if (offset === 0 || offset > uncompressedSize) {
6699
- return -(index - 2);
6700
- }
6701
- let matchLength = token & 15;
6702
- let length = matchLength + 240;
6703
- while (length === 255) {
6704
- length = data[index++];
6705
- matchLength += length;
6706
- }
6707
- let pos = uncompressedSize - offset;
6708
- const end = uncompressedSize + matchLength + 4;
6709
- while (uncompressedSize < end) {
6710
- output[uncompressedSize++] = output[pos++];
6711
- }
6712
- }
6713
- return uncompressedSize;
6714
- }
6715
- /**
6716
- * Compare file magic with lz4 magic number
6717
- * @param input
6718
- */
6719
- checkMagicNumber(data) {
6720
- if (data.byteLength < 4) return false;
6721
- const bytes = new Uint8Array(data, 0, 4);
6722
- const magic = (bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24) >>> 0;
6723
- return magic === LZ4_MAGIC_NUMBER;
3758
+ super(
3759
+ { name: "lz4", extensions: ["lz4"], contentEncodings: ["x-lz4"] },
3760
+ () => options.raw ? import("compress-utils/lz4_raw/decompress") : import("compress-utils/lz4/decompress"),
3761
+ options
3762
+ );
6724
3763
  }
6725
3764
  };
6726
3765
  }
@@ -6735,154 +3774,105 @@ var LZ4Decompressor;
6735
3774
  var init_lz4_decompressor = __esm({
6736
3775
  "../compression/src/lz4-decompressor.ts"() {
6737
3776
  "use strict";
3777
+ init_lz4_decompressor_compress_utils();
6738
3778
  init_compression();
6739
- init_lz4_compression();
6740
3779
  LZ4Decompressor = class extends Decompressor {
3780
+ /** Codec name. */
6741
3781
  name = "lz4";
3782
+ /** Recognized extensions. */
6742
3783
  extensions = ["lz4"];
3784
+ /** Recognized content encodings. */
6743
3785
  contentEncodings = ["x-lz4"];
3786
+ /** The optional WASM implementation is available after preload. */
6744
3787
  isSupported = true;
6745
- implementation;
3788
+ /** Decoder for framed payloads. */
3789
+ framed;
3790
+ /** Decoder for raw blocks. */
3791
+ raw;
3792
+ /** Whether to bypass format detection. */
3793
+ useRaw;
3794
+ /** Maximum caller-provided capacity before raw/Hadoop decoding allocates. */
3795
+ maximumCapacity;
3796
+ /** Creates lazy framed and raw decoder bindings. */
6746
3797
  constructor(options = {}) {
6747
3798
  super(options);
6748
- this.implementation = new LZ4Compression(options);
3799
+ this.framed = new LZ4CompressUtilsDecompressor({ ...options, raw: false });
3800
+ this.raw = new LZ4CompressUtilsDecompressor({ ...options, raw: true });
3801
+ this.useRaw = Boolean(options.raw);
3802
+ this.maximumCapacity = options.maxOutputByteLength ?? 512 * 1024 * 1024;
6749
3803
  }
6750
- /** Preloads lz4js for frame decoding; block decoding does not require it. */
3804
+ /** Initializes both decoder entry points for synchronous format detection. */
6751
3805
  async preload(modules = {}) {
6752
- await this.implementation.preload(modules);
3806
+ await Promise.all([this.framed.preload(modules), this.raw.preload(modules)]);
6753
3807
  }
6754
- /** Decompresses an LZ4 frame or block. */
3808
+ /** Loads the codecs and decodes one frame or bounded block. */
6755
3809
  async decompress(input, size) {
6756
- return this.implementation.decompress(input, size);
3810
+ await this.preload();
3811
+ return this.decompressSync(input, size);
6757
3812
  }
6758
- /** Decompresses an LZ4 frame or block synchronously. */
3813
+ /** Decodes one payload after preload; raw blocks require output capacity. */
6759
3814
  decompressSync(input, size) {
6760
- return this.implementation.decompressSync(input, size);
6761
- }
6762
- };
6763
- }
6764
- });
6765
-
6766
- // ../compression/src/zstd-decompressor-fzstd.ts
6767
- var import_fzstd, ZstdFzstdDecompressor;
6768
- var init_zstd_decompressor_fzstd = __esm({
6769
- "../compression/src/zstd-decompressor-fzstd.ts"() {
6770
- "use strict";
6771
- init_compression();
6772
- import_fzstd = require("fzstd");
6773
- ZstdFzstdDecompressor = class extends Decompressor {
6774
- name = "zstd";
6775
- extensions = ["zst"];
6776
- contentEncodings = ["zstd"];
6777
- isSupported = true;
6778
- constructor(options = {}) {
6779
- super(options);
3815
+ if (!this.useRaw && input.byteLength >= 4 && new DataView(input).getUint32(0, true) === 407708164) {
3816
+ return this.framed.decompressSync(input, size);
3817
+ }
3818
+ if (!Number.isSafeInteger(size) || size < 0 || size > this.maximumCapacity)
3819
+ throw new RangeError("lz4: provide a valid output capacity");
3820
+ if (!this.useRaw) {
3821
+ const hadoopOutput = this.decodeHadoopBlocks(input, size);
3822
+ if (hadoopOutput) return hadoopOutput;
3823
+ }
3824
+ return this.raw.decompressSync(input, size);
6780
3825
  }
6781
- /** Decompresses one Zstandard frame synchronously. */
6782
- decompressSync(input) {
6783
- return (0, import_fzstd.decompress)(new Uint8Array(input)).slice().buffer;
3826
+ /** Validates the legacy Hadoop lengths in TypeScript before decoding each raw block. */
3827
+ decodeHadoopBlocks(input, capacity) {
3828
+ const view = new DataView(input);
3829
+ const blocks = [];
3830
+ let inputOffset = 0;
3831
+ let outputOffset = 0;
3832
+ try {
3833
+ while (inputOffset < input.byteLength) {
3834
+ if (input.byteLength - inputOffset < 8) return null;
3835
+ const blockSize = view.getUint32(inputOffset, false);
3836
+ const chunkSize = view.getUint32(inputOffset + 4, false);
3837
+ inputOffset += 8;
3838
+ if (!blockSize || !chunkSize || blockSize > capacity - outputOffset || chunkSize > input.byteLength - inputOffset)
3839
+ return null;
3840
+ const decoded = new Uint8Array(
3841
+ this.raw.decompressSync(input.slice(inputOffset, inputOffset + chunkSize), blockSize)
3842
+ );
3843
+ if (decoded.length !== blockSize) return null;
3844
+ blocks.push(decoded);
3845
+ outputOffset += blockSize;
3846
+ inputOffset += chunkSize;
3847
+ }
3848
+ const output = new Uint8Array(outputOffset);
3849
+ let offset = 0;
3850
+ for (const block of blocks) {
3851
+ output.set(block, offset);
3852
+ offset += block.length;
3853
+ }
3854
+ return output.buffer;
3855
+ } catch {
3856
+ return null;
3857
+ }
6784
3858
  }
6785
3859
  };
6786
3860
  }
6787
3861
  });
6788
3862
 
6789
- // ../compression/src/zstd-fallback.ts
6790
- var zstd_fallback_exports = {};
6791
- __export(zstd_fallback_exports, {
6792
- decompressZstd: () => decompressZstd
6793
- });
6794
- function decompressZstd(input) {
6795
- return (0, import_fzstd2.decompress)(input);
6796
- }
6797
- var import_fzstd2;
6798
- var init_zstd_fallback = __esm({
6799
- "../compression/src/zstd-fallback.ts"() {
6800
- "use strict";
6801
- import_fzstd2 = require("fzstd");
6802
- }
6803
- });
6804
-
6805
- // ../compression/src/lib/zstd-compression.ts
6806
- var zstd_compression_exports = {};
6807
- __export(zstd_compression_exports, {
6808
- ZstdCompression: () => ZstdCompression
6809
- });
6810
- var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
6811
- var init_zstd_compression = __esm({
6812
- "../compression/src/lib/zstd-compression.ts"() {
3863
+ // ../compression/src/zstd-decompressor-compress-utils.ts
3864
+ var ZstdCompressUtilsDecompressor;
3865
+ var init_zstd_decompressor_compress_utils = __esm({
3866
+ "../compression/src/zstd-decompressor-compress-utils.ts"() {
6813
3867
  "use strict";
6814
- init_compression();
6815
- init_src2();
6816
- init_compression_stream();
6817
- init_decompression_stream();
6818
- CHUNK_SIZE = 1e6;
6819
- ZstdCompression = class extends Compression {
6820
- name = "zstd";
6821
- extensions = [];
6822
- contentEncodings = [];
6823
- isSupported = true;
6824
- options;
6825
- /**
6826
- * zstd-codec is an injectable dependency due to big size
6827
- * @param options
6828
- */
3868
+ init_compress_utils_compression();
3869
+ ZstdCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
6829
3870
  constructor(options = {}) {
6830
- super(options);
6831
- this.options = options;
6832
- registerJSModules(options == null ? void 0 : options.modules);
6833
- }
6834
- async preload(modules = {}) {
6835
- registerJSModules(modules);
6836
- const ZstdCodec = getJSModuleOrNull("zstd-codec");
6837
- if (!zstdPromise && ZstdCodec) {
6838
- zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
6839
- }
6840
- if (zstdPromise) {
6841
- zstd = await zstdPromise;
6842
- }
6843
- }
6844
- compressSync(input) {
6845
- getJSModule("zstd-codec", this.name);
6846
- const simpleZstd = new zstd.Simple();
6847
- const inputArray = new Uint8Array(input);
6848
- return simpleZstd.compress(inputArray).buffer;
6849
- }
6850
- async compress(input) {
6851
- var _a;
6852
- if (this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
6853
- const nativeOutput = await compressWithNativeCompressionStream(input, "zstd");
6854
- if (nativeOutput) return nativeOutput;
6855
- }
6856
- await this.preload();
6857
- return this.compressSync(input);
6858
- }
6859
- decompressSync(input) {
6860
- getJSModule("zstd-codec", this.name);
6861
- const simpleZstd = new zstd.Simple();
6862
- const inputArray = new Uint8Array(input);
6863
- return simpleZstd.decompress(inputArray).buffer;
6864
- }
6865
- async decompress(input, size) {
6866
- var _a;
6867
- if (!getJSModuleOrNull("zstd-codec") && this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
6868
- const nativeOutput = await decompressWithNativeDecompressionStream(input, "zstd");
6869
- if (nativeOutput) return nativeOutput;
6870
- }
6871
- await this.preload();
6872
- const inputArray = new Uint8Array(input);
6873
- if (!zstd) {
6874
- const { decompressZstd: decompressZstd2 } = await Promise.resolve().then(() => (init_zstd_fallback(), zstd_fallback_exports));
6875
- return ensureArrayBuffer(decompressZstd2(inputArray));
6876
- }
6877
- const simpleZstd = new zstd.Streaming();
6878
- const chunks = [];
6879
- for (let i = 0; i <= inputArray.length; i += CHUNK_SIZE) {
6880
- const chunkView = inputArray.subarray(i, i + CHUNK_SIZE);
6881
- const chunkArrayBuffer = ensureArrayBuffer(chunkView);
6882
- chunks.push(new Uint8Array(chunkArrayBuffer));
6883
- }
6884
- const decompressResult = await simpleZstd.decompressChunks(chunks);
6885
- return decompressResult.buffer;
3871
+ super(
3872
+ { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] },
3873
+ () => import("compress-utils/zstd/decompress"),
3874
+ options
3875
+ );
6886
3876
  }
6887
3877
  };
6888
3878
  }
@@ -6897,48 +3887,18 @@ var ZstdDecompressor;
6897
3887
  var init_zstd_decompressor = __esm({
6898
3888
  "../compression/src/zstd-decompressor.ts"() {
6899
3889
  "use strict";
6900
- init_zstd_decompressor_fzstd();
3890
+ init_zstd_decompressor_compress_utils();
6901
3891
  init_decompression_stream();
6902
- init_src2();
6903
- ZstdDecompressor = class extends ZstdFzstdDecompressor {
6904
- options;
6905
- compatibility = null;
6906
- constructor(options = {}) {
6907
- super(options);
6908
- this.options = options;
6909
- registerJSModules(options.modules);
6910
- }
6911
- /** Preloads an injected zstd-codec implementation when supplied. */
6912
- async preload(modules = {}) {
6913
- registerJSModules(modules);
6914
- if (getJSModuleOrNull("zstd-codec")) {
6915
- const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports));
6916
- this.compatibility ||= new ZstdCompression2(this.options);
6917
- await this.compatibility.preload(modules);
6918
- }
6919
- }
6920
- /** Decompresses with the built-in stream when available, then falls back to fzstd. */
6921
- async decompress(input) {
3892
+ ZstdDecompressor = class extends ZstdCompressUtilsDecompressor {
3893
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
3894
+ async decompress(input, size) {
6922
3895
  if (this.options.useNative !== false) {
6923
3896
  const output = await decompressWithNativeDecompressionStream(input, "zstd");
6924
3897
  if (output) return output;
6925
3898
  }
6926
- if (getJSModuleOrNull("zstd-codec")) {
6927
- await this.preload(this.options.modules);
6928
- }
6929
- return this.decompressSync(input);
6930
- }
6931
- /** Decompresses with a preloaded zstd-codec implementation or compact fzstd. */
6932
- decompressSync(input) {
6933
- if (this.compatibility) {
6934
- return this.compatibility.decompressSync(input);
6935
- }
6936
- if (getJSModuleOrNull("zstd-codec")) {
6937
- throw new Error("zstd: call preload() before synchronous decompression with zstd-codec");
6938
- }
6939
- return super.decompressSync(input);
3899
+ return super.decompress(input, size);
6940
3900
  }
6941
- /** Decompresses batches with a built-in stream or compact fzstd fallback. */
3901
+ /** Streams native batches when available, otherwise uses the WASM stream. */
6942
3902
  async *decompressBatches(inputBatches) {
6943
3903
  if (this.options.useNative !== false) {
6944
3904
  const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
@@ -6947,69 +3907,12 @@ var init_zstd_decompressor = __esm({
6947
3907
  return;
6948
3908
  }
6949
3909
  }
6950
- if (getJSModuleOrNull("zstd-codec")) {
6951
- yield this.decompress(await this.concatenate(inputBatches));
6952
- return;
6953
- }
6954
3910
  yield* super.decompressBatches(inputBatches);
6955
3911
  }
6956
3912
  };
6957
3913
  }
6958
3914
  });
6959
3915
 
6960
- // ../compression/src/lib/compress-utils-compression.ts
6961
- async function* transformBatches2(stream, inputBatches) {
6962
- try {
6963
- for await (const input of inputBatches) {
6964
- const output2 = stream.write(new Uint8Array(input));
6965
- if (output2.byteLength > 0) yield copyArrayBuffer(output2);
6966
- }
6967
- const output = stream.finish();
6968
- if (output.byteLength > 0) yield copyArrayBuffer(output);
6969
- } finally {
6970
- stream.destroy();
6971
- }
6972
- }
6973
- function copyArrayBuffer(bytes) {
6974
- return bytes.slice().buffer;
6975
- }
6976
- var CompressUtilsDecompressor;
6977
- var init_compress_utils_compression = __esm({
6978
- "../compression/src/lib/compress-utils-compression.ts"() {
6979
- "use strict";
6980
- init_compression();
6981
- CompressUtilsDecompressor = class extends Decompressor {
6982
- name;
6983
- extensions;
6984
- contentEncodings;
6985
- isSupported = true;
6986
- options;
6987
- loadModule;
6988
- /** Creates a format-specific compress-utils decoder. */
6989
- constructor(metadata, loadModule, options = {}) {
6990
- super(options);
6991
- this.name = metadata.name;
6992
- this.extensions = metadata.extensions || [];
6993
- this.contentEncodings = metadata.contentEncodings || [];
6994
- this.loadModule = loadModule;
6995
- this.options = options;
6996
- }
6997
- /** Decompresses one buffer with the selected compress-utils decoder. */
6998
- async decompress(input) {
6999
- const module2 = await this.loadModule();
7000
- const output = await module2.decompress(new Uint8Array(input), this.options.compressUtils);
7001
- return copyArrayBuffer(output);
7002
- }
7003
- /** Incrementally decompresses input batches with compress-utils. */
7004
- async *decompressBatches(inputBatches) {
7005
- const module2 = await this.loadModule();
7006
- const stream = await module2.createDecompressStream();
7007
- yield* transformBatches2(stream, inputBatches);
7008
- }
7009
- };
7010
- }
7011
- });
7012
-
7013
3916
  // ../compression/src/bzip2-decompressor-compress-utils.ts
7014
3917
  var BZip2CompressUtilsDecompressor;
7015
3918
  var init_bzip2_decompressor_compress_utils = __esm({
@@ -7076,13 +3979,43 @@ var init_xz_decompressor = __esm({
7076
3979
  }
7077
3980
  });
7078
3981
 
3982
+ // ../compression/src/lzo-decompressor-compress-utils.ts
3983
+ var LzoCompressUtilsDecompressor;
3984
+ var init_lzo_decompressor_compress_utils = __esm({
3985
+ "../compression/src/lzo-decompressor-compress-utils.ts"() {
3986
+ "use strict";
3987
+ init_compress_utils_compression();
3988
+ LzoCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
3989
+ /** Creates a lazy decoder; neither an encoder nor container framing is included. */
3990
+ constructor(options = {}) {
3991
+ super(
3992
+ { name: "lzo" },
3993
+ async () => await import("compress-utils/lzo/decompress"),
3994
+ options
3995
+ );
3996
+ }
3997
+ };
3998
+ }
3999
+ });
4000
+
4001
+ // ../compression/src/lzo-decompressor.ts
4002
+ var lzo_decompressor_exports = {};
4003
+ __export(lzo_decompressor_exports, {
4004
+ LzoDecompressor: () => LzoCompressUtilsDecompressor
4005
+ });
4006
+ var init_lzo_decompressor = __esm({
4007
+ "../compression/src/lzo-decompressor.ts"() {
4008
+ "use strict";
4009
+ init_lzo_decompressor_compress_utils();
4010
+ }
4011
+ });
4012
+
7079
4013
  // ../compression/src/default-codecs.ts
7080
- var DEFLATE, GZIP, BROTLI, SNAPPY, LZ4, ZSTD, BZIP2, XZ, DeflateDecompressor2, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2, BZip2Decompressor2, XZDecompressor2;
4014
+ var DEFLATE, GZIP, BROTLI, SNAPPY, LZ4, ZSTD, BZIP2, XZ, DeflateDecompressor2, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2, BZip2Decompressor2, XZDecompressor2, LzoDecompressor;
7081
4015
  var init_default_codecs = __esm({
7082
4016
  "../compression/src/default-codecs.ts"() {
7083
4017
  "use strict";
7084
4018
  init_lazy_compression();
7085
- init_src2();
7086
4019
  DEFLATE = { name: "deflate", extensions: [], contentEncodings: ["deflate"] };
7087
4020
  GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
7088
4021
  BROTLI = { name: "brotli", extensions: ["br"], contentEncodings: ["br"] };
@@ -7117,11 +4050,7 @@ var init_default_codecs = __esm({
7117
4050
  BROTLI,
7118
4051
  async () => (await Promise.resolve().then(() => (init_brotli_decompressor(), brotli_decompressor_exports))).BrotliDecompressor,
7119
4052
  options,
7120
- "brotli",
7121
- (preloadOptions) => {
7122
- var _a;
7123
- return !((_a = preloadOptions.modules) == null ? void 0 : _a.brotli) && !getJSModuleOrNull("brotli");
7124
- }
4053
+ "brotli"
7125
4054
  );
7126
4055
  }
7127
4056
  };
@@ -7141,11 +4070,7 @@ var init_default_codecs = __esm({
7141
4070
  ZSTD,
7142
4071
  async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
7143
4072
  options,
7144
- "zstd",
7145
- (preloadOptions) => {
7146
- var _a;
7147
- return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
7148
- }
4073
+ "zstd"
7149
4074
  );
7150
4075
  }
7151
4076
  };
@@ -7159,6 +4084,16 @@ var init_default_codecs = __esm({
7159
4084
  super(XZ, async () => (await Promise.resolve().then(() => (init_xz_decompressor(), xz_decompressor_exports))).XZDecompressor, options);
7160
4085
  }
7161
4086
  };
4087
+ LzoDecompressor = class extends LazyDecompressor {
4088
+ /** Retains options until the decoder is needed. */
4089
+ constructor(options = {}) {
4090
+ super(
4091
+ { name: "lzo", extensions: [], contentEncodings: [] },
4092
+ async () => (await Promise.resolve().then(() => (init_lzo_decompressor(), lzo_decompressor_exports))).LzoDecompressor,
4093
+ options
4094
+ );
4095
+ }
4096
+ };
7162
4097
  }
7163
4098
  });
7164
4099
 
@@ -7166,7 +4101,6 @@ var init_default_codecs = __esm({
7166
4101
  var init_src3 = __esm({
7167
4102
  "../compression/src/index.ts"() {
7168
4103
  "use strict";
7169
- init_compression();
7170
4104
  init_default_codecs();
7171
4105
  }
7172
4106
  });
@@ -8864,60 +5798,6 @@ var init_src6 = __esm({
8864
5798
  }
8865
5799
  });
8866
5800
 
8867
- // ../gis/src/lib/geoarrow/metadata-utils.ts
8868
- var init_metadata_utils = __esm({
8869
- "../gis/src/lib/geoarrow/metadata-utils.ts"() {
8870
- "use strict";
8871
- init_src4();
8872
- }
8873
- });
8874
-
8875
- // ../gis/src/lib/geoarrow/geoparquet-metadata.ts
8876
- function getGeoMetadata2(metadata) {
8877
- if (!metadata) {
8878
- return null;
8879
- }
8880
- const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
8881
- const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata2(stringifiedGeoMetadata);
8882
- if (!geoMetadata) {
8883
- return null;
8884
- }
8885
- for (const column of Object.values(geoMetadata.columns || {})) {
8886
- if (column.encoding) {
8887
- column.encoding = column.encoding.toLowerCase();
8888
- }
8889
- }
8890
- return geoMetadata;
8891
- }
8892
- function parseJSONStringMetadata2(stringifiedMetadata) {
8893
- if (!stringifiedMetadata) {
8894
- return null;
8895
- }
8896
- try {
8897
- const metadata = JSON.parse(stringifiedMetadata);
8898
- if (!metadata || typeof metadata !== "object") {
8899
- return null;
8900
- }
8901
- return metadata;
8902
- } catch {
8903
- return null;
8904
- }
8905
- }
8906
- var init_geoparquet_metadata = __esm({
8907
- "../gis/src/lib/geoarrow/geoparquet-metadata.ts"() {
8908
- "use strict";
8909
- init_metadata_utils();
8910
- }
8911
- });
8912
-
8913
- // ../gis/src/index.ts
8914
- var init_src7 = __esm({
8915
- "../gis/src/index.ts"() {
8916
- "use strict";
8917
- init_geoparquet_metadata();
8918
- }
8919
- });
8920
-
8921
5801
  // ../parquet/src/lib/arrow/convert-schema-from-parquet.ts
8922
5802
  function convertParquetSchema(parquetSchema, parquetMetadata, options) {
8923
5803
  const fields = getFields(parquetSchema.schema, options);
@@ -9217,14 +6097,45 @@ async function getSchemaFromParquetReader(reader) {
9217
6097
  const schema = convertParquetSchema(parquetSchema, parquetMetadata, {
9218
6098
  int96AsTimestamp: reader.int96AsTimestamp
9219
6099
  });
6100
+ restoreEmbeddedArrowMetadata(schema);
9220
6101
  applyGeoParquetToFieldMetadata(schema);
9221
6102
  unpackGeoMetadata(schema.metadata);
9222
6103
  unpackJSONStringMetadata(schema.metadata, "pandas");
9223
6104
  return schema;
9224
6105
  }
6106
+ function restoreEmbeddedArrowMetadata(schema) {
6107
+ var _a;
6108
+ const encodedSchema = (_a = schema.metadata) == null ? void 0 : _a["ARROW:schema"];
6109
+ if (typeof encodedSchema !== "string") {
6110
+ return;
6111
+ }
6112
+ try {
6113
+ const bytes = Uint8Array.from(atob(encodedSchema), (character) => character.charCodeAt(0));
6114
+ const embeddedSchema = arrow9.RecordBatchReader.from(bytes).open().schema;
6115
+ if (embeddedSchema) {
6116
+ schema.metadata = { ...Object.fromEntries(embeddedSchema.metadata), ...schema.metadata };
6117
+ restoreArrowFieldMetadata(schema.fields, embeddedSchema.fields);
6118
+ }
6119
+ } catch {
6120
+ }
6121
+ }
6122
+ function restoreArrowFieldMetadata(fields, arrowFields) {
6123
+ for (const field of fields) {
6124
+ const arrowField = arrowFields.find((candidate) => candidate.name === field.name);
6125
+ if (!arrowField) {
6126
+ continue;
6127
+ }
6128
+ field.metadata = { ...Object.fromEntries(arrowField.metadata), ...field.metadata };
6129
+ if (typeof field.type === "object" && "children" in field.type && arrowField.type.children) {
6130
+ restoreArrowFieldMetadata(field.type.children, arrowField.type.children);
6131
+ }
6132
+ }
6133
+ }
6134
+ var arrow9;
9225
6135
  var init_get_parquet_schema = __esm({
9226
6136
  "../parquet/src/lib/parsers/get-parquet-schema.ts"() {
9227
6137
  "use strict";
6138
+ arrow9 = __toESM(require("apache-arrow"), 1);
9228
6139
  init_src4();
9229
6140
  init_convert_schema_from_parquet();
9230
6141
  init_geospatial_metadata();
@@ -9400,7 +6311,7 @@ function toUint8Array2(binary) {
9400
6311
  }
9401
6312
  return new Uint8Array(binary);
9402
6313
  }
9403
- function toArrayBuffer4(binary) {
6314
+ function toArrayBuffer3(binary) {
9404
6315
  const bytes = toUint8Array2(binary);
9405
6316
  return bytes.slice().buffer;
9406
6317
  }
@@ -10223,8 +7134,8 @@ function mergeXxHash64(accumulator, value) {
10223
7134
  result = result * PRIME1 + PRIME4 & UINT64_MASK;
10224
7135
  return result;
10225
7136
  }
10226
- function rotateLeft(value, bits2) {
10227
- const shift = BigInt(bits2);
7137
+ function rotateLeft(value, bits) {
7138
+ const shift = BigInt(bits);
10228
7139
  return (value << shift | value >> 64n - shift) & UINT64_MASK;
10229
7140
  }
10230
7141
  function readUint32LE(value, offset) {
@@ -16061,7 +12972,7 @@ var init_parse_bson = __esm({
16061
12972
  });
16062
12973
 
16063
12974
  // ../bson/src/index.ts
16064
- var init_src8 = __esm({
12975
+ var init_src7 = __esm({
16065
12976
  "../bson/src/index.ts"() {
16066
12977
  "use strict";
16067
12978
  init_bson_writer();
@@ -16105,10 +13016,10 @@ function toPrimitive_FLOAT16(value) {
16105
13016
  throw new Error(`invalid value for FLOAT16: ${value}`);
16106
13017
  }
16107
13018
  const float32 = new Float32Array([numberValue]);
16108
- const bits2 = new Uint32Array(float32.buffer)[0];
16109
- const sign = bits2 >>> 16 & 32768;
16110
- const exponent = bits2 >>> 23 & 255;
16111
- const mantissa = bits2 & 8388607;
13019
+ const bits = new Uint32Array(float32.buffer)[0];
13020
+ const sign = bits >>> 16 & 32768;
13021
+ const exponent = bits >>> 23 & 255;
13022
+ const mantissa = bits & 8388607;
16112
13023
  let half;
16113
13024
  if (exponent === 255) {
16114
13025
  half = sign | 31744 | (mantissa ? 512 : 0);
@@ -16358,7 +13269,7 @@ function toPrimitive_BSON(value) {
16358
13269
  return toUint8Array2(arrayBuffer);
16359
13270
  }
16360
13271
  function fromPrimitive_BSON(value) {
16361
- return parseBSONSync(toArrayBuffer4(value));
13272
+ return parseBSONSync(toArrayBuffer3(value));
16362
13273
  }
16363
13274
  function toPrimitive_TIME_MILLIS(value) {
16364
13275
  const v = parseInt(value, 10);
@@ -16470,7 +13381,7 @@ var PARQUET_LOGICAL_TYPES, kMillisPerDay;
16470
13381
  var init_types = __esm({
16471
13382
  "../parquet/src/parquetjs/schema/types.ts"() {
16472
13383
  "use strict";
16473
- init_src8();
13384
+ init_src7();
16474
13385
  init_binary_utils();
16475
13386
  PARQUET_LOGICAL_TYPES = {
16476
13387
  BOOLEAN: {
@@ -17635,69 +14546,15 @@ var init_parquet_source_loader_types = __esm({
17635
14546
  }
17636
14547
  });
17637
14548
 
17638
- // ../compression/src/snappy-decompressor-hysnappy.ts
17639
- function readSnappyUncompressedLength(input) {
17640
- let value = 0;
17641
- let multiplier = 1;
17642
- for (let byteIndex = 0; byteIndex < Math.min(input.byteLength, 5); byteIndex++) {
17643
- const byte = input[byteIndex];
17644
- value += (byte & 127) * multiplier;
17645
- if ((byte & 128) === 0) {
17646
- if (!Number.isSafeInteger(value)) throw new Error("invalid Snappy uncompressed length");
17647
- return value;
17648
- }
17649
- multiplier *= 128;
17650
- }
17651
- throw new Error("invalid Snappy uncompressed length");
17652
- }
17653
- var sharedSnappyUncompressorPromise, SnappyHysnappyDecompressor;
17654
- var init_snappy_decompressor_hysnappy = __esm({
17655
- "../compression/src/snappy-decompressor-hysnappy.ts"() {
17656
- "use strict";
17657
- init_src2();
17658
- init_compression();
17659
- SnappyHysnappyDecompressor = class extends Decompressor {
17660
- /** Compression format name. */
17661
- name = "snappy";
17662
- /** Snappy does not have a standard standalone file extension. */
17663
- extensions = [];
17664
- /** Snappy does not have a standard HTTP content encoding. */
17665
- contentEncodings = [];
17666
- /** Whether the runtime can instantiate the embedded WASM decoder. */
17667
- isSupported = typeof WebAssembly !== "undefined";
17668
- /** Cached decoder instantiated by {@link preload}. */
17669
- uncompressor;
17670
- /** Loads and instantiates the embedded hysnappy WASM module once per JavaScript realm. */
17671
- async preload() {
17672
- if (!this.uncompressor) {
17673
- sharedSnappyUncompressorPromise ||= import("hysnappy").then(
17674
- (hysnappy) => hysnappy.snappyUncompressor()
17675
- );
17676
- this.uncompressor = await sharedSnappyUncompressorPromise;
17677
- }
17678
- }
17679
- /** Decompresses one Snappy payload synchronously after preload. */
17680
- decompressSync(input, size) {
17681
- if (!this.uncompressor) {
17682
- throw new Error("snappy hysnappy decoder has not been preloaded");
17683
- }
17684
- const bytes = new Uint8Array(input);
17685
- const outputLength = size ?? readSnappyUncompressedLength(bytes);
17686
- return toArrayBuffer2(this.uncompressor(bytes, outputLength));
17687
- }
17688
- };
17689
- }
17690
- });
17691
-
17692
14549
  // ../parquet/src/parquetjs/compression.ts
17693
14550
  async function preloadCompressions(options) {
17694
14551
  registerJSModules(options == null ? void 0 : options.modules);
17695
14552
  }
17696
- async function decompress3(method, value, size) {
14553
+ async function decompress(method, value, size) {
17697
14554
  if (!(method in PARQUET_COMPRESSION_METHODS)) {
17698
14555
  throw new Error(`parquet: invalid compression method: ${method}`);
17699
14556
  }
17700
- const inputArrayBuffer = toArrayBuffer4(value);
14557
+ const inputArrayBuffer = toArrayBuffer3(value);
17701
14558
  if (method === "UNCOMPRESSED") {
17702
14559
  return toUint8Array2(inputArrayBuffer);
17703
14560
  }
@@ -17708,7 +14565,7 @@ async function decompress3(method, value, size) {
17708
14565
  function createParquetPageDecompressor(method) {
17709
14566
  const decompressor = method === "UNCOMPRESSED" ? null : createParquetDecompressor(method);
17710
14567
  return async (value, size) => {
17711
- const inputArrayBuffer = toArrayBuffer4(value);
14568
+ const inputArrayBuffer = toArrayBuffer3(value);
17712
14569
  if (!decompressor) {
17713
14570
  return toUint8Array2(inputArrayBuffer);
17714
14571
  }
@@ -17721,10 +14578,12 @@ async function getParquetDecompressor(method) {
17721
14578
  }
17722
14579
  function createParquetDecompressor(method) {
17723
14580
  switch (method) {
14581
+ case "LZO":
14582
+ return new ParquetLzoDecompressor();
17724
14583
  case "GZIP":
17725
14584
  return new GZipDecompressor2();
17726
14585
  case "SNAPPY":
17727
- return new ParquetSnappyDecompressor();
14586
+ return new SnappyDecompressor2();
17728
14587
  case "BROTLI":
17729
14588
  return new BrotliDecompressor2();
17730
14589
  case "LZ4":
@@ -17736,12 +14595,11 @@ function createParquetDecompressor(method) {
17736
14595
  throw new Error(`parquet: invalid compression method: ${method}`);
17737
14596
  }
17738
14597
  }
17739
- var PARQUET_COMPRESSION_METHODS, ParquetSnappyDecompressor;
14598
+ var PARQUET_COMPRESSION_METHODS, ParquetLzoDecompressor;
17740
14599
  var init_compression2 = __esm({
17741
14600
  "../parquet/src/parquetjs/compression.ts"() {
17742
14601
  "use strict";
17743
14602
  init_src3();
17744
- init_snappy_decompressor_hysnappy();
17745
14603
  init_src2();
17746
14604
  init_binary_utils();
17747
14605
  PARQUET_COMPRESSION_METHODS = {
@@ -17749,36 +14607,59 @@ var init_compression2 = __esm({
17749
14607
  GZIP: true,
17750
14608
  SNAPPY: true,
17751
14609
  BROTLI: true,
17752
- // TODO: Understand difference between LZ4 and LZ4_RAW.
14610
+ LZO: true,
17753
14611
  LZ4: true,
17754
14612
  LZ4_RAW: true,
17755
14613
  ZSTD: true
17756
14614
  };
17757
- ParquetSnappyDecompressor = class extends Decompressor {
17758
- /** Compression format name. */
17759
- name = "snappy";
17760
- /** Snappy does not have a standard standalone file extension. */
17761
- extensions = [];
17762
- /** Snappy does not have a standard HTTP content encoding. */
17763
- contentEncodings = [];
17764
- /** snappyjs keeps this composite decoder available without WebAssembly. */
17765
- isSupported = true;
17766
- /** Preferred compact WASM decoder for page-sized frames. */
17767
- hysnappy = new SnappyHysnappyDecompressor();
17768
- /** Always-supported JavaScript decoder. */
17769
- snappyjs = new SnappyDecompressor2();
17770
- /** Whether this instance has selected the JavaScript fallback. */
17771
- useSnappyjs = !this.hysnappy.isSupported;
17772
- /** Decodes with hysnappy, retaining snappyjs after the first WASM setup or runtime failure. */
14615
+ ParquetLzoDecompressor = class extends LzoDecompressor {
14616
+ /** Prefers raw LZO1X and accepts complete, size-checked Hadoop block streams. */
17773
14617
  async decompress(input, size) {
17774
- if (!this.useSnappyjs) {
17775
- try {
17776
- return await this.hysnappy.decompress(input, size);
17777
- } catch {
17778
- this.useSnappyjs = true;
14618
+ try {
14619
+ return await super.decompress(input, size);
14620
+ } catch (error) {
14621
+ if (error instanceof RangeError || !Number.isSafeInteger(size) || size < 0 || size > 2147483647)
14622
+ throw error;
14623
+ const output = this.decodeHadoopBlocks(new Uint8Array(input), size);
14624
+ if (output === null) throw error;
14625
+ return output;
14626
+ }
14627
+ }
14628
+ /** Checks each block/chunk length and decodes chunks until their block size is satisfied. */
14629
+ decodeHadoopBlocks(input, size) {
14630
+ const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
14631
+ const chunks = [];
14632
+ let inputOffset = 0;
14633
+ let outputOffset = 0;
14634
+ try {
14635
+ while (inputOffset < input.length) {
14636
+ if (input.length - inputOffset < 4) return null;
14637
+ const blockSize = view.getUint32(inputOffset, false);
14638
+ inputOffset += 4;
14639
+ if (blockSize === 0) {
14640
+ return inputOffset === input.length && outputOffset === size ? concatenateArrayBuffers(...chunks) : null;
14641
+ }
14642
+ if (blockSize > size - outputOffset) return null;
14643
+ const blockEnd = outputOffset + blockSize;
14644
+ while (outputOffset < blockEnd) {
14645
+ if (input.length - inputOffset < 4) return null;
14646
+ const chunkSize = view.getUint32(inputOffset, false);
14647
+ inputOffset += 4;
14648
+ if (chunkSize === 0 || chunkSize > input.length - inputOffset) return null;
14649
+ const chunk = input.slice(inputOffset, inputOffset + chunkSize);
14650
+ inputOffset += chunkSize;
14651
+ const decoded = new Uint8Array(
14652
+ this.decompressSync(chunk.buffer, blockEnd - outputOffset)
14653
+ );
14654
+ if (decoded.length === 0) return null;
14655
+ chunks.push(decoded.buffer);
14656
+ outputOffset += decoded.length;
14657
+ }
17779
14658
  }
14659
+ return outputOffset === size ? concatenateArrayBuffers(...chunks) : null;
14660
+ } catch {
14661
+ return null;
17780
14662
  }
17781
- return await this.snappyjs.decompress(input, size);
17782
14663
  }
17783
14664
  };
17784
14665
  }
@@ -19893,7 +16774,6 @@ var init_codecs = __esm({
19893
16774
  init_dictionary();
19894
16775
  init_delta();
19895
16776
  init_byte_stream_split();
19896
- init_declare();
19897
16777
  PARQUET_CODECS = {
19898
16778
  PLAIN: {
19899
16779
  encodeValues,
@@ -21379,7 +18259,7 @@ async function decodeDataPage(cursor, header, context, target) {
21379
18259
  let dataCursor = cursor;
21380
18260
  if (context.compression !== "UNCOMPRESSED") {
21381
18261
  const compressedValues = cursor.buffer.slice(cursor.offset, cursorEnd);
21382
- const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, header.uncompressed_page_size) : await decompress3(context.compression, compressedValues, header.uncompressed_page_size);
18262
+ const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, header.uncompressed_page_size) : await decompress(context.compression, compressedValues, header.uncompressed_page_size);
21383
18263
  dataCursor = {
21384
18264
  buffer: valuesBuf,
21385
18265
  offset: 0,
@@ -21519,7 +18399,7 @@ async function decodeDataPageV2(cursor, header, context, target) {
21519
18399
  }
21520
18400
  let valuesBuffer = cursor.buffer.subarray(valuesOffset, cursorEnd);
21521
18401
  if (dataPageHeader.is_compressed !== false && context.compression !== "UNCOMPRESSED") {
21522
- valuesBuffer = context.decompressPage ? await context.decompressPage(valuesBuffer, valuesUncompressedByteLength) : await decompress3(context.compression, valuesBuffer, valuesUncompressedByteLength);
18402
+ valuesBuffer = context.decompressPage ? await context.decompressPage(valuesBuffer, valuesUncompressedByteLength) : await decompress(context.compression, valuesBuffer, valuesUncompressedByteLength);
21523
18403
  }
21524
18404
  cursor.offset = cursorEnd;
21525
18405
  return decodeDataPageV2Values(
@@ -21778,7 +18658,7 @@ async function decodeDictionaryPage(cursor, pageHeader, context) {
21778
18658
  cursor.offset = cursorEnd;
21779
18659
  if (context.compression !== "UNCOMPRESSED") {
21780
18660
  const compressedValues = dictCursor.buffer.subarray(dictCursor.offset);
21781
- const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, pageHeader.uncompressed_page_size) : await decompress3(context.compression, compressedValues, pageHeader.uncompressed_page_size);
18661
+ const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, pageHeader.uncompressed_page_size) : await decompress(context.compression, compressedValues, pageHeader.uncompressed_page_size);
21782
18662
  dictCursor = {
21783
18663
  buffer: valuesBuf,
21784
18664
  offset: 0,
@@ -22374,7 +19254,9 @@ var init_parquet_reader = __esm({
22374
19254
  async readBytes(start, length, signal) {
22375
19255
  const effectiveSignal = signal ?? this.props.signal;
22376
19256
  if (effectiveSignal == null ? void 0 : effectiveSignal.aborted) {
22377
- throw new Error("Request aborted");
19257
+ const error = new Error("Request aborted");
19258
+ error.name = "AbortError";
19259
+ throw error;
22378
19260
  }
22379
19261
  if (this.file.handle instanceof ArrayBuffer) {
22380
19262
  return new Uint8Array(this.file.handle, start, length);
@@ -23926,7 +20808,7 @@ var init_parquet_source_loader = __esm({
23926
20808
  init_src6();
23927
20809
  init_src2();
23928
20810
  init_src5();
23929
- init_src7();
20811
+ init_src4();
23930
20812
  init_get_parquet_schema();
23931
20813
  init_geoparquet_covering();
23932
20814
  init_parquet_bloom_filter();
@@ -24109,7 +20991,7 @@ var init_parquet_source_loader = __esm({
24109
20991
  );
24110
20992
  const projectedColumns = normalizeColumns(readOptions.columns, initialization.schema);
24111
20993
  const predicateColumns = physicalPlan.predicate ? getParquetPredicateColumns(physicalPlan.predicate) : [];
24112
- const geoMetadata = readOptions.bbox ? getGeoMetadata2(initialization.schema.metadata) : void 0;
20994
+ const geoMetadata = readOptions.bbox ? getGeoMetadata(initialization.schema.metadata) : void 0;
24113
20995
  const geometryColumn = readOptions.bbox ? readOptions.geometryColumn || (geoMetadata == null ? void 0 : geoMetadata.primary_column) : void 0;
24114
20996
  const filterColumns = [
24115
20997
  .../* @__PURE__ */ new Set([...predicateColumns, ...geometryColumn ? [geometryColumn] : []])
@@ -24939,7 +21821,7 @@ module.exports = __toCommonJS(iceberg_exports);
24939
21821
 
24940
21822
  // ../parquet/src/iceberg-table-source.ts
24941
21823
  init_src2();
24942
- var arrow9 = __toESM(require("apache-arrow"), 1);
21824
+ var arrow10 = __toESM(require("apache-arrow"), 1);
24943
21825
 
24944
21826
  // ../avro/src/lib/parsers/parse-avro.ts
24945
21827
  var arrow = __toESM(require("apache-arrow"), 1);
@@ -24952,7 +21834,7 @@ function toUint8Array(binary) {
24952
21834
  return new Uint8Array(binary.buffer, binary.byteOffset, binary.byteLength);
24953
21835
  return new Uint8Array(binary);
24954
21836
  }
24955
- function toArrayBuffer3(binary) {
21837
+ function toArrayBuffer2(binary) {
24956
21838
  return toUint8Array(binary).slice().buffer;
24957
21839
  }
24958
21840
  var decompressors = {};
@@ -24961,9 +21843,9 @@ async function decompressAvro(codec, value) {
24961
21843
  if (!isAvroCodec(codec)) throw new Error(`avro: unsupported compression codec "${codec}"`);
24962
21844
  const compression = getAvroDecompressor(codec);
24963
21845
  const compressedValue = codec === "snappy" ? value.subarray(0, -4) : value;
24964
- const output = toUint8Array(await compression.decompress(toArrayBuffer3(compressedValue)));
21846
+ const output = toUint8Array(await compression.decompress(toArrayBuffer2(compressedValue)));
24965
21847
  if (codec === "snappy") {
24966
- if (value.length < 4 || readUInt32BE2(value, value.length - 4) !== crc32(output)) {
21848
+ if (value.length < 4 || readUInt32BE(value, value.length - 4) !== crc32(output)) {
24967
21849
  throw new Error("avro: Snappy block CRC32 check failed");
24968
21850
  }
24969
21851
  }
@@ -24983,7 +21865,7 @@ function getAvroDecompressor(codec) {
24983
21865
  decompressors[codec] ||= new constructors[codec](codec === "deflate" ? { raw: true } : {});
24984
21866
  return decompressors[codec];
24985
21867
  }
24986
- function readUInt32BE2(bytes, offset) {
21868
+ function readUInt32BE(bytes, offset) {
24987
21869
  return bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3];
24988
21870
  }
24989
21871
  function crc32(bytes) {
@@ -26559,7 +23441,7 @@ function applyIcebergDeletes(batch, positionsByFile, equalityDeletes, outputColu
26559
23441
  var _a2;
26560
23442
  return ((_a2 = batch.rowIndices) == null ? void 0 : _a2[index]) ?? batch.rowOffset + index;
26561
23443
  });
26562
- const data = arrow9.tableFromArrays(columns);
23444
+ const data = arrow10.tableFromArrays(columns);
26563
23445
  return {
26564
23446
  ...batch,
26565
23447
  data,