@loaders.gl/scan 5.0.0-alpha.10 → 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/hudi.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();
@@ -4334,7 +4280,7 @@ var init_src4 = __esm({
4334
4280
  });
4335
4281
 
4336
4282
  // ../compression/src/lib/compression.ts
4337
- var CompressionTransform, Compressor, Decompressor, Compression;
4283
+ var CompressionTransform, Decompressor;
4338
4284
  var init_compression = __esm({
4339
4285
  "../compression/src/lib/compression.ts"() {
4340
4286
  "use strict";
@@ -4356,26 +4302,6 @@ var init_compression = __esm({
4356
4302
  return error;
4357
4303
  }
4358
4304
  };
4359
- Compressor = class extends CompressionTransform {
4360
- constructor(options) {
4361
- super();
4362
- this.compressBatches = this.compressBatches.bind(this);
4363
- }
4364
- /** Asynchronously compresses data. */
4365
- async compress(input) {
4366
- await this.preload();
4367
- return this.compressSync(input);
4368
- }
4369
- /** Synchronously compresses data. */
4370
- compressSync(input) {
4371
- throw new Error(`${this.name}: sync compression not supported`);
4372
- }
4373
- /** Compresses batches. */
4374
- async *compressBatches(asyncIterator) {
4375
- const input = await this.concatenate(asyncIterator);
4376
- yield this.compress(input);
4377
- }
4378
- };
4379
4305
  Decompressor = class extends CompressionTransform {
4380
4306
  constructor(options) {
4381
4307
  super();
@@ -4396,135 +4322,144 @@ var init_compression = __esm({
4396
4322
  yield this.decompress(input);
4397
4323
  }
4398
4324
  };
4399
- Compression = class extends Compressor {
4400
- constructor(options) {
4325
+ }
4326
+ });
4327
+
4328
+ // ../compression/src/lib/compress-utils-compression.ts
4329
+ async function* transformBatches(stream, inputBatches) {
4330
+ try {
4331
+ for await (const input of inputBatches) {
4332
+ const output2 = stream.write(new Uint8Array(input));
4333
+ if (output2.byteLength > 0) yield copyArrayBuffer(output2);
4334
+ }
4335
+ const output = stream.finish();
4336
+ if (output.byteLength > 0) yield copyArrayBuffer(output);
4337
+ } finally {
4338
+ stream.destroy();
4339
+ }
4340
+ }
4341
+ function copyArrayBuffer(bytes) {
4342
+ return bytes.slice().buffer;
4343
+ }
4344
+ function getDecompressOptions(options, size) {
4345
+ const decodeOptions = {
4346
+ ...options.compressUtils,
4347
+ ...size === void 0 ? {} : { expectedSize: size }
4348
+ };
4349
+ const capacity = decodeOptions.expectedSize;
4350
+ const maximum = options.maxOutputByteLength ?? 512 * 1024 * 1024;
4351
+ if (!Number.isSafeInteger(maximum) || maximum < 0 || maximum > 2147483647)
4352
+ throw new RangeError("Invalid maxOutputByteLength");
4353
+ if (capacity !== void 0 && (!Number.isSafeInteger(capacity) || capacity < 0 || capacity > maximum)) {
4354
+ throw new RangeError("expectedSize exceeds the configured output capacity limit");
4355
+ }
4356
+ return decodeOptions;
4357
+ }
4358
+ var CompressUtilsDecompressor;
4359
+ var init_compress_utils_compression = __esm({
4360
+ "../compression/src/lib/compress-utils-compression.ts"() {
4361
+ "use strict";
4362
+ init_compression();
4363
+ CompressUtilsDecompressor = class extends Decompressor {
4364
+ name;
4365
+ extensions;
4366
+ contentEncodings;
4367
+ isSupported = true;
4368
+ options;
4369
+ loadModule;
4370
+ /** Module initialized for synchronous operations. */
4371
+ module = null;
4372
+ /** Shared import and WASM initialization for concurrent callers. */
4373
+ modulePromise = null;
4374
+ /** Creates a format-specific compress-utils decoder. */
4375
+ constructor(metadata, loadModule, options = {}) {
4401
4376
  super(options);
4402
- this.decompressBatches = this.decompressBatches.bind(this);
4377
+ this.name = metadata.name;
4378
+ this.extensions = metadata.extensions || [];
4379
+ this.contentEncodings = metadata.contentEncodings || [];
4380
+ this.loadModule = loadModule;
4381
+ this.options = options;
4403
4382
  }
4404
- /** Asynchronously decompresses data. */
4405
- async decompress(input, size) {
4406
- await this.preload();
4407
- return this.decompressSync(input, size);
4383
+ /** Imports and initializes the codec without loading the opposite direction. */
4384
+ async preload(modules = {}) {
4385
+ await super.preload(modules);
4386
+ this.modulePromise ||= this.loadModule().then(async (module2) => {
4387
+ var _a;
4388
+ await ((_a = module2.preload) == null ? void 0 : _a.call(module2));
4389
+ this.module = module2;
4390
+ });
4391
+ try {
4392
+ await this.modulePromise;
4393
+ } catch (error) {
4394
+ this.modulePromise = null;
4395
+ throw error;
4396
+ }
4408
4397
  }
4409
- /** Synchronously decompresses data. */
4398
+ /** Runs synchronously after preload has initialized the WASM codec. */
4410
4399
  decompressSync(input, size) {
4411
- throw new Error(`${this.name}: sync decompression not supported`);
4400
+ var _a;
4401
+ if (!((_a = this.module) == null ? void 0 : _a.decompressSync))
4402
+ throw new Error(`${this.name}: call preload() before decompressSync()`);
4403
+ return copyArrayBuffer(
4404
+ this.module.decompressSync(new Uint8Array(input), getDecompressOptions(this.options, size))
4405
+ );
4412
4406
  }
4413
- /** Decompresses batches. */
4414
- async *decompressBatches(asyncIterator) {
4415
- const input = await this.concatenate(asyncIterator);
4416
- yield this.decompress(input);
4407
+ /** Decompresses one buffer with the selected compress-utils decoder. */
4408
+ async decompress(input, size) {
4409
+ const decodeOptions = getDecompressOptions(this.options, size);
4410
+ await this.preload();
4411
+ const module2 = this.module;
4412
+ const output = await module2.decompress(new Uint8Array(input), decodeOptions);
4413
+ return copyArrayBuffer(output);
4414
+ }
4415
+ /** Incrementally decompresses input batches with compress-utils. */
4416
+ async *decompressBatches(inputBatches) {
4417
+ await this.preload();
4418
+ const module2 = this.module;
4419
+ if (!module2.createDecompressStream) {
4420
+ yield await this.decompress(await this.concatenate(inputBatches));
4421
+ return;
4422
+ }
4423
+ const stream = await module2.createDecompressStream();
4424
+ yield* transformBatches(stream, inputBatches);
4417
4425
  }
4418
4426
  };
4419
4427
  }
4420
4428
  });
4421
4429
 
4422
- // ../compression/src/zstd-decompressor-fzstd.ts
4423
- var import_fzstd, ZstdFzstdDecompressor;
4424
- var init_zstd_decompressor_fzstd = __esm({
4425
- "../compression/src/zstd-decompressor-fzstd.ts"() {
4430
+ // ../compression/src/lz4-decompressor-compress-utils.ts
4431
+ var LZ4CompressUtilsDecompressor;
4432
+ var init_lz4_decompressor_compress_utils = __esm({
4433
+ "../compression/src/lz4-decompressor-compress-utils.ts"() {
4426
4434
  "use strict";
4427
- init_compression();
4428
- import_fzstd = require("fzstd");
4429
- ZstdFzstdDecompressor = class extends Decompressor {
4430
- name = "zstd";
4431
- extensions = ["zst"];
4432
- contentEncodings = ["zstd"];
4433
- isSupported = true;
4435
+ init_compress_utils_compression();
4436
+ LZ4CompressUtilsDecompressor = class extends CompressUtilsDecompressor {
4434
4437
  constructor(options = {}) {
4435
- super(options);
4436
- }
4437
- /** Decompresses one Zstandard frame synchronously. */
4438
- decompressSync(input) {
4439
- return (0, import_fzstd.decompress)(new Uint8Array(input)).slice().buffer;
4438
+ super(
4439
+ { name: "lz4", extensions: ["lz4"], contentEncodings: ["x-lz4"] },
4440
+ () => options.raw ? import("compress-utils/lz4_raw/decompress") : import("compress-utils/lz4/decompress"),
4441
+ options
4442
+ );
4440
4443
  }
4441
4444
  };
4442
4445
  }
4443
4446
  });
4444
4447
 
4445
- // ../compression/src/lib/compression-stream.ts
4446
- async function compressWithNativeCompressionStream(input, format) {
4447
- const outputBatches = compressBatchesWithNativeCompressionStream([input], format);
4448
- return outputBatches ? await concatenateBatches(outputBatches) : null;
4449
- }
4450
- function compressBatchesWithNativeCompressionStream(inputBatches, format) {
4451
- const compressionStream = createNativeCompressionStream(format);
4452
- return compressionStream ? transformBatches(inputBatches, compressionStream) : null;
4453
- }
4454
- function createNativeCompressionStream(format) {
4455
- if (typeof globalThis.CompressionStream === "undefined") {
4456
- return null;
4457
- }
4458
- try {
4459
- const CompressionStreamConstructor = globalThis.CompressionStream;
4460
- return new CompressionStreamConstructor(format);
4461
- } catch (error) {
4462
- if (error instanceof TypeError || (error == null ? void 0 : error.name) === "TypeError") {
4463
- return null;
4464
- }
4465
- throw error;
4466
- }
4467
- }
4468
- async function* transformBatches(inputBatches, compressionStream) {
4469
- const writer = compressionStream.writable.getWriter();
4470
- const reader = compressionStream.readable.getReader();
4471
- const writePromise = writeBatches(inputBatches, writer);
4472
- writePromise.catch(() => {
4473
- });
4474
- let outputCompleted = false;
4475
- try {
4476
- while (true) {
4477
- const { done, value } = await reader.read();
4478
- if (done) {
4479
- outputCompleted = true;
4480
- break;
4481
- }
4482
- yield new Uint8Array(value).buffer;
4483
- }
4484
- await writePromise;
4485
- } finally {
4486
- if (!outputCompleted) {
4487
- await reader.cancel().catch(() => {
4488
- });
4489
- await writer.abort().catch(() => {
4490
- });
4491
- await writePromise.catch(() => {
4492
- });
4493
- }
4494
- reader.releaseLock();
4495
- }
4496
- }
4497
- async function writeBatches(inputBatches, writer) {
4498
- try {
4499
- for await (const inputBatch of inputBatches) {
4500
- await writer.write(new Uint8Array(inputBatch));
4501
- }
4502
- await writer.close();
4503
- } catch (error) {
4504
- await writer.abort(error).catch(() => {
4505
- });
4506
- throw error;
4507
- }
4508
- }
4509
- async function concatenateBatches(batches) {
4510
- const output = [];
4511
- let byteLength = 0;
4512
- for await (const batch of batches) {
4513
- const bytes = new Uint8Array(batch);
4514
- output.push(bytes);
4515
- byteLength += bytes.byteLength;
4516
- }
4517
- const result = new Uint8Array(byteLength);
4518
- let offset = 0;
4519
- for (const batch of output) {
4520
- result.set(batch, offset);
4521
- offset += batch.byteLength;
4522
- }
4523
- return result.buffer;
4524
- }
4525
- var init_compression_stream = __esm({
4526
- "../compression/src/lib/compression-stream.ts"() {
4448
+ // ../compression/src/zstd-decompressor-compress-utils.ts
4449
+ var ZstdCompressUtilsDecompressor;
4450
+ var init_zstd_decompressor_compress_utils = __esm({
4451
+ "../compression/src/zstd-decompressor-compress-utils.ts"() {
4527
4452
  "use strict";
4453
+ init_compress_utils_compression();
4454
+ ZstdCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
4455
+ constructor(options = {}) {
4456
+ super(
4457
+ { name: "zstd", extensions: ["zst"], contentEncodings: ["zstd"] },
4458
+ () => import("compress-utils/zstd/decompress"),
4459
+ options
4460
+ );
4461
+ }
4462
+ };
4528
4463
  }
4529
4464
  });
4530
4465
 
@@ -4624,103 +4559,36 @@ var init_decompression_stream = __esm({
4624
4559
  }
4625
4560
  });
4626
4561
 
4627
- // ../compression/src/zstd-fallback.ts
4628
- var zstd_fallback_exports = {};
4629
- __export(zstd_fallback_exports, {
4630
- decompressZstd: () => decompressZstd
4631
- });
4632
- function decompressZstd(input) {
4633
- return (0, import_fzstd2.decompress)(input);
4634
- }
4635
- var import_fzstd2;
4636
- var init_zstd_fallback = __esm({
4637
- "../compression/src/zstd-fallback.ts"() {
4638
- "use strict";
4639
- import_fzstd2 = require("fzstd");
4640
- }
4641
- });
4642
-
4643
- // ../compression/src/lib/zstd-compression.ts
4644
- var zstd_compression_exports = {};
4645
- __export(zstd_compression_exports, {
4646
- ZstdCompression: () => ZstdCompression
4562
+ // ../compression/src/zstd-decompressor.ts
4563
+ var zstd_decompressor_exports = {};
4564
+ __export(zstd_decompressor_exports, {
4565
+ ZstdDecompressor: () => ZstdDecompressor
4647
4566
  });
4648
- var CHUNK_SIZE, zstdPromise, zstd, ZstdCompression;
4649
- var init_zstd_compression = __esm({
4650
- "../compression/src/lib/zstd-compression.ts"() {
4567
+ var ZstdDecompressor;
4568
+ var init_zstd_decompressor = __esm({
4569
+ "../compression/src/zstd-decompressor.ts"() {
4651
4570
  "use strict";
4652
- init_compression();
4653
- init_src2();
4654
- init_compression_stream();
4571
+ init_zstd_decompressor_compress_utils();
4655
4572
  init_decompression_stream();
4656
- CHUNK_SIZE = 1e6;
4657
- ZstdCompression = class extends Compression {
4658
- name = "zstd";
4659
- extensions = [];
4660
- contentEncodings = [];
4661
- isSupported = true;
4662
- options;
4663
- /**
4664
- * zstd-codec is an injectable dependency due to big size
4665
- * @param options
4666
- */
4667
- constructor(options = {}) {
4668
- super(options);
4669
- this.options = options;
4670
- registerJSModules(options == null ? void 0 : options.modules);
4671
- }
4672
- async preload(modules = {}) {
4673
- registerJSModules(modules);
4674
- const ZstdCodec = getJSModuleOrNull("zstd-codec");
4675
- if (!zstdPromise && ZstdCodec) {
4676
- zstdPromise = new Promise((resolve) => ZstdCodec.run((zstd2) => resolve(zstd2)));
4677
- }
4678
- if (zstdPromise) {
4679
- zstd = await zstdPromise;
4680
- }
4681
- }
4682
- compressSync(input) {
4683
- getJSModule("zstd-codec", this.name);
4684
- const simpleZstd = new zstd.Simple();
4685
- const inputArray = new Uint8Array(input);
4686
- return simpleZstd.compress(inputArray).buffer;
4687
- }
4688
- async compress(input) {
4689
- var _a;
4690
- if (this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
4691
- const nativeOutput = await compressWithNativeCompressionStream(input, "zstd");
4692
- if (nativeOutput) return nativeOutput;
4693
- }
4694
- await this.preload();
4695
- return this.compressSync(input);
4696
- }
4697
- decompressSync(input) {
4698
- getJSModule("zstd-codec", this.name);
4699
- const simpleZstd = new zstd.Simple();
4700
- const inputArray = new Uint8Array(input);
4701
- return simpleZstd.decompress(inputArray).buffer;
4702
- }
4573
+ ZstdDecompressor = class extends ZstdCompressUtilsDecompressor {
4574
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
4703
4575
  async decompress(input, size) {
4704
- var _a;
4705
- if (!getJSModuleOrNull("zstd-codec") && this.options.useNative !== false && ((_a = this.options.zstd) == null ? void 0 : _a.useNative) !== false) {
4706
- const nativeOutput = await decompressWithNativeDecompressionStream(input, "zstd");
4707
- if (nativeOutput) return nativeOutput;
4708
- }
4709
- await this.preload();
4710
- const inputArray = new Uint8Array(input);
4711
- if (!zstd) {
4712
- const { decompressZstd: decompressZstd2 } = await Promise.resolve().then(() => (init_zstd_fallback(), zstd_fallback_exports));
4713
- return ensureArrayBuffer(decompressZstd2(inputArray));
4576
+ if (this.options.useNative !== false) {
4577
+ const output = await decompressWithNativeDecompressionStream(input, "zstd");
4578
+ if (output) return output;
4714
4579
  }
4715
- const simpleZstd = new zstd.Streaming();
4716
- const chunks = [];
4717
- for (let i = 0; i <= inputArray.length; i += CHUNK_SIZE) {
4718
- const chunkView = inputArray.subarray(i, i + CHUNK_SIZE);
4719
- const chunkArrayBuffer = ensureArrayBuffer(chunkView);
4720
- chunks.push(new Uint8Array(chunkArrayBuffer));
4580
+ return super.decompress(input, size);
4581
+ }
4582
+ /** Streams native batches when available, otherwise uses the WASM stream. */
4583
+ async *decompressBatches(inputBatches) {
4584
+ if (this.options.useNative !== false) {
4585
+ const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
4586
+ if (output) {
4587
+ yield* output;
4588
+ return;
4589
+ }
4721
4590
  }
4722
- const decompressResult = await simpleZstd.decompressChunks(chunks);
4723
- return decompressResult.buffer;
4591
+ yield* super.decompressBatches(inputBatches);
4724
4592
  }
4725
4593
  };
4726
4594
  }
@@ -5328,60 +5196,6 @@ var init_src5 = __esm({
5328
5196
  }
5329
5197
  });
5330
5198
 
5331
- // ../gis/src/lib/geoarrow/metadata-utils.ts
5332
- var init_metadata_utils = __esm({
5333
- "../gis/src/lib/geoarrow/metadata-utils.ts"() {
5334
- "use strict";
5335
- init_src3();
5336
- }
5337
- });
5338
-
5339
- // ../gis/src/lib/geoarrow/geoparquet-metadata.ts
5340
- function getGeoMetadata2(metadata) {
5341
- if (!metadata) {
5342
- return null;
5343
- }
5344
- const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
5345
- const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata2(stringifiedGeoMetadata);
5346
- if (!geoMetadata) {
5347
- return null;
5348
- }
5349
- for (const column of Object.values(geoMetadata.columns || {})) {
5350
- if (column.encoding) {
5351
- column.encoding = column.encoding.toLowerCase();
5352
- }
5353
- }
5354
- return geoMetadata;
5355
- }
5356
- function parseJSONStringMetadata2(stringifiedMetadata) {
5357
- if (!stringifiedMetadata) {
5358
- return null;
5359
- }
5360
- try {
5361
- const metadata = JSON.parse(stringifiedMetadata);
5362
- if (!metadata || typeof metadata !== "object") {
5363
- return null;
5364
- }
5365
- return metadata;
5366
- } catch {
5367
- return null;
5368
- }
5369
- }
5370
- var init_geoparquet_metadata = __esm({
5371
- "../gis/src/lib/geoarrow/geoparquet-metadata.ts"() {
5372
- "use strict";
5373
- init_metadata_utils();
5374
- }
5375
- });
5376
-
5377
- // ../gis/src/index.ts
5378
- var init_src6 = __esm({
5379
- "../gis/src/index.ts"() {
5380
- "use strict";
5381
- init_geoparquet_metadata();
5382
- }
5383
- });
5384
-
5385
5199
  // ../parquet/src/lib/arrow/convert-schema-from-parquet.ts
5386
5200
  function convertParquetSchema(parquetSchema, parquetMetadata, options) {
5387
5201
  const fields = getFields(parquetSchema.schema, options);
@@ -5681,18 +5495,49 @@ async function getSchemaFromParquetReader(reader) {
5681
5495
  const schema = convertParquetSchema(parquetSchema, parquetMetadata, {
5682
5496
  int96AsTimestamp: reader.int96AsTimestamp
5683
5497
  });
5498
+ restoreEmbeddedArrowMetadata(schema);
5684
5499
  applyGeoParquetToFieldMetadata(schema);
5685
5500
  unpackGeoMetadata(schema.metadata);
5686
5501
  unpackJSONStringMetadata(schema.metadata, "pandas");
5687
5502
  return schema;
5688
5503
  }
5689
- var init_get_parquet_schema = __esm({
5690
- "../parquet/src/lib/parsers/get-parquet-schema.ts"() {
5691
- "use strict";
5692
- init_src3();
5693
- init_convert_schema_from_parquet();
5694
- init_geospatial_metadata();
5695
- }
5504
+ function restoreEmbeddedArrowMetadata(schema) {
5505
+ var _a;
5506
+ const encodedSchema = (_a = schema.metadata) == null ? void 0 : _a["ARROW:schema"];
5507
+ if (typeof encodedSchema !== "string") {
5508
+ return;
5509
+ }
5510
+ try {
5511
+ const bytes = Uint8Array.from(atob(encodedSchema), (character) => character.charCodeAt(0));
5512
+ const embeddedSchema = arrow8.RecordBatchReader.from(bytes).open().schema;
5513
+ if (embeddedSchema) {
5514
+ schema.metadata = { ...Object.fromEntries(embeddedSchema.metadata), ...schema.metadata };
5515
+ restoreArrowFieldMetadata(schema.fields, embeddedSchema.fields);
5516
+ }
5517
+ } catch {
5518
+ }
5519
+ }
5520
+ function restoreArrowFieldMetadata(fields, arrowFields) {
5521
+ for (const field of fields) {
5522
+ const arrowField = arrowFields.find((candidate) => candidate.name === field.name);
5523
+ if (!arrowField) {
5524
+ continue;
5525
+ }
5526
+ field.metadata = { ...Object.fromEntries(arrowField.metadata), ...field.metadata };
5527
+ if (typeof field.type === "object" && "children" in field.type && arrowField.type.children) {
5528
+ restoreArrowFieldMetadata(field.type.children, arrowField.type.children);
5529
+ }
5530
+ }
5531
+ }
5532
+ var arrow8;
5533
+ var init_get_parquet_schema = __esm({
5534
+ "../parquet/src/lib/parsers/get-parquet-schema.ts"() {
5535
+ "use strict";
5536
+ arrow8 = __toESM(require("apache-arrow"), 1);
5537
+ init_src3();
5538
+ init_convert_schema_from_parquet();
5539
+ init_geospatial_metadata();
5540
+ }
5696
5541
  });
5697
5542
 
5698
5543
  // ../parquet/src/lib/geo/geoparquet-covering.ts
@@ -5864,7 +5709,7 @@ function toUint8Array(binary) {
5864
5709
  }
5865
5710
  return new Uint8Array(binary);
5866
5711
  }
5867
- function toArrayBuffer3(binary) {
5712
+ function toArrayBuffer2(binary) {
5868
5713
  const bytes = toUint8Array(binary);
5869
5714
  return bytes.slice().buffer;
5870
5715
  }
@@ -6687,8 +6532,8 @@ function mergeXxHash64(accumulator, value) {
6687
6532
  result = result * PRIME1 + PRIME4 & UINT64_MASK;
6688
6533
  return result;
6689
6534
  }
6690
- function rotateLeft(value, bits2) {
6691
- const shift = BigInt(bits2);
6535
+ function rotateLeft(value, bits) {
6536
+ const shift = BigInt(bits);
6692
6537
  return (value << shift | value >> 64n - shift) & UINT64_MASK;
6693
6538
  }
6694
6539
  function readUint32LE(value, offset) {
@@ -12525,7 +12370,7 @@ var init_parse_bson = __esm({
12525
12370
  });
12526
12371
 
12527
12372
  // ../bson/src/index.ts
12528
- var init_src7 = __esm({
12373
+ var init_src6 = __esm({
12529
12374
  "../bson/src/index.ts"() {
12530
12375
  "use strict";
12531
12376
  init_bson_writer();
@@ -12569,10 +12414,10 @@ function toPrimitive_FLOAT16(value) {
12569
12414
  throw new Error(`invalid value for FLOAT16: ${value}`);
12570
12415
  }
12571
12416
  const float32 = new Float32Array([numberValue]);
12572
- const bits2 = new Uint32Array(float32.buffer)[0];
12573
- const sign = bits2 >>> 16 & 32768;
12574
- const exponent = bits2 >>> 23 & 255;
12575
- const mantissa = bits2 & 8388607;
12417
+ const bits = new Uint32Array(float32.buffer)[0];
12418
+ const sign = bits >>> 16 & 32768;
12419
+ const exponent = bits >>> 23 & 255;
12420
+ const mantissa = bits & 8388607;
12576
12421
  let half;
12577
12422
  if (exponent === 255) {
12578
12423
  half = sign | 31744 | (mantissa ? 512 : 0);
@@ -12822,7 +12667,7 @@ function toPrimitive_BSON(value) {
12822
12667
  return toUint8Array(arrayBuffer);
12823
12668
  }
12824
12669
  function fromPrimitive_BSON(value) {
12825
- return parseBSONSync(toArrayBuffer3(value));
12670
+ return parseBSONSync(toArrayBuffer2(value));
12826
12671
  }
12827
12672
  function toPrimitive_TIME_MILLIS(value) {
12828
12673
  const v = parseInt(value, 10);
@@ -12934,7 +12779,7 @@ var PARQUET_LOGICAL_TYPES, kMillisPerDay;
12934
12779
  var init_types = __esm({
12935
12780
  "../parquet/src/parquetjs/schema/types.ts"() {
12936
12781
  "use strict";
12937
- init_src7();
12782
+ init_src6();
12938
12783
  init_binary_utils();
12939
12784
  PARQUET_LOGICAL_TYPES = {
12940
12785
  BOOLEAN: {
@@ -14099,414 +13944,6 @@ var init_parquet_source_loader_types = __esm({
14099
13944
  }
14100
13945
  });
14101
13946
 
14102
- // ../compression/src/lib/fflate/index.ts
14103
- function gunzipSync(data, out) {
14104
- return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
14105
- }
14106
- 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, Inflate, Gunzip;
14107
- var init_fflate = __esm({
14108
- "../compression/src/lib/fflate/index.ts"() {
14109
- "use strict";
14110
- u8 = Uint8Array;
14111
- u16 = Uint16Array;
14112
- u32 = Uint32Array;
14113
- fleb = new u8([
14114
- 0,
14115
- 0,
14116
- 0,
14117
- 0,
14118
- 0,
14119
- 0,
14120
- 0,
14121
- 0,
14122
- 1,
14123
- 1,
14124
- 1,
14125
- 1,
14126
- 2,
14127
- 2,
14128
- 2,
14129
- 2,
14130
- 3,
14131
- 3,
14132
- 3,
14133
- 3,
14134
- 4,
14135
- 4,
14136
- 4,
14137
- 4,
14138
- 5,
14139
- 5,
14140
- 5,
14141
- 5,
14142
- 0,
14143
- /* unused */
14144
- 0,
14145
- 0,
14146
- /* impossible */
14147
- 0
14148
- ]);
14149
- fdeb = new u8([
14150
- 0,
14151
- 0,
14152
- 0,
14153
- 0,
14154
- 1,
14155
- 1,
14156
- 2,
14157
- 2,
14158
- 3,
14159
- 3,
14160
- 4,
14161
- 4,
14162
- 5,
14163
- 5,
14164
- 6,
14165
- 6,
14166
- 7,
14167
- 7,
14168
- 8,
14169
- 8,
14170
- 9,
14171
- 9,
14172
- 10,
14173
- 10,
14174
- 11,
14175
- 11,
14176
- 12,
14177
- 12,
14178
- 13,
14179
- 13,
14180
- /* unused */
14181
- 0,
14182
- 0
14183
- ]);
14184
- clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
14185
- freb = (eb, start) => {
14186
- const b = new u16(31);
14187
- for (let i = 0; i < 31; ++i) {
14188
- b[i] = start += 1 << eb[i - 1];
14189
- }
14190
- const r = new u32(b[30]);
14191
- for (let i = 1; i < 30; ++i) {
14192
- for (let j = b[i]; j < b[i + 1]; ++j) {
14193
- r[j] = j - b[i] << 5 | i;
14194
- }
14195
- }
14196
- return [b, r];
14197
- };
14198
- [fl, revfl] = freb(fleb, 2);
14199
- fl[28] = 258, revfl[258] = 28;
14200
- [fd, revfd] = freb(fdeb, 0);
14201
- rev = new u16(32768);
14202
- for (let i = 0; i < 32768; ++i) {
14203
- let x = (i & 43690) >>> 1 | (i & 21845) << 1;
14204
- x = (x & 52428) >>> 2 | (x & 13107) << 2;
14205
- x = (x & 61680) >>> 4 | (x & 3855) << 4;
14206
- rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
14207
- }
14208
- hMap = (cd, mb, r) => {
14209
- const s = cd.length;
14210
- let i = 0;
14211
- const l = new u16(mb);
14212
- for (; i < s; ++i) {
14213
- if (cd[i]) ++l[cd[i] - 1];
14214
- }
14215
- const le = new u16(mb);
14216
- for (i = 0; i < mb; ++i) {
14217
- le[i] = le[i - 1] + l[i - 1] << 1;
14218
- }
14219
- let co;
14220
- if (r) {
14221
- co = new u16(1 << mb);
14222
- const rvb = 15 - mb;
14223
- for (i = 0; i < s; ++i) {
14224
- if (cd[i]) {
14225
- const sv = i << 4 | cd[i];
14226
- const r2 = mb - cd[i];
14227
- let v = le[cd[i] - 1]++ << r2;
14228
- for (const m = v | (1 << r2) - 1; v <= m; ++v) {
14229
- co[rev[v] >>> rvb] = sv;
14230
- }
14231
- }
14232
- }
14233
- } else {
14234
- co = new u16(s);
14235
- for (i = 0; i < s; ++i) {
14236
- if (cd[i]) {
14237
- co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
14238
- }
14239
- }
14240
- }
14241
- return co;
14242
- };
14243
- flt = new u8(288);
14244
- for (let i = 0; i < 144; ++i) flt[i] = 8;
14245
- for (let i = 144; i < 256; ++i) flt[i] = 9;
14246
- for (let i = 256; i < 280; ++i) flt[i] = 7;
14247
- for (let i = 280; i < 288; ++i) flt[i] = 8;
14248
- fdt = new u8(32);
14249
- for (let i = 0; i < 32; ++i) fdt[i] = 5;
14250
- flrm = /* @__PURE__ */ hMap(flt, 9, 1);
14251
- fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
14252
- max = (a) => {
14253
- let m = a[0];
14254
- for (let i = 1; i < a.length; ++i) {
14255
- if (a[i] > m) m = a[i];
14256
- }
14257
- return m;
14258
- };
14259
- bits = (d, p, m) => {
14260
- const o = p / 8 | 0;
14261
- return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
14262
- };
14263
- bits16 = (d, p) => {
14264
- const o = p / 8 | 0;
14265
- return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
14266
- };
14267
- shft = (p) => (p + 7) / 8 | 0;
14268
- slc = (v, s, e) => {
14269
- if (s == null || s < 0) s = 0;
14270
- if (e == null || e > v.length) e = v.length;
14271
- const n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
14272
- n.set(v.subarray(s, e));
14273
- return n;
14274
- };
14275
- ec = [
14276
- "unexpected EOF",
14277
- "invalid block type",
14278
- "invalid length/literal",
14279
- "invalid distance",
14280
- "stream finished",
14281
- "no stream handler",
14282
- ,
14283
- // determined by compression function
14284
- "no callback",
14285
- "invalid UTF-8 data",
14286
- "extra field too long",
14287
- "date not in range 1980-2099",
14288
- "filename too long",
14289
- "stream finishing",
14290
- "invalid zip data"
14291
- // determined by unknown compression method
14292
- ];
14293
- err = (ind, msg, nt) => {
14294
- const e = new Error(msg || ec[ind]);
14295
- e.code = ind;
14296
- if (Error.captureStackTrace) Error.captureStackTrace(e, err);
14297
- if (!nt) throw e;
14298
- return e;
14299
- };
14300
- inflt = (dat, buf, st) => {
14301
- const sl = dat.length;
14302
- if (!sl || st && st.f && !st.l) return buf || new u8(0);
14303
- const noBuf = !buf || st;
14304
- const noSt = !st || st.i;
14305
- if (!st) st = {};
14306
- if (!buf) buf = new u8(sl * 3);
14307
- const cbuf = (l) => {
14308
- let bl = buf.length;
14309
- if (l > bl) {
14310
- const nbuf = new u8(Math.max(bl * 2, l));
14311
- nbuf.set(buf);
14312
- buf = nbuf;
14313
- }
14314
- };
14315
- 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;
14316
- const tbts = sl * 8;
14317
- do {
14318
- if (!lm) {
14319
- final = bits(dat, pos, 1);
14320
- const type = bits(dat, pos + 1, 3);
14321
- pos += 3;
14322
- if (!type) {
14323
- const s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
14324
- if (t > sl) {
14325
- if (noSt) err(0);
14326
- break;
14327
- }
14328
- if (noBuf) cbuf(bt + l);
14329
- buf.set(dat.subarray(s, t), bt);
14330
- st.b = bt += l, st.p = pos = t * 8, st.f = final;
14331
- continue;
14332
- } else if (type == 1) lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
14333
- else if (type == 2) {
14334
- const hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
14335
- const tl = hLit + bits(dat, pos + 5, 31) + 1;
14336
- pos += 14;
14337
- const ldt = new u8(tl);
14338
- const clt = new u8(19);
14339
- for (let i = 0; i < hcLen; ++i) {
14340
- clt[clim[i]] = bits(dat, pos + i * 3, 7);
14341
- }
14342
- pos += hcLen * 3;
14343
- const clb = max(clt), clbmsk = (1 << clb) - 1;
14344
- const clm = hMap(clt, clb, 1);
14345
- for (let i = 0; i < tl; ) {
14346
- const r = clm[bits(dat, pos, clbmsk)];
14347
- pos += r & 15;
14348
- const s = r >>> 4;
14349
- if (s < 16) {
14350
- ldt[i++] = s;
14351
- } else {
14352
- let c = 0, n = 0;
14353
- if (s == 16) n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
14354
- else if (s == 17) n = 3 + bits(dat, pos, 7), pos += 3;
14355
- else if (s == 18) n = 11 + bits(dat, pos, 127), pos += 7;
14356
- while (n--) ldt[i++] = c;
14357
- }
14358
- }
14359
- const lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
14360
- lbt = max(lt);
14361
- dbt = max(dt);
14362
- lm = hMap(lt, lbt, 1);
14363
- dm = hMap(dt, dbt, 1);
14364
- } else err(1);
14365
- if (pos > tbts) {
14366
- if (noSt) err(0);
14367
- break;
14368
- }
14369
- }
14370
- if (noBuf) cbuf(bt + 131072);
14371
- const lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
14372
- let lpos = pos;
14373
- for (; ; lpos = pos) {
14374
- const c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
14375
- pos += c & 15;
14376
- if (pos > tbts) {
14377
- if (noSt) err(0);
14378
- break;
14379
- }
14380
- if (!c) err(2);
14381
- if (sym < 256) buf[bt++] = sym;
14382
- else if (sym == 256) {
14383
- lpos = pos, lm = void 0;
14384
- break;
14385
- } else {
14386
- let add = sym - 254;
14387
- if (sym > 264) {
14388
- const i = sym - 257, b = fleb[i];
14389
- add = bits(dat, pos, (1 << b) - 1) + fl[i];
14390
- pos += b;
14391
- }
14392
- const d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
14393
- if (!d) err(3);
14394
- pos += d & 15;
14395
- let dt = fd[dsym];
14396
- if (dsym > 3) {
14397
- const b = fdeb[dsym];
14398
- dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
14399
- }
14400
- if (pos > tbts) {
14401
- if (noSt) err(0);
14402
- break;
14403
- }
14404
- if (noBuf) cbuf(bt + 131072);
14405
- const end = bt + add;
14406
- for (; bt < end; bt += 4) {
14407
- buf[bt] = buf[bt - dt];
14408
- buf[bt + 1] = buf[bt + 1 - dt];
14409
- buf[bt + 2] = buf[bt + 2 - dt];
14410
- buf[bt + 3] = buf[bt + 3 - dt];
14411
- }
14412
- bt = end;
14413
- }
14414
- }
14415
- st.l = lm, st.p = lpos, st.b = bt, st.f = final;
14416
- if (lm) final = 1, st.m = lbt, st.d = dm, st.n = dbt;
14417
- } while (!final);
14418
- return bt == buf.length ? buf : slc(buf, 0, bt);
14419
- };
14420
- gzs = (d) => {
14421
- if (d[0] != 31 || d[1] != 139 || d[2] != 8) err(6, "invalid gzip data");
14422
- const flg = d[3];
14423
- let st = 10;
14424
- if (flg & 4) st += d[10] | (d[11] << 8) + 2;
14425
- for (let zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) ;
14426
- return st + (flg & 2);
14427
- };
14428
- gzl = (d) => {
14429
- const l = d.length;
14430
- return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
14431
- };
14432
- Inflate = class {
14433
- /**
14434
- * Creates an inflation stream
14435
- * @param cb The callback to call whenever data is inflated
14436
- */
14437
- constructor(cb) {
14438
- this.ondata = cb;
14439
- }
14440
- /** Persistent bit-reader and Huffman decoding state. */
14441
- s = {};
14442
- /** Compression options or retained output window for this stream. */
14443
- o;
14444
- /** Compressed bytes pending decoding. */
14445
- p = new u8(0);
14446
- /** Whether the stream has received its final chunk. */
14447
- d;
14448
- /**
14449
- * The handler to call whenever data is available
14450
- */
14451
- ondata;
14452
- /** Appends pending input after checking stream lifecycle. */
14453
- e(c) {
14454
- if (!this.ondata) err(5);
14455
- if (this.d) err(4);
14456
- const l = this.p.length;
14457
- const n = new u8(l + c.length);
14458
- n.set(this.p), n.set(c, l), this.p = n;
14459
- }
14460
- /** Decodes pending input and retains the sliding window. */
14461
- c(final) {
14462
- this.d = this.s.i = final || false;
14463
- const bts = this.s.b;
14464
- const dt = inflt(this.p, this.o, this.s);
14465
- this.ondata(slc(dt, bts, this.s.b), this.d);
14466
- this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
14467
- this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
14468
- }
14469
- /**
14470
- * Pushes a chunk to be inflated
14471
- * @param chunk The chunk to push
14472
- * @param final Whether this is the final chunk
14473
- */
14474
- push(chunk, final) {
14475
- this.e(chunk), this.c(final);
14476
- }
14477
- };
14478
- Gunzip = class extends Inflate {
14479
- /** Whether the stream header still needs to be emitted or consumed. */
14480
- v = 1;
14481
- /**
14482
- * Creates a GUNZIP stream
14483
- * @param cb The callback to call whenever data is inflated
14484
- */
14485
- constructor(cb) {
14486
- super(cb);
14487
- }
14488
- /**
14489
- * Pushes a chunk to be GUNZIPped
14490
- * @param chunk The chunk to push
14491
- * @param final Whether this is the last chunk
14492
- */
14493
- push(chunk, final) {
14494
- Inflate.prototype.e.call(this, chunk);
14495
- if (this.v) {
14496
- const s = this.p.length > 3 ? gzs(this.p) : 4;
14497
- if (s >= this.p.length && !final) return;
14498
- this.p = this.p.subarray(s), this.v = 0;
14499
- }
14500
- if (final) {
14501
- if (this.p.length < 8) err(6, "invalid gzip data");
14502
- this.p = this.p.subarray(0, -8);
14503
- }
14504
- Inflate.prototype.c.call(this, final);
14505
- }
14506
- };
14507
- }
14508
- });
14509
-
14510
13947
  // ../compression/src/lib/native-decompressor.ts
14511
13948
  var native_decompressor_exports = {};
14512
13949
  __export(native_decompressor_exports, {
@@ -14604,8 +14041,8 @@ var init_lazy_compression = __esm({
14604
14041
  const { NativeDecompressor: NativeDecompressor2 } = await Promise.resolve().then(() => (init_native_decompressor(), native_decompressor_exports));
14605
14042
  return new NativeDecompressor2(this, this.nativeFormat, options);
14606
14043
  }
14607
- const Decompressor2 = await this.loadFallback();
14608
- const implementation = new Decompressor2({ ...options, useNative: false });
14044
+ const Decompressor3 = await this.loadFallback();
14045
+ const implementation = new Decompressor3({ ...options, useNative: false });
14609
14046
  await implementation.preload(options.modules);
14610
14047
  return implementation;
14611
14048
  }
@@ -14628,48 +14065,19 @@ var init_lazy_compression = __esm({
14628
14065
  }
14629
14066
  });
14630
14067
 
14631
- // ../compression/src/lib/fflate-stream.ts
14632
- async function* transformFflateBatches(processor, inputBatches) {
14633
- const chunks = [];
14634
- processor.ondata = (data) => {
14635
- chunks.push(data.slice().buffer);
14636
- };
14637
- for await (const batch of inputBatches) {
14638
- processor.push(new Uint8Array(batch), false);
14639
- yield* chunks.splice(0);
14640
- }
14641
- processor.push(new Uint8Array(0), true);
14642
- yield* chunks;
14643
- }
14644
- var init_fflate_stream = __esm({
14645
- "../compression/src/lib/fflate-stream.ts"() {
14068
+ // ../compression/src/gzip-decompressor-compress-utils.ts
14069
+ var GZipCompressUtilsDecompressor;
14070
+ var init_gzip_decompressor_compress_utils = __esm({
14071
+ "../compression/src/gzip-decompressor-compress-utils.ts"() {
14646
14072
  "use strict";
14647
- }
14648
- });
14649
-
14650
- // ../compression/src/gzip-decompressor-fflate.ts
14651
- var GZipFflateDecompressor;
14652
- var init_gzip_decompressor_fflate = __esm({
14653
- "../compression/src/gzip-decompressor-fflate.ts"() {
14654
- "use strict";
14655
- init_fflate();
14656
- init_compression();
14657
- init_fflate_stream();
14658
- GZipFflateDecompressor = class extends Decompressor {
14659
- name = "gzip";
14660
- extensions = ["gz", "gzip"];
14661
- contentEncodings = ["gzip", "x-gzip"];
14662
- isSupported = true;
14073
+ init_compress_utils_compression();
14074
+ GZipCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
14663
14075
  constructor(options = {}) {
14664
- super(options);
14665
- }
14666
- /** Decompresses one GZIP payload synchronously. */
14667
- decompressSync(input) {
14668
- return gunzipSync(new Uint8Array(input)).slice().buffer;
14669
- }
14670
- /** Decompresses GZIP batches incrementally. */
14671
- async *decompressBatches(inputBatches) {
14672
- yield* transformFflateBatches(new Gunzip(), inputBatches);
14076
+ super(
14077
+ { name: "gzip", extensions: ["gz", "gzip"], contentEncodings: ["gzip", "x-gzip"] },
14078
+ () => import("compress-utils/gzip/decompress"),
14079
+ options
14080
+ );
14673
14081
  }
14674
14082
  };
14675
14083
  }
@@ -14684,2236 +14092,45 @@ var GZipDecompressor;
14684
14092
  var init_gzip_decompressor = __esm({
14685
14093
  "../compression/src/gzip-decompressor.ts"() {
14686
14094
  "use strict";
14687
- init_gzip_decompressor_fflate();
14095
+ init_gzip_decompressor_compress_utils();
14688
14096
  init_decompression_stream();
14689
- GZipDecompressor = class extends GZipFflateDecompressor {
14690
- options;
14691
- constructor(options = {}) {
14692
- super(options);
14693
- this.options = options;
14694
- }
14695
- /** Decompresses with the built-in stream when available, then falls back to fflate. */
14696
- async decompress(input) {
14097
+ GZipDecompressor = class extends GZipCompressUtilsDecompressor {
14098
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
14099
+ async decompress(input, size) {
14697
14100
  if (this.options.useNative !== false) {
14698
14101
  const output = await decompressWithNativeDecompressionStream(input, "gzip");
14699
14102
  if (output) return output;
14700
14103
  }
14701
- return this.decompressSync(input);
14104
+ return super.decompress(input, size);
14702
14105
  }
14703
- /** Decompresses batches with a built-in or fflate stream. */
14106
+ /** Streams native batches when available, otherwise uses the WASM stream. */
14704
14107
  async *decompressBatches(inputBatches) {
14705
14108
  if (this.options.useNative !== false) {
14706
14109
  const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "gzip");
14707
14110
  if (output) {
14708
- yield* output;
14709
- return;
14710
- }
14711
- }
14712
- yield* super.decompressBatches(inputBatches);
14713
- }
14714
- };
14715
- }
14716
- });
14717
-
14718
- // ../compression/src/brotli/decode.ts
14719
- var makeBrotliDecode, BrotliDecode;
14720
- var init_decode = __esm({
14721
- "../compression/src/brotli/decode.ts"() {
14722
- "use strict";
14723
- makeBrotliDecode = () => {
14724
- function InputStream(bytes) {
14725
- this.data = bytes;
14726
- this.offset = 0;
14727
- }
14728
- let MAX_HUFFMAN_TABLE_SIZE = Int32Array.from([
14729
- 256,
14730
- 402,
14731
- 436,
14732
- 468,
14733
- 500,
14734
- 534,
14735
- 566,
14736
- 598,
14737
- 630,
14738
- 662,
14739
- 694,
14740
- 726,
14741
- 758,
14742
- 790,
14743
- 822,
14744
- 854,
14745
- 886,
14746
- 920,
14747
- 952,
14748
- 984,
14749
- 1016,
14750
- 1048,
14751
- 1080
14752
- ]);
14753
- let CODE_LENGTH_CODE_ORDER = Int32Array.from([
14754
- 1,
14755
- 2,
14756
- 3,
14757
- 4,
14758
- 0,
14759
- 5,
14760
- 17,
14761
- 6,
14762
- 16,
14763
- 7,
14764
- 8,
14765
- 9,
14766
- 10,
14767
- 11,
14768
- 12,
14769
- 13,
14770
- 14,
14771
- 15
14772
- ]);
14773
- let DISTANCE_SHORT_CODE_INDEX_OFFSET = Int32Array.from([
14774
- 0,
14775
- 3,
14776
- 2,
14777
- 1,
14778
- 0,
14779
- 0,
14780
- 0,
14781
- 0,
14782
- 0,
14783
- 0,
14784
- 3,
14785
- 3,
14786
- 3,
14787
- 3,
14788
- 3,
14789
- 3
14790
- ]);
14791
- let DISTANCE_SHORT_CODE_VALUE_OFFSET = Int32Array.from([
14792
- 0,
14793
- 0,
14794
- 0,
14795
- 0,
14796
- -1,
14797
- 1,
14798
- -2,
14799
- 2,
14800
- -3,
14801
- 3,
14802
- -1,
14803
- 1,
14804
- -2,
14805
- 2,
14806
- -3,
14807
- 3
14808
- ]);
14809
- let FIXED_TABLE = Int32Array.from([
14810
- 131072,
14811
- 131076,
14812
- 131075,
14813
- 196610,
14814
- 131072,
14815
- 131076,
14816
- 131075,
14817
- 262145,
14818
- 131072,
14819
- 131076,
14820
- 131075,
14821
- 196610,
14822
- 131072,
14823
- 131076,
14824
- 131075,
14825
- 262149
14826
- ]);
14827
- let BLOCK_LENGTH_OFFSET = Int32Array.from([
14828
- 1,
14829
- 5,
14830
- 9,
14831
- 13,
14832
- 17,
14833
- 25,
14834
- 33,
14835
- 41,
14836
- 49,
14837
- 65,
14838
- 81,
14839
- 97,
14840
- 113,
14841
- 145,
14842
- 177,
14843
- 209,
14844
- 241,
14845
- 305,
14846
- 369,
14847
- 497,
14848
- 753,
14849
- 1265,
14850
- 2289,
14851
- 4337,
14852
- 8433,
14853
- 16625
14854
- ]);
14855
- let BLOCK_LENGTH_N_BITS = Int32Array.from([
14856
- 2,
14857
- 2,
14858
- 2,
14859
- 2,
14860
- 3,
14861
- 3,
14862
- 3,
14863
- 3,
14864
- 4,
14865
- 4,
14866
- 4,
14867
- 4,
14868
- 5,
14869
- 5,
14870
- 5,
14871
- 5,
14872
- 6,
14873
- 6,
14874
- 7,
14875
- 8,
14876
- 9,
14877
- 10,
14878
- 11,
14879
- 12,
14880
- 13,
14881
- 24
14882
- ]);
14883
- let INSERT_LENGTH_N_BITS = Int16Array.from([
14884
- 0,
14885
- 0,
14886
- 0,
14887
- 0,
14888
- 0,
14889
- 0,
14890
- 1,
14891
- 1,
14892
- 2,
14893
- 2,
14894
- 3,
14895
- 3,
14896
- 4,
14897
- 4,
14898
- 5,
14899
- 5,
14900
- 6,
14901
- 7,
14902
- 8,
14903
- 9,
14904
- 10,
14905
- 12,
14906
- 14,
14907
- 24
14908
- ]);
14909
- let COPY_LENGTH_N_BITS = Int16Array.from([
14910
- 0,
14911
- 0,
14912
- 0,
14913
- 0,
14914
- 0,
14915
- 0,
14916
- 0,
14917
- 0,
14918
- 1,
14919
- 1,
14920
- 2,
14921
- 2,
14922
- 3,
14923
- 3,
14924
- 4,
14925
- 4,
14926
- 5,
14927
- 5,
14928
- 6,
14929
- 7,
14930
- 8,
14931
- 9,
14932
- 10,
14933
- 24
14934
- ]);
14935
- let CMD_LOOKUP = new Int16Array(2816);
14936
- {
14937
- unpackCommandLookupTable(CMD_LOOKUP);
14938
- }
14939
- function log2floor(i) {
14940
- let result = -1;
14941
- let step = 16;
14942
- while (step > 0) {
14943
- if (i >>> step !== 0) {
14944
- result += step;
14945
- i = i >>> step;
14946
- }
14947
- step = step >> 1;
14948
- }
14949
- return result + i;
14950
- }
14951
- function calculateDistanceAlphabetSize(npostfix, ndirect, maxndistbits) {
14952
- return 16 + ndirect + 2 * (maxndistbits << npostfix);
14953
- }
14954
- function calculateDistanceAlphabetLimit(maxDistance, npostfix, ndirect) {
14955
- if (maxDistance < ndirect + (2 << npostfix)) {
14956
- throw "maxDistance is too small";
14957
- }
14958
- let offset = (maxDistance - ndirect >> npostfix) + 4;
14959
- let ndistbits = log2floor(offset) - 1;
14960
- let group = ndistbits - 1 << 1 | offset >> ndistbits & 1;
14961
- return (group - 1 << npostfix) + (1 << npostfix) + ndirect + 16;
14962
- }
14963
- function unpackCommandLookupTable(cmdLookup) {
14964
- let insertLengthOffsets = new Int16Array(24);
14965
- let copyLengthOffsets = new Int16Array(24);
14966
- copyLengthOffsets[0] = 2;
14967
- for (let i = 0; i < 23; ++i) {
14968
- insertLengthOffsets[i + 1] = insertLengthOffsets[i] + (1 << INSERT_LENGTH_N_BITS[i]);
14969
- copyLengthOffsets[i + 1] = copyLengthOffsets[i] + (1 << COPY_LENGTH_N_BITS[i]);
14970
- }
14971
- for (let cmdCode = 0; cmdCode < 704; ++cmdCode) {
14972
- let rangeIdx = cmdCode >>> 6;
14973
- let distanceContextOffset = -4;
14974
- if (rangeIdx >= 2) {
14975
- rangeIdx -= 2;
14976
- distanceContextOffset = 0;
14977
- }
14978
- let insertCode = (170064 >>> rangeIdx * 2 & 3) << 3 | cmdCode >>> 3 & 7;
14979
- let copyCode = (156228 >>> rangeIdx * 2 & 3) << 3 | cmdCode & 7;
14980
- let copyLengthOffset = copyLengthOffsets[copyCode];
14981
- let distanceContext = distanceContextOffset + (copyLengthOffset > 4 ? 3 : copyLengthOffset - 2);
14982
- let index = cmdCode * 4;
14983
- cmdLookup[index + 0] = INSERT_LENGTH_N_BITS[insertCode] | COPY_LENGTH_N_BITS[copyCode] << 8;
14984
- cmdLookup[index + 1] = insertLengthOffsets[insertCode];
14985
- cmdLookup[index + 2] = copyLengthOffsets[copyCode];
14986
- cmdLookup[index + 3] = distanceContext;
14987
- }
14988
- }
14989
- function decodeWindowBits(s) {
14990
- let largeWindowEnabled = s.isLargeWindow;
14991
- s.isLargeWindow = 0;
14992
- if (s.bitOffset >= 16) {
14993
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
14994
- s.bitOffset -= 16;
14995
- }
14996
- if (readFewBits(s, 1) === 0) {
14997
- return 16;
14998
- }
14999
- let n = readFewBits(s, 3);
15000
- if (n !== 0) {
15001
- return 17 + n;
15002
- }
15003
- n = readFewBits(s, 3);
15004
- if (n !== 0) {
15005
- if (n === 1) {
15006
- if (largeWindowEnabled === 0) {
15007
- return -1;
15008
- }
15009
- s.isLargeWindow = 1;
15010
- if (readFewBits(s, 1) === 1) {
15011
- return -1;
15012
- }
15013
- n = readFewBits(s, 6);
15014
- if (n < 10 || n > 30) {
15015
- return -1;
15016
- }
15017
- return n;
15018
- } else {
15019
- return 8 + n;
15020
- }
15021
- }
15022
- return 17;
15023
- }
15024
- function _enableEagerOutput(s) {
15025
- if (s.runningState !== 1) {
15026
- throw "State MUST be freshly initialized";
15027
- }
15028
- s.isEager = 1;
15029
- }
15030
- function _enableLargeWindow(s) {
15031
- if (s.runningState !== 1) {
15032
- throw "State MUST be freshly initialized";
15033
- }
15034
- s.isLargeWindow = 1;
15035
- }
15036
- function attachDictionaryChunk(s, data2) {
15037
- if (s.runningState !== 1) {
15038
- throw "State MUST be freshly initialized";
15039
- }
15040
- if (s.cdNumChunks === 0) {
15041
- s.cdChunks = new Array(16);
15042
- s.cdChunkOffsets = new Int32Array(16);
15043
- s.cdBlockBits = -1;
15044
- }
15045
- if (s.cdNumChunks === 15) {
15046
- throw "Too many dictionary chunks";
15047
- }
15048
- s.cdChunks[s.cdNumChunks] = data2;
15049
- s.cdNumChunks++;
15050
- s.cdTotalSize += data2.length;
15051
- s.cdChunkOffsets[s.cdNumChunks] = s.cdTotalSize;
15052
- }
15053
- function initState(s, input) {
15054
- if (s.runningState !== 0) {
15055
- throw "State MUST be uninitialized";
15056
- }
15057
- s.blockTrees = new Int32Array(3091);
15058
- s.blockTrees[0] = 7;
15059
- s.distRbIdx = 3;
15060
- let maxDistanceAlphabetLimit = calculateDistanceAlphabetLimit(
15061
- 2147483644,
15062
- 3,
15063
- 15 << 3
15064
- );
15065
- s.distExtraBits = new Int8Array(maxDistanceAlphabetLimit);
15066
- s.distOffset = new Int32Array(maxDistanceAlphabetLimit);
15067
- s.input = input;
15068
- initBitReader(s);
15069
- s.runningState = 1;
15070
- }
15071
- function close(s) {
15072
- if (s.runningState === 0) {
15073
- throw "State MUST be initialized";
15074
- }
15075
- if (s.runningState === 11) {
15076
- return;
15077
- }
15078
- s.runningState = 11;
15079
- if (s.input != null) {
15080
- closeInput(s.input);
15081
- s.input = null;
15082
- }
15083
- }
15084
- function decodeVarLenUnsignedByte(s) {
15085
- if (s.bitOffset >= 16) {
15086
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15087
- s.bitOffset -= 16;
15088
- }
15089
- if (readFewBits(s, 1) !== 0) {
15090
- let n = readFewBits(s, 3);
15091
- if (n === 0) {
15092
- return 1;
15093
- } else {
15094
- return readFewBits(s, n) + (1 << n);
15095
- }
15096
- }
15097
- return 0;
15098
- }
15099
- function decodeMetaBlockLength(s) {
15100
- if (s.bitOffset >= 16) {
15101
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15102
- s.bitOffset -= 16;
15103
- }
15104
- s.inputEnd = readFewBits(s, 1);
15105
- s.metaBlockLength = 0;
15106
- s.isUncompressed = 0;
15107
- s.isMetadata = 0;
15108
- if (s.inputEnd !== 0 && readFewBits(s, 1) !== 0) {
15109
- return;
15110
- }
15111
- let sizeNibbles = readFewBits(s, 2) + 4;
15112
- if (sizeNibbles === 7) {
15113
- s.isMetadata = 1;
15114
- if (readFewBits(s, 1) !== 0) {
15115
- throw "Corrupted reserved bit";
15116
- }
15117
- let sizeBytes = readFewBits(s, 2);
15118
- if (sizeBytes === 0) {
15119
- return;
15120
- }
15121
- for (let i = 0; i < sizeBytes; i++) {
15122
- if (s.bitOffset >= 16) {
15123
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15124
- s.bitOffset -= 16;
15125
- }
15126
- let bits2 = readFewBits(s, 8);
15127
- if (bits2 === 0 && i + 1 === sizeBytes && sizeBytes > 1) {
15128
- throw "Exuberant nibble";
15129
- }
15130
- s.metaBlockLength |= bits2 << i * 8;
15131
- }
15132
- } else {
15133
- for (let i = 0; i < sizeNibbles; i++) {
15134
- if (s.bitOffset >= 16) {
15135
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15136
- s.bitOffset -= 16;
15137
- }
15138
- let bits2 = readFewBits(s, 4);
15139
- if (bits2 === 0 && i + 1 === sizeNibbles && sizeNibbles > 4) {
15140
- throw "Exuberant nibble";
15141
- }
15142
- s.metaBlockLength |= bits2 << i * 4;
15143
- }
15144
- }
15145
- s.metaBlockLength++;
15146
- if (s.inputEnd === 0) {
15147
- s.isUncompressed = readFewBits(s, 1);
15148
- }
15149
- }
15150
- function readSymbol(tableGroup, tableIdx, s) {
15151
- let offset = tableGroup[tableIdx];
15152
- let val = s.accumulator32 >>> s.bitOffset;
15153
- offset += val & 255;
15154
- let bits2 = tableGroup[offset] >> 16;
15155
- let sym = tableGroup[offset] & 65535;
15156
- if (bits2 <= 8) {
15157
- s.bitOffset += bits2;
15158
- return sym;
15159
- }
15160
- offset += sym;
15161
- let mask = (1 << bits2) - 1;
15162
- offset += (val & mask) >>> 8;
15163
- s.bitOffset += (tableGroup[offset] >> 16) + 8;
15164
- return tableGroup[offset] & 65535;
15165
- }
15166
- function readBlockLength(tableGroup, tableIdx, s) {
15167
- if (s.bitOffset >= 16) {
15168
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15169
- s.bitOffset -= 16;
15170
- }
15171
- let code = readSymbol(tableGroup, tableIdx, s);
15172
- let n = BLOCK_LENGTH_N_BITS[code];
15173
- if (s.bitOffset >= 16) {
15174
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15175
- s.bitOffset -= 16;
15176
- }
15177
- return BLOCK_LENGTH_OFFSET[code] + (n <= 16 ? readFewBits(s, n) : readManyBits(s, n));
15178
- }
15179
- function moveToFront(v, index) {
15180
- let value = v[index];
15181
- for (; index > 0; index--) {
15182
- v[index] = v[index - 1];
15183
- }
15184
- v[0] = value;
15185
- }
15186
- function inverseMoveToFrontTransform(v, vLen) {
15187
- let mtf = new Int32Array(256);
15188
- for (let i = 0; i < 256; i++) {
15189
- mtf[i] = i;
15190
- }
15191
- for (let i = 0; i < vLen; i++) {
15192
- let index = v[i] & 255;
15193
- v[i] = mtf[index];
15194
- if (index !== 0) {
15195
- moveToFront(mtf, index);
15196
- }
15197
- }
15198
- }
15199
- function readHuffmanCodeLengths(codeLengthCodeLengths, numSymbols, codeLengths, s) {
15200
- let symbol = 0;
15201
- let prevCodeLen = 8;
15202
- let repeat = 0;
15203
- let repeatCodeLen = 0;
15204
- let space = 32768;
15205
- let table = new Int32Array(32 + 1);
15206
- let tableIdx = table.length - 1;
15207
- buildHuffmanTable(table, tableIdx, 5, codeLengthCodeLengths, 18);
15208
- while (symbol < numSymbols && space > 0) {
15209
- if (s.halfOffset > 2030) {
15210
- doReadMoreInput(s);
15211
- }
15212
- if (s.bitOffset >= 16) {
15213
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15214
- s.bitOffset -= 16;
15215
- }
15216
- let p = s.accumulator32 >>> s.bitOffset & 31;
15217
- s.bitOffset += table[p] >> 16;
15218
- let codeLen = table[p] & 65535;
15219
- if (codeLen < 16) {
15220
- repeat = 0;
15221
- codeLengths[symbol++] = codeLen;
15222
- if (codeLen !== 0) {
15223
- prevCodeLen = codeLen;
15224
- space -= 32768 >> codeLen;
15225
- }
15226
- } else {
15227
- let extraBits = codeLen - 14;
15228
- let newLen = 0;
15229
- if (codeLen === 16) {
15230
- newLen = prevCodeLen;
15231
- }
15232
- if (repeatCodeLen !== newLen) {
15233
- repeat = 0;
15234
- repeatCodeLen = newLen;
15235
- }
15236
- let oldRepeat = repeat;
15237
- if (repeat > 0) {
15238
- repeat -= 2;
15239
- repeat <<= extraBits;
15240
- }
15241
- if (s.bitOffset >= 16) {
15242
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15243
- s.bitOffset -= 16;
15244
- }
15245
- repeat += readFewBits(s, extraBits) + 3;
15246
- let repeatDelta = repeat - oldRepeat;
15247
- if (symbol + repeatDelta > numSymbols) {
15248
- throw "symbol + repeatDelta > numSymbols";
15249
- }
15250
- for (let i = 0; i < repeatDelta; i++) {
15251
- codeLengths[symbol++] = repeatCodeLen;
15252
- }
15253
- if (repeatCodeLen !== 0) {
15254
- space -= repeatDelta << 15 - repeatCodeLen;
15255
- }
15256
- }
15257
- }
15258
- if (space !== 0) {
15259
- throw "Unused space";
15260
- }
15261
- codeLengths.fill(0, symbol, numSymbols);
15262
- }
15263
- function checkDupes(symbols, length) {
15264
- for (let i = 0; i < length - 1; ++i) {
15265
- for (let j = i + 1; j < length; ++j) {
15266
- if (symbols[i] === symbols[j]) {
15267
- throw "Duplicate simple Huffman code symbol";
15268
- }
15269
- }
15270
- }
15271
- }
15272
- function readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
15273
- let codeLengths = new Int32Array(alphabetSizeLimit);
15274
- let symbols = new Int32Array(4);
15275
- let maxBits = 1 + log2floor(alphabetSizeMax - 1);
15276
- let numSymbols = readFewBits(s, 2) + 1;
15277
- for (let i = 0; i < numSymbols; i++) {
15278
- if (s.bitOffset >= 16) {
15279
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15280
- s.bitOffset -= 16;
15281
- }
15282
- let symbol = readFewBits(s, maxBits);
15283
- if (symbol >= alphabetSizeLimit) {
15284
- throw "Can't readHuffmanCode";
15285
- }
15286
- symbols[i] = symbol;
15287
- }
15288
- checkDupes(symbols, numSymbols);
15289
- let histogramId = numSymbols;
15290
- if (numSymbols === 4) {
15291
- histogramId += readFewBits(s, 1);
15292
- }
15293
- switch (histogramId) {
15294
- case 1:
15295
- codeLengths[symbols[0]] = 1;
15296
- break;
15297
- case 2:
15298
- codeLengths[symbols[0]] = 1;
15299
- codeLengths[symbols[1]] = 1;
15300
- break;
15301
- case 3:
15302
- codeLengths[symbols[0]] = 1;
15303
- codeLengths[symbols[1]] = 2;
15304
- codeLengths[symbols[2]] = 2;
15305
- break;
15306
- case 4:
15307
- codeLengths[symbols[0]] = 2;
15308
- codeLengths[symbols[1]] = 2;
15309
- codeLengths[symbols[2]] = 2;
15310
- codeLengths[symbols[3]] = 2;
15311
- break;
15312
- case 5:
15313
- codeLengths[symbols[0]] = 1;
15314
- codeLengths[symbols[1]] = 2;
15315
- codeLengths[symbols[2]] = 3;
15316
- codeLengths[symbols[3]] = 3;
15317
- break;
15318
- default:
15319
- break;
15320
- }
15321
- return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
15322
- }
15323
- function readComplexHuffmanCode(alphabetSizeLimit, skip, tableGroup, tableIdx, s) {
15324
- let codeLengths = new Int32Array(alphabetSizeLimit);
15325
- let codeLengthCodeLengths = new Int32Array(18);
15326
- let space = 32;
15327
- let numCodes = 0;
15328
- for (let i = skip; i < 18 && space > 0; i++) {
15329
- let codeLenIdx = CODE_LENGTH_CODE_ORDER[i];
15330
- if (s.bitOffset >= 16) {
15331
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15332
- s.bitOffset -= 16;
15333
- }
15334
- let p = s.accumulator32 >>> s.bitOffset & 15;
15335
- s.bitOffset += FIXED_TABLE[p] >> 16;
15336
- let v = FIXED_TABLE[p] & 65535;
15337
- codeLengthCodeLengths[codeLenIdx] = v;
15338
- if (v !== 0) {
15339
- space -= 32 >> v;
15340
- numCodes++;
15341
- }
15342
- }
15343
- if (space !== 0 && numCodes !== 1) {
15344
- throw "Corrupted Huffman code histogram";
15345
- }
15346
- readHuffmanCodeLengths(codeLengthCodeLengths, alphabetSizeLimit, codeLengths, s);
15347
- return buildHuffmanTable(tableGroup, tableIdx, 8, codeLengths, alphabetSizeLimit);
15348
- }
15349
- function readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s) {
15350
- if (s.halfOffset > 2030) {
15351
- doReadMoreInput(s);
15352
- }
15353
- if (s.bitOffset >= 16) {
15354
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15355
- s.bitOffset -= 16;
15356
- }
15357
- let simpleCodeOrSkip = readFewBits(s, 2);
15358
- if (simpleCodeOrSkip === 1) {
15359
- return readSimpleHuffmanCode(alphabetSizeMax, alphabetSizeLimit, tableGroup, tableIdx, s);
15360
- } else {
15361
- return readComplexHuffmanCode(alphabetSizeLimit, simpleCodeOrSkip, tableGroup, tableIdx, s);
15362
- }
15363
- }
15364
- function decodeContextMap(contextMapSize, contextMap, s) {
15365
- if (s.halfOffset > 2030) {
15366
- doReadMoreInput(s);
15367
- }
15368
- let numTrees = decodeVarLenUnsignedByte(s) + 1;
15369
- if (numTrees === 1) {
15370
- contextMap.fill(0, 0, contextMapSize);
15371
- return numTrees;
15372
- }
15373
- if (s.bitOffset >= 16) {
15374
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15375
- s.bitOffset -= 16;
15376
- }
15377
- let useRleForZeros = readFewBits(s, 1);
15378
- let maxRunLengthPrefix = 0;
15379
- if (useRleForZeros !== 0) {
15380
- maxRunLengthPrefix = readFewBits(s, 4) + 1;
15381
- }
15382
- let alphabetSize = numTrees + maxRunLengthPrefix;
15383
- let tableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSize + 31 >> 5];
15384
- let table = new Int32Array(tableSize + 1);
15385
- let tableIdx = table.length - 1;
15386
- readHuffmanCode(alphabetSize, alphabetSize, table, tableIdx, s);
15387
- for (let i = 0; i < contextMapSize; ) {
15388
- if (s.halfOffset > 2030) {
15389
- doReadMoreInput(s);
15390
- }
15391
- if (s.bitOffset >= 16) {
15392
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15393
- s.bitOffset -= 16;
15394
- }
15395
- let code = readSymbol(table, tableIdx, s);
15396
- if (code === 0) {
15397
- contextMap[i] = 0;
15398
- i++;
15399
- } else if (code <= maxRunLengthPrefix) {
15400
- if (s.bitOffset >= 16) {
15401
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15402
- s.bitOffset -= 16;
15403
- }
15404
- let reps = (1 << code) + readFewBits(s, code);
15405
- while (reps !== 0) {
15406
- if (i >= contextMapSize) {
15407
- throw "Corrupted context map";
15408
- }
15409
- contextMap[i] = 0;
15410
- i++;
15411
- reps--;
15412
- }
15413
- } else {
15414
- contextMap[i] = code - maxRunLengthPrefix;
15415
- i++;
15416
- }
15417
- }
15418
- if (s.bitOffset >= 16) {
15419
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15420
- s.bitOffset -= 16;
15421
- }
15422
- if (readFewBits(s, 1) === 1) {
15423
- inverseMoveToFrontTransform(contextMap, contextMapSize);
15424
- }
15425
- return numTrees;
15426
- }
15427
- function decodeBlockTypeAndLength(s, treeType, numBlockTypes) {
15428
- let ringBuffers = s.rings;
15429
- let offset = 4 + treeType * 2;
15430
- if (s.bitOffset >= 16) {
15431
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15432
- s.bitOffset -= 16;
15433
- }
15434
- let blockType = readSymbol(s.blockTrees, 2 * treeType, s);
15435
- let result = readBlockLength(s.blockTrees, 2 * treeType + 1, s);
15436
- if (blockType === 1) {
15437
- blockType = ringBuffers[offset + 1] + 1;
15438
- } else if (blockType === 0) {
15439
- blockType = ringBuffers[offset];
15440
- } else {
15441
- blockType -= 2;
15442
- }
15443
- if (blockType >= numBlockTypes) {
15444
- blockType -= numBlockTypes;
15445
- }
15446
- ringBuffers[offset] = ringBuffers[offset + 1];
15447
- ringBuffers[offset + 1] = blockType;
15448
- return result;
15449
- }
15450
- function decodeLiteralBlockSwitch(s) {
15451
- s.literalBlockLength = decodeBlockTypeAndLength(s, 0, s.numLiteralBlockTypes);
15452
- let literalBlockType = s.rings[5];
15453
- s.contextMapSlice = literalBlockType << 6;
15454
- s.literalTreeIdx = s.contextMap[s.contextMapSlice] & 255;
15455
- let contextMode = s.contextModes[literalBlockType];
15456
- s.contextLookupOffset1 = contextMode << 9;
15457
- s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
15458
- }
15459
- function decodeCommandBlockSwitch(s) {
15460
- s.commandBlockLength = decodeBlockTypeAndLength(s, 1, s.numCommandBlockTypes);
15461
- s.commandTreeIdx = s.rings[7];
15462
- }
15463
- function decodeDistanceBlockSwitch(s) {
15464
- s.distanceBlockLength = decodeBlockTypeAndLength(s, 2, s.numDistanceBlockTypes);
15465
- s.distContextMapSlice = s.rings[9] << 2;
15466
- }
15467
- function maybeReallocateRingBuffer(s) {
15468
- let newSize = s.maxRingBufferSize;
15469
- if (newSize > s.expectedTotalSize) {
15470
- let minimalNewSize = s.expectedTotalSize;
15471
- while (newSize >> 1 > minimalNewSize) {
15472
- newSize >>= 1;
15473
- }
15474
- if (s.inputEnd === 0 && newSize < 16384 && s.maxRingBufferSize >= 16384) {
15475
- newSize = 16384;
15476
- }
15477
- }
15478
- if (newSize <= s.ringBufferSize) {
15479
- return;
15480
- }
15481
- let ringBufferSizeWithSlack = newSize + 37;
15482
- let newBuffer = new Int8Array(ringBufferSizeWithSlack);
15483
- if (s.ringBuffer.length !== 0) {
15484
- newBuffer.set(s.ringBuffer.subarray(0, 0 + s.ringBufferSize), 0);
15485
- }
15486
- s.ringBuffer = newBuffer;
15487
- s.ringBufferSize = newSize;
15488
- }
15489
- function readNextMetablockHeader(s) {
15490
- if (s.inputEnd !== 0) {
15491
- s.nextRunningState = 10;
15492
- s.runningState = 12;
15493
- return;
15494
- }
15495
- s.literalTreeGroup = new Int32Array(0);
15496
- s.commandTreeGroup = new Int32Array(0);
15497
- s.distanceTreeGroup = new Int32Array(0);
15498
- if (s.halfOffset > 2030) {
15499
- doReadMoreInput(s);
15500
- }
15501
- decodeMetaBlockLength(s);
15502
- if (s.metaBlockLength === 0 && s.isMetadata === 0) {
15503
- return;
15504
- }
15505
- if (s.isUncompressed !== 0 || s.isMetadata !== 0) {
15506
- jumpToByteBoundary(s);
15507
- s.runningState = s.isMetadata !== 0 ? 5 : 6;
15508
- } else {
15509
- s.runningState = 3;
15510
- }
15511
- if (s.isMetadata !== 0) {
15512
- return;
15513
- }
15514
- s.expectedTotalSize += s.metaBlockLength;
15515
- if (s.expectedTotalSize > 1 << 30) {
15516
- s.expectedTotalSize = 1 << 30;
15517
- }
15518
- if (s.ringBufferSize < s.maxRingBufferSize) {
15519
- maybeReallocateRingBuffer(s);
15520
- }
15521
- }
15522
- function readMetablockPartition(s, treeType, numBlockTypes) {
15523
- let offset = s.blockTrees[2 * treeType];
15524
- if (numBlockTypes <= 1) {
15525
- s.blockTrees[2 * treeType + 1] = offset;
15526
- s.blockTrees[2 * treeType + 2] = offset;
15527
- return 1 << 28;
15528
- }
15529
- let blockTypeAlphabetSize = numBlockTypes + 2;
15530
- offset += readHuffmanCode(
15531
- blockTypeAlphabetSize,
15532
- blockTypeAlphabetSize,
15533
- s.blockTrees,
15534
- 2 * treeType,
15535
- s
15536
- );
15537
- s.blockTrees[2 * treeType + 1] = offset;
15538
- let blockLengthAlphabetSize = 26;
15539
- offset += readHuffmanCode(
15540
- blockLengthAlphabetSize,
15541
- blockLengthAlphabetSize,
15542
- s.blockTrees,
15543
- 2 * treeType + 1,
15544
- s
15545
- );
15546
- s.blockTrees[2 * treeType + 2] = offset;
15547
- return readBlockLength(s.blockTrees, 2 * treeType + 1, s);
15548
- }
15549
- function calculateDistanceLut(s, alphabetSizeLimit) {
15550
- let distExtraBits = s.distExtraBits;
15551
- let distOffset = s.distOffset;
15552
- let npostfix = s.distancePostfixBits;
15553
- let ndirect = s.numDirectDistanceCodes;
15554
- let postfix = 1 << npostfix;
15555
- let bits2 = 1;
15556
- let half = 0;
15557
- let i = 16;
15558
- for (let j = 0; j < ndirect; ++j) {
15559
- distExtraBits[i] = 0;
15560
- distOffset[i] = j + 1;
15561
- ++i;
15562
- }
15563
- while (i < alphabetSizeLimit) {
15564
- let base = ndirect + ((2 + half << bits2) - 4 << npostfix) + 1;
15565
- for (let j = 0; j < postfix; ++j) {
15566
- distExtraBits[i] = bits2;
15567
- distOffset[i] = base + j;
15568
- ++i;
15569
- }
15570
- bits2 = bits2 + half;
15571
- half = half ^ 1;
15572
- }
15573
- }
15574
- function readMetablockHuffmanCodesAndContextMaps(s) {
15575
- s.numLiteralBlockTypes = decodeVarLenUnsignedByte(s) + 1;
15576
- s.literalBlockLength = readMetablockPartition(s, 0, s.numLiteralBlockTypes);
15577
- s.numCommandBlockTypes = decodeVarLenUnsignedByte(s) + 1;
15578
- s.commandBlockLength = readMetablockPartition(s, 1, s.numCommandBlockTypes);
15579
- s.numDistanceBlockTypes = decodeVarLenUnsignedByte(s) + 1;
15580
- s.distanceBlockLength = readMetablockPartition(s, 2, s.numDistanceBlockTypes);
15581
- if (s.halfOffset > 2030) {
15582
- doReadMoreInput(s);
15583
- }
15584
- if (s.bitOffset >= 16) {
15585
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15586
- s.bitOffset -= 16;
15587
- }
15588
- s.distancePostfixBits = readFewBits(s, 2);
15589
- s.numDirectDistanceCodes = readFewBits(s, 4) << s.distancePostfixBits;
15590
- s.contextModes = new Int8Array(s.numLiteralBlockTypes);
15591
- for (let i = 0; i < s.numLiteralBlockTypes; ) {
15592
- let limit = min(i + 96, s.numLiteralBlockTypes);
15593
- for (; i < limit; ++i) {
15594
- if (s.bitOffset >= 16) {
15595
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15596
- s.bitOffset -= 16;
15597
- }
15598
- s.contextModes[i] = readFewBits(s, 2);
15599
- }
15600
- if (s.halfOffset > 2030) {
15601
- doReadMoreInput(s);
15602
- }
15603
- }
15604
- s.contextMap = new Int8Array(s.numLiteralBlockTypes << 6);
15605
- let numLiteralTrees = decodeContextMap(
15606
- s.numLiteralBlockTypes << 6,
15607
- s.contextMap,
15608
- s
15609
- );
15610
- s.trivialLiteralContext = 1;
15611
- for (let j = 0; j < s.numLiteralBlockTypes << 6; j++) {
15612
- if (s.contextMap[j] !== j >> 6) {
15613
- s.trivialLiteralContext = 0;
15614
- break;
15615
- }
15616
- }
15617
- s.distContextMap = new Int8Array(s.numDistanceBlockTypes << 2);
15618
- let numDistTrees = decodeContextMap(
15619
- s.numDistanceBlockTypes << 2,
15620
- s.distContextMap,
15621
- s
15622
- );
15623
- s.literalTreeGroup = decodeHuffmanTreeGroup(256, 256, numLiteralTrees, s);
15624
- s.commandTreeGroup = decodeHuffmanTreeGroup(704, 704, s.numCommandBlockTypes, s);
15625
- let distanceAlphabetSizeMax = calculateDistanceAlphabetSize(
15626
- s.distancePostfixBits,
15627
- s.numDirectDistanceCodes,
15628
- 24
15629
- );
15630
- let distanceAlphabetSizeLimit = distanceAlphabetSizeMax;
15631
- if (s.isLargeWindow === 1) {
15632
- distanceAlphabetSizeMax = calculateDistanceAlphabetSize(
15633
- s.distancePostfixBits,
15634
- s.numDirectDistanceCodes,
15635
- 62
15636
- );
15637
- distanceAlphabetSizeLimit = calculateDistanceAlphabetLimit(
15638
- 2147483644,
15639
- s.distancePostfixBits,
15640
- s.numDirectDistanceCodes
15641
- );
15642
- }
15643
- s.distanceTreeGroup = decodeHuffmanTreeGroup(
15644
- distanceAlphabetSizeMax,
15645
- distanceAlphabetSizeLimit,
15646
- numDistTrees,
15647
- s
15648
- );
15649
- calculateDistanceLut(s, distanceAlphabetSizeLimit);
15650
- s.contextMapSlice = 0;
15651
- s.distContextMapSlice = 0;
15652
- s.contextLookupOffset1 = s.contextModes[0] * 512;
15653
- s.contextLookupOffset2 = s.contextLookupOffset1 + 256;
15654
- s.literalTreeIdx = 0;
15655
- s.commandTreeIdx = 0;
15656
- s.rings[4] = 1;
15657
- s.rings[5] = 0;
15658
- s.rings[6] = 1;
15659
- s.rings[7] = 0;
15660
- s.rings[8] = 1;
15661
- s.rings[9] = 0;
15662
- }
15663
- function copyUncompressedData(s) {
15664
- let ringBuffer = s.ringBuffer;
15665
- if (s.metaBlockLength <= 0) {
15666
- reload(s);
15667
- s.runningState = 2;
15668
- return;
15669
- }
15670
- let chunkLength = min(s.ringBufferSize - s.pos, s.metaBlockLength);
15671
- copyRawBytes(s, ringBuffer, s.pos, chunkLength);
15672
- s.metaBlockLength -= chunkLength;
15673
- s.pos += chunkLength;
15674
- if (s.pos === s.ringBufferSize) {
15675
- s.nextRunningState = 6;
15676
- s.runningState = 12;
15677
- return;
15678
- }
15679
- reload(s);
15680
- s.runningState = 2;
15681
- }
15682
- function writeRingBuffer(s) {
15683
- let toWrite = min(
15684
- s.outputLength - s.outputUsed,
15685
- s.ringBufferBytesReady - s.ringBufferBytesWritten
15686
- );
15687
- if (toWrite !== 0) {
15688
- s.output.set(
15689
- s.ringBuffer.subarray(s.ringBufferBytesWritten, s.ringBufferBytesWritten + toWrite),
15690
- s.outputOffset + s.outputUsed
15691
- );
15692
- s.outputUsed += toWrite;
15693
- s.ringBufferBytesWritten += toWrite;
15694
- }
15695
- if (s.outputUsed < s.outputLength) {
15696
- return 1;
15697
- } else {
15698
- return 0;
15699
- }
15700
- }
15701
- function decodeHuffmanTreeGroup(alphabetSizeMax, alphabetSizeLimit, n, s) {
15702
- let maxTableSize = MAX_HUFFMAN_TABLE_SIZE[alphabetSizeLimit + 31 >> 5];
15703
- let group = new Int32Array(n + n * maxTableSize);
15704
- let next = n;
15705
- for (let i = 0; i < n; ++i) {
15706
- group[i] = next;
15707
- next += readHuffmanCode(alphabetSizeMax, alphabetSizeLimit, group, i, s);
15708
- }
15709
- return group;
15710
- }
15711
- function calculateFence(s) {
15712
- let result = s.ringBufferSize;
15713
- if (s.isEager !== 0) {
15714
- result = min(result, s.ringBufferBytesWritten + s.outputLength - s.outputUsed);
15715
- }
15716
- return result;
15717
- }
15718
- function doUseDictionary(s, fence) {
15719
- if (s.distance > 2147483644) {
15720
- throw "Invalid backward reference";
15721
- }
15722
- let address = s.distance - s.maxDistance - 1 - s.cdTotalSize;
15723
- if (address < 0) {
15724
- initializeCompoundDictionaryCopy(s, -address - 1, s.copyLength);
15725
- s.runningState = 14;
15726
- } else {
15727
- let dictionaryData = (
15728
- /** @type{!Int8Array} */
15729
- data
15730
- );
15731
- let wordLength = s.copyLength;
15732
- if (wordLength > 31) {
15733
- throw "Invalid backward reference";
15734
- }
15735
- let shift = sizeBits[wordLength];
15736
- if (shift === 0) {
15737
- throw "Invalid backward reference";
15738
- }
15739
- let offset = offsets[wordLength];
15740
- let mask = (1 << shift) - 1;
15741
- let wordIdx = address & mask;
15742
- let transformIdx = address >>> shift;
15743
- offset += wordIdx * wordLength;
15744
- let transforms = RFC_TRANSFORMS;
15745
- if (transformIdx >= transforms.numTransforms) {
15746
- throw "Invalid backward reference";
15747
- }
15748
- let len = transformDictionaryWord(
15749
- s.ringBuffer,
15750
- s.pos,
15751
- dictionaryData,
15752
- offset,
15753
- wordLength,
15754
- transforms,
15755
- transformIdx
15756
- );
15757
- s.pos += len;
15758
- s.metaBlockLength -= len;
15759
- if (s.pos >= fence) {
15760
- s.nextRunningState = 4;
15761
- s.runningState = 12;
15762
- return;
15763
- }
15764
- s.runningState = 4;
15765
- }
15766
- }
15767
- function initializeCompoundDictionary(s) {
15768
- s.cdBlockMap = new Int8Array(256);
15769
- let blockBits = 8;
15770
- while (s.cdTotalSize - 1 >>> blockBits !== 0) {
15771
- blockBits++;
15772
- }
15773
- blockBits -= 8;
15774
- s.cdBlockBits = blockBits;
15775
- let cursor = 0;
15776
- let index = 0;
15777
- while (cursor < s.cdTotalSize) {
15778
- while (s.cdChunkOffsets[index + 1] < cursor) {
15779
- index++;
15780
- }
15781
- s.cdBlockMap[cursor >>> blockBits] = index;
15782
- cursor += 1 << blockBits;
15783
- }
15784
- }
15785
- function initializeCompoundDictionaryCopy(s, address, length) {
15786
- if (s.cdBlockBits === -1) {
15787
- initializeCompoundDictionary(s);
15788
- }
15789
- let index = s.cdBlockMap[address >>> s.cdBlockBits];
15790
- while (address >= s.cdChunkOffsets[index + 1]) {
15791
- index++;
15792
- }
15793
- if (s.cdTotalSize > address + length) {
15794
- throw "Invalid backward reference";
15795
- }
15796
- s.distRbIdx = s.distRbIdx + 1 & 3;
15797
- s.rings[s.distRbIdx] = s.distance;
15798
- s.metaBlockLength -= length;
15799
- s.cdBrIndex = index;
15800
- s.cdBrOffset = address - s.cdChunkOffsets[index];
15801
- s.cdBrLength = length;
15802
- s.cdBrCopied = 0;
15803
- }
15804
- function copyFromCompoundDictionary(s, fence) {
15805
- let pos = s.pos;
15806
- let origPos = pos;
15807
- while (s.cdBrLength !== s.cdBrCopied) {
15808
- let space = fence - pos;
15809
- let chunkLength = s.cdChunkOffsets[s.cdBrIndex + 1] - s.cdChunkOffsets[s.cdBrIndex];
15810
- let remChunkLength = chunkLength - s.cdBrOffset;
15811
- let length = s.cdBrLength - s.cdBrCopied;
15812
- if (length > remChunkLength) {
15813
- length = remChunkLength;
15814
- }
15815
- if (length > space) {
15816
- length = space;
15817
- }
15818
- copyBytes(s.ringBuffer, pos, s.cdChunks[s.cdBrIndex], s.cdBrOffset, s.cdBrOffset + length);
15819
- pos += length;
15820
- s.cdBrOffset += length;
15821
- s.cdBrCopied += length;
15822
- if (length === remChunkLength) {
15823
- s.cdBrIndex++;
15824
- s.cdBrOffset = 0;
15825
- }
15826
- if (pos >= fence) {
15827
- break;
15828
- }
15829
- }
15830
- return pos - origPos;
15831
- }
15832
- function decompress4(s) {
15833
- if (s.runningState === 0) {
15834
- throw "Can't decompress until initialized";
15835
- }
15836
- if (s.runningState === 11) {
15837
- throw "Can't decompress after close";
15838
- }
15839
- if (s.runningState === 1) {
15840
- let windowBits = decodeWindowBits(s);
15841
- if (windowBits === -1) {
15842
- throw "Invalid 'windowBits' code";
15843
- }
15844
- s.maxRingBufferSize = 1 << windowBits;
15845
- s.maxBackwardDistance = s.maxRingBufferSize - 16;
15846
- s.runningState = 2;
15847
- }
15848
- let fence = calculateFence(s);
15849
- let ringBufferMask = s.ringBufferSize - 1;
15850
- let ringBuffer = s.ringBuffer;
15851
- while (s.runningState !== 10) {
15852
- switch (s.runningState) {
15853
- case 2:
15854
- if (s.metaBlockLength < 0) {
15855
- throw "Invalid metablock length";
15856
- }
15857
- readNextMetablockHeader(s);
15858
- fence = calculateFence(s);
15859
- ringBufferMask = s.ringBufferSize - 1;
15860
- ringBuffer = s.ringBuffer;
15861
- continue;
15862
- case 3:
15863
- readMetablockHuffmanCodesAndContextMaps(s);
15864
- s.runningState = 4;
15865
- case 4:
15866
- if (s.metaBlockLength <= 0) {
15867
- s.runningState = 2;
15868
- continue;
15869
- }
15870
- if (s.halfOffset > 2030) {
15871
- doReadMoreInput(s);
15872
- }
15873
- if (s.commandBlockLength === 0) {
15874
- decodeCommandBlockSwitch(s);
15875
- }
15876
- s.commandBlockLength--;
15877
- if (s.bitOffset >= 16) {
15878
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15879
- s.bitOffset -= 16;
15880
- }
15881
- let cmdCode = readSymbol(s.commandTreeGroup, s.commandTreeIdx, s) << 2;
15882
- let insertAndCopyExtraBits = CMD_LOOKUP[cmdCode];
15883
- let insertLengthOffset = CMD_LOOKUP[cmdCode + 1];
15884
- let copyLengthOffset = CMD_LOOKUP[cmdCode + 2];
15885
- s.distanceCode = CMD_LOOKUP[cmdCode + 3];
15886
- if (s.bitOffset >= 16) {
15887
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15888
- s.bitOffset -= 16;
15889
- }
15890
- let insertLengthExtraBits = insertAndCopyExtraBits & 255;
15891
- s.insertLength = insertLengthOffset + (insertLengthExtraBits <= 16 ? readFewBits(s, insertLengthExtraBits) : readManyBits(s, insertLengthExtraBits));
15892
- if (s.bitOffset >= 16) {
15893
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15894
- s.bitOffset -= 16;
15895
- }
15896
- let copyLengthExtraBits = insertAndCopyExtraBits >> 8;
15897
- s.copyLength = copyLengthOffset + (copyLengthExtraBits <= 16 ? readFewBits(s, copyLengthExtraBits) : readManyBits(s, copyLengthExtraBits));
15898
- s.j = 0;
15899
- s.runningState = 7;
15900
- case 7:
15901
- if (s.trivialLiteralContext !== 0) {
15902
- while (s.j < s.insertLength) {
15903
- if (s.halfOffset > 2030) {
15904
- doReadMoreInput(s);
15905
- }
15906
- if (s.literalBlockLength === 0) {
15907
- decodeLiteralBlockSwitch(s);
15908
- }
15909
- s.literalBlockLength--;
15910
- if (s.bitOffset >= 16) {
15911
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15912
- s.bitOffset -= 16;
15913
- }
15914
- ringBuffer[s.pos] = readSymbol(s.literalTreeGroup, s.literalTreeIdx, s);
15915
- s.pos++;
15916
- s.j++;
15917
- if (s.pos >= fence) {
15918
- s.nextRunningState = 7;
15919
- s.runningState = 12;
15920
- break;
15921
- }
15922
- }
15923
- } else {
15924
- let prevByte1 = ringBuffer[s.pos - 1 & ringBufferMask] & 255;
15925
- let prevByte2 = ringBuffer[s.pos - 2 & ringBufferMask] & 255;
15926
- while (s.j < s.insertLength) {
15927
- if (s.halfOffset > 2030) {
15928
- doReadMoreInput(s);
15929
- }
15930
- if (s.literalBlockLength === 0) {
15931
- decodeLiteralBlockSwitch(s);
15932
- }
15933
- let literalContext = LOOKUP[s.contextLookupOffset1 + prevByte1] | LOOKUP[s.contextLookupOffset2 + prevByte2];
15934
- let literalTreeIdx = s.contextMap[s.contextMapSlice + literalContext] & 255;
15935
- s.literalBlockLength--;
15936
- prevByte2 = prevByte1;
15937
- if (s.bitOffset >= 16) {
15938
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15939
- s.bitOffset -= 16;
15940
- }
15941
- prevByte1 = readSymbol(s.literalTreeGroup, literalTreeIdx, s);
15942
- ringBuffer[s.pos] = prevByte1;
15943
- s.pos++;
15944
- s.j++;
15945
- if (s.pos >= fence) {
15946
- s.nextRunningState = 7;
15947
- s.runningState = 12;
15948
- break;
15949
- }
15950
- }
15951
- }
15952
- if (s.runningState !== 7) {
15953
- continue;
15954
- }
15955
- s.metaBlockLength -= s.insertLength;
15956
- if (s.metaBlockLength <= 0) {
15957
- s.runningState = 4;
15958
- continue;
15959
- }
15960
- let distanceCode = s.distanceCode;
15961
- if (distanceCode < 0) {
15962
- s.distance = s.rings[s.distRbIdx];
15963
- } else {
15964
- if (s.halfOffset > 2030) {
15965
- doReadMoreInput(s);
15966
- }
15967
- if (s.distanceBlockLength === 0) {
15968
- decodeDistanceBlockSwitch(s);
15969
- }
15970
- s.distanceBlockLength--;
15971
- if (s.bitOffset >= 16) {
15972
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15973
- s.bitOffset -= 16;
15974
- }
15975
- let distTreeIdx = s.distContextMap[s.distContextMapSlice + distanceCode] & 255;
15976
- distanceCode = readSymbol(s.distanceTreeGroup, distTreeIdx, s);
15977
- if (distanceCode < 16) {
15978
- let index = s.distRbIdx + DISTANCE_SHORT_CODE_INDEX_OFFSET[distanceCode] & 3;
15979
- s.distance = s.rings[index] + DISTANCE_SHORT_CODE_VALUE_OFFSET[distanceCode];
15980
- if (s.distance < 0) {
15981
- throw "Negative distance";
15982
- }
15983
- } else {
15984
- let extraBits = s.distExtraBits[distanceCode];
15985
- let bits2;
15986
- if (s.bitOffset + extraBits <= 32) {
15987
- bits2 = readFewBits(s, extraBits);
15988
- } else {
15989
- if (s.bitOffset >= 16) {
15990
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
15991
- s.bitOffset -= 16;
15992
- }
15993
- bits2 = extraBits <= 16 ? readFewBits(s, extraBits) : readManyBits(s, extraBits);
15994
- }
15995
- s.distance = s.distOffset[distanceCode] + (bits2 << s.distancePostfixBits);
15996
- }
15997
- }
15998
- if (s.maxDistance !== s.maxBackwardDistance && s.pos < s.maxBackwardDistance) {
15999
- s.maxDistance = s.pos;
16000
- } else {
16001
- s.maxDistance = s.maxBackwardDistance;
16002
- }
16003
- if (s.distance > s.maxDistance) {
16004
- s.runningState = 9;
16005
- continue;
16006
- }
16007
- if (distanceCode > 0) {
16008
- s.distRbIdx = s.distRbIdx + 1 & 3;
16009
- s.rings[s.distRbIdx] = s.distance;
16010
- }
16011
- if (s.copyLength > s.metaBlockLength) {
16012
- throw "Invalid backward reference";
16013
- }
16014
- s.j = 0;
16015
- s.runningState = 8;
16016
- case 8:
16017
- let src = s.pos - s.distance & ringBufferMask;
16018
- let dst = s.pos;
16019
- let copyLength = s.copyLength - s.j;
16020
- let srcEnd = src + copyLength;
16021
- let dstEnd = dst + copyLength;
16022
- if (srcEnd < ringBufferMask && dstEnd < ringBufferMask) {
16023
- if (copyLength < 12 || srcEnd > dst && dstEnd > src) {
16024
- for (let k = 0; k < copyLength; k += 4) {
16025
- ringBuffer[dst++] = ringBuffer[src++];
16026
- ringBuffer[dst++] = ringBuffer[src++];
16027
- ringBuffer[dst++] = ringBuffer[src++];
16028
- ringBuffer[dst++] = ringBuffer[src++];
16029
- }
16030
- } else {
16031
- ringBuffer.copyWithin(dst, src, srcEnd);
16032
- }
16033
- s.j += copyLength;
16034
- s.metaBlockLength -= copyLength;
16035
- s.pos += copyLength;
16036
- } else {
16037
- for (; s.j < s.copyLength; ) {
16038
- ringBuffer[s.pos] = ringBuffer[s.pos - s.distance & ringBufferMask];
16039
- s.metaBlockLength--;
16040
- s.pos++;
16041
- s.j++;
16042
- if (s.pos >= fence) {
16043
- s.nextRunningState = 8;
16044
- s.runningState = 12;
16045
- break;
16046
- }
16047
- }
16048
- }
16049
- if (s.runningState === 8) {
16050
- s.runningState = 4;
16051
- }
16052
- continue;
16053
- case 9:
16054
- doUseDictionary(s, fence);
16055
- continue;
16056
- case 14:
16057
- s.pos += copyFromCompoundDictionary(s, fence);
16058
- if (s.pos >= fence) {
16059
- s.nextRunningState = 14;
16060
- s.runningState = 12;
16061
- return;
16062
- }
16063
- s.runningState = 4;
16064
- continue;
16065
- case 5:
16066
- while (s.metaBlockLength > 0) {
16067
- if (s.halfOffset > 2030) {
16068
- doReadMoreInput(s);
16069
- }
16070
- if (s.bitOffset >= 16) {
16071
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
16072
- s.bitOffset -= 16;
16073
- }
16074
- readFewBits(s, 8);
16075
- s.metaBlockLength--;
16076
- }
16077
- s.runningState = 2;
16078
- continue;
16079
- case 6:
16080
- copyUncompressedData(s);
16081
- continue;
16082
- case 12:
16083
- s.ringBufferBytesReady = min(s.pos, s.ringBufferSize);
16084
- s.runningState = 13;
16085
- case 13:
16086
- if (writeRingBuffer(s) === 0) {
16087
- return;
16088
- }
16089
- if (s.pos >= s.maxBackwardDistance) {
16090
- s.maxDistance = s.maxBackwardDistance;
16091
- }
16092
- if (s.pos >= s.ringBufferSize) {
16093
- if (s.pos > s.ringBufferSize) {
16094
- ringBuffer.copyWithin(0, s.ringBufferSize, s.pos);
16095
- }
16096
- s.pos &= ringBufferMask;
16097
- s.ringBufferBytesWritten = 0;
16098
- }
16099
- s.runningState = s.nextRunningState;
16100
- continue;
16101
- default:
16102
- throw "Unexpected state " + s.runningState;
16103
- }
16104
- }
16105
- if (s.runningState === 10) {
16106
- if (s.metaBlockLength < 0) {
16107
- throw "Invalid metablock length";
16108
- }
16109
- jumpToByteBoundary(s);
16110
- checkHealth(s, 1);
16111
- }
16112
- }
16113
- function Transforms(numTransforms, prefixSuffixLen, prefixSuffixCount) {
16114
- this.numTransforms = 0;
16115
- this.triplets = new Int32Array(0);
16116
- this.prefixSuffixStorage = new Int8Array(0);
16117
- this.prefixSuffixHeads = new Int32Array(0);
16118
- this.params = new Int16Array(0);
16119
- this.numTransforms = numTransforms;
16120
- this.triplets = new Int32Array(numTransforms * 3);
16121
- this.params = new Int16Array(numTransforms);
16122
- this.prefixSuffixStorage = new Int8Array(prefixSuffixLen);
16123
- this.prefixSuffixHeads = new Int32Array(prefixSuffixCount + 1);
16124
- }
16125
- let RFC_TRANSFORMS = new Transforms(121, 167, 50);
16126
- function unpackTransforms(prefixSuffix, prefixSuffixHeads, transforms, prefixSuffixSrc, transformsSrc) {
16127
- let n = prefixSuffixSrc.length;
16128
- let index = 1;
16129
- let j = 0;
16130
- for (let i = 0; i < n; ++i) {
16131
- let c = prefixSuffixSrc.charCodeAt(i);
16132
- if (c === 35) {
16133
- prefixSuffixHeads[index++] = j;
16134
- } else {
16135
- prefixSuffix[j++] = c;
16136
- }
16137
- }
16138
- for (let i = 0; i < 363; ++i) {
16139
- transforms[i] = transformsSrc.charCodeAt(i) - 32;
16140
- }
16141
- }
16142
- {
16143
- unpackTransforms(
16144
- RFC_TRANSFORMS.prefixSuffixStorage,
16145
- RFC_TRANSFORMS.prefixSuffixHeads,
16146
- RFC_TRANSFORMS.triplets,
16147
- `# #s #, #e #.# the #.com/#\xC2\xA0# of # and # in # to #"#">#
16148
- #]# for # a # that #. # with #'# from # by #. The # on # as # is #ing #
16149
- #:#ed #(# at #ly #="# of the #. This #,# not #er #al #='#ful #ive #less #est #ize #ous #`,
16150
- ` !! ! , *! &! " ! ) * * - ! # ! #!*! + ,$ ! - % . / # 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`
16151
- );
16152
- }
16153
- function transformDictionaryWord(dst, dstOffset, src, srcOffset, len, transforms, transformIndex) {
16154
- let offset = dstOffset;
16155
- let triplets = transforms.triplets;
16156
- let prefixSuffixStorage = transforms.prefixSuffixStorage;
16157
- let prefixSuffixHeads = transforms.prefixSuffixHeads;
16158
- let transformOffset = 3 * transformIndex;
16159
- let prefixIdx = triplets[transformOffset];
16160
- let transformType = triplets[transformOffset + 1];
16161
- let suffixIdx = triplets[transformOffset + 2];
16162
- let prefix = prefixSuffixHeads[prefixIdx];
16163
- let prefixEnd = prefixSuffixHeads[prefixIdx + 1];
16164
- let suffix = prefixSuffixHeads[suffixIdx];
16165
- let suffixEnd = prefixSuffixHeads[suffixIdx + 1];
16166
- let omitFirst = transformType - 11;
16167
- let omitLast = transformType - 0;
16168
- if (omitFirst < 1 || omitFirst > 9) {
16169
- omitFirst = 0;
16170
- }
16171
- if (omitLast < 1 || omitLast > 9) {
16172
- omitLast = 0;
16173
- }
16174
- while (prefix !== prefixEnd) {
16175
- dst[offset++] = prefixSuffixStorage[prefix++];
16176
- }
16177
- if (omitFirst > len) {
16178
- omitFirst = len;
16179
- }
16180
- srcOffset += omitFirst;
16181
- len -= omitFirst;
16182
- len -= omitLast;
16183
- let i = len;
16184
- while (i > 0) {
16185
- dst[offset++] = src[srcOffset++];
16186
- i--;
16187
- }
16188
- if (transformType === 10 || transformType === 11) {
16189
- let uppercaseOffset = offset - len;
16190
- if (transformType === 10) {
16191
- len = 1;
16192
- }
16193
- while (len > 0) {
16194
- let c0 = dst[uppercaseOffset] & 255;
16195
- if (c0 < 192) {
16196
- if (c0 >= 97 && c0 <= 122) {
16197
- dst[uppercaseOffset] ^= 32;
16198
- }
16199
- uppercaseOffset += 1;
16200
- len -= 1;
16201
- } else if (c0 < 224) {
16202
- dst[uppercaseOffset + 1] ^= 32;
16203
- uppercaseOffset += 2;
16204
- len -= 2;
16205
- } else {
16206
- dst[uppercaseOffset + 2] ^= 5;
16207
- uppercaseOffset += 3;
16208
- len -= 3;
16209
- }
16210
- }
16211
- } else if (transformType === 21 || transformType === 22) {
16212
- let shiftOffset = offset - len;
16213
- let param = transforms.params[transformIndex];
16214
- let scalar = (param & 32767) + (16777216 - (param & 32768));
16215
- while (len > 0) {
16216
- let step = 1;
16217
- let c0 = dst[shiftOffset] & 255;
16218
- if (c0 < 128) {
16219
- scalar += c0;
16220
- dst[shiftOffset] = scalar & 127;
16221
- } else if (c0 < 192) {
16222
- } else if (c0 < 224) {
16223
- if (len >= 2) {
16224
- let c1 = dst[shiftOffset + 1];
16225
- scalar += c1 & 63 | (c0 & 31) << 6;
16226
- dst[shiftOffset] = 192 | scalar >> 6 & 31;
16227
- dst[shiftOffset + 1] = c1 & 192 | scalar & 63;
16228
- step = 2;
16229
- } else {
16230
- step = len;
16231
- }
16232
- } else if (c0 < 240) {
16233
- if (len >= 3) {
16234
- let c1 = dst[shiftOffset + 1];
16235
- let c2 = dst[shiftOffset + 2];
16236
- scalar += c2 & 63 | (c1 & 63) << 6 | (c0 & 15) << 12;
16237
- dst[shiftOffset] = 224 | scalar >> 12 & 15;
16238
- dst[shiftOffset + 1] = c1 & 192 | scalar >> 6 & 63;
16239
- dst[shiftOffset + 2] = c2 & 192 | scalar & 63;
16240
- step = 3;
16241
- } else {
16242
- step = len;
16243
- }
16244
- } else if (c0 < 248) {
16245
- if (len >= 4) {
16246
- let c1 = dst[shiftOffset + 1];
16247
- let c2 = dst[shiftOffset + 2];
16248
- let c3 = dst[shiftOffset + 3];
16249
- scalar += c3 & 63 | (c2 & 63) << 6 | (c1 & 63) << 12 | (c0 & 7) << 18;
16250
- dst[shiftOffset] = 240 | scalar >> 18 & 7;
16251
- dst[shiftOffset + 1] = c1 & 192 | scalar >> 12 & 63;
16252
- dst[shiftOffset + 2] = c2 & 192 | scalar >> 6 & 63;
16253
- dst[shiftOffset + 3] = c3 & 192 | scalar & 63;
16254
- step = 4;
16255
- } else {
16256
- step = len;
16257
- }
16258
- }
16259
- shiftOffset += step;
16260
- len -= step;
16261
- if (transformType === 21) {
16262
- len = 0;
16263
- }
16264
- }
16265
- }
16266
- while (suffix !== suffixEnd) {
16267
- dst[offset++] = prefixSuffixStorage[suffix++];
16268
- }
16269
- return offset - dstOffset;
16270
- }
16271
- function getNextKey(key, len) {
16272
- let step = 1 << len - 1;
16273
- while ((key & step) !== 0) {
16274
- step >>= 1;
16275
- }
16276
- return (key & step - 1) + step;
16277
- }
16278
- function replicateValue(table, offset, step, end, item) {
16279
- do {
16280
- end -= step;
16281
- table[offset + end] = item;
16282
- } while (end > 0);
16283
- }
16284
- function nextTableBitSize(count, len, rootBits) {
16285
- let left = 1 << len - rootBits;
16286
- while (len < 15) {
16287
- left -= count[len];
16288
- if (left <= 0) {
16289
- break;
16290
- }
16291
- len++;
16292
- left <<= 1;
16293
- }
16294
- return len - rootBits;
16295
- }
16296
- function buildHuffmanTable(tableGroup, tableIdx, rootBits, codeLengths, codeLengthsSize) {
16297
- let tableOffset = tableGroup[tableIdx];
16298
- let key;
16299
- let sorted = new Int32Array(codeLengthsSize);
16300
- let count = new Int32Array(16);
16301
- let offset = new Int32Array(16);
16302
- let symbol;
16303
- for (symbol = 0; symbol < codeLengthsSize; symbol++) {
16304
- count[codeLengths[symbol]]++;
16305
- }
16306
- offset[1] = 0;
16307
- for (let len = 1; len < 15; len++) {
16308
- offset[len + 1] = offset[len] + count[len];
16309
- }
16310
- for (symbol = 0; symbol < codeLengthsSize; symbol++) {
16311
- if (codeLengths[symbol] !== 0) {
16312
- sorted[offset[codeLengths[symbol]]++] = symbol;
16313
- }
16314
- }
16315
- let tableBits = rootBits;
16316
- let tableSize = 1 << tableBits;
16317
- let totalSize = tableSize;
16318
- if (offset[15] === 1) {
16319
- for (key = 0; key < totalSize; key++) {
16320
- tableGroup[tableOffset + key] = sorted[0];
16321
- }
16322
- return totalSize;
16323
- }
16324
- key = 0;
16325
- symbol = 0;
16326
- for (let len = 1, step = 2; len <= rootBits; len++, step <<= 1) {
16327
- for (; count[len] > 0; count[len]--) {
16328
- replicateValue(
16329
- tableGroup,
16330
- tableOffset + key,
16331
- step,
16332
- tableSize,
16333
- len << 16 | sorted[symbol++]
16334
- );
16335
- key = getNextKey(key, len);
16336
- }
16337
- }
16338
- let mask = totalSize - 1;
16339
- let low = -1;
16340
- let currentOffset = tableOffset;
16341
- for (let len = rootBits + 1, step = 2; len <= 15; len++, step <<= 1) {
16342
- for (; count[len] > 0; count[len]--) {
16343
- if ((key & mask) !== low) {
16344
- currentOffset += tableSize;
16345
- tableBits = nextTableBitSize(count, len, rootBits);
16346
- tableSize = 1 << tableBits;
16347
- totalSize += tableSize;
16348
- low = key & mask;
16349
- tableGroup[tableOffset + low] = tableBits + rootBits << 16 | currentOffset - tableOffset - low;
16350
- }
16351
- replicateValue(
16352
- tableGroup,
16353
- currentOffset + (key >> rootBits),
16354
- step,
16355
- tableSize,
16356
- len - rootBits << 16 | sorted[symbol++]
16357
- );
16358
- key = getNextKey(key, len);
16359
- }
16360
- }
16361
- return totalSize;
16362
- }
16363
- function doReadMoreInput(s) {
16364
- if (s.endOfStreamReached !== 0) {
16365
- if (halfAvailable(s) >= -2) {
16366
- return;
16367
- }
16368
- throw "No more input";
16369
- }
16370
- let readOffset = s.halfOffset << 1;
16371
- let bytesInBuffer = 4096 - readOffset;
16372
- s.byteBuffer.copyWithin(0, readOffset, 4096);
16373
- s.halfOffset = 0;
16374
- while (bytesInBuffer < 4096) {
16375
- let spaceLeft = 4096 - bytesInBuffer;
16376
- let len = readInput(s.input, s.byteBuffer, bytesInBuffer, spaceLeft);
16377
- if (len <= 0) {
16378
- s.endOfStreamReached = 1;
16379
- s.tailBytes = bytesInBuffer;
16380
- bytesInBuffer += 1;
16381
- break;
16382
- }
16383
- bytesInBuffer += len;
16384
- }
16385
- bytesToNibbles(s, bytesInBuffer);
16386
- }
16387
- function checkHealth(s, endOfStream) {
16388
- if (s.endOfStreamReached === 0) {
16389
- return;
16390
- }
16391
- let byteOffset = (s.halfOffset << 1) + (s.bitOffset + 7 >> 3) - 4;
16392
- if (byteOffset > s.tailBytes) {
16393
- throw "Read after end";
16394
- }
16395
- if (endOfStream !== 0 && byteOffset !== s.tailBytes) {
16396
- throw "Unused bytes after end";
16397
- }
16398
- }
16399
- function _assertAccumulatorHealthy(s) {
16400
- if (s.bitOffset > 32) {
16401
- throw "Accumulator underloaded: " + s.bitOffset;
16402
- }
16403
- }
16404
- function readFewBits(s, n) {
16405
- let val = s.accumulator32 >>> s.bitOffset & (1 << n) - 1;
16406
- s.bitOffset += n;
16407
- return val;
16408
- }
16409
- function readManyBits(s, n) {
16410
- let low = readFewBits(s, 16);
16411
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
16412
- s.bitOffset -= 16;
16413
- return low | readFewBits(s, n - 16) << 16;
16414
- }
16415
- function initBitReader(s) {
16416
- s.byteBuffer = new Int8Array(4160);
16417
- s.accumulator32 = 0;
16418
- s.shortBuffer = new Int16Array(2080);
16419
- s.bitOffset = 32;
16420
- s.halfOffset = 2048;
16421
- s.endOfStreamReached = 0;
16422
- prepare(s);
16423
- }
16424
- function prepare(s) {
16425
- if (s.halfOffset > 2030) {
16426
- doReadMoreInput(s);
16427
- }
16428
- checkHealth(s, 0);
16429
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
16430
- s.bitOffset -= 16;
16431
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
16432
- s.bitOffset -= 16;
16433
- }
16434
- function reload(s) {
16435
- if (s.bitOffset === 32) {
16436
- prepare(s);
16437
- }
16438
- }
16439
- function jumpToByteBoundary(s) {
16440
- let padding = 32 - s.bitOffset & 7;
16441
- if (padding !== 0) {
16442
- let paddingBits = readFewBits(s, padding);
16443
- if (paddingBits !== 0) {
16444
- throw "Corrupted padding bits";
16445
- }
16446
- }
16447
- }
16448
- function halfAvailable(s) {
16449
- let limit = 2048;
16450
- if (s.endOfStreamReached !== 0) {
16451
- limit = s.tailBytes + 1 >> 1;
16452
- }
16453
- return limit - s.halfOffset;
16454
- }
16455
- function copyRawBytes(s, data2, offset, length) {
16456
- if ((s.bitOffset & 7) !== 0) {
16457
- throw "Unaligned copyBytes";
16458
- }
16459
- while (s.bitOffset !== 32 && length !== 0) {
16460
- data2[offset++] = s.accumulator32 >>> s.bitOffset;
16461
- s.bitOffset += 8;
16462
- length--;
16463
- }
16464
- if (length === 0) {
16465
- return;
16466
- }
16467
- let copyNibbles = min(halfAvailable(s), length >> 1);
16468
- if (copyNibbles > 0) {
16469
- let readOffset = s.halfOffset << 1;
16470
- let delta = copyNibbles << 1;
16471
- data2.set(s.byteBuffer.subarray(readOffset, readOffset + delta), offset);
16472
- offset += delta;
16473
- length -= delta;
16474
- s.halfOffset += copyNibbles;
16475
- }
16476
- if (length === 0) {
16477
- return;
16478
- }
16479
- if (halfAvailable(s) > 0) {
16480
- if (s.bitOffset >= 16) {
16481
- s.accumulator32 = s.shortBuffer[s.halfOffset++] << 16 | s.accumulator32 >>> 16;
16482
- s.bitOffset -= 16;
16483
- }
16484
- while (length !== 0) {
16485
- data2[offset++] = s.accumulator32 >>> s.bitOffset;
16486
- s.bitOffset += 8;
16487
- length--;
16488
- }
16489
- checkHealth(s, 0);
16490
- return;
16491
- }
16492
- while (length > 0) {
16493
- let len = readInput(s.input, data2, offset, length);
16494
- if (len === -1) {
16495
- throw "Unexpected end of input";
16496
- }
16497
- offset += len;
16498
- length -= len;
16499
- }
16500
- }
16501
- function bytesToNibbles(s, byteLen) {
16502
- let byteBuffer = s.byteBuffer;
16503
- let halfLen = byteLen >> 1;
16504
- let shortBuffer = s.shortBuffer;
16505
- for (let i = 0; i < halfLen; ++i) {
16506
- shortBuffer[i] = byteBuffer[i * 2] & 255 | (byteBuffer[i * 2 + 1] & 255) << 8;
16507
- }
16508
- }
16509
- let LOOKUP = new Int32Array(2048);
16510
- function unpackLookupTable(lookup, map, rle) {
16511
- for (let i = 0; i < 256; ++i) {
16512
- lookup[i] = i & 63;
16513
- lookup[512 + i] = i >> 2;
16514
- lookup[1792 + i] = 2 + (i >> 6);
16515
- }
16516
- for (let i = 0; i < 128; ++i) {
16517
- lookup[1024 + i] = 4 * (map.charCodeAt(i) - 32);
16518
- }
16519
- for (let i = 0; i < 64; ++i) {
16520
- lookup[1152 + i] = i & 1;
16521
- lookup[1216 + i] = 2 + (i & 1);
16522
- }
16523
- let offset = 1280;
16524
- for (let k = 0; k < 19; ++k) {
16525
- let value = k & 3;
16526
- let rep = rle.charCodeAt(k) - 32;
16527
- for (let i = 0; i < rep; ++i) {
16528
- lookup[offset++] = value;
16529
- }
16530
- }
16531
- for (let i = 0; i < 16; ++i) {
16532
- lookup[1792 + i] = 1;
16533
- lookup[2032 + i] = 6;
16534
- }
16535
- lookup[1792] = 0;
16536
- lookup[2047] = 7;
16537
- for (let i = 0; i < 256; ++i) {
16538
- lookup[1536 + i] = lookup[1792 + i] << 3;
16539
- }
16540
- }
16541
- {
16542
- unpackLookupTable(
16543
- LOOKUP,
16544
- ` !! ! "#$##%#$&'##(#)#++++++++++((&*'##,---,---,-----,-----,-----&#'###.///.///./////./////./////&#'# `,
16545
- "A/* ': & : $ \x81 @"
16546
- );
16547
- }
16548
- function State() {
16549
- this.ringBuffer = new Int8Array(0);
16550
- this.contextModes = new Int8Array(0);
16551
- this.contextMap = new Int8Array(0);
16552
- this.distContextMap = new Int8Array(0);
16553
- this.distExtraBits = new Int8Array(0);
16554
- this.output = new Int8Array(0);
16555
- this.byteBuffer = new Int8Array(0);
16556
- this.shortBuffer = new Int16Array(0);
16557
- this.intBuffer = new Int32Array(0);
16558
- this.rings = new Int32Array(0);
16559
- this.blockTrees = new Int32Array(0);
16560
- this.literalTreeGroup = new Int32Array(0);
16561
- this.commandTreeGroup = new Int32Array(0);
16562
- this.distanceTreeGroup = new Int32Array(0);
16563
- this.distOffset = new Int32Array(0);
16564
- this.runningState = 0;
16565
- this.nextRunningState = 0;
16566
- this.accumulator32 = 0;
16567
- this.bitOffset = 0;
16568
- this.halfOffset = 0;
16569
- this.tailBytes = 0;
16570
- this.endOfStreamReached = 0;
16571
- this.metaBlockLength = 0;
16572
- this.inputEnd = 0;
16573
- this.isUncompressed = 0;
16574
- this.isMetadata = 0;
16575
- this.literalBlockLength = 0;
16576
- this.numLiteralBlockTypes = 0;
16577
- this.commandBlockLength = 0;
16578
- this.numCommandBlockTypes = 0;
16579
- this.distanceBlockLength = 0;
16580
- this.numDistanceBlockTypes = 0;
16581
- this.pos = 0;
16582
- this.maxDistance = 0;
16583
- this.distRbIdx = 0;
16584
- this.trivialLiteralContext = 0;
16585
- this.literalTreeIdx = 0;
16586
- this.commandTreeIdx = 0;
16587
- this.j = 0;
16588
- this.insertLength = 0;
16589
- this.contextMapSlice = 0;
16590
- this.distContextMapSlice = 0;
16591
- this.contextLookupOffset1 = 0;
16592
- this.contextLookupOffset2 = 0;
16593
- this.distanceCode = 0;
16594
- this.numDirectDistanceCodes = 0;
16595
- this.distancePostfixBits = 0;
16596
- this.distance = 0;
16597
- this.copyLength = 0;
16598
- this.maxBackwardDistance = 0;
16599
- this.maxRingBufferSize = 0;
16600
- this.ringBufferSize = 0;
16601
- this.expectedTotalSize = 0;
16602
- this.outputOffset = 0;
16603
- this.outputLength = 0;
16604
- this.outputUsed = 0;
16605
- this.ringBufferBytesWritten = 0;
16606
- this.ringBufferBytesReady = 0;
16607
- this.isEager = 0;
16608
- this.isLargeWindow = 0;
16609
- this.cdNumChunks = 0;
16610
- this.cdTotalSize = 0;
16611
- this.cdBrIndex = 0;
16612
- this.cdBrOffset = 0;
16613
- this.cdBrLength = 0;
16614
- this.cdBrCopied = 0;
16615
- this.cdChunks = new Array(0);
16616
- this.cdChunkOffsets = new Int32Array(0);
16617
- this.cdBlockBits = 0;
16618
- this.cdBlockMap = new Int8Array(0);
16619
- this.input = null;
16620
- this.ringBuffer = new Int8Array(0);
16621
- this.rings = new Int32Array(10);
16622
- this.rings[0] = 16;
16623
- this.rings[1] = 15;
16624
- this.rings[2] = 11;
16625
- this.rings[3] = 4;
16626
- }
16627
- let data = null;
16628
- let offsets = new Int32Array(32);
16629
- let sizeBits = new Int32Array(32);
16630
- function setData(newData, newSizeBits) {
16631
- if (isDirect(newData) === 0 || isReadOnly(newData) === 0) {
16632
- throw "newData must be a direct read-only byte buffer";
16633
- }
16634
- if (newSizeBits.length > 31) {
16635
- throw "sizeBits length must be at most 31";
16636
- }
16637
- for (let i = 0; i < 4; ++i) {
16638
- if (newSizeBits[i] !== 0) {
16639
- throw "first 4 must be 0";
16640
- }
16641
- }
16642
- let dictionaryOffsets = offsets;
16643
- let dictionarySizeBits = sizeBits;
16644
- dictionarySizeBits.set(newSizeBits.subarray(0, 0 + newSizeBits.length), 0);
16645
- let pos = 0;
16646
- let limit = newData.length;
16647
- for (let i = 0; i < newSizeBits.length; ++i) {
16648
- dictionaryOffsets[i] = pos;
16649
- let bits2 = dictionarySizeBits[i];
16650
- if (bits2 !== 0) {
16651
- if (bits2 >= 31) {
16652
- throw "newSizeBits values must be less than 31";
16653
- }
16654
- pos += i << bits2;
16655
- if (pos <= 0 || pos > limit) {
16656
- throw "newSizeBits is inconsistent: overflow";
16657
- }
16658
- }
16659
- }
16660
- for (let i = newSizeBits.length; i < 32; ++i) {
16661
- dictionaryOffsets[i] = pos;
16662
- }
16663
- if (pos !== limit) {
16664
- throw "newSizeBits is inconsistent: underflow";
16665
- }
16666
- data = newData;
16667
- }
16668
- function unpackDictionaryData(dictionary, data0, data1, skipFlip, sizeBits2, sizeBitsData) {
16669
- let dict = toUsAsciiBytes(data0 + data1);
16670
- if (dict.length !== dictionary.length) {
16671
- throw "Corrupted brotli dictionary";
16672
- }
16673
- let offset = 0;
16674
- let n = skipFlip.length;
16675
- for (let i = 0; i < n; i += 2) {
16676
- let skip = skipFlip.charCodeAt(i) - 36;
16677
- let flip = skipFlip.charCodeAt(i + 1) - 36;
16678
- for (let j = 0; j < skip; ++j) {
16679
- dict[offset] ^= 3;
16680
- offset++;
16681
- }
16682
- for (let j = 0; j < flip; ++j) {
16683
- dict[offset] ^= 236;
16684
- offset++;
16685
- }
16686
- }
16687
- for (let i = 0; i < sizeBitsData.length; ++i) {
16688
- sizeBits2[i] = sizeBitsData.charCodeAt(i) - 65;
16689
- }
16690
- dictionary.set(dict);
16691
- }
16692
- {
16693
- let dictionaryData = new Int8Array(122784);
16694
- let dictionarySizeBits = new Int32Array(25);
16695
- unpackDictionaryData(
16696
- dictionaryData,
16697
- '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',
16698
- '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',
16699
- "\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",
16700
- dictionarySizeBits,
16701
- "AAAAKKLLKKKKKJJIHHIHHGGFF"
16702
- );
16703
- flipBuffer(dictionaryData);
16704
- setData(asReadOnlyBuffer(dictionaryData), dictionarySizeBits);
16705
- }
16706
- function min(a, b) {
16707
- return a <= b ? a : b;
16708
- }
16709
- function copyBytes(dst, target, src, start, end) {
16710
- dst.set(src.slice(start, end), target);
16711
- }
16712
- function readInput(src, dst, offset, length) {
16713
- if (src == null) return -1;
16714
- let end = min(src.offset + length, src.data.length);
16715
- let bytesRead = end - src.offset;
16716
- dst.set(src.data.subarray(src.offset, end), offset);
16717
- src.offset += bytesRead;
16718
- return bytesRead;
16719
- }
16720
- function closeInput(src) {
16721
- return 0;
16722
- }
16723
- function asReadOnlyBuffer(src) {
16724
- return src;
16725
- }
16726
- function isReadOnly(src) {
16727
- return 1;
16728
- }
16729
- function isDirect(src) {
16730
- return 1;
16731
- }
16732
- function flipBuffer(buffer) {
16733
- }
16734
- function toUsAsciiBytes(src) {
16735
- let n = src.length;
16736
- let result = new Int8Array(n);
16737
- for (let i = 0; i < n; ++i) {
16738
- result[i] = src.charCodeAt(i);
16739
- }
16740
- return result;
16741
- }
16742
- function decode(bytes, options) {
16743
- let s = new State();
16744
- initState(s, new InputStream(bytes));
16745
- if (options) {
16746
- let customDictionary = (
16747
- /** @type {?Int8Array} */
16748
- options["customDictionary"]
16749
- );
16750
- if (customDictionary) attachDictionaryChunk(s, customDictionary);
16751
- }
16752
- let totalOutput = 0;
16753
- let chunks = [];
16754
- while (true) {
16755
- let chunk = new Int8Array(16384);
16756
- chunks.push(chunk);
16757
- s.output = chunk;
16758
- s.outputOffset = 0;
16759
- s.outputLength = 16384;
16760
- s.outputUsed = 0;
16761
- decompress4(s);
16762
- totalOutput += s.outputUsed;
16763
- if (s.outputUsed < 16384) break;
16764
- }
16765
- close(s);
16766
- let result = new Int8Array(totalOutput);
16767
- let offset = 0;
16768
- for (let i = 0; i < chunks.length; ++i) {
16769
- let chunk = chunks[i];
16770
- let end = min(totalOutput, offset + 16384);
16771
- let len = end - offset;
16772
- if (len < 16384) {
16773
- result.set(chunk.subarray(0, len), offset);
16774
- } else {
16775
- result.set(chunk, offset);
14111
+ yield* output;
14112
+ return;
16776
14113
  }
16777
- offset += len;
16778
14114
  }
16779
- return result;
14115
+ yield* super.decompressBatches(inputBatches);
16780
14116
  }
16781
- return decode;
16782
14117
  };
16783
- BrotliDecode = makeBrotliDecode();
16784
- }
16785
- });
16786
-
16787
- // ../compression/src/brotli-decode.ts
16788
- var brotli_decode_exports = {};
16789
- __export(brotli_decode_exports, {
16790
- BrotliDecode: () => BrotliDecode
16791
- });
16792
- var init_brotli_decode = __esm({
16793
- "../compression/src/brotli-decode.ts"() {
16794
- "use strict";
16795
- init_decode();
16796
14118
  }
16797
14119
  });
16798
14120
 
16799
- // ../compression/src/lib/brotli-compression.ts
16800
- var brotli_compression_exports = {};
16801
- __export(brotli_compression_exports, {
16802
- BrotliCompression: () => BrotliCompression
16803
- });
16804
- var import_zlib, DEFAULT_BROTLI_OPTIONS, BrotliCompression;
16805
- var init_brotli_compression = __esm({
16806
- "../compression/src/lib/brotli-compression.ts"() {
14121
+ // ../compression/src/brotli-decompressor-compress-utils.ts
14122
+ var BrotliCompressUtilsDecompressor;
14123
+ var init_brotli_decompressor_compress_utils = __esm({
14124
+ "../compression/src/brotli-decompressor-compress-utils.ts"() {
16807
14125
  "use strict";
16808
- init_compression();
16809
- init_src2();
16810
- import_zlib = __toESM(require("zlib"), 1);
16811
- init_compression_stream();
16812
- init_decompression_stream();
16813
- DEFAULT_BROTLI_OPTIONS = {
16814
- brotli: {
16815
- mode: 0,
16816
- quality: 8,
16817
- lgwin: 22
16818
- }
16819
- };
16820
- BrotliCompression = class extends Compression {
16821
- name = "brotli";
16822
- extensions = ["br"];
16823
- contentEncodings = ["br"];
16824
- isSupported = true;
16825
- options;
14126
+ init_compress_utils_compression();
14127
+ BrotliCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
16826
14128
  constructor(options = {}) {
16827
- super(options);
16828
- this.options = options;
16829
- registerJSModules(options == null ? void 0 : options.modules);
16830
- }
16831
- /**
16832
- * brotli is an injectable dependency due to big size
16833
- * @param options
16834
- */
16835
- async preload(modules = {}) {
16836
- registerJSModules(modules);
16837
- if (!getJSModuleOrNull("brotli")) {
16838
- const { BrotliDecode: BrotliDecode2 } = await Promise.resolve().then(() => (init_brotli_decode(), brotli_decode_exports));
16839
- registerJSModules({
16840
- brotli: {
16841
- compress: () => {
16842
- throw new Error("Brotli compression requires an injected encoder");
16843
- },
16844
- decompress: (input) => BrotliDecode2(input, void 0)
16845
- }
16846
- });
16847
- }
16848
- }
16849
- async compress(input) {
16850
- var _a;
16851
- const nativeOutput = await compressWithNativeCompressionStream(input, "brotli");
16852
- if (nativeOutput) return nativeOutput;
16853
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
16854
- const buffer = await promisify1(import_zlib.default.brotliCompress)(input);
16855
- return toArrayBuffer2(buffer);
16856
- }
16857
- return this.compressSync(input);
16858
- }
16859
- compressSync(input) {
16860
- var _a, _b;
16861
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
16862
- const buffer = import_zlib.default.brotliCompressSync(input);
16863
- return toArrayBuffer2(buffer);
16864
- }
16865
- const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
16866
- const inputArray = new Uint8Array(input);
16867
- const brotli = getJSModule("brotli", this.name);
16868
- const outputArray = brotli.compress(inputArray, brotliOptions);
16869
- if (!outputArray) {
16870
- throw new Error("Brotli compression failed");
16871
- }
16872
- return toArrayBuffer2(outputArray.buffer);
16873
- }
16874
- async decompress(input) {
16875
- var _a;
16876
- if (!getJSModuleOrNull("brotli")) {
16877
- const nativeOutput = await decompressWithNativeDecompressionStream(input, "brotli");
16878
- if (nativeOutput) return nativeOutput;
16879
- }
16880
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
16881
- const buffer = await promisify1(import_zlib.default.brotliDecompress)(input);
16882
- return toArrayBuffer2(buffer);
16883
- }
16884
- await this.preload();
16885
- return this.decompressSync(input);
16886
- }
16887
- decompressSync(input) {
16888
- var _a, _b;
16889
- if (!isBrowser && ((_a = this.options.brotli) == null ? void 0 : _a.useZlib)) {
16890
- const buffer = import_zlib.default.brotliDecompressSync(input);
16891
- return toArrayBuffer2(buffer);
16892
- }
16893
- const brotliOptions = { ...DEFAULT_BROTLI_OPTIONS.brotli, ...(_b = this.options) == null ? void 0 : _b.brotli };
16894
- const inputArray = new Uint8Array(input);
16895
- const brotli = getJSModuleOrNull("brotli");
16896
- if (brotli) {
16897
- const outputArray = brotli.decompress(inputArray, brotliOptions);
16898
- return toArrayBuffer2(outputArray.buffer);
16899
- }
16900
- throw new Error(`${this.name}: synchronous fallback is unavailable; preload a brotli module`);
16901
- }
16902
- async *decompressBatches(inputBatches) {
16903
- const nativeBatches = decompressBatchesWithNativeDecompressionStream(inputBatches, "brotli");
16904
- if (nativeBatches) {
16905
- yield* nativeBatches;
16906
- return;
16907
- }
16908
- yield this.decompress(await this.concatenate(inputBatches));
16909
- }
16910
- async *compressBatches(inputBatches) {
16911
- const nativeBatches = compressBatchesWithNativeCompressionStream(inputBatches, "brotli");
16912
- if (nativeBatches) {
16913
- yield* nativeBatches;
16914
- return;
16915
- }
16916
- yield this.compress(await this.concatenate(inputBatches));
14129
+ super(
14130
+ { name: "brotli", extensions: ["br"], contentEncodings: ["br"] },
14131
+ () => import("compress-utils/brotli/decompress"),
14132
+ options
14133
+ );
16917
14134
  }
16918
14135
  };
16919
14136
  }
@@ -16928,42 +14145,18 @@ var BrotliDecompressor;
16928
14145
  var init_brotli_decompressor = __esm({
16929
14146
  "../compression/src/brotli-decompressor.ts"() {
16930
14147
  "use strict";
16931
- init_compression();
14148
+ init_brotli_decompressor_compress_utils();
16932
14149
  init_decompression_stream();
16933
- BrotliDecompressor = class extends Decompressor {
16934
- name = "brotli";
16935
- extensions = ["br"];
16936
- contentEncodings = ["br"];
16937
- isSupported = true;
16938
- options;
16939
- fallback = null;
16940
- constructor(options = {}) {
16941
- super(options);
16942
- this.options = options;
16943
- }
16944
- /** Loads the injected or bundled JavaScript fallback. */
16945
- async preload(modules = {}) {
16946
- const fallback = await this.getFallback();
16947
- await fallback.preload({ ...this.options.modules, ...modules });
16948
- }
16949
- /** Decompresses with the built-in stream when available, then loads the bundled fallback. */
16950
- async decompress(input) {
14150
+ BrotliDecompressor = class extends BrotliCompressUtilsDecompressor {
14151
+ /** Decompresses with native streams when available, otherwise lazily initializes WASM. */
14152
+ async decompress(input, size) {
16951
14153
  if (this.options.useNative !== false) {
16952
14154
  const output = await decompressWithNativeDecompressionStream(input, "brotli");
16953
14155
  if (output) return output;
16954
14156
  }
16955
- const fallback = await this.getFallback();
16956
- await fallback.preload(this.options.modules);
16957
- return fallback.decompressSync(input);
14157
+ return super.decompress(input, size);
16958
14158
  }
16959
- /** Decompresses synchronously after the fallback has been preloaded. */
16960
- decompressSync(input) {
16961
- if (!this.fallback) {
16962
- throw new Error("brotli: call preload() before synchronous decompression");
16963
- }
16964
- return this.fallback.decompressSync(input);
16965
- }
16966
- /** Decompresses batches with a built-in stream or the bundled fallback. */
14159
+ /** Streams native batches when available, otherwise uses the WASM stream. */
16967
14160
  async *decompressBatches(inputBatches) {
16968
14161
  if (this.options.useNative !== false) {
16969
14162
  const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "brotli");
@@ -16972,46 +14165,21 @@ var init_brotli_decompressor = __esm({
16972
14165
  return;
16973
14166
  }
16974
14167
  }
16975
- yield this.decompress(await this.concatenate(inputBatches));
16976
- }
16977
- async getFallback() {
16978
- if (!this.fallback) {
16979
- const { BrotliCompression: BrotliCompression2 } = await Promise.resolve().then(() => (init_brotli_compression(), brotli_compression_exports));
16980
- this.fallback = new BrotliCompression2(this.options);
16981
- }
16982
- return this.fallback;
14168
+ yield* super.decompressBatches(inputBatches);
16983
14169
  }
16984
14170
  };
16985
14171
  }
16986
14172
  });
16987
14173
 
16988
- // ../compression/src/snappy-decompressor-snappyjs.ts
16989
- var SnappyJSDecompressor;
16990
- var init_snappy_decompressor_snappyjs = __esm({
16991
- "../compression/src/snappy-decompressor-snappyjs.ts"() {
14174
+ // ../compression/src/snappy-decompressor-compress-utils.ts
14175
+ var SnappyCompressUtilsDecompressor;
14176
+ var init_snappy_decompressor_compress_utils = __esm({
14177
+ "../compression/src/snappy-decompressor-compress-utils.ts"() {
16992
14178
  "use strict";
16993
- init_compression();
16994
- init_src2();
16995
- SnappyJSDecompressor = class extends Decompressor {
16996
- name = "snappy";
16997
- extensions = [];
16998
- contentEncodings = [];
16999
- isSupported = true;
14179
+ init_compress_utils_compression();
14180
+ SnappyCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
17000
14181
  constructor(options = {}) {
17001
- super(options);
17002
- registerJSModules(options.modules);
17003
- }
17004
- /** Loads snappyjs when it has not been injected. */
17005
- async preload(modules = {}) {
17006
- registerJSModules(modules);
17007
- if (!getJSModuleOrNull("snappyjs")) {
17008
- const snappy = await import("snappyjs");
17009
- registerJSModules({ snappyjs: snappy.default || snappy });
17010
- }
17011
- }
17012
- /** Decompresses one Snappy payload synchronously after preload. */
17013
- decompressSync(input) {
17014
- return getJSModule("snappyjs", this.name).uncompress(input);
14182
+ super({ name: "snappy" }, () => import("compress-utils/snappy/decompress"), options);
17015
14183
  }
17016
14184
  };
17017
14185
  }
@@ -17026,297 +14194,144 @@ var SnappyDecompressor;
17026
14194
  var init_snappy_decompressor = __esm({
17027
14195
  "../compression/src/snappy-decompressor.ts"() {
17028
14196
  "use strict";
17029
- init_snappy_decompressor_snappyjs();
17030
- SnappyDecompressor = class extends SnappyJSDecompressor {
14197
+ init_snappy_decompressor_compress_utils();
14198
+ SnappyDecompressor = class extends SnappyCompressUtilsDecompressor {
17031
14199
  };
17032
14200
  }
17033
14201
  });
17034
14202
 
17035
- // ../compression/src/lib/lz4-compression.ts
17036
- function readUInt32BE(data, offset) {
17037
- return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
17038
- }
17039
- var LZ4_MAGIC_NUMBER, LZ4Compression;
17040
- var init_lz4_compression = __esm({
17041
- "../compression/src/lib/lz4-compression.ts"() {
14203
+ // ../compression/src/lz4-decompressor.ts
14204
+ var lz4_decompressor_exports = {};
14205
+ __export(lz4_decompressor_exports, {
14206
+ LZ4Decompressor: () => LZ4Decompressor
14207
+ });
14208
+ var LZ4Decompressor;
14209
+ var init_lz4_decompressor = __esm({
14210
+ "../compression/src/lz4-decompressor.ts"() {
17042
14211
  "use strict";
17043
- init_src2();
14212
+ init_lz4_decompressor_compress_utils();
17044
14213
  init_compression();
17045
- LZ4_MAGIC_NUMBER = 407708164;
17046
- LZ4Compression = class extends Compression {
14214
+ LZ4Decompressor = class extends Decompressor {
14215
+ /** Codec name. */
17047
14216
  name = "lz4";
14217
+ /** Recognized extensions. */
17048
14218
  extensions = ["lz4"];
14219
+ /** Recognized content encodings. */
17049
14220
  contentEncodings = ["x-lz4"];
14221
+ /** The optional WASM implementation is available after preload. */
17050
14222
  isSupported = true;
17051
- options;
14223
+ /** Decoder for framed payloads. */
14224
+ framed;
14225
+ /** Decoder for raw blocks. */
14226
+ raw;
14227
+ /** Whether to bypass format detection. */
14228
+ useRaw;
14229
+ /** Maximum caller-provided capacity before raw/Hadoop decoding allocates. */
14230
+ maximumCapacity;
14231
+ /** Creates lazy framed and raw decoder bindings. */
17052
14232
  constructor(options = {}) {
17053
14233
  super(options);
17054
- this.options = options;
17055
- registerJSModules(options == null ? void 0 : options.modules);
14234
+ this.framed = new LZ4CompressUtilsDecompressor({ ...options, raw: false });
14235
+ this.raw = new LZ4CompressUtilsDecompressor({ ...options, raw: true });
14236
+ this.useRaw = Boolean(options.raw);
14237
+ this.maximumCapacity = options.maxOutputByteLength ?? 512 * 1024 * 1024;
17056
14238
  }
14239
+ /** Initializes both decoder entry points for synchronous format detection. */
17057
14240
  async preload(modules = {}) {
17058
- registerJSModules(modules);
17059
- if (!getJSModuleOrNull("lz4js")) {
17060
- const lz4 = await import("lz4js");
17061
- registerJSModules({ lz4js: lz4.default || lz4 });
17062
- }
17063
- }
17064
- compressSync(input) {
17065
- const lz4js = getJSModule("lz4js", this.name);
17066
- const inputArray = new Uint8Array(input);
17067
- return lz4js.compress(inputArray).buffer;
14241
+ await Promise.all([this.framed.preload(modules), this.raw.preload(modules)]);
17068
14242
  }
17069
- async compress(input) {
14243
+ /** Loads the codecs and decodes one frame or bounded block. */
14244
+ async decompress(input, size) {
17070
14245
  await this.preload();
17071
- return this.compressSync(input);
14246
+ return this.decompressSync(input, size);
17072
14247
  }
17073
- /**
17074
- * Decompresses an ArrayBuffer containing an Lz4 frame. maxSize is optional; if not
17075
- * provided, a maximum size will be determined by examining the data. The
17076
- * returned ArrayBuffer will always be perfectly sized.
17077
- * If data provided without magic number we will parse it as block
17078
- */
17079
- decompressSync(data, maxSize) {
17080
- try {
17081
- const isMagicNumberExists = this.checkMagicNumber(data);
17082
- const inputArray = new Uint8Array(data);
17083
- if (isMagicNumberExists) {
17084
- const lz4js = getJSModule("lz4js", this.name);
17085
- return lz4js.decompress(inputArray, maxSize).buffer;
17086
- }
17087
- if (!maxSize) {
17088
- const error = new Error("Need to provide maxSize");
17089
- throw this.improveError(error);
17090
- }
17091
- let uncompressed = new Uint8Array(maxSize);
17092
- const hadoopSize = this.decodeHadoopBlocks(inputArray, uncompressed);
17093
- if (hadoopSize !== null) {
17094
- return toArrayBuffer2(
17095
- hadoopSize === uncompressed.byteLength ? uncompressed : uncompressed.subarray(0, hadoopSize)
17096
- );
17097
- }
17098
- const uncompressedSize = this.decodeBlock(inputArray, uncompressed);
17099
- if (uncompressedSize < 0 || uncompressedSize > maxSize) {
17100
- throw new Error(`Invalid LZ4 block at byte ${Math.abs(uncompressedSize)}`);
17101
- }
17102
- return toArrayBuffer2(
17103
- uncompressedSize === uncompressed.byteLength ? uncompressed : uncompressed.subarray(0, uncompressedSize)
17104
- );
17105
- } catch (error) {
17106
- throw this.improveError(error);
14248
+ /** Decodes one payload after preload; raw blocks require output capacity. */
14249
+ decompressSync(input, size) {
14250
+ if (!this.useRaw && input.byteLength >= 4 && new DataView(input).getUint32(0, true) === 407708164) {
14251
+ return this.framed.decompressSync(input, size);
17107
14252
  }
17108
- }
17109
- async decompress(data, maxSize) {
17110
- const isMagicNumberExists = this.checkMagicNumber(data);
17111
- if (!isMagicNumberExists) {
17112
- return this.decompressSync(data, maxSize);
14253
+ if (!Number.isSafeInteger(size) || size < 0 || size > this.maximumCapacity)
14254
+ throw new RangeError("lz4: provide a valid output capacity");
14255
+ if (!this.useRaw) {
14256
+ const hadoopOutput = this.decodeHadoopBlocks(input, size);
14257
+ if (hadoopOutput) return hadoopOutput;
17113
14258
  }
17114
- await this.preload();
17115
- return this.decompressSync(data, maxSize);
14259
+ return this.raw.decompressSync(input, size);
17116
14260
  }
17117
- /**
17118
- * Decodes the legacy Hadoop LZ4 block stream used by older Parquet writers.
17119
- * Returns null when the input is not a valid Hadoop-framed stream.
17120
- */
17121
- decodeHadoopBlocks(data, output) {
14261
+ /** Validates the legacy Hadoop lengths in TypeScript before decoding each raw block. */
14262
+ decodeHadoopBlocks(input, capacity) {
14263
+ const view = new DataView(input);
14264
+ const blocks = [];
17122
14265
  let inputOffset = 0;
17123
14266
  let outputOffset = 0;
17124
- while (inputOffset < data.length) {
17125
- if (data.length - inputOffset < 8) {
17126
- return null;
17127
- }
17128
- const uncompressedByteLength = readUInt32BE(data, inputOffset);
17129
- const compressedByteLength = readUInt32BE(data, inputOffset + 4);
17130
- inputOffset += 8;
17131
- if (uncompressedByteLength === 0 || compressedByteLength === 0 || inputOffset + compressedByteLength > data.length || outputOffset + uncompressedByteLength > output.length) {
17132
- return null;
17133
- }
17134
- const compressedBlock = data.subarray(inputOffset, inputOffset + compressedByteLength);
17135
- const outputBlock = output.subarray(outputOffset, outputOffset + uncompressedByteLength);
17136
- const decodedByteLength = this.decodeBlock(compressedBlock, outputBlock);
17137
- if (decodedByteLength !== uncompressedByteLength) {
17138
- return null;
17139
- }
17140
- inputOffset += compressedByteLength;
17141
- outputOffset += uncompressedByteLength;
17142
- }
17143
- return outputOffset;
17144
- }
17145
- /**
17146
- * Decode lz4 file as block
17147
- * Solution taken from here
17148
- * https://github.com/pierrec/node-lz4/blob/0dac687262403fd34f905b963da7220692f2a4a1/lib/binding.js#L25
17149
- * @param input
17150
- * @param output
17151
- * @param startIndex
17152
- * @param endIndex
17153
- */
17154
- decodeBlock(data, output, startIndex, endIndex) {
17155
- startIndex = startIndex || 0;
17156
- endIndex = endIndex || data.length - startIndex;
17157
- let uncompressedSize = 0;
17158
- for (let index = startIndex; index < endIndex; ) {
17159
- const token = data[index++];
17160
- let literalsLength = token >> 4;
17161
- if (literalsLength > 0) {
17162
- let length2 = literalsLength + 240;
17163
- while (length2 === 255) {
17164
- length2 = data[index++];
17165
- literalsLength += length2;
17166
- }
17167
- const end2 = index + literalsLength;
17168
- while (index < end2) {
17169
- output[uncompressedSize++] = data[index++];
17170
- }
17171
- if (index === endIndex) {
17172
- return uncompressedSize;
17173
- }
17174
- }
17175
- const offset = data[index++] | data[index++] << 8;
17176
- if (offset === 0 || offset > uncompressedSize) {
17177
- return -(index - 2);
17178
- }
17179
- let matchLength = token & 15;
17180
- let length = matchLength + 240;
17181
- while (length === 255) {
17182
- length = data[index++];
17183
- matchLength += length;
17184
- }
17185
- let pos = uncompressedSize - offset;
17186
- const end = uncompressedSize + matchLength + 4;
17187
- while (uncompressedSize < end) {
17188
- output[uncompressedSize++] = output[pos++];
17189
- }
14267
+ try {
14268
+ while (inputOffset < input.byteLength) {
14269
+ if (input.byteLength - inputOffset < 8) return null;
14270
+ const blockSize = view.getUint32(inputOffset, false);
14271
+ const chunkSize = view.getUint32(inputOffset + 4, false);
14272
+ inputOffset += 8;
14273
+ if (!blockSize || !chunkSize || blockSize > capacity - outputOffset || chunkSize > input.byteLength - inputOffset)
14274
+ return null;
14275
+ const decoded = new Uint8Array(
14276
+ this.raw.decompressSync(input.slice(inputOffset, inputOffset + chunkSize), blockSize)
14277
+ );
14278
+ if (decoded.length !== blockSize) return null;
14279
+ blocks.push(decoded);
14280
+ outputOffset += blockSize;
14281
+ inputOffset += chunkSize;
14282
+ }
14283
+ const output = new Uint8Array(outputOffset);
14284
+ let offset = 0;
14285
+ for (const block of blocks) {
14286
+ output.set(block, offset);
14287
+ offset += block.length;
14288
+ }
14289
+ return output.buffer;
14290
+ } catch {
14291
+ return null;
17190
14292
  }
17191
- return uncompressedSize;
17192
- }
17193
- /**
17194
- * Compare file magic with lz4 magic number
17195
- * @param input
17196
- */
17197
- checkMagicNumber(data) {
17198
- if (data.byteLength < 4) return false;
17199
- const bytes = new Uint8Array(data, 0, 4);
17200
- const magic = (bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24) >>> 0;
17201
- return magic === LZ4_MAGIC_NUMBER;
17202
14293
  }
17203
14294
  };
17204
14295
  }
17205
14296
  });
17206
14297
 
17207
- // ../compression/src/lz4-decompressor.ts
17208
- var lz4_decompressor_exports = {};
17209
- __export(lz4_decompressor_exports, {
17210
- LZ4Decompressor: () => LZ4Decompressor
17211
- });
17212
- var LZ4Decompressor;
17213
- var init_lz4_decompressor = __esm({
17214
- "../compression/src/lz4-decompressor.ts"() {
14298
+ // ../compression/src/lzo-decompressor-compress-utils.ts
14299
+ var LzoCompressUtilsDecompressor;
14300
+ var init_lzo_decompressor_compress_utils = __esm({
14301
+ "../compression/src/lzo-decompressor-compress-utils.ts"() {
17215
14302
  "use strict";
17216
- init_compression();
17217
- init_lz4_compression();
17218
- LZ4Decompressor = class extends Decompressor {
17219
- name = "lz4";
17220
- extensions = ["lz4"];
17221
- contentEncodings = ["x-lz4"];
17222
- isSupported = true;
17223
- implementation;
14303
+ init_compress_utils_compression();
14304
+ LzoCompressUtilsDecompressor = class extends CompressUtilsDecompressor {
14305
+ /** Creates a lazy decoder; neither an encoder nor container framing is included. */
17224
14306
  constructor(options = {}) {
17225
- super(options);
17226
- this.implementation = new LZ4Compression(options);
17227
- }
17228
- /** Preloads lz4js for frame decoding; block decoding does not require it. */
17229
- async preload(modules = {}) {
17230
- await this.implementation.preload(modules);
17231
- }
17232
- /** Decompresses an LZ4 frame or block. */
17233
- async decompress(input, size) {
17234
- return this.implementation.decompress(input, size);
17235
- }
17236
- /** Decompresses an LZ4 frame or block synchronously. */
17237
- decompressSync(input, size) {
17238
- return this.implementation.decompressSync(input, size);
14307
+ super(
14308
+ { name: "lzo" },
14309
+ async () => await import("compress-utils/lzo/decompress"),
14310
+ options
14311
+ );
17239
14312
  }
17240
14313
  };
17241
14314
  }
17242
14315
  });
17243
14316
 
17244
- // ../compression/src/zstd-decompressor.ts
17245
- var zstd_decompressor_exports = {};
17246
- __export(zstd_decompressor_exports, {
17247
- ZstdDecompressor: () => ZstdDecompressor
14317
+ // ../compression/src/lzo-decompressor.ts
14318
+ var lzo_decompressor_exports = {};
14319
+ __export(lzo_decompressor_exports, {
14320
+ LzoDecompressor: () => LzoCompressUtilsDecompressor
17248
14321
  });
17249
- var ZstdDecompressor;
17250
- var init_zstd_decompressor = __esm({
17251
- "../compression/src/zstd-decompressor.ts"() {
14322
+ var init_lzo_decompressor = __esm({
14323
+ "../compression/src/lzo-decompressor.ts"() {
17252
14324
  "use strict";
17253
- init_zstd_decompressor_fzstd();
17254
- init_decompression_stream();
17255
- init_src2();
17256
- ZstdDecompressor = class extends ZstdFzstdDecompressor {
17257
- options;
17258
- compatibility = null;
17259
- constructor(options = {}) {
17260
- super(options);
17261
- this.options = options;
17262
- registerJSModules(options.modules);
17263
- }
17264
- /** Preloads an injected zstd-codec implementation when supplied. */
17265
- async preload(modules = {}) {
17266
- registerJSModules(modules);
17267
- if (getJSModuleOrNull("zstd-codec")) {
17268
- const { ZstdCompression: ZstdCompression2 } = await Promise.resolve().then(() => (init_zstd_compression(), zstd_compression_exports));
17269
- this.compatibility ||= new ZstdCompression2(this.options);
17270
- await this.compatibility.preload(modules);
17271
- }
17272
- }
17273
- /** Decompresses with the built-in stream when available, then falls back to fzstd. */
17274
- async decompress(input) {
17275
- if (this.options.useNative !== false) {
17276
- const output = await decompressWithNativeDecompressionStream(input, "zstd");
17277
- if (output) return output;
17278
- }
17279
- if (getJSModuleOrNull("zstd-codec")) {
17280
- await this.preload(this.options.modules);
17281
- }
17282
- return this.decompressSync(input);
17283
- }
17284
- /** Decompresses with a preloaded zstd-codec implementation or compact fzstd. */
17285
- decompressSync(input) {
17286
- if (this.compatibility) {
17287
- return this.compatibility.decompressSync(input);
17288
- }
17289
- if (getJSModuleOrNull("zstd-codec")) {
17290
- throw new Error("zstd: call preload() before synchronous decompression with zstd-codec");
17291
- }
17292
- return super.decompressSync(input);
17293
- }
17294
- /** Decompresses batches with a built-in stream or compact fzstd fallback. */
17295
- async *decompressBatches(inputBatches) {
17296
- if (this.options.useNative !== false) {
17297
- const output = decompressBatchesWithNativeDecompressionStream(inputBatches, "zstd");
17298
- if (output) {
17299
- yield* output;
17300
- return;
17301
- }
17302
- }
17303
- if (getJSModuleOrNull("zstd-codec")) {
17304
- yield this.decompress(await this.concatenate(inputBatches));
17305
- return;
17306
- }
17307
- yield* super.decompressBatches(inputBatches);
17308
- }
17309
- };
14325
+ init_lzo_decompressor_compress_utils();
17310
14326
  }
17311
14327
  });
17312
14328
 
17313
14329
  // ../compression/src/default-codecs.ts
17314
- var GZIP, BROTLI, SNAPPY, LZ4, ZSTD, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2;
14330
+ var GZIP, BROTLI, SNAPPY, LZ4, ZSTD, GZipDecompressor2, BrotliDecompressor2, SnappyDecompressor2, LZ4Decompressor2, ZstdDecompressor2, LzoDecompressor;
17315
14331
  var init_default_codecs = __esm({
17316
14332
  "../compression/src/default-codecs.ts"() {
17317
14333
  "use strict";
17318
14334
  init_lazy_compression();
17319
- init_src2();
17320
14335
  GZIP = { name: "gzip", extensions: ["gz"], contentEncodings: ["gzip"] };
17321
14336
  BROTLI = { name: "brotli", extensions: ["br"], contentEncodings: ["br"] };
17322
14337
  SNAPPY = { name: "snappy", extensions: [], contentEncodings: [] };
@@ -17338,11 +14353,7 @@ var init_default_codecs = __esm({
17338
14353
  BROTLI,
17339
14354
  async () => (await Promise.resolve().then(() => (init_brotli_decompressor(), brotli_decompressor_exports))).BrotliDecompressor,
17340
14355
  options,
17341
- "brotli",
17342
- (preloadOptions) => {
17343
- var _a;
17344
- return !((_a = preloadOptions.modules) == null ? void 0 : _a.brotli) && !getJSModuleOrNull("brotli");
17345
- }
14356
+ "brotli"
17346
14357
  );
17347
14358
  }
17348
14359
  };
@@ -17362,11 +14373,17 @@ var init_default_codecs = __esm({
17362
14373
  ZSTD,
17363
14374
  async () => (await Promise.resolve().then(() => (init_zstd_decompressor(), zstd_decompressor_exports))).ZstdDecompressor,
17364
14375
  options,
17365
- "zstd",
17366
- (preloadOptions) => {
17367
- var _a;
17368
- return !((_a = preloadOptions.modules) == null ? void 0 : _a["zstd-codec"]) && !getJSModuleOrNull("zstd-codec");
17369
- }
14376
+ "zstd"
14377
+ );
14378
+ }
14379
+ };
14380
+ LzoDecompressor = class extends LazyDecompressor {
14381
+ /** Retains options until the decoder is needed. */
14382
+ constructor(options = {}) {
14383
+ super(
14384
+ { name: "lzo", extensions: [], contentEncodings: [] },
14385
+ async () => (await Promise.resolve().then(() => (init_lzo_decompressor(), lzo_decompressor_exports))).LzoDecompressor,
14386
+ options
17370
14387
  );
17371
14388
  }
17372
14389
  };
@@ -17374,77 +14391,22 @@ var init_default_codecs = __esm({
17374
14391
  });
17375
14392
 
17376
14393
  // ../compression/src/index.ts
17377
- var init_src8 = __esm({
14394
+ var init_src7 = __esm({
17378
14395
  "../compression/src/index.ts"() {
17379
14396
  "use strict";
17380
- init_compression();
17381
14397
  init_default_codecs();
17382
14398
  }
17383
14399
  });
17384
14400
 
17385
- // ../compression/src/snappy-decompressor-hysnappy.ts
17386
- function readSnappyUncompressedLength(input) {
17387
- let value = 0;
17388
- let multiplier = 1;
17389
- for (let byteIndex = 0; byteIndex < Math.min(input.byteLength, 5); byteIndex++) {
17390
- const byte = input[byteIndex];
17391
- value += (byte & 127) * multiplier;
17392
- if ((byte & 128) === 0) {
17393
- if (!Number.isSafeInteger(value)) throw new Error("invalid Snappy uncompressed length");
17394
- return value;
17395
- }
17396
- multiplier *= 128;
17397
- }
17398
- throw new Error("invalid Snappy uncompressed length");
17399
- }
17400
- var sharedSnappyUncompressorPromise, SnappyHysnappyDecompressor;
17401
- var init_snappy_decompressor_hysnappy = __esm({
17402
- "../compression/src/snappy-decompressor-hysnappy.ts"() {
17403
- "use strict";
17404
- init_src2();
17405
- init_compression();
17406
- SnappyHysnappyDecompressor = class extends Decompressor {
17407
- /** Compression format name. */
17408
- name = "snappy";
17409
- /** Snappy does not have a standard standalone file extension. */
17410
- extensions = [];
17411
- /** Snappy does not have a standard HTTP content encoding. */
17412
- contentEncodings = [];
17413
- /** Whether the runtime can instantiate the embedded WASM decoder. */
17414
- isSupported = typeof WebAssembly !== "undefined";
17415
- /** Cached decoder instantiated by {@link preload}. */
17416
- uncompressor;
17417
- /** Loads and instantiates the embedded hysnappy WASM module once per JavaScript realm. */
17418
- async preload() {
17419
- if (!this.uncompressor) {
17420
- sharedSnappyUncompressorPromise ||= import("hysnappy").then(
17421
- (hysnappy) => hysnappy.snappyUncompressor()
17422
- );
17423
- this.uncompressor = await sharedSnappyUncompressorPromise;
17424
- }
17425
- }
17426
- /** Decompresses one Snappy payload synchronously after preload. */
17427
- decompressSync(input, size) {
17428
- if (!this.uncompressor) {
17429
- throw new Error("snappy hysnappy decoder has not been preloaded");
17430
- }
17431
- const bytes = new Uint8Array(input);
17432
- const outputLength = size ?? readSnappyUncompressedLength(bytes);
17433
- return toArrayBuffer2(this.uncompressor(bytes, outputLength));
17434
- }
17435
- };
17436
- }
17437
- });
17438
-
17439
14401
  // ../parquet/src/parquetjs/compression.ts
17440
14402
  async function preloadCompressions(options) {
17441
14403
  registerJSModules(options == null ? void 0 : options.modules);
17442
14404
  }
17443
- async function decompress3(method, value, size) {
14405
+ async function decompress(method, value, size) {
17444
14406
  if (!(method in PARQUET_COMPRESSION_METHODS)) {
17445
14407
  throw new Error(`parquet: invalid compression method: ${method}`);
17446
14408
  }
17447
- const inputArrayBuffer = toArrayBuffer3(value);
14409
+ const inputArrayBuffer = toArrayBuffer2(value);
17448
14410
  if (method === "UNCOMPRESSED") {
17449
14411
  return toUint8Array(inputArrayBuffer);
17450
14412
  }
@@ -17455,7 +14417,7 @@ async function decompress3(method, value, size) {
17455
14417
  function createParquetPageDecompressor(method) {
17456
14418
  const decompressor = method === "UNCOMPRESSED" ? null : createParquetDecompressor(method);
17457
14419
  return async (value, size) => {
17458
- const inputArrayBuffer = toArrayBuffer3(value);
14420
+ const inputArrayBuffer = toArrayBuffer2(value);
17459
14421
  if (!decompressor) {
17460
14422
  return toUint8Array(inputArrayBuffer);
17461
14423
  }
@@ -17468,10 +14430,12 @@ async function getParquetDecompressor(method) {
17468
14430
  }
17469
14431
  function createParquetDecompressor(method) {
17470
14432
  switch (method) {
14433
+ case "LZO":
14434
+ return new ParquetLzoDecompressor();
17471
14435
  case "GZIP":
17472
14436
  return new GZipDecompressor2();
17473
14437
  case "SNAPPY":
17474
- return new ParquetSnappyDecompressor();
14438
+ return new SnappyDecompressor2();
17475
14439
  case "BROTLI":
17476
14440
  return new BrotliDecompressor2();
17477
14441
  case "LZ4":
@@ -17483,12 +14447,11 @@ function createParquetDecompressor(method) {
17483
14447
  throw new Error(`parquet: invalid compression method: ${method}`);
17484
14448
  }
17485
14449
  }
17486
- var PARQUET_COMPRESSION_METHODS, ParquetSnappyDecompressor;
14450
+ var PARQUET_COMPRESSION_METHODS, ParquetLzoDecompressor;
17487
14451
  var init_compression2 = __esm({
17488
14452
  "../parquet/src/parquetjs/compression.ts"() {
17489
14453
  "use strict";
17490
- init_src8();
17491
- init_snappy_decompressor_hysnappy();
14454
+ init_src7();
17492
14455
  init_src2();
17493
14456
  init_binary_utils();
17494
14457
  PARQUET_COMPRESSION_METHODS = {
@@ -17496,36 +14459,59 @@ var init_compression2 = __esm({
17496
14459
  GZIP: true,
17497
14460
  SNAPPY: true,
17498
14461
  BROTLI: true,
17499
- // TODO: Understand difference between LZ4 and LZ4_RAW.
14462
+ LZO: true,
17500
14463
  LZ4: true,
17501
14464
  LZ4_RAW: true,
17502
14465
  ZSTD: true
17503
14466
  };
17504
- ParquetSnappyDecompressor = class extends Decompressor {
17505
- /** Compression format name. */
17506
- name = "snappy";
17507
- /** Snappy does not have a standard standalone file extension. */
17508
- extensions = [];
17509
- /** Snappy does not have a standard HTTP content encoding. */
17510
- contentEncodings = [];
17511
- /** snappyjs keeps this composite decoder available without WebAssembly. */
17512
- isSupported = true;
17513
- /** Preferred compact WASM decoder for page-sized frames. */
17514
- hysnappy = new SnappyHysnappyDecompressor();
17515
- /** Always-supported JavaScript decoder. */
17516
- snappyjs = new SnappyDecompressor2();
17517
- /** Whether this instance has selected the JavaScript fallback. */
17518
- useSnappyjs = !this.hysnappy.isSupported;
17519
- /** Decodes with hysnappy, retaining snappyjs after the first WASM setup or runtime failure. */
14467
+ ParquetLzoDecompressor = class extends LzoDecompressor {
14468
+ /** Prefers raw LZO1X and accepts complete, size-checked Hadoop block streams. */
17520
14469
  async decompress(input, size) {
17521
- if (!this.useSnappyjs) {
17522
- try {
17523
- return await this.hysnappy.decompress(input, size);
17524
- } catch {
17525
- this.useSnappyjs = true;
14470
+ try {
14471
+ return await super.decompress(input, size);
14472
+ } catch (error) {
14473
+ if (error instanceof RangeError || !Number.isSafeInteger(size) || size < 0 || size > 2147483647)
14474
+ throw error;
14475
+ const output = this.decodeHadoopBlocks(new Uint8Array(input), size);
14476
+ if (output === null) throw error;
14477
+ return output;
14478
+ }
14479
+ }
14480
+ /** Checks each block/chunk length and decodes chunks until their block size is satisfied. */
14481
+ decodeHadoopBlocks(input, size) {
14482
+ const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
14483
+ const chunks = [];
14484
+ let inputOffset = 0;
14485
+ let outputOffset = 0;
14486
+ try {
14487
+ while (inputOffset < input.length) {
14488
+ if (input.length - inputOffset < 4) return null;
14489
+ const blockSize = view.getUint32(inputOffset, false);
14490
+ inputOffset += 4;
14491
+ if (blockSize === 0) {
14492
+ return inputOffset === input.length && outputOffset === size ? concatenateArrayBuffers(...chunks) : null;
14493
+ }
14494
+ if (blockSize > size - outputOffset) return null;
14495
+ const blockEnd = outputOffset + blockSize;
14496
+ while (outputOffset < blockEnd) {
14497
+ if (input.length - inputOffset < 4) return null;
14498
+ const chunkSize = view.getUint32(inputOffset, false);
14499
+ inputOffset += 4;
14500
+ if (chunkSize === 0 || chunkSize > input.length - inputOffset) return null;
14501
+ const chunk = input.slice(inputOffset, inputOffset + chunkSize);
14502
+ inputOffset += chunkSize;
14503
+ const decoded = new Uint8Array(
14504
+ this.decompressSync(chunk.buffer, blockEnd - outputOffset)
14505
+ );
14506
+ if (decoded.length === 0) return null;
14507
+ chunks.push(decoded.buffer);
14508
+ outputOffset += decoded.length;
14509
+ }
17526
14510
  }
14511
+ return outputOffset === size ? concatenateArrayBuffers(...chunks) : null;
14512
+ } catch {
14513
+ return null;
17527
14514
  }
17528
- return await this.snappyjs.decompress(input, size);
17529
14515
  }
17530
14516
  };
17531
14517
  }
@@ -19640,7 +16626,6 @@ var init_codecs = __esm({
19640
16626
  init_dictionary();
19641
16627
  init_delta();
19642
16628
  init_byte_stream_split();
19643
- init_declare();
19644
16629
  PARQUET_CODECS = {
19645
16630
  PLAIN: {
19646
16631
  encodeValues,
@@ -21126,7 +18111,7 @@ async function decodeDataPage(cursor, header, context, target) {
21126
18111
  let dataCursor = cursor;
21127
18112
  if (context.compression !== "UNCOMPRESSED") {
21128
18113
  const compressedValues = cursor.buffer.slice(cursor.offset, cursorEnd);
21129
- const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, header.uncompressed_page_size) : await decompress3(context.compression, compressedValues, header.uncompressed_page_size);
18114
+ const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, header.uncompressed_page_size) : await decompress(context.compression, compressedValues, header.uncompressed_page_size);
21130
18115
  dataCursor = {
21131
18116
  buffer: valuesBuf,
21132
18117
  offset: 0,
@@ -21266,7 +18251,7 @@ async function decodeDataPageV2(cursor, header, context, target) {
21266
18251
  }
21267
18252
  let valuesBuffer = cursor.buffer.subarray(valuesOffset, cursorEnd);
21268
18253
  if (dataPageHeader.is_compressed !== false && context.compression !== "UNCOMPRESSED") {
21269
- valuesBuffer = context.decompressPage ? await context.decompressPage(valuesBuffer, valuesUncompressedByteLength) : await decompress3(context.compression, valuesBuffer, valuesUncompressedByteLength);
18254
+ valuesBuffer = context.decompressPage ? await context.decompressPage(valuesBuffer, valuesUncompressedByteLength) : await decompress(context.compression, valuesBuffer, valuesUncompressedByteLength);
21270
18255
  }
21271
18256
  cursor.offset = cursorEnd;
21272
18257
  return decodeDataPageV2Values(
@@ -21525,7 +18510,7 @@ async function decodeDictionaryPage(cursor, pageHeader, context) {
21525
18510
  cursor.offset = cursorEnd;
21526
18511
  if (context.compression !== "UNCOMPRESSED") {
21527
18512
  const compressedValues = dictCursor.buffer.subarray(dictCursor.offset);
21528
- const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, pageHeader.uncompressed_page_size) : await decompress3(context.compression, compressedValues, pageHeader.uncompressed_page_size);
18513
+ const valuesBuf = context.decompressPage ? await context.decompressPage(compressedValues, pageHeader.uncompressed_page_size) : await decompress(context.compression, compressedValues, pageHeader.uncompressed_page_size);
21529
18514
  dictCursor = {
21530
18515
  buffer: valuesBuf,
21531
18516
  offset: 0,
@@ -22121,7 +19106,9 @@ var init_parquet_reader = __esm({
22121
19106
  async readBytes(start, length, signal) {
22122
19107
  const effectiveSignal = signal ?? this.props.signal;
22123
19108
  if (effectiveSignal == null ? void 0 : effectiveSignal.aborted) {
22124
- throw new Error("Request aborted");
19109
+ const error = new Error("Request aborted");
19110
+ error.name = "AbortError";
19111
+ throw error;
22125
19112
  }
22126
19113
  if (this.file.handle instanceof ArrayBuffer) {
22127
19114
  return new Uint8Array(this.file.handle, start, length);
@@ -23673,7 +20660,7 @@ var init_parquet_source_loader = __esm({
23673
20660
  init_src5();
23674
20661
  init_src2();
23675
20662
  init_src4();
23676
- init_src6();
20663
+ init_src3();
23677
20664
  init_get_parquet_schema();
23678
20665
  init_geoparquet_covering();
23679
20666
  init_parquet_bloom_filter();
@@ -23856,7 +20843,7 @@ var init_parquet_source_loader = __esm({
23856
20843
  );
23857
20844
  const projectedColumns = normalizeColumns(readOptions.columns, initialization.schema);
23858
20845
  const predicateColumns = physicalPlan.predicate ? getParquetPredicateColumns(physicalPlan.predicate) : [];
23859
- const geoMetadata = readOptions.bbox ? getGeoMetadata2(initialization.schema.metadata) : void 0;
20846
+ const geoMetadata = readOptions.bbox ? getGeoMetadata(initialization.schema.metadata) : void 0;
23860
20847
  const geometryColumn = readOptions.bbox ? readOptions.geometryColumn || (geoMetadata == null ? void 0 : geoMetadata.primary_column) : void 0;
23861
20848
  const filterColumns = [
23862
20849
  .../* @__PURE__ */ new Set([...predicateColumns, ...geometryColumn ? [geometryColumn] : []])