hunk
dict | file
stringlengths 0
11.8M
| file_path
stringlengths 2
234
| label
int64 0
1
| commit_url
stringlengths 74
103
| dependency_score
sequencelengths 5
5
|
|---|---|---|---|---|---|
{
"id": 7,
"code_window": [
" // If no explicit configuration has been specified, we load and validate\n",
" // the configuration from the shared dev-infra configuration.\n",
" if (config === undefined) {\n",
" const {config: _config, errors} = loadAndValidateConfig();\n",
" if (errors) {\n",
" console.error(chalk.red('Invalid configuration:'));\n",
" errors.forEach(desc => console.error(chalk.yellow(` - ${desc}`)));\n",
" process.exit(1);\n",
" }\n",
" config = _config!;\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Invalid configuration:'));\n",
" errors.forEach(desc => error(yellow(` - ${desc}`)));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 42
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
export interface Schema {
/**
* The name of the project.
*/
name?: string;
/**
* When true, does not install dependency packages.
*/
skipInstall?: boolean;
}
| packages/bazel/src/schematics/ng-add/schema.d.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017563634901307523,
0.00017399631906300783,
0.00017235628911294043,
0.00017399631906300783,
0.000001640029950067401
] |
{
"id": 7,
"code_window": [
" // If no explicit configuration has been specified, we load and validate\n",
" // the configuration from the shared dev-infra configuration.\n",
" if (config === undefined) {\n",
" const {config: _config, errors} = loadAndValidateConfig();\n",
" if (errors) {\n",
" console.error(chalk.red('Invalid configuration:'));\n",
" errors.forEach(desc => console.error(chalk.yellow(` - ${desc}`)));\n",
" process.exit(1);\n",
" }\n",
" config = _config!;\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Invalid configuration:'));\n",
" errors.forEach(desc => error(yellow(` - ${desc}`)));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 42
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
const u = undefined;
function plural(n: number): number {
let i = Math.floor(Math.abs(n)), v = n.toString().replace(/^[^.]*\.?/, '').length;
if (i === 1 && v === 0) return 1;
return 5;
}
export default [
'en-AE',
[['a', 'p'], ['AM', 'PM'], u],
[['AM', 'PM'], u, u],
[
['S', 'M', 'T', 'W', 'T', 'F', 'S'], ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa']
],
u,
[
['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
[
'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
'October', 'November', 'December'
]
],
u,
[['B', 'A'], ['BC', 'AD'], ['Before Christ', 'Anno Domini']],
6,
[5, 6],
['dd/MM/y', 'd MMM y', 'd MMMM y', 'EEEE, d MMMM y'],
['h:mm a', 'h:mm:ss a', 'h:mm:ss a z', 'h:mm:ss a zzzz'],
['{1}, {0}', u, '{1} \'at\' {0}', u],
['.', ',', ';', '%', '+', '-', 'E', '×', '‰', '∞', 'NaN', ':'],
['#,##0.###', '#,##0%', '¤#,##0.00', '#E0'],
'AED',
'AED',
'United Arab Emirates Dirham',
{},
'ltr',
plural
];
| packages/common/locales/en-AE.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017622146697249264,
0.00017399823991581798,
0.0001723283639876172,
0.0001740460138535127,
0.0000012669366924455971
] |
{
"id": 8,
"code_window": [
" return await handleMergeResult(result, ignoreFatalErrors);\n",
" } catch (e) {\n",
" // Catch errors to the Github API for invalid requests. We want to\n",
" // exit the script with a better explanation of the error.\n",
" if (e instanceof GithubApiRequestError && e.status === 401) {\n",
" console.error(chalk.red('Github API request failed. ' + e.message));\n",
" console.error(chalk.yellow('Please ensure that your provided token is valid.'));\n",
" console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n",
" process.exit(1);\n",
" }\n",
" throw e;\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Github API request failed. ' + e.message));\n",
" error(yellow('Please ensure that your provided token is valid.'));\n",
" error(yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 67
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {getRepoBaseDir} from '../../utils/config';
import {promptConfirm} from '../../utils/console';
import {loadAndValidateConfig, MergeConfigWithRemote} from './config';
import {GithubApiRequestError} from './git';
import {MergeResult, MergeStatus, PullRequestMergeTask} from './task';
/** URL to the Github page where personal access tokens can be generated. */
export const GITHUB_TOKEN_GENERATE_URL = `https://github.com/settings/tokens`;
/**
* Merges a given pull request based on labels configured in the given merge configuration.
* Pull requests can be merged with different strategies such as the Github API merge
* strategy, or the local autosquash strategy. Either strategy has benefits and downsides.
* More information on these strategies can be found in their dedicated strategy classes.
*
* See {@link GithubApiMergeStrategy} and {@link AutosquashMergeStrategy}
*
* @param prNumber Number of the pull request that should be merged.
* @param githubToken Github token used for merging (i.e. fetching and pushing)
* @param projectRoot Path to the local Git project that is used for merging.
* @param config Configuration for merging pull requests.
*/
export async function mergePullRequest(
prNumber: number, githubToken: string, projectRoot: string = getRepoBaseDir(),
config?: MergeConfigWithRemote) {
// If no explicit configuration has been specified, we load and validate
// the configuration from the shared dev-infra configuration.
if (config === undefined) {
const {config: _config, errors} = loadAndValidateConfig();
if (errors) {
console.error(chalk.red('Invalid configuration:'));
errors.forEach(desc => console.error(chalk.yellow(` - ${desc}`)));
process.exit(1);
}
config = _config!;
}
const api = new PullRequestMergeTask(projectRoot, config, githubToken);
// Perform the merge. Force mode can be activated through a command line flag.
// Alternatively, if the merge fails with non-fatal failures, the script
// will prompt whether it should rerun in force mode.
if (!await performMerge(false)) {
process.exit(1);
}
/** Performs the merge and returns whether it was successful or not. */
async function performMerge(ignoreFatalErrors: boolean): Promise<boolean> {
try {
const result = await api.merge(prNumber, ignoreFatalErrors);
return await handleMergeResult(result, ignoreFatalErrors);
} catch (e) {
// Catch errors to the Github API for invalid requests. We want to
// exit the script with a better explanation of the error.
if (e instanceof GithubApiRequestError && e.status === 401) {
console.error(chalk.red('Github API request failed. ' + e.message));
console.error(chalk.yellow('Please ensure that your provided token is valid.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
throw e;
}
}
/**
* Prompts whether the specified pull request should be forcibly merged. If so, merges
* the specified pull request forcibly (ignoring non-critical failures).
* @returns Whether the specified pull request has been forcibly merged.
*/
async function promptAndPerformForceMerge(): Promise<boolean> {
if (await promptConfirm('Do you want to forcibly proceed with merging?')) {
// Perform the merge in force mode. This means that non-fatal failures
// are ignored and the merge continues.
return performMerge(true);
}
return false;
}
/**
* Handles the merge result by printing console messages, exiting the process
* based on the result, or by restarting the merge if force mode has been enabled.
* @returns Whether the merge was successful or not.
*/
async function handleMergeResult(result: MergeResult, disableForceMergePrompt = false) {
const {failure, status} = result;
const canForciblyMerge = failure && failure.nonFatal;
switch (status) {
case MergeStatus.SUCCESS:
console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));
return true;
case MergeStatus.DIRTY_WORKING_DIR:
console.error(chalk.red(
`Local working repository not clean. Please make sure there are ` +
`no uncommitted changes.`));
return false;
case MergeStatus.UNKNOWN_GIT_ERROR:
console.error(chalk.red(
'An unknown Git error has been thrown. Please check the output ' +
'above for details.'));
return false;
case MergeStatus.FAILED:
console.error(chalk.yellow(`Could not merge the specified pull request.`));
console.error(chalk.red(failure!.message));
if (canForciblyMerge && !disableForceMergePrompt) {
console.info();
console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));
console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));
return await promptAndPerformForceMerge();
}
return false;
default:
throw Error(`Unexpected merge result: ${status}`);
}
}
}
| dev-infra/pr/merge/index.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.9971626400947571,
0.07763916999101639,
0.00015973833797033876,
0.00022424074995797127,
0.2654492259025574
] |
{
"id": 8,
"code_window": [
" return await handleMergeResult(result, ignoreFatalErrors);\n",
" } catch (e) {\n",
" // Catch errors to the Github API for invalid requests. We want to\n",
" // exit the script with a better explanation of the error.\n",
" if (e instanceof GithubApiRequestError && e.status === 401) {\n",
" console.error(chalk.red('Github API request failed. ' + e.message));\n",
" console.error(chalk.yellow('Please ensure that your provided token is valid.'));\n",
" console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n",
" process.exit(1);\n",
" }\n",
" throw e;\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Github API request failed. ' + e.message));\n",
" error(yellow('Please ensure that your provided token is valid.'));\n",
" error(yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 67
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Logger} from '../../../logging/logger';
import {PartiallyOrderedTasks, Task, TaskDependencies} from '../api';
import {getBlockedTasks, sortTasksByPriority, stringifyTask} from '../utils';
import {BaseTaskQueue} from './base_task_queue';
/**
* A `TaskQueue` implementation that assumes tasks are processed in parallel, thus has to ensure a
* task's dependencies have been processed before processing the task.
*/
export class ParallelTaskQueue extends BaseTaskQueue {
/**
* A map from Tasks to the Tasks that it depends upon.
*
* This is the reverse mapping of `TaskDependencies`.
*/
private blockedTasks: Map<Task, Set<Task>>;
constructor(logger: Logger, tasks: PartiallyOrderedTasks, dependencies: TaskDependencies) {
super(logger, sortTasksByPriority(tasks, dependencies), dependencies);
this.blockedTasks = getBlockedTasks(dependencies);
}
computeNextTask(): Task|null {
// Look for the first available (i.e. not blocked) task.
// (NOTE: Since tasks are sorted by priority, the first available one is the best choice.)
const nextTaskIdx = this.tasks.findIndex(task => !this.blockedTasks.has(task));
if (nextTaskIdx === -1) return null;
// Remove the task from the list of available tasks and add it to the list of in-progress tasks.
const nextTask = this.tasks[nextTaskIdx];
this.tasks.splice(nextTaskIdx, 1);
this.inProgressTasks.add(nextTask);
return nextTask;
}
markAsCompleted(task: Task): void {
super.markAsCompleted(task);
if (!this.dependencies.has(task)) {
return;
}
// Unblock the tasks that are dependent upon `task`
for (const dependentTask of this.dependencies.get(task)!) {
if (this.blockedTasks.has(dependentTask)) {
const blockingTasks = this.blockedTasks.get(dependentTask)!;
// Remove the completed task from the lists of tasks blocking other tasks.
blockingTasks.delete(task);
if (blockingTasks.size === 0) {
// If the dependent task is not blocked any more, mark it for unblocking.
this.blockedTasks.delete(dependentTask);
}
}
}
}
toString(): string {
return `${super.toString()}\n` +
` Blocked tasks (${this.blockedTasks.size}): ${this.stringifyBlockedTasks(' ')}`;
}
private stringifyBlockedTasks(indentation: string): string {
return Array.from(this.blockedTasks)
.map(
([task, blockingTasks]) =>
`\n${indentation}- ${stringifyTask(task)} (${blockingTasks.size}): ` +
this.stringifyTasks(Array.from(blockingTasks), `${indentation} `))
.join('');
}
}
| packages/compiler-cli/ngcc/src/execution/tasks/queues/parallel_task_queue.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001768315996741876,
0.00017281819600611925,
0.00016775907715782523,
0.00017372608999721706,
0.000002985366108987364
] |
{
"id": 8,
"code_window": [
" return await handleMergeResult(result, ignoreFatalErrors);\n",
" } catch (e) {\n",
" // Catch errors to the Github API for invalid requests. We want to\n",
" // exit the script with a better explanation of the error.\n",
" if (e instanceof GithubApiRequestError && e.status === 401) {\n",
" console.error(chalk.red('Github API request failed. ' + e.message));\n",
" console.error(chalk.yellow('Please ensure that your provided token is valid.'));\n",
" console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n",
" process.exit(1);\n",
" }\n",
" throw e;\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Github API request failed. ' + e.message));\n",
" error(yellow('Please ensure that your provided token is valid.'));\n",
" error(yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 67
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Component, ViewEncapsulation} from '@angular/core';
// #docregion longform
@Component({
selector: 'my-app',
template: `
<h1>Hello World!</h1>
<span class="red">Shadow DOM Rocks!</span>
`,
styles: [`
:host {
display: block;
border: 1px solid black;
}
h1 {
color: blue;
}
.red {
background-color: red;
}
`],
encapsulation: ViewEncapsulation.ShadowDom
})
class MyApp {
}
// #enddocregion
| packages/examples/core/ts/metadata/encapsulation.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017700046009849757,
0.00017248095537070185,
0.0001686302275629714,
0.0001721465669106692,
0.0000032762698083388386
] |
{
"id": 8,
"code_window": [
" return await handleMergeResult(result, ignoreFatalErrors);\n",
" } catch (e) {\n",
" // Catch errors to the Github API for invalid requests. We want to\n",
" // exit the script with a better explanation of the error.\n",
" if (e instanceof GithubApiRequestError && e.status === 401) {\n",
" console.error(chalk.red('Github API request failed. ' + e.message));\n",
" console.error(chalk.yellow('Please ensure that your provided token is valid.'));\n",
" console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n",
" process.exit(1);\n",
" }\n",
" throw e;\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" error(red('Github API request failed. ' + e.message));\n",
" error(yellow('Please ensure that your provided token is valid.'));\n",
" error(yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 67
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Component, ErrorHandler, Injectable, NgModule} from '@angular/core';
@Component({
selector: 'benchmark-area',
template: '<ng-content></ng-content>',
styles: [`
:host {
padding: 1;
margin: 1;
background-color: white;
width: 1000px;
display: block;
}`],
host: {
'class': 'cfc-ng2-region',
}
})
export class BenchmarkArea {
}
declare interface ExtendedWindow extends Window {
benchmarkErrors?: string[];
}
const extendedWindow = window as ExtendedWindow;
@Injectable({providedIn: 'root'})
export class BenchmarkErrorHandler implements ErrorHandler {
handleError(error: Error) {
if (!extendedWindow.benchmarkErrors) {
extendedWindow.benchmarkErrors = [];
}
extendedWindow.benchmarkErrors.push(error.message);
console.error(error);
}
}
@NgModule({
declarations: [BenchmarkArea],
exports: [BenchmarkArea],
providers: [
{provide: ErrorHandler, useClass: BenchmarkErrorHandler},
]
})
export class BenchmarkModule {
}
| modules/benchmarks/src/expanding_rows/benchmark_module.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001770097587723285,
0.00017114072397816926,
0.0001627461751922965,
0.00017132837092503905,
0.000004990358320355881
] |
{
"id": 9,
"code_window": [
" const canForciblyMerge = failure && failure.nonFatal;\n",
"\n",
" switch (status) {\n",
" case MergeStatus.SUCCESS:\n",
" console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));\n",
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" info(green(`Successfully merged the pull request: ${prNumber}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 101
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {getRepoBaseDir} from '../../utils/config';
import {promptConfirm} from '../../utils/console';
import {loadAndValidateConfig, MergeConfigWithRemote} from './config';
import {GithubApiRequestError} from './git';
import {MergeResult, MergeStatus, PullRequestMergeTask} from './task';
/** URL to the Github page where personal access tokens can be generated. */
export const GITHUB_TOKEN_GENERATE_URL = `https://github.com/settings/tokens`;
/**
* Merges a given pull request based on labels configured in the given merge configuration.
* Pull requests can be merged with different strategies such as the Github API merge
* strategy, or the local autosquash strategy. Either strategy has benefits and downsides.
* More information on these strategies can be found in their dedicated strategy classes.
*
* See {@link GithubApiMergeStrategy} and {@link AutosquashMergeStrategy}
*
* @param prNumber Number of the pull request that should be merged.
* @param githubToken Github token used for merging (i.e. fetching and pushing)
* @param projectRoot Path to the local Git project that is used for merging.
* @param config Configuration for merging pull requests.
*/
export async function mergePullRequest(
prNumber: number, githubToken: string, projectRoot: string = getRepoBaseDir(),
config?: MergeConfigWithRemote) {
// If no explicit configuration has been specified, we load and validate
// the configuration from the shared dev-infra configuration.
if (config === undefined) {
const {config: _config, errors} = loadAndValidateConfig();
if (errors) {
console.error(chalk.red('Invalid configuration:'));
errors.forEach(desc => console.error(chalk.yellow(` - ${desc}`)));
process.exit(1);
}
config = _config!;
}
const api = new PullRequestMergeTask(projectRoot, config, githubToken);
// Perform the merge. Force mode can be activated through a command line flag.
// Alternatively, if the merge fails with non-fatal failures, the script
// will prompt whether it should rerun in force mode.
if (!await performMerge(false)) {
process.exit(1);
}
/** Performs the merge and returns whether it was successful or not. */
async function performMerge(ignoreFatalErrors: boolean): Promise<boolean> {
try {
const result = await api.merge(prNumber, ignoreFatalErrors);
return await handleMergeResult(result, ignoreFatalErrors);
} catch (e) {
// Catch errors to the Github API for invalid requests. We want to
// exit the script with a better explanation of the error.
if (e instanceof GithubApiRequestError && e.status === 401) {
console.error(chalk.red('Github API request failed. ' + e.message));
console.error(chalk.yellow('Please ensure that your provided token is valid.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
throw e;
}
}
/**
* Prompts whether the specified pull request should be forcibly merged. If so, merges
* the specified pull request forcibly (ignoring non-critical failures).
* @returns Whether the specified pull request has been forcibly merged.
*/
async function promptAndPerformForceMerge(): Promise<boolean> {
if (await promptConfirm('Do you want to forcibly proceed with merging?')) {
// Perform the merge in force mode. This means that non-fatal failures
// are ignored and the merge continues.
return performMerge(true);
}
return false;
}
/**
* Handles the merge result by printing console messages, exiting the process
* based on the result, or by restarting the merge if force mode has been enabled.
* @returns Whether the merge was successful or not.
*/
async function handleMergeResult(result: MergeResult, disableForceMergePrompt = false) {
const {failure, status} = result;
const canForciblyMerge = failure && failure.nonFatal;
switch (status) {
case MergeStatus.SUCCESS:
console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));
return true;
case MergeStatus.DIRTY_WORKING_DIR:
console.error(chalk.red(
`Local working repository not clean. Please make sure there are ` +
`no uncommitted changes.`));
return false;
case MergeStatus.UNKNOWN_GIT_ERROR:
console.error(chalk.red(
'An unknown Git error has been thrown. Please check the output ' +
'above for details.'));
return false;
case MergeStatus.FAILED:
console.error(chalk.yellow(`Could not merge the specified pull request.`));
console.error(chalk.red(failure!.message));
if (canForciblyMerge && !disableForceMergePrompt) {
console.info();
console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));
console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));
return await promptAndPerformForceMerge();
}
return false;
default:
throw Error(`Unexpected merge result: ${status}`);
}
}
}
| dev-infra/pr/merge/index.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.9989007711410522,
0.16634878516197205,
0.00017118637333624065,
0.0007340165902860463,
0.3563312888145447
] |
{
"id": 9,
"code_window": [
" const canForciblyMerge = failure && failure.nonFatal;\n",
"\n",
" switch (status) {\n",
" case MergeStatus.SUCCESS:\n",
" console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));\n",
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" info(green(`Successfully merged the pull request: ${prNumber}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 101
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
(function(global) {
global.ng = global.ng || {};
global.ng.common = global.ng.common || {};
global.ng.common.locales = global.ng.common.locales || {};
const u = undefined;
function plural(n) {
let i = Math.floor(Math.abs(n)),
t = parseInt(n.toString().replace(/^[^.]*\.?|0+$/g, ''), 10) || 0;
if (n === 1 || !(t === 0) && (i === 0 || i === 1)) return 1;
return 5;
}
global.ng.common.locales['da-gl'] = [
'da-GL',
[['a', 'p'], ['AM', 'PM'], u],
[['AM', 'PM'], u, u],
[
['S', 'M', 'T', 'O', 'T', 'F', 'L'],
['søn.', 'man.', 'tir.', 'ons.', 'tor.', 'fre.', 'lør.'],
['søndag', 'mandag', 'tirsdag', 'onsdag', 'torsdag', 'fredag', 'lørdag'],
['sø', 'ma', 'ti', 'on', 'to', 'fr', 'lø']
],
[
['S', 'M', 'T', 'O', 'T', 'F', 'L'], ['søn', 'man', 'tir', 'ons', 'tor', 'fre', 'lør'],
['søndag', 'mandag', 'tirsdag', 'onsdag', 'torsdag', 'fredag', 'lørdag'],
['sø', 'ma', 'ti', 'on', 'to', 'fr', 'lø']
],
[
['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
[
'jan.', 'feb.', 'mar.', 'apr.', 'maj', 'jun.', 'jul.', 'aug.', 'sep.', 'okt.', 'nov.',
'dec.'
],
[
'januar', 'februar', 'marts', 'april', 'maj', 'juni', 'juli', 'august', 'september',
'oktober', 'november', 'december'
]
],
u,
[['fKr', 'eKr'], ['f.Kr.', 'e.Kr.'], u],
1,
[6, 0],
['dd.MM.y', 'd. MMM y', 'd. MMMM y', 'EEEE \'den\' d. MMMM y'],
['HH.mm', 'HH.mm.ss', 'HH.mm.ss z', 'HH.mm.ss zzzz'],
['{1} {0}', u, '{1} \'kl\'. {0}', u],
[',', '.', ';', '%', '+', '-', 'E', '×', '‰', '∞', 'NaN', '.'],
['#,##0.###', '#,##0 %', '#,##0.00 ¤', '#E0'],
'DKK',
'kr.',
'dansk krone',
{
'AUD': ['AU$', '$'],
'DKK': ['kr.'],
'ISK': [u, 'kr.'],
'JPY': ['JP¥', '¥'],
'NOK': [u, 'kr.'],
'RON': [u, 'L'],
'SEK': [u, 'kr.'],
'THB': ['฿'],
'TWD': ['NT$'],
'USD': ['US$', '$']
},
'ltr',
plural,
[
[
['midnat', 'om morgenen', 'om formiddagen', 'om eftermiddagen', 'om aftenen', 'om natten'],
u, u
],
[['midnat', 'morgen', 'formiddag', 'eftermiddag', 'aften', 'nat'], u, u],
[
'00:00', ['05:00', '10:00'], ['10:00', '12:00'], ['12:00', '18:00'], ['18:00', '24:00'],
['00:00', '05:00']
]
]
];
})(typeof globalThis !== 'undefined' && globalThis || typeof global !== 'undefined' && global ||
typeof window !== 'undefined' && window);
| packages/common/locales/global/da-GL.js | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001756897836457938,
0.00017314341675955802,
0.00017002537788357586,
0.00017366315296385437,
0.000001938824198077782
] |
{
"id": 9,
"code_window": [
" const canForciblyMerge = failure && failure.nonFatal;\n",
"\n",
" switch (status) {\n",
" case MergeStatus.SUCCESS:\n",
" console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));\n",
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" info(green(`Successfully merged the pull request: ${prNumber}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 101
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
const u = undefined;
export default [
[['del mediodía', 'de la madrugada', 'de la mañana', 'de la tarde', 'de la noche'], u, u],
[['mediodía', 'madrugada', 'mañana', 'tarde', 'noche'], u, u],
['12:00', ['00:00', '06:00'], ['06:00', '12:00'], ['12:00', '20:00'], ['20:00', '24:00']]
];
| packages/common/locales/extra/es-PR.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017640973965171725,
0.00017576785467099398,
0.00017512596969027072,
0.00017576785467099398,
6.418849807232618e-7
] |
{
"id": 9,
"code_window": [
" const canForciblyMerge = failure && failure.nonFatal;\n",
"\n",
" switch (status) {\n",
" case MergeStatus.SUCCESS:\n",
" console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));\n",
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" info(green(`Successfully merged the pull request: ${prNumber}`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 101
} |
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {CompilerOptions} from '@angular/compiler-cli';
import {NgCompiler, NgCompilerHost} from '@angular/compiler-cli/src/ngtsc/core';
import {AbsoluteFsPath} from '@angular/compiler-cli/src/ngtsc/file_system';
import {TypeCheckingProgramStrategy, UpdateMode} from '@angular/compiler-cli/src/ngtsc/typecheck';
import * as ts from 'typescript/lib/tsserverlibrary';
import {makeCompilerHostFromProject} from './compiler_host';
export class Compiler {
private tsCompilerHost: ts.CompilerHost;
private lastKnownProgram: ts.Program;
private compiler: NgCompiler;
private readonly strategy: TypeCheckingProgramStrategy;
constructor(private readonly project: ts.server.Project, private options: CompilerOptions) {
this.tsCompilerHost = makeCompilerHostFromProject(project);
const ngCompilerHost = NgCompilerHost.wrap(
this.tsCompilerHost,
project.getRootFiles(), // input files
options,
null, // old program
);
this.strategy = createTypeCheckingProgramStrategy(project);
this.lastKnownProgram = this.strategy.getProgram();
this.compiler = new NgCompiler(ngCompilerHost, options, this.lastKnownProgram, this.strategy);
}
setCompilerOptions(options: CompilerOptions) {
this.options = options;
}
analyze(): ts.Program|undefined {
const inputFiles = this.project.getRootFiles();
const ngCompilerHost =
NgCompilerHost.wrap(this.tsCompilerHost, inputFiles, this.options, this.lastKnownProgram);
const program = this.strategy.getProgram();
this.compiler =
new NgCompiler(ngCompilerHost, this.options, program, this.strategy, this.lastKnownProgram);
try {
// This is the only way to force the compiler to update the typecheck file
// in the program. We have to do try-catch because the compiler immediately
// throws if it fails to parse any template in the entire program!
const d = this.compiler.getDiagnostics();
if (d.length) {
// There could be global compilation errors. It's useful to print them
// out in development.
console.error(d.map(d => ts.flattenDiagnosticMessageText(d.messageText, '\n')));
}
} catch (e) {
console.error('Failed to analyze program', e.message);
return;
}
this.lastKnownProgram = this.compiler.getNextProgram();
return this.lastKnownProgram;
}
getDiagnostics(sourceFile: ts.SourceFile): ts.Diagnostic[] {
return this.compiler.getDiagnostics(sourceFile);
}
}
function createTypeCheckingProgramStrategy(project: ts.server.Project):
TypeCheckingProgramStrategy {
return {
getProgram(): ts.Program {
const program = project.getLanguageService().getProgram();
if (!program) {
throw new Error('Language service does not have a program!');
}
return program;
},
updateFiles(contents: Map<AbsoluteFsPath, string>, updateMode: UpdateMode) {
if (updateMode !== UpdateMode.Complete) {
throw new Error(`Incremental update mode is currently not supported`);
}
for (const [fileName, newText] of contents) {
const scriptInfo = getOrCreateTypeCheckScriptInfo(project, fileName);
const snapshot = scriptInfo.getSnapshot();
const length = snapshot.getLength();
scriptInfo.editContent(0, length, newText);
}
},
};
}
function getOrCreateTypeCheckScriptInfo(
project: ts.server.Project, tcf: string): ts.server.ScriptInfo {
// First check if there is already a ScriptInfo for the tcf
const {projectService} = project;
let scriptInfo = projectService.getScriptInfo(tcf);
if (!scriptInfo) {
// ScriptInfo needs to be opened by client to be able to set its user-defined
// content. We must also provide file content, otherwise the service will
// attempt to fetch the content from disk and fail.
scriptInfo = projectService.getOrCreateScriptInfoForNormalizedPath(
ts.server.toNormalizedPath(tcf),
true, // openedByClient
'', // fileContent
ts.ScriptKind.TS, // scriptKind
);
if (!scriptInfo) {
throw new Error(`Failed to create script info for ${tcf}`);
}
}
// Add ScriptInfo to project if it's missing. A ScriptInfo needs to be part of
// the project so that it becomes part of the program.
if (!project.containsScriptInfo(scriptInfo)) {
project.addRoot(scriptInfo);
}
return scriptInfo;
}
| packages/language-service/ivy/compiler/compiler.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001776931167114526,
0.00017358222976326942,
0.00016727749607525766,
0.00017372675938531756,
0.0000029193270165706053
] |
{
"id": 10,
"code_window": [
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n",
" console.error(chalk.red(\n",
" `Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n",
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red(`Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 104
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {Arguments, Argv} from 'yargs';
import {GITHUB_TOKEN_GENERATE_URL, mergePullRequest} from './index';
/** Builds the options for the merge command. */
export function buildMergeCommand(yargs: Argv) {
return yargs.help().strict().option('github-token', {
type: 'string',
description: 'Github token. If not set, token is retrieved from the environment variables.'
})
}
/** Handles the merge command. i.e. performs the merge of a specified pull request. */
export async function handleMergeCommand(args: Arguments) {
const githubToken = args.githubToken || process.env.GITHUB_TOKEN || process.env.TOKEN;
if (!githubToken) {
console.error(
chalk.red('No Github token set. Please set the `GITHUB_TOKEN` environment variable.'));
console.error(chalk.red('Alternatively, pass the `--github-token` command line flag.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
await mergePullRequest(args.prNumber, githubToken);
}
| dev-infra/pr/merge/cli.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0007518019992858171,
0.00033643259666860104,
0.00016517943004146218,
0.00021437444956973195,
0.00024252713774330914
] |
{
"id": 10,
"code_window": [
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n",
" console.error(chalk.red(\n",
" `Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n",
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red(`Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 104
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {getSystemPath, normalize, virtualFs} from '@angular-devkit/core';
import {TempScopedNodeJsSyncHost} from '@angular-devkit/core/node/testing';
import {HostTree} from '@angular-devkit/schematics';
import {SchematicTestRunner, UnitTestTree} from '@angular-devkit/schematics/testing';
import * as shx from 'shelljs';
describe('static-queries migration with template strategy', () => {
let runner: SchematicTestRunner;
let host: TempScopedNodeJsSyncHost;
let tree: UnitTestTree;
let tmpDirPath: string;
let previousWorkingDir: string;
let warnOutput: string[];
let errorOutput: string[];
beforeEach(() => {
runner = new SchematicTestRunner('test', require.resolve('../migrations.json'));
host = new TempScopedNodeJsSyncHost();
tree = new UnitTestTree(new HostTree(host));
writeFile('/tsconfig.json', JSON.stringify({
compilerOptions: {
experimentalDecorators: true,
lib: ['es2015'],
},
}));
writeFile('/angular.json', JSON.stringify({
projects: {t: {architect: {build: {options: {tsConfig: './tsconfig.json'}}}}}
}));
warnOutput = [];
errorOutput = [];
runner.logger.subscribe(logEntry => {
if (logEntry.level === 'warn') {
warnOutput.push(logEntry.message);
} else if (logEntry.level === 'error') {
errorOutput.push(logEntry.message);
}
});
previousWorkingDir = shx.pwd();
tmpDirPath = getSystemPath(host.root);
// Switch into the temporary directory path. This allows us to run
// the schematic against our custom unit test tree.
shx.cd(tmpDirPath);
writeFakeAngular();
});
afterEach(() => {
shx.cd(previousWorkingDir);
shx.rm('-r', tmpDirPath);
});
function writeFakeAngular() {
writeFile('/node_modules/@angular/core/index.d.ts', ``);
}
function writeFakeLibrary(selectorName = 'my-lib-selector') {
writeFile('/node_modules/my-lib/index.d.ts', `export * from './public-api';`);
writeFile('/node_modules/my-lib/public-api.d.ts', `export declare class MyLibComponent {}`);
writeFile('/node_modules/my-lib/index.metadata.json', JSON.stringify({
__symbolic: 'module',
version: 4,
metadata: {
MyLibComponent: {
__symbolic: 'class',
decorators: [{
__symbolic: 'call',
expression: {
__symbolic: 'reference',
module: '@angular/core',
name: 'Component',
line: 0,
character: 0
},
arguments: [{
selector: selectorName,
template: `<span>My Lib Component</span>`,
}]
}],
members: {}
},
},
origins: {
MyLibComponent: './public-api',
},
importAs: 'my-lib',
}));
}
function writeFile(filePath: string, contents: string) {
host.sync.write(normalize(filePath), virtualFs.stringToFileBuffer(contents));
}
function runMigration() {
return runner.runSchematicAsync('migration-v8-static-queries', {}, tree).toPromise();
}
describe('ViewChild', () => {
it('should detect queries selecting elements through template reference', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
@Component({template: \`
<ng-template>
<button #myButton>My Button</button>
</ng-template>
<div>
<button #myStaticButton>Button outside ng-template</button>
</div>
\`})
export class MyComp {
private @ViewChild('myButton') query: any;
private @ViewChild('myStaticButton') query2: any;
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myButton', { static: false }) query: any;`);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myStaticButton', { static: true }) query2: any;`);
});
it('should detect queries selecting ng-template as static', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
@Component({template: \`
<ng-template #myTmpl>
My template
</ng-template>
\`})
export class MyComp {
private @ViewChild('myTmpl') query: any;
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myTmpl', { static: true }) query: any;`);
});
it('should detect queries selecting ng-template as static (BOM)', async () => {
writeFile('/index.ts', `\uFEFF
import {Component, NgModule, ViewChild} from '@angular/core';
@Component({template: \`
<ng-template #myTmpl>
My template
</ng-template>
\`})
export class MyComp {
private @ViewChild('myTmpl') query: any;
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myTmpl', { static: true }) query: any;`);
});
it('should detect queries selecting component view providers through string token',
async () => {
writeFile('/index.ts', `
import {Component, Directive, NgModule, ViewChild} from '@angular/core';
@Directive({
selector: '[myDirective]',
providers: [
{provide: 'my-token', useValue: 'test'}
]
})
export class MyDirective {}
@Directive({
selector: '[myDirective2]',
providers: [
{provide: 'my-token-2', useValue: 'test'}
]
})
export class MyDirective2 {}
@Component({templateUrl: './my-tmpl.html'})
export class MyComp {
private @ViewChild('my-token') query: any;
private @ViewChild('my-token-2') query2: any;
}
@NgModule({declarations: [MyComp, MyDirective, MyDirective2]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span myDirective></span>
<ng-template>
<span myDirective2></span>
</ng-template>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('my-token', { static: true }) query: any;`);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('my-token-2', { static: false }) query2: any;`);
});
it('should detect queries selecting component view providers using class token', async () => {
writeFile('/index.ts', `
import {Component, Directive, NgModule, ViewChild} from '@angular/core';
export class MyService {}
export class MyService2 {}
@Directive({
selector: '[myDirective]',
providers: [MyService]
})
export class MyDirective {}
@Directive({
selector: '[myDirective2]',
providers: [MyService2]
})
export class MyDirective2 {}
@Component({templateUrl: './my-tmpl.html'})
export class MyComp {
private @ViewChild(MyService) query: any;
private @ViewChild(MyService2) query2: any;
}
@NgModule({declarations: [MyComp, MyDirective, MyDirective2]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span myDirective></span>
<ng-template>
<span myDirective2></span>
</ng-template>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(MyService, { static: true }) query: any;`);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(MyService2, { static: false }) query2: any;`);
});
it('should detect queries selecting component', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
import {HomeComponent, HomeComponent2} from './home-comp';
@Component({
template: \`
<home-comp></home-comp>
<ng-template>
<home-comp2></home-comp2>
</ng-template>
\`
})
export class MyComp {
private @ViewChild(HomeComponent) query: any;
private @ViewChild(HomeComponent2) query2: any;
}
@NgModule({declarations: [MyComp, HomeComponent, HomeComponent2]})
export class MyModule {}
`);
writeFile(`/home-comp.ts`, `
import {Component} from '@angular/core';
@Component({
selector: 'home-comp',
template: '<span>Home</span>'
})
export class HomeComponent {}
@Component({
selector: 'home-comp2',
template: '<span>Home 2</span>'
})
export class HomeComponent2 {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(HomeComponent, { static: true }) query: any;`);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(HomeComponent2, { static: false }) query2: any;`);
});
it('should detect queries selecting third-party component', async () => {
writeFakeLibrary();
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
import {MyLibComponent} from 'my-lib';
@Component({templateUrl: './my-tmpl.html'})
export class MyComp {
private @ViewChild(MyLibComponent) query: any;
}
@NgModule({declarations: [MyComp, MyLibComponent]})
export class MyModule {}
`);
writeFile('/my-tmpl.html', `
<my-lib-selector>My projected content</my-lib-selector>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(MyLibComponent, { static: true }) query: any;`);
});
it('should detect queries selecting third-party component with multiple selectors',
async () => {
writeFakeLibrary('a-selector, test-selector');
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
import {MyLibComponent} from 'my-lib';
@Component({templateUrl: './my-tmpl.html'})
export class MyComp {
private @ViewChild(MyLibComponent) query: any;
}
@NgModule({declarations: [MyComp, MyLibComponent]})
export class MyModule {}
`);
writeFile('/my-tmpl.html', `
<a-selector>Match 1</a-selector>
<ng-template>
<test-selector>Match 2</test-selector>
</ng-template>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild(MyLibComponent, { static: false }) query: any;`);
});
it('should detect queries within structural directive', async () => {
writeFile('/index.ts', `
import {Component, Directive, NgModule, ViewChild} from '@angular/core';
@Directive({selector: '[ngIf]'})
export class FakeNgIf {}
@Component({templateUrl: 'my-tmpl.html'})
export class MyComp {
private @ViewChild('myRef') query: any;
private @ViewChild('myRef2') query2: any;
}
@NgModule({declarations: [MyComp, FakeNgIf]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span ngIf #myRef>No asterisk</span>
<span *ngIf #myRef2>With asterisk</span>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', { static: true }) query: any;`);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef2', { static: false }) query2: any;`);
});
it('should detect inherited queries', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
export class BaseClass {
@ViewChild('myRef') query: any;
}
@Component({templateUrl: 'my-tmpl.html'})
export class MyComp extends BaseClass {}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span #myRef>My Ref</span>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', { static: true }) query: any;`);
});
it('should detect queries declared on setter', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
@Component({templateUrl: 'my-tmpl.html'})
export class MyComp {
@ViewChild('myRef')
set query(result: any) { /* noop */}
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span #myRef>My Ref</span>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toMatch(/@ViewChild\('myRef', { static: true }\)\s+set query/);
});
it('should detect queries declared on getter', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
@Component({templateUrl: 'my-tmpl.html'})
export class MyComp {
@ViewChild('myRef')
get query() { return null; }
set query(result: any) { /* noop */}
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
writeFile(`/my-tmpl.html`, `
<span #myRef>My Ref</span>
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toMatch(/@ViewChild\('myRef', { static: true }\)\s+get query/);
});
it('should add a todo if a query is not declared in any component', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild, SomeToken} from '@angular/core';
export class NotAComponent {
@ViewChild('myRef', {read: SomeToken}) query: any;
}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(
`@ViewChild('myRef', /* TODO: add static flag */ { read: SomeToken }) query: any;`);
expect(warnOutput.length).toBe(1);
expect(warnOutput[0])
.toMatch(
/^⮑ {3}index.ts@5:11:.+could not be determined.+not declared in any component/);
});
it('should add a todo if a query is used multiple times with different timing', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
export class BaseClass {
@ViewChild('myRef') query: any;
}
@Component({template: '<ng-template><p #myRef></p></ng-template>'})
export class FirstComp extends BaseClass {}
@Component({template: '<span #myRef></span>'})
export class SecondComp extends BaseClass {}
@NgModule({declarations: [FirstComp, SecondComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', /* TODO: add static flag */ {}) query: any;`);
expect(warnOutput.length).toBe(1);
expect(warnOutput[0])
.toMatch(
/^⮑ {3}index.ts@5:11: Multiple components use the query with different timings./);
});
it('should be able to migrate an application with type checking failure which ' +
'does not affect analysis',
async () => {
// Fakes the `@angular/package` by creating a `ViewChild` decorator
// function that requires developers to specify the "static" flag.
writeFile('/node_modules/@angular/core/index.d.ts', `
export interface ViewChildDecorator {
(selector: Type<any> | Function | string, opts: {
static: boolean;
read?: any;
}): any;
}
export declare const ViewChild: ViewChildDecorator;
`);
writeFile('/index.ts', `
import {NgModule, Component, ViewChild} from '@angular/core';
@Component({
template: '<ng-template><p #myRef></p></ng-template>'
})
export class MyComp {
@ViewChild('myRef') query: any;
}
`);
writeFile('/my-module.ts', `
import {NgModule} from '@angular/core';
import {MyComp} from './index';
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(errorOutput.length).toBe(0);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', { static: false }) query: any;`);
});
it('should be able to migrate applications with template type checking failure ' +
'which does not affect analysis',
async () => {
writeFile('/index.ts', `
import {NgModule, Component, ViewChild} from '@angular/core';
@Component({
template: '<p #myRef>{{myVar.hello()}}</p>'
})
export class MyComp {
// This causes a type checking exception as the template
// tries to call a function called "hello()" on this variable.
myVar: boolean = false;
@ViewChild('myRef') query: any;
}
`);
writeFile('/my-module.ts', `
import {NgModule} from '@angular/core';
import {MyComp} from './index';
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(errorOutput.length).toBe(0);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', { static: true }) query: any;`);
});
it('should notify user if project has syntax errors which can affect analysis', async () => {
writeFile('/index.ts', `
import {Component, ViewChild} from '@angular/core';
@Component({
template: '<p #myRef></p>'
})
export class MyComp {
@ViewChild('myRef') query: any;
}
`);
writeFile('/file-with-syntax-error.ts', `
export classX ClassWithSyntaxError {
// ...
}
`);
writeFile('/my-module.ts', `
import {NgModule} from '@angular/core';
import {MyComp} from './index';
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(errorOutput.length).toBe(1);
expect(errorOutput[0]).toMatch(/file-with-syntax-error\.ts\(2,9\): error TS1128.*/);
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', { static: true }) query: any;`);
});
it('should gracefully exit migration if queries could not be analyzed', async () => {
writeFile('/index.ts', `
import {Component, ViewChild} from '@angular/core';
@Component({template: '<ng-template><p #myRef></p></ng-template>'})
export class MyComp {
@ViewChild('myRef') query: any;
}
// **NOTE**: Analysis will fail as there is no "NgModule" that declares the component.
`);
// We don't expect an error to be thrown as this could interrupt other
// migrations which are scheduled with "ng update" in the CLI.
await runMigration();
expect(errorOutput.length).toBe(1);
expect(errorOutput[0]).toMatch(/Cannot determine the module for class MyComp/);
});
it('should gracefully exit migration if AOT compiler throws exception', async () => {
writeFile('/my-component.ts', `
import {Component, ViewChild} from '@angular/core';
@Component({template: '<span #test></span>'})
export class MyComp {
@ViewChild('test') query: any;
}
`);
writeFile('/app-module.ts', `
import {NgModule} from '@angular/core';
import {MyComp} from './components';
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
writeFile('/components.ts', `export * from './my-component';`);
writeFile('/index.ts', `export * from './app-module';`);
// Enable flat-module bundling in order to simulate a common AOT compiler
// failure that can happen in CLI projects that use flat-module bundling
// e.g. with ng-packagr. https://github.com/angular/angular/issues/20931
writeFile('/tsconfig.json', JSON.stringify({
compilerOptions: {
experimentalDecorators: true,
lib: ['es2015'],
},
angularCompilerOptions: {
flatModuleId: 'flat-module',
flatModuleOutFile: 'flat-module-bundle.js',
},
files: ['index.ts']
}));
await runMigration();
expect(errorOutput.length).toBe(1);
expect(errorOutput[0]).toMatch(/^TypeError: Cannot read property 'module' of undefined/);
});
it('should add a todo for content queries which are not detectable', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ContentChild} from '@angular/core';
@Component({template: '<p #myRef></p>'})
export class MyComp {
@ContentChild('myRef') query: any;
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ContentChild('myRef', /* TODO: add static flag */ {}) query: any;`);
expect(warnOutput.length).toBe(1);
expect(warnOutput[0])
.toMatch(/^⮑ {3}index.ts@6:11: Content queries cannot be migrated automatically\./);
});
it('should add a todo if query options cannot be migrated inline', async () => {
writeFile('/index.ts', `
import {Component, NgModule, ViewChild} from '@angular/core';
const myOptionsVar = {};
@Component({template: '<p #myRef></p>'})
export class MyComp {
@ViewChild('myRef', myOptionsVar) query: any;
}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
await runMigration();
expect(tree.readContent('/index.ts'))
.toContain(`@ViewChild('myRef', /* TODO: add static flag */ myOptionsVar) query: any;`);
expect(warnOutput.length).toBe(1);
expect(warnOutput[0])
.toMatch(/^⮑ {3}index.ts@8:11: Cannot update query to set explicit timing./);
expect(warnOutput[0]).toMatch(/Please manually set the query timing to.*static: true/);
});
it('should not normalize stylesheets which are referenced in component', async () => {
writeFile('sub_dir/index.ts', `
import {Component, NgModule, ContentChild} from '@angular/core';
@Component({
template: '<p #myRef></p>',
styleUrls: ['./my-comp.scss']
})
export class MyComp {}
@NgModule({declarations: [MyComp]})
export class MyModule {}
`);
// In order to check that the stylesheet is not normalized, we add an "@import" statement
// that would be extracted by the "DirectiveNormalizer" and fail because the URL resolver
// is not able to resolve the "../shared" relative import to the SCSS file extension.
writeFile('/sub_dir/my-comp.scss', `@import '../shared'`);
writeFile('/shared.scss', `shared {}`);
spyOn(console, 'error').and.callThrough();
await runMigration();
expect(console.error).toHaveBeenCalledTimes(0);
});
it('should always use the test migration strategy for test tsconfig files', async () => {
writeFile('/src/tsconfig.spec.json', JSON.stringify({
compilerOptions: {
experimentalDecorators: true,
lib: ['es2015'],
},
files: [
'test.ts',
],
}));
writeFile('/src/test.ts', `
import {ViewChild} from '@angular/core';
import {AppComponent} from './app.component';
@Component({template: '<span #test>Test</span>'})
class MyTestComponent {
@ViewChild('test') query: any;
}
`);
writeFile('/src/app.component.ts', `
import {Component, ViewChild} from '@angular/core';
@Component({template: '<span #test></span>'})
export class AppComponent {
@ViewChild('test') query: any;
}
`);
writeFile('/src/app.module.ts', `
import {NgModule} from '@angular/core';
import {AppComponent} from './app.component';
@NgModule({declarations: [AppComponent]})
export class MyModule {}
`);
await runMigration();
expect(errorOutput.length).toBe(0);
expect(tree.readContent('/src/test.ts'))
.toContain(`@ViewChild('test', /* TODO: add static flag */ {}) query: any;`);
expect(tree.readContent('/src/app.component.ts'))
.toContain(`@ViewChild('test', { static: true }) query: any;`);
});
it('should not fall back to test strategy if selected strategy fails', async () => {
writeFile('/src/tsconfig.spec.json', JSON.stringify({
compilerOptions: {
experimentalDecorators: true,
lib: ['es2015'],
},
files: [
'test.ts',
],
}));
writeFile('/src/test.ts', `import * as mod from './app.module';`);
writeFile('/src/app.component.ts', `
import {Component, ViewChild} from '@angular/core';
@Component({template: '<span #test>Test</span>'})
export class AppComponent {
@ViewChild('test') query: any;
}
`);
writeFile('/src/app.module.ts', `
import {NgModule} from '@angular/core';
import {AppComponent} from './app.component';
@NgModule({declarations: [AppComponent, ThisCausesAnError]})
export class MyModule {}
`);
await runMigration();
expect(errorOutput.length).toBe(1);
expect(errorOutput[0]).toMatch(/Unexpected value 'undefined'/);
expect(tree.readContent('/src/app.component.ts')).toContain(`@ViewChild('test') query: any;`);
});
});
});
| packages/core/schematics/test/static_queries_migration_template_spec.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017802976071834564,
0.00017350279085803777,
0.00016354498802684247,
0.00017395507893525064,
0.000002754653451120248
] |
{
"id": 10,
"code_window": [
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n",
" console.error(chalk.red(\n",
" `Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n",
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red(`Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 104
} | // Imports
import * as nock from 'nock';
import {GithubApi} from '../../lib/common/github-api';
// Tests
describe('GithubApi', () => {
let api: GithubApi;
beforeEach(() => api = new GithubApi('12345'));
describe('constructor()', () => {
it('should throw if \'githubToken\' is missing or empty', () => {
expect(() => new GithubApi('')).toThrowError('Missing or empty required parameter \'githubToken\'!');
});
});
describe('get()', () => {
let apiBuildPathSpy: jasmine.Spy;
let apiRequestSpy: jasmine.Spy;
beforeEach(() => {
apiBuildPathSpy = spyOn(api as any, 'buildPath');
apiRequestSpy = spyOn(api as any, 'request');
});
it('should call \'buildPath()\' with the pathname and params', () => {
api.get('/foo', {bar: 'baz'});
expect(apiBuildPathSpy).toHaveBeenCalled();
expect(apiBuildPathSpy.calls.argsFor(0)).toEqual(['/foo', {bar: 'baz'}]);
});
it('should call \'request()\' with the correct method', () => {
api.get('/foo');
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[0]).toBe('get');
});
it('should call \'request()\' with the correct path', () => {
apiBuildPathSpy.and.returnValue('/foo/bar');
api.get('foo');
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[1]).toBe('/foo/bar');
});
it('should not pass data to \'request()\'', () => {
(api.get as any)('foo', {}, {});
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[2]).toBeUndefined();
});
});
describe('post()', () => {
let apiBuildPathSpy: jasmine.Spy;
let apiRequestSpy: jasmine.Spy;
beforeEach(() => {
apiBuildPathSpy = spyOn(api as any, 'buildPath');
apiRequestSpy = spyOn(api as any, 'request');
});
it('should call \'buildPath()\' with the pathname and params', () => {
api.post('/foo', {bar: 'baz'});
expect(apiBuildPathSpy).toHaveBeenCalled();
expect(apiBuildPathSpy.calls.argsFor(0)).toEqual(['/foo', {bar: 'baz'}]);
});
it('should call \'request()\' with the correct method', () => {
api.post('/foo');
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[0]).toBe('post');
});
it('should call \'request()\' with the correct path', () => {
apiBuildPathSpy.and.returnValue('/foo/bar');
api.post('/foo');
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[1]).toBe('/foo/bar');
});
it('should pass the data to \'request()\'', () => {
api.post('/foo', {}, {bar: 'baz'});
expect(apiRequestSpy).toHaveBeenCalled();
expect(apiRequestSpy.calls.argsFor(0)[2]).toEqual({bar: 'baz'});
});
});
describe('getPaginated()', () => {
let deferreds: {resolve: (v: any) => void, reject: (v: any) => void}[];
beforeEach(() => {
deferreds = [];
spyOn(api, 'get').and.callFake(() => new Promise((resolve, reject) => deferreds.push({resolve, reject})));
});
it('should return a promise', () => {
expect((api as any).getPaginated()).toBeInstanceOf(Promise);
});
it('should call \'get()\' with the correct pathname and params', () => {
(api as any).getPaginated('/foo/bar');
(api as any).getPaginated('/foo/bar', {baz: 'qux'});
expect(api.get).toHaveBeenCalledWith('/foo/bar', {page: 1, per_page: 100});
expect(api.get).toHaveBeenCalledWith('/foo/bar', {baz: 'qux', page: 1, per_page: 100});
});
it('should reject if the request fails', async () => {
const responsePromise = (api as any).getPaginated('/foo/bar');
deferreds[0].reject('Test');
await expectAsync(responsePromise).toBeRejectedWith('Test');
});
it('should resolve with the returned items', async () => {
const items = [{id: 1}, {id: 2}];
const responsePromise = (api as any).getPaginated('/foo/bar');
deferreds[0].resolve(items);
await expectAsync(responsePromise).toBeResolvedTo(items);
});
it('should iteratively call \'get()\' to fetch all items', async () => {
// Create an array or 250 objects.
const allItems = new Array(250).fill(null).map((_, i) => ({id: i}));
const apiGetSpy = api.get as jasmine.Spy;
const paramsForPage = (page: number) => ({baz: 'qux', page, per_page: 100});
const responsePromise = (api as any).getPaginated('/foo/bar', {baz: 'qux'});
deferreds[0].resolve(allItems.slice(0, 100));
setTimeout(() => {
deferreds[1].resolve(allItems.slice(100, 200));
setTimeout(() => {
deferreds[2].resolve(allItems.slice(200));
}, 0);
}, 0);
await expectAsync(responsePromise).toBeResolvedTo(allItems);
expect(apiGetSpy).toHaveBeenCalledTimes(3);
expect(apiGetSpy.calls.argsFor(0)).toEqual(['/foo/bar', paramsForPage(1)]);
expect(apiGetSpy.calls.argsFor(1)).toEqual(['/foo/bar', paramsForPage(2)]);
expect(apiGetSpy.calls.argsFor(2)).toEqual(['/foo/bar', paramsForPage(3)]);
});
});
// Protected methods
describe('buildPath()', () => {
it('should return the pathname if no params', () => {
expect((api as any).buildPath('/foo')).toBe('/foo');
expect((api as any).buildPath('/foo', undefined)).toBe('/foo');
expect((api as any).buildPath('/foo', null)).toBe('/foo');
});
it('should append the params to the pathname', () => {
expect((api as any).buildPath('/foo', {bar: 'baz'})).toBe('/foo?bar=baz');
});
it('should join the params with \'&\'', () => {
expect((api as any).buildPath('/foo', {bar: 1, baz: 2})).toBe('/foo?bar=1&baz=2');
});
it('should ignore undefined/null params', () => {
expect((api as any).buildPath('/foo', {bar: undefined, baz: null})).toBe('/foo');
});
it('should encode param values as URI components', () => {
expect((api as any).buildPath('/foo', {bar: 'b a&z'})).toBe('/foo?bar=b%20a%26z');
});
});
describe('request()', () => {
it('should return a promise', () => {
nock('https://api.github.com').get('/').reply(200);
expect((api as any).request()).toBeInstanceOf(Promise);
});
it('should call \'https.request()\' with the correct options', () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(200);
(api as any).request('method', '/path');
requestHandler.done();
});
it('should add the \'Authorization\' header containing the \'githubToken\'', () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method', undefined, {
reqheaders: {Authorization: 'token 12345'},
})
.reply(200);
(api as any).request('method', '/path');
requestHandler.done();
});
it('should reject on request error', async () => {
nock('https://api.github.com')
.intercept('/path', 'method')
.replyWithError('Test');
await expectAsync((api as any).request('method', '/path')).toBeRejectedWithError('Test');
});
it('should \'JSON.stringify\' and send the data along with the request', () => {
const data = {key: 'value'};
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method', JSON.stringify(data))
.reply(200);
(api as any).request('method', '/path', data);
requestHandler.done();
});
it('should reject if response statusCode is <200', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(199);
const responsePromise = (api as any).request('method', '/path');
await expectAsync(responsePromise).toBeRejectedWith(jasmine.stringMatching('failed'));
await expectAsync(responsePromise).toBeRejectedWith(jasmine.stringMatching('status: 199'));
requestHandler.done();
});
it('should reject if response statusCode is >=400', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(400);
const responsePromise = (api as any).request('method', '/path');
await expectAsync(responsePromise).toBeRejectedWith(jasmine.stringMatching('failed'));
await expectAsync(responsePromise).toBeRejectedWith(jasmine.stringMatching('status: 400'));
requestHandler.done();
});
it('should include the response text in the rejection message', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(500, 'Test');
const responsePromise = (api as any).request('method', '/path');
await expectAsync(responsePromise).toBeRejectedWith(jasmine.stringMatching('Test'));
requestHandler.done();
});
it('should resolve if returned statusCode is >=200 and <400', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(200);
await expectAsync((api as any).request('method', '/path')).toBeResolved();
requestHandler.done();
});
it('should parse the response body into an object using \'JSON.parse\'', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(300, '{"foo": "bar"}');
await expectAsync((api as any).request('method', '/path')).toBeResolvedTo({foo: 'bar'});
requestHandler.done();
});
it('should reject if the response text is malformed JSON', async () => {
const requestHandler = nock('https://api.github.com')
.intercept('/path', 'method')
.reply(300, '}');
await expectAsync((api as any).request('method', '/path')).toBeRejectedWithError(SyntaxError);
requestHandler.done();
});
});
});
| aio/aio-builds-setup/dockerbuild/scripts-js/test/common/github-api.spec.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.000175601860973984,
0.00017152936197817326,
0.00016716380196157843,
0.00017184462922159582,
0.0000019763044747378444
] |
{
"id": 10,
"code_window": [
" return true;\n",
" case MergeStatus.DIRTY_WORKING_DIR:\n",
" console.error(chalk.red(\n",
" `Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n",
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red(`Local working repository not clean. Please make sure there are ` +\n",
" `no uncommitted changes.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 104
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {AsyncTestCompleter, beforeEach, describe, expect, inject, it} from '@angular/core/testing/src/testing_internal';
import {ResourceLoaderImpl} from '@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl';
if (isBrowser) {
describe('ResourceLoaderImpl', () => {
let resourceLoader: ResourceLoaderImpl;
// TODO(juliemr): This file currently won't work with dart unit tests run using
// exclusive it or describe (iit or ddescribe). This is because when
// pub run test is executed against this specific file the relative paths
// will be relative to here, so url200 should look like
// static_assets/200.html.
// We currently have no way of detecting this.
const url200 = '/base/angular/packages/platform-browser/test/browser/static_assets/200.html';
const url404 = '/bad/path/404.html';
beforeEach(() => {
resourceLoader = new ResourceLoaderImpl();
});
it('should resolve the Promise with the file content on success',
inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
resourceLoader.get(url200).then((text) => {
expect(text.trim()).toEqual('<p>hey</p>');
async.done();
});
}), 10000);
it('should reject the Promise on failure',
inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
resourceLoader.get(url404).catch((e) => {
expect(e).toEqual(`Failed to load ${url404}`);
async.done();
return null;
});
}), 10000);
});
}
| packages/platform-browser-dynamic/test/resource_loader/resource_loader_impl_spec.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017497074441052973,
0.00017165197641588748,
0.00016843578487168998,
0.00017112305795308203,
0.000002425480488454923
] |
{
"id": 11,
"code_window": [
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n",
" console.error(chalk.red(\n",
" 'An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n",
" return false;\n",
" case MergeStatus.FAILED:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red('An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 109
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {Arguments, Argv} from 'yargs';
import {GITHUB_TOKEN_GENERATE_URL, mergePullRequest} from './index';
/** Builds the options for the merge command. */
export function buildMergeCommand(yargs: Argv) {
return yargs.help().strict().option('github-token', {
type: 'string',
description: 'Github token. If not set, token is retrieved from the environment variables.'
})
}
/** Handles the merge command. i.e. performs the merge of a specified pull request. */
export async function handleMergeCommand(args: Arguments) {
const githubToken = args.githubToken || process.env.GITHUB_TOKEN || process.env.TOKEN;
if (!githubToken) {
console.error(
chalk.red('No Github token set. Please set the `GITHUB_TOKEN` environment variable.'));
console.error(chalk.red('Alternatively, pass the `--github-token` command line flag.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
await mergePullRequest(args.prNumber, githubToken);
}
| dev-infra/pr/merge/cli.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00042852002661675215,
0.00026181121938861907,
0.00016325876640621573,
0.0002277330495417118,
0.00010728332563303411
] |
{
"id": 11,
"code_window": [
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n",
" console.error(chalk.red(\n",
" 'An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n",
" return false;\n",
" case MergeStatus.FAILED:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red('An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 109
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
const u = undefined;
export default [];
| packages/common/locales/extra/as.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017352313443552703,
0.00017036235658451915,
0.00016720157873351127,
0.00017036235658451915,
0.0000031607778510078788
] |
{
"id": 11,
"code_window": [
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n",
" console.error(chalk.red(\n",
" 'An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n",
" return false;\n",
" case MergeStatus.FAILED:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red('An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 109
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {NodeJSFileSystem, setFileSystem} from './src/ngtsc/file_system';
export {AotCompilerHost, AotCompilerHost as StaticReflectorHost, StaticReflector, StaticSymbol} from '@angular/compiler';
export {VERSION} from './src/version';
export * from './src/metadata';
export * from './src/transformers/api';
export * from './src/transformers/entry_points';
export * from './src/perform_compile';
export * from './src/tooling';
// TODO(tbosch): remove this once usages in G3 are changed to `CompilerOptions`
export {CompilerOptions as AngularCompilerOptions} from './src/transformers/api';
export {ngToTsDiagnostic} from './src/transformers/util';
export {NgTscPlugin} from './src/ngtsc/tsc_plugin';
setFileSystem(new NodeJSFileSystem());
| packages/compiler-cli/index.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017469785234425217,
0.00017321739869657904,
0.00017076201038435102,
0.0001741923624649644,
0.0000017484496765973745
] |
{
"id": 11,
"code_window": [
" return false;\n",
" case MergeStatus.UNKNOWN_GIT_ERROR:\n",
" console.error(chalk.red(\n",
" 'An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n",
" return false;\n",
" case MergeStatus.FAILED:\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"replace",
"keep",
"keep"
],
"after_edit": [
" error(\n",
" red('An unknown Git error has been thrown. Please check the output ' +\n",
" 'above for details.'));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 109
} | #!/usr/bin/env bash
# WARNING: CI_SECRET_AIO_DEPLOY_FIREBASE_TOKEN should NOT be printed.
set +x -eu -o pipefail
# Do not deploy if we are running in a fork.
if [[ "$CI_REPO_OWNER/$CI_REPO_NAME" != "angular/angular" ]]; then
echo "Skipping deploy because this is not angular/angular."
exit 0
fi
# Do not deploy if this is a PR. PRs are deployed in the `aio_preview` CircleCI job.
if [[ $CI_PULL_REQUEST != "false" ]]; then
echo "Skipping deploy because this is a PR build."
exit 0
fi
# Do not deploy if the current commit is not the latest on its branch.
readonly latestCommit=$(git ls-remote origin $CI_BRANCH | cut -c1-40)
if [[ $CI_COMMIT != $latestCommit ]]; then
echo "Skipping deploy because $CI_COMMIT is not the latest commit ($latestCommit)."
exit 0
fi
# The deployment mode is computed based on the branch we are building
if [[ $CI_BRANCH == master ]]; then
readonly deployEnv=next
elif [[ $CI_BRANCH == $CI_STABLE_BRANCH ]]; then
readonly deployEnv=stable
else
# Extract the major versions from the branches, e.g. the 4 from 4.3.x
readonly majorVersion=${CI_BRANCH%%.*}
readonly majorVersionStable=${CI_STABLE_BRANCH%%.*}
# Do not deploy if the major version is not less than the stable branch major version
if [[ !( "$majorVersion" < "$majorVersionStable" ) ]]; then
echo "Skipping deploy of branch \"$CI_BRANCH\" to firebase."
echo "We only deploy archive branches with the major version less than the stable branch: \"$CI_STABLE_BRANCH\""
exit 0
fi
# Find the branch that has highest minor version for the given `$majorVersion`
readonly mostRecentMinorVersion=$(
# List the branches that start with the major version
git ls-remote origin refs/heads/${majorVersion}.*.x |
# Extract the version number
awk -F'/' '{print $3}' |
# Sort by the minor version
sort -t. -k 2,2n |
# Get the highest version
tail -n1
)
# Do not deploy as it is not the latest branch for the given major version
if [[ $CI_BRANCH != $mostRecentMinorVersion ]]; then
echo "Skipping deploy of branch \"$CI_BRANCH\" to firebase."
echo "There is a more recent branch with the same major version: \"$mostRecentMinorVersion\""
exit 0
fi
readonly deployEnv=archive
fi
case $deployEnv in
next)
readonly projectId=aio-staging
readonly deployedUrl=https://next.angular.io/
readonly firebaseToken=$CI_SECRET_AIO_DEPLOY_FIREBASE_TOKEN
;;
stable)
readonly projectId=angular-io
readonly deployedUrl=https://angular.io/
readonly firebaseToken=$CI_SECRET_AIO_DEPLOY_FIREBASE_TOKEN
;;
archive)
readonly projectId=v${majorVersion}-angular-io
readonly deployedUrl=https://v${majorVersion}.angular.io/
readonly firebaseToken=$CI_SECRET_AIO_DEPLOY_FIREBASE_TOKEN
;;
esac
echo "Git branch : $CI_BRANCH"
echo "Build/deploy mode : $deployEnv"
echo "Firebase project : $projectId"
echo "Deployment URL : $deployedUrl"
if [[ ${1:-} == "--dry-run" ]]; then
exit 0
fi
# Deploy
(
cd "`dirname $0`/.."
# Build the app
yarn build --configuration=$deployEnv --progress=false
# Include any mode-specific files
cp -rf src/extra-files/$deployEnv/. dist/
# Set deployedUrl as parameter in the opensearch description
# deployedUrl must end with /
yarn set-opensearch-url $deployedUrl
# Check payload size
yarn payload-size
# Deploy to Firebase
yarn firebase use "$projectId" --token "$firebaseToken"
yarn firebase deploy --message "Commit: $CI_COMMIT" --non-interactive --token "$firebaseToken"
# Run PWA-score tests
yarn test-pwa-score "$deployedUrl" "$CI_AIO_MIN_PWA_SCORE"
)
| aio/scripts/deploy-to-firebase.sh | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00031785707687959075,
0.00018128308875020593,
0.0001641281705815345,
0.0001693372760200873,
0.00004129223816562444
] |
{
"id": 12,
"code_window": [
" return false;\n",
" case MergeStatus.FAILED:\n",
" console.error(chalk.yellow(`Could not merge the specified pull request.`));\n",
" console.error(chalk.red(failure!.message));\n",
" if (canForciblyMerge && !disableForceMergePrompt) {\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" error(yellow(`Could not merge the specified pull request.`));\n",
" error(red(failure!.message));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 114
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {Arguments, Argv} from 'yargs';
import {GITHUB_TOKEN_GENERATE_URL, mergePullRequest} from './index';
/** Builds the options for the merge command. */
export function buildMergeCommand(yargs: Argv) {
return yargs.help().strict().option('github-token', {
type: 'string',
description: 'Github token. If not set, token is retrieved from the environment variables.'
})
}
/** Handles the merge command. i.e. performs the merge of a specified pull request. */
export async function handleMergeCommand(args: Arguments) {
const githubToken = args.githubToken || process.env.GITHUB_TOKEN || process.env.TOKEN;
if (!githubToken) {
console.error(
chalk.red('No Github token set. Please set the `GITHUB_TOKEN` environment variable.'));
console.error(chalk.red('Alternatively, pass the `--github-token` command line flag.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
await mergePullRequest(args.prNumber, githubToken);
}
| dev-infra/pr/merge/cli.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0008847251301631331,
0.0004645345907192677,
0.0001666127354837954,
0.0004034002486150712,
0.0002959727426059544
] |
{
"id": 12,
"code_window": [
" return false;\n",
" case MergeStatus.FAILED:\n",
" console.error(chalk.yellow(`Could not merge the specified pull request.`));\n",
" console.error(chalk.red(failure!.message));\n",
" if (canForciblyMerge && !disableForceMergePrompt) {\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" error(yellow(`Could not merge the specified pull request.`));\n",
" error(red(failure!.message));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 114
} | // #docregion
export interface Hero {
id: number;
name: string;
}
| aio/content/examples/styleguide/src/01-01/app/heroes/shared/hero.model.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001699466083664447,
0.0001699466083664447,
0.0001699466083664447,
0.0001699466083664447,
0
] |
{
"id": 12,
"code_window": [
" return false;\n",
" case MergeStatus.FAILED:\n",
" console.error(chalk.yellow(`Could not merge the specified pull request.`));\n",
" console.error(chalk.red(failure!.message));\n",
" if (canForciblyMerge && !disableForceMergePrompt) {\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" error(yellow(`Could not merge the specified pull request.`));\n",
" error(red(failure!.message));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 114
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Component} from '@angular/core';
// #docregion I18nPluralPipeComponent
@Component({
selector: 'i18n-plural-pipe',
template: `<div>{{ messages.length | i18nPlural: messageMapping }}</div>`
})
export class I18nPluralPipeComponent {
messages: any[] = ['Message 1'];
messageMapping:
{[k: string]: string} = {'=0': 'No messages.', '=1': 'One message.', 'other': '# messages.'};
}
// #enddocregion
// #docregion I18nSelectPipeComponent
@Component(
{selector: 'i18n-select-pipe', template: `<div>{{gender | i18nSelect: inviteMap}} </div>`})
export class I18nSelectPipeComponent {
gender: string = 'male';
inviteMap: any = {'male': 'Invite him.', 'female': 'Invite her.', 'other': 'Invite them.'};
}
//#enddocregion
| packages/examples/common/pipes/ts/i18n_pipe.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017593419761396945,
0.00017237344582099468,
0.00016619273810647428,
0.0001736834237817675,
0.0000036864398680336308
] |
{
"id": 12,
"code_window": [
" return false;\n",
" case MergeStatus.FAILED:\n",
" console.error(chalk.yellow(`Could not merge the specified pull request.`));\n",
" console.error(chalk.red(failure!.message));\n",
" if (canForciblyMerge && !disableForceMergePrompt) {\n"
],
"labels": [
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" error(yellow(`Could not merge the specified pull request.`));\n",
" error(red(failure!.message));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 114
} | .hero-profile {
border: 1px solid gray;
padding: 5px;
padding-bottom: 20px;
padding-left: 20px;
border-radius: 10px;
background-color: lightgreen;
color: black;
}
.job-ad {
border: 1px solid gray;
padding: 5px;
padding-bottom: 20px;
padding-left: 20px;
border-radius: 10px;
background-color: lightblue;
color: black;
}
.ad-banner-example {
width: 400px;
} | aio/content/examples/dynamic-component-loader/src/assets/sample.css | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00016780626901891083,
0.00016649323515594006,
0.00016417683218605816,
0.0001674966188147664,
0.0000016428186881967122
] |
{
"id": 13,
"code_window": [
" if (canForciblyMerge && !disableForceMergePrompt) {\n",
" console.info();\n",
" console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));\n",
" console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));\n",
" return await promptAndPerformForceMerge();\n",
" }\n",
" return false;\n",
" default:\n"
],
"labels": [
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" info();\n",
" info(yellow('The pull request above failed due to non-critical errors.'));\n",
" info(yellow(`This error can be forcibly ignored if desired.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 117
} | /**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import chalk from 'chalk';
import {getRepoBaseDir} from '../../utils/config';
import {promptConfirm} from '../../utils/console';
import {loadAndValidateConfig, MergeConfigWithRemote} from './config';
import {GithubApiRequestError} from './git';
import {MergeResult, MergeStatus, PullRequestMergeTask} from './task';
/** URL to the Github page where personal access tokens can be generated. */
export const GITHUB_TOKEN_GENERATE_URL = `https://github.com/settings/tokens`;
/**
* Merges a given pull request based on labels configured in the given merge configuration.
* Pull requests can be merged with different strategies such as the Github API merge
* strategy, or the local autosquash strategy. Either strategy has benefits and downsides.
* More information on these strategies can be found in their dedicated strategy classes.
*
* See {@link GithubApiMergeStrategy} and {@link AutosquashMergeStrategy}
*
* @param prNumber Number of the pull request that should be merged.
* @param githubToken Github token used for merging (i.e. fetching and pushing)
* @param projectRoot Path to the local Git project that is used for merging.
* @param config Configuration for merging pull requests.
*/
export async function mergePullRequest(
prNumber: number, githubToken: string, projectRoot: string = getRepoBaseDir(),
config?: MergeConfigWithRemote) {
// If no explicit configuration has been specified, we load and validate
// the configuration from the shared dev-infra configuration.
if (config === undefined) {
const {config: _config, errors} = loadAndValidateConfig();
if (errors) {
console.error(chalk.red('Invalid configuration:'));
errors.forEach(desc => console.error(chalk.yellow(` - ${desc}`)));
process.exit(1);
}
config = _config!;
}
const api = new PullRequestMergeTask(projectRoot, config, githubToken);
// Perform the merge. Force mode can be activated through a command line flag.
// Alternatively, if the merge fails with non-fatal failures, the script
// will prompt whether it should rerun in force mode.
if (!await performMerge(false)) {
process.exit(1);
}
/** Performs the merge and returns whether it was successful or not. */
async function performMerge(ignoreFatalErrors: boolean): Promise<boolean> {
try {
const result = await api.merge(prNumber, ignoreFatalErrors);
return await handleMergeResult(result, ignoreFatalErrors);
} catch (e) {
// Catch errors to the Github API for invalid requests. We want to
// exit the script with a better explanation of the error.
if (e instanceof GithubApiRequestError && e.status === 401) {
console.error(chalk.red('Github API request failed. ' + e.message));
console.error(chalk.yellow('Please ensure that your provided token is valid.'));
console.error(chalk.yellow(`You can generate a token here: ${GITHUB_TOKEN_GENERATE_URL}`));
process.exit(1);
}
throw e;
}
}
/**
* Prompts whether the specified pull request should be forcibly merged. If so, merges
* the specified pull request forcibly (ignoring non-critical failures).
* @returns Whether the specified pull request has been forcibly merged.
*/
async function promptAndPerformForceMerge(): Promise<boolean> {
if (await promptConfirm('Do you want to forcibly proceed with merging?')) {
// Perform the merge in force mode. This means that non-fatal failures
// are ignored and the merge continues.
return performMerge(true);
}
return false;
}
/**
* Handles the merge result by printing console messages, exiting the process
* based on the result, or by restarting the merge if force mode has been enabled.
* @returns Whether the merge was successful or not.
*/
async function handleMergeResult(result: MergeResult, disableForceMergePrompt = false) {
const {failure, status} = result;
const canForciblyMerge = failure && failure.nonFatal;
switch (status) {
case MergeStatus.SUCCESS:
console.info(chalk.green(`Successfully merged the pull request: ${prNumber}`));
return true;
case MergeStatus.DIRTY_WORKING_DIR:
console.error(chalk.red(
`Local working repository not clean. Please make sure there are ` +
`no uncommitted changes.`));
return false;
case MergeStatus.UNKNOWN_GIT_ERROR:
console.error(chalk.red(
'An unknown Git error has been thrown. Please check the output ' +
'above for details.'));
return false;
case MergeStatus.FAILED:
console.error(chalk.yellow(`Could not merge the specified pull request.`));
console.error(chalk.red(failure!.message));
if (canForciblyMerge && !disableForceMergePrompt) {
console.info();
console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));
console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));
return await promptAndPerformForceMerge();
}
return false;
default:
throw Error(`Unexpected merge result: ${status}`);
}
}
}
| dev-infra/pr/merge/index.ts | 1 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.993488073348999,
0.07996033132076263,
0.00016384247282985598,
0.0009844928281381726,
0.26385587453842163
] |
{
"id": 13,
"code_window": [
" if (canForciblyMerge && !disableForceMergePrompt) {\n",
" console.info();\n",
" console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));\n",
" console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));\n",
" return await promptAndPerformForceMerge();\n",
" }\n",
" return false;\n",
" default:\n"
],
"labels": [
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" info();\n",
" info(yellow('The pull request above failed due to non-critical errors.'));\n",
" info(yellow(`This error can be forcibly ignored if desired.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 117
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {Element, LexerRange, Node, ParseError, ParseErrorLevel, ParseSourceSpan, XmlParser} from '@angular/compiler';
import {Diagnostics} from '../../../diagnostics';
import {TranslationParseError} from './translation_parse_error';
export function getAttrOrThrow(element: Element, attrName: string): string {
const attrValue = getAttribute(element, attrName);
if (attrValue === undefined) {
throw new TranslationParseError(
element.sourceSpan, `Missing required "${attrName}" attribute:`);
}
return attrValue;
}
export function getAttribute(element: Element, attrName: string): string|undefined {
const attr = element.attrs.find(a => a.name === attrName);
return attr !== undefined ? attr.value : undefined;
}
/**
* Parse the "contents" of an XML element.
*
* This would be equivalent to parsing the `innerHTML` string of an HTML document.
*
* @param element The element whose inner range we want to parse.
* @returns a collection of XML `Node` objects that were parsed from the element's contents.
*/
export function parseInnerRange(element: Element): Node[] {
const xmlParser = new XmlParser();
const xml = xmlParser.parse(
element.sourceSpan.start.file.content, element.sourceSpan.start.file.url,
{tokenizeExpansionForms: true, range: getInnerRange(element)});
if (xml.errors.length) {
throw xml.errors.map(e => new TranslationParseError(e.span, e.msg).toString()).join('\n');
}
return xml.rootNodes;
}
/**
* Compute a `LexerRange` that contains all the children of the given `element`.
* @param element The element whose inner range we want to compute.
*/
function getInnerRange(element: Element): LexerRange {
const start = element.startSourceSpan!.end;
const end = element.endSourceSpan!.start;
return {
startPos: start.offset,
startLine: start.line,
startCol: start.col,
endPos: end.offset,
};
}
/**
* This "hint" object is used to pass information from `canParse()` to `parse()` for
* `TranslationParser`s that expect XML contents.
*
* This saves the `parse()` method from having to re-parse the XML.
*/
export interface XmlTranslationParserHint {
element: Element;
errors: ParseError[];
}
/**
* Can this XML be parsed for translations, given the expected `rootNodeName` and expected root node
* `attributes` that should appear in the file.
*
* @param filePath The path to the file being checked.
* @param contents The contents of the file being checked.
* @param rootNodeName The expected name of an XML root node that should exist.
* @param attributes The attributes (and their values) that should appear on the root node.
* @returns The `XmlTranslationParserHint` object for use by `TranslationParser.parse()` if the XML
* document has the expected format.
*/
export function canParseXml(
filePath: string, contents: string, rootNodeName: string,
attributes: Record<string, string>): XmlTranslationParserHint|false {
const xmlParser = new XmlParser();
const xml = xmlParser.parse(contents, filePath);
if (xml.rootNodes.length === 0 ||
xml.errors.some(error => error.level === ParseErrorLevel.ERROR)) {
return false;
}
const rootElements = xml.rootNodes.filter(isNamedElement(rootNodeName));
const rootElement = rootElements[0];
if (rootElement === undefined) {
return false;
}
for (const attrKey of Object.keys(attributes)) {
const attr = rootElement.attrs.find(attr => attr.name === attrKey);
if (attr === undefined || attr.value !== attributes[attrKey]) {
return false;
}
}
if (rootElements.length > 1) {
xml.errors.push(new ParseError(
xml.rootNodes[1].sourceSpan,
'Unexpected root node. XLIFF 1.2 files should only have a single <xliff> root node.',
ParseErrorLevel.WARNING));
}
return {element: rootElement, errors: xml.errors};
}
/**
* Create a predicate, which can be used by things like `Array.filter()`, that will match a named
* XML Element from a collection of XML Nodes.
*
* @param name The expected name of the element to match.
*/
export function isNamedElement(name: string): (node: Node) => node is Element {
function predicate(node: Node): node is Element {
return node instanceof Element && node.name === name;
}
return predicate;
}
/**
* Add an XML parser related message to the given `diagnostics` object.
*/
export function addParseDiagnostic(
diagnostics: Diagnostics, sourceSpan: ParseSourceSpan, message: string,
level: ParseErrorLevel): void {
addParseError(diagnostics, new ParseError(sourceSpan, message, level));
}
/**
* Copy the formatted error message from the given `parseError` object into the given `diagnostics`
* object.
*/
export function addParseError(diagnostics: Diagnostics, parseError: ParseError): void {
if (parseError.level === ParseErrorLevel.ERROR) {
diagnostics.error(parseError.toString());
} else {
diagnostics.warn(parseError.toString());
}
}
| packages/localize/src/tools/src/translate/translation_files/translation_parsers/translation_utils.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001738112623570487,
0.00016856654838193208,
0.00016066465468611568,
0.00016880349721759558,
0.0000037487238842004444
] |
{
"id": 13,
"code_window": [
" if (canForciblyMerge && !disableForceMergePrompt) {\n",
" console.info();\n",
" console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));\n",
" console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));\n",
" return await promptAndPerformForceMerge();\n",
" }\n",
" return false;\n",
" default:\n"
],
"labels": [
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" info();\n",
" info(yellow('The pull request above failed due to non-critical errors.'));\n",
" info(yellow(`This error can be forcibly ignored if desired.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 117
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
const u = undefined;
function plural(n: number): number {
let i = Math.floor(Math.abs(n)), v = n.toString().replace(/^[^.]*\.?/, '').length;
if (i === 1 && v === 0) return 1;
return 5;
}
export default [
'en-UM',
[['a', 'p'], ['AM', 'PM'], u],
[['AM', 'PM'], u, u],
[
['S', 'M', 'T', 'W', 'T', 'F', 'S'], ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa']
],
u,
[
['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
[
'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
'October', 'November', 'December'
]
],
u,
[['B', 'A'], ['BC', 'AD'], ['Before Christ', 'Anno Domini']],
0,
[6, 0],
['M/d/yy', 'MMM d, y', 'MMMM d, y', 'EEEE, MMMM d, y'],
['h:mm a', 'h:mm:ss a', 'h:mm:ss a z', 'h:mm:ss a zzzz'],
['{1}, {0}', u, '{1} \'at\' {0}', u],
['.', ',', ';', '%', '+', '-', 'E', '×', '‰', '∞', 'NaN', ':'],
['#,##0.###', '#,##0%', '¤#,##0.00', '#E0'],
'USD',
'$',
'US Dollar',
{},
'ltr',
plural
];
| packages/common/locales/en-UM.ts | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.0001755402481649071,
0.00017119297990575433,
0.00016803652397356927,
0.00017083148122765124,
0.000002340567789360648
] |
{
"id": 13,
"code_window": [
" if (canForciblyMerge && !disableForceMergePrompt) {\n",
" console.info();\n",
" console.info(chalk.yellow('The pull request above failed due to non-critical errors.'));\n",
" console.info(chalk.yellow(`This error can be forcibly ignored if desired.`));\n",
" return await promptAndPerformForceMerge();\n",
" }\n",
" return false;\n",
" default:\n"
],
"labels": [
"keep",
"replace",
"replace",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" info();\n",
" info(yellow('The pull request above failed due to non-critical errors.'));\n",
" info(yellow(`This error can be forcibly ignored if desired.`));\n"
],
"file_path": "dev-infra/pr/merge/index.ts",
"type": "replace",
"edit_start_line_idx": 117
} | # Editor configuration, see https://editorconfig.org
root = true
[*]
charset = utf-8
indent_style = space
indent_size = 2
insert_final_newline = true
trim_trailing_whitespace = true
[*.md]
max_line_length = off
trim_trailing_whitespace = false
| integration/cli-hello-world-ivy-i18n/.editorconfig | 0 | https://github.com/angular/angular/commit/e28f13a102fca24ca74870ac53ad4651203c5f67 | [
0.00017176257097162306,
0.0001711375080049038,
0.00017051244503818452,
0.0001711375080049038,
6.250629667192698e-7
] |
{
"id": 0,
"code_window": [
" </script>`).content\n",
" )\n",
" })\n",
"\n",
" test('error on duplicated defalut export', () => {\n",
" expect(\n",
" parse(`\n",
" <script>\n",
" export default {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" test('error on duplicated default export', () => {\n"
],
"file_path": "packages/compiler-sfc/__tests__/compileScript.spec.ts",
"type": "replace",
"edit_start_line_idx": 459
} | import { parse, SFCScriptCompileOptions } from '../src'
import { parse as babelParse } from '@babel/parser'
import { babelParserDefautPlugins } from '@vue/shared'
function compile(src: string, options?: SFCScriptCompileOptions) {
return parse(src, options).descriptor.scriptTransformed!
}
function assertCode(code: string) {
// parse the generated code to make sure it is valid
try {
babelParse(code, {
sourceType: 'module',
plugins: [...babelParserDefautPlugins, 'typescript']
})
} catch (e) {
console.log(code)
throw e
}
expect(code).toMatchSnapshot()
}
describe('SFC compile <script setup>', () => {
test('should hoist imports', () => {
assertCode(
compile(`<script setup>import { ref } from 'vue'</script>`).content
)
})
test('explicit setup signature', () => {
assertCode(
compile(`<script setup="props, { emit }">emit('foo')</script>`).content
)
})
test('import dedupe between <script> and <script setup>', () => {
const { content } = compile(`
<script>
import { x } from './x'
</script>
<script setup>
import { x } from './x'
x()
</script>
`)
assertCode(content)
expect(content.indexOf(`import { x }`)).toEqual(
content.lastIndexOf(`import { x }`)
)
})
describe('exports', () => {
test('export const x = ...', () => {
const { content, bindings } = compile(
`<script setup>export const x = 1</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup'
})
})
test('export const { x } = ... (destructuring)', () => {
const { content, bindings } = compile(`<script setup>
export const [a = 1, { b } = { b: 123 }, ...c] = useFoo()
export const { d = 2, _: [e], ...f } = useBar()
</script>`)
assertCode(content)
expect(bindings).toStrictEqual({
a: 'setup',
b: 'setup',
c: 'setup',
d: 'setup',
e: 'setup',
f: 'setup'
})
})
test('export function x() {}', () => {
const { content, bindings } = compile(
`<script setup>export function x(){}</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup'
})
})
test('export class X() {}', () => {
const { content, bindings } = compile(
`<script setup>export class X {}</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
X: 'setup'
})
})
test('export { x }', () => {
const { content, bindings } = compile(
`<script setup>
const x = 1
const y = 2
export { x, y }
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup',
y: 'setup'
})
})
test(`export { x } from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export { x, y } from './x'
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup',
y: 'setup'
})
})
test(`export default from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export default from './x'
</script>`,
{
babelParserPlugins: ['exportDefaultFrom']
}
)
assertCode(content)
expect(bindings).toStrictEqual({})
})
test(`export { x as default }`, () => {
const { content, bindings } = compile(
`<script setup>
import x from './x'
const y = 1
export { x as default, y }
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
test(`export { x as default } from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export { x as default, y } from './x'
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
test(`export * from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export * from './x'
export const y = 1
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
// in this case we cannot extract bindings from ./x so it falls back
// to runtime proxy dispatching
})
})
test('export default in <script setup>', () => {
const { content, bindings } = compile(
`<script setup>
export default {
props: ['foo']
}
export const y = 1
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
})
describe('<script setup lang="ts">', () => {
test('hoist type declarations', () => {
const { content, bindings } = compile(`
<script setup lang="ts">
export interface Foo {}
type Bar = {}
export const a = 1
</script>`)
assertCode(content)
expect(bindings).toStrictEqual({ a: 'setup' })
})
test('extract props', () => {
const { content } = compile(`
<script setup="myProps" lang="ts">
interface Test {}
type Alias = number[]
declare const myProps: {
string: string
number: number
boolean: boolean
object: object
objectLiteral: { a: number }
fn: (n: number) => void
functionRef: Function
objectRef: Object
array: string[]
arrayRef: Array<any>
tuple: [number, number]
set: Set<string>
literal: 'foo'
optional?: any
recordRef: Record<string, null>
interface: Test
alias: Alias
union: string | number
literalUnion: 'foo' | 'bar'
literalUnionMixed: 'foo' | 1 | boolean
intersection: Test & {}
}
</script>`)
assertCode(content)
expect(content).toMatch(`string: { type: String, required: true }`)
expect(content).toMatch(`number: { type: Number, required: true }`)
expect(content).toMatch(`boolean: { type: Boolean, required: true }`)
expect(content).toMatch(`object: { type: Object, required: true }`)
expect(content).toMatch(`objectLiteral: { type: Object, required: true }`)
expect(content).toMatch(`fn: { type: Function, required: true }`)
expect(content).toMatch(`functionRef: { type: Function, required: true }`)
expect(content).toMatch(`objectRef: { type: Object, required: true }`)
expect(content).toMatch(`array: { type: Array, required: true }`)
expect(content).toMatch(`arrayRef: { type: Array, required: true }`)
expect(content).toMatch(`tuple: { type: Array, required: true }`)
expect(content).toMatch(`set: { type: Set, required: true }`)
expect(content).toMatch(`literal: { type: String, required: true }`)
expect(content).toMatch(`optional: { type: null, required: false }`)
expect(content).toMatch(`recordRef: { type: Object, required: true }`)
expect(content).toMatch(`interface: { type: Object, required: true }`)
expect(content).toMatch(`alias: { type: Array, required: true }`)
expect(content).toMatch(
`union: { type: [String, Number], required: true }`
)
expect(content).toMatch(
`literalUnion: { type: [String, String], required: true }`
)
expect(content).toMatch(
`literalUnionMixed: { type: [String, Number, Boolean], required: true }`
)
expect(content).toMatch(`intersection: { type: Object, required: true }`)
})
test('extract emits', () => {
const { content } = compile(`
<script setup="_, { emit: myEmit }" lang="ts">
declare function myEmit(e: 'foo' | 'bar'): void
declare function myEmit(e: 'baz', id: number): void
</script>
`)
assertCode(content)
expect(content).toMatch(
`declare function __emit__(e: 'foo' | 'bar'): void`
)
expect(content).toMatch(
`declare function __emit__(e: 'baz', id: number): void`
)
expect(content).toMatch(
`emits: ["foo", "bar", "baz"] as unknown as undefined`
)
})
})
describe('CSS vars injection', () => {
test('<script> w/ no default export', () => {
assertCode(
compile(
`<script>const a = 1</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('<script> w/ default export', () => {
assertCode(
compile(
`<script>export default { setup() {} }</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('<script> w/ default export in strings/comments', () => {
assertCode(
compile(
`<script>
// export default {}
export default {}
</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('w/ <script setup>', () => {
assertCode(
compile(
`<script setup>export const color = 'red'</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
})
describe('async/await detection', () => {
function assertAwaitDetection(code: string, shouldAsync = true) {
const { content } = compile(`<script setup>${code}</script>`)
expect(content).toMatch(
`export ${shouldAsync ? `async ` : ``}function setup`
)
}
test('expression statement', () => {
assertAwaitDetection(`await foo`)
})
test('variable', () => {
assertAwaitDetection(`const a = 1 + (await foo)`)
})
test('export', () => {
assertAwaitDetection(`export const a = 1 + (await foo)`)
})
test('nested statements', () => {
assertAwaitDetection(`if (ok) { await foo } else { await bar }`)
})
test('should ignore await inside functions', () => {
// function declaration
assertAwaitDetection(`export async function foo() { await bar }`, false)
// function expression
assertAwaitDetection(`const foo = async () => { await bar }`, false)
// object method
assertAwaitDetection(`const obj = { async method() { await bar }}`, false)
// class method
assertAwaitDetection(
`const cls = class Foo { async method() { await bar }}`,
false
)
})
})
describe('errors', () => {
test('<script> and <script setup> must have same lang', () => {
expect(
parse(`<script>foo()</script><script setup lang="ts">bar()</script>`)
.errors[0].message
).toMatch(`<script> and <script setup> must have the same language type`)
})
test('export local as default', () => {
expect(
parse(`<script setup>
const bar = 1
export { bar as default }
</script>`).errors[0].message
).toMatch(`Cannot export locally defined variable as default`)
})
test('export default referencing local var', () => {
expect(
parse(`<script setup>
const bar = 1
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).errors[0].message
).toMatch(`cannot reference locally declared variables`)
})
test('export default referencing exports', () => {
expect(
parse(`<script setup>
export const bar = 1
export default {
props: bar
}
</script>`).errors[0].message
).toMatch(`cannot reference locally declared variables`)
})
test('should allow export default referencing scope var', () => {
assertCode(
compile(`<script setup>
const bar = 1
export default {
props: {
foo: {
default: bar => bar + 1
}
}
}
</script>`).content
)
})
test('should allow export default referencing imported binding', () => {
assertCode(
compile(`<script setup>
import { bar } from './bar'
export { bar }
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).content
)
})
test('should allow export default referencing re-exported binding', () => {
assertCode(
compile(`<script setup>
export { bar } from './bar'
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).content
)
})
test('error on duplicated defalut export', () => {
expect(
parse(`
<script>
export default {}
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export default {}
</script>
<script setup>
const x = {}
export { x as default }
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export default {}
</script>
<script setup>
export { x as default } from './y'
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export { x as default } from './y'
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
const x = {}
export { x as default }
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
})
})
})
| packages/compiler-sfc/__tests__/compileScript.spec.ts | 1 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.08842606842517853,
0.006000168155878782,
0.00016351192607544363,
0.0027962499298155308,
0.014722905121743679
] |
{
"id": 0,
"code_window": [
" </script>`).content\n",
" )\n",
" })\n",
"\n",
" test('error on duplicated defalut export', () => {\n",
" expect(\n",
" parse(`\n",
" <script>\n",
" export default {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" test('error on duplicated default export', () => {\n"
],
"file_path": "packages/compiler-sfc/__tests__/compileScript.spec.ts",
"type": "replace",
"edit_start_line_idx": 459
} | import {
createRenderer,
createHydrationRenderer,
warn,
RootRenderFunction,
CreateAppFunction,
Renderer,
HydrationRenderer,
App,
RootHydrateFunction
} from '@vue/runtime-core'
import { nodeOps } from './nodeOps'
import { patchProp, forcePatchProp } from './patchProp'
// Importing from the compiler, will be tree-shaken in prod
import { isFunction, isString, isHTMLTag, isSVGTag, extend } from '@vue/shared'
declare module '@vue/reactivity' {
export interface RefUnwrapBailTypes {
// Note: if updating this, also update `types/refBail.d.ts`.
runtimeDOMBailTypes: Node | Window
}
}
const rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps)
// lazy create the renderer - this makes core renderer logic tree-shakable
// in case the user only imports reactivity utilities from Vue.
let renderer: Renderer<Element> | HydrationRenderer
let enabledHydration = false
function ensureRenderer() {
return renderer || (renderer = createRenderer<Node, Element>(rendererOptions))
}
function ensureHydrationRenderer() {
renderer = enabledHydration
? renderer
: createHydrationRenderer(rendererOptions)
enabledHydration = true
return renderer as HydrationRenderer
}
// use explicit type casts here to avoid import() calls in rolled-up d.ts
export const render = ((...args) => {
ensureRenderer().render(...args)
}) as RootRenderFunction<Element>
export const hydrate = ((...args) => {
ensureHydrationRenderer().hydrate(...args)
}) as RootHydrateFunction
export const createApp = ((...args) => {
const app = ensureRenderer().createApp(...args)
if (__DEV__) {
injectNativeTagCheck(app)
}
const { mount } = app
app.mount = (containerOrSelector: Element | string): any => {
const container = normalizeContainer(containerOrSelector)
if (!container) return
const component = app._component
if (!isFunction(component) && !component.render && !component.template) {
component.template = container.innerHTML
}
// clear content before mounting
container.innerHTML = ''
const proxy = mount(container)
container.removeAttribute('v-cloak')
return proxy
}
return app
}) as CreateAppFunction<Element>
export const createSSRApp = ((...args) => {
const app = ensureHydrationRenderer().createApp(...args)
if (__DEV__) {
injectNativeTagCheck(app)
}
const { mount } = app
app.mount = (containerOrSelector: Element | string): any => {
const container = normalizeContainer(containerOrSelector)
if (container) {
return mount(container, true)
}
}
return app
}) as CreateAppFunction<Element>
function injectNativeTagCheck(app: App) {
// Inject `isNativeTag`
// this is used for component name validation (dev only)
Object.defineProperty(app.config, 'isNativeTag', {
value: (tag: string) => isHTMLTag(tag) || isSVGTag(tag),
writable: false
})
}
function normalizeContainer(container: Element | string): Element | null {
if (isString(container)) {
const res = document.querySelector(container)
if (__DEV__ && !res) {
warn(`Failed to mount app: mount target selector returned null.`)
}
return res
}
return container
}
// SFC CSS utilities
export { useCssModule } from './helpers/useCssModule'
export { useCssVars } from './helpers/useCssVars'
// DOM-only components
export { Transition, TransitionProps } from './components/Transition'
export {
TransitionGroup,
TransitionGroupProps
} from './components/TransitionGroup'
// **Internal** DOM-only runtime directive helpers
export {
vModelText,
vModelCheckbox,
vModelRadio,
vModelSelect,
vModelDynamic
} from './directives/vModel'
export { withModifiers, withKeys } from './directives/vOn'
export { vShow } from './directives/vShow'
// re-export everything from core
// h, Component, reactivity API, nextTick, flags & types
export * from '@vue/runtime-core'
| packages/runtime-dom/src/index.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.0003374468651600182,
0.00018116153660230339,
0.00016145540575962514,
0.00016756691911723465,
0.000042445626604603603
] |
{
"id": 0,
"code_window": [
" </script>`).content\n",
" )\n",
" })\n",
"\n",
" test('error on duplicated defalut export', () => {\n",
" expect(\n",
" parse(`\n",
" <script>\n",
" export default {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" test('error on duplicated default export', () => {\n"
],
"file_path": "packages/compiler-sfc/__tests__/compileScript.spec.ts",
"type": "replace",
"edit_start_line_idx": 459
} | import * as m from 'monaco-editor'
import { compile, CompilerError, CompilerOptions } from '@vue/compiler-dom'
import { compile as ssrCompile } from '@vue/compiler-ssr'
import { compilerOptions, initOptions, ssrMode } from './options'
import { watchEffect } from '@vue/runtime-dom'
import { SourceMapConsumer } from 'source-map'
import theme from './theme'
declare global {
interface Window {
monaco: typeof m
_deps: any
init: () => void
}
}
interface PersistedState {
src: string
ssr: boolean
options: CompilerOptions
}
const sharedEditorOptions: m.editor.IStandaloneEditorConstructionOptions = {
fontSize: 14,
scrollBeyondLastLine: false,
renderWhitespace: 'selection',
minimap: {
enabled: false
}
}
window.init = () => {
const monaco = window.monaco
monaco.editor.defineTheme('my-theme', theme)
monaco.editor.setTheme('my-theme')
const persistedState: PersistedState = JSON.parse(
decodeURIComponent(window.location.hash.slice(1)) ||
localStorage.getItem('state') ||
`{}`
)
ssrMode.value = persistedState.ssr
Object.assign(compilerOptions, persistedState.options)
let lastSuccessfulCode: string
let lastSuccessfulMap: SourceMapConsumer | undefined = undefined
function compileCode(source: string): string {
console.clear()
try {
const errors: CompilerError[] = []
const compileFn = ssrMode.value ? ssrCompile : compile
const start = performance.now()
const { code, ast, map } = compileFn(source, {
filename: 'template.vue',
...compilerOptions,
sourceMap: true,
onError: err => {
errors.push(err)
}
})
console.log(`Compiled in ${(performance.now() - start).toFixed(2)}ms.`)
monaco.editor.setModelMarkers(
editor.getModel()!,
`@vue/compiler-dom`,
errors.filter(e => e.loc).map(formatError)
)
console.log(`AST: `, ast)
lastSuccessfulCode = code + `\n\n// Check the console for the AST`
lastSuccessfulMap = new SourceMapConsumer(map!)
lastSuccessfulMap!.computeColumnSpans()
} catch (e) {
lastSuccessfulCode = `/* ERROR: ${
e.message
} (see console for more info) */`
console.error(e)
}
return lastSuccessfulCode
}
function formatError(err: CompilerError) {
const loc = err.loc!
return {
severity: monaco.MarkerSeverity.Error,
startLineNumber: loc.start.line,
startColumn: loc.start.column,
endLineNumber: loc.end.line,
endColumn: loc.end.column,
message: `Vue template compilation error: ${err.message}`,
code: String(err.code)
}
}
function reCompile() {
const src = editor.getValue()
// every time we re-compile, persist current state
const state = JSON.stringify({
src,
ssr: ssrMode.value,
options: compilerOptions
} as PersistedState)
localStorage.setItem('state', state)
window.location.hash = encodeURIComponent(state)
const res = compileCode(src)
if (res) {
output.setValue(res)
}
}
const editor = monaco.editor.create(document.getElementById('source')!, {
value: persistedState.src || `<div>Hello World!</div>`,
language: 'html',
...sharedEditorOptions,
wordWrap: 'bounded'
})
editor.getModel()!.updateOptions({
tabSize: 2
})
const output = monaco.editor.create(document.getElementById('output')!, {
value: '',
language: 'javascript',
readOnly: true,
...sharedEditorOptions
})
output.getModel()!.updateOptions({
tabSize: 2
})
// handle resize
window.addEventListener('resize', () => {
editor.layout()
output.layout()
})
// update compile output when input changes
editor.onDidChangeModelContent(debounce(reCompile))
// highlight output code
let prevOutputDecos: string[] = []
function clearOutputDecos() {
prevOutputDecos = output.deltaDecorations(prevOutputDecos, [])
}
editor.onDidChangeCursorPosition(
debounce(e => {
clearEditorDecos()
if (lastSuccessfulMap) {
const pos = lastSuccessfulMap.generatedPositionFor({
source: 'template.vue',
line: e.position.lineNumber,
column: e.position.column - 1
})
if (pos.line != null && pos.column != null) {
prevOutputDecos = output.deltaDecorations(prevOutputDecos, [
{
range: new monaco.Range(
pos.line,
pos.column + 1,
pos.line,
pos.lastColumn ? pos.lastColumn + 2 : pos.column + 2
),
options: {
inlineClassName: `highlight`
}
}
])
output.revealPositionInCenter({
lineNumber: pos.line,
column: pos.column + 1
})
} else {
clearOutputDecos()
}
}
}, 100)
)
let previousEditorDecos: string[] = []
function clearEditorDecos() {
previousEditorDecos = editor.deltaDecorations(previousEditorDecos, [])
}
output.onDidChangeCursorPosition(
debounce(e => {
clearOutputDecos()
if (lastSuccessfulMap) {
const pos = lastSuccessfulMap.originalPositionFor({
line: e.position.lineNumber,
column: e.position.column - 1
})
if (
pos.line != null &&
pos.column != null &&
!// ignore mock location
(pos.line === 1 && pos.column === 0)
) {
const translatedPos = {
column: pos.column + 1,
lineNumber: pos.line
}
previousEditorDecos = editor.deltaDecorations(previousEditorDecos, [
{
range: new monaco.Range(
pos.line,
pos.column + 1,
pos.line,
pos.column + 1
),
options: {
isWholeLine: true,
className: `highlight`
}
}
])
editor.revealPositionInCenter(translatedPos)
} else {
clearEditorDecos()
}
}
}, 100)
)
initOptions()
watchEffect(reCompile)
}
function debounce<T extends (...args: any[]) => any>(
fn: T,
delay: number = 300
): T {
let prevTimer: number | null = null
return ((...args: any[]) => {
if (prevTimer) {
clearTimeout(prevTimer)
}
prevTimer = window.setTimeout(() => {
fn(...args)
prevTimer = null
}, delay)
}) as any
}
| packages/template-explorer/src/index.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.0001772262476151809,
0.00017236810526810586,
0.0001653527724556625,
0.00017232343088835478,
0.0000030198782496881904
] |
{
"id": 0,
"code_window": [
" </script>`).content\n",
" )\n",
" })\n",
"\n",
" test('error on duplicated defalut export', () => {\n",
" expect(\n",
" parse(`\n",
" <script>\n",
" export default {}\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" test('error on duplicated default export', () => {\n"
],
"file_path": "packages/compiler-sfc/__tests__/compileScript.spec.ts",
"type": "replace",
"edit_start_line_idx": 459
} | import {
ObjectDirective,
VNode,
DirectiveHook,
DirectiveBinding,
warn
} from '@vue/runtime-core'
import { addEventListener } from '../modules/events'
import {
isArray,
looseEqual,
looseIndexOf,
invokeArrayFns,
toNumber
} from '@vue/shared'
type AssignerFn = (value: any) => void
const getModelAssigner = (vnode: VNode): AssignerFn => {
const fn = vnode.props!['onUpdate:modelValue']
return isArray(fn) ? value => invokeArrayFns(fn, value) : fn
}
function onCompositionStart(e: Event) {
;(e.target as any).composing = true
}
function onCompositionEnd(e: Event) {
const target = e.target as any
if (target.composing) {
target.composing = false
trigger(target, 'input')
}
}
function trigger(el: HTMLElement, type: string) {
const e = document.createEvent('HTMLEvents')
e.initEvent(type, true, true)
el.dispatchEvent(e)
}
type ModelDirective<T> = ObjectDirective<T & { _assign: AssignerFn }>
// We are exporting the v-model runtime directly as vnode hooks so that it can
// be tree-shaken in case v-model is never used.
export const vModelText: ModelDirective<
HTMLInputElement | HTMLTextAreaElement
> = {
beforeMount(el, { value, modifiers: { lazy, trim, number } }, vnode) {
el.value = value == null ? '' : value
el._assign = getModelAssigner(vnode)
const castToNumber = number || el.type === 'number'
addEventListener(el, lazy ? 'change' : 'input', e => {
if ((e.target as any).composing) return
let domValue: string | number = el.value
if (trim) {
domValue = domValue.trim()
} else if (castToNumber) {
domValue = toNumber(domValue)
}
el._assign(domValue)
})
if (trim) {
addEventListener(el, 'change', () => {
el.value = el.value.trim()
})
}
if (!lazy) {
addEventListener(el, 'compositionstart', onCompositionStart)
addEventListener(el, 'compositionend', onCompositionEnd)
// Safari < 10.2 & UIWebView doesn't fire compositionend when
// switching focus before confirming composition choice
// this also fixes the issue where some browsers e.g. iOS Chrome
// fires "change" instead of "input" on autocomplete.
addEventListener(el, 'change', onCompositionEnd)
}
},
beforeUpdate(el, { value, modifiers: { trim, number } }, vnode) {
el._assign = getModelAssigner(vnode)
if (document.activeElement === el) {
if (trim && el.value.trim() === value) {
return
}
if ((number || el.type === 'number') && toNumber(el.value) === value) {
return
}
}
el.value = value == null ? '' : value
}
}
export const vModelCheckbox: ModelDirective<HTMLInputElement> = {
beforeMount(el, binding, vnode) {
setChecked(el, binding, vnode)
el._assign = getModelAssigner(vnode)
addEventListener(el, 'change', () => {
const modelValue = (el as any)._modelValue
const elementValue = getValue(el)
const checked = el.checked
const assign = el._assign
if (isArray(modelValue)) {
const index = looseIndexOf(modelValue, elementValue)
const found = index !== -1
if (checked && !found) {
assign(modelValue.concat(elementValue))
} else if (!checked && found) {
const filtered = [...modelValue]
filtered.splice(index, 1)
assign(filtered)
}
} else {
assign(getCheckboxValue(el, checked))
}
})
},
beforeUpdate(el, binding, vnode) {
el._assign = getModelAssigner(vnode)
setChecked(el, binding, vnode)
}
}
function setChecked(
el: HTMLInputElement,
{ value, oldValue }: DirectiveBinding,
vnode: VNode
) {
// store the v-model value on the element so it can be accessed by the
// change listener.
;(el as any)._modelValue = value
if (isArray(value)) {
el.checked = looseIndexOf(value, vnode.props!.value) > -1
} else if (value !== oldValue) {
el.checked = looseEqual(value, getCheckboxValue(el, true))
}
}
export const vModelRadio: ModelDirective<HTMLInputElement> = {
beforeMount(el, { value }, vnode) {
el.checked = looseEqual(value, vnode.props!.value)
el._assign = getModelAssigner(vnode)
addEventListener(el, 'change', () => {
el._assign(getValue(el))
})
},
beforeUpdate(el, { value, oldValue }, vnode) {
el._assign = getModelAssigner(vnode)
if (value !== oldValue) {
el.checked = looseEqual(value, vnode.props!.value)
}
}
}
export const vModelSelect: ModelDirective<HTMLSelectElement> = {
// use mounted & updated because <select> relies on its children <option>s.
mounted(el, { value }, vnode) {
setSelected(el, value)
el._assign = getModelAssigner(vnode)
addEventListener(el, 'change', () => {
const selectedVal = Array.prototype.filter
.call(el.options, (o: HTMLOptionElement) => o.selected)
.map(getValue)
el._assign(el.multiple ? selectedVal : selectedVal[0])
})
},
beforeUpdate(el, _binding, vnode) {
el._assign = getModelAssigner(vnode)
},
updated(el, { value }) {
setSelected(el, value)
}
}
function setSelected(el: HTMLSelectElement, value: any) {
const isMultiple = el.multiple
if (isMultiple && !isArray(value)) {
__DEV__ &&
warn(
`<select multiple v-model> expects an Array value for its binding, ` +
`but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
)
return
}
for (let i = 0, l = el.options.length; i < l; i++) {
const option = el.options[i]
const optionValue = getValue(option)
if (isMultiple) {
option.selected = looseIndexOf(value, optionValue) > -1
} else {
if (looseEqual(getValue(option), value)) {
el.selectedIndex = i
return
}
}
}
if (!isMultiple) {
el.selectedIndex = -1
}
}
// retrieve raw value set via :value bindings
function getValue(el: HTMLOptionElement | HTMLInputElement) {
return '_value' in el ? (el as any)._value : el.value
}
// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings
function getCheckboxValue(
el: HTMLInputElement & { _trueValue?: any; _falseValue?: any },
checked: boolean
) {
const key = checked ? '_trueValue' : '_falseValue'
return key in el ? el[key] : checked
}
export const vModelDynamic: ObjectDirective<
HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement
> = {
beforeMount(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'beforeMount')
},
mounted(el, binding, vnode) {
callModelHook(el, binding, vnode, null, 'mounted')
},
beforeUpdate(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate')
},
updated(el, binding, vnode, prevVNode) {
callModelHook(el, binding, vnode, prevVNode, 'updated')
}
}
function callModelHook(
el: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement,
binding: DirectiveBinding,
vnode: VNode,
prevVNode: VNode | null,
hook: 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated'
) {
let modelToUse: ObjectDirective
switch (el.tagName) {
case 'SELECT':
modelToUse = vModelSelect
break
case 'TEXTAREA':
modelToUse = vModelText
break
default:
switch (el.type) {
case 'checkbox':
modelToUse = vModelCheckbox
break
case 'radio':
modelToUse = vModelRadio
break
default:
modelToUse = vModelText
}
}
const fn = modelToUse[hook] as DirectiveHook
fn && fn(el, binding, vnode, prevVNode)
}
// SSR vnode transforms
if (__NODE_JS__) {
vModelText.getSSRProps = ({ value }) => ({ value })
vModelRadio.getSSRProps = ({ value }, vnode) => {
if (vnode.props && looseEqual(vnode.props.value, value)) {
return { checked: true }
}
}
vModelCheckbox.getSSRProps = ({ value }, vnode) => {
if (isArray(value)) {
if (vnode.props && looseIndexOf(value, vnode.props.value) > -1) {
return { checked: true }
}
} else if (value) {
return { checked: true }
}
}
}
| packages/runtime-dom/src/directives/vModel.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.0001775166456354782,
0.00017245800700038671,
0.00016420909378211945,
0.00017227036005351692,
0.0000036017486308992375
] |
{
"id": 1,
"code_window": [
"export function compileScript(\n",
" sfc: SFCDescriptor,\n",
" options: SFCScriptCompileOptions = {}\n",
"): SFCScriptBlock {\n",
" if (__DEV__ && !__TEST__ && !hasWarned) {\n",
" hasWarned = true\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
" const { script, scriptSetup, styles, source, filename } = sfc\n",
"\n",
" if (__DEV__ && !__TEST__ && !hasWarned && scriptSetup) {\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 42
} | import MagicString from 'magic-string'
import { BindingMetadata } from '@vue/compiler-core'
import { SFCDescriptor, SFCScriptBlock } from './parse'
import { parse, ParserPlugin } from '@babel/parser'
import { babelParserDefautPlugins, generateCodeFrame } from '@vue/shared'
import {
Node,
Declaration,
ObjectPattern,
ArrayPattern,
Identifier,
ExpressionStatement,
ArrowFunctionExpression,
ExportSpecifier,
Function as FunctionNode,
TSType,
TSTypeLiteral,
TSFunctionType,
TSDeclareFunction
} from '@babel/types'
import { walk } from 'estree-walker'
import { RawSourceMap } from 'source-map'
import { genCssVarsCode, injectCssVarsCalls } from './genCssVars'
export interface SFCScriptCompileOptions {
/**
* https://babeljs.io/docs/en/babel-parser#plugins
*/
babelParserPlugins?: ParserPlugin[]
}
let hasWarned = false
/**
* Compile `<script setup>`
* It requires the whole SFC descriptor because we need to handle and merge
* normal `<script>` + `<script setup>` if both are present.
*/
export function compileScript(
sfc: SFCDescriptor,
options: SFCScriptCompileOptions = {}
): SFCScriptBlock {
if (__DEV__ && !__TEST__ && !hasWarned) {
hasWarned = true
console.log(
`\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\n` +
`Follow https://github.com/vuejs/rfcs/pull/182 for its status.\n`
)
}
const { script, scriptSetup, styles, source, filename } = sfc
const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')
const isTS =
(script && script.lang === 'ts') ||
(scriptSetup && scriptSetup.lang === 'ts')
const plugins: ParserPlugin[] = [
...(options.babelParserPlugins || []),
...babelParserDefautPlugins,
...(isTS ? (['typescript'] as const) : [])
]
if (!scriptSetup) {
if (!script) {
throw new Error(`SFC contains no <script> tags.`)
}
return {
...script,
content: hasCssVars ? injectCssVarsCalls(sfc, plugins) : script.content,
bindings: analyzeScriptBindings(script)
}
}
if (script && script.lang !== scriptSetup.lang) {
throw new Error(
`<script> and <script setup> must have the same language type.`
)
}
const defaultTempVar = `__default__`
const bindings: BindingMetadata = {}
const imports: Record<string, string> = {}
const setupScopeVars: Record<string, boolean> = {}
const setupExports: Record<string, boolean> = {}
let exportAllIndex = 0
let defaultExport: Node | undefined
let needDefaultExportRefCheck = false
let hasAwait = false
const checkDuplicateDefaultExport = (node: Node) => {
if (defaultExport) {
// <script> already has export default
throw new Error(
`Default export is already declared in normal <script>.\n\n` +
generateCodeFrame(
source,
node.start! + startOffset,
node.start! + startOffset + `export default`.length
)
)
}
}
const s = new MagicString(source)
const startOffset = scriptSetup.loc.start.offset
const endOffset = scriptSetup.loc.end.offset
const scriptStartOffset = script && script.loc.start.offset
const scriptEndOffset = script && script.loc.end.offset
// 1. process normal <script> first if it exists
if (script) {
// import dedupe between <script> and <script setup>
const scriptAST = parse(script.content, {
plugins,
sourceType: 'module'
}).program.body
for (const node of scriptAST) {
if (node.type === 'ImportDeclaration') {
// record imports for dedupe
for (const {
local: { name }
} of node.specifiers) {
imports[name] = node.source.value
}
} else if (node.type === 'ExportDefaultDeclaration') {
// export default
defaultExport = node
const start = node.start! + scriptStartOffset!
s.overwrite(
start,
start + `export default`.length,
`const ${defaultTempVar} =`
)
} else if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
const defaultSpecifier = node.specifiers.find(
s => s.exported.name === 'default'
) as ExportSpecifier
if (defaultSpecifier) {
defaultExport = node
// 1. remove specifier
if (node.specifiers.length > 1) {
s.remove(
defaultSpecifier.start! + scriptStartOffset!,
defaultSpecifier.end! + scriptStartOffset!
)
} else {
s.remove(
node.start! + scriptStartOffset!,
node.end! + scriptStartOffset!
)
}
if (node.source) {
// export { x as default } from './x'
// rewrite to `import { x as __default__ } from './x'` and
// add to top
s.prepend(
`import { ${
defaultSpecifier.local.name
} as ${defaultTempVar} } from '${node.source.value}'\n`
)
} else {
// export { x as default }
// rewrite to `const __default__ = x` and move to end
s.append(
`\nconst ${defaultTempVar} = ${defaultSpecifier.local.name}\n`
)
}
}
}
}
}
// 2. check <script setup="xxx"> function signature
const setupValue = scriptSetup.setup
const hasExplicitSignature = typeof setupValue === 'string'
let propsVar: string | undefined
let emitVar: string | undefined
let slotsVar: string | undefined
let attrsVar: string | undefined
let propsType = `{}`
let emitType = `(e: string, ...args: any[]) => void`
let slotsType = `__Slots__`
let attrsType = `Record<string, any>`
let propsASTNode
let setupCtxASTNode
// props/emits declared via types
const typeDeclaredProps: Record<string, PropTypeData> = {}
const typeDeclaredEmits: Set<string> = new Set()
// record declared types for runtime props type generation
const declaredTypes: Record<string, string[]> = {}
if (isTS && hasExplicitSignature) {
// <script setup="xxx" lang="ts">
// parse the signature to extract the props/emit variables the user wants
// we need them to find corresponding type declarations.
const signatureAST = parse(`(${setupValue})=>{}`, { plugins }).program
.body[0]
const params = ((signatureAST as ExpressionStatement)
.expression as ArrowFunctionExpression).params
if (params[0] && params[0].type === 'Identifier') {
propsASTNode = params[0]
propsVar = propsASTNode.name
}
if (params[1] && params[1].type === 'ObjectPattern') {
setupCtxASTNode = params[1]
for (const p of params[1].properties) {
if (
p.type === 'ObjectProperty' &&
p.key.type === 'Identifier' &&
p.value.type === 'Identifier'
) {
if (p.key.name === 'emit') {
emitVar = p.value.name
} else if (p.key.name === 'slots') {
slotsVar = p.value.name
} else if (p.key.name === 'attrs') {
attrsVar = p.value.name
}
}
}
}
}
// 3. parse <script setup> and walk over top level statements
for (const node of parse(scriptSetup.content, {
plugins: [
...plugins,
// allow top level await but only inside <script setup>
'topLevelAwait'
],
sourceType: 'module'
}).program.body) {
const start = node.start! + startOffset
let end = node.end! + startOffset
// import or type declarations: move to top
// locate the end of whitespace between this statement and the next
while (end <= source.length) {
if (!/\s/.test(source.charAt(end))) {
break
}
end++
}
if (node.type === 'ImportDeclaration') {
// import declarations are moved to top
s.move(start, end, 0)
// dedupe imports
let prev
let removed = 0
for (const specifier of node.specifiers) {
if (imports[specifier.local.name]) {
// already imported in <script setup>, dedupe
removed++
s.remove(
prev ? prev.end! + startOffset : specifier.start! + startOffset,
specifier.end! + startOffset
)
} else {
imports[specifier.local.name] = node.source.value
}
prev = specifier
}
if (removed === node.specifiers.length) {
s.remove(node.start! + startOffset, node.end! + startOffset)
}
}
if (node.type === 'ExportNamedDeclaration' && node.exportKind !== 'type') {
// named exports
if (node.declaration) {
// variable/function/class declarations.
// remove leading `export ` keyword
s.remove(start, start + 7)
walkDeclaration(node.declaration, setupExports)
}
if (node.specifiers.length) {
// named export with specifiers
if (node.source) {
// export { x } from './x'
// change it to import and move to top
s.overwrite(start, start + 6, 'import')
s.move(start, end, 0)
} else {
// export { x }
s.remove(start, end)
}
for (const specifier of node.specifiers) {
if (specifier.type === 'ExportDefaultSpecifier') {
// export default from './x'
// rewrite to `import __default__ from './x'`
checkDuplicateDefaultExport(node)
defaultExport = node
s.overwrite(
specifier.exported.start! + startOffset,
specifier.exported.start! + startOffset + 7,
defaultTempVar
)
} else if (specifier.type === 'ExportSpecifier') {
if (specifier.exported.name === 'default') {
checkDuplicateDefaultExport(node)
defaultExport = node
// 1. remove specifier
if (node.specifiers.length > 1) {
// removing the default specifier from a list of specifiers.
// look ahead until we reach the first non , or whitespace char.
let end = specifier.end! + startOffset
while (end < source.length) {
if (/[^,\s]/.test(source.charAt(end))) {
break
}
end++
}
s.remove(specifier.start! + startOffset, end)
} else {
s.remove(node.start! + startOffset!, node.end! + startOffset!)
}
if (!node.source) {
// export { x as default, ... }
const local = specifier.local.name
if (setupScopeVars[local] || setupExports[local]) {
throw new Error(
`Cannot export locally defined variable as default in <script setup>.\n` +
`Default export must be an object literal with no reference to local scope.\n` +
generateCodeFrame(
source,
specifier.start! + startOffset,
specifier.end! + startOffset
)
)
}
// rewrite to `const __default__ = x` and move to end
s.append(`\nconst ${defaultTempVar} = ${local}\n`)
} else {
// export { x as default } from './x'
// rewrite to `import { x as __default__ } from './x'` and
// add to top
s.prepend(
`import { ${
specifier.local.name
} as ${defaultTempVar} } from '${node.source.value}'\n`
)
}
} else {
setupExports[specifier.exported.name] = true
if (node.source) {
imports[specifier.exported.name] = node.source.value
}
}
}
}
}
}
if (node.type === 'ExportAllDeclaration') {
// export * from './x'
s.overwrite(
start,
node.source.start! + startOffset,
`import * as __export_all_${exportAllIndex++}__ from `
)
s.move(start, end, 0)
}
if (node.type === 'ExportDefaultDeclaration') {
checkDuplicateDefaultExport(node)
// export default {} inside <script setup>
// this should be kept in module scope - move it to the end
s.move(start, end, source.length)
s.overwrite(start, start + `export default`.length, `const __default__ =`)
// save it for analysis when all imports and variable declarations have
// been recorded
defaultExport = node
needDefaultExportRefCheck = true
}
if (
(node.type === 'VariableDeclaration' ||
node.type === 'FunctionDeclaration' ||
node.type === 'ClassDeclaration') &&
!node.declare
) {
walkDeclaration(node, setupScopeVars)
}
// Type declarations
if (node.type === 'VariableDeclaration' && node.declare) {
s.remove(start, end)
for (const { id } of node.declarations) {
if (id.type === 'Identifier') {
if (
id.typeAnnotation &&
id.typeAnnotation.type === 'TSTypeAnnotation'
) {
const typeNode = id.typeAnnotation.typeAnnotation
const typeString = source.slice(
typeNode.start! + startOffset,
typeNode.end! + startOffset
)
if (typeNode.type === 'TSTypeLiteral') {
if (id.name === propsVar) {
propsType = typeString
extractRuntimeProps(typeNode, typeDeclaredProps, declaredTypes)
} else if (id.name === slotsVar) {
slotsType = typeString
} else if (id.name === attrsVar) {
attrsType = typeString
}
} else if (
id.name === emitVar &&
typeNode.type === 'TSFunctionType'
) {
emitType = typeString
extractRuntimeEmits(typeNode, typeDeclaredEmits)
}
}
}
}
}
if (
node.type === 'TSDeclareFunction' &&
node.id &&
node.id.name === emitVar
) {
const index = node.id.start! + startOffset
s.overwrite(index, index + emitVar.length, '__emit__')
emitType = `typeof __emit__`
extractRuntimeEmits(node, typeDeclaredEmits)
}
// move all type declarations to outer scope
if (
node.type.startsWith('TS') ||
(node.type === 'ExportNamedDeclaration' && node.exportKind === 'type')
) {
recordType(node, declaredTypes)
s.move(start, end, 0)
}
// walk statements & named exports / variable declarations for top level
// await
if (
node.type === 'VariableDeclaration' ||
(node.type === 'ExportNamedDeclaration' &&
node.declaration &&
node.declaration.type === 'VariableDeclaration') ||
node.type.endsWith('Statement')
) {
;(walk as any)(node, {
enter(node: Node) {
if (isFunction(node)) {
this.skip()
}
if (node.type === 'AwaitExpression') {
hasAwait = true
}
}
})
}
}
// 4. check default export to make sure it doesn't reference setup scope
// variables
if (needDefaultExportRefCheck) {
checkDefaultExport(
defaultExport!,
setupScopeVars,
imports,
setupExports,
source,
startOffset
)
}
// 5. remove non-script content
if (script) {
if (startOffset < scriptStartOffset!) {
// <script setup> before <script>
s.remove(endOffset, scriptStartOffset!)
s.remove(scriptEndOffset!, source.length)
} else {
// <script> before <script setup>
s.remove(0, scriptStartOffset!)
s.remove(scriptEndOffset!, startOffset)
s.remove(endOffset, source.length)
}
} else {
// only <script setup>
s.remove(0, startOffset)
s.remove(endOffset, source.length)
}
// 5. finalize setup argument signature.
let args = ``
if (isTS) {
if (slotsType === '__Slots__') {
s.prepend(`import { Slots as __Slots__ } from 'vue'\n`)
}
const ctxType = `{
emit: ${emitType},
slots: ${slotsType},
attrs: ${attrsType}
}`
if (hasExplicitSignature) {
// inject types to user signature
args = setupValue as string
const ss = new MagicString(args)
if (propsASTNode) {
// compensate for () wraper offset
ss.appendRight(propsASTNode.end! - 1, `: ${propsType}`)
}
if (setupCtxASTNode) {
ss.appendRight(setupCtxASTNode.end! - 1!, `: ${ctxType}`)
}
args = ss.toString()
}
} else {
args = hasExplicitSignature ? (setupValue as string) : ``
}
// 6. wrap setup code with function.
// export the content of <script setup> as a named export, `setup`.
// this allows `import { setup } from '*.vue'` for testing purposes.
s.prependLeft(
startOffset,
`\nexport ${hasAwait ? `async ` : ``}function setup(${args}) {\n`
)
// generate return statement
let returned = `{ ${Object.keys(setupExports).join(', ')} }`
// handle `export * from`. We need to call `toRefs` on the imported module
// object before merging.
if (exportAllIndex > 0) {
s.prepend(`import { toRefs as __toRefs__ } from 'vue'\n`)
for (let i = 0; i < exportAllIndex; i++) {
returned += `,\n __toRefs__(__export_all_${i}__)`
}
returned = `Object.assign(\n ${returned}\n)`
}
// inject `useCSSVars` calls
if (hasCssVars) {
s.prepend(`import { useCSSVars as __useCSSVars__ } from 'vue'\n`)
for (const style of styles) {
const vars = style.attrs.vars
if (typeof vars === 'string') {
s.prependRight(
endOffset,
`\n${genCssVarsCode(vars, !!style.scoped, setupExports)}`
)
}
}
}
s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`)
// 7. finalize default export
if (isTS) {
// for TS, make sure the exported type is still valid type with
// correct props information
s.prepend(`import { defineComponent as __define__ } from 'vue'\n`)
// we have to use object spread for types to be merged properly
// user's TS setting should compile it down to proper targets
const def = defaultExport ? `\n ...${defaultTempVar},` : ``
const runtimeProps = genRuntimeProps(typeDeclaredProps)
const runtimeEmits = genRuntimeEmits(typeDeclaredEmits)
s.append(
`export default __define__({${def}${runtimeProps}${runtimeEmits}\n setup\n})`
)
} else {
if (defaultExport) {
s.append(
`${defaultTempVar}.setup = setup\nexport default ${defaultTempVar}`
)
} else {
s.append(`export default { setup }`)
}
}
// 8. expose bindings for template compiler optimization
if (script) {
Object.assign(bindings, analyzeScriptBindings(script))
}
Object.keys(setupExports).forEach(key => {
bindings[key] = 'setup'
})
Object.keys(typeDeclaredProps).forEach(key => {
bindings[key] = 'props'
})
// TODO analyze props if user declared props via `export default {}` inside
// <script setup>
s.trim()
return {
...scriptSetup,
bindings,
content: s.toString(),
map: (s.generateMap({
source: filename,
hires: true,
includeContent: true
}) as unknown) as RawSourceMap
}
}
function walkDeclaration(node: Declaration, bindings: Record<string, boolean>) {
if (node.type === 'VariableDeclaration') {
// export const foo = ...
for (const { id } of node.declarations) {
if (id.type === 'Identifier') {
bindings[id.name] = true
} else if (id.type === 'ObjectPattern') {
walkObjectPattern(id, bindings)
} else if (id.type === 'ArrayPattern') {
walkArrayPattern(id, bindings)
}
}
} else if (
node.type === 'FunctionDeclaration' ||
node.type === 'ClassDeclaration'
) {
// export function foo() {} / export class Foo {}
// export declarations must be named.
bindings[node.id!.name] = true
}
}
function walkObjectPattern(
node: ObjectPattern,
bindings: Record<string, boolean>
) {
for (const p of node.properties) {
if (p.type === 'ObjectProperty') {
// key can only be Identifier in ObjectPattern
if (p.key.type === 'Identifier') {
if (p.key === p.value) {
// const { x } = ...
bindings[p.key.name] = true
} else {
walkPattern(p.value, bindings)
}
}
} else {
// ...rest
// argument can only be identifer when destructuring
bindings[(p.argument as Identifier).name] = true
}
}
}
function walkArrayPattern(
node: ArrayPattern,
bindings: Record<string, boolean>
) {
for (const e of node.elements) {
e && walkPattern(e, bindings)
}
}
function walkPattern(node: Node, bindings: Record<string, boolean>) {
if (node.type === 'Identifier') {
bindings[node.name] = true
} else if (node.type === 'RestElement') {
// argument can only be identifer when destructuring
bindings[(node.argument as Identifier).name] = true
} else if (node.type === 'ObjectPattern') {
walkObjectPattern(node, bindings)
} else if (node.type === 'ArrayPattern') {
walkArrayPattern(node, bindings)
} else if (node.type === 'AssignmentPattern') {
if (node.left.type === 'Identifier') {
bindings[node.left.name] = true
} else {
walkPattern(node.left, bindings)
}
}
}
interface PropTypeData {
key: string
type: string[]
required: boolean
}
function recordType(node: Node, declaredTypes: Record<string, string[]>) {
if (node.type === 'TSInterfaceDeclaration') {
declaredTypes[node.id.name] = [`Object`]
} else if (node.type === 'TSTypeAliasDeclaration') {
declaredTypes[node.id.name] = inferRuntimeType(
node.typeAnnotation,
declaredTypes
)
} else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
recordType(node.declaration, declaredTypes)
}
}
function extractRuntimeProps(
node: TSTypeLiteral,
props: Record<string, PropTypeData>,
declaredTypes: Record<string, string[]>
) {
for (const m of node.members) {
if (m.type === 'TSPropertySignature' && m.key.type === 'Identifier') {
props[m.key.name] = {
key: m.key.name,
required: !m.optional,
type:
__DEV__ && m.typeAnnotation
? inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes)
: [`null`]
}
}
}
}
function inferRuntimeType(
node: TSType,
declaredTypes: Record<string, string[]>
): string[] {
switch (node.type) {
case 'TSStringKeyword':
return ['String']
case 'TSNumberKeyword':
return ['Number']
case 'TSBooleanKeyword':
return ['Boolean']
case 'TSObjectKeyword':
return ['Object']
case 'TSTypeLiteral':
// TODO (nice to have) generate runtime property validation
return ['Object']
case 'TSFunctionType':
return ['Function']
case 'TSArrayType':
case 'TSTupleType':
// TODO (nice to have) genrate runtime element type/length checks
return ['Array']
case 'TSLiteralType':
switch (node.literal.type) {
case 'StringLiteral':
return ['String']
case 'BooleanLiteral':
return ['Boolean']
case 'NumericLiteral':
case 'BigIntLiteral':
return ['Number']
default:
return [`null`]
}
case 'TSTypeReference':
if (node.typeName.type === 'Identifier') {
if (declaredTypes[node.typeName.name]) {
return declaredTypes[node.typeName.name]
}
switch (node.typeName.name) {
case 'Array':
case 'Function':
case 'Object':
case 'Set':
case 'Map':
case 'WeakSet':
case 'WeakMap':
return [node.typeName.name]
case 'Record':
case 'Partial':
case 'Readonly':
case 'Pick':
case 'Omit':
case 'Exclude':
case 'Extract':
case 'Required':
case 'InstanceType':
return ['Object']
}
}
return [`null`]
case 'TSUnionType':
return [
...new Set(
[].concat(node.types.map(t =>
inferRuntimeType(t, declaredTypes)
) as any)
)
]
case 'TSIntersectionType':
return ['Object']
default:
return [`null`] // no runtime check
}
}
function genRuntimeProps(props: Record<string, PropTypeData>) {
const keys = Object.keys(props)
if (!keys.length) {
return ``
}
if (!__DEV__) {
// production: generate array version only
return `\n props: [\n ${keys
.map(k => JSON.stringify(k))
.join(',\n ')}\n ] as unknown as undefined,`
}
return `\n props: {\n ${keys
.map(key => {
const { type, required } = props[key]
return `${key}: { type: ${toRuntimeTypeString(
type
)}, required: ${required} }`
})
.join(',\n ')}\n } as unknown as undefined,`
}
function toRuntimeTypeString(types: string[]) {
return types.some(t => t === 'null')
? `null`
: types.length > 1
? `[${types.join(', ')}]`
: types[0]
}
function extractRuntimeEmits(
node: TSFunctionType | TSDeclareFunction,
emits: Set<string>
) {
const eventName =
node.type === 'TSDeclareFunction' ? node.params[0] : node.parameters[0]
if (
eventName.type === 'Identifier' &&
eventName.typeAnnotation &&
eventName.typeAnnotation.type === 'TSTypeAnnotation'
) {
const typeNode = eventName.typeAnnotation.typeAnnotation
if (typeNode.type === 'TSLiteralType') {
emits.add(String(typeNode.literal.value))
} else if (typeNode.type === 'TSUnionType') {
for (const t of typeNode.types) {
if (t.type === 'TSLiteralType') {
emits.add(String(t.literal.value))
}
}
}
}
}
function genRuntimeEmits(emits: Set<string>) {
return emits.size
? `\n emits: [${Array.from(emits)
.map(p => JSON.stringify(p))
.join(', ')}] as unknown as undefined,`
: ``
}
/**
* export default {} inside <script setup> cannot access variables declared
* inside since it's hoisted. Walk and check to make sure.
*/
function checkDefaultExport(
root: Node,
scopeVars: Record<string, boolean>,
imports: Record<string, string>,
exports: Record<string, boolean>,
source: string,
offset: number
) {
const knownIds: Record<string, number> = Object.create(null)
;(walk as any)(root, {
enter(node: Node & { scopeIds?: Set<string> }, parent: Node) {
if (node.type === 'Identifier') {
if (
!knownIds[node.name] &&
!isStaticPropertyKey(node, parent) &&
(scopeVars[node.name] || (!imports[node.name] && exports[node.name]))
) {
throw new Error(
`\`export default\` in <script setup> cannot reference locally ` +
`declared variables because it will be hoisted outside of the ` +
`setup() function. If your component options requires initialization ` +
`in the module scope, use a separate normal <script> to export ` +
`the options instead.\n\n` +
generateCodeFrame(
source,
node.start! + offset,
node.end! + offset
)
)
}
} else if (isFunction(node)) {
// walk function expressions and add its arguments to known identifiers
// so that we don't prefix them
node.params.forEach(p =>
(walk as any)(p, {
enter(child: Node, parent: Node) {
if (
child.type === 'Identifier' &&
// do not record as scope variable if is a destructured key
!isStaticPropertyKey(child, parent) &&
// do not record if this is a default value
// assignment of a destructured variable
!(
parent &&
parent.type === 'AssignmentPattern' &&
parent.right === child
)
) {
const { name } = child
if (node.scopeIds && node.scopeIds.has(name)) {
return
}
if (name in knownIds) {
knownIds[name]++
} else {
knownIds[name] = 1
}
;(node.scopeIds || (node.scopeIds = new Set())).add(name)
}
}
})
)
}
},
leave(node: Node & { scopeIds?: Set<string> }) {
if (node.scopeIds) {
node.scopeIds.forEach((id: string) => {
knownIds[id]--
if (knownIds[id] === 0) {
delete knownIds[id]
}
})
}
}
})
}
function isStaticPropertyKey(node: Node, parent: Node): boolean {
return (
parent &&
(parent.type === 'ObjectProperty' || parent.type === 'ObjectMethod') &&
!parent.computed &&
parent.key === node
)
}
function isFunction(node: Node): node is FunctionNode {
return /Function(?:Expression|Declaration)$|Method$/.test(node.type)
}
/**
* Analyze bindings in normal `<script>`
* Note that `compileScriptSetup` already analyzes bindings as part of its
* compilation process so this should only be used on single `<script>` SFCs.
*/
export function analyzeScriptBindings(
_script: SFCScriptBlock
): BindingMetadata {
return {
// TODO
}
}
| packages/compiler-sfc/src/compileScript.ts | 1 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.9954677820205688,
0.028241299092769623,
0.00016326329205185175,
0.00017199577996507287,
0.15538467466831207
] |
{
"id": 1,
"code_window": [
"export function compileScript(\n",
" sfc: SFCDescriptor,\n",
" options: SFCScriptCompileOptions = {}\n",
"): SFCScriptBlock {\n",
" if (__DEV__ && !__TEST__ && !hasWarned) {\n",
" hasWarned = true\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
" const { script, scriptSetup, styles, source, filename } = sfc\n",
"\n",
" if (__DEV__ && !__TEST__ && !hasWarned && scriptSetup) {\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 42
} | import { VNode } from './vnode'
import { ComponentInternalInstance, LifecycleHooks } from './component'
import { warn, pushWarningContext, popWarningContext } from './warning'
import { isPromise, isFunction } from '@vue/shared'
// contexts where user provided function may be executed, in addition to
// lifecycle hooks.
export const enum ErrorCodes {
SETUP_FUNCTION,
RENDER_FUNCTION,
WATCH_GETTER,
WATCH_CALLBACK,
WATCH_CLEANUP,
NATIVE_EVENT_HANDLER,
COMPONENT_EVENT_HANDLER,
VNODE_HOOK,
DIRECTIVE_HOOK,
TRANSITION_HOOK,
APP_ERROR_HANDLER,
APP_WARN_HANDLER,
FUNCTION_REF,
ASYNC_COMPONENT_LOADER,
SCHEDULER
}
export const ErrorTypeStrings: Record<number | string, string> = {
[LifecycleHooks.BEFORE_CREATE]: 'beforeCreate hook',
[LifecycleHooks.CREATED]: 'created hook',
[LifecycleHooks.BEFORE_MOUNT]: 'beforeMount hook',
[LifecycleHooks.MOUNTED]: 'mounted hook',
[LifecycleHooks.BEFORE_UPDATE]: 'beforeUpdate hook',
[LifecycleHooks.UPDATED]: 'updated',
[LifecycleHooks.BEFORE_UNMOUNT]: 'beforeUnmount hook',
[LifecycleHooks.UNMOUNTED]: 'unmounted hook',
[LifecycleHooks.ACTIVATED]: 'activated hook',
[LifecycleHooks.DEACTIVATED]: 'deactivated hook',
[LifecycleHooks.ERROR_CAPTURED]: 'errorCaptured hook',
[LifecycleHooks.RENDER_TRACKED]: 'renderTracked hook',
[LifecycleHooks.RENDER_TRIGGERED]: 'renderTriggered hook',
[ErrorCodes.SETUP_FUNCTION]: 'setup function',
[ErrorCodes.RENDER_FUNCTION]: 'render function',
[ErrorCodes.WATCH_GETTER]: 'watcher getter',
[ErrorCodes.WATCH_CALLBACK]: 'watcher callback',
[ErrorCodes.WATCH_CLEANUP]: 'watcher cleanup function',
[ErrorCodes.NATIVE_EVENT_HANDLER]: 'native event handler',
[ErrorCodes.COMPONENT_EVENT_HANDLER]: 'component event handler',
[ErrorCodes.VNODE_HOOK]: 'vnode hook',
[ErrorCodes.DIRECTIVE_HOOK]: 'directive hook',
[ErrorCodes.TRANSITION_HOOK]: 'transition hook',
[ErrorCodes.APP_ERROR_HANDLER]: 'app errorHandler',
[ErrorCodes.APP_WARN_HANDLER]: 'app warnHandler',
[ErrorCodes.FUNCTION_REF]: 'ref function',
[ErrorCodes.ASYNC_COMPONENT_LOADER]: 'async component loader',
[ErrorCodes.SCHEDULER]:
'scheduler flush. This is likely a Vue internals bug. ' +
'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next'
}
export type ErrorTypes = LifecycleHooks | ErrorCodes
export function callWithErrorHandling(
fn: Function,
instance: ComponentInternalInstance | null,
type: ErrorTypes,
args?: unknown[]
) {
let res
try {
res = args ? fn(...args) : fn()
} catch (err) {
handleError(err, instance, type)
}
return res
}
export function callWithAsyncErrorHandling(
fn: Function | Function[],
instance: ComponentInternalInstance | null,
type: ErrorTypes,
args?: unknown[]
): any[] {
if (isFunction(fn)) {
const res = callWithErrorHandling(fn, instance, type, args)
if (res && isPromise(res)) {
res.catch(err => {
handleError(err, instance, type)
})
}
return res
}
const values = []
for (let i = 0; i < fn.length; i++) {
values.push(callWithAsyncErrorHandling(fn[i], instance, type, args))
}
return values
}
export function handleError(
err: unknown,
instance: ComponentInternalInstance | null,
type: ErrorTypes
) {
const contextVNode = instance ? instance.vnode : null
if (instance) {
let cur = instance.parent
// the exposed instance is the render proxy to keep it consistent with 2.x
const exposedInstance = instance.proxy
// in production the hook receives only the error code
const errorInfo = __DEV__ ? ErrorTypeStrings[type] : type
while (cur) {
const errorCapturedHooks = cur.ec
if (errorCapturedHooks) {
for (let i = 0; i < errorCapturedHooks.length; i++) {
if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) {
return
}
}
}
cur = cur.parent
}
// app-level handling
const appErrorHandler = instance.appContext.config.errorHandler
if (appErrorHandler) {
callWithErrorHandling(
appErrorHandler,
null,
ErrorCodes.APP_ERROR_HANDLER,
[err, exposedInstance, errorInfo]
)
return
}
}
logError(err, type, contextVNode)
}
// Test-only toggle for testing the unhandled warning behavior
let forceRecover = false
export function setErrorRecovery(value: boolean) {
forceRecover = value
}
function logError(err: unknown, type: ErrorTypes, contextVNode: VNode | null) {
// default behavior is crash in prod & test, recover in dev.
if (__DEV__ && (forceRecover || !__TEST__)) {
const info = ErrorTypeStrings[type]
if (contextVNode) {
pushWarningContext(contextVNode)
}
warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`)
console.error(err)
if (contextVNode) {
popWarningContext()
}
} else {
throw err
}
}
| packages/runtime-core/src/errorHandling.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.0008186513441614807,
0.0002500834234524518,
0.00016510197019670159,
0.0001707310730125755,
0.00019300845451653004
] |
{
"id": 1,
"code_window": [
"export function compileScript(\n",
" sfc: SFCDescriptor,\n",
" options: SFCScriptCompileOptions = {}\n",
"): SFCScriptBlock {\n",
" if (__DEV__ && !__TEST__ && !hasWarned) {\n",
" hasWarned = true\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
" const { script, scriptSetup, styles, source, filename } = sfc\n",
"\n",
" if (__DEV__ && !__TEST__ && !hasWarned && scriptSetup) {\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 42
} | // Jest Snapshot v1, https://goo.gl/fbAQLP
exports[`compiler: codegen ArrayExpression 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return [
foo,
bar(baz)
]
}
}"
`;
exports[`compiler: codegen CacheExpression 1`] = `
"
export function render(_ctx, _cache) {
return _cache[1] || (_cache[1] = foo)
}"
`;
exports[`compiler: codegen CacheExpression w/ isVNode: true 1`] = `
"
export function render(_ctx, _cache) {
return _cache[1] || (
_setBlockTracking(-1),
_cache[1] = foo,
_setBlockTracking(1),
_cache[1]
)
}"
`;
exports[`compiler: codegen ConditionalExpression 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return ok
? foo()
: orNot
? bar()
: baz()
}
}"
`;
exports[`compiler: codegen Element (callExpression + objectExpression + TemplateChildNode[]) 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return _createVNode(\\"div\\", {
id: \\"foo\\",
[prop]: bar,
[foo + bar]: bar
}, [
_createVNode(\\"p\\", { \\"some-key\\": \\"foo\\" })
], 16)
}
}"
`;
exports[`compiler: codegen assets + temps 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
const _component_Foo = _resolveComponent(\\"Foo\\")
const _component_bar_baz = _resolveComponent(\\"bar-baz\\")
const _component_barbaz = _resolveComponent(\\"barbaz\\")
const _directive_my_dir_0 = _resolveDirective(\\"my_dir_0\\")
const _directive_my_dir_1 = _resolveDirective(\\"my_dir_1\\")
let _temp0, _temp1, _temp2
return null
}
}"
`;
exports[`compiler: codegen comment 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return _createCommentVNode(\\"foo\\")
}
}"
`;
exports[`compiler: codegen compound expression 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return _ctx.foo + _toDisplayString(bar) + nested
}
}"
`;
exports[`compiler: codegen forNode 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return (_openBlock(true), _createBlock(_Fragment, null, _renderList(), 1))
}
}"
`;
exports[`compiler: codegen forNode with constant expression 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return (_openBlock(), _createBlock(_Fragment, null, _renderList(), 64 /* STABLE_FRAGMENT */))
}
}"
`;
exports[`compiler: codegen function mode preamble 1`] = `
"const _Vue = Vue
return function render(_ctx, _cache) {
with (_ctx) {
const { createVNode: _createVNode, resolveDirective: _resolveDirective } = _Vue
return null
}
}"
`;
exports[`compiler: codegen function mode preamble w/ prefixIdentifiers: true 1`] = `
"const { createVNode: _createVNode, resolveDirective: _resolveDirective } = Vue
return function render(_ctx, _cache) {
return null
}"
`;
exports[`compiler: codegen hoists 1`] = `
"
const _hoisted_1 = hello
const _hoisted_2 = { id: \\"foo\\" }
return function render(_ctx, _cache) {
with (_ctx) {
return null
}
}"
`;
exports[`compiler: codegen ifNode 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return foo
? bar
: baz
}
}"
`;
exports[`compiler: codegen interpolation 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return _toDisplayString(hello)
}
}"
`;
exports[`compiler: codegen module mode preamble 1`] = `
"import { createVNode as _createVNode, resolveDirective as _resolveDirective } from \\"vue\\"
export function render(_ctx, _cache) {
return null
}"
`;
exports[`compiler: codegen module mode preamble w/ optimizeImports: true 1`] = `
"import { createVNode, resolveDirective } from \\"vue\\"
// Binding optimization for webpack code-split
const _createVNode = createVNode, _resolveDirective = resolveDirective
export function render(_ctx, _cache) {
return null
}"
`;
exports[`compiler: codegen static text 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
return \\"hello\\"
}
}"
`;
exports[`compiler: codegen temps 1`] = `
"
return function render(_ctx, _cache) {
with (_ctx) {
let _temp0, _temp1, _temp2
return null
}
}"
`;
| packages/compiler-core/__tests__/__snapshots__/codegen.spec.ts.snap | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00018927999190054834,
0.00017031269089784473,
0.00016464636428281665,
0.000168942628079094,
0.000005977295131742721
] |
{
"id": 1,
"code_window": [
"export function compileScript(\n",
" sfc: SFCDescriptor,\n",
" options: SFCScriptCompileOptions = {}\n",
"): SFCScriptBlock {\n",
" if (__DEV__ && !__TEST__ && !hasWarned) {\n",
" hasWarned = true\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep"
],
"after_edit": [
" const { script, scriptSetup, styles, source, filename } = sfc\n",
"\n",
" if (__DEV__ && !__TEST__ && !hasWarned && scriptSetup) {\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 42
} | <script src="../../../../node_modules/marked/marked.min.js"></script>
<script src="../../../../node_modules/lodash/lodash.min.js"></script>
<script src="../../dist/vue.global.js"></script>
<div id="editor">
<textarea :value="input" @input="update"></textarea>
<div v-html="compiledMarkdown"></div>
</div>
<script>
const delay = window.location.hash === '#test' ? 16 : 300
Vue.createApp({
data: () => ({
input: '# hello'
}),
computed: {
compiledMarkdown() {
return marked(this.input, { sanitize: true })
}
},
methods: {
update: _.debounce(function (e) {
this.input = e.target.value
}, delay)
}
}).mount('#editor')
</script>
<style>
html, body, #editor {
margin: 0;
height: 100%;
font-family: 'Helvetica Neue', Arial, sans-serif;
color: #333;
}
textarea, #editor div {
display: inline-block;
overflow: auto;
width: 50%;
height: 100%;
vertical-align: top;
-webkit-box-sizing: border-box;
-moz-box-sizing: border-box;
box-sizing: border-box;
padding: 0 20px;
}
textarea {
border: none;
border-right: 1px solid #ccc;
resize: none;
outline: none;
background-color: #f6f6f6;
font-size: 14px;
font-family: 'Monaco', courier, monospace;
padding: 20px;
}
code {
color: #f66;
}
</style>
| packages/vue/examples/classic/markdown.html | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00017387291882187128,
0.0001704208116279915,
0.0001685215684119612,
0.0001702752197161317,
0.0000018957159682031488
] |
{
"id": 2,
"code_window": [
" hasWarned = true\n",
" console.log(\n",
" `\\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\\n` +\n",
" `Follow https://github.com/vuejs/rfcs/pull/182 for its status.\\n`\n",
" )\n",
" }\n",
"\n"
],
"labels": [
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" // @ts-ignore `console.info` cannot be null error\n",
" console[console.info ? 'info' : 'log'](\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 44
} | import MagicString from 'magic-string'
import { BindingMetadata } from '@vue/compiler-core'
import { SFCDescriptor, SFCScriptBlock } from './parse'
import { parse, ParserPlugin } from '@babel/parser'
import { babelParserDefautPlugins, generateCodeFrame } from '@vue/shared'
import {
Node,
Declaration,
ObjectPattern,
ArrayPattern,
Identifier,
ExpressionStatement,
ArrowFunctionExpression,
ExportSpecifier,
Function as FunctionNode,
TSType,
TSTypeLiteral,
TSFunctionType,
TSDeclareFunction
} from '@babel/types'
import { walk } from 'estree-walker'
import { RawSourceMap } from 'source-map'
import { genCssVarsCode, injectCssVarsCalls } from './genCssVars'
export interface SFCScriptCompileOptions {
/**
* https://babeljs.io/docs/en/babel-parser#plugins
*/
babelParserPlugins?: ParserPlugin[]
}
let hasWarned = false
/**
* Compile `<script setup>`
* It requires the whole SFC descriptor because we need to handle and merge
* normal `<script>` + `<script setup>` if both are present.
*/
export function compileScript(
sfc: SFCDescriptor,
options: SFCScriptCompileOptions = {}
): SFCScriptBlock {
if (__DEV__ && !__TEST__ && !hasWarned) {
hasWarned = true
console.log(
`\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\n` +
`Follow https://github.com/vuejs/rfcs/pull/182 for its status.\n`
)
}
const { script, scriptSetup, styles, source, filename } = sfc
const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')
const isTS =
(script && script.lang === 'ts') ||
(scriptSetup && scriptSetup.lang === 'ts')
const plugins: ParserPlugin[] = [
...(options.babelParserPlugins || []),
...babelParserDefautPlugins,
...(isTS ? (['typescript'] as const) : [])
]
if (!scriptSetup) {
if (!script) {
throw new Error(`SFC contains no <script> tags.`)
}
return {
...script,
content: hasCssVars ? injectCssVarsCalls(sfc, plugins) : script.content,
bindings: analyzeScriptBindings(script)
}
}
if (script && script.lang !== scriptSetup.lang) {
throw new Error(
`<script> and <script setup> must have the same language type.`
)
}
const defaultTempVar = `__default__`
const bindings: BindingMetadata = {}
const imports: Record<string, string> = {}
const setupScopeVars: Record<string, boolean> = {}
const setupExports: Record<string, boolean> = {}
let exportAllIndex = 0
let defaultExport: Node | undefined
let needDefaultExportRefCheck = false
let hasAwait = false
const checkDuplicateDefaultExport = (node: Node) => {
if (defaultExport) {
// <script> already has export default
throw new Error(
`Default export is already declared in normal <script>.\n\n` +
generateCodeFrame(
source,
node.start! + startOffset,
node.start! + startOffset + `export default`.length
)
)
}
}
const s = new MagicString(source)
const startOffset = scriptSetup.loc.start.offset
const endOffset = scriptSetup.loc.end.offset
const scriptStartOffset = script && script.loc.start.offset
const scriptEndOffset = script && script.loc.end.offset
// 1. process normal <script> first if it exists
if (script) {
// import dedupe between <script> and <script setup>
const scriptAST = parse(script.content, {
plugins,
sourceType: 'module'
}).program.body
for (const node of scriptAST) {
if (node.type === 'ImportDeclaration') {
// record imports for dedupe
for (const {
local: { name }
} of node.specifiers) {
imports[name] = node.source.value
}
} else if (node.type === 'ExportDefaultDeclaration') {
// export default
defaultExport = node
const start = node.start! + scriptStartOffset!
s.overwrite(
start,
start + `export default`.length,
`const ${defaultTempVar} =`
)
} else if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
const defaultSpecifier = node.specifiers.find(
s => s.exported.name === 'default'
) as ExportSpecifier
if (defaultSpecifier) {
defaultExport = node
// 1. remove specifier
if (node.specifiers.length > 1) {
s.remove(
defaultSpecifier.start! + scriptStartOffset!,
defaultSpecifier.end! + scriptStartOffset!
)
} else {
s.remove(
node.start! + scriptStartOffset!,
node.end! + scriptStartOffset!
)
}
if (node.source) {
// export { x as default } from './x'
// rewrite to `import { x as __default__ } from './x'` and
// add to top
s.prepend(
`import { ${
defaultSpecifier.local.name
} as ${defaultTempVar} } from '${node.source.value}'\n`
)
} else {
// export { x as default }
// rewrite to `const __default__ = x` and move to end
s.append(
`\nconst ${defaultTempVar} = ${defaultSpecifier.local.name}\n`
)
}
}
}
}
}
// 2. check <script setup="xxx"> function signature
const setupValue = scriptSetup.setup
const hasExplicitSignature = typeof setupValue === 'string'
let propsVar: string | undefined
let emitVar: string | undefined
let slotsVar: string | undefined
let attrsVar: string | undefined
let propsType = `{}`
let emitType = `(e: string, ...args: any[]) => void`
let slotsType = `__Slots__`
let attrsType = `Record<string, any>`
let propsASTNode
let setupCtxASTNode
// props/emits declared via types
const typeDeclaredProps: Record<string, PropTypeData> = {}
const typeDeclaredEmits: Set<string> = new Set()
// record declared types for runtime props type generation
const declaredTypes: Record<string, string[]> = {}
if (isTS && hasExplicitSignature) {
// <script setup="xxx" lang="ts">
// parse the signature to extract the props/emit variables the user wants
// we need them to find corresponding type declarations.
const signatureAST = parse(`(${setupValue})=>{}`, { plugins }).program
.body[0]
const params = ((signatureAST as ExpressionStatement)
.expression as ArrowFunctionExpression).params
if (params[0] && params[0].type === 'Identifier') {
propsASTNode = params[0]
propsVar = propsASTNode.name
}
if (params[1] && params[1].type === 'ObjectPattern') {
setupCtxASTNode = params[1]
for (const p of params[1].properties) {
if (
p.type === 'ObjectProperty' &&
p.key.type === 'Identifier' &&
p.value.type === 'Identifier'
) {
if (p.key.name === 'emit') {
emitVar = p.value.name
} else if (p.key.name === 'slots') {
slotsVar = p.value.name
} else if (p.key.name === 'attrs') {
attrsVar = p.value.name
}
}
}
}
}
// 3. parse <script setup> and walk over top level statements
for (const node of parse(scriptSetup.content, {
plugins: [
...plugins,
// allow top level await but only inside <script setup>
'topLevelAwait'
],
sourceType: 'module'
}).program.body) {
const start = node.start! + startOffset
let end = node.end! + startOffset
// import or type declarations: move to top
// locate the end of whitespace between this statement and the next
while (end <= source.length) {
if (!/\s/.test(source.charAt(end))) {
break
}
end++
}
if (node.type === 'ImportDeclaration') {
// import declarations are moved to top
s.move(start, end, 0)
// dedupe imports
let prev
let removed = 0
for (const specifier of node.specifiers) {
if (imports[specifier.local.name]) {
// already imported in <script setup>, dedupe
removed++
s.remove(
prev ? prev.end! + startOffset : specifier.start! + startOffset,
specifier.end! + startOffset
)
} else {
imports[specifier.local.name] = node.source.value
}
prev = specifier
}
if (removed === node.specifiers.length) {
s.remove(node.start! + startOffset, node.end! + startOffset)
}
}
if (node.type === 'ExportNamedDeclaration' && node.exportKind !== 'type') {
// named exports
if (node.declaration) {
// variable/function/class declarations.
// remove leading `export ` keyword
s.remove(start, start + 7)
walkDeclaration(node.declaration, setupExports)
}
if (node.specifiers.length) {
// named export with specifiers
if (node.source) {
// export { x } from './x'
// change it to import and move to top
s.overwrite(start, start + 6, 'import')
s.move(start, end, 0)
} else {
// export { x }
s.remove(start, end)
}
for (const specifier of node.specifiers) {
if (specifier.type === 'ExportDefaultSpecifier') {
// export default from './x'
// rewrite to `import __default__ from './x'`
checkDuplicateDefaultExport(node)
defaultExport = node
s.overwrite(
specifier.exported.start! + startOffset,
specifier.exported.start! + startOffset + 7,
defaultTempVar
)
} else if (specifier.type === 'ExportSpecifier') {
if (specifier.exported.name === 'default') {
checkDuplicateDefaultExport(node)
defaultExport = node
// 1. remove specifier
if (node.specifiers.length > 1) {
// removing the default specifier from a list of specifiers.
// look ahead until we reach the first non , or whitespace char.
let end = specifier.end! + startOffset
while (end < source.length) {
if (/[^,\s]/.test(source.charAt(end))) {
break
}
end++
}
s.remove(specifier.start! + startOffset, end)
} else {
s.remove(node.start! + startOffset!, node.end! + startOffset!)
}
if (!node.source) {
// export { x as default, ... }
const local = specifier.local.name
if (setupScopeVars[local] || setupExports[local]) {
throw new Error(
`Cannot export locally defined variable as default in <script setup>.\n` +
`Default export must be an object literal with no reference to local scope.\n` +
generateCodeFrame(
source,
specifier.start! + startOffset,
specifier.end! + startOffset
)
)
}
// rewrite to `const __default__ = x` and move to end
s.append(`\nconst ${defaultTempVar} = ${local}\n`)
} else {
// export { x as default } from './x'
// rewrite to `import { x as __default__ } from './x'` and
// add to top
s.prepend(
`import { ${
specifier.local.name
} as ${defaultTempVar} } from '${node.source.value}'\n`
)
}
} else {
setupExports[specifier.exported.name] = true
if (node.source) {
imports[specifier.exported.name] = node.source.value
}
}
}
}
}
}
if (node.type === 'ExportAllDeclaration') {
// export * from './x'
s.overwrite(
start,
node.source.start! + startOffset,
`import * as __export_all_${exportAllIndex++}__ from `
)
s.move(start, end, 0)
}
if (node.type === 'ExportDefaultDeclaration') {
checkDuplicateDefaultExport(node)
// export default {} inside <script setup>
// this should be kept in module scope - move it to the end
s.move(start, end, source.length)
s.overwrite(start, start + `export default`.length, `const __default__ =`)
// save it for analysis when all imports and variable declarations have
// been recorded
defaultExport = node
needDefaultExportRefCheck = true
}
if (
(node.type === 'VariableDeclaration' ||
node.type === 'FunctionDeclaration' ||
node.type === 'ClassDeclaration') &&
!node.declare
) {
walkDeclaration(node, setupScopeVars)
}
// Type declarations
if (node.type === 'VariableDeclaration' && node.declare) {
s.remove(start, end)
for (const { id } of node.declarations) {
if (id.type === 'Identifier') {
if (
id.typeAnnotation &&
id.typeAnnotation.type === 'TSTypeAnnotation'
) {
const typeNode = id.typeAnnotation.typeAnnotation
const typeString = source.slice(
typeNode.start! + startOffset,
typeNode.end! + startOffset
)
if (typeNode.type === 'TSTypeLiteral') {
if (id.name === propsVar) {
propsType = typeString
extractRuntimeProps(typeNode, typeDeclaredProps, declaredTypes)
} else if (id.name === slotsVar) {
slotsType = typeString
} else if (id.name === attrsVar) {
attrsType = typeString
}
} else if (
id.name === emitVar &&
typeNode.type === 'TSFunctionType'
) {
emitType = typeString
extractRuntimeEmits(typeNode, typeDeclaredEmits)
}
}
}
}
}
if (
node.type === 'TSDeclareFunction' &&
node.id &&
node.id.name === emitVar
) {
const index = node.id.start! + startOffset
s.overwrite(index, index + emitVar.length, '__emit__')
emitType = `typeof __emit__`
extractRuntimeEmits(node, typeDeclaredEmits)
}
// move all type declarations to outer scope
if (
node.type.startsWith('TS') ||
(node.type === 'ExportNamedDeclaration' && node.exportKind === 'type')
) {
recordType(node, declaredTypes)
s.move(start, end, 0)
}
// walk statements & named exports / variable declarations for top level
// await
if (
node.type === 'VariableDeclaration' ||
(node.type === 'ExportNamedDeclaration' &&
node.declaration &&
node.declaration.type === 'VariableDeclaration') ||
node.type.endsWith('Statement')
) {
;(walk as any)(node, {
enter(node: Node) {
if (isFunction(node)) {
this.skip()
}
if (node.type === 'AwaitExpression') {
hasAwait = true
}
}
})
}
}
// 4. check default export to make sure it doesn't reference setup scope
// variables
if (needDefaultExportRefCheck) {
checkDefaultExport(
defaultExport!,
setupScopeVars,
imports,
setupExports,
source,
startOffset
)
}
// 5. remove non-script content
if (script) {
if (startOffset < scriptStartOffset!) {
// <script setup> before <script>
s.remove(endOffset, scriptStartOffset!)
s.remove(scriptEndOffset!, source.length)
} else {
// <script> before <script setup>
s.remove(0, scriptStartOffset!)
s.remove(scriptEndOffset!, startOffset)
s.remove(endOffset, source.length)
}
} else {
// only <script setup>
s.remove(0, startOffset)
s.remove(endOffset, source.length)
}
// 5. finalize setup argument signature.
let args = ``
if (isTS) {
if (slotsType === '__Slots__') {
s.prepend(`import { Slots as __Slots__ } from 'vue'\n`)
}
const ctxType = `{
emit: ${emitType},
slots: ${slotsType},
attrs: ${attrsType}
}`
if (hasExplicitSignature) {
// inject types to user signature
args = setupValue as string
const ss = new MagicString(args)
if (propsASTNode) {
// compensate for () wraper offset
ss.appendRight(propsASTNode.end! - 1, `: ${propsType}`)
}
if (setupCtxASTNode) {
ss.appendRight(setupCtxASTNode.end! - 1!, `: ${ctxType}`)
}
args = ss.toString()
}
} else {
args = hasExplicitSignature ? (setupValue as string) : ``
}
// 6. wrap setup code with function.
// export the content of <script setup> as a named export, `setup`.
// this allows `import { setup } from '*.vue'` for testing purposes.
s.prependLeft(
startOffset,
`\nexport ${hasAwait ? `async ` : ``}function setup(${args}) {\n`
)
// generate return statement
let returned = `{ ${Object.keys(setupExports).join(', ')} }`
// handle `export * from`. We need to call `toRefs` on the imported module
// object before merging.
if (exportAllIndex > 0) {
s.prepend(`import { toRefs as __toRefs__ } from 'vue'\n`)
for (let i = 0; i < exportAllIndex; i++) {
returned += `,\n __toRefs__(__export_all_${i}__)`
}
returned = `Object.assign(\n ${returned}\n)`
}
// inject `useCSSVars` calls
if (hasCssVars) {
s.prepend(`import { useCSSVars as __useCSSVars__ } from 'vue'\n`)
for (const style of styles) {
const vars = style.attrs.vars
if (typeof vars === 'string') {
s.prependRight(
endOffset,
`\n${genCssVarsCode(vars, !!style.scoped, setupExports)}`
)
}
}
}
s.appendRight(endOffset, `\nreturn ${returned}\n}\n\n`)
// 7. finalize default export
if (isTS) {
// for TS, make sure the exported type is still valid type with
// correct props information
s.prepend(`import { defineComponent as __define__ } from 'vue'\n`)
// we have to use object spread for types to be merged properly
// user's TS setting should compile it down to proper targets
const def = defaultExport ? `\n ...${defaultTempVar},` : ``
const runtimeProps = genRuntimeProps(typeDeclaredProps)
const runtimeEmits = genRuntimeEmits(typeDeclaredEmits)
s.append(
`export default __define__({${def}${runtimeProps}${runtimeEmits}\n setup\n})`
)
} else {
if (defaultExport) {
s.append(
`${defaultTempVar}.setup = setup\nexport default ${defaultTempVar}`
)
} else {
s.append(`export default { setup }`)
}
}
// 8. expose bindings for template compiler optimization
if (script) {
Object.assign(bindings, analyzeScriptBindings(script))
}
Object.keys(setupExports).forEach(key => {
bindings[key] = 'setup'
})
Object.keys(typeDeclaredProps).forEach(key => {
bindings[key] = 'props'
})
// TODO analyze props if user declared props via `export default {}` inside
// <script setup>
s.trim()
return {
...scriptSetup,
bindings,
content: s.toString(),
map: (s.generateMap({
source: filename,
hires: true,
includeContent: true
}) as unknown) as RawSourceMap
}
}
function walkDeclaration(node: Declaration, bindings: Record<string, boolean>) {
if (node.type === 'VariableDeclaration') {
// export const foo = ...
for (const { id } of node.declarations) {
if (id.type === 'Identifier') {
bindings[id.name] = true
} else if (id.type === 'ObjectPattern') {
walkObjectPattern(id, bindings)
} else if (id.type === 'ArrayPattern') {
walkArrayPattern(id, bindings)
}
}
} else if (
node.type === 'FunctionDeclaration' ||
node.type === 'ClassDeclaration'
) {
// export function foo() {} / export class Foo {}
// export declarations must be named.
bindings[node.id!.name] = true
}
}
function walkObjectPattern(
node: ObjectPattern,
bindings: Record<string, boolean>
) {
for (const p of node.properties) {
if (p.type === 'ObjectProperty') {
// key can only be Identifier in ObjectPattern
if (p.key.type === 'Identifier') {
if (p.key === p.value) {
// const { x } = ...
bindings[p.key.name] = true
} else {
walkPattern(p.value, bindings)
}
}
} else {
// ...rest
// argument can only be identifer when destructuring
bindings[(p.argument as Identifier).name] = true
}
}
}
function walkArrayPattern(
node: ArrayPattern,
bindings: Record<string, boolean>
) {
for (const e of node.elements) {
e && walkPattern(e, bindings)
}
}
function walkPattern(node: Node, bindings: Record<string, boolean>) {
if (node.type === 'Identifier') {
bindings[node.name] = true
} else if (node.type === 'RestElement') {
// argument can only be identifer when destructuring
bindings[(node.argument as Identifier).name] = true
} else if (node.type === 'ObjectPattern') {
walkObjectPattern(node, bindings)
} else if (node.type === 'ArrayPattern') {
walkArrayPattern(node, bindings)
} else if (node.type === 'AssignmentPattern') {
if (node.left.type === 'Identifier') {
bindings[node.left.name] = true
} else {
walkPattern(node.left, bindings)
}
}
}
interface PropTypeData {
key: string
type: string[]
required: boolean
}
function recordType(node: Node, declaredTypes: Record<string, string[]>) {
if (node.type === 'TSInterfaceDeclaration') {
declaredTypes[node.id.name] = [`Object`]
} else if (node.type === 'TSTypeAliasDeclaration') {
declaredTypes[node.id.name] = inferRuntimeType(
node.typeAnnotation,
declaredTypes
)
} else if (node.type === 'ExportNamedDeclaration' && node.declaration) {
recordType(node.declaration, declaredTypes)
}
}
function extractRuntimeProps(
node: TSTypeLiteral,
props: Record<string, PropTypeData>,
declaredTypes: Record<string, string[]>
) {
for (const m of node.members) {
if (m.type === 'TSPropertySignature' && m.key.type === 'Identifier') {
props[m.key.name] = {
key: m.key.name,
required: !m.optional,
type:
__DEV__ && m.typeAnnotation
? inferRuntimeType(m.typeAnnotation.typeAnnotation, declaredTypes)
: [`null`]
}
}
}
}
function inferRuntimeType(
node: TSType,
declaredTypes: Record<string, string[]>
): string[] {
switch (node.type) {
case 'TSStringKeyword':
return ['String']
case 'TSNumberKeyword':
return ['Number']
case 'TSBooleanKeyword':
return ['Boolean']
case 'TSObjectKeyword':
return ['Object']
case 'TSTypeLiteral':
// TODO (nice to have) generate runtime property validation
return ['Object']
case 'TSFunctionType':
return ['Function']
case 'TSArrayType':
case 'TSTupleType':
// TODO (nice to have) genrate runtime element type/length checks
return ['Array']
case 'TSLiteralType':
switch (node.literal.type) {
case 'StringLiteral':
return ['String']
case 'BooleanLiteral':
return ['Boolean']
case 'NumericLiteral':
case 'BigIntLiteral':
return ['Number']
default:
return [`null`]
}
case 'TSTypeReference':
if (node.typeName.type === 'Identifier') {
if (declaredTypes[node.typeName.name]) {
return declaredTypes[node.typeName.name]
}
switch (node.typeName.name) {
case 'Array':
case 'Function':
case 'Object':
case 'Set':
case 'Map':
case 'WeakSet':
case 'WeakMap':
return [node.typeName.name]
case 'Record':
case 'Partial':
case 'Readonly':
case 'Pick':
case 'Omit':
case 'Exclude':
case 'Extract':
case 'Required':
case 'InstanceType':
return ['Object']
}
}
return [`null`]
case 'TSUnionType':
return [
...new Set(
[].concat(node.types.map(t =>
inferRuntimeType(t, declaredTypes)
) as any)
)
]
case 'TSIntersectionType':
return ['Object']
default:
return [`null`] // no runtime check
}
}
function genRuntimeProps(props: Record<string, PropTypeData>) {
const keys = Object.keys(props)
if (!keys.length) {
return ``
}
if (!__DEV__) {
// production: generate array version only
return `\n props: [\n ${keys
.map(k => JSON.stringify(k))
.join(',\n ')}\n ] as unknown as undefined,`
}
return `\n props: {\n ${keys
.map(key => {
const { type, required } = props[key]
return `${key}: { type: ${toRuntimeTypeString(
type
)}, required: ${required} }`
})
.join(',\n ')}\n } as unknown as undefined,`
}
function toRuntimeTypeString(types: string[]) {
return types.some(t => t === 'null')
? `null`
: types.length > 1
? `[${types.join(', ')}]`
: types[0]
}
function extractRuntimeEmits(
node: TSFunctionType | TSDeclareFunction,
emits: Set<string>
) {
const eventName =
node.type === 'TSDeclareFunction' ? node.params[0] : node.parameters[0]
if (
eventName.type === 'Identifier' &&
eventName.typeAnnotation &&
eventName.typeAnnotation.type === 'TSTypeAnnotation'
) {
const typeNode = eventName.typeAnnotation.typeAnnotation
if (typeNode.type === 'TSLiteralType') {
emits.add(String(typeNode.literal.value))
} else if (typeNode.type === 'TSUnionType') {
for (const t of typeNode.types) {
if (t.type === 'TSLiteralType') {
emits.add(String(t.literal.value))
}
}
}
}
}
function genRuntimeEmits(emits: Set<string>) {
return emits.size
? `\n emits: [${Array.from(emits)
.map(p => JSON.stringify(p))
.join(', ')}] as unknown as undefined,`
: ``
}
/**
* export default {} inside <script setup> cannot access variables declared
* inside since it's hoisted. Walk and check to make sure.
*/
function checkDefaultExport(
root: Node,
scopeVars: Record<string, boolean>,
imports: Record<string, string>,
exports: Record<string, boolean>,
source: string,
offset: number
) {
const knownIds: Record<string, number> = Object.create(null)
;(walk as any)(root, {
enter(node: Node & { scopeIds?: Set<string> }, parent: Node) {
if (node.type === 'Identifier') {
if (
!knownIds[node.name] &&
!isStaticPropertyKey(node, parent) &&
(scopeVars[node.name] || (!imports[node.name] && exports[node.name]))
) {
throw new Error(
`\`export default\` in <script setup> cannot reference locally ` +
`declared variables because it will be hoisted outside of the ` +
`setup() function. If your component options requires initialization ` +
`in the module scope, use a separate normal <script> to export ` +
`the options instead.\n\n` +
generateCodeFrame(
source,
node.start! + offset,
node.end! + offset
)
)
}
} else if (isFunction(node)) {
// walk function expressions and add its arguments to known identifiers
// so that we don't prefix them
node.params.forEach(p =>
(walk as any)(p, {
enter(child: Node, parent: Node) {
if (
child.type === 'Identifier' &&
// do not record as scope variable if is a destructured key
!isStaticPropertyKey(child, parent) &&
// do not record if this is a default value
// assignment of a destructured variable
!(
parent &&
parent.type === 'AssignmentPattern' &&
parent.right === child
)
) {
const { name } = child
if (node.scopeIds && node.scopeIds.has(name)) {
return
}
if (name in knownIds) {
knownIds[name]++
} else {
knownIds[name] = 1
}
;(node.scopeIds || (node.scopeIds = new Set())).add(name)
}
}
})
)
}
},
leave(node: Node & { scopeIds?: Set<string> }) {
if (node.scopeIds) {
node.scopeIds.forEach((id: string) => {
knownIds[id]--
if (knownIds[id] === 0) {
delete knownIds[id]
}
})
}
}
})
}
function isStaticPropertyKey(node: Node, parent: Node): boolean {
return (
parent &&
(parent.type === 'ObjectProperty' || parent.type === 'ObjectMethod') &&
!parent.computed &&
parent.key === node
)
}
function isFunction(node: Node): node is FunctionNode {
return /Function(?:Expression|Declaration)$|Method$/.test(node.type)
}
/**
* Analyze bindings in normal `<script>`
* Note that `compileScriptSetup` already analyzes bindings as part of its
* compilation process so this should only be used on single `<script>` SFCs.
*/
export function analyzeScriptBindings(
_script: SFCScriptBlock
): BindingMetadata {
return {
// TODO
}
}
| packages/compiler-sfc/src/compileScript.ts | 1 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.9975548386573792,
0.010444240644574165,
0.0001628273748792708,
0.00017374921299051493,
0.10022686421871185
] |
{
"id": 2,
"code_window": [
" hasWarned = true\n",
" console.log(\n",
" `\\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\\n` +\n",
" `Follow https://github.com/vuejs/rfcs/pull/182 for its status.\\n`\n",
" )\n",
" }\n",
"\n"
],
"labels": [
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" // @ts-ignore `console.info` cannot be null error\n",
" console[console.info ? 'info' : 'log'](\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 44
} | import {
ComponentPublicInstance,
getCurrentInstance,
onMounted,
watchEffect,
warn,
VNode,
Fragment
} from '@vue/runtime-core'
import { ShapeFlags } from '@vue/shared/src'
export function useCssVars(
getter: (ctx: ComponentPublicInstance) => Record<string, string>,
scoped = false
) {
const instance = getCurrentInstance()
/* istanbul ignore next */
if (!instance) {
__DEV__ &&
warn(`useCssVars is called without current active component instance.`)
return
}
const prefix =
scoped && instance.type.__scopeId
? `${instance.type.__scopeId.replace(/^data-v-/, '')}-`
: ``
onMounted(() => {
watchEffect(() => {
setVarsOnVNode(instance.subTree, getter(instance.proxy!), prefix)
})
})
}
function setVarsOnVNode(
vnode: VNode,
vars: Record<string, string>,
prefix: string
) {
// drill down HOCs until it's a non-component vnode
while (vnode.component) {
vnode = vnode.component.subTree
}
if (vnode.shapeFlag & ShapeFlags.ELEMENT && vnode.el) {
const style = vnode.el.style
for (const key in vars) {
style.setProperty(`--${prefix}${key}`, vars[key])
}
} else if (vnode.type === Fragment) {
;(vnode.children as VNode[]).forEach(c => setVarsOnVNode(c, vars, prefix))
}
}
| packages/runtime-dom/src/helpers/useCssVars.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00017491602920927107,
0.00017058616504073143,
0.00016610529564786702,
0.0001708752242848277,
0.0000036851943150395527
] |
{
"id": 2,
"code_window": [
" hasWarned = true\n",
" console.log(\n",
" `\\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\\n` +\n",
" `Follow https://github.com/vuejs/rfcs/pull/182 for its status.\\n`\n",
" )\n",
" }\n",
"\n"
],
"labels": [
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" // @ts-ignore `console.info` cannot be null error\n",
" console[console.info ? 'info' : 'log'](\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 44
} | import {
h,
render,
nodeOps,
VNodeProps,
TestElement,
NodeTypes,
VNode
} from '@vue/runtime-test'
describe('renderer: vnode hooks', () => {
function assertHooks(hooks: VNodeProps, vnode1: VNode, vnode2: VNode) {
const root = nodeOps.createElement('div')
render(vnode1, root)
expect(hooks.onVnodeBeforeMount).toHaveBeenCalledWith(vnode1, null)
expect(hooks.onVnodeMounted).toHaveBeenCalledWith(vnode1, null)
expect(hooks.onVnodeBeforeUpdate).not.toHaveBeenCalled()
expect(hooks.onVnodeUpdated).not.toHaveBeenCalled()
expect(hooks.onVnodeBeforeUnmount).not.toHaveBeenCalled()
expect(hooks.onVnodeUnmounted).not.toHaveBeenCalled()
// update
render(vnode2, root)
expect(hooks.onVnodeBeforeMount).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeMounted).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeBeforeUpdate).toHaveBeenCalledWith(vnode2, vnode1)
expect(hooks.onVnodeUpdated).toHaveBeenCalledWith(vnode2, vnode1)
expect(hooks.onVnodeBeforeUnmount).not.toHaveBeenCalled()
expect(hooks.onVnodeUnmounted).not.toHaveBeenCalled()
// unmount
render(null, root)
expect(hooks.onVnodeBeforeMount).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeMounted).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeBeforeUpdate).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeUpdated).toHaveBeenCalledTimes(1)
expect(hooks.onVnodeBeforeUnmount).toHaveBeenCalledWith(vnode2, null)
expect(hooks.onVnodeUnmounted).toHaveBeenCalledWith(vnode2, null)
}
test('should work on element', () => {
const hooks: VNodeProps = {
onVnodeBeforeMount: jest.fn(),
onVnodeMounted: jest.fn(),
onVnodeBeforeUpdate: jest.fn(vnode => {
expect((vnode.el as TestElement).children[0]).toMatchObject({
type: NodeTypes.TEXT,
text: 'foo'
})
}),
onVnodeUpdated: jest.fn(vnode => {
expect((vnode.el as TestElement).children[0]).toMatchObject({
type: NodeTypes.TEXT,
text: 'bar'
})
}),
onVnodeBeforeUnmount: jest.fn(),
onVnodeUnmounted: jest.fn()
}
assertHooks(hooks, h('div', hooks, 'foo'), h('div', hooks, 'bar'))
})
test('should work on component', () => {
const Comp = (props: { msg: string }) => props.msg
const hooks: VNodeProps = {
onVnodeBeforeMount: jest.fn(),
onVnodeMounted: jest.fn(),
onVnodeBeforeUpdate: jest.fn(vnode => {
expect(vnode.el as TestElement).toMatchObject({
type: NodeTypes.TEXT,
text: 'foo'
})
}),
onVnodeUpdated: jest.fn(vnode => {
expect(vnode.el as TestElement).toMatchObject({
type: NodeTypes.TEXT,
text: 'bar'
})
}),
onVnodeBeforeUnmount: jest.fn(),
onVnodeUnmounted: jest.fn()
}
assertHooks(
hooks,
h(Comp, {
...hooks,
msg: 'foo'
}),
h(Comp, {
...hooks,
msg: 'bar'
})
)
})
})
| packages/runtime-core/__tests__/vnodeHooks.spec.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00017718368326313794,
0.00017265917267650366,
0.0001651592756388709,
0.00017390020366292447,
0.000003499405238471809
] |
{
"id": 2,
"code_window": [
" hasWarned = true\n",
" console.log(\n",
" `\\n[@vue/compiler-sfc] <script setup> is still an experimental proposal.\\n` +\n",
" `Follow https://github.com/vuejs/rfcs/pull/182 for its status.\\n`\n",
" )\n",
" }\n",
"\n"
],
"labels": [
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" // @ts-ignore `console.info` cannot be null error\n",
" console[console.info ? 'info' : 'log'](\n"
],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 44
} | 'use strict'
if (process.env.NODE_ENV === 'production') {
module.exports = require('./dist/runtime-dom.cjs.prod.js')
} else {
module.exports = require('./dist/runtime-dom.cjs.js')
}
| packages/runtime-dom/index.js | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00017357192700728774,
0.00017357192700728774,
0.00017357192700728774,
0.00017357192700728774,
0
] |
{
"id": 3,
"code_window": [
" )\n",
" }\n",
"\n",
" const { script, scriptSetup, styles, source, filename } = sfc\n",
" const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')\n",
"\n",
" const isTS =\n",
" (script && script.lang === 'ts') ||\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 50
} | import { parse, SFCScriptCompileOptions } from '../src'
import { parse as babelParse } from '@babel/parser'
import { babelParserDefautPlugins } from '@vue/shared'
function compile(src: string, options?: SFCScriptCompileOptions) {
return parse(src, options).descriptor.scriptTransformed!
}
function assertCode(code: string) {
// parse the generated code to make sure it is valid
try {
babelParse(code, {
sourceType: 'module',
plugins: [...babelParserDefautPlugins, 'typescript']
})
} catch (e) {
console.log(code)
throw e
}
expect(code).toMatchSnapshot()
}
describe('SFC compile <script setup>', () => {
test('should hoist imports', () => {
assertCode(
compile(`<script setup>import { ref } from 'vue'</script>`).content
)
})
test('explicit setup signature', () => {
assertCode(
compile(`<script setup="props, { emit }">emit('foo')</script>`).content
)
})
test('import dedupe between <script> and <script setup>', () => {
const { content } = compile(`
<script>
import { x } from './x'
</script>
<script setup>
import { x } from './x'
x()
</script>
`)
assertCode(content)
expect(content.indexOf(`import { x }`)).toEqual(
content.lastIndexOf(`import { x }`)
)
})
describe('exports', () => {
test('export const x = ...', () => {
const { content, bindings } = compile(
`<script setup>export const x = 1</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup'
})
})
test('export const { x } = ... (destructuring)', () => {
const { content, bindings } = compile(`<script setup>
export const [a = 1, { b } = { b: 123 }, ...c] = useFoo()
export const { d = 2, _: [e], ...f } = useBar()
</script>`)
assertCode(content)
expect(bindings).toStrictEqual({
a: 'setup',
b: 'setup',
c: 'setup',
d: 'setup',
e: 'setup',
f: 'setup'
})
})
test('export function x() {}', () => {
const { content, bindings } = compile(
`<script setup>export function x(){}</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup'
})
})
test('export class X() {}', () => {
const { content, bindings } = compile(
`<script setup>export class X {}</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
X: 'setup'
})
})
test('export { x }', () => {
const { content, bindings } = compile(
`<script setup>
const x = 1
const y = 2
export { x, y }
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup',
y: 'setup'
})
})
test(`export { x } from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export { x, y } from './x'
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
x: 'setup',
y: 'setup'
})
})
test(`export default from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export default from './x'
</script>`,
{
babelParserPlugins: ['exportDefaultFrom']
}
)
assertCode(content)
expect(bindings).toStrictEqual({})
})
test(`export { x as default }`, () => {
const { content, bindings } = compile(
`<script setup>
import x from './x'
const y = 1
export { x as default, y }
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
test(`export { x as default } from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export { x as default, y } from './x'
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
test(`export * from './x'`, () => {
const { content, bindings } = compile(
`<script setup>
export * from './x'
export const y = 1
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
// in this case we cannot extract bindings from ./x so it falls back
// to runtime proxy dispatching
})
})
test('export default in <script setup>', () => {
const { content, bindings } = compile(
`<script setup>
export default {
props: ['foo']
}
export const y = 1
</script>`
)
assertCode(content)
expect(bindings).toStrictEqual({
y: 'setup'
})
})
})
describe('<script setup lang="ts">', () => {
test('hoist type declarations', () => {
const { content, bindings } = compile(`
<script setup lang="ts">
export interface Foo {}
type Bar = {}
export const a = 1
</script>`)
assertCode(content)
expect(bindings).toStrictEqual({ a: 'setup' })
})
test('extract props', () => {
const { content } = compile(`
<script setup="myProps" lang="ts">
interface Test {}
type Alias = number[]
declare const myProps: {
string: string
number: number
boolean: boolean
object: object
objectLiteral: { a: number }
fn: (n: number) => void
functionRef: Function
objectRef: Object
array: string[]
arrayRef: Array<any>
tuple: [number, number]
set: Set<string>
literal: 'foo'
optional?: any
recordRef: Record<string, null>
interface: Test
alias: Alias
union: string | number
literalUnion: 'foo' | 'bar'
literalUnionMixed: 'foo' | 1 | boolean
intersection: Test & {}
}
</script>`)
assertCode(content)
expect(content).toMatch(`string: { type: String, required: true }`)
expect(content).toMatch(`number: { type: Number, required: true }`)
expect(content).toMatch(`boolean: { type: Boolean, required: true }`)
expect(content).toMatch(`object: { type: Object, required: true }`)
expect(content).toMatch(`objectLiteral: { type: Object, required: true }`)
expect(content).toMatch(`fn: { type: Function, required: true }`)
expect(content).toMatch(`functionRef: { type: Function, required: true }`)
expect(content).toMatch(`objectRef: { type: Object, required: true }`)
expect(content).toMatch(`array: { type: Array, required: true }`)
expect(content).toMatch(`arrayRef: { type: Array, required: true }`)
expect(content).toMatch(`tuple: { type: Array, required: true }`)
expect(content).toMatch(`set: { type: Set, required: true }`)
expect(content).toMatch(`literal: { type: String, required: true }`)
expect(content).toMatch(`optional: { type: null, required: false }`)
expect(content).toMatch(`recordRef: { type: Object, required: true }`)
expect(content).toMatch(`interface: { type: Object, required: true }`)
expect(content).toMatch(`alias: { type: Array, required: true }`)
expect(content).toMatch(
`union: { type: [String, Number], required: true }`
)
expect(content).toMatch(
`literalUnion: { type: [String, String], required: true }`
)
expect(content).toMatch(
`literalUnionMixed: { type: [String, Number, Boolean], required: true }`
)
expect(content).toMatch(`intersection: { type: Object, required: true }`)
})
test('extract emits', () => {
const { content } = compile(`
<script setup="_, { emit: myEmit }" lang="ts">
declare function myEmit(e: 'foo' | 'bar'): void
declare function myEmit(e: 'baz', id: number): void
</script>
`)
assertCode(content)
expect(content).toMatch(
`declare function __emit__(e: 'foo' | 'bar'): void`
)
expect(content).toMatch(
`declare function __emit__(e: 'baz', id: number): void`
)
expect(content).toMatch(
`emits: ["foo", "bar", "baz"] as unknown as undefined`
)
})
})
describe('CSS vars injection', () => {
test('<script> w/ no default export', () => {
assertCode(
compile(
`<script>const a = 1</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('<script> w/ default export', () => {
assertCode(
compile(
`<script>export default { setup() {} }</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('<script> w/ default export in strings/comments', () => {
assertCode(
compile(
`<script>
// export default {}
export default {}
</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
test('w/ <script setup>', () => {
assertCode(
compile(
`<script setup>export const color = 'red'</script>\n` +
`<style vars="{ color }">div{ color: var(--color); }</style>`
).content
)
})
})
describe('async/await detection', () => {
function assertAwaitDetection(code: string, shouldAsync = true) {
const { content } = compile(`<script setup>${code}</script>`)
expect(content).toMatch(
`export ${shouldAsync ? `async ` : ``}function setup`
)
}
test('expression statement', () => {
assertAwaitDetection(`await foo`)
})
test('variable', () => {
assertAwaitDetection(`const a = 1 + (await foo)`)
})
test('export', () => {
assertAwaitDetection(`export const a = 1 + (await foo)`)
})
test('nested statements', () => {
assertAwaitDetection(`if (ok) { await foo } else { await bar }`)
})
test('should ignore await inside functions', () => {
// function declaration
assertAwaitDetection(`export async function foo() { await bar }`, false)
// function expression
assertAwaitDetection(`const foo = async () => { await bar }`, false)
// object method
assertAwaitDetection(`const obj = { async method() { await bar }}`, false)
// class method
assertAwaitDetection(
`const cls = class Foo { async method() { await bar }}`,
false
)
})
})
describe('errors', () => {
test('<script> and <script setup> must have same lang', () => {
expect(
parse(`<script>foo()</script><script setup lang="ts">bar()</script>`)
.errors[0].message
).toMatch(`<script> and <script setup> must have the same language type`)
})
test('export local as default', () => {
expect(
parse(`<script setup>
const bar = 1
export { bar as default }
</script>`).errors[0].message
).toMatch(`Cannot export locally defined variable as default`)
})
test('export default referencing local var', () => {
expect(
parse(`<script setup>
const bar = 1
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).errors[0].message
).toMatch(`cannot reference locally declared variables`)
})
test('export default referencing exports', () => {
expect(
parse(`<script setup>
export const bar = 1
export default {
props: bar
}
</script>`).errors[0].message
).toMatch(`cannot reference locally declared variables`)
})
test('should allow export default referencing scope var', () => {
assertCode(
compile(`<script setup>
const bar = 1
export default {
props: {
foo: {
default: bar => bar + 1
}
}
}
</script>`).content
)
})
test('should allow export default referencing imported binding', () => {
assertCode(
compile(`<script setup>
import { bar } from './bar'
export { bar }
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).content
)
})
test('should allow export default referencing re-exported binding', () => {
assertCode(
compile(`<script setup>
export { bar } from './bar'
export default {
props: {
foo: {
default: () => bar
}
}
}
</script>`).content
)
})
test('error on duplicated defalut export', () => {
expect(
parse(`
<script>
export default {}
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export default {}
</script>
<script setup>
const x = {}
export { x as default }
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export default {}
</script>
<script setup>
export { x as default } from './y'
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
export { x as default } from './y'
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
expect(
parse(`
<script>
const x = {}
export { x as default }
</script>
<script setup>
export default {}
</script>
`).errors[0].message
).toMatch(`Default export is already declared`)
})
})
})
| packages/compiler-sfc/__tests__/compileScript.spec.ts | 1 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.014565115794539452,
0.0013696918031200767,
0.00016532755398657173,
0.00026637990958988667,
0.0029772233683615923
] |
{
"id": 3,
"code_window": [
" )\n",
" }\n",
"\n",
" const { script, scriptSetup, styles, source, filename } = sfc\n",
" const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')\n",
"\n",
" const isTS =\n",
" (script && script.lang === 'ts') ||\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 50
} | import { RendererOptions } from '@vue/runtime-core'
export const svgNS = 'http://www.w3.org/2000/svg'
const doc = (typeof document !== 'undefined' ? document : null) as Document
let tempContainer: HTMLElement
let tempSVGContainer: SVGElement
export const nodeOps: Omit<RendererOptions<Node, Element>, 'patchProp'> = {
insert: (child, parent, anchor) => {
parent.insertBefore(child, anchor || null)
},
remove: child => {
const parent = child.parentNode
if (parent) {
parent.removeChild(child)
}
},
createElement: (tag, isSVG, is): Element =>
isSVG
? doc.createElementNS(svgNS, tag)
: doc.createElement(tag, is ? { is } : undefined),
createText: text => doc.createTextNode(text),
createComment: text => doc.createComment(text),
setText: (node, text) => {
node.nodeValue = text
},
setElementText: (el, text) => {
el.textContent = text
},
parentNode: node => node.parentNode as Element | null,
nextSibling: node => node.nextSibling,
querySelector: selector => doc.querySelector(selector),
setScopeId(el, id) {
el.setAttribute(id, '')
},
cloneNode(el) {
return el.cloneNode(true)
},
// __UNSAFE__
// Reason: innerHTML.
// Static content here can only come from compiled templates.
// As long as the user only uses trusted templates, this is safe.
insertStaticContent(content, parent, anchor, isSVG) {
const temp = isSVG
? tempSVGContainer ||
(tempSVGContainer = doc.createElementNS(svgNS, 'svg'))
: tempContainer || (tempContainer = doc.createElement('div'))
temp.innerHTML = content
const first = temp.firstChild as Element
let node: Element | null = first
let last: Element = node
while (node) {
last = node
nodeOps.insert(node, parent, anchor)
node = temp.firstChild as Element
}
return [first, last]
}
}
| packages/runtime-dom/src/nodeOps.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00017373586888425052,
0.00017088867025449872,
0.0001660229463595897,
0.00017136498354375362,
0.000002251914793305332
] |
{
"id": 3,
"code_window": [
" )\n",
" }\n",
"\n",
" const { script, scriptSetup, styles, source, filename } = sfc\n",
" const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')\n",
"\n",
" const isTS =\n",
" (script && script.lang === 'ts') ||\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 50
} | import { compileTemplate } from '../src/compileTemplate'
import { parse, SFCTemplateBlock } from '../src/parse'
test('should work', () => {
const source = `<div><p>{{ render }}</p></div>`
const result = compileTemplate({ filename: 'example.vue', source })
expect(result.errors.length).toBe(0)
expect(result.source).toBe(source)
// should expose render fn
expect(result.code).toMatch(`export function render(`)
})
test('preprocess pug', () => {
const template = parse(
`
<template lang="pug">
body
h1 Pug Examples
div.container
p Cool Pug example!
</template>
`,
{ filename: 'example.vue', sourceMap: true }
).descriptor.template as SFCTemplateBlock
const result = compileTemplate({
filename: 'example.vue',
source: template.content,
preprocessLang: template.lang
})
expect(result.errors.length).toBe(0)
})
test('warn missing preprocessor', () => {
const template = parse(`<template lang="unknownLang">hi</template>\n`, {
filename: 'example.vue',
sourceMap: true
}).descriptor.template as SFCTemplateBlock
const result = compileTemplate({
filename: 'example.vue',
source: template.content,
preprocessLang: template.lang
})
expect(result.errors.length).toBe(1)
})
test('transform asset url options', () => {
const input = { source: `<foo bar="~baz"/>`, filename: 'example.vue' }
// Object option
const { code: code1 } = compileTemplate({
...input,
transformAssetUrls: {
tags: { foo: ['bar'] }
}
})
expect(code1).toMatch(`import _imports_0 from 'baz'\n`)
// legacy object option (direct tags config)
const { code: code2 } = compileTemplate({
...input,
transformAssetUrls: {
foo: ['bar']
}
})
expect(code2).toMatch(`import _imports_0 from 'baz'\n`)
// false option
const { code: code3 } = compileTemplate({
...input,
transformAssetUrls: false
})
expect(code3).not.toMatch(`import _imports_0 from 'baz'\n`)
})
test('source map', () => {
const template = parse(
`
<template>
<div><p>{{ render }}</p></div>
</template>
`,
{ filename: 'example.vue', sourceMap: true }
).descriptor.template as SFCTemplateBlock
const result = compileTemplate({
filename: 'example.vue',
source: template.content
})
expect(result.map).toMatchSnapshot()
})
test('template errors', () => {
const result = compileTemplate({
filename: 'example.vue',
source: `<div :foo
:bar="a[" v-model="baz"/>`
})
expect(result.errors).toMatchSnapshot()
})
test('preprocessor errors', () => {
const template = parse(
`
<template lang="pug">
div(class='class)
</template>
`,
{ filename: 'example.vue', sourceMap: true }
).descriptor.template as SFCTemplateBlock
const result = compileTemplate({
filename: 'example.vue',
source: template.content,
preprocessLang: template.lang
})
expect(result.errors.length).toBe(1)
const message = result.errors[0].toString()
expect(message).toMatch(`Error: example.vue:3:1`)
expect(message).toMatch(
`The end of the string reached with no closing bracket ) found.`
)
})
| packages/compiler-sfc/__tests__/compileTemplate.spec.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.00019325796165503561,
0.00017172346997540444,
0.00016622254042886198,
0.0001693472731858492,
0.000006602782832487719
] |
{
"id": 3,
"code_window": [
" )\n",
" }\n",
"\n",
" const { script, scriptSetup, styles, source, filename } = sfc\n",
" const hasCssVars = styles.some(s => typeof s.attrs.vars === 'string')\n",
"\n",
" const isTS =\n",
" (script && script.lang === 'ts') ||\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [],
"file_path": "packages/compiler-sfc/src/compileScript.ts",
"type": "replace",
"edit_start_line_idx": 50
} | import {
VNode,
normalizeVNode,
Text,
Comment,
Static,
Fragment,
VNodeHook
} from './vnode'
import { flushPostFlushCbs } from './scheduler'
import { ComponentOptions, ComponentInternalInstance } from './component'
import { invokeDirectiveHook } from './directives'
import { warn } from './warning'
import { PatchFlags, ShapeFlags, isReservedProp, isOn } from '@vue/shared'
import { RendererInternals, invokeVNodeHook, setRef } from './renderer'
import {
SuspenseImpl,
SuspenseBoundary,
queueEffectWithSuspense
} from './components/Suspense'
import { TeleportImpl } from './components/Teleport'
export type RootHydrateFunction = (
vnode: VNode<Node, Element>,
container: Element
) => void
const enum DOMNodeTypes {
ELEMENT = 1,
TEXT = 3,
COMMENT = 8
}
let hasMismatch = false
const isSVGContainer = (container: Element) =>
/svg/.test(container.namespaceURI!) && container.tagName !== 'foreignObject'
const isComment = (node: Node): node is Comment =>
node.nodeType === DOMNodeTypes.COMMENT
// Note: hydration is DOM-specific
// But we have to place it in core due to tight coupling with core - splitting
// it out creates a ton of unnecessary complexity.
// Hydration also depends on some renderer internal logic which needs to be
// passed in via arguments.
export function createHydrationFunctions(
rendererInternals: RendererInternals<Node, Element>
) {
const {
mt: mountComponent,
p: patch,
o: { patchProp, nextSibling, parentNode, remove, insert, createComment }
} = rendererInternals
const hydrate: RootHydrateFunction = (vnode, container) => {
if (__DEV__ && !container.hasChildNodes()) {
warn(
`Attempting to hydrate existing markup but container is empty. ` +
`Performing full mount instead.`
)
patch(null, vnode, container)
return
}
hasMismatch = false
hydrateNode(container.firstChild!, vnode, null, null)
flushPostFlushCbs()
if (hasMismatch && !__TEST__) {
// this error should show up in production
console.error(`Hydration completed but contains mismatches.`)
}
}
const hydrateNode = (
node: Node,
vnode: VNode,
parentComponent: ComponentInternalInstance | null,
parentSuspense: SuspenseBoundary | null,
optimized = false
): Node | null => {
const isFragmentStart = isComment(node) && node.data === '['
const onMismatch = () =>
handleMismatch(
node,
vnode,
parentComponent,
parentSuspense,
isFragmentStart
)
const { type, ref, shapeFlag } = vnode
const domType = node.nodeType
vnode.el = node
let nextNode: Node | null = null
switch (type) {
case Text:
if (domType !== DOMNodeTypes.TEXT) {
nextNode = onMismatch()
} else {
if ((node as Text).data !== vnode.children) {
hasMismatch = true
__DEV__ &&
warn(
`Hydration text mismatch:` +
`\n- Client: ${JSON.stringify((node as Text).data)}` +
`\n- Server: ${JSON.stringify(vnode.children)}`
)
;(node as Text).data = vnode.children as string
}
nextNode = nextSibling(node)
}
break
case Comment:
if (domType !== DOMNodeTypes.COMMENT || isFragmentStart) {
nextNode = onMismatch()
} else {
nextNode = nextSibling(node)
}
break
case Static:
if (domType !== DOMNodeTypes.ELEMENT) {
nextNode = onMismatch()
} else {
// determine anchor, adopt content
nextNode = node
// if the static vnode has its content stripped during build,
// adopt it from the server-rendered HTML.
const needToAdoptContent = !(vnode.children as string).length
for (let i = 0; i < vnode.staticCount; i++) {
if (needToAdoptContent)
vnode.children += (nextNode as Element).outerHTML
if (i === vnode.staticCount - 1) {
vnode.anchor = nextNode
}
nextNode = nextSibling(nextNode)!
}
return nextNode
}
break
case Fragment:
if (!isFragmentStart) {
nextNode = onMismatch()
} else {
nextNode = hydrateFragment(
node as Comment,
vnode,
parentComponent,
parentSuspense,
optimized
)
}
break
default:
if (shapeFlag & ShapeFlags.ELEMENT) {
if (
domType !== DOMNodeTypes.ELEMENT ||
vnode.type !== (node as Element).tagName.toLowerCase()
) {
nextNode = onMismatch()
} else {
nextNode = hydrateElement(
node as Element,
vnode,
parentComponent,
parentSuspense,
optimized
)
}
} else if (shapeFlag & ShapeFlags.COMPONENT) {
// when setting up the render effect, if the initial vnode already
// has .el set, the component will perform hydration instead of mount
// on its sub-tree.
const container = parentNode(node)!
const hydrateComponent = () => {
mountComponent(
vnode,
container,
null,
parentComponent,
parentSuspense,
isSVGContainer(container),
optimized
)
}
// async component
const loadAsync = (vnode.type as ComponentOptions).__asyncLoader
if (loadAsync) {
loadAsync().then(hydrateComponent)
} else {
hydrateComponent()
}
// component may be async, so in the case of fragments we cannot rely
// on component's rendered output to determine the end of the fragment
// instead, we do a lookahead to find the end anchor node.
nextNode = isFragmentStart
? locateClosingAsyncAnchor(node)
: nextSibling(node)
} else if (shapeFlag & ShapeFlags.TELEPORT) {
if (domType !== DOMNodeTypes.COMMENT) {
nextNode = onMismatch()
} else {
nextNode = (vnode.type as typeof TeleportImpl).hydrate(
node,
vnode,
parentComponent,
parentSuspense,
optimized,
rendererInternals,
hydrateChildren
)
}
} else if (__FEATURE_SUSPENSE__ && shapeFlag & ShapeFlags.SUSPENSE) {
nextNode = (vnode.type as typeof SuspenseImpl).hydrate(
node,
vnode,
parentComponent,
parentSuspense,
isSVGContainer(parentNode(node)!),
optimized,
rendererInternals,
hydrateNode
)
} else if (__DEV__) {
warn('Invalid HostVNode type:', type, `(${typeof type})`)
}
}
if (ref != null && parentComponent) {
setRef(ref, null, parentComponent, parentSuspense, vnode)
}
return nextNode
}
const hydrateElement = (
el: Element,
vnode: VNode,
parentComponent: ComponentInternalInstance | null,
parentSuspense: SuspenseBoundary | null,
optimized: boolean
) => {
optimized = optimized || !!vnode.dynamicChildren
const { props, patchFlag, shapeFlag, dirs } = vnode
// skip props & children if this is hoisted static nodes
if (patchFlag !== PatchFlags.HOISTED) {
// props
if (props) {
if (
!optimized ||
(patchFlag & PatchFlags.FULL_PROPS ||
patchFlag & PatchFlags.HYDRATE_EVENTS)
) {
for (const key in props) {
if (!isReservedProp(key) && isOn(key)) {
patchProp(el, key, null, props[key])
}
}
} else if (props.onClick) {
// Fast path for click listeners (which is most often) to avoid
// iterating through props.
patchProp(el, 'onClick', null, props.onClick)
}
}
// vnode / directive hooks
let vnodeHooks: VNodeHook | null | undefined
if ((vnodeHooks = props && props.onVnodeBeforeMount)) {
invokeVNodeHook(vnodeHooks, parentComponent, vnode)
}
if (dirs) {
invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount')
}
if ((vnodeHooks = props && props.onVnodeMounted) || dirs) {
queueEffectWithSuspense(() => {
vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode)
dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted')
}, parentSuspense)
}
// children
if (
shapeFlag & ShapeFlags.ARRAY_CHILDREN &&
// skip if element has innerHTML / textContent
!(props && (props.innerHTML || props.textContent))
) {
let next = hydrateChildren(
el.firstChild,
vnode,
el,
parentComponent,
parentSuspense,
optimized
)
let hasWarned = false
while (next) {
hasMismatch = true
if (__DEV__ && !hasWarned) {
warn(
`Hydration children mismatch in <${vnode.type as string}>: ` +
`server rendered element contains more child nodes than client vdom.`
)
hasWarned = true
}
// The SSRed DOM contains more nodes than it should. Remove them.
const cur = next
next = next.nextSibling
remove(cur)
}
} else if (shapeFlag & ShapeFlags.TEXT_CHILDREN) {
if (el.textContent !== vnode.children) {
hasMismatch = true
__DEV__ &&
warn(
`Hydration text content mismatch in <${vnode.type as string}>:\n` +
`- Client: ${el.textContent}\n` +
`- Server: ${vnode.children as string}`
)
el.textContent = vnode.children as string
}
}
}
return el.nextSibling
}
const hydrateChildren = (
node: Node | null,
vnode: VNode,
container: Element,
parentComponent: ComponentInternalInstance | null,
parentSuspense: SuspenseBoundary | null,
optimized: boolean
): Node | null => {
optimized = optimized || !!vnode.dynamicChildren
const children = vnode.children as VNode[]
const l = children.length
let hasWarned = false
for (let i = 0; i < l; i++) {
const vnode = optimized
? children[i]
: (children[i] = normalizeVNode(children[i]))
if (node) {
node = hydrateNode(
node,
vnode,
parentComponent,
parentSuspense,
optimized
)
} else {
hasMismatch = true
if (__DEV__ && !hasWarned) {
warn(
`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` +
`server rendered element contains fewer child nodes than client vdom.`
)
hasWarned = true
}
// the SSRed DOM didn't contain enough nodes. Mount the missing ones.
patch(
null,
vnode,
container,
null,
parentComponent,
parentSuspense,
isSVGContainer(container)
)
}
}
return node
}
const hydrateFragment = (
node: Comment,
vnode: VNode,
parentComponent: ComponentInternalInstance | null,
parentSuspense: SuspenseBoundary | null,
optimized: boolean
) => {
const container = parentNode(node)!
const next = hydrateChildren(
nextSibling(node)!,
vnode,
container,
parentComponent,
parentSuspense,
optimized
)
if (next && isComment(next) && next.data === ']') {
return nextSibling((vnode.anchor = next))
} else {
// fragment didn't hydrate successfully, since we didn't get a end anchor
// back. This should have led to node/children mismatch warnings.
hasMismatch = true
// since the anchor is missing, we need to create one and insert it
insert((vnode.anchor = createComment(`]`)), container, next)
return next
}
}
const handleMismatch = (
node: Node,
vnode: VNode,
parentComponent: ComponentInternalInstance | null,
parentSuspense: SuspenseBoundary | null,
isFragment: boolean
): Node | null => {
hasMismatch = true
__DEV__ &&
warn(
`Hydration node mismatch:\n- Client vnode:`,
vnode.type,
`\n- Server rendered DOM:`,
node,
node.nodeType === DOMNodeTypes.TEXT
? `(text)`
: isComment(node) && node.data === '['
? `(start of fragment)`
: ``
)
vnode.el = null
if (isFragment) {
// remove excessive fragment nodes
const end = locateClosingAsyncAnchor(node)
while (true) {
const next = nextSibling(node)
if (next && next !== end) {
remove(next)
} else {
break
}
}
}
const next = nextSibling(node)
const container = parentNode(node)!
remove(node)
patch(
null,
vnode,
container,
next,
parentComponent,
parentSuspense,
isSVGContainer(container)
)
return next
}
const locateClosingAsyncAnchor = (node: Node | null): Node | null => {
let match = 0
while (node) {
node = nextSibling(node)
if (node && isComment(node)) {
if (node.data === '[') match++
if (node.data === ']') {
if (match === 0) {
return nextSibling(node)
} else {
match--
}
}
}
}
return node
}
return [hydrate, hydrateNode] as const
}
| packages/runtime-core/src/hydration.ts | 0 | https://github.com/vuejs/core/commit/9146cc485e317ff29192796f9366471144ed3ad2 | [
0.0009867760818451643,
0.00020150929049123079,
0.00016489838890265673,
0.00016955140745267272,
0.00015218059706967324
] |
{
"id": 0,
"code_window": [
" \"build/dist/material-ui-pickers.esm.js\": {\n",
" \"bundled\": 113798,\n",
" \"minified\": 66892,\n",
" \"gzipped\": 14510,\n",
" \"treeshaked\": {\n",
" \"rollup\": {\n",
" \"code\": 49182,\n",
" \"import_statements\": 1317\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" \"gzipped\": 14511,\n"
],
"file_path": "lib/.size-snapshot.json",
"type": "replace",
"edit_start_line_idx": 4
} | import { Theme } from '@material-ui/core';
import createStyles from '@material-ui/core/styles/createStyles';
import withStyles, { WithStyles } from '@material-ui/core/styles/withStyles';
import classnames from 'classnames';
import * as PropTypes from 'prop-types';
import * as React from 'react';
import { CSSTransition, TransitionGroup } from 'react-transition-group';
export type SlideDirection = 'right' | 'left';
interface SlideTransitionProps extends WithStyles<typeof styles> {
transKey: React.Key;
className?: string;
slideDirection: SlideDirection;
children: React.ReactChild;
}
const animationDuration = 350;
const SlideTransition: React.SFC<SlideTransitionProps> = ({
classes,
className,
children,
transKey,
slideDirection,
}) => (
<TransitionGroup
className={classnames(classes.transitionContainer, className)}
>
<CSSTransition
key={transKey}
mountOnEnter
unmountOnExit
timeout={animationDuration}
children={children}
classNames={{
enter: classes[`slideEnter-${slideDirection}`],
enterActive: classes.slideEnterActive,
exit: classes.slideExit,
exitActive: classes[`slideExitActiveLeft-${slideDirection}`],
}}
/>
</TransitionGroup>
);
(SlideTransition as any).propTypes = {
classes: PropTypes.shape({}).isRequired,
children: PropTypes.node.isRequired,
className: PropTypes.string,
slideDirection: PropTypes.oneOf(['left', 'right']).isRequired,
transKey: PropTypes.string.isRequired,
innerRef: PropTypes.any,
};
SlideTransition.defaultProps = {
className: undefined,
};
const styles = (theme: Theme) => {
const slideTransition = theme.transitions.create('transform', {
duration: animationDuration,
easing: 'cubic-bezier(0.35, 0.8, 0.4, 1)',
});
return createStyles({
transitionContainer: {
display: 'block',
position: 'relative',
'& > *': {
position: 'absolute',
top: 0,
right: 0,
left: 0,
},
},
'slideEnter-left': {
willChange: 'transform',
transform: 'translate(100%)',
},
'slideEnter-right': {
willChange: 'transform',
transform: 'translate(-100%)',
},
slideEnterActive: {
transform: 'translate(0%)',
transition: slideTransition,
},
slideExit: {
transform: 'translate(0%)',
},
'slideExitActiveLeft-left': {
willChange: 'transform',
transform: 'translate(-100%)',
transition: slideTransition,
},
'slideExitActiveLeft-right': {
willChange: 'transform',
transform: 'translate(100%)',
transition: slideTransition,
},
});
};
export default withStyles(styles, {
name: 'MuiPickersSlideTransition',
})(SlideTransition);
| lib/src/DatePicker/components/SlideTransition.tsx | 1 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00019815585983451456,
0.0001766211207723245,
0.00017087440937757492,
0.00017522451526019722,
0.000007053472927509574
] |
{
"id": 0,
"code_window": [
" \"build/dist/material-ui-pickers.esm.js\": {\n",
" \"bundled\": 113798,\n",
" \"minified\": 66892,\n",
" \"gzipped\": 14510,\n",
" \"treeshaked\": {\n",
" \"rollup\": {\n",
" \"code\": 49182,\n",
" \"import_statements\": 1317\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" \"gzipped\": 14511,\n"
],
"file_path": "lib/.size-snapshot.json",
"type": "replace",
"edit_start_line_idx": 4
} | import { ReactWrapper } from 'enzyme';
import * as React from 'react';
import DateTimePicker, {
DateTimePickerProps,
} from '../../DateTimePicker/DateTimePicker';
import { mount, utilsToUse } from '../test-utils';
describe('e2e - DateTimePicker', () => {
let component: ReactWrapper<DateTimePickerProps>;
const onChangeMock = jest.fn();
beforeEach(() => {
jest.clearAllMocks();
component = mount(
<DateTimePicker
date={utilsToUse.date('2018-01-01T00:00:00.000Z')}
onChange={onChangeMock}
openTo="date"
minDate="1900-01-01"
maxDate="2100-01-01"
leftArrowIcon="keyboard_arrow_left"
rightArrowIcon="keyboard_arrow_right"
dateRangeIcon="date_range"
timeIcon="access_time"
/>
);
});
it('Should renders', () => {
expect(component).toBeTruthy();
});
it('Should render year selection', () => {
component
.find('ToolbarButton')
.first()
.simulate('click');
expect(component.find('Year').length).toBe(201);
component
.find('Year')
.at(1)
.simulate('click');
expect(onChangeMock).toHaveBeenCalled();
});
it('Should render hour view', () => {
component
.find('ToolbarButton')
.at(2)
.simulate('click');
expect(component.find('TimePickerView').props().type).toBe('hours');
});
it('Should render minutes view', () => {
component
.find('ToolbarButton')
.at(4)
.simulate('click');
expect(component.find('TimePickerView').props().type).toBe('minutes');
});
it('Should change meridiem', () => {
component
.find('ToolbarButton')
.at(6)
.simulate('click');
if (process.env.UTILS === 'moment') {
expect(onChangeMock).toHaveBeenCalled();
return;
}
expect(onChangeMock).toHaveBeenCalledWith(
utilsToUse.date('2018-01-01T12:00:00.000Z'),
false
);
});
});
| lib/src/__tests__/e2e/DateTimePicker.test.tsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00017727106751408428,
0.00017417644266970456,
0.00017207747441716492,
0.00017397318151779473,
0.000001703807242847688
] |
{
"id": 0,
"code_window": [
" \"build/dist/material-ui-pickers.esm.js\": {\n",
" \"bundled\": 113798,\n",
" \"minified\": 66892,\n",
" \"gzipped\": 14510,\n",
" \"treeshaked\": {\n",
" \"rollup\": {\n",
" \"code\": 49182,\n",
" \"import_statements\": 1317\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" \"gzipped\": 14511,\n"
],
"file_path": "lib/.size-snapshot.json",
"type": "replace",
"edit_start_line_idx": 4
} | /* eslint-disable */
import { MuiPickersUtilsProvider } from 'material-ui-pickers';
// pick utils
import MomentUtils from '@date-io/moment';
import DateFnsUtils from '@date-io/date-fns';
import LuxonUtils from '@date-io/luxon';
function App() {
return (
<MuiPickersUtilsProvider utils={DateFnsUtils}>
<Root />
</MuiPickersUtilsProvider>
);
}
ReactDOM.render(<App />, document.querySelector('#app'));
| docs/src/Pages/GettingStarted/MuiPickersProvider.example.jsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00019561052613426,
0.00017815397586673498,
0.0001606974401511252,
0.00017815397586673498,
0.000017456542991567403
] |
{
"id": 0,
"code_window": [
" \"build/dist/material-ui-pickers.esm.js\": {\n",
" \"bundled\": 113798,\n",
" \"minified\": 66892,\n",
" \"gzipped\": 14510,\n",
" \"treeshaked\": {\n",
" \"rollup\": {\n",
" \"code\": 49182,\n",
" \"import_statements\": 1317\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" \"gzipped\": 14511,\n"
],
"file_path": "lib/.size-snapshot.json",
"type": "replace",
"edit_start_line_idx": 4
} | import React from 'react';
import SourcablePanel from '_shared/SourcablePanel';
import { Typography } from '@material-ui/core';
const ControllingProgrammatically = () => (
<div>
<Typography variant="h2" gutterBottom>
Control programmatically
</Typography>
<Typography variant="body1" gutterBottom>
Any picker can be controlled by <span className="inline-code"> ref </span>
property which add an ability open any picker from the code. See an
example below
</Typography>
<SourcablePanel
title="Open from button"
sourceFile="Guides/ControllingProgrammatically.example.jsx"
/>
</div>
);
export default ControllingProgrammatically;
| docs/src/Pages/Guides/ControllingProgrammatically.jsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00016851307009346783,
0.00016759609570726752,
0.00016579941438976675,
0.00016847578808665276,
0.0000012705332892437582
] |
{
"id": 1,
"code_window": [
" transform: 'translate(0%)',\n",
" },\n",
" 'slideExitActiveLeft-left': {\n",
" willChange: 'transform',\n",
" transform: 'translate(-100%)',\n",
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(-200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 91
} | import { Theme } from '@material-ui/core';
import createStyles from '@material-ui/core/styles/createStyles';
import withStyles, { WithStyles } from '@material-ui/core/styles/withStyles';
import classnames from 'classnames';
import * as PropTypes from 'prop-types';
import * as React from 'react';
import { CSSTransition, TransitionGroup } from 'react-transition-group';
export type SlideDirection = 'right' | 'left';
interface SlideTransitionProps extends WithStyles<typeof styles> {
transKey: React.Key;
className?: string;
slideDirection: SlideDirection;
children: React.ReactChild;
}
const animationDuration = 350;
const SlideTransition: React.SFC<SlideTransitionProps> = ({
classes,
className,
children,
transKey,
slideDirection,
}) => (
<TransitionGroup
className={classnames(classes.transitionContainer, className)}
>
<CSSTransition
key={transKey}
mountOnEnter
unmountOnExit
timeout={animationDuration}
children={children}
classNames={{
enter: classes[`slideEnter-${slideDirection}`],
enterActive: classes.slideEnterActive,
exit: classes.slideExit,
exitActive: classes[`slideExitActiveLeft-${slideDirection}`],
}}
/>
</TransitionGroup>
);
(SlideTransition as any).propTypes = {
classes: PropTypes.shape({}).isRequired,
children: PropTypes.node.isRequired,
className: PropTypes.string,
slideDirection: PropTypes.oneOf(['left', 'right']).isRequired,
transKey: PropTypes.string.isRequired,
innerRef: PropTypes.any,
};
SlideTransition.defaultProps = {
className: undefined,
};
const styles = (theme: Theme) => {
const slideTransition = theme.transitions.create('transform', {
duration: animationDuration,
easing: 'cubic-bezier(0.35, 0.8, 0.4, 1)',
});
return createStyles({
transitionContainer: {
display: 'block',
position: 'relative',
'& > *': {
position: 'absolute',
top: 0,
right: 0,
left: 0,
},
},
'slideEnter-left': {
willChange: 'transform',
transform: 'translate(100%)',
},
'slideEnter-right': {
willChange: 'transform',
transform: 'translate(-100%)',
},
slideEnterActive: {
transform: 'translate(0%)',
transition: slideTransition,
},
slideExit: {
transform: 'translate(0%)',
},
'slideExitActiveLeft-left': {
willChange: 'transform',
transform: 'translate(-100%)',
transition: slideTransition,
},
'slideExitActiveLeft-right': {
willChange: 'transform',
transform: 'translate(100%)',
transition: slideTransition,
},
});
};
export default withStyles(styles, {
name: 'MuiPickersSlideTransition',
})(SlideTransition);
| lib/src/DatePicker/components/SlideTransition.tsx | 1 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.7995232939720154,
0.10720434039831161,
0.00020753750868607312,
0.0018738321959972382,
0.24242812395095825
] |
{
"id": 1,
"code_window": [
" transform: 'translate(0%)',\n",
" },\n",
" 'slideExitActiveLeft-left': {\n",
" willChange: 'transform',\n",
" transform: 'translate(-100%)',\n",
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(-200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 91
} | import { ShallowWrapper } from 'enzyme';
import * as React from 'react';
import {
DateTimePickerTabs,
DateTimePickerTabsProps,
} from '../../DateTimePicker/components/DateTimePickerTabs';
import { DateTimePicker } from '../../DateTimePicker/DateTimePicker';
import { shallow } from '../test-utils';
describe('DateTimePickerTabs', () => {
let component: ShallowWrapper<DateTimePickerTabsProps>;
beforeEach(() => {
component = shallow(
<DateTimePickerTabs
theme={{ palette: { type: 'light' } } as any}
classes={{} as any}
view="date"
onChange={jest.fn()}
dateRangeIcon="foo"
timeIcon="bar"
/>
);
});
it('Should renders', () => {
// console.log(component.debug());
expect(component).toBeTruthy();
});
});
| lib/src/__tests__/DateTimePicker/DateTimePickerTabs.test.tsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.0001745415065670386,
0.0001737125712679699,
0.0001720605796435848,
0.0001741240848787129,
0.0000010110049970535329
] |
{
"id": 1,
"code_window": [
" transform: 'translate(0%)',\n",
" },\n",
" 'slideExitActiveLeft-left': {\n",
" willChange: 'transform',\n",
" transform: 'translate(-100%)',\n",
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(-200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 91
} | import { ShallowWrapper } from 'enzyme';
import * as React from 'react';
import {
CalendarHeader,
CalendarHeaderProps,
} from '../../DatePicker/components/CalendarHeader';
import { shallow, utilsToUse } from '../test-utils';
describe('CalendarHeader', () => {
let component: ShallowWrapper<CalendarHeaderProps>;
beforeEach(() => {
component = shallow(
<CalendarHeader
classes={{} as any}
theme={{} as any}
currentMonth={utilsToUse.date('01-01-2017')}
onMonthChange={jest.fn()}
slideDirection="right"
utils={utilsToUse}
/>
);
});
it('Should renders', () => {
// console.log(component.debug());
expect(component).toBeTruthy();
});
});
| lib/src/__tests__/DatePicker/CalendarHeader.test.tsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00018387309683021158,
0.000176967543666251,
0.00017316345474682748,
0.00017386612307745963,
0.000004891372100246372
] |
{
"id": 1,
"code_window": [
" transform: 'translate(0%)',\n",
" },\n",
" 'slideExitActiveLeft-left': {\n",
" willChange: 'transform',\n",
" transform: 'translate(-100%)',\n",
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(-200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 91
} | import { Theme } from '@material-ui/core';
import createStyles from '@material-ui/core/styles/createStyles';
import withStyles, { WithStyles } from '@material-ui/core/styles/withStyles';
import Typography from '@material-ui/core/Typography';
import classnames from 'classnames';
import * as PropTypes from 'prop-types';
import * as React from 'react';
const positions = {
0: [0, 40],
1: [55, 19.6],
2: [94.4, 59.5],
3: [109, 114],
4: [94.4, 168.5],
5: [54.5, 208.4],
6: [0, 223],
7: [-54.5, 208.4],
8: [-94.4, 168.5],
9: [-109, 114],
10: [-94.4, 59.5],
11: [-54.5, 19.6],
12: [0, 5],
13: [36.9, 49.9],
14: [64, 77],
15: [74, 114],
16: [64, 151],
17: [37, 178],
18: [0, 188],
19: [-37, 178],
20: [-64, 151],
21: [-74, 114],
22: [-64, 77],
23: [-37, 50],
};
export interface ClockNumberProps extends WithStyles<typeof styles> {
index: number;
label: string;
selected: boolean;
isInner?: boolean;
}
export class ClockNumber extends React.Component<ClockNumberProps> {
public static propTypes: any = {
index: PropTypes.number.isRequired,
label: PropTypes.string.isRequired,
selected: PropTypes.bool.isRequired,
classes: PropTypes.object.isRequired,
isInner: PropTypes.bool,
innerRef: PropTypes.any,
};
public static defaultProps = {
isInner: false,
};
public getTransformStyle = (index: number) => {
const position = positions[index];
return {
transform: `translate(${position[0]}px, ${position[1]}px`,
};
};
public render() {
const { selected, label, index, classes, isInner } = this.props;
const className = classnames(classes.clockNumber, {
[classes.selected]: selected,
});
return (
<Typography
variant={isInner ? 'body1' : 'subtitle1'}
component="span"
className={className}
style={this.getTransformStyle(index)}
>
{label}
</Typography>
);
}
}
const styles = (theme: Theme) => {
const size = theme.spacing.unit * 4;
return createStyles({
clockNumber: {
width: size,
height: size,
userSelect: 'none',
position: 'absolute',
left: `calc(50% - ${size / 2}px)`,
display: 'inline-flex',
justifyContent: 'center',
alignItems: 'center',
borderRadius: '50%',
color:
theme.palette.type === 'light'
? theme.palette.text.primary
: theme.palette.text.hint,
},
selected: {
color: theme.palette.common.white,
},
});
};
export default withStyles(styles, {
name: 'MuiPickersClockNumber',
})(ClockNumber as React.ComponentType<ClockNumberProps>);
| lib/src/TimePicker/components/ClockNumber.tsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00017544905131217092,
0.00017223648319486529,
0.00016172396135516465,
0.0001735425612423569,
0.000003507005203573499
] |
{
"id": 2,
"code_window": [
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n",
" transform: 'translate(100%)',\n",
" transition: slideTransition,\n",
" },\n",
" });\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 96
} | import { Theme } from '@material-ui/core';
import createStyles from '@material-ui/core/styles/createStyles';
import withStyles, { WithStyles } from '@material-ui/core/styles/withStyles';
import classnames from 'classnames';
import * as PropTypes from 'prop-types';
import * as React from 'react';
import { CSSTransition, TransitionGroup } from 'react-transition-group';
export type SlideDirection = 'right' | 'left';
interface SlideTransitionProps extends WithStyles<typeof styles> {
transKey: React.Key;
className?: string;
slideDirection: SlideDirection;
children: React.ReactChild;
}
const animationDuration = 350;
const SlideTransition: React.SFC<SlideTransitionProps> = ({
classes,
className,
children,
transKey,
slideDirection,
}) => (
<TransitionGroup
className={classnames(classes.transitionContainer, className)}
>
<CSSTransition
key={transKey}
mountOnEnter
unmountOnExit
timeout={animationDuration}
children={children}
classNames={{
enter: classes[`slideEnter-${slideDirection}`],
enterActive: classes.slideEnterActive,
exit: classes.slideExit,
exitActive: classes[`slideExitActiveLeft-${slideDirection}`],
}}
/>
</TransitionGroup>
);
(SlideTransition as any).propTypes = {
classes: PropTypes.shape({}).isRequired,
children: PropTypes.node.isRequired,
className: PropTypes.string,
slideDirection: PropTypes.oneOf(['left', 'right']).isRequired,
transKey: PropTypes.string.isRequired,
innerRef: PropTypes.any,
};
SlideTransition.defaultProps = {
className: undefined,
};
const styles = (theme: Theme) => {
const slideTransition = theme.transitions.create('transform', {
duration: animationDuration,
easing: 'cubic-bezier(0.35, 0.8, 0.4, 1)',
});
return createStyles({
transitionContainer: {
display: 'block',
position: 'relative',
'& > *': {
position: 'absolute',
top: 0,
right: 0,
left: 0,
},
},
'slideEnter-left': {
willChange: 'transform',
transform: 'translate(100%)',
},
'slideEnter-right': {
willChange: 'transform',
transform: 'translate(-100%)',
},
slideEnterActive: {
transform: 'translate(0%)',
transition: slideTransition,
},
slideExit: {
transform: 'translate(0%)',
},
'slideExitActiveLeft-left': {
willChange: 'transform',
transform: 'translate(-100%)',
transition: slideTransition,
},
'slideExitActiveLeft-right': {
willChange: 'transform',
transform: 'translate(100%)',
transition: slideTransition,
},
});
};
export default withStyles(styles, {
name: 'MuiPickersSlideTransition',
})(SlideTransition);
| lib/src/DatePicker/components/SlideTransition.tsx | 1 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.9824735522270203,
0.09435772150754929,
0.0001689930650172755,
0.002851641969755292,
0.2810106873512268
] |
{
"id": 2,
"code_window": [
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n",
" transform: 'translate(100%)',\n",
" transition: slideTransition,\n",
" },\n",
" });\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 96
} | language: node_js
node_js:
- "8"
before_install:
- cd lib
env:
- CMD='test:date-fns'
- CMD='test:luxon'
- CMD='test:moment'
- CMD='build:analyze'
- CMD='lint'
script: npm run $CMD
after_script: npx codecov
| .travis.yml | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00017490969912614673,
0.00017345912056043744,
0.00017200855654664338,
0.00017345912056043744,
0.0000014505712897516787
] |
{
"id": 2,
"code_window": [
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n",
" transform: 'translate(100%)',\n",
" transition: slideTransition,\n",
" },\n",
" });\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 96
} | import { IUtils } from '@date-io/core/IUtils';
import { Omit } from '@material-ui/core';
import * as React from 'react';
import { MuiPickersContextConsumer } from '../MuiPickersUtilsProvider';
import { MaterialUiPickersDate } from '../typings/date';
export interface WithUtilsProps {
utils: IUtils<MaterialUiPickersDate>;
}
const checkUtils = (
utils: IUtils<MaterialUiPickersDate> | null | undefined
) => {
if (!utils) {
// tslint:disable-next-line
throw new Error(
'Can not find utils in context. You either a) forgot to wrap your component tree in MuiPickersUtilsProvider; or b) mixed named and direct file imports. Recommendation: use named imports from the module index.'
);
}
};
export const withUtils = () => <P extends WithUtilsProps>(
Component: React.ComponentType<P>
) => {
const WithUtils: React.SFC<Omit<P, keyof WithUtilsProps>> = props => (
<MuiPickersContextConsumer>
{utils => {
checkUtils(utils);
return <Component utils={utils} {...props} />;
}}
</MuiPickersContextConsumer>
);
WithUtils.displayName = `WithUtils(${Component.displayName ||
Component.name})`;
return WithUtils;
};
| lib/src/_shared/WithUtils.tsx | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.00017611293878871948,
0.00017215809202753007,
0.00016597610374446958,
0.00017327166278846562,
0.0000037532568057940807
] |
{
"id": 2,
"code_window": [
" transition: slideTransition,\n",
" },\n",
" 'slideExitActiveLeft-right': {\n",
" willChange: 'transform',\n",
" transform: 'translate(100%)',\n",
" transition: slideTransition,\n",
" },\n",
" });\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" transform: 'translate(200%)',\n"
],
"file_path": "lib/src/DatePicker/components/SlideTransition.tsx",
"type": "replace",
"edit_start_line_idx": 96
} | // rollup-plugin-typescript does not resolve `extends`, so tsconfig.build.json is the base and we just alter it for IDE and testing.
{
"extends": "../tsconfig.base.json",
"compilerOptions": {
"module": "commonjs",
"outDir": "build",
"declaration": true,
"jsx": "react",
"skipLibCheck": true
},
"include": ["src/**/*"],
"exclude": ["./src/__tests__/**/*", "build"]
}
| lib/tsconfig.json | 0 | https://github.com/mui/material-ui/commit/f7f3422e8c9b53fe24b08b9318b0583a06770490 | [
0.0001739244908094406,
0.00017317516903858632,
0.00017242584726773202,
0.00017317516903858632,
7.493217708542943e-7
] |
{
"id": 0,
"code_window": [
" <div class=\"gf-form-inline\">\n",
" <div class=\"gf-form\">\n",
" <label class=\"gf-form-label width-6 query-keyword\">Series</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n",
" <gf-form-dropdown\n",
" model=\"tag.key\"\n",
" lookup-text=\"false\"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 12
} | import './add_graphite_func';
import './func_editor';
import _ from 'lodash';
import GraphiteQuery from './graphite_query';
import { QueryCtrl } from 'app/plugins/sdk';
import appEvents from 'app/core/app_events';
const GRAPHITE_TAG_OPERATORS = ['=', '!=', '=~', '!=~'];
const TAG_PREFIX = 'tag: ';
export class GraphiteQueryCtrl extends QueryCtrl {
static templateUrl = 'partials/query.editor.html';
queryModel: GraphiteQuery;
segments: any[];
addTagSegments: any[];
removeTagValue: string;
supportsTags: boolean;
/** @ngInject **/
constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {
super($scope, $injector);
this.supportsTags = this.datasource.supportsTags;
if (this.target) {
this.target.target = this.target.target || '';
this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);
this.buildSegments();
}
this.removeTagValue = '-- remove tag --';
}
parseTarget() {
this.queryModel.parseTarget();
this.buildSegments();
}
toggleEditorMode() {
this.target.textEditor = !this.target.textEditor;
this.parseTarget();
}
buildSegments() {
this.segments = _.map(this.queryModel.segments, segment => {
return this.uiSegmentSrv.newSegment(segment);
});
let checkOtherSegmentsIndex = this.queryModel.checkOtherSegmentsIndex || 0;
this.checkOtherSegments(checkOtherSegmentsIndex);
if (this.queryModel.seriesByTagUsed) {
this.fixTagSegments();
}
}
addSelectMetricSegment() {
this.queryModel.addSelectMetricSegment();
this.segments.push(this.uiSegmentSrv.newSelectMetric());
}
checkOtherSegments(fromIndex) {
if (this.queryModel.segments.length === 1 && this.queryModel.segments[0].type === 'series-ref') {
return;
}
if (fromIndex === 0) {
this.addSelectMetricSegment();
return;
}
var path = this.queryModel.getSegmentPathUpTo(fromIndex + 1);
if (path === '') {
return Promise.resolve();
}
return this.datasource
.metricFindQuery(path)
.then(segments => {
if (segments.length === 0) {
if (path !== '') {
this.queryModel.segments = this.queryModel.segments.splice(0, fromIndex);
this.segments = this.segments.splice(0, fromIndex);
this.addSelectMetricSegment();
}
} else if (segments[0].expandable) {
if (this.segments.length === fromIndex) {
this.addSelectMetricSegment();
} else {
return this.checkOtherSegments(fromIndex + 1);
}
}
})
.catch(err => {
appEvents.emit('alert-error', ['Error', err]);
});
}
setSegmentFocus(segmentIndex) {
_.each(this.segments, (segment, index) => {
segment.focus = segmentIndex === index;
});
}
getAltSegments(index) {
var query = index === 0 ? '*' : this.queryModel.getSegmentPathUpTo(index) + '.*';
var options = {
range: this.panelCtrl.range,
requestId: 'get-alt-segments',
};
return this.datasource
.metricFindQuery(query, options)
.then(segments => {
var altSegments = _.map(segments, segment => {
return this.uiSegmentSrv.newSegment({
value: segment.text,
expandable: segment.expandable,
});
});
if (altSegments.length === 0) {
return altSegments;
}
// add query references
if (index === 0) {
_.eachRight(this.panelCtrl.panel.targets, target => {
if (target.refId === this.queryModel.target.refId) {
return;
}
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'series-ref',
value: '#' + target.refId,
expandable: false,
})
);
});
}
// add template variables
_.eachRight(this.templateSrv.variables, variable => {
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'template',
value: '$' + variable.name,
expandable: true,
})
);
});
// add wildcard option
altSegments.unshift(this.uiSegmentSrv.newSegment('*'));
if (this.supportsTags && index === 0) {
this.removeTaggedEntry(altSegments);
return this.addAltTagSegments(index, altSegments);
} else {
return altSegments;
}
})
.catch(err => {
return [];
});
}
addAltTagSegments(index, altSegments) {
return this.getTagsAsSegments().then(tagSegments => {
tagSegments = _.map(tagSegments, segment => {
segment.value = TAG_PREFIX + segment.value;
return segment;
});
return altSegments.concat(...tagSegments);
});
}
removeTaggedEntry(altSegments) {
altSegments = _.remove(altSegments, s => s.value === '_tagged');
}
segmentValueChanged(segment, segmentIndex) {
this.error = null;
this.queryModel.updateSegmentValue(segment, segmentIndex);
if (this.queryModel.functions.length > 0 && this.queryModel.functions[0].def.fake) {
this.queryModel.functions = [];
}
if (segment.type === 'tag') {
let tag = removeTagPrefix(segment.value);
this.addSeriesByTagFunc(tag);
return;
}
if (segment.expandable) {
return this.checkOtherSegments(segmentIndex + 1).then(() => {
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
});
} else {
this.spliceSegments(segmentIndex + 1);
}
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
}
spliceSegments(index) {
this.segments = this.segments.splice(0, index);
this.queryModel.segments = this.queryModel.segments.splice(0, index);
}
emptySegments() {
this.queryModel.segments = [];
this.segments = [];
}
targetTextChanged() {
this.updateModelTarget();
this.refresh();
}
updateModelTarget() {
this.queryModel.updateModelTarget(this.panelCtrl.panel.targets);
}
targetChanged() {
if (this.queryModel.error) {
return;
}
var oldTarget = this.queryModel.target.target;
this.updateModelTarget();
if (this.queryModel.target !== oldTarget) {
this.panelCtrl.refresh();
}
}
addFunction(funcDef) {
var newFunc = this.datasource.createFuncInstance(funcDef, {
withDefaultParams: true,
});
newFunc.added = true;
this.queryModel.addFunction(newFunc);
this.smartlyHandleNewAliasByNode(newFunc);
if (this.segments.length === 1 && this.segments[0].fake) {
this.emptySegments();
}
if (!newFunc.params.length && newFunc.added) {
this.targetChanged();
}
if (newFunc.def.name === 'seriesByTag') {
this.parseTarget();
}
}
removeFunction(func) {
this.queryModel.removeFunction(func);
this.targetChanged();
}
addSeriesByTagFunc(tag) {
let newFunc = this.datasource.createFuncInstance('seriesByTag', {
withDefaultParams: false,
});
let tagParam = `${tag}=`;
newFunc.params = [tagParam];
this.queryModel.addFunction(newFunc);
newFunc.added = true;
this.emptySegments();
this.targetChanged();
this.parseTarget();
}
smartlyHandleNewAliasByNode(func) {
if (func.def.name !== 'aliasByNode') {
return;
}
for (var i = 0; i < this.segments.length; i++) {
if (this.segments[i].value.indexOf('*') >= 0) {
func.params[0] = i;
func.added = false;
this.targetChanged();
return;
}
}
}
getAllTags() {
return this.datasource.getTags().then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTags(index, tagPrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
return this.datasource.getTagsAutoComplete(tagExpressions, tagPrefix).then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTagsAsSegments() {
let tagExpressions = this.queryModel.renderTagExpressions();
return this.datasource.getTagsAutoComplete(tagExpressions).then(values => {
return _.map(values, val => {
return this.uiSegmentSrv.newSegment({
value: val.text,
type: 'tag',
expandable: false,
});
});
});
}
getTagOperators() {
return mapToDropdownOptions(GRAPHITE_TAG_OPERATORS);
}
getAllTagValues(tag) {
let tagKey = tag.key;
return this.datasource.getTagValues(tagKey).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
getTagValues(tag, index, valuePrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
let tagKey = tag.key;
return this.datasource.getTagValuesAutoComplete(tagExpressions, tagKey, valuePrefix).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
tagChanged(tag, tagIndex) {
this.queryModel.updateTag(tag, tagIndex);
this.targetChanged();
}
addNewTag(segment) {
let newTagKey = segment.value;
let newTag = { key: newTagKey, operator: '=', value: '' };
this.queryModel.addTag(newTag);
this.targetChanged();
this.fixTagSegments();
}
removeTag(index) {
this.queryModel.removeTag(index);
this.targetChanged();
}
fixTagSegments() {
// Adding tag with the same name as just removed works incorrectly if single segment is used (instead of array)
this.addTagSegments = [this.uiSegmentSrv.newPlusButton()];
}
showDelimiter(index) {
return index !== this.queryModel.tags.length - 1;
}
}
function mapToDropdownOptions(results) {
return _.map(results, value => {
return { text: value, value: value };
});
}
function removeTagPrefix(value: string): string {
return value.replace(TAG_PREFIX, '');
}
| public/app/plugins/datasource/graphite/query_ctrl.ts | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.023465236648917198,
0.0009536899742670357,
0.000165337638463825,
0.00020611191575881094,
0.0036745257675647736
] |
{
"id": 0,
"code_window": [
" <div class=\"gf-form-inline\">\n",
" <div class=\"gf-form\">\n",
" <label class=\"gf-form-label width-6 query-keyword\">Series</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n",
" <gf-form-dropdown\n",
" model=\"tag.key\"\n",
" lookup-text=\"false\"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 12
} | import angular from 'angular';
import _ from 'lodash';
import $ from 'jquery';
import * as d3 from 'd3';
import { contextSrv } from 'app/core/core';
import { tickStep } from 'app/core/utils/ticks';
import { getColorScale, getOpacityScale } from './color_scale';
let module = angular.module('grafana.directives');
/**
* Color legend for heatmap editor.
*/
module.directive('colorLegend', function() {
return {
restrict: 'E',
template: '<div class="heatmap-color-legend"><svg width="16.8rem" height="24px"></svg></div>',
link: function(scope, elem, attrs) {
let ctrl = scope.ctrl;
let panel = scope.ctrl.panel;
render();
ctrl.events.on('render', function() {
render();
});
function render() {
let legendElem = $(elem).find('svg');
let legendWidth = Math.floor(legendElem.outerWidth());
if (panel.color.mode === 'spectrum') {
let colorScheme = _.find(ctrl.colorSchemes, {
value: panel.color.colorScheme,
});
let colorScale = getColorScale(colorScheme, contextSrv.user.lightTheme, legendWidth);
drawSimpleColorLegend(elem, colorScale);
} else if (panel.color.mode === 'opacity') {
let colorOptions = panel.color;
drawSimpleOpacityLegend(elem, colorOptions);
}
}
},
};
});
/**
* Heatmap legend with scale values.
*/
module.directive('heatmapLegend', function() {
return {
restrict: 'E',
template: '<div class="heatmap-color-legend"><svg width="100px" height="14px"></svg></div>',
link: function(scope, elem, attrs) {
let ctrl = scope.ctrl;
let panel = scope.ctrl.panel;
render();
ctrl.events.on('render', function() {
render();
});
function render() {
clearLegend(elem);
if (!_.isEmpty(ctrl.data) && !_.isEmpty(ctrl.data.cards)) {
let rangeFrom = 0;
let rangeTo = ctrl.data.cardStats.max;
let maxValue = panel.color.max || rangeTo;
let minValue = panel.color.min || 0;
if (panel.color.mode === 'spectrum') {
let colorScheme = _.find(ctrl.colorSchemes, {
value: panel.color.colorScheme,
});
drawColorLegend(elem, colorScheme, rangeFrom, rangeTo, maxValue, minValue);
} else if (panel.color.mode === 'opacity') {
let colorOptions = panel.color;
drawOpacityLegend(elem, colorOptions, rangeFrom, rangeTo, maxValue, minValue);
}
}
}
},
};
});
function drawColorLegend(elem, colorScheme, rangeFrom, rangeTo, maxValue, minValue) {
let legendElem = $(elem).find('svg');
let legend = d3.select(legendElem.get(0));
clearLegend(elem);
let legendWidth = Math.floor(legendElem.outerWidth()) - 30;
let legendHeight = legendElem.attr('height');
let rangeStep = 1;
if (rangeTo - rangeFrom > legendWidth) {
rangeStep = Math.floor((rangeTo - rangeFrom) / legendWidth);
}
let widthFactor = legendWidth / (rangeTo - rangeFrom);
let valuesRange = d3.range(rangeFrom, rangeTo, rangeStep);
let colorScale = getColorScale(colorScheme, contextSrv.user.lightTheme, maxValue, minValue);
legend
.selectAll('.heatmap-color-legend-rect')
.data(valuesRange)
.enter()
.append('rect')
.attr('x', d => d * widthFactor)
.attr('y', 0)
.attr('width', rangeStep * widthFactor + 1) // Overlap rectangles to prevent gaps
.attr('height', legendHeight)
.attr('stroke-width', 0)
.attr('fill', d => colorScale(d));
drawLegendValues(elem, colorScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth);
}
function drawOpacityLegend(elem, options, rangeFrom, rangeTo, maxValue, minValue) {
let legendElem = $(elem).find('svg');
let legend = d3.select(legendElem.get(0));
clearLegend(elem);
let legendWidth = Math.floor(legendElem.outerWidth()) - 30;
let legendHeight = legendElem.attr('height');
let rangeStep = 1;
if (rangeTo - rangeFrom > legendWidth) {
rangeStep = Math.floor((rangeTo - rangeFrom) / legendWidth);
}
let widthFactor = legendWidth / (rangeTo - rangeFrom);
let valuesRange = d3.range(rangeFrom, rangeTo, rangeStep);
let opacityScale = getOpacityScale(options, maxValue, minValue);
legend
.selectAll('.heatmap-opacity-legend-rect')
.data(valuesRange)
.enter()
.append('rect')
.attr('x', d => d * widthFactor)
.attr('y', 0)
.attr('width', rangeStep * widthFactor)
.attr('height', legendHeight)
.attr('stroke-width', 0)
.attr('fill', options.cardColor)
.style('opacity', d => opacityScale(d));
drawLegendValues(elem, opacityScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth);
}
function drawLegendValues(elem, colorScale, rangeFrom, rangeTo, maxValue, minValue, legendWidth) {
let legendElem = $(elem).find('svg');
let legend = d3.select(legendElem.get(0));
if (legendWidth <= 0 || legendElem.get(0).childNodes.length === 0) {
return;
}
let legendValueScale = d3
.scaleLinear()
.domain([0, rangeTo])
.range([0, legendWidth]);
let ticks = buildLegendTicks(0, rangeTo, maxValue, minValue);
let xAxis = d3
.axisBottom(legendValueScale)
.tickValues(ticks)
.tickSize(2);
let colorRect = legendElem.find(':first-child');
let posY = getSvgElemHeight(legendElem) + 2;
let posX = getSvgElemX(colorRect);
d3
.select(legendElem.get(0))
.append('g')
.attr('class', 'axis')
.attr('transform', 'translate(' + posX + ',' + posY + ')')
.call(xAxis);
legend
.select('.axis')
.select('.domain')
.remove();
}
function drawSimpleColorLegend(elem, colorScale) {
let legendElem = $(elem).find('svg');
clearLegend(elem);
let legendWidth = Math.floor(legendElem.outerWidth());
let legendHeight = legendElem.attr('height');
if (legendWidth) {
let valuesNumber = Math.floor(legendWidth / 2);
let rangeStep = Math.floor(legendWidth / valuesNumber);
let valuesRange = d3.range(0, legendWidth, rangeStep);
let legend = d3.select(legendElem.get(0));
var legendRects = legend.selectAll('.heatmap-color-legend-rect').data(valuesRange);
legendRects
.enter()
.append('rect')
.attr('x', d => d)
.attr('y', 0)
.attr('width', rangeStep + 1) // Overlap rectangles to prevent gaps
.attr('height', legendHeight)
.attr('stroke-width', 0)
.attr('fill', d => colorScale(d));
}
}
function drawSimpleOpacityLegend(elem, options) {
let legendElem = $(elem).find('svg');
clearLegend(elem);
let legend = d3.select(legendElem.get(0));
let legendWidth = Math.floor(legendElem.outerWidth());
let legendHeight = legendElem.attr('height');
if (legendWidth) {
let legendOpacityScale;
if (options.colorScale === 'linear') {
legendOpacityScale = d3
.scaleLinear()
.domain([0, legendWidth])
.range([0, 1]);
} else if (options.colorScale === 'sqrt') {
legendOpacityScale = d3
.scalePow()
.exponent(options.exponent)
.domain([0, legendWidth])
.range([0, 1]);
}
let rangeStep = 10;
let valuesRange = d3.range(0, legendWidth, rangeStep);
var legendRects = legend.selectAll('.heatmap-opacity-legend-rect').data(valuesRange);
legendRects
.enter()
.append('rect')
.attr('x', d => d)
.attr('y', 0)
.attr('width', rangeStep)
.attr('height', legendHeight)
.attr('stroke-width', 0)
.attr('fill', options.cardColor)
.style('opacity', d => legendOpacityScale(d));
}
}
function clearLegend(elem) {
let legendElem = $(elem).find('svg');
legendElem.empty();
}
function getSvgElemX(elem) {
let svgElem = elem.get(0);
if (svgElem && svgElem.x && svgElem.x.baseVal) {
return svgElem.x.baseVal.value;
} else {
return 0;
}
}
function getSvgElemHeight(elem) {
let svgElem = elem.get(0);
if (svgElem && svgElem.height && svgElem.height.baseVal) {
return svgElem.height.baseVal.value;
} else {
return 0;
}
}
function buildLegendTicks(rangeFrom, rangeTo, maxValue, minValue) {
let range = rangeTo - rangeFrom;
let tickStepSize = tickStep(rangeFrom, rangeTo, 3);
let ticksNum = Math.round(range / tickStepSize);
let ticks = [];
for (let i = 0; i < ticksNum; i++) {
let current = tickStepSize * i;
// Add user-defined min and max if it had been set
if (isValueCloseTo(minValue, current, tickStepSize)) {
ticks.push(minValue);
continue;
} else if (minValue < current) {
ticks.push(minValue);
}
if (isValueCloseTo(maxValue, current, tickStepSize)) {
ticks.push(maxValue);
continue;
} else if (maxValue < current) {
ticks.push(maxValue);
}
ticks.push(tickStepSize * i);
}
if (!isValueCloseTo(maxValue, rangeTo, tickStepSize)) {
ticks.push(maxValue);
}
ticks.push(rangeTo);
ticks = _.sortBy(_.uniq(ticks));
return ticks;
}
function isValueCloseTo(val, valueTo, step) {
let diff = Math.abs(val - valueTo);
return diff < step * 0.3;
}
| public/app/plugins/panel/heatmap/color_legend.ts | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0021282536908984184,
0.00024727798881940544,
0.0001660579291637987,
0.0001708675699774176,
0.00034695162321440876
] |
{
"id": 0,
"code_window": [
" <div class=\"gf-form-inline\">\n",
" <div class=\"gf-form\">\n",
" <label class=\"gf-form-label width-6 query-keyword\">Series</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n",
" <gf-form-dropdown\n",
" model=\"tag.key\"\n",
" lookup-text=\"false\"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 12
} | mysql_opendata:
build: blocks/mysql_opendata
environment:
MYSQL_ROOT_PASSWORD: rootpass
MYSQL_DATABASE: testdata
MYSQL_USER: grafana
MYSQL_PASSWORD: password
ports:
- "3307:3306"
| docker/blocks/mysql_opendata/docker-compose.yaml | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001681620196904987,
0.0001681620196904987,
0.0001681620196904987,
0.0001681620196904987,
0
] |
{
"id": 0,
"code_window": [
" <div class=\"gf-form-inline\">\n",
" <div class=\"gf-form\">\n",
" <label class=\"gf-form-label width-6 query-keyword\">Series</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n",
" <gf-form-dropdown\n",
" model=\"tag.key\"\n",
" lookup-text=\"false\"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"tag in ctrl.queryModel.tags\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 12
} | // Copyright 2016 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package graphite provides a bridge to push Prometheus metrics to a Graphite
// server.
package graphitebridge
import (
"bufio"
"errors"
"fmt"
"io"
"math"
"net"
"sort"
"strings"
"time"
"context"
"github.com/prometheus/common/expfmt"
"github.com/prometheus/common/model"
dto "github.com/prometheus/client_model/go"
"github.com/prometheus/client_golang/prometheus"
)
const (
defaultInterval = 15 * time.Second
millisecondsPerSecond = 1000
)
// HandlerErrorHandling defines how a Handler serving metrics will handle
// errors.
type HandlerErrorHandling int
// These constants cause handlers serving metrics to behave as described if
// errors are encountered.
const (
// Ignore errors and try to push as many metrics to Graphite as possible.
ContinueOnError HandlerErrorHandling = iota
// Abort the push to Graphite upon the first error encountered.
AbortOnError
)
var metricCategoryPrefix []string = []string{
"proxy_",
"api_",
"page_",
"alerting_",
"aws_",
"db_",
"stat_",
"go_",
"process_"}
var trimMetricPrefix []string = []string{"grafana_"}
// Config defines the Graphite bridge config.
type Config struct {
// The url to push data to. Required.
URL string
// The prefix for the pushed Graphite metrics. Defaults to empty string.
Prefix string
// The interval to use for pushing data to Graphite. Defaults to 15 seconds.
Interval time.Duration
// The timeout for pushing metrics to Graphite. Defaults to 15 seconds.
Timeout time.Duration
// The Gatherer to use for metrics. Defaults to prometheus.DefaultGatherer.
Gatherer prometheus.Gatherer
// The logger that messages are written to. Defaults to no logging.
Logger Logger
// ErrorHandling defines how errors are handled. Note that errors are
// logged regardless of the configured ErrorHandling provided Logger
// is not nil.
ErrorHandling HandlerErrorHandling
// Graphite does not support ever increasing counter the same way
// prometheus does. Rollups and ingestion might cannot handle ever
// increasing counters. This option allows enabled the caller to
// calculate the delta by saving the last sent counter in memory
// and subtraction it from the collected value before sending.
CountersAsDelta bool
}
// Bridge pushes metrics to the configured Graphite server.
type Bridge struct {
url string
prefix string
countersAsDetlas bool
interval time.Duration
timeout time.Duration
errorHandling HandlerErrorHandling
logger Logger
g prometheus.Gatherer
lastValue map[model.Fingerprint]float64
}
// Logger is the minimal interface Bridge needs for logging. Note that
// log.Logger from the standard library implements this interface, and it is
// easy to implement by custom loggers, if they don't do so already anyway.
type Logger interface {
Println(v ...interface{})
}
// NewBridge returns a pointer to a new Bridge struct.
func NewBridge(c *Config) (*Bridge, error) {
b := &Bridge{}
if c.URL == "" {
return nil, errors.New("missing URL")
}
b.url = c.URL
if c.Gatherer == nil {
b.g = prometheus.DefaultGatherer
} else {
b.g = c.Gatherer
}
if c.Logger != nil {
b.logger = c.Logger
}
if c.Prefix != "" {
b.prefix = c.Prefix
}
var z time.Duration
if c.Interval == z {
b.interval = defaultInterval
} else {
b.interval = c.Interval
}
if c.Timeout == z {
b.timeout = defaultInterval
} else {
b.timeout = c.Timeout
}
b.errorHandling = c.ErrorHandling
b.lastValue = map[model.Fingerprint]float64{}
b.countersAsDetlas = c.CountersAsDelta
return b, nil
}
// Run starts the event loop that pushes Prometheus metrics to Graphite at the
// configured interval.
func (b *Bridge) Run(ctx context.Context) {
ticker := time.NewTicker(b.interval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
if err := b.Push(); err != nil && b.logger != nil {
b.logger.Println("error pushing to Graphite:", err)
}
case <-ctx.Done():
return
}
}
}
// Push pushes Prometheus metrics to the configured Graphite server.
func (b *Bridge) Push() error {
mfs, err := b.g.Gather()
if err != nil || len(mfs) == 0 {
switch b.errorHandling {
case AbortOnError:
return err
case ContinueOnError:
if b.logger != nil {
b.logger.Println("continue on error:", err)
}
default:
panic("unrecognized error handling value")
}
}
conn, err := net.DialTimeout("tcp", b.url, b.timeout)
if err != nil {
return err
}
defer conn.Close()
return b.writeMetrics(conn, mfs, b.prefix, model.Now())
}
func (b *Bridge) writeMetrics(w io.Writer, mfs []*dto.MetricFamily, prefix string, now model.Time) error {
for _, mf := range mfs {
vec, err := expfmt.ExtractSamples(&expfmt.DecodeOptions{
Timestamp: now,
}, mf)
if err != nil {
return err
}
buf := bufio.NewWriter(w)
for _, s := range vec {
if math.IsNaN(float64(s.Value)) {
continue
}
if err := writePrefix(buf, prefix); err != nil {
return err
}
if err := writeMetric(buf, s.Metric, mf); err != nil {
return err
}
value := b.replaceCounterWithDelta(mf, s.Metric, s.Value)
if _, err := fmt.Fprintf(buf, " %g %d\n", value, int64(s.Timestamp)/millisecondsPerSecond); err != nil {
return err
}
if err := buf.Flush(); err != nil {
return err
}
}
}
return nil
}
func writeMetric(buf *bufio.Writer, m model.Metric, mf *dto.MetricFamily) error {
metricName, hasName := m[model.MetricNameLabel]
numLabels := len(m) - 1
if !hasName {
numLabels = len(m)
}
for _, v := range trimMetricPrefix {
if strings.HasPrefix(string(metricName), v) {
metricName = model.LabelValue(strings.Replace(string(metricName), v, "", 1))
}
}
for _, v := range metricCategoryPrefix {
if strings.HasPrefix(string(metricName), v) {
group := strings.Replace(v, "_", " ", 1)
metricName = model.LabelValue(strings.Replace(string(metricName), v, group, 1))
}
}
labelStrings := make([]string, 0, numLabels)
for label, value := range m {
if label != model.MetricNameLabel {
labelStrings = append(labelStrings, fmt.Sprintf("%s %s", string(label), string(value)))
}
}
var err error
switch numLabels {
case 0:
if hasName {
if err := writeSanitized(buf, string(metricName)); err != nil {
return err
}
}
default:
sort.Strings(labelStrings)
if err = writeSanitized(buf, string(metricName)); err != nil {
return err
}
for _, s := range labelStrings {
if err = buf.WriteByte('.'); err != nil {
return err
}
if err = writeSanitized(buf, s); err != nil {
return err
}
}
}
if err = addExtentionConventionForRollups(buf, mf, m); err != nil {
return err
}
return nil
}
func addExtentionConventionForRollups(buf *bufio.Writer, mf *dto.MetricFamily, m model.Metric) error {
// Adding `.count` `.sum` suffix makes it possible to configure
// different rollup strategies based on metric type
mfType := mf.GetType()
var err error
if mfType == dto.MetricType_COUNTER {
if _, err = fmt.Fprint(buf, ".count"); err != nil {
return err
}
}
if mfType == dto.MetricType_SUMMARY || mfType == dto.MetricType_HISTOGRAM {
if strings.HasSuffix(string(m[model.MetricNameLabel]), "_count") {
if _, err = fmt.Fprint(buf, ".count"); err != nil {
return err
}
}
}
if mfType == dto.MetricType_HISTOGRAM {
if strings.HasSuffix(string(m[model.MetricNameLabel]), "_sum") {
if _, err = fmt.Fprint(buf, ".sum"); err != nil {
return err
}
}
}
return nil
}
func writePrefix(buf *bufio.Writer, s string) error {
for _, c := range s {
if _, err := buf.WriteRune(replaceInvalid(c)); err != nil {
return err
}
}
return nil
}
func writeSanitized(buf *bufio.Writer, s string) error {
prevUnderscore := false
for _, c := range s {
c = replaceInvalidRune(c)
if c == '_' {
if prevUnderscore {
continue
}
prevUnderscore = true
} else {
prevUnderscore = false
}
if _, err := buf.WriteRune(c); err != nil {
return err
}
}
return nil
}
func replaceInvalid(c rune) rune {
if c == ' ' || c == '.' {
return '.'
}
return replaceInvalidRune(c)
}
func replaceInvalidRune(c rune) rune {
if c == ' ' {
return '.'
}
if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '-' || c == '_' || c == ':' || (c >= '0' && c <= '9')) {
return '_'
}
return c
}
func (b *Bridge) replaceCounterWithDelta(mf *dto.MetricFamily, metric model.Metric, value model.SampleValue) float64 {
if !b.countersAsDetlas {
return float64(value)
}
mfType := mf.GetType()
if mfType == dto.MetricType_COUNTER {
return b.returnDelta(metric, value)
}
if mfType == dto.MetricType_SUMMARY {
if strings.HasSuffix(string(metric[model.MetricNameLabel]), "_count") {
return b.returnDelta(metric, value)
}
}
return float64(value)
}
func (b *Bridge) returnDelta(metric model.Metric, value model.SampleValue) float64 {
key := metric.Fingerprint()
_, exists := b.lastValue[key]
if !exists {
b.lastValue[key] = 0
}
delta := float64(value) - b.lastValue[key]
b.lastValue[key] = float64(value)
return delta
}
| pkg/metrics/graphitebridge/graphite.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0003033531829714775,
0.00017322759958915412,
0.00016351848898921162,
0.00016863564087543637,
0.000021990203094901517
] |
{
"id": 1,
"code_window": [
" <label class=\"gf-form-label query-keyword\" ng-if=\"ctrl.showDelimiter($index)\">AND</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"!ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 46
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.9955812096595764,
0.12969066202640533,
0.0004814840212929994,
0.004011290147900581,
0.32734736800193787
] |
{
"id": 1,
"code_window": [
" <label class=\"gf-form-label query-keyword\" ng-if=\"ctrl.showDelimiter($index)\">AND</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"!ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 46
} | import angular from 'angular';
export class AdminListOrgsCtrl {
/** @ngInject */
constructor($scope, backendSrv, navModelSrv) {
$scope.init = function() {
$scope.navModel = navModelSrv.getNav('cfg', 'admin', 'global-orgs', 1);
$scope.getOrgs();
};
$scope.getOrgs = function() {
backendSrv.get('/api/orgs').then(function(orgs) {
$scope.orgs = orgs;
});
};
$scope.deleteOrg = function(org) {
$scope.appEvent('confirm-modal', {
title: 'Delete',
text: 'Do you want to delete organization ' + org.name + '?',
text2: 'All dashboards for this organization will be removed!',
icon: 'fa-trash',
yesText: 'Delete',
onConfirm: function() {
backendSrv.delete('/api/orgs/' + org.id).then(function() {
$scope.getOrgs();
});
},
});
};
$scope.init();
}
}
angular.module('grafana.controllers').controller('AdminListOrgsCtrl', AdminListOrgsCtrl);
| public/app/features/admin/admin_list_orgs_ctrl.ts | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017529122123960406,
0.0001709217467578128,
0.00016721163410693407,
0.00017059207311831415,
0.00000338179006575956
] |
{
"id": 1,
"code_window": [
" <label class=\"gf-form-label query-keyword\" ng-if=\"ctrl.showDelimiter($index)\">AND</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"!ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 46
} | foo[?key == `{"a":2}`] | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-52 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017413805471733212,
0.00017413805471733212,
0.00017413805471733212,
0.00017413805471733212,
0
] |
{
"id": 1,
"code_window": [
" <label class=\"gf-form-label query-keyword\" ng-if=\"ctrl.showDelimiter($index)\">AND</label>\n",
" </div>\n",
"\n",
" <div ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"!ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.segments\" role=\"menuitem\" class=\"gf-form\">\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 46
} | import coreModule from '../../core/core_module';
import _ from 'lodash';
export class DataSourcesCtrl {
datasources: any;
unfiltered: any;
navModel: any;
searchQuery: string;
/** @ngInject */
constructor(private $scope, private backendSrv, private datasourceSrv, private navModelSrv) {
this.navModel = this.navModelSrv.getNav('cfg', 'datasources', 0);
backendSrv.get('/api/datasources').then(result => {
this.datasources = result;
this.unfiltered = result;
});
}
onQueryUpdated() {
let regex = new RegExp(this.searchQuery, 'ig');
this.datasources = _.filter(this.unfiltered, item => {
return regex.test(item.name) || regex.test(item.type);
});
}
removeDataSourceConfirmed(ds) {
this.backendSrv
.delete('/api/datasources/' + ds.id)
.then(
() => {
this.$scope.appEvent('alert-success', ['Datasource deleted', '']);
},
() => {
this.$scope.appEvent('alert-error', ['Unable to delete datasource', '']);
}
)
.then(() => {
this.backendSrv.get('/api/datasources').then(result => {
this.datasources = result;
});
this.backendSrv.get('/api/frontend/settings').then(settings => {
this.datasourceSrv.init(settings.datasources);
});
});
}
removeDataSource(ds) {
this.$scope.appEvent('confirm-modal', {
title: 'Delete',
text: 'Are you sure you want to delete datasource ' + ds.name + '?',
yesText: 'Delete',
icon: 'fa-trash',
onConfirm: () => {
this.removeDataSourceConfirmed(ds);
},
});
}
}
coreModule.controller('DataSourcesCtrl', DataSourcesCtrl);
| public/app/features/plugins/ds_list_ctrl.ts | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001743709872243926,
0.00017270154785364866,
0.0001717340637696907,
0.0001725422771414742,
8.077801112449379e-7
] |
{
"id": 2,
"code_window": [
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.unpause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-play\"></i></a>\n",
" </div>\n",
" <!--\n",
" <div ng-if=\"!ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.pause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-pause\"></i></a>\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 50
} | import './add_graphite_func';
import './func_editor';
import _ from 'lodash';
import GraphiteQuery from './graphite_query';
import { QueryCtrl } from 'app/plugins/sdk';
import appEvents from 'app/core/app_events';
const GRAPHITE_TAG_OPERATORS = ['=', '!=', '=~', '!=~'];
const TAG_PREFIX = 'tag: ';
export class GraphiteQueryCtrl extends QueryCtrl {
static templateUrl = 'partials/query.editor.html';
queryModel: GraphiteQuery;
segments: any[];
addTagSegments: any[];
removeTagValue: string;
supportsTags: boolean;
/** @ngInject **/
constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {
super($scope, $injector);
this.supportsTags = this.datasource.supportsTags;
if (this.target) {
this.target.target = this.target.target || '';
this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);
this.buildSegments();
}
this.removeTagValue = '-- remove tag --';
}
parseTarget() {
this.queryModel.parseTarget();
this.buildSegments();
}
toggleEditorMode() {
this.target.textEditor = !this.target.textEditor;
this.parseTarget();
}
buildSegments() {
this.segments = _.map(this.queryModel.segments, segment => {
return this.uiSegmentSrv.newSegment(segment);
});
let checkOtherSegmentsIndex = this.queryModel.checkOtherSegmentsIndex || 0;
this.checkOtherSegments(checkOtherSegmentsIndex);
if (this.queryModel.seriesByTagUsed) {
this.fixTagSegments();
}
}
addSelectMetricSegment() {
this.queryModel.addSelectMetricSegment();
this.segments.push(this.uiSegmentSrv.newSelectMetric());
}
checkOtherSegments(fromIndex) {
if (this.queryModel.segments.length === 1 && this.queryModel.segments[0].type === 'series-ref') {
return;
}
if (fromIndex === 0) {
this.addSelectMetricSegment();
return;
}
var path = this.queryModel.getSegmentPathUpTo(fromIndex + 1);
if (path === '') {
return Promise.resolve();
}
return this.datasource
.metricFindQuery(path)
.then(segments => {
if (segments.length === 0) {
if (path !== '') {
this.queryModel.segments = this.queryModel.segments.splice(0, fromIndex);
this.segments = this.segments.splice(0, fromIndex);
this.addSelectMetricSegment();
}
} else if (segments[0].expandable) {
if (this.segments.length === fromIndex) {
this.addSelectMetricSegment();
} else {
return this.checkOtherSegments(fromIndex + 1);
}
}
})
.catch(err => {
appEvents.emit('alert-error', ['Error', err]);
});
}
setSegmentFocus(segmentIndex) {
_.each(this.segments, (segment, index) => {
segment.focus = segmentIndex === index;
});
}
getAltSegments(index) {
var query = index === 0 ? '*' : this.queryModel.getSegmentPathUpTo(index) + '.*';
var options = {
range: this.panelCtrl.range,
requestId: 'get-alt-segments',
};
return this.datasource
.metricFindQuery(query, options)
.then(segments => {
var altSegments = _.map(segments, segment => {
return this.uiSegmentSrv.newSegment({
value: segment.text,
expandable: segment.expandable,
});
});
if (altSegments.length === 0) {
return altSegments;
}
// add query references
if (index === 0) {
_.eachRight(this.panelCtrl.panel.targets, target => {
if (target.refId === this.queryModel.target.refId) {
return;
}
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'series-ref',
value: '#' + target.refId,
expandable: false,
})
);
});
}
// add template variables
_.eachRight(this.templateSrv.variables, variable => {
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'template',
value: '$' + variable.name,
expandable: true,
})
);
});
// add wildcard option
altSegments.unshift(this.uiSegmentSrv.newSegment('*'));
if (this.supportsTags && index === 0) {
this.removeTaggedEntry(altSegments);
return this.addAltTagSegments(index, altSegments);
} else {
return altSegments;
}
})
.catch(err => {
return [];
});
}
addAltTagSegments(index, altSegments) {
return this.getTagsAsSegments().then(tagSegments => {
tagSegments = _.map(tagSegments, segment => {
segment.value = TAG_PREFIX + segment.value;
return segment;
});
return altSegments.concat(...tagSegments);
});
}
removeTaggedEntry(altSegments) {
altSegments = _.remove(altSegments, s => s.value === '_tagged');
}
segmentValueChanged(segment, segmentIndex) {
this.error = null;
this.queryModel.updateSegmentValue(segment, segmentIndex);
if (this.queryModel.functions.length > 0 && this.queryModel.functions[0].def.fake) {
this.queryModel.functions = [];
}
if (segment.type === 'tag') {
let tag = removeTagPrefix(segment.value);
this.addSeriesByTagFunc(tag);
return;
}
if (segment.expandable) {
return this.checkOtherSegments(segmentIndex + 1).then(() => {
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
});
} else {
this.spliceSegments(segmentIndex + 1);
}
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
}
spliceSegments(index) {
this.segments = this.segments.splice(0, index);
this.queryModel.segments = this.queryModel.segments.splice(0, index);
}
emptySegments() {
this.queryModel.segments = [];
this.segments = [];
}
targetTextChanged() {
this.updateModelTarget();
this.refresh();
}
updateModelTarget() {
this.queryModel.updateModelTarget(this.panelCtrl.panel.targets);
}
targetChanged() {
if (this.queryModel.error) {
return;
}
var oldTarget = this.queryModel.target.target;
this.updateModelTarget();
if (this.queryModel.target !== oldTarget) {
this.panelCtrl.refresh();
}
}
addFunction(funcDef) {
var newFunc = this.datasource.createFuncInstance(funcDef, {
withDefaultParams: true,
});
newFunc.added = true;
this.queryModel.addFunction(newFunc);
this.smartlyHandleNewAliasByNode(newFunc);
if (this.segments.length === 1 && this.segments[0].fake) {
this.emptySegments();
}
if (!newFunc.params.length && newFunc.added) {
this.targetChanged();
}
if (newFunc.def.name === 'seriesByTag') {
this.parseTarget();
}
}
removeFunction(func) {
this.queryModel.removeFunction(func);
this.targetChanged();
}
addSeriesByTagFunc(tag) {
let newFunc = this.datasource.createFuncInstance('seriesByTag', {
withDefaultParams: false,
});
let tagParam = `${tag}=`;
newFunc.params = [tagParam];
this.queryModel.addFunction(newFunc);
newFunc.added = true;
this.emptySegments();
this.targetChanged();
this.parseTarget();
}
smartlyHandleNewAliasByNode(func) {
if (func.def.name !== 'aliasByNode') {
return;
}
for (var i = 0; i < this.segments.length; i++) {
if (this.segments[i].value.indexOf('*') >= 0) {
func.params[0] = i;
func.added = false;
this.targetChanged();
return;
}
}
}
getAllTags() {
return this.datasource.getTags().then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTags(index, tagPrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
return this.datasource.getTagsAutoComplete(tagExpressions, tagPrefix).then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTagsAsSegments() {
let tagExpressions = this.queryModel.renderTagExpressions();
return this.datasource.getTagsAutoComplete(tagExpressions).then(values => {
return _.map(values, val => {
return this.uiSegmentSrv.newSegment({
value: val.text,
type: 'tag',
expandable: false,
});
});
});
}
getTagOperators() {
return mapToDropdownOptions(GRAPHITE_TAG_OPERATORS);
}
getAllTagValues(tag) {
let tagKey = tag.key;
return this.datasource.getTagValues(tagKey).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
getTagValues(tag, index, valuePrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
let tagKey = tag.key;
return this.datasource.getTagValuesAutoComplete(tagExpressions, tagKey, valuePrefix).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
tagChanged(tag, tagIndex) {
this.queryModel.updateTag(tag, tagIndex);
this.targetChanged();
}
addNewTag(segment) {
let newTagKey = segment.value;
let newTag = { key: newTagKey, operator: '=', value: '' };
this.queryModel.addTag(newTag);
this.targetChanged();
this.fixTagSegments();
}
removeTag(index) {
this.queryModel.removeTag(index);
this.targetChanged();
}
fixTagSegments() {
// Adding tag with the same name as just removed works incorrectly if single segment is used (instead of array)
this.addTagSegments = [this.uiSegmentSrv.newPlusButton()];
}
showDelimiter(index) {
return index !== this.queryModel.tags.length - 1;
}
}
function mapToDropdownOptions(results) {
return _.map(results, value => {
return { text: value, value: value };
});
}
function removeTagPrefix(value: string): string {
return value.replace(TAG_PREFIX, '');
}
| public/app/plugins/datasource/graphite/query_ctrl.ts | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.026474719867110252,
0.003546459134668112,
0.00016525646788068116,
0.0005933624925091863,
0.006258186884224415
] |
{
"id": 2,
"code_window": [
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.unpause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-play\"></i></a>\n",
" </div>\n",
" <!--\n",
" <div ng-if=\"!ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.pause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-pause\"></i></a>\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 50
} | # my global config
global:
scrape_interval: 10s # By default, scrape targets every 15 seconds.
evaluation_interval: 10s # By default, scrape targets every 15 seconds.
# scrape_timeout is set to the global default (10s).
# Load and evaluate rules in this file every 'evaluation_interval' seconds.
#rule_files:
# - "alert.rules"
# - "first.rules"
# - "second.rules"
# alerting:
# alertmanagers:
# - scheme: http
# static_configs:
# - targets:
# - "127.0.0.1:9093"
scrape_configs:
- job_name: 'prometheus'
static_configs:
- targets: ['localhost:9090']
- job_name: 'node_exporter'
static_configs:
- targets: ['127.0.0.1:9100']
- job_name: 'fake-data-gen'
static_configs:
- targets: ['127.0.0.1:9091']
- job_name: 'grafana'
static_configs:
- targets: ['127.0.0.1:3000']
| docker/blocks/prometheus2/prometheus.yml | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017653460963629186,
0.00017409627616871148,
0.00017258389561902732,
0.00017363327788189054,
0.0000015158361748035531
] |
{
"id": 2,
"code_window": [
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.unpause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-play\"></i></a>\n",
" </div>\n",
" <!--\n",
" <div ng-if=\"!ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.pause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-pause\"></i></a>\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 50
} | .page-kiosk-mode {
dashnav {
display: none;
}
}
.playlist-active,
.user-activity-low {
.react-resizable-handle .add-row-panel-hint,
.dash-row-menu-container,
.navbar-button--refresh,
.navbar-buttons--zoom,
.navbar-buttons--actions,
.panel-menu-container,
.panel-info-corner--info,
.panel-info-corner--links {
opacity: 0;
}
.navbar {
box-shadow: none;
background: transparent;
}
.navbar-page-btn {
border-color: transparent;
background: transparent;
transform: translate3d(-40px, 0, 0);
i {
opacity: 0;
}
}
.gf-timepicker-nav-btn {
transform: translate3d(40px, 0, 0);
}
}
| public/sass/components/_view_states.scss | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017385715909767896,
0.0001689320633886382,
0.00016443064669147134,
0.00016872023115865886,
0.00000336800076183863
] |
{
"id": 2,
"code_window": [
" <metric-segment segment=\"segment\" get-options=\"ctrl.getAltSegments($index)\" on-change=\"ctrl.segmentValueChanged(segment, $index)\" />\n",
" </div>\n",
"\n",
" <div ng-if=\"ctrl.queryModel.seriesByTagUsed\" ng-repeat=\"segment in ctrl.addTagSegments\" role=\"menuitem\" class=\"gf-form\">\n",
" <metric-segment segment=\"segment\" get-options=\"ctrl.getTagsAsSegments()\" on-change=\"ctrl.addNewTag(segment)\" />\n",
" </div>\n"
],
"labels": [
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
" <div ng-if=\"ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.unpause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-play\"></i></a>\n",
" </div>\n",
" <!--\n",
" <div ng-if=\"!ctrl.paused\" class=\"gf-form\">\n",
" <a ng-click=\"ctrl.pause()\" class=\"gf-form-label query-part\"><i class=\"fa fa-pause\"></i></a>\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "replace",
"edit_start_line_idx": 50
} | foo.bar[*].baz[2] | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-599 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017133857181761414,
0.00017133857181761414,
0.00017133857181761414,
0.00017133857181761414,
0
] |
{
"id": 3,
"code_window": [
" </div>\n",
"\n",
" <div class=\"gf-form gf-form--grow\">\n",
" <div class=\"gf-form-label gf-form-label--grow\"></div>\n",
" </div>\n",
" </div>\n"
],
"labels": [
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" -->\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "add",
"edit_start_line_idx": 53
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.6151315569877625,
0.1535015106201172,
0.00016495089221280068,
0.000997816794551909,
0.2645300328731537
] |
{
"id": 3,
"code_window": [
" </div>\n",
"\n",
" <div class=\"gf-form gf-form--grow\">\n",
" <div class=\"gf-form-label gf-form-label--grow\"></div>\n",
" </div>\n",
" </div>\n"
],
"labels": [
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" -->\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "add",
"edit_start_line_idx": 53
} | // TODO: in order for this reporter to be completely honest
// we need to retrofit to be more like the json reporter such that:
// 1. it maintains ScopeResult collections, which count assertions
// 2. it reports only after EndStory(), so that all tick marks
// are placed near the appropriate title.
// 3. Under unit test
package reporting
import (
"fmt"
"strings"
)
type story struct {
out *Printer
titlesById map[string]string
currentKey []string
}
func (self *story) BeginStory(story *StoryReport) {}
func (self *story) Enter(scope *ScopeReport) {
self.out.Indent()
self.currentKey = append(self.currentKey, scope.Title)
ID := strings.Join(self.currentKey, "|")
if _, found := self.titlesById[ID]; !found {
self.out.Println("")
self.out.Print(scope.Title)
self.out.Insert(" ")
self.titlesById[ID] = scope.Title
}
}
func (self *story) Report(report *AssertionResult) {
if report.Error != nil {
fmt.Print(redColor)
self.out.Insert(error_)
} else if report.Failure != "" {
fmt.Print(yellowColor)
self.out.Insert(failure)
} else if report.Skipped {
fmt.Print(yellowColor)
self.out.Insert(skip)
} else {
fmt.Print(greenColor)
self.out.Insert(success)
}
fmt.Print(resetColor)
}
func (self *story) Exit() {
self.out.Dedent()
self.currentKey = self.currentKey[:len(self.currentKey)-1]
}
func (self *story) EndStory() {
self.titlesById = make(map[string]string)
self.out.Println("\n")
}
func (self *story) Write(content []byte) (written int, err error) {
return len(content), nil // no-op
}
func NewStoryReporter(out *Printer) *story {
self := new(story)
self.out = out
self.titlesById = make(map[string]string)
return self
}
| vendor/github.com/smartystreets/goconvey/convey/reporting/story.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017472532636020333,
0.0001698286214377731,
0.0001654063817113638,
0.00016955044702626765,
0.00000338880522576801
] |
{
"id": 3,
"code_window": [
" </div>\n",
"\n",
" <div class=\"gf-form gf-form--grow\">\n",
" <div class=\"gf-form-label gf-form-label--grow\"></div>\n",
" </div>\n",
" </div>\n"
],
"labels": [
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" -->\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "add",
"edit_start_line_idx": 53
} | <div class="modal-body">
<div class="modal-header">
<h2 class="modal-header-title">
<i class="fa fa-copy"></i>
<span class="p-l-1">Row Options</span>
</h2>
<a class="modal-header-close" ng-click="ctrl.dismiss();">
<i class="fa fa-remove"></i>
</a>
</div>
<form name="ctrl.saveForm" ng-submit="ctrl.save()" class="modal-content text-center" novalidate>
<div class="section">
<div class="gf-form">
<span class="gf-form-label width-7">Title</span>
<input type="text" class="gf-form-input max-width-13" ng-model='ctrl.row.title'></input>
</div>
<div class="gf-form">
<span class="gf-form-label width-7">Repeat for</span>
<dash-repeat-option panel="ctrl.row"></dash-repeat-option>
</div>
<div class="gf-form-button-row">
<button type="submit" class="btn btn-success" ng-click="ctrl.update()">Update</button>
<button type="button" class="btn btn-inverse" ng-click="ctrl.dismiss()">Cancel</button>
</div>
</div>
</form>
</div>
| public/app/features/dashboard/partials/row_options.html | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0005961944116279483,
0.00036246521631255746,
0.00016398972366005182,
0.00034483836498111486,
0.00019452931883279234
] |
{
"id": 3,
"code_window": [
" </div>\n",
"\n",
" <div class=\"gf-form gf-form--grow\">\n",
" <div class=\"gf-form-label gf-form-label--grow\"></div>\n",
" </div>\n",
" </div>\n"
],
"labels": [
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" -->\n"
],
"file_path": "public/app/plugins/datasource/graphite/partials/query.editor.html",
"type": "add",
"edit_start_line_idx": 53
} | package notifiers
import (
"testing"
"github.com/grafana/grafana/pkg/components/simplejson"
m "github.com/grafana/grafana/pkg/models"
. "github.com/smartystreets/goconvey/convey"
)
func TestOpsGenieNotifier(t *testing.T) {
Convey("OpsGenie notifier tests", t, func() {
Convey("Parsing alert notification from settings", func() {
Convey("empty settings should return error", func() {
json := `{ }`
settingsJSON, _ := simplejson.NewJson([]byte(json))
model := &m.AlertNotification{
Name: "opsgenie_testing",
Type: "opsgenie",
Settings: settingsJSON,
}
_, err := NewOpsGenieNotifier(model)
So(err, ShouldNotBeNil)
})
Convey("settings should trigger incident", func() {
json := `
{
"apiKey": "abcdefgh0123456789"
}`
settingsJSON, _ := simplejson.NewJson([]byte(json))
model := &m.AlertNotification{
Name: "opsgenie_testing",
Type: "opsgenie",
Settings: settingsJSON,
}
not, err := NewOpsGenieNotifier(model)
opsgenieNotifier := not.(*OpsGenieNotifier)
So(err, ShouldBeNil)
So(opsgenieNotifier.Name, ShouldEqual, "opsgenie_testing")
So(opsgenieNotifier.Type, ShouldEqual, "opsgenie")
So(opsgenieNotifier.ApiKey, ShouldEqual, "abcdefgh0123456789")
})
})
})
}
| pkg/services/alerting/notifiers/opsgenie_test.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017805452807806432,
0.00017191767983604223,
0.00016854745626915246,
0.0001702858426142484,
0.000003354628688612138
] |
{
"id": 4,
"code_window": [
" segments: any[];\n",
" addTagSegments: any[];\n",
" removeTagValue: string;\n",
" supportsTags: boolean;\n",
"\n",
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" paused: boolean;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 19
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00032646345789544284,
0.00019086938118562102,
0.00016645870346110314,
0.00017362718062940985,
0.0000513698578288313
] |
{
"id": 4,
"code_window": [
" segments: any[];\n",
" addTagSegments: any[];\n",
" removeTagValue: string;\n",
" supportsTags: boolean;\n",
"\n",
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" paused: boolean;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 19
} | .dashlist-section-header {
margin-bottom: $spacer;
color: $text-color-weak;
}
.dashlist-section {
margin-bottom: $spacer;
}
.dashlist-link {
@include list-item();
.fa {
padding-top: 3px;
}
.dashlist-star {
float: right;
}
.fa-star {
color: $orange;
}
}
| public/sass/components/_panel_dashlist.scss | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017809665587265044,
0.00017484634008724242,
0.0001727674825815484,
0.0001736749109113589,
0.0000023279781089513563
] |
{
"id": 4,
"code_window": [
" segments: any[];\n",
" addTagSegments: any[];\n",
" removeTagValue: string;\n",
" supportsTags: boolean;\n",
"\n",
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" paused: boolean;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 19
} | @import "base/fonts";
| public/sass/fonts.scss | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001747713249642402,
0.0001747713249642402,
0.0001747713249642402,
0.0001747713249642402,
0
] |
{
"id": 4,
"code_window": [
" segments: any[];\n",
" addTagSegments: any[];\n",
" removeTagValue: string;\n",
" supportsTags: boolean;\n",
"\n",
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" paused: boolean;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 19
} | package datasources
import (
"testing"
"github.com/grafana/grafana/pkg/bus"
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/models"
. "github.com/smartystreets/goconvey/convey"
)
var (
logger log.Logger = log.New("fake.logger")
oneDatasourcesConfig string = ""
twoDatasourcesConfig string = "./test-configs/two-datasources"
twoDatasourcesConfigPurgeOthers string = "./test-configs/insert-two-delete-two"
doubleDatasourcesConfig string = "./test-configs/double-default"
allProperties string = "./test-configs/all-properties"
brokenYaml string = "./test-configs/broken-yaml"
fakeRepo *fakeRepository
)
func TestDatasourceAsConfig(t *testing.T) {
Convey("Testing datasource as configuration", t, func() {
fakeRepo = &fakeRepository{}
bus.ClearBusHandlers()
bus.AddHandler("test", mockDelete)
bus.AddHandler("test", mockInsert)
bus.AddHandler("test", mockUpdate)
bus.AddHandler("test", mockGet)
bus.AddHandler("test", mockGetAll)
Convey("One configured datasource", func() {
Convey("no datasource in database", func() {
dc := newDatasourceProvisioner(logger)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 2)
So(len(fakeRepo.updated), ShouldEqual, 0)
})
Convey("One datasource in database with same name", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "Graphite", OrgId: 1, Id: 1},
}
Convey("should update one datasource", func() {
dc := newDatasourceProvisioner(logger)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 1)
So(len(fakeRepo.updated), ShouldEqual, 1)
})
})
Convey("Two datasources with is_default", func() {
dc := newDatasourceProvisioner(logger)
err := dc.applyChanges(doubleDatasourcesConfig)
Convey("should raise error", func() {
So(err, ShouldEqual, ErrInvalidConfigToManyDefault)
})
})
})
Convey("Two configured datasource and purge others ", func() {
Convey("two other datasources in database", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "old-graphite", OrgId: 1, Id: 1},
{Name: "old-graphite2", OrgId: 1, Id: 2},
}
Convey("should have two new datasources", func() {
dc := newDatasourceProvisioner(logger)
err := dc.applyChanges(twoDatasourcesConfigPurgeOthers)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 2)
So(len(fakeRepo.inserted), ShouldEqual, 2)
So(len(fakeRepo.updated), ShouldEqual, 0)
})
})
})
Convey("Two configured datasource and purge others = false", func() {
Convey("two other datasources in database", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "Graphite", OrgId: 1, Id: 1},
{Name: "old-graphite2", OrgId: 1, Id: 2},
}
Convey("should have two new datasources", func() {
dc := newDatasourceProvisioner(logger)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 1)
So(len(fakeRepo.updated), ShouldEqual, 1)
})
})
})
Convey("broken yaml should return error", func() {
_, err := configReader{}.readConfig(brokenYaml)
So(err, ShouldNotBeNil)
})
Convey("can read all properties", func() {
cfgProvifer := configReader{}
cfg, err := cfgProvifer.readConfig(allProperties)
if err != nil {
t.Fatalf("readConfig return an error %v", err)
}
So(len(cfg), ShouldEqual, 2)
dsCfg := cfg[0]
ds := dsCfg.Datasources[0]
So(ds.Name, ShouldEqual, "name")
So(ds.Type, ShouldEqual, "type")
So(ds.Access, ShouldEqual, models.DS_ACCESS_PROXY)
So(ds.OrgId, ShouldEqual, 2)
So(ds.Url, ShouldEqual, "url")
So(ds.User, ShouldEqual, "user")
So(ds.Password, ShouldEqual, "password")
So(ds.Database, ShouldEqual, "database")
So(ds.BasicAuth, ShouldBeTrue)
So(ds.BasicAuthUser, ShouldEqual, "basic_auth_user")
So(ds.BasicAuthPassword, ShouldEqual, "basic_auth_password")
So(ds.WithCredentials, ShouldBeTrue)
So(ds.IsDefault, ShouldBeTrue)
So(ds.Editable, ShouldBeTrue)
So(len(ds.JsonData), ShouldBeGreaterThan, 2)
So(ds.JsonData["graphiteVersion"], ShouldEqual, "1.1")
So(ds.JsonData["tlsAuth"], ShouldEqual, true)
So(ds.JsonData["tlsAuthWithCACert"], ShouldEqual, true)
So(len(ds.SecureJsonData), ShouldBeGreaterThan, 2)
So(ds.SecureJsonData["tlsCACert"], ShouldEqual, "MjNOcW9RdkbUDHZmpco2HCYzVq9dE+i6Yi+gmUJotq5CDA==")
So(ds.SecureJsonData["tlsClientCert"], ShouldEqual, "ckN0dGlyMXN503YNfjTcf9CV+GGQneN+xmAclQ==")
So(ds.SecureJsonData["tlsClientKey"], ShouldEqual, "ZkN4aG1aNkja/gKAB1wlnKFIsy2SRDq4slrM0A==")
dstwo := cfg[1].Datasources[0]
So(dstwo.Name, ShouldEqual, "name2")
})
})
}
type fakeRepository struct {
inserted []*models.AddDataSourceCommand
deleted []*models.DeleteDataSourceByNameCommand
updated []*models.UpdateDataSourceCommand
loadAll []*models.DataSource
}
func mockDelete(cmd *models.DeleteDataSourceByNameCommand) error {
fakeRepo.deleted = append(fakeRepo.deleted, cmd)
return nil
}
func mockUpdate(cmd *models.UpdateDataSourceCommand) error {
fakeRepo.updated = append(fakeRepo.updated, cmd)
return nil
}
func mockInsert(cmd *models.AddDataSourceCommand) error {
fakeRepo.inserted = append(fakeRepo.inserted, cmd)
return nil
}
func mockGetAll(cmd *models.GetAllDataSourcesQuery) error {
cmd.Result = fakeRepo.loadAll
return nil
}
func mockGet(cmd *models.GetDataSourceByNameQuery) error {
for _, v := range fakeRepo.loadAll {
if cmd.Name == v.Name && cmd.OrgId == v.OrgId {
cmd.Result = v
return nil
}
}
return models.ErrDataSourceNotFound
}
| pkg/services/provisioning/datasources/datasources_test.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00019617647922132164,
0.00017273407138418406,
0.00016564583347644657,
0.00017192543600685894,
0.000007145355084503535
] |
{
"id": 5,
"code_window": [
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n",
"\n",
" if (this.target) {\n",
" this.target.target = this.target.target || '';\n",
" this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);\n",
" this.buildSegments();\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.paused = false;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 24
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001948562276083976,
0.0001720279105938971,
0.0001652555220061913,
0.00016852261614985764,
0.000009027965461427812
] |
{
"id": 5,
"code_window": [
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n",
"\n",
" if (this.target) {\n",
" this.target.target = this.target.target || '';\n",
" this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);\n",
" this.buildSegments();\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.paused = false;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 24
} | "\uD834\uDD1E" | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-322 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017381308134645224,
0.00017381308134645224,
0.00017381308134645224,
0.00017381308134645224,
0
] |
{
"id": 5,
"code_window": [
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n",
"\n",
" if (this.target) {\n",
" this.target.target = this.target.target || '';\n",
" this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);\n",
" this.buildSegments();\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.paused = false;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 24
} | # How to contribute
We definitely welcome your patches and contributions to gRPC!
If you are new to github, please start by reading [Pull Request howto](https://help.github.com/articles/about-pull-requests/)
## Legal requirements
In order to protect both you and ourselves, you will need to sign the
[Contributor License Agreement](https://cla.developers.google.com/clas).
## Guidelines for Pull Requests
How to get your contributions merged smoothly and quickly.
- Create **small PRs** that are narrowly focused on **addressing a single concern**. We often times receive PRs that are trying to fix several things at a time, but only one fix is considered acceptable, nothing gets merged and both author's & review's time is wasted. Create more PRs to address different concerns and everyone will be happy.
- For speculative changes, consider opening an issue and discussing it first. If you are suggesting a behavioral or API change, consider starting with a [gRFC proposal](https://github.com/grpc/proposal).
- Provide a good **PR description** as a record of **what** change is being made and **why** it was made. Link to a github issue if it exists.
- Don't fix code style and formatting unless you are already changing that line to address an issue. PRs with irrelevant changes won't be merged. If you do want to fix formatting or style, do that in a separate PR.
- Unless your PR is trivial, you should expect there will be reviewer comments that you'll need to address before merging. We expect you to be reasonably responsive to those comments, otherwise the PR will be closed after 2-3 weeks of inactivity.
- Maintain **clean commit history** and use **meaningful commit messages**. PRs with messy commit history are difficult to review and won't be merged. Use `rebase -i upstream/master` to curate your commit history and/or to bring in latest changes from master (but avoid rebasing in the middle of a code review).
- Keep your PR up to date with upstream/master (if there are merge conflicts, we can't really merge your change).
- **All tests need to be passing** before your change can be merged. We recommend you **run tests locally** before creating your PR to catch breakages early on.
- Exceptions to the rules can be made if there's a compelling reason for doing so.
| vendor/google.golang.org/grpc/CONTRIBUTING.md | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001751942909322679,
0.00017199771536979824,
0.00017071887850761414,
0.00017103884601965547,
0.0000018515105466576642
] |
{
"id": 5,
"code_window": [
" /** @ngInject **/\n",
" constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {\n",
" super($scope, $injector);\n",
" this.supportsTags = this.datasource.supportsTags;\n",
"\n",
" if (this.target) {\n",
" this.target.target = this.target.target || '';\n",
" this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);\n",
" this.buildSegments();\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.paused = false;\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 24
} | outer.bad||outer.foo | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-476 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017470234888605773,
0.00017470234888605773,
0.00017470234888605773,
0.00017470234888605773,
0
] |
{
"id": 6,
"code_window": [
"\n",
" if (segment.type === 'tag') {\n",
" let tag = removeTagPrefix(segment.value);\n",
" this.addSeriesByTagFunc(tag);\n",
" return;\n",
" }\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.pause();\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 193
} | import './add_graphite_func';
import './func_editor';
import _ from 'lodash';
import GraphiteQuery from './graphite_query';
import { QueryCtrl } from 'app/plugins/sdk';
import appEvents from 'app/core/app_events';
const GRAPHITE_TAG_OPERATORS = ['=', '!=', '=~', '!=~'];
const TAG_PREFIX = 'tag: ';
export class GraphiteQueryCtrl extends QueryCtrl {
static templateUrl = 'partials/query.editor.html';
queryModel: GraphiteQuery;
segments: any[];
addTagSegments: any[];
removeTagValue: string;
supportsTags: boolean;
/** @ngInject **/
constructor($scope, $injector, private uiSegmentSrv, private templateSrv) {
super($scope, $injector);
this.supportsTags = this.datasource.supportsTags;
if (this.target) {
this.target.target = this.target.target || '';
this.queryModel = new GraphiteQuery(this.datasource, this.target, templateSrv);
this.buildSegments();
}
this.removeTagValue = '-- remove tag --';
}
parseTarget() {
this.queryModel.parseTarget();
this.buildSegments();
}
toggleEditorMode() {
this.target.textEditor = !this.target.textEditor;
this.parseTarget();
}
buildSegments() {
this.segments = _.map(this.queryModel.segments, segment => {
return this.uiSegmentSrv.newSegment(segment);
});
let checkOtherSegmentsIndex = this.queryModel.checkOtherSegmentsIndex || 0;
this.checkOtherSegments(checkOtherSegmentsIndex);
if (this.queryModel.seriesByTagUsed) {
this.fixTagSegments();
}
}
addSelectMetricSegment() {
this.queryModel.addSelectMetricSegment();
this.segments.push(this.uiSegmentSrv.newSelectMetric());
}
checkOtherSegments(fromIndex) {
if (this.queryModel.segments.length === 1 && this.queryModel.segments[0].type === 'series-ref') {
return;
}
if (fromIndex === 0) {
this.addSelectMetricSegment();
return;
}
var path = this.queryModel.getSegmentPathUpTo(fromIndex + 1);
if (path === '') {
return Promise.resolve();
}
return this.datasource
.metricFindQuery(path)
.then(segments => {
if (segments.length === 0) {
if (path !== '') {
this.queryModel.segments = this.queryModel.segments.splice(0, fromIndex);
this.segments = this.segments.splice(0, fromIndex);
this.addSelectMetricSegment();
}
} else if (segments[0].expandable) {
if (this.segments.length === fromIndex) {
this.addSelectMetricSegment();
} else {
return this.checkOtherSegments(fromIndex + 1);
}
}
})
.catch(err => {
appEvents.emit('alert-error', ['Error', err]);
});
}
setSegmentFocus(segmentIndex) {
_.each(this.segments, (segment, index) => {
segment.focus = segmentIndex === index;
});
}
getAltSegments(index) {
var query = index === 0 ? '*' : this.queryModel.getSegmentPathUpTo(index) + '.*';
var options = {
range: this.panelCtrl.range,
requestId: 'get-alt-segments',
};
return this.datasource
.metricFindQuery(query, options)
.then(segments => {
var altSegments = _.map(segments, segment => {
return this.uiSegmentSrv.newSegment({
value: segment.text,
expandable: segment.expandable,
});
});
if (altSegments.length === 0) {
return altSegments;
}
// add query references
if (index === 0) {
_.eachRight(this.panelCtrl.panel.targets, target => {
if (target.refId === this.queryModel.target.refId) {
return;
}
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'series-ref',
value: '#' + target.refId,
expandable: false,
})
);
});
}
// add template variables
_.eachRight(this.templateSrv.variables, variable => {
altSegments.unshift(
this.uiSegmentSrv.newSegment({
type: 'template',
value: '$' + variable.name,
expandable: true,
})
);
});
// add wildcard option
altSegments.unshift(this.uiSegmentSrv.newSegment('*'));
if (this.supportsTags && index === 0) {
this.removeTaggedEntry(altSegments);
return this.addAltTagSegments(index, altSegments);
} else {
return altSegments;
}
})
.catch(err => {
return [];
});
}
addAltTagSegments(index, altSegments) {
return this.getTagsAsSegments().then(tagSegments => {
tagSegments = _.map(tagSegments, segment => {
segment.value = TAG_PREFIX + segment.value;
return segment;
});
return altSegments.concat(...tagSegments);
});
}
removeTaggedEntry(altSegments) {
altSegments = _.remove(altSegments, s => s.value === '_tagged');
}
segmentValueChanged(segment, segmentIndex) {
this.error = null;
this.queryModel.updateSegmentValue(segment, segmentIndex);
if (this.queryModel.functions.length > 0 && this.queryModel.functions[0].def.fake) {
this.queryModel.functions = [];
}
if (segment.type === 'tag') {
let tag = removeTagPrefix(segment.value);
this.addSeriesByTagFunc(tag);
return;
}
if (segment.expandable) {
return this.checkOtherSegments(segmentIndex + 1).then(() => {
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
});
} else {
this.spliceSegments(segmentIndex + 1);
}
this.setSegmentFocus(segmentIndex + 1);
this.targetChanged();
}
spliceSegments(index) {
this.segments = this.segments.splice(0, index);
this.queryModel.segments = this.queryModel.segments.splice(0, index);
}
emptySegments() {
this.queryModel.segments = [];
this.segments = [];
}
targetTextChanged() {
this.updateModelTarget();
this.refresh();
}
updateModelTarget() {
this.queryModel.updateModelTarget(this.panelCtrl.panel.targets);
}
targetChanged() {
if (this.queryModel.error) {
return;
}
var oldTarget = this.queryModel.target.target;
this.updateModelTarget();
if (this.queryModel.target !== oldTarget) {
this.panelCtrl.refresh();
}
}
addFunction(funcDef) {
var newFunc = this.datasource.createFuncInstance(funcDef, {
withDefaultParams: true,
});
newFunc.added = true;
this.queryModel.addFunction(newFunc);
this.smartlyHandleNewAliasByNode(newFunc);
if (this.segments.length === 1 && this.segments[0].fake) {
this.emptySegments();
}
if (!newFunc.params.length && newFunc.added) {
this.targetChanged();
}
if (newFunc.def.name === 'seriesByTag') {
this.parseTarget();
}
}
removeFunction(func) {
this.queryModel.removeFunction(func);
this.targetChanged();
}
addSeriesByTagFunc(tag) {
let newFunc = this.datasource.createFuncInstance('seriesByTag', {
withDefaultParams: false,
});
let tagParam = `${tag}=`;
newFunc.params = [tagParam];
this.queryModel.addFunction(newFunc);
newFunc.added = true;
this.emptySegments();
this.targetChanged();
this.parseTarget();
}
smartlyHandleNewAliasByNode(func) {
if (func.def.name !== 'aliasByNode') {
return;
}
for (var i = 0; i < this.segments.length; i++) {
if (this.segments[i].value.indexOf('*') >= 0) {
func.params[0] = i;
func.added = false;
this.targetChanged();
return;
}
}
}
getAllTags() {
return this.datasource.getTags().then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTags(index, tagPrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
return this.datasource.getTagsAutoComplete(tagExpressions, tagPrefix).then(values => {
let altTags = _.map(values, 'text');
altTags.splice(0, 0, this.removeTagValue);
return mapToDropdownOptions(altTags);
});
}
getTagsAsSegments() {
let tagExpressions = this.queryModel.renderTagExpressions();
return this.datasource.getTagsAutoComplete(tagExpressions).then(values => {
return _.map(values, val => {
return this.uiSegmentSrv.newSegment({
value: val.text,
type: 'tag',
expandable: false,
});
});
});
}
getTagOperators() {
return mapToDropdownOptions(GRAPHITE_TAG_OPERATORS);
}
getAllTagValues(tag) {
let tagKey = tag.key;
return this.datasource.getTagValues(tagKey).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
getTagValues(tag, index, valuePrefix) {
let tagExpressions = this.queryModel.renderTagExpressions(index);
let tagKey = tag.key;
return this.datasource.getTagValuesAutoComplete(tagExpressions, tagKey, valuePrefix).then(values => {
let altValues = _.map(values, 'text');
return mapToDropdownOptions(altValues);
});
}
tagChanged(tag, tagIndex) {
this.queryModel.updateTag(tag, tagIndex);
this.targetChanged();
}
addNewTag(segment) {
let newTagKey = segment.value;
let newTag = { key: newTagKey, operator: '=', value: '' };
this.queryModel.addTag(newTag);
this.targetChanged();
this.fixTagSegments();
}
removeTag(index) {
this.queryModel.removeTag(index);
this.targetChanged();
}
fixTagSegments() {
// Adding tag with the same name as just removed works incorrectly if single segment is used (instead of array)
this.addTagSegments = [this.uiSegmentSrv.newPlusButton()];
}
showDelimiter(index) {
return index !== this.queryModel.tags.length - 1;
}
}
function mapToDropdownOptions(results) {
return _.map(results, value => {
return { text: value, value: value };
});
}
function removeTagPrefix(value: string): string {
return value.replace(TAG_PREFIX, '');
}
| public/app/plugins/datasource/graphite/query_ctrl.ts | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.9983123540878296,
0.04827195033431053,
0.0001637913956074044,
0.0007667565951123834,
0.17040152847766876
] |
{
"id": 6,
"code_window": [
"\n",
" if (segment.type === 'tag') {\n",
" let tag = removeTagPrefix(segment.value);\n",
" this.addSeriesByTagFunc(tag);\n",
" return;\n",
" }\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.pause();\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 193
} | package unidecode
// AUTOGENERATED - DO NOT EDIT!
var tableData = "x\xda,\x9c\x05\\\x1cW\xd7\xc6\xf7\xcc\xec.]\x96e\x17[\xa8\x84\x92ThB\x02qwwwe\x80\t;\xd8\x00\xcbB ^\xb7\xd4ݛ\xba\xb7\x91\xb6\x91\xba[jI=\xa9\xbb\xc4]\xde\xef9\x0f\xdf\xef\xfd\x9d\xff\xb9\xf7̝;w\xce}\xe6\xec얼\x1e\x8f\xe8\xff\xc4\xf0\x88az\xc4\xf4z\xc4\xeb\xf3\x88\xcf\xef\x11\u007f\x92G\x92N\xf3\xc8i\x01\x8f\x04\x92=\x92\x1c\xf4H0\xc5#)!\x8f\x84R=\x92\x1a\xf6H8\xe2\x91H\x9aG\xd2\xd2=\x92\x9eᑌL\x8fdfy$+\xea\x91h\xb6G\xb2s<\x92s\xbaGN?\xc3#g\x9c\xe9\x913\xcf\xf2\xc8Ym<\xd2&\xd7#\xb9g{\xe4\xec<\x8f\xe4\xb5\xf5H\xdbv\x1eiw\x8eG\xce9\xd7#\xe7\x9e\xe7\x91\xf3\xce\xf7\xc8\xf9\xf9\x1eɿ\xc0#\x17\xb4\xf7H\xfb\x0e\x1e\xe9P\xe0\x91\x82\x8e\x1e\xe9\xd8\xc9#\x9d\n=RX䑢\xce\x1e\xe9\xdc\xc5#]\xbaz\xa4k7\x8ft\xeb\xee\x91\xee=<ң\xa7Gz\xf6\xf2H\xaf\xde\x1e\xe9\xdd\xc7#}\xfaz\xa4o?\x8f\xf4\xeb\xef\x91\xfe\x03<2`\xa0G\x06\x0e\xf2Ƞ\xc1\x1e\x19<\xc4#C\x86zd\xe80\x8f\f\x1b\xee\x91\xe1#<2b\xa4GF\x8e\xf2Ȩ\xd1\x1e\x19=\xc6#c\xc6zd\xec8\x8f\x8c\x1b\xef\x91\xf1\x13<2a\xa2G&N\xf2Ȥ\xc9\x1e\x99<\xc5#S\xa6zd\xea4\x8fL\x9b\xee\x91\xe93<2c\xa6Gf\xce\xf2Ȭ\xd9\x1e\x99=\xc7#s\xe6zd\xee<\x8f,\x98\xef\x91\xf9\v\xe0\x17zd\xe1\"\x8f,*\xf6H\xb1\xe5\x11\xab\xc4#%\xa5\x1e)-\xf3H\x99\xed\x11{\xb1G\x16\x97{\xa4<摘\xe3\x11\xa7\xc2#\x15\x95\x1e\xa9\xac\xf2HU\xb5G\xaak<R\xe3zĭ\xf5Hm\x9dG\xea\xea=R\x1f\xf7H\xbc\xc1#\r\t\x8f$\x1a=\xd2\xd8䑦%\x1eY\xd2\xec\x91\xe6\x16\x8f\xb4,\xf5\xc8\xd2e\x1eY\xb6\xdc#\xcbWxd\xc5J\x8f\xac\xbc\x0f\xf9\xbf\x1f\xf9_\xeb1\x86\x15=\xe01&O{\xd0c\x9c;\xe8!\x8f1g\xc0\xc3\x18\xfb\x88ǘ6\xedQl\xcec\x1e\xf3\x82\xd2\xf6\x8fc\xa9Ox\x8c\xfe\xfd\x9f\xc49O#T\xdf\xfe\x19\xecƳ\x1e\xb3\xcc.\u007f\xcec\x14tZ\x87\x8dX\x8f\x8d\u0600\xcdۈ\x85<\x8f\x04\xbd\x80\xcd{\x11\x1b\xb7\t\x1b\xb5\x19\x8b\xde\xe21\x06\x0e\xdc\xea1\xbb\x14u\u007fI\xd9\xf5e\x8f٭\xa8\xfb+؏W\xb1\x17\xaf\xc1^\x87\xbd\x01{\x13\xf6\x16\xecm\x8f1d\xc4;ؠw\xb19\xef\xc1އ}\x00\xfb\x10\x9b\xf3\x11l\x1b\xecc\xd8'\xd8\xc0O\xb19\x9fas>\x87m\x87\xed\x80}\x01\xfb\x12\xc9\xf8\n\xfekl\xd07\xb0oa\xdf\xc1vb\x83vy\x8c\xe9\xb1\xef=F<\xfe\x03\xee\xf1G\xd8O\xb0\x9fa\xbf\xc0~\x85\xfd\xe61,\xfbw\xec\xd1\x1f؟?a\u007f\xc1\xfe\x86\xfd\x83\xfd\xf9\x17\xf6\x1fl7l\x0f\xf6p/\xf6g\x1fnu?\xec\x00\xec \xec\x10\xec04{\x04\xfe(Rs\fv\x1cv\x02v\x12{t\xcac4\xc4\xfe\x87\x06\x9e\xc7!\"b\x19\xf0&\xbc\x17\xde\a\xef\x17\x19\x96$Rz\x1a|\x00>\x19>\b\x9f\x02\x1f\x82O\x15\x19\x1e\x16)\x8b\xc0\xa7\xc1\xa7\x8b\x8c\xc8\x10\xb13\xe1\xb3\xe0\xa3\xf0\xd9\xf09\xf0\xa7ß\x01\u007f&\xfcY\"\xa3ڈ\x94\xe7\u009f\r\x9f\a\xdf\x16\xbe\x1d\xfc9\xf0犌>O$v>|>\xfc\x05\"cڋ8\x1d\xe0\v\xe0;\xc2w\x82/\x84/\x82\xef\f\xdf\x05\xbe\xab\x18c\xc6v\x13é\xe8.2\xb6\x87HEO\x91q\xbdD*{\xc3\xfa\x88\x8c\xef+R\xd5\x0f\xbe?\xfc\x00\xf8\x81\xf0\x83\xe0\a\xc3#\x05\xe3\x87\xc2\x0f\x13\x998\\\xa4f\x04\xfcH\xf8Q\xf0\xa3\xe1Lj\x91_3V\x8c\x9a\xf2qbL\x1c5^d\xd2\x04\x11w\"\xfc$\xf8\xc9\xf0S\u09ca1i\xc441\\{\xba\xc8\xd4\x19\"\xf53\xe1g\xc1φ\x9f\x03?Wd\xda<\x91\xf8|\xf8\x05\xf0\v\xe1\x17\xc1\x17\xc3[\xf0%\"\xd3KE\x1a\xca\xe0m\xf8\xc5\xf0\xe5\xf01\x91\x19\x8eH\xa2\x02\xbe\x12\xbe\n\xbe\x1a\xbe\x06ޅ\xaf\x85\xaf\x83\xaf\x87\x8f\xc37\x88\xccJ\x8845\x8a\xcci\x12i^\x02\xdf,2\xb7E\xf0l\xc2/\x83_\x0e\xbf\x02~%\xae\xbbJ\xa4d\xb5\xc8\xd0\va\x17\xa1}\xb1H\xcfK`\x97\xe2\xce.Ö_\x8e-\xbf\x02[}%\xec*\xd8\xd5\xd8\xf25\xb0kD\xba]+2\xf8:l\xef\xf5\"#o\x10Y|#\xb6\xf2&\xd8\xcdb\xc4\x1ao\xc1\xfe\xdc\n\xbb\r\xbbq;v\xe2\x0ed\xf9N\xd8]X\xe0\xdd\xc8\xee=\xc8\uef78\xc8}\xb0\xfb\x91µH\xe1\x98\a\x90B\xe7A\x91\xc9\x0f\x89\xd4>,Ɯ\xa9\x8f\x88t}\x14\xf6\x98\x18\xd3F?.F<\xf6\x04\xb2\xf2$\xb2\xf3\x14\xfc\xd3\xf0\xcf\xe0Οŝ?\x87;]'2s=\xfc\x06\xdc\xf9F\xdc\xe5\xf3\xb8\xcb\x17Ę;\xfaE\xc5&1Zb\x9b\x15[0\xe3V\x91\x1e/\xc1^\x16\xa3!\xfe\nR\xf6\xaaȲ\xd7\xc4X\xb6\xecu`\xc0\x1b\"m\xdf\x14c\xf8ܷ\x80\x96\xb7\xc5(kyG\x8c\xf1c\xdf\x05*\xde\x13\xa3\xaa\xe2}(b\xec\a@Ň\x10H\xc5Gx\x80\xb6\xe1\x01\xfa\x187\xfd\t\x84\xf9)n\xec3\xdc\xd8\xe7X\xdfv\xaco\a\xfc\x17\xf0_\xc2\u007f\x05\xff5\xfc7\xf0\xdf\xc2\u007f\a\xbf\x13\xd9܅9\xbe\xc7\x1c?\xc0\xff\b\xff\x93\xa0\"\xfd,\xa8\t\xbf \xaf\xbf\xe21\xf9\r\xfew\xf8?\x90\xd6?\x91ֿp\x95\xbfq\x95\u007f\xe0\xff\x85\xffOot\xb7\xde\xe3\x1e<\n{\xf5\x06\xf6\xe9\r\xec\xd7\x1b8\x80\x93\x0f\xe2\xe4Cb\x8c\x9ey\x18\x1bq\x04\x1bq\x14\x1bq\f\xd7;\x8e\xeb\x9d\xd0\xeb\x9d\xd4\xeb\x9d\xc2|\xff\xc3|\x1e\x03e\xc2@\x99\x807\u1f46\x8c\xf0\x19b\xfb\xe1\x93\xe0O3dL\xc0\x10'\x19>\b\x9fbȤ\x90!n*|\x18>b\xc8\xd44C\xea\xd3\xe13\xe03\r\x99\x91eH\"\n\x9f\r\x9fcȴ\xd3\r\x89\x9fa\xc8\xf43\ri8ː9m\fi\xce5d\xf4ن\xc4\xf2\f\x99\xd8\u0590\xb2v\x861i\xc69\x86\xe1&\xce5d\xeey\x86\xb4\x9c\x8f\x15\xe5cE\x17`%\xed\xb1\x92\x0e\xb8b\x01\xae\xd8\x11\xbe\x13|!|\x11|g\xf8.\xf0]1s7\xcc\xdcݐ\xaa\x1e\x86\xd4\xf4\xc4\xd5z\x19R\xd1\xdb0\xcaJ\xfa\x18F]m_\xcc\xd8ϐa\xfd\r)\x1d`\xa0P`M\x83\xb0\xb6\xc1\xb8\xda\x10Ü7h\xc1Pr\x98!C\x87c\xfd#\fY8\x12W\x1f\x85\xab\x8f6d\xec\x18\xcc6\u0590\xbaq\xb0\xf1\xb8\xdf\t\xb8߉\xb8\xea$\\u2V:\x056\x156͐\x92\xe9X\xd1\f\\g&\xeem\x16l6\xe6\x98c\xc8\u0e70yhχ-\x80-\x84-¼ņ\x94\xa3V\x97\x97\xc0Jaeȝ\x8d\xb9\x17#G\xe5\xb0\x18r\xef\xc0*\xb0\x0f\x95\xb8\xc3*X5\xac\xc60\xaa溆̪\x85\xd5\x19R]\x8f[\x8f\xc3\x1a`\t,\xa2\x11\x89\x1dф\x1c-1dd3V\xdc\x02[\n[\x06[\x0e[\x01[\t[\x85;Z\r\xbb\x10\x19\xb9\b\xbbv1Vu\t\xfc\xa5\xb0ː\xcb\xcbaW`UW\"3W\x19\xd2x5\xb2\xb3Ɛ\xa6kp\xf7\xd7b\xa5\xd7!\x8b\xd7\xc3n\xc0\xfe\xdd\b\xbbɐA7\xc3n\x81݊\xac߆;\xbf\x1d\x99\xbd\x03\x19\xbdӐQwA\x01w\xe3\x1a\xf7\x18Ry/v\xe3>d\xf5~\x8c]\v{\x00{\xd6\xf2 0\xf7!m=l\xe0\x11~\x04\x98\xf6(0\xec1\xc3X<\xf1q\xdcx\xfc\t\xa0\xe5IØ5\xeb)\xc3X\xb0\xe0i$\xea\x19س\x98\xf29\xf8u\x98~=nm\x03l#\xecy\xd8\vX\xf2\x8bX\xf2&C\xf27\x1b\xd2n\x8b!\xc5[\xd1~\t\xfee\xd8+h\xbf\x8a%\xbc\x06{ݐ\xfeo\x182\xf0M\xdc\xea[\x86\xcc|\x1b\xfe\x1d\xf8w1\xe6=C:\xbdoH\xd1\a\x86\xcc\xffА\x8e\x1f\x19\xb2h\x1b\xda\x1f#\xf6\x89!}?5\xa4\xf03\xcc\xf79\xc6n\xc7y;p\xde\x17\x86\x14|\x89\xf3\xbeB\xfbk\x1c\xff\x06)\xf9\x16\xe7~gȊ\x9dX\xcb.\xa4\xff{Cf\xff\x80\xf4\xfc\x88\xcd\xfd\t[\xf1\xb3!K~\xc1Z\xfe\xc19\xff\x1a2\xe0?\x8c\xdbM\x99\xee!\xf7\x92\xfb\xc8\xfd\xe4\x01\xf2 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\x9cd*'\x93Sȩ\xe44r:9\x83\x9cI\xce\"g\x93sȹ\xe4<r>\xb9\x80\\H.\"KM\xb1\xcaL\xb1mS\x9cŦ\xb8\xe5\xa6$b\xa6\x94:\xa6\x94U\x98\x12\xab4\xa5\xbaʔ\xfajS\x1ajLitMYR\xcb3\xeb\xc8z2N6\x98\x92\x9f0\xa5c#{M\xe4\x12\xb2\x99\\J.#\x97\x93+L\x19\xb4\x92\xadU\xe4j\xf2B\xf2\"\xf2RS\x86\\fJ\xbf\xcbM\x19q\x05\xecJS\xc6\\\xc5#W\x9b2i\r[ט2\xe3Z\xf4\xaeñ\xeb1\xfe\x06S\x86\xdeh\xe2cҔ\xe17\xe3\x9c[L\x99{+\xfcm&\xde\foǠ;L\x19w\xa7)\xe3\xef2e\xc2\xdd&>&Mc\\\xfc^\xccp\x9f)\x93\xef7e\xeaZ\xce\xfb\x80)\xd3\x1e4e\xfaC\x98\xffaӘ\x1c{\x04\xe3b\x8f\xa2\x15\u007f\f\x83\x1f\xc7LO\xe0ГH\xe1SH\xe1Ӱg\x90\xc6g\x91\xc2\xe7\x10[gJ\xc9zS\xca7 \x95\x1bq\xecy\x13\x9f\x93\xf0/\x9ax;܄\x81\x9bM\xa9\xdcbJ\xd5V\xe4\xf8%Sj^Fn_\xc1\x1e\xbcjJ\xedk\xc8\xf9\xeb\xa6\xc4߀\xbd\x89ܿ\x85I\xdf6\x8d\xda\xd8;\xa6Q\x19{\x17\xad\xf8{\x18\xfa>\xa6\xf9\x00\x87>D\xfb#\xf8m\xf0\x1fs\xf1\x9f\xe0\xea\x9f\xea\x95>\xc3\x12?\x87m\x87\xed\xd0\x19\xbe\xc0\xf4_\x9ar\xfeW\x1c\xf75\xf9\x8diLk\xf8\xd64\xe2\rߙ2k\xa7)M\xbbL\x99\xf2\xbd)u?\xe0H\xed\x8f8R\xfb\x13Z\xb1\x9fъ\xfdb\xca\xc8_MY\xfc\x9b\xe6\xe3w]\xd0\x1f\xa6\x8c\xfe\x13r\xf9\vi\xff\x1b\xf7\xfc\x8fi\f\x1b\xfd\xafi\x94\xc6\xfeCҝ\xddX\x88\xb3\a\xb7\xbb\x17\xb7\xb5\x0f\xf2\xdaoJ\xc5\x01^\xf9 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4x\x8d1\xb6\x00\xae\xe15\x86W\x98^cT\x85Wc>t[\xfc^\x19\x93\xe45\xe68\xa7yel\xc0\x8b7\x8ad/\xde#\x82^sz<\x96\xe25\xc6U\x840\"\xd5+3\xc2^sxK,\xe2\x95!i^\x19\x9a\ue559\x19^\x19\x95\xe9\x95\xe1Y^\x19\x11\xf5\x1asc\xd9^\x99\x9b\x83\xe1\xa7\xc3\xce\xf0ʸ3\xbd2\xfe,\xafLh㕉\xb9^\x99t\xb6W&\xe7yej[\xafLk\xe7\x95\xe9\xe7`\xdas\xbd2\xf2<\\'v\xbeט\x1e\xcf\xf7\x1a\xc3b\x17x\x91\xc3\xf6^\xef\xb4Xi\xac\x83W\xf2\v\xbc2\xa7#|'\\\xa7\x10+O\x14\x01Vg\xafX]\xbcR\xd2\xd5+\x8dݼR\xde\xdd+e=\xbcb\xf7\xf4╣\x97WZz{\xc5\xe9\x03\xeb\xeb\x95\xca~^\xa9\xea\xef\x95\xea\x01^\xa9\x19\xe8\x15w\x90Wj\a{\xa5~\x88W\xe2C\xbd\xd20\xcc+\x89\xe1^Y<\u008b}\x1a\xe9E\x11\x1f\xe5ž\x8c\xf6b#\xc7x\xbdq\xacd,V0\xce+\xcd\xe3\xe1'\xe0:\x13\xbd\x86\x93\x98\x04X\x93\x01{\n\xe0N\xf5\x1ae\x15ӼFy\xc5t\x8d\xcd@\xb7e&\x960\xcbk4;\xb3\xbdR1Nj\u05f5\xb9^\xbc\xa4\xcd\xf3\x9a\r\xf1\xd8|\\\xafb\x01F,\xc4\x02\x16yͲ\x96X1\x12\x85\xef@n\t\xee\xb6\x14\xd7)ӽ\xb2u\xbaň\x94#\x12ӈ\xa3\x91\n\x8c\xad\xc4\xd8*\xdd\xdej]A\rR\x19w1k\xbc\u058bG\xb0\u038bg\xa0\x1e)\x8e\xe3\xe6\x1a\x90\xc7\x04\xee\xa0\x11\xbe\t~\t\xae\xd9\fk\xc1,K1\xcb2\xf8\xe5\xf0+\xbcƤ\x86\x95^\xc3mX\xe5\x95)\xab\xbdRw\xa1\xd7ߡK\xe7Ν;\\\xe6UI]\xee\rh\xb7P#Wx\x83\x1d\xbah\x8b\xbd+y\xfc*\xf2j\xaf\xb4[\x03\xbb\xc6kL\u037f\xd6k\xd4\xe7_\a\xed\xe5_\x8f\xf4\xe4ߠ\xad\x1b\xb5u\x93\xb6n\xd6\xd6-^sn,\xffV\xaf\xd9\x12˿\rrʿ\x1d;\x99\u007f\an(\xffN\xdcP\xfe]ں[[\xf7h\xeb^mݧ\xad\xfb\xb5\xb5\x16\xb2\xcd\u007f\x00\x99\xcd\u007f\x10\xad\xf2\x87\xd0*\u007f\x18)\xc8\u007f\x04)\xc8\u007fT\x15\xf6\x98n\xee\xe3\x10W\xfe\x13\xd8\xd7\xfc'!\xb8\xfc\xa7\xb0\xd7\xf9OC\x87\xcf \x11\xcfz\x8d\x19\xf9\xcfy\x8dD\xfe:\xaf9.\x96\xbf\xdekV\xc6\xf27\xe0Yh\x88o\xc4~5ğ\xf7\x9a\xc3b\xf9/x\xcd\xd2X\xfe\x8blob{\xb3WFo\xf1Jl\xab\xea\xf7%\x95\xce\xcb<\xfa\n\x8f\xbe\xea\x95\xe2\xd7\xf4\x01y]\xb5\xf9\x86\xae\xf9M]\xf3[\xcc\xd3\xdb\xe4;\xba\xfewu\xfd\xef\xb1\xff>\xf9\x81\xce\xf7\xa1\xce\xf7\x11\xfb\xdbȏ\xc9O\xf0\x00|\n\xfb\f\x8f\xe4\xe7\xf0۽\xc6\x10{\x87\x17\xaf\xcc_\xa8@\xbeT\x81|\xe5\x95\xc1_þ\x81}\v\xfbNW\xb1SW\xb1\v\xcf\xea\xf7xJ~\xd0*\xf0\xa3\n\xf5'<\xb5?C\x8a\xbf\xc0\xff\n\xff\x1b\xe4\xf0;\xe4\xf0\a\xfc\x9f\xf0\u007f\xc1\xff\r\xff\x0fd\xf8/d\xf8\x1f\xb2\xb6\x1bY\xdb\x03\xbf\x17~\x1f\xfc~\xf8\x03\xba惺\xe6C\\\xe7a\xf2\bDw\x14\xa2;\xc6\xdeq\xf2\x04y\x92<Ez|J!\r\xd2$\xbd\xa4\x8f\xf4\x93I\xe4id\x80L&\x83d\n\x19\"S\xc90\x19!\xd3\xc8t2\x83\xcc$\xb3\xc8(\x99M搧\x93g\x90g\x92g\x91m\xc8\\\xf2l2\x8flK\xb6#\xcf!\xcf%\xcf#\xcf'\xf3\xc9\v\xc8\xf6d\a\xb2\x80\xecHv\"\v\xc9\"\xb23\xd9\xc5'C\xba\xfadh7\x9f\x8c\xea\xee\x93\xe1=|2\xa2\xa7O\xe6\xf6\x82\xef\r\xeb\xe33\xa6\x17\xf7\xf5a\xab\xfb\xf9dL\u007f\x9f\x8c\x1f\xe0\x83\xfe\a\"\x1c\x1f\xe4\x93q\x83}2z\x88\x0f\xfb>\xd4g\x8c\x8a\r\xf3a\xbf\x86\xfbd\xc2\b\x9f\xcc\x19铉\xa3|\xa8\xbf\xa3}2i\x8c\x0f\x1a.\x1e\xeb\x93\xc9\xe3|2v\xbcϘ\x1a\x9b\xe0\x93i\x13}2s\x92O\xa6O\xf6\xc9\xd4)>|P\x14O\xf5ɬi>cr\xf1t\\\xa7x\x06N\x9d铑\xb3\xb8\xd8\xd9\xe4\x1c\x9f\xf4\x9f\xeb\x93\xfcy>)\x9a\uf4f6\v|\xd2q\xa1O\x06-\xf2Ia1GX>\xb1J|RR\xea\xc3w\n\x9f\x94\xd9>\xb1\x17\xfb\xa4\xa5\x1c>\x06s|FCq\x85\x0fҭ\xf4\x89S\xe5÷\n\x1f\x9e\xe7\x1a\x84\xe3\xaeO*k}\x12\xab\xf3A\xc7\xf5>\xa3<\x16\xf7A\u007f\r>\xa9N\xf8P\xf0|R\xd3\xe4C)_\xe2\x13\xb7هG\xb2\xb8\xc5'\xb5K}R\xb1\xccg\xd4ǖ\xfb$\xbe\xc2'\x8d+}Ұ\xca'\xf5\xab}\xa8\xcd\xc5\x17\xfa\xa4\xe9\"\x9fQ[|1\xaeS|\tN\xbd\xd4'\x8b/\xf3\x19v\xd3\xe5\\\xf1\x15X\xfb\x95>\xe9t\x15{W\x93k\xc8k\xc8k\xc9\xebȵ\xe4\xb3>\x19\xfc\x1c\xeee\x1d\xeeu=&܀;و\xfe\xf3\xb0\x17\x10{\x11\xb6\t\xf1\xcd\x1c\xbd\xc5'\x89\xad\xc8\xd9\x1b>\xe9\xfb\x16#o\x93\xef\x90\xef\x92\xef\x91\xef\x93\x1f\x90\x1f\x92\x1f\x91\xdbȏ\xc9O\x91\xdbϐ\xdbϑ\xdb\xed\xc8\xd5\x0e\xdc\xf0\x17\xc8\uf5daůp\xe7_#S\xdf \x91\xdf¾Czw\"{\xbb`\xdf#{?\xc0~D\x96~\xf2I\xf1\xcfH\xdd/\xb0_5\xf3\xbf)~\xf7I\xdd\x1f\xc8۟\x9a\xe3\xbf0\xd5\u07fc\xe2?\xe4\xbf\xe4\u007f\xe4nr\x0f\xf4\xb3\xd7g\xb8\xcd\xfbp\xfb\xfbq\x83\a|\xd2\xee \x0f\x1d\"\x0f\x93Gȣ\xe41\xf28y\x82<I\x9e\"=~V\r\xd2 M\xd2K\xfaH?\x99D\x9eF\x06\xc8d2H\xa6\xf8\xa5c\x88\xadT2LF\xc842\x9d\xcc 3\xc9,2Jf\x939\xe4\xe9\xe4\x19\xe4\x99~\xe9w\x16[m\xc8\\\xf2l\xbf\f\xcac\xab\x9d_\xacs\xfc\x92\u007f\xae\xdfh\xca?\xdfo4\xe7_\xe0\x97\x92\xf6~\x19\xdc\xc1/\r\x05~\xbc\xa0v\xf4KE'\xbf\x8c.\xf4c\xb7\x8a\xfcR\xd6\xd9o\x94ź\xf8\xa5\xbe\xab_Z\xba\xf9%\xdeݏ\xe4\xf7\xf0˴\x9e~\x19\xde\xcb/\xd3{\xfben\x1f\xbf\x14\xf7\xf5˨~\xbcN\u007fr\x009\x90\x1cD\x0e\xf1\xcb\xe2\xa1~\xa9\x1b\xe6\x97\xca\xe1~\xa9\x1a\xe1\x97\xea\x91~\xa9\x19\xe5\x97\xd8h\xbf4\x8d\xf1ˊ\xb1~i\x1e\xe77\xac\x9a\xf1~#Q3\xc1o85\x13\xb1\xecI~IL\xf6\x8b3\xc5/\xb3\xa6\xe3\x16f\xc0fr\xd2Y\xe4lr\x0e9\x97\x9cG\xce'\x17\x90\v\xc9Ed\xb1_:[~\xe9R◮\xa5~\xe9V\xe6\x97\xee\xb6_z,\xf6K\xcfr\xbf\xf4\x8a\xf9\xa5\xb7\xe3\x97>\x15~9\xaf\xd2/\x85Uزj\xbft\xa8\xe1\xd9.Y\x875\xd4\xc3\xe2\xb0\x04\xac\xd1o\xe475\x01\x89%@s3\xf2\xd9\xd0\xe2\xc7\xc7yl)Ҽ\f)^\x8et\xad\xf0K\xedJM\xf5*\xbfQ\x12[\x8d\x91\xb1\v\x91\xf0\x8b\xfcFM\xf3\xc5Hv\xf3%\xe8]\xeaGY\xb9\xcco\x96\x96\xc6.G\xac\xec\n\xe4\xfaJ\xd8U~cx\xc3պ%k\xfcfYY\xec\x1a\xecе\x88_\a\xbb\xdeo\xd4\xd7\xdf\xe0\x97\xa97\xc2n\x82\xdd\f\xbb\x05v+\xec6\xec\xeb\xed\xf0w`\xe3\xee\x84\xdd\x05\xbb\x1bv\x0f\xec^\xac\xea>\xbf1j\xf4\xfd~\x19\xb9\x16\xf6\x00\xecA\xbf4>\x84\xfdz؏o)\x8f\xf8eʣ\xb0\xc7T\x15\x8fc\xf7\x9e\xf0˸'aOa\xd5\xe5O\xa3\xf1\x8c_ʟ\x85\x00\x9e\xf3\xcb\xc4u\xf0\xeba\x1b`\x1b\xfd2\xfey\xd8\v\xb0\x17a\x9bp|3l\vl+\xec%\xd8\xcb\xd8\xfeW\xfc\xf8px\xd5oĚ_C\xefu\xa4\xe0\r\xc8\xf2M\xec\xf6[~õ\xdfV\xbc\x03\r\xbc\v\xd5&\xdeS\xbc\x8fc\x1f`\x91\x1fB0\x1f\xf9e\xce6\xd8Lj}\x86\xfe\xe7\xaa\xed\xedض\x1dP\x92\xbd\x133\xed\xf2\xcb9\u007f\xfae\xe1\u007fܹ\xdd\xe4\x1eh`/4\xb0\x0f\x1a\xd8\x0f\r\x1c\x80\x06\x0eB\x03\x87\xa0\x81\xc3\xd0\xc0\x11h\xe0(4p̏ϩ\xe3\xc8\xf0\t$)v\xd2/\xe7\x9f\xf2\x1b\x05՞$\xa3\xa8H\x92\xa4\xc8H\x92\x8ef\x92\xb4\xf5\xc2|I\xd2ɏ~\x12\xec\xb4$\xe9\x17H\x92A\xc9I\xb2\"\x98$KS\x92dy(I:\xa4&\xf1qO\x92\xfc\xf4$)\xc9H\x92\xf2LXV\x92\x94Ea\xd9I\x12\xcbI\x92\xa6ӓ\xa4\xe5\x8c$\x19}f\x924\x9c\x05k\x93$\u0379IFs\xec\xec$\xa9\xccK\x92\xaa\xb6IR\xdd.Ij\xceI\x92\xf8\xb9\xb0\xf3\x92\xa4\xf8\xfc$\xa9͇]\x90$\xd3\xda'I]\x87$\xa9/H\xc2\x03\xdb\x113t\xe2u\v\xc9\"\xb2s\x12\xbe\xdb\xc0\xbaº%ɐ\xee\xb0\x1e\xb0\x9eIb\xf7\x82\xf5\x86\xf5I\x92\x11}\x93\xc4\xe9\a\xeb\x9f$\x89\x01\xb0\x81\xb0AI\xe2\x0e\xc1%\x87\xe2>F$\xc9\xec\x91I2eT\x92\f\x1e\r\x1b\x93$\xcb\xc6&I\xc18^e<9\x81\x9cHN\"'\x93Sȩ\xe44r:9\x83\x9cI\xce\"g\x93sȹ\xe4<r>\xb9\x80\\H.\"\x8bI\x8b,!K\xc92\xd2&\x17\x93\xe5d\x8ct\xc8\n\xb2\x92\xac\"\xab\xc9\x1a\xd2%k\xc9:\xb2\x9e\x8c\x93\rd\x82l$\x9b\xc8%d3\xd9B.%\x97\x91\xcb\xc9\x15\xe4Jr\x15\x94\xb0Z7\xefB\xec\xf2E\xd8ɋ!\x97K\x92d\xfc\xa5P\xc0eH\xfb\xe5I\xd2x\x05Tpe\x92,\xbe*\tE\xe1\xea$ԕ5\xd0\xc65\x10ԵI\xa8(\xd7A\x18\xd7CU7@M7B\x037AE7C \xb7$IŭI(2\xb7ᔆۓ\x8cX\xec\x8e$<\xdcw\xea\fwa\xf0\xddz\xe1{p\xf6\xbd8\xfb>\x9cy?\x82k\xb1\xdf\x0f$\xe1\xb5\xe7Ah\xeb!\x88\xf4a\b\xe7\x91$ò\x1e\x85:\x1eK2l\xfbqH\xe3\x89$\xc3u\x9f\x84v\x9eB\xa4\xf9i\b\xe5\x19D\xac\xe7xW\xeb\xc8\xf5\xe4\x06r#\xf9<\xf9\x02\xf9\"\xb9\x89\xdcLn!\xb7\x92/\x91/\x93\xaf\x90\xaf\x92\xaf\x91\xaf\x93o\x90o\x92o\x91o\x93\xef\x90\xef\x92\xef\x91\xef\x93\x1f\x90\x1f\x92\x1f\x91\xdbȏ\xc9O\xc8O\xc9\xcf\xc8\xcf\xc9\xed\xe4\x0e\xf2\v\xf2K\xf2+\xf2k\xf2\x1b\xf2[\xf2;r'\xb9\x8b\xfc\x9e\xfc\x81\xfc\x91\xfc\x89\xfc\x99\xfc\x85\xfc\x95\xfc\x8d\xfc\x9d\xfc\x83\xfc\x93\xfc\x8b\xfc\x9b\xfc\x87\xfc\x97\xfc\x8f\xdcM\xee!\xf7\x92\xfb\xc8\xfd\xe4\x01\xf2 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4\x04\xf8J\x14\x90\x89\x06\xcc\f\xc8h/#\xbe\x80X\xfe\x00\x84\x91\x14\x10紀\xe18\x81\x80$\x92\x03F\"\x11\f\xc8Ԕ\x80\x8c\x0f\x05\f{bj@\xec0,\x82\xb1NZ\xc0p'\xa6\a\xc4̀e\"\x92\xc8\nHe4\x00]f\a\xa4<'\x00\xe5\x9d\x1e\xc0'\xce\x19\x01)=3\x00\xf5\x9e\x15\x90\x8a6\x01\xa3\"\x96\x8bp\xf3\xd9\x01h9/\xa0\x9f\xb8m\x03\xf8\xd4l\x17\xd0\xcf\xc8sp\xa8\xe6܀4\x9c\x87ñ\xf3\x03R\x96\x8f\x83\xb1\v\x02R\xd3>`\xd6\xd4\xd4t\bHmA\x00\x1fs\x1d\x03R\xd2)\x80O\xe5\u0080T\x17\x05\xa4\xb9s@\xea\xbb\x04\xf0\xb1\xda5 U\xdd`\xdd\x03fUUU\x8f\x804\xf6\f\xe0\xf9\xe8\x05\xc4{\a$\xde' \xb1\xbe\xbc\xf1~d\xff\x80\xe4\x0f\x80\r\xd4\x14\fB\n\x06k\n\x86 \x05C5\x05Ð\x82\xe1\x01c\xea\xd4\x11\x9a\x83\x91\xb8\xffQ\xb0њ\x831\x9a\x83\xb1\xb8\xffq\xb0\U0005a0c9\x9cq\x1299`\x0e\x991a\nf\x9e\n\x9b\x16\x90\xe2\xe9\xf03xl&9\x8b\x9c\x1d\x90\xba9\x01\xb32\x16\x9b\x1b0\xcbc\xb1y\x01i\x99\x1f\xf0\x96!\x1d\vp?\xb1\x85\x01Y\xbc(`47\x17\xeb*\xac\x801~|\t\xb6\xa4T\x1be\x013\xaf(\xcf\x0ex\xf3\x8a\x8a\xf2\x16\a\xa4sy@\xba\xc4\x02\xd2\xd5\tH\xb7\x8a\x80t\xaf\fH\x8f\xaa\x80\xf4\xac\x0eH\xaf\x9a\x80\xf4v\x03ҧ6 \x85u\xbct=\x19'\x1b\xc8\x04\xd9H6\x91K\xc8f\xb2\x85\\J.#\x97\x93+ȕ\xe4*r5\x14v!\xec\"\xa8\xecbF.\x81\xca.\xd5\x14_\x86\x14_\xae)\xbe\x02)\xbeRS|\x15R|\xb5\xde\xdc\x1a\x8e\xbc\x86\xbc\x16Y\xbeN\xb3|=\xbb7\x907\"\xd17i\xa2o\x86\xd8nQ\xb1\xdd\n\xb1ݦb\xbb]\xc5v\a\xc4v\xa7\x8a\xed.\x88\xedn\x15\xdb=*\xb6{Ul\xf7Ql\xf7\xab\xd8\xd6Rl\x0f\xa8\xd8\x1e\x84\xd8\x1eR\xb1=\f\xb1=\xa2b{\x14b{\x8cW{\x1cb{B\xc5\xf6$\xc4\xf6\x94\x8a\xedi\x88\xed\x19\x88\xedY\x88\xed9\x8eY\a\xa5\xadgk\x03\xb9\x91|^\x15\xf7\x82*\xeeE(n\x13\x14\xb7\x99\xf1-\xe4V\xe8\xe0%\xb6^ք\xbc\x82\x84\xbc\xaa\ty\r\ty]\x13\xf2\x06\x12\xf2\xa6&\xe4-\x8ez\x9b|\a\tyW\x13\xf2\x1e\xbb\xef\x93\x1f !\x1fjB\xb6\xb1\xfb1\xf9\t\xf9)\xf9\x19\xf99\xb9\x9d\xdcA~A~\x19\x90\x82\xaf\xd8\xfa\x9a\xfc\x86\xfc\x96\xfcN\x1f\xa6\x9d\xaa\xc0]\xec\u007f\xaf\x1a\xfcAW\xf5\xa3J\xef'h\xf0gm\xfc£\xbf\x92\xbfA\x82\xbfC\x82\u007f@\x82\u007fB\x82\u007fA\x82\u007fC\x82\xff@\x82\xffB\x82\xffA\x82\xbb!\xc1=\x986\u007f/P\xbc\x0f\x13\xc6\xf7+\x0e\x04\x8c.E\a\x03FעC\x01\xa3[\xd1\xe1\x80ѽ\xe8H )\xafK^\xa7\xbc.EG\x03fQ\x97\x9e\xc7y\x95\x13\xe4I\xf2\x14\xe9Ifi#\x8dd\x147\xb6\xbc\xa4/\x19\xe5-Y\xcb[2\xca[\xb2\x96\xb7d\x94\xb7d-o\x1c\x90B\x86\xc8T2\x9c\x8cO\xc7H\xb2\x969\xf6\xd3Ɍd|Tf&k\xa9KF\xa9K\xd6R\x97\x8cR\x97\xac\xa5.YK]2J]\xb2\x96\xbad\x94\xbad-u\xc9Z꒵\xd4%\xb3\xd4%k\xa9Kf\xa9K\xd6R\x97\x8cR\x97\xac\xa5.\x19\xa5.YK]2J\x1d/\xd7!\x19\xa5.YK]2J]\xb2QRR\x98\x8cR\x97\x8cR\x97\x8cR\xc71]\x93Q뒍\xaa\xaa\xee\xec\xf6HF\xb1K\xd6b\xc7n\xefdT\xbbdT;\xf6\xfa\x91\xfd\x93Q\xed\xd8\x1a\xa89\x19\x84\x9c\f֜\fAN\x86jN\x86\xf1\xe0pr\x049\x92\x1c\xa59\x19\xad9\x19\xc3\xfeXr\x9c\xe6d\xbc\xe6d\"\xfb\x93\xc8\xc9\xe4\x14r*9\x8d\x9cN\xce g\x92\xb3\xc8\xd9\xe4\x9cd\x16\xc1d\x16\xc1d\x14\xc1d\bp\x01\x0f-LF\rd\xab\x98\xb4\xc8\x12\xb2\x94,#mrq2\na2\na2\na2\na2\na2\na2\na2\na2\na2\n!\x94R\x97,\xa3\x1b\x92\xfd\xa3\nG\x14N*L\xf0\xf4F\xb2\x89\\B6\x93-\xe4Rr\x19\xb9\x9c\\A\xae$W\x91\xab1\U00045c0b0\xf9Ō\\\x02\x11^\xaa\t\xbf\f\t\xbf\\\x13~\x05\x12~\xa5&\xfc\xaadT?\x0eZ\x83\x14O\xbc\x86\xcdk\x93Q\xfd4\xd9\xd7#\xc1\x13o`\xec\xc6d\x14?M\xf5͐\xdf-*\xbf[!\xbf\xdbT~\xb7\xab\xfc\xee\x80\xfc\xeeT\xf9\xdd\x05\xf9ݭ\xf2\xbbG\xe5w\xaf\xca\xef>\xca\xef~\x95\xdfZ\xca\xef\x01\x95߃\x90\xdfC*\xbf\x87!\xbfGT~\x8fB~\x8f\xf1j\x8fC~O\xa8\xfc\x9e\x84\xfc\x9eJ\xd6\xe2\a\xf9=\x93l4[\xcfB\u007f\xcfq\xd0:\xe8o\xbd\xeao\x03\xbb\x1b\xa1\xbf\xe7U\u007f/$k\xe9\x83\xfc6A~\x9byl\v\xb9\x15\xf2{\t\xf6\xb2\xe6\xe2\x15\xe4\xe2U\xcd\xc5k\xc8\xc5뚋7\x90\x8b7\x93\xb5\xf0i*\xde\xe6)\xef \x15\xefj*\xde\xd3T\xbc\xcf\xd8\aHŇ\x9a\x8am\xec~L~\x92\xac\x1f\xb8\x9f\xb2\xfd\x19\xf99\xb9\x9d\xdcA~A~I~E~M~C~K~G\xee$w\x91ߓ?\xe8\xc2~d\xf3'\xf2g\xf2\x17\xf2W\xf27(\xefw(\xef\x0f(\xefO(\xef/(\xefo(\xef\x1f(\xef_(\xef?(o7\x94\xb7\x87\xa3\xf7\x92\xfb\xc8\xfd\xe4\x01\xf2 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4\x04Y\t\x83xɃ\x99A\xbc\xe41\xe2\v\xa2\n\x06\xb5\n\x06Q\x05\x83Z\x05\x83\xa8\x82A\xad\x82A\xbc\xe4\x05\xf1\x92ǁ\xa9d8\x88\xf7\xbc\xa0\x16@v\xd3Ɍ ^\xf5\x82Z\xff\x82\xa8\u007fA\xad\u007fAԿ\xa0ֿ\xa0ֿ \xea_P\xeb_\x10\xf5/\xa8\xf5/\xa8\xf5/\xa8\xf5/\xc8\xfa\x17\xd4\xfa\x17d\xfd\vj\xfd\v\xa2\xfe\x05\xb5\xfe\x05Q\xff\x82Z\xff\x82\xa8\u007f\xbcZ\x87 \xea_P\xeb_\x10\xf5/\xa8\xafzAԿ \xea_\x10\xf5\x8fc\xba\x06Q\xff\x82Z\xff\xd8\xed\x19\xd4\xda\x17\xd4\x17\xbd J_\x10\xa5\x8f\xf1~d\xff J\x1fl\xa0\xa6a\x10\xd20X\xd30\x04i\x18\xaai\x18\x864\f\xe7\xc0\x11\xe4Hr\x14\x121Z\x131\x86ݱ\xe48$b\xbc&b\"\xbb\x93\xc8\xc9\xe4\x14r*9\x8d\x9cN\xce g\x06\xa5`\x16l6{sȹ\xe4<r~PK^P\xdf\xfa\xd8_\x14\xd4\xf7\xbe\xa0\xbe\xf7\x05\xf5\xbd\x8f\xc1R\xb2\x8c\xb4\xc9\xc5A\x14\xbc \n^\x10\x05/\x88\x82\x17D\xc1\v\xa2\xe0\x05Q\xf0\x82(xA\x14\xbc\xa0\xf4\xa9\xe3\xe8z2N6\x90\t\xb2\x91l\"\x97\x90\xcdd\v\xb9\x94\\F.'W\x90+\xc9U\xe4j\xf2B\b\xef\"\b\xefb\xf6.\x81\xf0.Ռ_\x86\x8c_\xae\x19\xbf\x02\x19\xbfR3~\x15\a\\M\xae!\xafA\xb6\xaf\r\xe2\x83\xe6:M\xf9\xf5\x8c݀d\xdf\x18\xc4\xc7\xccM\x9a\xf1\x9b!\xbd[\x18\xbf\x95\xbc\x8d\xbc]\xe5w\a\xe4w'\xbbwA\u007fw\xb3u\x8f\n\xf0^\x15\xe0}\xec\xdfO\xae%\x1fP\x05>\b\x05>\xc4\xee\xc3\xe4#\xe4\xa3P\xe1cA\xfd\xc2\xf18T\xf8\x04cO\x92O\x91OC\x89\xcf@\x89\xcfB\x89\xcf鞭\x83\x10\u05eb\x107\x04\xf5[\xc7\xc6 \n!G\xbe\xa0j|\x11j\xdc\x045nfh\v\xb9\x95|\x89|Y\xf3\xf3\n\xf2\xf3\xaa\xe6\xe75\xe4\xe7u\xcd\xcf\x1b<\xf8&\xf9\x16\xf96\xf2\xf3\x8e\xe6\xe7]\xcd\xcf{\x8c\xbd\x8f\xfc|\xa0\xf9\xf9P\U000f3371\x8f\xc9O\xc8O\xc9\xcf\xc8\xcf\xc9\xed\xe4\x0e\xf2\v\xf2Kh\xf2+\xb6\xbe&\xbf!\xbf%\xbf#w\x92\xbb\xc8\xef\xc9\x1f\xc8\x1fɟȟ\xc9_\xc8_\xc9\xdf \xcc\xdf!\xcc? \xcc?!̿ ̿!\xcc\u007f \xcc\u007f!\xcc\xff \xcc\xdd\x10枠\xb7\xa0K炽A\x1f\\\xe7\x82}A\xbf\xfa\xce\x05\xfb9\xcb\x01\xf2 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4\xa4\xb0*\xa6\xa0*\xc2\xcc\x14TEF|)\xa8\x8a)Z\x15SP\x15S\xb4*\xa6\xa0*\xa6hULAULAU\xe4\xc0\xd4\x14|\xf7Mѷ\xc2\x14-\x8a\x8c\xa5\xa7\xe0\xdbo\x8a\xbe\x13\xa6hMLAMLњ\x98\x82\x9a\x98\xa251Ekb\njb\x8a\xd6\xc4\x14\xd4\xc4\x14\xad\x89)Z\x13S\xb4&\xa6\xb0&\xa6hMLaMLњ\x98\x82\x9a\x98\xa251\x0551Ekb\nj\"/\xd9!\x0551Ekb\njb\x8a\xd6\xc4\x14\xd4\xc4\x14\xd4\xc4\x14\xd4\xc4\x14\xfd\xfa\x9b\x82\x92\x98\xa2%\x91g\xf4H\xc1+a\x8a\x96\xc5\x14-\x8b)(\x8b)(\x8b<֏\xecO\x0e \aj.\x06!\x17\x835\x17C\x90\x8b\xa1\x9a\x8ba\xc8\xc5\xf0\x14\xfd\x0e\xccQ#\x91\x8cQ\x9a\x8cњ\x8c1\x8c\x8dE2\xc6i2\xc6k2&26\x89\x9cLN!\xa7\x92\xd3\xc8\xe9\xe4\x8c\x14)\x98\t\x9b\xc5\xdelr\x0e9\x97\x9cG\xce'\x17\x90\v\xc9Ed\xb1.\xcaJ\xd1\xd2\xc8~)YF\xda\xe4\xe2\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\x94\xc6\x14\xbc\vrt\x1dYO\xc6\xc9\x062A6\x92M\xe4\x12\xb2\x99l!\x97\x92\xcb\xc8\xe5\xe4\nr%\xb9\x8a\\M^\b\r^\x04\r^\xcc\xde%\xd0ग़\xf7ː\xf7\xcb5\xefW \xefWjޯBޯ\x86\x06\xd7p\xe05H\xfb\xb5\x9a\xf6\xeb4\xed\xd73v\x03\xd2~\xa3\xa6\xfd&M\xfb\xcd\xd0\xe0-\xaa\xc1[\xa1\xc1\xdbT\x83\xb7\xab\x06\xef\x80\x06\xefT\r\xde\x05\rޭ\x1a\xbcG5x\xafj\xf0>j\xf0~\xd5\xe0Zj\xf0\x01\xd5\xe0\x83\xd0\xe0C\xaa\xc1\x87\xa1\xc1GT\x83\x8fB\x83\x8f\xf1\x92\x8fC\x83O\xa8\x06\x9f\x84\x06\x9fR\r>\r\r>\x03\r>\v\r>\xa7\x1a\\\a\r\xaeW\rn\xe0\x19\x1b\xa1\xc1\xe7U\x83/\xa8\x06_\x84\x067A\x83\x9byl\v\xb9\x95|\x89|Ys\xf1\nr\xf1\xaa\xe6\xe25\xe4\xe2u\xcd\xc5\x1b\xc8ś\xba\xddoq\xd4\xdbH\xc6;\x9a\x8cw5\x19\xef1\xf6>\x92\xf1\x81&\xe3CM\xc66\xc6>&?!?%?#?'\xb7\x93;\xa0\xbf/`_\xb2\xf7\x15\xf95\xf9\r\xf9-\xf9\x1d\xb9\x93ܕ\xa2U\xfe{\xb6\u007f\xd0E\xfd\xa8\x1a\xfc\x89\xfd\x9f\xc9_\xc8_\xc9ߠ\xc1ߡ\xc1?\xa0\xc1?\xa1\xc1\xbf\xa0\xc1\xbf\xa1\xc1\u007f\xa0\xc1\u007f\xa1\xc1\xff\xa0\xc1\xdd\xd0\xe0\x1e\x8e\xdeK\xee#\xf7\x93\aȃ\xe4!\xf20y\x84<J\x1e#\x8f\x93'ȓ\xe4)\xd2\x13b\xfd#\x8d\x10*`\b\x15\x90=_\b\x150\xa4\x150\x84\n\x18\xd2\n\x18B\x05\fi\x05\f\xa1\x02\x86P\x01905\x84\n\x18\xd2\n\x18\xd2\n\xc8Xz\b\x150\xa4\x150\xa4\x150\x84\n\x18\xd2\n\x18B\x05\fi\x05\fi\x05\f\xa1\x02\x86\xb4\x02\x86P\x01CZ\x01CZ\x01CZ\x01C\xac\x80!\xad\x80!V\xc0\x90V\xc0\x10*`H+`\b\x150\xa4\x150\x84\n\xc8Kv\b\xa1\x02\x86\xb4\x02\x86P\x01CZ\x01C\xa8\x80!T\xc0\x10*`H+`\b\x150\xa4\x150\xc4_\x00C\xa8\x80!\xad\x80!\xad\x80!T\xc0\x10* g\xebG\xf6'\a\x90\x035\x17\x83\x90\x8b\xc1\x9a\x8b!\xc8\xc5P\xcd\xc50\xe4b8\a\x8c G\"\x1b\xa34\x1b\xa35\x1bc\x91\x87q\x9a\x87\U0005a1c9\x1c1\x89\x9cLN!\xa7\x92\xd3\xc8\xe9\xe4\fr&9+\x84\xd7B\xb6\xe6\x90s\xc9y\xe4|r\x01\xb9\x90\\D\x16\x87\xb4\xfc\x85\xb4\xfc\xb1_J\x96\x916\xb98\x84\xf2\x17B\xf9\v\xa1\xfc\x85P\xfeB(\u007f!\x94\xbf\x10\xca_\b\xe5/\x84\xf2\x17B\xf9\xe3\xe8:\xb2\x9e\x8c\x93\rd\x82l$\x9b\xc8%d3\xd9B.%\x97\x91\xcb\xc9\x15\xe4Jr\x15\xb9\x9a\xbc\x10\x02\xbc\b\x02\xbc\x98\xbdK \xc0K5\xe9\x97\x01\xf6\xe5!Ӳ\xec+\x90\xff+5\xffW!\xffWk\xfe\xd7 \xff\xd7\xe8\xdd^\vA^\xa7w|=v\xe0\x06݁\x1bu\an\xc2\x0eܬ;p\x8b\xee\xc0\xad\x9c\xf96\xf2v\xf2\x0eh\xf3N\xd5\xe6]\xd0\xe6ݪ\xcd{T\x9b\xf7\x86\xf0\x8eW~\x1f\x14z\xbf*t-\x14\xfa\x80*\xf4AU\xe8C!\xb3\xa2\xa6\xf9a\fi\xaexD\xd5\xfa(\xd5\xfa\x98\xaa\xf5q\xaa\xf5\tU\xeb\x93!oMMY\xd9S\x10\xed\xd3*\xdag \xdagU\xb4\xcfA\xb4\xebx\xf5\xf5\x18W\xb6\x01\xcaݨ\xca}\x1e\xca}A\x95\xfb\"\x94\xbb)dT\x97l\x86|\xb7@\xbe[9\xfa%\xe8\xf7e\xb6^!_\x85\x80_S\x01\xbf\xae\x02~\x03\x02~\x13\x02~K\x15\xfevH\x16\xbf\xc3A\xef\x92\xef\x91\x1f\x90\x1f\x92\x1f\x91\xdbȏ5͟h\x9a?e\x9a?C\x9a?\xd74oG\x9awp\xc8\x17\x9a\xec/\xd9\xfc\n)\xff\x1aI\xfeF\x93\xfc\xad&\xf9;$y\xa7&y\x97&\xf9{\xec\xc4\x0f\x1c\xf9#\xf9\x13\xf93\xf9\v\xf9+\xf9\x1b\xf9;\xf9\a\xf9'\xf9\x17\xf97\xf9\x0f\xf9/\xf9\x1f\xb9\x9b\xdcC\xee%\xf7\xe9\xf6\xef\u05ed?\x102\xf3\n\xf3\x0e2z\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4\xa4\xb2\x1e\xa6J\xa5\x91\nQ\x98\n\xaf§\xf0+\x92R\xa1\x8f\xd3R\xf5?\xeb\aR\xa1\x8ddEP\x91\xa2\b\xa5Jsj\xaa\x94\x85S\xa5!\x92\x8amOS\xa4+2R\xa5&\x13\x87\xb2p(\xaa\x81lE\x8e\xe2t\x1c:#UJ\xceL\x95ڳR\xa1\x856\xa9\xb28W\x1bg\xa3\x91\xa7\x8d\xb6\xa9R\xdd\x0e\x93\x9f\x93*\xf5\xe7\xa6\xca\xd4\xf3R\xa5\xea\xfcT\x19\x9f\x9f*M\x17\xa4J\xbc=\xac\x03\xac Ub\x1dq\xacS\xaa\x14\x17\xa2]\x94*+:\xa7\x8a\xd5\x05\xd65\x15\x1b\xdd\r\xa8\xee\x9e*N\x8fTlq\xcfT#a\xf7J5\x13\t\xbbw\xaa$\xfa\xa0\x9b\xe8\x9b*\xf9\xfd\x98\x89\xfe\xe4\x00r 9(\xd5\x1c\x1a+\x1c\x9c*\xf6\x10\xccc\x0fM\x15w\x18\x1a\xcep\xc5\b\xc0\x1d\x99*\x05\x13Re¤T3\xafC\xde\xe4T\xe9<%U\xbaLM\x95\xae\xd3R\xa5\xdb\xf4T\xe9>#Uz\xccL\x95\x9e\xb3R\xa5\xd7\xecT\xe9='U\xfa\xccM\xe5\u007f\xab\x98\x97\xea\x83+ʛϋ- \x17\x92\x8b\xc8b\xd2\"K\xc8R\xb2\x8c\xb4\xc9\xc5d9\x19#\x1d\xb2\x82\xac$\xab\xc8j\xb2\x86t\xc9Z\xb2\x8e\xac'\xe3d\x03\x99 \x1b\xc9&r\t\xd9L\xb6\x90K\xc9e\xe4rr\x05\xb9\x92\\E\xae\x86\xc0.T1]\xc4\xee\xc5ڼ\x84\xcdK\xc9\xcbTc\x97\xab\x9c\xae`\xffJ\xec\xebUl]M\xae\xc1\xf1\xe6kؼ\x96\xbc\x8e\xbc\x9e\xbc\x81\xbc\x91\xbc\tr\xbb\x19\"\xb8EEv\xab\xe26\xc6o\x87\xde\xee\x80\xde\xee\x84\xde\xeeRu\xdd\r\x99ݣ\x8d{Ѹ\x8fc\xee\x87\xe0\xd6Bp\x0f@p\x0f2\xf2\x10d\xf50[\x8f@t\x8f\xb2\xf5\x18\xf98\x16\xf8\x04\xae\xf3${OAz\xcf@v\xcfBr\xebTr\xebUr\x1b \xb9\x8d*\xb9\xe71\xe9\v\xa9Fs\xf3\x8b\x10\xdc&\x15\xdcf\x9e\xb6\x05ZڊK\xbc\xa4w\xf72C\xaf\x90\xafBm\xaf\xa5\x1a\xb6\xf3:F\xbc\x81\xb9\x9a\xdfT\xb5\xbdŃoCn\xef\xb0\xf5\x11D\xb7\x8d\xad\x8f\xc9O \xbdO!\xbd\xcf \xbd\xcf!\xbd\xed\x90\xde\x0eH\xef\vH\xefKH\xef+H\xefkH\xef\x1b\x8e\xfe\x96\xfc.Ո\xd5\xec\x04\xaaw\xb1\xff=\xf9\x03\xf9#\xf9\x13\xf93\xf9\v\xf9+\xf9\x1b\xf9;\xf9\a\xf9'\xf9\x17\xf97\xf9\x0f\xf9/\xf9\x1f\xb9\x9b\xdcC\xee%\xf7\x91\xfb\xc9\x03\xe4A\xf2\x10y\x98<B\x1e%\x8f\x91\xc7\xc9\x13\xe4I\xf2\x14\xe9\t\xebo\x9f\xa7\x85\xf9p\x05\xc2\xfaD\x06\xc3\xd2)%\xac\xff}0D\xa6\xb6\x1e\f\xc3u*ʋ\xc0\x15\x14\xe5\xa5\xc1\xcd.\xcaK\x0f\xfb\xf3\x8af\xa3\x91\x11\xc6s\t\x9f\x196:\xe6入s۰ti\x17\x96\xae焥۹a\xe9~^Xz\x9c\x1f\x96\x9e\xf9a\xe9uAXz\xb7\x0fK\x9f\x0ea\xa3\xb0GA\xd8\xecRأc\xd8\xecZأS\xd8\xecVأ0lv/\xecQ\x146{\x14\xf6\xe8\x1c6{\x16\xf6\xe8\x126{\x15\xf6\xe8\x1a6{\x17\xf6\xe8\x166;\x15\xf6\xe8\x1e\x96\x82\x1ea\xe9\xd03,\v{\x85eQ\x9f\xb0\xac\xe8\x1b\xe6\xabYX\x16\xf4\x0f\x1b\xf3\xe6\r\b\x1b\v\x16\f\x0eK\xe5\x900\x1e\x9f\xa1a)\x1f\x16\xc6\xe7\xf7\xf00\x9e\x9d\x11a)\x1d\x19\xc6\xf33*,\x15\xa3y\xde\x18ědž\xf1q=.\xac\x1f\xd7\xe3\xc3\xf8\xb8\x9e\x10֏\xeb\x898T3),\r\x93q86%,eSq06-,5\xd3\xc3R;#\x8c\xe7bfXJf\x85\xf1\xe1<;,\xd5s0.>7\xac\u007f\x95?\x0f#[\xe6\x87\xf5\xaf\xf1\x17\x84\xa5ia\xd8h\x89-\nKKqX\xf2\xad\xb04\x97\x84\xa5\xbe4,Uea|P\xdba3\x1e\x8f-\x0eK\xbc<,\xb1XX,'lV\xc6\xe3\x15\x18T\xc9UV\x91\xd5d\r钵d]\x18\x0fS}X\x9cx\x18\xcfQCX\x12\x890\x1e\x9fưLm\n\xe3SpIX\xc67\x87\xf1I\xd8\x12\x16{i\x18\x9f\xcf\xcb\xc2\xe2.\x0f\xe3\xa3yEX&\xac\f\xcb\xe8U8{\xb5\x9e}5g\\C^C^K^\x87\x8c^\xaf\x19\xbd\x01\x19\xbdQ3z\x93f\xf4fd\xf4\x16\xcd\xe8\xad\xc8\xe8m\x1cy\xbbf\xf4\x0e\xcd\xe8\x9d\xcc\xe8]\x9aѻ\x99\xd1{4\xa3\xf7\"\xa3\xf7iF\xefGF\xd7jF\x1f@F\x1fDF\x1fҌ>\x8c\x8c>\xa2\x19}\x14\x19}L3\xfa83\xfa\x84f\xf4If\xf4)d\xf4i\xcd\xe83\xc8\xe8\xb3\xc8\xe8s\xc8\xe8:$k=2\xbaA3\xba\x11\x88?\x8f\x84\xbe\x80\x84\xbe\x88\x84nbB7\xe3\xc4-\x18\xbb\x15c_\xe2b_\x0e\xcb\xecW ⾳\xfb潪b\x9eT\x94\xf7\x9az\xb7(\xefu\xf8\xf9\xee\xfc\xbc7\xe0/\x98\xd4>\xef#\x9e\xb1\x8d\xfc\x84\xfc\x94\xfc\x8c\xfc\x9c\xdcN\xee \xbf \xbf$\xbf\"\xbf&\xbf!\xbf%\xbf#w\x92\xbb\xc8\xef\xc9\x1f\xc8\x1fɟȟ\xc9_\xc8_\xc9\xdf\xc8\xdf\xc9?\xc8?ɿȿ\xc9\u007f\xc8\u007f\xc9\xff\xc8\xdd\xe4\x1er/\xb9\x8f\xdcO\x1e \x0f\x92\x87\xc8\xc3\xe4\x11\xf2(y\x8c<N\x9e O\x92\xa7HOD*%\x02\xa1\x18\x11)7#\x10\x8a7\x02\xa1\xf8\"R\xea\x8f@(I\x11\xa98-\x82\x97\xe6\x00\xc2\xcd\xc9\x11\xbcQ7\a#PKJD\xd5\x12\x8a@-\xa9\x11UK\x18\x03j\"z(-\xa2/K\x11)\xcb\xc0\xd1XfDj\xb2\"R\x1b\x8d@.\xd9\x11)ɉ@.\xa7G\xa4\xfa\x8c\x884\x9f\x19\x91\xfa\xb3\"R\xd5&\"M\xb9\x11\x89\x9f\x1d\x91X^\x04/\xbfm#b\xb5\x8b\xf0\x0f\xea#\xe2\x9c\x1b\x81\xd8ϋH\xe2\xfc\b\x1e\x95\xfc\x88\xd8\x17\xf0X\xfb\x88\xb8\x1d\"x_-`\xb7#\x9aV'\x8c/\xd4\xf1E\x18\xdfY\xc7w\xc1\xf8\xae8\xe4t\xe3\xa8\xeed\x0f\xb2gD&\xf6\x8aH~\xef\x88\xf4\xed\xcbH?\xb2?9\x80\x1cH\x0e\"\aG\xa4\xf3\x90\x88t\x19\x1a\x91\xae\xc3\"\xd2mxD\xba\x8f\x88H\x8f\x91\x11\xe99*\"\xbdFG\xa4\xf7\x98\x88\xf4\x19\x1bѪ<.ª<\x1e\xa9\xe90!b\xd4w\x98\x88[\xeb0)b\xd8\x1d&G \xfc)@|jD\xa6N\x8b\xe0\xc1\x9f\x1e\x91\xf13\"x\xf0g\"2K#\xb3\x11\x99\xa3\x91\xb9\xbc\xf8<r>\xb9\x80\\H.\"\x8bI\x8b,!K\xc92\xd2&\x17\x93\xe5d\x8ct\xc8\n\xb2\x92\xac\"\xab\xc9\x1a\xd2%k\xc9:\xb2\x9e\x8c\x93\rd\x82l$\x9b\xc8%d3\xd9B.%\x97\x91\xcb\xc9\x15\xe4Jr\x15\xb9\x9a\xbc\x90\xbc\x88\xbc\x98\xbc\x84\xbc\x94\xbc\x8c\xbc\x9c\xbc\x82\xbc\x92\xbc\x8a\xbc\x9a\\C^C^K^G^O\xde@\xdeH\xdeD\xdeL\xdeB\xdeJ\xdeF\xdeN\xdeA\xdeI\xdeE\xdeM\xdeC\xdeK\xde\x17\x91!\xf7Gd\xe8ڈ\x8cz \"\xc3\x1f\x8cȈ\x87\"2\xf3\xe1\x88\xcc}$bL/~4\"c\x1e\x8bȸDZ\xabODd\u0093\xd0\xdeS\x11\x99\xf4tD&?\x131\xe6ƞž?\x17\x91i\xeb\"2}}Dfl\x88\x18\x93\x8b7F\x8cq\xc5\xcfG\x8cQ\xf9/Ddʋ\x11cZlSD\xff\x99\xc6\xe6\x881\xacx\v\xce\xcb\xdf\x1a\x91a/\xa1\x17{9\x82\xfa\x18\x91\xb1\xafFd\xf4k\xb8\xfc\xeb\x11\x99\xf3FDf\xbd\x191f\xc7ފ\x18\x93F\xbcͥ\xbeC\xbeK\xbeG\xbeO~@~H~Dn#?&?\xc1#\xf9)\x1e\xe0\xcfP*>\xc7\xe3\xbd\x1d\x8fՎ\x884~\x11\x91\x96/\xf1\xcc\x17\u007f\x85'\xefk\x14\x94o\xf0@\u007f\x8b\a\xfc;<\xfa;\xf1\x84\xee\xc2\xe3\xff}\x04\x9f\x00?\xe0i\xff\x11O\xf9O\x11i\xf8\x19O\xe7/\xa8\tſ\xa2\xfc\x14\xff\x86ғ\xff{D\xea\xfe\xd0\xe7\xe2ψ\xfe\x93\x8d\xbfP\x80\x8a\xff\xc6y\xf9\xff\xa0\x1c\xfd\xab\xe5迈,ٍ\x92\xb4\aeb/.\xbf\x0f%d?Jǁ\x88\xb1$v0b\xb8\xf6\xa1\x88,>\xcc\xe5\x1e!\x8f\x92\xc7\xc8㭏\xe3\tvN\x92\xa7HO\x9a\x94K\x9aQ^n\xa4I\x8d\x99&e\xde4\xd45_\x9a\xd4\xfbӤ:)MJNK3JJ\x02i\x12ON\xc3#\x9b\x92&\x15\xa14\xa3\xa2\"5MJ\xc3iR\x19I\x93\x86\xb44\xa9MO\x93XF\x1a\nh&P\x93\x05\x94E\x81\x92l\xccW\x9e\x93f\xd4ל\x0eԟ\x01\xc4\xce\x04&\x9e\x95fT\x97\xb4\x01&\xe6\xe2\n\xe5g\x035m\x81x\xbb4\xb3$^~\x8e\xb2\xe1\\e\xc9y\xca\xf8\xf9ʊ|\f\xa9\xb8\x00(m\x0f4t\x00j\v\x80\x89\x1dq\xb8db',\xb2\xbc\x10\xa8)\x02\xca:\x03\xf5]\x80\xea\xae@I\xb743^R\xde\x1d\x8c\xc7{\xe0\x96z\"X\xd1\v(\xed\rT\xf6\x01\x1a\xfa\x02\xb5\xfd\x80\xd8\xe04\x99;\x04\xf9\x19\x8a\xb4\fC6\x86#\x1b#p\xd6H\xc4G#\x0fc\x90\x82\xb1\xb8\xfdq\xb8\xfd\xf1i2q\x02bSӌ\xd2\xcai@lf\x9aQ[2\v\x988;͈\xc5\xe6\xa4ɔ\xb9i\xace\xe4|r\x01\xb9\x90\xb4\xd2\xc4*I×\xd2\xd24\xa3\xd9*K3\x9b-\xdbN3lwq\x9a\xd8\xe5\xe8\xdan\fGl'M܊4\xa3ɪL3\x9b,\xbb*\r{_\x8d\x03nM\x9a$\\\xc4l\xb7\x16\x87\xed:\xc0\xa9ǁD\x1c\xb3$\x1a\xd0r\x12i\xe24\xa6\x99V'\xb7I\x99X\x92\xe6mF\xa79\xcd\a\xd7춤ym\xb7\x93\xbb\x94.\xb1,\xcd\ag'\x96㨆W\xb4\xfa\xc4\xca4/\xc2\xee\xaa4\x13n\xb5v\x9a\xed\v\xb5\xe3^\xa4L\\\x8cq\x88Y\x97\xa4\xf9\xe9\xedK[\x1b\xb6{\x19.\x87a\x97\xd39W\xa4\x99\x89N֕i^о*-)щ\x97\xbbZ\x03\xcd\xf6\x1a=\x9a\xb8\x06Cq\xf8ZL\xa9\x87\xafc\u05fe\x1e\x13\xea\x18\xf7\x06ƛ\xed\x1b\x19O\xdcD\xe7܌\xf5\xa3w\v֏\xc1\x89[\x11u:%nK3\x9dN\xd6\xedi^\ak\xbaC;\xee\x9d\xca\xc4]\x1a\xb2\x13wkg\xc6=i2\xe3\xde4\xef\f\\\xec\xbe4sF\xa7\xc4\xfdJgm\x9a1c\xc6\x03ܧ\aɇȇ\xc9G\xc8G!\x95\xc7\xf4Qz\x1c\x88?\x81\xe7\xe9I<\x00\x15O\x01\xb1\xa7!\xa1gҤ\xea\xd94\xa3\xaa\xfc9\xa0z\x1dP\xb2\x1e\x88o\x00\x1a6\x02\xb5\xcf\x03\xb1\x17\xa0\xb4\x17\xa1\xb4M\xfa,l\x86ܶ\xe8s\xb7U\x1f\xad\x97 \xb0\x97!\xbaW\xf0ܽ\n\xe1\xbd\x06\u1f4e\xe7\xee\r\\\xb0\xea\xcd4\xb3<^\xfe\x96\x8e{[\x9f\xbew\x80\xf8\xbb\xc0\xdc\xf7\x80\x86\xf7\xf59\xfc \xcdh\xa8\xfa0ͬ*\x8f\u007f\x84k\xd5l\x03\xca>F\xbf!\xf6\t\x9aU\x9f\xa2Y]\xfe\x992\xfe9X\x12߮\x8c\xedH3\xeb'\xd6~\x81v<\xfe%\x06\xce\xfd\n\xa8\xfc\x1a\x98\xf2\r\x9e\xe0\xf2o\x81\xaa\xef\xf4\x81\xde\t\xc4w\xa5\x99\xd5\xf1\xf8\xf7h\xce\xfd\x01(\xfd\x11\x88\xfd\xa4\x8f\xfaϸ\xa9\xaa_\xf4\x99\xfd\x15OF\xec7}<~\xd7G\xf6\x0f}Z\xff\x04\xaa\xfe\xd2\a\xf5o<b\xff \x9f\xff\xea\xbd\xefN\xc3[\xda\x1e<`{ӌ\x89\xf1}\xc0\xdc\xfd\xfap\x1dг\x0f\xe2\xe1\xaa9\x04T\x1d\x06\xaa\x8f\x00%G\xf1\xac\x1d\xe3\x9e\x1c'O\x90'\xc9S\xa4'݈Y\x02$\f\xc01\xd3͘eyA\xdb\xf6!`\xfb\x017)\x9d\xff\x82*ݨ\xb2\x02@\"\x19p\x82\xe9f\x95e\xa5\x80\xb6\x1dB\xc0N\x05\xdc0\xfaMV\x04\x13Ĭ4e\"]\xe9d\xa4{\x11\xb12\xd5\xd9v\x96\xc6\xec\xa8\xd2\xcd\xd6P\x93\x95\x93nT[\xa7\x03\x893\x00\xe7\xcct\xb3ڲ\xce\x02m\xbb\r\x02v.\xe0\x9e\x8d~\x93\x95\x97n\xc6[\xac\xb6\xcaD;\xa5sN\xba\x17\x11\xeb\\u\xb6}\x9e\xc6\xec\xf3\x95n\xbe\x86\x9a\xac\vҍz\xab=\x90\xe8\x008\x05\xe9f\xbdeu\x04m\xbb\x13\x02v!\xe0\x16\xa1\xdfduN7\xe2V\x17 \xd1\x15p\xbaa\x1a\xcb\xea\x0e\xdav\x0f\x04잀\xdb\v\xfd&\xab7\x18\xb3\xfa(\x13}\x95N?\\\x0e\xb7\xd9_\x9dm\x0fИ=P\xe9\x0e\xd2P\x9358ݨ\xb3\x86\x00\x89\xa1\x803,ݬ\xb3\xac\xe1\xa0m\x8f@\xc0\x1e\t\xb8\xa3\x98\xefш6Yc\xd8\x1e\xabmg\\\xba\x17\x11k\xbc:۞\xa01{\"\x8fO\"'#\x12\xb3\xa6(\x13S\x95\xce4\f\xc5z\xa6\xab\xb3\xed\x19\x1a\xb3g*\xddY<c\xb6\x1eh\xb2\xe6\xb03\x97\x1dg^\xbaOc\xd6|z\xdb^\xc0\xb0\xbd\x90c\x16\x91\xc5\xe9F\x89e\x01\x89\x12\xc0)M7\xd1-\x03m\xdbF\xc0^\f\xb8\xe5\xe87Y\xb1t\xa3\xd1r\x80D\x05\xe0T\xa6\x9b\x8d\x96U\x05\xdav5\x02v\r\xe0\xba\xe87Y\xb5\xe9F\x83U\a$\xea\x01'\x9en6XV\x03h\xdb\t\x04\xecF\xc0mB\xbf\xc9Z\x92n\x94Z\xcd@\xa2\x05p\x96\xa6\x9b\xa5\x96\xb5\f\xb4\xed\xe5\b\xd8+\x00w%\xfaM֪tc\x89\xb5\x1aH\\\b8\x17\xa5\x9bK,\xebbж/A\xc0\xbe\x14p/\xe3m]\x8eh\x93u\x05\xdbWj۹*\u074b\x88u\xb5:\xdb^\xa31\xfb\x1a\x1e\xbf\x96\xbc.ݨ\xb1\xae\a\x127\x00\u038d\xe9f\x8de\xdd\x04\xda\xf6\xcd\bط\x00\xee\xad\xe87Y\xb7\x81\xcd\xd6\xed\xca\xc4\x1dJ\xe7\xcet/\"\xd6]\xeal\xfbn\x8d\xd9\xf7(\xdd{5\xd4dݗn\xe4[\xf7\x03\x89\xb5\xbc\xda\x03\xe9f\xbee=\b\xda\xf6C\b\xdb\x0f\x03\xee#\xe87Y\x8f\xa6\x1b\x95\xd6c@\xe2q\xc0y\"ݬ\xb4\xac'A\xdb~\n\x01\xfbi\xc0}\x86\xd3<\x8bh\x93\xf5\x1c\xdb\xeb\xb4\xed\xacO\xf7\"bmPg\xdb\x1b5f?\xcf\xe3/\x90/\"\xb2\xc4ڤLlV:[0\x14yܪζ_Ҙ\xfd\xb2\xd2}\x85g\xbc\xaa\a\x9a\xac\xd7\xd8y\x9d\x1d\xe7\x8dt\x9fƬ7\xe9m\xfb-\x86\xed\xb79\xe6\x1d\xf2\xddt|\x9c\xbf\a$\xde\a\x9c\x0f\xd2\xf1\xc1n}\b\xda\xf6G\b\xd8\xdb\x00\xf7c\x0e\xfd$\xdd(\xb6>\x05\x12\x9f\x01\xce\xe7\xe9f\xb1em\am{\a\x02\xf6\x17\x80\xfb%\x87~\x95n\xb4X_\x03\x89o\x00\xe7\xdbt\x13\xc5\xe2;жw\"`\xef\x02\xdc\xef\xd1o\xb2~\x00c֏\xca\xc4OJ\xe7\xe7t/\"\xd6/\xeal\xfbW\x8dٿ)\xdd\xdf5\xd4d\xfd\x91\x8e\xb7\x94?\x81\xc4_\x80\xf3w:\xdeW\xac\u007f@\xdb\xfe\x17\x01\xfb?\xc0\xddͅ\xecI7ʬ\xbd@b\x1f\xe0\xecO7\xcb,\xeb\x00h\xdb\a\x11\xb0\x0f\x01\xeea\xf4\x9b\xac#`\x99uT\x998\xa6t\x8e\xa7{\x11\xb1N\xa8\xb3\xed\x93\x1a\xb3O)\xdd\xffi\xa8\xc9\xf2d\x18\x15\x96\x00\t\x03p\xcc\f\xb3\x02\xb5\x1cD-G\xc0\xf6\x03n\x12\xfaM\xd6i\x19F\xb9\x15\x00\x12ɀ\x13\xcc0\xcbQ\xcbA\xd4r\x04\xecT\xc0\rg\xf0\xdf\xc6!\xdad\xa5\xb1\x9d\xaem'#Ë\x88\x95\xa9\x0e\xb5\\cv\x94dz\xc9\x1cDʭӕ\x893\x94Ι\x18\x8a\v\x9c\xa5\x0e\xf5\\cv\xae\xd2=\x9bg\xe4e\x98\r1\xab\xad2\xd1N霓\xe1E\xc4:W\x1d*\xba\xc6\xec\xf3\x95n\xbe\x86P\xd13\xf0\xfd\xc0j\xafLtP:\x05\x19^D\xac\x8e\xeaP\xd65f\x17*\xdd\"\r\xa1\xb2g\x98\xb51\xab\x8b2\xd1U\xe9t\xcb\xf0\"buW\x87\xf2\xae1\xbb\xa7\xd2\xed\xa5!Tx\\2n\xf5Q&\xfa*\x9d~\xb8<>\x10\xfa\xabC\x85ט=P\xe9\x0e\xd2\x10*<:-\xd6\x10eb\xa8\xd2\x19\x86\x03\x10\xdcpu(\xf3\x1a\xb3G*\xddQ\xbc\xfb\xd1\x19\xc6bk\f\x90\x18\v8\xe32\xcc\xc5(\xf2 j<\x02\xf6D\xc0\x9d\x84~\x9359è\xb5\xa6\x00\x89\xa9\x803\rkEu\aQ\xdc\x11\xb0g\x02\xee,\xf4\x9b\xac\xd9\x19f}\xb35'ìn\xb6\xe6\xe2\xe4fk\x1e\xaf6\x9f\\@.$\x17\x91Ť\x95!y%\x19RX\x9a!\x1d\xcb2\xa4\x9f\x9d!}\x17g\x98}\xfb\xe6\x95gȠX\x86QT\xe4dH\x97\x8a\f\xe9Z\x99!ݪ2\xa4{u\x86\xf4\xa8ɐ\x9en\x86\xf4\xaa͐\xdeu\x19ҧ>\xc3\xecҹ \x9eav\xed\\Аav\xeb\\\x90\xc80\xbbw.h\xcc0{t.h\xca0{v.X\x92a\xf6\xea\\Мa\xf6\xee\\Вa\xf6\xe9\\\xb04ë\u007f\x1d\xb6,#\xa9K\xe7\x8e\xfa\xe7a˹\xa6\x15\xe4Jr\x15\xb9\x9a\xbc\x90\xbc\x88\xbc\x98\xbc\x84\xbc\x94\xbc\x8c\xbc\x9c\xbc\x82\xbc\x92\xbc\x8a\xbc\x9a\\C^C^K^G^O\xde@\xdeH\xdeD\xdeL\xdeB\xdeJ\xdeF\xdeN\xdeA\xdeI\xdeE\xdeM\xdeC\xdeKޗ!\xd6\xfd\x19b\xaf\xcd\x10\xe7\x81\fq\x1f̐\xc4C\x19\xd2\xf8\xb0>\x90\x8fd\xa0\x86?\xaa\xcf\xdfc\xfaT>\xae\x0f\xe1\x13\xfa\x90>\t4>\x95\x81W\xb5\xa7\x01\xfb\x19\xc0y\x16p\x9f\x03\x12\xeb\x80\xc6\xf5\x19x;\xdb\x00\xd8\x1b\x01\xe7y\xc0}\x01H\xbc\b4n\xca\xc0\xdb\xd5f\xc0\xde\x028[\x01\xf7% \xf1r\x06>\xc0^\xc90c5֫\x19\xf8\xf0\x8a\xbd\x86\x80\xfd:\xe0\xbc\x01\xb8o\x02\x89\xb7\x80Ʒ3̺\x84\xf5\x8e\xd2~W鼧t\xdfW&>P6~\x98\x81w\xa7\x8f2$\xbe\r\r\xfbc\xc0\xf9\x04p?\x05\x12\x9f\x01\x8d\x9fg\xa0\x02n\xcf\xc0\a\xfd\x0e\xb4\xec/в\xbfD\xcb\xf9\n-\xe7k\xb4\xdco\x80ķ@\xe3w\x19fY\x95\xb5\x13\x8fJ\x95\xb5Ki\u007f\xaft~P\xba?*\x13?)\x1b\u007f\xe6s\xfa\v\x9f\xc6_\xf9\x9c\xfe\xc6g\xf2w>\xb9\u007f(\x1b\xff\xcc\xc0g\xcb_\x80\xfd7\xe0\xfc\x03\xb8\xff\x02\x89\xff\x80\xc6\xdd\x19\xa8\xe2{\x00{/\xe0\xec\x03\xdc\xfd@\xe2\x00\xd0x\x90\x9bw\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4d\xf2\xbfEg\x8amd\x9a\x96嘙\xe2x3\r\xc7\xf1e\x8a\xeb\xcf4\\7IqZ\xa6a\xdb\x01\x1cK\xce\x14+\x98i\xa0\x1egb\xad!E*\xe0\x84\x15\x91L\xb3\xc9q\xd2\xc8t\x04\xdc\fE&\xfa\xae\x9bEF\xc9l\x84\xad\x1c\xc5\xe9\x99\xfa\x19z\x06y&y\x16&w\xdadJSn\xa6䟝)\ry\x99R\xd96\x13_\xf4\xdbeJ\xfc\x9cL\xa99\x17\aσ?\x9fK\xcfG\xef\x82L)m\x9f)\x83:dJU\x01VZ\xd3\x11wP\xd3\t\v\xaf)\xc4t5E\x99\xa8>\x9d3\xbd(GN\x17\xb4\x9d\xae\x99f\xad\xe3tC\xd3펦\xeb\xf6 {f\xeaW\x8b^\x99\x10po\x1c\xb3\xfadj\x05\xeb\v6\xd9\xfd\xc8\xfeJg\x009\x10\x13\xe2F\a\xb5\xba\xc1\x1as\x87\x90C5\xe4\xba\xc3Z\xddp\x8dY#ȑ\x1a\xb2\xacQ\xadnt\xab\x1b\x93)\xb5ca\xe32%6>\x13\x9a\x9b\x90\xe9\xc5˥3\x11mgR\xa6\xd9\xe08\x93\xd1t\xa7\xa0\xe9\xbaS\xc9i\x99\xfa\xb9<=\x13✁c\xd6\xccL}\x1f\x9d\x056ٳ\xc99Jg.9\x0f\x13b\x8d\xf3[\xdd\x02\x8d\xb9\v\xc9E\x1ar\xdd\xe2Vgi\xcc*!K5\x84\x17\xe7Vg\xb7\xba\xc5ؐr\x1cn\xb0cJ\xc7Q\xba\x15J\xab2\x13orU\x99^\xbc\xda9\xd5h;5\x99f\xa5\xe3\xb8h\xba\xb5h\xban\x1dY\x8f\x80\x15\xcf\xd4W\xc0\x86L}\x99K\x90\x8dJ\xa7\x89\\\x82Y\xb0\xd0\xe6Vע1w)\xb9LC\xae\xbb\xbcխИ\xb5\x92\\\x95\xc9\xd7\xc4խ\xee\xc2Vw\x11\xc4s1\xae\xd7t\t\xc6رKuE\xb1\xcbt\x19\xb1\xcbu\x05\xb1+2\xf1B~e\xa6\x17o\xe8\xceUh;Wg\x9a\xa5\x8e\xb3\x06M\xf7\x1a4]\xf7Z\xf2:\x04\xac\xeb3\xf5M\xfe\x06\xb0ɾ\x91\xbcI\xe9\xdcLނY\xb0\xda[[\xddm\x1aso'\xefА\xeb\xde\xd9\xea\xeeҘu7y\x8f\x86,\xeb\xdeVw_\xab\xbb\x1fr^\x8bM\x8d=\x90\x89\x9a\xf8`\xa6\x17_6\x9d\x87\xd0v\x1e\xce4\xab\x1d\xe7\x114\xddG\xd1t\xdd\xc7\xc8\xc7\x11\xb0\x9e\xc8\xd4/\xa5O\x82M\xf6S\xe4\xd3J\xe7\x19\xf2ŶU=\xd7\xea\xd6i\xcc]OnА\xebnlu\xcfk\xccz\x81|QC\x96\xb5\xa9\xd5mnu[2\xa5z+\xec%\\3\xf62\x1a\xaf\xc0^\xcdD]~-Ӌ\xef\x17\xce\xeb\x99Z\x9e3\xcd\x1a\xc7y\x13M\xf7-4]\xf7m\xf2\x1d\x04\xacw3\xf5{\xc8{`\x93\xfd>\xf9\x81\xd2\xfa\x90\xfc\b\xb3\xe02\xdbZ\xddǭ\xee\x13<\xee\x9f\xe2\xdc\xf2π\xd8\xe7\x99\xf8 ٞ\xe9\xc57|g\a\xda\xce\x17\x99f\x95\xe3|\x89\xa6\xfb\x15\x9a\xae\xfb5\xf9\r\x02ַ\x99\xfaK\xc0w`\x93\xbd\x93ܥt\xbe'\u007f\xc0,\xc8Ǐ\xad\xee'\x8d\xb9?\x93\xbfh\xc8u\u007fmu\xbfi\xcc\xfa\x9d\xfcCC\x96\xf5g\xab\xfb\v5\xe7o\xd8?\xb0\u007fQ\xa6\xec\xff2\xbdx\x05sv\xa3\xed\xec\xc94㎳\x17Mw\x1f\x9a\xae\xbb\x9f<\x80\x80u0S\xbf\xbb\x1f\x02\x9b\xec\xc3\xe4\x11\xa5s\x94<\x86Y\xb0\xa2\xe3\xad\xee\x84\xc6ܓ\xe4)\r\xb9\xee\xffZ\x9d'K\xbf\xeb\vid!dYf\xab\xf3\xb6:_\x96\xc4\xfd\xb0\xa4,#\xdet\x1a\x1a\x014*\x93qBeS\x10\xcdY)\x18\x87*\x14\x82\xc3\x13\x9e\n\x87\a'\f\a)F\xb2\xf47\x824\xa5\x93\x8eP\xccq2\xb4\xe3fj\aE];V4\x8b\xbf+d\xabk\xb2sZ\xdd\xe9t\xce\x19\xad\xee\xcc,\x9f:\xe7\xac\xff\xf7m\x18vs[\xddٌ\xban\xde\xff\xfb\xb6\f[\xedZ\xdd9\x8c\xe2u\xfb\xff\xfdyXu\xec\xfc,|\x18\xe6gy\xf1mƹ\x00m\xa7}\x96\xd9\xec8\x1d\xd0t\v\xd0tݎd'\x04\xac\xc2,\xfd\xd6S\x046ٝ\xc9.J\xa7+\xd9\r\xb3`I\xdd[]\x0f\x8d\xb9=\xc9^\x1ar\xddޭ\xae\x8fƬ\xbed?\r\xe1E\xbb\xd5\rhu\x03\xb3\xa4y\x10l0l\x88\xaeih\x96Qo\x0fS\fςdGdy\xeb\xb1ܑ\b8\xa3\xb2\xccz\xc7\x19\x8d\xa6;\x06M\xd7\x1d\x8b\x11\xee8\xf4\xad\xf1Y\xfa\xfb\xcf\x04\xf4\xad\x898\x03\x13Oju\x93\xb3\xa4~\nl*lZ\x16\u07bd\xa7gy\xf12\xee\xcc@ۙ\x99e.v\x9cYh\xba\xb3\xd1t\xdd9hZs\xb3\xf4u}\x1e\xc6\xe9o&\xadnA\x96,^\x98\xa5\xdfY\x16\x91\xc5J\xc7\"K\xb2\xf0\xfd\xc5qJ[]\x99\xc6\\[;\xae\xbbX;Vy\x16\xbf\xfaIJ|\xfa=\xc7r\xfe\xdfWd\xa1\\U\xe2\x18櫢s\xaa\xe9\xdc\x1a:\xcb\xcd\xd2\xff\x1c[\v6\xdbuJ\xa7^\xe9ƕVC\x16^\x1c\x13\x80Әe\xe2\xc2Mh\xbaK\xd0t\xddf4\xad\x96,\xfd\xe5oi\x96Ė\xc1\x96#T\xb9\"\xcb[\x87\xeb\xaf\xcc2\xea\x9cUYf\x9d\xe3\xacFӽ\x10M\u05fd\bM\xeb\xe2,\xfd\xf9\xea\x92,\xa9\xbb\x14k\xa8\x8aٗ\xd19\x97ӹW\xd0YW\xea\xf6\\\xa5[r\xb5n\xc6\x1a݁k\xb2|5\xf8F\xe8\\\x9be֔;\xd7eyA\xe7z\xed\xb87h\xc7uoԎu\x93v,\xeb\xe6,T\xa6[\xb2\xf4\x8f9o\xe5\x03s\x1b\x1f\x98\xdb\xf9\xa4\xdc\xc1G\xe4Nf\xfa.\xe6\xf8nf\xf5\x1e\xa6\xf3^\xcd\xdb}Y&\x96u\u007f\x96\x17t\xd6j\xc7}@;\xae\xfb\xa0v\xac\x87\xb4cY\x0fC\x11\xb1G8ѣ\x9c\xe8\xb1\xd6]z\x9c\xf3=ѺKOrڧZw\xe9i\x9d\xfd\x99,)y6K\xec\xe7\xb2\xc4Y\x97%\xee\xfa,\xb16d\xe1\xbdm#\xe0<\x0f\xb8/\x00\u058b\xb8\v{\x13\xe0l\x06\xdc-\x80\xb55\v\x1f\xe9/\x01\xceˀ\xfb\n`\xbd\xaa{\xf5\x9a\xee\xd5\xeb\xbaKo\xe8\xfe\xbc\x99e\x96\xc7\x12o)ݷ\x95\xf6;Y^\xd0~W;\xce{J\xeb}\xa46\xf1\x81&\xf9C\xcd\xf9GY\xfa\x03\xe76\xcd\xfcǚ\xf4O\xb0\x88ħ\xba\x9c\xcftu\x9fg\xe9\xef*\xdbu\x8d;ty_@\x02M\x89/\x95\xeeWJ\xfb\xeb,\xaf\xfe\x02\xf8\x8dv\x9co\x95\xd6wz\xf7\x89\x9dL\xc8.f\xea\xfb,~G\xff\x81\t\xfb\x91\xc9\xf9I\xa5\x98\xf8Y\xe9\xfe\xa2\xb4\u007fU\x8d\xda\xf6o\xdaq~WZ\u007fd\xe1k쟀\xfb\x17`\xff\x9d\xa5\xdfb\xffA\xd3\xf9\x17\xb0\xfe˒\xda\xddY\xf8\xf2\xb3\ap\xf7\x02\xf6\xbe,\xfd\x81b?\x9a\xce\x01\xc0:\x98eV\xc6\x12\x87\x94\xeea\xa5}$\xcb\v\xdaG\xb5\xe3\x1cSZ\xc7\xc1\xca\xc4\t\xa5{Ri\x9f\u00a0J\xdb\xfe\x9fv\x1cO\x14\xb4$jTV\x1aQ|\xd71\x01\xd7\vؾ\xa8\xfe\x8c\xe7G\xd3I\x02\xacӢ\xf8\xbe\x14\x00\xdcd\xc0\x0eF\xf5\xb7\xe9\x144\x9d\x10`\xa5F\xf1e!\f\xb8\x11\xc0N\x8b\xea\x0f@\xe9h:\x19\x80\x95\x195*\x12Y\x8a(\xe0f\x03vNT\u007f\x9b9\x1dM\xe7\fř\x80u\x16\x82\x15\x896J7Wi\x9f\x1d\xf5\x82v\x9ev\x9c\xb6J\xab]\x14\xdf\xec\xce\x01\xdcs\x01\xfb\xbc\xa8\xfe\n\u007f>\x9aN>`]\x10\xc5\x17\xa7D{\xa5\xdbAi\x17D\xbd\xa0\xddQ;N'\xa5U\x88\x93b\x89\"\xa5\xdbYiw\x89\xe2)\xb0\xed\xae\xdaq\xba)\xad\xeeQ}\x84\x13=\xe8ܞtv\xaf\xa8O\x9dݛ]\xa7\x0f\x9d\xd57\xaa\xdf\xc7\xfa)\xdd\xfeJ{\x80\x1e\xb0\xed\x81\xdaq\x06)\xad\xc1Q\xa3%1\x04p\x87\x02\xf6\xb0\xa8\xfe\b7\x1cMg\x04`\x8d\x8cJ\xcb(\xd8h\xac\xb0%1F\xe9\x8eU\xda\xe3p\x03\x18:^;\xce\x04\xa551\x8ao\x95\x93\x00w2`O\x89\xeao\xf4S\xd1t\xa6\x01\xd6\xf4\xa8\xfe.?C\xe9\xceTڳ\xa2\xfcY~\xb6v\x9c9Jk.F\xc6\xe6E\xf5[\xe2|\xa5\xbb@i/\x8c\xf2\xe7\x9dE\xdaq\x8a\x95\x96\x15՟\x9aJ\x94n\xa9\xd2.\x8b\xf2\x97&[;\xceb\xa5U\x8e\xf30U\x8c\xceu\xe8\xec\n\xa4Kg\xabdש\xa2\xb3\xaa\xa32\xbb&*\x85n\x145\u0529\x8dj\x9ds\xea\xe0P\t\xeb\xa3>uN\x9c]\xb7\x81]\xd7M\xb0k5\xb2kYMQ\xfe\x8d\x05\xd9L\xb6\x90K\xc9e\xe4rr\x05\xb9\x92\\\x15\x95\xbc\xd5Q)\xb90*U\x17Ee\xf1\xc5Q\x89_\x12\x95\x9aK\xa3\x12\xbb,*e\x97G\xa5ከ\x94^\x19\x95\xba\xab\xa2R}uT\xca\xd7@\xff\xe5\xd7`_\xae\x8dJ\xfduQ\xb1\xae\x8f\x8a{CT\x127Fž)*\xce\xcdQ\xa34vKT\xff85j\xd4\xc6n\x8bJ\xed\xedQYr\a\xfc\x9dQ\xe9\u007fWT\x06\xdeͫ\xdfC\xdeKއ\xab\xdf\x1f\x95Ƶ\x98\xe8\x01<#\xf5\x0fF\xa5\xf9\xa1\xa84=\xac\x13=\xa2x\x14\xd7z\f\xd7z<jX\xa5O\x00\xf6\x93\xe8=\x05{\x1a\xf6L\xd4p\xedg\x81\x9a簮uQ\xa9\\\x8f\x85o\x80߈E?\xaf\x8b~\x01\x8d\x17a\x9b0\xedf\xdc\xe1\x16\xd8V\xd8K\xb0\x97q\u05ef\xc0^\x85\xbd\x86\x9bx\x1d7\xf3FT*\xde\xc4\xf8\xb7\xf4Zo\xe3\xea\xefD\r\xdb}\x17\xf7\xf1\x1en\xff}\xe4\xea\x03؇\xb0\x8fp\xa9m\x88}\x8c|}\x02\xfb\x14\xb9\xfb\fy\xfd\x1c\xb6\x1d\xe3w\xc0\xbe\xc0\x8c_\"\x87_\xc1\xbe\x86}\x83\x9c\u007f\v\xfbN\x97\xb6S\xb1\vg}\x8f[\xf9!j\xdaV\xfd\x8fQ\xd3q\xeb\u007f\x8a\x1au\x89\x9f\x15\xbf(~\xc5\xc5~\xd3\xf4\xfc\xae\xf8C\xf1'\xf6\xe6/\xe4\xf7o\xe8矨\xf4\xfd7*\x05\xffE\x8d.\xbdv\x03\xbd\xf7\x00}\xf62\xc5\xfb\xc8\xfd\xe4\x01\xf2 y\x88<L\x1e!\x8f\x92\xc7\xc8\xe3\xe4\t\xf2$y\x8a\xf4d\xf3\x97\f\xd2 M\xd2K\xfaH?\x99D\x9eF\x06\xc8d2H\xa6\x90!2\x95\f\x93\x112\x8dL'3\xc8L2\x8b\x8c\x92\xd9d\x0ey:y\x06y&y\x16ن\xcc%\xcf&\xf3ȶd;\xf2\x1c\xf2\\\xf2<\xf2|2\x9f\xbc\x80lOv \vȎd'\xb2\x90,\";\x93]Ȯd7\xb2;ك\xecI\xf6\"{\x93}Ⱦd?\xb2?9\x80\x1cH\x0e\"\a\x93Cȡ\xe40r89\x82\x1cI\x8e\"G\x93cȱ\xe48r<9\x81\x9cHN\"'\x93Sȩ\xe44r:9\x83\x9cI\xce\"g\x93sȹ\xe4<r>\xb9\x80\\H.\"\x8bI\x8b,!K\xc92\xd2&\x17\x93\xe5d\x8ct\xc8\n\xb2\x92\xac\"\xab\xc9\x1a\xd2%k\xc9:\xb2\x9e\x8c\x93\rd\x82l$\x9b\xc8%d3\xd9B.%\x97\x91\xcb\xc9\x15\xe4JrU\xb6T\xae\xce6*c\x17fK\xf9E\xd9Fy\xec\xe2l<×dK\xe9\xa5\xd9\xfa\u007f\x12\x99-\x15\x97g\x1b\x15\xb1+\x10n\xbe2[\x1a\xae\xca\xd6w\U000abce5lM6\xff?\"q\xa0\xe6Z\x1c\xb8.\x1b\xd5\xedz\xc4o\xc86\xcab7fK\xcdM\xd9R{s6\x8a\xe7-\xd9Rrk\xb6Q\x12\xbb-[\xaaoϖ\xe6;\xb2\xa5\xfe\xcel\xa9\xba+[\x1a\xef\xce\xd6\xff+8 ~o\xb6\xc4\xef˖\xd8\xfd8\xb26[\xea\x1e\xc8\x16\xeb\xc1lò\x1e\xca\x16\xe7\xe1l\xc3q\x1eɖģ\xd9F\xa2\xf21 \xf1x\xb6\x99H4>\x91m\xd47?\x99m\xd677?\x95mT5?\x9dmV57?\x93-\xf6\xb38\xd7y.\xdbp\xddu\x8a\xf5\xe8&6`\u038d:\xe7\xf3\x8a\x170\xf1\x8b:\xf1&,js\xb6\xd1ܼ\x05Wت\x93\xbf\x04X/\xe3<\xfb\x15ĭW1\xca~\r\x93\xbe\x8e\xf3\xec7t\xe67uҷtҷ\xb3e\xc2;\xd92\xfa]t\x8a?Ľm˖\xb6۳\xa5pG6\xff6\xeb\x8bl\xe9\xfbe\xb6\x14|\x95m\x14\x14|\x9d\xad\u007f\xea\xfeMv\xeb\xbf&\xf96\xdb\x187\xf5\xbbl\xc9\xdf\xc9\xfd\xd8E~O\xfe\x90-\x9d\u007f̖.?eKן\xb3\xa5\xdb/\xd9\xd2\xfd\xd7l\xe9\xf1[\xb6\xf4\xfc=[z\xfd\x91-\xbd\xff̖>\u007fq\xf4\xdf\xe4?\xe4\xbf\xe4\u007f\xe4nr\x0f\xb9\x97\xdcG\xee'\x0f\x90\a\xc9C\xe4a\xf2\by\x94<F\x1e'O\x90'\xc9S\xa4'\xc7\xcc\x1b\x9c'9\xbe\xbc\xc2\xc2\xc2<#\xc7\xe8\x98g\xe6\x18\x85y\xde\x1c\xa3o\x9e/\x87\xf7\x9f\x94#\x9dN\xd3#\x01=\x12\xceaȇ\xcei9\xd2%=G\xbaf\xe4H\xb7\xcc\x1c鞕#=\xa29\xd23;Gz\xe5\xe4H\xef\xd3s\xa4\xcf\x19\x1c}&y\x16ن\xcc%\xcf&\xf3r\xc4j\x9b#v\xbb\x1cq\xce\xc9\x11\xf7\xdc\x1cI\x9c\x97#\x93\xceϑ\x19\xf99\x86m_\x90#5\xeds \xec\x0e9RR\x90#\xb5\x1ds\xa4\xaeS\x8e\x94\x17\xe6HuQ\x8eTuΑx\x97\x1c\b\xb1k\x8e4tˑ\xb2\xee9P\u007f\x8f\x1c\xa9\xe8\x99#ͽr\xa4\xbew\x8e4\xf5ɑ\xc5}s\xa4\xb2_\x8e\xbe\x86\xf7\xcf1\x1a\xe2\x03r\xa4e`\x8e\xc4\x06\xe5\x18-\xf5\x83s\xf0ek\bZ\xb1\xa1z\xfa0\xdc\xf6p,k\x04\x965\x12\xcb\x1a\x85e\x8dƲ\xc6`Ycu5㰚\xf1X\xcd\x04\xacf\"V3\t\xab\x99\x8c\x05L\xc1\x02\xa6\xea\fӰ\x80\xe9z\x99\x19X\xc5L\xac`\x16\xae>\x1b#\xe7\xe0\x92ss\x8c\x8a\xe6y\x98\xa7y~\x8eQֲ\x00WZ\x88+-\xca1\x9c\xe6b\\\xc2\xc2\xe5J\xf42\xa58\xa9\f'\xd98i1.W\xae7\x1a\xc3u\x1c\\\xa7\x02\x97\xa8\xc4}Ua@5\x06\xd4\xe8\xe5\\\xdcU-n\xbaN\x17Q\xaf7\x14\xc7\xcc\r\x98'\x81h#\x867ip\t\xb3\xdfL\xb6\x90K\xc9e\xe4rr\x05\xb9\x92\\E\xaeΑ\xd1\x17\xe6\xc8\xec\x8brd\xd6\xc592\xe1\x12(\xa8[ޥPP\xb7n\xdd\xf2.\xc3^^\x8e\x8b]\x81\x8b]\xa9\xab\xbf*GJ\xafƢ\x1a\xd6\xe4h\xe5\xb9\x06\xf7Zv-\x0e\xd4\\\x87;\xb8\x1ewp\x03n\xe9\xc6\x1c\x94\x99\x9bp_\xf1\x9bua\xb7`\xfd\xb7b\xa2\xdb0\xe4v\rܑ\x83\xd2v\xa7Nw\x17\xa6\xbb;G\xffA\xb9Ngݛ\xa3E\xec>\x8c\xbb\x1f\x13\xc7\xd6\xea\x14\x0f\u0b9b\x1f\xd4\xd3\x1e\xc2<\x0f#\x8d\x8f \xfd\x8f栀=\x96#\xf9\x8f\xf3.\x9e \x9f$\x9f\"\x9f&\x9f!\x9f%\x9f#ב\xeb\xc9\r\xe4F\xf2y\xf2\x05\xf2Er\x13\xb9\x99\xdcBn%_\"_&_!_%_#_'\xdf \xdf$\xdf\"\xdf&\xdf!\xdf%\xdf#\xdf'? ?$?\"\xb7\x91\x1f\x93\x9f\x90\x9f\x92\x9f\x91\x9f\x93\xdb\xc9\x1d\xe4\x17\xe4\x97\xe4W\xe4\xd7\xe47\xe4\xb7\xe4w\xe4Nr\x17\xf9=\xf9\x03\xf9#\xf9\x13\xf93\xf9\v\xf9+\xf9\x1b\xf9;\xf9\a\xf9'\xf9\x17\xf97\xf9\x0f\xf9/\xf9\x1f\xb9\x9b\xdcC\xee%\xf7\x91\xfb\xc9\x03\xe4A\xf2\x10y\x98<B\x1e%\x8f\x91\xc7\xc9\x13\xe4I\xf2\x14Y\xd5FJ\xaa\xdbHYM\x1bY춑\xea\xda6RS\xd7Fj\xeb\xdbH}\x1c\xd6\xd0F\xe2\x896\xd2\xd0\xd8FZ\x9a\xdaH\xf9r\x1c[\x85sV\xe3\x9c\vq\xceE\x88]\xdcF*/i#U\x97\xe2\xfc\xcbp\xfe\xe5\x18s\x05ν\x12\xe7^\xddF\x1a״\x91%\xd7\xe0|O\xae\f\x91\\\xb1\x8c\\\x19j\xe6J\x89\x17\xde\a\xef\x87O\x82?-W\x86\x05r\xa549W\x86\as\xa5,\x05>\x04\x9f\n\x1f\x86\x8f\xc0\xa7\xc1\xa7\xc3g\xc0g\xe6ʈ\xac\\\xb1\xa3\xf0\xd9\xf09\xf0\xa7ß\x01\u007f&\xfcY\xf0m\xe0sse\xe4ٹ\xb28/WF\xb5͕\xf2v\xb92\xfa\x9c\\\x89\x9d\v\u007f\x1e\xfc\xf9\xf0\xf9\xf0\x17\xc0\xb7\x87\xef\x00_\x00\xdf1W\xc6t\xca\x15\xa7\x10\xbe\b\xbes\xae\x8c\xeb\x92+\x95]\xe1\xbb\xc1w\x87\xef\x01\xdf3W\xc6\xf7ʕ\xaa\xde\xf0}\xe0\xfb\xc2\xf7\x83\xef\x0f?\x00~`\xaeL\x18\x94+Ճ\xe1\x87\xc0\x0f\x85\x1f\x06?<W&\x8eȕ\x9a\x91\xf0\xa3\xe0GÏ\x81\x1f\v?\x0e~|\xaeL\x9a\x90+\xeeD\xf8I\xf0\x93\xe1\xa7\xc0O\x85\x9f\x06?=W&\xcfȕڙ\xf0\xb3\xe0g\xe7\xca\xd49\xb9R?\x17~\x1e\xfc|\xf8\x05\xf0\v\xe1\x17\xc1\x17\xe7\xca4+W\xe2%\xf0\xa5\xf0e\xf06\xfcb\xf8r\xf8\x18\xbc\x03_\x91+\xd3+s\xa5\xa1\n\xbe\x1a\xbe\x06ޅ\xaf\x85\xaf\xfb?\xa2\xce\x02\xbe\xa9\xeb}\xe3\xbbI\x8b\xcd\xdd\xe1\x16\xcaHѤA°\xe1\xdax\x82\x06\bmh\x03m\xc3\xda\x06\x97\r\x87\xb9\xbb\u00801܆\xbb\xbb\xbb\xbb\xbb\xdb\xef\xff\x9c\xe7\xbd\xdd\xff\xb3\xcf\xfb}εs\x8f\xbcGoX\xa1y%\xb5@~I-^\x00\x8dC{B{A{C\xfb@\xfbB\xfbA\xfb\x97Ԃ\x03Jj=\aB\aA?(\xa9\xb5\xfe\xb0\xa4\xd6k0t\bt(t\x18t8t\x04t$t\x14ttI\xad\xcdG%\xb5\xde\x1fC?\x81~ZRk\xfbYI\xad\xcf\xe7%\xb5v_\x94\xd4\xfa~\t\xfd\n\xfa5\xf4\x1b跨\xab\uf42e\xef\xf1\xec\x0f\xb8\xefG\xf8\xd8O\xc8\xcb\xcf%\xf9\x89\x9f\xfc\xb5\xa4ɗ\xff\x1b\x83\xbf\xc3\r\xff\xc0-\u007fB\xc7@\xc7B\xff\x82\x8e\x83\x8e\x87N\x80\xfe\r\x9d\b\xfd\a:\t:\x19:\x05:\x15:\r:\x1d:\x03:\x13:\v:\x1b:\a\xfa/t.\xdcn\x1e\xdcn>t\x01t!t\x11t1t\tt)t\x19t9t\x05t%t\x15t5t\rt-\xdcm\x1d\xdcm=t\x03t#\xaa{\x13\xaa{3t\vt+t\x1bt;t\at't\x17t7t\x0ft/t\x1ft?\xf4\x00\xf4 \xf4\x10\xf40\xf4\b\xf4(\xf4\x18\xf48\xf4\x04\xf4$\xaa\xeb\x14\xaa\xeb4\xf4\f\xf4,\xf4\x1c\xf4<\xf4\x02\xf4\"\xf4\x12\xf42\xf4\n\xf4*\xf4\x1a\xf4:\xaa\xe5\x06\x8a\xfb&\xf4\x16\xf46\xf4\x0e\xf4.\xf4\x1e\xf4>K\xfb\x01\xf9\x90|D>&\x9f(\xa5\x855\x98\tf\x86%\xc0\x12aE`Ea\xc5Ji\xf5\x8b\xc3J\xc0\x9e\x84=\x05{\x1a\xf6\f\xecY\xd8s\xa5\xb4\xc8\xf3\xb0\x17`/\xc2^\x82\xbd\f{\xa5\x14\x97\x9f\xe4k\xa5\xd0!\xc0ހ\xbd\t{\v\xf66\xac$\xaf\x96\"u<\x93\x04+\r+\x03K\x86\x95\x85\xbd\x03+\a\xb3\xe0\xfe\x14XyX\x05XEX%XeX\x15\x98\xb5\x94\x16\xb5\xc1RavXUX5XuX\r\x98\xa3\x94ּ&\xec]X-XmX\x1dX]X=\xd8{\xa5\xb4X}X\x03XCX#XcX\x13\xa6\xae)٬\x14fY\xb0\x16\xb0\x96\xb0V\xb04\x98\x93W]\xa4\xbb\x94\x16\xf7\xc0\xbc0\x1f\xcc\x0f\v\xc0\x82\xb0ְ6\xbc\xabm)-Ў\xa1\xf6\bu`(\x84PG\x86:!\xd4\x19\xef\x0eú\xc0\xd2a\x19\xb0\b\xac+,\x13\x96\x85\xf7Fa\xdd`\xddaٰ\x1cX.,\x06끺{\x1f\x96\x87\xb2ˇ\x15\xc0Ⱎ(\x8b^\xb0ވ\xa3\x0f\xac/\xd2\xd4\x0f\xd6\x1f\xe1\x01\xb0\x81L\xc1 \xf2\x03<\xff!l0l\bl(l\x18l8l\x04l$\xea\u007f\x14l4\xec#\xd8ǰO`\x9f\xc2>\x83}\x8e\xf7}\x01\xfb\x12\xf6\x15\xeck\xd87\xb0oa\xdf\xc1\xbeG\xbd\xfd\x00\xfb\x11\xf6\x13\xecg\xd8/\xb0_a\xbf\xc1~Gz\xfe\x80\xfd\t\x1b\x03\x1b\v\xfb\v6\x0e6\x1e6\x01\xf9\xfc\x1b6\x11\xf6\x0fl\x12l2l\nl*l\x1a\xd28\x1d6\x036\x136\v6\x9b9\x9b\x83п\xb0\xb9H\xe5<\xd8|\xd8\x02\xd8BآRZ\xb9\xc5(\xa1%Х\xa5\xb4\x81\xcbJ\x99J\x0f\\\x8e䮀\xad\x84\xadb\x14\xab\x11Z\x03[\x8b\x84\xae\x83\xad\x87m\x80m\x84m*e*\xd7y3Pn\v0p+b\xdb\x06\xdb\x0e\xdb\x01\xdb\xc9\bv\x91\xbbq\xbc\a\xb6\x17>\xb8\x0f\xb6\x1fv\x00v\x90W\x0f\x952u.wX\xe1\b0\xf0(*\xea\x18\xec8\xec\x04\xecd)\xcd{\nv\x1a\xe13\xb0\xb3p\x9cs\xb0\xf3\xb0\v\xb0\x8b\xb8v\t\xc9\xef|\x19(w\xa5\x94\xd6\xf9*\xa3\xbdF^G\x11ހ݄\xdd\xe2\x99\xdb\b݁\xddE\xe1݃݇=\x80=\x84=Bq<F\fO\xe8\x1a\xff3\xc1̰\x04X\"\xac\b\xac(\xac\x18\xac8\xac\x04\xecI\xd8s\xbaV\xe9y\xd8\v\xb0\x17a/\xe9\xa6J\x95^VxE7\xf5\xef\xff\xaa\xaeuzM\xd7ʽ\x0e{C\xd7*\xbe\t}K\xd7J\xbf\r+\xa9\x9b*V,\x85\x80\xaek\x15\x92t\xacrK\xebZ\xf92\xba\xa9|\xddd]\xab\\V7U\xae\xfc\x8en\xc6\n\xb1\x1c\x0e-\xbaV\"E7\x95(Q\x05o\xb5ꦲV\x9bn.k\xb5\xa6\"F\xbb\x8e\xba\xa8\xaa\x9b˕+WM\xd7:W\xd7M\x9d;\xd7\xd0͝;wv\xe8Zǚ\xbaV\xfb]]\xab[\v\xb1\xd7\xd6MIIu\x80zu\x91\xd8zH\x1d\x96\xa1\x95\xea\xe3\xae\x06\xba\xb9|\xf9\xf2\rU\xca\x1b\xe9Z\x95\xc6\b\xb4o\xa2\x9bB\x95\x9a\xea\xec\x1ctS\xbd\xa4\xe6\xea\xc1\x16\xbaV\xa3\xa5nr\xbb[\xe9&K(M7\xb5Oq\xf2\x16\x17\xe9&=\xa4\x97\xf4\x91~2@\x06\xc9\xd6d\x1b\xb2-َlOv CdG\xb2\x13ٙ\f\x93]\xc8t2\x83\x8c\x90]\xc9L2\x8b\x8c\x92=t\xcdZ\xa0kU\xe3\xbaV\xad\xa7\xaeU\uf16c\xf4\xd65G\x1f]\xab\xd9\x17\x95\xd0\x0fe\xd1_\xd7\xea\f\xd05\xcb@]K\x19\xa4k\xb9\x1f\xe0\x99\x0fu\xcd6X\xd7R\x87\xe8\x9a}(\x9e\x1f\x86\xe7\x87\xe3\xf9\x11x~$\x9e\x1f\x85\xe7G\xe3\xf9\x8f\xf0\xfc\xc7x\xfe\x13<\xff)\x9e\xff\x8co\xfd\x9c\xfc\x82\xfc\x92\xfc\x8a\xfc\x9a\xfc\x86\xfc\x96\xfc\x8e\xfc\x9e\xfc\x81\xfc\x91\xfc\x89\xfc\x99\xfc\x85\xfc\x95\xfc\x8d\xfc]77n\x18\xf8C75l\xf5'\x907F75i2V\xd7Z\xfd\xa5\x9bs\xa2\xd9\xe3t\xcd9^7\xbb\v\xf2'\xe8&o\xfeߺ\xd6z\xa2nr\xfa\xfeѵF\x93tS\xe3\xc0d]k9E\xd7\xfcSuS\xa3\xbci\x8cr:9\x83\x9cI\xce\"g\x93s\xc8\u007fɹ\xe4<r>\xb9\x80\\H.\"\x17\x93Kȥ\xe42r9\xb9\x82\\I\xae\"W\x93kȵ\xe4:r=\xb9\x81\xdcHn\"7\x93[ȓ\xe4)\xf24y\x86<K\x9e#ϓ\x17ȋ\xe4%\xf22y\x85\xbcJ^#\xaf\x937ț\xe4-\xf26y\x87\xbcK\xde#\xef\x93\x0fȇ\xe4#\xf21Y>IkY!I\xab\x9f\x9a\xa45\xa9\x95\xc4}^\xb2\x0eY\x97\xacG\xbeG\xd6'\x1b\x90\r\xc9Fdc\xb2\tٔlF6'[\x90-\xc9Vd\x1a\xe9\xc4[]\f\xb9I\x0f\xe9%}I\x89\xba\xad\x8a]\xf7CS\xa1\x01\x1eWӃ<\xae\xa6\xb7\x86ڡm\xa0U\xa1my\xbd\xba\xde\x0eZ\rڞ\xc7\x0e\xbd\x03\xefs\xe8!\x9ew\xe8\x1d\xa15\xa0\x9d\x92̸\xde9Ik\x1eN25o\xde%\xc9ܼy\xf3t\x04\x83\x19IZ0\x92d\n6\xef\x9ad\x0e6o\x9e\x99\x94\x006\xcf¥6\xd1$\xadM\xb7$S\x9b\xe6ݓ\xccm\x9a7\xcfN\xd2Z\xe5$i\rs\x93\xb4F\xb1$-\xadG\x92\x16}?\xc9\x14\x8d\xe6%\x99\xa3\xd1h>\x82=\v\x92\xb4\x9e\xf1$S\xcfh\xcf$s\xcfh\xb4WR\x02\x18\xed\x8dK\xbd\xfb$i\xbd\xfb&\x99zG\xfb%\x99{G\xa3\xfd\x93\xb4\xec\x01IZ\xfa\xc0$-cP\x92\x96\xf3A\x92\xc9\xd2\xe8\xc3$S\xa3\x94\xc1I\x89\x16K\xff\x94\x94!IZ\xcaP\x96\xce0r89\x82\x1cI\x8e\"G\x93\x1f\x91\x1f\x93\x9f\x90\x9f\x92\x9f\x91\x9f'i\x95\xbeH\xd2\xfa\u007f\t\xfd\n\xfa5\xf4\x1b\xe8\xb7IZ\x87\uf4b4*\xdfC\u007f\x80\xfe\x88\xf3?\xc1~N\xd2\x06\xfe\x02\xfb\x15\xe1\xdfp\xdf\xef\xd0?\xa0\u007fB\xc7\xc0\xc6\xc2\xfe\xc2\xf18\xe8x\xe8\x04\xd8\xdf\bO\x84\xfd\x03\x9b\x04\x9b\f\x9b\x02\x9b\x8ak\xd3`\xd3a3`3a\xb3`\xb3as\x92\xb4\x8e\xff\xa2\x06\xe6\xe2\xfd\xf3\x92\xb4:\xf3\x11^\x80s\v\xf1\xdc\"\xd8bܳ\x04\xb6\x14\xe1e\xb0\xe5\b\xaf\x80\xadĽ\xab\xa0\xab\xa1k`k\x11^\a]\x0f\xdd\x00\xdd\b\xdb\x04\xdb\f\xdb\x02\xdb\nۆkۡ;\xa0;\xa1\xbb\xa0\xbb\xf1\xde=\xc8\xf7^\xe8>\xe8~\x9c?\x00;\x88\xbc\x1f\x82\x1d\xc6=G`G\xf1\xeec\xd0\xe3\xd0\x13Г\xd0S\xb0Ӱ38>\v=\a=\x0f\xbb\x00\xbb\b\xbb\x04\xbb\f\xbb\x02\xbb\x8a\xeb\xd7\xf0\x8e\xeb\xb0\x1b8\xbe\xc9Z\xb9E\xde&\xef\x90w\xc9{\xe4}\xf2\x01\xf9\x90|D>&\x9f(\xcd/a\xa4\x894\x93\td\"Y\x84,J\x16#\x8b\x93%\xc8'ɧȧ\xc9g\xc8g\xc9\xe7\xc8\xe7\xc9\x17\xc8\x17ɗȗ\xc9W\xc8W\xc9\xd7\xc8\xd7\xc97\xc87ɷȷɒd)R'\x93\xc8\xd2d\x192\x99,K\xbeC\x96#-d\nY\x9e\xac@V$+\x91\x95\xc9*\xa4\x95\xb4\x91\xa9\xa4\x9d\xacJV#\xab\x935H\aY\x93|\x97\xacE\xd6&\xeb\x90u\xc9z\xe4{d}\xb2\x01ِlD6&\x9b\x90M\xc9fds\xb2\x05ْlE\xa6\x91N\xd2E\xbaI\x0f\xe9%}\xa4\x9f\f\x90A\xb25نlK\xb6#ۓ\x1d\xc8\x10ّ\xecDv&\xc3d\x172\x9d\xcc #dW2\x93\xcc\"\xa3d7\xb2;\x99M搹d\x8c\xecA\xbeO\xe6\x91\xf9d\x01\x19'{\x92\xbd\xc8\xded\x1f\xb2/ُ\xecO\x0e \a\x92\x83\xc8\x0f\xc8\x0f\xc9\xc1\xe4\x10r(9\x8c\x1cN\x8e G\x92\xa3\xc8\xd1\xe4G\xe4\xc7\xe4'\xe4\xa7\xe4g\xe4\xe7\xe4\x17\xe4\x97\xe4W\xe4\xd7\xe47\xe4\xb7\xe4w\xe4\xf7\xe4\x0f\xe4\x8f\xe4O\xe4\xcf\xe4/\xe4\xaf\xe4o\xe4\xef\xe4\x1f\xe4\x9f\xe4\x18r,\xf9\x179\x8e\x1cON \xff&'\x92\xff\x90\x93\xc8\xc9\xe4\x14r*9\x8d\x9cN\xce g\x92\xb3\xc8\xd9\xe4\x1c\xf2_r.9\x8f\x9cO. \x17\x92\x8b\xc8\xc5\xe4\x12r)\xb9\x8c\\N\xae W\x92\xab\xc8\xd5\xe4\x1ar-\xb9\x8e\\On 7\x92\x9b\xc8\xcd\xe4\x16r+\xb9\x8d\xdcN\xee w\x92\xbb\xc8\xdd\xe4\x1er/\xb9\x8f\xdcO\x1e \x0f\x92\x87\xc8\xc3\xe4\x11\xf2(y\x8c<N\x9e O\x92\xa7\xc8\xd3\xe4\x19\xf2,y\x8e<O^ /\x92\x97\xc8\xcb\xe4\x15\xf2*y\x8d\xbcN\xde o\x92\xb7\xc8\xdb\xe4\x1d\xf2.y\x8f\xbcO> \x1f\x92\x8f\xc8\xc7\xe4\x13e\xd8\xf3\x93&\xd2L&\x90\x89d\x11\xb2(Y\x8c,N\x96 \x9f$\x9f\"\x9f&\x9f!\x9f%\x9f#\x9f'_ _$_\"_&_!_%_#_'\xdf \xdf$\xdf\"\xdf&K\x92\xa5H\x9dL\"K\x93e\xc8d\xb2,\xf9\x0eY\x8e\xb4\x90)dy\xb2\x02Y\x91\xacDV&\xab\x90V\xd2F\xa6\x92v\xb2*Y\x8d\xacN\xd6 \x1ddM\xf2]\xb2\x16Y\x9b\xacC\xd6%\xeb\x91\xef\x91\xf5\xc9\x06dC\xb2\x11٘lB6%\x9b\x91\xcd\xc9\x16dK\xb2\x15\x99F:I\x17\xe9&=\xa4\x97\xf4\x91~2@\x06\xc9\xd6d\x1b\xb2-َlOv CdG\xb2\x13ٙ\f\x93]\xc8t2\x83\x8c\x90]\xc9L2\x8b\x8c\x92\xdd\xc8\xeed6\x99C\xe6\x921\xb2\a\xf9>\x99G\xe6\x93\x05d\x9c\xecI\xf6\"{\x93}Ⱦd?\xb2?9\x80\x1cH\x0e\"? ?$\a\x93Cȡ\xe40r89\x82\x1cI\x8e\"G\x93\x1f\x91\x1f\x93\x9f\x90\x9f\x92\x9f\x91\x9f\x93_\x90_\x92_\x91_\x93ߐߒߑߓ?\x90?\x92?\x91?\x93\xbf\x90\xbf\x92\xbf\x91\xbf\x93\u007f\x90\u007f\x92cȱ\xe4_\xe48r<9\x81\xfc\x9b\x9cH\xfeCN\"'\x93Sȩ\xe44r:9\x83\x9cI\xce\"g\x93s\xc8\u007fɹ\xe4<r>\xb9\x80\\H.\"\x17\x93Kȥ\xe42r9\xb9\x82\\I\xae\"W\x93kȵ\xe4:r=\xb9\x81\xdcHn\"7\x93[ȭ\xe46r;\xb9\x83\xdcI\xee\"w\x93{Ƚ\xe4>r?y\x80<H\x1e\"\x0f\x93Gȣ\xe41\xf28y\x82<I\x9e\"O\x93gȳ\xe49\xf2<y\x81\xbcH^\"/\x93Wȫ\xe45\xf2:y\x83\xbcI\xde\"o\x93wȻ\xe4=\xf2>\xf9\x80|H>\"\x1fK\u007f\x98\xcc\xfe\x90L!˓\x15Ȋd%\xb22Y\x85\xb4\x9262\x95\xb4\x93U\xc9jdu\xb2\x06\xe9 k\x92\uf4b5\xc8\xdad\x1d\xb2.Y\x8flI\xb6\"\xd3H'\xe9\"ݤ\x87\xf4\x92>\xd2O\x06\xc8 ٚlC\xb6%ۑ\xed\xc9\x0ed\x88\xecHv\"\xb7&k\xe1m\xc9Z\x97\xed\xc9Z\xfa\x8ed-cg\xb2\x16ٕ\xacuݝ\xace\xeeIֲ\xf6&k\xd1}\xc9Z\xb7\xfd\xc9Z\xf7\x03\xc9Z\xf6\xc1d-\xe7P\xb2\x96{8Y\x8b\x1dI\xd6z\x1cM\xd6\xde?\x96\xac\xe5\x1dO\xd6\xf2O$k\x05'\x93\xb5\xf8\xa9d\xad\xe7\xe9d\xadיd\xad\xf7\xd9d\xadϹd\xad\xef\xf9d\xcdz\x81o\xbcH^\"/\x93Wȫ\xe45\xf2:y\x83\xbcI\xde\"o\x93wȻ\xe4=\xf2>\xf9\x80|H>\"\x1f\x93O\x94\xd5*i0SY\xad\xbf\x19\x96\x80p\"\xac\b\xc2Ea\xc5\x10.\x0e+\x81\U00013c27\xcaj\x15\x9e\x86=\x03{\x16\xf6\x1c\xecy\xd8\v\xb0\x17a/\xc1^\x86\xbd\x02{\x15\xf6\x1a\xecu\xd8\x1b\xb07ao\xc1ކ\x95\x84\x95\x82\xe9\xb0$XiX\x19X2\xac,\xec\x1dX9\x98\x05\x96\x02+\x0f\xab\x00\xab\b\xab\x04\xab\f\xab\x02\xb3\xc2l\xb0T\x98\x1dV\x15V\rV\x1dV\x03\xe6\x80Մ\xbd\v\xab\x05\xab\r\xab\x03\xab\v\xab\a{\x0fV\x1f\xd6\x00\xd6\x10\xd6\b\xd6\x18\xd6\x04\xd6\x14\xd6\f\xd6\x1c\xd6\x02\xd6\x12\xd6\ne\x91\x06s\xa2,\\07\xc2\x1e\xa8\x17\xd7|0?,\x00\v\xc2Z\xc3\xda\xc0\xda\xc2\xda\xc1\xda\xc3:\xc0B\xb0\x8e\xb0N\xb0ΰ0\xac\v,\x1d\x96\x01\x8b\xc0\xba\xc22aY\xb0(\xac\x1b\xac;,\x1b\x96\x03˅\xc5`=`\xef\x97ժ\xe4\x95\xd5:\xe4\x97\xd5\xda\x14 =q\xa4\xa7'\xb4\x17\xb47\xb4\x0f\xb4/\xb4\x1f\xb4?t\x00t t\x10\xf4\x83\xb2Z\x99\x0fa\x83aC`Ca\xc3`\xc3a#`#a\xa3`\xa3a\x1f\xc1>\x86}\x02\xfb\x14\xf6\x19\xecs\xd8\x17\xb0/a_\xc1\xbeF\xbc\xdf \xdeo\xcbr\x14#\xbf'\u007f \u007f$\u007f\"\u007f&\u007f!\u007f%\u007f#\u007fG<\u007f\xc0\xfe\x84\x8d\x81\x8d\x85\xfd\x05\x1b\a\x1b\x0f\x9b\x00\xfb\x1b6\x11\xf6\x0fl\x12l2l\nl*l\x1al:lFY\xad\xe3L\xd8,\xd8l\u061c\xb2Z\xdd\u007fasa\xf3`\xf3a\v`\v\xcbj\xc1E\xb0Ű%\xb0\xa5e\xb5\xda\xcb`\xcba+`+a\xab`\xab\xcbj\xe5\xd7\xc0\xd6\xc2\xd6\xc1\xd6\xc36\xc06\xc26\xc16ö\xc0\xb6¶\xc1\xb6\xc3v\xc0v\xc2v\xc1v\xc3\xf6\xc0\xf6\xc2\xf6\xc1\xf6\xc3\x0e\xc0\x0e\xc2\x0e\xc1\x0eÎ\xc0\x8e\u008e\xc1\x8e\xc3N\xc0N\xc2N\xc1N\xc3\xce _ga\xe7`\xe7a\x17`\x17\x91\xb7K\xb0˰+e5\xd7U\x9c\xbb\x06\xbb\x0e\xbb\x01\xbb\t\xbb\x05\xbb\r\xbb\x03\xbb\xcbR\xbeG\xde'\x1f\x90\x0f\xc9G\xe4c\xf2\xa5w8/'_!_%_#\xf3\xc8|\xb2\x80\x8c\x93=\xc9^do\xb2\x0fٗ\xecG\xf6'\a\x90\x03\xc9A\xe4\a\xe4\x87\xe4`r\b9\x94\x1cF\x0e'G\x90#\xc9Q\xe4h\xf2#\xf2c\xf2\x13\xf2S\xf23\xf2s\xf2\v\xf2K\xf2+\xf2k\xf2\x1b\xf2[\xf2;\xf2{\xf2\a\xf2G\xf2'\xf2g\xf2\x17\xf2W\xf27\xf2w\xf2\x0f\xf2Or\f9\x96\xfc\x8b\x1cG\x8e''\x90\u007f\x93\x13\xc9\u007f\xc8I\xe4dr\n9\x95\x9cFN'g\x903\xc9Y\xe4lr\x0e\xf9/9\x97\x9cG\xce'\x17\x90\v\xc9E\xe4br\t\xb9\x94\\F.'W\x90+\xc9U\xe4jr\r\xb9\x96\\G\xae'7\x90\x1b\xc9M\xe4fr\v\xb9\x95\xdcFn'w\x90;\xc9]\xe4nr\x0f\xb9\x97\xdcG\xee'\x0f\x90\a\xc9C\xe4a\xf2\by\x94<F\x1e'O\x90'\xc9S\xe4i\xf2\fy\x96<G\x9e'/\x90\x17\xc9K\xe4e\xf2\ny\x95\xbcF^'o\x907\xc9[\xe4m\xf2\x0ey\x97\xbcG\xde'\x1f\x90\x0f\xc9G\xe4c\xf2\x89r\x9cy\x90\x9d\xc9i\xe4\x12r)\xb9\x8c\\N\xae W\x92\xab\xc8\xd5\xe4\x1ar-\xb9\x8e\\On 7\x92\x9b\xc8\xcd\xe4\x16r+\xb9\x8d\xdcN\xee w\x92\xbb\xc8\xdd\xe4\x1er/\xb9\x8f\xdcO\x1e \x0f\x92\x87\xc8\xc3\xe4\x11\xf2(y\x8c<N\x9e O\x92\xa7\xc8\xd3\xe4\x19\xf2,y\x8e<O^ /\x92\x97\xc8\xcb\xe4\x15\xf2*y\x8d\xbcN\xde o\x92\xb7\xc8\xdb\xe4\x1d\xf2.y\x8f\xbcO> \x1f\x92\x8f\xc8\xc7\xe4\x13\x16M\xd7,Z\xd8d\xd1lf\x8b\xd6%\xc1\xa2\x95K\xb4h\u074bX\xb4Ԣ\x16-\xbb\x98E{\xaf\xb8EK/aѢOZ\xb4\xaeOY\xb4*O[\xb4\x9cg,Z\xfe\xb3\x16\xad\xc7s\x16\xad\xf4\xf3\x16-\xf2\x82E\xb3\xbfhѲ^\xb2h5_\xb6h\xb1W,Z\xf5W-Z\xdek\x16\xad\xe3\xeb\x16-\xe3\r\x8b\xd6\xedM\x8b\x96\xf9\x96E\xab\xfb\xb6E\xcb-i\xd1\nJY\xb4\xf7u\x8bV1ɢ\x95/mѪ\x95\xb1h\xb5\x93-Z\xa5\xb2\x16-\xfe\x8eEs\x94\xb3h=-\x16\xadr\x8aE+[ޢ\xb5\xaf`ђ+Z0C\xb2h\xbd+[\xb4\xa4*\x16\xed\x1d\xabE\xabe\xb3h\xef\xa6Z\xb4\xaav\x8b֡\xaaE\xb3V\xb3h}\xab[\xb4\x1a5,\x9a\xc5a\xd1:մh\xf5\u07b5h\xbdjY\xb4Pm\x8bV\xa6\x8eE\xebSע\xa5Գhu\u07b3$\xb4Ϩ\x11\xaaoIl\x9fa\xab\x11j\xa04\xb5F\xa8\xa1\xa5\b\x8e\x11h\xa4N\xd8k\x84\x1a\xf3\x04\x02MT \x15\x81\xa6\x96\xa2\xea\x16\x84\x9a\xa9{\xaa\xd6\b5\xe7=\b\xb4\xe0=\b\xb4\x94{\x10j\xa5N\xd9\x11H\xe3)\x15r\xaaP\xaa\n\xb9,\xc5\x18\x15\x82n\x15W\xb5\x1a!\x0f\xe3B\xc0˸\x10\xf0I\\\b\xf9\x19\x17\x02\x01\x89\v\xa1\xa0ąPk#.\x04ۨ\xfb\xaa\"Ж\xf7\xa9P;ާB\xed\xe5>\x15\xec\xa0N\xdaU(ē\fvT\xc1T\x06;Y\x8aK\xf2\x10\xee\xac\xd2W\xbdF(\xcc\xf4!Ѕ\xe9C ]҇P\x06Ӈ@D҇PWI\x1fB\x99F\xfa\x10\xccb\xfa\x10\x88J\xfa\x10\xea&\xe9C\xa8\xbb\x91>\x04\xb3%}\b\xe5\x18\xe9C0\xd7H\x1f\x82\xb1\xc2\xf4!\xdcC\xc5Y\r\x81\xf7\x19\xa7\n\xe51N\x15ʗ8U\xb0\x80q\xaaP\\\xe2T\xc1\x9e\x12\xa7\n\xf62\xe2T\xe1\xde\xeaު*ԇ\xf72ؗ\xf72\xd8O\xeee\xb8\xbf:mgp\x00OKx\xa0\n\xa7Jx\x90\xa5\x84Q\x9c8\xf8@\xf9\x9f#\xf4!\xfd\xcf\x11\x1aL\xffs\x84\x86\x88\xff9BC\xe9\u007f\x8e\xd00\xf1?Gh\xb8\xf8\x9f#4\xc2\xf0?Gh$\xfd\xcf\x11\x1a%\xfe\xe7\b\x8d\x16\xffs\x84>2\xfc\xcf\x11\xfaX\xfc\xcf\x11\xfa\xc4\xf0?G\xe8S\xc3\xff\x1c\xa1\xcf\n\xfd\xcf\x11\xfa\x9c\xfe\xe7\b}!\xfe\xe7\b})\xfe\xe7\b}e\xf8\x9f#\xf4\xb5\xf8\x9f#\xf4\x8d\xe1\u007f\x8eз\x86\xff9B\xdf\x15\xfa\x9f#\xf4\xbd\xf8\x9f#\xf4\x83\xe1\u007f\x8eЏ\x86\xff9B?\x15\xfa\x9f#\xf4\xb3\xe1\u007f\x8e\xd0/\x85\xfe\xe7\b\xfdZ\xe8\u007f\x8e\xd0o\xff\xf9\x9f#\xf4;\xfd\xcf\x11\xfaC\xfc\xcf\x11\xfaS\xfc\xcf\x11\x1ac\xf8\x9f#4V\xfc\xcf\x11\xfa\xcb\xf0?Gh\x9c\xe1\u007f\x8e\xd0\xf8B\xffs\x84&\x88\xff9B\u007f\x1b\xfe\xe7\bM4\xfc\xcf\x11\xfa\xa7\xd0\xff\x1c\xa1I\x86\xff9B\x93\v\xfd\xcf\x11\x9aR\xe8\u007f\x8e\xd0\xd4\xff\xfc\xcf\x11\x9a&\xfe\xe7\bM7\xfc\xcf\x11\x9aa\xf8\x9f#4\xb3\xd0\xff\x1c\xa1Y\x86\xff9B\xb3\v\xfd\xcf\x11\x9aS\xe8\u007f\x8eп\xff\xf9\x9f#4\xd7\xf0?Gh^\xa1\xff9B\xf3\v\xfd\xcf\x11Z\xf0\x9f\xff9B\v\v\xfd\xcf\x11Z\xf4\x9f\xff9B\x8b\xff\xf3?Gh\xc9\xff\xfb\x9f#\xb4T\x95g\rGh\x19\xcb\x13\x81\xe5,O\x04VHy\"\xb4\x92\xe5\x89\xc0*)O\x84VKy\"\xb4\xc6(O\x04ײ<\x11X'\xe5\x89\xd0z)O\x846\x18\xe5\x89\xe0F)O\x846\x19\xe5\x89\xe0f\xa3<\x11\xdcRX\x9e\boey\"\xb0M\xca\x13\xa1\xedR\x9e\b\xed0\xca\x13\xc1\x9dR\x9e\b\xed2\xca\x13\xc1\xddFy\"\xb8\xa7\xb0<\x11\xde+\xe5\x89\xd0>\xa3<\x11\xdco\x94'\x82\a\n\xcb\x13\xe1\x83Fy\"x\xa8\xb0<\x11>\\X\x9e\b\x1f\xf9\xaf<qpT\xa5\xb7:\x02ǘ^\x15:\xce\xf4\xaa\xd0\tI\xaf\n\x9edzU蔤W\x05OKzU\xf0\x8c\x91^\x15>\xcb\xf4\xaa\xd09I\xaf\n\x9e\x97\xf4\xaa\xe0\x05#\xbd*|Qҫ\x82\x97\x8c\xf4\xaa\xf0e#\xbd*|\xa50\xbd\xeaઊ\xbb\x9a\n]c\xdc\f^g\xdc\fސ\xb8\x19\xbeɸ\x19\xbc%q3|[\xe2f\xf8\x8e\x117\x0f\xee\xaa\xfb\xab2x\x8f\xf7K\xf8>\xef\x97\xf0\x03\xb9_\x0e\x1e\xaa\vv\t?\xe2\x05\xe3\xe0\xb1:H5\x0e\xfegy\xf2\xbf\xee\xd3\x11\xea\\Qk\x15\xae\xa8ew\x81\xa6W\xd4\xdc\x19\x155o\xa4\xa2\x16\xeeZQ+Ȭ\xa85˪\xa8eE+j-\xbbUԺw\xaf\xa8\xb5ˮ\xa8\xf5ͭ\xa8\xa5\xc5*j\xf5\x9f\xa8\xcc\xefA\xa4\x894\x93\td\"Y\x84,J\x16#\x8b\x93%\xc8'ɧȧ\xc9g\xc8g\xc9\xe7\xc8\xe7\xc9\x17\xc8\x17ɗȗ\xc9W\xc8W\xc9\xd7\xc8\xd7\xc97\xc87ɷȷɒd)R'\x93\xc8\xd2d\x192\x99,K\xbeC\x96#-d\nY\x9e\xac@V$+\x91\x95\xc9*\xa4\x95\xb4\x91\xa9\xa4\x9d\xacJV#\xab\x935H\aY\x93|\x97\xacE\xd6&\xeb\x90u\xc9z\xe4{d}\xb2\x01ِlD6&\x9b\x90M\xc9fds\xb2\x05ْlE\xa6\x91N\xd2E\xbaI\x0f\xe9%}\xa4\x9f\f\x90A\xb25نlK\xb6#ۓ\x1d\xc8\x10ّ\xecDv&\xc3d\x172\x9d\xcc #dW2\x93\xcc\"\xa3d7\xb2;\x99M搹d\x8c\xecA\xbeO\xe6\x91\xf9d\x01\x19'{\x92\xbd\xc8\xded\x1f\xb2/ُ\xecO\x0e \a\x92\x83\xc8\x0f*'(/\xfaPd\xb0\xc8\x10\x91\xa1\"\xc3D\x86\x8b\x8c\x10\x19)2Jd\xb4\xc8G\"\x1f\x8b|\"\xf2\xa9\xc8g\"\x9f\x8b|!\xf2\xa5\xc8W\"_\x8b|#\xf2\xad\xc8w\"ߋ\xfc \xf2#\xd3\xfe\x93\x1c\xfc,\xf2\x8bȯ\"\xbf\x89\xfc.\xf2\x87ȟ\"cDƊ\xfc%2Nd\xbc\xc8\x04\x91\xbfE&\x8a\xfc#2Id\xb2\xc8\x14\x91\xa9\"\xd3D\xa6\x8b\xcc\x10\x99)2Kd\xb6\xc8\x1c\x91\u007fE\xe6\x8a\xcc\x13\x99/\xb2@d\xa1\xc8\"\x91\xc5\"KD\x96\x8a,\x13Y.\xb2Bd\xa5\xc8*\x91\xd5\"kD֊\xac\x13Y/\xb2Ad\xa3\xc8&\x91\xcd\"[D\xb6\x8al\x13\xd9.\xb2Cd\xa7\xc8.\x91\xdd\"{D\xf6\x8a\xec\x13\xd9/r@\xe4\xa0\xc8!\x91\xc3\"GD\x8e\x8a\x1c\x139.rB\xe4\xa4\xc8)\x91\xd3\"gDΊ\x9c\x139/rA\xe4\xa2\xc8%\x91\xcb\"WD\xae\x8a\\\x13\xb9.rC\xe4&\x9d\xee\x16y\x9b\xbcC\xde%\xef\x91\xf7\xc9\a\xe4C\xf2\x11\xf9\x98|\xa2\n#\xd2DL\"f\x91\x04\x91D\x91\"\"EE\x8a\x89\x14\x17)!\xf2\xa4\xc8S\"O\x8b<#\xf2\xac\xc8s\"ϋ\xbc \xf2\xa2\xc8K\"/\x8b\xbc\"\xf2\xaa\xc8k\"\xaf\x8b\xbc!\xf2\xa6\xc8[\"o\x8b\x94\x14)%\xa2\x8b$\x89\x94\x16)#\x92,RV\xe4\x1d\x91r\"\x16\x91\x14\x91\xf2\"\x15D*\x8aT\x12\xa9,RE\xc4*b\x13I\x15\xb1\x8bT\x15\xa9&R]\xa4\x86\x88C\xa4\xa6Ȼ\"\xb5Dj\x8b\xd4\x11\xa9+RO\xe4=\x91\xfa\"\rD\x1a\x8a4\x12i,\xd2D\xa4\xa9H3\x91\xe6\"-DZ\x8a\xb4\x12I\x13q\x8a\xb8D\xdc\"\x1e\x11\xaf\x88O\xc4/\x12\x10\t\x8a\xb4\x16i#\xd2V\xa4\x9dH{\x91\x0e\"!\x91\x8e\"\x9dD:\x8b\x84E\xba\x88\xa4\x8bd\x88DD\xba\x8ad\x8ad\x89DE\xba\x89t\x17\xc9\x16\xc9\x11\xc9\x15\x89\x89\xf4\x10y_$O$_\xa4@$.\xd2S\xa4\x97Ho\x91>\"}E\xfa\x89\xf4\x17\x19 2Pd\x90\xc8\a\"\x1f\x8a\f\x16\x19\"2Td\x98\xc8p\x91\x11\"#EF\x89\x8c\x16\xf9H\xe4c\x91OD>\x15\xf9L\xe4s\x91/D\xbe\x14\xf9J\xe4k\x91oD\xbe\x15\xf9N\xe4{\x91\x1fD~\x14\xf9I\xe4g\x91_D~\x15\xf9M\xe4w\x91?D\xfe\x14\x19#2V\xe4/\x91q\"\xe3E&\x88\xfc-2Q\xe4\x1f\x91I\"\x93E\xa6\x88L\x15\x99&2]d\x86\xc8L\x91Y\"\xb3E\xe6\x88\xfc+2Wd\x9e\xc8|\x91\x05\"\vE\x16\x89,\x16Y\"\xb2Td\x99\xc8r\x91\x15\"+EV\x89\xac\x16Y#\xb2Vd\x9d\xc8z\x91\r\"\x1bE6\x89l\x16\xd9\"\xb2Ud\x9b\xc8v\x91\x1d\";Ev\x89\xec\xae\u008dcr/\xb9\x8f\xdcO\x1e \x0f\x92\x87\xc8\xc3\xe4\x11\xf2(y\x8c<N\x9e O\x92\xa7\xc8\xd3\xe4\x19\xf2,y\x8e<O^ /\x92\x97\xc8\xcb\xe4\x15\xf2\xaa$\xf1\x9a\xc8u\x91\x1b\"7En\x89\xdc\x16\xb9#rW\xe4\x9e\xc8}\x91\a\"\x0f\x19\xf3#\xf21\xf9\x84U\xd35\xab\xa9\xa2n\xb2\x9a*\xebf\xabV:\xc1\x9aؾEs_(\x11\xe1\"V\xadJQ\xabf-f\xd5j\x17\xb7\x9a\xea\xea%\xac\xa6ڵ\x9f\xb4\x9a\xeb\xd6՟\xb2jퟶ\x9a0xY\xb5~\xcfZM\x03\xf4符\xf6\x96\xe7\xad\xe6\x14\fZV\xed\xbd\x17\xad\xa66\xfaK\xb8\xebeu\xd7+\xb8\xd8\xfeU\xab9\x84q\xcaj\xb2X^\xc7})\xfa\x1b\xea\xec\x9b<\xfb\x96\xd54P\u007f\xdbj\xeaܹ\xa4\xd5T\xae\\)$\xaa\xa2\x8eh\x92\xac\x9a\xad\xb4UK-c\xd5\xec\xc9V\xadjY\xabV\xed\x1d\xabV\xbd\x9cU\xaba\xb1j\x8e\x14\xabV\xd3j\xd5\x06ڬZ\x85T\x98\x1dV\x15V\x1d\xcfְ\xf2\xff\xed\xe1\xb0&T\xb0Y+Ԅ\xa4Z+\xbc\v\xb1[+Բr\x81C\xd6!\xdf#\xeb[\xb5p\x03XC\xab\x16m\x04kl\xd5\xe2M`M\xadZ\xa4\x19\xac\xb9U\x8b\xb5\x80\xb5\xb4\x9a\xba\x87[YM\x99\xe14\x84\xa2N\x84\xa2.\x84\xe2n\x84\xe2\x1e\x84\"^\x84\">\x84b~\x84b\x01\xab)?\x1c\xb4\x9a\xfa\x86[[\xd5\xff\v\xad\r\x82Ѷ8\x19o\x87P\xbc=B\x91\x0e\bEB\b\xc5:\"\x14\xebd5\x15\x84;[M\x19\xe1\xb0U\xfd\xffκ \x18M\xb7\xaa\xffqZ\x06\x19\xc1\x89xW\xdc\x15\xc9D(\x92\x85P,\x8aP\xac\x9bՔ\x1b\xee\x0eD\xb3\x81x\x0e\x10\xc9\x05b1\xab)+\xdc\xc3j\xea\x12~\xdfj\xea\x11\xce\xc3a4\x1f\x87\xd1\x02\x1cF\xe38\x8c\xf7\xc4a\xbc\x17\x0e\xe3\xbdq\x18\xe9\x83\xc3H_\x1cF\xfa\xe10\xd6\x1f\x87\xb1\x018\x8c\r\xb4\x9ar\u0083\x80\xe8\a@\xfcC 2\x18\x88\r\xb1\x9a\xfa\x84\x87*\f\x03\xe2\xc3\x15F\x00\xb1\x91\n\xa3\xac\xa6\xbc\xf0h \xfa\x11\x10\xff\x18\x88|\x02\xc4>\xb5\x9az\x85?S\xf8\x1c\x88~\x01D\xbe\x04b_Y\xb5ܯ\xad\xa6\x9e\xf1oXEߒߑߓ\xbf\xc0Y\u007f\x85\xfdƣ\xdf\xc9?P\x89\u007f\xc2Ơ\x12\xc7\xc2\xfeB%\x8e\x83\x8dG%N\x80\xfd\x8dJ\x9c\b\xfbGU\xe4$U\x91\x93UENQ\x159UU\xe44U\x91\xd3UE\xceP\x159SU\xe4,U\x91\xb3UE\xceQ\x15\xf9/+r\xae\xaa\xc8y\xaa\"竊\\\xa0*r\xa1\xaa\xc8E\xaa\"\x17\xab\x8a\\\xa2*r\xa9\xaa\xc8e\xac\xc8\xe5\xaa\"W\xb0\nW\x92\xabTE\xaeV\x15\xb9FU\xe4ZU\x91\xebTE\xaeW\x15\xb9AU\xe4FU\x91\x9bTEnV\x15\xb9EU\xe4VU\x91\xdbTEnW\x15\xb9CU\xe4NU\x91\xbbTE\xeeV\x15\xb9GU\xe4^U\x91\xfbTE\xeeW\x15y@U\xe4AU\x91\x87TE\x1eV\x15yDU\xe4QU\x91\xc7TE\x1eW\x15yB\xd5\xe1I\x85S\xaa\x0eO+\x9cQuxVᜪ\xc8\xf3\xaa\"/\xa8\x8a\xbc\xa8*\xf2\x92\xaa\xc8˪\x0e\xaf(\\U\x15yMU\xe4uU\x917P\x917UE\xdeR\x85~[\x95\xed\x1d\x1c\x86\xef\x02\xd1{@\xe4>\x10{\x84\xaa|\f{\xc2\xc6m\x1e\xd2D\x9a\xc9\x042Ѧ5(b\xd3\xdcEmZZ1\x9b֤\xb8MkT¦\xf9\x9f\xb4iΧlZ\xab\xa7mZ\xd3glZ\xcbgmZ\xb3\xe7lZ\x8b\xe7m\x9a\xe7\x05\x9b\xd6\xe6E\x9b\xa9]\xb3\x97l\xa6\x86\xcd^\xb6\x99|\xcd^\xb1i\xdeWmZ\xbb\xd7lZ\xc3\xd7m\x9a\xef\r\x9bV\xffM\x9b\xe6z˦5~\xdbfjܬ\xa4\xcdT\xbfy)\x84\x9a\xeb\b\x05\x92l&W\xa04B\xce28\xe7L\xb6\x99\xeb;\x9b\x96\xb5\x99\x1b;\x9b\xbe\x83\x13\xder6\xad\xb9Ŧ\x05Rl\xa6\xe6\x81\xf26-X\xc1fr6\xadh35uVb\xba+\x93UH+i\xb3i\x99\xa96Sf\xa6\x1dȯj\xd3r\xab\xd9L\xb9ݪ\x03Y5lZ\x86\xc3f\xcaȨi\xd3\xf2\u07b5\x99\xb23k\x019\xb5\x81.u\x80\xfc\xba@A=\xa0\xc7{6S^V}\x9b\x96\xd3\xc0\xa6uih3u\xe9\xd2\b\xc8ol\xd3\xf2\x9b\xd8L\xf9\xf9\xcdlZ\xb7\xe66S\xb7n-lZzK\x9bֽ\x95M+H\xb3i=\x9c6-\xcbe\xd3\xc2n\x9b)\x1c\xf1\xd8P\xdd^\x9b\xfa\xfbo>\x9b)\x12\xf3۴H\xc0\xa6\xfe\xfe[\x10W\"\xadmZ\xac\x8d\rU\xdb֦\xfe\xfe[;\x9b)\x16i\x8f\v\xb1\x0e6-\x1e\xb2\xa9\xbf\xff\xd6\x11\x97#\x9d\x80hg\\\x88\x87\x11K\xbc\vB\xd1t\x9b\x16\x8d S\xb9]\x81\x8cL ?\vh\x17\xb5\xa9\xbf\t\xd6\ry\xc8\xe8nS\u007f\xf7+\x1b\xc1v9\x80'\xd7f\xca\xe9\x12\x03\xf2{\x00\xed\xde\a\x9cy\xc8Uf\x81M\xfd\x9d\xbe\xb8bAO\x9c\xe8\xd6\v(\xe8\r8\xfb\xd8\xd4\xdf\xe2\xeb\x8b,g\xf6\x03r\xfb\x03\x19\x03\x80.\x03\x81n\x83P\xd9\x1f\xc2G\x06\xa3^\xf2\x87\x00\xed\x86\xdaL=\x9c\xc3l\xa6\xac\xac\xe1\xf0\x91\x116\xf9\x03r#m\xc6\x1f\x90\x1be\xe3\x1f\x8c\x1bm3\xfe\xec\xdbG6\xf9\xb3o\x1f\xdb\xf8\xf7\xde>Ae\u007fjS\u007f\xa6\xed3\xd6\xe6\xef6S\x83\xc0\x1fp\xb2\xe6\u007f\xdaL-\x9a\x8fA\xcd\a\xc6\xc23\x1a\xff\xa5\x9c\xc49\x0e\xfe\xe3\x1ao3\xbb\x9c\xce\tp\x11\xef\xdfʁ\x9c\x13m\xe6\xe6N\xe7?\x88\xc6霄\xd3i\x93mfgӦSl\t\xf5q~*\x04\x17\xa6\xc1\xebҦ\xe3\xf9\xb4\x19\xea\xf9\xa63m\t\xb8蜅F0\x1b\x8e?\a\xce\xfe/\x9c}.\x931\x8f\x9cO. \x17\x92\x8b\xc8\xc5\xe4\x12r)\xb9\x8c\\N\xae W\x92\xab\xc8\xd5\xe4\x1ar-\xb9\x8e\\On 7\x92\x9b\xc8\xcd\xe4\x16r+\xb9\x8d\xdcN\xee w\x92\xbb\xc8\xdd\xe4\x1er/\xb9\x8f\xdcO\x1e \x0f\x92\x87\xc8\xc3\xe4\x11\xf2(y\x8c<N\x9e O\x92\xa7\xc8\xd3\xe4\x19\xf2,y\x8e<O^ /\x92\x97\xc8\xcb\xe4\x15\xf2*y\x8d\xbcN\xde o\x92\xb7\xc8\xdb\xe4\x1d\xf2.y\x8f\xbcO> \x1f\x92\x8f\xc8\xc7\xe4\x13\xa9fKf\x8a\x06榘\xc0\x8c\x143\x98\x97\x92\x00\xe6\xa4$\x82]R\x8a\x80\xf9)ESM\x96\x94b\bvK)\x0e\xa6\xa7\x94\x00\xbb\xa7<\t\x16\xa4<\x05\xf6Hy\x1a\xccJy&5\xc1\x92\x19Ny\x16\x92\x1bNy\x0e\x92\x11Ny\x1e\xa2\xfe\x14\x1b$'\x9c\xf2\"\xa4K8\xe5%H~8\xe5e<\x16Ny\x05\a\xdd\xc2)\xafB\xd2\xc3)\xafA\xba\x87S^\x87\x14\x84Sހ\xf4\b\xa7\xbc\t\xc9\n\xa7\xbc\xa5\ue327\xbc\x9d\xcaMm\xb2\x14\xa9\xe3\x82-EO\x82\xa4\xa6\xe8\xa5!\xf6\x14\xbd\f\xa4j\x8a\x9e\f\xa9\x96\xa2\x97\x85TO\xd1߁\xd4H\xd1\xcbA\x1c)\xba\x05R3EOIM\xb4ج)z\xf9\xd4\"\x96\xb6\xf1H\x8a^\x01\x81f\xf1X\x8a^1\xb5\xa8ŗ\x15\x8f\xa6\xe8\x95pOZ<E\xaf\x8cK-\xa2\xb9)z\x15\x9c\xf0\xe3\x84\x15\xea\xc5\r6\\h\x97\x85\x13\xa9*\x96\x18\x02v\x04|Y\x88\xae*bI\x8b\xe6f\xa6\xe8\xd5\xd4C8S\x1d\x97\x1a\x86\xf1T\x8d§\x1c\b\xb4\n\xe3\x955\x11h\xa4.\xbd\x8b{\x9b\xe1J-\x9ch\xa3RU\x1bѴ\x88\x86\xf1\xee:\xb8\xe4\xc1-u\xa1\xed\xa0\xf5\xd4-Q\xdc\xf2\x1eN\xb4\xc0\x89\xfa<\x81\x87\x1b\xa4b\xda\xdc0\xd5T\xb7n#\x96Tc\xb2\tٔlF6'[\x90-\xc9Vd\x1a\xe9$]\xa4\x9b\xf4\x90^\xd2G\xfa\xc9\x00\x19$[\x93mȶd;\xb2=ف\f\x91\x1d\xc9Ndg:f\x98\x8eم\x8e\x99N\xc7̠cF\xe8\x98]阙\xca1\xb3\xe8\x98Q:f7:fw:f6\x1d3\x87\x8e\x99+\x8e\x19\x13\xc7\xec!\x8e\xf9\xbe8f\x9e8f\xbe8f\x818f\x9c\x8e\xd9S\x1c\xb3\x978foq\xcc>\xe2\x98}\xc51\xfb\x89c\xf6g\xca\a\x90\x03\xc9A\xa9\t-\x9b\xfb\xf4\x0f\xc41?\x14\xc7\x1c,\x8e9D\x1cs\xa88\xe60q\xcc\xe1\xe2\x98#\xc41G\x8ac\x8e2\x1cst\xa1c~T\xe8\x98\x1f\xff瘟\x18\x8e\xf9i\xa1c~f8\xe6\xe7\x86c~Q\xe8b_\x16:\xe6W\x85\x8e\xf9\xf5\u007f\x8e\xf9\x8d\xe1\x98\xdf\x16:\xe6w\x85O}_\xe8\x98?\xa8\x17\xe1ʏ8\xe1T^\xf8\x13N8q\xc7ό\x0eW~)|\xc1\xaf*\xa0\xd2\xf2[a,\xbf\xa7\x16\x83C\x86ի\xfe(\xf4\xcd?\v\xbdv\f.\xb6ˊ\xa8\x8bc\x11\xf4e\xf1\xbe\xbfx6\xa6\x82\xe3xg8E\x1f\xaf\xe2S\xf9\x9fP\xf8\xaa\xbf\x91\x88\xb6x\xf7Dd\xa5\x1do\xfe\xa7\xb0\xbdL\xfa\xaf\xbdL6\xda\xcb\x14\xa3\xbdL-|\xf34\xf54t:+m\x069\x93\x9cE\xce&\xe7\x90\xff\x92s\xc9y\xe4|r\x01\xb9\x90\\D.&\x97\x90KSM\xb6\xb4e\xa9\xa6Դ\xe5\xa9&{ڊTSմ\x95\xa9\xa6ji\xabRM\xd5\xd3V\xa7\x9aj\xa4\xadI59\xd2֦\x9aj\xa6\xadK5۬i\xebA[\xda\x0605m##\xd9Dn&\xb7\x90[S\xb5\xf0\xb6T-\xba=U\x8b\xef\x80\xedL\xd5b\xbbR1\xb3\xdd\rD\xf7\x00\xf1\xbd@d\x1f\x10۟\x8aU\xc3\x01 z\x10\x88\x1f\x02\"\x87\x81ؑT\xac\r\x8e\x02\xd1c@\xfc8\x109\x01\xc4N\xa6b\xea\u007f\n\x88\x9e\x06\xe2g\x80\xc8Y v.\x15S\xff\xf3@\xf4\x02\x10\xbf\bD.\x01\xb1˩\x98\xc8_\x01\xa2W\x81\xf85 r\x1d\x88\xddHŤ\xee&\x10\xbf\x05\xc4n\xa7b\xe6~\a\x88\xde\x05\xe2\xf7\x80\xc8} \xf6 \x153\xbb\x87@\xf4\x11\x10y\fĞ\xb0\x17\x0fc\xa1X\x90\x13\xc9-\xd0\xec\x89\xe1\xec\x1eYa\x93\xbdH8\xa7G$/b\xb6\x9b\xc3y\x91\x04{\x91hn.|8ў\x10\xcdM\xcf*b7\xf7\x8a\xe5\x16\xb5\x17\x89\xe4\xa7\xc73b\xc5\xec\t\xe1\xf4\xbcHq{b,\x9e\x9b\x1e)a7Dzr\x9e\xb4\x17\xe9\x1e\x8eVʋ>eOL\x0f\xe7\x85\v\x9e\xb6\x17M\x0fg\xc7\xf2\xa2\x91g\xecE2\xc3\xd9ٱ\xdcg퉙\u171c\xf0s\xf6\x84\xcchf\xf8y\x9c\x8fGs#\xe1\x17\xf0H\x1c7\xbeh/\x8a\x13\xd9\x19\x91\xbc\x97\xec\tݣٱ\x97\xedŔd\xe6\x85s^\xb1\x17W\xc1\x9cHA$\xefU9\xdd+\\P\xf0\x1a\xa2\xc2\xd5\xd7\xedŔ\xe8\x05\xb1\xdc7\xec\xc5\xd2\xf3\xe2}#Ѽ؛\xf6\xc4\xeey\xb1\xdc\xc8[\xf6\x84\xf4p~\xe4m$1\x96\x17\xcf\r\x97\xc4\xfbb\x95b=JA\xfb\xa4gGt$\x15\xa5\x11͉$ًa\x05\x98\x9d\x8d\xbc\x97\xc6Eu\xb2\f\x1e\x86&\xdb\x133b}#\xb9e\xed\t\x19\x91\xfc\xe8;\xf6\"\x19\xb1\xec\xecp^9\xbb\x19/\xb5\xd8\x13rù\xb1\x14$;7VP\xde^4+\x12\xcd\xcc*ȯ`/\x8abU\xcfW\xb4'\xaaRϯd/\xd2%\x9c\x97\x17ɮ\x8cK\xd1p>\xb2S\x05\x97\xa2\xe9\xf1l\xab=\x01\x1a\xb3ًuQ\xa5\x804\xa4\xda\x13\xbb\xa2,3\xec\xf6\x84\xae\x91HAU<\x1b\xcfϊdW\xc3\xf9\xbcpnzu\xf5\xa2\xf4\x02TY\r<\x1bɏ9\x10i\xd7\b\xea.\xb3\xa6=1+\x92W\xd0\xf7]D\x1eA-\xd5\xc2\r\xe1\xccHm{B\x97HA\xb8\x0e\xceƢ\xb9\x05u\xed\t=cXo\xd8\xcd\xe8\x14\xdeS'\xe3\xb9\x19\xf5\xed\tY\xa8\xaf\x06\x90X^nC{bN4=/\xd6Ȟ\x90\x13͎4\x86\x84ӳ\x9a(\xc9\xeb\xde\xd4^4'\x9c\x9b\x1f\x8d\xe56\xb3\x17\xe1m\xb9\xcd\xd5\xfd(\xc1\x16\xf6bT\xe4\xb6%n\x8ed\x86[\xe1f\b\x8a+\r\xf7\xa8\x8at\xda\x13\xfa\x84\xf32\\\"nH<\x9c\xeb\xb1'fGq\xd1kOȎ\xe6\x85}\xf6ļx\x8fHį\xb4Kv$`7\xe7Er\x82\xf6by1\x14kf$\xb7\xb5=AyB\x1b\xbbɚ\xd5\xd6n\xb2e\xb5\xb3\x9bR\xb3\xda\xdbM\xf6\xac\x0evSլ\x90\xddT-\xab\xa3\xddT=\xab\x93\xddT#\xab\xb3\xdd\xe4\xc8\n\xdbM5\xb3\xba\xd8\xd13d\xa5\x83\xb6\xac\f05+\x02ڳ\xba\x82U\xb32\xc1jYY`\xf5\xac(X#\xab\x1b\xe8\xc8\xea\x0e\xd6\xccʶ\x9bS\xadY9\xa0-+\x17L͊\x81\xf6\xac\x1e`լ\xf7\xed\xe6f\xee\xfayvSF8ߎEf\x81\u074cb\x88\xdbM\xb1`O\xbb\xa9Gz/;?\x13\x93}Ⱦd?{\x91f\x91h~$\xda\xdf^\xc4\xd7'\x16\xef\x15\x1e`/\xea\x0fG\xf3\x11\x1ehOL\x8bD\xbbE\a\xd9\x13\x9a\xe7\xa6W\xfe\x00\xf1\xd4\xff\xd0nʭ?X\x154J\x1e-x\x88ݔS\u007f\xa8\xddԽ\xfe0\xa0\xc1p\xbb)\xad\xc1\b\xbb\xa9i\x83\x91v3\x1a\xe3(\xb8'd4\x1em\xf2\x11\x1em\xf2\xb1\xbd\x04\x1fm\xa2\x9c\xec\x13{q\x1e\xa8\x86\xf4)\"\xca\xfc\fqd~n75\xeb\xfb\x85\xddܽY\xdf/\xed\xe6\xb4f}\xbf\xb2\x9b\x9b6\xeb\xfb\xb5\xdd\xeco\xd6\xf7\x1b\xe3y\xd6\u05f7x&\xfb;\xe49\xfb{<\x98\xfd\x83\xdd\xd45\xe7G\xbc%\xe7'\xe3.V\xf9ϸ+\xe7\x17\xbb)=\xe7Wܕ\xf3\x1b\\#\xa7c\xea\xefhd\x90?\xecf\xf0O$\x132\x86\x97\xaa\x8e\xe5%\xfb_\xea\x92}\x1c/\xd9\xc7\xe3\xa0J\xfe\x04xQ\x95\xfc\x8e\xa9\u007f\xdbM\xee\xf0D$\xd1\x1d\xfe\aIt\x87'!\x89\xee\xf0d8J8c\n\xdc&\x9cQ%\u007f\xaa\xbd(\xb5c\xea4d?\u007f:\x12\x96?\xc3\xfe$\x13\x96\x1fI\x8f\xe5f\xccD\xca\xf2g\xe1bp6.\x06\xe7\x18š\xdaǿ\xb8\x14\x9c\x8b\xf4\x06\xe7\xa1H\x83\xf3qS\xeb\x05\xb8\xa9\xf5B\xe3&個pS\xebŸ\xa9\xf5\x12\xdc\xd4z)\x92\xea\xca\xcaYfOH\x83,G\x9fY9\xa7\xf2\n\xbb\xa9\xc1\xfb+\x91\xfb\xf4U@\xc6j{B\xc3*\xdd3\xd7\xd8\xcd\rc\x95ע\xe8\x1a\xacCm\xf5Yoǀ\xb0\x01\x05\xef\xdeh7Es7\xd9\x13ZVnYy\xb3\xdd\xd42m\v\xe2/\xd8j7e\xe7l\x03r\xb7\xdb\xcd\xe8\x1ew \xd8{'^\xdfe\x97]\xfd_\x8bv\x83\xb1\xec=He\xb3\xbdh\xf6x\xef>\xbb\xd9\xedNۏ\x82\xf2\x1e\xb0\x9b\xf2\xf3\x0e\xdaM\xbe\x9e\x87\xec\xa6\xd6]\x0e\xd3\xf1\x8e\x90G\xd1z2\x8e\xa1\xf5d\x1cG\xeb\xc98\x81֓q\x12\xad'\xe3\x14ZO\xc6i\xb4\x9e\x8c3h=\x19g\xd1z2Ω֓q^\xb5\x9e\x8c\v\xaa\xf5d\\T\xad'\xe3\x92j=\x19\x97U\xebɸ\xa2ZO\xc6U\xd5z2\xae\xa9֓q]\xb5\x9e\x8c\x1b\xaa\xf5d\xdcT\xad'\xe3\x96j=\x19\xb7U\xebɸ\xa3ZO\xc6]\xb0Z\xc6=\xb0z\xc6}\xb0F\xc6\x03Б\xf1\x10\xac\x99\xf1\xc8n\xb6[3\x1e\x83\xb6\x8c'\xd2\xe4[\xae\x88I\xc4,\x92 \x92(RD\xa4\xa8H1\x91\xe2\"%D\x9e\x14yJ\xe4i\x91gD\x9e\x15yN\xe4y\x91\x17D^\x14yI\xe4e\x91WD^\x15yM\xe4u\x917D\xde\x14yK\xe4m\x91\x92\"\xa5Dt\x91$\x91\xd2\"eD\x92Eʊ\xbc#RN\xc4\"\x92\"R^\xa4\x82HE\x91J\"\x95E\xaa\x88XEl\"\xa9\"v\x91\xaa\"\xd5D\xaa\x8b\xd4\x10q\x88\xd4\x14yW\xa4\x96Hm\x91:\"uEꉼ'R_\xa4\x81HC\x91F\"\x8dE\x9a\x884\x15i&\xd2\\\xa4\x85HK\x91V\"i\"N\x11\x97\x88[\xc4#\xe2\x15\xf1\x89\xf8E\x02\"A\x91\xd6\"mDڊ\xb4\x13i/\xd2A$$\xd2Q\xa4\x93Hg\x91\xb0H\x17\x91t\x91\f\x91\x88HW\x91L\x91,\x91\xa8H7\x91\xee\"\xd9\"9\"\xb9\"1\x91\x1e\"\xef\x8b\xe4\x89\xe4\x8b\x14\x88\xc4Ez\x8a\xf4\x12\xe9-\xd2G\xa4\xafH?\x91\xfe\"\x03D\x06\x8a\f\x12\xf9@\xe4C\x91\xc1\"CD\x86\x8a\f\x13\x19.2Bd\xa4\xc8(\x91\xd1\"\x1f\x89|,\xf2\x89ȧ\"\x9f\x89|.\xf2\x85ȗ\"_\x89|-\xf2\x8dȷ\"߉|/\xf2\x83ȏ\"?\x89\xfc,\xf2\x8bȯ\"\xbf\x89\xfc.\xf2\x87ȟ\"cDƊ\xfc%2Nd\xbc\xc8\x04\x91\xbfE&\x8a\xfc#2Id\xb2\xc8\x14\x91\xa9\"\xd3D\xa6\x8b\xcc\x10\x99)2Kd\xb6Ȝ4.\x9fȹ\xe4<r>\xb9\x80\\H.\"\x17\x93Kȥ\xe42r9\xb9\x82\\I\xae\"W\x93kȵ\xe4:r=\xb9\x81\xdcHn\"7\x93[ȭ\xe46r;\xb9\x83\xdcI\xee\"w\x93{Ƚ\xe4>r?y\x80<H\x1e\"\x0f\x93Gȣ\xe41\xf28y\x82<I\x9e\"O\x93gȳ\xe49\xf2<y\x81\xbcH^\"/\x93Wȫ\xe45\xf2:y\x83\xbcI\xde\"o\x93wȻ\xe4=\xf2>\xf9\x80|H>\"\x1f\x93O8e\xbcr&6\xc2\xec^79\x13Z\x86c\xba\xd9i\xf6D\xf5\x04g\x11.\xd2\xf5Dg\x02\xd6\xe5z\x11\xb9\xb7\xa8Ӝ\x16Ӌ9\x8b\xb4\xe3\xc5\xe2\xce\x04_8W/Qx\xf3\x93r\xf3SNs\x8b\xa8\xfe\xb4\xd3\xdc \xae?\xe34\xb7\x8d\xeb\xcf:\x13ӰNןs&4\rG\xf5睉\r\xb3bq\xfd\x05C_T\x11b\xb2\xad\xbf\xe4L\xf0D#\xfa\xcbN\xb3;\xaa\xbf\x82س\xa2\xfa\xab\"\xaf\xa9Kq\xfdugb\x03\x95\xda7\x10oD\u007f\x13\x11\xc4p\xf4\x16\xf2\xa0\xf4m\xa7\xd9\x17\xd5K:\x8b4T\x9b\rz)gB#<\xa3ˣI\xce\"\xad\xd4\x06\x85^ZN\x97q&\xb4\xc5˓\vO\x97\xc51\xd2\xf0\x8e\xf1\x86r\xceD\x9f:mA\x9a\xe3\xb9z\x8a3\xa1\x05\x1e*\xef47\x8d\xe8\x15\xf0\xf6\xb0^\xd1Y\xc4\xc3'+\xa9\xf4\xab\xf7WfΫ\xa8[#\xbaՙ\xd8D\xa5\xc2\xe6Ll\xaa2\x97\xaa\x92\xa5\x02v\x95mhUgB\xabh\xae^͙\x88\xdc\xc7\xf4\xea\xce\x04\xa8^\xc3in\x16\xd6\x1d΄ָ\xa5&\x92\ny\x17G\x91\xa8^K\xee\xa8\xedLl\xa1RX\xc7in\x15\xd5\xeb\xe2\x9dq\xbd\x9e3\xc1\x8dw\xbe\xe747\x89\xeb\xf5\x91\xbc\xa8ހl\xe8Lp\xa2\xc8\x1b\xa9:\u009aRo,\xf9h\"\xd2T\xc5\x18ћ\xa9\xac\xc7\xf4\xe6|\xa2\x85\xd4uKu)\xaa\xb7r\x9a[\xc7\xf54u\x10֝H[\\w\xe1%aݍ\xb7GtOaֽ\xceD\xb7J\x94\x0f\xaa\xca\xc4\xefLD\xe1\xc4\xf4\x00\x1f\t\xb2\f\xa2z\xebªiS\x18h\xcbw\xb6C\x02P\x14\xed\xe5\xd5\x1d\x9c\ti\xc8LH\xd2ؑ\x1eى\x15\xde\xd9in\x13\xd5\xc3\xce\"\xdcjһ\x88?\xa5K\x85f8\x13\x9a\x85\xb3\xf5\x88D\xd2U\xf9M\\\xcft&\xfa{ų\xf5,q\xa3(k\xa8\x9b3ѩ\x9e\xef\xae\xde\x10ֳ\xe1\xfa\x91l=Gnɕ\xe7cN\xb3+[\uf064\xe0\r\xef;\x13[\xa9\xaa\xcbs&4\xc4+\xf2\x9dfo\\/\x80\xbb\xc7#z\\\xfc\xa6'\x8b\xbe\x97\x8a#\xac\xf7v\x9a\x9da\xbd\x8fJ^\xae\xde\x17\xe7b\xd9z?\xa7\xb9q\xb6\xde\x1f\x95\xaf\xd23@\xde2Pn\x19\x84x\xf1\xea\x0f\x94\xafE\xf5\x0f\xe5\xe4`\xe3\xa5C\xc4O\x86\xb2\xa4\x86!\xc9x\xe9p\\S\xc5;\x02-2\xac\x8fd+\x1b\xa5\xeaB\x95\xe9h\xc9\xc8G\"\x1f\xe3\xbdy\xfa'\xea\rq\xfdS\xde\xf9\x19\xf99\xf9\x05\x92\x0f\xff\xfe\x92\xf5\xf4\x15\xcb\xfak\xd6\xf97\x86\x9b}\xcbF\xf5\x1d\"CҾG\xd2\"\xb9\xfa\x0f\"?\xb2\x1d\xfc\xa4\x9a}D\xff\x99\a\xbf0\x86_\x19\xfe\x8d\x85\xfd\xbb3\xc1\x8fv\xf6\x873\xb1\xb5*\xf3?\x9d\x89-\x95\x8eq\x9a\xfda}\xacz\t\xf2\U00057abb\xa8>\x8ey\x1co4\x90\t\xce\xc4f*?\u007f#\x93q}\xa2\x94\xd8?\x85\x95?\xc9H\xdfd\u0530\xd2)\x85\ryj\xe1\x1dӌ;\xa6\xd3wf\xa8n W\x9f\x89~)\xa6ϒ\xc6?[\x92>G\x9aٿ,\xd4\\}.\x0e\xd1 \xe7I\xab\x9b\xefL\xf0\"\xaf\vD\x162O\x8b\xe0\xfca}\xb1\x91\xa5%L\xf5R)\xeeer\xdfr6\x8f\x15F\xe7\xba\xd2in\x17\xd1W)w\xcb\xd5W\xa3{\x8b\xebk\x8c\xceo-\xd2\x13\xd6\xd7\x15\xf6\xa9\xeb\xe5\x9e\r҇l4:\xa3M\xceD\xaf*\x89\xcdF\x87\xb7\x05\xce\x16ӷJ\xff\xbb\r\xfe\x81\x1a\u070e\xa3>a}\anQ\x11\xed\xc4+\xa3\xfa.I\xd4n\x16\xf6\x9e\u0097쥯\xees&\xaar\xd2\xf7\x1bz\x00\x15\x85l\x1fD\xa9\xabw\x1cB\xb9*=,\x19:\xc2\x06\x9d\xab\x1f\x15\xe7<\xc6<\x1fw\x9a\x1bE\xf5\x13\xaa\xf8\xa2\xfaIU|x\xe0\x14/\x9df%\xc6\xf43\xaa\xa5\xab\x97\x9e\x85\x1f\x85\xf5sR\x8b\xe7y\xcf\x05V\xecE\xb41\xbc\xe0\x92\xbc粴\xc9+\xc6\xe3W\x9d\x89m\xd5\xd3\u05cc\xd7_/\xecpnp\x90\xb8)\xfd\xe4-z\xecm:S\xae~G\n\xef\xae\xf4j\xf7\x8c~\xf8\xbeQ0\x0f\xe4=\x0f\x8d\xca{\xe4L\xc0e\xfd1s\xf2?ܫN>\xe12ޢ\xb9\x94;\x9b\\\tnx\x82٥\x1aL\x82\vu\x8ax\x13]\xf0\x92\\\xbd\x88\v^\x92\xab\x17u\xa9\f\x15s\xc1\x9fr\xf5\xe2.\xf1\xf1\x12<\xf9\xa4K\xb9\xccS.s}\x8c\x8a.\x95\xd0gx\xe6Y\x97\xaa\x85\xe7\\\xaa7}^=\x88\x11\xd1\xc5\xda\u007fѕ\xd0\x00\xef{\xc9E\xb7|\x99\xf7\xbd\xe2J\xf4\xab8_-L\xdak.\xba\xf0뮄f\xa8\xb57\x94D\xf57\x99ķ\\\t\rq\xf0\xb6\xcb\x18qJ\xba\xe8(\xa5\\th\xbd\xf0t\x12nC\xef_ڥ\x1ak\x19\x97xA\xb2\xcb\x18\xcd˺\x8c\x8a{\xc7E\xff*\xe7\x92\xf2\xb3 \xa9j@\x94\xac\x96\x978+\xb884Ut\xc9z\x0eq\xa9\x17Tv\x99\x9dq\xbd\x8aK\xb58\xab\xcb\xdc4\xae\xdbp&\xaa\xa7\x92v\x17\x1b_Ud\x16\xf7Vs\x99\xdb\xc4\xf5\xea.\xf1\xa1\x1a.\f\x8aȝÕ\xe8C\x9f\xa6\xd7D=\xc4\xf5w]\xaa+\xaa\xe5Jl\xa0*\xb46\x8f\xea\xb8\xe8/u]\xca\x1d\xea\xb1\xc0\xdf\xe3\x85\xfa,\xf0\x06.\xa3Sl\xc8j\xcb\xd5\x1b\xa1\xa0 \x8d]\xec؛H\x117\x95\xe47s\xa99Ks\xbe\xab\x05\xc2Q\xbd\xa5z?*\xbb\x95\xcb\xdc0\xaa\xa7If\x9d.\xe5+.y\xc6\rA\xf9{\xa46\xbc.qW\x9f\xcb\xec\x8f\xea~\x95\vD\x1fp\x99\x9bE\xf4 cl\xedb+k\x83*Aٷe}\xb5c\xb2ۻT\xa3\xee \xf1\x85\\\t-\x11_GW\xa2S\x95G'\x974\xc6\xce,\xb9\xb0Q\xbe]\x98\xd2t\xbcS]ˀo\x85\xf5\x88K\x1aJW\xa9\x8aL\x97\xb9eXϒ\x83\xa8\xf8q7Wb35\x1awg\xb2\xb2Q\xbd\xc8a\x8e\xcb\xe85s]j\x8a\x1332\xd2C\xd5\x0e\x06@zi\x9e+Q}M\xd2\xf3\xa5\xcc\v\\jd\x89\xbb\xa4\x8f\xeaI\xa7\xee\x85\xe2E}\xf5\x16\xaf\xec\xe3\xe2\x80\xd6\x17iR\xe9\xed\x87\\\xa8\xa6\xd3\xdf%\xbd\xfe\x00\x96\xea@\xe6~\x90\x8b=\xd5\a\xca\r\x11ۇF\xc5\x0f\x96\xe2\x1a\x82\xe2@\x04C]\x9c\x94\fsq\xdc\x1f\xaeR\x1e\xd5G\xf0\xf9\x91.\x0e\xa1\xa3pc<\xac\x8fv\x15Q\x93\xaeL\xfd#\x97\x9a$}\xec\xe2\xfc\xe2\x13yǧ.sZT\xffL\xea\xefs\xfa\xdd\x17R}_\xc2gr\xf5\xaf\xf0L\\\xff\x1a\x1e\x82S\xdf0\x93\xdfJ\x1b\xf8Ψ\x86\xef\xd5\xcb\xc2\xfa\x0f\xf2\xce\x1f\xa5E\xfc\xe4Jl\xaa.\xfel\xf8\xee/L\u05ef.5W\xf8\xcd%]\xd3\xef.N\x91\xff\x90\x02\xfc\x13I@\x06\xc6\xf0}cQS\x18\b\x8d\xa2\x19\xa7\"A\xfeǣ\x88\"\xfa\x04\x97̦\xfeFǢjn\xa2K\xf5\x8eQ\xfd\x1f\xc3=&Aի'K\xff1\x85\xbd\xccT\xd4\x01\x921\xcdU\xa4ET]\x9c\xee2\xe6\\3\x8c\xb8g\x8a\xab\xcdr\xc9H4\xdb\xc5\x01r\x0eS\xf3\xafKM+\xe7\xba8\x89\x9a\xe7\x92!v\xbeQ)\v\xa4R\x16\xb2a/ra\x86\x99\xab/V\xed*\xa6/Qހå\xea\x16\x8c\x86\xf4\xef\xe5.5m[\x81\xac\xc4\xf5\x95.Sc}\x95\x8bS\xf2\xd5,\xfb5\xae\"-YWkQ\x02q}\x1d\x13\xbf\x1e9A\x99n`\x19nd\x0f\xb8\t}\x83\xbam\xb3\xcb\xdc.\xaeo1\x8ad++x\x9b\xd1\x06\xb6+\xbf\xcb\xd5w\xb8d\xe4\xdfitj\xbb\xa4\x03\xdc\r\xffG\xa9\xedA\xff\x10\xd7\xf72\xd2}L\xda~Fr\x80g\x0e\xbad&{Hy~L?\xcc\x1c\x1ca\x97rTj\xef\x98t}ǥ\xcf>\xc1\x1bN\xb2\xc1\x9f\x92\x1e\xf5\xb4Q\xa2g\xa4ٝuq\x86x\x0e>\x84\xa7\xcf\xf3]\x17\xc4w/\xca\x1d\x97\f\xf7\xb8,Q^aB\xae\xb2y^cE\\gFb\xfa\r\xc9\xc1M\xe3\xfe[,\xed\x98~\xdb\xc5\xd9\xdd\x1d\x17Ʋ\xa8~\xd7%#\xde=v\xec\xf7\xe9\xd3\x0fdHy\xc8\xc4>\x92\f<f\x87\xf4?#\xae'\xdcF\u007f\xaf\xb9\xe9\xd5&\xb7\xb4k\xb3\x1bN\x9a\xab'\xb89\x9a&\xba9\xb4\x14q3/E\xdd\x1c~\x8b\xb9\x99\x99\xe2n\x19!J\xb8\x13\u0557Z\xfdI\xb7\xeaI\x9er\xcb\xfa\xe7i7S\xf0\x8c[\xf5\x01\xb9\xfa\xb3n\xba\xd6s\"ϻ9\ax\xc1\x8d\xee8\xa6\xbf\xe8N\xf0\xab堛sݗ\x11m\x16\xde\xf9\x8a[\xba\x86W݉n\x95\xbd\xd7\xdc2\"\xbe\ue99f\xbf\xe1V\xae\xf2\xa6[\r\xd8o\xb9Um\xbc\xed\xe6T\xa5\xa4[\x9c\xa1\x94\x9b\xd3\x02\xdd͙lRavK\xcb\xe92n\x19\xfa\x93\xdd\xecbʺ\x13[\xaa<\xbc\x83\x87U\xea\xcb\x19y\xb2\xb8Uu\xa4\xb8\xa5\x93-\xefV\xddq\x057;\x87\x8anY\xc8Urs\x94\xa8\xac\xce\xc6\xf4*\xeeD\x9fz\xd0\xeaNl\xc5堛\x1e\x9a\xea\x96%\xabݭ\xa6iUU\xd9`\ft+\u05ef\xceW\xd4ps\xe1\xe6@yCj\xba\xa5\x92\xdeU\xef\xc0q-\xb7\x9a\xd2֖\xb4\xd6qs\xd1QW%\nQ\xd6s\xcb~\xa6;\xb1\xad:\xac\xef6\x9a}\x03#\x8e\x86n\xbac#w\xa2S嬱ۘP4a9c0t\xb3sj&\xe5\xd2\\r\xd3\u00ad\x1c\xa7\xa5\xe1\x13\xad\xdc\t^\xe4-\x8d\xc5\xec\x94;\\\xa8\x16\x15\xbd[\xa2\xf7\xb8\xc5\t\xbdF-\xf9\x90\xb7\x98\xeew\xa3\xf5\a\xdc\x1c\xf8\x83n6\x96\xd6\xee\">Y\x13\xba\xd9Ƿu\xabѵ\x9d\x9b}S{7;\xda\x0en\xe9\x80B\xe2C\x1d\x99\xfbN\xee\"\xcd\xd8ot\x16\xd7\f\xbbe\xb4\xed\xe2\x96֗.\t\xc9p\xb3k\x8f\x18\xb9\xef\xeaV}N\xa6\x9b\v\xda,\xb7\x1a\x80\xa2n\xd5ܺ\xb9Uk\xe8.E\x9amTw\x8e[v.r\xddjp\x8b\xd1\xc5zH\xf2\xdfw\xb3\xd7\xcfs\xab\x9e!\x1fթ\n\xb3\xc0\xad\xba\xeb\xb8[:؞n\xb3\vkB7\x17@\xbdE\xfaH\x16\xfa\xa2\xde\xc3z?\xb7\xeak\xfbKI\x0f\x90r\x1c\xe8\xe6\x84tP\xa1\u007f~\xe0\x96E!*\x19\x8f\x0f\x96\xf4\rq\xab.l\xa8\x9b\xfd\xd10\xa6\u007f8\xea[%a\x84;ѫ\x92>ҭ\xfa\x99Qn5\xfc\x8cvs\x91\xf7\x11\xa2B\x1c\x1f\xbbբ\xf1\x13ԥ\x8a\xffS\xb7L\x8c>3*\xeas7;\xf2/$Q_\xbaU\xff\xf8\x95[M\x83r\xf5\xaf\r\xbf\xffFZ\xe6\xb7F\x83\xff\xce\xcd\xee\xe7{7{\xd9\x1f$\x87?\xba\xa5\xcb\xfa\xc9-]\xf3\xcfRK\xbfH\xdb\xfeU\xb5\u0098\xfe\x9b[\xa6\x19\xbf\xbb\xd5\xfc\xe2\x0fý\xfe\x14\x0f\x1c\xe3\xe6\xbab\xac\x9b\xa3\xe4_F\xfaƉ{\x8f\xc7[ЇM\x90W\xff\x8dւ\xe8&\xaa֒\xab\xff\x83\xa6\x87\x14L\x92\xbej\xb2\x91\x80)*\x9e\x98>ը\xdaiF72\xddh\xa03\xdc\xe6\xfa1}\xa6ۘ\x1cϢ\xc3\xcf6\xda\xdb\x1cD\x85\x92\xfb\xd7mL\x8e纍\xbd\x9fyF\xe72_:\xcd\x05\xd2\x14\x17\xba9\xc9\\\xe46\x16\\\x8b\x8d\xa6\xb9D\\r)]|\x19\x8bv9]`\x85\x94\xd9J\xb6\xa1\x98\xbe\xca-+E\xb7,H\xd7\xf0\x9e\xb5\xe8#q\xb0Ψ\x83\xf5n\x19\xdb6H\x81n4\x9a\xfb&\xa3c\xd9\xec66ն\xb8\x8d\x89\xddV\xa3\x12\xb7\xb9e\xe4\xdc\xee6&\x06;\xdc\x1c\xabw\xaa&\x87\xb1ҭ\x96\xa7\xbb\x99\xb8=n\xce\r\xf7\x16\xfa\xe2>\xb71\xad\xda\xef\x96\xfd\x87\x03\xecn\x0f❪(\x0f\xb9e\xe1~X<\xf9\b\x1b\xcdQ\xf8\xb3Z0\xba\xb9@9^X\xbe'\x8c\xf6x\xd2\xcd\x19\xf8)\xb7\xcc{N\xbb\xb9\xe9s\x06iU1\x9e\x95\xc6p\xce\xc8\xeby\xf1\xbb\v\xaa\x17\xb9h<qɈ\xe8\xb2[\xe6fW\xdc\xdc.\xb9\xeaV\x93\x93kn\xb5\xea\xb8..s\x83\x8d\xe6\xa6\x11\xd7-\x95}\x95\x97\xdb(W<p\x87\x9d\xca])\xf9{\xe2\x81\xf7\x8d\xa2z\xe0V\xab\x8b\x87F\x97\xf6\xc8-\x13\xbc\xc7n\xb5\xc2\xf8\x9f\xf2\xfa\xa8\xfe\x84G\xf5\r\x9a\x87\xd3\x16\x93G\xe6cf\x8f\x14H\x02/&z\x12\x1b\xa9\x17\x16\xf1\x88\xcf\x14\xf5\xc84\xbe\x98Gfu\xc5=\x92\x93\x12\x1e\xfa\xf4\x93\x1e\x96\xccS\x1e\xc9\xe7\xd3\x1e\xba\xd63\x1e\xb6\x86g=\xf2\x11\xd0\xc3V\xf0\xbcG\x8d\xf1/xT[\u007f\xd1\x03\u007f\xc0\xe2\xd1#\xbd\xe0\xcb\x1e\x99*\xbe\xe2AU\xe6\xea\xafzԈ\xf5\x9a\x87\xb9|\xdd#\xae\xf4\x86'1Me\xecM\x8f\x1a\u007f\xde\xf2Ȥ\xf2m\x0f|\\\xe5\xa2$\x9f)\xe51\x9c@GL\xe8\x19\x92<ld\xa5=\xca7\xcbx\x8c9\\\xb2\x87\xb3\xa6\xb2\x1es\xa3\xb8\xfe\x8eG\xa6'\xe5<\x9cBX<\xec\xbbR<\xaa\xc7,\xefa\xb7\\\xc1\xc3ަ\xa2J%*\xba\x92\xa1\x95=\xaa\xf3\xaa\xe2I\xf4\xabtY=\xf4'\x9b'\xb1\x95JO\xaa\x94\x8f\xdd(ܪ\x9eD\xafzu5\x0f\xa7\x12\xd5=t\xb4\x1a\x8c\xc1\xe1\xe1 \\S\x12\U0002e1fdD-\x8f\xf4$\xb5=l\x8du$#u=\xb2)Xϣ&\xfc\xef\xb1(\xea{\xd8o6\x90\xc7\x1bz\xa4\x87m\xe4A\x8bR\ti\xac\x8a\x84C\xa7Gu\x131\xbdi\xe1\x95f\x1eq\xb2\xe6\x1e\xa3\xc1\xb4@e\"U-=\xe6\x96\x11\xbd\x95\x1c\xa4ydpqz\xcc\xfe\xb8\xee*,_7\x13\xe0\x91{\xbc<\xf0y8a\xf3\xf3\xc6\x00\xcb/(\x89o-\xd2\xc6ÕM[\x91v\x86\xa3\xb57\xea\xb7\x03\xe2BY\x87<lL\x1d=\xe8Gbz'\x8fL\xe6;\xcbŰ\x87\v\xbd.\x86o\xa6\xb3\xf82<\xc6\x10\x1b\xa1ku\xf5ȞI&\xca\x11%\x96\xe5\x91e]\xd4c\xec\xbcu\xf3\xa8>\xb3\xbbG\xedhe{d5\x94\xa3\xbc%\xae\xe7zT\u007f\x12\x13\xaf\xed!\xbe\xf8\xbeqK\x9eG\xa6\x84\xf9\x1e\x99)\x16xd\xa2\x17\xf7\x18+K\x8f\xeadzyԴ\xa8\xb7GF\xab>\x1e5o\xea\xeb)\xe2\xee\xd1\v5\xd4\xcf#\xe3H\u007f\xa3\t\rP\x99C\xae\x06zT\x174\x88\xcd\xef\x03\x86?4\xbcf\xb0\xc7\xe8\xfd\x86Hq\f\xf5$\xc0\x8b\xf4a\x92\xb5\xe1FU\x8f\x90\x8b#\x912\x15\xfd(\xb9i\xb4G\x8d\xf2\x1f\x15\xc6\xf01\x0f?\x91\x86\xf9\xa9\a\xc3uX\xff\xac\xf0\xe2\xe7\x12\xc3\x17\x1e\xe93\xbe\xf4pU\xf9\x95\x87#\xf1\xd7\x1e5\x19\xf9\xc6\xf0\x83o=j]\xfa\x9dG\xc6\xef\xef=\\\xb3\xfe\xe0\xe1l\xe3G\x0f'G?I\xff\xf2\xb3ѿ\xfc\u008c\xfd\xca\xe7~\x93\xba\xff\xdd(\xc4?\x8c6\xfd\xa7ǘލa\xf9\x8d52\xf6\x97G\x96\xf2\xe3<\xdcg\x18\xafj$G\x9f\xe0Q3\x89\xbf\xe5\x95\x13\x19\xed?F%L\xf2ȸ2Y\xba\x97)F\x89L\xf5H\x9f8\u0378m\xbaG\xed#\xcf(l\x183=\xec\xb0g\xf1\xec\xec\xc2Nb\x8eGu\xb5\xffzdF<׃5M\xae>\x8f\xef\x9e\xefag\xbc\xc0x\xdbB\xa3\x1d-\x92>g\xb1\x87\x13\x9e%F-/5\x9cu\x99\xb4\xfc\xe5x\x16u\xb7\x82\xadd%\x9df\x95G\xf5\xff\xabU\xe1\xa3\xd8\xd6xd\xa8_k<\xb7\xae\xd0q\xd7{d|\xde\xe0\x91\xbd\xbd\x8d\x1eن\xdad$c\xb3\x87+\x89-\xc6{\xb7J\xd5l\xf3pR\xb0\x9d\x95\xb0\x83\rf\xa7GfD\xbb\x8c\xe2ݭJ?\x8eV\xb6\xc7ù\xc8^\xb6\xdd}\x1en0\xef\x97^\xf8\x80\x87\x03\xd6A\x91CF\xef{\x98\r\xe6\b\xfbѣ\xf4\xdcc\x1e\x0e\xa4\xc7EN\x88\x9c4\xca\xff\x14k\xf7\xb4\xf4\x8cgT\a\xd7=\xa6\x9f5.\x9eSN\xd7]?\xefQ\xb3\xdd\v,\xe7\x8bƥK\x1eY\xed^6\x8e\xaf(?\x8b\xeaW\v\x1b\xfe59\xbe.\x05p\xc3#\x03\xfdM\xe3\xa9[\x1e\xb5\x01u\xbb\xb0\u05fbc\fdwY\x03\xf7<jBu_\x92\xf4\x80YxhtL\x8f<\x9c\x1f=\x16\xf9\x9f\x87\x13\xb3'\xbc\\\xfci^\xa9\x03\x93\x1c\x9a\xbdܮM\x10I\xf4\x16\xe5\xf4\x01\x83\xa8\x97\x9dYQ/?\x19\x16\xf3\xaa:(\xeeU/)\xe1eSy\xd2+\x9d\xdfS^\x94<\x96\x9f^\xa6\xe3\x19/\xb7k\x9f\xe5\x9d\xcfy9\xc2>\xef\x95\xfe\xe6\x05/F\x8e\xb0\xfe\xa2\x97\x8bڗ\xbc\xb2\xfa\xf4\xaaz}ŋ\x81 \xa2\xbf\xea\xa5\x1b\xbe\xe6e\x9f\xf6\xbaW\xed\xea\xbfᕖ\xf0\xe6\u007fI{˫J\xf8myaI\xaf*\xa2R^U=\xbaWf`I^:yi\xafxY\x19\xaf\xd1D\x93\xbdl\te\xbd\x18\xd4#\xfa;^\xce\xc0ˉX\xbc\x1cXS\x98\x9c\xf2FD\x15\xe4Ί^\xe9\xd3*yů+{\xd9\aU\xf1\xf2+\x8dU\n\xd2\xf6_\xfaRQ@\xf0E\xbbWm\xb7T\xf5\xd2\x17\xaby\xd58S\xdd\xcb\x11\xba\x86\x8a\x1e\x118\xbc\xd2\xc1\xd7\xf4r\x15\xf6\xaeW\xf9O-\xaf\x1a\xc2jK\xaa\xeax\xb98\xa9\xcb+\xf5\xe4\xe0=/]\xa6\xbeD܀%\xddЫV\x8a\x8d\x8c\xf45F\xf9\xa1\xe14\x91\xf45e16\xf3J\xc7\xd4\\UWLo\xe1\xe5ǵ\x96|Y+\xaf\xfaܒfT\xa8SR\xe3\xfa/?nɮ\xc7+\xad\xd3+1\xf8XR~\xbe8\xe0\xe5\xc6H\x10\xe5\x8b\xf7\xb66\x8a\xab\x8dWu\x11m\xff\x8b\xa7\x9dW\x8d)\xed\x8d\xfa\xec n\x10\xf2\xaaydG梓d\xa9\xb3Wz\x8b\xb0\x97co\x17\xaf\xac\xfbӍ\xf7g\xf0\xde\b\x9f\xeb*\xb7d\xb2\xfa\xb3\xbc\xdc\x14\x8dz\x8d\x05o7\xe3\x81\xee\x12m\xb6W\u05909^5\xf5ȕL\xc5\xe8K=\n\x1fy\xdfx$ϫ\xb6V\xf2\xbd\\\xc5\x16H\x81\xc7\xff\xcbHO\xaflZ\xf422\xdaۛ\xe8W\xc7}\xbcj\xae֗\x05\xd3\x0fE\x82\xb2\xe8ox\xd2\x00\xaf\xac<\x06z9\x1e\f\xf2ʤ\xf3\x03IŇ^\x99\a\x0f\x9661D\x1a\xcaPy\xfd0#\xffý\xb2Z\x19\xc1̎\xf4\xaa)\xf3(i)\xa3\xc53>2b\xfdX\x0e?12\U000e985fy\x8d\x15\xa8\x94\xd3\x17,\xc7/\x8d\x8b_\xb1\x85\u007fm\x1c}#\x8e\xfa\xad\x91\xc1\xef\xa0*\x83\xdf{\xd5\x0f\x14~`\x06\u007f\xf4r\u007f\xf7'\x1e\xfc\xec\xe5\xc7Iß\u007f\xf5\xf2\x93\xc3o^\x99\u007f\xfc\xee\xe5d\xff\x0f\x96\xfb\x9f^~\x18\x18#-}\xac\x97]\xf4_\xdeĖ\xaa\xf8\xc7y92\x8e\x97\xb7O\xf0\xca\xe8\xf0\xb7\xbci\xa2W}\xed\xf8G\x1a\xc6$6\xfb\xc9^\xf9|0\x85\x89\x9f*\xf7M\xf3\xaa\xe1>\xa6Og\xcaf\x18mb\xa6\x97K\xadY\"\xb3\x8d\x1a\x9c#\xd5\xf1\xafW\xa67s\xbdj\x8b\u007f\x9eWV\xd6\xf3\xbd\x9cK,\xf0\x1a\xc3\xeaBy\xf5\"I\xfab\xaf\xda>\\\xe2\xe5\xac`)\xdb\xd12\xe3]˽\x9ct\xaf\xa0\x8b\xae\x94\xceh\x95\x97\v\xd8\xd5^\xd9d]\xe3\x95E\xf3ZC\xd7ye\x8e\xb2\x9e\x11m\xf0r\xefc\xa3\x91\xcaMF\x83\xd8L\xff\xda\"\xadl\xabW& ۼ\xdc\x1c\xdc\xeeU\x1fDw\x88\xab\xee4b\xdbe\x94\xe0n\xaf\x9a\a\xed!\xf7J\xf7\xbd\x8f\xb5\xb1\x9f\x05w@^wЛؚ\xcb\xcc\xc2\xd6pX\n\xeb\x88W}F<ʗ\x1f3\xfc\xf8\xb8\xe4\xfb\x04}褗;ۧ\xbcƢ\xfd\xb4\xe1\x87g\f\u007f8k\x14\xef9\xbe\xed\xbc8\xf9\x05/\a؋F\x1e/yeyy\x99\xde}EF\x8e\xab\xe2\x0f\xd7\xc4g\xaeK2o\x88\xdcdzn\xb1\x92o{\xb9\xd5u\xc7++\x95\xbb\xc6{\xefI\x9f~\xdf\xf0\x92\a^\xae6\x1ez\xb9\x04~$\x17\x1f{9S\xfc\x1f\x8b\xe3\t\x1f\xef\xd0|\x89ij\xd6k\xf2%8\xc3}t\xb3\x8f\x9fC\x12D\x12}|\xae\x88O>\x15\x17\xf5ɯL}\xc6\x18]\xdc'\xdb\x1e%|*\x1fO\xfa0\x9b\x8b\xe9O\xf9Tw\xf2\xb4O\xad\xfc\x9f\xf1\xa9\xb5\xe4\xb3>\fE1\xfd9\x9f\xea~\x9e\xf7ICy\xc1gn\x84\xf1\xd1\xc7\xf4\xbd\xe43\x96\x87/\xfb\xd4\xc6\xd9+>\xf6\t\xaf\xfa\xb8\x91\xf1\x9aJYL\u007f\xddG\xa7z\xc3'{\xaboʓo\xf9T1\xbf\xedS;`%}\xc6*\xbc\x94O\xbe\x99\xea\x85'\x92|\x86[\x97\xf6\xa9\xc9c\x19\x1f\xa7~\xc9>ծ\xca\xfa\xe4+\xc3;>v$\xe5|\x9c\x04X|\x89\xed\xd4\x03)\x85O\x96\xf7\xb1ۯ\xc0\b*\xfa\xb8\xffVI\x1e\xa9,R\xc5\xc7Ţ\xd5\xc7\xea\xb4\xc9\xc9T\x9ftdvC\xab\xfa\x12}\xaa\xba\xaa\xf9\xd4d\xac\xbad\xa2\x06\x13\xe2\xf0\xa9YZM\x9f\xea\xeb\xde\xe5\x99Z\xcc\\m\x95\xa2\xb0^\xc7\xc7\uefee\x91\xdcz>\xb5\x90~\x8f\xf7\xd5\xf7\xd1A\x1b\xf8\xb8\xb2k蓱\xad\x91\x0f\xb3?\xb5)\xebS\x1f˛\xf8ԗ\x8e\xa6>\xc3ݛ\xf9\x94\x0f4\x97$\xb7\xf0\xb1\x0fk)Ѵb:\xd2|\x1c\xb2\x9cR\x15.\x1f\x9d\xd3-'=R1^F\xe9\xf3I\x97\xed\x97[\x02\x92\xfd\xa0\x8fn\xdc\xda\xc7\x0f:m\xe4d[\x9fjA\xed|\xaa\xabh\xafR\xa2&x\x1d|\xeaCi\xa8\xb0\x9c;\x1a\xf9\xeb\xc4ӝ}\xb2\x0f\x1b\x962\xe8\xe2S\xed \xdd\xc7\xe5~\x06\x0f\"LmW\x1fǖL\x9f\xda\x18Β\x94D}\xecº\x89t\xf7qݟ\xedK\xa8\xafV\x92\x85\x0e\x97\xebc\xf7\x1b\xf3qe\xd5\xc3\xc7\xc9\xf8\xfbro\x9eO\xdaR>\x93]\x80$\xa8\x9f\xe8\xf8\xe4\x974=\xa5\xb0z\xf9\xa4I\xf7\x96w\xf6\xf1\xa9n\xa7\xaf\x8f=}?y\xa2?\x8bz\x00#\x19\xe835\xd6\a\xf9\xa4\x8b\xfb\x80I\xffP\x1a\xd5`\x1f\xe7\xafC\x8c\f\x0fU7\x0e\xf3\xc9V\xf5p\x9fj\xf8#|\xfc\x81\xd5H\xb9q\x14ύ\xf6\xa9\xb1\xe8#\xf2cq\x90O|\xfc\x1a\xfc\xa9d\xec3\x1f\xc7\xd5\xcf}\xf2S\xaa/\xe4e_\xfaT\u007f\xfe\x15\x1f\xfbZn\xfcƧ\x16\x9e\xdf\x1a\xf7}\xe7SS\x9d\xef\xf9\x8e\x1f$\xc2\x1f}\xfc4\U00093466\x9f\xf1\x18\\\xe7\x17\x1f'H\xbfJ\xeb\xf8\xcd'\x13\xaf\xdf\x19\xd9\x1f\xc6џ>c\xd7p\x8c\xa4p,\xa3\xfd\xcbǮq\x9c\x8f[Q\xe3}\xb2\x16\x9f\xe0\x93=Xi\x18\x13}\xecl\xff\xf1\xa9\xd9\xff$iQ\x93%\x92)>\xb5\xfa\x99ʨ\xa6\xf9\x8c\xed\x8e\xe9>n\x06\xcc\xe0ٙr\xe3,\x91\xd9Fb\xe6\xf0\xb9\u007f\x8d^h\xae\x8f\v\xa5y>~C\x9c\xcfִ\x80\\\xe83\a\xba\xeb\x8b|\xdc\xcfY\xccֺ\xc4'\vȥ>c;t\x99\x8f\x9b\xd4\xcb}\xdc)^!\xb2Rd\x95\xc8j\x9f\xda\xd7[\xe3\xe3\xee\xf3Zq\xdcu>N:\xd7\xd3#6ȹ\x8d\xbe\xa2>\x99pm\xf2q\xac\xd8\xec\x93]\x87->\xf9\xb9\xdbV\x9f\xda\t\xd9\xe6S{\xdb\xdb}\xfcd\xb2C\\p\xa7\x8f+\xd6]F;\xdc\xcd\xe4\xef1\x1e\xdfk4\xa7}t\xcc\xfd>\xceN\x0e\xf8\xb868\xe8\xe3g\x80C\xaa\xaf\x8f\xe9\x87\xc5\xe9\x8f\xc8ɣH1\xfc\xf9\x98zST?n\f\x00'|\x9cB\x9c\xf4\xa9\x95\xf0)\xf6\xfa\xa7}\xb2\xf08#-\xf0\xac\f\x02\xe7\xe4\xc6\xf3\xe2[\x17|2F^\xf4\xc9\xd6\xd6%\xe6\xe5\xb2O~\xd0tŧ\xa6\x01W}\xdc\v\xb8&\xbd\xfcu\xc9\xda\r)\x9c\x9bR=\xb7\xd05\xc6\xf4\xdb\xd2\xd2\xee\xf88\xef\xb8\xcb\xea\xbc\xe7\xe3\xbe\xf5}y\xf8\x81OM\x0f\x1e\xfad\xed\xf7\x88\xc5\xfcX\x1c\xff\u007f>\xf9A\xd2\x13~\xfe,P\xf3\xabR1\xf9\x13\xd3Tɛ\xfd|<\xc1\xaf\x06\xb0D\xbfl\xa8\x16\xf1\xf3SCQ\xbf\x9a\xcf\x17\xf3\xabvS\xdcϥ\xa1_\xe2\u007f\xd2\xcf5\xe1S~\x19ӟ\xf6\xcbj\xfd\x19?\x9b˳~\xe5\x8a\xcf\xf9\xd5\"\xf6y\xbf\xd1\x0e^\xf0\xb3Q\xbe\xe8\xe70\xf4\x92_\xed`\xbc\xecW\xbd\xd9+~S}\xfdU\xbf\xfa\xa6\xf2\x9a_}\xf0y\xddϵ\xcb\x1b~~\x90\xf4s\xc7\xe6-\xbflǾ\xed\xa7\xf3\x96\xf4'\xf8q\xb6\x94\x9f}\x97\xeegKL\U000ab074\xb4\x9f\xed\xa7\x8cH\xb2\x9f=aY\xbf\xeaY\xdf\xf1s\xce^ί\xaa\xc2\xe2\xe7\xef\x8fR\xfc\\\a\x97\xf7\xa3\xef\xa9\xe0g7S\xd1/ͽ\x92?\xb1\x99Jze\xbfZ\xce\xe5\xeaU\xfcj\xbdc\xf5Kq\xda\xfc\xac\xe7T\xbfl\x03\xda\xfd\xaaǫJV\xf3ˏ\xaf\xaa\xfb\xcdΈ^C\xb2\xe3\xf0s\xa8\xf3\xcb\xc7\xd8w\xfd\xdc5\xac\xe5\xe7r\xba\xb6\x14\\\x1df\xbf.\xe3\xa8秇\xbe\xe7W\xfdU})\x84\x06,\xaf\x86*\xa9\x8dXa\x8d\xfdܱi\xe2W\r\xae)\x93\xd7\xcco|\xael\xcehZH4-\xfdj\x1e\xd2\xca/>\x99fd\xc1)\x95\xef\xf2\x1b\x03\xa4\x9b\xe9\xf5H\xd9z\xf9\x88\x8f\x95\xe0\xf7\xb3-\a\x98\xbe \xab\xb7\xb5\x9f\xfb\x9dm\xfc\xd2Ŵ\xf5\xcb\xd6E;\xbf\xfc{\n\xbf1U\xec\xc0T\x84T\x92;\xfa\xe9ߝ\xfc2y\xeb\xecO\xc0DJ\x0fK\tt\xf1\xab\xa1=\xddoJ\xd33\xfcҺ\"~n\x16v\xf5\xb3=d\xfa\xd57\x9f,\xbfl\x03F%\xaen\xc6aw$\x19\xb5\x9c\xcd\"\xcea\x92sY\x1a1\xbfl\xb4\xf4\xa0+\xbf\xefWm8\x8f\xe1|?\x9b~\x01[C\x9c>\xde\xd3\xcfIW/q\xd1\xde~\xfeا\x0fc\xeb\xeb\x97%C?\xa3\xb6\xfb\xfbՔh\x80\xe1\xf7\x03\xfdj^7ȯ:\xa1\x0f\xfc\xaa\x87\xf8\x10\xc5\x1e\xc9\xd1\a\xfb\xd5\x1cm\x88\x9f?\xf7\x18\xea\xe72u\x98\x9f\xd3\xfb\xe1~N\x10G\xd0gG\xb2\xacG\xf9e\x1a=\x9a\xa9\xf9H\x1a\xcc\xc7<\xf8\xc4\xcf\xdfw~\xea\xe7\x10\xf1\x99_\x16\x15\x9f\xf3\xb1/\xfc\x1cr\xbf4\xca\xe2+\xbfZ\xe3|\xedW\xbf[\xfa\x86\x19\xfe\x96\xe1\xef\xfc\xfc\"\xfc=[\xc2\x0f~\xf9\x14\xf0\xa3_\x16\x10?\xf9e\xd7\xecg$\x15/\xfdůz\x98_\xfd\xd2\xf7\xff\xe6\xe7z\xf2w\x96\xe8\x1f~\xb5\xd1\xf1\xa7\xaa\xd01~cs~\xac$\xf5/\x16\xff8\x16\xd8x?\x17Q\x13X\xd6\u007fK\xcf3\xd1\xcf\rQi7\x93\xa4\x8f\x99\xcc~e\x8a\x91\xf6\xa9\xf4\xeai~c\x9a4\xdd\xcf\xef\x063\x8c\u009f\xe9W\x9d\xe6,?\xe7o\xb3\xfd\xfc\xa1\xd2\x1c\xbf\xfc\x16\xeb_?\xfb\xe0\xb9F\x92\xe7\xa9\xf4\xcd7\xba\xb3\x05~\xfe*d!j\x1cw.\xf2sl\\\xec\xe7\xdag\tS\xbb\x94\rh\x19\xaa\x04]\xc6r\xa3\x8eW\x18\xbd\xdbJ\xa3\xb5\xac\xf2\x1bK\x80\xd5\xd2lְ\xa0\xd7\xfa\xd5\xef\xcd\xd7\xf9\xb9y\xbdޯ6\xf07\xd0U7\xfa\xf9S\x93M\x85\x1d\xe0f\xbec\x8b\x9f\xbf\xef\xda\xea7\xa6~\xdbؾ\xb7Ӂv\x18\xf9\xdcI\x9f\xd8\xe5\xe7\x96\xd9niP{\xfc\x9c\x93\xeeEф\xf3QR\xfb\x8c\xf6\xb6_\x9c\xea\x80\xdcu\x90\xa5y\xc8/\xbbۇ\xfd\\\xdf\x1e\xc1+b\xfaQ?ǎcF{=n8\xc0\t\xf1Ɠ\xc6pp\x8a\x15pZ\x95\xde\x19\xc9\xe5Y\xbfL\bϱ՟\xf7\xab\x1ff_\xf0\xabI\xf0Ez\xe6%\xbf\xda\x05\xbbl$\xfd\x8aQ\xfeW\xa5t\xaf\xf9մ\xf7\xba\x9f\x93\xb8\x1b\xe2%7\xfdƦ\xf1-v÷\xc57\xee\xf8\xd5\xf8u\xd7\xcfߖܓ~\xfa>]\xf5\x81t\xca\x0f\xfd\xf2c\xe6G\xfeĦJ\x1f\xb3S\x8e\xe9\xffc\x8a\x9f\b\xb0\x93\xd0\x02\xac[S@\xb9\xbd\x99L\b\xb0\x9fJ\f0\x96\"\x01~6/\x1a\x90\x9fj\x14\vp\xdb3\xa0j\xa6D\x80\xf3\x84'\x03j\xd8z* \xf9x:\xa0\xdc+W\u007f&\xa0r\xffl@9\xf8s\x01\xd9fy>\xc0\x06\xf5B\x80\x03\xf5\x8b\x01.Q_\n\xa8\xfe\xee\xe5\x00wd_\t\xa8\xca}5\xc0\xae\xfe\xb5\x80j>\xaf\a\x94o\xbc\x11\xe0\xe0\xf4f@\rzo\x050\x0f\xcf\xd6\xdf\x0e\x88\x9b\x95\x94\xdbK\x05\x12ZF\xf2u=\xc0\x82L\n\x14\xfe\xe3\v\xc9@\x19yA\xb2\x91\xbc\xb2\x01\xd9ux'\xc0\x89e\xb9\x80r\x03\x8b\xa4/%\xa0\xd6\a\xe5\x03\xb2?]!\xc0\x11\xb3b@\xf5_\x95\x98\xa4\xca\x01\x996U\t\xb0G\xb4\x06d\xf3\xd2\x160&\x98\xa9\x01\xd5\xe2\xed,\x81\xaa\x01\xa3_\xaf\x16P\xab\xdc\xea\x01\x8e\xae5\x02\xca\xc3\x1c\x01Y{\xd5\f\xa8F\xf0n@>J\xd5\np\xfb\xa2\xb6\xa4\xac\x0eK\xb0n\x80\x1db=&\xe2=\x96~\xfd\x80\xf4\x00\r\x02\tNHC\x95{,\xe7\x022\xbfklh\x93\x80\xf1\xfb\x81\xa6,\xc6f\x01\xf1\x89\xe6\x01N\x81[\x040\x91h\x19\x10Ol\x150\xda]Z\x80Ù\x93\x15\xe3\np\xb4q\a\xf85\xc1#\x89\xf22\x1d>\x16\x86\x9f\f\x04؛\x04\x03\\µ\x16i\x13Ps\x96\xb6\x01գ\xb5\v\xa8&\xda^\xa2\xe9@o\x8a顀j\x10\x1dY\xe9\x9d\x18O\xe7\x00=?\x1c\xe0Pҥ\xb0\x12\xd3\r\xef\xca\b\xa8uoDR\xd15\xa06i3\x03j37+ \xab\xa5h\x80\x13\xccn\xb8/\xacw\x97Ȳ\x03f_D\xcf\t\x18\xf3\xf1\\\x14\x18\xaa \xa6\xee\xc4b.\xc0\xef\xb5\xefK;\xc8c)\xe5\ad\xc0-\bp\xc2\x18\x0f\xa86\xd93 \x13\xd1^\x86\xe7\xf46\x8a\xadO@\xfe٠\xe1\xe3\xfd\x02\xec\x04\xfa\a\xd4\xd2h\x00\xeb|`\x80c\xd0 )\x94\x0f\x02\xaaO\xfe0 \x03\xd2`q\xa1!\x01\xae\x80\x87\x06dot\x18\x1db\xb8$\u007f\x04\xb39R\x1cgT\x80\xf3\x9e\xd1\xd28?\np\xfe\xfd\xb1\xe1\n\x9f\x04\xe4\xcb\xfb\xa7\x01\xf6۟\x05\xccވ\xfe9\xe3\xfaB\xbc\xf8\xcb\x00LJ\xaf\x02\x1cJ\xbe\xa6\xa3\u007f\x130>\x06\xb2R\xbf\vp\xc3\xe7\xfb\x80\xf1\xab\x89\x1f\x02\x1c<~4\xda\xcdO\x86\xfeL\xb7\xfc\x85\xf5\xf7+\x1b\xcfo\x01\xee\xf1\xff\x1e0>-\xfc!9\xfbS\xeajL@\xcd\x1a\xc6\x06\x8c\x8f<\u007f\x05\xd4Ri\x9c\xd4\xc4\xf8\x80\x8c:\x13\nk\xfbo&yb@\xfe=\xd4?R\xa2\x93\x02\xb2#<Yjj\x8a\x94\xe6\xd4\x00\xe7D\xd3\x02\\GMg\x93\x9b\xc1\xc653\xc0\xces\x96$cv@\xb6@\xe7\x04\xe4G+\xff\xcass\x03\x89\xee\xacX\xbe>O\x12?\x9f\xb9Z\xc0\xd7/\x94\x02_\x14\xe0\x97\x83\xc5\x01\xd5i/Af\x10\xc9\xd2\x00\x87\xf7e\xac\xe3\xe5R\x96+X\x14+U\x83Z\x15\xe0蹺\xb0寡\xff\xad5j|]@\xfd&d\xbd\xd1wm\bp\x9d\xb2\x91\xdd\xea&\xe9\xaa6\xb3\x93\xdb\x12\xe0\xfaok\x80\xf3\x98m\xf4\x9a\xed\x01\xf5\xaf*v\x18\x05\xb3\xd3\xe80v\x05ԧ\xf2\xdd\x01.\xc9\xf6\x04\xd4\x18\xbb\x97U\xb2/ \xeb\xf4\xfdl\xc9\a\x8c6t0\xc0\x99ࡀ\x1a\x06\x0e\xb3q\x1e\x91\xbc\x1e\x95\xb6p, \xbb\x9e\xc7\x19Չ\x80\x9aٜ\x94J8\x15\xe0\x98xZ\x12zF\x06\x80\xb3\x92\xc4sr\xf2\xbc\xf4\xd4\x17\xa4n/\xb2X.\xe1\xe9h\xbe~9\xc0\x1f\xae\\\t\x98\x9d\x99\xfaU\xbe\xffZ@\r\x8fו\x1f\x87\xf5\x1b\xec\xd8nJ\x83\xba\x15\x90\xc9\xc4mv\x1cw\x02jq\u007f\x97\xbc\x17\x90]\xb2\xfbҙ<\x90f\xf20\xa0v\xe2\x1fI)<\x16\xf9\x9f4\xe0'\x82\xaaUkA\xfeˊ\xa0\xcc\xe8\xcdA\xe3\x83q\x82q\"1ȍ\xe2\"A>R4\xc8E{\xb1 \xfc*\xa6\x17\x0f2\xa3%\x82*}O\x06\xa5\xe1?\x15\x94\x8dߧ\x83\xf4\x90g\x82\xe6\xa6a\xfd٠\x1aB\x9f3ny>\xa8\x9a\xd4\vA6\xa1\x17\x83\xecp^\n\xaa%\xc1\xcbA\xa9\x8cW\x82\xaa\xf7z5h\x8c\x1c\xaf\x05U3y=\xa8\x96\xb0o \xd5\x11\xfd\xcd G<\xf2mFW2\xc8݆RAՄt\xbe5)(\x9dO\xe9\xa0\xeap\xcb\x04\xe5\x9f+$\a\xc5\xd7\xcb\x06\xe1/\xc8\xda;FN\xcb\x05լ\xd2b\xa41%\xc8yR\xf9 \xb7\xe2*\x04\xb9\x84\xa8\x18\xe4HX)([\xb7\x95\x83\x1cS\xab\x18\x8fX\x83ʻlA~\\H\r\xca\xd2\xcd\x1ed\x13\xaa\x1a\xe4\x8eO5\xe3\xd6\xeaA\xe5=5\x82t\x1bGP;k\x06\xe5\x97\\\xef\x06\xa5A\xd7\n\xaaFW;\xc8FSG\x8a\xbf\xaeH\xbd\xa0\xaa\xd3\xf7\x82\xdcޮ\x1f\xc4\x1c\xabA\x90?\x19k\x18\xe4\xf6G\xa3 \xbd\xb2\xb1\x14p\x93 ;\xb7\xa6\xc1¯R͂\xea\xf7\xdf̓\xec)Z\x04\xf9{\xd2 ǶVAc͗f\x94\x89\x93%\xe7bR\xdct\x14\x8f\xa4\xd9\x1b\x14g\xf3\xb1f\xfcA\xf9\x1c\x1d\x907\x06\x83\xecU[\a\xd56v\x9b \xb7\xaa\xda\x06\xe9\xff\xed$\xd1\xed\x83l\x06\x1d\x82j\x1d\x1abat\f\xb2\x03\xebd\xd4N砚Ɇ%\x91]\x98\xc8\xf4\xa0\xf4\xe7\x19A\xee\x10F\x822;\xed\x1a\xe4\xfc6Sޝ\xc5TFU\xa1t\vrn\xd3=\xa8:\x91\xec \x9bw\x8e\x91\xb1ܠL_c\xf4\xdd\x1eA\xe9\x84ޗ\xb4\xe6\x05eN\x9c\xcf\xd7\x16\x04\xd9'ƃ\xfcz\xdb3\xa8\xdag\xaf w\x8b{\a\xb9\xf4\xef\x13\x94\xaf\xe9}\xf1\x0e\xb5u\x19d{\xee\x1fT\x83\xf2\x00r\xa0\x94\xc8 \xf1\x82\x0f\x82\xb2H\xfa\x90\rpp\x90\x93\x8e!AՉ\r\r\xb2\x0f\x1d\x16T}\xd7p)\xeb\x11A\xae#G\x06\xd5|`T\x90\xf3\xf4\xd1\xffG\xd4U\aJQ~m\x1a\x04\x15\x11\x10\x01\x91k\x80\x88\"\x16\x82\x8a\"(-!q\xb7c\xb6gwg/)e \n\x18\x94 )HwH\v(!)ݠ4\b\xd2)\x8d\xc0\xb7\xe7y\xce\xfe\xbe\u007ff\xee\xee\x9dy\xe3\xc4s\x9es\xdewf\xa1\x92\xef\xb2Y\xcc\xe8\x03\xcb\xebK\xb9\xf4\xe3]\xfd\xb3\x05\x86\ad\\\xe8\xfbl\x16/y\x1a\x946\x81tn\x87K\x06C\tC(\xbe\xa1\xd9\x12ԇe\x83\x05\x0f\xa7\x96Fp\xf0?\xc2\xcdF\xc2\xf6Fek\xc4\xfa)\x1b(3:[\"̘l,2\x8e\xcd\xce\xdf@\x1ck\\67r\x8dW\xa3\x9f\x80['Rϓp\xc7d\xf4=%\x9b9\xc4T8\xc24\xea|z6w\xa0\xcd\xc8F25\x13r\x9c\x95\xadd\xecg\xcai6\x9a\x9c\x03ḁd\xe6eKH\x9a\xcf^\x16ds]r\xa1Z\xd5/\xd9\\\xf8Y\x94͊\xe9\xe2l!\x11K \xfa_u\x98\xbf\xa9\x89,\xcd&\x1b[\x96\xcdؾ\x9c]\xae\xc8\xce\x140)\x9d\x95z\xdb*\x88t5\xa6\xb5F\xbb]\x9bM\xe6\xb1\x0e\xdf\xfe\x01C\\\x9f\x8dh\xb2A\x85\xb3\x91\u07b9)[\xc2\xdffLdK\xfa\uf72c\xadٺ\xc7%[R\xff\xedD\x95\x1d\xb4\x95\x9d\xecz\x97\xb6\xb1\x9bJ\xdd\xc3\xd3\xdel\x84\xf6?\xa9п\xa8\xbc}\xd9H.\xf6\xc3\xd5\x0e\xc8\xed\xa9\xac\x83\xda\xc3!^y\x986}\x847\x1c\xcd\x06\xf5:\x96\xcd\x15\xeb\xbf\xf5|\x9c\x16\u007f\"\x9b\x8bD\xff\xa8\x1b\x9d\xcc\xd6]V\xa7\xb2\xb9\xf9\xfct6\xf8ҙl\xd6>\xcf\xc2vα\xa3\xf3z\xd3\x05Z\xd9E\x06\x80K\x02\x94\xa9\xac\xcbz\xc7\x15\xce\xe2\xdflɢ\xae\xf2õl\xec\xef\xbf\xce\x1bn\xa4\xa7\x94\xfet3\xed*\xe9L/\x9b\xb5\x9e\xdb\b4wx\xc5\u007f\xd9(\x8b\xde\xe5\xa7{h\xea>;\xcde\xc3w\xb9m\x98l\x1e\x1b\x9e\x05\xc8k\x13\xc0\xcag\x13\xaf\xcfoc\x9eg\xe3X\v\xda\xd0u!\x1b)\xf0\x03\xb8\xa6\xb0\x8d\xec\xba\b\x1b{Ц\xe4\xf0!\x1b\x86\xfb\xb0\xde[Toz\xc4&\x96Y\xcc&F\xfe\xa8\xfe\xaf\xb8\x9eK\xd8ҀU\xd2&#|\f\xc7R8>n\xa3\xd8KK\xf7\xe1\xac26>\\h\x13CzBo-g\xe3\xa2ʓz.\x8f;\xb3l\x82\x16O\xe1\xef\xa7m\xacC>c\xd3\xfaܳ\x98h\x05\x9b8_E[\xbe\x86\xed̬\xe7p}%\x1b\xca\x0f\xcfs\x02\x95mx\xc8\x1es}\xd1&d\xa9\x8a\x8d\x8bv6qƪ\x18\xc6\xcb6\x01\xb1Wl\\7{Uϯٸ\xf3\xfeu\x1b\x13\xaej6B\xe4\x1b6\xacEU\xb7\x15\xac\x9d\xe8ء}Ǭ\x1a\xe9Y\x18\x96\x91\xf5\xa6M\v\x19o\xd9\x14\xb1\u07b6\t\x92״\xc1\xd4߱\x89\xa3\xbfk\x13\x9c\xabe\x03\xedxφ\xfaOm\x9e\xeaذ\f\xf7\xbe\r\xf1\xe5\x03\x1b\xd6\x18\xeb\xda\x10t\xea\xd9P\x9a\xadoC\U0007304d{\b\x1a\xda\x10\xf3\x1aٸ&ژ\x17}h\xc3\x13 Ml\x88\xb4MmX\x03o\x86\xf96\xb7\xf1\tC\xbd\xbf\x85M\x18XK\x1b\xf7,\xb5\x82\x18Z۸\xb0\x9f\x8d\x81\xdal\x8c#v\xfcϡ\xffs\xda\xe8v.v\xe1\xb6\t6xlR\xc3\xf0B\xc8>\x8e\xc4\x0fљY\x86MhO\xc0\x86e\x87\xa0\x8d\x94&d\x83\xb7\x84mR*\x8c\xb0\xa5(%\x11\xb3!)6m\xd8)\x16\xb7\xb1p\x99\xb0\x11\xf1\x926d\x82\x96Mʤ)\x1b\x1c$\a\xd3kcS\x1fnkc\xf9\xb0\x9dM\x9e\x83lo\x13r\xd9\xc1\x06h\xefh\x03\x8c|l\x93\x85\xfeN6!ߝmX\x17\xefbCq\xba+\xe6\xd1\xcd\xc6lφRƧ6\xfa\xe6g6`\xd8\xe7p\x80\xee6A\x84/8\xe4\x1e6\x16\xb3\xbf\xb4\t\x1c\u007fec8\xe8\xa9\xe7^\xb0\xd3\xde\x18\xc7\xd72\xe2.Y\xdf\xd8P\xf4\xfc\xd6ƗĨ\x0e\xfa\xd8X\x84\xec\v\xe9\xf7\xc3\xf0\xfa\xe3\xe6\x016\xd9\x17\xf5=\x875\xd0\x06\xa68Ȇe\xfa\x1f\b\x01\x83m\xc8 \x87ذ\xdbw\xa8\x8d\x8b-\xc30\xd6\xe16\xadO\x8e\xb0!\xa9\xf9цH3\x92\xa7Q\xf4\x89\x9flHLF\xab\xf0ưٱ6Ys\x1aG\x19\x8dW\x8f\x9d`C~:ц$g\x92\r%\x8a\xc9\x19\xf1O\xb1\xb1\x8c2U a\x9aM\xaa\x82\xd3Uy3lL\x8ff\xc2Nf\xd9P\xb9\xfc\x99B\x98mC\xa9a\x8e:\xda\\\x1bx\xfb<[\xfe\xfaF\"\x9c5߆\x92\xf4\x02\x9bd\xde\vU^\xbf\xd8ȶ\x17\xd9\x18\xe1\x16\xdb\xf8$\xca\x12\x1b\xca\f\xbfB\x97\xbf\xc1˗r:ˈ\x8a\xcbm\xc2\xfaV\xa8\xd6~O\xcf\\\x9e\xb4\xb7\xb1\xa0\xb6\xca&\x94j\xb5\x8d\x1cy\x8d\xba\xd7Z\x1b\x8a\xcb\xebl\xba\x9d\x85~\xba\x9e\xae\xbc\x01\x0e\xb2\xd1\x06\xae\xbd\xc9\xc6J\xc2f\x1b\xf3\xdf-6%\xa5[m\x88\xe9\xdbl\xa09\xdbm`\x1e;\xa8̝6\x94\x89w٤ҷ;sǞ\xf4\x90r,3k/\xbe\xfe\xd3\x06\n\xf8\x17\xbb\xdeG\xd0ޟ\x11\xfb\x01\x9bP݃6֞\x0eaD\x87\x01}Gp\xf7Q\x00\xe41\x1b\x97\xac\xff\xb6\xa1\xc0x\x1c\x9es\"\xd3\xdf?6,\xf1\x9f\xb4I\xe9\xfe\x14C\xc6i\x9b>\xf8|\xc6\xc6'\xd9\xce\xda4\xc5:\xa7\xe6zކE\x91\v\xf4\xe2\x8bP\xd1%\x1b\x1e7\xbbl\xc3\xf2\xe4\x15\x1bS\x97\u007f\tGW\xe95\xd7h\u007fס\xa0\x1b\xfc\xee&>ܢ\x02o\xc3\x0f\xeeظ\xe9\xf6?\xe0\xe9]\x1br\xf5{\x18\xe2}\xa0@.\xbbĥ\xdcvq\x97<v\xe2K^;\xf0%\x9f].\xc8o'b\x15\xb0\xc39\nڡ\x80Bv\xee\xcf{\xc0\x8eXhO[k\x11;\x95\xfe\xa0]\xa2\xf0Cv\t>\x0f۹\xbb\xb8\xa8\x9d\x0fJ\xd8E\x8c\xc5\xec\f\x13\x8f\xf2\xcb\xe2v\x99s\t~(iǴ\x1e\xb3\xc3bK\xa1\x91\xc7\xed*\xe1\xd2v\xd8a\x19;\x02vY\xbb@\xf0\x13v\xe6\"\xe5\xec\xd0\xe8\x93vxWy\xbb\xf2\xb4,;<\xfb);\xb6\xe3<\xcd\xd33\x18\xf4\xb3v\xd1r\x05;\xf6/T\xb4s\x9b\xa7=\u007f\v\xb9\xad\x92L\xe8y;m\xba\xb2\x1d\x82\u007f\xc1\xceG\x96^\xc4\xddU\xecJ\x82_\x92K\xabځ\r/\xdba\xa4\xaf\xb0\x9bW\xed\xa2\x81\xd7\xecX]{ݮ\x91\xad\x9a\x1d\xfbW\xec\xc0\xe9\xea\x9cQ\r;\xeb\xaaoڵP\xf4\x16\x87\U000f6741\xb4\xa6\xfe\xff\x1d\x95\xfa\xbbv%\x1b\xb5T9\xef\xd9\v4\xef\"WԶ\x17l\x95\xd3\xce\f\x85\xb3\xeaؕ-\xbf\x9f\x19\xe9\a\xaa\x8c\xbavnq\xacG\x91\u05f7\xd3\xd5\x1a`\xb8\rqldg\xf0jl'u\xfe\xd0.$\xb9IF\x11M\xedt\xe4fv\xe0Ls\xbb\xf0\u05cfpla\x87\x9f\xb5\xb4K>\xdd\n\xb7\xb5\xb6\xb3v\x92\x9d\xb9\xdd\x06\xb5\xda\xd5\xda\x1cv\x80\x8333w\x97]b\xa2[\xad\xc9c',y\xedȫ|v\xee.\xf2\xd3\x1a\r;\xcb=\x01\xbb`b0\xd3A\xc8\x0e/\x0fۅ\xc2DT\x88Q\xbb@S\xcc\xce\xfd\v&U\x15\xa7n\x13\xdaN\xd2N\x90\xb6\xec\xa8\xf0\xa6\xec\x00\xe9\x1c;\xe2_\x1b{\xbe\xdai\xb2\xd2\xd6N\x88j\x97\xd1h{\x1dj\a;\x1d\xb5\xa3\x9d\xc9\xcb\xc7vI\xb5;\xd9%\x06u\xb6K\x85\xa3\x8bZ~W\xdaD7\xbb\xf0\x9aO2\xb6\xfa\xa9=\xb3\x93\xe13;<\xffs;\xaa(\xdd\xed\x88\\_\xd8\xf1\xe4Y\x0f;\x1f\xe7\xf9\xd2NF\xf1\x95]<\xbb'\xef\xe8\x05\x9b\xeem\xd7'\u07be\xe6\xec\xbeQu}kg$\xf9N\a\xd8\xc7\x0e\xd8\xe8k\x97ģ\x1f\x1d\xa8\xbf]+t\x03\xe8\xe8ߣŁv-\x99\x0f\xb2K\xf0\xff\xc1\x8e*\xd3`\xcap\b\xb4<4-f\x99\xfd0\x8cgx\xa6\x99\x11v-`\xfeHk\x1bi'\xb1\x19eg\xa5\xe3'\xbdm\xb4]\xa2\xca\x18;\x8b\xbdc\xf5<\xce.Qh\xbc]\x18\xeb\x04\xb5ɉv\"\xe7$;\xea\x1d\x93i>S ˩vd(\xd3x\x9a\xce\xd3\fLa\xa6]\xf9\xef,B\xcc\xcf<Ͷ\x03x\xe7\xd8YĘ\vC\x9ag\a\t\x9b\x9f\xf1\x9c\x05\xbch\xa1]\xca\x12\xbf\xd8%V,\x12\x81\xe7d-\xb6\xe7o\"\fv\t@\xe1\xd7̬\u007f\x83\x17-\xd59.\xb3#\xc8/\xb7c\x95\xd0.Q\xe3w\x80\xd7JU\xc8*\xbbn\xb7[\x8d\xb6ר\xbe\xd6\xda%\x1f_\xc7\xce\xff\xb0#\xfb[o\x17\xec\xde`\xe7\x82\xe5F;\x03\xfe&;S\xdb\xcdj`[\xe8\x00[y\xcf6(x\xbb]ʎ;\xe0\x05;\x01Ļ\xec\xa8j춣f\xb0G\xb1o\xafN\xe9O;\x82\xeb_v\xe5\xe6\xfb`\xc8\xfb\xa9\xf3\x03\x1c\xd4A;r\x85C:\x9c\xc3v\x92\xb6#z>j\xe7&\x18x\xf4\xdfvl\xba8\xaeC=\x91n!-\x94\u007f8ғl\xf6\x14\xfb<\r\xb5\x9f\xa1Ŝ%\xa2\x9c\xb3\xe3ك\xf3\xfc\U00082f60\x93\xber\xf1\u007f\u007f]\xcah\xf82\x04}\xc5\x0eF\xf1/B\xdbU;\xe8\xe7\xb5\xff]|\xdd.\x14\xf4\x06\x8e7\x19\xefn\xe1\xb6\xdb\xf8\xea\x0e\xcc\xf1?\xfe㮝\xa4잝\xeb\x9b\xf7\xed(\xb8\xe5r\xf0\xeb\xdc\x0e\xb9/\x8f\x03Δׁ\xf5B\a6c\xe5w\xa8^\v8\b\xe0\x05\x1d\xd8\xffW(\xfd\xef4\x91}\xc0\xc1-F\x85\x1d\xe0\x13E\x1c\xc8i\x1ft\x901?\xe4\x10\xfa\xf9\xb0\x03yGQ\a\xca@\x8f8t\xf5\xb8\x98\x83/\x1cu N\x16\xe7\u007fK8Pn,\xe9\x10u?\xe6\xc0\x82G)\a\x11\xedq\a\xe2\\i\x87\x80t\x19\al\xbf,OO8\xc4\xe8\xca9\x98\xcf>\xe9\xc8\u05faK\xfb\xac\xf2\x0e\xb0\xd6,\x9e\x9er\x88S?\xed\xe0f\xe2g\xf4\xfc\xac\x03ѫ\x82\x03\xb5\x91\x8a\x0e\xa2\xcas\x0e\xf1\x92J\x0e)\xe2>\xef \xaeVv \xd7x\x01Sz\xd1\xc1\x8dYU\x1c\b\x9a/9H\x9a\xab:\xb8Q\xe6e\a6\x9b\xbc\xe2\x80\xda_u %{\x8d\r\xbc\xee@jW\xcd\x01ky\xc3!NT\x1d\xe2\xaf\xe1\x00\x1f~\xd3\x01N\xf9\x16g\xf6v\xfa\xcbN\x1d\xb3j:Ԅ\xdfq\xa00\xf1./\xaa\xe5\x90\x05\xb1\xf7\x1cy릲j;H#\xea8Ȇ\xdfw\bf|\xc0~\xea:\x90p\xd4s0\x95\xaf\x0fa4p\xe0\xd5\x00\rU\xb3\x8d\x1c\b\x15\x8d\x1dL$\x1dt\xec&TSS*\xa6YZ\x97\xe9\xd17\xd7>>B;-\x1c\x88\xa1-\x1dX\x9ai\xc5\xe9\xb6Ɯ\xb23\xe6cs\x80\xde\xdb\x1d\f~\x0e^䄞]\x0e\x8d\xf3n\a\xf6/y\x1c\xdc]\xe5u\xc0\xb1|\x0e&\xac~\x1d\x91\xe1\x90L*\xe0\xc0\xceĠ\x83\x919\xe4@~\x19\xc6\xff\"\x0e\x81\xc0(\xfe\x8eeF`\xaa|\xe2\x14l\x82\x82Lf\xfemQY)\xce>\x87\x06\xd1\x06\xeai\xabw\xb6\xe3\x9d\xed\x1d\xb2?\xbf\x03\x8e\x1d\x1d\\>\xfc\x98\xa2\xec\xe4 xuv\x90\xd4tqH\\\xe9\xea\xc0Ja7\aJR\x9f8\x90h}\xea\x00d}\xe6`\x0e\xf3\xb9\x03\xa1\xa0\xbb\x03\xcf\x16:\xb8\xa6\xdf\xc3!e\xd4/)\x95\xaf\x1c|h\xb2\xa7\x83IT/G\x06\bz\xc3&\xbfv\xc8b\xc27\x0eT\x1f\xbfu\x00j\xbe\xc3\u007f\xfa8\x18g\xfb\xd2\x16\xfaQ\xcf\xfd\x1d \b\x03\x1cJZ\xbe\x87-\rt\b\xb7\x1b\x84a\xfc\xa0\x82\x1f\x9c\xb9d\b\xcd}\xa8\x03qu\x18%8\xdc\xc15\xb8\x11\x0e\x90\xf6\x1f)Ǒ\x0eT\xb5G\xfdo\x90?\xa5g\x9f\x16\xc2h\x8ea\x8cC\x16\x88\xc6:P\xb2\x1bG\x99\x8f\x87\xb0'8$\fMt\x80\\NRӜ\xac\x100\xc5\xc1ll*\x14<\r\x97Nw \u007f\x9d\x81\x81\xcft\b\xec\xcer\b\xed\xff\xd9\xc1z\xfbl\ak8s\x1cL\x8a\xe7»\xe7Qc\xf3\xb5\xe5\x05t˅\x0e2\xc9_\b\x85\x8b\x1cif\xbc\xd8\x01\xaa\xb3\xc4!\xe1\xf9WX\xfco\x18\xeaR\a7\xc8,s`\xdb\xf8r\xb9x\x85CB\xd4\xef\x0e\xc1ޕ\x0eI\x9eW94\x81Z\xed\xe0\x03\x12\x0eTz\xd6:\x84\x86\xac\x83\x82\xfeP\xbc\\\xef\x90e\xbb\r8n\xa4\x1c79\xb0r\xb3\xd9A6\xb1E\x91f\xab\x03Lj\x9b\x03${;\x10{\x87C\x8a\xa3;\x1dL\x8ew9\x10\xd7v\xa3\xb1=\x0e\t\xb9{\xb5\x91?\x1d(I\xffE\x1b\xd9G\xa5\xeewpa\xee@\xc6!\x0e:\xc0\xc7\x0e\xc1\x14\x0e;Pl8\xe2P\x12uT\xe0 '\xeb\x98C\xd3I\ak\xcelj\xb5'0\xb7\u007f\xd4\tN\xea\xf9\x14\x10ᴃ\x19\xea\x19J\xf8,\x9a?\x87\xe3y\xf5\x85\v\x0eng\xb8\xe8к\xc5%\a*_\x97\t\x90WhB\xff:\xb8\xe9\xec\xaa\x03\xa9\xf35\x9a\xdfu\xfe\xf3\x86\x03eқ\xfct\x8b.w[\xf5u\x87\xa0\xff\x9f\x03\xa4\xf4.\xed\xe7\x9eB\xe3}\b,\x97\x93Ox\xe6vB\x8ay\x9c\xf4\xb9\xbcNY;\xcd\xe7\x04\xa9\xcd\xef\x14\x06R\xc0\x99VPNVA'%P\xc8\xc9*\xe6\x03N֭\n;9\xa7\"Nn\x1fz\xd0)D\xe2!\xa7\xd2\xfc\x87\x9d\xac\xbe\x17u2.?\xe2\xc4s\x12N\xac\xb9>\xea\x14+/\xce!\x94p\n\t(\xe9\xc4.\x92ǜ\xac\xed\x97r\x12~\x1ew\x16h\n\xa5\x95vR\xfbe\x9c\xc0\x9a\xb2N\xbc\xc6͉\xc7\xd5\xcb9!\xa1'\x9dx2\xb9\xbc\x93\xaa\xcbrR(O9\xa1\x8f\xa7\x9d\xa8\x90<\xe3\x94\xe0\xf1\xac3\xe3\xbd\x15\x9ciۮ\xe8\x84\xdd<\xe7\xc4k\x1e*\xf1\xca\xe7\x9d\xdcgP\x19\x83}\xc1\t\x81\xbf\x88\x0fU\x9c\x82\xee/\xf1\xab\xaa\x18\xca\xcbN\xb1\xd1W\xf0\xf7\xab\x10\xe6kN\xbe\x89[\xe5T\xcd)\x96\xfa\x86S\xea\x82\xd5eh\xe9\x9ej8\xc5\xe7\xde\xd4+\xder\x92~\xbf\xed$\x89\xae\xe9\xd4$\xe6\x1d\xa7\xb0\xbbw\x9d\xc2\x0ek\xc9xߓCm*\xab\x8e\x0e\xf3}'\xeb\xf3\x1f8\xb1߫.\xba\xab\xe7\x94\x12e}'j\x16\rT\xa6\r\x9d(\x864r2Yi\xac\x9a\xfa\xd0\t\xb7h\x8215u\xa2\xa0\xdd\fZk.\xdd}\xe4\x94\xcd\x17-\x9c\xe0\x96-\x9d@\xeeV\xd4`k'\x9c5\xdbIBas\nHٝ4;\x87S\xab\xabNT\x06\\\xfa\xd1\xedd@\xf18\x19\xfb\xbc\xaa_\x9fS(\x9e\x1f\x124h\x13\x01\xa7`R\xd0\t\xdb\x0e9\xb9\xb2\x16VC\x89`\x84Qm5\xe6DiǤf\xe2NP\xec\x84\x13L1\xc9\x06,\x18w\n\xe2ɁͶ\xd1!\xb4U=\xb4K\x8f\xb4\x93\x91\xd5މ\x85\xe6\x0eN\xa6\xd9\x1d\x9d\\:\xfaXͪ\x93\x93\xb5\xfb\xceN\xd2\xfc.N\xa0MW\x18H7Z\xe9'Nli\xff\xd4\tN\xf3\x99\x13H\xfc\xb9S \xb4;,\xe5\v\n\xb0\x87S\xd6\xfb\xbeL_\x9d\xfe\xffWN\xa0rO'\xe2]/'\x99\u007fo'*\xe6_S/ߠ\x97oU\x86\xdf9\xb9٭\x8f\x13<\xb2/DҏJ\xe9\xefdAa\x00L\xf6{\xa7\x06\xbc\x81\xecd\x90S\xb3\xa8\x1fԊ\x06;\xa5\xe03D\xe7<\xd4ɠ1\x8cm\r\xe7hG\xf0\xde\x1f\x9d\f0#\x9d\xcc\xe1G9Q\x82\xfe\ts\x19\xedD(\x1e\xe3D\xb4\x1b\xeb$\xcf\x18\xc7\x01\x8ew\x02\xfa'\xc0e&:\xb905\x89\x8dO\x86\xe6\xa78A,\xa6\xc2\x18\xa69\x85\xeeL\xa7;\xcdp櫓\x16\xd2L\bq\x16%\xfa\xb3\x13@7\xdb\t\n7\x87\x8a\x98\xeb\x94\\n\x1e\xa6=_\x87\xba@\xe7\xb5\xd0\xc97\b\xfc\xe2\x14\x1a\xb2\xc8\t\xb8\\\xecD%a\tg\xf7\xab\x13\xb4\xeb7\xf4\xbd\xd4)\fd\x99\x131`\xb9\x13\x84q\x05\x15\xf2;u\xbb҉\xea\xdd*\x95\xc5j\xedp\x8d\x13\xf8\xbc\xd6ɤq\x9d\x93\xc8\xfe\x87\x8ec\xbdS\xa2\xc3\x06\xa7\xf0\xfe\x8dN\t\x1f9Y\x9b\xd4\n7;\xc1+\xb78\xb9'f\xab\x93\x95\x8dmNd\x15\u06dd(c\xed\x00&\xec\xc4Tw\x11\xc4v;%\x18\xedqr\xb3\xc7^\x98ٟN\xa6\x8b\xaa\xce}N\xc4\xd8\xfd\xb8\xf2\x80S\v\x12\a\x9d\\:<\xa4\x83=\f7>\x02\x179\n\xd4<F9\xffM\xef:\xee\x04Y:\xe1\xd4\x12\xc9?\x19\xb8:\xe9\x94\xe7dN\x11EO\v(\xa7\x83\xa2\x13;2\xce:\x85j\x9cs\xa2B|\x1eڽ\x80\xe3E\xc8\xf9\x12/\xbe\xec\xd4T\xfd\n\xe4\xfe\xaf\x13\xafn\xbe\xea\x14.p\r\x96\u007f]\x83\xd2\r\xda\xd7M'\x9f/\xbaE\xfb\xba\xad\"\xbc\xa3\xe7\xff\xd0\xeb]'\xf7q\xdcSc\xbcO\xff\xce\xe5¤r\xbbXd\xc8\xe3b\xaa\xe8\x12\xfb\xca\xe7\xc2[i\\\xb8\xb0\x80KL\xa9\xa0\v\x0eXȅ\xe0\xf8\x00\xbe+\xec\x82@\x8a\xb8\x88\x10\x0f\xba\xf4}4.X\xd2\xc3.\x10\xe0\xa2<=\xe2☊\xa1\xe9G]0\xfa\xe2zG\t\x97xnI\x17\b\xd2c.\x81\xbdR.R\x9b\xc7]\xc8CK\xbbT4e\\\x9cEY\x17\x13\x96'\\`\x9c\xe5\\\xb4\xa2']\x8c!\xe5\xd1M\x96\v\xdb͞r\x89\xb5<\xedҐ\xfaL\xfaZ\xa4\x8a.\x91r\x05\x17_=Y\xd1E\x80}\xce\x05\xf5Vr\xc9\x02\xcd\xf3.1\xa3\xca.X\xd8\v.\x1aȋ\x90Q\x15\x17\xe8\xe6K\x94AU\x17r\xc1\x97]4\xf0W\xd8\xf1\xab:\xaa\xd7\\\x12C^\xd7\u007fVs\x11s\xdep\xa5\r/adU\xc78j\xb8\xf4\x85\xa6.\x06\x84\xb7\\b\x86o\xbb\x84\x04\xd7t\xc1E\xdfqѻ\xdeu\x01\xdfk\xb1\xeb\xf7\\\x99\x12]m\x17Yg\x1d\x15\xeb\xfb\x99\x19\u007f\xc0\x1b\xea\xaa\x0e\xea\xe9@\xea\xff\xef\xce\x06.ݘ\xde\xd0\xc5\xe8\xd5\xc8%\xb5\xd2\xc6.q\x82\x0f]d@M\xd8_S\x17\xca\x16\xcd\xd8fs\x97\xb0\xab\x8f\\\x00\xca\x16.lWi\xc9S+\x17\xd7\x17Z\xbb\x90Vd\xe3J\x1b\x8ev\x17\x1e\xb3q\x88r\xd3I#\xd4\xefr\xa1\x0e\xe1\xc6\x05\x1e\x17\x83\xb3\x97\xea\xf5\xb9\x98\xdd\xfb]\x02\x9d\x06\x85\x1dp\x01\v\x82.\x01\x93\x90K\xbc$\xec\x92\x1c.\xe2\xc2\xd2_\xd4ş\xa9p\xa9\xa3\x9a.\xec\u007f\x8b\xebt\x12\xec<\xe9b\x9d\xc8ra\xbbv\xcaE:\x91\xe3b\x8ci\xe3\x02;h\xab6\xde\xce%Q\xb4=\xc6\xd8\x01\x1a\xea\x88\xc1\u007f\x8co:A^\x9d\xd9}\x17\x97Tʺ\xba\x04j\xbb\xb9\x10\xd1?qa\xed\xf8S\x9e>S5|\xae\x03\xea\xaev\xf1\x05\x05\xdc\xc3E\xb0\xfe҅}8tמ.\xbev\xac\x97K\x1fy\xec\r\v\xfd\xdaŲ\xcf7.\tcߺ\xa4\x96\xfd\x9d\x8b\x8c\xb7\x8f\v\xb4\xa7\xaf\vQ\xb6\x9f\vQ\xa2\xbf\x8b\xfcw\x00\xfc\xe4{\x17i\xc4@\x17Wf\x06A\xfb?p\x1c\x83]\f\xf4C\xf4\x96\xa1.\xae9\fs\xf1}2\xc3]\xcc\xcaF\xb8H\xb3~d\u007f#\xd1\xf2(\xea\xe8'\xba\xf6h\x9eƸt\xc1i\xac\xda\xfc8\x97P\xe1\xf1.\xc2\xf4\x04^5\xd1\x05\xc6?I\x1d}2ڛ\xa2\xde:\x95\xd7LS\x8b\x9e\xeeb\x05}\x86Ki\xf8L\x17\xeaV\xb3\xf4\xfb\x9f՜f\xbb\xb0\x9d`\x8e\v\x85\x8d\xb9\x1c\xdc<\xda\xc5|\x9a\xf7\x02\xbdt\xa1\v\x01\xee\x17\x1d\xe2\"\x17+I\x8bU+K\\\xca ~\x85\xac~s\xe1\x11\xb9\xa5.\xa9\a\xa7\x13H\x17\u07be\xb5\xdc%\x11n\x85\v4\xf4w\x176֬\x84\xb9\xaeRW^\x8dOk\\\xa0hk\xd1\xd4:6\xf5\x87\x8b\xb5\xaf\xf5.Ԓ7\xb8\x18a7\xba\x98{m\x82\xd9mvq\xe3\xd6\x16\x17_\xb2\xb3U\x85\xb5\x8d\x10\xbc݅X\xbdÅ\x90\xb4\x13\xa6\xb2\x8b\x92ۭw\xee\xe1%{\xf5\xe3\x9f\f\x03\u007f\xe1\xd2}\x94\xcf~\x9d\xd4\x01\xbd\xe6 o9\xe4\x92\xe8r\u0605H\u007f\xc4%\xbc\xf2\xa8\vk\xf9\xc7x\xc1\xdf.\x89p\xc7]\x12\xb8N\xb8\x18\x84\xfea\xef'iZ\xa7ԚO\xab\x90\xcf0,\x9cu\x81D\x9d\xd3~\xcf3\xf4\\\xd0&.\xba\x90;^ҩ^\x86]\\\xc1\xf1_\x0e\xf8*\xfb\xbf\x961\xb3\xeb\xfc\xfa\x86\x8b\xb5\x87\x9b\x04\x9f[.,\xd7\xdc\x06\xa4\xdcq\xa12\xf5\x9f\v\xd5\xe7\xbb.I<\xee\xf1\x82\xfb\xea[\xb9ܒS\xe4v\xb3\x91<nE\x95\xbcnQD>7\x8aW\xf9\xddb\xc8\x05ܚq\x17\xcc\xfcQ(s\xf5\x03n̰\xb0\x1b\xd5\xda\"n\xf4\xfa\xa0\x1b\x18\xf3\x90\x1b\xfd=\xec\xc6\x18\x8a\xbai\x87\x8f\xb8\xc5B\x8a\xb9\x99m>\xea\x96G\x16\x8a\xe3X\x02ǒn\xd9Y\xfa\x98\x9bfQ\x8aM=\ue9b5\x96vkz_&\xf3GY\xb7h\xed\t\xdcTέ\xcc\xe5I7E[\xdeMw\xca\xd2\xf3Sn\xfe\xa4\x93\x9b\x85\xaag\xf4\xfc\xac\x1b\x9eYA直\xe7\xe7܀\x96Jnf\xbe\xcf\xebՕ\xf5\xfc\x82\x9e_D\xdfUx\xf1KnT\u0aba\xc1-_v+M\u007f\xc5\r\x1e\xfc\xaa\x1b[F^s\v\xb6\xbf\xce\x0f\xd5\xdcHV\xdf\xe0\xa7\xea<\xd5pì\xdetÏ\xder\x83ؾ\xed\xc6\x0f\x97\xd4t\vL\xbf\xe3FX\u007f\x97\xf2\xaf\xe5f`~\xcf-f[\xdb-<\xb2NZfx\x1f\xb8[\xb8\xcd\ana!u\xf1\xffznD\xb7\xfan\xe6y\rܒ\xcb6t\v\xdfo\xc4\u007f5v\x8b\x91\u007f\xe8f\x99\xb3\tGӔ\xa7fn\x16\x0e\x9aC\x91\x1f\xb9a\xdb-TA-\xd1Y+\f\xb1\xb5\x9bl.\x1b\xdf\xd9({\xbb\x1b\x9c\xd5\xe1N\xa7\xa2N72_\x976\xe8\xc6\b<n\xa4\xa4^*\xde\xc7\xe6\xfdn\x89\x00\x86[\xcc8\x80c\x10\x8d\x86t\x8ea|\x17\xc1좼%\x86\x0f\xa6\x1b\xa1;\xae*M\xf0c\x92\x8d[h#\xe5\xc6&\x9a\x1c7v+\xb5\xc1\xd0ۺ\xc9\xd6\xdaq\xd0\xed\xd5~:\xb8%\x1evt#\x1e~\x9c\x96\xb9\xd1\xc1\xc8\xea\xc4k:\xbb\xb9\x1e\xd3ō\xc7\x10ݒ}ws\xa3\x80\xf5\t\xa4\xf9\xa9\x1b\xa8\xf5\x99\x9b\xd8\xf0\xb9[ \xa9\xbb\x1b\x8b\x18_\xb8\xc1\n{\xe0\xae/\xd9\xe0Wn\x14({\xbaQ\x8d\xebE\xfb\xea\xed\xc6\x1b\x02\xbevc\xab*\xda\xfd\x96*\xfbN$\xda\a:\xe9\xebf\xac\xef\xe7Fٲ\xbf\x9b\xd8<\x00\xad\u007f\xef\xc6f\x92\x81z\xcd |\xf9\x83\x1b\xa87\x98M\r\x81A\fus!|\x98N~\xb8[\xa8\xfd\b7hҏt\xea\x91n\xa9f\x8erc\xfd\xe4'\x9eF\xbbu\x83\x0e\x140V[\x19\a$\x19\xefF\xea5\x81\x12\x9c\xe8\x06C\x9a\x04\xa9Nv3\x12N\xc1mS\xdd\b^\xd3\x00F\xd3\xddأ=Í\b6\xd3MV8ˍ\x9c\xe1g7\x8aF\xb3\xe9\xc3s\xdc\xd8\xea1\u05ed\xab\x11\xf3(\xc4\xf9\x98\xd1\x02\xb7\x00\xf8B\xe0\xde/n\xd4:\x17\xb9\x85`,־\x97hӿ\xd2\xe1~\x13\xc1\xb53\xb3\x96\xbaI\u0097\x89謬\xe5t\xee\x15\x1c\xd5\xefn\xe4*+ݬN\xae\xe2\xd4V\xc3\nָӈ\xdf.\x9d7\xba\xa5\xe6\xba\x0e\"\xf8Í\xed\xa9\xebE]\x1b0\xbd\x8dD\xcdMnl\xab\xd8\fSނqm\x05\"ns\xa3\xb4\xb9\xddM*\xbbC{ډ.v\xb9\xa5\x92\xb9\x9b\xae\xb9\aw\xed%&\xfc\x89\xd9\xfe\xe5F\x00\xdc\xe7\x96P\xbc\x1f\x92>\x00#9\xa8\xcd\x1c\xe2Շ)\xbf#n>\xe3qԍծc\xb8\xe1o\xda\xdeq7i\xf8\t\xb7\u058b\xffq\x93\xe8\x9d\xd4\u007f\x9c\x929\x9d\x96\xc3\x19\x18\xf7Y\xb7,z\x9ds\xcb\xee\x9e\xf3n\xae\xd3^p\x83\xc8\\\u0530sIϗ\xddH\x87\xaf\xa0\xbf\u007f9\x96\xabjx\xd7\xdc$j\xd7is7ԁn\xba\x95\x1b\xdd\x028\xdcvs'\xc9\x1d7\xc2\xe9\u007fn\xac^\xdc\xe5<\xee\x11H\xefcX\xb9<L\xc1s{\xb0r\x9fǃ\x946\xaf\a\x946\x9f\x87\x9d\xe6\xf7\x80\xa6\x14\xf0\x90\xf3\x17\xf4h\xec-\x94\xf9\xe3\x01\x8f\xd0\xd8\xc2\x1e,\xb8\x16\xf1 \xb5|\xd0#\xb6\xfb\x10[z\xd8#\x9eU\xd4\x03;{ă\xdaU1\x9e\x1e\xf5\xc8c\x99\xc5=\x12\x06Jx\xb0\xce_\xd2#\x1e\xfd\x18\x8e\xa5<\xf4\x99\xc7=\xa8\x82\x95橌\x87[K\xcaz\x80aOx\x10i\xcayT\x19Oz\xb0\xb7\xa0\xbc\x87\x0f\xda{h\xb2Oy\x00:Og\xaez\xc6\x03m?\xeb\x81F+x$PT\xf4\xc0מ\xf3\x90_W\xf2\x00\x04\x9e\xf7p\xa7Ee\x8c\xf5\x05v\xfa\xa26[\xc5Ch\u007f\tS\xa8\xca>_\xf6\xf0w\f=\xb2*\xf9\xaaG\xf9\xe4k\x1e\x91\xf9\xeb췚\x87\xd8\xf0\x86\x87j\xaf\xeeA\xad\xa9\x86\a\x9b\b\xde\xf4H\x00x\xcb#v\xfd\xb6\av[\xd3\x03\xc3~\xc7\x03\x9e\xfb.\x87]\xcb#\xb5S\x0f(Wm*\xb1\x8e\a\x0f\xdcs&\x1fx\xc0\x16\xebz\x10K\xeby\xc4\xdc\xeb\xe3\xd8\xc0C\x92\xd5\xd0â_#\x8f.g7\xe6-\x1fz\x88\x8aM<\x82\xacM1\xf4f\x1e\xe6\a\xcd=@\xbe\x8f(\x89\x16\xec\xaa%O\xad8\xbd\xd6zi\xb6\apj\xf3\x00\xd5\xed\x1eRl\x87\xa7\xb0\xec\xc4m\x1f3SF\x96\xd3\x03N\xe7B\x17n\xcf\x03\x8dÝ\xe4?\xe9\xf8\xe7AP\xf4zĨ}\x1eP(\xbf\a\xbf\x06\xe5\xe1Jb\xc0\xc3W/\x06=LdB\x1e\xfaG\x98\x8a\x8bx\xa4:\x10\xf5 Ŏa\"\xa6\xaa6\xee\xa1\x13&<\x92\xdd%9hK\x15\x9d\xf2\xb0|\x9a\xe3\xc1KSڨ(\xdazX%h\xe7A\x92מ\xff\xed\x00qv\xa4\xc6?\xf6\xa0\xc4\xd5I{\xe9\xacR\xe8\xe2Q\xb6\xd8\xd5\xc3\xe8\xdb\xcd\xc3\xca\xd4'\x1e&\x9f\x9fz\x80x\x9fy\x10\x91>\xf70\xdfꎙ\u007fA1\xf4\xf0hU\xebK\xb5\xb8\xaf\xf4\xdc\xd3#Ѩ\x97\a\xcfI\xf5\xf6\b\xbc\u007f\xedњ\xca7\x1e<\x05\xf2-O\xdfy\x00\x1b}x\xea\vQ\xf6\x83\xd8\xfb{$\xa3\x1d\xe0a\xe0\xfeޣ\x8b\xbc\x03=$\x15\x83\xf0\xef\x1f\xa8\xa8\xc1\x1eb\xdc\x10*|(Ac\x98\x8ef8a`\x84N\xf4G=\x8f\U0010090d\xf2\xb0&\xf5\x13]v\xb4\ady\x8c\xb68փLx\x1cm{\xbc\xaah\x02?N\xa4\xb5M\xd2~&\xc37\xa6x\x10c\xa6z\x80\x99\xd3<\x82\xb2\xd3q\x9c\x81\xff\xcf\x14\xff\x98\xa5@\xf6345\xdb\x03R4\xc7#!h.d0\xcf#\xb5\xc0\xf9\x90\xe3\x02\x8aj!\xf5\xf9\x8bG8\xd0\"5\xdb\xc5\x14\xdc\x12\x8f\xc6F\x8f<.\xf1\x1b\x04\xb8ԃ躌\xfe\xbf\x9cw\xaf\xa0\x19\xfe\xee\x11(_I\x17X\xa52^\xad\xe75jkk=,\x19\xacÈ\xfe\x00|\xaeW\xebؠ\xff\xdb\xe8A\xb8\xddD\xc1o\xa6\xd1n\xe1ܷz\x18\x13\xb7y\xf80\xd8v\x0f_\x8f\xb7\xc3\xc3ȴS\xfb٥\xe7\xdd\x1c\xe2\x1e\xb6\xb5\x97\xa7?y\xfa\x8bM\xee\xe3\xa7\xfd\x1e\xdd\xfew\x80\xea9\x98\xf9|\xc8\xc3\xf2\xc0\xe1\f\xc0\x1d\xf1\xb0\xd8pԃ0~L\x87\U000b778f{\xb0\xfaw\xc2\xc3\xcc\xfd\x1f\x0fH\xd2IU\xf3)L\xf9\xb4\xfe\xf3Lz\xaa\xe1D\xd6Y8\xed9O\xbe\xe6\x9dҁ\x93\xa7\v\x1e>\xe9r\x91\x88y\x89\xa7\xcbP\xee\x15h\xfd_\x8f$~W=\xc2Ȯ\x11=\xaf{\xb8\xa0|#c\xda7q\xe5-\x9a\xe5m\x0e\xf8\x8e\x87\xebl\xffy\xf27\x8f\x19\xed\xb3\xee\xf2\xeb{\xbc\xe8\xbeG(J.\xaf(=\xb7Wr\x88<^@r^\xaf\x84\xf5|^:m~\xaf\x16\xdc\nxQ\x1e-\xe8\x05Z\x14\xe2\xb5\x0fxAD\v{e\x01\xbf\x88\x17c{\xd0+*\u007f\xc8+$\xe5a/\xd6H\x8az\xa1\xdbG\xbc\xea\xf3żܽ\xf8\xa8\x17\xa4\xae\xb8W\xea\x8a%\xbc\xe0{%\xd1\xd6c^\xbcN\xa4\x94W\x06\xf9\xb8\x97\xa5\xd4\xd2젌\x97\x8a*\xeb\x157~\x82_\x96\xf3\x8a\xd1?镤\xb1\xbc\x175U\x1c\x9f\xf22\ayڋ\xc7'\x9e\xf1R&\xcfz\xa5\xdaU!3\xb9\x8a\x1c\xc8s^\x8d\xa6\x95\xbc\\\xff{\xdeKmV\xf6\xb2\xa8\xf1\x02\xa7\xfd\xa2\x17\\\xa7\nf\xfa\x92\x97\x9b,\xab\xb2\x8d\x97\xbd0\xabW\xbc\xacҾ\xaa\xfd\xbf\x96\x99\xfb\xeb^<\xbf\\͋\xe2\xd3\x1b\xbc\xa9:\x05Tëy\ue6fc\xe8-\xaf0\x8d\xb7\xbd\x12wkzA\x03\xde\U0004257e\xeb\x95rk-/6辗\x19vm\xaf\x14|\xebx\x85\x12\xbe\xcf&?\xf0JE\xb7.\xe4X\x0f\x12\xa9\xaf\xe3m\xa0#k\xe8-\xd8\xca\xe8\xda1\x1d\xba\x1ayi\xad\x8d\xbdXZ\xf9Ы\x8e\xd0\xc4\v\xa0h\x8av\x9byA֛{\xf9b\U000cff28y\xb4\xf0jB\xdc\xd2\xcb\x04\xab\x95\x17\xe9`k\xaf\xb0\xd8l/W2m\x9c\x83\x1d\x13r\xe0_N\x1d\x8d+#\x1f\xb7W\xb7\x95{\xbc\x84\v/\xc6\ue8da\xfd0+\x83\xb6\x18\xf0f\x1e\xcc\f\u0080C鱤\xa7\x1c\xf6\xf2\xe7\x131ܨj0\xa6\xad\x99\xb4ظ\x97uڄv\x9fTuY^\x16W\xbd\xc8\xder\xbc@\xbc6^\"n[/\x88B;/\xe8G{\x95_\a/\xb7\x15t\xf42\xae~\xece\x89\xab\x93\x9e;{Y'\xef\xc2ۺz\x81\xffݼ$,\x9fxA\x89?\xe5\xe93/^\xf6\xed\x05Ru\xf7\n\x89\xfb\xc2KF\xd3\x03B\xfbҫ\x1b\x13\xbe\xf2f\x16\xc8{\xc2\xe6{yY\x85\xeb\rI|\xedEl\xfb\xc6\v\xfa\xf5\xed\xff\xe4\xf4\x1d\x8d\xb3\x8fW\xd8h_/\xde\xcbя\x93\xec\x0f\xdb\x19\xe0\x15\xba\xf5\xbdWpj \xe58\xc8+\x9b\xdc\u007f\xf0\x12\xb4\a\xc3φx\xb1\xa9k\xa8\x97\xe8;\f\xed\r\xf7\xeav\x1c/\t\xfb\x8f^Y\x99\x18\t\xf5\x8d\xf22)\xf9\xc9\xcbղ\xd1^\x14\x03\xc6x\x15\xbf\xc6\xc24\xc7Q\xc9\xe3\xbd\xcc\xda&\xf0\xe3D/\xf2\xb1I0\xf9\xc9^\xc0\xec\x14/\x8bNS\xbd\xc2)\xa6qZ\xd31\xd2\x19\xda\xc5L\x15\xdc,\x8a\xf6g\xc0\xdal\x85\xb59\xde\xcc/Iy\xc1\xe9\xe7y\x91\xb1·\xfc\x17x\xf1\xac\x87\x17\xb5\x84_\xbc\xe46\x8b\xbc\xa4K\x8b\xbd\xc8N\x97xɉ~\xe5U\xbf\xa9\xf8\x97z%|.\xc3q\xb9\xcac\x85\x17ώ\xff\xee\x95U\xb7\x95\x99\x19\xaf\xa2\x04V{Q@Z\xe3\x95Dr-\x9di\x9d\x17\x14\xef\x0f\x82\xc0zE\xbf\r^f7\x1b\xd9\xdc&/\vi\x9b\xbd\xd8N\xb0E\a\xb0\x95\xedm\xe3i;\xed`\x87W\xb8\xc0N/v\xce\xec\xf2\x82\x80\xed\xf6\"\xb6\xef\xf1\x92\xd1\xec%\x10\xfd\t\xfd\xff\x05m\xec\xa3\x13\xecW\xcf9\x00Q\x1f\xf4J0:\xe4\xc5j\xc7a\x9d\xe1\x91\fn\x1d\x85\xe1\x1c\xe3\xd4\xfe\xce\xd8\xea\xf1t\xc79\xc1\xac\x13^\xeeA\xfe\a&zҫ\xa4\xee\x94\x17\f\xe6\xb4\x17L\xeb\fOguX\xe70\x9e\xf3\xb4\xc4\vj\x83\x17\xd5\x1f/\xa9\x86/\xabj\xaex\x91d\xea\xb7W9\xc1k^D\xbd\xeb\xf4\xa9\x1b\xfaϛ0\xe3[^\xa9\x18\xdcVIޡ\xf4\xff\xf3b\xbd\xec.?\xddSL\xbc\xaf^\x9eˇ\x1d\x87\xb9}\xdc}\x9a\xc7'\x92\xca\xeb\xc3O\x0e\xfb\xf8Xu~\x1f \xa6\x80O\x18@A\x1f\xfa-\x84\xeb\x1e\xf0q\x0fba\x9fH\xa0\b\xbe{\x10LJ|R\x10x؇\x97\x04\x14\xf5!\xca<\x82\xef\x8a\xf1ã<\x15\xf7q8%|\xac\xe0\x95\xf4a\x92\x8f\xf9\x04\x16K\xf9\x10-}\xcc\x1aJ\xfbD\x17e|\xa8B\x96\xf5\xa1\xf0\xf1\x84O\x99{9\x9f\xb0\x89'}̸\xcb\xfbD\x1aY>\x85\xe0\xa7|\xe0\xa6O\xfb\xc0\xfe\x9fA\xab\xcf\xe2\x92\n>\xc1Ԋ>\xca\xff9\xf4Z\xc9G>\xf4\xbcO\x96\xb4*\xfbH\x9a^\xf01b\xbe\x88\xe9U\xc1}/\xf9H\xea\xaa\xfa\x10\xfb^\xf6\xb1T\xfc\x8a\x0f\x9b0^\xf5qU\xe55m\xe1u\x1f\xc0\xabZfTod\xc6^ݧ\x96S\xc3\xc7g\a\xde\xf4\xf17\x863\u07ff\r\xf1\xd6\xc4\xf1\x1d\x1f\xea\xdd\xef\xf2\x92Z>}\xe4ÇrU\xed\xf4?ӆZ\xc7'\xbb\xe5\xde\xc7\xf5\x1f\xf8\xb0\xa8Q7\xadK#jf\xd5\xf3\xe1\xf5\xe4\xf5}\x84\x9b\x06l\xa6\xa1\x0f\x9e\xd4(\xd3ac\x15\xf9\x87\x98f\x13\xfe\xb7)gٌ\xc2l\xeeCQ\x15\xc7\x16>\xc0UK\x1fӼV>\xb1\xf1\xd68f\xfb\xf8ت\xcd\a\xeb\xb3\xfb\x80\x80\x0e~r\xf2\xe4\x82H\xdd8zp\xf4\xe2\xe8\xf3a稟'\xc3\xc7@\x1c\xf01\xfc\x04}\xd8t\x19\xf2\x11\x88ô\xcb\bOQ\x9f\x00V\x8cFb\xfa\xb0\f\x14\xf71h'\xd4Ԓ>,\x15Y*\xf4\x94\x8fN\x97\xe3\xe3F\x866\x19=\xb5\xf5\xd1K۱\xb5\xf6<u\xf0q+dG\x1f\xe0\xf3c\b\xa2\x93\x8fP\xdd٧\xec\xa1\v&\xd2\xd5\xc7\x02|7\x1f\n\xb8\x9f@1\x9f\xb2\x9d\xcf|\xccV>\x87Uv\xd7+\xbf\xf0)\x03\xea\xe1\x93\xc7F\xbe\u052f\xbfRS\xea\xe9\x03\xb8\xf5\xf2\t_\xeb\xed\x03 |\xed\xc3k\xc0\xbe\xf1\xe9\x1b\xdf|\\]\xfd\x0ej\xe8\xe3\x03\xb1\xea듽.\xfd|\x1a+\xfaS\x1b\x03|\xf8\xbdEm{\xa0O`q\x90\x8f\xab\xb1?\xf8\xf8\xb3\xf9>D\x95!\xfa\xedP\x9f\xbcyc\x98\x0f\xaf#\x1b\x8eQ\x8c\xe0\x85?\x029F\xfa\x14?G\xb1\x87\x9f\xf4\xbe\xd1>2\xdd1ln,\xb44\xce\a\xbc\x1c\xefC؞\xa0\x16=\x91\xe2\x99\xe4\x03;\x9b\xac\xf04ŧ\x14n*\xc45\x8dS\x9f\xee\x035\x9c\xa1ҟ\xe9\x03#\x99\xc5o\u007f\xc6\xf0fg\x04:G\xd5;\x97\xed\xcf\xc3L\xe6g\xfe\xbb \xf3\xc7B\xfa\xc9/\xf8\xf7\"\x9f\x96\xd2\x16S\x81K|L\x88\u007fe\x0f\xbf\xe9ǥ4\xe7e>Th\x96\xfb\x98A\xae\xf0i\x80\xfc݇Ű\x95>)\x01\xac\xf2!\xe0\xac\xf6!ڮ\x81E\xac\x85\xb1\xac\xf3\xc9k\xcb\xfe\xf0\xa1 \xbf\xde\a\xa6\xba\xc1\xc7(\xbfч\x02\xeb&\x18\xdbf^\xb2\x85\xa7\xad>F\xb5m>\xec\x97۞\xd6b8k\a\x8e;} j\xbb\xa0\x9a\xdd\xc4\xdd=>,\xc5\xed\xa5~\xfeT\xfb\xfa\xcb\xc7\x15\xa4}\x90\xd9~\x1fX\xe9\x01\xb5\xff\x83>\xae\xc2\x1c\xf2\xa1Px\x98\xa7#\x19S?\x9a\x11\xd21\xe0\xf4\xdf\x18\xe3q\xfc}\x02\xcd\xfd\xe3\x93\xc4\xff\xa4\x0f\xec\xe5\x14\xc1\xe4\xb4\x1aƙL+g}\x8c\xa9\xe7`\x1a\xe7U\xed\x178̋\x98\xc1%\x1fꐗ}\\ȹ\xe2Þ\x84\u007f}X\x15\xb9\xea#i\xbd\xe6cx\xbb\xee\xc3&\xc0\x1b>}T\xe2\xa6\x0f{\xa7o\xe9\x84o+\xf2ߡ:\xfe\xf3\x91\x1b\xddE \xb8\xc7\xd0x\x9f\xe1/\x97\x9f\x0e\x95ۏ\xfe\xf2\xf8ɗ\xf2\xfae\x86\xf9\xfc\xf2DW~\xbf\x9a}\x01\u007f\x86\xa0\x16\xf4K\xd0,\xe4G\xb4\xf4\xc3\x00\n\xfb\x19_\x8a\xf8!\xc0\a\xfdH\x13\x1f\xf2\x83\a>\x9c>ɏa\xf8\xe9ŏ\xf8\x81\xde\xc5\xfcXZy\xd4/\x11\xa9\xb8\x1f\xe9\u007f\t\xbf\x9ajI?\x12L\xbf\xd0\xc1R~\xa4\x99\x8f\xfb\xa5\xdaY\xda/\xb3(\x83\x11\x94\xf5\xcbN\xed'\xfc\xfa|\xa4\x1f\xbf\xca\xefg\x8ePޏh\xe9\a\xa6<\x85\xa1>\xed\x17\x10x\xc6\xcf\xdf\xe3\xf7\x8b\xafU\xf0\x8bB+\xfa\x89\x96\xcf\xf9\x89\u0095\xfc\\\xb2y\xde/\x95\x98\xca~>\xcc\xf1\x02\xeex\xd1/j\xaf\xe2\x17\xdb~\x89MU\xf5c\u007f\xf7\xcb~\x86\xc6W\xfcT\xff\xab~\xa6\x16\xaf\xf9ս_\xf7\v$U\U000c3c3dᗼ\xa1:Z\xab\x81\xe3\x9b~\x18\xf9[\xfeB\x8ds\xda\x19\xe1v\x1d\xb3\xde\xf6\xb3\x94Wӏ:\xe4;~\xa0ѻ\xfe\xbc\x8dͬZ\x98\xd2{~8|m?ܥ\x8e\x1f\xc8\xf1\xbe\x1f\xde\xf0\x01Z\xad\xebG\xa9\xac\x9e\x9f{\xa6\xeb\xfbui\xa6\x81_\x12\xbb\x86~\xd8`#?\x1f\xedPI~\xe8'\xb5o\x92\x19yS?J\x85\xcd\xfc\xa8\xea7\xf7\xb3*\xff\x91\x1f\x11\xb2\x856\xdd\x12\xfd\xb5\xf23\b\xb7\xf6\x03\x04\xb2\xfdyZf\xd9\xfcؘm\xf7\xa3j\xe2P3p\xfa\x19(yrs&\x1e?\xa0ы\xd9\xf9\xfcj\xe0~U\x81\xe1\a\xef\f\xf0\x96\xa0_\xea\xa8!H5\xcc\xdb#~ť(\xac*\xe6G\xf80\xfd\xf2\x00L\xdc/շ\x84\x9f\xa15\xe9\xa7\xe3[~r\xb5\x94\x9f\xb4'\a\xb3h\xe3G!\xa2\xad\x1f\x15\xb6vj\x1f\xed\xfdxʭ\x83_\xf0\xb3#\a\xf1\xb1?OݬNi\x89t\xe9\xd81\xab\xb36\xdeŏ\x80\xdd\xd5\x0f_\xeb旜\xe2\x13Z\xf8\xa7~l_\xfa\xccOP\xfa\xdc\xcf\x00\xdd]\xcf_\xa8\xe9\xf5\x80y|\xe9ǂ\xc5W~\xa6\xc7=9\x9c^~\x81\x91\xde8~\xed\xe7\v\xe20\xeao\xfd\xd8\x11\xf8\x1d\xa5\xd4\xc7/\xf5\xfc\xbe~,A\xf4\xa3\xea\xfa\xd3T\a\xe0_\xdfû\x06Bԃ\xfc\x84\x98\x1f8\xab\xc1ho\x88\x1f\xf9\xd6P?\xaa\x04\xc3p\xe1p\xd5\xf6\b\x85\x8a\x1fUn#\xfd\x1a\u007fG\xb1\x85\x9f\x00!\xa3q\x1cC?\x19\xeb\x17\xe6?ί\x8fK\x8e\xf73\xb9\x9e\xa0\xfe2\x11\xedO\xe2\x1c'\xe3\xda)~\xbc\xc9e*E7MD=ݏ\x95\xa1\x19\xeal3uܳ\xd0\xd1\xcfD\x9f\xd9\xda\xe2\x1c?R\x9c\xb9\x9c\xc6<?\xea\xbf\xf3\xfd@\xda\x05\x19X[\xe8\xc7O\xc2\xfe\x82\x0e\x17\x01\x0f\x16\xfb\xb9\x17i\x89\x9e\u007fU\\\xf8͏\xc0\xb5\xd4/\x88\xbdL\xbd`\xb9\x1a\xd2\n?։~\x87\xe4V\xfa\xb1.\xb2\x8a\xfa[\r\x1cY\xe3g\xf2\xb7V\x11j\x9d\x1f\xd4\xf9\x0f?\xca-\xeb\xfdZw͈g\xa3\x1f\xc1d\x93\x1a\xc4f?\n\x82[0\xc0\xad\xd4\xf06\x98\xc0v?\xa8\xe4\x0e\xbf$\xa7;U\x1d\xbb\b&\xbb\xa1\xe8=8\xee\xf5\xa3(\xf8\xa7_â\x9f[\xbf\xf7\xc1\n\xf6\xfb\x11R\x0e`\xf4\a\xfd\xac\xfc\x1d\xf23\x81\xf4\x83\x11\x1c\xa1b\x8f\x8a\x16\x8e\xf9\xf1\xd8\xe3\xdf\nP\xc7\xfd\xe47'Ԋ\xff\xf1\xb3\xe4p\x120}ʏ틧3\x16r\x06\xfes\x96Z9G\x8b<\xcfk.\xf8A\xdd/\xaa\xe0/Qe\x97\xa9\xff+t\x9d\u007f3>~\xd5ϝ\xfe\u05c8N\xd73hu\xc3ύ\xdc7\xfd\xba\xab\xed\x96_^\x89x[\xb5x\a\xee\xf8\x9f\x9fQ\xf8.'~Ogr\x1f\xa2\xcae\xd0\xe1r\x1bTU\x1e\x03c\xcdk\xd0\xe8\xf2\x19\x10H~C\x1e\xbe.`\xd0\x02\v\xf2\xcbB\x86\xe8\xe4\x01\x1c\v\x1b\xc8 \xf5\xae\a\r\xda\xfbC\x06\x8c\xf4a\xfc\xb3\xa8!F\xff\x88\xc1\xbdz\xc5\f\xca\xefQ\x03\xc0Q\xdc`\xeeQ\xc2@\xfeX\xd2HK\xfe1\x83\f\xa1\x94\x81\x97\xd6>n\b\xa8\x95Ʊ\f:-k\xc8\x02\xd4\x13\x06\xc4Z\xce\x00\x10=i\xe0\t\x8f\xf2\x068S\x96\x019>ep\xcaO\x1bx\xee\xfc\x19\x83\v\x9c\xcf\x1a`\x06\x15\f\x04\x9b\x8a\x06\xca\xff\xcf\xf1Tɀ\xf3=o\x103+\xb3\xa1\x17\fٗ\xf6\"\x8eU\f\xbc*\xd5\x00Y\xadj\xe8o\x12\x1b\xaa\x99W\f\xb1\xdeW\r\t\xe4\xaf\x19b\x1b\xaf\x1b\x19RQ\xcd\x10'y\xc3@$\xaaN\x01\xd40\x94\x0e\xbc\xa9\x82y\xcb\xc0\x8a\xd3\xdb\x066[\xd64\x98\x19\xbfcH\x8d\xf9]\xdeSˠüǖj\x1b\xd0o\x1dm\xe0}\x83\xc1\xe7\x03Cܽ\xae\x81\xfd\xe6\xf5\f\xe4\xd0\xf5)\xe6\x06\x86T\xc4\x1a\x1a\x12V\x1a\xa9r\x1b\x1b\xe0G\x1ff&҄3o\xaa\x03hfpGzs\n\xed#\x03\xe9l\v\x830\xd4\xd2 ;oeH\r\xb0\xb5\x81b\xab\x01\xaf\xb7\x19\b[v\x03\xd6\xef\xe0\xc9ɓ\xcb\xe0[Si.\x1eCX\xaf\xd7\xd0\xfc\xcdg\xe8\x0f\xf5\x1bR42\x8c\xcc\xd6ۀ\x01\xac\x0e\x1at\xa0\x10\x15\x166𪸈\x81zS\xd4\xe0\xab\xe4(/\xd3\xd0\xe7\x1e\ra{\tUY\xd2\x00\xdcX\x14Iʐ|+\xc7\xd0]_mh\xeam\r\xa6\xc1\xed\xd8g{\x95U\aξ\xa3J\xfcc\x83\xb0\xd7\xc9 \r\xedl\b1\xebb\x80xt5P\xe6\xeaf\xb0\xe0\xff\t\xac\xe7S\x1c?\x835\u007fn\xb0~\xdb\xdd`\xa9\xe9\v\x95i\x0f\x03!\xe5KC\xf9\xf9Wl\xaf\xa7\x8a\xa5\x97\xa1X\xd3\x1bm}mHz\xf2\x8d\xc10\xfe-\xbd\xf9;\x03\xd9P\x1f\x83h\xd1\xd7`\xc2\xd3\xcf\xe0\xe3\xfa\xfd\xa9\x9a\x01*\x9e\xefu \x03\xe9\t\x83(\xc3\x1f\x14(\x06g\xfa\x1bB\x81\r\xe5i\x98!p:\x1c\xc7\x11\x06\xa0\xedG\x03\xc0<\xd2\xe0\xcbu\f0\xbb\x9fx\x1a\r\x17\x1ac\xa0\x161\xd6\x10\x98\x1ag\x90N\x8d7\x90\xb6L\xa0sN4@\xea&\xf149#\x84)\x06b\xfdT\xccy\x9a\xa1\x9bYi?3\ff\xc23U\x90\xb3\f\x04L\x9a\xdalv9ǐ\xbc|\xae\xde8\x8f#\x9do\xe8\"\xfd\x02C(\xc9B\x00\xd6/\x06H\xec\"\xbdt\xb1\x01\x80^\xc2)\xfe\xca\x1b\u007f\xd3\x1e\x97\xaaI-\xe3薫\x9cW\x18xz\xfbwEŕ\x06\xf76\xac2P\f]\xcd\xd3\x1a(n-\xbd~\x9d\x01\xfa\xf5\a\x1d{\xbd\xc1\fn\x03<`\xa3\x81\x15\x97M\x18\xddf\x03\xe1q\x8b!o`\xddj`G\xca6\x83\x99\xcev\x03\xe1~\x87\xc17\xcd\x01,w\xf1\xfa\xdd\x04\xcb=\x06\xb6\x9d\xee5\xb0w\xe5O\x9a\xc1_\xb0\xc6}T\xeb~\x03Y\xc5\x01\x83\xcb\x13\a\xd1\xc8!\xfdt\x98\xba<\x02%\x1c\x85\xcb\x1fcg\u007f\xb3\xeb\xe3\x1aTN\xd0d\xff!6\x9f\xe4\xe9\x14\xc7pZa\xea\f\x90\xed,\xaf<g(w?\x9f\xf9\xe3\x02\xbd\u0881\xdf\xf17P\x90\xbel`q\xe4J\xc6\"\xff%&]5\xc8/\xae\xe90\xafsL7T,75H\xdd2\xf8\xee\x82\xdbz\xf9\x1d \xf6\u007f\xc0껪\xaa{t\xf0\xfb\x90u\xae\x00\xfd#w\x00\xcfj\xe5\tHq-o\x80\x04\"_\x00v\x95?\xc0\x1d5\x05\xf4\\Pυ\x02\x12@\x1f\b\x80\xf1\x15\x0e\x88A\x16\t\x90I<\x18\x10\xf8}(\x80$\xe2\xe1\x00\xd7\u008b\x06\xf0^\xf1\x80άX@V\xcd\x1e\r\x80\x01\x17G[%\xf4\xf6\x92\x01-\xfa=\x16\x009*\x95\xf9\xfcx\x80K\xf9\xa5\x034\xb72\x01QS\xd9\x00\xb2\x8e'\x02 \x12\xe5\x02\xe9t5\x9dI\xf2\xcb\xf2\x01\x91@V\x009\xd5S\x01\xf0\xba\xa7\xf1\xdd3\x01@\xc1\xb3\x01\xd4/*\x04\xb8͠\xa2\xf6\xf0\\ \x13\xd9*ah\xcf\xeb\xd0*s\xbc/\x04\xf0\xda9\xfd\xb2J\x00j\u007f) 8[\x15\xd3|Y\xdby\x05\x9f^\xc5\xf1\xb5\x009\xdb\xeb\x01\x18`\xb5\x80x\xc7\x1b\x01Ɉ\xab\xe3X\x03\xc77\x03i\xa2\xf0\x16G\xfcv@\x02]\xcd\x00\xdc\xe3\x1d\xfc\xfb]|U+\xc0g\xa5\xdf\v\xe0a\xd2\xda\x01\xf2\xa1:\x01R\xb7\xf7\x03\xba\xc2\xf7A@Q\xbfn@\xf4]\x0f\xc7\xfa\x01\xd6-\x1b\xa0\xc1\x86\x01\xf0\xecF\x9cD\xe3\x00w8\u007f\x18\xc8\xd3*\xabI\x00eʦ\x01l\x91o\x16@\x06\xd8< \u0560\x8f\x02B<[\x04\xa4\xc6\xdd2 \x99|\xab\xb4\x9e\xf1\x9eՀ\xd8sv\xa0`\x03Ò<\xd8\x16\xc0\xfe#{\x00UIG@c\xa03\xc0\x9a\xa7+\xc0\xc8\xe2\x86H=\x01Y_\xf2\x06\x006\xbe\x80\xfe\xf8p\x00[\x82\f\f>\x10\x10\xfe\x11\f\xa0\n\x11\x82م\xd9t$\xc0\x10\x16\r\xf0Us\x01\xa4\xd5f\x00\xa5\xe2x\x00\xee\x9b\b\x803$\x03\xf4P+\x80\xdaK*\x80bFN\x00\xb5\xb46\x01<\xd7\xd4\x16Jk\xa7\x8d\xb6\xe7%\x1dhV\x1d1؏1\xd3N\x01\x81\xb0θ\xbaK@P\xb6+\a\xd0- \x19\xee'\xa2\xceO\x03\xc8\x16>\vpO\xc1\xe7\x19'\xe8\x0eS\xfc\x82\xa2\xef\x11P`\xf8R\xb5\xf9U\x80e\x99\x9e\x01q\xe0^\x01T\x97{Ci_\xd3\xed\xbe\xa1\x8b~\v5|\x17\x00\xea\xf6\tpY\xa0o@\xe9W\xbf\x00\xe8N\xff\x00R\x92\x01\x01ɭ\xbf\x87,\a\xd2C\a\xc9\x1di\xd0\xfc!\x80u\xae\xc1\x01<Q8$\x80W\xf4\x0fU\xfd\f\v =\x1d\xcekF`\xea?\x06\xb0F9\x12ݏ\x82\x1c~\n\xc8\x1a\xea\xe8\x00\xc9\xc5\x18\xaail\x00\xd9ո\x8c\x1f\x8f\x0f\x00\xd5&`*\x13\x03\xa8AM\n\xb0\xe02\x99\u009b\x12`\xb8\x9f\x1a@8\x9a\x16\x90W\xecL\x87xg\x04@\xe7f\x06XS\xd5\xe9\xfeL#\x9d\xad\x9a\x9d\xc3V\xe7\x06$\xaf\x9a\x17\x10v:\x1fs^\x10\x10\x06\xb30\x80\xc0\xf0\v\x1a\\\x14\x90\x1d\x1a\x8b\x03\x82\xf6Kp\xfcU-ﷀ\xac\xba.\r\x10\xf3\x97\xc1c\x97\a\x10\x92W\x04\x10D\u007f\xa7A\xac\x84<V\xa9\u05ef\x0e`\u007fݚ\x00\"\xeaڀ\xbeh5 \xdc\xf1\x8f\x00ˀ\xeb\x03\xf2:\xc1\r\xb8o#帉6\xb69\x80\"\xf6\x96\x00\xcb\xf0[\x03\xf26\x85m\x01\x16Q\xb6\xab=\xee\x80M\xec\xa4\xe5\xef\x82\x02v\xf3\xc3\x1e\x9e\xf6B\x1d\u007fⲿ\x02\\\x19\xd8\x17\xc0\xae\x83\xfdj\x86\a\x02X\x9d>\xc8\xd3!\b\xe60Du\x04\xb7\x1d\xa5\xeb\x1c\v\xe8\xafh(\xdc\x1d\xa7\xf6N\x044]\f \x16\x9d\f\xf0\x89\x90S\x01\tz\xa7a\x06gt\xb0g\x03\xa8\xe4\x9c\v 6\x9f'\xb6] \x94^̘\xe9\xa5\x00\xca\x05\x97\x03LO\xae\xe8\xf9\xdf\x00s\xe2\xab\x01l$I\xc7\xc0\x00\xea\xc4\xd7\x03x\x84\xe6F\x00\x1b\xfboR\x9f\xb7\x02`\x17\xb7\x03¾\xee\x04\xb8\xd8\x18\xc0\x13{w\x03x\xec\xc2̺\xc7\xee\xefC\xac\xb9\x822\xda\xdcAܝ'\x88\xf1\xe5\r\xc2\x02\xf3\x051\xfb\xfcAp\xbd\x02<\x15\xe4\xff\n\x05\x91\xa0=\x10\x94U\xec\xc2A.J\x16\t\xd2\x12\x1f\f\xe2w\x12\x83dJ\x0f\a\x05ъ\x06\x19\xb1\x1e\tʦ\x98bA\x96\xe8\x1e\rb\u007fS\xf1 L\xb7DP\xe2G\xc9 \xc2\xd8cAY\x17)\x15\x84\u007f?\x1e,Ԥc\xfb\x98\x99F\xd3\xd2A\xd1L\x19\x0e\xa3l\x90[\xb5\x9e\b\x8a\x99\x96\vҍ\x9f\f\xca\xee\xda\xf2A\x88\"+\br\xf7T\x90\xc9\xe8\xd3:\xaag\x82*\xf5g\x83\x82@\x15\x82\x10U\xc5 J\x90\xcfaȕ\x82B\x8c\x9e\x0f\u009a*\aAp^\bb\a㋐Z\x95 7!\xbc\x14\x94\xac\xbb\xaa\xce\xfe\xe5\xa0b\xdb+A\x84\xa6Wyz-\xc8\u05cd\xbc\x1e\xc4RD\xb5 m\xea\rL\xa7z\x90\xce^#H\v{3(\x9e\xfaV\x90\v\xc9o\a\x19\xaejr\f\xef\x04\x81c\xefr~\xb5\x82\x88\r\xef\x05\xb9)\xb6\xb6ίNP\x02\xc3\xfbA\xb0\xc7\x0f\x82Ȝ\xea\x06\x99^\xd4\v\xa2\xaeS?\br\xd1 (u\xe5\x86AzH\xa3 \xe0\xadqPb܇Aq\xab&A\x04\xa3\xa6A.\xa56\v\xa2\x10\xd3<Ȥ磠\x18z\x8b Yrˠ,(\xb4\xa2\xd6Z\a%Df\aɻl\xf8d\x0fb\xff\xa2\x03\x13t\x06\xf9ȓ\v\x8aw\a\xb1\xe9\xc0C\x81{\x83\xc8\x0e|A\xe4\xca\xfe \xf7\xd0\x18*\xa0\x806\x1a\f\xa2\xa6\x15\n\xc2#ÔL$\x888\x10U\xa1Ƃ |&m-\x1e\x04z%\x82\b\x87ɠ\xc0\x8f\x15\x04\x00\xa4\xa0\x8b\x1c6\xd9&(\xf4\xac-l\xa0\x9dε}\x10A\xa7C\x90\xa5\x87\x8eA}\x8f\\\x90\xaf\xda\xec\x14\x84Cw\x86@\xbb\x04\xf1\x0e\xa0\xaeA\xf1\xb2nAb\xde'\xd4\xe0\xa7A\xd9\x16\xfd\x19z\xf8<(q\xb3{\x90\xa9\xc8\x17\x19\xe3\xe9\x11$\x91\xf92\x88x\xfdU\x10\x01\xa4g\x90\xd9h\xaf )ho:\xe5\xd7A}\xe21HJ\xf1-\x95\xf8]P\x00\xadOP\tG_\xf1\xeeTV?\x18|\xff \x8a\x06\x03\x82\xa8\x14\u007f\x1f\x14\x1e90\b\xdc\x1d\x14DP\xfc!H\xec\x1a\x1c$\f\x0f\x81ʆ\xc2ӆQ\xc1\xc33N4\"\x98y\x89\x1c\x11d$\xae\x1dE\x03\xfbI\xcdwt\xe6\xea1A\xbc/yl\x10\xe4j\\\x10\x01n|\x10\xdccB\x90Qp\"e9\t\xae59\xc8b\xe5\x94 6\x1aL\r\xf2\xf9\x0e\xfa\xe2\xf4 \x9e\xf8\x9f\x01\xe5\xcd\f\xb2\x9c9K\a\xffs\x10I\xd7l*x\x8e\xcai.\x1b\x9f\a\xb3\x9b\x1fD-cAڢ\x8c\x80\x91\xb5\x90\xa6\xf4\v\x01fQ\x10\x11lq\x90\xf5\xee%\xaa\xa6_\xa9\x95߂\xacS,UK[\x16d\xf1f9ռB\x8d\xf5wE\x86\x95t\xc3U\xfa\xf5\xea\xa0p\xa85\x9c\xcc\xda \xd8\xf8\xba \xf2\x90?\x82\\\xec_\x1f\xc4s\xaa\x1b\x82\x12\xa57\x06Q\xb7\xd8\x14D\xc1k3\xa7\xbd%\xc8\xccgk\x90\xdbd\xb6A`\xdb\xe9\xa3;\x88\r;\x83\xfc5E5\xdb\xdd:\x9c=P\xd2\xde \u007f\xf6\xee\xcf +\xe3\u007f\x05ɽ\xf6\x05\xc9#\xf6\xab\xa7\x1d\xe08\x0f\xa6o\xc6NV \xff\xe1\xa0\xe49G`\x13Ga\xceǂR\xcb\xfb;\x88\r\xaff\xd6q\x18\xdb\t\f\ua7e0\x04\xfc\x938\x9e\xca\xd8\xf9\xe9 \xca8g(\x9a\xb3<\x9d\x83\a\x9d\xa7\x96.\x10\x9a/*\xd8^\nj\xb9\xe0r\x90\xaf\x91\xbaB\xf7\xfe\x97pxUUpM\r\xe0:\x00\xe9\x06\x05q\x93q\xe6V\x10\x15\x94\xdbA\xf0\xa7;T\xf8\u007f<\xdd\r\"\x98\xdf\v\x82k\xde'\x92\xe4\n1\x9d\xcc\x1d\x92\xc0\x96'\x84\xaaO\xde\x10ř/ā\xe5\x0f\x11y\v\x84\xb0\xef\xa3`\b\xb7\x16\n\x91$<\x10B)\xabp\x88L\xaaH\b\x01\xf7\xc1\x10\xf9\xd2C!\xa0\xdc\xc3<\x15\rIty$\x04~U,\xc4\xec\xf1\xd1\x10w\xda\x17\x0f\xc1\xeaK\x84`\x81%C\"\xee\xc7B\x98I\xa9\x10\x90\xeb\xf1\x10L\xb7tHxn\x99\x10\xc4R6D\x9b{\"\x04\x8c-\x17B&\xf3d\bor+\x1f\xd2'\x1dC\x94\xe8S!>\xc7\xf3t\bU\xb4gBHɟ\r\xa5y|\x85\x10\xa1\xaeb\b\x16\xfe\\\x88\xae])$\x11\xf7\xf9\x10\x14V9\xc4\xf4\xf9\x85\x10\xc8\u058b!\x90\xba*!ɑ^\nI\xf2V5\x04\xf0y9$\xf4\xf7\x15\x0e\xf7\xd5\x10ޗ\x13B\xd9\xe2\xf5\x10\xb5W-\x045\xbc\x11R\xde\\=D\xf7\xae\x11\xa2\t\xbf)cz+$\b\xfa6GT3D\xb6\xf4N\b\x1a\u007f7\x04\x8dׂ\xe2\xde\vIL\xac\x1d\x92\xe5\xb4:!X\xcd\xfb!\x92\xfb\x0f\xf8\xb1n\b\xd0W/\x04\xb8\xa8O\xb16\baSJC\x8a\xaeQ\bp\xd58$?=\xfc\xa1\x1aF\x93\x10b|\xd3\x10\xabS\xcdBj\xa3\xcdC\x99,\xfa\xa3\x10P\xa6E\x88\xf0\xd62\xc4p\xdd*\xa4\xbb\x83[\x87\x04\xab\xb3C\x82\xc36\xf6d\x0f1::B\xacQ8U\xae.ڎ;D\xf0\xf1\x84\x04ż!<\x19\xe6\xa3m\xfa\xd56\x8d\x10\x92\xfb\x00\x04\x1d\xa4,B\xff\x1bSX\x1b\x8c\x84\xf0\x00R4\x84\x8am,\x84\xbdifH\xf2\x80xH7D%BX-M\x86X\xb6\xb2\xa8\xb4TH8v\x0e?\xb4\t\x01tچPOm\xa7\xa6\xd1>\x84\f\xa8\x03%ۑ\x82\xfa8\xc4\xf4\xa8\x93\xfaLgt\xd6\x05Ǯ!\xe4Y\xdd\xd4(?\t\x917}\x1aҟ\xdeό\xe8\xf3\x10\xaaY\xdd\xe9n_\xa8\xc5\xf4\b!\xb6|\x19\x12\xdc\xf9JG\xdb3\x84p\xd5+\x84w\x88\xf4\xe6\xe9\xeb\x10\b\xc67!\xee_\xd5\xee\xbe\v\xf1U;}B\xc0\xe3\xbe!\x90\xec~!\x81\xca\xfe!\xb0\xc3\x01!Ů\xef3\u007f\f\x841\f\n\x81i\xfe\x10\"\x90\x0e\x0eɂ\xfe\x10\x1d\xd7А\xd6އ\xc1\x0f\x86\x87@\x83F\x84\xc8\v~\f\xa1\x8472\xa4\x11rT\x88\xab\x90\xa1\xcc\x06\xdc\xd1*\xa81\x98\xd7\xd8\x10*\x8a\xe3B\bN\xe3y\x9a\x10B\x00\x9d\b\xf0\x98\xc4\x0f\x939\xf1)!\xddɪ\xf69-\x04n2=$\xe4gFH\u007f\xa3\n7\xce\"\xbc\xfc\x1c\"\x1d\x9c\x1d\xd2g\xb5\xe7\x84\xc0\xca\xe6\x86$\r\x9dGl\x9bO\xd1-\xd0I,\f1r\x12q\x16\xc1,\x17븗\x84\xf8lů\x00\x8a\xdfB`\x94K\xb5\xe7e!\xf2\xf6\xe5\nR+BX\xe8\xf9]\xa1se\b/\xaeY\x15B:\xb2\x1a\xed\xaeQ\xebZ\xab\xe3\\\x17\x12\x16\xfa\aF\xb7>\xc42\xd3\x06\xc8jcH\xdf\xc0J\xcb\xdbL\xd1m\t\xe9V\xd6\x10\xab\xbc\xdbB\x8cr\xdb\ta;8\xc1\x9d!\xee|\xd9E\t\xef\x06\xd0\xec\x01\x96\xec\rIH\xfe\x132\xfb\v^\xb0/$\x04d\u007fH\xe2\xcd\x01\x8a\xe2`\x88\xb4\xe1\x10\x1d\xfapH\xaa\x8bG0\xac\xa3!\xe4\xf0\xc7t\xfc\u007f\x13\xba\x8f\x87\xb8\xc8w\"\x84(\xf4OH~\xb5\xe4$\x1a>\x85\x86O\x87$}:\x83\xbf\xcf\xe2x.$\xf9\xeayx\xf8\x054}\x91xu)\xc4|\xf42\xc6{\x85>\xfa/\xe7w\x95\xb2\xbc\x06\x87\xbb\xaeb\xbfA\xc5\xdd\f\x81'\xdf\"\xce\xdd&\x14\xde\xe1\f\xfe\x83\xf0\xef\xd2\xc7\xee\x85P&\xbaϖs\x85\x81\xf6\xb9ä\ry\xc2PZްxF\xbe0\x9c?\u007f\x18\xceT L{)\x18\xa6\xcb\x15\n#Iy \f\xb6X8,\x11\xa2HXX\u0083a\xd8\xc9Ca\xba\xf1\xc3a\xe9\xbdh\x98\x99\xd3#azV1=?\xca\u058b\xeb\xc7\x12a\x88\xb0d\x18\xdb]\x1f\xd3&J\x85\x91}=\x1ef\x9d\xb8t\x98\xf8]&\f}\x95\r\xd3J\x9f\b\x8b\xa2˅\x11\x13\x9e\f\x03Y\xcbs\x94Ya\xd1\xe1S\x18\xe4\xd3\xec\xf1\x990\x93\xd0gÐX\x850\x19RE\\\xf3\\\x98<\xbeRX\xc2\xdb\xf3a\x1ac\xe50\xdd\xe2\x850\x9f\x8c\xe4X\xab\xe0\x8e\x97\xc2\xfcݘ\xaaa\xc8\xf5\xe50\x9f\xf5\xe0\xe9հ\x04\x88\xd7\xc2X\xd9~=,\xe6^-\x8c\xa7\xa4\xde\b\x93\xdbV\x0f\xa3\x1eP#\x8c\xda\xfa\x9ba\x04\x80\xb7\xc2x,2̊B\xcd0\xfc\xeb\x9d0\x02\xf3\xbbaVRk\x85\x15|\xde\v\x8bQ\xd7ց\xd7\t\x03\xbf\xdf\x0f#m\xfa ,!\xb4nXJ\x90\xf5\xc2RZ\xaa\x1f\x96RC\x830\x11\xa6!\xc4\xd3(\f\xea\xd28,\x96\xf7aX\"[\x93\xb00Ŧ:\xeffl\xady\x98\t\xd4Gaо\x16aF\xf5\x96ad5\xad\xc2\u008f[\x87\x11\xed\xb2\xc3\xe2c\xb60\u007f\x8e\x18\x8d9\xb41'/w\x85\x19&\xdda\x84!OX\x16\xa8\xbda\xdd'\xe1\xd3\xe9\xf8y\xb1\x01\x81\x04(\x88 m$\x14\x16.\x15\x0es\xd3j\x18\xd8\x16\x85\xbccaT\x02M\x9dd\x9cm$\xb4\xffd\x98\x18b\xa9\xe9\xa7\xc2\xe009\x9cc\x1b\xda~\xdb0\x12\xc90\x11\xaf=>u\xc8H\xbc#D\xf4\xb1N\xbfSX`\xb93\xef\xeb\x12&dw\rK\xe9\xad[X\xb7\x14}\x02\v\xfdTG\xf0Y\xfaZy\bR?v\x0f\x13T\xbe\xc0${\xa8\\\xbe\x84@\xbe\x82\x8d\xf5ԙ\xf4\xd2s\xef0x\xd6\xd7a<\x1b\xf8\r&\xfd-\x8e߅IB\xfa\x84\x01*}i\xb0\xfd\xf4\xdb\xfe\xf4\x9b\x01aTп\xa7A\r\xe4i\x10\x8d\xfa\ahq0?\f\t#\x85\x19Jy\x0e\v\xeb\xda\xdcp\x9d\xe4\x880j\x89?\x86\xf1[Va\xc0\xd1(~\xf7\x13\x9a\x19\xad\"\x1a\xa33\x1d\x1b\x96\x9cc\\\x18\xf5\xda\xf1\xb4\xba\ta\xb0։\xb4\x9bIa\xb0\x84ɐ锰\xf2ȩa\xf2\xeei\x90\xeat\x95\xd7\f\xfdvf\x98\xaf˛\xa5\xdf\xff\x1c\x96H>\x9bN7G\xbf\x9c\xab\xe7ya\xc6\xc20\"\xf8\x02\xfdv!\xc7\U0008bdb4(\x8cz\xe8bu\xb5%\x9cگa\xbeP\xf97\xccmi\x18Yڲ0\xf6\x1e.\xa7\xff\xaeH\x1bQ\x97p\xd6\xefan\xa3]\t\x9d\xac\xd2q\xae\x0ecYd\r`q-\xef[\x17\x96\xb8\xf4G\x18\x8bi\xeb1\xeb\r\xda\xeb\xc60S\xc5Mj\xaf\x9b\xf5\xbc%,\x11dkXj\x12\xdb¬\x8cn\x87\xe9\xec`3;ì\xfc\xec\n3P\xec\x0e\xe7\xad\xdb>k\x0f.ً\x11\xfdI\xac\xfa+\x8ce\xde}aR\xb5\xfd\xfcx@\x87{0\xcc\n\xee!\x02\xd6a\xcc\xfa\b\x00\xe5hX\x02\xd71\x1c\xff\xc6\xf18\xa3\xc1\x89\xb0\xfc~\xd4?a\xc4ߓ\x84\x89S\xec\xect\x18\xbb\x02\xceP\x96gì(\x9e\v\x83\xa3\x9d\aB\\\xc0\xf1\"\x8e\x97\xe8\xeb\x97\x19R\xae\x84\xb9C\x15\x8ew\x15\x17\\\xd3Xp\x9dz\xb8\x11\xd6ň\x9b\xeaַ\xf8\xfd\xed07 ݡ{\xff\xc7\xd3\xdd0\xb6\xba\xde\vs5\xfe>f\x95+\x82u\x87\xdc\x11\xa4\x9by\"x\xfbFވ0\x95|\x11\xf8H\xfe\b\xc2q\x81\b\nr\x05#\xea\x0f\x85\"\xe2\x00\x0fD\xa8\xb7\xc2\x11l~+\x12A\x04x0\xa2\x88\xf6P\x84\xea|8\xc2\xdd\x1bE#\xd8*\xf2H\x04k\xec\xc5\"0\xcbG\xd1R\U00048a2aDD0\xa3d\x04f\xfcX\x040W\n\xa3y\\{*\x1dA\x04+\x13a\xf1\xbflD\x88\xc7\x13\x11ο\\\x04\xd1\xee\xc9\b3\x98\xf2\x11R\x95\xac\b#\xebS:\x9c\xa7#\xb0\xc3g\"\xf4\xd4g#\xac\x1eU\x88P2\x159\x99\xe7\"\x88Õ\"\xfc\xf1\xe2\x88\xf0\x90\xca\x11V\x1e^\x88\x88:^\xe4t\xaaDh\x90/E\x98\xd1T\x8d@\v/\xf3\xf4J\x04\xafZ\x8d\x00~^\x8b\xa0p\xfcz\x04^Q-\x82\r9\x19iU\x8f\x00\xe1jDX\x86~3\"\x00\xfc\x96\xce\xe5m\xaa\xa6f\x84[\xe1߉\x90a\xbc\x1b!A\xa9\x15QSx/B#\xab\x1d\xe1\xbaT\x1d\x8e\xe2\xfdH\xe6\a<2\u007f\xd4Uaԋ \x8b\xa8\x8f\x195\x88\x10\xb4\x1aF\x00P\x8d\"0\xe3\xc6\xfc\xf4aD\xd7)\x9bDX\xa4m\x1aa\t\xa8\x19\x15\xd5<\x82@\xfeQDw\x8f\xb5\x10\x1d\xc9k\xc9#D\xf0V\x11!\x83\xadiq\xd9\x11\xa4\x0f\xb6\bl\xddΓ#\x02\x02㌠F\xeaҹ\xb9iz\x1e\x9d\xba\x176\xe2\x8bhb\xe3\xcfX\xa4\x11\x91\xe2m \x82\xd4,\xc8S(\x82\xb5G\xb6\x1ea\x97Q\xaa7\x16a`7\xd9Y<´=\x11!:\xdc\xd2NS\x11\xe119\x11\xc2Q\x1b\f\xa1mD_\xa2\x03\xd3m\x8f\xef:DH\xda;F\x04s>\xd6\xeb;\xd1/:\xab\xc1u\xc1\r])\xdcn\x11\xa9R}\xc2Q|\x1a\x01D\u007f\x16\xd1Z\xe5\xe7\x19\xdb\xe8\x1e\xd1'<T\x96=h\xe9_\xa6}'\x1d0U\x95=\xf5\xdc\v\xed\xf7\x8e\xf0W\x1f)\xefo8\xf9o#\x02\xb7\xdfE\x80\b}\xa8\xfa\xbe\x11!I\xfd\xd4I\xfaG\xe4\xf9\xc2\x01\x11D\xc1\xef#\x88\xf0\x03uV\x83h\xb7?DP\x01\x1c\x1c!\xd6\x0e\x89\xe4o*\xdd\x0e\xc5L\x86\xa9/\x0eWo\x1a\x11\xe1O^E\x90ی\xa4)\x8dR@\xf8I\xedmt\x04%\xb61\x11\x14{\xc6F\xf8\"\x88q\x99ُ\x874'Pq\x13im\x93\"x\xab\x0e\x9cdJD\xf0x*\xa5<-\x82\xb2\xf9tJhF\x04\xd8;\x93\xf7Ί\xc8\xf2\xde\xcf\xf0\xe5\xd9\x11\xdd\xc3\n/\x9c\x1b\xd1\x12\xf4<\nj~\x04k\x93\vh:\vU\xb2\xbfD\xf4)\xf9E\x11ҁ\xc5j\xa3K\"ܘ\xa3\n\xff-\x82\xfc})չ,\x02\xe4]\x0e\vY\x01\xe5\xfc\x8e\x11\xaf\xcc8\xe3\xaa\b\xb0~5<d\r\x8ek1\xbfu\x84\xbb?\xd4\xe3֫\xfa7\x10N6\x12A7)\x00m\xe6$\xb7\xa0\x87\xad\x197ܦ(\xb8=\x02\x06\xb6CE\xbe\x93\x13ܥ#\xde-ꗽ9\x10\xe8^\f\xe1ψdr\u007f\xd1\x06\xf6E\xb8\xade\u007f\x04\xd1\xeb\x00\xd5z\x10~q\bc=\xac\x1eu$\x83EG\x89v\xc7\"``\u007fSo\xc7#\x8c\x9a\x11a\x04\xff@$'#\xac\x1f\x9eRP;\x1dazq&\x82\xb4\xe6l\x84\xc9\xcb9œ\xf3\x11ք.\xb0\xc1\x8b\x11\xf0\x98K\x11,|\\\xe6\xe9JDXӿ\x90\xc4\xd5\b\xab\x9f\xd70\xa9\xeb\b77`\xf379\xb5[\x11$ܷy\xba\x13)\xd84'\x90\xd3.\x9dJFP&\xba\x1b\xe1\xfb2\xee\xe9\xf9~\x04;X\xa3\x00\x88\xdcQ\xec\xef\xca\x13\x15\xf8\xcc\x1b\x85\xed䋂\xd0\xe5\x8fb\x01\xb2@\x14Ѯ`TXO\xa1(\x86\xf7@\x14\u0529p\x94\x95\x9c\"Q\xfd٫(B\xeeCQ\xfcjG\x94a\xa9h\x14\xba~$*3*\x16\xe5ovD\xf1HG\x94X_\"ʢh\xc9(\xf1\xe5\xb1(\x1f\x91-\xa5\xe7ǣ\\\x1b*\x1d\xa5ו\x89\xaaٕ\x8d\x12U\x9e\x88\xc2@\xcbEiGOF\xc58\xcbG\xc5鲢\x1a;\xa3\xba\x97Uoy&J\x8b|V\xfb\xa8\xc0\x81U\x8c\xd2J\x9e\x8bR\x95\x95\xa2\xe2p\xcfG\xb9s\xa7r\x14\xa8\xf2BT\xfc\xef\xc5(*<U\xa2(\xf9\xbd\x14\x05\xfd\xac\xca\xd3\xcbl\xed\x15~z5\x8a]\"\xafEe\xa9\xef\xf5\xa8<\xacZ-\x8a\xfc\xe6\r\x9e\xaaGQ\x9a\xa8\x11\x153|3\x8a\xc2\xf1[\x98\xc4\xdbQ\xf0\xb1\x9aQ<\x04\x19\xc5\x13\xd4\xefF\xb9fY+*\xdbPߋ\xe2\xf1\xe2\xda\xd1\x02u\x03\xf22\xac:Q\xd9h\xf0~\x945\xda\x0f\xa2L\xd5\xebF%\x8a\u05cb\x82\xa0ՏJTi\x10E\xf9\xb6a\x94Q\xa0Q\x14~\xd18\nB\xf9!.i\x12\x95\xdd%M1\xacfQ\xbaa\xf3(\x96\x94>\x8ab\x85\xbc\x05\xa7\xd62J\xfa\xda*\x8a\x12V\xeb(*\xadQ\x85$[\x945\x1a{\x14\xf9\x82#\x8a\x85ɨ$\xb8\xae(\xf3ewTPۃ\xffx\xa18_\x14\xb6\xed\x8fr\x19\xceP[\t\xa4\xdb\xcaIt\xcc\n\xa6{̱\x8c\xacP\xb4@\xab\x9c`\xba\xd5p\x14\x0f\xd7E\xd2\xdfw\x8c\xa6\xa3\xa4\xf6\x19\x8b\x12\xceͨ\xbc\x9c\"\x1e\xe5\x12N\"*\xe9F2\xaa\xbft\x15e\x92\x90\xa2\xa5\xe6DA&\xdbDA\x1c\xdbFIg\xdaE\x81\xed\xed\xa3\xc0\x8d\x0eQ\xe2f\xc7(\x9c\xf7\xe3(\xde$\xd1)*\xcf$u\xe6ȻDQ\xf2\xed\x1a\x05\x19\xec\x16\xe5\xaa\xc4'4\x89O\xf5\xe3gQ.\xea~N\xcf\xe9\xae\x1f\xbf\x80\xf2{\xd0پ\x8c\"\xe6|\x15E\x15\xb6'\xfe\xd5+\x8aH\xd6\x1bN\xf95\xac\xe3\x1b\xb5\xeco\xa3`Z\xdfEI8\xfb\xd0}\xfbB\xb4\xfd\xe0\x99\xfd\xa3\x88\u007f\x03\xa2xUyT\xf0d`T֗\x06E\x914\xfe@S\x18\xac\xee8\x84S\x1e\x1aE0\x18\x16\xc5\xc6\xfe\xe1\xd1<u\xb3FD\xf9\x86r\xf5\xbb\x91Q\x14\xe0GE\xf9\xf4cT\x9f~\x8c\"\x80\x8f\x91\xe1\xa5\x157\x96}\x8c\xa3\x90\xc6G\x91aL\xa0\xbfL\x84\xa5M\x12ut\rgM\x8e2>O\x89*U\x9a\x1a-\xd0Đ\xdfL\x9d\x16\xd5$sz\x945\xfe\x19\x9c\xd1\xcc(\xc3\xcb,\xd5\xce\xcfQ\xd9d0;ʍ\xb9s \x82\xb9\x98\xf5<\x8eq~\x94\xf9\xd2\x02\xbdqa\x94/a\xe5i\x11%\xbe\x18B[\x02\xa7\xff\x15m\xfc\x16\x15$^\x8a\xe3\xb2(\b\xea\xf2(J\"+\xa0\x8a\xdf\xe9\xd6+q\xf1*\xc5\xc1\xd5Q2\xe15Q\x89\xd7k\xa3R}[\x17\x15\x18\xff#\x8a\xba\xdez\xbaކ\xa8>\x14\xb81\x8a=|\x9b\xe0\xe6\x9bՎ\xb7`0[\xa3R?\xda\x16\xc5\x0e\xff\xed\xf4\xea\x1dp\x9b\x9dQ\xbc\xf3}W\x14\xab\x9a\xbbi&{TA{ռ\xfe\x8c\x82]\xfe\x15\x05\xc3\xdaG0\xdf\x1feJr *)\xc9Az\xf2\xa1(\xb2\x87Ô\xef\x91(\xeb\x9dG\xa3,\x1b\x1f\x83\x9f\xffMY\x1e'\x10\x9e \xac\xfc\x13e>\t/?\x15\x95({\x9aXv&*e\xa6\xb3\x98\xc79U\xf1y\xcc\xe7\x02\xc5v1*E\xa2KQ\xac\x91\\\xa6\xbf\\\x81\\\xff\x8d\"Y\xbe\x1a\xe5f\xa7k\xec\xf1:\x9c\xf9\x06/\xbc\x19Ent\x8bZ\xb9\xad\xfa\xbd\xc3A\xfdGK\xbe\x1bE\x85\xe5\x1e\xc7s\x9f\x97\xe6\x8aa\x16\xb9c\xe8\"O\f\x96\x9d7\x96\xafAN\x97\xac|1\x06\xf8\xfc1tX \x06k-\x18\xe3\x93ՅbL\xbe\x1f\x88\x010\n\xc7\x18:\x8a\xc4\b\x1c\x0fƄ)<\x14+\xd0\xd2\xe8\"\x15֘\xd8x\xd1\x18\x8a5\x8f\xc4(\xc8b1xã18^\xf1\x98nC*\x11\x13\x95\x96\x8ciXħR\xb8\xff\xf1\x98\x98V\xe9\x98r\xa42zIY\xfc\xf3\x89\x98\xec\x12/\x17\xc3>\x81'cؐZ>F\xebˊ\x01\xb0\x9f\x8a\xd1\xe0\x9f\x8e\x89\xe0\x9f\xe1\x97\xcf\xea5\x15b\x02\xfb\x15c\xfa\x82rtU\x89\x93{>&<\xa1r\f\xb2~!F\xed\xbd\x18\x03\x95\xa8\x12\x93\x17\x1d\xbc\x84c\xd5\x18l\xea\xe5\x98<\x92\xffJ\x8c \xffj\fu\xd3\xd7bX\x15z]\xc5V\rc~#\x06\xceQ=F3\xaf\x11\x13\xc7x3=\x85\xf4\xb8ޢjގ!|ԌI\xc9\xf3\x9d\x18\xdf8\x17#\xb7\xaa\x15\x13sz\x8f\x83\xac\x1d#\x9e\u05c9\x81P\xbf\x1f\xc3R\xe8\a1}\x8fE\xdd\x18\xa2x\xbd\x98Ҽ\xfa1\xa1\x89\rb\xc2\xfe\x1b\xe2\xd8(F\xc2\xd1\x18S\xff0Ɣ\xaaILФ)\a\xd3,\xa6\x8f\x0e5\x8f\x91H|\x14\xe3\x8an\v=\xb7\x8cq\xb9\xa3\x15\xc7\xd4:\x06cˎ\xa1\xfcg\x8b\xc1\xd2\xed1>\x9f\xe4\x88Itv\xc6\xc0\xf8]\xe9q\x19\xed\xe5\xcd\xe41R\x17O,\x1d\xcaҨ\xe7\xa5\xd9\xf9Tn\xfe\x98@\xb6\x11ÊX@\r \x18\xd3w\xce\xc1V\xc21\xd6B#1\xae>Ƹ\xd6\x12\x8be~\xd1*\x96Y\xfc\x8a\xd3\xf2\x121d9\xc9\x188\x85\xa5\x8d\xa6b\b\x8891\xf2\x8e64\xac\xb612\xefv0\xa1\xf61\xb0\xa1\x0e\xd0C\xc7\x18b\xc4\xc7*\x9aN1\xf8[\xe7\x18\xb6\xaf\xc6H\xb8\xba\xd2Ѻň\xe0\x9f`\xc0\x9f\xc6PB\xf8,\x86<\xfa\xf3\x18\x80\xad{L\x1e:\xf8\"\xa69e\x8f\x18\xf8ї:\x9a\xafhi=鰽b\xdc\xc4\xd4[\x9d\xf0\xeb\x18\x99\xe97\xff\x9b\xe9\xb71\xc1\xac\xefbL\x88\xfa\xc4d\x1bD\xdf\x18\xa2P\xbf\x98 S\xff\x98@ր\x98\x00\xce\xf7\xb8x`\fI\xd4 \xb8\xc5\x0f\xd4\xff`\xba\xcc\x10\x8afh\x8c\x14}\x98z\xc4pU\xfe\x88\x18\xd2\xe2\x1fcX8\x1f\x19CX\x19\x15#\x95\xf9)&\x91|\xb4z\xe2\x18\xc0\xc4X\xbdq\\\x8c\x84j|\f\xefޛ\x10\xe3S\x1d1\xe2\xf7\xa4\x18Y\xea䘰\xb4)p\xa0\xa98N\x8b!\xbaN\xe7m3ԂfR\xad\xb3b\x82\xec?DŽ\xfeϦYΉ\xa161WM|\x1eqh~\x8cu\xba\x051D\xa4\x85t\x98_T\xe1\x8b\xd0\xd3b\x05\x8b%\xb1\x82\xf5:Z9\x1dұ1V(\r\xa4\t\xd3J\aH\xba\xdcR\xcajY\f\xd4ly\x8cU\xf2\x15*\xa4ߵӕ1\x06\xc8Uhw5\fa\x8d\xb6\xbe6\xc67į\x8b\x91L\xfc\x11#\x9f]\x1f\xe3\xf3p\x1bp\xf5F\x1c7\xc5\xc0L7ǰ\ak\x8b\xceakL\x1e\x8b\xda\x16\x03\xb5\xdb\x1e\xc3\xf6\xab\x1dj%;c\xd8ĵ+\x86:\xd8\xee\x18S\x84=1\xe5\x1b{i\x16\u007fBO\u007fat\xfbԞ\xf6\xc3c\x0f\xe0x\x10\x06s\x88\x8d\x1cV\xd4?\x12c\x92w4F\xfez,Fv\xf67,\xea8\\\xe1\x04\xc5\xfbO\xa6\xbf\x93\xea٧0\x9d\xd31\xb2\xd331\xa4\x89g\xd1\u05f9\x18y\xfdy Ӆ\x18R⋴\xc5K1n\x1c\xb9\x1c\xe3szW\xd0̿*\xe5\xab\xf0\xcck1\x89\xadש\x90\x1b1\xeco\xba\xc9\xd3-\xbd\xf0v\x8c\x9b\x1e\xee\xd0\xe6\xfe\xe3\xe9n\x8c\xc9\xf1\xbd\f\xeeݏ\x81\xf0\xe42a\xe1\xb9MP\xbf<\xa6\x18q^\x13y|>\x13&\x96ߔ\xa1\x160\x19M\n\x9ax3\x00\x8e\x0f\x98:\xf1\xc2&XF\x11S]\xfcAS\xf9\xddC&\f\xe8a\x938Y\xd4\x14\xc8{\x047\x173\xe1y\x8f\x9a,\a\x1479\xfa\x12\xa68iI\x13K)\x8f\x99\xd4V)S\u007f\xe5\xca\x04[/mj]\xa6\x8cY0m\xfd\x92.\x945\v6ɱ\xccx:x\x9a\xb4\xcer&\x82Ǔ\xa6h\xaa\xbc)\xe9I\x96I\xe3{\xea\u007f\xb7=m\xa6\x1d2\x91\x0e\xa0f:b\xcb/\x0e?k\"\xe5\xaf\xc0qW4\xb15\xee9\xb3@\x13\xfc2q%3m\x14\x91t>i\x02\xc9+\xeb\xf0^0\xa9\xf7\x17\xf9u\x15\x13\xd4\xeb%\x13ʭj\"T\xbcl\n\xd9|\xc5\xccWO\xdeFg\xc2!_\xe3\xe9u\x93+ \xd5L\xc0\xcb\x1b&\u0378\xbaN\xa4\x06\xe4\xff\xa6Iv\xf7\x16\xe6\xf3\xb6\t\x9b\xaa\xc9\xd3;\xa6V\x85\xdeՁ\xd42Y\xfbz\xcf\x14\x9b\xabmJ,\xaec\x82\xfb\xbco\xcar\xd0\a&\u007fL\xa8\xae)(Y\xcf\x04\xad\xaaor\xb3\xab)\x14\xa1\xa1\x89\xb7\x0152\x19\xcf\x1b\x9bBw?d\u007fMLĊ\xa6&<\xa6\x99\x89*^sZ\xcbG\xfc\xd4\xc2\x14N\xd7\xd2\xd4-<&\x8a`\xad)\x98l\nצ\U000f36d2\xa2;L0]'5\xec2%\xa9q\xe3\xe81\t;^\x93n\xe13\x198\xfc&8\xad\x819\x06LD\x91\xa0\x89(\x122\x89\xb3a\x93Q\"\xa2\xe7\xa8I<\x8d\x99\f\x8c\xa6\x8a!\x0e\xe5$L\xc1\x89$\xe7a\xe1\xab\x14\x87\x93cr\x03`\x1b\xf4\xd56\xfde\xba\xafv\xd4^{v\xd9\xc1\x14\\\xe8\x88&>f\x13\x9dL\x14\x15;\x9b\x88w]\xb4\xef\xae&\x98}7\x93[`>1\xb1\x1b\xe9SS6\x13\u007ff\x16HgN\xf2\xdbWf\xa1ƒ)\xb53\xb2\xba\x9bؚ\xfe\x85\x99\xbfI\xc7v9Y=L\x14\xb9\xbf4Q\x97\xfb\xca\x04\r\xedi\"E\xeb\x85\xe1\xf56\xe9\xe9_×\xbf\x81\xb3}k\x16li$\x8cD:p\xd2F\xfb\x98\x92x\xf6\xa5^\xfa\xd1\xf0\xfa\xc3\xd0\x06\xa8\r}o\n\xde\f4\xc1\xe2\a\x99\xf8\x81\x0f\x93\xa1\u007f\xb0I:=\xc4\x14\xe0\x1c\xaaz\x1c\x86\x9e\x86\x9b\xb2{e\x04-\xeaG\x95\xf3H\x93x=\xca\x04/\xf9\xc9$2\x8e\x86\xaf\x8f1Y\x15\x1ak\n\xeb\x1dDZ\x8cg\x03\x13(ɉ\xa6\x16\x8c&\x99`\x14\x93MD\x83)4\xe9\xa9\xea\xd6\xd3L)\x11L7\xb1Ap\x86\xf61\x93S\x9c\xa5C\xfe\xd9D\xb20\x9b&8\xc7\xc4v\xae\xb9\x14\xdf<5\xac\xf9&\x98\xcd\x02\xbde\xa1\xc9H\xf0\x8b\x89퉋L\xae\xeb.\x86\x85/1\xb5\xfa\xff+\xe6\xfd\x9b)\xf0\xbc\x14>\xba\f\xd2Yn\n\x88\xaf0\xc1\x9c\u007f7Q\x83X\xc9!\xae2\x916\xae6\x11kטB\x8bך\xe0q\xebL.\xc5\xff\x91\x16\u007f\xda\x1c\xd6ì6\x98,\xb3m4\x91\xd6n2\x19.6g\xc0v\x8b\x89$i\xab\x8ac\x9b\xa9\xcfC\xd2@w\xc0\xadw\x9a\fg\xbb8\x92݊\xba{\xe8\x99{\xc5\xfe\xda˛u\xd4\xed\xff\xd2q\xec\xa3V\xf6\xab\xaa\x0f\x98H\x18\x0e\x9a\xc2tӗ\x1f2\xf35kgf\x1d&j\x1f1\x91]\x1c\xa5\xa5\x1d\x830\xfe\x86\x18\x8e\xab+\x9f0Q\xa7\xfc\xc7d\xf6tRG|\x8aA\xe84M\xfc\fOgM\xee\x83;g\x82\x03\x9f7\x85L^ \xb6^\xa4\xfe.\x99\xdc\xf7y\x99 p\x05\xb0\xf1\xaf\xa9$\xf9*>^3I̮\x13\x9fn\xc0\xd6o\x9a\x88\x81\xb7(\x8c\xdb&7:\xdea\xe4\xf8\x8f\xa7\xbb&\xaa\xb2\xf7L\xd4b\uf6e8\xe5䊋\xb7\xe7\x8egHi\x9e\xb8\xb8o\xde8\xfd#_\x9c\x1e\x98?N\xd2S .ԣ`\x1cտBq\xaee<\x10\xcf<\xd1]8\x0e\x1aQ$N\xb6\xfd`\x9c\xf1\xfb\xa1\xb8(\xfd\xe18\xa8_\xd18\xf6\n=\x12\x17\x9f.\x16\xd78\xfbh\\ܲx\x1c\x10R\"\xce\x15\xb7\x92q\xf1\xa3\xc7\xe2b\x89\xa5\xe2\xfcy\x8f8M\xb8t\x9c\x19o\x194S6\x8e\x94\xe6\t^S.\x0egz\x92\x9f\xcaǵ\xf6\x97\x15\xc7j\xc6Sq\xa9\x9e<\x1d\xe7\xcf`<\x13\xa7y<\x1b'\x13\xae\x10g \xac\x18\x87柋\xc3\xcd+\xc5E\xf3\xcf\xc7\xc9x*\xc7\tx/\xc45\xe9T\xe1T\x89\xc3L^\x8a\x17l\x90\x93\xe8\xd8>'\xabj\\\xed\xf9e\x19u\x1a\x01_\x89\x139_\x8dKf\xfaZ\x9c\x1b{\xe2\xf0\xe0jqfHo\xc4a\x91յ\xd1\x1aq)X\xbcɹ\xbc\x15\x87\xe5\xbc\x1d\x87\xe6kƉI\xefı\xbd\xf0\xdd8jt\xb5\xe2D\xbd\xf70\xe6\xdaqxa\x9d\xb8>)\x19\x97,\xf8\x838\xb0\xa7.$Q/.̽\xbe\xf6\xde \x8e$\xaea\x1c\x15\xb6Fq\xe0Gc\xfd\xe7\x87q\x16\xb3\x9a\xc4\xd3\x115\x1d5\xa9\xedf\xdaa\xf38<\xef\xa38r\xea\x16q Q\xcb8\xe3M\xab86\xf3\xb7\x8e+\xcf\xcaV=\xda\xe2\xcc\x1f\xecq\x81\\G\xe6\xdfNh\xde\x15G\xb6\xe6\xe6\xc9\x13G\xa0\xf0\xc6\xe1q>ؔ?\x8etƈk\xf5!\xc01\x04\xe3\xac\x0e\x85\xe2\xc8\xfe\xc2Tf$\x9e\xd9\v\x1b\x8d\xf3\xb9\xf9X\x1c\x8cҌ+\x93\x8c\xc7Q\xb2J\xa8\x82\x93q\xe4.V\\\xe0/EY\xe4pzm\xe2p\xb4\xb6qD\xd5v\xe9\xf6:\xb67\xb2ڧ\xfb\xed\x98\xe6^\x1dⲕ\xafc\x1c;\x8d>\xc6H;ő\x0eu\x8es\xe3V\x17\xd8mWZL7\x9e>\x89\x13\xe8?\x8d\v\x00\u007fF\x95\u007f\x1eW\xe7\xef\xce\xe9\u007fA\xcd\xf4\x88\xf3)\xac/\xe3(V|\x05e\xf7\x8cc\xafE\xaf8\xeb\xe8\xbdiI_\xc7I\x19\xbe\xc9\b\xf7[\xaa\xff;\x88\xbc\x0f/\xea\x1bGQ6\x8eU\xb0\xfe\xb0\xb9\x01qP\xa4\xef\xe9\xaf\x03\xe3$@\x83(\xfe\x1f\xe2\xcc\xee\acrC\xd8\xf1и\xe4\xdf\xc3\xe2\xc2Ć\xc7ItGPB?ƹ\xebsd\x9c\x89\xff(\xdc\xf7S\x1cAqt\x1c\x98<F\xf1dl\x1c5\xc1q\xea^\xe33^4!\x8e\xb5\x89\x89\x18\xea$\x05\x80\xc9q\x12\xa4)q\xecߛJ\xf1L\x8bgx\xf1\xf48B\xc9\f\xb5\xb3\x99\x94\u05ec8\"\xd5\xcfq,\x16Ύ3\x85\x9b\x13\x17h\x9f+\xe8%\xef\x14\x88#\x06̏\x83K.\xc0\x80\x17Ɖ\xef\xbf\x00\xae\x16\xa9\x99-ƈ\x96\xd0$~\xd5a\xffƞ\x96\xc2\u0557\xe9ԖS\xa6+\xd0\xd1\xefhde\x9c\x15\xd1Uq\x80\xf4\xea8\t\xef\x1a\xf4\xb7\x96\x9e\xbe..+5\u007fĹ\xf6\xb3\x9e\"\xdd@\xab٨\x83\xdf\x14G\xc8\xd8L4\xd9\x12\xd7\x12\xd3V\x1d\xf16\xaaq;O;\xe2\xb2Ss'\x8cp\x170}w\x9c\xbb!\xf7\u0efdq<\x05\xf0'\x95\xfdW\\^\xb7\xb1\x0f\xff\xd9O\x95\x1d\xe0d\x0f\xc6%\x1b9\xa4\x86{\x18-\x1d\x89\x83\xd2\x1c\x8d3 \x1f\x8bc3\xe9\xdfq\x06\xcc\xe3\xe2\xf8VN\xd6\tN\xe2\x1fN\xe2$=\xf4\x14\xba8M!\x9dAkg\xf9\x9fs\x1a\x88γ\xfb\v\xf1<u\xb3.\x02$.\xc5I\x0e.\xc7\x11\x01\xafą9\xfe\x1bg\xd1\xe5j\x1c\xe9\xe55\xf6r]\xf1\xebFZ\xaa\x9d\xd21\x13\x0ep+Ϊ\xc7\xed8s\xff;\x8a\xd1\xff\xa9\x1e\xefR\x8f\xf7(\xde\xfb\xfa\xdf\\\tE\x9c\xdc\t:b\x9e\x84\xd8~\xde\x04S\xfd|\t\xb0\xd9\xfc\t\xe9\xa1@\"\x13\x1f\v&`\xa4\x85\x12\xe0\xdb\x0f$\b\xf1\x85\x13\x8c+E\x12\xb2.\xf9`\x82\xbf\xd9\xf0P\x02c~8!\xf3)\x9a@2\xf7HBDR,\x81\xeaܣ\t\x16\x1c\x8b'\xf4\xcd;\t\xc0d\xc9D\u07baV\xd6c\x1c@)\x9e\x1eO@\x88\xa5\x13P~\x19\xb4R6!k\x80O$\xb8@\\\x0e\xdd<\x99\xa0\f\xca'\n\xb4j\xdf1ͱ\xb3\x12\x9ag&\xa4\xf2\xfft\x82\xcc\xe3\x99\x04\x02׳\xb8\xa7\x02\x8e\x15\xf5\xc2\xe7\x12b*\x95\x12\xc2ОO0\x8cWN@\xd5/$P4}1\x81\\\xa2JB|\xe6%\x8e\xb9j\x02o\x11\xc0]\xaf$\xb0\x14\xf0*\x9a}-A\xb8x=A>R-\xc1\x1fF{#A\x02Y\x1d7\xd6H\xc8J\xfb\x9bh\xf1\xad\x04\xdep\x9e\x10\xa6T\x93=\xbe\x93\x00\xaa\xbd\xab\xf7\xd6J\xa0\f\xfd\x9e~\xac͏u\x12\x9ay\xbe\x9f@\xc8\xff \x81\xd2b\xdd\x04\xb4_\x8f3\xae\x9f\x00\x05o\x80\xb15\xd4)7JЀ\x1a\xa3\xff\x0f\x13B~\x9b$\xf0\xab \t@v\xb3\x04\x98Vs\x88\xe6#\x8c\xacEB*_-U\x9e\xad0\xf1։|iꑕ\x8d)ٴQ;\xfe\xe5\xc0w\xce\x04\xa8\xa2+\xa1[_)V\x0f\xba\xf5r\x16>\x8c̟\xe0\x9exC\xdb\x0f$\x80\t\xc1\x84\xee@\rA\x9b\xe1\x84\xec\xf2\x89`\xa4QH-\x86oL\x1c\xe3\t\xbc\xf2$\x01\vN\xeaT-\n4\x95\x90\x97\x95\xe4\xf0C\x1b|h\x9bХ\xa2v\t\x84\x82\xf6<u\x80\xa9uL\xe01\x83\x8f1\xb8N\xf8\xaas\x02h\xd7%\x81\x85\xa5\xae<uKH\"\xf2I\x82\x8e\xf7i\x02aೄ\xb0\x94\xcfq\xec\x9e@.\xf5\x05>\xf4H\xe0ͬ\t\x12\xb8\xaf\x12\xdcu\xd43\xa1iL/\xb6\xd9;\xa1[\xad\xbe\x86$\xbfI\x80\x0f}\x9b@p\xfd.\x81-\a}h\x85}\x13\xdc\xc9\xd8/\x81\xc7$\xfb'\x90\xed\x0eH\b\xca|\x9f \x80\x0fL\x80\xd6\fR\x1d\xfc\x00\xe1\x0fN\xa0\x162\x84b\x1e\x9a\x90|{\x18\x9b\x1e\x9e@eaD\x82/\xd4I\b\xa8\x8f\xc4\x05\xa3\x12do?\xb1\xc5\xd1\tԛ\xc7$X\x9c\x1a\x9b@\xf0\x19\a;\x19O\x03\x9a\x90\x99\xcaD\x1a\xe5\xa4\x04\x1f\x00\x9d\fALI\x00\xab\xa7&\x88\xe3\xd30\xb2\xe9\xecwFB`zfB\xa9\xc4,\x1d\xfd\xcf\xecd6\xfe;'QH|\xbec\xfb\x8eYsU\x03\xf3(\xa5\xf90\xdc\x05\t\xd6v\x16\x12K~\xe1\x18\x16\xa9\\\x16\xa3\xbb%\xf4\x9d_\x13\xc8/\u007fK \x85\xa4Ζ%PH_\x9e \x11]\xc1\xd1\xfe\xce\xd3ʄ0\xacU\xbcm5\x84\xb4\x06\r\xaeE\xd7\xebx\xd5\x1f:\x82\xf5\xf8\xd7\x06\xf5\x90\x8d0\xe0M\t\xa6\x1a\x9b\x13R\x82ْ@\xa2\xb8\x95\xa7m\x80\x87\xed\tT\xf6v`\xb2;a\x8a\xbb\x12\xc2Tv\xe3\xb8\aǽ\t<\xe8\x81\xe3_\xf8f\x9f\"\xfa\xfe\x04\xaa:\a\x88\xca\ay:\x94\x10\xa2t8\xf1\xbf\xe7Տ$\xc0d\x8e&H\x89\x8f%\xf0\xf4\xe6\xdf\x18\xd4\xf1\x04\xb8\xe9\tZ\xe0?\t\xe1\x05'\x13\xba_'\xc1\xc8t\x1a\xeev\x06ןM\xa0vy\x8efx>\x01\xfex\xe1\xff\xfb\xbaHt\xb9\x94\xc02\xe3e\xdcy%\x81\x12ݿ\td\x93W1\x83k\t\xd0\xd0\xeb\x1c\xf2\r\xce\xe3&\xfd\xf3\x16\xe4p\x1b\xc7;\x1c\xdf\u007f\t\xa9\xb1\xddU\x13\xb8\x97\x10.z\x9fM\xe4JJxΝ\x94\xd1\xe5I\x8a\x1b\xe7M2\xd3˗\xd4e\xc9d\xe6\x05\xacI\x91L\xc1$\xc2V\xa1\xa4.K&\xf1\x18ca\xfdX$IN\xf6 \xafz()\xe1\xef\xe1$v:\x15M\xf2\x8d\xe5I\xc9N\x8b%\xb1\xc9\xee\xd1$ܴx\x92\xfb)J$\xb1$\x99\xc4\xfe\xb0ǒ\xa8\xee\x94\xc2w\x8f'A\x14K')\xd42I\x85\xf6\xb2I\xd0\xfd'\x92\xb2\u0378\\\xfa\x0eysN\x12b)\x9f\x94\x1aQV\x92\xa5ɧ\x92,\x9d?\x9d\xa4u?\x83f\x9fM\xc2\xe4+$\x05\x8c+&\xf1ө\xcf%\t?\x95\x92\xb2Z\xf7|R\xaa\u0095\x93b\xf7/\xe8\xbd/\xe2\xbb*\xda\xe2KI8dUH\xf2e\xbd\xe4\x15m\xe4\xd5$\xa0\xe05\x9e^O\xf2'C\xaa%!\xfc7\x92\x8a\xdeՓ\\\x90\xa8\x91d\xcd\xe1\xcd$\xe3\xff[\xc9\xc2i\x91u0,\xb3kǬ\xb7\x93\x92\xc6\xd7L\xe2\a \x93ؓ\xf4n\x12\xe9Z\xad$\x90\xf7\xbd$KD\xb5\x93\x00\xad:IX\xd9\xfbI \xc2\aI\xd9(\\7IfY/IH\xa9\x9f\x84\x1b6H\x12v\x1a&\xc5\r\x1b%\xc1\xaf\x1b'\xc9\xf6>\xccȺI\x12\xd5\xf8\xa6\xec\xb4Y\x12`\xdc\x1c\xa2\xfb(\tCk\xa1zlɮ[Aƭ\x93\xcc]\xb2\x93X\x1e\xb1%\xb9\xa95\xc9\xf8\xe3H\x8a\xaf;qt%\xe1G\xee\xa4\xc4\fOR\x16N\xbdI\xae\xee\xfa\x92\nt\xfe$B\x94\x81\x1b\x02ɂi\x80\x93\r:A\xea<\x94d\x0e\x1a\xa6\b\"\xbc8\xaa}Œ\xc2\xceͤ\xb8F<\xc9%\x93\x84*,\x99ԇ@\x92\xc8/SI`[N\x92\x9bx\xdb$\x91U\xb4M\x92ֵK\n\x9e\xb5Or\xbfs\a=wL\"\t\xfb8\t\xd8\xef\x94\xd4\xf0\xd99ɽ2]\x92\xfa\xecGW\x1a}\xb7$\x17\x92?I\xa6S\x0e\xa9\xb2BZ\x9fѠ?OJh\xeb\x8e\xe3\x17I\x90\x9d\x1ePΗI)\x91\u007fE{\xea\x99$K\xef\xa5M\xf5N\x82f\u007f\x9d$\xb3\xfeF\xcf\xdf\xd2B\xbfK\x82\xef\xf6I\xe2ɘ\xbeIa-\xfd\x92H\x85\xfa'\xf9bV\xe0\xc0\xf7I\x14\x81\a&\x01\xb5\x83\x92\x02\x17?\xa8\xe1\f\x86܇$\xf5\xf9ءI\x86\xe8aI$\x88IĊ\x11\x14\xfe\x8fI\xa0\xd8\xc8$\n\x89\xa3\x92\\e\xf9));\xc8F'Q%\x1c\x93D\x02>\x96=\x8d\x83\x89\x8eO2+\x9d\x90\x9481\x11\x984)\x89\xb7'LN\x92GO\xd1K\xa6&A\xba\xa7a&ӓ\xc2 f\xb0\xa9\x99I\x84\xb9YI\xacI&A\xaeg\xd3F\xe7\xf04\x97\xa7yI\x81\xc6\xf9\xe8e\x01\xccc!\xc4\xfcKR\xaa*\x8b\x92\xc8{\x16SpKt\xb2\xbfr~\xbf%\x99\xe5-MJ\xa4[\xa6\b\xb8\x9c*X\x01\x1b\xfe=\xa9\xbb\x00V&\xf5uV\xab0\xa2\xd5I\x90\xce5t\x93\xb5\xe8q]\x12q揌٬W[ې\x94,d#\x1du\x13\x86\xb89\x89%\x8e-\xea\xa0[\x93`\x8dۀ\x0f\xdb9\xd6\x1d\x18\xd4N5\xdf]\xb4\xccݘԞ$\xc2\xc5^\x8c\xf0O\xc8\xee\xaf$71\xedK\n\x8b\xdcO\a?@\xe79\x98\x14\xb2t(ɼ\xf8pR+\x0eG\x92\xcc+\x8e&\xf1\xe6\x9fc\x18\xe5\xdf0\xe1\xe3h\xf9\x04\x80\xea\x1f\xcc\xf7d\x12u\xacSI\xf0\x8c\xd3I\xe5sg\x92H^\xce&Y\xcd8\x97\xc4\xf6\x85\xf3\xc0\xed\v4\x9b\x8b\x8c\x13\x97\xe8\u007f\x97\x15U\xaf\xc0\xff\xfeU\xb4\xbc\x9a$Q\xb8\x96d\xa5\xf5:۹\x91d\xc2x\x13\xc0|\x8b\x00q\x1b\xe3\xbcC\xf9\xff\x97\x94\x1c\xfc.\xcc\xee\x9e\xfa\xff}F\x84\\\x16\xb7\xb6綤\xa7<\x16~\xc1\xc3\xe2\x06V\x9e\xf2[\xa8\xb2\x14\xb0T \x05-\xdcX\xc8b\"h\xe1\xc7\x01\n[\x8c\xb9E,\x0e\xfcA\v\xcff>d\x89\x84\x1eF\xdbE-a\r\x8fX\xdc\x00Y̒\xc9?jI._\xdcBu\xb5\x84\x05s+\xc9\xf6\x1f\xb3\xc4\x01KY\x82\xba\x8f[(ܗ\xb6 \xd62\x96BdY\v\xc1\xf7\t\v3.gI\x18{\xd2b\xb0*\x8f\x99dY\xd8\xdb\xf5\x94\x05\xf9?\x8d\uf7b1Ĵ\x9e\xb5hu\x15,\xf0ӊ\x968\xd5s\x9cS%\x8b\xf4\xecy\vҫlѸ^\xb0\xf0\xb8\x87\xc5\xf4\xad\x8a\xa5&\xff\x92\x85zLU\x8bo'\xb7\xc4\x0e^\xc1\\_Uپf\t¿n\xd1\xf6\xaaY\x00\xff7,E\xc9\xea\x9cv\rK\xab\x1eoZ\xcc|\u07b2\xb8\"\xf3\xb6\x05\xe4\xaai\xc9s\x99\xefX\xe0\xf7\xefZ\b1\xb5 \xa3\xf7,!\x1f\xb5-@L\x1d\xcc\xf1}\v>\xf6\x81E]\u05f5\x18\x17\xeae$W\xdf\xe2zo\x83\x8cR\x1bZ\xe0,\x8d,zZcK\x9e\x95\xfcPzIf5\xb1\x98\xc86\x85\x1a\x9b\xb1\x9f\xe6\x16\xb9\xe5G\x16\x92\x84\x16\x96\xb8WK\x8b\x05\x85V\x9cbk\xca6\x9b\xb6`\xb3\x00\x02v\xca\xd8a!CrZ\b?.\v\xb1\xd2mq\x85\xcac1\xbczu8>\v\xbe\xee\x871\x18\x96Xv\xc0\x02\xa7\fZ\b\xd5!UQ\x18\xb3\x8fXB\u0896.3Z\xa8#\x98\x16(i\xdcb6\x9e`\x8fIK\x00Ѳ\xb8\xf1$\x05\xa3́T\xdbXL4\xdaZ,j\xb5\xb3\x88\xc5\xed\xd1E\aKbkG\x8b\x14\xf2c\v\x85\xd5N\x16xUgN\xbb\vu\xd0\xd5\xd2\x10\xd2\xcd\xe2\xf3\f\x9fX@\xeeO-\xb0\xd8\xcf2\x1a\xf8\xdcB\x14\xe9n\xe9\xfbu,ҹ\x1e\x96l\xad\xf9\xd2\xe2\v\xca-\xacB\xf6\xb4P.\xea\xc5)\xf4V%\u007f\xadV\xfb\x8d\x85Bͷ\x16\x1f^\xfe\x0e\r\xf4\xb1\b!}\xf5\xa2~\xdaM\u007f\x8bTj\x80\x95\xa7n\xd6\xf7\x96 \xe0@\v\x94k\x90\xc5\xdd[?X($\x0f\xb6$\x9b\x1b\x02q\r\xb5\xc8\xee\x86\xc1\xbb\x87ӹF\xe8\x97?\xd2\x1dFZ\x92\xab\x8c\xa2`~\xb2P\xca\x1a\xad\"\x1dC\x13\x18k\xe1\x99H\v\x11~\xbcZ\xfd\x04KX\xf3D\xba\xf4$\v\xc5\xfa\xc9\n.S,]\x0e\x99jI\xde>\rښn\x11\x14g(\xb0̴X\xa5\x9ee\xe9\xf6\xbf\x9f-!\xb1\xb3-\xd6\x15\xe6dژkI&;\xcf\xe2\v{\xe6c,\v(х\x16B\xe6/\n%\x8b,\t\x9d\x8bq\xc5\x12\xb8\xf7\xaf\x16\xc2\xcco\x96\xae\x00-\xa5\x13,\xb3\x84A,W\xa3]a1]\xfc\x9d\xc0\xb0Ғ\xb7q\xafR\xa9\xae\xb6d\xd1u\r\fz\xad\x85,s\x9d%1\xe5\x0fK\xe2\xd9z\vkp\x1b8\x9e\x8d\x16\nÛ,r\xbe\xcd\n+[,\xae\xf7l\xa5eo\xb34\u007f\xd9n\x81\x13\xec@{;-\x92\xb2]\x16\x82\xdcnKb\xc4\x1e\v+%{1\x99?\xa9\xb0\xbf,V\xf4\xf6Q\x9d\xfb\x89J\a\xb4\x8f\x83\x16\b\xc2!\x8b\x15\xeb\xc3\x16\x19\xc2\x11K\xb2ͣ\x16h\xd71\xf8\xc4ߖ\x84\xc3\xe3\xf8\xfb\x04z\xfb\x87\xd2:\t\xdc=\xa5\xd6z\xdabX=c\x81\xf1\x9c%蟳\x90\xfc\x9d\a\xa2]\xb0X\x1d\xbd\x88\xb6.\xa9=_VǸb\xb1\xe2\xf1\xaf\xfa\xe7U\xe0\xe35\x8bD\xf1:-\xee\x06\x15s\xd3\"\xf7\xbde\x81\xb3\xdcV8\xbc\xa3\xb3\xf8\xcf\xe2~\xf6\xbb\x9c\xf3=\x8e\xe5>ƛ+\x05\n\x92;\xc5v\xf3\xa4\xc0y\xf3\xa6\xe4M\xe7\xf9R\x10J\xfe\x14[/\xa0\xd7\x14LI\x0eU(%h\xf9@\n\xceXX\xffU$U0\r\xb3\x01y:2\x85\xfd\xac)1\x83\x87S\xe2+ES\xb0\xf9GR4\xf6b)&\x8e)\x91p\xf1\x94\xa8\xde\xcc*\x91\x12Q\x94\xd4\xd6\x1eKQ\x14\xa5\xf4\xfcx\n|\xb6t\x8a\xaeT&\x85pYV\x1b|\"\xc5\a\xb4ʡ\x8d'S@\xe3\xf2)\xfa\u007fVJ$\xfe\x14\x06\xf2t\x8aH\xf7L\nk\x91Ϧ\x04o+\xa4\xc4\xfc+\xe2\xf8\\J|\xb4R\n^\xfc<%R9%1\xee\x85\x14\"\xe6\x8b)\t\x1fUx\xc1K)\xa9*VMq\xc9\xfb\xe5\x14T\xf0J\x8a\x80\xfdjJ\u007f\xe7*%\xc2~\x1d\x92\xab\x96\x02o{#E\xfc\xae\xce;j\xa4\xf8\x9e\x00\xbd\xf1\xad\x14u\xf6v\x8an_3\x05T}'\xc5\r\xad)\xe8\xbdV\n\x99\xf5{)\xacD\xd4N!\xc6\xd5I\xa5\xa1\xee\xfd\x14\x02\xe8\a\xbc\xabn\x8a\xc0T/%.S\x1f\xc7\x06\xfcW\xc3\x14m\xa4Q\n\xdbM\x1asN\x1f\xa6P!k\x92\xe2\xaax\xd3\x14\x93\x86f)0\xa6\xe6)!\x13\x1f\xa5\x84.\xb4\x80\x19\xb4L\xa1>\xdaJU\xd1Z\xcf\xd9)\x89\x9a6\x95\xb7=\xa5uyG\n\x8fv\xa4`\x86\xae\x14\xf9\xb6\x9b\xa3\xf7\xa4\xb0\x88\xe0Mi\xd8\xf0\xa5tS\x86?\x85\x92\x8a\x01\xed\x06R\x92\xa6\x04iB!\xde\x19NI \x88\xa4\x94\x93FS\x8c\b1h\xdeL)\x1b\x8f\xa7m\xa9cz\x86\x89\x14\x96\xa5\x93)\x12\x05Kl\\\x9e\x80\xe4\xa0rR\x84\xa26)R϶)p\x94vj\x98\xedS\xd8\x14\xd4!\x85\xc71:Rs\x1f\xa7ȸ:\xa5\xb8c\xa2sJѳK\x8aT\xa2+\x15\xdd-E\x87\xfe$\x85(\xf7)\\\xe4\xb3\x14\xe2\xfc\xe7\x9cJ\xf7\x14\xb6\x01|\xa1\x16\xd2#U\xa0\x05\x9eh\xf8\x92\x8a\xfe\x8a\x9e\xd4S\xa5\xdc\v\x8a\xe8\r\x87\xfb:\x85\n\xc27)\xecj\xf8\x96\x17~\xc7S\x9f\x94\xb0\xe4\xbe)D\xef~\xbc\xb0\xbfNt\x80\xce\xec\xfb\x14\xa8\xea@\xfd8H\r\xe7\x87\x14 |p\x8aU\xa1!)\xee\xb7\x1c\x9a\x11\xf60\x18\xf6\xf0\x14\xc8\xfd\x88\x94\xbcX\xe7ǔ\xe0\xd5\xc8\x14\xd8\u0528\x14\xd2ğR(2\x8dN\x91\xf9\x8d\xa1\x03\x8e\xe5\xa4\xc7\xc1*Ƨ\x80\x97\x13R\xb2\xcbfbJ\x88\xce$\xda\xe4\xe4\x14~\xca#\x85\xed\x9bSS\xc2a\xa6\xa5$\xbeL\xa7\x87\xceH\xe9Z\xe4̔\xe4\x01\xb3\xd8\xea\xcf)\x89\xf9\xb3\xd1\xf6\x9c\x14˺sSX\xf6\x9a\x97Bd\x9e\x9f\u008e\x89\x05\xd4\xfc\xc2\x14\xabe\xbf\xd0\xc3\x16\xe1\xf6\xc58.I\t\xf2\xff\x9a\xc2\x16\x1c\xb6\xbe\x14\xa8\xb0\x8c\x03\\\x9eB\xa6\xb3\"\xc5ױ\xf2\xb42\xc5\x17\x06\xacJ\x91\x1d\xadN1\xf5]\x93\xc2*\xdeڔ\xc4\xdeu)݈\x93B\xa4[\x9f\xb1\xf9\r\x98\xdfFX\xc8&\x80\xd2\xe6\x14\x97\x10\xd52\xb6\xa6\x84\"l\xa3\xcflOa\a\xc2\x0e\xe0\xd1Nܴ+\x85ط;\xc5\xdfoݓ\x02'\xdb\v\xef\xf9SM\xff/:\xf5\xbe\x146\xc4\xee\xa7\x18\x0e\xa4\xb8\x86\xa8\xf6\u007f\x88\xdd\x1e\xa6\x05\x1f!\xe8\x1f\xa5\x95\x1eӱ\xfc\xadv}\x1c\x86x\"\xc5\x17礸\x10v\x92&x*\x85\x1a\xd6i\xfa\xf2\x19\xf8\xf2Yj\xe3\x1c\xb0\xe2<\x86v!\xc5\x05\xe4\x8b\xec\xf6RJi\xfd\xe5\x14^\x81rE\xe3\xc1\xbf)-\xba_\x85l\xae\x01c\xaf\xa7d{\xf6\r\f\xe2&ڼ\x85\xe3mz\xe9\x1du\xc6\xffRȍ\xef*J\xdc\xe3\xec\xefsJ\xb9r\x18\xf1r\xe7\xc8\x00\xf3\xe40\x12\xe7\xcd\x11\xa8˗#t+\u007f\x8e\xbec.G\xb0\xb4`\x8e\xe8\xa9\x10\xfe\xff@\x8e\xf4\\\x18\xc7\"9\x14߃9\xf0\xb9\x87r\xc0z\x1e\xce!\x13)\x9a\x83\x1d5\x8f\xe4`\x92\xc5rಏ\xe6\xa8\x15\x17\xcf\x11s/\x91\x03\x89\x97\xcc\xc1\xf6\xa0Ǵ\xd7R\xda\xc2\xe39x\xa0\xact\x0ea\xbaL\x8eTZ\xca\xe6P\xd9O\xe4\b\x01,\x87\xa1\xfd\x1fOW\x1d(E\xf5\x85\x95\x0e\xc1n\x85G\x18\b\x88\xa2\x12\xa2t\x83t\x83\xe0\xa3{cf\xb6{6\xe8\xee\xee\xc6\x00\x11\x14\x03E,J\x10TB%\x14Q\x10D\xba\u007f\xef|\xdf\xd9\xdf?o\xde\xee\xceܹ\xf7\xc4w\xbes\xee\x9d;\xa5\x1c\"\x9a\xd2\x0e:{\x8eC\xf0\xbb\x8cC\xa5W\xd6\x01\x16V\xceA_/\xef\x80\xe6\x9er\x88\xff>\x8d^<\xe3 \xa1x\xd6A$\xaf\xe0`T{\xce!nU\xd1\x01\xa1Ur\x88\xc5Uv0\xb5y\xde\xc1eNU\x1c\xa0[/8ȳ^t\x80\xbbUu(K})\xfb\xcf\xcb\x0eM#^q\b\x9aUs0\xc6Ww`\u007f\xa4\x1a\x0eݎ\x95\xe2xՑ]-R\xcb\xc1'\x94_s\x80X\xbd\xee\x10\x16_\xdb\xc1$\xbd\x8eC\xed\xa6\xaeʫ\x9e\x83\xa6Z\xdf\xc1 \xdb\xc0\x81<\xae!;\xd5\xc8A\xa6\xddX\xcfj\xe2\xd0\xf7@:`\xbb\xcdxh\x8e\xfe\xb5Pa\xb5\xa4\xf2\xdep\x00\x01Z9\x84̴v\xf0%\x90\xaa\xac\xb6\x0e\x81\xddv\x0eV\x82\xdb;\xe0m\x1d\x1c|\xde\xc3!0\xd6\xc9!\x0f\x04v\x86\xf9tq\x00D\xba:\x00\xcfݴ\v\xddU\x01=\xf4\xf8&\xb4\xda\x13F\xd6\v\xff\xbf\xa5*\xc9u\xa0(\xd8ۡ\x10\xd2\xc7\xc1\x18\xe9@\xa6\xd1\xcf!@\xd6_\x856\xc0A<\x1c\xe8\xd0\xe08\b\xfa\x1c\xec\x10o\x1a\xe2@D\x1a\xea\x00\xf7\x1d\xe6\x80\xc7\x0ewp\xda\xd8A\xc19\x1d\x88G\xae<\xad\xe4\r\xc6\xed\xe0\xd3\b\x86C\x02\xb1\xe9\x00;\xb3\x1c\\h\xe3\xc0ۚ\xbd\x0eqo\x9f\x83\x85d\xbfC\x03\xa3\x1e\x83\xd4C\xc8\xc1\xac3\xec\x10\xf4\x8f8\x90\x1cD)\xe1\x98C2\xa38\xfe&\x1c\xca\x11l\x87\x16\xe5\x92\xd9oR\x0e@aZU\x90q M\x1b\xe1\xc0^l#\x1d\xe0\xeb\xa3\x1cx6u\xb4\x83\v\x8a\xc68$\xd9\x1b\xcb.\x8cSs\x1dOט\xe0@\xa4\x98\xe8@0\x9b\xa4\xd63\xd9!\xe0;\xc5\x01̞\xea\x10 \x9f\xe6`\xda9]\xedu\x86\x8et&t4\xcbQ\xa0\xf5\x90\xbc\f\x92\x864\x87~6\x97\x9f\xe6\x01j\xe6s\xb0\v\xa8\xb4\x85\x0e<Y\xb0HMg15\xb2\xc4!\xe1m\xa9\x03Lt\x19.[\x0e/]\xe1@LZ\xe9@\xd5l\x95\x83\t\xc8jz\xe7\x1ax\xe7Z\a\xe1\xeem\aK\x1e\xef8\xf8\xde\x0e\xb5\xe6\xf7\x1c\x8cC\xeb\x00\x1d\xeb\x1d\x82\xa4\xef\xab'nPc\xf9@\x95\xb5\x91\xedn\xa2}|\xc8\xc3G0\xa0\xcd\x0e\x84\x99\x8f\xe1\r\x9f8$\t\xfbԁ\xd4с\x02\xf8\x16X\xfa\xe7\x0e}\xb0Co\xbe\xd5\xc1\xe2ʗD\xc9m\xc4̯\x1c(\xa3\u007f\r\x8d\u007f\x83\v\xbfe\xf3\xdfѓ\xb6;\x10gw\xe0\x06;\x1d\xcc\xdfv9\xb8\xc2i7\x85\xfb=mq\x8f\x03I\xd3^\a\x82\xd0\x0fz\xdf}\xc0\xc6\xfd\x14ޏ\xd4\xffO\xf8\xeeg\ak\xa5\a\x14\x10\x0e\xea\xf1\x90\x834\xe80\xbb\xf8\vb\xc0\xaf\x18\xedo\xe8\xe1\x11\xda\xc4Q\x87\xb0\x83c\x0e\xd4\x17\x8f;$\xb5\xf8݁\x80\xfc\x87\x03Q\xf6\x04\x0f\u007f:𪏓\x0e)\xda\xfe\xe5\x00\xd5\xfc\xdb\xc1<\xf2\x14\xad\xe4\xb4\x03u\xa4\u007f\x1c2]z\x06\x8eqV\xe5\xf7/=\xe3\x1cG\xf5\x9fC\xf2\xeb\xf3\x8a\x13\x17\x1c\xcc\x1e.\xe6)1wXn\xce%\xc2\xe9e\a\x12\xbb+\x94\xceUG\xc1\xfa\xf2\xb0\xf455\xda\xebl\xf0\x86\x03\xd5Ǜ\x0e\x14\xddo\x01kn\xc3\xd0\xeep\"\x94\xde\xe9\xd4\x1d\xe6\x9cx\x9c\xc3)\xfeS\xc0ɧ9\x9c\x94T!\xa7$\\\x85\x9d\x9c\xa2)\xe2\x84Ɗ:a\xbaŜ@\xba\xe2N\x06\U000fb70c\xf9%\x9c\xb4\xaf\x92N\tRw;\xe1r\xf785it\xca\xc8\xefs\x8a1\xdc\xefTg\u007f\xc0)C~\xd0ɇ9\x9c|Q\x87\x93\x8e\xf8\b\xfa\xf6\xa8\x13v\xf7\x98\x13\xde\xfc\xb8v\xee\t'\x9d\xe1I\xa7\f\xaa\x94\x93\x02/\xed$\xe4\xe6\xe8Ye\x9c\xb0\xb6\xb2N\b\xa5\x1c\xfb^\xde\xc9\xd4\xfd)'\x14\xfd\xb4\x93+R\x9d\xba\x1d\x80\x13vV\xc1\t\xb5>\xe7\x04Ө\xe8\x14\x16R\x89?Uvr9*\x0fU\xf4V/8\xc5\xea^t\xe2\xe5VNZ\xe7K:\xf2\x97\xf5\x9cW\x9c\xf0\x87jN\x00Eu\xa7\xf8[\r=\xa7\xa6\x13\xd5\xf9WU\x82\xb5\x9c\x98\xd8{\xcd\xc9-\xf6^׳j;aQuح\xba\xce\xec\x02\xa8zNr\xfe\xfaN\xdaU\x03'\x83}C'wdu\"\x907\xe6\xd5M\x9c\x8c\xa8M\x9d\x92]5SI6w\xeak\xae\x9c2?\xd1\xd2\xc9x\xfa\x86\x13k\aZ9\x11\xbb[Sdm\x9c\x85\x9a\xe2i\x97\xb6N)\x91\xb7s\xc2\xca\xda;I\x17;\xf0\u070e\xd0L'\x88\xa5\xb3\x93P\xdaʼnH\xd4\xd5IP\xec\xe6$\xc4w\xd7A\xf7\xa0H\xdf\xe4]z:e!U/\xaa\xe7-v=\x97\x87\xdeN\xae\xae\xea\xe3d\x85U\xef\xdcω\xc8\xd6_\xedg\x00;2Љ\x901\x88\x9f\x06;\x05t\x87\xd0҆\xc2\xee\x879A\xe7\x87;\xb5\xc8\xedpr=\xa0\x93&\xefR\xa3r\xebр1\x98N\x06\x12\xcbI\xa8\xf68\x81\xf7^\xa7n\xf5\xe9s\"G\xf5;\x91&\x05hzA'\n]!\xd5R؉\x82@\x84\x87\xa8\x13x\x1eSό;\x05\x99\x12N\r\xef6m'\xe9īFRN\x8d\x9ai'_\xe7\xe1\x14\x9e2\x02\x165\x12n3\xca\xc9Lv\xb4S\xa0m\x8c\x13\x8b\xc3\xc6\xd2m\xc7Q\x14\xe3\xf9\xe5\x04'\xb3\x9c\x89N\x99w\x9c\xe4$K\x98\xec$Ϙ\xe2\x04\x99\x99\xea$%\x9c\xe6D\x01vzVV3\x9cX\xc05\xd3\t*5+\xfb\xf5\xec\xec?s\xe8zs\x9dʌ\xe7Q\xc5\xf3\x9d\x92f.pbI\xdaB\xa7\xce\xc0/\xa2\xae\x17;%!]\xe2\xe4\xcc\xdeR\xa7D\xeae0\x86\xe5N,\xc3X\xc1\xc3J\x15\xfd*\x15\xe7j'i\xd4\x1a'61\xa7\xad\xbd\xed\xc4\xd4\xd8;Y\x81\xbd\xcb\xcf\xef9\x91\xee\xae\xe3a\xbd\x93S\xff\xef\xab\xec78\xc9b> \xe8ld\xbf6Q\x97\x1f:\x19h?\xe2\xd06;\x11|>V\x9f\xff\x84*\xfe\u0529\x1c\xee3\x0ex\v\x8c\xe6s'\xe7g\xbe\xa0\x19oU\xd8\xfaR\xfd`\x9bS\xe8\xe9WN\xe2\xfe\xd7N\xd6$\xbeqb\x8a\xe2['c\xf9w\xda\xc7\xedj\x8e;\x9cH\x81w\xaa\xd1\xefr\",\xedv\n9\xfd\xde\xc9j\xec\x1e'J\x00{\xd9\xd5\x1f\xd8\xf1}:\xc8\xfdNp\x8e\x1fi\x85?\xd1(~V\xf3>\xe0D 9HM\x1d\xa2 \x0e\xab\xa0\u007f\xc9*\xeeW\x98\xdfo4\xab#t\x9b\xa3Y\x138\xe6\xc4l\xcaq~\xfd\xbb\x13\xd3e\u007fP,'\bd\u007f:\xc9>O:\xb1=+\xcf\xfc\x9b\xa7\x9cr2\xf19\xedD\xc0\xfe\xc7)\xd5\xcd3\xfc\xed\xacS\xa8ٿ\xb0\x90sY\r\xff\xe7\x04S<\x8fpsAE|Qm䒓5\xc5\xcbD\x8e+N̊\\u\x922^sr\x02\xe6\xba\xe2\xd5\rh\xed\xa6\x82\xe9-\xaa\xf6\xb6\x93U\x86;\\\xf2\xe3\x9d.\xe9B>\x17\xa8G~\x97\x10\xc9\x02.\xc0PA\x97<L^ȅ\x84\xa2\xb0\x8b\xda*\x82Ӌ\xba \xa9b.\x98WqW\xf6!\x91\xbb\\`\n%\\B\xe2K\xba\x80\x19w\xbb$\xa4\xdc\xe3\x12}\xde\xeb\xe2\xde:<\xdc\xcf\xcb\x1f`c\x0f\xbah\x1f\x0f\xb9\xf08\xc6\xc3.q\x82G\\\\\xf6\xf6\xa8\v\x8fR>\xe6\x02\x88<\xeeB\x00z\u0085\x89\x9b']\xa8\x96\x94r\xc1\xb3K\xa3\x839.\xa4depײ.\xdaB94Yޅ\x97&\xbbPru\xd1p\x9fq1\xa2<\xeb\xd2\x1c\xd3\xc5\xe9\xc4\xe7\\\xfa\x00@E\x17\x9e\x15\xac\x84\xc6+g\xbf}\xde\x05\xf0\xa8\xe2\xa2n^\xe0@^䡪K\xc0\xec%\x8a\xefe\x97\xa0\xf6+.\xd6i\xab\xb9\xf08Au\x97@[\r\x970\x88\x9a\x14ɫ.-j\xd5r\xe9\x84\xc3k.\x9a\xd6\xeb<\xa16\x0fux\xa8\xcbC=\x17\x97hԇ\xfa\x1a\xb8\x90\x185t)\xf26rqy\\c\x17|\xa0\x89\x8b\xabut\xa8\xcd\\\xf4\xfb\xe6.\xfaD\v\x17\xbd\xb7\xa5+\xfb\x9aH\x95Q+\x17Cxk\x97\xa4Qm\\\xa4\x04m]\xf0\xa8v.\xb8d{\x17\x8b\x01\x1d\\,\xecv\x84\xbc:\xb9X\x1c\xef\xac\xc7..\x86ˮ\x14T7\x97\x1a~\xf7\xec?= \xad7](\x12\xf7ta=H/\xde\xe1-\x97xX.\x05\xdf;\xab\x88>.\x14\xe7\xfb\xf2\x8a~jI\xfd]\x02G\x03\\\xc4\xe1\x81l`\x90\v\x1e;\u0605\x12\xfd\x10\x17\b\xd6P\x97\xbe\b\xcb\x05\xa8\x1a\xceA9\\\xe0\x93N\x17\x1f\xe9pa\xe1\xafۅM\xbd\f8\x8f\xe9BnfQ\xb2\x1ej\xc3˃\xcf\xc5\x05=~\x17ʏ\x01\x17\x1et\t\xba\x88\x06!\x17\xc3T\xd8EO\x8d\xb8\xf2\xb5ʉ\xbad6 \x96\x95|\x9c\x0e\x94\x80\x10m\x98r\x12\xff\xa7x\xdb4ԝ\xc1\xdf\x11\xf8a$\u007f\x18\xe5\xd2\xe9\xef\xd1.\xd4\xe8\xc7\xe8M\xc6f\xe55\xce\x05<\x1dOG\x9f\xe0\x12\x8e3Q\ra\x92jv\xb2\v\x91y\x8a\x8bh1\xd5U\xa4\xb5#`I%x\x1a\a8ݥ1q\x86\v<y&\xba0\v\xe61\xdbEB=\xc7\xc5'}\xe7\xba$\xa6\xcfS\x13\x9a\xef\xe24\xe2\x02\xb8\xc8B\x17JQ\x8b\xd4 \x17S%K\xf0\xdbR\x171~\x19\xddh\xb96\xb7\x82\xe3\\\t%\xac\u0099\xab]\x88\xe0k\\\x927\xae\xa5\xae\xdfv\x91\x03\xbcC\xa0y\xd7%%\xaa\xf7\\\x02\xc0벶\xb6ޅT\xf2}\x8ei\x83K\xebR\x1f\xb8\xb8\xb6m\xa3\x8bO\x04mҮ\u007f\x88A~\x84\xbf\x9b\xf1\xf7c\xdc\xfe\x13\xc5\xc7O]\xc0\xd8ϲ:ܢ\xb6\xfe9\xec\xf6\v\x179\xeaV\x02\xc0\x97t\x80m.\x86\xbe\xaf\\|\x9c\xeak\x17\x9e\xdb\xfaƥ\x8fu\xb8PU\xf9\xce\xc5\\e\xbb\xfa\xe3\x0eb\xe1N\x97P\xc0]:\xd2\xdd\xf0\x9c\uf24f{Tx{\x15B~\xe0\x15\xfb\xe8\x01\xfby\xf3\x1fi\x03?\xb9\x10\xd1\u007f\xa6\a\x1dP+=\x88\xb1\x1dr1\x06\x1d&2\xffBQ\xfd\xca\xc3oj.Gp磸\xe0\x98\v\x11\xf98\xdb\xfc\xdd\x05\x8e\xf2\x87\v\x04\xf3\x84\v,\xf1Oj\xf9$D\xf8\x97\v$\xfdoE\xe1Sj\x89\xa7\x89T\xff\xd0\x1b\xcf\xd0\x1bκH\x9a\xfe\xa5\x8a\xcf\xe1\x86\xff\xf1\xb7\xf3\xea\xea\x17x\xe1EW\xa1\x0e\x98\xba\xb8$\xc0#A\x93\x1d\xba\xe2\x92\xd4\xf8\xaaJ\xfd\x9a\v\x01\xfd:\xe5pÅ(}S\xe3\xce-=ަ\xc3\xdc\xe1\x16_\xbbӍf\xf2\xb9i\xe3\xf9\xdd\xf4\x90\x02nI\x18\n\xba%u,\xe4\x06J\x14v#l\x14q\x8b\xf5\x17u\xcb\x03\xe6\xc5\xdcb\xa0\xc5ݸ\xdb]n]\xe7R\xc2MbU\xd2\r\xa1ލ\xa6\xee\xc1e\xf7\xbaa\xfa\xf7\xb9\xa9\xe1\xfb\xddP\xdb\x03nl\xe3\xeaƸ\x1fr3\xf7{\xd8-F\xf6\b\xdbx\xd4\xcd\xd4\xeb17\x12\xb3\xc7\xd9\xe9'ܔ\xf1\x93l\xb5\x94\x9b&R\xda\xcdt)\x87זq\x83\x82\x94u\v0\x94s\xd3\x18ʳ\x85\xa7\xdcP\xc7\xd3<\xf3\x197\xd5\xf1\xac\x9b\xfeR\xc1-f\xf0\x9c\x9bOuUt\x97\xe8`X\xc3\xfa\r\xc9\x1d>Lv~\xab\xe4\x96bce\xb7Ү\xe7\xdd\xe0\xb2UܚL\xbf\xe0f\x16\xf8\xa2[*\rU\xdd\xdcB\x807z\x99\x1d~\x85\x87jn\t\xe2\xd51\xde\x1an\xa1\xd65\xddX\x1f\xfc*\xbe\xaa冺^s\xcbnƯ\xbb\xb3Yfm\xb7\xac\x1c\xaa\xe3Vܪ\xeb\xceVr\xeb\xb9eڢ~^\xaf\xe5S\x036\xd50{^#73\xcc\xc6\xd9/\x9a\xb8\xf9P}S7\xe6\xe0\x9a\xb9\x91\x954w\xd3\xcdZ\xb8\t\x15-ݘ\x06}\xc3-e\x88V\xff\xbfWk7\xf6\xa9n\xe3\x06\x19o\xebf\x94h\xc7{\xb6ws\x91N\a\xb7D\x82\x8e\xff\xbf\xa8\x93\x1bU\x8fΔE\x174\xd9\xd5-\x93\x01ݲ\xc2\xeb\xeeFf\xd5\xc3]\xa4\xa31p\x90 śn\xach\xe9\xe9F&\xd7ˍ\xe5Zo\xb9\xb1\xfe\"\xd7-\xc9Ro7j\x93}\xdc\u061d\xa3\xaf\x9b\xe5\xf3~n.k\xe8\xef\xc6\\\xf1\x00\x9c:\xd0M\xee2\xc8-qh0\xadp\b\xe46\xd4\rr6\xcc-H4\\G\xefp\v\xadq\xb2\xdf.\x9c\xe7v+\xb91Т\xe9\xc6~\x02nB\xa2ǭ3\x98z\xf4\xb9\xa5f\xe8w\xcb\xd6(\x01\x18{P\xbb\x17r\xeb\xbb@\xf4\xca\bz\x14\xc5\xfdb83\x0e\xf7I\xe0\xaf\xed\xc6\x06*I\xb7\xb0Д\x0e\"\xedF\xb0ȸ\xb1\xfe`\x84\xder\xa4\x1bu\xeaQ\x90\xeeh7\x9e\x82tc\x9d\xd1X\x1d\xd487c\xd4x5\x80\tn\xc9\xf4&\xe2\xd4In\xe0\xc8d7J\x82SБ\xa9\x94\xcc47\x92\x90\xe9n\xf0\x89\x19n\x99^\x9c\xe9Fmz\x16\x8d|6\xfa:\xc7\r\xa4\x9f\xabN9\x8fڞ\xef֙\x84\x05\xee\xc2͆\xf4\x1b\x9e\xd7\xc4B\x9c\xbe\b\x1d]\xec\x06gY\xe2\x162\xb9\xd4\xcd\xe9\xa2eğ\xe5\xe8\xc5\n7Al%\xef\xb5\xca\r~\xb8Z\xbf]\xa3\xa3_\xebFXx\x1b\xde\xf4\x0e?\xbc\xeb\x06Kz\x0f\xc2[\xe7\xc6\xec\xe7z7\x17\xfb\xbc\xef\x96%\x81\x1b8\xa6\x0f\xdc\xd9\x14`\xa3[ӦM\x18\xe6\x874\x80\x8f\xdcL\xbf7î?vc]\xe3'0\xe0O\xddH\xf8>s\x93\xb4m\xf9\u007fK\x9f\xbb\x11\xe4\xbf\xc8b\xe4V\x1a\xf8\x970\x9bmnΒ}\xe5V\x96\xfb5l\xea\x1b\n\xfc[\b\xe3;\xe8e\xbb[fNwdmo'1g\x97\x1b\x94m7\xbd\xe1{\xb7\x10\x89=\x8ae{ݨP\xfe\x80F\xf6\xe1\xf2\xfd@\xed\x1f9\x98\x9f\xdc`t?\x13X\x0f\xe0.\aݨA\x1frK\"y\x18\xb6\xf8\x8b\x9b\x01\xe6W\xb7\xaez\xd5\x11\x1eq\xe35\x90G\u074c\xe3\xc7\x10S\x8e\xbb\x19\xba~\x87\xa8\xff`x8\xe1&o\xfb\xd3-\xf5\xe5\x93\x1ag\xfer\x93=\xfd\xadfr\x8aN|\x1a\xd6\xf0\x0f\xc7uƍL\xf9\xac\x1bS\x11\xfff\x01\xf7\x1c\xd0\xf9?76g8\x8f\x0f\x17\xdcx\x16D}\xeb\x12\f沛\v\xa9\xae\xc0̮\xb2\xc9k\xd4\xd3\xf5\xbc\xbb\xcbo7\xdcL5oR\xe2\xb7\xe8Q\xb7\x89\vw\x18\xe0\xecw\x1ar}>\x03\xec+\xbfAq\x140\xc8&\n\x1a\x80\xc7B\x06\x84]\xd8\x00b\x171\xc4\xfa\x8a\x1aR:*f\x88\xe4\x8b\x1b\x8c\xb2w\x19\xb8}\t\x035̒\x86\xf4\xf3n\x83ny\x8f\xa1\xc0|\xaf\x81\x8c\xf0>\x03\xbd\xb8\xdf@1\xff\x01\x83\xa4\xf1AC\xa2\xd9C\x86&V\x0f\x1b\xc2\x1c\x1e1\xf8\x9a,C%\xf4\x98!6\xf9\xb8\xc1\"\xfb\x13\x06L\xfeIC\x1e\xa4*e\xa0\x16Y\xda\xc83\xe5\xbcX\x96c`\xed^\x19\x03\xbe]\xd6\x10\v*\xa7\xb7*o\xe0u\x92\x06\xfc\xedi\x83\xa0\xf1\x8c!)\xe7\xb3\x06c\\\x05\x83y\xd6s\x067\xaa3\x80\xb5\x95xIe=\xe9y\x95Y\x15\x83y\xd5\v\xe8\u074b\x06V\x98U5\x10\xfc_2\x00Q/\x1b\xf0\xa9W\fƓj\x06L\xb5:\x0f5\fк\x9a\x06bΫ\x94u-\x03f\xf0\x9a!.\xf9\xba\xc1e\x11\xb5\rXL\x1d\xed@]\x03\xf3\xe3\xf5\f\xf1\xe5\xfa\xfae\x03\x03\xb5݆\x86\xd8O#\x03\x96\xd6\xd8@ͳ\x89\x01\xc8j\n\xd9638k\xd3\xdcȆ\xb1\x16<\xab\xa5\x01\xce\xfd\x86ZB+C\x01\xae\xb5!>\xdc\xc6\xd0iٶ\x06\xb9s;C\x9c\xaf=\xfev`\v\x1d\r\xe4\xf7\x9d\f0\xda\xce\x06HA\x17CL\xb9+\xfev3\x94\x80w7\xa4\x8c\xd2\xc3\x00#~\x13]\xeei\xd0qzQ\x0eo\x19dV\xb9\x069Xo\x83T\xbeO\xdeȼyI\xa5\x91\x17\xaf\x87\xe7\xf4\x83\xc5\xf57$\x90\r0\xe8\x1f\x03\rq\xb9A\x06\xd8\xe6`\x83\xd3ZCTgC\xa9\x9ea\x86\xf8\xeep\xfd\xd2ap\xee\xd2 $\xb8\fDh\xb7\x81j\xaea`+\x14S\x8d\xcf2\x00\xec\x1ej\xdbk(\xae\xfa\f\xdd)\xc0\xc0N\x01h>\xa8͇`\xe2a\x83\xcc/b\x10p\xa2l!FK\x8d\xeb\xb9\t8\x99M\xd1%\r\xdd\xdf\xdc\xe0ʯ\xb4!\xd17\x83[\x8c\xc0ߑ\x10\xdd(C\xe6pG\x1b\x9cS\x19c <\x8c\xcd\x13Jn\xce8\x83\xd3^\xe3\ry\x82`\x02\x1cy\"\xfc`\x92\xa1s\x96\x86 \xf7\x14\x83\xf1f\xaa\x81\xb2\xf64\x03\xecd:\x9a\x9f\x81\xf3g\xe2\xffY\x06s\xf2ٰ\xbd9\x06\x1f\xe1\x99kH\xb0\x9fg\b\xfd\x9bo\xf0\xd1H\x03!h!|c\x11-b\xb1\xba\xc1\x12\x83\xab\xf9\x97\x1a\xc0\xeae\x1c\xedr\x03\x91e\x05?\xad4PJ[\xa5`\xb2\x9a\xbe\xb2\xc6\x00\xa0\xaf5$\b\xbcM\xb7|G\x05\xfa\xae\x8a\xf0\xbd,\xee\xac3\x189\xd6\xd33އ\xf9o0$@~`\xb0\x94\xb4\xd1`\xd5u\x13\xba\xfe\xa1\xca\xfb#X\xd5f\xb8\xe0džL\xc1}b \xb8|J\xaf\xfe\xcc \xa7\xdcbH\\\xf9\x1cg|a\b\xe9\xd8j0\x8544\xaem3\x98\x1e~\x85{\u007fm\b\xf3\xfd\x86\x8d|k`F\xf7;\x83\xd1d\xbb\x81t}\a\xfcd\xa7\xfa\xe8.=\xee\xa6L\xbe7d\x12e\x8f\xc1\xbcb\xaf\x81\xa4\xe8\a\x83\x11k\x9fJj?\xe0\xfdǬa\xfe\xa4R\xf9\xd9`\xd1\xf6\x80\xaa\xec \xd1\xf8\x90\x81:\xefaU\xeb/\x86\x14g~\xa5M\xfe\x06\xb3:B(<j`\xc2영\x9dɎ\xd3c~7@h\xfe0\x84\xc1\x9f0t1ߟ\xf4\xe0\x93\x06\"\xd4_\x06g\xd3\xff6P\xf2?e誎Ӹ\xd5?\x06\xc8\xfa\x19\x03K\xc1\xcf\x12\xa8\xfe58\x93s.\xafݼ4\xd2@%\xf1<\xedꂑ\xafQ\xceEC\xe9\xf5%CVw\\\x86\xf9]\xc1ٟ߫\xae\x19\xa8z^\xa7\xe1\xdc0\x10\x10o\x1a,\xd4\xdeR\xa9\xdc6H\x9b\xee0\x11\r\xef4i\x00\xf9L\b'\xbf\tO*`\xd27\n\x9a\f\xae\x85Ll\xabcr[\x1dS,\xa7\xa8\t\xed\x153%\xcf)n\x8a\xf9\xdce\xd2\xfaJ\xe0\xec\x92&\x94u\xb7\xc9$\xfa\x1e\x13\x8b\xea\xee5\x8b4\x188h\x90!\xab|LV_M\x98\xfd\x03&\xed\xf2A\x13P\xf4\x90\xc9\x15\x91\x0f\x9b\x00\xd8GL\x98Σ\xa6x\xe4c\xa60\x9d\xc7M\x16\x1b\x9f0\x11\x89\x9f4!\xacR\xa6\xdaai\x13\xae\x92\xa3͖1A\x87˚,\x91\x963!\xfd\xf2\xa6\x8a\xee)S\xc2\xe6Ӧ@\xd13f\x9e\xbc\x9f5\x11\xc1+\x98\x1a\xa5\x9f\xc3O\x15M\xbaq%\xf6\xb9\xb2)\x88\xf4\xbc\xc9T\xb6\x8a\xc9\xdc\xf5\x05\x8a\xf2E\x93\x8f!V5\xa1\x87\x97L \xff\xcb&\x8c\xea\x15Sܹ\x9a)ihu\x13U\x87\x1aڵ\x9a<\xe3US,\xbf\x16e\xf4\x9a\xa9\x05\xb3\xd7MA\xfa\xda&\x90\xa6\x8e\t3\xa9\v\xa1\xd43\x11\xb8\xeb\x9bP~\x03\x93\xeb\xd0\x1a\xaaz\x1b\x99b5\x8dM\xc6\xfa&&\u0869\x89je3ʶ\xb9I\xcfkA\xc1\xb54\xb9a\xfd\x1b&\xb1\xa6\x15\xef\xd9\xda\xd4\xe7'ۘt\xbe\xb6\xa6NԵ3\xe9P\xedU\xe1\x1dԆ:\x9ap\x8aN&\xab\xbf\x9dM\x06\xef.0\x9c\xae&BB7\x88\xbf\xbb\xc9\x12N\x0f\f\xe8MS#gO\x13\x0f1\xf62e\xc2\xfb-\x9a]\xae\x89h\xdf\xdb$\x15\xedC\xe3\xeak\xc2\r\xfb\xd1\x14\xfa\x9b\xd89\x80f8\x90\x87Az\x8b\xc1\xa6\x80\xf9\x10\x13\v\x11\x86\xb2\xcda&\xeb\v\xc3a\xbe\x0e5}\xa7\t'v\xa9tܦB\xadab\xcf\x00\xd3\x04NY&i\xb3\x87=\xf0\x9aR8\U0001960d\xf7\x9b\xb2\x14(\x90\xb5\xa4 -+\x94\x95[X\xcd'\xc2\x1eFM\xc1\xcd\x18\xcd>\xae\xbf%`}6:\x96\xd4!\xa48\xe64=6\xa3\x8a\x1ea\n;\x19\xa9:\x18e\x82\xe0\x8c6\x95Ɍ1A^\xc7Ҫ\xc6iK\xe3Mp\xcf\t\xb0扐\xda$\x935\xbf\xc9b1\xb2Ϲ\xc9\xf2\xe3T\x13(8͔\x19\xef\xe9&Ak\x06M{\xa6\xa9\xef\xcd\xca\x1a\xeblS\xd0tNV\x8fs)\xc9y\xa6\x10\xa1\xf9&9\xd7\x02\x13\t\xdeB\x0e~\x115\xb1ؔ\U0003b13d\\\xaag.\x83L\x97\x9b\x12-V\x98(ޭD7V\x99(\xe8\xad\xd6ެ1\x19\x1d֚X\xcd\xf8\xb6\x89\xe9\xcbwL\x90\xa3w՚߃1\xad3Q\xfc[or\x96\xe0}\xdep\x03\xcc\xef\x03\xf6h#\x84\xb2\x89\x9a\xfc\xd0$\xe5\xf9\x88\x06\xb6\xd9Ģ\x96\x8fMԣ>\x01\x06~\x8a\xae\u007f\xa6\xdaآN\xf4\xb9\tb\xf5\x85\x89\xe5\x8d[M\xac\"\xf8\x12\xbe\xbc\rJ\xfd\x8a*\xf8\x9a\x1e\xf9\r\xbe\xfb\xd6\xc4r\x80\xef\xb2\xe2\xdcnb\xfeo\aŸ\x93}\xdfeJ1o\xb7\xc9\x00\xf9=z\xbb\a\x97\xef\xe5\xe5?\xb0w\xfbT\xd7\xfbMaf?\x9a\x1a\xb8~B\xa7\u007fV\xe4:`\xe2\xb9\xf4\x83\xbc\xf2\x90\xca갉\t\x87_L!\a\xbf\x9a\xa8\x0f\xfdf\"\f\x1e\x81\xdf\x1ee珙\xcc\xf9\x8f\x9b\bp\xbf\x9bd\u007f\u007f\xa07'LYI\xf9\xa7Y\xbca\xbf!\xb9\x03,w\xee0+礩|\xfb/\x93\x15\x94\xbfi\f\xa7L,\xa4?m\xb2\xfc\xf3\x8f\t\x06t\xc6\xe4\xe2᳦T\xcf\xff5\xefj\xd8\xcf\x188H\x9b:g\x16\u007fc\x90;\xfb\xe9\xbf<\x85\xe6Eܜ\xf3\xe8\xde\x05\rK\x17\xe1Y\x97L\xf2\xa0˦p\x98+f\xf1\xa6\xfd\x86X\xa6C\xae̹j\x92O_\xcb\xfa\xeau\x13U\xf4\x1bf\xe1\xf6\xb9\xee\xdc!\xfdrn\xaa\x91\xdd2ɍo\x9b\xa8\xea\xdca\xf1y\xe0;-6\x9e\xcf\"\xed\xcbo\x91\x82\x14\xb0\x88\x1e\x05\xad\xe2\xed\xfb\r\xef\xc3n\xe7\x14\xb2\xa4\v\x85-j\xa6\x88%>^\xd4b\x98.fa2\xa2\xb8%T\xf5.K\x86\\\xc2\xe2=KZ\x8a\x1cw[\x9cm\xbdǂ\xff\xddk\xd1G\xef\xb3ă\xef\xb7$\xc2<`Av\x0fZ\x94\xddCz\xaf\x87-\x84\xa8G,P\xdfG-\x84\x83\xc7,}іEwxB\x8fOZ`\n\xa5,\x15JiKCl\x8e\xc5\xdaG\x99\xec\x17e-&J\xe5\xf4X\xde\x02r?\x95\xfd\xfdiK\x00\xe1\x19\v\xdb\xc4<k\xb1\x9aY\xc1җ\x0e?g\x89\xf1V\xb4\x84]T\xd2\x1f+[\f\xb8\xcf[\xcc]\xabXLX^о\xbdh!\xaf\xacj\x81`\xbe\xa4#x\xd9B~\xf9\x8a\xc5\xd8_\rMV\xb7\xf0\xbcB\r\xfd\xb2\xa6\xaa\xeaU\x8b\xfc\xa8\x96\x85\x84\xf35\xfd\xf8\xba\xc5\xe8Uے\x04\xa4\x8e\x8a\xbe\xae%\xe8S\x0f\x9a\xaao\x01\xab\x1aX\\>\xcbO\x8d\xb2BjlI\n\xd9\xc4\x02\xc1oj\xc1\xae\x9b\xa1\x1f\xcd->\x87\xd8B\x87\xd0\xd2B`}\x83\x87Vz\xdf\xd6\x16\xa2p\x1b\\\xd2VOm\x87F\xdb[y\x88\xe6\xcc\xe9`\xa1\xda\xdb\xd1R'\xead\x89\x87u\xb6dAH\x17\x8e\xb5+;\xd5\xcdBy\xb1\xbb\x1aa\x0f\x8b\xfb\U000a0c5e\xf8\xdb˒gy\u07b2PIȵ\xf8\x9af\x8c\xb5\x0f\xda\xebk\xc1\xc3\xfbYx\xd5j\u007f\x8c\u007f\x00?\fd7\x06Y\x05[\xf43rs\x06s\xa8C(͡\x96@\xe90\xfc\x1d\x8e;9,pT\xa7%\xbe\xe8b\xff\xdc\xf8ݰ\x80,\xa6\xc5r\xa0\xc5\x16<\x16\x1d\xcek\x91\xb6\xfa,\xc1W\xbf\x05\xfe\x15Ȏ=\x98\xb5\xb0PV\xfea\x8b\x95\x8a\x88\x05\xac\x8dⲘ\x85\xbd \xe2\xbcm\xc2*\xdc!\xd7\x14\xbc\xb0\xf5\xe4$\x1d)\x95m6\x9d\xfd'\xa3\x9d\x1aa\t\x06\x8edOG\xf10\x1a\x8e6\xc6\u0083,c\xe9o\xe3,,c\x18\xcf\xc3\x04Jo\"\xc6<\xc9\xca\x16!&[\x98\x14\x9db1_\x9d\nyO\xa3\x19L\xb7\x18KgX\xcc]fZ\x92\xefϲ\x90\xa3\xceVT\x99c\x81Y͵\x98Oͳ$\xbd\x98\x9f\xd7j\x9eZ\x16X\x82\xba\v-r\xb2E\x16\xb9\xf2b\xba\xcb\x12K\x92⥼\xd52\x8b\xb9(;\xb9\x82m\xae\xb4\xc0?V\xa1O\xab\xd1\xf15hq\xad\xc5\xca\xd2\xdb\xff\x1f\xc6;\xea\x9a\xefZȚ\u07b3P\xd7\\\a\xa9\xac'\xc0\xbcoI\xa6\xb8\x01p\xf7\x81\x85r\xc4F\xd8\xd0&\x8a\xebC\xb5̏,Ἓٓ\x8f-.\xe1\xff\xc4\xc2\xdaY(\xf03\vE\xba-\x96\xc4\xfd\xcfՓ\xbf\xa0\xf3oU\xe4\xfc\x92J\xdef\xe9\xb6\xe8\x96Tﾶ\xb4\xae\xf6\x8d\x02˷\x16Y\xc5w\xeao\xdb-M\xd2vX,\xca\xecĠwYXų\x9b\xde\xf8\xbd\x05\x12\xb1\xc7²\xa9\xbd*\xdc\x1f,\x04\x89}\xec\xf6~\vU\xd5\x1f-\xa9\x02\xfcd\x81\x8d\xffl\xe19\xe6\x03zσ\x16\v;\x87\xf4V\x87-!\x88\xbfX\xfazfH\xee7=\xe7\x88\xc52\xe7QKX\xd31\xe8\xe08\xef\xf4\xbb\x05\x06\xfa\a{s\x02\xa8\xff\xa7\x85\x82\xe7I\v\xa5ؿ,\xad\xd0Z\x8c\xe4\xa7TD\xa71\xb6\u007f4|\x9c\xb1\x94\x1d\x9e\xb5H\x03\xfe\xb5@\x99\xceQ\xd8\xffYB\x95\xcf\xd35.p\xac\x17\xa1\x8dK\xaa\x80˖\x14\x18\xae\xf0\xa7\xab0\x99k\x16\x92\x9e\xeb\x16_KiI\x1d\xfa\xa6\x85\xa5\xa0\xb7\xac\xbc\xf4\xea6\x05z\x87G<\xffN\x0f\x8c-\x9fGD\x96\xdf\x033*\xe0\x91RgA\x0f죐\x87\xb8^\xd8#\x91Ob\xa5\aO\x99\xe0\xeab\x1e\x14\x1c\x8b{h\x86wy\x84\x10\x95\xf0P7%\xf5ʻ=\"\xe2{p\xc1\xbd\x1e\xf0\x99\xfb< q\xf7{(\x9b\a<\xb2\xca\xe8A\x0fl\xe9!\x0fx\xf2\xc3\x1e\x94f=X>\xeb\xc1c[\x8fy\xe0-\x8f{0\xd8'<x5\xb3\x87r+\x85\xd3K\xb3\xdd\x1ct\xb1\x8c'\xeb&e=`E\xe5<\xc0\xa3\xf2\x1e@\xd0S\x1e\xbe\x9e\xe5i\x0f\x15\xf5\x8c\a\xce\xfb\xac\x87\x82\xad\xe0\x11\xf0}\u0383\x1d\x84*z\xa0\x95J\x1e\xd5Ve\x0f\v\xd2\xcf\xeb\x10\xab@b/xP\xc8x\x11]\xa9ꡳ\xbe\xe4!|\xbd\x9c\xbd\xf6\x15\x0fwV\xae\xe6AY\xb5\xba\a\xa9D\r\x0f\x12њ\x1e&\xae\xafz@Aja\xf8\xafyd:\xf9u\x0fHqm\x8a\xa7\x8e\x87l\xa2\xaeG\x19~=\x8fD\xab\xfa\x1ebW\x03\x0fIiC\x0f\x97\x134\xe2\x98\x1b{`\x9bM<\xb4Ŧ\x1eXY3j\xba9[nᑹ\x88\x96\x1e\xee\x81Nɵ\xd2\vZ\xab\xb4\xdbx\xf8\u009a\xb6\x1e.\x99o\a\xe5\xb6\xf7\xc0\xb0:`\xfc\x1d=t\xf6N\x1eq\xa9\xce\x14}\x17\x8f\xf8PW\x0f\xa0\xb9\x1bo\xdb\xdd\x03\xeb\xee\xa1r\u007f\x93\x1f{zPY\xe8E\xf9\xbf\x05\x85\xe6R\xf1\xbdվ\xfah\xa7\xfaz\x80\xa5\xfd<\n3\xfd=H%\x06\xe0^\x03=`\xff\x83\xd8\xdc`\x8f,\xed\x18b\xe5\fѻ\r\xd56\x86\xa98\x87S\x06\x0e\x8f\x80\x9cS\x87\xe0\xa2\xf6\xddz\x8dA5\x9b\x1e.ص\xf4\xe8\xf1H|\xf2\xf2\xe6>\x0f\xb7\xb0\xf3H\xc9.\xe0\x11h\rz\x98օ\xf0)\xec\xc1\xfb\xab#<D=x\x84=\xe6\x11\xff\x8d{\x90S%x\xb0=\xa8-$=\xf2t{\xca#E\x8b4\a\x9cɪ~\x04o6\xd2#\x18?\xcaC\xc6=ڃ\x15Kc`;c!\xbfq\x1efg\xe3=\x04\x9f\t<e\xa2G\x92\xbbI\x9e<h\x98\xecAe}\x8a\a\xacs*\xba3̓x?]\xedx\x86\x87\xf9\xc2L\xb8\xdf,\\;ۣ\vi\xe6\xf0\xfa\xb9ٞ\xcd\xe3\xe7\xf9\x1eybd\x01\xa1f!\xbf[\xe4!\xc8.\xf6H-b\t\x04\xb5\x94?-\xd3~.G\xe3+<,\x9c\xac\xcc6\xba\n\x8a]\xedaƳ\x06\xe6\xbaV/y\x1b\xd6\xf6\x8e\a\xa1\xef]\x0f\x97\xc9z\x18\xb2\xd7y@\u007f\xd6{\x90\xb4\xbf\xef\xc1\xd37\x1b\xe8w\x1fx\xc0Z7z\x04,7\xf1\xc4\x0fy\xf8H/\xdf\xccS>\xc6)\x9fxX\"\xfb\xd4#y\xe4g\x1e@\xed\x16\x0fvnUS\xfa\x02>\xb1\xd5\x030\xfe\xd2\xc3\x1a\xc56\x8fNU~\xe5A\x9e\xf55z\xff\x8d^\xf2->}\a\xff\xd9\x0es\xdaA\xe1\xef\xc4\x0f\xbb<xe\xdan\xbd\xf7\xf7t\xd1=\x1e\x16\x83\xf6\xe2\x9c\x1fp\xd7}\x1eL\xef\xee\xf7\x80\x10\xfe\xe8\x01\xa9\xfcɃ\f\xf3g\x0fH\xe3\x01\xe0\xc5A\n\xe3\x90G9\xdca\x9e\xf3\vp\xe7W\xbd\xd1o\x1e2\xf0#\x10\xfcQ\xe2\xd01\x8f0\x9e\xe3z\xf3\xdf\xd9\xe8\x1f\x8a\x0f'<\x12\x95\xfeD+'\xe9\xed\u007f\xa9\x18\xff\xf6\x90T\x9e\xc2)\xa7!\xcd\u007f\xd0\xf0\x19\x8f\x90Գ\x1e-\v\xfeK%\x9e\xc3}\xfe\xf30@\x9f\xd7\xe3\x05\x0f\xc2\xf0EH\xfc\x92\x87\x99\xfee\x0f\xa9\xfa\x15\x8ff\xd8W=\x98K\xbf\xe6\xc1J\xc1\xeb\xb0\xd8\x1b\xec\xe9M\rY\xb7x\xcamj\xf0\x0e/g\xc0\xee\xf4\xaa<\xf2yQ\xeb\xca\xefE.Q\xc0\xcb\xc7\xd0\vz\xd1F!/\x93\xe4\xc2^N\x98\x14\xf1\x02ЊzA<\x8ay\xe1\xb8Ž\xd8|\xf3./\x81\xa6\x84W\xd2ɒl\xf6n/\x91\xec\x1e\xafB\u05fd^\x94\xb0\xee\xf32\xac\xdc\xef\x05x=\xe0\x95P\xf4\xa0W߯\xe5չ\xf0\x87\xbdX\x1d\xab\xe7>\xea\x058>\x96\xed\xf9\xe3\xec\xc5\x13^\xf1\xff'\xbd\b쥴\x89\xd2z\xcc\xd1\xf1\x94\xf1J\xa6[\xd6\xcb\xea`9/\xb8uy\xaf\x98\xe1S^\xbcd\v\u007f\x9f\xf1r\xbd\xe2\xb3^xB\x05\xaf>\x84\xe9%۫\xe8\x95\xf2F%/#Oe/j$\xcf{\xb9\xc7G\x15\xfc\xf8\x02\x9b~\x11MW\xf5b\xa3s\x15\xf9\xcb\xda\xda+\x1cG\xb5\xec(\xab{Y\x17\xa8\xe1\xc5ҕ\x9a\xda\xf5W\xbdܓ\xbd\x96\x8a\xf05/\xdf\x11\x82\xe1\xd6\xf6\xaa\x97\xd5\x11\x1d\fʩ\xeb\xa5\xf7\xd5\xcbʹ>\x85\xd3\xc0\v\x0fo\xe8\xe5\x04K#/`\xaf\xb1\x97\xac\xa4\t\xa4\xd2ԛ\xdd\xc1\xc7\v\xca\xd7\\\xfb\xd3\u009b\x87\x97-\xbdp\xcf7T\xb9\xad\xbcba\xad\xbd(2\xb6\xf1\"\xe4\xb4\xf5\xd2C\xday\x99)\xb4\xf7\xd2H;xQ@\xee\xc8\x16:y\x89ڝi\x18]\xbcZw\xea\xea\xc5\xfc_7\x19ݠ\x9c\xee^\x92\xd8\x1e\xd9q\xbc\xe9\x15\xc7\xe9\xc9;\xf5\xa2\xc4\xdf\xd2\x0e\xe6z\xb9_Lo~\xdd\xc7+H\xd5\xd7+\x90\xde\x0f\u007f\xfb{\xc5\xdf\x06\xb0\x1f\x03\xbdB\xd5\ay\xc5c\aC=C\xbc\x882C\xbd\x98\xfe\x1e\xe6\xd574{\x05_\x1c\xbc\xc8\xe9\x15z\xea\xf2\"mq{\x89\xd3\x06\x84`zQ\x01\xb4x\xb5\xc7˒\xb8W\x85\xe1\xa3\xfc\xfd\xe8S\xc0\v\x12\x19T\x03\by\xa5\\\x1e\xf6\x02\xc1\"^\x84\xa8\xa8\x17Ō\x18m \xee\x15HHx%\x8e\xda^0\xbe\xa4\xba`\xca\xcb(\x95\xe6\xe5\x19X\xdd\b/+0#\xbdxz{\x94\x97\b4\xda\xcb\xc4l\x8cW2\xa4\xb1^бq\x1c\xcc\xf8\xac\x02&Ћ'\xaa\x95N\xf2\xa2\xa8;Ye;\xc5+\x81m\xaaW\xa9\xdd4\bn\xba\x97\x1cn\x06\\}&,r\x96\x97[\xdd\xcf\xf6\xb2\xa8<\xc7\v~7\x97\xc6>\x8f\xad\xce\xf72\xa4-Ț\xdcB\xaf\x84\xedE^\xc2\xefb/\xa8\xc5\x12/V(-\xf5\x82\x19-\x83\xb4\x97{I\xf3Vx%SYIo_\xe5%\xe1X\xad\b\xb1F\xfb\xb0\xd6K\x8e\xf8\xb6\x17\v\xfc\xdeQ\xe3}\x97@\xf5\x9eW\xe2\xf1:\x88x\xbd\x97I\xd2\xfb\x94\xfb\x06/\xa8\xd9\a\x94\xedF\xbdn\x13.\xf8\xd0+\xb1\xfa#/\x92\xb4\xcd^\x06\x8e\x8fUݟx\xb1\xb1\x9dz\xe1g^!W[\xbc \x8b\x9f\xab¾\xf0\x82\xe2o\xf5\xb2\xc6\xf4\xa5\x17\x95\x9dm\xc4ï\x88\x83_\xab \xbeQ\xd8\xfa\u058b\xca\xf0w\xfaq;\x9caG\x168vz\x91-\xecR\xb3ڭg}϶\xf6\xc0\xd2\xf7j\x8b?(h\xed\xf32~\xed\xa7B~\x84p\u007f\xf2\xa2f\xf3\xb3\x97S\x14\a(\xa7\x83\x14\xf2!\xda\xc7a/\x9fĤ\x84~\x85\x93\xfc\xe6\xe5Z\x82#^)\xf0\x1cew\x8e\xd1\xc1\x8f\xc3R~W\xcd\xfc\xe1E4;AG\xf8S\xbf=\xe9%+\xf8\v8\xff\xb7:\xe0)/\x99\xcei\xc2\xd1?^N휁\xfc\xcf\xea\x8f\xffzY\x8e<\xc7\xc1\xfe\xe7\x05\xcb<\xcf{_\xf0\xb2\xe8qы\xe0\t\x1b\xbb\f\x80\xbf\xe2EȽ\xea\x95t\xf6\x9a\x17ˢ\xae{%7\xbb\xe1թ\x97\x9b\x10\xc9-/\x88\xc5\xed\xac\xac\xef\xf0ѥ\xee\xf4\t \xe4\xf3!\x11\xce\xefC8,\xe0\xc3\xc0\v\xfaD;\x85|\xc2:\n\xfb\x10m\x8b\xf8\xf0\x82\x86\xa2>t\xb2\x98\x8f\xcbÊ\xfb \x8c\xbb|һ\x12>\b\xbb\xa4\x0fXt\xb7\x0f\x13\xfb\xf7\xf8\xf2\xa0\xf7^\x9fd\xac\xf7\xf9\xb0{\x8f\x0f\xd5\xf9\a||\x88\xc4\a\xc0{ȧ\xa5ڇ}\xb0\xf3G|\x88\xf4\x8f\xfa\x10\xbb\x1f㹏\xfb\xe0SO\xf8\xc8\x06\x9e\xf4\t\xa6\x94\xf2\x89˖\xf6!\xca\xe5\xf8\xb0q\x8fO4Z\xd6\a\xe6_\xce\aɔ\xe7\xe1)\x9f\x84\x89\xa7}\xcc\xea\x9e\xf11>=\xeb\x13}T\xf0!\xc1z\xce'H[\xd1\a\x8b\xa9\x04AT\xf6\xb1J\xfd\xbcO^1]\xc5ǂ\xe8\v>ݥ\xc0\xc7pP\xd5\a\x06\xfb\x92O\x96S\xbc\xec\xc3+\x99}\xc2\v\xab\xe1\xff\xea>ZJ\r\x9fl\x85Y\x93\xe2|\x15\xed\xd7\xf2Ѣ_\xf3х_\xe7@k\xe3\xc7:\xbe\"\xf5ܹ\x03r\x87\xf7˩\xeb\x83q\xd7\xf3q=e}\x1fK2\r\xd8׆>Up#ꨱH\xbe\x89\x0f\xf3\x86M}Hכ\xf9đ\x9a\xfb\xe0\xcd-0\xea\x96\x14\xd3\x1b>L\u07b7\xf21.\xb4\xa6\xc4\xdbh\x87\xda\xeaP\xdb\xf9Ġڳ{\x1d|\\%\xd2\xd1G\xd7\xe9\xe4\x03\x1aw\xf6\x11\u07ba\U0002cbbcY7\xfd\xb6;\xbf\xed\xa1Cx\xd3\xc7Ģ\xa7\x0f̾\x97\x8f\xf5\xf0\xb7|\x9cS\xcc\xd5[\xf4\x86F\xfb\xe8\xc9}y\xa3~>\xd2\xcb\xfe*\xbd\x01\xbe\x82Ͱ\x87\x0fMh\x10\x0f\x83E\nC|Ȩ\x87\xfa\xe8\xa4\xc3\xf4\xcaἫ\x83\x83u\xd2\x13\\>0\x027ni\xb0\xbb\xa6\x98\xfb\x90A9\x16\xe4\xe7\xf11\x16y}\x1a }(F\xf8}|\x9c<\xe0\xe3\xfctP\xc7\x18R\xe1\x85y\x9b\x88\x8fS Q\x1f7[\x8b\xf9\xf8\n\xf58|(\xe1c%\xc2\xf6q\xca \xe9c\xa5\xd5\a\xf2\x93\x86=e|Ą\x11\xf4̑>\x86\xb0Qڝ\xd1>\xc9-Ơ\xabc\xa1\xe3qt\xb2\xf1\x1c\xee\x04\xb5\u05c9>d;\x93|Ȣ'\xfbPt\x9a\xe2\x138\x99\x8a\xbeL\xf3aw\x9d\xe9>\xb0\x9e\x19>f\xd43}\\\x92;ˇ\x95\x01\xb3q\xea\x1c\x15\xc9\\\x1f\xd9\xfd<\x8eu\xbe\x0f\x14r\x81vx\xa1O(\xc4\"\xba\xe2b\xc2\xc4\x12\xd5\xc9R\xf5\xb1e>\t\xf0\xcb}\x98\xbd\xa4\xed\xacT\x03[\xa5\xee\xba\xdaG\x18]C;X\xabx\xf6\xb6O\xb8\xc8;4\xf8wU\xe8\xef\xa9P\xd6\xc1\xf1\xd7\xfbP\x1cx߇\xca熼v\xfb\xe5i\xf5\x03\fa#U\xbdI\xd1\xe5C\x9f.\xf8\xa1\xd06\xf3\xf010\xf3\x13\x1f\x8b͟\xfa\xb8\v\xdbg>\x99\xae\xd9\"\x96\xf6\xb9\x0f+~ho[}\xb2\xc0\xfaK\x1fc\xd16\x1f\x97\x8a\u007f\xe5C\xc1\xfek\xa0\xe17\x1c\xe2\xb7>\xbe\xe1\xf5;\x1fJ/\xdb}\x88\x17;t\xc0;9\xd0]\xe8\xe7n\x1f\xa7\xac\xbf'6\xeea\x03{}Hz~\xa0\x16\xf7\x11c\xf7C\x96?\xfa\xa4\xd0\xf7\x13\x87\xf7\xb3\xda\xd5\x01\x1f(\xdf\xc1,\xee\x1eR\xcf;\x8c{\xfc\xe2\x93\xc9\xf1_U\x86\xbf\xc1\x94\x8e\xe0\xefQb\xfc1\x9f\x86\x98\xe3\xaa\xf8\xdfiE\u007f\xb0\xff'|,\xb9\xfd\x89\xd6N\x02\xa2\xff\xc2\xff\u007f\xfbPW8\xa5f~Z\xbb\U000cf3f3\x16g\xd8˳>\x89s\xff\xfa\xc8\xc2\xcf\xf9P\b\xfb\x0f\xe0~\xde\xc7hy\xc1G\xc2tQ\x15|\t\xd0t\x99\xeerE\r\xee\xaa\xda\xec5\x9f\x96#\xaeSh7\x80\xc17\x15\x93n\xc16n\x03m\xef\xf0so\xb9;\xfd\f\xce\xf9\xfc\xe8P~\xbf\xb2\xc6\x02~^SЏ\x00U\xc8O^U\xd8/hQ\xc4O\xd7.\xea\x17\x0f,\xe6\a\f\x17\xf73\xd8\xdc\xe5\x87hJ\xf8E'%\xfd@\xf2\xbb\xfdx\xd4\xd2\x0fۺ\xd7O;\xbe\xcf/t\xe3~\xbfN\xa9<\xe0\x17;y\x10\u007f\x1f\xc2m\x1e\xf6c\xe5\xcf#~\x11\xe8\xa3~\xf1\xf0\xc7\xfc(\xbf?\xee\xd7\xdd\xedpޓ~:c)?\x89Si?\x02T\x8e_L\xb4\f\aV\x96\x87r~<\x91^\xde/\xaf;zJ\a\xf5\xb4_\x03\xca3\xec\xfa\xb3<T\xf0#\xe6?\xe7\x17yU\xc4\xdfJ~P\x8c\xca\x1c\xc8\xf3\xbcO\x15\xbfnT\x80S^\xf4\x13\xa5\xab\xea\xf1%\xbf\x18\xc5\xcb~\x01\xb4W\xfc\xd9\a>\xaa\xf9\xc9\xe9\xaa\xfb1\x19_Ï\t\xf6\x9a~n\xe4\xe3\a%\xaa\xc5\xc3kh\xf6\xf5\xbc1\xca\xd8j\xfb\xb1ַ\x8e\x1f\xcb\x06\xeb\xfa\xc5\xf1\xeaA@\xf5\xfd\xb2\u0c81_\x1c\xb7\xa1\x1fs*\x8dt\x80\x8d\xf5\u0604#j\x8a\xf3\x9b\xf1Cs?'T[\xf8\xe1Q-\xfd\x9a\xa5\xbeA\x81\xb5\x82\x92Z\xb3+m\xfc\x98-j\xcb+\xdb\xf9\x99\xed\xb6\xf7\v}ꀿ\x1d\xfd\x92\xdbt\xf2\xcb\"\xbf\xce<\xad\x8b\x9f\x13\x16]\xfdH\xaf\xba\xf9\xf1V\x83\xee~1\xf2\x1e~\xbceҏ\xb8\xde\xd3O\xe2\xd0\xcbϔ\x11\xea\xcb\xf5\xb3 \xde\x1b\r\xf7\xf1\x8bo\xf6\x85\xd6\xfb\xf9\xb5\xa0\xd2ߏe=ڛ\x81~\xe6+\x83\xd8\xe8`?ʐC\xfc@\x96\xa1\xec\xd20\x98\xe3p?\xd28\x87\x9f\xe0\xe3\xe4G\x97\x9fY\x94\xdb\x0f\xf2l\xf8\xe9\xf7\xa6\x1f\xe5*ˏ\xa0\xe9\xf1\x8b'y\xfd\xa8K\xf9h\xff~?\xd6\x0e\x05 ܠ_\x92\x8b\x90j9\xecǺ\x90\x88\x9f\x01)\x8aQ\xc4\xfc\xacP\xc4y\xa3\x04\x1b\xb3\xd9\xc3$NI\xf9\t\fi?\"X\xc6\x0f\xb4\x1b\xe1G>3\x92\xca\x18\xe5\x17<\x18\xed\a,\x8d\xf1\vc\x1e\xcb\x0e\x8dӁ\x8d\x87f&\xf8u/;Hk\x92Z\xc4d?+\x15S\xfc\x12S\xa6B\xd9Ө\xa8鰭\x19\x18\xe9L\x1a\xc3,?#\xfelmy\x8e\x9f\xb5蹐\xe7<\np\xbe\x9fa`\x01\xae_\b{\\\x04\xdb\\\xccV\x96\xf8\x19q\x96BRˠ\xcc\xe5\x18\xc5\n\xb4\xb3\x12\x17\xae\xf2\x13\xa8W\xfb\x11\xca\xd6\xf8\xb9\x88y-\x8d\xe3m8\xc5;~V\xfa\xdf\xf5K\x9d\xe0=Jp\x1d~Z\xef\xe7b\x93\xf7\xe9(\x1b0\xbe\x0f\xe8f\x1b\xe9ߛ\xfcX[\xf3!:\xf0\x11\xfen\xf6#\xf5\xfd\x98\xee\xf3\x89\x1f\v\xef>\x05\xca}\xe6\x97\t\xa3-~\xacx\xfc\x1c]\xfc\u008f\xa7\x93\xb6\xe2\x97/!\xfam~Dܯ\xfc\xc8Y\xbe\x86<\xbfQY\u007f\xab\n\xff\xce\xcfh\xbaݏ2\xe7\x0e\x1ev\xfau\xbeq\x97\x1f\xf9\xc4n?\xf7w\xf5#\xde\xed\x01\x9a\xee\xf5\xb3\xa0\xf0\x03\x8dd\x9f\x9f\v\a\xf6\xfb\xf1>\x10~\xf9\x13\x06\xf23\xdc\xe5\x80_Ҥ\x83~L\x97\x1c\x02\xb2\x1e\x86\xa8~\x81\x8c~\xa5\x05\xfd\x06o=\x82\x9f\x8f\xfae\"\xf8\x98\x1a\xeaq`\xd7\xef~\xcd\xfc\xffЎ\x9f\xa0\\\xfeT\xdb9I\x8f\xfe\x8b\xf7\xff\x9b\x87S~\x14XO\xfb%M\xfc\a\xb29C\xb3<\v%\xff\x9bm\xf4\x9c\x9f\xd4\xfb?^w\x9e']\x80\xcc/Ҫ/\xe1\xf2\xcb<\xe1\x8a\x1ft\xea*e\u007f\xcd/L\xeb:\xe4|\x83\x1e\u007f\x93\xeeqKm\xe36\xac\xff\x8e\x80\xd8ם\x01<\t\x95/@֝? ?\x15\bH\xb9\xa4`\x80n_( \x8eW8\x007/\x12\x80\x1a\x8b\x06(\xe7b\x011\xa2\xe2\x01\xed\xf9]\x01\xd1{\x89\x00\xebt%\xb5\x81\xbb\x03x\xcfr\x00\x94\xf2^\xb4v_@\xc0\xe0\xfe\x00\xc4\xf4@\x00\x1d\u007f0\xc0\xcd\"\x1f\n\x90,=\x1c@6\xfcH@\x84\xf3h\x00C}\x8c\x87\xc7ٙ'\x02|\a\xef\x93\x01\xb2\x95R\x011\x89\xd2\x01\x1aUN\x80%\x8b2\x01Qfـ\x18A\xb9\x80е\xf2\x01,\xcbx*\x00\xe7{: \xa2z\x06\xe2x6@*Z\x017}\x0eҨ\x18\x10[\xaa\x14@\xd6V9\x00Y?\x1fИP%@6\xf3B\x00\xef\xbd\xca\n\xa2j\x00\x8e\xf7R\x00U\xaf\x97\x03\xe4m\xaf\x04Dk\xd5Г\xea\xb8C\r\\V3\xa0\xc5R\x8e\xae\x16/~-\x80\xc4\xedu\x9cX;\x00$\xa9\xc3C]\x88\xaf^\x80+;\xeb\a\x00\x00\r\x02\xb0݆8\xbfQ\x80Yz\xe3\x00\xd6\xd8\x04\x88\x9aM\x03x*\xb8\x19\xef\xd3\x1cg\xb6\x80BZB0o\xe0\x9bV\x01F\xef\xd6\xec}\x9b\x00\xbc\xb1m@\x96\x03\xb6\xa3\xcc\xdaCf\x1d\x02ʭ:\x060/\xd6\t\x97wfw\xba\x04\x98\xb2u\rH\xad\xab[@\xb7\xdf\t\x10/{\x04h\xe3o\x06\xf0v\x9d\x9e\xe8D/^\xf9V\x80v\x9a\x8b;\xf6\x0e\xc0x\xfb\x04\x88^}\xa9\x87~\x10b\xff\x00*K\x03p߁\x01<\xb5?\x88\xbd\x1e\x9cUŐ\x00\xb7\xdf\t\x90\xb8\x0fÝ\x86\a\xc8R\x1d\x1c\x8eS\x1bwi\xef\xdc\x01\x01\x03#\x00l4\x03xB\xda\n\xc8\xda!O\x00\xcbK\xbc\x01\xad;\xfa`6\xfe\xec\xc7@\x80\x99]\x10\xdd\v\x05\xb0\x8a+\x1c`98\x12@\x95,\x1a\xd0\xe5\xc115\xf88\xbc&\x11\x00յ)\xcad\x80\xd41\xc5k\xd2j\x97\x99\x00\xd6\x14\x8e\xe0\xb7#\xd5\xd2G\xa1k\xa3\x03p\xf61*\xe9\xb1\x01\xd2\xd5q\x01\xe6\x88\xe3\x03\x12\xe5&\x04\x10\xfc'\xb2\x81I4\x84Ɂ\xec\f\xfc\x14~?5@\xe60Mۚ\xfe\xff\x13f\x04t\nq\xa6\xaawVVγ\x03\xa8\xda\xce\t\xf0\xe1\xe2\xb9\x01y\x82j^\x00\xb5\xa5\xf9\x01A\xdd\x05pυ\x012\xe5E0\xfdŰ\xbb%\x01\xb2\x82\xa5\x01\x94,\x97\x05\xb0\x16d9\x95\xb3\"\x00\xc8[\x89\x06Wa\xa8\xab\x81(k \xe4\xb5\x01\xc1ӷ\xb3\x1ax\x87#x\x97\x87\xf7t \xeb\x02\x9c\x12Y\x8fK\xde\x0f\xb0\xb6\xbfAE\xf3\x01\x9a\xd8\x18`\xbdu\x13T\xfa!\xc4\xf5\x11;\xb4\xf9\xff\xe3\xff8\xa0\xef\x00a\xdf>\r\xf0\x05t\x9f\x05Hm\xb7d\xa5\xf1y\x00\xc9\xce\x17\x01R\xaf\xad\x01L\x12\u007f\xa9\xc2٦\xba\xf9*\xdb\xeb\xaf9\xe2oxڷ\xda\xdaw\xb4\x85\xed\xb0\xc6\x1d\x01\xe4\r;\x03\xe0\x9d\xbb\x02x]\xd9\ue03e\x19\x92?\xee\t\xb0h\xb27\x80-\xcf\xf5\xc7}j\xfa\xfby\xe9\x8f\x01n]\x17`\xe4\xfc\x19\x83?\x10`)\xf8 \x8d\xe8P\x80\xe1\xee\xb0\xf6\xe4\x17\xb5\xb4_Ք\u007f\xd3㑀&GG\x01\b\xc7\x02B\x02\x8e\aP\xb1\xf8];\xf3\x87\xba\xfa\x89\x00\x8b$\u007f\xea\xb5'U\xfa\u007f\xe1ҿ٫S\xfa\xe3逐\xe1\u007f\x88\xb6g\x02,\xbb\x9d\r0\xfb\xffW\x03̹\x80\xa6\xb0\xff\x05XH9\x1f`fx\x81ҿ\x18\xe0\xeek\x97\xb4\xd1\xcb\x01d\xb0W\xf4\xe3U\x8e\xf5\x1a\x0f\xd7\x03R\xbc\xbb\xa1\xa1\xe4&\f\xe5V\x80\xbb\xf00\xe8\xdd\x11d\xed\xe8\xce .\xc8\x17,\xdc\xd14\xacގ\x9c\xfcA\t\xb9\x05\x82\x82B\x05\x83\xf4\x8bBA\xa1\r\x85\x83d\xfaE\xf0[\xd1 q\xbeX\x90FT<\x88\xa7\xfa\xee\n\x8a5\x97\b\xd2/J\x06\xc9J\xef\x0eJ\"pO\x90%\x97{\xb5\xd9\xfb\x82X\u007fx\u007f\x10+W\x83\x12\x99\x1e\f2\xf3{((r|8ȉ\xbcG\x82\x84\xfcG\x83:\xd1\xf8X\x10|\xff\xf1\xa0\xb0\xd7'8\x84'\x83\xf9[\xe5\xe6\x94\nb\x94\xa5\x83\x12Tr\x82ble\x82\xb0\xbc\xb2A\x94\x99\xca\x05\x81:\xe5\x83\xfa~\xe5\xa0h\xf9\xe9\xa0\x04\xc7g\x82R4\u007f6\x88Փ\x15\x82\xa8\v=\x17\x94yЊA\tv\x95p\xbb\xcaA\x9a\xd3\xf3A!\x16U\x82RK}\x01\u05ff\x18\xc4#TU\x83\xc8\"_\n\xf2\xf9Ƞ\xac\xe4{\x85\xdfU\v\xc2j\xab\aQ\xc0\xaf\x11\x94\x82jͼ\xef\xfa\xf9s^Ց\xd7\n\xaa\x1b\xbd\x16\xa4\xb9\xbe\x9e7h\x875\xa4_N\xed q\xb3N\x10\xa5κA\xa0_\xbd\xa0\x18W}\x0e\xbbA\x10\xf0\xd20\b\xc0h\x14\xd4\xfc\x10\xa2m\x92m\xb8i\x10롚\x05i_̓\xc4\xc5\x16A$*-\x83\xacƾA}\xb6\nʞ\x15\xad\x83R\xa3n\x13\xd4D\xba-%\xde.Hgh\x0f\x83\xe8\x00Iu\f\xb2\xf2\xda\t\xb2\xec\x1cTj\xd1%\b@\xed\x1aĬa7t\xa8;\xb4:(\xa7G\x90\x05\x837\x83:\xc3\xd8\x13\xd7\xf6\x82L\xdf\n\x82 \xe7\x06%\xac\xf4\x0e\xcaR\x94>\xd0j\xdf Y^\xbf\xa0\xb8|\xff Aw\x80Jq`\x10Ӫ\x83\xb4\x87\x83i/C\x82\b\x11C\x83\nl\xc3Ԣ\x87S-\x0e\x0e\xcb\x19\x04\x93s\xa9\x95\xba\x83\xba\xc3k\x90+\x85M\xf4\xce\n\"\x97\xf7\x04\xc1a\xbcA\xa6/\xbe \x9c\xcb\x1f$[\v\xe4}\x9d;\xc0\x91\x13T\xc3\x0fq0\xe1`\xbe\xd69\x91 \x01-\xaa\xb7\x89i\xcf\xe3A\xa1\x18\t\n\xca\xce\xeb\x8al\"\x00y\xa5\xf07\x8d\xbf\x19X\xd5\bj}d\x90+\xa3F\x05\xc5\xcfGkCc\xd41\xc7\xc2\x15\xc6\xf1\xd4\xf1Y\x19O\b\x127&\x06Q-\x9e\x14\xe4L\xcf\xe4\xa00\x8a)A)gL\x85Z\xa7\x05Q\x8a\x9a\xae\xa2\x9a\x11\x04\x1e΄rf\x051]1\x1bw\x98\x13$]\x98\xab\x03\x9b\xa7\x864\x9fW,\br_\xbd\x85\xaa\xa9E\n\r\x8b!\xce%\xd0\xe2R\xdcw\x19\x1ck9\xbdvE\x10U֕\xb4\xf9UA\x84\xe0\xd5*\xb35Als\xb2VG\xfcv\x90\x99\xe7;\xea(\xef҄\xdf\vj%a\x9d\xfa\xc3\xfa !\xf8}\x85\xb0\rYX\xf9\x000\xb5\x91ְ\x89\xd6\xf0a\x10\x19\xe6GA\xce&o\x86\x80>\x0eJ@\xfdD\xe1\xe9S\xed\xceg\x10ؖ p\xfe\xf3\xa0\xf2\xc9/\xd4#\xb6\x06\x91w\u007fI$ئ\xe2\xf8*\xa8\xb0\xffu\x90[;|\x13d\xe1\xf6[\xde\xfe\xbb \x03\xcfv\x8acG\x10\xd3u;\x83\xa0\xb1\xbb\x82\f{\xbbU\xe4\xdf\a\x11\xc8\xf7\x04\x11\xe8\xf7\xe6\x8dcА\x9c\x1f\x82\x98\xf6\xddG\xdb\xdb\x1f\x94\xcc\xeb\xc7 \x93\xf8\x9f8\xb8\x9f\xd5^\x0fК\x0f\x061\x83t\x88\xd2=\x9c5\x99_\bo\xbf\x06\xb1\xf2\xf97\xbd\xe7\x11\x1d\xfc\xd1 \xe9\xc0\xb1 \x03\xf4\xf1 wG\xfc\x1d\xf1\xe4\x0f\xf8\xec\t\xd8\xee\x9fA\x12ӓA\xc4\xf9\xbf\x14\x06\xfe\xa6\x85\x9e\xe2\xb8O\a\xb52\xfb\x8f\xc2\xe0\x99 JigU\xd7\xff\x06奰\xe7\xd0\xec\u007fA\xb0\xea\xf3h\xfd\x02@\xfab\x90sޗ覗\x83\x8c\x84W\x82 \xb1W\xb3B\xbf\x16\xc4^\x00׃d67\x82`.7\xe1G\xb7\x82\xa8%\xdeΞ{GH\xcc\xf2\xce\x10\xb6\xad\v\xe1\t\xff\xfc!\x89R\x05Bb5\x05C,h\x14\n\x01\xe9\n\x87duf\x91\x10-\xadh\x88\x02.\x16\x12\v)\x1e\x02r\xdf\x15\x12\xbaX\"\x04\xf5\x94\f\xc1\x95\xee\x0e\x89y\xdd\x13b&~o\b\xeb4\xef\vQ\xb4\xf7\x87\n\xb7\xcf5\xe4\xbd\xfd\x0f\xf0\x87\aC\x12\xe6\x1f\n\x91I<\x1c\x92\x84=7\xe7\x91\x105\xf2hH\xbc鱐\x94\n\x1e\x0fI\x98{\"D\xa4}2DvX*\x04w*\x1dby9'$N]&D\t\x97\r1^\x86`L\xe5Cxf\xe4\xa9\x10\xc9\xde\xd3!\x06\x8fgBj\xe5φ\xe0k\x15B \xfeυ\x90mTԞT\n\x89\rT\x0e\xc1\xaf\x9e\xe7oUB\xb0\xd5\x17B\xd0\xc0\x8b\xa1\x82Ms\xcdܜ\xaa\xfc\xf8R\b8\xfarHP\xe1\x15\\]\r\x92\xa9\x1e\xe2{C0\xb4\x9a:\x9cWCȻj\x85\x84\x92\xbf\x16Ұ\x19\xa2}\xd6\x0e1_\xad\x83Kꆈs\xf5B\xc0\xd7\xfa\xecD\x83\x10l\xab!\x87\xda($\xeao\x1c\x82k4\t\xa1N\xd34D\xa8h\x16\u009eR\xcdCR*h\x01ѶTݾ\x01ݶb\x8b\xadu<mB\\\xd4\xde6\x94}jR;\xd0>\x04\x18\xe8\x10\xc2\n\x90\x8e\xfam\xa7P^\x1c\x19\x9c\x97v\x86\xe8\"]\xf4\xf2\xae\x18|7\xfc\xed\xae\xfa\xe9\x11\x022\xbe\x19b\x82\xdb\x13\xbd\xee\xc5q\xbd\xa5B\xc8\r\x15\xc9\x13\xf9pCV\xb0\xaa\x1c\xfap\xac}U<\xfd8\xcc\xfe!\r\xd4\x03BB'\x06\xeaɃBD\xd2\xc1jbC\xf2\xfa%ǡ!\xbca\vF5<\x04hvh?\x9clХ#p\x87$32 )3\x84\x8dw8rO\x88\xe5`o\bUO\x9f~\xf4\x87\x84O\x05B\xdc\xf65\x84J^(D\xdc\x0e\x87\xf0\u0590\x90\x94\xb8\xa2!,\xa5\x8cQ\xdcq\x1dMB\xe47\xac_\x8e\x1d\x12(H\x86P\x19K\x85\x04\xac\xd3!\x04\xbaL\x88\xb5\x84\x11!T\aG\x86P\x8d\x1b\x85\xf3G\x87\xc0\xb4ǰͱ\x18\xe3\xb8\x10\xe3f\xa8h+kH\xee\xb0A\x86#gB(\u007f;G\xceĐp\xe2I8i2\xcdu\n\xccujHXݴ\x90\xd4֦\x03\x05f\xa8;\xcfT-\xcf\xc2E\xb3\xe1\xfesB\xe4\xa1s\xf1ݼ\x90\xe4:\xf3\xf1˂\x10\x91\u007fa\x88\x1cf\x11F\xbf8\x84pI!/\xd5\x06\x97\x85\x10\xa3\x97\x87\xb2[ج\b\xa1ܴ\x92#Y\xc5A\xae\x86\x81\xae\xe1wk\xf3\xb0\xc4\x1ab\rs\xe4\xbc\x1d\xd2W\xb6\xbc\xa3b~\x170\xf0^\xf6\xebu!<{\xb9>\xc4*\xd9\xfb\xe8\xe8\x06v\xe0\x03X\xe4F\x8c{\x13\xfa\xfe!e\xf8\x11;\xb09\xa4)\xd5\xc7\xec\xe1'!V\x98>\r\x91}|F\x1c\xdd\x12*\x94\x87\x99yv\xffy\b\x9b\x13}\xc1\xc3\xd6\x10\xa3ԗj\x85ۨ\xb3\xafB\\U\xf3u\b\xb1\xf0\x1bXط\xda\xf2w\x00\xe3\xed\xea#;\x885;C2װ\v=\xdfM\xd3\xfa\x1e\x83\xdc\x03[\xda\x1bB\xfd\xfd\x87\x90И}!\x94\x80\xf7\x87\x10\n\u007f\xd4.\xfc\x14B\xc0\xfd\xf9\xffR;\x10\xc2\xcb)\x0e\xfe_\xe4\x87\xf4\xcc\xc30\xf5_8\x82_)\xf9\xdfBH\x85\x8f\xa8\xed\x1d\r\xe9\x9c\xd81\x18\xc9q\x9e\xfb;\x0f\u007f\x84P\x13:\x818\xf3gV\t'\xb3\x97\xfc\x15\"\xd3\xfc\x1bpv*\xc4e\x83\xa7\xa9\xd4\u007fT\bgT\x93g\xd9ֿ!>\xeet.\x84\xc8\xfd\x1f\xe4p>\x04\x96{\x01>y\x91\xbf\\Rc\xbcL\x8c\xb8\x82\xa1\\\r1?\xb8\x16B\xb5\xe8::v#\xc4(\u007f3\xa4\xe4\xe0\x16\u007f\xbd\x1dB\xdd\ue3b0\x98ڝaT\xcb\xf3\x85i\xa5\xf9\xc3X_U \f\xd3)\x18\xa6y\x17\n\vn\x15\x0e\v-)\x12\xc6\x14}\xd10j\xa8\xc5\xc2(~\x15\xe7\xe1\xae04P\",Y^ɰ\xf8\xc2\xdda\xechvO\x18\xfb3\xdd\x1bF\x15\xe1\xbe0\xe8\xd7\xfda\xa4\xe0\x0f\x84I\xdb\x1e\fc\xde1\xcc\xc7<\u0080\x82G\xb4\a\x8f\x86Y\x8eE\x9f\x1f\x0f\xf3\x95\xcca\xb0\xa5'ٓRa\xc6\xc902\xa4\x9c\xb0\xb8g\x990\x17\xe2\x96\r#\x14\x97\v\xc3\xeeˇ!\x86\xa7\u0088\xe6O\x87\v\xb6\x184</\xb1\xe4\x85φ\xc5\xe6*\xf0vυ\xc5&+b \x95\xc2\f!\x95\xb5G\xcf\xf3\xf2*a\xbeF$,\x12\u007f\x11\x17W\rs\uf770>\xf8\x18\x86\xe5\xbe\x12\x06g\xaa\x16\x16\xec\xae\x1ef~Z\x83_\xd6\f3}y5\f\x8c\xaa\x15ֵ\xabh\xee\xf50bH\xed0\xa3[\x9d0\x82|\xdd0\xb1\xbb^\x98\xef\xd6\nklh\x10\xa6Y5\fK\x11\xbaQX\xabg\x8dÀ\xd9&aA\x81\xa6a1\xe9f\x94~\xf30&\xc6Z\x84\vv\x96`\xd82L\xaf\u007f\x83Rm\x15\xe6\xb6\x19\xad9\xa66T\\[v\xbb\x9d\x8a\xa4}\x18\xc9j\x870\xf0\xa4c\x18\xeb\xba:\x855\x11\xed\x1c\x16o\xef\x02Qv\r\x13\xa0\xba\xe9\xb1{\x18\x13v=\xd8\xfa\x9ba\xa9\xda\xf5\fӖ{\x85\x99\x9b\xbc\x15ƴ_n\x18!\xacw\x98\xf9C\x9f0\vD}u\xbc\xfd \xab\xfey\xe7\xe6\xc9z@\x98p<0̂\xf5\xa00}f0mk\bu6\x94w\x1d\xa6\xf7\x19\x1e\x16\x8cr\x841k\xe0\fc5\x89K\x1br\x87%\x8a\x1aaup3\xacي\x15\x06\xab\xf5p\xc8^Z\x8d/L`\xf3\x87\xb9\xe06\x10Fx\n\x86\t\x89!Ud8,\xb8\x1c\tg_CI߉Q+\xf10\xe7$\x12\xda\x01;L\x96\x96\xa4\xf7\xa5\u0098\xfeI\xab\x183a\xe0ሰ0\x9e\x91\xfc0\x8a\xa3\x1b\xad\xe6:\x06\x06:\x16R\x1a\x17f\x96<>\x8c\xf2\xf7\x840\xa6\x9d'\x861\xc71\t\xa7LV3\x98\x02\xe5M\xe5\xc0\xa6\x85A\xec\xa6g\x8djF\x98i\xd0Lx嬼\xd6\x1cCrf\xe7\xf9S\xae\xd1/gNXww\r#\xaa\xcc\v㉸\xf9a\xc1\xb5\x05\x18\xfa°\x02\xe7\"\xb5\xa3Ū\x89%\xea\x0eKØ\x9d\xc4\xdf\xe5a֮W\xe0\xd3J\x8aaU\x98\x94b\xb5\x1a\xc1\x9a0\x1f\xd9Z\x1b\xe6\x16\xaf8\xf7\x1d\xdaػ\xbc\xe4\xbd0\xd3\xfcuanS\xb4>̹\xf7\xf7ì\x86m\bca\xf2\aa\x04\xbd\x8dD\x8cM4\x8a\x0f\xc3Xj\xf3\x11\x9a\xdd\x1cֵ\xact\xefO\xc2\\U\xf2\xa9z\xf6g\xaa\xed-8\xf9\xf30_E\x19\xc6D\xeaV\x15͗a,\x8c\xd9\x16F\x01\xe1\xab06\xe7\x01\xd8|\x13f>\xfamVD\xdf\x11\x9d\xb6\x87\x91\xf5\xed\bc\xd9\xf3\xce0\xd8\xff.\xa0\xf3nm\xf4\xfb0\xa8\xdb\x1e\x88x/l\xfa\x87p!\xa1}Cs\xf6\x855\xd4\xef\x0f\x17\xceS\x92\xec\xba\xf9#\xce\xf8)k\xd0?\xab\xed\x1e\b\vO?\xa8r=\x14\xe6\xea\x8e\xc3:\xa8_0\xa8_\xc3$\x9c\xbfe\xb1\xe7HX\xe2\xd4Q\xf6\xeaX\x98y\xef\xf10k\b\xbf\xd3\x1e\xff\b\xa3\xb4w\x02\x0e\xf5'm\xfed\x98\xdc\xe1\xaf0#\xe5\xdfj֧\xc2L\x10O\xebm\xff\xa1Z\xcf\xc0B\xcf\xf2ÿ\x18\xfc\xb90\xd2\xde\xff\xf4\x9e\xe7y\xaf\va2\xe4\x8b*\x9aKz\x9f\xcb\f\x1cW\x88\x06W\xe15\u05c8a\xd7i\xe97x\xc6ͬs\xde\n3q\xbcM\xf0\xbd#\x82R՝\x11}7e\x84\xed珈,\vD\n\xb6\xca\xf5\xe6\xe6\x14\x8c\x14n\xdd\xd7!\xb4\xbeP\x84\xe3)\x1cAf[$B\x16^4\x02\x9d\x16\x8b\x88ދGh\u007fwE\x84픈\xd0\xfdKF\x84\xee\xdc\x1d\xc1J\xa2{\"\x8c\xd1\xf7F\xa8\xa3\xfb\"X\xb9u\u007f\x84^\xf3@$\xbb\xb2\xe5\xc1\bz\xff\x10{\xf9pD\x9f\xe5\u007f$\"\x10\xf0h\x84\x98\xf8X\x04n\xf1xD\x84\xf9\x04\xafx2Bh*\x15\x01\xb1*\x1d\x91\xbabND \xa0L\x04;藍0\xd9)\x17\xa1e\x94\x8fH\x9c}J\xaf{Z\x05\xf1\f\xdb~6\x92\x87=nGN\x85\b|깈\x10\xf8\x8a\x11\x82F\xa5\x88\xd0\xee\xca\x11\xc1\x83\xe7#\x88\xcfU\"P\xc8\v\xe8\xe7\x8b\xdaV\xd5\b\xc0\xfa\xa5\x88&g/G\xe8\xf3\xafD\xb0\x14\xbbZ\x04\n\xab\x1e\x11s\xaf\x11\x91\xc0V3\xc2J\xc1\xab\x11\xaa\xbfVD(\xd2k\x11\x06\x8e\u05f5\xdd\xda\x11\x01\xad:\x11V\xad\xebF\x00\x85\xf5\"p\x9e\xfaY\x915\x88\x10\x1d\x1aBG\x8d\"X\x8b\xde8\x82U\xefMT\x1dM#Z\x05i\x16\xc1\xc3\x0f\xcdE\xcb\xc3rZ`\x14-\xf3t%\x0fǾ\x11\x01(\xb7\x8a`c\xae\xd6ڗ6\x11\x84\x8f\xb6\x11&\xec\xed\"\\o\xd6>\x02\xdaׁC\xeb\xa8]\xec\x14\x01\xf7\xec\x1c\x01\x9ev\x89\x88\xddwe\u007f\xbbEX+\xe8\x1e!\b\xf5\x88`\x93\xe87\xd5Pz\xca]\xf3\x02jDW\xbcF\x80\x1e\xb9\xecRo\xf6\xa1O\x04+\x05\xfbF\x98<\xf6C\xef\xfbg\x876 \x92\xbf\xe3\xf0\x9c\x81\x11\xa9\x1e\x0f\x8ah%n0\xaf\x1c\x82S\x87Fd\xeet\x98\xdeqxD#\xa5#B\x97vF\xc0\xae]\x11z\xb4;\x02\x1eaD\x18\xea͈\x10eK\xfb灰\xbd\x11,\xae\xf4Q1~|\x17\x88\xb0\f\x15\x84\xa3\x85\xa0\xc1p\x04S\xb2\x115\x8bh\x04\xb48\x16\x91\nm<\x026\x9b\xd0A\xd9\x11\x81\xadd\x84u\xa6\x14L/\r\x93\xc9\xd0\xc8FD\x80\x1b#\xf5\xfcQ\x11\xa50\xa3#`\xcccp۱<w\x9cz\xc0x\xed\xf5\x84\bjJ\x13a\x88\x93\xf4\xcb\xc9\xea\xeaS\xe8\x01S#\n\xb3\xd3\xf4\xe2\xe9\x11\x90\xaf\x19zÙ\x11p\x9cY\x90\xe8\xec\bf\xe5\xe7p@sy\xd7yj\xd3\xf3#\x82\x9f\v\"`\xb2\va\v\x8b\"\x8c\xf4\x8b\xd5.\x97\xe8=\x96F\x84\xb6/\x8b\x80\xd1/\x87\xccVD\x10\vWfǷ\n߮\x8e\x80\xf2\xad\x89\x00X\xd7\x12\x12\xde\xd6V߉\x90\xa4\xbf\x1b\x11\x92\xfe^\x04\xec|]\x84\xc1t}D\b\xff\xfb\xbc~\x83:\xd8\a\x11\x04͍\x11\x90\xf5M4\xe6\x0f#H\x14>\x8a\x90\x98o\x8e\x80H~L\xc7\xff$\x82$\xe1\xd3\b(\xd0g\xda\xff-\x11\x90\xe2ϩ\x9b/\x80W[U\f_F\x84\xe5n\x8b\xe8\xf6v\x90\xdb\u05fc\xd37\x11\x8dJߪ<\xbe\x8b\x80\x02oG\x03;\"\xa4\xcf;#\xa4\x1a\xbb`_\xbb#d=\xdfG\x00\xf3{\x14\x85\xf7*d\xfe@\xab\xdd\x17\x11\x9a\xba\x9fN\xf5c\x04D\xf1\xa7\by\xf2\xcf\xf4\x89\x03\x11\xf0Ѓ\xea燲\xeep\x98\n\xfe%\x02\xbe\xf8\xab\x9a\xffo\x11\x92\xbc#\x1a'\x8eFH\xf6\x8eEH \x8f\xd3S\u007f\xc7\xf0\xfe\xa0C\x9c \xc4\xfe\t͝\x8cH\b\xfb\v\xff\xff\r#=\x15!\r9\x1da҉/\xcf\xc0\xfe\xcfF\xc0!\xfeU\xac8\x17QN\xf0_\x04l\xe4|ֽ/\xd0\x0e.F\x18|/Eȭ.+$^\x89\x90\xb4]eG\xaeE\xc0\x8d\xaek0\xba\xa1Fp3B\x96t\x8b\x16w\x1b\xdeqGTw\xe6\x89\n\xd7\xc9\x17\x15\xaa\x91?\xaa\xaeQ J\b)\x18\xe5}\vEa\xff\x85\xa32\xc4\"Q\x06\xf8\xa2Ql\x02\x1b\x85\x89\x16\x8fB\xe6wE\xc5%JD\xc13KF\xc9M\xee\x8e2\xe4\xdf\x13\xa51\xdd\x1b\x05Q\xb8O{p\u007fT7\x1a\x88\nsy0*\xbd{H/y8\n\x1e\xf3H\x94A\xfe\xd1(\xa2\xf5cQ1\x9fǣ\x12\x19\x9f\x882\xec=\x19eH+\x15հQ:\x8a\xf8\x99\x13%\n\x94\x89\nҔ\x8d\x8a\x89\x95\xd3ᕏ\x02\xb6\x9e\x8a2V=\x1dE4{&\xcaկQ\xc2F\x85(\xe2\xe2sQ\x04\x9c\x8aQ\x84\x9fJQ8B\xe5(1\xff\xf9(\xc3C\x95(\x83\xc7\vQ\xb5\xb5\x17\xa3DĪQ@\xefK:ԗ\xa34\xbaW\xa2ĜjQ\xa4\xe4\xd5\xd9j\x8d(=\xba&\xbf}5\x8aU\xb6\xb5\xf8\xe9\xb5h\x91\x16\xb9\xb9C\xfa\xb9\xf3\x92Ҩ v\xed(K\xe7u\xa2\xa8\xf2ԍ\xf2\x8d#\xdaF}\x1dE\x03=6\x8cr\x01v\xa3(xI\xe3('\x99\x9aD\x11\xac\x9aF\xc1\x8d\x9bEu\xb3\x98\xe6Pq\x8b(\x1f\xd1k\xa9m\xbcA\x01\xb5\xe2ɭ\xa1\xb06\xdaP\xdb()};=\xb6\xd7~t\xd0\xcf\x1d\xa3\x98o\xec\xc4^v\x8e\xc2\x15\xbb@\x9f]\xa3B\x11\xbaEe\x06\xb5{T8W\x8f(\x90\xe9ͨ$\xcc=\xa3\x98\v\xee\x85_ޢ]\xe4j뽣Rc\xec\x13\x05}\xec\v+\xed\x17\xa5\xdf\xf6G\xdb\x03\xa2\b\xd8\x03\xa3H\x9e\x06E9\xe378\n\xe4\x1f\xc2\xeb\x86F\tGâؕ'\n\x04sD\xe5Ih':\xe5\x8ab\xf3 w\x14\xd0h\xc0\xd4ͨ@\xb1\x15\x95՝\x9e(\xdcϋ\xce\xf8p\x89\x1fV\x17\x88r!J0\no\x0eE\x85\x83\x85\xa3\x82\x14\x11\xb5\x98h\x94\xf0\x13c\x1bq\xfc\x98\xd01ؐLR{\x9d\xa2\xd0Ҹs\x06'\x8e\xc0ߑQnv0*\xca\xd2\xc5\xe8(&f\xc6D\x95@\x8c\x8d\xca\xea\xd3qQL\xaf\x8dד&D\x11V'\xf20)\x8a@1\x19C\x98B\x0f\x9a\xaagN\x83\xe4\xa7g[\x9b\x11\xe5f\xfc3y֬(\xc1n6<l\x0e57\x17.=/\n蜯\xbe\xb0\x00g,T0X\x14%\xae/\x8e\xe2m\xb5KxX\xaa\xe7.S\x87YNM\xadЋV\xa2\x89UѢ]s\xf3\xb8\xfd\xf0\\+gu\xb6[k\xf4\x94\xb5\xd0\xe2\xdbQ\xa2\xf9;QD\x8dw\xa3\xac=\xbe\xa7x\xb2.*h\xbe>\n\x02\xf7\xbe:\xf1\x06\xca\xe0\x03\xfd\xb81\xca0\xb7\x89V\xff\xa1\xb6\xf8Q\x14{\x01o\xce\xde\xf7cřOp\xdfO\xa3,\xfb}\x86\x8en\x89\xea\x9a\xd6\xcfՓ\xbe\xe0-\xb6F\x19\u05ff\x8c\xa28\xb1\x8d\x87\xaf\xa2\xc8w\xbf\x86\xe1~C?\xfd6\x8a\x1d\t\xbeCsۣ\xf2\x80\xc7\x0e\xfc\xbf\x13V\xb0K\x85\xbf\x9b\xd6\xf3=mwOT\xca\\{1\xc6\x1f\b-\xfb\xb2\b\xbf\x1f\xdf\xfe\x88\xbf?\xc1\xcb\u007f\x8e\x92\x00\x1f \x92\x1f\xe4\xe1P\x94a\xf0pT\xa8\xe5/\xda\xe1_\xb3\xf8\xf6\x1b\x14|\x84=>\x1aEP;\x16E0:\x1e\x05=\xf9\x9d\x83\xfa\x83\x06qB\x91\xf7\xcf(\x83\xf2\xc9(*g\u007fE9\xa7\xfbw\x94\x11\xebT\x14\x91\xea4\xfb\xf0\x0f\x91\xedLT8\xd4Y\xfc\xfd\x970r.*ϭ\xfc\xa7\xf8}\x1e\x12\xb9\xa0\xfa\xba\x88\xd1_\"\xd0\\\xa6\xff_\xa1\x18\xaf\xeaP\xaf\xe1\xf2\xebT\xff\r\\}\x93\xb7\xbc\xa5\xfd\xbb\x1d\x05\xff\xbb#\x86u\"w\xc60i\x97/\xc6gDbXE[ \x06\\*\x18\xc3\xf4L\xa1\x18^\xf9\x1cC\x84+\xc2CQ\x1e\x8a\xc5\xc0R\x8a\xf3pWL\x1e\xb0/\x11\x93ղ\xb99%cL\xee\xefƷ\xf7İ\x01ֽ1M\xb7\xee\x8b\xc1\xf4\ue3f1d\xf4@LB\xf6\x831\x1a\xe2C1\x82\xcb\xc31L\xc0=\x12C<~4&+@\x1e\x8b\x89u<\x1e\xe3\x9e<1\x01\xac'c\x98L.\x15â\x9b\xd21\x81֜\x98ȴ\f\u007f)\xcbA\x96\x8b\x819\x96\x8fa\xa3\xf4\x18\xfd\xe6\xe9\x98<5\xfdL\f3\xb1\xcf\xc6\xe0\x01\x158\xba\xe7b\x9cƮ\x18\x93\xd9\xdfJ<\xa52\xae~\x9e-V\x89aM\xe6\v1 ͋1\xe1\xfcUc\\\xac\xf5\x12\xc6\xfd2e\xf8\x8a\x8e\xb3ZL\x1e^\xae\x1e\x93\x84\xa7F\x8c\xeb\xc8jƸ\t,GY\x8b#{-\x86\xb2\xf3\xeb<Ԏ\xd1H먀\xea\xc6\xe0\r\xf5\xa8\xb5\xfa1T\xf0\x1b\xf0܆1\xb2\x87F1<<\xd88F?j\x12\xd3j}Sv\xb6YL\x16 6\x8f1ڷ\x88qҰ%\x1b~#\xc6Ǣ[\xc5X\xe0l\x8d\xb1\xb4\x89\xc9\xfa\xae\xb6Tv\xbb\x18\"L{v\xa1C\x8c\x16ڑ\x1a\xeb\x14S\xb2\xd79\x86\xfd\x04\xba\xc4\xf0\xb8O\xd7\x18yp7\xa8\xa8{LbF\x8f\x98\xb8ۛ1\xd4\xc5z\xc6@\xe3{ńV\xbe\x15#\vȍ1\xb9\xeb\x1d\x93\t\xcd!\xb9\xa6#\xa7\x0f\xef\xdaW\xa5\xda/\x86E\xb4zހ\x18\xa6r\aƊu0,w\xeep\xe1\x15\x83\xf8\xdd`=e\x88vwh\x8c\xe05\x8c?\x0f\u05ef\x1dzt\xea鮘8\x95;;(C\x15g\xea\xed-^\xed\xa1\x1a\xbc\x14\xa1\x8f\xda\xf0\xab$\x031Tꂰ\x9e\x90^\x18\xd6cD\xa5\x1f\xc58b\xf8\x1b\x8f14&`\xe2vL\xea!ɘ\xf8s\n\xff\xa7\xf1}F\xcf\x1a\xa1Ǒ1L\x93\x8d\u0089\xa3c\xb2D`\fn96\x86\x92ظ\x18\x9e\x91\x1d\x1f\xc3\fք\x98\xac$\x9a\b\rL\x8a1,M\x8e\xe9\xac\xfe\x14\xb415\x86\xe4kZ\x8c\x989=&\x04uF\x8c\xa9\xcf\xcc\x18cά\x98\xcc\xd2ώ\x91\xb9̉1\xfc͍!\xc1\x9a\x17\xc3L\xd0\xfc\x98,{]\x10S\x1a\xb60&\x91w\x11e\xb58\x06\xe8[\x12\x93\xf0\xb04\x06\xc8]\x16C<Y\x1e\xc3R\xbc\x15\xea\x8a+c\x04\xdbU1&z\xabc,߮\xa1Q\xaf\x8dI\xc2\xf8v\xdeP0\xa9\xc9\xc1\xbe\x1bCq\xe4\xbd\x18\xe3\xd7:\x88w=-\xed}\xa2\xe0\x86\x18H\xf8\a\xc0\x96\x8d1\x06\xeaM1\xac\x9f\xc5ߏة\xcdl\xf1c\xb5\xe3ObX\x11\xf0i\x8cy\xe2g1M\r\xb7\xc44\xf7\xf9<\xc6\xe4RO\xd8\x1a\x03Y\xfaRŷ\x8d\x9e\xf4\x15-\xe5k\xde⛘\xf0\x94oc\u0083\xbf\x8b\t\xdeo\x8fq\x95\xef\x8e\x18*\xc2;\xe9x\xbbx\xef\xdd\x00\xce\xefc\x92:\xee\xa14\xf7Ƥ\xd4\xf7\x83z\xcf>\x9c\xb0\x1f\xa2\xfdQ\xa5\xf8\x93B\xc4\xcf1\x12\x8b\x031\x14\x86\x0eRև\x88\xa3\x87\xb3\xe6\xfe\v\x9b\xfd5\x86\n\xebo1Y\x88\u007f\x04=;\x1a\x93\x12ޱ\x98$Z\xc7a.\xbf\xc7\xf8\f%\x1c\xf8D\x8c,\xebO5\xef\x931\xae\x99\xfa+\xef\x82ܜ\xbfcB\xb2O\xa9(O\xc7d\xee\xff\x9f\x18\xc8\xec\x19\xed\xe7Yq\xacܜ\u007f\xd1\xf4\xb9\x98\xee\xf9\xfe_\f\x137\xe7a\xbc\x17\xb4͋\xec\xe4%\xb5\xd3\xcb1}\x1bݕ\xec?W\x01a\xd7b\xf9\x1a\xe5\\\x8f\xb1\n~#\xc6\x10}3\xcfGQ\x8d\x85\xa8nǰB玸\xd6h\xef\x8c\x13\x03\xf3\xc5q\x87\xfcq\x10\x83\x02qP\u0382q(\xb8\x10\xbf,\xccOE\xe2\x12\a\x8aƱ\x17L\xb18\x96\xfdċ\xb7\xee=ȟ\x97\xe5\xe4\x1aV\xce]q\xc0W\x898\xe7sK\xc6\xe5\x8d\xc0w\xc7I>\xef\x89K\xb8\xbd7\x8e2\xd5}q\xa1\xc9\xf7\xc7\xf9 \xc1\x03q\xb2\xe1\a\xe3\xe0\x12\x0f\xc5\xc5H\x1e\x8eÒ\x1f\x893[y4\x0eG\u007f,\xcet\xec\xf18\xe5\xfbD\x1c\xc0\xf0d\x9c\xf5\x84Rq\xd4xK\xc7\x01\xcf9q\xf2\xc22q\xe2QY\x0e\xae\\\x9c\xb5\x99\xf2q\x9a\xefS\x1c\xde\xd3q\xd9\x1a\xec\x998\xe8\xeb\xb3q)\xb7V\x88\x83\x0e?\x17\xc7\xc6G\x15\xe3\x98Y\xac\x14\xc73\x94\x95\xb3\x82|>oHy\xadV\x89\x8b)\xbe\x10\xc7r\xab\x17yjո\xac\x92\xc8K&\xf3Nq\xf8s^\x8e\x8b\x1f\xbe\x12\x17\x88\xa8\x16\x87\xb9W\x8fK\xd6Q#N`\xae\x19W\a{\x95\x82\xaf\x15\a\x17~-\xae\xd3\x1a\xaf\xc7\xe9a\xb5\xd1P\x9d8\x1f\x92\xa8\x1bG\xfc\xaf\x17\xa7\xda\xeb\xc7\x11s\x1a\xc4\xf9\xea\xca8\x17\xe55\x8a\xc3\x1b\x1b\xc7\xe9tM\xd8\xe9\xa6*\xc6f\xbcQ\xf3\xb8\xd0\xd5\x16q\xb1˖qI\xa7ވs^SE\xd5:\xce*H\x1b\f\xb6-\xfe\xb6\x8bK\xd4k\x1f\x87\x9bw\x88+\xc9\xeeH]v\x8aӎ;\xa3\xc7]ص\xaeqr\xc7nq>\v\xdc=.\xabYzP;o\xc6ɯzƕR\xf5\xa2\x81\xbe\x95'\x92\xbc\xa1\xe7Rn\xbd\xe3Bo\xfa\xc4\x05\xe2\xfb\xa2\xa7\xfd\xe2\xb4\xfe\xfe\xb4\xb0\x01q\x81Áq}\x96cP\x1c\t\xe1\xe08\xc8Ȑ\xb8\"\xdaP\x9aϰx\x9e\xfb\f\x8fcɕ#.\xcbr\x9dq\x00\xa8+N\\vǁp\x86Z\x9f\x89ƭ8\x00\xc5\x13g\xed\xc4\x1b\x97\xb8\xef\x8bk$\xf0C8\x818\xa1(\x18\x17\xf0\n\xc5Y\xa4\tDž\xa4D\xe2\x9c\x1c\x88\xc6\xf1`L,\xce\xf2Y<\xae\v\u007f\xe2\x02$6NMƱ\xa6*\x15'\xb9K\xc7%Tf\xe2\xacʌ\x88\vb\x8c\x84\xd6F\xc1wF\xc7I\u007f\xc6\xc0I\xc7B\xf6\xe3h\xe5\xe3\xe3\xc8\x01'\xa0\xf1\x89qTU&A\x98\x93\xb3=\x9f\x82ߦRW\xd3\xe2Ĭ\xe9\x94䠜\x19qR\xf8\x99qM,fa\xa0\xb3\xb5ks\x00\x12s\xe3\x12]\xe6eU8\x1f-.P\xe9-\x8c\xb38\xb1\b\xdf.\xa6z\x97\xc8\xf5\xeeܜ\xa5\xea\x9c\xcb\xd4%\x96Ǚm\xaf\x88\xb3\f\xbd\x12\x82\\\x15\xc7j\x82\xd5:\xce5t\x97\xb5q@\xdc\xdbq\x82\xe5;*\xdfw\xe3\xc8\x1a\xde\xe3\x8d\xd6i/\xd6+8\xbc\x0f\xe3\xdb\xc0\x16>\x88cS\xa0\x8dqͽ6\xc5Q=\xfc0\x8e\xa0\xfd\x91v|s\x1c唏\xe3|3\xdf't\xadO\x15\xf6>ST\xdb\x12\xc7Kt?ׁ|\x01\xf3\xd8\x1a\xe7\xf3\xa7_\xc6Q\xd2\xdc\x16\a\x91\xff\n\xba\xfb:\xce\x1a\xc27\xf0\xc2o\xf5\xba\xef\xe2(cmgk;\x00\x1e;\x81\xa5\xbb\xd8\xe7\xddT\xe2\xf7q\x14\xef\xf7ą\xc9썃\xc0\xff\xa0ػO\xadp\xbf\"Ə\xea+?\xc5\xf9x\xccϸ\xe3\x818\xa2\xd4A\xa8\xe5\x10[8\xac-\xfc\x12G%\xe3\u05f8\xc4\xc7\xdf\xf4\xcb#\x8a\xdbG\xa1\x93c\xfa\xed\xf1\xb8\xee;\xa0v\xfcG\\\x18҉\xb8\x86\xb9?\xf5\xb4\x93q\xe4y\u007fe\xbf\xff;.Q\xea\x94j\xe7t\x1c\xa4\xf3\x9f8\xab\xa6g`\xc8gi\xbb\xff\xea\x97\xe7ԛ\xfe\xe3\xb9\xe7\xa9\xdf\v<\\\x84S\\R\xff\xbd\x1c\a%\xb9\xc2߮\x12֯\xc5A5\xae\xc7\xc9\x1an\xc41;pSeu\v>~;\x0e\x96wG\x82YeB\xbe˗\xd0\x1aA\xfe\x84Xy\x01\xfc-\x98\xc0ՅpFa\xfc-\x92\xa0\x94\x8b&\x04 \x8b\xf1\x84\xe2\tĒ\xbb\x12x(\xbe\x04\x0f%\x13\x85\xbb\xe6\xf6u\xe4\x11\xfa\xbby\xd6=\t$\xdb\xf7&`h\xf7%Pƺ\x9f_>\x90 \x84?\x98\x80\xd9=\x94\x90\xa9\x9b\x87\xf1\xf7\x91\x84\x06\xcb\x04f\xa7\x1e\xe3\xe5\x8f'\x14\x04\x9fHp\xe7\xaa'\x13\xa8T\x94J\x88\xe5\x97N0\xa6\xe4$\x90?\x97I\x90\xed\x96M\xd0=\xca%\xc44\xcb'\x10ٟJH\xaa\xfat\x02r{&\x01\xb7z6\x81y\x82\nٛ<\x97 K\xad\x98 \x95\xad\xc4\xdf+'\xb8\x01A\xa2p\xd3~\x86l\xd8R%\xa1\x18\xfcB\x82:z1Q\xb0\x81\\P5\xc1\xcc\xee\xa5\x04\xea\x10/'$K}%\x81:u\xb5\x84\xc0[\xf5\x04UT#!:\xae\x99\xbd\xf3\xab\t\xe0q\xad\x046{M0\xb5|=A\xfc\xaa\r-\xd5\xe18\xea&\x04\xb2\xea%P魟`9\xbaABBqÄnb\a\x156N\xf0\x89\x8c&\t2\x88\xa6\xbc\xbeY\x02\xe1\xa09z\xd3\"\xc1=\x1cZ&\xb8$\xf2\r\xa8\xbbUB\xf3\x8d\xd6\tN\x04\xb4I0\xe8\xb5M\xe8[*\x13(F\xb4O\xc02;\xb0\xe1\x8e\tƀN\t\x98]g\b\xbfK\x02\b\xd0U\xe5\xd3-\x81$\xa7{\x02y{\x8f\x04\xe6^\xde̻\x8b\xc3=(\xa7'\r\xb5W\x82\xa8\xf9V\x9ea9\xfa[\xc3\xfb\xe5\xe4&\xb8\xb0\xb87m\xa2\x0f\x84\xd4\x17\xed\xf7K \xf8\xf7W=\fH\xc0\xf3\a\xea\xb0\x06%\x04k\x06\xe3\xfc!\xf8;4\xc1\xfaٰDv\x06}x\xa2@^\xfe\x9e\xe3H(OqjS.=\xba\x13R\x922\x12\xc0\x17\x13·\x12\xe4\xf1\x1e~\xe9\xe5\xc1DZ\xf9y\b\xa0{\xc1\x84\xa4{!\xd5@8\x01\x1e\x18I\xc8\xde\x1a\xd1\x04\xaa/\xb1\x04\xa9l<A\xf0Hp@v\x82!#\x99\xe0\" \xb4\x96Npw\x86L\x82\xe01\"\x81\xca\xeb\xc8\x04\x92\xbaQ\tb\xd6hh\u007f\f\xfe\x8eMp\x8f\x9bq\t}\xd8h|B\x18\xc2\x04:\xd1D\x88gR\x82\x8f\x9eMN\b\x88MI\xa0255\x81\xe01-\x01Й\x9eИ2#!\x81`&\xa40+\x01T\x9fM{\x9a\x03\x87\x9c\xcb\xf3\xe7\xa1\xe1\xf9\xea\x86\v\x12`\xc3\v\xb5\u007f\x8b\x12\xa0e\x8b\x13\x98hX\x92\xc0\\\xeaR\x0e{\x19\x94\xb4<!\xa9ʊ\x04\xb6'H\xa0\x12\xb3\n-\xaeN0\xb9]\x93@L[\x9b\x90\xbc\xec\xed\x04\xe6\xb8\xdf!8\xbd\x8b\xab\xde#\x88\xac\xe3a\xbd\xba\xf3\xfb\xe8\xe3\x86\x04\xc2\xd7\a\t\x14\x946\xb2Ǜ\x12 W\x1f\xf2n\x1f%\xa4\xb8\xb09\x81\x00\xf71\x8d\xfd\x93\x04\xdeR\x99\x00U\xfc,\xc1\xfdA\xb6(`|\x9e`U\xe2\x8b\x04r\xad\xad\t\xa4\xbe_\xaa\xbbl\x83\xf6\xbe\xca\x13\x87e\xe4\xe6|M\x81}\x03\x97\xfd6\x817T&\xf28\xdcvE\x86\x1d\t\xe52;\xd5iv\xa95\xefN\bs\xfa\x1e\x8d\xedQI\xecM \x91\xfeAqg\x1f\xe1m\xbf\x1aՏ\t\xe1\x98?%\xf4i̬\x11\x1c\xc0\xad\x0f&\x18\xce\x0f%$W<\x9c\x90\x1c\xf2\x97\x04\xd2\xcd_\x13\xcc+)\xa2#\t̂\x1cō\x8f\xe1\xefq\xe0\xc4\xef\xe8\xfc\x1f\t<\x97r\"!\xf9\xee\x9f\x04\xbe\x93\t\x89\xaa\u007f\x01c\xfeNp\xf9\xde)5\x87\xd3\xf4\x82\u007f\xe8\xedgt\xd4g\x13x\xcc\xef_\x85\xbes\tҕ\xff\x12 K\xe7\x13\xa4\xe2\x17pߋĝK\t\xc4\xce\xcb4\xff+\tI|\xaf\xaak^K\x80\x90_\x87\xa5\xdeHh\xda|3!\f\xe4\x16\x8c\xf86\xd5p\x87-g\xdcisR&\x9f\r]\xe7\xb7\x11\x1e\n\xd8(\x10\x15䗅x(l\x8b\xd1\x15\xb1\xc5Y\x8a\xdaB\x18\x8b\xe1\xff\xe26^\x15b\xa3TX\xc2\x16+,i3C\xb9\xdbf\xb2}\x8f\r\xa0\xbc\xd7ffu\x1f?\xdeo\xe3\x19\xf0\al\x8e\xf8A[\xb5\xf4\x90-\x11\xe2a\x9b\xbbN>b\x8b\xce\x1e\xb5uE\x8f\r;{\xdc\x06v=aӳ\x9e\xb4\x89\x0f\xa5l\xb2\x98Ҷ`@\x8e\r\xc6P\x06\xbd,k#\xbb,g\x8b'\x94G/\x9f\xb2\x91l=m\xcbJ\xf6gl\xe5\a\xcfڲ\x88\xb3\x82ͪ\xab\xadD\xa7\xa2M\xac\xa8\xc4aV\xb6\tZ\xcf\xeb\xb1\n\x84\xf9\x02n\xfb\xa2\rK\xa8\x8a۾d+\xe1~\xd9\x06\xbc\xbc\xc2\xfeW\xb3\x11*\xaa\xdb2\x89UC\xc7V\xd3\x16\x16\xf8j\xb6#\xb5\xf4\x96\xafٺ\x8b\x9d\xad\xb1\xb76\xc5W\x87\xf7\xa9k\x83BֳY2\xabo\xa3L\xd1\xc0\xe6\x1cuC\x1b\xf5\x89F\xb6\x14y\x1b\xabZ\x9a\xd8\xe48M\xf5\xa4f6\x90\xbb\xb9\xfe\xdc\u0096\xeaDK\x1b\xa9\xa4\xcd@؊\xe3nm\x03\xc2\xda\xd8\xfa\x0e.[\xa6\x02\xdb\xd9\x1a5\xdb۴\xc1\x0ePYG\x1bu\xacN6\xaaӝmС.vv\x9dzWt\xa9\x9b\x8d\xf0\xdf\xdd\xc6B\x83\x1e\xb6\x18蛶\x90\x87\x9e6'\x11zQpoق\x83\xb9\xb6\x06D\x8a\xa0\x8fJ\xae\xaf\x8dUI\xfdԒ\xfa\xdb\xe0\xbd\x03\xf4\xe3@Jh\x10\xfb3\xd8\xc6\x03BC\xa8\x88\xa16\n#\xc3lz\xdfp\x9b\xbc\xcaa\xc3G\x9d\xb6\xd4\x12]6\x1c\xc6m\x03\x15\r\x1b\xc5\x02\x13\x1a\xb7(\x0f\x0f\x1b\xf3\xdaR\xe7\xf7a\x10~[\x9e\v\v\xd8@\xd7 \\$dK\b\n\xdb\b0\x11\x1e\xa2\xb6\x16$bj\xbaq\x18h\xc2\xceK\x0f\xf2\x82\xa1-\xfc'i\xb3О\x82XӸq\x86\xca\x1f\x01?\x1c\x89\x1fF\xfd_\xb4\xa3a\xdecl\xb0\xaf\xb16\x8b\xad6\xa6\x8b\xc6ۘm\x9f\xa0w\x9bh\x93FM\xb2\x05^&\xdb\xc0\x8e)6aw\xaa\x9a\xc94\xb5\x8b\xe96\x8a\xf83lě\x996\x1e\xa7\x9ce\x83\x03̶\x19\xe9\xe7\xd8|\xfe|\xae\x8d\x9a\xce<\x1bQ|\xbe\x8d\x9a\xea\x02\x1b\xd1a!\u007f[D\xd5/\xb69s\xbd\x84?.\xb5\xb1>f\x99MF\xb7\xdc&J\xae\xb0\xc9\xe9Vb\xf4\xab켰\xb1\x1ac_c#Ʈ\xb5\x11F߶Q1x\xc7\x16L\u007f\xd7榮6\x1eEZg35[o\x83\x90\xbfoK\x82\xb3\xc1.\xd4\xd1\xc8\x1d\x90\x97C\xea\xaf\x1bm\xf0\xa8M\xeċjA\x1f\xe9qs^\xf3V\x9f\x9c\x8fm\xa6\xbb\x9f\xa8\x87~\xaa\xc7\xcf\x00\x1d[8\xe6\xcfUj_@\xf7[m\xc9\xc1\xbe\xb4\x89\xe6\xdb\xd4\u007f\xbe\xb2\xb1*\xf6k[\xd0\xf9\x1b\x1b\x19\xa4-D\xe0;\xe8c;\ro\a%\xbd\xd3\x06\xeaﲱ\x84y7l\xed{[2\x88=\x80\x9a\xbd6\x12\xad\x1fl\x94\x00\xf6AP\xfbmT\x99~\xb45\xb2\xfed3\v\xfb\xd9\xe6\xac\xc1\x01\x9b\x85\xa6\x836\x97\xb0\x1c\xb2\xb1\x97\xc9a\x1bK\xb9~\x01\xe2\xff\n\xeb\xfa\r\xc6{Ė\xc0v\x94\xea<f#X\x1e\xb7A\x1d~\xb7\x99\b\xff\x01\x9b=\xc1/\xff\xc4\xe0OR9\u007f\xa1\xb3\u007f\xab\v\x9f\xa2;\x9e\xb69Y\xf0\x8f\x8d\x00~Fm\xfd\xac\xcd\x177C2\xe7l\x06\xf9\xfflp\x90\xf3\xbc\xf2\x02\x00ꢚ\xcf%\x9bKv.\xab\a_\xa1]^\x85 \xaf\xa9\xbc\xaf\xdbH_oؠ\xd37\tI\xb7l\xa6f\xb7m\xceE&%\x9cޙ\x14\xb8ɗ\x14!\xe7O\xb2ʚļk\xc1$\x95_(\x89\nxᤊ\xb6H\x92\x00\\4\x89N\x16K\xc2ꊣ\x9d\xbb\x92\xf4\xa8\x12I\x02d\xc9$\x14{w\x12\xc9\xe0=I\xb8\xe6\xbd\xda\xc0}I\xbe\xbc9)|\xe3\x81$\t̓h\xe7\xa1$L\xeb\xe1\xa4D\xacG\x92\xe0я&\x8b\xb7\xb0\xcc\xdcރ\xdc2\xb7\xf4X\x125\xccǓ\xc8H\x9f\xc8\xfb\x94'\xf8'\x93\xc0\xc3RI\x80fi\x1er\xb4Oe\xf8\xb1l\xb2`\xd7\xdc\xc1\x83r\xca\xf1c\xf9$-\xfe)=>\xad\xc7g\x92,\xd3<\x9b\x942q\x85$\xb0幤\x10\xa9\x8aI\xe5ʕ\xd8\xcb\xcaI\x89\x86\xcf\xe3o\x95$\xe2c\x92N\xf6b\x92\xb3\xbfU\x93\xe4r/%\xe1\xb5/'\x914&\xc51\xab\xa9\x94\xab\xeb\xfdj\xa0\x99\x9aIVK_M\x82\x91\xd4J\x8a\x05\xbc\x96\xcc\x03\x83\xd79\xc4\xda\xda\xcd:I\xb8q\xdd$\xea\x8e\xf5\x92\x1a\x84\xeb'\x99?4Hb\x8e\xa1!\x0f\x8d\x92b#\x8d\x93\xb0\xe6&I\x14\x17\x9b&Ŋ\x9b%Q~k\x8e\xfb\xb4H\x8a\v\xb7LҔ\xde\xc0\x88Z%\xc5[['\xe9\xeam\x92\x98\xfen\x9b$\xa8\xb6K2\xa8\xb4\xd7c\x87$\xe6\xd9;R\xbf\x9d\x92\xe2P\x9d\x93\xc0\xf1.I\xf1\xe0\xaeY\tvK\xb2r\xdb=)L\xa8G\x12\xee\xf3\xa6ޥgR\xca\xf0\xbd\x92\x1at\xdf\xd2ss\x93\xe2]\xbd\x93\x88\xf7}\x92\x04\x9a\xbeIzC\xbf$\x89R\u007f\x1aހ\xa4\xb8\xf1@~\x18\x94\x94\xfa\xc0\xe0\xa4Č!0\xfe\xa1IV{\x86%\x81\xd0Ó\xac\x95:\x92\f\x8aI\xc0\x91+\xa9\xcb\\\x93$\x11\x06[3\x93\x04l+\xc9y\xc8$\xe3\x827\x89\b\xed\x83X\xfdI@p\x006\x1dLb\xed[(\xc9L;̛D\xd44\xa2I\x84\xa4X\x12q4\x9e\x84\xc7&\x92\x82*vR\v\x95\xc9$\v(\xa9d\xf6\xa1\xb8t\x12\xcc2\x93d\xce;\"\x89\xdd\x1cG\xb2K\xa3hᣳF1&\x89\x9c|,\xfb?.\x89\a\u007f\xc7\xf3\xa4\tI\x94p'&\x11\xdf'\xb1ߓ\xd56\xa7\xf0\xe3T\xf6mZ\x92\x15\xa9\xe9IF\xaa\x19I\x99D\x9a\xa9^6\vH2;\x89zʜ$\xf70\x98\xab\x83\x9c\x97\x14\x84\x9d\x0f3\\\x00\t-L\xb2\x00\xb2(\tα8)y\xe1\x12X\xcc\xd2$֠,\x83\x9b,כ\xaeP\xfd\xaeL\xcaZ\xd1UIy\xf2su\x12av\x8d\xded-\x9bz\x1b\x8e\xf4N\x92e\xcfw\x93Xu\xff\x1elg\x1d\xfe\xaeOb\x9dk\x92\xf9\xf3\x06t\xe7\x83$\xd2\u038d\x1c馤\xce\xde\u007f\xa8\xbe\xf0\x11lgs\x12\xe9\xd0\xc7I&o\x9f$\xf37\x1a\x9e\xf3)\x8c\xf5\xb3$f\xe2\xb7$A\xbd>\xd7N\u007f\x91$\xc3\xdfJ!\u007f\x89An\xe3\xf0\xbe\xc2}\xbfN\"0\xaaD\xbfM\x92\xed}\x97\xe4D\xf9v\xda\xfa\x0e\x8es'\xb5\xb1+ɒ\xf6n\x02\xc2\xf7I\xe1\xd4{\x92`={\xd56\u007f t\uf8e9\xedO\xa2\x00\xfdcRh\xdbOj\x86?'\xb1P\xf4@R66=\x98D\"q\b\xb0{Xƒ\x17\x1bi\xb6\xbf\xd2N~\x83\x04\x8e@\x8fG\x93xN\xf5\x98\xf6\xfa8\x04\xfe;\xcf\xfbC\xf1\xe9DR\xb8˟I\x92\xa5\x93\n\xf2\u007f\x11\xd6\xfeN\x92\xf0\x9f\"6\x9cN\xb2\"\xf2\x0fP\xe8\x8cb\xe8Yu\xbf\u007f!\xa8s\x1aX\xfe# \x9fO2B\xaa\xa1^$\x80\\\xa2\x85_Nb\xe6\xe2J\x12\xa4\xff*\xbaw\r\xc1\xe6:Fq#\xc9\xfa\xfcM\b\xe4\x16\x10\xeevR2\xf0;R\xc2i\xefL\xe9|W\xbe\x14D\x9c?\xa5\x8eT \x85\xf5\x9d\x05S\xc0\xb7B)\x06\xed\xc2)i\xb4H\x8a\x13\x10ES\x90k\xb1\x14\x18D\xf1\x14R\xc7\x14\xf6\x1fHɍJ\xa6P[\xbd;%\xef*\x92\xcc\x11gܛB\xbd\xe7\xbe\x14\x88\xfc\xfd\xbc\xcf\x03)\x01\xb1\aq\xc2C)\xd8\xc0\xc3),py$\x85gP\x1eM1\xcc<\x96¸\x1fO\t\xb6=\x91\x92\nǓ)1\xcbR)x~\xe9\x94L\x1b\xe6\xa44\xbd*\x93\x02\xf9)\x9b\x12'*\x97\x1d\\y\\\xf1T\x8aR\u007f:\xc5L\xf6\x99\x14\x92\x93gS\x80\xc4\n)\xc0\xc4s)\xbaEE\n\xa2R\n\xa0U\x99?>\x9f\x02\bUI\x91\x80\xbf\x80N\xbd\x98\x02\x03\xa8\x9aBI\xe8\xa5\x14\x9d\xf9唬z|%E0\xae\x96*\x9cG\xd9\x1cC\x1c9\xd5S:]W#\x85T\xa4f\x8a&\xf1j\n\xec\xa6\x16[y-%Ŷ\xd7S\xa2\xc4\xda)\xec|N9ԅB\xeaQ\x96\xf5SZ!h\x90B\xe6\xdf0E\xbcj\x94\x92٥\xc6)\x02h\x93\x147fhʋ\x9a\xa5\x98\xf56O\xa1\x00Ղ\x87\x96)\xac\xa2z#%\x06\xd5*\xc5\xec\xadu\n\xa8\xd3&\x05:\xd7V%\xd3.\x85\xac\xab}\nx\xd2!\x85\xc8\xdb1\x05\xce\xdd)%a\xb63\xac\xa1K\niaWJ\xb9[*/\xd0wOq~\xa8G\n4\xeb\xcd\x14jZ=S\x98\x00\ue552|\xfa\xad\x94\xf8|n\n\x98՛\xf2\xee\x93b\x15\xbd/\xfb\xda/%5\xad\xfe)A\x9c\x01)\x89\xe4\x03\xd9Р\x14\xd9\xe9\xe0\x94\xa4aCR\xf4ġ)Y\xdf2,E.2<%.\xe7H\xb1\xb6\xe1\xe4 \\)8\xb8;%1\xcd\xd0q\x9a\xfc\xcdJ\x01\xf7<\xea\x11^HȗB)ҟb1*\x00\xad\x04S\xa4\n!\xdc0\x9c\xe2\xa4T\x84\x92\x8d\xaa=\xc7\xd8j\x1c\xcd$\xd0\x19;\x05\x80M\xc2%R\xfc\x90\x86\x01d\xa8\xf4\x11\x14\xe1H~\x1a\x85\x9b\x8dNI\xba2&\xa5\xa4cl\x8a\x13C\xe3\xe8l\xe3S\x02\t\x13R\xdc\rrb\xd6\x0f&\xa5\x80n\x93Sd\x1dS\xb2\xb68U\x8dpZJ\xb8\xe0\xf4\x14\x83Ό\x94$\xf93SR&\x98\x95\"2\xcfN\x81T́e\xceM1\xf1\x98G\x11\xcd\xd7V\x16\xd0\x1a\x17\xa68\u05fc(\x05\x00[\x9c\x92p\xb0\x84\xd7/\xa5[-SQ/Oa\xb5\xe0\n\x15\xe0ʔ\xf0\xd3U)\xa4\xaa\xabi\xb6kR\xc0\xfb\xb5y\xa2\x90T1\x85\xa8\xf3\x0e\x9by\x97\xa7\xbc\x97\xc2c\xa2\xebRX\"\xb6\x9e\xd2z?\xc5%\x19\x1bRL\x9e>\xa0\xf5n\x84\x99mR`\xfb0\x85\xfc\xe5#\xe8\u007fs\n\x93\x14\x1f\xab\x93\u007f\x92b\xc0\xfb4%\x85\x95\xcfRR\"ܒb$\xf8<\x85\xac\xed\v\x05\x96\xadjc_\xa2\x9dm\xb0\xe7\xaft\x88_\xc3\\\xbf\xa1A\u007fK\x91|\x97b\xa5u{\x8a\xa1d\a`jg\n\xc1iW\na`w\x8a\x11\xf9\xfb\x14ˡ{RZhۛB\x99\xef\x87\x14\xc3\xe2>\x9a\xf0~\xb8\xfe\x8f\xfa\xe5O\x00\xe7\x9f\xe1\x8e\a`\x12\aэC\xd4\xc2a \xcb/\xf8\xe1ה$\xb0\xbf\xd1X\x8f\xe8@\x8e\x02\x9f\x8f\xa5Pl>\x9eB\xe0\xfd]}\xf8\x0f*\xe4D\n\xc10\xc5\xf4\xe7\xa4\n\xf4/\x9a\xc0\xdfTө\x14R\xb6\xd3)Į\u007f\xb2#8\xa30s\x96\x9a\xfa7\x05\xf2p\x8e\xc6\xfe\x1f\xc7s\x9e\x12\xbe@\xaf\xb9\xc8//\xa1ߗ\xa9\xfc+\x04\xa9\xabp\x98kD\xd1\xebT\xe1\r\xf5\xb9\x9b\xaa\xca[)\xa4u\xb7S\xc8/\xeeH#ۺ3-`\x91/\rh\xc9\xcfC\x81\xb4(\xb0`\x9aK\\\n\xa5\xb1\xddkZdY$\x8d1\x14M\xb3hP,\xcd\a<\xd20\xb9\xbb\xd2\xe2\xd4%Ұƒiqӻ\xd3\xfa(\xf2=i}\xbe#-\xf2\xba/\xafi\xa9\\\u070fF\x1fȞ\xf4`\x1a\xe3{(\x8db\xc1\xc3i\x01\x84G\xd2܉\xf3Ѵ\xa8\xe91m\xe6q\xdcꉴ\xb0\xce'\xd3\xf4\xbbRz,\x9dF\xb0\xcaI\xabw\x97I\xd3Z˦\tz\xe5\xd2\x04\xc6\xf2i\xc8\xfd\xa94\x1e\xbcz:M\x80{&-\x10\xfel\x1aڭ\x90\x86\x1e\x9fK\x8baVL\xc30+\xa5aÕ\xf9\xe9y\f\xb3J\x9a\xc8\xfbB\xbaH\x8b\\S\x16K漘\x86)U\xe5\xe1\xa54b\xc8\xcbifW\xaf\xa4aR\xd5\u0603\xeal\xb1F\x9apR3\xcdu\xaf\xaf\xa6\xf1>\x10\xdc\xe05\xf4\xe0u6V[O\xa8\x93\xe6\x1ev8\xa3\x1e\x1b\xa9\x0fe5H\xd3\xeb\x1a\xa6\xf1Hb#ʵ1/o\x92f\xd2\xd34M+o\x06\xc96O\x13A[\xa4QEi\x99F\x11\uf374\x84\xf8V\xf8\xdb\x1aM\xb7I\xe3\x05\x17m\xf1\xa1]Z\xa0\xbe\xbd6\xd4!\xcd\xd8\xdf1\r\x93섫:\xa7\xc5㺤\xc1q\xba\xa6%\\u\xc3W\xdd\xf1\xb7\a\xday\x13\xa7\xf6\x84R{\xa5\x11\x01\xdeJ3N\xe7Bǽ\xd3(\f\xf5I#\xda\xf6M\x83\x9c\xf4S\x81\xf5\xd7\xe3\x00\x8a``\x1a\xf3\xbf\x83\xd2\x12\\\x06\xa7\xe1%C\xd2Z\x98\x1e\x9a\x06\xc9\x1c\x96&\xe4\f\x87\xec\x1c\xfcҙ\xd6z\xa6+\r:\xee\xa6،\xb4\xa0\x80\x99\x06=\xb3\xd2\xe0x\x1et՛\xc6$\x86/-\t\xb0?M\xf4\x0e\xa4\xe1\xc0\xc14\xc9H(-ip8\xcd\xc2i\x1aq3\x9af\xc9?\xc6\xfbġ\x80DZ\x18\x93\x9d\u0588\x96Ls\xfa+\x95\xce#\x0e鴤\xb9\x994\xea\xd8#T\xcc#Ө\x1e\x8e\xe2a4]wL\x9a\xf3\xb9c\xd3\x12\xa1\xc6Ѷ\xc7\xf30!\r\xa67\x11\xde=)\x8d9\xa8\xc9t\x96)\xf8nj\x9aդiiF\xc0\xe9i\xf0\x8a\x19\x1c\xd1\xcc4\xcab\xb3p\xea\xec\xb42\xce9ia#s\xd3\x12\x8e祥t9?ͪւ4H\xccB\x1e\x16\xa59\xe9\xb68\xcdգK\xd2\xc0\xa8\xa5\xb0\x88e\xec\xcc\xf24\xe2\xc2\n|\xb7\x92\xa3]\x95\x06O\\\x9dַF*\x00\xacMK z;\x9d\xbfC\xbf\x9cw\xa8\xbew\xd3\xe0`\xef\xa51\xf9\xb4.ͬb=\x9by\x9f?nHK*\xfbA\x1a\f~#Lk\x13\xdc\xecC\xdc\xf3#\xf6c3\x9b\xf88\x8dy\x94O\xd22a\xf6)\xd0\xe83\xbd\xfd\x964қ\xcfՌ\xbe\xa0\xb7lMs\xd2\xec˴\xc4\xfaml\xec+\x00\xca״\x9bo\xd2(j}\xab`\xf3\x1dNܞF)m\a>\xecT\xb4څn\xedΚ\xe4\xf7heO\x1a\x0f\x9a\xed\x85M\xfd\x00\x99\xef\xa3r\xf6\xf3\xf0\xa3\x02\xf3O\x18\xce\xcfi\xae\x1b=\x90\x96%]\aӘE:Į\x1f\x86\xd1\xfd\xa2\xe3\xf9U\\Ǒ\xf3\x9b:\xdd\x11\xdc\xfc(N9\xa6\x82<\x0eW\xf9=O\x80\xb99\u007fp4'p\u009f\xaa\uf4c0\xf6\xbf\xd2\x1a\xde\xfeN#@\x9fJ#C=\xadj\xff\x87\xc8w&\x8d4\xe8l\xba@\xa3\xdey\xa1\x8f_\x9eK\xa3d\xf3_\x1a\xc4\xf9<\xb0\xe5\x02\xac\xedb\x9a\xd5\xfcK\x1c\xc2e*\xfcJ\x9au\xf6\xabi\xd2\xd0k\xbc\xfez\x9a\xbb\x8c\xdfH\xa3\xe4\u007f3\x8d]On\x89\x1fݦ\xe2\xef\xc8\x00\x14\xee\xcc0>\xe6\xcb\x10\x95\xf3g\xc8\v\vdHy\nfD\x88\x852\xfaZ\x8f\f\x00\xa0HF\xe2eQ\xfcT,#b*\x9ea\xb2|WF\\\xaeD\x06\xe0W2\xa3\x9b\xb6f`w\xf7d`\xd9\xf7f\xa0\xe9\xfb2\xac\x92f\xf4\x99\x8d\f3\x94\a3\xec\xf8C\x19\xe8\xf2\xe1\f\n\x80\x8fd \x9cG3\xacz?\x96A\xee\xf0xFl\xf7\x89\x8c\x84\x85'3\"\xa3R\xf8[:\x83\xd9\xc3\f<\xbdL\x06v\\6C(*\x97шX>#\xa2}*#\x00\xf9t\x06U\xf6g0\x94g3\x98\xa3\xad\x90aN\xff\\\x06U\xe3\x8a\x19T\xed+e\x80v\x953\x90\xe1\xf3\xb8Q\x95\f\xe1\xe6\x05\xf6\xeaŌ\xb8J\xd5\f\xc2\xdaK\x19\xbc\x16\xe5\xe5\x8c\x18\xc9+*\x8fj\x19\x89\xf8\xd53\fA52\x84\xb2\x9a\x19\x80\u05eb\x19q\xeaZ\x19>\x86\xf8\x1a\x9by=\xa3k<jg\x10\x03\xeadP\xa1\xad\x9ba\x95\xb0^&O\xaf\xf53\x80\xfc\x06\x19A\xea\x86\x19\xdac\xa3\f\xd8~\xe3\f\x9d\xa0I\x86\x8eՔ\xcd4\xcb0=l\x9e\x01ȷ\xc8\b\xffk\x99\x91\x04\xe0\x8d\f6\xa1\xcb\bT\xb4V\x1d\xb5ɀ7\xb7\xcdH\xd0j\x97a)\xb6=dЁ\xba\xed\x98\x01\x98wR\xa3\xea\x9c\xd1\x1ag\x17*\xbbk\x86d\xb7[\x065\xda\xee\x1c\\\x0f\xd8ћ*\x9c\x9e\x19\x14\f{\xf1\xb7\xb7\xf0[n\x86\xabS{g\xc0Y\xfbО\xfaf\xe0\x01\xfd2(\xba\xf4\xcf \xac\f\xd0\x11\x0edO\x06e4\xe6\r\xce0y\x19\x92\x81\xe7\x0fͰL4,#\x99\xcdp\xdcš=p\xd2\xf4\\j1nH\xc5\xc8\xc8L\xa2\x99\x91\x18m\xf1\xc6\x1e\x1a\x8a\x17V㣡\xfa3 \x83\x01Xf0\x83\xb2x(\x83*E8\x83'\xf7\"\x19\x16\xc1\xa2\xda\xd1XF\x13\xb38\x95\x90PO\xb23\xac &a\xa7)\xd8i:#h\x97\xc1\xff#\xb4\xb7#3,\xa6\x8dʐ\xf9\x8d\u0380o\x8f\xa15\x8cջ\x8d\xd3\xe3x\xa8u\x02\xfcw\"\x871\x89\xb6<9\x83\xc86\x05\x96:\x15n<-\x03\xc26]E7\x03?̈́ fe0w1\x1b\xf61\aR\x99K\xb1\xcd\xcbH\b\x9f\x9faip\x01\xaeY\x98Ax^\xa4C^\x9ca\xfa\xb0\x04\xa6\xb34\xc3\xecfY\xde@\x1d9\xcb3@\xc3\x15\x19`\xe3J\xcadUF\xabI\xab\x89?k2(}\xad\xfd\x1fS\xd7\x1d\xafc\xfd\xfe\xed\x95(J\xa48D\x11RDV\"#{\xef\n\a'\x0eq\x0eα\x9a\xa4γ\xf7\x9e${\xef=B$+ٻ쭲\t\xbf\xe7z\xbf\xaf\xe7\xfb\xfa\xfdq>\xf7y\x9e\xe7\xbe?\xe3\x9a\xef\xeb\xfa\x8c;\anm\x01$~a\x8e\xe4\x85\x16\xe5\b\x94ZL\xe1YB\xab\xb1T\xfb\xbf,\x87!\xc0\xf2\x1c\xba\xd1\x159\xe2NVB]W\xa1+\xabs4\x1f\x9a\x03P\xb9\x96\x8c[Gʬ\xcfQo\xbf!\apac\x92q\x9brtG\xf5\xcf\x1c\xe6\xe6\x1c:\x90-Tҭ\xec\xc5/\xec\xfa6\x90g;\xca_\xa9\x85;r\x10\xf4\xfcF9\xde\t\xee\xee\xcaa8\xb9\x1bµ\x87\xd4؛C\x8c\xf9{Nᶩ\xc3S\x87\xa5\x8fJOٗ\xa3ɼ?r\xe8\xf5\xf6\xe7(x:\x90#\xae\xe8`\x0e\x12+\x87 E\x87\xc9\xf1#9\x82\x18\x8e\xb2_\xc7r\x98\x9d<\xae\xd7\x13\xda\xfb\x93\xa0Ω\x1c8\xf5\xd39L)\xfe\x99\x83t\xf3_9\xf0gg\xd0ճ\x10\xa9s9\x9a\xcc?\x9f\xd4\xf9\v4\x87\x17s\xb0|\xe0R\x0e`\xd4e^\xaePV\xae\x92\x92\xd7\xd4\f]צo\xe4p\xbd\xcd\xcd\x1c8\xc1\xbfu\xd8\xff\xe4\xc0\xf1\xff\x9bT\xe9[9\b\xb2nchw()ws\x14+\xdc\xcba4r\x1f\x04|@\xc3\xf1P+~\x04\xa9\xfc/\x87\xf31\x8fs$\xc7\xf1D;\xf1\x14.$\x97A4-\xb7Ai\x99\xc7\x00_\x9f\xd7\x00\xb9\xc8g\x80@\xe47P\x9c\v\x18\x88d\v\x1a\xa4\xa9B\x06\x99\x04+l\xa0\x05,b\xa0V>c\x80\xd9)\x8a\x1f\x9f5\xa07\xc5\f\xe4Xq~|\u0380\xad\x1a\x06*j\t\x03E\xb1\xa4\x81V\xe8\x05\x03\"\x82\x17\r\xb4\x84\xa5\f\x88__2p\xf5Oi\x03\xcco\x19\x03\x16%\xbfl\x10\xad,k@\x1a\xe8\x15\x03·W\r\x88{\xca\xf1\xc6\xf2\x06\xb1i)\x06\xf1\x9c\x15\xd0\xed\x8a\x06\xa6\x9a_çJ\x06\bJe\x03\x82\xd0\xd7\r\xa2To\x18D\xf1\xab\x18Ȍ\xaa\x1cЛ\x06Ɠ\xd5\xf0Xu\xfdT\xc3@0\xf1\x96A6(\xd64pf\xf7m\x83j\xf1;\x06\x01y\xb5\f\x9co\xae\xadd|\xd7\x00\x0e\xd61\x88P\xd55\xc0o\xbdg\x10!\xacg\xa0\xa7\xac\x8f\x1e4\xe0O\r\rЉF\x06\b\xd4\xfb\x1cWc\xf6\xea\x03\x03|~\x13\x12\xb6\xa9A%\xf2C\x03\x96&43`\xa9Xs\x83\xcc\xef\xb40 \xc3\xd4Ҡ\xca\xfd\x91A\xb4\xa6\x95A\x12=\xad\r\xe2\tې\x8emѯv\x06\x82\xb0\xf6\x068\xb4\x0e\x06\xacP\xe8h\xa0-\xee\xc4!t6\x10\xd9vQ!\xe8j\x00\xd4\xeaf \x88\xean`\xec\xddC\xa9Փ}\xef\xa5?\xf76H0\xd1\xc7 6\xf5c\x03=\xa4\x013۟\x1aT\xf2\xfb\xf2\xeb~\xfc\xba\xbf\x81\xdb\xd6R\r\xccU\f\x00\xd1\x06\x1aD\xc6\a\xa1L3H\xde\xff3\x03\xb0\xcb`\x03\xf6h\x18\xb8(=݀\x85LCq\xdf0\x03\xf5\xe3s\x03-\xe5p\x83\xf8\xc5\x11\x06\xa4\xfc3\f\x88a2\rj\xedF\xb2ۣ\f2\xdd4:I\xbf,\x03\xd0]\xb6!o\x97\xf4\x941\xc9o\xc7&\xff\x19G\x96\x8c\x87\xacO\xe0\x87/\f\x88\x11\xbe4\xc0\x1e}e\xc0\x8a\x9c\xaf\xa9c\xdf\x18\x90\x01\xfb\xd6\x00,7Q\xe9<\xc9\x00\x8c\xf0\x9d*\xded\x83\x98\xfe\xef\rL\xe9\xff`\x80m\xc9a\xad\x06\x03\xf0\xb0рD\x8fI9c6`\xfd\xaeŀP\xdaj\xc0\xde\"\x9b\x01\xf9\x0e\xbb\x01\x93\xca\x0e\x83\xb8@\xa7\x81\xf0\xdae@\xfa\xcam\x10\xbf\xee\x81~y\xc9U\x9f\x01sK~\x03\xf1r\x00\x84\f\x1a$V\r\x19$\\\n\x1b\xc4=E\f\x12~DA\xd0\x18\t\x1a瀧\xf02\x95\xfd\xfd\xd1\x00\v;\r\xd5\xfcd\x80K\x98\xce\xce\xcf\x00\xa5g\x1a0;0K\xa5e\xb6\x81fk\x0e\x98>׀\xfc\xdc<60\x1f\"\xbb \xf1X\">D_\x16\x19x\xd8\xd5b\xf4c\t\x1aYj`ph\x90U\x90\xcbI\xfd\x15\x06\xf5m+I\xbeU\x06\x1c\x92\xbb\x1aʱ\x86\x8c_\v\x1dYG\x93\xb8\xde \xb9\xd4\rT\xbf\x8d\x06\xb8\x87M\x06X\xf7\x9f\r\x98\x8e\xd9l@ز\xc5P\xa4\xad\x9c~;$}xF\xcaV\xe1簄o4$W>m3\xd0lo\xa7&\xfdj\x00\xea\xdea\xc0N\xc9ߔ\xc3;I\xf9]\xec\xdbn\u07b3Ǡ\x96\u007f/L\xd1\xefj]\xf6\x19\x18\xcf\xfc\x91\xa0k\x82l\xfb\r\x125\x1e\xc0\xc0\x0fB\x11\x0e)\xe3\x0e\x1b\xe0\x85\x8f\xd0\xf2\x1d5\x00\xac\x1d3\x88o;\x8e\xdbO@\x89N\xfe\xaf\xab\xa7\f\x8cTN\x1b0\xf7\xf3'\x9f\xf8\v\xad\x9fQ\xb3\u007fV\xaf\xe7@\xdc\xf3j\xd3/\x18\xb0\x80\xf8\xa2\xb2\xee\x12$\xed2yvŀp\xe3\xaaJ\xfa5\x15\xd8\xebd\xd2\r\x83.V\xb9i`*\xfbo\x03\u0588\xfd\xa3\xda\xfc\xafA\xe3\x84[\xc9\x1bo\xd3\xd8\xdd\xe1\xe5\xae\x01>\xf9\x9e\xd6~\x9f\xcc{`\x00\x0eyH\x9b\xf6\bV\xf6?\xc8\xcec\xca\xe6\x13\x88\xfdS(m.#Nd5\xe2\x87<F\xa0\u07bcF\xf0'\x9f\x11\xc1f~\xa3`\xea\x02(\v\x1aE\xd0\n\x19\xd5p\x156B\xe3\x8b\x18\x19\a<c\xe4V\u007f#8\xf8\xac\x91\xcb\x14\x8a\x19\xa1Q\xc5yy\xce(\xca\xf6\xbc\x91=.a\x84Ɩ\xe4\xe5\x05\xd4\xfe\xa2Q\xf8X\xcaȳi_2b\x14\xa5\x8d\xb0\x02e\x8cP\x88\x97\x8d\bH\xcb\x1aő\xbdb\xcc\xd7bDjʫ\xc6\x02\xadҳ2\xd2R\xca\x19\x81\xd9\xcb\x1b\x05\x06\xa4\x18\x91切\x0f\x15\x8dL2\xbef\xa4S\xae\xa4\xbd\xa8l\x14i\u007f\xdd\b\f\xfc\x86Q3\xb7U\x8c\x98\xa4\xaej\x04\xf2~ӈE\xe6Ռ`\\u#\xdfgZ\xc3H\x11~\xcbH\xa7W\xd3\b]z\xdb\xc8\x18\xf0\x1dm\xb0\x96Q䥶\x91\xd2\xf3.G[\xc7(\xa2U\xd7\b\x1c\xf9\x9e\x11\xf1M=\x8c\xa8\xbeQ\x04\xb4\x01\xa9ِ4nd\xa4\x81x\xdf\b_\xd1\xd8H\t\xf9\xc0\b\xe8\xdc\x04\\ljL\xae\xab1bµ\x19\x1bjnT\xd8\xd3\xc2X(\xd1\xf9!\xa9\xe3SSZ\x1aem\xc1GFJp+\xa3\xa2\xbd\xd6\xfaE\x1b#\x0fhE\xb5\xed\x8c\xf0\x01\xed\x8d2\xf7\xde\xc1\b\xfc\xd1\xd1(\xf6\xa7S\xb2\xe6\xceF\xb8\xdd.F\xc0ˮF\x00\xbdnF\xb8\xf4\xeeFd\x95{\x18Ū\xf74B\xc0{\x19aRz\xb3\xf7}\x8c\xc8$~l\xe4\xf4\xda'F*ҧJ\xaf\xbeFQ\xa8~F\xb8\x8e\xfeFZ\x94T#\x8c\xc6\x00#wb\xe0\x96Al)\rc\xfb\fL\x1dL\xc1\x1eb\x84\xfdI\xe7CC\x8db\xbc\x87\x91\xe4\x9f\x1b\x91K\x19N2\x8f\xc0\xb82\x8ct\x98\x99F\xcc.\x8c4ҳ\x8f2\x8a\x12\x8dVNd\xb1\xb5l2p\x8c\x11.h\xac\xb1`\xb7\xd4\xd1b\x04\xc7\x19q\xc4\xf4x\xb62A\t\xfb\x85\x11\xfe\xe0Kp\xf8+#|\xc4\xd7FA\bߠ\xf2oQN4\xc2uM2\x12w}\xc7AN\xe6 \xbeW\xd6\xff\x00m\xc91ʚ@\x03\xb4\xca\bv\x99P\x9a\xb5A\x8b\x91\x8bq\xac\xaa\xa36ꓝ\fp\x18\x01\xb7\x9cF\xae\xe3r\x19\xe1\xa0\xdcF\x01\x92\x1e\x94^#\xe0\x92\x8f\xc3\xf0\x1b\xf1rH#\x93\xd3A#\x8f\x8ec%a\xdc\x1f1\xea\xb9\xe5ʼ\x18\x87\x12'\x1f\xa6\x18\xe1\xf8\xa7b\x94?\x1a\tO\xa6Q\xa4\u007f\u0097Ӎ\xcc\xd7\u0380\x15\x98I\x1a\xcf2\xe6i\x912\xdb(\x86l\x8e\x11@b\xae\x91\xe1\xf4<\fv\xbe\x91\xe1\xe9\x02UÅ\xd4\xfaEFq\xa2\x8b\xb5\xb7K(@K\x95 ˌ|S\xc1r%\xd4\n\x0ef%\x9eY\xa5_\xaef\xd7\xd6p\x84k\xf1\xdb:\u07b8\x9e]\xdb`\xd4\xfd\xfdF\x81\x05\x9b\xb4\xf2\x9f\xf5\xf9\xcd\xfay\v\xa9\xbe\x95T\xff\x05\x94\xdaF\x92n\xd7\xee\xfd\xca\xfav\xb0\xa9\xdf0\xae\x9d \xc9.T\xbd[\t\xb3\a\x84\xd9\xcb\x11\xfe\xce1\xedC\xc7\xfe02\xde\xdao\xc4b\xc3\x03\xfc\xed\xa0QVS\x1cb\xb5\x87Ɇ#F\x9e\xa1r\x14\xad\x1c3\n~?N-?A\xcd?\x896O\x19\x15\xe2\x9f6\"u\xf0\xa7\x91\xc8\xfd/\xa3\xb8\xdd3\xb4\x85gi\xf3\xceql\xe7\x8dL\x8a^0r\xea\xe0\"\u007f\xbdd\xc4z\xb3\xcbF\xb8\xe3+F\xc2\xee\xabFɜ]3J\x8a\xec:\xfar\x03\x06\xf0&\xbb\xf9\xb7\x11\xb8\xff\x1f(\xf7\xbf\xfa\xcc-\xa3 \xe9\xdbɞ\xdd\xd1\xf6\xee\xf2\x91{F\xac4\xbbO\a\xf1\x00\xf4{\be{\x84\x9a\xff#\x1d\x1e\xe3\x87'\xe4\xcaS|\xc8e\u0087ܼ\xe41q\xa6;\xaf\t\xef\x8a4\xa1\xdb\xf9y)`\"\x9d\v\x9a8\xc4B&\xbc\xf7\xca\x04\xc3XĄ(\xf6\x19\x13\xb3\xe8E\xf5\x9egM\xc0\xe5\xc5L\x80\x03\xc5M\x92r{\xce\xc4\x04\xaaI\xbaW\xc2\x04\xa4V\x92\x8f\xbf`\x02\xd6z\xd1D\r)e\x12W\xfd\x92\t\xb8\xb14\x9a+\xc3\x1b_\xe6\x8deM\t\x05y\xc5\x04D\xff\xaaI\xccI9\x13\xf4\xae\xbc\x89)\xd6\x14\x13Ŵ\x02\xef\xafh\x82\xbd~\xcd\x04jT21\b\xacl\x12h\xf9\xba\x89\xc6\xef\r\x13\xd2rUL lU\x93\x9e\x95𦉓8\xd5XEu\x13E\xa9\x86\t!\xf5[&\x1aǚ&\xa0\xa8\xb7M\xf0\x9a\xef`\xbc\xb50\xd0\xda(\xdf5\t\xe7\xeb\x98 AuMb\xbd\xde\xd3.\xd6ç\xfax\xa4\x81\x89h\xae\xa1\tH\xb4\x91IW\xba\xbdo\x82\xf876\xc9,\xd5\a(\x9b\x98\xa8GMM\"\xcd\x1f\x82o\xcdL\xba\xeb\xc2\x04W\xda\xc2D\xf4\xd5\xd2$\xc2\xfd\x91\x89I\xd4V&\xf1íM\xd8\xf1\xde\xc6\x04\xfb\xdc\xd6\xc4u\x9a\xedL\x88\xb1ڣ\xcf\x1dL\x02\x9b:\x9aďu2A4;\x93%]\xf0{W\x93ha7\x13\x17Pw7q\x8e\xa1\x87I\xa4\xb7g\x92|\xbdpSo\x93X\xed>&A%\x1f\x9bd\x8d\xe0'\x94\x8cO9о&\xc9W\xf43\xc1\xb5\xf47q. \x15$\x19@\xc6\x0fD\x93\x83L\x1a\v\xa7\x81h\x9f\x99`R\x06S؆\xa8\x9c\xa6\xf3ۡ\xa6|\x89x2e\x18\u007f\xfc\x9c\x14\x1cn\x82\u058ePBe\x98\x00\xb32)\x99#M\xd0\xfaQ&\xac\xeb\x1bmRg\x9fe\x82Q\xccV~\x8d1\x11\xbb\x8e51\x0e\x1eg\x12\xeb6^\xd91\xc1D\xd3\xfc\x85H藬\xfe+\xea\xd8\xd7I\x9a|c\x02\xec\xfc\xd6$\x11\xc8D\x13\xd3\v\x93Lt$\xdfQF&\x9b\x90\xf0\xf8\x9e\xf4\xf9\xc1\xa4\xa7\x88昰\xbd\xc6`\x92\f\xa8\xd1$\xa6\xd1db:\xd2\f=\xb1P|\xadT/\x1b\xc4\xcenbN\xd6!}r&\xabr\xc9'7i\xe511E\xee5\xc1(\xfaL\x82\n\xfc&\xe2\x92\x00\x15#hb|\x1e2q\xcdC\xd8\x04\xcf\x141\U00048ae8I\x96\a\xc6Х\xb8*\xd8\x14\x93\x065SI\xe0\x1fU[\xa6\xa1\xfb?\xa1\x9cn\xc2\xf2\x88\x19\xaa\xb83M\x02ff\x91p\xb3MLq\xcd1q5\xe8\\U\x8fy\xfay\xbeI\\\xe4\x02S\xa1ީ\xa3夸\x94\x85&\x8d\x1b\x16\x99\x18\xdd,f\xc3KL\x92\nY\nY\\fbnr\xb9vr\x85\thl\xa5\x89S\x0e\xabL\xccz\xac6!\xd6XCv\xac5\xc9\xd9z\xeb \x84\xebM\x12\xc8n\xa0e٨\x86o\x93I\xf2\xb0?\x9bx\xd4\xc5f%\xdd\x16\xb5-[M\xccq\xfc\x02\x1em\x83y\xdbn\x02\xca\xf9\xd5\xc4\x03\x19vP\xca~\x83\xd2\xed4q\xfed\x97\x89~uw\xd2\x10\xec1I\x06n\xaf\t\xfb6~7\x11v\xef31\x8d\xf6\x87Iç\xfd\xfa\xd8\x01J\xcfA\x13\x92o\x87L\x98&:\xacr|\xc4D\\u\xd4D\xd0~\xccDPt\x1c,<A\x13r\x12:xJ\u007f:Mi\xf9SI\xf4\x17?\x9e1\xc1ם\xa5\xf6\x9c\x13\xb1:o҄\xc9\x05\x98\x9e\x8b&\x80\xcdK0R\x97\xc1\xe1+*qW\xb5\xab\xd7@\x93\xebh\xfb\x06\f\xdcM\x93n\xd1\xfeۄ%\xa6\x14\x89\u007fI\xf6[\x90\xb6\xdb*OwL\x98\xa9\xb8\xabԾg\"\x8e\xbc\xcf\xe1?P\xc3\xf7\x90j\xf8H\xe5\xf8?\x1d\xc5c\x938\xf7'&\xbc\"\xe4)\xba\x91ˌTmn\xb3\xe4\xff\xf2\x98\xc1\x98\xbcf\xa0\xd1|fj[~3XP\xc0L\x8fU\xd0\xcca\x142\x8b\xe6\x146K\xfcSĬ\xc6\xea\x193\xb2\x9dE\xcd\xd2гfb\xb6bf1\x1b\xc5\xcd\x14\xc2\xe7\xf0\xe9y\xb3\x8c\xb4\x84Y\xe7\xf8J\x9a9\x9e\x17\xccX\xaf\xf1\xa2YB\xd2RfQ\xe9\x97̜\xb4+m\x86x\x961S\x12^6\x83#e\xcd\x1a\x18\xbdbf\xc4\xf7\xaa\x19\f(g\x06Z(o\x86\xedM1\xc3eV\xe0\xa5\"\xc7\xf7\x9aY8P\xc9L٨l\xd6\xf5\xa6f\xca\xe3\x1bfL1\x9a%\x8fR\x15\xe5\x9bf\x05&\xd5\xcc0\xde\xd5\x13\xa4K`\x86\x1aJ\x8f\xb7\xccx9\xa4\x99a\xa2Y\xf7_\x9811QˌLhm\xb3\xac\xf7z\xd7L\xe4X\a$\xa8k\xa6D\xbfg\x16\xe7S\x0fe}3\xf0]\x03\xb6\xd3\xd0,\xaa\xd8\xc8,\xe0\xe8\xfd\xe4p\x1b\x9b\x11\x81}`\xa6\x8fnb\xc6\xd4PS3\x04\xf3C3u\xb2\x99YD\xba\xb9\x99\as\xb60\xcb.\xf3\x96h\xf5#3|z+3\x16\xe1\xb56\xabε1\xc3U\xb65\x03\xb0\xb63'份2\xb1\x83\x19\x80\xa2\xa3YԺ\x93\x19\x87\xacv6\xd3\ru\x81(t5Cl\xbb\x995\xe2\xecn\x96\xf5\x15=\x12\xb7&\x18\xdb\xd3\f\xafڋ\\\xebm\xa6a\xedc\x86a\xf8\x98\xf7|b\x16u\xf9\u052c\xebd\xfb\x9a)\xb5\xfd\xccX{џ\xf7\xa6\x9au_\xa2\x19\xb6l\xa0\x8a\xc3 \xf4+M;\xf4\x99\x99\xd6t\xb0\xb2a\x88\x19\a\xfc\xa5\x83\x92CͲ\xf8l\x98\x99^\xecs\xb3X\xb3\xe1\xec\xfb\b\xd2/\x03\xf7e\xa2\x1c\xa9b?\xca̕]\xa3YU\x96\xb6\x9bm\xa6M\x1bc\x16\xab9\x16L\x1ag&\xc4\x18o\x861\x9a\x00\xdd\xfaB\xe9\xf8\xa5\x8a\xcbW\x90\xbe\xaf\xf5\xd37l\xff[\xb3X\xf9\x89\xe4\xfb$\x1d\xffwf\x84\x9b\x93\xcdt\x93fڴ\x1f\xa8\xab9\xcaj\x03\xc4Ո.\x9b\xcc\f\bͬ\xc7b\x861\xb0\n7mfzt;\x9fv\xe8G'\x15å\x95\xb9u\xac\x1e3,\x90\x97\xe2\xe0S\x1d\xf5S\xc7\x03\xac=h\xe6b\xc2\x10{\x19F\x0f\"ʤ\xa8\x129\xc6.\xc41\xbc)\xfc0\x15\x1c\xfb\xd1L4>\xcd,\x06\xf3'3|\xf9t\xfc4\x83\xaa4\xd3L\x9c=\x8b\xaa<[\xfb6G\xf92\xd7,fl\x9e\x19hm\xbe\x19\bj\x01:\xb1\x90\x1f\x16\xa1\xb2ŬyIR\u007f\x96\x92\xe0ˠ\x91\xcb\xcd\xe2\x89V\x98\x05]\xaf4\vR^\x05\xcdY-$[c\x86/YkVH\xb3\xceL\xf7\xbd\xdeLӻ\x81\xaa\xb4\xd1L\xf0\xbc\x89z\xf2sR\xa56\x9b\x05\xb4n1\v\x88\xdbj&p\xfc\xc5,\xb8p\x1bua{\xb2\xe2_\xa9\";`\xf5~3\xd3\xff\xef4\x8bW\xd9E\x13\xbcی\x97Z\x99ŷ\xef5\x13\x8c\xfen\x16\x10\xba\x0f#\xfe\x03\xe5~\xb3\u009e\x03\x94\x98\x83l\xe7\x90\x19P\xec0?\x1d!q\x8f\x92\f\xc7̊^\x8e\x9b\xb9\xdcF\x85\xec$\xf5\xe1\x94\x19X鴙{\xf5\xcd\x1a*\x9a9\xb7H2\x9fE\xdb\xe7\x92\xc3>o\x06\xb2\xbc`Vdy\xd1\flz\xc9\xcc`\x11佢zr\x95}\xb9f\x16\x90t\x1dzqC\r\xc4M|\xf7\xb7\x19\xc0\xe9\x1f3\xd0ٿ\xec\xf3\xad\xe40o\x9b\t\x91\xee(c\xeeB\xbf\xef\xa9\x1d\xbf\xcf\x11= \x05\x1f\x9a\xe1\xfb\x1eA\x10\xffS\xd3\xfb\xd8\f\xfc\xf3\xc4,\xc8\xe9)5#\x97E\xba\x91\xdbBl\x95\xc7Bz\xe4\xb5\x10\x02\xe5\xb3PQ\xf2[\x14\x86\x14\xb0\x10\xf5\x14\xb4\xc0*\x15\xb2\xc0V\x15\xd6NJX\xf0N\x0e\v\\mQ\v\xd5\xe8Y\v`G1\x8b\xba\xce\xe2\x16\x9a\x82\xe7,p`\xcf[\xe0\tKX\xc4x\x94\xb4\xa0S/X\x12\xf2\xf8\"zV\xcaB\xe3\xf0\x92\xf6\xa4\xb4E\x80D\x19\x8b`\x85\x97-P\xb0\xb2\x16\xbc*قE7\x16\u009ar\x16!|y\x8b\xf8\xb3\x14\v\x95\xb4\x82E\x04\xae\"\x9b}\xcd\x02KP\xc9B\xa7[\xd9\x02iy\xddBk\xf7\x06*\xabb\x81{\xaaj\x81\vz\xd3\x02;PM\xbb_\xddB\xafH\n\xbce\x81e\xafi!;߶\xc0\x92\xbcc\x11C_\xcb\x02M\xa9\xcd\u07be\xabMԱ\xd0d\xd4U2\xbdg\x11\xfd\xa9\xa7\xbfַ\xd0\x184\xb0`\rICV\xd1H\xbf}\xdf\x02/\xd8X?~`\x11W\xd7\x04eS\v\x8cև\x16N\x8f7\xe3\x9d\xcd-\"\a-,L\x02\xb6\xb4`\xf1\xdeG\x16\xb5\x11\xad,bZZ\x93\x04m,b`\xdbZ\x98Zjg\xc1\x8a\x81\xf6\x16Q\xbe\x0e\x16\xe4\x1e;Z\b\xd1:Yh\x18:[\x10\x9ft\xe1\xa5+\x87ٍ\x97\ueb34\x87\x05Ɍ\x9e\x16Ht/\vB\xeaސ\x96>\xfc\xf01>|\xa2\xc4\xfd\xd4\"\xc1e_\vv7\xf6\x13i\xe8o\x91\x1cP\xaaE\xd5l\x80\x85\xd6x\xa0>0Ȃ|\u007f\x9a\x05\xda\xf8\x99E,\xc7`\vva\x80,\xe9\x16\xccC\x0f\xb5\xc0S\r\x83h}n\x81\xc6\f\xb7pK\xa2\x05`)\x03\xb7gZ\xc4я\xb4`\xf5\xc4(mk4\xebȂ\xb8e[\xb8\\g\x8c\x05\x19\x8b\xb1\xe8\xfe8\x92`\xbc\x05I\xeb\t\x16N\x06~A\x1e|i\x11\a\xfc\x95E\"\x8d\xaf\xf1\xff7\x16ؙo\xf1\xd5D\v\x94~\x92j\xdew\x10\xdd\xc9\x16,\xb5\xb1`\xde\xe1\a\xedG\x8e\x05\x93\x13\x06\v\x12\xa6(M\xb8\xdb̆,\x16\xa4@\xad`\xa4\xcd\"\x99);\xf8\xe7\xc0\xb0\x9d\x1c\xaf\xcb\xc2\xd9\t7\xef\xf6\xa0G^\x8c\xde'\x04\xf7[\xc4W\x04Pq\x90\xec\vQ\xd6\xc3ڏ\b\x852j\xc1\x84F\xccBC\x1e\xb7\x10\x9fN\x01\xf5\xa7Z0\xd5\xf6\xa3\x85)\xaei\x16Y\xe7\xf1\x13\x885\xdd¥\xa73(b3-X\xad>\x8b\xf2;ۂT\xd4\x1c\xb68\xd7B$9\xcf\"\xd0s>\xa9\xbc\xc0\"\xb1\xf6B2q\x11\xe5l1ƹ\x046b)~_f\x81\xf1^\xaeva\x85\x85\x90a\xa5\x05\v\xc7VY\x90\xf2^mQ(\xb6Ƣ\xb6v\xad\x05\xa6r\x9d\x05\vCף\xc3\x1b,\x00\xe6\x1bI\xb0M \xfc\xcfhp\xb3E\x12s[,p\xbd[)\xe4\xbfP\x14\xb7i\xc3\xdbѧ_I\xfb\x1d\xb0N\xbf\x89\xcdHO\xd9i!\x96\xdb\xc5\av[\xb89k\x8fJ\xf6^\v\xf1\xd4\xef\x16\x9e\xeb\xa6d\xfe\xc3\x02o\xbc\x9f2y\x80\x97\x83\x16d\xf7\x0e\xf1\xb7\xc3\x16\x8d\xb6\x8eh\x95G-\xf4C\xc7,\x98\x138n\x01\x929\x01\x19;\xa9f\xe8\x94%\x99/\xb50Y\xfb\xa7\x05\xf3t\u007fY\xb8\x8b\xfe\x8c*\xffY\x12\xf0\x9c\xf6\xf2<\xfd\xc1\x050\xfd\"\xb9v\xc9\xc2H\xe3\xb2^\xaf\x90oW-\x82S\xaeYt\x95\xd0u\x98\xa6\x1b4\xb57-\x8a\x11\xfe\xb6ps\xd5?\x16̄\xfdK\x8d\xbae\xc1۔n\xb3\xffw\xd4\xfeܵp\xb9\xd6=T|?\xc9\xcb\a\x16콰(J\u007f\x84\xae\xfdG\x95{l\xc1\x19\x8fO OO\xd5V\xe6\xb2\xc2\xf9\xe4\xb6b6%\x8f\x95\x04\xc9k\xd5\n\xf2Y\xd1\xfd\xfcV\x02\xe1\x02V\xc6S\x05\xad\xe8a!+\x83\x8f\xc2V\x8c\xbd\x88\x15\xb4}\xc6\n+X\xd4\xca\x03Q\xad\x84rŬ\x90\xf8\xe2Vr\xf69+\xc6\xfe\xbc\x15\x89\xba\x12V\x12\xb8\xa4\x95L{\xc1*\x12\xf6\xa2U\xa8T\xca\n\x03\xfc\x12k-\xcdZ\xcbXuO\xa2\x95ֽ,\xebyE\x9f\u007f\xd5\n\xf5,g\xa5ܔ\xb7\n\x19R\xacT\xd2\nV\xeaeE+\xd4\xf45\xabУ\x92\xf6\xa02\t\xf1\xbaU9\xf5\x86\x15\xaaY\x85t\xa8j\xe5&\f\x8e\xb7\x9a\x15\xda[\xddJ\xf5\xaaa\x05\x99߲B9kZ\xa9\xbeo[E#߱Rdja`\xb5\xadP\xdcw\xadP\xb4:Vhk]\xab\xaa\xe1{V\xe8g=+T\xae\xbe\x15J\xd9\xc0*\x9a\xd7Њh\xd1\n\x1dz\x9f}jl\x85z}`\x85\x066\xb1\x8a\xca5\xb5B+?\xb4b\a\x86\x12\xa59~ja\x85Ƶ$\xfd?\xb2ByZ)\xa1Z[!dm\xacХ\xb6 [;p\xa1\xbd\x15\vQɋ\x8eV\u0557NVQ\xa3\xce\x18T\x17\xab\xbe\t\xd9J\xa5\xe9f\x85\x0eu'\xadz\xb0\xe6\x9eV\x8ao/\x15\xa8\xdeh\xa2OR\xdc>\xb6BD?\x01K>%\xc7\xfbR\xaa\xfaQ\xe4\xfa\xabȥ\xaaX\rPy\x1aH\x01\x18d\x85\xb9J\xb3\xe2\x95T\x1c\xc6`+\xb2*C\xac\xaaf\xe9\xf8q\xa8UQ\xf10P\xf6\xf3\xe4\xc7\xe1V \x9e\x11V`\x90\f+\x17-fZ\x810G\xf22\xca*^f\xb4\x15\xf35Y\x18B\xb6\x95\x88}\f\xfb1\xd6*\xe8b\x9cvr\xbcU\x17\xa2O\xb0\"\xd7\xf8\x85\nۗV\x81\xfc_Y\xe1R\xbe\xe6o\xdfp\x04\xdf⧉\xaa\x8f\x93\xf4\xfa\x9d\x15\xb0r\xb2U\xdc\xd4\xf7V\xa6\a~\xb0\x8aoαJ\x02\xc0`%\xc02R\bMV\xec\xb60[\x05\x1aX\xac@\xe2V6`\xb3½٭\b\x1c\x1cVdT\x9ch\xd5ee\n\xd7mŤ\xafNJ%#^\x8e\xccg\xc5\xf4\xbaߊ7!\x83\x94A\x1d{\xc8*X3lE\\\x19A\x1f\xa3*\xf71+v\xecǕ\x9cS\xac\xcc/N\xb5\xe2H\x90\x1f!\xa7\xd3\xd0˟\xac\x04\xae\xd3)\x993 \xb43\xad\x922\x9a\x85\x1bf\xb3\xffs\xac\n\xad\xe7Z\t?\xe7\xe9u\xbe\x15 w\x81\x15\x89\x85\x85xr\x11\xad\xc6b\x8a\xd2\x12^\x96Z%P[f\x955B˭\xb0\xb5+\xac\x92\xf0Zi\x95Xa\x95\x15k\xc6W\x93;k\xc0\xe5\xb5ʇu:\xac\xf5Vƅ\x1b\xa8\x8a\x1b\xad\xb2[r\x13\x89\xfe3*\xde\fA\xd8¯\xb6Z5#\xf6\x8b\x15\x11\xed6+6;n\x87V\xffj\xe5\x11\x8a;\xac\xba!Ê\xd5U;\xad\x82\nw\x91\xf1\xbbѿ=|z/\x15\xffw\xf0l\x9f\x15\x8b\xa7\xfe\x10\xaa\xa5\xa6\xec'\xfb\x0f\x80\a\a\xf9\xec!\xf6\xf10\x06rĊ\xf9\x92\xa3\xb8ᘊ\xe9q\xab\x00\xc0\x13V\x01O'\xf1\xcb)\b\xfai+N\t\xfb\x13\xdd\xfc\v\x86\xe0\fm\xd4Y\x15\xe4sV\xba\xf3\xf3\x94\x98\vl\xfebR\xad/Y\x91\xed\xbf\xcc\xcf\xe9)Wh\xf1\xae&\xd5\xe2\x9a\x15\xbb\xa5\xae[\x15\xe8\xde \x8boB,\xfe\xb6rb\xe1\x1f\xf6\xff_\x8e\xfa\x96\xca\xe8m\x1a\xf1;ʐ\xbbV\xc9\xd4\xdcSQ\xb8\x0f\xc3\xf4@;\xf9\x90\x9d{\x84\x01\xfc\x87\xf1=\xc6\xffOh՞Z\xe5\\\x88\\6\xe8En\x1b\x93LylX{\x99\xd7\xc6\xfcf>\x9b\x90(\xbf\r\xfd+`\xc3Z\xa3\x826\x84~\x85l\xa8\xa5\xb0\x8d\x93\x14El\x9c\xfdy\xc6F\xd2\x14\xb51\x1b\xf3\xac\x8d}+f\x83H\x16\xb7I\x87\x9f\xb3\xb1\xfb\xcf\xdbDZJ\xd8\xe4L\x8a\x926\x86\x856Ʊ/ڠ\xbd\xa5l\xd2\xe3\x97ث\xd26\x19D\x19\x94/ې\xc9(k\xc3\xda\x1a\x1b\xb7\x1b\xbfjcN\xbc\x1cn)\xcfn\xa7\xd8\xe0\x89+\xd8\x18\xe9W\xb4\x89\x86\xbc\x86\x81U\xb2\x89JT\xb6a\xbb\xcc\xebh\xea\r\x9b(z\x15\x1b\x91\u007fU\x1b_Ϩ\x1f\xabٸZ\xb9\xba\r\xbc\xa9a\xd3\x04\xc1[6n#\xa9\xc9\xef߶\xe1@7\x1b\xe8_\xcb\x06\xbd\xaam\xe3J\xd7w\x95Nul\x9aj\xafk\x13s\xf6\x9e\rf\xb8\x9e\x8d\nWߦ'07PJ5\xb4\xc1n5\xb2Ѡ\xbc\x8f\x016\xb6\x89l\u007f\x80A4\xb1A\xea\x9b\xda\xf4`p\x1b\xf6:4\xb3!E\xd0\x1ccnaCڢ\xa5\r\x1bI?Қ[ٰ\x9c\xb3\xb5\r\xdb\x04\xdb\xd8\xc4µ\x05\x97\xda\xd9T}\xdb\xdbhe;\xe80;\xa2\xbaN\xa0Wg\xb2\xa6\x8b\r\xf1sW\x1b\x96\xb3u\xd3\a\xba\xdbD {\xd8t\x1dVO0\xab\x97\x8dP\xac7(\xddGG\xf4\xb1\r\x1a\xf6\x89\r\xe6\xf6St\xa3\xaf\rz\xd2\x0f\r\xf5'mS\x93\x9d\x1a\x00\xba\rd\xbb\x83\x94Ai6\xe6H?\xb3Q\x89\x06\xdb`\x15\x87\xd8hk\xd2mX\xf83\x94\x14\x18\x06\"~nc\x14<<Az\xb9\x8e\xb0Q}2l\xc0>\x99ԏ\x91Iv\x8d\";GC~\xb20\x84l0`\x8c\x8d/:\xe6e\x9c\rہǃ\x90\x13T\a\xbe\xd0\xeb\x976I\x19|\xa5t\xf8\x9a5~\x93h\x1f\xdb\xf4m\x8a\x8b&\xb2\xef\x93P\xc5w\xa0\xe4d\x94\xdf\xdb8\xb9\x88\xee\xe7\xb0\u007f\x06\xad\xda\xc8\xcaL\xaa}f\x90\xceb\x93ē\xd5\x06\xa3lSZ\xd8\xd9C\x87\r\xde\xceI\xea\xbalb\x00\xdd\xfc\xe0\xb11\x1d\xe3e\x13>\x1b\x17\xca\xf9\xa9\xa8\x01\x1b\xa1h\x90\xf5\x84\x94la\xfe\x1a\xb1\xf1\x15jQ\x1b\x92$1\x1b\x122q\x1b\xf3\x9dS\xf8q*e\xe7G\x8cp\x9a\r\xee\x90j?]\x891C\xab\x99\ty\x98Ey\x98M\x12\xcfa\xc3sm\xccKͳ\x11\xe6η!\xbf\xb7\xc0V\xb0k\xda\xe0\xd4Qi)\vQ\xf1\"\xc8\xecb\xea\xe4\x12^\x96\xea#\xcbԆ-\xb7\x15\xe8\x906*5;e\x85\x8d\x8bll\x12]\xac\x02\rW\x83\xdakTZ\xd7\xda\nv\xcf\x1a\x9d=,-e\x1d\xed\xdaz\x1b\xc0\xdb\x06[\xe1\x04\xd2\xe5/\x1bm|]\xfe&\xb4\xff\xb3\r\x93'\x9bmؗ\xb0\xc5\x06\x97\xb6\x95\x84\xfe\xc5V\xb0w\xea\xe0\u052c\xb4\x94m\xe8\xe5v\xaa\xe4\xaf\xff\xfbz\a\f\xcao6,t\xdci\x93\xd4\xee.\x1b|\xcan\x1bV*\xed!\xd5\xf7\x92ſ۰\xe6a\x1f4\xe4\x0f\x1bC\x87\xfd\x94\xe7\x036@\xe5\x836\xfa\xc0CIu:Ls~ĆL\xcdQ\xb5CǨ\x95\xc7myZ\xa4\x9c\xb0I\n\xe3$L\xf6)\x1b\xc0\xfai\x1b\xf7\x05\xfc\xc9J\xffb\x13gl\xea\a\xcfژ\xbb:g\x93\x99\x84\xf3\xa0\xc3\x05\x9b☋\xe8\xdd%\x1b\xbd\xffe6t\xc5&SFWm\x84\xe7\xd7X\xdf\xf5\xa4Fܰ\xe5k*\xabP\xd5\n\xffmC\xd4\xf3\x8fM\x92j\xff\xda\x04*ܲ\x01\x16ܦ\x86ܱq\x01\xe5]\xe9\xfe=\x9b\x00\x8b\xfb6\xa2\xf6\a\xa4\xfcC\x1b\xc0\xd3#\x9b \xa0\xfflxՔ\x8d\xb9\xd6'6\x04-OmLs\xe7\xb2K\\\x93ۮ.<\x8f]\xc4!\xaf\x9d\xce.\x9f]\xcf\xfb\xcco\x17\vW\xc0\x8e\x83\xa3\n\xda\xe9q\n\xd9\xd9fa;\"\xdb\"v4\xfd\x8c\x1dh\xbd\xa8]\xb3\xae\xcfڅ\xc7\xc5\xec\\\xf9]\xdc\xce͋v\xa6a\x9e\xb7#\x1a(a\x87\x97(i\x87G{\xc1\x8eu\xa8v\xf6\xb7\x94\xb6\xf2\x92]\xf0Li;\xe9Z\x86O\xbcl\xa7A.\x9bl\xed\x15\xbb\xe0\xccW\xed\b\xa2\xca\xd99\x87^\xdeN\x98\x9ab\xc7\xca\xdc\nvl3\xa8h\xc7\xcb\x19\xed$z%;\x93\x97\x95\xedX8\xfc\xba\x9d\xd6\xe4\r;\xfdN\x15;\xc3\xc0\xaav\xf0\xe6M;\xbct5;NǪ\x9el\xbd\x86\x9dr\xf3\x96\x1d^\xaa\xa6]4\xecm;\xe7{߱ӒԲkj\xa3\xb6\x1do\x83x\xd7\x0e\xf8Q\xc7.ӱuI\x9f\xf7씰zvHo}P\xa4\x01\xc6\xd6\x10\xff7\xb2#\xbd\xf7\xbe\x1d\xa7\xe56V2|\x00Z7\xe1oM혋\xf9\xd0.b\xd4\xccN\xd1knG<\xd4\xc2\xce\x18\xba%\xf8\xfa\x91\x1d\x11P+;\x03\x91\xd6v\x95\xf36vh_[;\xe6\x03\xda\xd9y<w{;Ե\x83\xcaHGm\xbb\x93]\x8c\u007fg;\xec@\x17;2\x8b]\xed\x10\xf4nvX\xb4\xee\x18a\x0f\xbb\x048=Ƀ^*\a\xbd\xc1\x8b>\xa0\xd7\xc7v\xccw~\x02\xc1\xfc\x14#ꫤ\xeb\xa7d\xe9oǤI\xaa\x1d\xa1\xe9\x00\xbb\x18\xf7\x81(\aa@il\xf03\xf6t\xb0]\f\xcb\x10;\fK\xba\x9dfc\xa8]\xd4t\x98\x1d\n\xfeyr\xc4\xc3\xed\xf2\x12\r27C\x99\x99\xa9\x8d\x8e\xb4\x8b&\x8e\xb2\x8bJ\x8dF3Y*\x9aٔ\xfc1\x18\xc4X;\xa6\x17\x95\xde\xe3ѫ\tv\xa8\xe3\x17*\xd2_ڡ\x82_Qo\xbe\xe6\xd3\xdf(=\xbf\xd5J'\xaa\x96MBS\xdf鯓)\xf7\xdfC\b~H\xca]\x8eJ\xab\x81\xd2i\xa4\xf8\x9b(\xcaf\xd5\x02K\xf2n\xab\xaa\x83\r\xf2d\xa7\x14:P\xa3\x13\x1cpQ\x80\xdc\x14>\x0f\xa9\xecU\x91\xf1Q\x82\xfc\xca\xf6\x00\xba\x17$\xa5C\xa4{\xd8\x0e;\x1d\x81\xe4E\xed\xd8Ǐ2n\x97D\xed\x14;\xd68N\xb53\xdf\xf2\xa3]vOMC\xf9\x13n\x9bnG\x14;Î\xa5\xdf3\xf5\xbeYz\x9d\xad\xd79vx\xa8\xb9\xfaq\x1e\uf78f\x1a\x16\xe8\x97\v\xf5\xba\xc8N\xbb\xbf\xd8.\xab\x92\x97ع\xd2y\xa9^\x97)\xb3\x96+aV\xe8u\xa5\xbd`\xd7\xec\x01r\x8e\xe4*;\xcf\xf9^\xad\xf5\xad\xd1\xeb\xda\x04\x89\xd23S\xd6\xd9\xf3\xb6\xceLYo'\xf0\xd9`\x97ue\x1b\xedD\x19\x9b\xec|\x97\xb1ڗ\xcd\x10\xe8-(\xb7\xdaq\xaa\x8d\x1d\xc9\xd1m\x90\x9e\xed4Q\xbfڑ\xa1܁\x1b~\xb3\xcb\xca\xef\x9d\xca\xc6]v\xeeӰs2k\x8f\x9d\x89\x93\xbdv\xf1\xb0\xbfӞ\xee\xb3#+\xf4\x87\x9dY\xea\xfdP\x80\x03Tƃv\x01M\x87\xd0\xc7\xc3\"\xeeGT\a\x8fR\xb4\x8e\xd9\vv\xcb\xc8J\x1b\x9e\x91r\x9c\xb5\x9cPƟ\xa458e'\x14=mG\x14\xf2'9\xff\x17\xac\xf3\x19;\xa3\xb9\xb3\x14\xe9s\x18\xd2y\xbb\xae\xe8\xbf\xc0\x9e_T^\\\xb2\xc35^\x86\x9e_\x81:^\xb5\xcb!c\xd7t\xa4\xd7\xed\x80\xfe7\xec\x92E\xbaIk\xf67e\xf2\x1f;pƿ\t+\x92\x96\x99r\xcb\xce \xef6\xe5\xfe\x8e\x9d+\xe1\xeeҖ\u07b3\xcb|\xd8};\x91\xf3\x03H\xf8C;6\x1b<B\a\xff\xb3\x03\x9b=\xb63\x97\xf5\xc4\x0e\xe4\xf8\x94l\xc9\xe5\x00\xa6\xce\xed\xe0\xbce\x1e\a\xb7h8Л|\x0e.\x83\xce\xef\xc0dO\x01\x87\x10\xa1\xa0\x03P\xb5\x90C\x87]ء\x9b\x17\x1d\\\x9aꐍ/E\x1d\xe8۳\x0eƣ\xc5\x1cȒ\x14OT+\xde\xd1\x017\xff<\xbf,\xe1\x10ҔD\xf9\x82Cb\xdb\x17\x1d\x1co)\x87\xf0\xfc%\af\xc4J;d,e\x1c\xf4\x8b\x0e\x92\xa0\xacC\x1d\xf8+\x0e\xe1\xfa\xab\x0e\x18\x9er\x0eM\x92\x95wH\xa6'\xc5\x01@^\xc1\x01?T\xd1\xc1\xd4\xdek\x0e\xf2\xb9\x92\x03\x91Ke\ah\xfb\xbaC\xec\xd9\x1b\tj\xa4\x0e\xcbH\xa9\xe2@6\xb0\xaa\x03^\xe8M\aB\xadj\x0e\xc0\xd8\xea\x0e\x12\xbc\x86\x83\xe2\xf5\x96\x03\xec\xae\xe9\x10{\xf16\x87\xff\x8e\x83\xb6\xae\x96\x03\x92V\xdb!Z\xf1\xae\x83\xdaW\xc7\x01T\\\xd7\xc1\x13m0\xd6z\x18d}\x87\bo\x03\a岡\x03\xa0\xb6\x91Cb\x88\xf7\x1d\b\f\x1b\xa3\xa6\x0f\x1c\xccA5q\xf0M\xffḋ\xfc\xd4\xcc\x01d\xdbܡ\u07b8\x85\x03\xf2\xdc\x12\xed|\x84\xe7[\x91\\\xad\x1d4\x0fm\xd8\xe9\xb6\x0e\xe8X;\x87,\xbcq\xd0\x0etp@m;\xcaw\x9d\x1c0\x90\x9d\x1d\n\b\xbb\x90\x8d]\x1d\x00\xbf\xdd\xd0\xf7\xee\x1cT\x0fG\xc1\xa6\x99\x99\x02\xe6{b`\xbd\x1cH=\xf7v\xc0]\xf4q >\xf9\u0601\xd8\xf3\x13\x8aϧ\x0e\t*\xfaB\x1a\xfa\xb1\xcb\xfd\x95\x10\xa9\xe0\xe6\x00\xdc0СKn\x1c0\x92i\xac\xf13\aQ\xcc`\x87\xa6Ň8\x04\x97\xa6s\x9cC\x1dr\xa0\xe30V\xfa9*\x1bN\xd1\x18A\xa9\xca \x013\xd1\xf8H\a\x80\xff(\xde>\x9a\xbc\xcfr\xc0\x01d;\xb0\xf4h\x8c\x03\x1bQ\xc6j_Ʃ\"\x8c\aq'`\xc4_@.\xbft\xd0r~\xe5\x10\xf4\xf95\xbb\xf3\r\x18\xfa-{>\xd1\x01\x838Ɂ\x00\xeb;\xb2p\xb2\x8a\xd6\xf7\x0e\xfa\xa2\x1f\x1c\\\f\x97\xe3\x10\x93bp\xf0|/\xa3\xf2ȤW\xb3C<\x8d\x05\x82lU\xd2\xd9؊\x9d\xa2\xe4\xc0oNt\xd0\xe5\xe0\xc2@\xb7\x83\xe1\xb4ǁcm\x1c\xccv\xf8\x1c\f7\xfc\x0e\xcc^\x060\xb2\xa0\x83;\x91C\x0eq6a\x87B\xeb\bY\x11u(\xea\x8f9\xc4\xe3\xc6\x1d\x8c\xa6\xa680\v6\xd5\xc1L\xe4\x8f\x0e.\xb7\x9f\xe6\x90\xe0\xe4'\a\x1c\xeat\aC\xc2\x19\x0eN\xfc\xcf\xd4\xde\xcfr`?\xe1l\a\xe68\xe6\x90Fs\xf5\xa6y\xa0\xf0|Pv\x01%x!{\xbbȁ\xb4\xe5b\xca\xe7\x12\x90{\xa9\x03\xce~\x99\x83\xc7\xce,w\x10\xb6\xafp\x00X\xact\xc8ΝU\xe0\xffj\ar\xe8k\x1c\xb2\xf6a-\xf9\xbe.9\xb6\xf5\x0e\x80\xad\r4d\x1b\xc9\xd0M\x0e\x01P?\x83F\x9b\x1d\x98\xbe\xd8\xe2\x10H\xb8\xd5!Q\xf0/\x0e8\x8dm\x0e1\xd0\xdb)\xed\xbfҰ\xeePj\xfc\xe6 \nډ\av\xb1\x91\xddT\xf9=\x0e\x06\xbb{\x1dL\xa7:x\xa4\xeb>\x87\xe6\xb2\xfep\x14\xe8\x98%\xe7E\xee\xa7\xfe\x1e\xa0\xfe\x1fL\xda\xc2C4\xa3\x87)\xcfG`\xa6\x8e\x82E\xc7@\xc1\xe3\xf8\xff\x84\x03\xab\\N:0\x17\u007fJ\xdb<\xcd6\xfft\xe8\xcb\xfc\x1d\b^\xcf8\xe8\x9a\xcf:$\xa7r\x0e}>OB^\x80\x84]dO.\xc1#\\VWp\x05\x02v\xd5!H隃\x80\xf1:\xcd\xcb\r5\x977\x1d\x98\x8b\xf9\x9b\x1c\xf8ǡ\x87\x9d\xd2\x18߂\x13\xba\xed\xa0\x93\xbdC\x8e\xdfE\x13\xf7\x1c\x9a\x98\xbd\xef@.\xe1\x01\x84\xe2\xa1\xca\xf2#\aS-\xffA\xee\x1f;d\xba\xe8\t\x89\xf4ԁ\x1cv.'\x8e\xb4\xcd\xed\xc4\x18\xf28\x13\xc6.\xafS\xb8\x99\xcf\xc9\xed\xa1\xf9\xf1\xa9\x80\x13\xc3*\xe8\x04\xef\n9a\xc6\v;\xb5\xed\"\xc9\u007f\x9eq\xe2h\x8d\xa2N\xa6\x1e\x9eur\xa5z1\xa7Щ\xb8St\xe79',\xe0\xf3N\x01\xaa%\x9c\x18nI\xa7t\xfa\x05\xa7\xf0\xe4\xc5d]\xa5\xd8\xe4KN\xbe\x94\xd8\xc9\x11\x95q\x8aH\xbf\xec\x94e\x00e\x9d\fn^q\n\x1b_u\xd2\xe0\x94sb\x92\xa3\xbcS\xf1\u007f\x8aS\xc0{\x05')Qщѿ\xe6TkY\xc9\t\x04UY\u007f~\xdd)3\xe1o8i\x18\xaa\xa0\xb1\xaaNh\xea\x9b\xf8P\xcd\xc9\xd4[u'\xac}\rg2\xad\xeaD\x96\xa1\xa6\x93\xc6\xe3m'\x94\xe7\x1d\xa7\x80\x9fZN\xb0\xa6\xb6\x93\a\x15\xbc\xeb\x14\xf5\xaa\xe3\xc4F\xbd\xbaN\xca\xf4{N\xba\xe8zzS}R\xa6\x81S\xb5\xaf\xa1\x93\xae\xbb\x91\x13\x13$\xef;\x89D\x1b;!\v\x1f8E\xc0\x9aplM\xf5\xb7\x0fyk3'\xc3\xeb\xe6NZ\xd6\x16`FKm\xef#\xde\xd4ʉ\x1d\x1b\xac\xad\x8d\x93k\x03\xdb:aE\xda9\x99\xe6n\xef\x84\x1d\xe9\xe0\xa4\xc4vt\x8aLur\x12\x8fv\x86\x98tq\"\xea\xecʎts\"(\xe8N\xd2\xf4 \x15z\x82½\x9c@E\xbd\x9dt\xc3}\x9c\x88-?v>\x93\xc0 i#2\x86gde\xa4|\xe2\x84q\xfd\x94r\xd0\xd7\t\xcb\xd6\xcf\xc9e\x00\xfd\x9d\x98MIu\x024\x0epbG\xfa@'\x8c\xe0 \xa7\x04)iN\xf1v\x9f\x81\x03\x83\x9d\xcc1\x0eq\"<KW\xb9\x1c\xea\x84o\x18\xe6$:\xf9\\\xef\x1aN2\x8cp\x12pe8a\xc42\x9d\fXG:u\x99\xd2(\xa7\x9a\x99є\xb8,\xa7\x00\xb9l'u~\x8c\x13\xfa5\xd6)\x06r\x9c\x93\xc7a\x8fw\"ȝ\xe0\x94\xb8\xfa\v\x92\xe7K'N[\xfe\x8a4\xfb\x1a\xdc\xf9\xc6Y\xa0\x03\xda\xf8\x96b6\xd1)\xa6k\x92\x13\t\xca\xefx\xe7d'\xf0\xea\xf7\xe4\xca\x0fN\xfa\xcb\x1c's\xf7\x06'쉑m\x98t\x84f\xa7$\x81-N,ر:\x05\x16ٜ<\xa5\xc8\xee\x14\xe3\xe0\x80\xb28\xc1#\x97\x93\x16\xdaͪ<\xe4\xadW\x1b\xf0\x91-~\xd07\xe0\x94\b:H\xed\x0f9\x05\x9c\x87\x9d\x8cu#J\u0528\x93\xaf\xcb\xe0cqU\xe7)N\xa4ɦ:\xb1\x04\xf3G\x92b\x9a\x9a\x8f\x9f\x92\x94\x9e\xee\xe4y43T\xbbfB\xd8fAfg;\x01g\xe68\x91\xa4\x98\v\xa1\x9c\x97|p>\b\xbd\xc0I\x17\xb3\x10\xb4]\xc4\xe1,FǗ85l\xc4s\xcbP\xe3rX\xa3\x15\xfa\xd0J\xfc\xb2*ɐ\xd50bk\x9cpekul\xebȑ\xf5\xaai\x1b@\x80\x8d(7%\x1f\xfc\x99Vd\xb3V\xbb\x05}ي{~\xe1\xe3ۜ\x043\u06dd\x98\xc8\xf9\xd5\t\x0f\xbb\x83\xc2\xf8\x1b?\xed\xe4e\x17:\xba۩\x89\xfe=\xb0({\x9d\x9a\f\xf8\x1d\xbf\xees2`\xe4e?u\xf9\x00Fs\xd0\xc9E]\x87\x9c\xc0\xaf\x87\x9d\x9c$>\xa2z\u007f\x14\xa49\xc6'\x8e;e\x0e\xfe\x04L\xecIU\xd7SԈ\xd3NIS\xfe\xe9Է-\xe2\x963NDag\xb5\x85sʱ\xf3j_/8q6\xc3E\xa7\"\xf4Kp\x03\x97i\x84\xaf\x80\xadW\x9dX\xfbz\x8d\xba|\xddɼ\xf7\rX\xb8\x9bN°\xbf\x9drx\xc6?N\x01-\xff:e\xa1\xc3-\xd0\xf36\x86w\xc7ɅnwI\xac{\xd0\xcb\xfb\xb8\xe1\x81S\x8e4y\xe8$z}\xe4,\xdcz\xf4\x90\xf4\xf1\xd9\xc3\x13\x11\xa3\x93sL\x8f\x9d⥟\x80\xa2O\xa9ع\\2\xce\xdc.¸<.]\x88\xe3\xa2z\xe4s\xc1\x94\xe5w!\x9f]\xc0\x05^\x16taW\xbfK\xea*\xec\x12\xbcW\xc4\x05\xfe?\xe3Jxآ.\x84SϺ\x80\xbd\x8b\xb9\x10!\x14w\xa1\xb1\xe7\\\xec\xdb\xf3.\xe4>J\xb8\x04:\x95t!\xa7\xf5\x82\x8b\x0e\xefE\x17\x8ei)\xe5\x82\xd5|\xc9\x05\x95*\x8d;˸\xb0T\xe1e\xb4\\\xd6\x05\x8c\xf1\x8a\x8bٮW\xd9B9\x17\xa0Ly\x17\xa8\x93\xe2\x12\x92Up\xa9(Uta\x9e\xe35\x17\xb0\\%\x97й\xb2\v \xf4u\x17߯\xe8\"\xba\xad\xe2*\xd8*u\x80\xbc2\xb1\xaa\xab@\xebQ\x92F|\xd3U\xa0\xc3\xe0\xd4\xd4a)\xd5\\0\xdd\xd5]\x98\xbb\xa8\xe1\x12&\xbf\xe5\x12\x10S\xd3%\xccx\x9bm\xbf\xe3\xc2\xdb\xc7j\xb9\xc4^\xd7\x16ʼ\xeb\xa2\n\xd5q\x11\xac\xd6E\xef\xde\xc3\r\xf5\xc0\x86\xfa\x18Y\x03\x97\x88JC\x97\xb0\xbe\x91\v\xc6\xff}\x97\xe0\xa1\xc6.:D\x17\xa7\xff\x9a\xb8\x80⚺(\xb8\x1f\xb2\xddf\xbc4wa\x91O\v\x17^\x8e\xe1\xa2\x01\xfd\x88\xbf\xb5r!\xe5\xdd\xda\xc5\xf8\xa6\x8d\x8b*\xd2օ\xc5\b\xed\\\xa2\x14\xed]X\x85\xea\xd2\x05^\x1d]<\b\x9c\x15tv\tB\xec\xe2\x02Z\xee\xea\x02\x02\xed撬Ow\x97\xa8W\x0f\x17\xbdKO\xe5w/HLo\xb4\x93\x9e\xd2Dž\x00\xf1c\xfd\xf1\x13\xfc\xf8\xa9K\xf4\xba/\x05\xad\x1f\xe8\xd0\xdf\xc5Dt*\xa5e\x00\x1a\x1d\xe8B\xf2c\x10\xe5*ͅ\xf4\xcag.E*\x83]\xb2=d\b\xb8\x91Nn\x0fu!qJZ}\x8e߇\xbb\xe0\xadG\xb8\x18\x9ed\x80\x0f\x99\xa0\xf7H\x97b\x92Q.y\xb1\xf8h\x17\xa0c\x96\x8b\xfa\x93\xad\xe3\x1a\xa3\xea1V\x85o\x9c\x8b\x86o<I1\xc1%\xf1\xdc\x17.\x89\x15\xbeTf\u007fE\xca}\xed¤\xfd7\xecη\x14ډ\x14\xdaI.\x82\x8f\xef\\:O;٥띾\xd7v\u007fp\t4\xccq\xc1\xd1\x1a\xa0\x13F\b\x8b\xc9%N\xcdLM\xb2\xb8\x10\xcdZ]0d6W\xf2\x15\x8a.\x9a+\a;\xe9t\xd1\xe5\xbbt,n\x17}\x9a\a\xb4\xf7R||d\xb1\xdf\x05h\x1cp\x11Z\x04]XW\x11r!\b\rkE\x11\xbdF]XA\x1b\xe3\xa0\xe2.LvOq\xc1\x85ME\x9f\u007fD\x13\xd3\\\xe2m~r\x89\x97\x98\x0e\x16\xcc 9f\xba4\t4\xcb%+\xcfg\x8b\xb8'Z\x9fC\xe9\x9f\xeb\x92|\xfc<\x17\xce\v\x9f\xaf2\xb4\xc0E;\xbd\xd0U\xa8m\xea\xe8\xec\xc1\xf2n\f\x97L\x1a.v\xd1V/q\xc1\xe2.u\xe1\x94\xc5ed\xc6\U00084d8b\u052cp\xc1\x1b\xact\x11ݬr!{\xb0\x9a\xe3X\xe3\xe22\xb6\xb5.A\x14\xeb\\\xf0\xf4\xeb]H\xabmpрoLZ\x98M.\x04e?\xbb\x04\xd2lv\x01%mq1\xe8\xda\xea\xc2l\xd1/\xb4\x95\xdbhضS\xc0~uIx\xb0Å]\x1a\xe0\xe8N\x17\x81\xee.\x17\xe3\xf9ݐ\xfe=\x1c\xc6^\x8a\xcf\xef*~\xfb\\\x9c\xa5\xfd\xc3Eܻ_\x9f=\xc0\x16\x0fR\x10\x0eA\xc0\x0f\xab\xd2\x1fA\x8bGQ\x1es1\rz\\\x87s\xc2EP|2\xc1\xb4\x846\x9eR\t9\xad\xc4\xfeS\xf5\xe6/v\xe6\f\xef:\xebB\x18\u007f\x8e\x86\xe2|R#/\xc0\x00]TٸD\xb1\xba좫\xbb\xe2\x12\bs\x15\xaa\u007fͅ\xa5A\xd7ɡ\x1b.ş7]|\xff0\xee\xf9\xc7%K\x9a\xffu\x15\xe84^~\xbbE\xe9\xbcM\x83|\a\xd6\xf7.\x8d\xcb=\x17\xb0\xe1}\xb4\xfe\xc0\xa5\xdbZ\x1f\xba\x98\x80x\xa4\xfa\xfc\x9f\x8b/\xde}\xacR\xf2\xc4\x05\xd8\xf94y\u007f.7fVr\xbb!\xefyܴ\xdfy\xdd\xe0Y>\xb709\xbf[:V\xc0\xadӷ\x05\xdd8h\xa8\x90\x9b\x01fa7\x9c@\x117z\xf3\x8c\x9bswE\xdd\"\xd7ϺE\v\x8a\xb9I\x99\xe2n\xc9y?\xe7fN\xf7y7T\xbc\x84;OӔ\x92\xee\xfcm\xf1\xc6~\xb7$\xca^t\x03ߖr\v\xa2}\xc9\r\x04]\xda\xcd׀\x95q\x8b/z٭\xa4/\xebF\x9a\xf3\x157\xec\xe0\xabn\xae\f.\xe7Fڴ\xbc\x1bH1\xc5MXT\xc1-\x10\xa4\xa2\x9b\x1c~\xcdM\x01\xa8\x84o+\xbbE _w\x03k\xbd\xe1fJ\xae\x8a\x1b\x81OU\xb7\x92\xeaM7c\x97jn\x81\"\xd5\u074c\xe8j\xb8Aз\xdc\xe2\xe3j\xba\xa1;o\xbba\xb3\xdfq\xd3m\xd5\x02\x19k\xbb5~ħ:n\xc0\xa4\xban.\xfb}/\xf1xjJ=7\xf2\x05\xf5\xdd\xd8}\xd0\xc0]\xb0m\xea\x84Ԅcn\xe8\x16\xdf\xd8\xc8\rl\xf6\xbe\x1b\"\xdf؍\xc8\xef\x037_=\x9c VZJS\xa5\xf4\x87\xfc\xb2\x99\x1b\x8e\xbf\xb9[\x81e\v~\xddҍÿ?rc긕\x9b)\x91\xd6nq\"mtTm݀\x1e\xed\xb4\xc2\xf6\xe0E\a\xb7\x88_Gr\xa4\x93\x12\xbb\xb3\x1bo\xebwcz\xb5\xab[\x8c_7w\x02\nt\xe77=܄[=\xddb[z\xb9\x11(\xf4vS\xab\xfb\xb8\xe9\xfe>vs\xbd\xc7'n\xe4i?\x057\xfa\xbai\xba\xfa\xb9\xa9\x9b\xfdݚ\xbdMe\a\x06\xa0\xe1\x81nz\xf6An\x18\xe147\x16X}\xe6\xe6\xfaTmg\x88\x1b\t\x8fte\xe0P7<\xd407A\xed\xe7z\x1d\xee\x86\v\x18\xe1\x06 \xcc\xd0\xf1e\xba\x19w\x8ft\v\xa4\x1cEi\x1f\xed\xd6\xd7ghdz\xf5\xf3\x187\xe7$Ʋ\xc1qn\t\xc7ƻi\x8f&\xb8\x01\xa7\xbepý\u007f\xa9\xc2\xf1\x95\x9ba\xc3\xd7n5\xb0\xdf@Ŀu\xc34OD\xab\x93\xdc<\x0e\u038d\xb9\xed\xc9n1\xfb߳\x9a\x1f\xc8\xd3\x1c\xdeap3P4B\x91Ln\xe6\x1b\xcd$\xabEykuc\xfa\xc0\x061\xb6\xbbaL\x1cnYX\xe4Dk.7\xb6j\xba\xdd<w\xd5\xe3\xe6\xd2\x06\xaf\x9ba\x9d\x8f\x8f\xfb\x93\xf6 \xe0\x16\x10\x10ts7YH\x155\xec\x16c\x1eq\xc3\xe2Eݲz3\xe6\x16\xbc\x15w\xf3\xa0\xa8)n\x1a\xa6\xa9\x18\xee\x8fn\xb1\xd2\xd3T\x16\u007fJ\xb2z\xba\x9bf{\x06{9\x93\";ˍWq\xccv\xe3D\x8d9n\x84\xads\xa9\x16\xf3\xdc\xc87\xcdW\xea.\xd0\xebB7R\x05\x8b\xdc\xe2\x84\x17\xbbi#\x97舖\xd2|,\x03A\x96\xbb\xe1xV`T+\xddr\x8c\xe9*5u\xab\xdd\xffs\xbdk\xdcI\xf4\xbc\x96\xe4XG>\xac\xe7e\x03/\x1b\xdd\x12:l\x82\xc2\xff\xcc\xfb6\xbbe\xe7\xe4\x16\x90{\xab\x9b{f~!\xaf\xb7\xa9\xddٮ\xf2\xf2\xab\xf2k\x87\x9bo8\xfd\xcd-3\x03;\xddX\x86\xb6\xcb-8i7\x87\xb5\a\x94\xddK\xbd\xf8\x9d\xb4\xda\a}\xfeCe{\xbfJ\xf3\x01\x10\xe0 zt\b\xf5\x1dV5;\x92\xe4\xe7Q7V\x0e\x1f\x83a<\x9e4~'\x94V'\xd9\xfc)7\x13\x00\xa7\xdd\xf4\xc3\u007f\xba\xe9\x97\xffrs\x1e\xec\x8cڵ\xb3\xb4\x84\xe7ܘ\x998ρ^\xd0\xce\\ts]\xd7%\x9a\xb2˪DW\xdcH\xad]\x85۹Fٽ\x0e\xde\xdcp3v\xb9I\xf2\xfe\xed\xd6\xf5\xab\xfc\xf8//\xb7\x92\xce\xe16Fy\x87\x86\xf6.,\xd3=\xb7x\xe3\xfbnL\x9c=H\x8e\xf8\xa1[\x10\xfd#7_\xbdH>=fW\x9f\xb8\xf1n\x85\xa7n\xf5չ<P\xec\xdc\x1e\x01\x1ay<\xa0t^\x0fv\u007f\xe7\xf3\xf0Ԁ\xfc\x9e|\x9d\x12\xd2T\xc0\x83\t\x91\x82\x1e\xc4ƅ<\xe4Ca\x0f!h\x11\x0f-\xdf3\x1e\x92\xb5\xa8GӦ\xcfz\x10[\x16\xf3\x10n\x17\xf7\x00\xe8>\xe7ar\xf4y\x0f\x94\xbe\x84\aP\xb3\xa4\a\xcb2^\xf0\xc0Ͻ\xe8\x01\x15Ky\xb0\x8c\xd5CZ\x96\xf6\xa8U)\xe3aN\xf4e\x8f8\xe1\xb2\x1e*\xda+\xac\xe1U6Z\xce\x03\xc5/\xef\x11S\x9d\xe2\x11RU\xf0\x00\xcdT\xf4p\xeb?/\x95<\xf4\xa8\x95=\x84ۯ{\xa0\x96oh\x9bU<\xd8WQ\x95\x04x\xd3#\\\xa8\xe6\xa1\nU\xf7\x80\xf45<x\xf3\xa2\x87\x02^\xd3C_\xfc\xb6\x12\xe9\x1d\x0f}t-\xfd\xbe\xb6\aP\xe1]\x8fHy\x1d\xf6\xa8\xae\x87f\xf9=\x8f\x98\xacz\x1e\x98\xd6\xfa\x1ex\xad\x06\x1eN26\xf4\b4j\xe4A\x98\xfd\xbeGf\xf9\x1a{\x00l>\xf0\x88\x1a4\xf1\x88!m\xea\xe1\x82\xce\x0f=H\n5\xf3\x10(5\xf7\x00y\xb5P\xae\xb6\xf4\x10\xb6|\x04\xf2\xb6\xf2\xc0b\xb4\xf6\x88\x99mせm\xeb\xe1\xcc@;\x0f\xa6\x8d\xda+\x89;Pb:z\xf2w\xc0\x11\xe3\x1e\tc:+\xa9\xba赫\x88C\xc2\xd1w\xf3\xc0\x8bu\xf7\x00\xce\xf6\xf0ऱ\x9e\x1eQ\x84^$Bo\xb4\xdf\xc7\xc3Ŋ\x1f{4\x96\xfbģqԧ\x1e\x02\xb0\xbe\x1e\x99R\xeb\xe7\x11\xbf\xdd\xdfCۜ\xea\xa1w\x18\x00\x96\f\xf4PE\ay\x10\x13\xa7\xe1\xcb\xcf\xc8\xe1\xc1\xbc\f\xf1PA\xd3=\t\x87>\x147\f\xf3\x00\xdb\u007f\xae\x1d\x1f\xeeANs\x84\a\x87\xc4闙\x1eDM#=\xb4\r\xa3\x92\xb2=Z\u007f\xcf\xf2\x882g{h\xee\xc6x\xb8\xdfj,i:\x8e\xe3\x1c\xef!\xe0\x9f\xe0\x91\xa5|_xxH\x9c\a\xe6\xee+\x1d\xfd\xd7\x1e\x86D\xdfx\x90C\xfc\x96\x15L\xa40OR\xcd\xfa\xce\x03\v4\x99\x1d\xfd\xde\x03\x88\xf7\x83\a\xe1P\x0e\xc4\xc0ࡏ0\xaaX\x9b<\x84\x14f\x8f\x98\x05\x8bʃ\xd5#\xe0Ǧ\xa2i\xf7h\x06̡:\xe0\x04_\\\xd4v\xb7>\xe3\xf1\x00iy=\x92\xb5\xf2a\xd4~\x0f\x93[\x01\x0fQMЃLM\xc8#\b/\xecA\x8a&\x02\xb9\x8dz\x90^\x8ay\x984\x8a'5y\x8aG\x9c\xcaT\n\xf2\x8f\x1ez\xd1i\x1e$\x10~\xd2\xeeM'\afx\x90M\x9a\xe9A\x9c:\xcb#>v\xb6\ai\x859\x1e\x9aҹ\x1e\xa6\xc5\xe6Q\x88\xe7{\x00~\x16x\x90\xa1Z葔\xcd\"(\xebb\xadz\x89G\xcd\xebR\xfdb\x99G\x90\xefrH\xc0\n\x11\x94\x95\xa0\xdb*\x8ch5jX\xe3A\xcec\xad\xf2m\x9dGR\x14\xeb=HQl\xf0\xc0\xdfn\xf40\xe3\xb3Ƀ\x10\xf8gj\xf9fԺ\xc5èd\xab\xca\xf1/\xda\xf26\xda\xdf\xed\x14\xe0_=L\xb8z\xe8=\u007f\xf3\x00\x02\xee\x84\xd1\xd8\xe5\x91t\xc9n\x8f\x84#{h+\xf6*\x03~\xf7 \xcc\xdeG\x93\xfa\x87G\xf2\x1a\xfb=\f\xde\x0e\xc0X\x1ed\x97\x0ey\xd4\a\x1cf\x8f\x8f\xc0\xf2\x1c\xa5\xf1?F\x8d=\xae\x96焇ٌ\x93ЙS*\x0e\xa7=\b\xfe\xff\xa4\xb9\xfc\xcb\x03,|\x86v\xe6\xacG\xf7{x\x18\f\x9fO\xf4R\\\xa5~}\xd1\x03/vI\xdd\xc7e\x0f\xa0\xcf\x15\xf6\xe4*\xb9}\xcd#\x90庇\x19\x8c\x1bI>\xdd\xf4H6\xe1ou(\xff@\xe4\xffUռ\xe5\xd1<\xccmՖ;\x1e\x89\xdb\ueca3\xf7<\x92\xbe\xb8\xcf\x0e> \x81\x1e\xc2-<\x82(\xfd\xe7A\xb8\xf2\xd8#!\xeb\x135\xe6O=\xc4\x13\xb9\xbcL5\xe4\xf6\u009f\xe6\xf1\x8a\x11\xcb\xeb\xd5N\xe5\xf3\"\x86\xce\xef\x85\xc1.\xe0E\x04\\\xd0\v\xa6\x17\xf2\xc2\xf5\x16\xf6\"\x96*\xe2E\xec\xfd\x8c\x97\x00\xa3\xa8\x17\xf6\xe7Y/X_\xcc\vR\x16\xf7\xea\x19\x00^D\xd6\xcf{Ł\x95\xf02)Q\xd2Kiy\xc1+Z\xf5\xa27\x11o\x96\xf2\xaa\xe7\u007f\xc9\vY(\xede`P\x86M\xbe\xecE\xe0W\xd6\xcb\xe0\xd2+@\xe8U\xaf\x04X\xe5\xbc\b\x93\xcb{\x11\xa1\xa6x\x15\x1cU\xf0\x8ajW\xf4\x8a\"\xbc慍\xaa\xe4%\x0e\xae\xec\xa5\xdfx\xdd\xcb\xd8\xd2\v9\xa9\xe2%[\xabz\xe9\x16\xdf\xf4B\xfb\xaay\x11ZW\xf7¡\xd7\xf0\xd2\x1e\xbd\xa5\xa3\xab\x89\x01\xbc\xede\x18\xf9\x8eWps-/\xe2\x9d\xda^=b\x9c\xf4\xa8\x93\x1c_]/\xe3\x91\xf7\xbc\t\xbd\xac\xe7\x85s\xa9綾m\xe0U\x83\xd2\xd0\xcb \xa6\x91\x17@\xfa}\xaf\x82\xef\xc6^\xba\xd8\x0f\xbc\xe2&\x9bxŕ4\xf5\"\xce\xf8\xd0\v<\xd7\f}h\ue17fo\xc1\x9fZz\x05\x98~\xe4\xa5Mm\xe5\x15\x05n\xed\x15\xc9l\xe3\x85}n륨\xb5ӱ\xb7\xe7\xd7\x1d\xbcb\xd6:\x92\xaf\x9d\xbc@\xf1\x9d\xbd\f`\xbaxq\x9a\x9c\x17\xd2\xde\xcd\v\xff\xda\xdd˰\xa4\x87\x97n\xac\xa7V\xdb\xcb\v\x80ڛl\xe8\xe3%D\xfc\xd8K\xbc\xfa\x89\x97\xf8\xf4S\xaf\xa0\xe3\xbe^\x81\xe1\xfd\xbc\xb4\x18\xfd\xd9v*\xa9?\xc0\v72\xd0K\xe45\xc8+r\x9f慓\xf4\x025\r\xf6¥\f\xc1/\xe9^\xfa\xab\xa1I\xd2\x0f\xf3\x12p}N\xd6\x0e\xf7\u00ad\x8dP\x9afx\tm2\xbdԚ\x91\x18\xe1(rh\xb4\x0e)\xcb+><\xdbK]\x1d\xe3U7:6)v\xe3\x92\xff\x8c\xf7bno\x82W\x00\xfd\x17^\xac\xd1\xfb\xd2+\x8e\xf3+\xed\xfe\xd7^\xc9A~\x93|\xe0[/\x1c\xd3D\xaf\x847\x93\xbc8\xf0|D\xcaw^\xfa\xb2\xc9\xec\xf2\xf7\xbc\xe9\a/\xa6Dr\xbcbH\r^$Č\xf8`\xf2\x02\x1c\x9b)t\x16/=\x8aUIn\xf32\xf8\xb6\x8bR&\x1c%ov\xaa\xe4\xbb\xf4\xeaV\xe1\xf6x\x11X{\xbd\x80\xfb\xbe\x04\xbb\xb2Ge\xa7\xf8\xbdH6\x06\xbc0\x95A/lmH\x1f\t{\tu\"|&\ua957\x88y\x19P\xc7\xd1\xc7)l}\xaaW2\xfe?z\t9\xa6A\x1e\u007fB9\xdd+o0\x9cA{4S\xfb<ˋu,\xb3٩9^\xb1\xa0s\xa9\xf4\xf3\u052ċ(,\xf0\xd2\\/\xf4\xc2 /\x82\x8a.\xf6\xc2\xdd-\xe1e\xa9\xf2o\x19\x18\xb2܋(cE\x92\x13+A\xf3\xf4\x94U\xac}5\x89\xbd\x86\r\xaf\xe5\xa7u\xa2\xbd\xeb\xbdX\xf2\xbd\xc1+\xcex\xa3\x17ˁ7%E\xe2g/\\\xe0\xe6\xe4\xe7-hk\xab\x17~\xe1\x17\u07bc\xcd\v\x88\xb0\xdd+\x16\xfeW/b\xc5\x1d^\x18\xfa\u07fcx1\xd4N/\xb6\x92\xee\xa2\\\xef\x86\xc2\xef\xf1\x02\t\xee\xf5\x16\xec4dl\xb6\xf8K\xb5\x95\xfb\xa8\xb6\u007fx\x05\x02\xef\xa7\b\x1c\x00\x95\x0f\xb2\x9aCނ\xcdx\x90\xf8a%\xfb\x11r\xf3(\f\xea1/p\xf1qU\xdb\x13z\xcfI/\xe7\x8aOy\xb1\x1a\xfd4,\xeb\x9f^D\r\u007f)%\xcfxŏ\x9f\xf5\xd2מS\x95:\x8f\x9e\\\xe0`/\xb2ۗ(\u0097\x93\x12~E%\xfc*\t{\x8d\xd2|\x1d\x92r\x83O\xde\xfc_\xb7\xff\xa6\xe8\xfcCR\xfd\xab\x02{KE\xe4\xb6J\xe1\x1d\xb2\xea\xaeJ\xff=\xb6x\x9f\x12\xfb\x80\x12\xfb\x90\xe2\xf4\x88-\xfc\x87\x8e>\xe6sO FOI\xbf\\>\x91\xc5\xdc>\x91\xcb<>\xbc\xd9\xdf\a\xb1\xc8烂\xe7\xf7q\x92\xd2G\x11,\xe8\x13\x0e\x15\xf2\x89D\x14\xf6aDE|*W\xcf\xf8\x84pE}h\xf1Y\x1fd\xa7\x18\xef)\xeeK\x88\xd3s>\xd2\xf2y\x1f\x98]\xc2'\x02S\xd2\a:\xbf\xe0\x838\xbc\xe8\x03\x1fK\xa1;/\xf9\xc8\xf6\xd2>\xe9|\x19\xfe\xf4\xb2\x0fL*\xeb#\a^\xf1a!\x0f\xcar\xbe\xbc\xed\xd2R\xca\xfb`)S|p\xda\x15|\xf4\xc4\x15}\x82\x1e^\xf3\x89ɫ\xe4\xc3\n\x90\xca>\b\xe2\xeb>\x86\xc5o\xf8 )U\xa4\xa7U}:A\xf7\xa6\x0f\x02\\͇\x15\x13\xd5}\xc4\x195|\x98ex\xcbǭ\x015}\xdc\x17\xe9\x13\x11y\xc7Gk_\xcbG\x90[[\xab\u007f\x97\xad\xd5\xf1\xd1I\xd5\xf5!\xaa~ϧ\x00\xaf\x9e4[\x1f\x14i\xe0\x13?\xd1\xd0'~\xa2\x91\x8f\x13\x95>\"\xd5\xc6>ڛ\x0f|\tDф\xc3h\xcaˇ>A\xc0\xcd|\x9c\x17k\x0e\x82\xb4\xf0I\x80\xd0҇\xdd\x1d>\xc6U\xad|L\x8e\xb6\xf6\x11\x8b\xb6\xf1\x01\x8e\xb4\xf5\xc1\xbb\xb6\xf3\x89'm\xef\xd3\xc5\x10\x1d|<!\x80\xf7t\xf2Q\x1c;\xfb\x04\xb0v\xf1A\xc0\xbaB\x14\xba\xf9\x10Rt\xf7Q\xd6{\xf8\x10\xd7\xf6\xf4\xd1\xed\xf7Ҷz\xfb\xb8\x10\xa4\x0fz\xf7\xb1OT\xe0\x13\x1f\xf3\xaf\xfad\xdf$\xe5\xfb\x91\xa8\xfd}\xe2\xe9Rɛ\x01>&\xd1\x06*\x11\a\xf9`AӴ_\x9f\xf9\x10H\f\xf6\xc1J\f!\x93\xd2\xf5ǡd\xe10^>\xf7a\xad\xd4p\xc8\xc3\bJL\x86\x0f\xd3\x12\x99d\xd4H\x9f\x98\xd5Q>B\xaa\xd1J\xb5,\xf08[\xd90Ƈ<\xfcXmb\x1c\b=>9\x82\t\xfa\xf5\x17\xac\xf0K\x1f0\xedW*\x0f_\xfb\xb8\x97\xe0\x1b\x1d\xf8\xb7>\x85\xc5\x13\xa91\x93\xf8\xd4w \xefd\x9f\xa0\xcb\xef\xf1\xff\x0f\xca\xc8\x1c\x1f\xdfa̋\x91\x836q(f\x1f\xf2 \x16\x9f\xd8]\xabO\xc1\x95\x8d2g\xe7\x8f\x0e6\xe0$\xe7\\l\xd5Mm\xf4@\xff\xbc\xa4\xa0\x0f\xaa\xe3g;\x01\x9f\x00\xb3 4=\xe4\xd3w\x17C\xcc\">]\x1f\x17\xf5a\x89H\xcc'\xc8 \x8e;\xa7\xb0\xad\xa9>X\xc8\x1f}X\x10<\xcd\a\xb7\xf4\x93\x0fK\xeb\xa7\xfb\x88]f\x80\xc23\xd9\xc7Y\xbc\xcc\xc6\xc0\xe7(=\xe7\xfa\x90\\\x99\xe7\x93\xf8j>dq\x01z\xb0\x90\r/B\x93\x8b\xd9\xe4\x12ѫ\xa5\x1c\xd52\xa5\xdcrܰ\xc2'\xd1\xc1J\x94\xabP\xae\xf6\x117\xaf\x81\x19\\K\x01\\\xe7\xe3\x0e\x8b\xf5>\x04\xb4\x1b|8~b#\x04g\x13M\xd2Ϥ\xddf55[|\x12\xc1m\xf5\xe9\x01\x15\xbf\xe0\xe36\xf4p\xbb\x0f\xaf\xeeW۵\x83-\xfc\xe6Ct\xbc\x93\r\xec\xf2\xc9Ε\xdd>b\xc7=\x90½\x94\xf3\xdf}\x92\xda\xdf\xe7\x93\x15\x01\u007f\xf8\x805\xf7\x832\a|\\TtЧ\x8btH\xb6\xc3>\xb8\x9a#>@\xab\xa3\xbe\x82]\xe9d\x8e\xf9\xe8\xf7\x8e\xb3\xda\x13\xa8\xf0\xa4\xb6x\n\x1d=\r\x12\xfd\xa9\xf5\xfe\xe5\x03J=\x03*\x9d%\x05\xce\xf9\xb0;\xe7<\x1e\xbe\x80\x87.\xa2\xbc\x84.]Fy\x857]\xf5\tξ\xe6\xc3\x1b:\xae\xfb\x04\xd9\xdc\xf0I<~\x93\xbe\xe2or\xf4\x1f\x1f\xf7Q\xfcK\xb9\xbb\x85\xe6n\xa3\xbc\xe3â\xaf\xbb\xaax\xf7|@\xb6\xf7!\xdf\x0f|\x00\"\x0f}\fR\x1e\xa9\xad\xfc\xcfG_\xfdX\x8d\xcf\x13\x88\xf1S\x1f\x13-\xb9\xfc\x92\x13\xcb\xed\x97\x1e\xe7\xf1K_\xf2\xfa\xa9\xe2\xf9\xfc\f\"\xf3\xfb\xe1N\v\xf8\x89\xb6\n\xfais\n\xf9a@\n\xfb\x11y\x14\xf1\xb3C\xcf\xf8\x05_\x14\xf5\xeb\xa9\x00~P\xbc\x98\x1f\x00\xad\xb8\x1f\xb1\xcas~\xcem<\xef窑\x12~\bhI\xbf\x88\xf1\v\xfa\xe4\x8b~lP-\xe5\x87j\xbc䇾\x94\xf6\xf3\x8d\x84e\xfc\x8c\xb8^\xf6\xcbH\xcajӯ\xf8\x93|}U\xbf)\xe7\x87I-\xef'jHaC\x15\xfcb\xda+\xfa\xb1\x82\xfe5?H\\\xc9\x0f\xc6V\xf6\x93t\xaf\xfb\x11漁\xfa\xab\xf8\xa1\xf0U9\x967YI5?\xe6!\xfd\"\xfd5\xfcb\n\xde\xf2#\xa5R\xd3O\xf5}\xdbO%}\xc7/\xfc\xaf\xe5\xc7,\xa4\x9fz\xf7\xae\x1f{?\xea\x80\xe8u\xfdd\xf6{~\xda\xc3z~,\xd5\xf1c\xa9\x0e\x9bn\xc8\xe17B\x9b\xef\xe3\xa9\xc6\xec\xfe\a\xda\xe1&zm\xea\x87<|\xe8\x17Yi\xc6\x1e7G\xf7Z\x90\xf8-\xd9\xf4GړVJ\xa9ָ\xa7\x8d\x9fq~[<\xde\xce\x0fqj\xcf\xc6;\xf8\xf1\xb2F\x94\x9d\xfct\xae\x9d\xfd̺v\xd1kW?]~7?\xf1Jw\x15\x95\x1e\xfa}O\xbf:\xf9^\xfa@o\xfd\xa1\x8f^?\xf6Sd?\xd1ϟjE}\xd9\xf9~\xbc\xf4\xf7#k\x94ꗰj\x80\x9fk0\a\xeau\x90\x1f[\x83\xd3\xfc\x92 \xfaL\x9f\x1f\xec\x87\xdd\x1b\x82/\xd3\xfdbӇ\xfa\x19\xe0\x0f\xf3\xf3\x00r\xbf\xe6T\xfdX\xe32\xc2/\xd0#\xc3/\x18/\x13R0\x92?\x8c\xf2#\xab7ڏ\x8cB\x96\x1fj\x9d\xedG\xc6n\f87\x96\x022\xce/\xd3n\xe3\xfd\xa2\xf0\x13 q_\xf8\x05\xc8|\xe9\x97T\xf8W~\xc0\xa9\xaf!?\xdf\xf8\x11*|\xeb\x87\x13\x9d\xe8\a\x8c\x99\xe4G\xc0\xfd\x9d\xca\xeed\x0e\xeb{\x15\x92\x1f\x12\x03\xcb\x18\x9e\x91\x92\xc3\xc6\f\xbc\xd9\xc8\x1aL\x90\x10\xb3\x1f\v&,~\xb8>\x946?\xce\\\xb7\xfb\xb9\x0e\xc3\xe1/\xd86cHꄴ\x14':\xe5\xf2\x13\xa5\xb8U\xd3=~\xcc\xeayU\xdb|~\x18S\xbf\x9fӂ\x01\xbd;\xe8g\x04\x1f\xf2s\x1dA\xd8\xcf\x104\xe2\x17\xb0\x1a\xf5\xab3\x8c\xa9\xcc\xc4\xfd\xc0\xb7S\xfcbϧ\xfa%\xc8\xfe\x91=\x9d\xe6Ǥ\xf5O~\xe6\x1d\xa6\x8363\xfcH\x16\xcf\xe4e\x16\xc4o\xb6\x1a\xa690WsQ\xd3<\xe5\xdf|?\x03\xd0\x05`\xe0B\xfdv\x91?o\xc7\x11)\x8bI\x9e%~\xb8\x99\xa5\xe8\xdf2?R\xb9\xcbم\x15~\xa4\xbaWBBV\xf9\x05\x96\xadf\u007f\xd7\xf8\xf5D\x00?\xdf\xda\xe8\a\xe6[\xaf4\xd8@9\xd8\b\xc2o\xd2F\u007f\xf6+x\xdc\xec\xd7\xe3\xc6A\xe5\xad\xd4\xca_\xd4>l\xf3\xd3Yn\x87\xac\xfd\xea\x97\x1d%;\xb4\x86\xdf\xfc\x88\x0fv\xd2\n\xec\xa2\x04\xee\xf6\vf\xdcC\xb3\xbb\xd7\xcf<\xce\xef\xe8\xf1>\xde\xf8\x87\xf6j\xbf\x1fn\xef\x80_Ò\x83\xd4\xe4C\xa4\xf3a?\xa0\xe9\x11?R\xb5G\xf9\xe81\xd4s\x9cD9Az\x9d$\xbdN\xd1R\x9ef%\u007f\x828\u007f\xf1\xa93T\xaf\xb3\x18\xc29\f\xe1<\xfe\xbf\xc0\xdf/\xb2\xe7\x97\xd0\xf3\xcb\xec\xd5\x15\xfet\x95\xb5^cS\xd7\xfd\b\xb5n\xf0rSI\xf47\x99\xf3\x8f~\xfc\x17T\xbeEɿ\xed\x17\xb7{\x87\xb5\xdc\xf5s{\xce=\xbf\xc4?\xf7\xfdLQ<\xf0s\x16\xe9\xa1\xca\xf1#\xde\xfc\x9f\xfe\xfc\x98\x15=\xe1\xe5\xa9_\xa3\xf8\\\x01\xc1\x18\xb9\x038c<\xa0\xaf\xdf\b\xd0l\xe5\v@L\xf2\a\xf4\xde\x02\x01\x9epW0\x80\xa1\x15\n\x88K-\x1c\x10\xf9-\x82\xff\x9f\t\b\xdc)\x1a`B\xf0\xd9\x00\xa2\xefb\x01q\x95\xc5\x03\xdc\x04\xf0\\@\xfc\xc4\xf3\x01\xa8\\\x89\x00\xccC\xc9\x00f!^\b\x88,\xbf\x18\x80\u007f)Ŷ_\nH\x94S:\xa0\xdb\xff\x03\xb2U\xed\xe5\x00\xadf\xd9\x00\x9c\xc0+\x01Q\x96W\x03\x14\x86r\x81\x04\xfe+/EJ\x00\x94\xaf\x10\x00\b\xae\x18\xc0R\xb3\xd7\x02\\tU\t\xbd\xae\xac\x9f^\x0f`Q\xf9\x1b\x01\x80\xe9*\x01n\xfe\xaf\x1a\xe0\x0e\x9b7\xd9N\xb5\x80\xb0\xb5z\x00&\xa8F\x00\xa1\xc7[\x01HDM\x8e\xf4m\xfe\xf6N@\xd8R+@\x9b\\;\xa0\xce\xe0\xdd\x00\xf9R'\x00\xdcW\x17\x84\u007f\x8f\xa4\xac\xa7C\xaa\x1f\x006n\xc0K\xc3\x00N\xa8k\x14@\n\xfc}~\xd98\x80\xb7o\xa0l\x12`\xb4\xd2T\x19\xf7!\xefl\x16\xe0\x1eG\xd6\xdd\"@-k\x19\x90\x05\xf8\x1f\x050\xf3\xde*\xa0\xdbT[\a`\xe8ۀ\x1em\x038\xc0\xad]@\xa2\x8f\xf6B\xc4\x0eRtd}\x9d\x02\x88\xf0;\a\x10\x90w\t\x10?v\r\xe8&\x9an\xbc\xab{\x80\xe2\xdb#\x80x\xbc'*\xee\x15` \xd7;\xc0\x85\x19}\x02t\x80\x1f\xeb\xf5\x93\x80ڐO\x03\xb2\x17\xa2/)\xde/\xc0\xc4b\xff\x00\xf35\xa9\xa8k@\x00\xc9ׁ\x10\xabA\x01\x84\x16i\x01\xe4r?S!\x18\f9\x1c\x12\x80\xe6\xa7\ahy\x86\x92W\xc3\x02z\xb8x@&\x1e\x86\a\xe8wF\x04\x80\x842\xb4\xf3\x99\xa4\xfcȀ\xc0\x99Q\x01\x98\xa7\xd1\x01D\\Y\x01N\x8fdCe\xc6(\xe5Ǫʌ#\xcd\xc7'Uf\x82\xaa\xcc\x17Џ/Q~E\xe1\xff\x1a\x9d\xfc\x86\xb2\xff-F3\x91\xfa0I\x15\xe8;ՙ\xc9Й\xefљ\x1fT\x15r\xa0\x18\x06\x95\x1b#\x85\xdcD\x014\xab\xe8Y\xd8\x19\xab\n\x9e-\xc9s;\xc5\xdd\x01r:9T\x17\xa9㦐y\xf8\xa4W\x9f\xf4\xe9\xd5\x0f\x11\n@<\x82\xca\xff\x90HH8)\x04\x11\nAT\xbe\x8c\x91`q\xf2k\x8a\xb2z\xaa\x8a\xc0\x8fd\xd94\xb2\xfa'\xe5\xcatpe\x06\xfb4SI=+@\xbc6;\xc0\x9c\xf5\x9c@\xc1\x8e\xa32\xe4M\x1bs\xa1\x93\xf3\x02\xc0\xbf\xf3\xb5\x8e\x05z\xdb\u0080@\x93E\x01A+\x8b\x03\x98\xf5\\\x12\xc0&\xef\xa54\x06\xcb\x02t\xe9\xcb\x03\xba\xdd1 .ve@L\xfe\xaa\x80\xac\xbeXM\x1b\xb2&@8\xb26\x00\x04\xb3.\x80I\x8c\xf5\x01$\xd46\x88\xd2d\xa4l\f`ZvS\x00\b\xfb\xe7\x80`\xd8\xcd*\xc0[T\x80\xb7\xea\xf5\x17\u07b4M;\xba]\xaf\xbf\xeau\x87>\xf6[\x00>hg@\x02\xa8]J\x84\xddz\xd3\x1e\xfd\xbcW\xfb\xf6\xbb\x8e~\x9f\xfe\xfe\aF\xbf\x1fC:\x80\xc1\x1cd\xb7\x0fq\x10\x87ه#ڥ\xa3\xfa\xd81\xbd\x1e\x0f\x00\x83\x9e\xe0\xa8N\xf2\xd3)^N\a\xf8\x02\x0e^\xfe\n\xe0\x05\ng\x02\xe2\xaeΪ>\x9cC\x8b\xe7\x03\xc0x\x17\xb4k\x17\x03XSu)\xa9\x1c\x97\x03\b~\xae\x04\xe06\xafBʯ\x05\xe8\xe9\xaf\a\xf8\xae\xc6\x00\xdc\xd5Mv\xe3o^\xfea=\xff\xf2\xb7[\x01._\x854\xdf\tpq\xfc]0\xf1\x1e\xd5\xe2~\x00^\xf7\x01G\xfc0 \x01\xf7\xa3\x00\xe6\x01\xffC?\x1f\a\x10\x02<သ\x06\x90\xfd\xca\x15\x84\x96\xe4\x0e\xa2wy\x82\u0529\xbcA=#'\bU\xcb\x1f$\xdc+\x10\x04Q\v\x069'[((m\x14\x0e&7?\x06u%\x8e^\x8b\x06%\x89\xf1l\x10\xbaR,(\xee\xa2xP\xba\xff\\\x10\xb4|>(3Z%\x82\xf9:$\xa8]2\x98Х\x17\x822\xd3\xfdb\x10\xae\xa3T\x10ٱ\x97\x82\xb2ιtP\xc8V&\x88\xae\xbf\xccn\x94\r\xc2R\xbf\x12\xc4\xcc\xe7\xab\xfc\xad\\\x90~\xa0|\x90Y\x8f\x14\xedz\x85 m^E4\xf1ZP\xccZ\xa5 \xe6\xa7*\a\xc1\xef׃\xc9\xe3T\x83P\x87*A=\x15Gz\xf6f0\u007f\a\xf9P\x8dmV\x0f\x8a[\xab\x11\xd4\x14\xd4[A\x90\xb9f\x10\xd6\xe5m\xed\xc2;A\xac\x82\xac\x15\x14\xcf];\xc8x\xfd\xdd \x92\x02u\xd8FݠX\xc7\xf7\x82\x88Z\xea\x05i\x10\xeb\a\x89N\x1b\x80>\r\x83\x98\xd1m\x14D\xb8\x18\x84\vn\x1c\x04\x8f?\bBԛ\x04\xc1\xf8\xa6\x18ӇA\xe0\xa1fA\tR\x9akM-\x820N-\x83\".\x1f\x81\x94\xad\x82\x98\x1an\x1dD\xe8\xd3&\x88)\xa5\xb6\xac\xbe]P\xed\\\xfb \xb3x\x1d\x82\x10ӎA\x80\x96N`b\xe7\xa0hB\x97 <Sנ\xba\xffnA\xda\xcb\xee\xecS\x0fR\xa4gRDz\x05\xa9#\xbdI\x85>\x14\xbe\x8f\x83\x8cw?\xa1\xa8|\x8a\xbe\xf7\r\x12g\xf7K>\xdb?\x88\xdcPj\x90K\x1f\x06$8\"_\x0f$\xdf\a\x05\xa9\x92i\xe8\xd6gA\xa8\xe4`%\xfa\x90 T0\x1d4\x1cJQ\x1f\x062|Α\r\x0fB\xe5F\x04\xa1k\x19\xca\xc0LV=2\b\xbd\x19\x15\x14%\x1a\x1d\x84\xdad\x81\x06ِ\xf01\xa4\xc1\xd8dG\xc7Qi\xc6C\xe2'\xa8&}\x81\a\xbeTi\xfc\n\xac\xfd\x9a\x12\xfe\x8d\bط\xe8\xceD*\xc3$j\xc0w\x94\xecɔ\xb9\xefU\x82\u007fP\xb9̡\xd4\x18\xc83#$\xc9D\x890+\xed,\x10\t+\xe8iC\x93vJ\x8e\x83\xdcw\x92\xfb.\x8a\x87\x9bB\xe0Ir߫\x14\xf6\x05\xb9j\xd2ϖ\x02\xecU09\xdc\x10y\x19\x0e\x8a\a\x8a\x04%\xef\x13\x85\xa0\xc5\xd0b<(\xab}\xa6\x04\xe1j\xa7R\xd5~T\x02O\vJ \xfbSP\xd2\x15Ӄ\xe2\xe4f\xe8 g\x06\x91B\x9b\x15\x04\xbc\x9a\xcd&\xe6\x04\x01_\xe6*W\xe7\x05e\xceu>\b\xb7 H?\xb1\x90\xed,\n\n\xc8^L)X\xc2\xcbR\xb2zY\x10xiy\x10\xf6tE\x10\xc9ʕA\xa4\xbfV\xb1\xb9\xd5A\xd9\xec\xb5&(\xaee-Eb\x1d\xfb\xb3\x9e\xb7o\xa0\"l\f\nV\xd9\x14\xe4:\x1b\x8cv3eeK\x90\x9b\x99\xb7\xb2\xe9_\xc0\xfcmA\x99\a\xd9\x1e\xe4\xeb\x8a\xf1aGP\xc1\xcaoxzg\x90i\xbc]A\x02\xc9\xddAF5{\x82\xdc\xec\xb37(~\xeewv}_P\xd6B\xfd\x81\xaf\xf6\a%\xc1t \xc8\xdd'\a)\x80\x87\x82\x04Q\x87\x83L\xdc\x1c\t\x02\x1d\x1c\x05\xa1\x8f\xa9\x91>N\x19?\x01\x8e\x9ddwO\xf1r\x1a\x02\xff'%\xe6/\x10\xfbL\x90A\xc3Y\xaa\xf79\x92\xe3|\x90\v\b.\x04yD\xc5\xc5 3{\x97H\xea\xcbA\x02\x9c+A\xc6!W\x93\x83\xbe\x06\xf5\xb9N#p\x03\x14\xb8ɱ\xfdM\xaa\xffC\x95\xffW\x1e\xcc\xceN\xb9E\xb2\xdf\x0e\"\x82\xbcÎ\xdd\x05\x01\xee\xa9\xed\xbc\x1f\x04\xd0\u007f\x10䲣\x87A]\xb0\xff\x88r\xf1\x1f\x84\xf1q\x90\x88\xe8I\x100\xf0)\xb5-W(\xa1\x86\xb9Cj\xc8\xf2\x84 \nyC\"\x9b\xf9Bؽ\x11\xd2\x03\xc6C\xe4F\xc1\x10\x82\xedB!Ҥp\b\x13\x8cEB \xcd3!\x04)EC\\\x12\xf9lH0e\xb1\x10\x82D\x94υ`\xec\x9e\x0fA#J\x84\x00\xafJ\xf2\xcb\x17B\xf0\xe8/\x86\xe0\xe7J\x85$e\xf5\x926S:\xc4%\xbfe\xf4\xf3\xcb!\x02\xff\xb2\xac蕐\xfa\xa4WCԱr!d(ʇDMRB\x02j+\x84\xf4T\xd5\x10\x10\xe5k\xda\xc7J!\xe8w\xe5\x102\n\xaf\x87\x84\xfbo\x84\x80!\xab\x84 \x11UyǛ!X\x99j\xdar\xf5$\xcdj\x84 \x0eo\x85\xc0\x98\x9a!\xa6B\xdf\x0eQ*\xde\t\x89\xf5\xad\x15\u0092\xe4\xda!\xc9(\xbc\xcb\xe1\xd6\tQ\xdc\xeb\x860}\xf5\x1eiQ/D\xe7S?$\xf9\xcb\x06\xac\xbba(\x99\x16n\x04\x9e\xbc\x8fJ\x1b\x87 '\x1f\x84ԃ7\t\x89\xc5k\x1a\x92\xa9\x9a\x0fC\x00\x1b\xcdBD\x80͕|-B\xa2\u007f-C\xf0\x88\xac\xbb\x15H\xd4:$\xd1K\x9b\x10V\x89\xb5\r\x89P\xb6\v\t\x04i\x1fb\xa2\xaaC\bY\xec\x8e!\xda\xd8N!\x846\x9d9\xe8.$T\xd7\x10O\x00\xef\x16\x02\xc2\xe8\x1e\xa2\x13\xe8\x11\x02N\xe8\xc9a\xf7b\xaf{\x87\xe8\x13\xfb\x844m\x1a\xc2\v7Bb\xba?eu}C0|\xfdH\x9f\xfe|<5D\xe30\x00\x84\x18\xa8T\x1e\x14R\xb3\x9c\x16\x82#\xfc\x1f\xbd\x06\x87DO\x86\x80^\xe9!N\xd5\f\x05i\x87\x85\b\x86?\x0f\x89\x8a\x0f\a\x15F\xb0\xe1\x8c\x10483\x04\xd39\x124\x1b\x15\x12\xeb8\x1a\x94\xc9B\xdb\xd9!ڝ1!ؒ\xb1\x90\x9cq!13\xe3\xd1\xea\x04v\xfc\x8b\x10\x94\xfbK\xd6\xfdUH\xec\xd7\xd7!تo0\xe8oC\xb0P\x13\x95ғС\xefB\xb0\x05\x93\x95\x86ߓ3?\x90x9!\x18\x0f\x83*\x83Q\x87b\xc2\xc0\xccI\xc1\xb4\x90bV\xea\xb4-\x04\x1ba\x0fA\xed\x1d\xd0F'J\x17\xb4\u052dz\xeeQ\xbd\xf0\x82\xfd>ʑ_[\nPf\x82Ԉ\x10E6\fM\x8d@\xee\xa2\x14\x88\x98*I\\\xa5y\x8a\xca\xe1T\xf6\xffG\x15\xc7i*M?\x91R\xd3\xc1\xbc\x19\xffc\xde\xcc$Wg\x85\xc4\xcd\xcf\x0e\x01=\xce\xe1e./\xf3\xc0\xb8\xf9!\x9cȶ\x00\xf4\\\x18\xc2\xfcҢ\x10\xd28\x8bC\xb0\x9bKBpQK!\xfa\xcb\xc8\xd9\xe5\xb0\v+B\xe25W\x86$9\xb1\x8a\x84]\x1db\xaeaM\biõ!\xac\xda[\x17\x92\xc4\xe2\xfa\x10\xcc\xe7\x86\x10\x0f\x86٨\x94ل\x8a\u007f\x06)7\x87dc\xec\x16\xf4lk\b\x19\xe7_Bȹn\x83\xfclWN\xff\xaa\xb6b\a\xbe\xfd-$q\xc5ΐ\xf8\xd0\x11)\xbb(\xfc\xbb\xa1\xd3{B\f\x1a\xf7\xb2\x96\xdfCX\x15\xb2\x0f\xd6\xe4\x0f\x15\xc3\xfdl\xe8\x00\xc6t\x90O\x1f\xd2\xca\x0eC`\x8f\x84\x80\xa9\x8f\xf2rL\xc7x<\x84\x99\x88\x13\xfa\xf1d\b\xcb4O\x85\xb0$\xfa\xb4J֟\xb4\xf2\u007f\xf1r\x06m\x9c\rqQĹ\x10P\xd5\xf9\x10^\xbd}!\x84\xb5\x8f\x17CpZ\x97\xf8\xc0ev\xe7JH\x96\xa7\\\r1\xf9~M5\xf9zH\xd2]7\xf0\xdbMV\xf27\x1a\xf8'\x84\xf9\x82\u007fC\xe2\xe5o\xb1\xde\xdbЯ;!q\xa1wCt\xc0\xf7\xa0\xa0\xf7C\x9c\x11x\xc0\xee<\xa4\t\u007f\x04\x91\xfaO\x9bz\f\x19OMy\x12bR\xe0i\b\x93z\xb9\xc2\xd2\\\xee\xb0hO\x9e0\xba\x9a7L-ȇ\x9f\xf2\x87\xf9|\x810\xfdm\xc1\xb0.C-\x14\xa6O)\xac\xb7\x17\t3%\xf4L\x98n\xa8h\x18\xb8\xf9ٰ\x04N\xc5\xc22SP<\x8c\xc4\xf0saQ\xbd\xe7\xc3\\\xbeW\"L\xb0R\x92\xad\xbf\xa0\xed\xbd\x18\x16\xee\x97\n\x03\xa1\xbe\x14\x06^-\xcdK\x99DK؏\x11\x16\xc3]6\x8c\xdc\xc7+a\xaaݫz-\x17\xe6\xf1\x16\xe5ô|)a\x02\xb4\nan&\xa8\xc8\xe6^\xe3ӕ\xc2<\xf2\xb8r\x18\x00\xfdu^\xde\bCت\x84\x99L\xab\x1a\x16S\xfa&\u007f\xab\x16\x06\xbe\xa8\xceO5xy\x8b\x03\xac\x19֔\xfd\xdba\x1c1\x8e\xb2\x16h\\;\xcc<\xc0\xbbaaf\x1d\xedl\xdd0\xe6#\xdeSR\xd6\vÒ\xd4\xe7\xb7\rº?\xa1!\xeai\xc4o\xdf\x0fc\x06\xa1qX\x98\xfc\x01(\xda$\f\x10\xd14\f\v\xf5a\x18AD\xb3\xb0\xa0\xf4\xe6aI\xab\xb5\xe03-A\xb7\x8f\xc20\x91\xad\xc2T\xc8\xd6a\x05Nm\xd0J\xdb0T\xbd\x1d*n\x1f\xe6\x11\x86\x1d\x92\xf7t\fs\x1f\xa3\xb2\xbas\x186\xa5K\x98\x96\xaekX\xecA70\xb0;\xfa\xd7\x03-\xf6\fsr\xb8\x17[\xee\x1dV7\x88\x06?\x0ec\xd1\xc3'a\xc4j\x9fⱾ\xe1|-F\xa5\xa7\xf4\vS\xbc\xfb\x87\xe1FR\xc3\\\x1d0\x00\xf7\fDՃ\xc2\t(\x97&\xc5ga\xc8\xf5\xe00s\x8cC\xc2\f\x04љ\xa1$а0a\xe9\xe7aĀ\xc3\xc3\x04##\xd0팰؋\xcc0\xd0\xffH\b\xef(|5:,S\x15Yaj~v\x18\x01ʘ\xb0L\x10\x8e\r# \x18\x17.\xd8!uxꄄ\x13\f\xe7\xef\x961(#eBX2\x01_\x84\x81\xba\xbe\fcU)\xe5\xe6\xeb0^;\x15&`\xff\x96#\x9b\x18\x16c8)\x8cɲ\xef\xc2L\xd3O\x86\xa4|\x8f\xce\xfd\x80!\xe7\x90\xfa\x86\xb0xZ\xa3RÄg\xcd\xec\x89%\x8c\xb3R\xadh\xc4\x16֣\xc4Ì\xa2\x1ca\xf8\\g\x18^\xc1\x85\xea\xdda,\x12\xf0\xa0JoX\\\x8e/\\\xb0m\xea\xd0\xf4a\xa9)\xfe0\xb3?\x810\x02\x99`Xf\xdeB\xa4e8\x8c\x95U\x9102\x1fѰz\xadXX\xacT<,\xd1\xde\x14vwj\x98\xb6\xef\xc700\xc1\xb40\x9c\xfcOԿ\xe9a8\xc7\x19\xda\xd2̰8\xb3Y\x10\xbe\xd9aF\xd0sX\xcd\xdc0Q\xc1\xbc\xb0\xa4u\xe6S\x19\x16\x84\x19D.\f\x8b\x9bZ\x14F\x0ebq\xe2\xc1\x8cQ\xa9)K\u0089\xd0 +-ei\x18\xd6~\x99HSB\xaa\x96\xd3>\xad\b\x03\x14\xac\x84\xb1[E\x03\xb3Zub\rX\xbe\x96\x12\xb5.\f\x10\xb1\x1eҺ!\x8c\xb0}c\x18g\x01l\"\xb9\u007f\x0e\xd3/n\x0e\v|\xd8\x12\x16h\xb0\x95\xcc\xfc%\xcc9\xd9m\xa0\xf6\xf602忒Y;`\x18~c+;y\xd9\x15\x86\xa3\xda\x1df\x9edO8\u007f\xf7\xc1\x89!\xed\r\x17h:Z6;\xfd\x1e.\xd25{\x80\xbc\x959\xf1a_\xb8pۄԍ\x90\xe3\xe0\xfe\b3\x1d\xb3?,a\xf9\x81\xb0\xf8\x97\x83\xa0\xe3\xa10S\xf9\x87\x93<:\xc21\x1c\rs1\xdb1\xc8\xd6q\x15\xa7\x13a,\x8e?\tQ8\x15f\xfcs:\xcc0\xef\xcf0B\x9d\xbf\xc2\b@Π\xa9\xb3`ٹ0\x9c\xdeyh\xcc\x05ZËIkx)L\xbc{9\x8c\x05jWT\xf8\xaf\x86\x81\x80\xae\x81\f\xd7u\xc47\xd4\x14\xde\f\xf3\xe5\xfd*\xc3\xff\x84\x13\x00)u\xa0\xbcq#\\\xa0y\xc6\xd0\xc4s\xb7\u0085\xbaf\x0fK\x1b\x9d\xf8\xf7v\x18p\xf4\x8e\xea\xf7]Z\xc0{\xfc\xf6>E\xf4\x81j\xc1C\x8a\xe1#8\xa6\xff\xb4\xb5Ǡ\xc1\x930'\xa1\x9f\xea5W\x84.$w\x84\x1e/OD\x8ep\xcd\x1b\x81<\xe6\xe3%\u007f\x04g\xc5E\xf8\xee\x8d\b\x02\xaaB\x11\xac&/\x1c\xd1\x00\xadH\x84\x1e\xef\x99\b_E\x15\x81h<\xcbK\xb1\bmi\xf1\x88(\xfas\x91\x84){>\u0088\xbdDD\x84\xa6d\x04\x93X/\xe8}/F`TJE`9^\x8a\x88\xa1*\x1d)\xd4>{TFBkS\xcaDp\xb8\xddˑ\x82\xadRG\xa5&\x94\xb8l\x04\x16\xed\x15}\xfc\xd5\b\xa6)\xcaEDH\xcbGh\xd4R\"\x00\xb5\x15\"p?\x15#\x02\xc6_\x8b\x80z\x95x\xa9\x1c\xe1Z\xd3H\x9e>)oD\x18\x80T\x89\x88=\xa8\x1aA\xe8\xfafD4\xb0Z\x84\xf0\xa4z\x84\xfe\xadFD$\xf0-v\xa1&\xbb\xf6v\xa4p\xab\u052c\xd4!\x89\xbf\x94w\x942\xb5\"\x02\xa4kG$\x8f\xf6n\x04Z\\'\x82\xb5\xbeu#\u0099\xf7\"\xb4!\xf5\"bJ\xeb\xebX\x1a\xb0\xdb\r#P\xdeF\x11\xe4MI\xd5\xc6\x11\x82\xb8\x0f\xf0x\x13\x94M#\xe0\xfc\x87\x11\x9d\x9bk\xc6[\x9bG4\v\xd6\"B\x15j\x19\xd1\xe0\xf2\xa3\b\xd7'\xb7\x8a`\x99@\xeb\b^O\xd1&\x82M\x0emѕv\x11U\xaa\xf6\x111\xc3\x1d\"z\x9ax\x04\xd1T\xa7\x88\x18\x84\xceI9\xe8\x12\xc1\xc6\u052e\x11\x06\b\xdd\xf4\xda=\x02wԃ\xf5\xf6\x8c \xe8\xec\xc5\x1azGx\xfag\x1f\f\xee\xe3H\xbe\x16\xa3\x13\xbe2ѯ\xf1\t9\xfb4\x02_\xd47\xc24a\xbf\b\x04\xbd\u007f\x84\x80'5\x82\xf7r\r \x91\x06F\xe8t\aE\x105\xa4E`??\x8b\xe8Z\xcf\xc1\x11Q\xc2!\x11\xd5\xd8\xf4\xffǣ\xa1\x91\x84ꥧ'\f\xea\xb0H\x81\xf6\xd9Y\xa3\xb3S>\x8f`\xae\x11T\x1d\x11\x11?\x9c\x11A\xee!\xf3\u007f\xf7\x8eD\x85\xa3\"\xb0\xf2\xa3\xf1!+\x82\xad\x99\xd9\x11\xe2\xbe1Iҍ\x15\x99\x1f\x17\xc1\xdaS\x1d\xca\x04<\xf0ED_L\x05\x1d\xfb*\x02\xa0\xf05Z\xfd&\x02\x13\xfam\x04^~\"\x1e\x9e\xa4\xd2\xfc]D\x90\xcf䈸\xe0\xef\xc1\x96\x1f\"t\xa99\x11=`\x1c\xf7\x1bY\x87)\x02\x17h\x86\xb2Yp\xbf5\x02\x17i#A\xed\x11\xf1\xa6\x8e\b\xbd'\t\xe7\x8a\xc0\v\xba#p-\x1e\xda\x02oD\x9c\x9f/B_懵\b\xb0\x8e\xa02%\x84އUL\":\xc0hD\xfcM,I\x908y?%B\xb72\x15\xc4\xf8QUe\x9a\n\xffO\xf8v:\xd5s\x86\xea\xc7\xcc\b\x1cҬ\b\x9c\xc9\xec\b\xdc͜\b<\xdd\\4=O\x85|~\x84^aA\x84\xc6x!4uQ\x04&yq\x04\x06~I\x04F}iR*\x96E\xb0k1\"f\u007f\x85\x92re\x84~cU\x846~u\x846x\r;\xb66\"\x8eh\x1d\x05u=\xed\xe2\x06X\xba\x8d\xc9Z7\xf1Οi$6\x93\x94[h\xf4\xb6\x8ah\xfcB=\xdd\x06\x06mO*ӯj\x94w$\xd5\xf9\xb7\b\xad\xf6N\n\xfc.\x98\x94\xdd\x18\xd6\x1eX\xaa\xbd\xb4a\xbf\xd3`\xedSi\xf9C\xe9\xb9\x1f\xc6\xe7\x80ڍ\x83T\xf9CT\xf9ô0Gh\x92\x8e*\t\x8f\xb1\xabǡ\x9a'\xa8\xbd'U\xa7OQ\x8bOS\xe3\xff\xa4v\xfcE\xdd;\x03ΝU\x85<\xa7\"\u007f\x1e\x04\xcdH\xb9\x10\x11\u007fz\x11\x83\xbd\x84;/G\xe0N\xafD\x04\xf8\\\xa5\x0f\xb9\x86߯+\xf1o\x80\xb57#̌\xff\x1d\xc9\xd7!=#\xe5\x1f\xb6\xf6/\xc9{K\u007f\xbc\x1d\xe1V\xc7;\x14\xf1\xbb\x11b\xe0{\x11\xb8\xdb\xfbp'\x0f\"@<\x0f\xd1\xc6#\xf2\xee?\xb2\xe7\xb1R\xeb\tk}\n\xcd\xcc\x15\xc5\xc2\xd8\xdc\xd1\xfc\xbd\xa57y\xa2 E^^\xf2EE{\xf2G\xe9J\vD\xa9\xfc\x05\xa3h\xbeP\x14\xa3)\x1c\x95%\xc6E\xa2\x1aa>\x13%k\x8aF\xd9\xe7g\xa3h\xbbXT\x8e\x81(\x1e\x95\x9d\x93\xcfE\x91Lz>*\x99\xa5\x12Q\xcap\xc9(\f\xcc\vQ\xbcx#\n\aY\x8aϾ\x14\x15J\x96\x8eRD\xcaD1ڗ\xa3\xe2\xb3\xcaFI\x82W\xa2x\xe7FT\xccz\xb9(\x81`yޘ\x12Ed_!*(\xb9b\x14f㵨(C\xa5\xa8n\b\xac\x1c\xc5i8Q\u074b\x11\xa5\x1f\xac\x82\x81U\x8d\"\x19\xf8&n\xa9\x16M\x98\xdc\xf4\xc1\xe9)գ\\\x84P#\xca$\xd4[Qq\xc95\xa3bCގ\"\x92\u007f'*9\xe9Z\xecDm\xd2\xea\xdd(\x97EՉ҆ԍ\xc2AFah\xebE\xe1\xe2\xeaG\x11L5\x88\x8a(5\x8c2\x8am\x14\x05\xd4~?*\xb6\xbbq\x14ǹ|\x00\n4\xe1\xedM\xb5\xc6\x0f\xa3\xc8&4\x8b\x12\xfc5g\xf3-\xf8x\xcbh\xa1D\xc87H\x80\xf4Gф\xa1\x1b\x96\x9e\xd2*1<ِ\x11\xe5\xce\xf26dM[\xf4\xab\x1d\xc6\xdc^\xb9߁<\xe9\x18\x15I\xee\x84\xf1v\x8e2.\xee\x82\x1b\xbbF\xc5\xfcv\x8b\xc2\xfeu\xe7\xa5GT\xccEϨhY\xaf(LYo0\xa2OTR\xfc\x1fGix>\x89\n\x90\xff4\x9a0\x18}\xa5\xe8\x17\xd5m\xfe\xfd\xa3\"өhm@\x94\xd6i`\x14@vP\xb4P\xeba\xa9\xa3\xb2\a\xa7\xa6\xa4E\x13QO\x02Mf\xa7|\x16\x15\xe708J\x971$\x8a8'\x1d254*qͰ(\xe7n>\x8f2c1<\nu\x19\x11%\xe6Ɉb\x15^f\x94\xba9\x12Ս\x8ab\xa5\xfd\xe8\xa8\xee\xe6\xc7\x00\xb21\x801\x90\x91\xb1*\x85\xe3\xa2b\xb0\xc6C\\'D\xf16\u007f\x95\x8f/\xa3\\\xa8\xf9\x95~\xfe:\n\xeb\xfcMT]\xf8\xb7xr\xa2\x92c\x12x\xff\x1d\xca\xc9\xfa\xdd\xf7\x90\xf0\x1f8\xf6\x9c(1\xbd\x01\x8f\x19\xa3\f\x06LQ\xfa\x1c3:h\x812X\xa3\x05Z\x8f\xceN@I[\xb4h\xdb\xf4a\xd9\xe9Y\xa9\x83\xe4\x14\x17;8\xec \x81\x9cQĈ\xae(2\x02\xee(a\x8b'\n@\xec\x05\xdd|Q\xd8q?\x18\x15\x00W\x82\xf8?$\xfc\nG\xe1Q#Q伢\xa0wL{\x15\a\xa1\xa6P\x01\xa6F\xb1-Q\xe95-\xca\\\xe4OQ̆O\x8f\"\xd31\x03\xb5\xcfT\r\x9b\x15E\xe2~vT֝\xce\xc1\xc8\xe6F\vu\x1b\x9d=XN\xc1\x9c\x17\xe5Y\n\xf3\xd5\xea,\x80b/\xd4g\x17i;\x8b\xa3\x9cIZ\x12\xe5*\xf8\xa5Q\x18\xc0e\xe8\xcc\xf2(6\"\xac\x88r\x12~e\x14\x10}U\x14xwu\x14\xa8z\r\xa8\xb5\x16\x95\xafS1X\x1f\xe5ތ\rQ\xe4\x066\x82?\x9bP\xfe\x1c\x15/\xbb9\n_\xb5\x85#ߊ*~\x81ll\x8br\xfd\xc6\xf6(N\x17\xfd\x15\x84܁\xf27<\xba\x134\xdb\x15\x15,\xbf[5{O\x14\xd1\xe5^}\xf6\xf7(w\f\xecC\x8d\u007fD\x15\a\xef\x8f\"\xb8=\x10\x15\az\x90=8\x04A:\f\v|\x84<>J\xbbp,\xca<\xedq5y'\xa2\xc8מ\x84֞\x8a&\xf3ڧ\xa3ܼ\xfb'\xf4\xfc/h\xe3\x19z\x88\xb3Q\xf8\xe5sQ:\xf4\xf3Q\x99T\xb8\xa0]\xbe\x88\x86/E1\x15p\x19\x95^Q\xd6\\\x8d\n\xba\xbe\x16U@p=\n\x18}C\x1f\xbc\xa9\xfd\xfa\x9b\xb4\xfb'\n\xa4\xf6o\x14\xbe\xf4V\x94\xc0\xeb\xb6^\xef\x80Xw\xa3X\x9c\u007f/\n\xa7}\x1f=}\xa0\x8d=\x84\x1a?\x8a\xf2\xf4\xa1\xff\xf4\xb9\xc7Q\xc0\x84'\xe8\xe4Sx\xba\\1\xe8C\xee\x18\xcce\x9e\x98hWޘ\xfc\x9e/&\xec\xcb\x1f\x03u\vĤ\xf6\x821\x82\x80B1\xd1\xf4\xc21z\x8f\"1\xa9\xe8\x99\x18\x13\x96Ec\x00\x0f\xcf\xc6d\xd9|\xb1\x18\xbbS<\xc6p\xf9\xb9\x98$\xf2\x9f\x8fa\x8fc\t\xd4Y2\x86\x15h/\xc4\xe0a_\x8cI\xbfK\xc5DL_\x8aq\xf7@\xe9X\x92+e\xf8\xe0\xcbZk\xd9\x18\xb1\xc8+1\xd1\xfbWc\"\x16\xe5b4\xeb\xe5c\xc4')1P\xb0\x02\x06S1F\xedx-FTQ)\xc6h1&r\xf2zL\f\xdb\x1b1\xaaW\x15\xf6\xa7j\x8c\x00\xe0͘(B\xb5\x18\x8dPu\xf4\xb2\x06\x1ex+F\xdf[S\xa9\xf1v\x8c\xde\xfd\x9d\x18\xe4\xad\x16\xfaV[\x1b~7\x06\x06ԉ\xc1\xb1ԍ\x89\xe8\xbc\xc7\x1b\xeb\xc5ē֏\xc1\x936\x88\xc1\xa75\x8c\xd1y6\x8aѷ\xbd\x1f\x13\xff\xd7X\x87\xf8A\x8c\x9e\xb2IL\xa4\xb3iL|ч B\xb3\x18\xbdT\xf3\x98ؕ\x16\xb1\x84\xbdj\tb\u007f\x14\xa3 \xb4\x8a\x89\xe6\xb5ƃmb\xb0\xf5mc\xb4\x81\xedbb\xfc\xda\xc7`\xad;\xc4\xe0\x1c:\xc6\xe8::\xc5\xe83:\xc7h\xe8\xba\xc4h~\xbb\xea\xf0\xba\xc5DĻ\xa3\xd5\x1e\xe0aOi\xbb\x17\x88\xd7;\x06{\xda'&\xf6\xe2\xe3\x18\f\xdf'1\xb1q\x9f\xc6\xc4\x02\xf4\x8dAu\xfb\xc5h\xb1\xfaǸU\x1f\x8c\x1b\x80;\x06\xc6\xf4\xd5\xfd\xa8:\rR\xfa\x99\xca\xc2`\xca\xe9\x90\x18\xd5(]\xafCcT\xafa\x14\x83\xcfA\x85\xe1`߈\x18Md\x86\nu\xa6\xd64\x92\x02<JEv\xb4\nY\xd6\xff\xa40\x1b\x8f\x8f\x89a\x89\xcaXe\xf78\xed\xdbx\xa5\xf0\x84\x18Ι\xf8B\xbf\xfeR\xaf_\xc5x\x868\u007f\xfd\x065}\x1b\x03B\x9b\x18\x93\x93\xbf'a\xbc\xdfň\xeb'\xe3\xbb\xef\xf5\xd3\x0f1\xc0\xa5\x9c\x18P\x85\x81\x9f\x8cZ\xb3\t\ngFi\x01c\xad\xa4\xa0-F\xb3i\xe7c\x8e\x18\xa0\xbe\x13\x14uA\xdf\xdd膇$\xf2\xf26_\x8cN\xd8\x0f\x81\n\xc44\xd6\v\xb2\xff\xa1\x18@S\x18\xadEpK4\x86E\a\xb1\x98f#\xe2lg\x8a\xd63\x15\xe3\xfaQ\xa95\x8d\xd5\xfc\x84\xe1M\x8f\xc1\x8e\xcd\xe0e&d|V\x8cG\xe2̎\x89c\x9d\x13㮛\xb9z\x9d\x87o\xe7\xc70\xf9\xb4\x00\x1a\xb6\x10\xe5\xa2\x18p\xe2b\xfc\xbeDY\xb14\x06\x04\xb1\fw,\xd7*V\xc4\x00\x00Vƈ\xd9W\xe1\x89ոe\x8d\u07b26&\xceh]LR\xf2\xebQn\x88!׳\x11?l\x8a!\xf8\xfc9\x96\xaf\x83\x04\x821\xc4\x1d[bj\u07b7&\xff\xf9\x85r\xb2-\xa6\xc7\xc1n\x8fћ\xfd\x1a\xc3\xdc\xe7\x0eU\xf1\xdfb\x02\x18w\xc6\x14\x05\xeeүw\xd3<\xef\x01\x89\xf7\xc6\x18\xc4\xfe\x1e\x83Gۗ\xe8\x8d\xec\xc3\xe0e?\xd4\xe1\x80j\xe8\xc1\x18B\x80C\xa8\xf5p\x8cn\xe0\b\x06q\x14\xe51\xbd\xf1x\f;\xb5N\xc4\x00\tNR\x14OŸX\xf84\xea\xfc3\x06|\xf0\x17yv\x064:K\xfd=\xc7\xef\xce+\x93/@\xbd.\xa2\xb3\x97b\xdc\x0fx9&S\xa0Wb\x98\xa4\xbe\x1a\x83\xef\xbc\x06\x1bs\x9d\x0f߈a)\xc2M|\xf7\xb7\xda\xdb\u007fح\u007f\xf9\xd8-\xf4\xe36ۼá\xdd\xe5\xd3\xf7P\xfd}H\xf0\x03Z҇d\xc5#\xb0\xf4?\x94\x8fc܉\xcf\xcbS5W\xb9\xe2\"~\xb9\xe32\xa0<q\n\\\u07b8\xec+\xc9\x17\x87n口\xc2\x02q.\xda)\x18\x17\x88Q(\x8e \xbbp\x1c6\xbcH\\|\xfc3q\xd6XTky\x96?\x16\x8bs\xed_\xf1\xb8\xe8\xc9sq\x1c\xee\xf9\xbc~Y\".\x86\xb0d\\l\xe3\v(_\x8cӽ\x94\x8a\xf3\xd4\xf08\x16\xec\x94ֺ\xcb\xc4\xc5;\x1c\xd7<D\xd98\xc0\xd1+q\x1c]\xa3\xf7\x94\x8b\x13ҕ\x8f3\xe7\x99\x12\x87\xf8T\xe0\xa5\"\xeb}-\x8etI\xa58B\xcd\xcaqI?\xbd\x1e'\xfc\u007f\x83\x1d\xaf\x12gR\xa8*h\xf3f\\1{\xb58\xfce\xf58\xa4\xa4\x06?\xbd\x15\xe7\x9cA\u0378\x18\x9d\xb7\xe3\x94\xd1w\xe2\xba/?\x8e\xe4v\xed\xb8\xc0\xd8w\xe3\\V\x13\x17\xf8R7.>轸Hh\xbd8U\xb5>oh\x10\a&h\b\xda6\x8a\xc3/\xbc\x1fg\xa64\x0e\xec\xf9\x01\x1ak\x82\xb2i\x1c9\xab\x0fQS\xb3\xb8\x98\x8f\xe6q$\xc9Z\xc4\xe1F[\xc6\xe9R>ⷭ\xe2\x9crm\x1d\xe72\xc26 a\xdb8\x97.\xb7\x8b\x8b\xa1j\x0f\xe6t\xc0\xff\x1dQv\xc2]\x9d\xf1\u007f\x978\x14\xb0k\x9c\x96\xb5\x9b^\xbb\xc7\xc5/\xf5\x88\v,\xe8\x19\xc7\x01\xaf\xbd\xe2X\xda\xd0;\x0eS\xd5'\x0e\xb3\xff1\t\xf7\t\xda\xf8\x94u\xf5U\xba\xf5\x03\xa1\xfaǙ K\x8d\xd3^\x0e\xd0\xeb\xc08\xd4tP\x9c\xd83\x8d\xb5\u007fƶ\x06ǹ\x11?\x0e;\x9eN\xb2\r\x8d\xf3@\xb8aq8\xf4\xcf\xe3p\x80\xacfD\\\xd4*#.\x9e \x93]\x1b\x19\xe7;\xfa\xc1\xf7\xd1q\x98\xb6,eNv\\`Ҙx£\x8f\x8d\xcbK\xb6\xc7\xe1\xf9\xf1\xda\xc2\x04>\xfaE\x9c\xb6\xe3K\xb6\xf1U\x1c\xe6\xefk\x10\xe5\x1b\x8e\xf5[\xa5\xd7D\xd0k\x12{\xff\x1d\x06>Y\a\xfa=\t\xf6\x83\xd2!\a\xa42\xf0N#\xc6`\xd2f\xcd\xe8\xaa\x05\x1d\xb2Ɖ\x18mq\xaeڰ\xc7u\v\xa2~vR\xbc\\z\x9b[\xaf\x1e\xbd\xcd\x1b\xc7\xd6\x1a_\\\xd2o~\xedI\x00\x9f\x82zkHo\r\xf3\xd6H\x1c\xe9\xd5(e3F\xcb\x10\xe7\x97S\xe2\x00\xabS\xe3\xdc$\xf4#\x06;-\x8e\x18\xe2'2n:F2#\x9e7\xe1\x8af\xa2\x9c\x85r6\xca9(碜\x87r>\xca\x05(\x17\xa2\\\x84r1\xca%(\x97\xa2\\\x86r9\xca\x15(W\xa2\\\x85r5\xca5(ע\\\x87r=\xca\r(7\xa2܄\xf2g\x94\x9bQnA\xb9\x15\xe5/(\xb7\xa1\u070e\xf2W\x94;P\xfe\x86r'\xca](w\xa3܃r/\xca\xdfQ\xeeC\xf9\a\xca\xfd(\x0f\xa0<\x88\xf2\x10\xca\xc3(\x8f\xa0<\x8a\xf2\x18\xca\xe3(O\xa0<\x89\xf2\x14\xca\xd3(\xffD\xf9\x17\xca3(Ϣ<\x87\xf2<\xca\v(/\xa2\xbc\x84\xf22\xca+(\xaf\xa2\xbc\x86\xf2:\xca\x1b(o\xa2\xfc\x1b\xe5?(\xffEy\v\xe5m\x94wP\xdeEy\x0f\xe5}\x94\x0fP>D\xf9\b\xe5\u007f(\x1f\xa3|\x822ה<\xe9Y\xb9\x13Ÿ<Sr\xa7\xe7M\xfc\x93\x99oJ\xde\xf4\xb4\xac\xfcR\x8e+\x90\xf8\"\xad\xa0\xfc\x9bYhJ\x9e\u052c\u0089b\\\x91)\xb9S\x9fI\xfc\x93YtJ\xde\xec\x8cq\xcfNɓ\x9dQL\xfe\xcd,>%OF\xd6s\x89b\xdc\xf3Srg\x94H\xfc\x93YrJ\x9e\xb4q/Lɝ\xf6\xe2\x94<c\xb3KM\xc9; =\xeb%)Ǖ\x9e\x92g@z\x19\xf97\xf3\xe5)\xf9\x06$\xda,\x8b˸W仴W\xf1!\xb3\\\xe2CjVy)ǥ$\x9eH\xad \xfffVL\xfc\x9ah\xfb\xb5ć\xec\x8cJ\xf8\x90Y9\xf1!#\xebu)ǽ\x91\xb85\xa3\x8a\xfc\x9bY5Q\xa6\x8d{3\xf1EZ5\xf97\xb3\xba<\x94UC\xcaqo%\xbeή)\xfff\xbe-\xb5\x8c\x1a\xf7\x8e|\x18U+Q\x8eϪ-\xe5\xb8w\x13\xf7\x8c\xaf#\xfff\xd6M\xdc3~Ը\xf7\xe4èzS\xf2f\xa6g\u0557r\\\x83)y2\xd3\x1bʿ\x99\x8d\xa6\xe4\xcbL\x8c\xe2}\xf9\x90\xd6\x18\x1f2?H|H\xcdj\"带\x89[S?\x94\u007f3\x9b%~M\x8c\xa2y\xe2CvF\v|\xc8l\x99\xf8\x90\x91\xf5\x91\x94\xe3Z%n\xcdh-\xfff\xb6\x91{\xb2\xdaJ9\xae]\xe2\xeb\xec\xf6\xf2of\ayhԸ\x8e\xf2aT\xa7D9>\xab\xb3\x94\xe3\xba$\xee\x19\xdfU\xfe\xcd언'\xd1\xe9\xee\xf2aT\x8f\xc4\b\x12,\xe8\x89˸^\x89\x81\fH\xef\x8d\x0f\x99}\xa6\xe4\x1f l\xf8?\x9a\xce:\xc0\x8d\x9b\x89\xe2\xfd\x0e\x9223333\xb7i\x03\xc5\x14\x92\xa2\xe5\xddH^/(\x1e9\xb7N\x99\x99\x99sP\x0esRfffffn?\xcd\x1b\xdd?\xf3{\xef͊\xbc\xb6\xef\xec&\xcd\x11\xc2\xf2H\xc4\xf1Qb\xed\xd1l+\xee\x18\xa0<\x96GV*0V\xf1%\xfe U\xb6\xcd\"\x12kc\xb6\x85\x1b\x05\x94\x9aG\x14\x06\xc6\xd6\x18q\x99p\x16\xd7al\x8a\xd1.\x03ʜ[\xcd\x02\xc6Z\xcc\xd8(G\xc36\x1a\x8c\x96#\xa0t|e\xab\tcnj\xeb\xc8\xfd\xf9\xba\x80\xb2\x1c\xd7\xeeт\xb1c\xc7u\xe6|\xae\xe3`\xe3\xe3\xc5\xda\x13\xd8V܉@y\x12\x8f\xa8\x9c\fcOa\x14\xeeT\xa0<\x8d[\xc5\xe90\xf6\fFӝ\t\x94gq\xaby6\x8c=\x87'\xf6\x9b=\x17\xb6q\x1e\xa3\xe5\xce\a\xca\v\xf8\xcaօ0\xf6\"\xbe\xd2ߚ\x8ba\x1b\x97\x8c\xeb0Y\xcd]\n\x94\x97\x8dk\xf7\xb8\x1c\xc6^1\xae\xd3#.\xaf\x84\x8d\xaf\x12k\xaff[q\xd7\x00\xe5\xb5<\xa2r\x1d\x8c\xbd\x9e/\xf1\xf7\xe4\x06\xb6\xcd\xe2F\xb1\xf6&\xb6\x85\x1b\a\x94\xdd<\xa2聱\xbd\xb8\xd2\xf5\x01\xe5\xcd\xdcj\xde\x02co\xc5\xe8Fy\x1bl\xe3vF\xab\xbc\x83/i\xdd\tc\xc7\xf3%\xfe,\x13`\x1b\x13ǵ\xfb\xa3L\xe2ZN\x1eזզ\xb0\xb4S\xc7u\xf01\xa6\xb1\x89\xa7\xc3\xd8\x19\xdeT\xdcL\xae\xe5,\u007fie6K;\xc7w\x9b\x85\x9b\v\x94w\xf9\xacY\xdc\rc\xef\xf1\xa6p\xf7r-\xef\xf3#\x8a\xfbY\xda\a|\x8d\xcb\a}\x10?ė\xbb\x87\xb9\x96\x8f\xf8\xa0\xf9(K\xfb\x18\x8fo\x94\x8f\xb3i<\xe1k\xcb=ɵ|\xca_\xd3z\x9a\xa5}f\\\xfb\xa8\x9a{\x96k\xf9ܸ\xb6Q\xb5\xe7Y\xda\x17|\xad\xb8\x17\xb9\x96/\xf9\xb8\xf22K\xfb\x8a\xafE\xf9\xaa\x0f\x8a\xd7X\xda\xd7}m\xba7\xb8\x96o\xfa\xb8\xf9\x16K\xfb\xf6\xb8\x8eQ~\xe5w\xd84\xde\xf5\xb5\xe5\xde\xe3Z\xbe\xef\xafi}\xc0\xd2~8\xae}L\xcd}ĵ\xfcx\\ۘ\xda',\xed\xa7\xe3:\xc6\xf8\x97\xe5g@\xf99g\xf1\x170\xf6Ko*\xee+\xae\xe5\xd7~D\xe5\x1b\x96\xf6[_\v\xf7\x1d\xd7\xf2{\x1f\x17?\xb0\xb4?\xfa\x1a\x97?q\xb5?\xfb\xdat\xbfp-\u007f\xf5\x974\u007fci\u007f\xf7\xf3\xfam\xfe\xc1\xa6\xf1\xa7\xaf-\xf7\x17\xd7\xf2o\u007fM\xeb\x1f\x96\xf6_\u007f\x8d\xbf\xd1\xff\xb1i\xcc\xd3\xdd\x1e\xf9\x9f \\˶\ueda8\xd6\xce\xd2vtwD~\xb3\x9dl\xe2\x010v\xa07\x157/\xd7r>\u007fie~\x96v\x01\xdf\xf57xAo\x9a\xc5B\xbe\x16na\xae\xe5\"\xfe\x9abQ\x96v1_\xe3rq\x1f\xc4K\xb0\xb4K\xf2\xd5n)\xae\xe5\xd2>n.\xc3\xd2.\xcbs5\xca\xe5\xd84\x96\xefnw5\xb7\x02\xd7r\xc5\xee6W[\x89\xa5]\xb9\xbb\xc3\xf9\xad\xad\xc2\xc6\xff\xe2\xc4Ʈ\xe6Mŭε\\\xc3_ZY\x93\xa5]\xcbw\xfdSpm\xa0\\\xc7g\xcdb]\x18\xbb\x9e7\x85[\x9fk\xb9\x81\x1fQl\xc8\xd2n\xe4k\\n\xec\x83x\x13\x96vS\x1e\xe46\xe3Zn\xee\xe3\xe6\x16,\xed\x96<K\xa3܊Mck\xbfk\xff n\x03\x94\xdb\xfa\xcdG\xb5\xed`\xec\xf6ݝ\x11?\x90;\xc0\xc6;\x8a\xb5;\xb1\xad\xb8\x9d\x81r\x17\x1eQ\xd9\x15\xc6\xeeƗ\xf8\xdd\xeeζY\xec!\xd6\xeeɶp{\x01\xe5\xde<\xa2\x18\x04c\xf7a\xc4徜Ńa\xec\x10\x8cvC\x81r\x18\xb7\x9a\xfb\xc1\xd8\xfd1c\xa3<\x00\xb6q`wG\xee7\u007f\x10P\x1e\xdc\xdd\xee1\x1c\xc6\x1e\xd2ݙ\xf3\xe6\x0f\x85\x8d\x0fcT\xdc\xe1@9\x82\xaf\xac\x8c\x84\xb1G0\nw$P\x1eŭ\xe2h\x18{\f#.\x8f\xe5,\xae\xc0X\xc5h\xba*PF\xdcj\xc60v\x14\xaf\xe9w\xa7a\x1b\xa6\xbb\xc3\xe45W\x03ʤ\xbbݣ\x0ec\xd3\xeeN\x8f\xd8e\xc22G\x1c\x17b\xade[q\xa3\x81\xb2\xc1#+\x04c\x1d_\xe2\x1f\xe2&\xdbf1\x86Q\xb8.\xa0,\x01\xdbb\xc4\xe5X\x1e\x17\x1f\ac\x8f\xc7\xf5\xee\x04\xbfߚ;\x91kyRw[^;\x99\xa5=\xc5\xef\xd8o\xe3T6\xf1i0\xf6to*\xe5\x19\xfe\xa2ʙ,\xedY>\xf7+\x9f\xedM\xb38\aƞ\xebM\xe1\xce\xe3Z\x9e\xef/-.`i/\xf45./\xf2A|1K{\t\x0fr\x97r-/\xf3q\xf3r\x96\xf6\n\x9e\xa5Q^ɦq\x95\xdfbZsW\x03\xe55~\xf7i\xedZ\x18{\x9d?u\xea7x=l|\x83X{#ۊ\xbb\t(\xc7\xf1\x88J7\x8c\xed\xe1K\xfcn{\xd96\x8b>\xb1\xf6f\xb6Ey\v_Z\xdc\ncoc\xc4\xe5\xed\x9c\xc5w\xc0\xd8;1̍\a\xca\t\xdcjN\x84\xb1\x930U\xa3\x9c\fۘ\xc2h\xb9\xa9@9\x8d\xaflM\x87\xb13\xf8J\xffn5\x13\xb61\xab\xbb\xdd\x1fo6\xd7rNw[Z\x9b\xcb\xd2\xde\xd5\xdd\xe1\xcf\xe2\xee\x06\xca{8\x8b\uf171\xf7ySq\xf7s-\x1f\xf0#*\x0f\xb2\xb4\x0f\xf9\xae\u007fkx\x18(\x1f\xf1Y\xb3x\x14\xc6>\xe6M\xe1\x1e\xe7Z>\xe1G\x14O\xb2\xb4O\xf9\x1a\x97O\xfb ~\x86\xa5}\x96\a\xb9縖\xcf\xfb\xb8\xf9\x02K\xfb\"\xcf\xd2(_b\xd3x\xd9ז{\x85k\xf9\xaa\xbf\xa6\xf5\x1aK\xfb\xba\xbf\xc6\x1f\xea\r6\x8d7\xbb\xdbuͽŵ|\xbb\xbbM\xd7\xdeai\xdf\xed\xee\xd0\xfeL\xef\x01\xe5\xfb\x9c\xc5\x1f\xc0\xd8\x0f\xbd\xa9\xb8\x8f\xb8\x96\x1f\xfb\x11\x95OX\xdaO}ן\xe93\xa0\xfc\xdcg\xcd\xe2\v\x18\xfb\xa57\x85\xfb\x8ak\xf9\xb5\x1fQ|\xc3\xd2~\xebk\xec\xbe\xe3Z~\xef\xe3\xf8\a\x96\xf6G\x1e\xea~\xe2Z\xfe\xec\xe3\xe6/,\xed\xaf<W\xa3\xfc\x8dM\xe3\xf7\xee\xf6z\xcd\xfd\xc1\xb5\xfc\xb3\xbb\xad^\xfb\x8b\xa5\xfd\xbb\xbb\xa3\xee\xb7\xfb\x0f\x9b\xf8_\x18\xfb\x9f7\x157O\x8f\xaf\xe5\xffz\xda\xea\x956\x96\xb6\xbd\xa7\xa3\xee\xf7\xd9\xe1M\xb3脱\x03\xbc)\xdc@\xae\xe5\xbc\xfe\xd2b>\x96v~_c\xb7\x00\xd7rA\x1f\xc7\v\xb1\xb4\v\xf3P\xb7\b\xd7rQ\x1f7\x17ci\x17\xe7\xb9\x1a\xe5\x12l\x1aK\xf6th\xff\xf0.\x05\x94K\xf7\xb4{,\xd3ө\xf9A]\x16a\xbc\x9cX\xbb<ۊ[\x01(W\xe4K++\xc1ؕ\xf9\x12\xffخ\",W\xe5\xb8Y\xac&֮ζpk\x00\xe5\x9a<\xb2X\vƮ͈\xdd:@\xb9.\xb7\xe2\xf5`\xec\xfa\x98\xc4m\x00\x94\x1br\xab\xb9\x11\x8c\xdd\x18\x137\xcaM`\x1b\x9b\xf6tf\xbc\xe1\xcdz:\x98\x9b3*n\v\xa0ܲ\xa7\xddc+\x18\xbb5_\xe97\xb8\r\xdbf\xb1\xadX\xbb\x1d\xdb\xc2m\x0f\x94;\xf0\x88bG\x18\xbb\x13#.w\xe6,\xde\x05\xc6\xee\x8a\xd1n7\xa0ܝ[\xcd=`잘\xb1Q\xee\x05\xdbػ\xa7Ô57\b(\xf7\xe9i\xf7\xd8\x17\xc6\x0e\xee\xe9\xf4\x88\xdd\x10a9\x14q<L\xacݏm\xc5\xed\x0f\x94\a\xf0\xc8ʁ0\xf6 \xbe\xc4?\xda\a\v\xcb\xe1\x1c7\x8bC\xc4\xdaC\xd9\x16\xee0\xa0<\x9cG\x16#`\xecHF\\\x1e\xc1Y|$\x8c=\xaa\xa73\xe7\a\xef\xe8\x9e\x0e\xe61b\xed\xb1l+\xae\x02\x94\xaa\xa7ݣ\nc#\xbeį\x1f\v\xcbQ\x1c7\v\xcd(\x9c\x01\xca\x1a\x8f(\x12\x18[g\xc4e\xcaY\x9c\xc1\xd8\xdco\xa2\xe6\n\xbf\t\xbf\xb8e\x13\x8f\xf6\xb5\xe2\x1a\\K\xeai\xf3\x9a\xa5m\xfak\xfcrc\x80\xb2\xcbg\x1e0\xb6\xe5M\xe1\xc6r-\x8f\xf3#\x8a\xe3Y\xda\x13|\x8d\xcb\x13}\x10\x9f\xc4Ҟ\xdc\xd3\xdeUq\xa7p-O\xedi몜\xc6Ҟ\xde\xd3\xd1\xe5\xe7:Ûfq&\x8c=\xcb\x1b\xff#\xc8_T\x9c\xc3Ҟ\xebk\\\x9e\xe7\x83\xf8|\x96\xf6\x82\x9e\xf6\xb15w!\xd7\U000a27b6\xb1\xb5\x8bY\xdaKz:\xc6\xfa\xa3\\\xca&\xbe\f\xc6^\xeeM\xc5]\xc1\xb5\xbc\xd2_Z\xb9\x8a\xa5\xbd\xdaw\xfd\xba\xd7x\xd3,\xae\x85\xb1\xd7yS\xb8빖7\xf8K\x8b\x1bYڛ|\x8d\xcbq>\x88\xbbY\xda\x1e\x1e\xe4z\xb9\x96}>n\xde\xcc\xd2\xde³4\xca[\xd94n\xf3\xb5\xe5n\xe7Z\xde\xe1\xafi\xdd\xc9Ҏ\xf7\xd7\xf0g\x186\x8d\x89=\xedU\xff\x11\x86k9\xb9\xa7\xadZ\x9b\xc2\xd2N\xed\xe9\xa8\xfag\xe54\xa0\x9c\xceY<\x03\xc6\xce\xf4\xa6\xe2fq-g\xfb\x11\x959,\xed\\\xdf\xe5\x8f0\xde\xf8\x8f00\xf6\x1eo\xfcG\x18\xae\xe5}\xfe\xd2\xe2~\x96\xf6\x01_\xfdG\x18\x1f\xc4\x0f\xb1\xb4\x0f\xf3 \xf7\b\xd7\xf2Q\x1f7\x1fci\x1f\xe7Y\x1a\xe5\x13l\x1aO\xfa\xdarOq-\x9f\xf6״\x9eai\x9f\xf5\xd7\xf8\xc3<Ǧ\xf1\xbc?\x99\xbf'/\x00\xe5\x8b\xfe\x80ck/\xc1ؗ{:=b\xf7\x8a\xb0|\x15q\xfc\x9aX\xfb:ۊ{\x03(\xdf䑕\xb7`\xecی\xa2|\x87\xb3\xe2]\x18\xfb\x1e\xc3\xff\xbc\xe1,\xfe\x00\xc6~\xc8h\x96\x1fq\xd6\xfc\x18\xc6~\xc2\xd3\xfb#|\n\xdb\xf8\x8c\xd1r\x9f\x03\xe5\x17|e\xebK\x18\xfb\x15_\xe9\x0f\xf25l\xe3\x1b\xff\xea\xf0'\xf9\x16(\xbf\U000ef631\xb5\xefa\xec\x0f\xfe\xf5\xc6'\xf8\x116\xfeI\xac\xfd\x99m\xc5\xfd\x02\x94\xbf\xf2\x88\xcao0\xf6w\xbe\xc4ߛ?\xd86\x8b?\x19E\xf9\x17`\xfff\xf8\x9fE< \xfe\x17W\x94\xff\xb1i\xce\xd3\xcb\xc6\xfe\xaf\x97G7\xca6\xd8F;\xa3\xe5:\x80\xb2\xb3\xd7_\xd9\x1a\x00c\a\xf2\x95\xfe\f\xf3\xc26\xe6\xebm\xa7\x9a\x9b\x9fk\xb9@o\x1b\xd5\x16di\x17\xea\xed \xbf\xfd\x85\xd9ċ\xc0\xd8E\xbd\xa9\xb8Ÿ\x96\x8b\xfbK+K\xb0\xb4K\xfa\xae\xdf\xf7R\xde4\x8b\xa5a\xec2\xde\x14nY\xae\xe5r\xfe\xd2by\x96v\x05_\xe3rE\x1f\xc4+\xb1\xb4+\xf3 \xb7\n\xd7rU\x1f7WciW\xe7Y\x1a\xe5\x1al\x1ak\xfa\xdarkq-\xd7\xf6״\xd6ai\xd7\xf5\xd7\xf8c\xacǦ\xb1\xbe7\xfe\x18\x1b\x00\xe5\x86>\xa3\xdaF0v\xe3\xdeN\xe2\xa3l\x02\x1bo*\xd6nƶ\xe26\a\xca-xDeK\x18\xbb\x15\xa3p[\x03\xe56\xdc*\xb6\x85\xb1\xdb1\xe2r{\xce\xe2\x1d`쎌\xa6\xdb\t(w\xe6Vs\x17\x18\xbb+\xa3\xe5v\x03\xcaݹ\xd5\xda\x03\xc6\xee\xc9\xfb\xf0\xfb\xdf\v\xb6\xb1wo\xc7X\xff\x1e:\b(\xf7\xe9m\xf7\xd8\x17\xc6\x0e\xee\xed\x1c\xcb\xef\xa2C\xd86\x8b\xa1b\xed0\xb6\x85\xdb\x0f(\xf7\xe7\x11\xc5\x010\xf6@F\xec\x0e\x02ʃ\xb9\x15\x0f\x87\xb1\x87`\x12w(P\x1eƭ\xe6\xe10v\x04&n\x94#a\x1bG0Z\xeeH\xa0<\x8a\xafl\x1d\rc\x8f\xe1+\xfdޏ\x85mTz;\xaa~\xef\n(\xab\xbd\xed\x1e\x11\x8c\x8d{;\xab\xfc\xf3`\x94\xb0\xd4\x1c7\v#\xd6\xd6\xd8\x16.\x01\xca:\x8f,R\x18\x9b1b\x97\x03e\xc1\xad\xd8\xc2\xd8ј\xa4lp\xd6$\x18\xeb0c\xa3l\xc26\xc60Z\xae\v(K\xbe\xb2Ղ\xb1c\xf9J\xbf\xf9\xe3`\x1b\xc7\xf7v4\x1a\x95\xf2\x84\xdev\x8f\x13{;\x1b\r\xbf͓8l\x16'3\nw\nP\x9eʗ\x14\xa7\xc1\xd8\xd3\x19\xb1;\x03(\xcf\xe4V|\x16\x8c=\x1b\x83\xdd9@y.\xb7\x9a\xe7\xc1\xd8\xf31\u007f\xa3\xbc\x00\xb6q!\xa3\xe5.\x02ʋ\xf9\xca\xd6%0\xf6R\xbe\xd2\xef\xf22\xd8\xc6\xe5\xfe\xc5\xda\xf0?\x9c\x80\xf2J\xffznT\xae\x82\xb1W3\xfc\xcf'Ίka\xecu\x8c\xd8]\x0f\x947p+\xbe\x11\xc6\xde\xc4h\xbaq@\xd9ͭf\x0f\x8c\xed\xf5\xef\f\xbc\xbb>\xd8\xc6͌\x96\xbb\x05(o\xe5+[\xb7\xc1\xd8\xdb\xf9J\xbf\xbb;`\x1bw\xfa\xe7\xb0\u007f\x02\x8c\a\xca\t\xfein*\x13a\xec$\xff4\xe7\x1b?\x99m\xb3\x98\"\xd6Ne[\xb8i@9\x9dG\x143`\xecLF\xecf\x01\xe5ln\xc5s`\xec\\L\xe2\xee\x02ʻ\xb9ռ\a\xc6ދ\x89\x1b\xe5}\xb0\x8d\xfb\x19-\xf7\x00P>\xc8W\xb6\x1e\x82\xb1\x0f\xf3\x95~\xef\x8f\xc06\x1e\xf5\x8fz\xc5=Ƶ|\xbc\xb7\xadQy\x82\xa5}\xd2?\xee~\xdbOy\xd3,\x9e\x86\xb1\xcfxS\xb8g\xb9\x96\xcf\xf9K\x8b\xe7Y\xda\x17|\x8d\xcb\x17}\x10\xbf\xc4Ҿ̃\xdc+\\\xcbW}\xdc|\x8d\xa5}\x9dg\xf1\x9f\x94\xd84\xde\xf4\xb5\xe5\xde\xe2Z\xbe\xed\xafi\xbd\xc3Ҿ\xeb\xaf\xf1{{\x8fM\xe3\xfd\xde\xf6\xa4\xe6>\xe0Z~\xd8ۖ\xd4>bi?\xee\xedH\xfc\xcf\xc8O\x80\xf2S\xce\xe2\xcf`\xec\xe7\x1e\xfe\xd5\xf6\x05P~\xe9[\xcd\xe2+\x18\xfb\xb57\x85\xfb\x86k\xf9\xad\x9f\xac\xf8\x8e\xa5\xfd\x9e\xafq?p-\u007f\xf4q\xf3'\x96\xf6g\x1e\xd4(\u007fa\xd3\xf8\xd5ז\xfb\x8dk\xf9\xbb\xbf\xa6\xf5\aK\xfb\xa7\xbf\xc6\xef\xf5/6\x8d\xbf{\xdbG\xd7\xdc?\\\xcb\u007f{\xdbF\xd7\xfeci\xe7\xe9\xeb\x18\xed\xf7\xfa?\xa0l\xeb\xf3Y\xdc\x0ec;<\xfc^;\x81r\x80o5\x8b\x810v^o\n7\x1f\xd7r\xfe\xbe\xb6\xd1\xc5\x02,\xed\x82|\x8d[\x88k\xb9\xb0\x8f\x9b\x8b\xb0\xb4\x8b\xf2\xa0F\xb9\x18\x9b\xc6⾶\xdc\x12\\\xcb%\xfd5\xad\xa5Xڥ\xfd5~\xaf˰i,\xdbב\xf8\av9\xa0\\\xbe\xaf\xddc\x05\x18\xbbb_g\xc2\x0f\xeeJ\xc2re\xc4\xf1*b\xed\xaaL\xbf\xdb\xd58n\x16\xab\x8b\xb5k\xb0-ܚ@\xb9\x16OX\xac\rc\xd7\xc1\x95n]\xa0\\\x8f[\xcd\xf5a\xec\x06\x18\xdd(7\x84ml\xc4h\xb9\x8d\x81r\x13\xbe\xb2\xb5)\x8cݬ\xaf#\xf7\x1b\xde\x1c(\xb7\xe8k\xf7\xd8\x12\xc6n\xd5י\xf3\x86\xb7\x16\x96\xdb \x8e\xb7\x15k\xb7c\xfa\ro\xcfq\xb3\u0601Q\xb8\x1d\x81r'\x9e\xa8\xd8\x19\xc6\xee\x82+\xca]9k\xee\x06cw\xc7\xe8F\xb9\alcOF\xcb\xed\x05\x94{\xf3\x95\xadA0v\x1f\xbe\xd2?\xc0\xfb\xc26\x06{\xb4jn\bP\x0e\xf5W\xb6j\xc3`\xec~\xfeʖ\xdf\xf0\xfe\xc2\xf2\x00\xc4\xf1\x81b\xedAL\xbf\xe1\x839n\x16\xc3\xc5\xdaC\xd8\x16\xeeP\xa0<\x8c',\x0e\x87\xb1#p\xa5\x1b\t\x94Gp\xaby$\x8c=\xaa\xaf\xdd\u007f\xa0;\x9akyL_[Y;\x96\xa5\xad\xf4u\xf0\x879\x05\x94U\xce\xe2\b\xc6\xc6\x1e\xfc)\xc9g\xfeC\x92\xaf\xfe3\x12ײ\xe6\x87\x17\tK[\xf7\xb5\xe5R\xaee\xe6\xe3V\xce\xd2\x16~\xa8\u007f\x04,\x9b\xc6\xe8\xbev\u007f\xfe\x06ג\xfaڼfi\x9b}\x1d|\xf61@\xd9\xc5Y\\\xc2ؖ\x87\u007f9\x8c\x05\xca\xe3|\xabY\x1c\x0fcO\xf0\xa6p'r-O\xf2\x93\x15'\xb3\xb4\xa7\xf05\xeeT\xae\xe5i>n\x9e\xceҞ\xc1\x83\x1a\xe5\x99l\x1ag\xf9\xdargs-\xcf\xf1״\xceei\xcf\xf3\xd7\xf8\xbd\x9eϦqA\x1f\xff\xe7\xd7\vQ/B\xbd\xb8\xaf\xfd\xc0\xc2]\xd2\xd76\xb4vi_\xfb\x90\x9a\xbb\xac\xafc?\xbf\xfd\xcb\xfb\xda\xf7h\xd9+\xfa\xda\x0f\xa6ڕ}\x1d\x83\xfc\xa7ū\xfa\xda\a\xc5\xf6꾶a\xb5k\xfa:\xf6\xf1\x0f\xf7\xb5}\xedC[\x8d\xeb\xfa:vWMw}_\xfb\xb0\xc2\xde\xd0\xd76\xa2\xb8\xb1\xaf\xfd\x80\xa6\xbb\x89/j\x16\xe3\xfaڇW\\w_۠J\x0f\x96\xecE\xed\xeb\xeb\xd83\xf2?y\xfa\xdawo6n\xe1\x15\x9aŭ\xbcvao\xebk\x1b\u07bc\xbd\xafm\u007f{G_\xc7`\xff\x92\xba\xb3\xaf}d\xe1\xc6\xfbY[nB_\xfb>Y1\xb1\xaf}\x84\xff\x94\xd4\xd7~h\xb31\xd9oҴ\xa6x\x1d۩}m#+\xd3\xfa\xda\x06\x17ӱʌ\xbe\xf6\xc1Ik\xa6\xdfy\xe1f\xf1d\xb5xv_\xdbaŜ\xbe\xb6=\x9bs\xfb\xf8\x8f\x0e5\xee\xf2\xa7\xa8\xc5w\xf7\xb5\xedѺ\xa7\x8f\xff\xa4\x88\xbd\xd7\x1f\xbef\xef\xe3\xfd\x17\xf6~\xbe\xaa\xe2\x1e\xc0|\x0f\xb2)\xecC\xfe\x02\x13?\xdc\xd79\x92?\xc2<\x82֣}mC\xe2\xc7 \x1fG}\x02\xf5IԧP\x9fF}\x06\xf5Y\xd4\xe7P\x9fG}\x01\xf5EԗP_F}\x05\xf5U\xd4\xd7P_G}\x03\xf5MԷP\xdfF}\a\xf5]\xd4\xf7P\xdfG\xfd\x00\xf5CԏP?F\xfd\x04\xf5S\xd4\xcfP?G\xfd\x02\xf5K\u052fP\xbfF\xfd\x06\xf5[\xd4\xefP\xbfG\xfd\x01\xf5GԟP\u007fF\xfd\x05\xf5W\xd4\xdfP\u007fG\xfd\x03\xf5OԿP\xffF\xfd\a\xf5_\xd4yƷ\xe9\xca\xffƷ\xeb\x8an\x1b\xdf\xe1\xabn\a\xa8\x83\xb3\xbc\x93M\x9e\f\x00\xcc@\u03a2y\xb9\xa6\xf3q\x94\xea\xf9\x81l\x01@-\b\xd0B\x80[\x18\xb0\x8b\x00fQ\x1e\x96-\xc6U-Α\xa2%\xd8Вl\x88\x96\xc2\x1aziΒe\xb8V\x97\xe5Z_\x8e\xab[\x9e\xab]\x81\xabY\x91k\xbc\x12\x0f\x88\xf5\xca\xe3;\x19z\x15!\xad\x8a8_\r6OV\x17\x9a5\x10Gk\x02\xe9ZHS\xbd\xb60[G\xa8\xd6\x15\xd2zB\xb7\xbe\xd0n 4\x1bbx\xb6\x11\xa06F\xaah\x13X\xda\x14\x96h3YRo\x8e8\xd9\x02\xa8n\tԷ\x02\xdcր\xdd\x060\xdb\xfa\x03\xb5*\xdbyӪ\xe8\xed\xfdp\x0f\xbd\x83\x90vD\x9c\xef\x04\x9b';\v\xcd.\x88\xa3]\x81t7\xa4\xa9\xde]\x98\xed!T{\ni/\xa1\xdb[h\a\t\xcd>\x18\x9e\xed\v\xa8\xc1H\x15\r\x81\xa5\xa1\xb0D\xc3dI\xbd\x1f\xe2d\u007f\xa0z\x00P?\x10p\a\x01\xf6`\xc0\f\a\xe2C00և\x8e\x1f\x00\xeaÂ\xa0å\x93\x8f\x90 OF\x06a\x8e\x90Nt\xa40=J\x1a\xa9>:\x88\xec\x98 ԱAP%\b\xa7\x82\xb0\xd5 L$\xd3d\xb1P\x8d\x92\x86\"-\x01\x19\t\xfc\aٰ\x03\x9dH'\xa9\v\xab\xa9\xb0\x9e\t].\xb4\x85\xd0X\u007f\xf7\xe2b\xb4?r\\\xe8\x86\x0f=4\t\xc9!Λ\xb0y2Fh\xba\x10G%\x90\xb6\x90\xa6z\xac0;N\xa8\x8e\x17\xd2\tBw\xa2О$4'cxv\n\xa0NE\xaa\xe84X:\x1d\x96\xe8\fYR\x9f\x8989\v\xa8\x9e\r\xd4\xcf\x01ܹ\x80=\x0f0\xe7\xfb7\x85\xf8\x02>\x95\xbe\x90\x13\xad/\x02\xe8b\xce\xf2K\xd8\xe4ɥ\x80\xb9\x8c\xb3\xe8r\xae\xe9\x15\x1c\xa5\xfaJ \xbb\nPW\x03t\r\xe0\xae\x05\xecu\x80\xb9\x9e\x87e7pU7r\xa4\xe8&64\x8e\rQ7\xd6\xd0=\x9c%\xbd\\\xab}\\\xeb7su\xb7p\xb5\xb7r5\xb7\xf1S..n\xe7\x9b\xe2\x1f\xf8;\xf8n\xf2\x8d\xb83\b\x1a/\x9d|\x82\x04y21\b3I:\xd1da:E\x1a\xa9\x9e\x1aD6-\b5=\b\x9a\x11\x84\x9b\x19\x84\x9d\x15\x84\x99-\xd3ds\x84j\xae4\x14\xdd%\x01\xdd-\x01\xd1=a\a\xfa^\xe9$\xf7\t\xab\xf7\v\xeb\x0f\b݃B\xfb\x90\xd0<\xcco\x18\xf1#8\xb2~\x14\xa1֏\t\xe9q\xc4\xf9\x13\xb0y\xf2\xa4\xd0<\x858z\x1aH\x9fA\x9a\xeag\x85\xd9sB\xf5\xbc\x90^\x10\xba\x17\x85\xf6%\xa1y\x19óW\x00\xf5*RE\xaf\xc1\xd2\xeb\xb0DoȒ\xfaM\xc4\xc9[@\xf5m\xa0\xfe\x0e\xe0\xde\x05\xec{\x80y\xdf?\xe5\x8a\x0f\xfc\xa9\n\xfd\xa1O\xfc}\xfb\b\xa0\x8f9\xcb?a\x93'\x9f\x02\xe63\u03a2Ϲ\xa6_p\x94\xea/\x81\xec+@}\r\xd07\x80\xfb\x16\xb0\xdf\x01\xe6{\x1e\x96\xfd\xc0U\xfdȑ\xa2\x9f\xd8\xd0\xcfl\x88~\xc1\x1a\xfaWΒ߸V\u007f\xe7Z\xff\x83\xab\xfb\x93\xab\xfd\x8b\xab\xf9\xdb\u05ee\xca?~@WE\xff\xeb\xcf\xec\xa1\xff\x13\xd2<\x138\xce\xff7\x81m\x9e\xb4\tM;\xe2\xa8\x03H;\x91\xa6z\x800\x1b(T\xf3\ni>\xa1\x9b_h\x17\x10\x9a\x051<[\bP\v#U\xb4\b,-\nK\xb4\x98,\xa9\x17G\x9c,\x01T\x97\x04\xeaK\x01ni\xc0.\x03\x98e\x81x9\f\x8c\xf5\xf2\x13\x06\x80z\x85 hE\xe9\xe4+I\x90'+\aaV\x91N\xb4\xaa0]M\x1a\xa9^=\x88l\x8d ԚA\xd0ZA\xb8\xb5\x83\xb0\xeb\x04a֕i\xb2\xf5\x84j}i(\xda@\x02\xdaP\x02\xa2\x8d\xc2\x0e\xf4\xc6\xd2I6\x11V7\x15\xd67\x13\xbaͅv\v\xa1\xd9r\x82\xbf\x87\xf1V\xfe\xc8E\xac\xb7\xf6\xa1\x87\xdeFH\xdb\"η\x83͓\xed\x85f\a\xc4ю@\xba\x13\xd2T\xef,\xccv\x11\xaa]\x85\xb4\x9b\xd0\xed.\xb4{\b͞\x18\x9e\xed\x05\xa8\xbd\x91*\x1a\x04K\xfb\xc0\x12\xed+K\xea\xc1\x88\x93!@u(P\x1f\x06\xb8\xfd\x00\xbb?`\x0e\xf0\aj\x15\az\xd3*\xf4A~\xb8\x87>XH\xc3\x11\xe7\x87\xc0\xe6ɡBs\x18\xe2\xe8p \x1d\x814\xd5#\x85\xd9\x11Bu\xa4\x90\x8e\x12\xba\xa3\x85\xf6\x18\xa19\x16ó\n\xa0\x14REUX\x8a`\x89bYR\x8fB\x9ch\xa0j\x80z\rp\t`\xeb\x80I'\xb4\xe9f\xe6O\xd5ԹO\x9aZ\x17\x00Y\xce\xf2\xd1l\xf2\xa4\x01\x18\xe2,r\\\xd3&G\xa9\x1e\x03d]\x80*\x01j\x01n,`\x8f\x03\xcc\xf1<,;\x81\xab:\x91#E'\xb1\xa1\x93\xd9\x10\x9d\x825\xf4\xa9\x9c%\xa7q\xad\x9eε~\x06Ww&W{\x16Ws6\xbf\x86\xe2\xe2\x1c~\x96\xf9\x1f;\xe7\xf2ӓ\u007f\x0e\x9d\x17\x04\x9d/\x9d\xfc\x02\t\xf2\xe4\xc2 \xccE҉.\x16\xa6\x97H#\u0557\x06\x91]\x16\x84\xba<\b\xba\"\bwe\x10\xf6\xaa \xcc\xd52Mv\x8dP]+\rE\xd7I@\xd7K@tC\u0601\xbeQ:\xc9M\xc2\xea8a\xbd[\xe8z\x84\xb6Wh\xfa\xfc\x91\xbb\xe2\x9bqd}\vB\xado\x15\xd2m\x88\xf3\xdba\xf3\xe4\x0e\xa1\xb9\x13q4\x1eH' M\xf5Da6I\xa8&\vi\x8a\xd0M\x15\xdaiB3\x1dó\x19\x80\x9a\x89T\xd1,X\x9a\rK4G\x96\xd4s\x11'w\x01ջ\x81\xfa=\x80\xbb\x17\xb0\xf7\x01\xe6~>P\xed\x0165\xfd \x0f\xafi\xfd\x90\x90\x1eF\x9c?\x02\x9b'\x8f\n\xcdc\x88\xa3ǁ\xf4\t\xa4\xa9~R\x98=%TO\v\xe9\x19\xa1{Vh\x9f\x13\x9a\xe71<{\x01P/\"U\xf4\x12,\xbd\fK\xf4\x8a,\xa9_E\x9c\xbc\x06T_\a\xeao\x00\xeeM\xc0\xbe\x05\x98\xb7\xf9M\xa1\xf9\x0e\xbf\xa0\x9a\xfa]~\t\xfa\x97\xd1{Bz\x1fq\xfe\x01l\x9e|(4\x1f!\x8e>\x06\xd2O\x90\xa6\xfaSa\xf6\x99P}.\xa4/\x84\xeeK\xa1\xfdJh\xbe\xc6\xf0\xec\x1b@}\x8bT\xd1w\xb0\xf4=,\xd1\x0f\xb2\xa4\xfe\x11q\xf2\x13P\xfd\x19\xa8\xff\x02\xb8_\x01\xfb\x1b`~\xf7\a\x8a\x9b\u007fx\x137\xf5\x9f~\xb8\x87\xfeKH\u007f#\xce\xff\x81͓\u007f\x85\xe6?\xc4\xd1<\x13\x19\xe9\xff&r\x9a\xea6a\xd6.T\x1dB\xea\x14\xba\x01B;Ph\xe6\xc5\xf0l>@͏T\xd1\x02\xb0\xb4 ,\xd1B`\xae\x17F\x9c,\x02T\x17\x05\xea\x8b\x01nq\xc0.\x01\x98%'\xfa;T[ʛVM/\xed\x87{\xe8e\x84\xb4,\xe2|9\xd8<Y^hV@\x1c\xad\b\xa4+!M\xf5\xca\xc2l\x15\xa1ZUH\xab\t\xdd\xeaB\xbb\x86Ь\x89\xe1\xd9Z\x80Z\x1b\xa9\xa2u`i]X\xa2\xf5dI\xbd>\xe2d\x03\xa0\xba!P\xdf\bp\x1b\x03v\x13\xc0l:\xb1M\xd76\xf3\xa7\xaa\xe9\xcd}\xe2O\xb3\x05@[r\x96o\xc5&O\xb6\x06\xcc6\x9cE\xdbrM\xb7\xe3(\xd5\xdb\x03\xd9\x0e\x80\xda\x11\xa0\x9d\x00\xb73`w\x01̮<,ۍ\xabڝ#E{\xb0\xa1=\xd9\x10\xed\x855\xf4ޜ%\x83\xb8V\xf7\xe1Zߗ\xab\x1b\xcc\xd5\x0e\xe1j\x86N\xe4?\xd73l\"\xff\xb9\x1e\xbd\x9f?3\u007f\x17\xb2\xbf\x90\x0e@\x9c\x1f\b\x9b'\a\t\xcd\xc1\x88\xa3\xe1@z\b\xd2T\x1f*\xcc\x0e\x13\xaaÅ4B\xe8F\n\xed\x11Bs$\x86gG\x01\xeah\xa4\x8a\x8e\x81\xa5ca\x89*\xb2\xa4V\x88\x93*P\x8d\x80z\f\xb8Q\x80Հ1@\\\xc3\xc0X'\x13\a\x80\xba\x1e\x04\xa5\xd2\xc93\t\xf2$\x0f\xc2\x14҉\xac0\x1d-\x8dT7\x82\xc8(\b傠f\x10nL\x10\xb6+\bS\xca4YK\xa8\xc6JC\xd1q\x12\xd0\xf1\x12\x10\x9d\x10v\xa0O\x94Nr\x92\xb0z\xb2\xb0~\x8aН*\xb4\xa7\t\xcd\xe9|\xd8V\xe5\f\xb6\xad\x8a>\x93\xe7\xe1\xefP\xce\n\x82ΖN~\x8e\x04yrn\x10\xe6<\xe9D\xe7\v\xd3\v\xa4\x91\xea\v\x83\xc8.\nB]\x1c\x04]\x12\x84\xbb4\b{Y\x10\xe6r\x99&\xbbB\xa8\xae\x94\x86\xa2\xab$\xa0\xab% \xba&\xec@_+\x9d\xe4:a\xf5za\xfd\x06\xa1\xbbQho\x12\x9aq¸[&\x88u\xcfā\"to\xbf\xa2\xbe\xd0\xcco\x0eQ\x9e\xdcү̭\xa1\x19\xdd\x16Dz{\xe8\xa5\xfa\x8e~\x95\xddٯ\xd4\xf8~E\x13\xfa\x95\x9bد\xec\xa4~e&\x87\xe9\xb2)A\xa8\xa9\xa1\xa7hZ\x88hz\x88\x88f\xf4oH\xcf\f\xcddV\x10\xd5\xd9A\xd4\xe7\x04\xe1\xe6\x06a\xef\n\xc2\xdc\xcdw=.\xee\xe1\xc7\xc3\xfffu/\xe7\xfc\xab\xd6}A\xd0\xfd\xd2\xc9\x1f\x90 O\x1e\f\xc2<$\x9d\xe8aa\xfa\x884R\xfdh\x10\xd9cA\xa8ǃ\xa0'\x82pO\x06a\x9f\n\xc2<-\xd3d\xcf\bճ\xd2P\xf4\x9c\x04\xf4\xbc\x04D/\x84\x1d\xe8\x17\xa5\x93\xbc$\xac\xbe,\xac\xbf\"t\xaf\n\xedkB\xf3:\xbfA\xc5o\xe0\xc8\xfaM\x84Z\xbf%\xa4\xb7\x11\xe7\xef\xc0\xe6ɻB\xf3\x1e\xe2\xe8} \xfd\x00i\xaa?\x14f\x1f\t\xd5\xc7B\xfaD\xe8>\x15\xdaτ\xe6s\fϾ\x00ԗH\x15}\x05K_\xc3\x12}#K\xeao\x11'\xdf\x01\xd5\xef\x81\xfa\x0f\x80\xfb\x11\xb0?\x01\xe6g<\x8d\xe3\xe2\x17\xdcN\u007f\xbb~\xc5Ӂo\xe0o\xfd\x8a~\x0f\xcd\xfc\x8f\x10\xe5ɟ\xfd\xca\xfc\x15\x9a\xd1\xdfA\xa4\xff\x84^\xaa\xff\xedW\xd9\u007f\xfdJ\xcd3)(\xfa_\xbfrm\xfdʶ\xf7+\xd31I\xa6\xcb:\x83P\x03BO\xd1\xc0\x10Ѽ!\"\x9a/\xa8\\\xcf\x1f\x9a\xc9\x02AT\x17\f\xa2\xbeP\x10n\xe1 \xec\"A\x98E'\xf1\x9bW\xbc\xd8$<\x1ezqɵ^\"\bZR:\xf9R\x12\xe4\xc9\xd2A\x98e\xa4\x13-+L\x97\x93F\xaa\x97\x0f\"[!\b\xb5b\x10\xb4R\x10n\xe5 \xec*A\x98Ue\x9al5\xa1Z]\x1a\x8a\u0590\x80֔\x80h\xad\xb0\x03\xbd\xb6t\x92u\x84\xd5u\x85\xf5\xf5\x84n}\xa1\xdd@h6\x9c\xc4\u007f\nv#>r\xa17\xe6\xd0\xdf\xefM\x84\xb4)\xe2|3\xd8<\xd9\\h\xb6@\x1cm\t\xa4[!M\xf5\xd6\xc2l\x1b\xa1\xdaVH\xdb\t\xdd\xf6B\xbb\x83\xd0\xec\x88\xe1\xd9N\x80\xda\x19\xa9\xa2]`iWX\xa2\xdddI\xbd;\xe2d\x0f\xa0\xba'P\xdf\vp{\x03v\x10`\xf6atU\xf6\xe5\x81]\x15=\x98\x1f\x18\xfe\x1ehH\x104T:\xf90\t\xf2d\xbf \xcc\xfe҉\x0e\x10\xa6\aJ#\xd5\a\x05\x91\x1d\x1c\x84\x1a\x1e\x04\x1d\x12\x84;4\b{X\x10\xe6p\x99&\x1b!T#\xa5\xa1\xe8\b\t\xe8H\t\x88\x8e\n;\xd0GK'9FX=VX\xaf\b\x9d\x12ڪ\xd0D\xc28\x96\tb=\x8a\x9f\xfb\xf8\x8eH\xf7+2\xa1\x99\xd7B\x94'I\xbf2\xf5Ќ\xd2 \xfcG>\xe9\xa5:\xefWYѯ\x94\xedW4\xba_\xb9F\xbf\xb2\u052f\x8c\v\xd3e\xcd Ԙ\xd0S\xd4\x15\"*CD\xd4\xeaߐ\x1e\x1b\x9a\xc9qAT\x8f\x0f\xa2~B\x10\xee\xc4 \xecIA\x98\x93q\xf3\xe3S\xf0t\x89\xf5\xa9\x9c\xf3\xf7G\xa7\x05A\xa7K'?C\x82<93\bs\x96t\xa2\xb3\x85\xe99\xd2H\xf5\xb9Ad\xe7\x05\xa1\xce\x0f\x82.\b\xc2]\x18\x84\xbd(\bs\xb1L\x93]\"T\x97JC\xd1e\x12\xd0\xe5\x12\x10]\x11v\xa0\xaf\x94Nr\x95\xb0z\xb5\xb0~\x8d\xd0]+\xb4\xd7\t\xcd\xf5x\x83*n\xc0K\xb8\xd07\xe2\xb5\xef_\xb67\x05A㤓wK\x90'=A\x98^\xe9D}\xc2\xf4fi\xa4\xfa\x96 \xb2[\x83P\xb7\x05A\xb7\a\xe1\xee\b\xc2\xde\x19\x84\x19/\xd3d\x13\x84j\xa24\x14M\x92\x80&K@4%\xec@O\x95N2MX\x9d.\xac\xcf\x10\xba\x99B;Khf\xf3\x1bTs\x0e\x1f\xb9\xa9\xe7r\xe8?_\xde%\xa4\xbb\x11\xe7\xf7\xc0\xe6ɽBs\x1f\xe2\xe8~ }\x00i\xaa\x1f\x14f\x0f\t\xd5\xc3BzD\xe8\x1e\x15\xdaDŽ\xe6q\fϞ\x00ԓH\x15=\x05KO\xc3\x12=#K\xeag\x11'\xcf\x01\xd5\xe7\x81\xfa\v\x80{\x11\xb0/\x01\xe6e\xbcf\xe3\xe2\x15<w\xfd\x0f\xd5W\xf1\xdc石\xaf\xf5+z=4\xf37B\x94'o\xf6+\xf3VhFo\a\x91\xbe\x13z\xa9~\xb7_e\xef\xf5+\xf5~\xbf\xa2\x0f\xfa\x95\xfb\xb0_ُ\xfa\x95\xf98L\x97}\x12\x84\xfa4\xf4\x14}\x16\"\xfa<DD_\xf4oH\u007f\x19\x9a\xc9WAT\xbf\x0e\xa2\xfeM\x10\xee\xdb \xecwA\x98\xef\xf1N\x1d\xff \x8f\x87\xfeQr\xad\u007f\n\x82~\x96N\xfe\x8b\x04y\xf2k\x10\xe67\xe9D\xbf\v\xd3?\xa4\x91\xea?\x83\xc8\xfe\nB\xfd\x1d\x04\xfd\x13\x84\xfb7\b\xfb_\x10f\x9eɘ&\xfb\x9fP\xb5MFCQ\xbb\x04\xd4!\x01Q\xa7\x88\\\x0f\x90N2PX\x9dWX\x9fO\xe8\xe6\x17\xda\x05\x84f\xc1\xc9|\xd8\xdaB\xb05\xbd0\xe6\xf1\x1f\xc5\x17\t\x82\x16\x95N\xbe\x98\x04y\xb2x\x10f\t\xe9DK\nӥ\xa4\x91ꥃȖ\tB-\x1b\x04-\x17\x84[>\b\xbbB\x10fE\x99&[I\xa8V\x96\x86\xa2U$\xa0U% Z-\xec@\xaf.\x9dd\rauMa}-\xa1[[h\xd7\x11\x9au\xf9\xb0\xad\xe6zl[M\xbd>\xcf\xc3\xdfsm\x10\x04m(\x9d|#\t\xf2d\xe3 \xcc&҉6\x15\xa6\x9bI#՛\a\x91m\x11\x84\xda2\b\xda*\b\xb7u\x10v\x9b ̶2M\xb6\x9dPm/\rE;H@;J@\xb4S\u0601\xdeY:\xc9.\xc2\xea\xae\xc2\xfanB\xb7\xbb\xd0\xee!4{\xf2a\xe3\xe6^l\xe3\xa6ޛ\xe7\xe1\xef\xc0\x06\x05A\xfbH'\xdfW\x82<\x19\x1c\x84\x19\"\x9dh\xa80\x1d&\x8dT\xef\x17D\xb6\u007f\x10\xea\x80 \xe8\xc0 \xdcAA\u0603\x830\xc3e\x9a\xec\x10\xa1:T\x1a\x8a\x0e\x93\x80\x0e\x97\x80hD\u0601\x1e)\x9d\xe4\ba\xf5Ha\xfd(\xa1;Zh\x8f\x11\x9acqgk\x15\x9c\xbd\xa6\x15\x1e4\xff4\xae\x06A\x91t\xf2X\x82<\x19\x15\x84\xd1҉\x8c0\xadI#\xd5I\x10Y=\b\x95\x06AY\x10.\x0f\xc2\x16A\x18+\xd3d\xa3\x85\xaa!\rE$\x019\t\x88\x9aa\az\x8ct\x92.a\xb5\x14\xd6[B7Vh\x8f\x13\x9a\xe3'\xf3_C;\x81\x8f\\\xd3'r\xe8Oz\x92\x90NF\x9c\x9f\x02\x9b'\xa7\n\xcdi\x88\xa3Ӂ\xf4\f\xa4\xa9>S\x98\x9d%Tg\v\xe9\x1c\xa1;Wh\xcf\x13\x9a\xf31<\xbb\x00P\x17\"Ut\x11,]\fKt\x89,\xa9/E\x9c\\\x06T/\a\xeaW\x00\xeeJ\xc0^\x05\x98\xab'\xb7\xe5\x95k&\xb7\xe7\x15}\xed\xe4\x0e_\xf5u\x00]\xcfY~\x03\x9b<\xb9\x1107q\x16\x8d\xe3\x9avs\x94\xea\x1e \xeb\x05T\x1f@7\x03\xee\x16\xc0\xde\n\x98\xdbxXv;Wu\aG\x8a\xeedC\xe3\xd9\x10M\xc0\x1az\"g\xc9$\xae\xd5\xc9\\\xebS\xb8\xba\xa9\\\xed4\xaef:\xd7x\x06\x0f\x88\xf5\xccɝ\f=KH\xb3\x11\xe7s`\xf3d\xae\xd0܅8\xba\x1bH\xefA\x9a\xea{\x85\xd9}Bu\xbf\x90\x1e\x10\xba\a\x85\xf6!\xa1y\x18óG\x00\xf5(RE\x8f\xc1\xd2\xe3\xb0DOȒ\xfaI\xc4\xc9S@\xf5i\xa0\xfe\f\xe0\x9e\x05\xecs\x80y\xde\x1f\xa8Uy\xc1\x9bVE\xbf\xe8\x87\xf37c/\t\xe9e\xc4\xf9+\xb0y\xf2\xaaм\x868z\x1dH\xdf@\x9a\xea7\x85\xd9[B\xf5\xb6\x90\xde\x11\xbaw\x85\xf6=\xa1y\x1fó\x0f\x00\xf5!RE\x1f\xc1\xd2ǰD\x9fȒ\xfaS\xc4\xc9g@\xf5s\xa0\xfe\x05\xe0\xbe\x04\xecW\x80\xf9\x1a\x88\xbf\xc1\xc0X\u007f;y\x00\xa8\xbf\v\x82\xbe\x97N\xfe\x83\x04y\xf2c\x10\xe6'\xe9D?\v\xd3_\xa4\x91\xea_\x83\xc8~\vB\xfd\x1e\x04\xfd\x11\x84\xfb3\b\xfbW\x10\xe6o\x99&\xfbG\xa8\xfe\x95\x86\xa2\xff$\xa0y\xa6 \xfa\x9f\x88\\\xb7MA'i\x17V;\x84\xf5N\xa1\x1b \xb4\x03\x85f\xde)\xedy\\\xcc7\xa5\xc3W=\xbf\x0f\xf9\x17\xb7\x05\x84\xb4 \xe2|!\xd8<YXh\x16A\x1c-\n\xa4\x8b!M\xf5\xe2\xc2l\t\xa1ZRHK\t\xdd\xd2B\xbb\x8c\xd0,\x8b\xe1\xd9r\x80Z\x1e\xa9\xa2\x15`iEX\xa2\x95dI\xbd2\xe2d\x15\xa0\xba*P_\rp\xab\x03v\r\xc0\xac9\xa5-\x8f\xd7\xe2S\xe9\xb59\xd1z\x1d\x80\xd6\xe5,_\x8fM\x9e\xac\x0f\x98\r8\x8b6\xe4\x9an\xc4Q\xaa7\x06\xb2M\x00\xb5)@\x9b\x01ns\xc0n\x01\x98-yX\xb6\x15W\xb55G\x8a\xb6aC۲!\xda\x0ek\xe8\xed9Kv\xe0Zݑk}'\xaeng\xaev\x17\xaefW\u007fi+.v\xe3\x9b\xe2\x1f\xf8\xdd\xf9n\xf2\x8d\xd8#\b\xdaS:\xf9^\x12\xe4\xc9\xdeA\x98A҉\xf6\x11\xa6\xfbJ#Ճ\x83Ȇ\x04\xa1\x86\x06AÂp\xfb\x05a\xf7\x0f\xc2\x1c \xd3d\a\n\xd5A\xd2Pt\xb0\x044\\\x02\xa2C\xc2\x0e\xf4\xa1\xd2I\x0e\x13V\x0f\x17\xd6G\b\xddH\xa1=Bh\x8e\xf4Gn\xc5G\xe1\xc8\xfah\x84Z\x1f#\xa4c\x11\xe7\x15\xd8<QBSE\x1cE@\x1a#M\xf5(a\xa6\x85\xca\b\xa9&t\x89\xd0օ&\xc5\xf0,\x03T\x8eTQ\x01K\x16\x96h\xb4,\xa9\x1b\x88\x13\x02\xaa\x0e\xa87\x017\x06\xb0]\x80)\xfdS\xaeh\xf9S\x15z\xacO\xfc};\x0e\xa0\xe39\xcbO`\x93''\x02\xe6$\u03a2\x93\xb9\xa6\xa7p\x94\xeaS\x81\xec4@\x9d\x0e\xd0\x19\x80;\x13\xb0g\x01\xe6l\x1e\x96\x9d\xc3U\x9dˑ\xa2\xf3\xd8\xd0\xf9l\x88.\xc0\x1a\xfaBΒ\x8b\xb8V/\xe6Z\xbf\x84\xab\xbb\x94\xab\xbd\x8c\xab\xb9\xdc\u05ee\xca\x15~@WE_\xe9\xcf\xcc\xdf*]%\xa4\xab\x11\xe7\xd7\xc0\xe6ɵBs\x1d\xe2\xe8z \xbd\x01i\xaao\x14f7\t\xd58!u\v]\x8f\xd0\xf6\nM\x1f\x86g7\x03\xea\x16\xa4\x8an\x85\xa5\xdb`\x89n\x97%\xf5\x1d\x88\x93;\x81\xeax\xa0>\x01p\x13\x01;\t0\x93\x81x\n\x06\xc6z\xaa\u007fz⛣iA\xd0t\xe9\xe43$ȓ\x99A\x98Y҉f\v\xd39\xd2H\xf5\xdc \xb2\xbb\x82Pw\aA\xf7\x04\xe1\xee\r\xc2\xde\x17\x84\xb9_\xa6\xc9\x1e\x10\xaa\a\xa5\xa1\xe8!\t\xe8a\t\x88\x1e\t;ЏJ'yLX}\\X\u007fB\xe8\x9e\x14ڧ\x84\xe6i\xbe\x87\xf13|\xbbc\xfd\xac\x0f\xf9ۡ\xe7\x84\xf4<\xe2\xfc\x05\xd8<yQh^B\x1c\xbd\f\xa4\xaf M\xf5\xab\xc2\xec5\xa1z]Ho\bݛB\xfb\x96м\x8d\xe1\xd9;\x80z\x17\xa9\xa2\xf7`\xe9}X\xa2\x0fdI\xfd!\xe2\xe4#\xa0\xfa1P\xff\x04p\x9f\x02\xf63\xc0|\xceo\n\xc5\x17\xfc\x82*\xf4\x97\xfc\x12\xf4/\xa3\xaf\x84\xf45\xe2\xfc\x1b\xd8<\xf9Vh\xbeC\x1c}\x0f\xa4? M\xf5\x8f\xc2\xec'\xa1\xfaYH\xbf\bݯB\xfb\x9b\xd0\xfc\x8e\xe1\xd9\x1f\x80\xfa\x13\xa9\xa2\xbf`\xe9oX\xa2\u007fdI\xfd/\xe2\xe4?\xa0:\xcfTF\xfd\u007f\x80k\x03l;`:\xa6\xb6\xe5\xcdΩ\xedyS\x0f\xf0\x89\xff\x045\x10\xa0y9\xcb\xe7c\x93'\xf3\x03f\x01\u03a2\x05\xb9\xa6\vq\x94ꅁl\x11@-\n\xd0b\x80[\x1c\xb0K\x00fI\x1e\x96-\xc5U-͑\xa2e\xd8вl\x88\x96\xc3\x1azyΒ\x15\xb8VW\xe4Z_\x89\xab[\x99\xab]\x85\xabY\xd5_\xda\x15\x17\xabM\xedd\xe8է\x0e\x00\xf5\x1aAК\xd2\xc9ג O\xd6\x0e¬#\x9dh]a\xba\x9e4R\xbd~\x10\xd9\x06A\xa8\r\x83\xa0\x8d\x82p\x1b\aa7\t\xc2l*\xd3d\x9b\t\xd5\xe6\xd2P\xb4\x85\x04\xb4\xa5\x04D[\x85\x1d譥\x93l#\xacn+\xaco't\xdb\v\xed\x0eB\xb3\xa3?rW\xbc\x13\x8e\xacwF\xa8\xf5.B\xda\x15q\xbe\x1bl\x9e\xec.4{ \x8e\xf6\x04ҽ\x90\xa6zoa6H\xa8\xf6\x11ҾB7Xh\x87\b\xcdP\fφ\x01j?\xa4\x8a\xf6\x87\xa5\x03`\x89\x0e\x94%\xf5A\x88\x93\x83\x81\xeap\xa0~\b\xe0\x0e\x05\xeca\x809\x9c\x0fT\x1b\xc1\xa6\xa6G\xf2p\xff\x01\xef\b!\x1d\x898?\n6O\x8e\x16\x9ac\x10G\xc7\x02i\x05i\xaa\x950\xab\nU$\xa4X\xe8F\t\xad\x16\x1a\x83\xe1Y\rP\tREuXJa\x892YR爓\x02\xa8Z\xa0>\x1ap\r\xc0\x12`\xdcT\xfe+bM~A5\xf5\x98\xa9\xfc\x17̴\xee\x12R\x898o\xc1\xe6\xc9X\xa19\x0eqt<\x90\x9e\x804\xd5'\n\xb3\x93\x84\xead!\x9d\"t\xa7\n\xediBs:\x86gg\x00\xeaL\xa4\x8a\u0382\xa5\xb3a\x89Α%\xf5\xb9\x88\x93\xf3\x80\xea\xf9@\xfd\x02\xc0]\b؋\x00s\xb1?Pܼě\xb8\xa9/\xf5\xc3\xf9\x9b\x95˄t9\xe2\xfc\n\xd8<\xb9Rh\xaeB\x1c]\r\xa4\xd7 M\xf5\xb5\xc2\xec:\xa1\xba^H7\bݍB{\x93Ќ\xc3\xf0\xac\x1bP=H\x15\xf5\xc2R\x1f,\xd1Ͳ\xa4\xbe\x05qr+P\xbd\r\xa8\xdf\x0e\xb8;\x00{'`\xc6\xf3\x1d\xaaM\xe0\xd3\xd5\xf4D~<\xfcSn\x92\x90&#Χ\xc0\xe6\xc9T\xa1\x99\x868\x9a\x0e\xa43\x90\xa6z\xa60\x9b%T\xb3\x854G\xe8\xe6\n\xed]Bs7\x86g\xf7\x00\xea^\xa4\x8a\ue0e5\xfba\x89\x1e\x90%\xf5\x83\x88\x93\x87\x80\xea\xc3@\xfd\x11\xc0=\n\xd8\xc7\x00\xf3\xb8\u007fۮ=\xe1OU\xd3O\xfağ\xe6)\x80\x9e\xe6,\u007f\x86M\x9e<\v\x98\xe78\x8b\x9e皾\xc0Q\xaa_\x04\xb2\x97\x00\xf52@\xaf\x00\xeeU\xc0\xbe\x06\x98\xd7yX\xf6\x06W\xf5&G\x8a\xdebCo\xb3!z\ak\xe8w9K\xde\xe3Z}\x9fk\xfd\x03\xae\xeeC\xae\xf6#\xae\xe6\xe3\xa9mQ哩\xedQE\u007f:\xb5\xc3W\xfd\x19@\x9fs\x96\u007f\xc1&O\xbe\x04\xccW\x9cE_sM\xbf\xe1(\xd5\xdf\x02\xd9w\x80\xfa\x1e\xa0\x1f\x00\xf7#`\u007f\x02\xcc\xcf<,\xfb\x85\xab\xfa\x95#E\xbf\xb1\xa1\xdf\xd9\x10\xfd\x815\xf4\x9f\x9c%\u007fq\xad\xfe͵\xfe\x0fW\xf7/W\xfb\x1fW3\xcf4_\xe3\xffM\xf3\x03b\xdd6\xad\x93\xa1ۅԁ8\xef\x84͓\x01B3\x10q4/\x90·4\xd5\xf3\v\xb3\x05\x84jA!-$t\v\v\xed\"B\xb3(\x86g\x8b\x01jq\xa4\x8a\x96\x80\xa5%a\x89\x96\x92%\xf5҈\x93e\x80\xea\xb2@}9\xc0-\x0f\xd8\x15\x00\xb3\xa2?P\xab\xb2\x927\xad\x8a^\xd9\x0f\xe7/BV\x11Ҫ\x88\xf3\xd5`\xf3du\xa1Y\x03q\xb4&\x90\xae\x854\xd5k\v\xb3u\x84j]!\xad't\xeb\v\xed\x06B\xb3!\x86g\x1b\x01jc\xa4\x8a6\x81\xa5Ma\x896\x93%\xf5戓-\x80\xea\x96@}+\xc0m\r\xd8m\x00\xb3-\x10o\x87\x81\xb1\xde~\xda\x00P\xef\x10\x04\xed(\x9d|'\t\xf2d\xe7 \xcc.҉v\x15\xa6\xbbI#ջ\a\x91\xed\x11\x84\xda3\b\xda+\b\xb7w\x10vP\x10f\x1f\x99&\xdbW\xa8\x06KC\xd1\x10\th\xa8\x04D\xc3\xc2\x0e\xf4~\xd2I\xf6\x17V\x0f\x10\xd6\x0f\x14\xba\x83\x84\xf6`\xa1\x19\xee\xef^\\\x1c\xe2\x8f\xec\u007f\xcf9ԇ\xfc{\xcfaB:\x1cq>\x026OF\n\xcd\x11\x88\xa3#\x81\xf4(\xa4\xa9>Z\x98\x1d#T\xc7\n\xa9\"tJh\xabB\x13ax\x16\x03j\x14RE\x1a\x96\f,QM\x96\xd4\t\xe2\xa4\x0eTS\xa0\x9e\x01.\al\x01\x18;\xad-\x8aG\xf3\xa9t\x83\x13\xad\t \xc7Y\xded\x93'c\x00\xd3\xc5YTrM[\x1c\xa5z,\x90\x1d\a\xa8\xe3\x01:\x01p'\x02\xf6$\xc0\x9c\xccòS\xb8\xaaS9Rt\x1a\x1b:\x9d\r\xd1\x19XC\x9f\xc9Yr\x16\xd7\xea\xd9\\\xeb\xe7pu\xe7r\xb5\xe7q5\xe7\xf3S...\xe0\x9b\xe2\x1f\xf8\v\xf9n\xf2\x8d\xb8(\b\xbaX:\xf9%\x12\xe4ɥA\x98ˤ\x13].L\xaf\x90F\xaa\xaf\f\"\xbb*\buu\x10tM\x10\xee\xda \xecuA\x98\xebe\x9a\xec\x06\xa1\xbaQ\x1a\x8an\x92\x80\xc6I@\xd4\x1dv\xa0{\xa4\x93\xf4\n\xab}\xc2\xfa\xcdBw\x8b\xd0\xde*4\xb7\xf1\x1bF|;\x8e\xac\xef@\xa8\xf5\x9dB\x1a\x8f8\x9f\x00\x9b'\x13\x85f\x12\xe2h2\x90NA\x9a\xea\xa9\xc2l\x9aPM\x17\xd2\f\xa1\x9b)\xb4\xb3\x84f6\x86gs\x005\x17\xa9\xa2\xbb`\xe9nX\xa2{dI}/\xe2\xe4>\xa0z?P\u007f\x00p\x0f\x02\xf6!\xc0<\xec\x9fr\xc5#\xfeT\x85~\xd4'\xfe\xbe=\x06\xd0\xe3\x9c\xe5O\xb0ɓ'\x01\xf3\x14g\xd1\xd3\\\xd3g8J\xf5\xb3@\xf6\x1c\xa0\x9e\a\xe8\x05\xc0\xbd\bؗ\x00\xf32\x0f\xcb^\xe1\xaa^\xe5H\xd1kl\xe8u6Do`\r\xfd&g\xc9[\\\xabos\xad\xbf\xc3ս\xcbվ\xc7ռ\xefkW\xe5\x03?\xa0\xab\xa2?\xf4g\xe6/B>\x12\xd2Lj\xf3O`\xf3\xe4S\xa1\xf9\fq\xf49\x90~\x814\xd5_\n\xb3\xaf\x84\xeak!}#t\xdf\n\xedwB\xf3=\x86g?\x00\xeaG\xa4\x8a~\x82\xa5\x9fa\x89~\x91%\xf5\xaf\x88\x93߀\xea\xef@\xfd\x0f\xc0\xfd\tؿ\x00\xf37\x10\xff\x83\x81\xb1\xfe\xd7?=\xf1E\xc8\u007fA\xd0<\xd3\xd1\xc9\xff7\x1dA\x9e\xb4\x05aڥ\x13u\b\xd3Ni\xa4z@\x10\xd9\xc0 ԼA\xd0|A\xb8\xf9\x83\xb0\v\x04a\x16\x94i\xb2\x85\x84jai(ZD\x02ZT\x02\xa2\xc5\xc2\x0e\xf4\xe2\xd2I\x96\x10V\x97\x14֗\x12\xba\xa5\x85v\x19\xa1Yv\xba\xbf\x87\xf1r\xd3\xfd\xed\x8e\xf5\xf2>\xe4/BV\x10Ҋ\x88\xf3\x95`\xf3de\xa1Y\x05q\xb4*\x90\xae\x864ի\v\xb35\x84jM!\xad%tk\v\xed:B\xb3.\x86g\xeb\x01j}\xa4\x8a6\x80\xa5\ra\x896\x92%\xf5ƈ\x93M\x80\xea\xa6@}3\xc0m\x0e\xd8-\x00\xb3\xa5?P\xab\xd8ʛV\xa1\xb7\xf6\xc3\xf9\x8b\x90m\x84\xb4-\xe2|;\xd8<\xd9^hv@\x1c\xed\b\xa4;!M\xf5\xce\xc2l\x17\xa1\xdaUH\xbb\t\xdd\xeeB\xbb\x87\xd0\xec\x89\xe1\xd9^\x80\xda\x1b\xa9\xa2A\xb0\xb4\x0f,Ѿ\xb2\xa4\x1e\x8c8\x19\x02T\x87\x02\xf5a\x80\xdb\x0f\xb0\xfb\x03\xe6\x80\xe9mQ\xf3@\u007f\xaa\xa6>\xc8'\xfe\x03\xcf\xc1\x00\r\xe7,?\x84M\x9e\x1c\n\x98\xc38\x8b\x0e皎\xe0(\xd5#\x81\xec\b@\x1d\t\xd0Q\x80;\x1a\xb0\xc7\x00\xe6X\x1e\x96U\xb8*ő\xa2*\x1b\x8a\xd8\x10\xc5XC\x8f\xe2,\xd1\\\xab\x86k\xbd\xc6\xd5%\\m\x9d\xabI\xfd\xa5\xfc\xf5\x03?\xcb\xfc\x8f\x9d\x9c\x9f\x9e\xfcs\xa8\b\x82\xact\xf2\xd1\x12\xe4I#\bC҉\x9c0mJ#\xd5c\x82Ⱥ\x82Pe\x10\xd4\n\u008d\r\xc2\x1e\x17\x849^\xa6\xc9N\x10\xaa\x13\xa5\xa1\xe8$\t\xe8d\t\x88N\t;ЧJ'9MX=]X?C\xe8\xce\x14ڳ\x84\xe6l\u007f\xe4\xae\xf8\x1c\x1cY\x9f\x8bP\xeb\xf3\x84t>\xe2\xfc\x02\xd8<\xb9Ph.B\x1c]\f\xa4\x97 M\xf5\xa5\xc2\xec2\xa1\xba\\HW\bݕB{\x95\xd0\\\x8d\xe1\xd95\x80\xba\x16\xa9\xa2\xeb`\xe9zX\xa2\x1bdI}#\xe2\xe4&\xa0:\x0e\xa8w\x03\xae\a\xb0\xbd\x80\xe9\xe3\x03\xd5nfSӷ\xf0p\xff9\xeeV!݆8\xbf\x1d6O\xee\x10\x9a;\x11G\xe3\x81t\x02\xd2TO\x14f\x93\x84j\xb2\x90\xa6\b\xddT\xa1\x9d&4\xd31<\x9b\x01\xa8\x99H\x15͂\xa5ٰDsdI=\x17qr\x17P\xbd\x1b\xa8\xdf\x03\xb8{\x01{\x1f`\xee\xe77\x85\xe6\x03\xfc\x82j\xea\a\xf9%\xe8_F\x0f\t\xe9a\xc4\xf9#\xb0y\xf2\xa8\xd0<\x868z\x1cH\x9f@\x9a\xea'\x85\xd9SB\xf5\xb4\x90\x9e\x11\xbag\x85\xf69\xa1y\x1eó\x17\x00\xf5\"RE/\xc1\xd2˰D\xafȒ\xfaU\xc4\xc9k@\xf5u\xa0\xfe\x06\xe0\xde\x04\xec[\x80y\xdb\x1f(n\xbe\xe3M\xdc\xd4\xef\xfa\xe1\xfcE\xc8{Bz\x1fq\xfe\x01l\x9e|(4\x1f!\x8e>\x06\xd2O\x90\xa6\xfaSa\xf6\x99P}.\xa4/\x84\xeeK\xa1\xfdJh\xbe\xc6\xf0\xec\x1b@}\x8bT\xd1w\xb0\xf4=,\xd1\x0f\xb2\xa4\xfe\x11q\xf2\x13P\xfd\x19\xa8\xff\x02\xb8_\x01\xfb\x1b`~\xe7;T\xfb\x83OW\xd3\u007f\xf2\xe3\xe1\x9fr\u007f\t\xe9o\xc4\xf9?\xb0y\xf2\xaf\xd0\xfc\x878\x9ag\x06#\xfd\xdf\fNS\xdd&\xccڅ\xaaCH\x9dB7@h\a\nͼ\x18\x9e\xcd\a\xa8\xf9\x91*Z\x00\x96\x16\x84%Z\b\xcc\xf5\u0088\x93E\x80\xea\xa2@}1\xc0-\x0e\xd8%\x00\xb3䌶\xa8\xb6Ԍ\xf6\xa8\xa6\x97\xf6\t\xff\xa51\x80\x96\xe5,_\x8eM\x9e,\x0f\x98\x158\x8bV䚮\xc4Q\xaaW\x06\xb2U\x00\xb5*@\xab\x01nu\xc0\xae\x01\x985yX\xb6\x16W\xb56G\x8a\xd6aC\xeb\xb2!Z\x0fk\xe8\xf59K6\xe0Zݐk}#\xaenc\xaev\x13\xaef\xd3\x19\xfc?\xb5\xdfl\x06\xffO\xed\xf5\xe6\xfe\xcc\xfc]\xc8\x16B\xda\x12q\xbe\x15l\x9el-4\xdb \x8e\xb6\x05\xd2퐦z{a\xb6\x83P\xed(\xa4\x9d\x84ng\xa1\xddEhv\xc5\xf0l7@\xed\x8eT\xd1\x1e\xb0\xb4',\xd1^\xb2\xa4\xde\x1bq2\b\xa8\xee\x03\xd4\xf7\x05\xdc`\xc0\x0e\x01\xccP \x1e\x86\x81\xb1\xdeo\xc6\x00P\xef\x1f\x04\x1d \x9d\xfc@\t\xf2\xe4\xa0 \xcc\xc1҉\x86\v\xd3C\xa4\x91\xeaC\x83\xc8\x0e\vB\x1d\x1e\x04\x8d\b\u008d\f\xc2\x1e\x11\x849R\xa6Ɏ\x12\xaa\xa3\xa5\xa1\xe8\x18\t\xe8X\t\x88*a\aZI'\xa9\n\xab\x91\xb0\x1e\v\xdd(\xa1\xd5Bc\xf8\xb0\xadJ\x8dm\xab\xa2\x13\x9e\x87\xbfC\xa9\aA\xa9t\xf2L\x82<Ƀ0\x85t\"+LGK#Ս 2\nB\xb9 \xa8\x19\x84\x1b\x13\x84\xed\n\u00942M\xd6\x12\xaa\xb1\xd2Pt\x9c\x04t\xbc\x04D'\x84\x1d\xe8\x13\xa5\x93\x9c$\xac\x9e,\xac\x9f\"t\xa7\n\xediBs\xba0>C&\x88\xf5\x993\x06\x8a\xd0g\xf5+:;4\xf3sB\x94'\xe7\xf6+s^hF\xe7\a\x91^\x10z\xa9\xbe\xb0_e\x17\xf5+uq\xbf\xa2K\xfa\x95\xbb\xb4_\xd9\xcb\xfa\x95\xb9<L\x97]\x11\x84\xba2\xf4\x14]\x15\"\xba:DD\xd7\xf4oH_\x1b\x9a\xc9uAT\xaf\x0f\xa2~C\x10\xee\xc6 \xecMA\x98q|\xd7㢛\x1f\x0f\xff\x9bU\x0f\xe7\xfc\xabVo\x10\xd4'\x9d\xfcf\t\xf2\xe4\x96 ̭҉n\x13\xa6\xb7K#\xd5w\x04\x91\xdd\x19\x84\x1a\x1f\x04M\b\xc2M\f\xc2N\n\xc2L\x96i\xb2)B5U\x1a\x8a\xa6I@\xd3% \x9a\x11v\xa0gJ'\x99%\xac\xce\x16\xd6\xe7\b\xdd\\\xa1\xbdKh\xee\xe67\xa8\xf8\x1e\x1cYߋP\xeb\xfb\x84t?\xe2\xfc\x01\xd8<yPh\x1eB\x1c=\f\xa4\x8f M\xf5\xa3\xc2\xec1\xa1z\\HO\bݓB\xfb\x94\xd0<\x8d\xe1\xd93\x80z\x16\xa9\xa2\xe7`\xe9yX\xa2\x17dI\xfd\"\xe2\xe4%\xa0\xfa2P\u007f\x05p\xaf\x02\xf65\xc0\xbc\x8e\xa7q\\\xbc\x81\xdb\xe9oכx:\xf0\r|\xab_\xd1ۡ\x99\xbf\x13\xa2<y\xb7_\x99\xf7B3z?\x88\xf4\x83\xd0K\xf5\x87\xfd*\xfb\xa8_\xa9\x8f\xfb\x15}үܧ\xfd\xca~֯\xcc\xe7a\xba\xec\x8b ԗ\xa1\xa7\xe8\xab\x10\xd1\xd7!\"\xfa\xa6\u007fC\xfa\xdb\xd0L\xbe\v\xa2\xfa}\x10\xf5\x1f\x82p?\x06a\u007f\n\xc2\xfc\x8c7\xaf\xf8\x17y<\xf4\xaf\x92k\xfd[\x10\xf4\xbbt\xf2?$ȓ?\x830\u007fI'\xfa[\x98\xfe#\x8dT\xff\x1bD\xf6_\x10j\x9e\x99\"\xe8\u007fA\xb8\xb6 l{\x10\xa6c&\xa6\xc9:\x85j\x804\x14\r\x94\x80敀h>\x11\xb9\x9e_:\xc9\x02\xc2\xea\x82\xc2\xfaBB\xb7\xb0\xd0.\"4\x8b\xce\xe4\u007f\nf\xb1\x99\xfcO\xc1\xe8\xc59\xf4\xf7{\t!-\x898_\n6O\x96\x16\x9ae\x10G\xcb\x02\xe9rHS\xbd\xbc0[A\xa8V\x14\xd2JB\xb7\xb2Ю\"4\xabbx\xb6\x1a\xa0VG\xaah\rXZ\x13\x96h-YR\xaf\x8d8Y\a\xa8\xae\v\xd4\xd7\x03\xdc\xfa\x80\xdd\x000\x1b2\xba*\x1b\xf1\xc0\xae\x8aޘ\x1f\x18\xfe\x1eh\x93 hS\xe9\xe4\x9bI\x90'\x9b\aa\xb6\x90N\xb4\xa50\xddJ\x1a\xa9\xde:\x88l\x9b ԶA\xd0vA\xb8탰;\x04av\x94i\xb2\x9d\x84jgi(\xdaE\x02\xdaU\x02\xa2\xdd\xc2\x0e\xf4\xee\xd2I\xf6\x10V\xf7\x14\xd6\xf7\x12\xba\xbd\x85v\x90\xd0\xec#\x8c\xf7\x95\tb=x\xe6@\x11zH\xbf\xa2\xa1\xa1\x99\x0f\vQ\x9e\xec\u05ef\xcc\xfe\xa1\x19\x1d\x10Dz`\xe8\xa5\xfa\xa0~\x95\x1dܯ\xd4\xf0~E\x87\xf4+wh\xbf\xb2\x87\xf5+sx\x98.\x1b\x11\x84\x1a\x19z\x8a\x8e\b\x11\x1d\x19\"\xa2\xa3\xfa7\xa4\x8f\x0e\xcd\xe4\x98 \xaa\xc7\x06Q\xaf\x04\xe1T\x10\xb6\x1a\x84\x89p\xf3\xe3\x18O\x97X\x8f✿?\xd2A\x90\x91N^\x93 O\x92 L]:Q*L3i\xa4:\x0f\"+\x82P6\b\x1a\x1d\x84k\x04a)\b\xe3d\x9a\xac)Tc\xa4\xa1\xa8K\x02*% j\x85\x1d\xe8\xb1\xd2I\x8e\x13V\x8f\x17\xd6O\x10\xba\x13\x85\xf6$\xa19\x99\x0f\xdb*N\xc1K\xb8Ч\xe2\xb5\xef_\xb6\xa7\x05A\xa7K'?C\x82<93\bs\x96t\xa2\xb3\x85\xe99\xd2H\xf5\xb9Ad\xe7\x05\xa1\xce\x0f\x82.\b\xc2]\x18\x84\xbd(\bs\xb1L\x93]\"T\x97JC\xd1e\x12\xd0\xe5\x12\x10]\x11v\xa0\xaf\x94Nr\x95\xb0z\xb5\xb0~\x8d\xd0]+\xb4\xd7\t\xcd\xf5\xfc\x06ռ\x81\x8f\xdc\xd47r\xe8?_\xde$\xa4q\x88\xf3n\xd8<\xe9\x11\x9a^\xc4Q\x1f\x90ތ4շ\b\xb3[\x85\xea6!\xdd.tw\b\xed\x9dB3\x1eó\t\x80\x9a\x88T\xd1$X\x9a\fK4E\x96\xd4S\x11'Ӏ\xeat\xa0>\x03p3\x01;\v0\xb3\U0005a34b9x\xee\xfa\x1f\xaas\xf1\xdc石w\xf5+\xba;4\xf3{B\x94'\xf7\xf6+s_hF\xf7\a\x91>\x10z\xa9~\xb0_e\x0f\xf5+\xf5p\xbf\xa2G\xfa\x95{\xb4_\xd9\xc7\xfa\x95y<L\x97=\x11\x84z2\xf4\x14=\x15\"z:DD\xcf\xf4oH?\x1b\x9a\xc9sAT\x9f\x0f\xa2\xfeB\x10\xee\xc5 \xecKA\x98\x97\xf1N\x1d\xbf\"\x8f\x87~Ur\xad_\v\x82^\x97N\xfe\x86\x04y\xf2f\x10\xe6-\xe9Do\v\xd3w\xa4\x91\xeaw\x83\xc8\xde\vB\xbd\x1f\x04}\x10\x84\xfb0\b\xfbQ\x10\xe6c\x99&\xfbD\xa8>\x95\x86\xa2\xcf$\xa0\xcf% \xfa\"\xec@\u007f)\x9d\xe4+a\xf5ka\xfd\x1b\xa1\xfbVh\xbf\x13\x9a\xefq\xd8\xda\x0f\xb05\xfd#\xe6\xf1\x1f\xc5\u007f\n\x82~\x96N\xfe\x8b\x04y\xf2k\x10\xe67\xe9D\xbf\v\xd3?\xa4\x91\xea?\x83\xc8\xfe\nB\xfd\x1d\x04\xfd\x13\x84\xfb7\b\xfb_\x10f\x9eY\x98&\xfb\x9fP\xb5\xcdBCQ\xbb\x04\xd4!\x01Q\xa7\x88\\\x0f\x90N2PX\x9dWX\x9fO\xe8\xe6\x17\xda\x05\x84f\xc1Y\xfc\x06\xd5\\\x88m\xab\xa9\x17\xe6y\xf8{\xaeE\x82\xa0E\xa5\x93/&A\x9e,\x1e\x84YB:ђ\xc2t)i\xa4z\xe9 \xb2e\x82P\xcb\x06A\xcb\x05\xe1\x96\x0f®\x10\x84YQ\xa6\xc9V\x12\xaa\x95\xa5\xa1h\x15\thU\t\x88V\v;ЫK'YCX]SX_K\xe8\xd6\x16\xdau\x84f]>l\xdc\\\x8fm\xdc\xd4\xeb\xf3<\xfc\x1d\xd8\x06AІ\xd2\xc97\x92 O6\x0e\xc2l\"\x9dhSa\xba\x994R\xbdy\x10\xd9\x16A\xa8-\x83\xa0\xad\x82p[\aa\xb7\t\xc2l+\xd3d\xdb\t\xd5\xf6\xd2P\xb4\x83\x04\xb4\xa3\x04D;\x85\x1d蝥\x93\xec\"\xac\xee*\xac\xef&t\xbb\v\xed\x1eB\xb3'\xeelm/\x9c\xbd\xa6\xf7ƃ\xe6\x9fƃ\x82\xa0}\xa4\x93\xef+A\x9e\f\x0e\xc2\f\x91N4T\x98\x0e\x93F\xaa\xf7\v\"\xdb?\bu@\x10t`\x10\xee\xa0 \xec\xc1A\x98\xe12Mv\x88P\x1d*\rE\x87I@\x87K@4\"\xec@\x8f\x94Nr\x84\xb0z\xa4\xb0~\x94\xd0\x1d-\xb4\xc7\bͱ\xb3\xf8\x9fb\xac\xf0\x91kZq\xc8\u007f\xa1LH\x11\xe2<\x86͓QB\xa3\x11G\x06HkHS\x9d\b\xb3\xbaP\xa5Bʄ.\x17\xdaBh,\x86g\xa3\x01\xd5@\xaa\x88`\xc9\xc1\x125eI=\x06q\xd2\x05TK\xa0\xde\x02\xdcX\xc0\x1e\a\x98\xe3g\xb55*'\xccjoT\xf4\x89\xb3:|\xd5'\x01t2g\xf9)l\xf2\xe4T\xc0\x9c\xc6Yt:\xd7\xf4\f\x8eR}&\x90\x9d\x05\xa8\xb3\x01:\ap\xe7\x02\xf6<\xc0\x9c\xcfò\v\xb8\xaa\v9Rt\x11\x1b\xba\x98\r\xd1%XC_\xcaYr\x19\xd7\xea\xe5\\\xebWpuWr\xb5Wq5Ws\x8d\xaf\xe1\x01\xb1\xbevV'C_'\xa4\xeb\x11\xe77\xc0\xe6ɍBs\x13\xe2h\x1c\x90v#Mu\x8f0\xeb\x15\xaa>!\xdd,t\xb7\b\xed\xadBs\x1b\x86g\xb7\x03\xea\x0e\xa4\x8a\ue125\xf1\xb0D\x13dI=\x11q2\t\xa8N\x06\xeaS\x007\x15\xb0\xd3\x003\xdd\x1f\xa8U\x99\xe1M\xab\xa2g\xfa\xe1\xfc\xcd\xd8,!\xcdF\x9cρ͓\xb9Bs\x17\xe2\xe8n \xbd\ai\xaa\xef\x15f\xf7\t\xd5\xfdBz@\xe8\x1e\x14ڇ\x84\xe6a\f\xcf\x1e\x01ԣH\x15=\x06K\x8f\xc3\x12=!K\xea'\x11'O\x01է\x81\xfa3\x80{\x16\xb0\xcf\x01\xe6y ~\x01\x03c\xfd\xe2\xac\x01\xa0~)\bzY:\xf9+\x12\xe4ɫA\x98פ\x13\xbd.LߐF\xaa\xdf\f\"{+\b\xf5v\x10\xf4N\x10\xee\xdd \xec{A\x98\xf7e\x9a\xec\x03\xa1\xfaP\x1a\x8a>\x92\x80>\x96\x80蓰\x03\xfd\xa9t\x92τ\xd5υ\xf5/\x84\xeeK\xa1\xfdJh\xbe\xf6w/.\xbe\xf1G\xf6\xbf\xa7}\xebC\xfe\xc5\xed;!}\x8f8\xff\x016O~\x14\x9a\x9f\x10G?\x03\xe9/HS\xfd\xab0\xfbM\xa8~\x17\xd2\x1fB\xf7\xa7\xd0\xfe%4\u007fcx\xf6\x0f\xa0\xfeE\xaa\xe8?X\x9ag6[\xa2\xff\x81\xb9n\x9b\xcdq\xd2\x0eT;\x80z'\xe0\x06\x00v `\xe6\x9d\xdd\u0588\xe7\x9b\xedO\xa5\xe7\xe7D\xeb\x05\x00Z\x90\xb3|!6y\xb20`\x16\xe1,Z\x94k\xba\x18G\xa9^\x1cȖ\x00Ԓ\x00-\x05\xb8\xa5\x01\xbb\f`\x96\xe5a\xd9r\\\xd5\xf2\x1c)Z\x81\r\xadȆh%\xac\xa1W\xe6,Y\x85kuU\xae\xf5ո\xbaչ\xda5\xb8\x9a5\xfd\xa5\xad\xb8X˟\x96\xbf\x97Z{\xf6\x00P\xaf\x13\x04\xad+\x9d|=\t\xf2d\xfd \xcc\x06҉6\x14\xa6\x1bI#\xd5\x1b\a\x91m\x12\x84\xda4\b\xda,\b\xb7y\x10v\x8b ̖2M\xb6\x95Pm-\rE\xdbH@\xdbJ@\xb4]\u0601\xde^:\xc9\x0e\xc2\xea\x8e\xc2\xfaNB\xb7\xb3\xd0\xee\"4\xbb\xfa#\xb7\xe2\xddpd\xbd;B\xad\xf7\x10Ҟ\x88\xf3\xbd`\xf3do\xa1\x19\x848\xda\aH\xf7E\x9a\xea\xc1\xc2l\x88P\r\x15\xd20\xa1\xdbOh\xf7\x17\x9a\x030<;\x10P\a!Ut0,\r\x87%:D\x96ԇ\"N\x0e\x03\xaa\x87\x03\xf5\x11\x80\x1b\t\xd8#\x00s\xa4\u007f\xca\x15G\xf9S\x15\xfah\x9f\xf8\xfbv\f@\xc7r\x96W\xd8\xe4\x89\x02L\x95\xb3(\xe2\x9a\xc6\x1c\xa5z\x14\x90i@\x19\x80j\x80K\x00[\aL\xcaò\x8c\xab\xca9RT\xb0!ˆh4\xd6\xd0\r\xce\x12\xe2Zu\\\xebM\xaen\fW\xdb\xc5Ք\xbevUZ~@WE\x8f\xf5g\xe6o\x95\x8e\x13\xd2\xf1\x88\xf3\x13`\xf3\xe4D\xa19\tqt2\x90\x9e\x824է\n\xb3ӄ\xeat!\x9d!tg\n\xedYBs6\x86g\xe7\x00\xea\\\xa4\x8a\u0383\xa5\xf3a\x89.\x90%\xf5\x85\x88\x93\x8b\x80\xea\xc5@\xfd\x12\xc0]\n\xd8\xcb\x00s9\x10_\x81\x81\xb1\xbe\xd2?=\xf1\xcd\xd1UA\xd0\xd5\xd2ɯ\x91 O\xae\r\xc2\\'\x9d\xe8zaz\x834R}c\x10\xd9MA\xa8qAPw\x10\xae'\b\xdb\x1b\x84\xe9\x93i\xb2\x9b\x85\xea\x16i(\xbaU\x02\xbaM\x02\xa2\xdb\xc3\x0e\xf4\x1d\xd2I\xee\x14V\xc7\v\xeb\x13\x84n\xa2\xd0N\x12\x9a\xc9|\x0f\xe3)|\xbbc=Շ\xfc\xed\xd04!MG\x9cπ͓\x99B3\vq4\x1bH\xe7 M\xf5\\av\x97P\xdd-\xa4{\x84\xee^\xa1\xbdOh\xee\xc7\xf0\xec\x01@=\x88T\xd1C\xb0\xf40,\xd1#\xb2\xa4~\x14q\xf2\x18P}\x1c\xa8?\x01\xb8'\x01\xfb\x14`\x9e\xe67\x85\xe2\x19~A\x15\xfaY~\t\xfa\x97\xd1sBz\x1eq\xfe\x02l\x9e\xbc(4/!\x8e^\x06\xd2W\x90\xa6\xfaUa\xf6\x9aP\xbd.\xa47\x84\xeeM\xa1}Kh\xde\xc6\xf0\xec\x1d@\xbd\x8bT\xd1{\xb0\xf4>,\xd1\a\xb2\xa4\xfe\x10q\xf2\x11P\xfd\x18\xa8\u007f\x02\xb8O\x01\xfb\x19`>\xf7o\n\xcd/\xfc\xa9\x9a\xfaK\x9f\xf8OP_\x01\xf45g\xf97l\xf2\xe4[\xc0|\xc7Y\xf4=\xd7\xf4\a\x8eR\xfd#\x90\xfd\x04\xa8\x9f\x01\xfa\x05p\xbf\x02\xf67\xc0\xfc\xceò?\xb8\xaa?9R\xf4\x17\x1b\xfa\x9b\r\xd1?XC\xff\xcbY\xf2\x1f\xd7\xea<s|\xad\xff\x8f\xabk\xe3j۹\x9a\x8e9\xfe5\x14\x17\x9ds:\x19z\xc0\x9c\x01\xa0\x1e\x18\x04\xcd+\x9d|>\t\xf2d\xfe \xcc\x02҉\x16\x14\xa6\vI#\xd5\v\a\x91-\x12\x84Z4\bZ,\b\xb7x\x10v\x89 ̒2M\xb6\x94P--\rE\xcbH@\xcbJ@\xb4\\\u0601^^:\xc9\n\xc2\xea\x8a\xc2\xfaJB\xb7\xb2Ю\"4\xab\xfa#wū\xe1\xc8zu\x84Z\xaf!\xa45\x11\xe7k\xc1\xe6\xc9\xdaB\xb3\x0e\xe2h] ]\x0fi\xaa\xd7\x17f\x1b\bՆB\xdaH\xe86\x16\xdaM\x84fS\f\xcf6\x03\xd4\xe6H\x15m\x01K[\xc2\x12m%K\xea\xad\x11'\xdb\x00\xd5m\x81\xfav\x80\xdb\x1e\xb0;\x00fG>Pm'65\xbd3\x0f\xf7\x1f\xf0v\x11Ү\x88\xf3\xdd`\xf3dw\xa1\xd9\x03q\xb4'\x90\xee\x854\xd5{\v\xb3AB\xb5\x8f\x90\xf6\x15\xba\xc1B;Dh\x86bx6\fP\xfb!U\xb4?,\x1d\x00Kt\xa0,\xa9\x0fB\x9c\x1c\fT\x87\x03\xf5C\x00w(`\x0f\x03\xcc\xe1\xfe@\xad\xe6\boZM=\xd2\x0f\xe7o]\x8e\x10ґ\x88\xf3\xa3`\xf3\xe4h\xa19\x06qt,\x90V\x90\xa6Z\t\xb3\xaaPEB\x8a\x85n\x94\xd0j\xa11\x18\x9e\xd5\x00\x95 UT\x87\xa5\x14\x96(\x93%u\x8e8)\x80\xaa\x05\xea\xa3\x01\xd7\x00,\x01\xc6\xf9\x03\xc5ͦ7qS\x8f\xf1\xc3\xf9\x9b\x95.!\x95\x88\xf3\x16l\x9e\x8c\x15\x9a\xe3\x10G\xc7\x03\xe9\tHS}\xa20;I\xa8N\x16\xd2)Bw\xaaО&4\xa7cxv\x06\xa0\xceD\xaa\xe8,X:\x1b\x96\xe8\x1cYR\x9f\x8b89\x0f\xa8\x9e\x0f\xd4/\x00܅\x80\xbd\b0\x17\xf3\x1d\xaa]§\xab\xe9K\xf9\xf1\xf0O\xb9˄t9\xe2\xfc\n\xd8<\xb9Rh\xaeB\x1c]\r\xa4\xd7 M\xf5\xb5\xc2\xec:\xa1\xba^H7\bݍB{\x93Ќ\xc3\xf0\xac\x1bP=H\x15\xf5\xc2R\x1f,\xd1Ͳ\xa4\xbe\x05qr+P\xbd\r\xa8\xdf\x0e\xb8;\x00{'`\xc6\xcfik\xd4&\xf8S\xd5\xf4D\x9f\xf0_\x1a\x03h2g\xf9\x146y2\x150\xd38\x8b\xa6sMgp\x94\xea\x99@6\vP\xb3\x01\x9a\x03\xb8\xb9\x80\xbd\v0w\xf3\xb0\xec\x1e\xae\xea^\x8e\x14\xdddž\xeegC\xf4\x00\xd6\xd0\x0fr\x96<ĵ\xfa0\xd7\xfa#\\ݣ\\\xedc\\\xcd\xe3sڲ\xca\x13sڳ\x8a~rN\x87\xaf\xfa)\x80\x9e\xe6,\u007f\x86M\x9e<\v\x98\xe78\x8b\x9e皾\xc0Q\xaa_\x04\xb2\x97\x00\xf52@\xaf\x00\xeeU\xc0\xbe\x06\x98\xd7yX\xf6\x06W\xf5&G\x8a\xdebCo\xb3!z\ak\xe8w9K\xde\xe3Z}\x9fk\xfd\x03\xae\xeeC\xae\xf6#\xae\xe6c\xae\xf1'< ֟\xce\xe9d\xe8τ\xf49\xe2\xfc\v\xd8<\xf9Rh\xbeB\x1c}\r\xa4\xdf M\xf5\xb7\xc2\xec;\xa1\xfa^H?\bݏB\xfb\x93\xd0\xfc\x8c\xe1\xd9/\x80\xfa\x15\xa9\xa2\xdf`\xe9wX\xa2?dI\xfd'\xe2\xe4/\xa0\xfa7P\xff\ap\xff\x02\xf6?\xc0\xcc3\xb7=kU\xfe7\xb7\xc3W\xdd6\xb7\x93\xa1ۅԁ8\xef\x84͓\x01B3\x10q4/\x90·4\xd5\xf3\v\xb3\x05\x84jA!-$t\v\v\xed\"B\xb3(\x86g\x8b\x01jq\xa4\x8a\x96\x80\xa5%a\x89\x96\x92%\xf5҈\x93e\x80\xea\xb2@}9\xc0-\x0f\xd8\x15\x00\xb3\"\x10\xaf\x84\x81\xb1^y\xee\x00P\xaf\x12\x04\xad*\x9d|5\t\xf2d\xf5 \xcc\x1a҉\xd6\x14\xa6kI#\xd5k\a\x91\xad\x13\x84Z7\bZ/\b\xb7~\x10v\x83 ̆2M\xb6\x91Pm,\rE\x9bH@\x9bJ@\xb4Y\u0601\xde\\:\xc9\x16\xc2\xea\x96\xc2\xfaVB\xb7\xb5\xd0n#4\xdb\xfa\xbb\x17\x17\xdb\xf9#\xfb\xdfs\xb6\xf7!\xff\u07b3\x83\x90vD\x9c\xef\x04\x9b';\v\xcd.\x88\xa3]\x81t7\xa4\xa9\xde]\x98\xed!T{\ni/\xa1\xdb[h\a\t\xcd>\x18\x9e\xed\v\xa8\xc1H\x15\r\x81\xa5\xa1\xb0D\xc3dI\xbd\x1f\xe2d\u007f\xa0z\x00P?\x10p\a\x01\xf6`\xc0\f\x9fۖŇ\xf0\xa9\xf4\xa1\x9ch}\x18@\x87s\x96\x8f`\x93'#\x01s\x04gё\\ӣ8J\xf5\xd1@v\f\xa0\x8e\x05\xa8\x028\x05\xd8*`\"\x1e\x96\xc5\\\xd5(\x8e\x14i6d\xd8\x10հ\x86N8K\xea\\\xab)\xd7z\xc6\xd5\xe5\\m\xc1\xd5X~\xca\xc5\xc5h\xbe)\xfc\xaf\x8a\xf1\xdd\xc4?+\x16\x049\xe9\xe4M\t\xf2dL\x10\xa6K:Q)L[\xd2H\xf5\xd8 \xb2\xe3\x82P\xc7\aA'\x04\xe1N\f\u009e\x14\x849Y\xa6\xc9N\x11\xaaS\xa5\xa1\xe84\t\xe8t\t\x88\xce\b;\xd0gJ'9KX=[X?G\xe8\xce\x15\xda\xf3\x84\xe6|~È/\xc0\x91\xf5\x85\b\xb5\xbeHH\x17#\xce/\x81͓K\x85\xe62\xc4\xd1\xe5@z\x05\xd2T_)̮\x12\xaa\xab\x85t\x8d\xd0]+\xb4\xd7\t\xcd\xf5\x18\x9e\xdd\x00\xa8\x1b\x91*\xba\t\x96\xc6\xc1\x12u˒\xba\aq\xd2\vT\xfb\x80\xfà\xbb\x05\xb0\xb7\x02\xe66\xff\x94+n\xf7\xa7*\xf4\x1d>\xe1\u007f\x85\f\xa0\xf1\x9c\xe5\x13\xd8\xe4\xc9D\xc0L\xe2,\x9a\xcc5\x9d\xc2Q\xaa\xa7\x02\xd94@M\ah\x06\xe0f\x02v\x16`f\xf3\xb0l\x0eW5\x97#Ew\xb1\xa1\xbb\xd9\x10݃5\xf4\xbd\x9c%\xf7q\xad\xdeϵ\xfe\x00W\xf7 W\xfb\x10W\xf3\xb0\xaf]\x95G\xfc\x80\xae\x8a~ԟ\x99\xbf\byLH\x8f#Ο\x80͓'\x85\xe6)\xc4\xd1\xd3@\xfa\f\xd2T?+̞\x13\xaa\xe7\x85\xf4\x82н(\xb4/\t\xcd\xcb\x18\x9e\xbd\x02\xa8W\x91*z\r\x96^\x87%zC\x96\xd4o\"N\xde\x02\xaao\x03\xf5w\x00\xf7.`\xdf\x03\xcc\xfb@\xfc\x01\x06\xc6\xfaC\xff\xf4\xc4\x17!\x1f\x05A\x1fK'\xffD\x82<\xf94\b\xf3\x99t\xa2υ\xe9\x17\xd2H\xf5\x97Ad_\x05\xa1\xbe\x0e\x82\xbe\t\xc2}\x1b\x84\xfd.\b\xf3\xbdL\x93\xfd T?JC\xd1O\x12\xd0\xcf\x12\x10\xfd\x12v\xa0\u007f\x95N\xf2\x9b\xb0\xfa\xbb\xb0\xfe\x87\xd0\xfd)\xb4\u007f\t\xcd\xdf|\x0f\xffO\xd3YGWn3Q\xbc\x9b\xa52333333Sd\xbfJ\x91m\xc5\xed(MSfffffZ\xe82\xef\xb6\xfd\xca\xcc\xcc\xcc\xed\xe7\xb9W\xef\x9f\xf9\xdd\xf9\xcdʲ\x1f%\xcf\xe7\xecI\xeb\x1f}\xba[\xf6\xdfFꍐ\xffH\x99n\x88\xea\xd0o\x88\xb6\xc1w\x90\xae?t>\x00(\a\u0096v\x10Y\r&\xcd\xf4\xa4\xcc@\xc6\x19\xc9z&\xd2͌\xe5\xd5,\x80\x99\x15\xd6\xc8lhev\xb4\"spK;'\xb4\x9f\v\xc8\xe6\x06\x8ay\x808/P\xcf\a\xb8\xf9\x874\x1f\n\xdd\v4M_\xb7]\xb0Y\xae7B\x16\"ea\xe8\xb0\b\xda\xe0\x17%\xddb\xd0\xf9\xe2@\xb9\x04li\x97$\xab\xa5H\xb34)ːqY\xb2^\x8et\xcbcy\xb5\x02`V\x845\xb2\x12ZY\x19\xad\xc8*\xdcҮ\n\xedW\x03\xb2Ձb\r \xae\t\xd4k\x01n\xed!\x1dU\xcf:\xcdU\xf5\xd8u\x1b\xd3|\xe1Y\x0f\x90\xf5Յ\r\xb4\t~C\xc0m\xa4.\xdfXk\xb9\x89\xaa\xd2n\nT\x9b\x01fs@\xb6\x00\xe2\x96@\xbd\x15\xe0\xb6\xd6e\xd56ZͶ\xaa\x8cl\xa7\x8dl\xaf\x8d\xc8\x0e\xd8\xc3\xee\xa8\xce\xef\xa45\xdbYk\xb1\x8bָ\xab\xd6z7\xadn\xf7\xe6\x9f\xf6\xb6\xba\xf7h\xaeV\xef{\xec9d\x10h\xf7JA\xf6\xe6$\xecC\x11\xfc\xbe)\xb8\xfd8\xc9\xf7'\xcb\x038(\xed\x81)T\a\xa5`\x0eNA\x0eI!\x1e\x9aB}X\n\xeep\x1e\xa6\xea$\x8d\xe1\xc0HF!9\x85H+\x9d\x81=\x82\x13o\xc9̑E\x17\x19=Y\x17\xa4+\x9bK\xeemU\xb8d\x1b \xad\xed&\xa5\x86\x0eG\xa2\r\xfe(\xd2\tt\x1e\x81\xb2\a\xb6\xb4G\x93U/i\x8e!\xa5\x8f\x8cǒ\xf5q\xa4;\x1e˫\x13\x00s\"\xac\x91\x93\xd0\xca\xc9hEN\xe1\x96\xf6Th\u007f\x1a\x90\x9d\x0e\x14g\x00\xf1L\xa0>\vpg\xeb\x05u\x9d\xa3M\x97=W\x977\xdf\xe3\xce#\xe5|\xe8p\x01\xda\xe0/$\xddE\xd0\xf9\xc5@y\tli/%\xab\xcbHs9)W\x90\xf1J\xb2\xbe\x8atWcyu\r`\xae\x855r\x1dZ\xb9\x1e\xad\xc8\r\xdc\xd2\xde\b\xedo\x02\xb2\x9b\x81\xe2\x16 \xde\nԷ\x01\xeev\xfdP\xe8\xb9C\xdfP=\xf6N}\v6o\xa3\xbbH\xb9\x1b:܃6\xf8{Iw\x1ft~?P>\x00[\xda\a\xc9\xea!\xd2<L\xca#d|\x94\xac\x1f#\xdd\xe3X^=\x01\x98'a\x8d<\x85V\x9eF+\xf2\f\xb7\xb4\xcfB\xfb!@6\x14(\x86\x01q8P?\a\xb8\x11\xcd\x05\xb5zF6M\xabǎj\x96덐Ѥ\x8c\x81\x0ec\xd1\x06?\x8et\xe3\xa1\xf3\t@9\x11\xb6\xb4\x93\xc8j2i\xa6\x902\x95\x8c\xd3\xc8\xfayҽ\x80\xe5Ջ\x80\xf9\x1f\xac\x91\x97\xd0\xca\xcbhE^\xe1\x96\xf6Uh\xff\x1a\x90\xbd\x0e\x14o\x00\xf1M\xa0~\vpo\xeb3\xd4\xf5\x8e^]\x97}W\x1f\x8f\xe6%\xf7\x1e)\xefC\x87\x0f\xd0\x06\xff!\xe9>\x82\xce?\x06\xcaO`K\xfb)Y}F\x9a\xcfI\xf9\x82\x8c_\x92\xf5W\xa4\xfb\x1a˫o\x00\xf3-\xac\x91\xef\xd0\xca\xf7hE~\xe0\x96\xf6Gh\xff\x13\x90\xfd\f\x14\xbf\x00\xf1W\xa0\xfe\rp\xbf7\x1f\xdb]\u007f4W\xd5e\xffl\x8c\xfe\xa71@\xfeV\x17\xfe\xd1&\xf8\u007f\x01\xf7\x9f\xba|\xba\xa1M-\xfb\rmTi;\x80\xaa?`\x06\x002\x10\x88\x83\x80z0\xe0\xa6\xd7e\xd5\fZ͌\xaa\x8c̤\x8d̬\x8d\xc8,\x8a`gU\xe7gӚͮ\xb5\x98Ck\x9cSk=\x97V7\xf7\xd0\x0e\xd39\xcf\xd0\xfe\xa6\xd3\xce;t@S\xed|\x80̯.,\xa0M\xf0\v\x02n!u\xf9\xc2Z\xcbET\x95vQ\xa0Z\f0\x8b\x03\xb2\x04\x10\x97\x04\xea\xa5\x00\xb7\xb4.\xab\x96\xd1j\x96Ued9mdymDV\xc0\x1evEu~%\xad\xd9\xcaZ\x8bU\xb4\xc6U\xb5֫iu\xabkm\xad\xa1\vZv͡\x03\x15v-Rֆ\x0e\xeb\xa0\r~]ҭ\a\x9d\xaf\x0f\x94\x1b\xc0\x96vC\xb2ڈ4\x1b\x93\xb2\t\x197%\xeb\xcdH\xb79\x96W[\x00fKX#[\xa1\x95\xadъl\xc3-\xed\xb6\xd0~; \xdb\x1e(v\x00\xe2\x8e@\xbd\x13\xe0vn.\xa8\xafs\x97\xa6\xe9봻6\xcb\xf5F\xc8n\xa4\xec\x0e\x1d\xf6@\x1b\xfc\x9e\xa4\xdb\v:\xdf\x1b(\xf7\x81-\xed\xbed\xb5\x1fi\xf6'\xe5\x002\x1eH\xd6\a\x91\xee`,\xaf\x0e\x01̡\xb0F\x0eC+\x87\xa3\x15\xe9\xe4\x96\xd6@\xfb\f\xc8r\xa0h\x01\xf1\b\xa0\xb6\x80s@\xab\v\v[\xd6\x0f\x1d\x04\xda\"\x05)9\t\x15E\xf0!\x05\xd7\xcdI^\x93\xe5\x91\x1c\x94\xf6\xa8\x14*I\xc1\xc4\x14\xa4'\x85xt\nuo\n\xee\x18\x1e\xa6\xea#ͱ\x1c\x189\x8eB\x8e\xa7\x109!\x9d\x81=\x91\x13\u007f\x12\x99\x9dL\x16\xa7\x90\xf1T\xb2>\x8dt\xa77\xcf^\xab\xfb\x8c撛\xdfs\xcel\xa4\xfe\xdes\x16)gC\x87s\xd0\x06\u007f.\xe9\u0383\xce\xcf\a\xca\v`K{!Y]D\x9a\x8bI\xb9\x84\x8c\x97\x92\xf5e\xa4\xbb\x1c˫+\x00s%\xac\x91\xab\xd0\xca\xd5hE\xae\xe1\x96\xf6Zh\u007f\x1d\x90]\x0f\x147\x00\xf1F\xa0\xbe\tp77\x1f\n\xad[\xf4\xaa\xec\xadj\xac\xbd\r\x90\xdbՅ;\xb4\t\xfeN\xc0ݥ.\xbf[ky\x8f\xaa\xd2\xde\vT\xf7\x01\xe6~@\x1e\x00\xe2\x83@\xfd\x10\xe0\x1e\xd6e\xd5#Zͣ\xaa\x8c<\xa6\x8d<\xae\x8d\xc8\x13\xd8\xc3>\xa9\xce?\xa55{Zk\xf1\x8c\xd6\xf8\xac\xd6z\x88V7T_r\xad\xeea\xfa\xa4\xe8\xdf\xf8\xd2g\x13\u007f\xe3+\x05\x19\xc1I\x18I\x11\xfc\xa8\x14\xdchN\xf21d9\x96\x83ҎK\xa1\x1a\x9f\x82\x99\x90\x82LL!NJ\xa1\x9e\x9c\x82\x9b\xc2\xc3TSI3\x8d\x03#\xcfS\xc8\v\x14\"/\xa63\xb0\xff\xe3ĿDf/\x93\xc5+d|\x95\xac_#\xdd\xeb\xfa\x81\xd1z\x03\x97l߄\xb4\xf6-Rކ\x0e\xef\xa0\r\xfe]ҽ\a\x9d\xbf\x0f\x94\x1f\xc0\x96\xf6C\xb2\xfa\x884\x1f\x93\xf2\t\x19?%\xeb\xcfH\xf79\x96W_\x00\xe6KX#_\xa1\x95\xafъ|\xc3-\xed\xb7\xd0\xfe; \xfb\x1e(~\x00\xe2\x8f@\xfd\x13\xe0~n^rݿ4W\xd5m\u007fm\x8c\xfei/@~W\x17\xfe\xd0&\xf8?\x01\xf7\x97\xba\xfco\xad\xe5?\xaaJ\xfb/P\xfd\a\x98\xe9\x86)\xa4\x1f\x10;\x80\xba?\xe0\x06\fk\x96U\x03\xb5\x9aA\xaa\x8c\f\xd6F\xa6\xd7Fd\x06E\xb03\xaa\xf33i\xcdf\xd6Z̢5Ϊ\xb5\x9eM\xab\x9b\xbd\xa9\xbd\x9ds4\vz;\xed\x9c\xc3\x06*\xec\\\xa4\xcc\r\x1d\xe6A\x1b\xfc\xbc\xa4\x9b\x0f:\x9f\x1f(\x17\x80-\xed\x82d\xb5\x10i\x16&e\x112.J\u058b\x91nq,\xaf\x96\x00̒\xb0F\x96B+K\xa3\x15Y\x86[\xdae\xa1\xfdr@\xb6<P\xac\x00\xc4\x15\x81z%\xc0\xad\f\xb4V\xc1\u0096]u\xd8 Ю\x96\x82\xac\xceIX\x83\"\xf85Spkq\x92\xafM\x96\xebpP\xdauS\xa8\xd6K\xc1\xac\x9f\x82l\x90B\xdc0\x85z\xa3\x14\xdc\xc6<L\xb5\ti6\xe5\xc0\xc8f\x14\xb29\x85\xc8\x16\xe9\f얜\xf8\xad\xc8lk\xb2؆\x8cے\xf5v\xa4\xdb^\x9f\xc3\xd6\x0e\xfat\xb7쎍\xd4\x1b!;\x91\xb23t\xd8\x05m\xf0\xbb\x92n7\xe8|w\xa0\xdc\x03\xb6\xb4{\x92\xd5^\xa4ٛ\x94}ȸ/Y\xefG\xba\xfd\xb1\xbc:\x000\a\xc2\x1a9\b\xad\x1c\x8cV\xe4\x10ni\x0f\x85\xf6\x87\x01\xd9\xe1@\xd1\tD\x03\xd4\x19\xe0\xf2\xe6\x82\xfa\xba[M\xd3\xd7m\x8fh\x96\xeb\x8d\x10K\x8a\x83\x0e]h\x83\xf7\xa4+\xa0\xf3\x12(+\xd8\xd2\x06\xb2\xea&MMʑd<\x8a\xac\x85t\x11˫\x1e\xc0\x1c\rk\xa4\x17\xad\x1c\x83V\xa4\x8f[\xdac\xa1\xfdq@v<P\x9c\x00\xc4\x13\x81\xfa$\xc0\x9d<\xac\xc3\xf4\x9c\xd2\\U\x8f=\xb51\xcd\x17\x9e\xd3\x009]]8C\x9b\xe0\xcf\x04\xdcY\xea\U000b3d56\xe7\xa8*\xed\xb9@u\x1e`\xce\a\xe4\x02 ^\b\xd4\x17\x01\xeeb]V]\xa2\xd5\\\xaa\xca\xc8e\xda\xc8\xe5ڈ\\\x81=\xec\x95\xea\xfcUZ\xb3\xab\xb5\x16\xd7h\x8d\xd7j\xad\xaf\xd3\xea\xae\xd7\xf7P\xab\xfb\x06}\x955?vnԗ\xa7\xfe\x1c\xba)\x05\xb9\x99\x93p\vE\xf0\xb7\xa6\xe0n\xe3$\xbf\x9d,\xef࠴w\xa6Pݕ\x82\xb9;\x05\xb9'\x85xo\n\xf5})\xb8\xfby\x98\xea\x01\xd2<ȁ\x91\x87(\xe4a\n\x91G\xd2\x19\xd8G9\xf1\x8f\x91\xd9\xe3d\xf1\x04\x19\x9f$\xeb\xa7H\xf7\xb4~\x02\xb6\x9e\xc1%\xdbg!\xad\x1dB\xcaP\xe80\fm\xf0\xc3I\xf7\x1ct>\x02(G\u0096v\x14Y\x8d&\xcd\x18Rƒq\x1cY\x8f'\xdd\x04,\xaf&\x02f\x12\xac\x91\xc9he\nZ\x91\xa9\xdc\xd2N\x83\xf6\xcf\x03\xd9\v@\xf1\"\x10\xff\a\xd4/\x01\xeee\xbd\xa0\xaeW\xb4鲯\xea\xf2\xe6{\xdck\xa4\xbc\x0e\x1d\xde@\x1b\xfc\x9b\xa4{\v:\u007f\x1b(߁-\xed\xbbd\xf5\x1ei\xde'\xe5\x032~H\xd6\x1f\x91\xeec,\xaf>\x01̧\xb0F>C+\x9f\xa3\x15\xf9\x82[\xda/\xa1\xfdW@\xf65P|\x03\xc4o\x81\xfa;\xc0}\xaf\x1f\n=?\xe8\x1b\xaa\xc7\xfe\xa8o\xc1\xe6m\xf4\x13)?C\x87_\xd0\x06\xff+\xe9~\x83\xce\u007f\a\xca?`K\xfb'Y\xfdE\x9a\xbfI\xf9\x87\x8c\xff\x92\xf5\u007f\xa4\x9bn\xb8.\xaf\xfa\x01\xa6c\xb8Z#\xfd\xd1\xca\x00\xb4\"\x03\xc1`\aA\xfb\xc1@6=P\xcc\x00\xc4\x19\x81z&\xc0\xcd<\xbc\xf9m\xafg\x96\xa6i\xf5\xd8Y\x9b\xe5z#d6Rf\x87\x0es\xa0\r~N\xd2\xcd\x05\x9d\xcf\r\x94\xf3\xc0\x96v^\xb2\x9a\x8f4\xf3\x93\xb2\x00\x19\x17$\xeb\x85H\xb70\x96W\x8b\x00fQX#\x8b\xa1\x95\xc5ъ,\xc1-\xed\x92\xd0~) [\x1a(\x96\x01\xe2\xb2@\xbd\x1c\xe0\x96o.\xa8\xafk\x05\xbd\xba.\xbb\xa2>\x1e\xcdKn%RV\x86\x0e\xab\xa0\r~Uҭ\x06\x9d\xaf\x0e\x94k\xc0\x96vM\xb2Z\x8b4k\x93\xb2\x0e\x19\xd7%\xeb\xf5H\xb7>\x96W\x1b\x00fCX#\x1b\xa1\x95\x8dъl\xc2-\xed\xa6\xd0~3 \xdb\x1c(\xb6\x00\xe2\x96@\xbd\x15\xe0\xb6\x1e\xdea\xba\xb6i\xae\xaa\xcbn\xdb\x18\xfd\xdfA\x80l\xaf.\xec\xa0M\xf0;\x02n'u\xf9\xceZ\xcb]T\x95vW\xa0\xda\r0\xbb\x03\xb2\a\x10\xf7\x04\xea\xbd\x00\xb7\xb7.\xab\xf6\xd1j\xf6Ued?md\u007fmD\x0e\xc0\x1e\xf6@u\xfe \xad\xd9\xc1Z\x8bC\xb4\xc6C\xb5ևiu\x877\xd5tv6\vL\xa75\xcd5뽐\x8c\x94\x1c:\xb4\xd0\x06\u007f\x04\xe9,t\ue032\v\xb6\xb4\x9e\xac\nҔ\xa4Td\fd\xddM\xba\x1a˫#\x01s\x14\xac\x11A+\x11\xadH\x0f\xb7\xb4GC\xfb^ ;\x06(\xfa\x80x,P\x1f\a\xb8\xe3\x81\xd6\tXز'\x0e\x1f\x04ړR\x90\x939\t\xa7P\x04\u007fj\n\xee4N\xf2\xd3\xc9\xf2\f\x0eJ{f\n\xd5Y)\x98\xb3S\x90sR\x88\xe7\xa6P\x9f\x97\x82;\x9f\x87\xa9. ͅ\x1c\x18\xb9\x88B.\xa6\x10\xb9$\x9d\x81\xbd\x94\x13\u007f\x19\x99]N\x16W\x90\xf1J\xb2\xbe\x8atW\xeb\xc5\xf6u^\xa3m_\xa7\xbdV\x8f\xa3\xf7P\xaeKA\xae\xe7$\xdc@\x11\xfc\x8d)\xb8\x9b8\xc9o&\xcb[8(\xed\xad)T\xb7\xa5`nOA\xeeH!ޙB}W\n\xeen\x1e\xa6\xba\x874\xf7r`\xe4>\n\xb9\x9fB\xe4\x81t\x06\xf6AN\xfcCd\xf60Y<B\xc6G\xc9\xfa1\xd2=N\xb6\x9e\xe0\x01Z\xf6\xc9\xe1\x83\x19\xecS\xed$O\xa7ax&\xa9\xe0\x9fm'7$\r\xf3\xa1)\x94\xc3Ҭ\xb4\xc3۩z\xae\x9d̈v\x92\x91\xed\x14G\xb5S=\xba\x9dܘt\xb8jl\nf\\\x9a\x19\x19\x9f\x94LHJdb\xfb\x84\xec\xa44\xf4\x93SȦ\xa4PLM!NK\xa1~>\x05\xf7\x82>\xeb\xad\xee\x17\xf5\xf1h~\xb3\xfa\x9fz\xfdU\xeb\xa5\x14\xe4eN\xc2+\x14\xc1\xbf\x9a\x82{\x8d\x93\xfcu\xb2|\x83\x83Ҿ\x99B\xf5V\n\xe6\xed\x14\xe4\x9d\x14\xe2\xbb)\xd4\xef\xa5\xe0\xde\xe7a\xaa\x0fH\xf3!\aF>\xa2\x90\x8f)D>Ig`?\xe5\xc4\u007fFf\x9f\x93\xc5\x17d\xfc\x92\xac\xbf\"\xdd\xd7\xfa\x01\xd5\xfa\x06\x97l\xbf\x85\xb4\xf6;R\xbe\x87\x0e?\xa0\r\xfeG\xd2\xfd\x04\x9d\xff\f\x94\xbf\xc0\x96\xf6W\xb2\xfa\x8d4\xbf\x93\xf2\a\x19\xff$\xeb\xbfH\xf77\x96W\xff\x00\xe6_X#\xff\xa1\x95\xe9\x9e\xd3V\xa4\x1f\x18l\xc7s\xaa}\u007f \x1b\x00\x14\x03\x818\b\xa8\a\x03nz]\xd1\xd7\xea\x9e\xe1\xb9A\xa0\x9d\xf1\xb9\xc1\fv\xa6v\x92\x99\xd30̒T\U00033d93\x9b-\r\xf3\xd9S(\xe7H\xb3\xd2\xce\xd9N\xd5\\\xedd\xe6n'\x99\xa7\x9d\xe2\xbc\xedT\xcf\xd7Nn\xfet\xb8j\x81\x14̂ifd\xa1\xa4d\xe1\xa4D\x16i\x9f\x90]4\r\xfdb)d\x8b\xa7P,\x91B\\2\x85z\xa9\x14\xdc\xd2\xfax\xf4\xb5\x96\xe1\xe3a\x97\xa5\xb7v\xb9\x14dyN\xc2\n\x14\xc1\xaf\x98\x82[\x89\x93|e\xb2\\\x85\x83Ү\x9aB\xb5Z\nf\xf5\x14d\x8d\x14\xe2\x9a)\xd4k\xa5\xe0\xd6\xe6a\xaauH\xb3.\aF֣\x90\xf5)D6Hg`7\xe4\xc4oDf\x1b\x93\xc5&dܔ\xac7#\xdd\xe6\xcf5/\xe3\xee-\xf4\x92\xbb\xed\x96*\xf5\x8fc\x91\xb25t\xd8\x06m\xf0ےn;\xe8|{\xa0\xdc\x01\xb6\xb4;\x92\xd5N\xa4ٙ\x94]ȸ+Y\xefF\xbaݱ\xbc\xda\x030{\xc2\x1a\xd9\v\xad\xec\x8dVd\x1fni\xf7\x85\xf6\xfb\x01\xd9\xfe@q\x00\x10\x0f\x04\xea\x83\x00w\xb0\xa2\xb7\xf3\x10]\xd8\xdbi\x0f\xd5\aF\xef\x03\x1d\x96\x82\x1c\xceI\xe8\xa4\bޤ\xe02N\xf2\x9c,[\x1c\x94\xf6\x88\x14*\x9b\x82q)HW\nѧP\x17)\xb8\x92\x87\xa9*\xd2\x04\x0e\x8ctSHM!rd:\x03{\x14'^\xc8,\x92E\x0f\x19\x8f&\xeb^\xd2\x1dC\xb6\xfax\x80\x96=V_\xfb\xb8Gt\\;\xc9\xf1i\x18NH*\xf8\x13\xdbɝ\x94\x86\xf9\xc9)\x94\xa7\xa4YiOm\xa7\xea\xb4v2\xa7\xb7\x93\x9c\xd1N\xf1\xccv\xaa\xcfj'wv:\\uN\n\xe6\xdc43r^Rr~R\"\x17\xb4O\xc8^\x98\x86\xfe\xa2\x14\xb2\x8bS(.I!^\x9aB}Y\n\xeer<\xf9\xad+\xf0ri\xd9+\xd5\xeb\xfd\xa3\xabR\x90\xab9\t\xd7P\x04\u007fm\n\xee:N\xf2\xeb\xc9\xf2\x06\x0eJ{c\n\xd5M)\x98\x9bS\x90[R\x88\xb7\xa6Pߖ\x82\xbb\x9d\x87\xa9\xee ͝\x1c\x18\xb9\x8bB\xee\xa6\x10\xb9'\x9d\x81\xbd\x97\x13\u007f\x1f\x99\xddO\x16\x0f\x90\xf1A\xb2~\x88t\x0f\xe3\x03\xaa\xfb\x11\xbc\x85\xbb\xed\xa3x\xef7o\xdb\xc7R\x90\xc79\tOP\x04\xffd\n\xee)N\xf2\xa7\xc9\xf2\x19\x0eJ\xfbl\nՐ\x14\xcc\xd0\x14dX\nqx\n\xf5s)\xb8\x11<L5\x924\xa3802\x9aB\xc6P\x88\x8cMg`\xc7q\xe2Ǔ\xd9\x04\xb2\x98H\xc6Id=\x99tS\xf4\x03\xaag\xaa^r\x8f\x9d\xa6\xb2\xf9~\xf9<)/@\x87\x17\xd1\x06\xff?ҽ\x04\x9d\xbf\f\x94\xaf\xc0\x96\xf6U\xb2z\x8d4\xaf\x93\xf2\x06\x19\xdf$\xeb\xb7H\xf76\x96W\xef\x00\xe6]X#\uf855\xf7ъ|\xc0-\xed\x87\xd0\xfe# \xfb\x18(>\x01\xe2\xa7@\xfd\x19\xe0>\xc7{\xb6\xd5\xfd\x05^\xbb\xcd\x0f\xd5/\xf1\xdaן\xb3_\xb5\x93|\x9d\x86ᛤ\x82\xff\xb6\x9d\xdcwi\x98\u007f\x9fB\xf9C\x9a\x95\xf6\xc7v\xaa~j'\xf3s;\xc9/\xed\x14\u007fm\xa7\xfa\xb7vr\xbf\xa7\xc3U\u007f\xa4`\xfeL3#\u007f%%\u007f'%\xf2O\xfb\x84\xec\xbfi\xe8\xffK!\x9bn\x04C\xd1/\x85ؑB\xdd?\x057`\x84~R\xb7\x06\x8e\xc0\xe3a\a\xd1[;8\x05\x99\x9e\x930\x03E\xf03\xa6\xe0f\xe2$\x9f\x99,gᠴ\xb3\xa6P͖\x82\x99=\x05\x99#\x858g\n\xf5\\)\xb8\xb9y\x98j\x1e\xd2\xccˁ\x91\xf9(d~\n\x91\x05\xd2\x19\xd8\x059\xf1\v\x91\xd9\xc2d\xb1\b\x19\x17%\xeb\xc5H\xb78.\xb6k\t\xb4]vI\x1c\xa7\xf9*\xbeT\n\xb24'a\x19\x8a\xe0\x97M\xc1-\xc7I\xbe<Y\xae\xc0AiWL\xa1Z)\x05\xb3r\n\xb2J\nq\xd5\x14\xea\xd5Rp\xab\xf30\xd5\x1a\xa4Y\x93\x03#kQ\xc8\xda\x14\"\xeb\xa43\xb0\xebr\xe2\xd7#\xb3\xf5\xc9b\x032nH\xd6\x1b\x91nc\xbdؾ\x9eM\xb4\xed뱛\xeaq\xf4>\xd7f)\xc8朄-(\x82\xdf2\x05\xb7\x15'\xf9\xd6d\xb9\r\a\xa5\xdd6\x85j\xbb\x14\xcc\xf6)\xc8\x0e)\xc4\x1dS\xa8wJ\xc1\xed\xcc\xc3T\xbb\x90fW\x0e\x8c\xecF!\xbbS\x88\xec\x91\xce\xc0\xeeɉߋ\xcc\xf6&\x8b}ȸ/Y\xefG\xba\xfd\xf5b[=\ah\xdb\xea\xb1\a\xeaq\xf4\x1e\xd8A)\xc8\xc1\x9c\x84C(\x82?4\x05w\x18'\xf9\xe1d\xd9\xc9AiM\nU\x96\x82\xc9S\x90V\n\xf1\x88\x14j\x9b\x82s<L\xd5E\x1aρ\x91\x82BJ\n\x91*\x9d\x81\r\x9c\xf8n2\xab\xc9\xe2H2\x1eE\xd6B\xba\x88g\xb6\xab\a\xd7\xdee\x8fƃּ\x8c{S\x90c8\t}\x14\xc1\x1f\x9b\x82;\x8e\x93\xfcx\xb2<\x81\x83Ҟ\x98BuR\n\xe6\xe4\x14\xe4\x94\x14\xe2\xa9)ԧ\xa5\xe0N\xe7a\xaa3Hs&\aF\u03a2\x90\xb3)D\xceIg`\xcf\xe5ğGf\xe7\x93\xc5\x05d\xbc\x90\xac/\"\xdd\xc5#\x9a\x1f=]\x97\xe8%w\xd9KU\xea\xff\r#\xe5r\xe8p\x05\xda\xe0\xaf$\xddU\xd0\xf9\xd5@y\rli\xaf%\xab\xebHs=)7\x90\xf1F\xb2\xbe\x89t7cyu\v`n\x855r\x1bZ\xb9\x1d\xad\xc8\x1d\xdc\xd2\xde\t\xed\xef\x02\xb2\xbb\x81\xe2\x1e \xde\v\xd4\xf7\x01\xee\xfe\x11\x1d\xd2\xf9\xc0\x88\xfe\xd2i\x1f\x1c1\xa0\xa9\xf6!@\x1eV\x17\x1e\xd1&\xf8G\x01\xf7\x98\xba\xfcq\xad\xe5\x13\xaaJ\xfb$P=\x05\x98\xa7\x01y\x06\x88\xcf\x02\xf5\x10\xc0\r\xd5e\xd50\xadf\xb8*#\xcfi##\xb4\x11\x19\x89=\xec(u~\xb4\xd6l\x8c\xd6b\xac\xd68Nk=^\xab\x9b\xa0\xb55Q\x17\xb4\xec\xa4\x11\x03\x15v2)S\xa0\xc3T\xb4\xc1O#\xdd\xf3\xd0\xf9\v@\xf9\"li\xffGV/\x91\xe6eR^!\xe3\xabd\xfd\x1a\xe9^\xc7\xf2\xea\r\xc0\xbc\tk\xe4-\xb4\xf26Z\x91w\xb8\xa5}\x17ڿ\ad\xef\x03\xc5\a@\xfc\x10\xa8?\x02\xdc\xc7\xcd\x05\xf5u~\xd24}\x9d\xf6\xd3f\xb9\xde\x19\xfb\x8c\x94ϡ\xc3\x17h\x83\xff\x92t_A\xe7_\x03\xe57\xb0\xa5\xfd\x96\xac\xbe#\xcd\xf7\xa4\xfc@\xc6\x1f\xc9\xfa'\xd2\xfd\x8c\xe5\xd5/\x80\xf9\x15\xd6\xc8oh\xe5w\xb4\"\u007fpK\xfb'\xb4\xff\v\xc8\xfe\x06\x8a\u007f\x80\xf8/P\xff\a\xb8\xe9F*Z\xfdF\xea\u0096\xed\x189\b\xb4\xfdS\x90\x01\x9c\x84\x81\x14\xc1\x0fJ\xc1\r\xe6$\x9f\x9e,g࠴3\xa6P͔\x82\x999\x05\x99%\x858k\n\xf5l)\xb8\xd9y\x98j\x0e\xd2\xccɁ\x91\xb9(dn\n\x91y\xd2\x19\xd8y9\xf1\xf3\x91\xd9\xfcd\xb1\x00\x19\x17$\xeb\x85H\xb7\xf0\xc8\xfe\xd2\xea^\xa4\xb9\xe4\xe6\xf7\xb4E\x1b\xa9\xbf\xb8-F\xca\xe2\xd0a\t\xb4\xc1/I\xba\xa5\xa0\xf3\xa5\x81r\x19\xd8\xd2.KVˑfyRV \xe3\x8ad\xbd\x12\xe9V\xc6\xf2j\x15\xc0\xac\nkd5\xb4\xb2:Z\x915\xb8\xa5]\x13گ\x05dk\x03\xc5:@\\\x17\xa8\xd7\x03\xdc\xfa#;\xa4\xb5\x81^\x95\xddP\x8d\xb5\x1b\x01\xb2\xb1\xba\xb0\x896\xc1o\n\xb8\xcd\xd4\xe5\x9bk-\xb7PU\xda-\x81j+\xc0l\r\xc86@\xdc\x16\xa8\xb7\x03\xdc\xf6\xba\xac\xdaA\xab\xd9Q\x95\x91\x9d\xb4\x91\x9d\xb5\x11\xd9\x05{\xd8]\xd5\xf9ݴf\xbbk-\xf6\xd0\x1a\xf7\xd4Z\xef\xa5\xd5\xed\xad/\xb9V\xf7>\xfa\xa4\xe8_\x15\xd3g\x13\u007fV,\x05ٟ\x93p\x00E\xf0\a\xa6\xe0\x0e\xe2$?\x98,\x0fᠴ\x87\xa6P\x1d\x96\x829<\x05\xe9L!\x9a\x14\xea,\x05\x97\xf30U\x8b4Gp`\xc4R\x88\xa3\x10\xe9Jg`='\xbe \xb3\x92,*2\x06\xb2\xee&]\xdd\\r_\xebH\\\xb2=\n\xd2Z!%B\x87\x1e\xb4\xc1\x1fM\xba^\xe8\xfc\x18\xa0\xec\x83-\xed\xb1du\x1ci\x8e'\xe5\x042\x9eH\xd6'\x91\xeed,\xafN\x01̩\xb0FNC+\xa7\xa3\x159\x83[\xda3\xa1\xfdY@v6P\x9c\x03\xc4s\x81\xfa<\xc0\x9d\u07fc\xe4\xba/h\xae\xaa\xdb^\xd8\x18\xfd+d\x80\\\xac.\\\xa2M\xf0\x97\x02\xee2u\xf9\xe5Z\xcb+T\x95\xf6J\xa0\xba\n0W\x03r\r\x10\xaf\x05\xea\xeb\x00w\xbd.\xabn\xd0jnTe\xe4&m\xe4fmDn\xc1\x1e\xf6Vu\xfe6\xad\xd9\xedZ\x8b;\xb4\xc6;\xb5\xd6wiuw7\xb5\xb7\xf3\x9efAo\xa7\xbd\xb7\xb9f\xbd\xabt\x1f)\xf7C\x87\a\xd0\x06\xff \xe9\x1e\x82\xce\x1f\x06\xcaG`K\xfb(Y=F\x9a\xc7Iy\x82\x8cO\x92\xf5S\xa4{\x1a˫g\x00\xf3,\xac\x91!he(Z\x91a\xdc\xd2\x0e\x87\xf6\xcf\x01\xd9\b\xa0\x18\t\xc4Q@=\x1apc\x80\xd6X,l\xd9q\xcd\xcb\x13w\x8eƧ \x138\t\x13)\x82\x9f\x94\x82\x9b\xccI>\x85,\xa7rP\xdai)Tϧ`^HA^L!\xfe/\x85\xfa\xa5\x14\xdc\xcb<L\xf5\ni^\xe5\xc0\xc8k\x14\xf2:\x85\xc8\x1b\xe9\f웜\xf8\xb7\xc8\xecm\xb2x\x87\x8c\xef\x92\xf5{\xa4{_\x9f\xc3\xd6\a\xfat\xb7쇍ԻC\x1f\x91\xf21t\xf8\x04m\xf0\x9f\x92\xee3\xe8\xfcs\xa0\xfc\x02\xb6\xb4_\x92\xd5W\xa4\xf9\x9a\x94o\xc8\xf8-Y\u007fG\xbaﱼ\xfa\x010?\xc2\x1a\xf9\t\xad\xfc\x8cV\xe4\x17ni\u007f\x85\xf6\xbf\x01\xd9\xef@\xf1\a\x10\xff\x04\xea\xbf\x00\xf7\xb7~(t\xff\xa3o\xa8n\xfb\xaf\xbe\x05\x9b\xb7\xd1\u007f\xa4L7Ju\xe87J\xdb\xe0;H\xd7\x1f:\x1f\x00\x94\x03aK;\x88\xac\x06\x93fzRf \xe3\x8cd=\x13\xe9f\xc6\xf2j\x16\xc0\xcc\nkd6\xb42;Z\x919\xb8\xa5\x9d\x13\xda\xcf\x05ds\x03\xc5<@\x9c\x17\xa8\xe7\x03\xdc\xfc\xa3:\xa4g\x81Q\xfd\xa5\xc7.ؘ\xe6\x1b\xd4B\x80,\xac.,\xa2M\xf0\x8b\x02n1u\xf9\xe2Z\xcb%T\x95vI\xa0Z\n0K\x03\xb2\f\x10\x97\x05\xea\xe5\x00\xb7\xbc.\xabV\xd0jVTed%mdemDV\xc1\x1evUu~5\xad\xd9\xeaZ\x8b5\xb4\xc65\xb5\xd6kiuk7\xff\xb4\xb7սNs\xb5z\xdff\xddQ\x83@\xbb^\n\xb2>'a\x03\x8a\xe07L\xc1m\xc4I\xbe1Yn\xc2Ai7M\xa1\xda,\x05\xb3y\n\xb2E\nq\xcb\x14\xea\xadRp[\xf30\xd56\xa4ٖ\x03#\xdbQ\xc8\xf6\x14\";\xa43\xb0;r\xe2w\"\xb3\x9d\xc9b\x172\xeeJֻ\x91n\xf7\xe6\x92{[{\xe0\x92힐\xd6\xeeE\xca\xde\xd0a\x1f\xb4\xc1\xefK\xba\xfd\xa0\xf3\xfd\x81\xf2\x00\xd8\xd2\x1eHV\a\x91\xe6`R\x0e!\xe3\xa1d}\x18\xe9\x0e\xc7\xf2\xaa\x130\x06\xd6H\x86Vr\xb4\"-ni\x8f\x80\xf6\x16\xc8\x1cPt\x01\xd1\x03u\x01\xb8R/\xa8\xabҦ\xcb\x06]\xde|\xc1\xeb&\xa5\x86\x0eG\xa2\r\xfe(\xd2\tt\x1e\x81\xb2\a\xb6\xb4G\x93U/i\x8e!\xa5\x8f\x8cǒ\xf5q\xa4;\x1e˫\x13\x00s\"\xac\x91\x93\xd0\xca\xc9hEN\xe1\x96\xf6Th\u007f\x1a\x90\x9d\x0e\x14g\x00\xf1L\xa0>\vpg7\x17\xd4\xd7s\x8e\xbe\xa1z\xec\xb9\xfa\x16l\xdeF\xe7\x91r>t\xb8\x00m\xf0\x17\x92\xee\"\xe8\xfcb\xa0\xbc\x04\xb6\xb4\x97\x92\xd5e\xa4\xb9\x9c\x94+\xc8x%Y_E\xba\xab\xb1\xbc\xba\x060\xd7\xc2\x1a\xb9\x0e\xad\\\x8fV\xe4\x06nio\x84\xf67\x01\xd9\xcd@q\v\x10o\x05\xea\xdb\x00w{sA\xad\x9e;\x9a\xa6\xd5c\xefl\x96띕\xbbH\xb9\x1b:܃6\xf8{Iw\x1ft~?P>\x00[\xda\a\xc9\xea!\xd2<L\xca#d|\x94\xac\x1f#\xdd\xe3X^=\x01\x98'a\x8d<\x85V\x9eF+\xf2\f\xb7\xb4\xcfB\xfb!@6\x14(\x86\x01q8P?\a\xb8\x11\xfa\fu\x8d\u052b벣\xf4\xf1h^r\xa3I\x19\x03\x1dƢ\r~\x1c\xe9\xc6C\xe7\x13\x80r\"li'\x91\xd5d\xd2L!e*\x19\xa7\x91\xf5\xf3\xa4{\x01˫\x17\x01\xf3?X#/\xa1\x95\x97ъ\xbc\xc2-\xed\xab\xd0\xfe5 {\x1d(\xde\x00\xe2\x9b@\xfd\x16\xe0\xden>\xb6\xbb\xdei\xae\xaa˾\xdb\x18\xfdOc\x80\xbc\xaf.|\xa0M\xf0\x1f\x02\xee#u\xf9\xc7Z\xcbOT\x95\xf6S\xa0\xfa\f0\x9f\x03\xf2\x05\x10\xbf\x04\xea\xaf\x00\xf7\xb5.\xab\xbe\xd1j\xbeUe\xe4;m\xe4{mD~\xc0\x1e\xf6Gu\xfe'\xad\xd9\xcfZ\x8b_\xb4\xc6_\xb5ֿiu\xbf7U:\xffh\x16H\xa7\xfd\xb3\xb9f\xbd\x17\xf2\x17)\u007fC\x87\u007f\xd0\x06\xff/\xe9\xfe\x83Χ\x1b\xad(\xfb\x8dV[\xda\x0e\xb2\xeaO\x9a\x01\xa4\f$\xe3 \xb2\x1eL\xba鱼\x9a\x0103\xc2\x1a\x99\t\xaďVd\x160\xd8Y\xa1\xfdl@6;P\xcc\x01\xc49\x81z.\xc0\xcd\r\xb4\xe6\xc1\u0096\x9dw\xf4 \xd0Η\x82\xcc\xcfIX\x80\"\xf8\x05Sp\vq\x92/L\x96\x8bpP\xdaES\xa8\x16K\xc1,\x9e\x82,\x91B\\2\x85z\xa9\x14\xdc\xd2<L\xb5\fi\x96\xe5\xc0\xc8r\x14\xb2<\x85\xc8\n\xe9\f슜\xf8\x95\xc8le\xb2X\x85\x8c\xab\x92\xf5j\xa4[]/\xb6\xafs\rm\xfb:\xed\x9az\x1c\xbd\x87\xb2V\n\xb26'a\x1d\x8a\xe0\xd7M\xc1\xad\xc7I\xbe>Yn\xc0Ai7L\xa1\xda(\x05\xb3q\n\xb2I\nq\xd3\x14\xea\xcdRp\x9b\xf30\xd5\x16\xa4ْ\x03#[Q\xc8\xd6\x14\"ۤ3\xb0\xdbr\xe2\xb7#\xb3\xed\xc9b\a2\xeeH\xd6;\x91ng\xb2\xb5\v\x0fв\xbb\x8e\x1e\xcc`wk'\xd9=\r\xc3\x1eI\x05\xbfg;\xb9\xbd\xd20\xdf;\x85r\x9f4+\xed\xbe\xedT\xed\xd7Nf\xffv\x92\x03\xda)\x1e\xd8N\xf5A\xed\xe4\x0eN\x87\xab\x0eI\xc1\x1c\x9afF\x0eKJ\x0eO\xaay\xe2\xda'dM\x1a\xfa,\x85,O\xa1h\xa5\x10\x8fH\xa1\xb6)8\xa7\xcfz\xab\xbbK\x1f\x8f\xe67+\xaf^\u007f\xd5*R\x90\x92\x93PQ\x04\x1fRpݜ\xe45Y\x1e\xc9Ai\x8fJ\xa1\x92\x14LLAzR\x88G\xa7P\xf7\xa6\xe0\x8e\xe1a\xaa>\xd2\x1cˁ\x91\xe3(\xe4x\n\x91\x13\xd2\x19\xd8\x139\xf1'\x91\xd9\xc9dq\n\x19O%\xeb\xd3Hw\xfa\xe8\xe6\x03\xaau\x06.ٞ\ti\xedY\xa4\x9c\r\x1d\xceA\x1b\xfc\xb9\xa4;\x0f:?\x1f(/\x80-\xed\x85du\x11i.&\xe5\x122^J֗\x91\xeer,\xaf\xae\x00̕\xb0F\xaeB+W\xa3\x15\xb9\x86[\xdak\xa1\xfdu@v=P\xdc\x00\xc4\x1b\x81\xfa&\xc0\u074c\x97q\xab\xfb\x16<\x9d\xfa\xd7\xc8\xf0r\xc0\x9f#k'\xb9=\r\xc3\x1dI\x05\u007fg;\xb9\xbb\xd20\xbf;\x85\xf2\x9e4+\xed\xbd\xedT\xdd\xd7N\xe6\xfev\x92\a\xda)>\xd8N\xf5C\xed\xe4\x1eN\x87\xab\x1eI\xc1<\x9afF\x1eKJ\x1eOJ\xe4\x89\xf6\t\xd9'\xd3\xd0?\x95B\xf6t\n\xc53)\xc4gS\xa8\x87\xa4\xe0\x86\xe2ë5\x8c\x8f\x87\x1dNo\xeds)\xc8\bN\xc2H\x8a\xe0G\xa5\xe0Fs\x92\x8f!˱\x1c\x94v\\\n\xd5\xf8\x14̄\x14db\nqR\n\xf5\xe4\x14\xdc\x14\x1e\xa6\x9aJ\x9ai\x1c\x18y\x9eB^\xa0\x10y1\x9d\x81\xfd\x1f'\xfe%2{\x99,^!\xe3\xabd\xfd\x1a\xe9^חq\xf7\x1bz\xc9\xdd\xf6M\x95\xfa\xd7\xcbHy\x1b:\xbc\x836\xf8wI\xf7\x1et\xfe>P~\x00[\xda\x0f\xc9\xea#\xd2|L\xca'd\xfc\x94\xac?#\xdd\xe7X^}\x01\x98/a\x8d|\x85V\xbeF+\xf2\r\xb7\xb4\xdfB\xfb\xef\x80\xec{\xa0\xf8\x01\x88?\x02\xf5O\x80\xfbY\xd1\xdb\xf9\x8b.\xec\xed\xb4\xbf\xea\x03\xa3\xf7\x81~KA~\xe7$\xfcA\x11\xfc\x9f)\xb8\xbf8\xc9\xff&\xcb\u007f8(\xed\xbf)T\xff\xa5`\xa6\x1b\xc3 \xfdR\x88\x1d)\xd4\xfdSp\x03\xc6\xe00\xd5@\xd2\f\xe2\xc0\xc8`\n\x99\x9eBd\x06\x86`g\xe4\xc4\xcfDf3\x93\xc5,d\x9c\x95\xacg#\xdd\xecdk\x0e\x1e\xa0e\xe7\x1c3\x98\xc1\xce\xd5N2w\x1a\x86y\x92\n~\xdevr\xf3\xa5a>\u007f\n\xe5\x02iV\xda\x05۩Z\xa8\x9d\xcc\xc2\xed$\x8b\xb4S\\\xb4\x9d\xea\xc5\xda\xc9-\x9e\x0eW-\x91\x82Y2͌,\x95\x94,\x9d\x94\xc82\xed\x13\xb2˦\xa1_.\x85l\xf9\x14\x8a\x15R\x88+\xa6P\xaf\x94\x82[y\x8c>\xf9\xadU\xf4\xf1\xe8n\xd9U\xd5\xeb\xfd\xa3\xd5R\x90\xd59\tkP\x04\xbff\nn-N\xf2\xb5\xc9r\x1d\x0eJ\xbbn\n\xd5z)\x98\xf5S\x90\rR\x88\x1b\xa6Po\x94\x82ۘ\x87\xa96!ͦ\x1c\x18ٌB6\xa7\x10\xd9\"\x9d\x81ݒ\x13\xbf\x15\x99mM\x16ېq[\xb2ގt\xdb\xeb\xc5\xf6u\xef\xa0m_\xb7\xddQ\x8f\xa3\xf7\x96vJAv\xe6$\xecB\x11\xfc\xae)\xb8\xdd8\xc9w'\xcb=8(\xed\x9e)T{\xa5`\xf6NA\xf6I!\xee\x9bB\xbd_\nn\u007f\x1e\xa6:\x804\ar`\xe4 \n9\x98B\xe4\x90t\x06\xf6PN\xfcadv8Yt\x92ѐuF\xba|L\xf3\x01\xd5\xd3\xd2K\xee\xb1G\xa8l\xbe_ZR\x1ct\xe8B\x1b\xbc']\x01\x9d\x97@Y\xc1\x966\x90U7ijR\x8e$\xe3Qd-\xa4\x8bX^\xf5\x00\xe6hX#\xbdh\xe5\x18\xb4\xcd\x19rK{,\xb4?\x0eȎ\a\x8a\x13\x80x\"P\x9f\x04\xb8\x93\xf1\x9emu\x9f\x82\xd7n\xf3C\xf5T\xbc\xf6\xf5\xe7\xeci\xed$\xa7\xa7a8#\xa9\xe0\xcfl'wV\x1a\xe6g\xa7P\x9e\x93f\xa5=\xb7\x9d\xaa\xf3\xdaɜ\xdfNrA;\xc5\v۩\xbe\xa8\x9d\xdc\xc5\xe9p\xd5%)\x98K\xd3\xcc\xc8eI\xc9\xe5I\x89\\\xd1>!{e\x1a\xfa\xabRȮN\xa1\xb8&\x85xm\n\xf5u)\xb8\xeb\xf5\xf1\xe8m\xdd\xc0\xc7\xc3\xdeHo\xedM)\xc8͜\x84[(\x82\xbf5\x05w\x1b'\xf9\xeddy\a\a\xa5\xbd3\x85\xea\xae\x14\xcc\xdd)\xc8=)\xc4{S\xa8\xefK\xc1\xdd\xcf\xc3T\x0f\x90\xe6A\x0e\x8c<D!\x0fS\x88<\x92\xce\xc0>ʉ\u007f\x8c\xcc\x1e'\x8b'\xc8\xf8$Y?E\xba\xa7q\xb1]Ϡ\xed\xb2\xcf\xe28\xcdW\xf1!)\xc8PN\xc20\x8a\xe0\x87\xa7\xe0\x9e\xe3$\x1fA\x96#9(\xed\xa8\x14\xaa\xd1)\x981)\xc8\xd8\x14\xe2\xb8\x14\xea\xf1)\xb8\t<L5\x914\x93802\x99B\xa6P\x88LMg`\xa7q\xe2\x9f'\xb3\x17\xc8\xe2E2\xfe\x8f\xac_\"\xdd\xcb\xf8\x80\xeay\x05o\xe1\x1e\xfb*\xde\xfb\xcd\xdb\xf6\xb5\x14\xe4uN\xc2\x1b\x14\xc1\xbf\x99\x82{\x8b\x93\xfcm\xb2|\x87\x83Ҿ\x9bB\xf5^\n\xe6\xfd\x14\xe4\x83\x14\xe2\x87)\xd4\x1f\xa5\xe0>\xe6a\xaaOH\xf3)\aF>\xa3\x90\xcf)D\xbeHg`\xbf\xe4\xc4\u007fEf_\x93\xc57d\xfc\x96\xac\xbf#\xdd\xf7z\xb1\xad\x9e\x1f\xb4m\xf5\xd8\x1f\xf58z\x0f\xec\xa7\x14\xe4gN\xc2/\x14\xc1\xff\x9a\x82\xfb\x8d\x93\xfcw\xb2\xfc\x83\x83\xd2\xfe\x99B\xf5W\n\xe6\xef\x14\xe4\x9f\x14\xe2\xbf)\xd4\xff\xa5\xe0\xa6\x1b\x8b\xc3T\xfdH\xd31\x16\x03#\xfd)d\x00\x85\xc8@\x86`\aq\xe2\a\x93\xd9\xf4d1\x03\x19g$\xeb\x99H7\xf3X}f\xbbfѶ\xaf\xcbΪ\xc7\xd1\xfbc\xb3\xa5 \xb3s\x12\xe6\xa0\b~\xce\x14\xdc\\\x9c\xe4s\x93\xe5<\x1c\x94v\xde\x14\xaa\xf9R0\xf3\xa7 \v\xa4\x10\x17L\xa1^(\x05\xb70\x0fS-B\x9aE90\xb2\x18\x85,N!\xb2D:\x03\xbb$'~)2[\x9a,\x96!\xe3\xb2d\xbd\x1c\xe9\x96\x1f\xdb\xfc\xe8\xe9ZA/\xb9ˮ\xa8R\xff\x9f!)+C\x87U\xd0\x06\xbf*\xe9V\x83\xceW\a\xca5`K\xbb&Y\xadE\x9a\xb5IY\x87\x8c\xeb\x92\xf5z\xa4[\x1f˫\r\x00\xb3!\xac\x91\x8d\xd0\xca\xc6hE6\xe1\x96vSh\xbf\x19\x90m\x0e\x14[\x00qK\xa0\xde\np[\x8f\xed\u05f9\xcd؎N\xbb\xed\xd8\xfeͯ\xc4\xdbi\x95\xed\x1b\x11vhb\xf0;ju;5\"߹)\xe5.M_\xda]\xb5V\xbbi5\xbbk\x95=\xb4\xc6=\xb5\xd6{iu{7\xff\xbcڧ)fߦ7\xb2_\x13e\xff&\x8a\x1c\xa0\a\xb5\a6\xc2\x1fԔ\xec\xe0\xa6\x14\x874%\x1eڔ\xfa\xb0\xa6\xb8Û\xd2\xeal\xfea˚\xb1\x03\xf4\xd7\xd7\f\x90\\]hi\x13\xfc\x11\x80\xb3\xear\xa7\xb5\xecRUZ\x0fT\x05`J@* \x06\xa0\xee\x06\\\xad˪#\xb5\x9a\xa3T\x19\x11m$j\xd3\xfc|\xc6\x1e\xf6hu\xbeWkv\x8c֢Ok<Vk}\x9cVw\xfc؎\xbe\xce\x13\xc6\xf6\xef\xeb\xb4'\x8e\x1d\xa0\xb7\xb7N\x02\xe4du\xe1\x14m\x82?\x15p\xa7\xa9\xcbO\xd7Z\x9e\xa1\xaa\xb4g\x02\xd5Y\x809\x1b\x90s\x80x.P\x9f\a\xb8\xf3uYu\x81Vs\xa1*#\x17i#\x17k#r\t\xf6\xb0\x97\xaa\xf3\x97i\xcd.\xd7Z\\\xa15^\xa9\xb5\xbeJ\xab\xbbZk\xeb\x1a]в\u05ce\x1d\x88\xdbTבr=t\xb8\x01m\xf07\x92\xee&\xe8\xfcf\xa0\xbc\x05\xb6\xb4\xb7\x92\xd5m\xa4\xb9\x9d\x94;\xc8x'Y\xdfE\xba\xbb\xb1\xbc\xba\a0\xf7\xc2\x1a\xb9\x0f\xad\u070fV\xe4\x01ni\x1f\x84\xf6\x0f\x01\xd9\xc3@\xf1\b\x10\x1f\x05\xea\xc7\x00\xf7\xf8؎V\xf7\x13c\xfb7\xbf5=9v\x80\xfe\x16\xf5\x14 O\xab\v\xcfh\x13\xfc\xb3\x80\x1b\xa2.\x1f\xaa\xb5\x1c\xa6\xaa\xb4Á\xea9\xc0\x8c\x00d$\x10G\x01\xf5h\xc0\x8d\xd1e\xd5X\xadf\x9c*#㵑\tڈL\xc4\x1ev\x92:?Yk6Ek1Uk\x9c\xa6\xb5~^\xab{al\xbf\u058b͉\xdb\xff5\xad\xb5/i\x95\x97\x1b\x11^ib\xf0\xafju\xaf5\"\u007f\xbd)\xe5\x1bM_\xda7\xb5Voi5ok\x95w\xb4\xc6w\xb5\xd6\xefiu\xef7\xff\xbc\xfa\xa0)\xe6æ7\xf2Q\x13\xe5\xe3&\x8a|\xa2\a\xb5\x9f6\xc2\u007f֔\xec\xf3\xa6\x14_4%~ٔ\xfa\xab\xa6\xb8\xaf\x9b\x97G\xab\xfb\x9b\xe6\xa1տ\xd5\xd5<\x19\xf8[]\xa4|\x0f\x1d~@\x1b\xfc\x8f\xa4\xfb\t:\xff\x19(\u007f\x81-\xed\xafd\xf5\x1bi~'\xe5\x0f2\xfeI\xd6\u007f\x91\xeeo,\xaf\xfe\x01̿\xb0F\xfeC+Ӎ\x1b\x88[;\xfd\xc0`;Ʃ\xf6\xfd\x81l\x00P\f\x04\xe2 \xa0\x1e\f\xb8\xe9\xc7u\xf4\xb5f\x18\xd7\\\x95\x9dQ\x8d\xb53\x012\xb3\xba0\x8b6\xc1\xcf\n\xb8\xd9\xd4\xe5\xb3k-\xe7PU\xda9\x81j.\xc0\xcc\r\xc8<@\x9c\x17\xa8\xe7\x03\xdc\xfc\xba\xacZ@\xabYP\x95\x91\x85\xb4\x91\x85\xb5\x11Y\x04{\xd8E\xd5\xf9Ŵf\x8bk-\x96\xd0\x1a\x97\xd4Z/\xa5\xd5-=\xae_\xf72\xe3:\xba\xed\xb2\xe3\xfa\xeb\x9f\xe8\xd2*\xcb7\"\xac\xd0\xc4\xe0W\xd4\xeaVjD\xberS\xcaU\x9a\xbe\xb4\xabj\xadV\xd3jV\xd7*kh\x8dkj\xad\xd7\xd2\xea\xd6n\xfey\xb5NS̺Mod\xbd&\xca\xfaM\x14\xd9@\x0fj7l\x84ߨ)\xd9\xc6M)6iJܴ)\xf5fMq\x9b\x8f\xeb\xe8\xed\xdcb\\\xff\xdeN\xbb\xe5\xb8\x01z[e+@\xb6V\x17\xb6\xd1&\xf8m\x01\xb7\x9d\xba|{\xad\xe5\x0e\xaaJ\xbb#P\xed\x04\x98\x9d\x01\xd9\x05\x88\xbb\x02\xf5n\x80\xdb]\x97U{h5{\xaa2\xb2\x976\xb2\xb76\"\xfb`\x0f\xbb\xaf:\xbf\x9f\xd6l\u007f\xad\xc5\x01Z\xe3\x81Z냴\xba\x83\xb5\xb6\x0e\xd1\x05-{踁\xb8=r\x18)\x87C\x87N\xb4\xc1\x1b\xd2e\xd0y\x0e\x94-\xd8\xd2\x1eAV\x964\x8e\x94.2z\xb2.HWbyU\x01&\xc0\x1a\xe9F+5Z\x91#\xb9\xa5=\n\xda\v\x90E\xa0\xe8\x01\xe2\xd1@\xdd\v\xb8c\x9a\xa7\xa2\xd5\xd7<]-{\xec\xb8\x01z\x9b\xe38@\x8eW\x17N\xd0&\xf8\x13\x01w\x92\xba\xfcd\xad\xe5)\xaaJ{*P\x9d\x06\x98\xd3\x019\x03\x88g\x02\xf5Y\x80;[\x97U\xe7h5\xe7\xaa2r\x9e6r\xbe6\"\x17`\x0f{\xa1:\u007f\x91\xd6\xecb\xad\xc5%Z\xe3\xa5Z\xeb˴\xba˛7b\xf7\x15\xcd˻\xdb^ټ\x13\x9a\x97\xf5U\x80\\\xad.\\\xa3M\xf0\xd7\x02\xee:u\xf9\xf5Z\xcb\x1bT\x95\xf6F\xa0\xba\t07\x03r\v\x10o\x05\xea\xdb\x00w\xbb.\xab\xee\xd0j\xeeTe\xe4.m\xe4nmD\xee\xc1\x1e\xf6^u\xfe>\xad\xd9\xfdZ\x8b\a\xb4\xc6\a\xb5\xd6\x0fiu\x0f\x8f\xeb\xd7\xf3ȸ\x8e\x1e\xfb\xe8\xb8\xfeͯ\xf4\x8fi\x95\xc7\x1b\x11\x9ehb\xf0OjuO5\"\u007f\xba)\xe53M_\xdag\xb5VC\xb4\x9a\xa1Ze\x98\xd68\\k\xfd\x9cV7\xa2\xf9\xe7\xd5Ȧ\x98QModt\x13eL\x13\x9b_G\xf4\xa0v\\#\xfc\xf8\xa6d\x13\x9aRLlJ\x9cԔzrSܔ\xe65\xdd\xea\x9eڼ\x1e\x9a\x0f\xe6i\xcd+H?\xa7\x9f'\xe5\x05\xe8\xf0\"\xda\xe0\xffG\xba\x97\xa0\xf3\x97\x81\xf2\x15\xd8ҾJV\xaf\x91\xe6uR\xde \xe3\x9bd\xfd\x16\xe9\xde\xc6\xf2\xea\x1d\xc0\xbc\vk\xe4=\xb4\xf2>Z\x91\x0f\xb8\xa5\xfd\x10\xda\u007f\x04d\x1f\x03\xc5'@\xfc\x14\xa8?\x03\xdc\xe7\xcd'K\xeb\v\xbd*\xfb\xa5\x1ak\xbf\x02\xe4ku\xe1\x1bm\x82\xff\x16pߩ˿\xd7Z\xfe\xa0\xaa\xb4?\x02\xd5O\x80\xf9\x19\x90_\x80\xf8+P\xff\x06\xb8\xdfuY\xf5\x87V\xf3\xa7*#\u007fi#\u007fk#\xf2\x0f\xf6\xb0\xff\xaa\xf3\xffiͦ\x1b\xdfԢ\x9f\xd6ء\xb5\xee\xaf\xd5\r\x18\xdf\xd1\xdb5\xb0\x89]v\xd0\xf8\x01\xfau~0 ӫ\v3h\x13\xfc\x8c\x80\x9bI]>\xb3\xd6r\x16U\xa5\x9d\x15\xa8f\x03\xcc\xec\x80\xcc\x01\xc49\x81z.\xc0ͭ˪y\xb4\x9ayU\x19\x99O\x1b\x99_\x1b\x91\x05\xb0\x87]P\x9d_Hk\xb6\xb0\xd6b\x11\xadqQ\xad\xf5bZ\xdd\xe2\xe3;\xfaz\x96\x18\u07ff\xf9\x1e\xbe\xe4\xf8\x01\xfa\xb5|)@\x96V\x17\x96\xd1&\xf8e\x01\xb7\x9c\xba|y\xad\xe5\n\xaaJ\xbb\"P\xad\x04\x98\x95\x01Y\x05\x88\xab\x02\xf5j\x80[]\x97Ukh5k\xaa2\xb2\x966\xb2\xb66\"\xeb`\x0f\xbb\xae:\xbf\x9e\xd6l}\xad\xc5\x06Z\xe3\x86Z덴\xba\x8d\xc7w\xb4z6\x19\u07ff\xf9>\xbd\xe9\xf8\x01\xfa\xf5z3@6W\x17\xb6\xd0&\xf8-\x01\xb7\x95\xba|k\xad\xe56\xaaJ\xbb-Pm\a\x98\xed\x01\xd9\x01\x88;\x02\xf5N\x80\xdbY\x97U\xbbh5\xbb\xaa2\xb2\x9b6\xb2\xbb6\"{`\x0f\xbb\xa7:\xbf\x97\xd6lo\xad\xc5>Z\xe3\xbeZ\xeb\xfd\xb4\xba\xfd\x9bG\xba\xeb\x80\xe6\xfc\xbb\xec\x81ͥ6/\x8f\x83\x009X]8D\x9b\xe0\x0f\x05\xdca\xea\xf2õ\x96\x9d\xaaJk\x80*\x03L\x0eH\v\x88G\x00\xb5\x05\x9c\xd3eU\x97V\xe3U\x19)\xb4\x91R\x1b\x91\n{ؠ\xcewk\xcdj\xadőZ\xe3QZk\xd1\xea\xe2\xf8~]=\xe3;\xba\xec\xd1\xe3\xfb\xeb\u007f\x1b\xd2*\xc74\"\xf451\xf8c\xb5\xba\xe3\x1a\x91\x1fߔ\xf2\x84\xa6/\xed\x89Z\xab\x93\xb4\x9a\x93\xb5\xca)Z\xe3\xa9Z\xebӴ\xbaӛ\u007f^\x9d\xd1\x14sf\xd3\x1b9\xab\x89rv\x13E\xceу\xdas\x1b\xe1\xcfkJv~S\x8a\v\x9a\x12/lJ}QS\xdc\xc5\xe3;|\xe7%\xe3\xfb\xfbN{\xe9\xf8\x01M\xb5\x97\x01r\xb9\xbap\x856\xc1_\t\xb8\xab\xd4\xe5Wk-\xafQU\xdak\x81\xea:\xc0\\\x0f\xc8\r@\xbc\x11\xa8o\x02\xdcͺ\xac\xbaE\xab\xb9U\x95\x91۴\x91۵\x11\xb9\x03{\xd8;\xd5\xf9\xbb\xb4fwk-\xee\xd1\x1a\xef\xd5Zߧ\xd5ݯ\xb5\xf5\x80.h\xd9\a\xc7\x0fT؇Hy\x18:<\x826\xf8GI\xf7\x18t\xfe8P>\x01[\xda'\xc9\xea)\xd2<M\xca3d|\x96\xac\x87\x90n(\x96W\xc3\x003\x1c\xd6\xc8she\x04Z\x91\x91\xdcҎ\x82\xf6\xa3\x81l\fP\x8c\x05\xe28\xa0\x1e\x0f\xb8\t\xcd\x05\xf5uNl\x9a\xe6\x9b\xee\xa4f\xb9~\xef\x9dL\xca\x14\xe80\x15m\xf0\xd3H\xf7<t\xfe\x02P\xbe\b[\xda\xff\x91\xd5K\xa4y\x99\x94W\xc8\xf8*Y\xbfF\xbaױ\xbcz\x030o\xc2\x1ay\v\xad\xbc\x8dV\xe4\x1dni߅\xf6\xef\x01\xd9\xfb@\xf1\x01\x10?\x04\xea\x8f\x00\xf71\xd0\xfa\x04\v[\xf6\xd3\xf1\x83@\xfbY\n\xf29'\xe1\v\x8a\xe0\xbfL\xc1}\xc5I\xfe5Y~\xc3Ai\xbfM\xa1\xfa.\x05\xf3}\n\xf2C\n\xf1\xc7\x14\xea\x9fRp?\xf30\xd5/\xa4\xf9\x95\x03#\xbfQ\xc8\xef\x14\"\u007f\xa43\xb0\u007fr\xe2\xff\"\xb3\xbf\xc9\xe2\x1f2\xfeK\xd6\xff\x91n\xba\t\xfd}\xab\xbb߄\x01M\xb5\x1d\x13\x06*l\u007fR\x06@\x87\x81h\x83\x1fD\xba\xc1\xd0\xf9\xf4@9\x03lig$\xab\x99H33)\xb3\x90qV\xb2\x9e\x8dt\xb3cy5\a`\xe6\x8452\x17Z\x99\x1b\xad\xc8<\xdc\xd2\xce\v\xed\xe7\x03\xb2\xf9\x81b\x01 .\b\xd4\v\x01n\xe1\t\x1d\xbe\xb5\x88^\x95]T\x8d\xb5\x8b\x01\xb2\xb8\xba\xb0\x846\xc1/\t\xb8\xa5\xd4\xe5Kk-\x97QU\xdae\x81j9\xc0,\x0f\xc8\n@\\\x11\xa8W\x02\xdcʺ\xacZE\xabYU\x95\x91մ\x91յ\x11Y\x03{\xd85\xd5\xf9\xb5\xb4fkk-\xd6\xd1\x1a\xd7\xd5Z\xaf\xa7խ\xdf\xfc\xd3\xe6\xbb\xe9\x06\xcd\xd5\xea\xf7\xea\r'\f\x02\xedF)\xc8Ɯ\x84M(\x82\xdf4\x05\xb7\x19'\xf9\xe6d\xb9\x05\a\xa5\xdd2\x85j\xab\x14\xcc\xd6)\xc86)\xc4mS\xa8\xb7K\xc1m\xcf\xc3T;\x90fG\x0e\x8c\xecD!;S\x88\xec\x92\xce\xc0\xeeʉߍ\xccv'\x8b=ȸ'Y\xefE\xba\xbd\x9bK\xeek\xed\x83K\xb6\xfbBZ\xbb\x1f)\xfbC\x87\x03\xd0\x06\u007f \xe9\x0e\x82\xce\x0f\x06\xcaC`K{(Y\x1dF\x9a\xc3I\xe9$\xa3!\xeb\x8ct9\x96W-\xc0\x1c\x01kĢ\x15\x87V\xa4\x8b[Z\x0f\xed\v +\x81\xa2\x02b\x00\xean\xc0\xd5\xcdK\xae\xfb\xc8檺\xedQ\x8dѿ\x1c\x05HT\x17z\xb4\t\xfeh\xc0\xf5\xaaˏ\xd1Z\xf6\xa9*\xed\xb1@u\x1c`\x8e\a\xe4\x04 \x9e\b\xd4'\x01\xeed]V\x9d\xa2՜\xaa\xca\xc8i\xda\xc8\xe9ڈ\x9c\x81=\xec\x99\xea\xfcYZ\xb3\xb3\xb5\x16\xe7h\x8d\xe7j\xad\xcf\xd3\xea\xceojo\xe7\x05͂\xe6\xdb\xfa\x85\xcd5\xebw\xf7\x8bH\xb9\x18:\\\x826\xf8KIw\x19t~9P^\x01[\xda+\xc9\xea*\xd2\\M\xca5d\xbc\x96\xac\xaf#\xdd\xf5X^\xdd\x00\x98\x1ba\x8d܄VnF+r\v\xb7\xb4\xb7B\xfbۀ\xecv\xa0\xb8\x03\x88w\x02\xf5]\x80\xbb\x1bh݃\x85-{o\xf3\xf2\xc4\xf7\xfa\xfbR\x90\xfb9\t\x0fP\x04\xff`\n\xee!N\xf2\x87\xc9\xf2\x11\x0eJ\xfbh\n\xd5c)\x98\xc7S\x90'R\x88O\xa6P?\x95\x82{\x9a\x87\xa9\x9e!ͳ\x1c\x18\x19B!C)D\x86\xa53\xb0\xc39\xf1ϑ\xd9\b\xb2\x18I\xc6Qd=\x9atc\xf49l\x8dէ\xbbe\xc75R\xbf\xf3\x8f'e\x02t\x98\x886\xf8I\xa4\x9b\f\x9dO\x01ʩ\xb0\xa5\x9dFVϓ\xe6\x05R^$\xe3\xff\xc8\xfa%ҽ\x8c\xe5\xd5+\x80y\x15\xd6\xc8kh\xe5u\xb4\"opK\xfb&\xb4\u007f\v\xc8\xde\x06\x8aw\x80\xf8.P\xbf\a\xb8\xf7\xf5C\xa1\xfb\x03}Cu\xdb\x0f\xf5-ؼ\x8d>\"\xe5c\xe8\xf0\t\xda\xe0?%\xddg\xd0\xf9\xe7@\xf9\x05li\xbf$\xab\xafH\xf35)ߐ\xf1[\xb2\xfe\x8et\xdfcy\xf5\x03`~\x845\xf2\x13Z\xf9\x19\xad\xc8/\xdc\xd2\xfe\n\xed\u007f\x03\xb2߁\xe2\x0f \xfe\t\xd4\u007f\x01\xee\xef\xe6C\xa1\xe7\x9f\xe6\xaaz쿍i\xbe\x9f\xfc\a\xc8t\x13\x1b\x17\xfaMl\x9a\xe0;\x00\xd7_]>@k9PUi\a\x01\xd5`\xc0L\x0f\xc8\f@\x9c\x11\xa8g\x02\xdc̺\xac\x9aE\xab\x99U\x95\x91ٴ\x91ٵ\x11\x99\x03{\xd89\xd5\xf9\xb9\xb4fsk-\xe6\xd1\x1a\xe7\xd5Zϧ\xd5\xcd\xdf\xfc\xd3\xe6\xbb\xf7\x02\x13\a*\xec\x82\x13\a\x81v\xa1\x14daN\xc2\"\x14\xc1/\x9a\x82[\x8c\x93|q\xb2\\\x82\x83\xd2.\x99B\xb5T\nf\xe9\x14d\x99\x14\xe2\xb2)\xd4˥\xe0\x96\xe7a\xaa\x15H\xb3\"\aFV\xa2\x90\x95)DVIg`W\xe5įFf\xab\x93\xc5\x1ad\\\x93\xac\xd7\"\xdd\xda\xcd%\xf7\xb6\xd6\xc1%\xdbu!\xad]\x8f\x94\xf5\xa1\xc3\x06h\x83ߐt\x1bA\xe7\x1b\x03\xe5&\xb0\xa5ݔ\xac6#\xcd\xe6\xa4lA\xc6-\xc9z+\xd2m\x8d\xe5\xd56\x80\xd9\x16\xd6\xc8vhe{\xb4\";pK\xbb#\xb4\xdf\t\xc8v\x06\x8a]\x80\xb8+P\xef\x06\xb8\xdd\xf5\x82\xba\xf6Ц\xcb\xee\xa9˛\xafk{\x91\xb27t\xd8\am\xf0\xfb\x92n?\xe8|\u007f\xa0<\x00\xb6\xb4\a\x92\xd5A\xa49\x98\x94C\xc8x(Y\x1fF\xbañ\xbc\xea\x04\x8c\x815\x92\xa1\x95\x1c\xadH\x8b[\xda#\xa0\xbd\x052\a\x14]@\xf4@]\x00\xael.\xa8\xaf\xa7j\x9a\xbe\x1e\x1b\x9a\xe5zo\xa2\x9b\x94\x1a:\x1c\x896\xf8\xa3H'\xd0y\x04\xca\x1e\xd8\xd2\x1eMV\xbd\xa49\x86\x94>2\x1eK\xd6Ǒ\xeex,\xafN\x00̉\xb0FNB+'\xa3\x159\x85[\xdaS\xa1\xfdi@v:P\x9c\x01\xc43\x81\xfa,\xc0\x9d\xdd\\P\xab眦i\xf5\xd8s\x9b\xe5z\xdf\xe2<R·\x0e\x17\xa0\r\xfeB\xd2]\x04\x9d_\f\x94\x97\xc0\x96\xf6R\xb2\xba\x8c4\x97\x93r\x05\x19\xaf$\xeb\xabHw5\x96W\xd7\x00\xe6ZX#ס\x95\xebъ\xdc\xc0-\xed\x8d\xd0\xfe& \xbb\x19(n\x01\xe2\xad@}\x1b\xe0n\xd7g\xa8\xeb\x0e\xbd\xba.{\xa7>\x1e\xcdK\xee.R\xee\x86\x0e\xf7\xa0\r\xfe^\xd2\xdd\a\x9d\xdf\x0f\x94\x0f\xc0\x96\xf6A\xb2z\x884\x0f\x93\xf2\b\x19\x1f%\xeb\xc7H\xf78\x96WO\x00\xe6IX#O\xa1\x95\xa7ъ<\xc3-\xed\xb3\xd0~\b\x90\r\x05\x8aa@\x1c\x0e\xd4\xcf\x01n\xc4\xc4\x0e\xdf5\xb2\xb9\xaa.;\xaa1\xfa\x1f}\x00\x19\xa3.\x8c\xd5&\xf8q\x80\x1b\xaf.\x9f\xa0\xb5\x9c\xa8\xaa\xb4\x93\x80j2`\xa6\x002\x15\x88Ӏ\xfay\xc0\xbd\xa0˪\x17\xb5\x9a\xff\xa92\xf2\x926\xf2\xb26\"\xaf`\x0f\xfb\xaa:\xff\x9a\xd6\xecu\xad\xc5\x1bZ\xe3\x9bZ뷴\xba\xb7\x9b\xea;\xdfi\x16\xf8N\xfbns\xcdz/\xe4=Rއ\x0e\x1f\xa0\r\xfeC\xd2}\x04\x9d\u007f\f\x94\x9f\xc0\x96\xf6S\xb2\xfa\x8c4\x9f\x93\xf2\x05\x19\xbf$\xeb\xafH\xf75\x96W\xdf\x00\xe6[X#ߡ\x95\xefъ\xfc\xc0-\xed\x8f\xd0\xfe' \xfb\x19(~\x01\xe2\xaf@\xfd\x1b\xe0~\aZ\u007f`a\xcb\xfe\xd9|\xc4\xe3>\xc9_)\xc8ߜ\x84\u007f(\x82\xff7\x05\xf7\x1f'\xf9t\x93\xc0\xb2\xdf$\fJۑB\xd5?\x053 \x05\x19\x98B\x1c\x94B=8\x057=\x0fS\xcd@\x9a\x19902\x13\x85\xccL!2\vC\xb0\xb3r\xe2g#\xb3\xd9\xc9b\x0e2\xceI\xd6s\x91n\xeeI\xcd\xc5\xf6uΣm_\xa7\x9dW\x8f\xa3\xf7P\xe6KA\xe6\xe7$,@\x11\xfc\x82)\xb8\x858\xc9\x17&\xcbE8(\xed\xa2)T\x8b\xa5`\x16OA\x96H!.\x99B\xbdT\nni\x1e\xa6Z\x864\xcbr`d9\nY\x9eBd\x85t\x06vEN\xfcJd\xb62Y\xacB\xc6U\xc9z5ҭN\xb6\xd6\xe0\x01Zv\xcdI\x83\x19\xecZ\xed$k\xa7aX'\xa9\xe0\xd7m'\xb7^\x1a\xe6\xeb\xa7Pn\x90f\xa5ݰ\x9d\xaa\x8d\xda\xc9l\xdcN\xb2I;\xc5M۩ެ\x9d\xdc\xe6\xe9p\xd5\x16)\x98-\xd3\xcc\xc8VI\xc9\xd6I\x89l\xd3>!\xbbm\x1a\xfa\xedRȶO\xa1\xd8!\x85\xb8c\n\xf5N)\xb8\x9d\xf5You\uf88fG\xf3\x9bծ\xea\xf5W\xad\xddR\x90\xdd9\t{P\x04\xbfg\nn/N\xf2\xbd\xc9r\x1f\x0eJ\xbbo\n\xd5~)\x98\xfdS\x90\x03R\x88\a\xa6P\x1f\x94\x82;\x98\x87\xa9\x0e!͡\x1c\x189\x8cB\x0e\xa7\x10\xe9Lg`\r'>#\xb3\x9c,Zd<\x82\xac-\xe9ܤ\xe6\x03\xaaՅK\xb6\x1e\xd2ڂ\x94\x12:Th\x83\x0f\xa4\xeb\x86\xcek\xa0<\x12\xb6\xb4G\x91\x95\x90&\x92\xd2Cƣɺ\x97t\xc7`y\xd5\a\x98ca\x8d\x1c\x87V\x8eG+r\x02\xb7\xb4'B\xfb\x93\x80\xecd\xa08\x05\x88\xa7\x02\xf5i\x80;\x1d/\xe3V\xf7\x19x:\xf5oV\xe1倿Z\xd5Nrv\x1a\x86s\x92\n\xfe\xdcvr\xe7\xa5a~~\n\xe5\x05iV\xda\v۩\xba\xa8\x9d\xcc\xc5\xed$\x97\xb4S\xbc\xb4\x9d\xea\xcb\xda\xc9]\x9e\x0eW]\x91\x82\xb92͌\\\x95\x94\\\x9d\x94\xc85\xed\x13\xb2צ\xa1\xbf.\x85\xec\xfa\x14\x8a\x1bR\x887\xa6Pߔ\x82\xbb\x19\x1f^\xad[\xf8x\xd8[魽-\x05\xb9\x9d\x93p\aE\xf0w\xa6\xe0\xee\xe2$\xbf\x9b,\xefᠴ\xf7\xa6Pݗ\x82\xb9?\x05y \x85\xf8`\n\xf5C)\xb8\x87y\x98\xea\x11\xd2<ʁ\x91\xc7(\xe4q\n\x91'\xd2\x19\xd8'9\xf1O\x91\xd9\xd3d\xf1\f\x19\x9f%\xeb!\xa4\x1b\xaa/\xe3\xeeaz\xc9\xddv\xb8J\xfd\xe3X\xa4\x8c\x80\x0e#\xd1\x06?\x8at\xa3\xa1\xf31@9\x16\xb6\xb4\xe3\xc8j<i&\x902\x91\x8c\x93\xc8z2\xe9\xa6`y5\x150\xd3`\x8d<\x8fV^@+\xf2\"\xb7\xb4\xff\x83\xf6/\x01\xd9\xcb@\xf1\n\x10_\x05\xea\xd7\x00\xf7\xba\xa2\xb7\xf3\r]\xd8\xdbi\xdf\xd4\aF\xef\x03\xbd\x95\x82\xbc\xcdIx\x87\"\xf8wSp\xefq\x92\xbfO\x96\x1fpP\xda\x0fS\xa8>J\xc1|\x9c\x82|\x92B\xfc4\x85\xfa\xb3\x14\xdc\xe7<L\xf5\x05i\xbe\xe4\xc0\xc8W\x14\xf25\x85\xc87\xe9\f췜\xf8\xef\xc8\xec{\xb2\xf8\x81\x8c?\x92\xf5O\xa4\xfb\x99l\xfd\xc2\x03\xb4\xec\xaf\xfa\xda\xc7=\xa2\xdf\xdaI~O\xc3\xf0GR\xc1\xff\xd9N\xee\xaf4\xcc\xffN\xa1\xfc'\xcdJ\xfbo;U\xff\xb5\x93\x99nrJү\x9dbG;\xd5\xfd\xdb\xc9\r\x98\xcc\xc3U\x03S0\x83\xd2\xcc\xc8\xe0\xa4d\xfa\xa4DfH)\xd8\x19\xd3\xd0ϔB6s\n\xc5,)\xc4YS\xa8gK\xc1\xcd>Y\x9f\xfc\xd6\x1c\x93\xf5\xe5Ҳs\xaa\xd7\xfbGs\xa5 ss\x12\xe6\xa1\b~\xde\x14\xdc|\x9c\xe4\xf3\x93\xe5\x02\x1c\x94v\xc1\x14\xaa\x85R0\v\xa7 \x8b\xa4\x10\x17M\xa1^,\x05\xb78\x0fS-A\x9a%90\xb2\x14\x85,M!\xb2L:\x03\xbb,'~92[\x9e,V \xe3\x8ad\xbd\x12\xe9V\u058b\xed\xeb^E۾n\xbb\xaa\x1eG\xef-\xad\x96\x82\xac\xceIX\x83\"\xf85Spkq\x92\xafM\x96\xebpP\xdauS\xa8\xd6K\xc1\xac\x9f\x82l\x90B\xdc0\x85z\xa3\x14\xdc\xc6<L\xb5\ti6\xe5\xc0\xc8f\x14\xb29\x85\xc8\x16\xe9\f얜\xf8\xad\xc8lk\xb2؆\x8cے\xf5v\xa4\xdb~r\xf3\x01ճ\x83^r\x8f\xddQe\xf3\xfdr'Rv\x86\x0e\xbb\xa0\r~W\xd2\xed\x06\x9d\xef\x0e\x94{\xc0\x96vO\xb2ڋ4{\x93\xb2\x0f\x19\xf7%\xeb\xfdH\xb7?\x96W\a\x00\xe6@X#\a\xa1\x95\x83ъ\x1c\xc2-\xed\xa1\xd0\xfe0 ;\x1c(:\x81h\x80:\x03\\\xae+z[\xdd-\xbcv\x9b\x1f\xaaG൯?gm;\x89K\xc3ЕT\xf0\xbe\x9d\\\x91\x86y\x99B\xf3匳҆v\xaa\xba\xdb\xc9\xd4\xed$G\xb6S<\xaa\x9dji'\x17\xd3\u1a9e\x14\xcc\xd1if\xa47)9&)\x91\xbe\xf6\t\xd9c\xd3\xd0\x1f\x97Bv|\n\xc5\t)\xc4\x13S\xa8OJ\xc1\x9d\xac\x8fGo\xeb\x14>\x1e\xf6TzkOKAN\xe7$\x9cA\x11\xfc\x99)\xb8\xb38\xc9\xcf&\xcbs8(\xed\xb9)T\xe7\xa5`\xceOA.H!^\x98B}Q\n\xeeb\x1e\xa6\xba\x844\x97r`\xe42\n\xb9\x9cB\xe4\x8at\x06\xf6JN\xfcUdv5Y\\C\xc6k\xc9\xfa:\xd2]\x8f\x8b\xed\xba\x01m\x97\xbd\x11\xc7i\xbe\x8aߔ\x82\xdc\xccI\xb8\x85\"\xf8[Sp\xb7q\x92\xdfN\x96wpP\xda;S\xa8\xeeJ\xc1ܝ\x82ܓB\xbc7\x85\xfa\xbe\x14\xdc\xfd<L\xf5\x00i\x1e\xe4\xc0\xc8C\x14\xf20\x85\xc8#\xe9\f죜\xf8\xc7\xc8\xecq\xb2x\x82\x8cO\x92\xf5S\xa4{\x1a\x1fP=\xcf\xe0-\xdcc\x9f\xc5{\xbfy\xdb\x0eIA\x86r\x12\x86Q\x04?<\x05\xf7\x1c'\xf9\b\xb2\x1c\xc9AiG\xa5P\x8dN\xc1\x8cIAƦ\x10ǥP\x8fO\xc1M\xe0a\xaa\x89\xa4\x99ā\x91\xc9\x142\x85Bdj:\x03;\x8d\x13\xff<\x99\xbd@\x16/\x92\xf1\u007fd\xfd\x12\xe9^\u058bm\xf5\xbc\xa2m\xabǾ\xaa\xc7\xd1{`\xaf\xa5 \xafs\x12ޠ\b\xfe\xcd\x14\xdc[\x9c\xe4o\x93\xe5;\x1c\x94\xf6\xdd\x14\xaa\xf7R0\xef\xa7 \x1f\xa4\x10?L\xa1\xfe(\x05\xf71\x0fS}B\x9aO90\xf2\x19\x85|N!\xf2E:\x03\xfb%'\xfe+2\xfb\x9a,\xbe!\xe3\xb7d\xfd\x1d\xe9\xbe\xc73\xdb\xf5\x03\xae\xbd\xcb\xfe\x88\a\xady\x19\xff\x94\x82\xfc\xccI\xf8\x85\"\xf8_Sp\xbfq\x92\xffN\x96\u007fpP\xda?S\xa8\xfeJ\xc1\xfc\x9d\x82\xfc\x93B\xfc7\x85\xfa\xbf\x14\xdctSp\x98\xaa\x1fi:\xa6``\xa4?\x85\f\xa0\x10\x19\xc8\x10\xec N\xfc`2\x9b\x9e,f \xe3\x8cd=\x13\xe9f\x9e\xd2\xfc\xe8\xe9\x9aeJs\xc9]vV\x95\xfa\x9f\x80H\x99\x1d:́6\xf89I7\x17t>7P\xce\x03[\xday\xc9j>\xd2\xccO\xca\x02d\\\x90\xac\x17\"\xdd\xc2X^-\x02\x98Ea\x8d,\x86V\x16G+\xb2\x04\xb7\xb4KB\xfb\xa5\x80li\xa0X\x06\x88\xcb\x02\xf5r\x80[~JGֹ\u0094\xfeY\xa7]qʀ\xa6ڕ\x00YY]XE\x9b\xe0W\x05\xdcj\xea\xf2յ\x96k\xa8*\xed\x9a@\xb5\x16`\xd6\x06d\x1d \xae\v\xd4\xeb\x01n}]Vm\xa0\xd5l\xa8\xca\xc8F\xda\xc8\xc6ڈl\x82=\xec\xa6\xea\xfcfZ\xb3͵\x16[h\x8d[j\xad\xb7\xd2\xea\xb6\xd6\xda\xdaF\x17\xb4\xec\xb6S\x06*\xecv\xa4l\x0f\x1dv@\x1b\xfc\x8e\xa4\xdb\t:\xdf\x19(w\x81-\xed\xaed\xb5\x1biv'e\x0f2\xeeI\xd6{\x91no,\xaf\xf6\x01̾\xb0F\xf6C+\xfb\xa3\x159\x80[\xda\x03\xa1\xfdA@v0P\x1c\x02\xc4C\x81\xfa0\xc0\x1d\xde\\P_gg\xd3\xf4uZ\xd3,\xd7;c\x19)9th\xa1\r\xfe\b\xd2Y\xe8\xdc\x01e\x17li=Y\x15\xa4)I\xa9\xc8\x18Ⱥ\x9bt5\x96WG\x02\xe6(X#\x82V\"Z\x91\x1eni\x8f\x86\xf6\xbd@v\fP\xf4\x01\xf1X\xa0>\x0ep\xc7\x03\xad\x13\xb0\xb0eO\x9c2\b\xb4'\xa5 's\x12N\xa1\b\xfe\xd4\x14\xdci\x9c䧓\xe5\x19\x1c\x94\xf6\xcc\x14\xaa\xb3R0g\xa7 \xe7\xa4\x10\xcfM\xa1>/\x05w>\x0fS]@\x9a\v90r\x11\x85\\L!rI:\x03{)'\xfe22\xbb\x9c,\xae \xe3\x95d}\x15\xe9\xaen\x9e\xbdV\xf75\xcd%7\xbf\xa7]\xdbH\xfd\xc5\xed:R\xae\x87\x0e7\xa0\r\xfeF\xd2\xdd\x04\x9d\xdf\f\x94\xb7\xc0\x96\xf6V\xb2\xba\x8d4\xb7\x93r\a\x19\xef$\xeb\xbbHw7\x96W\xf7\x00\xe6^X#\xf7\xa1\x95\xfbъ<\xc0-\xed\x83\xd0\xfe! {\x18(\x1e\x01\xe2\xa3@\xfd\x18\xe0\x1eo>\x14ZO\xe8U\xd9'\xd5X\xfb\x14 O\xab\v\xcfh\x13\xfc\xb3\x80\x1b\xa2.\x1f\xaa\xb5\x1c\xa6\xaa\xb4Á\xea9\xc0\x8c\x00d$\x10G\x01\xf5h\xc0\x8d\xd1e\xd5X\xadf\x9c*#㵑\tڈL\xc4\x1ev\x92:?Yk6Ek1Uk\x9c\xa6\xb5~^\xab{A_r\xad\xee\x17\xf5Iѿ\xf1\xa5\xcf&\xfe\xc6W\n\xf22'\xe1\x15\x8a\xe0_M\xc1\xbd\xc6I\xfe:Y\xbe\xc1Ai\xdfL\xa1z+\x05\xf3v\n\xf2N\n\xf1\xdd\x14\xea\xf7Rp\xef\xf30\xd5\a\xa4\xf9\x90\x03#\x1fQ\xc8\xc7\x14\"\x9f\xa43\xb0\x9fr\xe2?#\xb3\xcf\xc9\xe2\v2~I\xd6_\x91\xeek\xfd\xc0h}\x83K\xb6\xdfBZ\xfb\x1d)\xdfC\x87\x1f\xd0\x06\xff#\xe9~\x82\xce\u007f\x06\xca_`K\xfb+Y\xfdF\x9a\xdfI\xf9\x83\x8c\u007f\x92\xf5_\xa4\xfb\x1b˫\u007f\x00\xf3/\xac\x91\xff\xd0\xcatS\xb5\x15\xe9\a\x06\xdb1U\xb5\xef\x0fd\x03\x80b \x10\a\x01\xf5`\xc0M?\xb5#\xeb\x9eaj\xff\xac\xdb\xce\xd8\x18\xfd\xd3^\x80̬.̢M\xf0\xb3\x02n6u\xf9\xecZ\xcb9T\x95vN\xa0\x9a\v0s\x032\x0f\x10\xe7\x05\xea\xf9\x007\xbf.\xab\x16\xd0j\x16Ted!mdamD\x16\xc1\x1evQu~1\xad\xd9\xe2Z\x8b%\xb4\xc6%\xb5\xd6KiuK7\xb5\xb7s\x99fAo\xa7]\xb6\xb9f\xbd\xab\xb4\x1c)\xcbC\x87\x15\xd0\x06\xbf\"\xe9V\x82\xceW\x06\xcaU`K\xbb*Y\xadF\x9a\xd5IY\x83\x8ck\x92\xf5Z\xa4[\x1b˫u\x00\xb3.\xac\x91\xf5\xd0\xca\xfahE6\xe0\x96vCh\xbf\x11\x90m\f\x14\x9b\x00qS\xa0\xde\fp\x9b\x03\xad-\xb0\xb0e\xb7\x9c:\b\xb4[\xa5 [s\x12\xb6\xa1\b~\xdb\x14\xdcv\x9c\xe4ۓ\xe5\x0e\x1c\x94v\xc7\x14\xaa\x9dR0;\xa7 \xbb\xa4\x10wM\xa1\xde-\x05\xb7;\x0fS\xedA\x9a=90\xb2\x17\x85\xecM!\xb2O:\x03\xbb/'~?2۟,\x0e \xe3\x81d}\x10\xe9\x0e\xd6\xe7\xb0u\x88>\xdd-{h#\xf5\xee\xd0a\xa4\x1c\x0e\x1d:\xd1\x06oH\x97A\xe79P\xb6`K{\x04YY\xd28R\xba\xc8\xe8ɺ ]\x89\xe5U\x05\x98\x00k\xa4\x1b\xad\xd4hE\x8e\xe4\x96\xf6(h/@\x16\x81\xa2\a\x88G\x03u/\xe0\x8ei.\xa8\xaf\xbbO\xdfP\xdd\xf6X}\v6o\xa3\xe3H9\x1e:\x9c\x806\xf8\x13Iw\x12t~2P\x9e\x02[\xdaS\xc9\xea4ҜN\xca\x19d<\x93\xac\xcf\"\xdd\xd9X^\x9d\x03\x98sa\x8d\x9c\x87V\xceG+r\x01\xb7\xb4\x17B\xfb\x8b\x80\xecb\xa0\xb8\x04\x88\x97\x02\xf5e\x80\xbb\xbc\xf9P蹢\xb9\xaa\x1e{ec\x9aoPW\x01r\xb5\xbap\x8d6\xc1_\v\xb8\xeb\xd4\xe5\xd7k-oPU\xda\x1b\x81\xea&\xc0\xdc\f\xc8-@\xbc\x15\xa8o\x03\xdc\xed\xba\xac\xbaC\xab\xb9S\x95\x91\xbb\xb4\x91\xbb\xb5\x11\xb9\a{\xd8{\xd5\xf9\xfb\xb4f\xf7k-\x1e\xd0\x1a\x1f\xd4Z?\xa4\xd5=\xac\xef\xa1V\xf7#\xfa*k~\xec<\xaa/O\xfd9\xf4X\n\xf28'\xe1\t\x8a\xe0\x9fL\xc1=\xc5I\xfe4Y>\xc3Ai\x9fM\xa1\x1a\x92\x82\x19\x9a\x82\fK!\x0eO\xa1~.\x057\x82\x87\xa9F\x92f\x14\aFFS\xc8\x18\n\x91\xb1\xe9\f\xec8N\xfcx2\x9b@\x16\x13\xc98\x89\xac'\x93n\x8a~\x02\xb6\xa6\xe2\x92\xed4Hk\x9f'\xe5\x05\xe8\xf0\"\xda\xe0\xffG\xba\x97\xa0\xf3\x97\x81\xf2\x15\xd8ҾJV\xaf\x91\xe6uR\xde \xe3\x9bd\xfd\x16\xe9\xde\xc6\xf2\xea\x1d\xc0\xbc\vk\xe4=\xb4\xf2>Z\x91\x0f\xb8\xa5\xfd\x10\xda\u007f\x04d\x1f\x03\xc5'@\xfc\x14\xa8?\x03\xdc\xe7zA]_h\xd3e\xbf\xd4\xe5\xcd\x17\xbc\xafH\xf9\x1a:|\x836\xf8oI\xf7\x1dt\xfe=P\xfe\x00[\xda\x1f\xc9\xea'\xd2\xfcL\xca/d\xfc\x95\xac\u007f#\xdd\xefX^\xfd\x01\x98?a\x8d\xfc\x85V\xfeF+\xf2\x0f\xb7\xb4\xffB\xfb\xff\x80l\xbai\x8a\xa2\x1f\x10;\x80\xba?\xe0\x06Lk>\x14z\x066M_\x8f\x1d4m\xa0\xc2\x0e&ez\xe80\x03\xda\xe0g$\xddL\xd0\xf9\xcc@9\vlig%\xab\xd9H3;)s\x90qN\xb2\x9e\x8btscy5\x0f`\xe6\x8552\x1fZ\x99\x1f\xad\xc8\x02\xdc\xd2.\b\xed\x17\x02\xb2\x85\x81b\x11 .\nԋ\x01n\xf1\xe6\x82Z=K4M\xab\xc7.\xd9,\xd7;+K\x91\xb24tX\x06m\xf0˒n9\xe8|y\xa0\\\x01\xb6\xb4+\x92\xd5J\xa4Y\x99\x94Uȸ*Y\xafF\xbaձ\xbcZ\x030k\xc2\x1aY\v\xad\xac\x8dVd\x1dniׅ\xf6\xeb\x01\xd9\xfa@\xb1\x01\x107\x04\xea\x8d\x00\xb7\xb1>C]\x9b\xe8\xd5u\xd9M\xf5\xf1h^r\x9b\x91\xb29t\xd8\x02m\xf0[\x92n+\xe8|k\xa0\xdc\x06\xb6\xb4ے\xd5v\xa4ٞ\x94\x1dȸ#Y\xefD\xba\x9d\xb1\xbc\xda\x050\xbb\xc2\x1a\xd9\r\xad\xec\x8eVd\x0fni\xf7\x84\xf6{\x01\xd9\xde@\xb1\x0f\x10\xf7\x05\xea\xfd\x00\xb7\xff\xb4\x8e\xac\xeb\x80檺쁍\xd1\xff\xff\x05\xc8\xc1\xea\xc2!\xda\x04\u007f(\xe0\x0eS\x97\x1f\xae\xb5\xecTUZ\x03T\x19`r@Z@<\x02\xa8-\xe0\x9c.\xab\xba\xb4\x1a\xaf\xcaH\xa1\x8d\x94ڈT\xd8\xc3\x06u\xbe[kVk-\x8e\xd4\x1a\x8f\xd2Z\x8bV\x17\xa7u\x14\x9d=\xd3\xfa\x17\x9d\xf6\xe8i\x03\x9aj{\x019F]\xe8\xd3&\xf8c\x01w\x9c\xba\xfcx\xad\xe5\t\xaaJ{\"P\x9d\x04\x98\x93\x019\x05\x88\xa7\x02\xf5i\x80;]\x97Ugh5g\xaa2r\x966r\xb66\"\xe7`\x0f{\xae:\u007f\x9e\xd6\xec|\xad\xc5\x05Z\xe3\x85Z담\xba\x8b\xb5\xb6.\xd1\x05-{鴁\n{\x19)\x97C\x87+\xd0\x06\u007f%鮂ί\x06\xcak`K{-Y]G\x9a\xebI\xb9\x81\x8c7\x92\xf5M\xa4\xbb\x19˫[\x00s+\xac\x91\xdb\xd0\xca\xedhE\xee\xe0\x96\xf6Nh\u007f\x17\x90\xdd\r\x14\xf7\x00\xf1^\xa0\xbe\x0fp\xf77\x17\xd4\xd7\xf9@\xd3\xf4u\xda\a\x9b\xe5z#\xe4!R\x1e\x86\x0e\x8f\xa0\r\xfeQ\xd2=\x06\x9d?\x0e\x94O\xc0\x96\xf6I\xb2z\x8a4O\x93\xf2\f\x19\x9f%\xeb!\xa4\x1b\x8a\xe5\xd50\xc0\f\x875\xf2\x1cZ\x19\x81Vd$\xb7\xb4\xa3\xa0\xfdh \x1b\x03\x14c\x818\x0e\xa8\xc7\x03n\x02К\x88\x85-;i\xda \xd0NNA\xa6p\x12\xa6R\x04\xff\u007f\x96\xce:\xcem\xa3\tÕ\x0f\xca\xcc\xec6\xcc\r33'M\xdaP\xd3\xe4\xd6vv-K\xb2\x9a\x91s\xbd\xb6)\xf3Wfffff\fC\x1bfN\xcapw\xcd\xe9\xdbyG\u007f\xe4yf\xde\xf5j\xb5\x96\xec\xf3\xb9\xbf\xfen^R\x98\xf92\x92] \xf6\x16ʀ\xa7\x17%\x85\xbf8)Ԓ\xa4\xa0\xa5I\x11-K\x8apyR\x98\x9f\xe40\xfe\xcfb\xb5B\x06\x14\xad\x94\x80VI@\xb4:9\x03\xbdFFܵ\xe2\xcc:qa\xbd8\xda \x0e7\x8a\xcd&{\xf5r\xc5\xcdv\xcb\xf6s\xce\x16\x1b\xf2瞭bچ8؎6pw\x88\xcdN\xc4\xd9]\x90\xb7\x1b\xa9\xa7\xf7\x88\xfd_\xc4\xeaW1\xfd&\x8e~\x17\x87\u007f\x88͟\x98\xee\xff\x05\xa9\xbf\x91*\xfa\a-\xfd\x8b\x96\xa8V\x96\xd4u\x88\xddz(\xf3\x1fT\xd8\vE\rP\x18Cf\x9f\xf9\xa9BΙow\xa5S\xf3m\xa2u\x19D\xe5\x9c\x05\x15\xdc\x04n%d\xf6\xe5,\xbb\x1f\xd3۟#O\x1f\x00\xf9\aB\xea \x88\x0e\x86\xa2C\xa0\xf0P\xc8\x1c\xc6\xd3\xfcÙ\xea\b\x8e\x14\x1d\xc9\r\x1d\xc5\r\xd1\xd1XC\x1fÙ{,3s\x1c\xb3p<3:\x81\x19\x9e\xc84'ه\xd6\xe4\x8a'ϯ`\xe9S\xe6W\xc2\xfaԤ\xa0\xb4\x8c\x04\xa7I\x10\xb8\xa7'\x85i$#\xd9\xc6b\xaf\x89\fx\xbaiR\xf8͒B5O\nj\x91\x14Qˤ\b[%\x85i-\x87\xf1ۈU[\x19P\xd4N\x02:C\x02\xa2\xf6\xc9\x19\xe8\x0e2\xe2v\x14g:\x89\v\x9d\xc5Q\x17q\xd8Ul\xba\xd9-\xd7\xe4\xbac˺\aB\xad{\x8a\xa9\x17\xe2\xa07\xda\xc0\xed#6}\x11g\xfbA^\u007f\xa4\x9e\x1e \xf6\a\x8a\xd5 1\r\x16GC\xc4\xe1P\xb1\x19\x86\xe9\xfepH\x8d@\xaah$Z\x1a\x85\x96h\xb4,\xa9\xc7 v\xc7B\x99qPa<\x14\x9d\t\x85\x13 3\xd1\xderų쮊\xfal\x9b\xf0_\x8e\x82h2g\xc1\x14n\x02w*d\xa6q\x96=\x87\xe9M\xe7\xc8\xd3\xe7B\xfe\fḦ́\xa8\n\x8a\x14\x14f \x93\xe5i~\x8e\xa9fq\xa4HsC\x86\x1b\xa2<\xd6\xd0.gn\x81\x99\xf1\x98\x05\x9f\x19\x05̰\xc84\xa1eu\xd5yvBu\x95\x9em\xf7\xcc_\x84\x90\x98\"\xc4A\tm\xe0\xce\x11\x9bj\xc4\xd9\xf3!\xaf\x06\xa9\xa7/\x10\xfb\x17\x8a\xd5Eb\x9a+\x8e.\x16\x87\x97\x88ͥ\x98\xee_\x06\xa9ˑ*\xba\x02-]\x89\x96\xe8*YR_\x8dؽ\x06\xca\\\v\x15\xae\x83\xa2\xeb\xa1\xf0\u007f\x90\xb9\x01\xca݈\x899}\x93\xbd=\xf1E\xc8\xcdIA\xb7\xc8Hp\xab\x04\x81{[R\x98\xdbe${\x87ػS\x06<}WR\xf8w'\x85\xba')\xe8ޤ\x88\xeeK\x8a\xf0\xfe\xa40\x0f\xc8a\xfc\a\xc5\xea!\x19P\xf4\xb0\x04\xf4\x88\x04D\x8f&g\xa0\x1f\x93\x11\xf7qq\xe6\tq\xe1Iq\xf4\x948|Zl\x9e\xe1k\x98{\x96/wN?gC\xfe\"\xe4y1\xbd\x808x\x11m\xe0\xbe$6/#ξ\x02y\xaf\"\xf5\xf4kb\xffu\xb1zCLo\x8a\xa3\xb7\xc4\xe1\xdbb\xf3\x0e\xa6\xfb\xefB\xea=\xa4\x8a\xdeGK\x1f\xa0%\xfaP\x96\xd4\x1f!v?\x862\x9f@\x85O\xa1\xe83(\xfc\x1c2_\xf0\x9bB\xf1K~A\x15\xf5W\xfc\x12\xb4/\xa3\xaf\xc5\xf4\r\xe2\xe0[\xb4\x81\xfb\x9d\xd8|\x8f8\xfb\x03\xe4\xfd\x88\xd4\xd3\xf3\xc4\xfe|\xb1Z \xa6\x85\xe2h\x918\\,6K0\xdd_\n\xa9eH\x15-GK?\xa1%\xfaY\x96\xd4+\x10\xbb+\xa1\xcc*\xa8\xb0\x1a\x8a\xd6@\xe1ZȬ\xb3o\n\xa5\xf5vW%\xbd\xc1&\xf6\x17\x9e\x8d\x10m\xe2,\xd8\xccM\xe0n\x81\xccVβۘ\xdev\x8e<\xbd\x03\xf2wBj\x17D\xbb\xa1h\x0f\x14\xfe\x02\x99_y\x9a\xff\x1bS\xfdΑ\xa2?\xb8\xa1?\xb9!\xfa\vk\xe8\xbf9s\xffaf\xfee\x16j\x99Q\x1d3\xacg\x9a\xff\xf85\x94+\xee\xe5\xbb\xcc\xfe\xd8i\xe0ۓ\u007f\x0e\xc5IA\xfb,\xc0H\xe0,@\x10\xb8\xa9\xa40e2\x92-\x17{\x152\xe0\xe9ʤ\xf0\xf7M\n\xb5_R\xd0\xfeI\x11\x1d\x90\x14\xe1\x81Ia\x0e\x92\xc3\xf8\a\x8b\xd5!2\xa0\xe8P\t\xe80\t\x88\x0eO\xce@\x1f!#\xee\x91\xe2\xccQ\xe2\xc2\xd1\xe2\xe8\x18qx\xac\xd8\x1c\xb7\xc0\xbe\x03\xe6\x8e_\xc0[\xd6' \xd4\xfaD1\x9d\x8488\x19m\xe0\x9e\"6\xa7\"Φ!\xef4\xa4\x9e>]\xec7\x12\xab\xc6bj\"\x8e\x9a\x8a\xc3fb\xd3\x1c\xd3\xfd\x16\x90j\x89TQ+\xb4\xd4\x1a-Q\x1bYR\xb7E춃2g@\x85\xf6P\xd4\x01\n;B\xa6\x13o(ߙ\x9b\xbc\xee\xc2\xd3\xed\xefq]\xc5\xd4\rq\xd0\x1dm\xe0\xf6\x10\x9b\x9e\x88\xb3\xbd \xaf7RO\xf7\x11\xfb}Ū\x9f\x98\xfa\x8b\xa3\x01\xe2p\xa0\xd8\f\xc2t\u007f0\xa4\x86 U4\x14-\rCK4\\\x96\xd4#\x10\xbb#\xa1\xcc(\xa80\x1a\x8a\xc6@\xe1XȌ\xb3\x1b\xaa)\x8d\xb7MMI\x9fi\xa7\xf3\x17!\x13\xc44\x11qp\x16\xda\xc0=[l&!\xceN\x86\xbc)H==U\xecO\x13\xabs\xc44]\x1c\x9d+\x0eg\x88\xcdLL\xf7\xab \xa5\x90*ʠ\xa5,Z\xa2\x9c,\xa9g!v5\x941P!\x0fE.\x14\x16 \xe3\xd9\r\xe5J\xbemr%\x1d\xd8\xe9\xfcEHQL!\xe2\xe0<\xb4\x81;[l\bq6\x82\xbc\x12RO\xcf\x11\xfb\xd5bu\xbe\x98j\xc4\xd1\x05\xe2\xf0B\xb1\xb9\b\xd3\xfd\xb9\x90\xba\x18\xa9\xa2K\xd0ҥh\x89.\x93%\xf5\xe5\x88\xdd+\xa0̕P\xe1*(\xba\x1a\n\xaf\x81̵|\x85\xf2\xd7\xf1\xee\xf2\xfaz~>\xec-\xf7?1݀8\xb8\x11m\xe0\xde$67#\xce\xde\x02y\xb7\"\xf5\xf4mb\xffv\xb1\xbaCLw\x8a\xa3\xbb\xc4\xe1\xddbs\x0f\xa6\xfb\xf7B\xea>\xa4\x8a\xeeGK\x0f\xa0%zP\x96\xd4\x0f!v\x1f\x862\x8f@\x85G\xa1\xe81(|\x1c2O,H\x15\xf2O\xda]\xe5\xf5S6\xe1\xffi\f\xa2g8\v\x9e\xe5&p\x9f\x83\xcc\xf3\x9ce_`z/r\xe4\xe9\x97 \xffeH\xbd\x02ѫP\xf4\x1a\x14\xbe\x0e\x997x\x9a\xff&S\xbdő\xa2\xb7\xb9\xa1w\xb8!z\x17k\xe8\xf78s\xdfgf>`\x16>dF\x1f1Ï\x99\xe6\x93\x05\xa9\xa8\xea\xd3\x05eQ\x95\xfelA\xb9\xa5\xfe\x1c\xa2/8\v\xbe\xe4&p\xbf\x82\xccלe\xbfaz\xdfr\xe4\xe9\xef \xff{H\xfd\x00яP4\x0f\n\xe7Cf\x01O\xf3\x172\xd5\"\x8e\x14-憖pC\xb4\x14k\xe8e\x9c\xb9˙\x99\x9f\x98\x85\x9f\x99\xd1\nf\xb8\x92iV1s\xabyBN\xafYP\xc1\xd2kŴ\x0eq\xb0\x1em\xe0n\x10\x9b\x8d\x88\xb3\x9b o3ROo\x11\xfb[\xc5j\x9b\x98\xb6\x8b\xa3\x1d\xe2p\xa7\xd8\xec\xc2t\u007f7\xa4\xf6 U\xf4\vZ\xfa\x15-\xd1o\xb2\xa4\xfe\x1d\xb1\xfb\a\x94\xf9\x13*\xfc\x05E\u007fC\xe1?\x90\xf9\xd7n\xa8\xa6\xaa\xd665U\xba\xceN\xe7/B\xea\xc5\xf4\x1f\xe2`/\xda\xc0m\x10\x9b\x18qv\x9f\x85,\xcfYȩ\xa7Sb\xbfL\xac\xca\xc5T!\x8e*\xc5\xe1\xbeb\xb3\x1f\xa6\xfb\xfbC\xea\x00\xa4\x8a\x0eDK\a\xa1%:\x18\x0e\xf4!\x88\xddC\xa1\xccaP\xe1p(:\x02\n\x8f\x84\xccQP\xeehL\xcc\xe9c\x16V\xc2\xfaؤ\xa0\xe3d$8^\x82\xc0=!)̉2\x92=I\xec\x9d,\x03\x9e>%)\xfcS\x93B\xa5\x93\x82NK\x8a\xe8\xf4\xa4\b\x1b%\x85i,\x87\xf1\x9b\x88US\x19P\xd4L\x02j.\x01Q\x8b\xe4\ftK\x19q[\x893\xadŅ6⨭8l'6g,,\x8br\xc5\xf6v\xcb\xf6sN\a\x1b\xf2瞎b\xea\x848\xe8\x8c6p\xbb\x88MW\xc4\xd9n\x90\xd7\x1d\xa9\xa7{\x88\xfd\x9eb\xd5KL\xbd\xc5Q\x1fq\xd8Wl\xfaa\xba\xdf\x1fR\x03\x90*\x1a\x88\x96\x06\xa1%\x1a,K\xea!\x88ݡPf\x18T\x18\x0eE#\xa0p$dF-LE\xb9Ѽ+=\x86\x13\xad\xc7B4\x8e\xb3`<7\x81{&d&p\x96\x9d\xc8\xf4\xce\xe2\xc8\xd3gC\xfe$HM\x86h\n\x14M\x85\xc2i\x909\x87\xa7\xf9ә\xea\\\x8e\x14\xcd\xe0\x86frCT\x855\xb4\xe2\xcc\xcd03Yf!njf1C\xcd4\x86o\xb9\\1\xcf\x17\x85\xff.\x13_M\xfc]\xa6\xa4 OF\x02_\x82\xc0\r\x92\xc2\x14e$\x1b\x8a\xbd\xf3d\xc0ӳ\x93§\xa4PQRP))\xa29I\x11V'\x859_\x0e\xe3\u05c8\xd5\x052\xa0\xe8B\t\xe8\"\t\x88\xe6&g\xa0/\x96\x11\xf7\x12q\xe6Rq\xe12qt\xb98\xbcBl\xae\xb4[\xae\xc9]\x85-\xeb\xab\x11j}\x8d\x98\xaeE\x1c\\\x876p\xaf\x17\x9b\xff!\xce\xde\x00y7\"\xf5\xf4Mb\xfff\xb1\xbaEL\xb7\x8a\xa3\xdb\xc4\xe1\xedbs\a\xa6\xfbwB\xea.\xa4\x8a\xeeFK\xf7\xa0%\xbaW\x96\xd4\xf7!v\xef\x872\x0f@\x85\a\xa1\xe8!(|\x182\x8f\xd8[\xae\xf8\xa8\xddUQ?f\x13\xfesL\x10=\xc1Y\xf0$7\x81\xfb\x14d\x9e\xe6,\xfb\f\xd3{\x96#O?\a\xf9\xcfC\xea\x05\x88^\x84\xa2\x97\xa0\xf0eȼ\xc2\xd3\xfcW\x99\xea5\x8e\x14\xbd\xce\r\xbd\xc1\rћXC\xbfř\xfb63\xf3\x0e\xb3\xf0.3z\x8f\x19\xbe\xcf4\x1fXVW}h'TW\xe9\x8f\xec\x9e\xf9\x8b\x90\x8f\xc5\xf4\t\xe2\xe0S\xb4\x81\xfb\x99\xd8|\x8e8\xfb\x05\xe4}\x89\xd4\xd3_\x89\xfd\xaf\xc5\xea\x1b1}+\x8e\xbe\x13\x87ߋ\xcd\x0f\x98\xee\xff\b\xa9yH\x15\xcdGK\v\xd0\x12-\x94%\xf5\"\xc4\xeeb(\xb3\x04*,\x85\xa2eP\xb8\x1c2?A\xb9\x9f11\xa7W\xd8\xdb\x13_\x84\xacL\nZ%#\xc1j\t\x02wMR\x98\xb52\x92]'\xf6\xd6ˀ\xa77$\x85\xbf1)Ԧ\xa4\xa0\xcdI\x11mI\x8apkR\x98mr\x18\u007f\xbbX\xed\x90\x01E;%\xa0]\x12\x10\xedN\xce@\xef\x91\x11\xf7\x17q\xe6Wq\xe17q\xf4\xbb8\xfcCl\xfe\xe4k\x98\xfb\x8b/wN\xffmC\xfe\"\xe4\x1f1\xfd\x8b8\xa8E\x1b\xb8ubS\x8f8\xfb\x1f\xe4\xedE\xea\xe9\x06\xb1\x1f\x8b\xd5>\x8b`r\xc4QJ\x1c\x96\x89M\xf9\"\x9e\xeeW@\xaa\x12\xa9\xa2}\xd1\xd2~h\x89\xf6\x87\x03}\x00b\xf7@(s\x10T8\x18\x8a\x0e\x81\xc2C!s\xd8\"\xfb\xa6P<\xdc65E}\x84\x9d\xce_\x84\x1c)\xa6\xa3\x10\aG\xa3\r\xdcc\xc4\xe6X\xc4\xd9\xe3 \xefx\xa4\x9e>A\xec\x9f(V'\x89\xe9dqt\x8a8<UlҘ\xee\x9f\x06\xa9ӑ*j\x84\x96\x1a\xa3%j\"Kꦈ\xddfP\xa69Th\x01E-\xa1\xb0\x15dZ/JE\xa56vW%\xdd\xd6&\xf6\x17\x9ev\x10\x9d\xc1YО\x9b\xc0\xed\x00\x99\x8e\x9ce;1\xbd\xce\x1cy\xba\v\xe4w\x85T7\x88\xbaCQ\x0f(\xec\t\x99^<\xcd\xef\xcdT}8Rԗ\x1b\xea\xc7\rQ\u007f\xac\xa1\ap\xe6\x0edf\x061\v\x83\x99\xd1\x10f8\x94i\x86هV\xe7\x8a\xc3\xedn\xf9{\x8f\x11\x8b*a=2)h\x94\x8c\x04\xa3%\b\xdc1Ia\xc6\xcaHv\x9c\xd8\x1b/\x03\x9e>3)\xfc\tI\xa1&&\x05\x9d\x95\x14\xd1\xd9I\x11NJ\n3Y\x0e\xe3O\x11\xab\xa92\xa0h\x9a\x04t\x8e\x04Dӓ3\xd0\xe7ʈ;C\x9c\x99).T\x89#%\x0e3b\x93\xb5[\xae\xce\xe5\xb0e=\v\xa1\xd6ZL\x06q\x90G\x1b\xb8\xae\xd8\x14\x10g=\xc8\xf3\x91z:\x10\xfbE\xb1\n\xc5t\x9e8\x9a-\x0eIl\"L\xf7K\x90\x9a\x83TQ5Z:\x1f-Q\x8d,\xa9/@\xec^\be.\x82\ns\xa1\xe8b(\xbc\x042\x97\xf2\x86\xf2\x97q\x93ח\xf3t\xfb{\xdc\x15b\xba\x12qp\x15\xda\xc0\xbdZl\xaeA\x9c\xbd\x16\xf2\xaeC\xea\xe9\xeb\xc5\xfe\xff\xc4\xea\x061\xdd(\x8en\x12\x877\x8b\xcd-\x98\xee\xdf\n\xa9ې*\xba\x1d-݁\x96\xe8NYR߅ؽ\x1b\xca\xdc\x03\x15\ue162\xfb\xa0\xf0~\xc8<\xc0o\n\xa5\a\xf9\x05U\xd2\x0f\xf1Kо\x8c\x1e\x16\xd3#\x88\x83G\xd1\x06\xeecb\xf38\xe2\xec\x13\x90\xf7$RO?%\xf6\x9f\x16\xabg\xc4\xf4\xac8zN\x1c>/6/`\xba\xff\"\xa4^B\xaa\xe8e\xb4\xf4\nZ\xa2WeI\xfd\x1ab\xf7u(\xf3\x06Tx\x13\x8aނ·!\xf3\x8e\xddP\xae\xf4\xaemr%\xfd\x9e\x9d\xce_\x84\xbc/\xa6\x0f\x10\a\x1f\xa2\r\u070f\xc4\xe6c\xc4\xd9O \xefS\xa4\x9e\xfeL\xec\u007f.V_\x88\xe9Kq\xf4\x958\xfcZl\xbe\xc1t\xff[H}\x87T\xd1\xf7h\xe9\a\xb4D?ʒz\x1ebw>\x94Y\x00\x15\x16B\xd1\"(\\\f\x99%|\x85\xf2Kywy\xbd\x8c\x9f\x0f{\xcb-\x17\xd3O\x88\x83\x9f\xd1\x06\xee\n\xb1Y\x898\xbb\n\xf2V#\xf5\xf4\x1a\xb1\xbfV\xac։i\xbd8\xda \x0e7\x8a\xcd&L\xf77Cj\vRE[\xd1\xd26\xb4D\xdbeI\xbd\x03\xb1\xbb\x13\xca\xec\x82\n\xbb\xa1h\x0f\x14\xfe\x02\x99_\xed\xdbv\xfe7\xbb\xab\xbc\xfe\xdd&\xfc\u007f\aA\xf4'g\xc1_\xdc\x04\xeeߐ\xf9\x87\xb3\xec\xbfL\xaf\x96#O\xd7A~=\xa4\xfe\x83h/\x145@a\f\x99}\x16\xdbi\xbe\xc3T\xa9\xc56RT\xc6\r\x95sCT\xc1\nt%g\xee\xbe\xcc\xcc~\xcc\xc2\xfe\xcc\xe8\x00fx \xd3\x1c\xb48\x15V\x1d\xbc\xb8,\xac҇,.\xb7ԇBt\x18g\xc1\xe1\xdc\x04\xee\x11\x909\x92\xb3\xecQL\xefh\x8e<}\f\xe4\x1f\v\xa9\xe3 :\x1e\x8aN\x80\xc2\x13!s\x12O\xf3Of\xaaS8Rt*7\x94\xe6\x86\xe84\xac\xa1O\xe7\xccm\xc4\xcc4f\x16\x9a0\xa3\xa6̰\x19\xd34g\xe6Z\xf0\x84\x9cn\xb9\xb8\x82\xa5[\x89\xa95\xe2\xa0\r\xda\xc0m+6\xed\x10gπ\xbc\xf6H=\xddA\xecw\x14\xabNb\xea,\x8e\xba\x88îb\xd3\r\xd3\xfd\xee\x90\xea\x81TQO\xb4\xd4\v-QoYR\xf7A\xec\xf6\x852\xfd\xa0B\u007f(\x1a\x00\x85\x03!3\xc8n\xa8\xa6j\xb0mj\xaa\xf4\x10;\x9d\xbf\b\x19*\xa6a\x88\x83\xe1h\x03w\x84،D\x9c\x1d\x05y\xa3\x91zz\x8c\xd8\x1f+V\xe3\xc44^\x1c\x9d)\x0e'\x88\xcdDL\xf7ς\xd4\xd9H\x15MBK\x93\xd1\x12M\x91%\xf5T\xc4\xee4(s\x0eT\x98\x0eE\xe7B\xe1\f\xc8̄rU\x98\x98\xd3jq%\xac3IAY\x19\tr\x12\x04\ueb240ZF\xb2F\xec\xe5e\xc0\xd3nR\xf8\x85\xa4P^R\x90\x9f\x14Q\x90\x14a1)L(\x87\xf1\xcf\x13\xab\xd92\xa0\x88$\xa0H\x02\xa2Rr\x06z\x8e\x8c\xb8\xd5\xe2\xcc\xf9\xe2B\x8d8\xba@\x1c^(6\x17٫\x97+ε[\xb6\x9fs.\xb6!\u007f\xee\xb9DL\x97\"\x0e.C\x1b\xb8\x97\x8b\xcd\x15\x88\xb3WB\xdeUH=}\xb5ؿF\xac\xae\x15\xd3u\xe2\xe8zq\xf8?\xb1\xb9\x01\xd3\xfd\x1b!u\x13RE7\xa3\xa5[\xd0\x12\xdd*K\xea\xdb\x10\xbb\xb7C\x99;\xa0\u009dPt\x17\x14\xde\r\x99{\xec\x9bB\xee^ޕ\xbe\x8f\x13\xad\xef\x87\xe8\x01\u0382\a\xb9\t܇ \xf30g\xd9G\x98ޣ\x1cy\xfa1\xc8\u007f\x1cRO@\xf4$\x14=\x05\x85OC\xe6\x19\x9e\xe6?\xcbT\xcfq\xa4\xe8yn\xe8\x05n\x88^\xc4\x1a\xfa%\xceܗ\x99\x99W\x98\x85W\x99\xd1k\xcc\xf0u\xa6y\x83o\xb9\\\xf1M\xbe(\xfc\xf7\x82\xf8j\xe2/\x06%\x05\xbd##\xc1\xbb\x12\x04\xee{Iaޗ\x91\xec\ab\xefC\x19\xf0\xf4GI\xe1\u007f\x9c\x14ꓤ\xa0O\x93\"\xfa,)\xc2ϓ\xc2|!\x87\xf1\xbf\x14\xab\xafd@\xd1\xd7\x12\xd07\x12\x10}\x9b\x9c\x81\xfeNF\xdc\xefř\x1fą\x1f\xc5\xd1<q8_l\x16\xf0\x1bFn!\xb6\xac\x17!\xd4z\xb1\x98\x96 \x0e\x96\xa2\r\xdceb\xb3\x1cq\xf6'\xc8\xfb\x19\xa9\xa7W\x88\xfd\x95b\xb5JL\xab\xc5\xd1\x1aq\xb8Vl\xd6a\xba\xbf\x1eR\x1b\x90*ڈ\x966\xa1%\xda,K\xea-\x88ݭPf\x1bT\xd8\x0eE;\xa0p'dv\xd9[\xae\xb8\xdb\ueaa8\xf7\u0604\xff0\x11D\xbfr\x16\xfc\xc6M\xe0\xfe\x0e\x99?8\xcb\xfe\xc9\xf4\xfe\xe2\xc8\xd3\u007fC\xfe?\x90\xfa\x17\xa2Z(\xaa\x83\xc2z\xc8\xfc\xc7\xd3\xfc\xbdL\xd5\xc0\x91\xa2\x98\x1b\xdag\x89m\x88\x1cV\xa0SKl\xe6\x9613\xe5\xccB\x053\xaad\x86\xfb2\xcd~\x96\xd5U\xfb\xdb\t\xd5U\xfa\x80%\x15,}\xa0\x98\x0eB\x1c\x1c\x8c6p\x0f\x11\x9bC\x11g\x0f\x83\xbcÑz\xfa\b\xb1\u007f\xa4X\x1d%\xa6\xa3\xc5\xd11\xe2\xf0X\xb19\x0e\xd3\xfd\xe3!u\x02RE'\xa2\xa5\x93\xd0\x12\x9d,K\xeaS\x10\xbb\xa7B\x994T8\r\x8aN\x87\xc2F\x90i\f\xe5\x9a`bN7]R\t\xebfIA\xcde$h!A\xe0\xb6L\n\xd3JF\xb2\xad\xc5^\x1b\x19\xf0tۤ\xf0\xdb%\x85:#)\xa8}RD\x1d\x92\"\xec\x98\x14\xa6\x93\x1c\xc6\xef,V]d@QW\t\xa8\x9b\x04Dݓ3\xd0=d\xc4\xed)\xce\xf4\x12\x17z\x8b\xa3>\u2c2f\xd8\xf4\xe3k\x98\xebϗ;\xa7\aؐ\xbf\b\x19(\xa6A\x88\x83\xc1h\x03w\x88\xd8\fE\x9c\x1d\x06yÑzz\x84\xd8\x1f)V\xa3\xc44Z\x1c\x8d\x11\x87c\xc5f\x1c\xa6\xfb\xe3!u&RE\x13\xd0\xd2D\xb4Dgɒ\xfal\xc4\xee$(3\x19*L\x81\xa2\xa9P8\r2\xe7\xd8\r\xd5\x14\xa7ۦ\xa6\xa8ϵ\xd3\xf9\x8b\x90\x19b\x9a\x898\xa8B\x1b\xb8Jl2\x88\xb3Y\xc8\xcb!\xf5\xf4,\xb1\xaf\xc5ʈ)/\x8e\\qX\x10\x1b\x0f\xd3}\x1fR\x01REE\xb4\x14\xa2%:O\x96Գ\x11\xbb\x04e\"\xa8P\x82\xa29PX\r\x99\xf3\x97\xa4\xc2R\x8d\xddUI_`\x13\xfb\vυ\x10]\xc4Y0\x97\x9b\xc0\xbd\x182\x97p\x96\xbd\x94\xe9]Ƒ\xa7/\x87\xfc+ u%DWA\xd1\xd5Px\rd\xae\xe5i\xfeuLu=G\x8a\xfe\xc7\r\xdd\xc0\rэXC\xdfę{33s\v\xb3p+3\xba\x8d\x19\xde\xce4w\xf0k(W\xbc\x93\xef2\xfbc\xe7.\xbe=\xf9\xe7\xd0\xddIA\xf7\xc8Hp\xaf\x04\x81{_R\x98\xfbe$\xfb\x80\xd8{P\x06<\xfdPR\xf8\x0f'\x85z$)\xe8Ѥ\x88\x1eK\x8a\xf0\xf1\xa40O\xc8a\xfc'\xc5\xea)\x19P\xf4\xb4\x04\xf4\x8c\x04D\xcf&g\xa0\x9f\x93\x11\xf7yq\xe6\x05q\xe1Eq\xf4\x928|Yl^\xe1w\xc0ܫز~\r\xa1֯\x8b\xe9\r\xc4\xc1\x9bh\x03\xf7-\xb1y\x1bq\xf6\x1d\xc8{\x17\xa9\xa7\xdf\x13\xfb\xef\x8b\xd5\ab\xfaP\x1c}$\x0e?\x16\x9bO0\xdd\xff\x14R\x9f!U\xf49Z\xfa\x02-ї\xb2\xa4\xfe\n\xb1\xfb5\x94\xf9\x06*|\vE\xdfA\xe1\xf7\x90\xf9\x817\x94\xff\x91\x9b\xbc\x9e\xc7\xd3\xed\xefq\xf3Ŵ\x00q\xb0\x10m\xe0.\x12\x9bň\xb3K o)RO/\x13\xfb\xcb\xc5\xea'1\xfd,\x8eV\x88Õb\xb3\n\xd3\xfdՐZ\x83T\xd1Z\xb4\xb4\x0e-\xd1zYRo@\xecn\x842\x9b\xa0\xc2f(\xda\x02\x85[!\xb3\x8d\xdf\x14J\xdb\xf9\x05U\xd2;\xf8%h_F;Ŵ\vq\xb0\x1bm\xe0\xee\x11\x9b_\x10g\u007f\x85\xbcߐz\xfaw\xb1\xff\x87X\xfd)\xa6\xbf\xc4\xd1\xdf\xe2\xf0\x1f\xb1\xf9\x17\xd3\xfdZH\xd5!UT\x8f\x96\xfeCK\xb4W\x96\xd4\r\x88\xdd\x18\xca쳔Up\xa0(\x05\x85e\x90)_j?\xed\x95*l\x93+\xe9ʥ\x15,\xbd\xaf\x98\xf6C\x1c\xec\x8f6p\x0f\x10\x9b\x03\x11g\x0f\x82\xbc\x83\x91z\xfa\x10\xb1\u007f\xa8X\x1d&\xa6\xc3\xc5\xd1\x11\xe2\xf0H\xb19\n\xd3\xfd\xa3!u\fREǢ\xa5\xe3\xd0\x12\x1d/K\xea\x13\x10\xbb'B\x99\x93\xa0\xc2\xc9Pt\n\x14\x9e\n\x99\xb4\xddPM\xfe4\xde]^\x9fn\xa7\xf3\x17!\x8d\xc4\xd4\x18q\xd0\x04m\xe06\x15\x9bf\x88\xb3\xcd!\xaf\x05RO\xb7\x14\xfb\xadĪ\xb5\x98ڈ\xa3\xb6Ⱍ\u061c\x81\xe9~{Hu@\xaa\xa8#Zꄖ\xa8\xb3,\xa9\xbb v\xbbB\x99nP\xa1;\x14\xf5\x80\u009e\x90\xe9\xb54\x15\xe6{\xdb]\xe5u\x1f\x9b\xf0\xff\xe8\x03Q?\u0382\xfe\xdc\x04\xee\x00\xc8\f\xe4,;\x88\xe9\r\xe6\xc8\xd3C \u007f(\xa4\x86A4\x1c\x8aF@\xe1HȌ\xe2i\xfeh\xa6\x1aÑ\xa2\xb1\xdc\xd08n\x88\xc6c\r}&g\xee\x04ff\"\xb3p\x163:\x9b\x19Nb\x9a\xc9KS\xa6j\xca\xd22S\xa5\xa7.-\xb7\xd4\xd3 :\x87\xb3`:7\x81{.dfp\x96\x9d\xc9\xf4\xaa8\xf2\xb4\x82\xfc\f\xa4\xb2\x10\xe5\xa0h\x16\x14j\xc8\x18\x9e\xe6\xe7\x99\xca\xe5HQ\x81\x1b\xf2\xb8!\xf2\xb1\x86\x0e8s\x8b\xccL\xc8,\x9cnjf3Cb\x9a\x88\x99+\U0004471e\xb3\xb4\x82\xa5\xab\xc5t>\xe2\xa0\x06m\xe0^ 6\x17\"\xce^\x04ys\x91z\xfab\xb1\u007f\x89X]*\xa6\xcb\xc4\xd1\xe5\xe2\xf0\n\xb1\xb9\x12\xd3\xfd\xab u5REנ\xa5k\xd1\x12]'K\xea\xeb\x11\xbb\xff\x8327@\x85\x1b\xa1\xe8&(\xbc\x192\xb7\xd8\r\xd5T\xddj\x9b\x9a*}\x9b\x9d\xce_\x84\xdc.\xa6;\x10\aw\xa2\rܻ\xc4\xe6n\xc4\xd9{ \xef^\xa4\x9e\xbeO\xec\xdf/V\x0f\x88\xe9Aq\xf4\x908|Xl\x1e\xc1t\xffQH=\x86T\xd1\xe3h\xe9\t\xb4DOʒ\xfa)\xc4\xee\xd3P\xe6\x19\xa8\xf0,\x14=\a\x85\xcfC\xe6\x05(\xf7\"&\xe6\xf4KK+a\xfdrR\xd0+2\x12\xbc*Aྖ\x14\xe6u\x19ɾ!\xf6ޔ\x01O\xbf\x95\x14\xfe\xdbI\xa1\xdeI\nz7)\xa2\xf7\x92\"|?)\xcc\ar\x18\xffC\xb1\xfaH\x06\x14},\x01}\"\x01ѧ\xc9\x19\xe8\xcfd\xc4\xfd\\\x9c\xf9B\\\xf8R\x1c}%\x0e\xbf\x16\x9bo\xec\xd5\xcb\x15\xbf\xb5[\xb6\x9fs\xbe\xb3!\u007f\xee\xf9^L? \x0e~D\x1b\xb8\xf3\xc4f>\xe2\xec\x02\xc8[\x88\xd4Ӌ\xc4\xfeb\xb1Z\"\xa6\xa5\xe2h\x998\\.6?a\xba\xff3\xa4V U\xb4\x12-\xadBK\xb4Z\x96\xd4k\x10\xbbk\xa1\xcc:\xa8\xb0\x1e\x8a6@\xe1F\xc8l\xb2o\n\xb9ͼ+\xbd\x85\x13\xad\xb7B\xb4\x8d\xb3`;7\x81\xbb\x032;9\xcb\xeebz\xbb9\xf2\xf4\x1e\xc8\xff\x05R\xbfB\xf4\x1b\x14\xfd\x0e\x85\u007f@\xe6O\x9e\xe6\xff\xc5T\u007fs\xa4\xe8\x1fn\xe8_n\x88j\xb1\x86\xae\xe3̭gf\xfec\x16\xf62\xa3\x06f\x183\xcd>\xcb\xec-\x97+:\xcb*X:\xb5\xac\x12\xd6eIA\xe52\x12TH\x10\xb8\x95Ia\xf6\x95\x91\xec~bo\u007f\x19\xf0\xf4\x01I\xe1\x1f\x98\x14ꠤ\xa0\x83\x93\":$)\xc2C\x93\xc2\x1c&\x87\xf1\x0f\x17\xab#d@ё\x12\xd0Q\x12\x10\x1d\x9d\x9c\x81>FF\xdccř\xe3ą\xe3\xc5\xd1\t\xe2\xf0D\xb19i\x99}\xc3ȝ\x8c-\xebS\x10j}\xaa\x98҈\x83\xd3\xd0\x06\xee\xe9b\xd3\bq\xb61\xe45A\xea\xe9\xa6b\xbf\x99X5\x17S\vq\xd4R\x1c\xb6\x12\x9b֘\uedc1T[\xa4\x8aڡ\xa53\xd0\x12\xb5\x97%u\a\xc4nG(\xd3\t*t\x86\xa2.P\xd8\x152ݖ\xa5L\xb1\xbb\xddUQ\xf7\xb0\t\xff\xe5(\x88zq\x16\xf4\xe6&p\xfb@\xa6/g\xd9~L\xaf?G\x9e\x1e\x00\xf9\x03!5\b\xa2\xc1P4\x04\n\x87Bf\x18O\xf3\x873\xd5\b\x8e\x14\x8d\xe4\x86FqC4\x1ak\xe81\x9c\xb9c\x99\x99q\xcc\xc2xft&3\x9c\xc04\x13-\xab\xabβ\x13\xaa\xab\xf4\xd9v\xcf\xfcE\xc8$1MF\x1cLA\x1b\xb8S\xc5f\x1a\xe2\xec9\x907\x1d\xa9\xa7\xcf\x15\xfb3\xc4j\xa6\x98\xaađ\x12\x87\x19\xb1\xc9b\xba\x9f\x83\xd4,\xa4\x8a4Z2h\x89\xf2\xb2\xa4v\x11\xbb\x05(\xe3A\x05\x1f\x8a\x02(,B&\x84r\xe7abN϶\xb7'\xbe\b\xa1\xa4\xa0HF\x82\x92\x04\x81;')L\xb5\x8cd\xcf\x17{52\xe0\xe9\v\x92¿0)\xd4EIAs\x93\"\xba8)\xc2K\x92\xc2\\*\x87\xf1/\x13\xab\xcbe@\xd1\x15\x12Е\x12\x10]\x95\x9c\x81\xbeZF\xdckękŅ\xeb\xc4\xd1\xf5\xe2\xf0\u007fbs\x03_\xc3܍|\xb9s\xfa&\x1b\xf2\x17!7\x8b\xe9\x16\xc4\xc1\xadh\x03\xf76\xb1\xb9\x1dq\xf6\x0eȻ\x13\xa9\xa7\xef\x12\xfbw\x8b\xd5=b\xbaW\x1c\xdd'\x0e\xef\x17\x9b\a0\xdd\u007f\x10R\x0f!U\xf40Zz\x04-ѣ\xb2\xa4~\f\xb1\xfb8\x94y\x02*<\tEOA\xe1Ӑy\x86\xdf\x14\x8a\xcf\xf2\v\xaa\xa8\x9f㗠}\x19=/\xa6\x17\x10\a/\xa2\rܗ\xc4\xe6e\xc4\xd9W \xefU\xa4\x9e~M\xec\xbf.Vo\x88\xe9Mq\xf4\x968|[l\xde\xc1t\xff]H\xbd\x87T\xd1\xfbh\xe9\x03\xb4D\x1fʒ\xfa#\xc4\xee\xc7P\xe6\x13\xa8\xf0)\x14}\x06\x85\x9fC\xe6\v\xfb\xa6P\xfa\xd2\ueaa4\xbf\xb2\x89\xfd\x85\xe7k\x88\xbe\xe1,\xf8\x96\x9b\xc0\xfd\x0e2\xdfs\x96\xfd\x81\xe9\xfdȑ\xa7\xe7A\xfe|H-\x80h!\x14-\x82\xc2ŐY\xc2\xd3\xfc\xa5L\xb5\x8c#E˹\xa1\x9f\xb8!\xfa\x19k\xe8\x15\x9c\xb9+\x99\x99U\xcc\xc2jf\xb4\x86\x19\xaee\x9au\xfc\x1a\xca\x15\xd7\xf3]f\u007f\xecl\xe0ۓ\u007f\x0emL\n\xda$#\xc1f\t\x02wKR\x98\xad2\x92\xdd&\xf6\xb6ˀ\xa7w$\x85\xbf3)\u052e\xa4\xa0\xddI\x11\xedI\x8a\xf0\x97\xa40\xbf\xcaa\xfc\xdf\xc4\xeaw\x19P\xf4\x87\x04\xf4\xa7\x04D\u007f%g\xa0\xff\x96\x11\xf7\x1fq\xe6_q\xa1V\x1cՉ\xc3z\xb1\xf9\x8f\xdf\x01s{\xb1e݀P\xebXL\xfb,\xe78p\x96s\x1b\xb8)\xb1)C\x9c-\x87\xbc\n\xa4\x9e\xae\x14\xfb\xfb\x8a\xd5~b\xda_\x1c\x1d \x0e\x0f\x14\x9b\x830\xdd?\x18R\x87 Ut(Z:\f-\xd1\u1ca4>\x02\xb1{$\x949\n*\x1c\rE\xc7@᱐9n\xb9\xddP\xfexn\xf2\xfa\x04\x9en\u007f\x8f;QL'!\x0eNF\x1b\xb8\xa7\x88ͩ\x88\xb3i\xc8;\r\xa9\xa7O\x17\xfb\x8dĪ\xb1\x98\x9a\x88\xa3\xa6Ⱉ\xd84\xc7t\xbf\x05\xa4Z\"U\xd4\n-\xb5FK\xd4F\x96\xd4m\x11\xbb\xed\xa0\xcc\x19P\xa1=\x14u\x80\u008e\x90\xe9d7TS\xeal\x9b\x9a\x92\xeeb\xa7\xf3\x17!]\xc5\xd4\rq\xd0\x1dm\xe0\xf6\x10\x9b\x9e\x88\xb3\xbd \xaf7RO\xf7\x11\xfb}Ū\x9f\x98\xfa\x8b\xa3\x01\xe2p\xa0\xd8\f\xc2t\u007f0\xa4\x86 U4\x14-\rCK4\\\x96\xd4#\x10\xbb#\xa1\xcc(\xa80\x1a\x8a\xc6@\xe1XȌ\xb3\x1bʕ\xc6\xdb&W\xd2g\xda\xe9\xfcE\xc8\x041MD\x1c\x9c\x856p\xcf\x16\x9bI\x88\xb3\x93!o\nROO\x15\xfb\xd3\xc4\xea\x1c1M\x17G\xe7\x8a\xc3\x19b3\x13\xd3\xfd*H)\xa4\x8a2h)\x8b\x96('K\xeaY\x88]\re\fT\xc8C\x91\v\x85\x05\xc8x|\x85\xf2>\xef.\xaf\x03~>\xec-W\x14S\x8888\x0fm\xe0\xce\x16\x1bB\x9c\x8d \xaf\x84\xd4\xd3s\xc4~\xb5X\x9d/\xa6\x1aqt\x818\xbcPl.\xc2t\u007f.\xa4.F\xaa\xe8\x12\xb4t)Z\xa2\xcbdI}9b\xf7\n(s%T\xb8\n\x8a\xae\x86\xc2k s\xed\xf2\x94\xc9_gw\x95\xd7\xd7ۄ\xffG\x1f\x88n\xe0,\xb8\x91\x9b\xc0\xbd\t27s\x96\xbd\x85\xe9\xddʑ\xa7o\x83\xfc\xdb!u\aDwB\xd1]Px7d\xee\xe1i\xfe\xbdLu\x1fG\x8a\xee\xe7\x86\x1e\xe0\x86\xe8A\xac\xa1\x1f\xe2\xcc}\x98\x99y\x84Yx\x94\x19=\xc6\f\x1fg\x9a'\x96\x97M\xeb;\xfdI\xf0)\xf0i\xf0\x19\xf0Y\xf09\xf0y\xf0\x05\xf0E\xf0%\xf0e\xf0\x15\xf0U\xf05\xf0u\xf0\r\xf0M\xf0-\xf0m\xf0\x1d\xf0]\xf0=\xf0}\xf0\x03\xf0C\xf0#\xf0c\xf0\x13\xf0S\xf03\xf0s\xf0\v\xf0K\xf0+\xf0k\xf0\x1b\xf0[\xf0;\xf0{\xf0\a\xf0Gp\x1e8\x1f\\\x00.\x04\x17\x81\x8b\xc1%\xe0Rp\x19\xb8\x1c\xfc\t\xfc\x19\\\x01\xae\x04W\x81\xab\xc15\xe0Zp\x1d\xb8\x1e\xdc\x00n\x047\x81\x9b\xc1-\xe0Vp\x1b\xb8\x1d\xdc\x01\xee\x04w\x81\xbb\xc1=\xe0/\xe0\xaf\xe0o\xe0\xef\xe0\x1f\xe0\x9f\xe0_\xe0\xdf\xe0?\xe0\xbf`-X\aփ\xff\x81{\xc1\x06p\x9f\xda\xf2\x91U5i\xa7\xb6\xd2*\xd0\xe9Tm\xd9\xc8\\\xba̲\x98.\xb7cE/]\xc1ʤ+\xad\xaa\xf3\xe9}E\xfb\xd5V\x8c\xb4oq\xe9\xfdm[\xf2\xd2\a\xb0\xfc\xf4\x81\xb5ec\xaa\xd2\a\x81\a\x83\x87Ԗ\x8d\xaaJ\x1f\x8a\xfa0\xf0p\xf0\b\xf0H\xf0\xa8\xda\xf21U\x85\xf4ѢcDNJ\x8e\x13\x1d/:At\"+H\x9f$:Yt\x8a\xe8TQZt\x1a\xcbO\x9f.j$j,j\xc2\n\xd3ME\xcdD\xcdk+\xec<\x9dn\x91\xb8e\xe2V\x89['n\xc3\x0f\xafI\xb7\xad\xad\x1c\x83筝\xddI1}\x06\xd8\x1e\xec\x00v\x04;\x81\x9d\xc1.`W\xb0\x1b\xd8\x1d\xec\x01\xf6\xb4\xc7-\x16ҽD\xbdE}D}E\xfdD\xfdYAz\x80=!\xfb\x19'=0\xf1\xa0ă\x13\x0f\xe1\x87դ\x87\x8a\x86\x89\x86\x8bFXU\x97\xd2#E\xa3D\xa3EcDcE\xe3D\xe3EgZ\x95\n\xe9\t\xa2\x89,?}\x96]\xd0\xfe\x88H\x9f\x9dxR\xe2ɉ\xa7$\x9eZ[>\xd1\x1ec\x1an\x8csj\xcbG\xd9\v:]t.+HϨ\xad\x1cſh\xa7g\xda\xc7\x14\xd3U\xb5\x15\xa3\xec\x8f\u07b4\xb2]>\x9d\xa9-\x1f\x97\xabIgYA:W[1\xce>4=˶\xf6\xa0ڶ\xd5\xf6\xa1\xa6\xb6l\\>\x9d\xaf-\x9f`\x8f\xea\x8a\n,?\xed\xd5VL\xa8\xaa)\xa4\xfd\xda\xca\t\xb8r\x81\xcdsa\xbaȪI\x87v\xb8\xda^\xd8\xf3l\x9b\x0fҳY~\x9aXa:\xaa-\x9bR\x95.ՖO\xb1Ǜ#\xaa\xae\xad\x98\xc27\xc4\xf9\x89k\x12_\x90\xf8\xc2\xc4\x17%\x9e\x9b\xf8\xe2ė\xd8c\xe6җ\x82\x97\x81\x97\x83W\x80W\x82W\x81W\x83׀ׁׂ\xd7\xdb\x13\xc9\x15\xd2\xff\x13\xdd \xbaQt\x13+H\xdf,\xbaEt\xab\xe86\xd1\xed\xa2;Dw\x8a\xee\x12\xdd-\xbaGt\xaf\xe8>\xd1\xfd\xa2\aX^\xfaA\xd1C\xa2\x87E\x8f\x88\x1e\x15=\xc6\xf2ӏ\x8b\x9e\x10=)zJ\xf44+L?c\x9f\x1b\xbe\xfe\xcf&~.\xf1\xf3\x89_H\xfcb\xe2\x97\x12\xbf\x9c\xf8\x95į&~-\xf1\xeb\x89\xdfH\xfc&/W\x93~K\xf4\xb6\xe8\x1dѻ\xb5\xa9\xb1\xe9\xf7\xec\x13\\L\xbf\x0f~\x00~\b~\x04~\f~\x02~\n~\x06~\x0e~a\x17\xe1\x17\xe0\x97\xb5\xe5\x93\xec\x1b\xe5WV\xf6\xe9\xfaڎ\x95\xd2߀߂߁߃?\x80?\x82\xf3\xc0\xf9\xe0\x02p\xa1=3\xfbz[$Z,Z\xc2\n\xd2KE\xcbD\xcbE?\xb1\xbc\xf4Ϣ\x15\xa2\x95\xa2U\xf6\xf4\xf8帺65<\xbd\x86\xb1\x96\xb1\x8e\xb1\x9e\xb1\x81\xb1\x91\xb1\x89\xb1\x99\xb1\x85\xb1\x95\xb1\x8d\xb1\x9d\xb1\x83\xb1\xb3\xb6lx!\xbd\v\xdcm\x19\xa4\xf7\x80\xbf\x80\xbf\x82\xbf\x81\xbf\x83\u007f\x80\u007fZ\xfa\xe9\xbf\xc0\xbf\xc1\u007f,\xc3\xf4\xbf`-XW[1\x90_'\xf5\xb5\xe5\x03\xed\r\xfd_m\xd9\xc0|z\xafm\xec\xeb\xb1\xc1\xcaT\xa5c\xfb\x10c\xc7\xf6\xa9c\xdb\x1ffu\x15\x13\x8d}i\xa6\x12\x97\xd5UN\xe4\xff\n\x93.Ga_\xfc\x15\\\xf0ũ\xac+\x1fg\x8a\xe9}\xeb*\xac\n\xe9\xfd\xea*\x86\xf1\x03\xf7O|\x805\xbf\xbd\x1ch]m\x8ftP]٤R\xfa\xe0\xba\xf2a\xa5b\xfa\x90\xbar\xfb\x034}\xa8谺ʩ8\xe4\xe1\xd2\x1fQW1\xde~JK\x1f)\xedQ\xa2\xa3\xeb\xca&\xe7\xd3\xc7ԕO5\xa5\xf4\xb1ueS\xf2\xe9\xe3\xea\xf8m\xed\xf8\xba\x8a\tƮtB]\xe5\xe4</}b]ِR\xfa\xa4\xba\x8a\x11|\x94\x93\x13\x9fR\xc77©r\xb04\x9f\xa5ΧO\x93\xf6t9j#\xe9\x1a\x8b\x9a`\x8d\xa6ue\x83J\xe9f\x125\x17\xb5\x10\xb5\xac+\x1fb\xdfs[ՕMȧ[\xd7U\f-ٮM\x1d\u007f6h\v\xb6\x03\xcf\x00ۃ\x1d\xc0\x8e`'\xb03\xd8\x05\xec\nv\x03\xbb\x83=\xc0\x9e`/\xb07\xd8\a\xec\v\xf6\x03\xfb\x83\x03\xc0\x81\xe0 p08\x04\x1c\n\x0e\x03\x87\x83#\xc0\x91\xe0(p48\x06\x1c\v\x8e\x03ǃg\x82\x13\xc0\x89\xe0Y\xe0\xd9\xe0$p28\x05\x9c\nN\x03\xcf\x01\xa7\x83\xe7\x823\xc0\x99`\x15\xa8\xc0\f\x98\x05s\xe0,P\x83\x06̃.X\x00=\xd0\a\x03\xb0\b\x86\xe0y\xe0l\x90\xc0\b,\x81s\xc0j\xf0|\xb0\x06\xbc\x00\xbc\x10\xbc\b\x9c\v^\f^\x02^\n^\x06^\x0e^\x01^\t^\x05^\r^\x03^\v^\a^\x0f\xfe\x0f\xbc\x01\xbc\x11\xbc\t\xbc\x19\xbc\x05\xbc\x15\xbc\r\xbc\x1d\xbc\x03\xbc\x13\xbc\v\xbc\x1b\xbc\a\xbc\x17\xbc\x0f\xbc\x1f|\x00|\x10|\b|\x18|\x04|\x14|\f|\x1c|\x02|\x12|\n|\x1a|\x06|\x16|\x0e|\x1e|\x01|\x11|\t|\x19|\x05|\x15|\r|\x1d|\x03|\x13|\v|\x1b|\a|\x17|\x0f|\x1f\xfc\x00\xfc\x10\xfc\b\xfc\x18\xfc\x04\xfc\x14\xfc\f\xfc\x1c\xfc\x02\xfc\x12\xfc\n\xfc\x1a\xfc\x06\xfc\x16\xfc\x0e\xfc\x1e\xfc\x01\xfc\x11\x9c\a\xce\a\x17\x80\v\xc1E\xe0bp\t\xb8\x14\\\x06.\a\u007f\x02\u007f\x06W\x80+\xc1U\xe0jp\r\xb8\x16\\\a\xae\a7\x80\x1b\xc1M\xe0fp\v\xb8\x15\xdc\x06n\aw\x80;\xc1]\xe0np\x0f\xf8\v\xf8+\xf8\x1b\xf8;\xf8\a\xf8'\xf8\x17\xf87\xf8\x0f\xf8/X\vց\xf5\xe0\u007f\xe0^\xb0\x01ܧ>5k\x96c\x91OYxe\xf5e\xb3f\xe5˙^E}\x8a\xa2Jƾ\xf5\xfc\xd0\xfd\xc0\xfd\xc1\x03\xc0\x03\xc1\x83\xc0\x83\xc1C\xc0C\xc1\xc3\xc0\xc3\xc1#\xc0#\xebS~p\x94E\xeeh\x8b\xfc1\xf5\xa99\xc1\xb1\xf5e~\xc1\x1c\x87\xf1\xe3\xc1\x13\xc0\x13\xc1\x93\xc0\x93\xebS5\xf9S\xebS\xf6\x93i\xbd3\xf3\xf4z'ۨ\xde1\x8d\xeb\x9dB\x93z\xc7kZ\xef\xf8\xcd\xec\xbf\xe6\xf5NԢ\xdei\xd5Ҟ\xb2iU\xefPk.\xdaآm\xbdS\xd5\xce\xfek_\xef\xa8\x0e\xf5\x8e\xeeh\x8f\xd0\xc9\x1e\xa1s\xbd3\xa7K\xbdsAW\xac\xd2\xcd\xce\xef^\xef\xd4\xf4\xb0\xc7\xedi\xff\xf5\xb2\xc7\ue351>\xb6ꋪ_\xbd\x13\xf4\xb7\xff\x06\xa0\x1bX\uf103\xec\xbf\xc1\xe8\x86ԧ\"\x1a\xca\x18V\xef\xcc\x1e\u038b\x8f\xb0\x87\x1ciwY\x1ceW\x1em\x8f9\xc6>z\xac=\xdak\x98\xf1:\xf8\x06\xf8&\xf8\x16\xf86\xf8\x0e\xf8.\xf8\x1e\xf8>\xf8\x01\xf8!\xf8\x11\xf81\xf8\t\xf8)\xf8\x19\xf89\xf8\x05\xf8%\xf8\x15\xf85\xf8\r\xf8-\xf8\x1d\xf8=\xf8\x03\xf8#8\x0f\x9c\x0f.\x00\x17\x82\x8b\xe4\xd9؋\x1f[\xe0\x00p 8\b\x1c\f\x0e\x01\x87\x82\xc3\xc0\xe1\xe0\bp$8\n\x1c\r\x8e\x01ǂ\xb7\x80\xb7\x82߀߂߁߃?\x80?\x82\xf3\xc0\xf9\xe0\x02p!\xb8\b\\\f.\x01\x97\x82\xcb\xc0\xe5\xe0O\xe0\xcf\xe0\np%\xb8\n\\\r\xae\x01ׂ\xeb\xc0\xf5\xe0\x06p#\xb8\t\xdc\fn\x01\xb7\x82\xdb\xc0\xed\xe0\x0ep'\xb8\v\xdc\r\xee\x01\u007f\x01\xff\x03\xf7\x82\r\xe0>\rL\aL\x81e`9X\x01V\x82\xfb\x82\xfb\x81\xfb\x83\a\x80\a\x82\a\x81\a\x83\x87\x80\x87\x82\x87\x81\x87\x83G\x80G\x82G\x81G\x83ǀǂǁǃ'\x80'\x82'\x81'\x83\xa7\x80\xa7\x82\x8d\x1a\x9c\x8b\x1b\xa3j\x026\x05\x9b\x81\xcd\xc1\x16`K\xb0\x15\xd8\x1al\x03\xb6\x05ہg4\xa4ڶmߐjӦC\x83Ӧc\x833\xa3\x93\xfd\u05f9\xc1iޥ!\xd5\"ݵ\xc1\xb9\xb0[Cjn\xba{\x833\xadGCjz\xbagCjZ\xf3^\re-\xa6\xa7{7\xa4z\xf5\xea\xd3P֧O\xbao\x83ӫ_C\xaaO\xba\xbf}\xdc\x00~\xdc@;sP\x833w0\x96\x19\x02\x0e\x05\x87\x81\xe3\x1a\x9c\xd6\xe3\xed\xbf3\x1b\x9c\xb6\x13\x1b\x9c\x9eg58=\xcenp\xfaNjpN\x9blOe\x8a=\x85\xa9\rN\x8bi\xf68\xe7\xd8\xe3L\xb7>\xd7zF\x83\xd3hf\x83Ӵ\xaa\xc1i\xa9\x1a\x9cV\x19\xfbج]=\xd7\xe0\xf4\x99\xd5\xe0\xf46\r\xce9\xf9\x06\xa7\xb1\xdb\xe04)48\xfd<\xac\xe6\x83\x01X\x04\t,\x81{\xc1\x06p\x9f\x187G윖\x8a\x9d\xd3\xcbb\xa7Qy\xec4\xae\x88\x9d&\x95\xb1\xd3t\xdf\xd8i\xb6_\xec4\xdf?vZ\x1c\x10;-\x0f\x8c\x9dV\a\xc5N\xeb\x83c\xa7\xcd!\xb1\xd3\xf6\xd0\xd8iwX\xec\x9cqx\xec\xb4?\"v:\x1c\x19;\x1d\x8f\x8a\x9dNG\xc7N\xe7cb\xa7˱\xb1\xd3\xf5\xb8\xd8\xe9v|\xect?!vz\x9c\x18;=O\x8a\x9d^'\xc7N\xefSb\xa7ϩ\xb1\xd37\x1d;\xfdN\x8b\x9d\xfe\xa7\xc7\u0380F\xb13\xb0q\xec\fj\x12;\x83\x9b\xc6ΐf\xb13\xb4y\xec\fk\x11;\xc3[\xc6ΈV\xb13\xb2u\xec\x8cj\x13;\xa3\xdb\xc6Θv\xb13\xf6\x8c\xd8\x19\xd7>v\xc6w\x88\x9d3;\xc6΄N\xb13\xb1s\xec\x9c\xd5%v\xce\xee\x1a;\x93\xba\xc5\xce\xe4\xee\xb13\xa5G\xecL\xed\x19;\xd3z\xc5\xce9\xbdcgz\x9f\xd89\xb7o\xec\xcc\xe8\x17;3\xfb\xc7NՀ\xd8Q\x03c'3(v\xb2\x83c'7$vf\r\x8d\x1d=,v\xcc\xf0\xd8ɏ\x88\x1dwd\xec\x14FŎ7:v\xfc1\xb1\x13\x8c\x8d\x9d\xe2\xb8\xd8\t\xc7\xc7\xceyg\xc6\xce\xec\t\xb1C\x13c':+vJg\xc7ΜI\xb1S=9vΟ\x12;5Sc\xe7\x82i\xb1\xbd\xba\xb1s\xd1\xf4ؙ{n\xec\\<\x03\xcf\xfeL\xb0\xca>\x9fʞ_ƞ[\xd6>\xc79\xfb|ϊS\xd5EmO\xce\xd8\x13\xc8ۃ\xba\xf6\xc4\nvQ/N\xd5T\xf9\x16\xa5\xc0\xa2X\x8cSQ)\xb4\x17\xe7<\xfb\xd8\xd9\xf6\xb1d\x1f\x1b\xd9ǖ\xecc\xe7ĩBU\xb5E\xfe|\x8bR\x8dE\xee\x02\x8b\xe2\x85q\x8a\xaa.\xb2\xc8ϵ(]l\x91\xbbĢx\xa9=\\\xd5e\x16\xf9\xcb\xf9\xc0WX䮴(^\x15\xa7\x82\xaa\xab-\xf2\xd7X\x94\xae\xb5\xc8]gQ\xbc>N\x99\xaa\xffY\xe4o\xb0(\xddh\x91\xbbɢxs\x9c\xf2\xabn\xb1\xc8\xdfjQ\xba\xcd\"w\xbbE\xf1\x0e\xde\xc1\x9d\xbc\x83\xbbx\awǩ\xd9U\xf7X\xe4\xef\xb5(\xddg\x91\xbbߢ\xf8\x80}\n\xaa\x1e\xb4\xcf\xf5C\xf6\xfey\xd8\xde?\x8f\xdak\xf2X\x9c\xd2\xfaq\vz\u008e<i\xcf\xc0}\xca\xc2<m\xaf\xdd3q*\x9b}\xd6^\x8c\xe7┧\x9f\xb7\xf0_\xb0P/Z\xd0K\x16\xd1\xcb\x16\xe1+\xf6\xe0\xe6U{\x1d_\xb3\xd7\xfd\xf58\xa5\xd4\x1b\x16\xf4\xa6\xbd\x82o\xd9\xe7\x80ޱ\x97\xfb\xdd8\xe5\xba\xef\xd9{\xe2}{\xdd?\xb0\xd7\xf5C{\xad?\xb2\xf7\xc3Ǹb\x9f\x80\x9f\x82\x9f\xd9'\xfe\xf38U\x95\xfb\x82\xf7\xf5e\\VS\x95\xfb*N\xe5\x8a_۫\xf0\r\x1e\xf2-\xf8\x9d\x1d\xca\x15\xbf\xb7\x8f\xca\xfd`/Ώ\xbc\xbdyqYuUn~\x9c*\xe6\x16\xe0A\v\xc1E\xfc\xc4,\xb6Wr\x89\x1d\xcf\x15\x97ڇ\xe6\x96Y\xe4\x97\xf3\xd3\xf6\x13\x1e\xf33\xb8®TZi\xd3\xfc*{\xf1W#[\x03\xae\x05\xd7ũv\x03\xd7ǩq\x136\xd8W\xfaF\xfb\xea\xddd\xef\xc2\xcdqjJ\xef-qjR\xef\xadx\xd46\x9bm\xb7c;\xacwZ\xef\xb2\xdem\xdf\x11\xf6\xd8W\xd9/xį\xe0o\xe0\xef\xe0\x1f\xe0\x9f\xe0_\xe0\xdf\xe0?\xe0\xbf`\xad\xbd\xeb\xeb\xec\xb1\xea\xed]\xff\xff\x00\x00\x00\xff\xff\xb4;\x96\xed"
| vendor/github.com/rainycape/unidecode/table.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0007198577513918281,
0.0007198577513918281,
0.0007198577513918281,
0.0007198577513918281,
0
] |
{
"id": 6,
"code_window": [
"\n",
" if (segment.type === 'tag') {\n",
" let tag = removeTagPrefix(segment.value);\n",
" this.addSeriesByTagFunc(tag);\n",
" return;\n",
" }\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.pause();\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 193
} | import { EventEmitter } from 'eventemitter3';
export class Emitter {
emitter: any;
constructor() {
this.emitter = new EventEmitter();
}
emit(name, data?) {
this.emitter.emit(name, data);
}
on(name, handler, scope?) {
this.emitter.on(name, handler);
if (scope) {
var unbind = scope.$on('$destroy', () => {
this.emitter.off(name, handler);
unbind();
});
}
}
removeAllListeners(evt?) {
this.emitter.removeAllListeners(evt);
}
off(name, handler) {
this.emitter.off(name, handler);
}
}
| public/app/core/utils/emitter.ts | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00018005375750362873,
0.00017418237985111773,
0.0001697363768471405,
0.00017346968525089324,
0.0000037225127016426995
] |
{
"id": 6,
"code_window": [
"\n",
" if (segment.type === 'tag') {\n",
" let tag = removeTagPrefix(segment.value);\n",
" this.addSeriesByTagFunc(tag);\n",
" return;\n",
" }\n",
"\n"
],
"labels": [
"keep",
"keep",
"add",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
" this.pause();\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 193
} | // Go MySQL Driver - A MySQL-Driver for Go's database/sql package
//
// Copyright 2013 The Go-MySQL-Driver Authors. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at http://mozilla.org/MPL/2.0/.
package mysql
import (
"fmt"
"io"
"os"
"strings"
"sync"
)
var (
fileRegister map[string]bool
fileRegisterLock sync.RWMutex
readerRegister map[string]func() io.Reader
readerRegisterLock sync.RWMutex
)
// RegisterLocalFile adds the given file to the file whitelist,
// so that it can be used by "LOAD DATA LOCAL INFILE <filepath>".
// Alternatively you can allow the use of all local files with
// the DSN parameter 'allowAllFiles=true'
//
// filePath := "/home/gopher/data.csv"
// mysql.RegisterLocalFile(filePath)
// err := db.Exec("LOAD DATA LOCAL INFILE '" + filePath + "' INTO TABLE foo")
// if err != nil {
// ...
//
func RegisterLocalFile(filePath string) {
fileRegisterLock.Lock()
// lazy map init
if fileRegister == nil {
fileRegister = make(map[string]bool)
}
fileRegister[strings.Trim(filePath, `"`)] = true
fileRegisterLock.Unlock()
}
// DeregisterLocalFile removes the given filepath from the whitelist.
func DeregisterLocalFile(filePath string) {
fileRegisterLock.Lock()
delete(fileRegister, strings.Trim(filePath, `"`))
fileRegisterLock.Unlock()
}
// RegisterReaderHandler registers a handler function which is used
// to receive a io.Reader.
// The Reader can be used by "LOAD DATA LOCAL INFILE Reader::<name>".
// If the handler returns a io.ReadCloser Close() is called when the
// request is finished.
//
// mysql.RegisterReaderHandler("data", func() io.Reader {
// var csvReader io.Reader // Some Reader that returns CSV data
// ... // Open Reader here
// return csvReader
// })
// err := db.Exec("LOAD DATA LOCAL INFILE 'Reader::data' INTO TABLE foo")
// if err != nil {
// ...
//
func RegisterReaderHandler(name string, handler func() io.Reader) {
readerRegisterLock.Lock()
// lazy map init
if readerRegister == nil {
readerRegister = make(map[string]func() io.Reader)
}
readerRegister[name] = handler
readerRegisterLock.Unlock()
}
// DeregisterReaderHandler removes the ReaderHandler function with
// the given name from the registry.
func DeregisterReaderHandler(name string) {
readerRegisterLock.Lock()
delete(readerRegister, name)
readerRegisterLock.Unlock()
}
func deferredClose(err *error, closer io.Closer) {
closeErr := closer.Close()
if *err == nil {
*err = closeErr
}
}
func (mc *mysqlConn) handleInFileRequest(name string) (err error) {
var rdr io.Reader
var data []byte
packetSize := 16 * 1024 // 16KB is small enough for disk readahead and large enough for TCP
if mc.maxWriteSize < packetSize {
packetSize = mc.maxWriteSize
}
if idx := strings.Index(name, "Reader::"); idx == 0 || (idx > 0 && name[idx-1] == '/') { // io.Reader
// The server might return an an absolute path. See issue #355.
name = name[idx+8:]
readerRegisterLock.RLock()
handler, inMap := readerRegister[name]
readerRegisterLock.RUnlock()
if inMap {
rdr = handler()
if rdr != nil {
if cl, ok := rdr.(io.Closer); ok {
defer deferredClose(&err, cl)
}
} else {
err = fmt.Errorf("Reader '%s' is <nil>", name)
}
} else {
err = fmt.Errorf("Reader '%s' is not registered", name)
}
} else { // File
name = strings.Trim(name, `"`)
fileRegisterLock.RLock()
fr := fileRegister[name]
fileRegisterLock.RUnlock()
if mc.cfg.AllowAllFiles || fr {
var file *os.File
var fi os.FileInfo
if file, err = os.Open(name); err == nil {
defer deferredClose(&err, file)
// get file size
if fi, err = file.Stat(); err == nil {
rdr = file
if fileSize := int(fi.Size()); fileSize < packetSize {
packetSize = fileSize
}
}
}
} else {
err = fmt.Errorf("local file '%s' is not registered", name)
}
}
// send content packets
if err == nil {
data := make([]byte, 4+packetSize)
var n int
for err == nil {
n, err = rdr.Read(data[4:])
if n > 0 {
if ioErr := mc.writePacket(data[:4+n]); ioErr != nil {
return ioErr
}
}
}
if err == io.EOF {
err = nil
}
}
// send empty packet (termination)
if data == nil {
data = make([]byte, 4)
}
if ioErr := mc.writePacket(data[:4]); ioErr != nil {
return ioErr
}
// read OK packet
if err == nil {
_, err = mc.readResultOK()
return err
}
mc.readPacket()
return err
}
| vendor/github.com/go-sql-driver/mysql/infile.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00025576294865459204,
0.00017725052020978183,
0.00016522275109309703,
0.00017473399930167943,
0.000018886410543927923
] |
{
"id": 7,
"code_window": [
" }\n",
"\n",
" var oldTarget = this.queryModel.target.target;\n",
" this.updateModelTarget();\n",
"\n",
" if (this.queryModel.target !== oldTarget) {\n",
" this.panelCtrl.refresh();\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" if (this.queryModel.target !== oldTarget && !this.paused) {\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "replace",
"edit_start_line_idx": 237
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0002353037998545915,
0.0001834944123402238,
0.00016423726629000157,
0.00016940550995059311,
0.000026665860787034035
] |
{
"id": 7,
"code_window": [
" }\n",
"\n",
" var oldTarget = this.queryModel.target.target;\n",
" this.updateModelTarget();\n",
"\n",
" if (this.queryModel.target !== oldTarget) {\n",
" this.panelCtrl.refresh();\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" if (this.queryModel.target !== oldTarget && !this.paused) {\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "replace",
"edit_start_line_idx": 237
} | import angular from 'angular';
import _ from 'lodash';
import './link_srv';
function panelLinksEditor() {
return {
scope: {
panel: '=',
},
restrict: 'E',
controller: 'PanelLinksEditorCtrl',
templateUrl: 'public/app/features/panellinks/module.html',
link: function() {},
};
}
export class PanelLinksEditorCtrl {
/** @ngInject */
constructor($scope, backendSrv) {
$scope.panel.links = $scope.panel.links || [];
$scope.addLink = function() {
$scope.panel.links.push({
type: 'dashboard',
});
};
$scope.searchDashboards = function(queryStr, callback) {
backendSrv.search({ query: queryStr }).then(function(hits) {
var dashboards = _.map(hits, function(dash) {
return dash.title;
});
callback(dashboards);
});
};
$scope.dashboardChanged = function(link) {
backendSrv.search({ query: link.dashboard }).then(function(hits) {
var dashboard = _.find(hits, { title: link.dashboard });
if (dashboard) {
link.dashUri = dashboard.uri;
link.title = dashboard.title;
}
});
};
$scope.deleteLink = function(link) {
$scope.panel.links = _.without($scope.panel.links, link);
};
}
}
angular
.module('grafana.directives')
.directive('panelLinksEditor', panelLinksEditor)
.controller('PanelLinksEditorCtrl', PanelLinksEditorCtrl);
| public/app/features/panellinks/module.ts | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.004334517754614353,
0.0008920963737182319,
0.00016388780204579234,
0.00017011971795000136,
0.0015408922918140888
] |
{
"id": 7,
"code_window": [
" }\n",
"\n",
" var oldTarget = this.queryModel.target.target;\n",
" this.updateModelTarget();\n",
"\n",
" if (this.queryModel.target !== oldTarget) {\n",
" this.panelCtrl.refresh();\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" if (this.queryModel.target !== oldTarget && !this.paused) {\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "replace",
"edit_start_line_idx": 237
} | // Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package ldap
import (
"errors"
"io/ioutil"
"os"
ber "gopkg.in/asn1-ber.v1"
)
// LDAP Application Codes
const (
ApplicationBindRequest = 0
ApplicationBindResponse = 1
ApplicationUnbindRequest = 2
ApplicationSearchRequest = 3
ApplicationSearchResultEntry = 4
ApplicationSearchResultDone = 5
ApplicationModifyRequest = 6
ApplicationModifyResponse = 7
ApplicationAddRequest = 8
ApplicationAddResponse = 9
ApplicationDelRequest = 10
ApplicationDelResponse = 11
ApplicationModifyDNRequest = 12
ApplicationModifyDNResponse = 13
ApplicationCompareRequest = 14
ApplicationCompareResponse = 15
ApplicationAbandonRequest = 16
ApplicationSearchResultReference = 19
ApplicationExtendedRequest = 23
ApplicationExtendedResponse = 24
)
var ApplicationMap = map[uint8]string{
ApplicationBindRequest: "Bind Request",
ApplicationBindResponse: "Bind Response",
ApplicationUnbindRequest: "Unbind Request",
ApplicationSearchRequest: "Search Request",
ApplicationSearchResultEntry: "Search Result Entry",
ApplicationSearchResultDone: "Search Result Done",
ApplicationModifyRequest: "Modify Request",
ApplicationModifyResponse: "Modify Response",
ApplicationAddRequest: "Add Request",
ApplicationAddResponse: "Add Response",
ApplicationDelRequest: "Del Request",
ApplicationDelResponse: "Del Response",
ApplicationModifyDNRequest: "Modify DN Request",
ApplicationModifyDNResponse: "Modify DN Response",
ApplicationCompareRequest: "Compare Request",
ApplicationCompareResponse: "Compare Response",
ApplicationAbandonRequest: "Abandon Request",
ApplicationSearchResultReference: "Search Result Reference",
ApplicationExtendedRequest: "Extended Request",
ApplicationExtendedResponse: "Extended Response",
}
// Ldap Behera Password Policy Draft 10 (https://tools.ietf.org/html/draft-behera-ldap-password-policy-10)
const (
BeheraPasswordExpired = 0
BeheraAccountLocked = 1
BeheraChangeAfterReset = 2
BeheraPasswordModNotAllowed = 3
BeheraMustSupplyOldPassword = 4
BeheraInsufficientPasswordQuality = 5
BeheraPasswordTooShort = 6
BeheraPasswordTooYoung = 7
BeheraPasswordInHistory = 8
)
var BeheraPasswordPolicyErrorMap = map[int8]string{
BeheraPasswordExpired: "Password expired",
BeheraAccountLocked: "Account locked",
BeheraChangeAfterReset: "Password must be changed",
BeheraPasswordModNotAllowed: "Policy prevents password modification",
BeheraMustSupplyOldPassword: "Policy requires old password in order to change password",
BeheraInsufficientPasswordQuality: "Password fails quality checks",
BeheraPasswordTooShort: "Password is too short for policy",
BeheraPasswordTooYoung: "Password has been changed too recently",
BeheraPasswordInHistory: "New password is in list of old passwords",
}
// Adds descriptions to an LDAP Response packet for debugging
func addLDAPDescriptions(packet *ber.Packet) (err error) {
defer func() {
if r := recover(); r != nil {
err = NewError(ErrorDebugging, errors.New("ldap: cannot process packet to add descriptions"))
}
}()
packet.Description = "LDAP Response"
packet.Children[0].Description = "Message ID"
application := uint8(packet.Children[1].Tag)
packet.Children[1].Description = ApplicationMap[application]
switch application {
case ApplicationBindRequest:
addRequestDescriptions(packet)
case ApplicationBindResponse:
addDefaultLDAPResponseDescriptions(packet)
case ApplicationUnbindRequest:
addRequestDescriptions(packet)
case ApplicationSearchRequest:
addRequestDescriptions(packet)
case ApplicationSearchResultEntry:
packet.Children[1].Children[0].Description = "Object Name"
packet.Children[1].Children[1].Description = "Attributes"
for _, child := range packet.Children[1].Children[1].Children {
child.Description = "Attribute"
child.Children[0].Description = "Attribute Name"
child.Children[1].Description = "Attribute Values"
for _, grandchild := range child.Children[1].Children {
grandchild.Description = "Attribute Value"
}
}
if len(packet.Children) == 3 {
addControlDescriptions(packet.Children[2])
}
case ApplicationSearchResultDone:
addDefaultLDAPResponseDescriptions(packet)
case ApplicationModifyRequest:
addRequestDescriptions(packet)
case ApplicationModifyResponse:
case ApplicationAddRequest:
addRequestDescriptions(packet)
case ApplicationAddResponse:
case ApplicationDelRequest:
addRequestDescriptions(packet)
case ApplicationDelResponse:
case ApplicationModifyDNRequest:
addRequestDescriptions(packet)
case ApplicationModifyDNResponse:
case ApplicationCompareRequest:
addRequestDescriptions(packet)
case ApplicationCompareResponse:
case ApplicationAbandonRequest:
addRequestDescriptions(packet)
case ApplicationSearchResultReference:
case ApplicationExtendedRequest:
addRequestDescriptions(packet)
case ApplicationExtendedResponse:
}
return nil
}
func addControlDescriptions(packet *ber.Packet) {
packet.Description = "Controls"
for _, child := range packet.Children {
child.Description = "Control"
child.Children[0].Description = "Control Type (" + ControlTypeMap[child.Children[0].Value.(string)] + ")"
value := child.Children[1]
if len(child.Children) == 3 {
child.Children[1].Description = "Criticality"
value = child.Children[2]
}
value.Description = "Control Value"
switch child.Children[0].Value.(string) {
case ControlTypePaging:
value.Description += " (Paging)"
if value.Value != nil {
valueChildren := ber.DecodePacket(value.Data.Bytes())
value.Data.Truncate(0)
value.Value = nil
valueChildren.Children[1].Value = valueChildren.Children[1].Data.Bytes()
value.AppendChild(valueChildren)
}
value.Children[0].Description = "Real Search Control Value"
value.Children[0].Children[0].Description = "Paging Size"
value.Children[0].Children[1].Description = "Cookie"
case ControlTypeBeheraPasswordPolicy:
value.Description += " (Password Policy - Behera Draft)"
if value.Value != nil {
valueChildren := ber.DecodePacket(value.Data.Bytes())
value.Data.Truncate(0)
value.Value = nil
value.AppendChild(valueChildren)
}
sequence := value.Children[0]
for _, child := range sequence.Children {
if child.Tag == 0 {
//Warning
child := child.Children[0]
packet := ber.DecodePacket(child.Data.Bytes())
val, ok := packet.Value.(int64)
if ok {
if child.Tag == 0 {
//timeBeforeExpiration
value.Description += " (TimeBeforeExpiration)"
child.Value = val
} else if child.Tag == 1 {
//graceAuthNsRemaining
value.Description += " (GraceAuthNsRemaining)"
child.Value = val
}
}
} else if child.Tag == 1 {
// Error
packet := ber.DecodePacket(child.Data.Bytes())
val, ok := packet.Value.(int8)
if !ok {
val = -1
}
child.Description = "Error"
child.Value = val
}
}
}
}
}
func addRequestDescriptions(packet *ber.Packet) {
packet.Description = "LDAP Request"
packet.Children[0].Description = "Message ID"
packet.Children[1].Description = ApplicationMap[uint8(packet.Children[1].Tag)]
if len(packet.Children) == 3 {
addControlDescriptions(packet.Children[2])
}
}
func addDefaultLDAPResponseDescriptions(packet *ber.Packet) {
resultCode, _ := getLDAPResultCode(packet)
packet.Children[1].Children[0].Description = "Result Code (" + LDAPResultCodeMap[resultCode] + ")"
packet.Children[1].Children[1].Description = "Matched DN"
packet.Children[1].Children[2].Description = "Error Message"
if len(packet.Children[1].Children) > 3 {
packet.Children[1].Children[3].Description = "Referral"
}
if len(packet.Children) == 3 {
addControlDescriptions(packet.Children[2])
}
}
func DebugBinaryFile(fileName string) error {
file, err := ioutil.ReadFile(fileName)
if err != nil {
return NewError(ErrorDebugging, err)
}
ber.PrintBytes(os.Stdout, file, "")
packet := ber.DecodePacket(file)
addLDAPDescriptions(packet)
ber.PrintPacket(packet)
return nil
}
var hex = "0123456789abcdef"
func mustEscape(c byte) bool {
return c > 0x7f || c == '(' || c == ')' || c == '\\' || c == '*' || c == 0
}
// EscapeFilter escapes from the provided LDAP filter string the special
// characters in the set `()*\` and those out of the range 0 < c < 0x80,
// as defined in RFC4515.
func EscapeFilter(filter string) string {
escape := 0
for i := 0; i < len(filter); i++ {
if mustEscape(filter[i]) {
escape++
}
}
if escape == 0 {
return filter
}
buf := make([]byte, len(filter)+escape*2)
for i, j := 0, 0; i < len(filter); i++ {
c := filter[i]
if mustEscape(c) {
buf[j+0] = '\\'
buf[j+1] = hex[c>>4]
buf[j+2] = hex[c&0xf]
j += 3
} else {
buf[j] = c
j++
}
}
return string(buf)
}
| vendor/github.com/go-ldap/ldap/ldap.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00021823249699082226,
0.0001745670015225187,
0.00016176853387150913,
0.00017527432646602392,
0.000009623085134080611
] |
{
"id": 7,
"code_window": [
" }\n",
"\n",
" var oldTarget = this.queryModel.target.target;\n",
" this.updateModelTarget();\n",
"\n",
" if (this.queryModel.target !== oldTarget) {\n",
" this.panelCtrl.refresh();\n",
" }\n",
" }\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep",
"keep"
],
"after_edit": [
" if (this.queryModel.target !== oldTarget && !this.paused) {\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "replace",
"edit_start_line_idx": 237
} | package v2
import (
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"errors"
"fmt"
"net/http"
"net/url"
"sort"
"strings"
"time"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/credentials"
"github.com/aws/aws-sdk-go/aws/request"
)
var (
errInvalidMethod = errors.New("v2 signer only handles HTTP POST")
)
const (
signatureVersion = "2"
signatureMethod = "HmacSHA256"
timeFormat = "2006-01-02T15:04:05Z"
)
type signer struct {
// Values that must be populated from the request
Request *http.Request
Time time.Time
Credentials *credentials.Credentials
Debug aws.LogLevelType
Logger aws.Logger
Query url.Values
stringToSign string
signature string
}
// SignRequestHandler is a named request handler the SDK will use to sign
// service client request with using the V4 signature.
var SignRequestHandler = request.NamedHandler{
Name: "v2.SignRequestHandler", Fn: SignSDKRequest,
}
// SignSDKRequest requests with signature version 2.
//
// Will sign the requests with the service config's Credentials object
// Signing is skipped if the credentials is the credentials.AnonymousCredentials
// object.
func SignSDKRequest(req *request.Request) {
// If the request does not need to be signed ignore the signing of the
// request if the AnonymousCredentials object is used.
if req.Config.Credentials == credentials.AnonymousCredentials {
return
}
if req.HTTPRequest.Method != "POST" && req.HTTPRequest.Method != "GET" {
// The V2 signer only supports GET and POST
req.Error = errInvalidMethod
return
}
v2 := signer{
Request: req.HTTPRequest,
Time: req.Time,
Credentials: req.Config.Credentials,
Debug: req.Config.LogLevel.Value(),
Logger: req.Config.Logger,
}
req.Error = v2.Sign()
if req.Error != nil {
return
}
if req.HTTPRequest.Method == "POST" {
// Set the body of the request based on the modified query parameters
req.SetStringBody(v2.Query.Encode())
// Now that the body has changed, remove any Content-Length header,
// because it will be incorrect
req.HTTPRequest.ContentLength = 0
req.HTTPRequest.Header.Del("Content-Length")
} else {
req.HTTPRequest.URL.RawQuery = v2.Query.Encode()
}
}
func (v2 *signer) Sign() error {
credValue, err := v2.Credentials.Get()
if err != nil {
return err
}
if v2.Request.Method == "POST" {
// Parse the HTTP request to obtain the query parameters that will
// be used to build the string to sign. Note that because the HTTP
// request will need to be modified, the PostForm and Form properties
// are reset to nil after parsing.
v2.Request.ParseForm()
v2.Query = v2.Request.PostForm
v2.Request.PostForm = nil
v2.Request.Form = nil
} else {
v2.Query = v2.Request.URL.Query()
}
// Set new query parameters
v2.Query.Set("AWSAccessKeyId", credValue.AccessKeyID)
v2.Query.Set("SignatureVersion", signatureVersion)
v2.Query.Set("SignatureMethod", signatureMethod)
v2.Query.Set("Timestamp", v2.Time.UTC().Format(timeFormat))
if credValue.SessionToken != "" {
v2.Query.Set("SecurityToken", credValue.SessionToken)
}
// in case this is a retry, ensure no signature present
v2.Query.Del("Signature")
method := v2.Request.Method
host := v2.Request.URL.Host
path := v2.Request.URL.Path
if path == "" {
path = "/"
}
// obtain all of the query keys and sort them
queryKeys := make([]string, 0, len(v2.Query))
for key := range v2.Query {
queryKeys = append(queryKeys, key)
}
sort.Strings(queryKeys)
// build URL-encoded query keys and values
queryKeysAndValues := make([]string, len(queryKeys))
for i, key := range queryKeys {
k := strings.Replace(url.QueryEscape(key), "+", "%20", -1)
v := strings.Replace(url.QueryEscape(v2.Query.Get(key)), "+", "%20", -1)
queryKeysAndValues[i] = k + "=" + v
}
// join into one query string
query := strings.Join(queryKeysAndValues, "&")
// build the canonical string for the V2 signature
v2.stringToSign = strings.Join([]string{
method,
host,
path,
query,
}, "\n")
hash := hmac.New(sha256.New, []byte(credValue.SecretAccessKey))
hash.Write([]byte(v2.stringToSign))
v2.signature = base64.StdEncoding.EncodeToString(hash.Sum(nil))
v2.Query.Set("Signature", v2.signature)
if v2.Debug.Matches(aws.LogDebugWithSigning) {
v2.logSigningInfo()
}
return nil
}
const logSignInfoMsg = `DEBUG: Request Signature:
---[ STRING TO SIGN ]--------------------------------
%s
---[ SIGNATURE ]-------------------------------------
%s
-----------------------------------------------------`
func (v2 *signer) logSigningInfo() {
msg := fmt.Sprintf(logSignInfoMsg, v2.stringToSign, v2.Query.Get("Signature"))
v2.Logger.Log(msg)
}
| vendor/github.com/aws/aws-sdk-go/private/signer/v2/v2.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0006061092717573047,
0.00020787908579222858,
0.00016352332022506744,
0.00017496223154012114,
0.00010480091441422701
] |
{
"id": 8,
"code_window": [
"\n",
" showDelimiter(index) {\n",
" return index !== this.queryModel.tags.length - 1;\n",
" }\n",
"}\n",
"\n",
"function mapToDropdownOptions(results) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" pause() {\n",
" this.paused = true;\n",
" }\n",
"\n",
" unpause() {\n",
" this.paused = false;\n",
" this.panelCtrl.refresh();\n",
" }\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 374
} | <query-editor-row query-ctrl="ctrl" has-text-edit-mode="true">
<div class="gf-form" ng-show="ctrl.target.textEditor">
<input type="text" class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.targetTextChanged()"></input>
</div>
<div ng-hide="ctrl.target.textEditor">
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Series</label>
</div>
<div ng-repeat="tag in ctrl.queryModel.tags" class="gf-form">
<gf-form-dropdown
model="tag.key"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-key"
get-options="ctrl.getTags($index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
/>
<gf-form-dropdown
model="tag.operator"
lookup-text="false"
allow-custom="false"
label-mode="true"
css-class="query-segment-operator"
get-options="ctrl.getTagOperators()"
on-change="ctrl.tagChanged(tag, $index)"
min-input-width="30"
/>
<gf-form-dropdown
model="tag.value"
lookup-text="false"
allow-custom="true"
label-mode="true"
css-class="query-segment-value"
placeholder="select tag value"
get-options="ctrl.getTagValues(tag, $index, $query)"
on-change="ctrl.tagChanged(tag, $index)"
start-open="!ctrl.showDelimiter($index)"
/>
<label class="gf-form-label query-keyword" ng-if="ctrl.showDelimiter($index)">AND</label>
</div>
<div ng-repeat="segment in ctrl.segments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getAltSegments($index)" on-change="ctrl.segmentValueChanged(segment, $index)" />
</div>
<div ng-if="ctrl.queryModel.seriesByTagUsed" ng-repeat="segment in ctrl.addTagSegments" role="menuitem" class="gf-form">
<metric-segment segment="segment" get-options="ctrl.getTagsAsSegments()" on-change="ctrl.addNewTag(segment)" />
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
<div class="gf-form-inline">
<div class="gf-form">
<label class="gf-form-label width-6 query-keyword">Functions</label>
</div>
<div ng-repeat="func in ctrl.queryModel.functions" class="gf-form">
<span graphite-func-editor class="gf-form-label query-part" ng-hide="func.hidden"></span>
</div>
<div class="gf-form dropdown">
<span graphite-add-func></span>
</div>
<div class="gf-form gf-form--grow">
<div class="gf-form-label gf-form-label--grow"></div>
</div>
</div>
</div>
</query-editor-row>
| public/app/plugins/datasource/graphite/partials/query.editor.html | 1 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.9965125918388367,
0.12504859268665314,
0.00016632003826089203,
0.0004824117640964687,
0.3293827474117279
] |
{
"id": 8,
"code_window": [
"\n",
" showDelimiter(index) {\n",
" return index !== this.queryModel.tags.length - 1;\n",
" }\n",
"}\n",
"\n",
"function mapToDropdownOptions(results) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" pause() {\n",
" this.paused = true;\n",
" }\n",
"\n",
" unpause() {\n",
" this.paused = false;\n",
" this.panelCtrl.refresh();\n",
" }\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 374
} | to_string(`1.2`) | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-165 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017194281099364161,
0.00017194281099364161,
0.00017194281099364161,
0.00017194281099364161,
0
] |
{
"id": 8,
"code_window": [
"\n",
" showDelimiter(index) {\n",
" return index !== this.queryModel.tags.length - 1;\n",
" }\n",
"}\n",
"\n",
"function mapToDropdownOptions(results) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" pause() {\n",
" this.paused = true;\n",
" }\n",
"\n",
" unpause() {\n",
" this.paused = false;\n",
" this.panelCtrl.refresh();\n",
" }\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 374
} | package pluginproxy
import (
"testing"
"github.com/grafana/grafana/pkg/bus"
m "github.com/grafana/grafana/pkg/models"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/util"
. "github.com/smartystreets/goconvey/convey"
)
func TestPluginProxy(t *testing.T) {
Convey("When getting proxy headers", t, func() {
route := &plugins.AppPluginRoute{
Headers: []plugins.AppPluginRouteHeader{
{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
},
}
setting.SecretKey = "password"
bus.AddHandler("test", func(query *m.GetPluginSettingByIdQuery) error {
key, err := util.Encrypt([]byte("123"), "password")
if err != nil {
return err
}
query.Result = &m.PluginSetting{
SecureJsonData: map[string][]byte{
"key": key,
},
}
return nil
})
header, err := getHeaders(route, 1, "my-app")
So(err, ShouldBeNil)
Convey("Should render header template", func() {
So(header.Get("x-header"), ShouldEqual, "my secret 123")
})
})
}
| pkg/api/pluginproxy/pluginproxy_test.go | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.00017197660054080188,
0.00016964308451861143,
0.0001679336855886504,
0.00016962749941740185,
0.0000013295295957505004
] |
{
"id": 8,
"code_window": [
"\n",
" showDelimiter(index) {\n",
" return index !== this.queryModel.tags.length - 1;\n",
" }\n",
"}\n",
"\n",
"function mapToDropdownOptions(results) {\n"
],
"labels": [
"keep",
"keep",
"keep",
"add",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" pause() {\n",
" this.paused = true;\n",
" }\n",
"\n",
" unpause() {\n",
" this.paused = false;\n",
" this.panelCtrl.refresh();\n",
" }\n"
],
"file_path": "public/app/plugins/datasource/graphite/query_ctrl.ts",
"type": "add",
"edit_start_line_idx": 374
} | foo[*][2] | vendor/github.com/jmespath/go-jmespath/fuzz/corpus/expr-622 | 0 | https://github.com/grafana/grafana/commit/d8f2a207750535f3f61f68b33cc738c058465424 | [
0.0001760088634910062,
0.0001760088634910062,
0.0001760088634910062,
0.0001760088634910062,
0
] |
{
"id": 0,
"code_window": [
" * When strictStyling is true:\n",
" * - selector is the attribute added to all elements inside the host,\n",
" * - hostSelector is the attribute added to the host itself.\n",
" */\n",
" shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {\n",
" const sourceMappingUrl: string = extractSourceMappingUrl(cssText);\n",
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" const commentsWithHash = extractCommentsWithHash(cssText);\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 148
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* This file is a port of shadowCSS from webcomponents.js to TypeScript.
*
* Please make sure to keep to edits in sync with the source file.
*
* Source:
* https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
*
* The original file level comment is reproduced below
*/
/*
This is a limited shim for ShadowDOM css styling.
https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
The intention here is to support only the styling features which can be
relatively simply implemented. The goal is to allow users to avoid the
most obvious pitfalls and do so without compromising performance significantly.
For ShadowDOM styling that's not covered here, a set of best practices
can be provided that should allow users to accomplish more complex styling.
The following is a list of specific ShadowDOM styling features and a brief
discussion of the approach used to shim.
Shimmed features:
* :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
element using the :host rule. To shim this feature, the :host styles are
reformatted and prefixed with a given scope name and promoted to a
document level stylesheet.
For example, given a scope name of .foo, a rule like this:
:host {
background: red;
}
}
becomes:
.foo {
background: red;
}
* encapsulation: Styles defined within ShadowDOM, apply only to
dom inside the ShadowDOM. Polymer uses one of two techniques to implement
this feature.
By default, rules are prefixed with the host element tag name
as a descendant selector. This ensures styling does not leak out of the 'top'
of the element's ShadowDOM. For example,
div {
font-weight: bold;
}
becomes:
x-foo div {
font-weight: bold;
}
becomes:
Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
selectors are scoped by adding an attribute selector suffix to each
simple selector that contains the host element tag name. Each element
in the element's ShadowDOM template is also given the scope attribute.
Thus, these rules match only elements that have the scope attribute.
For example, given a scope name of x-foo, a rule like this:
div {
font-weight: bold;
}
becomes:
div[x-foo] {
font-weight: bold;
}
Note that elements that are dynamically added to a scope must have the scope
selector added to them manually.
* upper/lower bound encapsulation: Styles which are defined outside a
shadowRoot should not cross the ShadowDOM boundary and should not apply
inside a shadowRoot.
This styling behavior is not emulated. Some possible ways to do this that
were rejected due to complexity and/or performance concerns include: (1) reset
every possible property for every possible selector for a given scope name;
(2) re-implement css in javascript.
As an alternative, users should make sure to use selectors
specific to the scope in which they are working.
* ::distributed: This behavior is not emulated. It's often not necessary
to style the contents of a specific insertion point and instead, descendants
of the host element can be styled selectively. Users can also create an
extra node around an insertion point and style that node's contents
via descendent selectors. For example, with a shadowRoot like this:
<style>
::content(div) {
background: red;
}
</style>
<content></content>
could become:
<style>
/ *@polyfill .content-container div * /
::content(div) {
background: red;
}
</style>
<div class="content-container">
<content></content>
</div>
Note the use of @polyfill in the comment above a ShadowDOM specific style
declaration. This is a directive to the styling shim to use the selector
in comments in lieu of the next selector when running under polyfill.
*/
export class ShadowCss {
strictStyling: boolean = true;
constructor() {}
/*
* Shim some cssText with the given selector. Returns cssText that can
* be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
*
* When strictStyling is true:
* - selector is the attribute added to all elements inside the host,
* - hostSelector is the attribute added to the host itself.
*/
shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {
const sourceMappingUrl: string = extractSourceMappingUrl(cssText);
cssText = stripComments(cssText);
cssText = this._insertDirectives(cssText);
return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;
}
private _insertDirectives(cssText: string): string {
cssText = this._insertPolyfillDirectivesInCssText(cssText);
return this._insertPolyfillRulesInCssText(cssText);
}
/*
* Process styles to convert native ShadowDOM rules that will trip
* up the css parser; we rely on decorating the stylesheet with inert rules.
*
* For example, we convert this rule:
*
* polyfill-next-selector { content: ':host menu-item'; }
* ::content menu-item {
*
* to this:
*
* scopeName menu-item {
*
**/
private _insertPolyfillDirectivesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(
_cssContentNextSelectorRe, function(...m: string[]) { return m[2] + '{'; });
}
/*
* Process styles to add rules which will only apply under the polyfill
*
* For example, we convert this rule:
*
* polyfill-rule {
* content: ':host menu-item';
* ...
* }
*
* to this:
*
* scopeName menu-item {...}
*
**/
private _insertPolyfillRulesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(_cssContentRuleRe, (...m: string[]) => {
const rule = m[0].replace(m[1], '').replace(m[2], '');
return m[4] + rule;
});
}
/* Ensure styles are scoped. Pseudo-scoping takes a rule like:
*
* .foo {... }
*
* and converts this to
*
* scopeName .foo { ... }
*/
private _scopeCssText(cssText: string, scopeSelector: string, hostSelector: string): string {
const unscopedRules = this._extractUnscopedRulesFromCssText(cssText);
// replace :host and :host-context -shadowcsshost and -shadowcsshost respectively
cssText = this._insertPolyfillHostInCssText(cssText);
cssText = this._convertColonHost(cssText);
cssText = this._convertColonHostContext(cssText);
cssText = this._convertShadowDOMSelectors(cssText);
if (scopeSelector) {
cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
}
cssText = cssText + '\n' + unscopedRules;
return cssText.trim();
}
/*
* Process styles to add rules which will only apply under the polyfill
* and do not process via CSSOM. (CSSOM is destructive to rules on rare
* occasions, e.g. -webkit-calc on Safari.)
* For example, we convert this rule:
*
* @polyfill-unscoped-rule {
* content: 'menu-item';
* ... }
*
* to this:
*
* menu-item {...}
*
**/
private _extractUnscopedRulesFromCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
let r = '';
let m: RegExpExecArray|null;
_cssContentUnscopedRuleRe.lastIndex = 0;
while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {
const rule = m[0].replace(m[2], '').replace(m[1], m[4]);
r += rule + '\n\n';
}
return r;
}
/*
* convert a rule like :host(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar
*/
private _convertColonHost(cssText: string): string {
return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
}
/*
* convert a rule like :host-context(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar, .foo scopeName > .bar { }
*
* and
*
* :host-context(.foo:host) .bar { ... }
*
* to
*
* .foo<scopeName> .bar { ... }
*/
private _convertColonHostContext(cssText: string): string {
return this._convertColonRule(
cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
}
private _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
// m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
return cssText.replace(regExp, function(...m: string[]) {
if (m[2]) {
const parts = m[2].split(',');
const r: string[] = [];
for (let i = 0; i < parts.length; i++) {
const p = parts[i].trim();
if (!p) break;
r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
}
return r.join(',');
} else {
return _polyfillHostNoCombinator + m[3];
}
});
}
private _colonHostContextPartReplacer(host: string, part: string, suffix: string): string {
if (part.indexOf(_polyfillHost) > -1) {
return this._colonHostPartReplacer(host, part, suffix);
} else {
return host + part + suffix + ', ' + part + ' ' + host + suffix;
}
}
private _colonHostPartReplacer(host: string, part: string, suffix: string): string {
return host + part.replace(_polyfillHost, '') + suffix;
}
/*
* Convert combinators like ::shadow and pseudo-elements like ::content
* by replacing with space.
*/
private _convertShadowDOMSelectors(cssText: string): string {
return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
}
// change a selector like 'div' to 'name div'
private _scopeSelectors(cssText: string, scopeSelector: string, hostSelector: string): string {
return processRules(cssText, (rule: CssRule) => {
let selector = rule.selector;
let content = rule.content;
if (rule.selector[0] != '@') {
selector =
this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
} else if (
rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
}
return new CssRule(selector, content);
});
}
private _scopeSelector(
selector: string, scopeSelector: string, hostSelector: string, strict: boolean): string {
return selector.split(',')
.map(part => part.trim().split(_shadowDeepSelectors))
.map((deepParts) => {
const [shallowPart, ...otherParts] = deepParts;
const applyScope = (shallowPart: string) => {
if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
return strict ?
this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :
this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
} else {
return shallowPart;
}
};
return [applyScope(shallowPart), ...otherParts].join(' ');
})
.join(', ');
}
private _selectorNeedsScoping(selector: string, scopeSelector: string): boolean {
const re = this._makeScopeMatcher(scopeSelector);
return !re.test(selector);
}
private _makeScopeMatcher(scopeSelector: string): RegExp {
const lre = /\[/g;
const rre = /\]/g;
scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
}
private _applySelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// Difference from webcomponents.js: scopeSelector could not be an array
return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
}
// scope via name and [is=name]
private _applySimpleSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// In Android browser, the lastIndex is not reset when the regex is used in String.replace()
_polyfillHostRe.lastIndex = 0;
if (_polyfillHostRe.test(selector)) {
const replaceBy = this.strictStyling ? `[${hostSelector}]` : scopeSelector;
return selector
.replace(
_polyfillHostNoCombinatorRe,
(hnc, selector) => {
return selector.replace(
/([^:]*)(:*)(.*)/,
(_: string, before: string, colon: string, after: string) => {
return before + replaceBy + colon + after;
});
})
.replace(_polyfillHostRe, replaceBy + ' ');
}
return scopeSelector + ' ' + selector;
}
// return a selector with [name] suffix on each simple selector
// e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name] /** @internal */
private _applyStrictSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
const isRe = /\[is=([^\]]*)\]/g;
scopeSelector = scopeSelector.replace(isRe, (_: string, ...parts: string[]) => parts[0]);
const attrName = '[' + scopeSelector + ']';
const _scopeSelectorPart = (p: string) => {
let scopedP = p.trim();
if (!scopedP) {
return '';
}
if (p.indexOf(_polyfillHostNoCombinator) > -1) {
scopedP = this._applySimpleSelectorScope(p, scopeSelector, hostSelector);
} else {
// remove :host since it should be unnecessary
const t = p.replace(_polyfillHostRe, '');
if (t.length > 0) {
const matches = t.match(/([^:]*)(:*)(.*)/);
if (matches) {
scopedP = matches[1] + attrName + matches[2] + matches[3];
}
}
}
return scopedP;
};
const safeContent = new SafeSelector(selector);
selector = safeContent.content();
let scopedSelector = '';
let startIndex = 0;
let res: RegExpExecArray|null;
const sep = /( |>|\+|~(?!=))\s*/g;
// If a selector appears before :host it should not be shimmed as it
// matches on ancestor elements and not on elements in the host's shadow
// `:host-context(div)` is transformed to
// `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
// the `div` is not part of the component in the 2nd selectors and should not be scoped.
// Historically `component-tag:host` was matching the component so we also want to preserve
// this behavior to avoid breaking legacy apps (it should not match).
// The behavior should be:
// - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
// - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
// `:host-context(tag)`)
const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
// Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
let shouldScope = !hasHost;
while ((res = sep.exec(selector)) !== null) {
const separator = res[1];
const part = selector.slice(startIndex, res.index).trim();
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
scopedSelector += `${scopedPart} ${separator} `;
startIndex = sep.lastIndex;
}
const part = selector.substring(startIndex);
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
// replace the placeholders with their original values
return safeContent.restore(scopedSelector);
}
private _insertPolyfillHostInCssText(selector: string): string {
return selector.replace(_colonHostContextRe, _polyfillHostContext)
.replace(_colonHostRe, _polyfillHost);
}
}
class SafeSelector {
private placeholders: string[] = [];
private index = 0;
private _content: string;
constructor(selector: string) {
// Replaces attribute selectors with placeholders.
// The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(keep);
this.index++;
return replaceBy;
});
// Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
// WS and "+" would otherwise be interpreted as selector separators.
this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(exp);
this.index++;
return pseudo + replaceBy;
});
}
restore(content: string): string {
return content.replace(/__ph-(\d+)__/g, (ph, index) => this.placeholders[+index]);
}
content(): string { return this._content; }
}
const _cssContentNextSelectorRe =
/polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim;
const _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _cssContentUnscopedRuleRe =
/(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _polyfillHost = '-shadowcsshost';
// note: :host-context pre-processed to -shadowcsshostcontext.
const _polyfillHostContext = '-shadowcsscontext';
const _parenSuffix = ')(?:\\((' +
'(?:\\([^)(]*\\)|[^)(]*)+?' +
')\\))?([^,{]*)';
const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
const _shadowDOMSelectorsRe = [
/::shadow/g,
/::content/g,
// Deprecated selectors
/\/shadow-deep\//g,
/\/shadow\//g,
];
// The deep combinator is deprecated in the CSS spec
// Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future.
// see https://github.com/angular/angular/pull/17677
const _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g;
const _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
const _polyfillHostRe = /-shadowcsshost/gim;
const _colonHostRe = /:host/gim;
const _colonHostContextRe = /:host-context/gim;
const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
function stripComments(input: string): string {
return input.replace(_commentRe, '');
}
// all comments except inline source mapping
const _sourceMappingUrlRe = /\/\*\s*#\s*sourceMappingURL=[\s\S]+?\*\//;
function extractSourceMappingUrl(input: string): string {
const matcher = input.match(_sourceMappingUrlRe);
return matcher ? matcher[0] : '';
}
const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
const _curlyRe = /([{}])/g;
const OPEN_CURLY = '{';
const CLOSE_CURLY = '}';
const BLOCK_PLACEHOLDER = '%BLOCK%';
export class CssRule {
constructor(public selector: string, public content: string) {}
}
export function processRules(input: string, ruleCallback: (rule: CssRule) => CssRule): string {
const inputWithEscapedBlocks = escapeBlocks(input);
let nextBlockIndex = 0;
return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function(...m: string[]) {
const selector = m[2];
let content = '';
let suffix = m[4];
let contentPrefix = '';
if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
contentPrefix = '{';
}
const rule = ruleCallback(new CssRule(selector, content));
return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
});
}
class StringWithEscapedBlocks {
constructor(public escapedString: string, public blocks: string[]) {}
}
function escapeBlocks(input: string): StringWithEscapedBlocks {
const inputParts = input.split(_curlyRe);
const resultParts: string[] = [];
const escapedBlocks: string[] = [];
let bracketCount = 0;
let currentBlockParts: string[] = [];
for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
const part = inputParts[partIndex];
if (part == CLOSE_CURLY) {
bracketCount--;
}
if (bracketCount > 0) {
currentBlockParts.push(part);
} else {
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
currentBlockParts = [];
}
resultParts.push(part);
}
if (part == OPEN_CURLY) {
bracketCount++;
}
}
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
}
return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
}
| packages/compiler/src/shadow_css.ts | 1 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.9984446167945862,
0.16352634131908417,
0.0001649768528295681,
0.002821971196681261,
0.33331403136253357
] |
{
"id": 0,
"code_window": [
" * When strictStyling is true:\n",
" * - selector is the attribute added to all elements inside the host,\n",
" * - hostSelector is the attribute added to the host itself.\n",
" */\n",
" shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {\n",
" const sourceMappingUrl: string = extractSourceMappingUrl(cssText);\n",
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" const commentsWithHash = extractCommentsWithHash(cssText);\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 148
} | import { NgModule } from '@angular/core';
import { RouterModule } from '@angular/router';
import { AppComponent } from './app.component';
@NgModule({
imports: [
RouterModule.forChild([{ path: '03-03', component: AppComponent }])
],
declarations: [
AppComponent
],
exports: [ AppComponent ]
})
export class AppModule {}
| aio/content/examples/styleguide/src/03-03/app/app.module.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.00017349599511362612,
0.00017120770644396544,
0.00016891943232621998,
0.00017120770644396544,
0.0000022882813937030733
] |
{
"id": 0,
"code_window": [
" * When strictStyling is true:\n",
" * - selector is the attribute added to all elements inside the host,\n",
" * - hostSelector is the attribute added to the host itself.\n",
" */\n",
" shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {\n",
" const sourceMappingUrl: string = extractSourceMappingUrl(cssText);\n",
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" const commentsWithHash = extractCommentsWithHash(cssText);\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 148
} | import { ReflectiveInjector } from '@angular/core';
import { Car, Engine, Tires } from './car';
import { Logger } from '../logger.service';
// #docregion injector
export function useInjector() {
let injector: ReflectiveInjector;
// #enddocregion injector
/*
// #docregion injector-no-new
// Cannot instantiate an ReflectiveInjector like this!
let injector = new ReflectiveInjector([Car, Engine, Tires]);
// #enddocregion injector-no-new
*/
// #docregion injector, injector-create-and-call
injector = ReflectiveInjector.resolveAndCreate([Car, Engine, Tires]);
// #docregion injector-call
let car = injector.get(Car);
// #enddocregion injector-call, injector-create-and-call
car.description = 'Injector';
injector = ReflectiveInjector.resolveAndCreate([Logger]);
let logger = injector.get(Logger);
logger.log('Injector car.drive() said: ' + car.drive());
return car;
}
| aio/content/examples/dependency-injection/src/app/car/car-injector.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.00017441804811824113,
0.00017290787945967168,
0.00017136520182248205,
0.00017294037388637662,
0.000001246531155629782
] |
{
"id": 0,
"code_window": [
" * When strictStyling is true:\n",
" * - selector is the attribute added to all elements inside the host,\n",
" * - hostSelector is the attribute added to the host itself.\n",
" */\n",
" shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {\n",
" const sourceMappingUrl: string = extractSourceMappingUrl(cssText);\n",
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"keep",
"replace",
"keep",
"keep"
],
"after_edit": [
" const commentsWithHash = extractCommentsWithHash(cssText);\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 148
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import * as path from 'path';
import * as ts from 'typescript';
import {MetadataBundler, MetadataBundlerHost} from '../../src/metadata/bundler';
import {MetadataCollector} from '../../src/metadata/collector';
import {ClassMetadata, MetadataGlobalReferenceExpression, ModuleMetadata} from '../../src/metadata/schema';
import {Directory, open} from './typescript.mocks';
describe('metadata bundler', () => {
it('should be able to bundle a simple library', () => {
const host = new MockStringBundlerHost('/', SIMPLE_LIBRARY);
const bundler = new MetadataBundler('/lib/index', undefined, host);
const result = bundler.getMetadataBundle();
expect(Object.keys(result.metadata.metadata).sort()).toEqual([
'ONE_CLASSES', 'One', 'OneMore', 'TWO_CLASSES', 'Two', 'TwoMore', 'ɵa', 'ɵb'
]);
const originalOne = './src/one';
const originalTwo = './src/two/index';
expect(Object.keys(result.metadata.origins !)
.sort()
.map(name => ({name, value: result.metadata.origins ![name]})))
.toEqual([
{name: 'ONE_CLASSES', value: originalOne}, {name: 'One', value: originalOne},
{name: 'OneMore', value: originalOne}, {name: 'TWO_CLASSES', value: originalTwo},
{name: 'Two', value: originalTwo}, {name: 'TwoMore', value: originalTwo},
{name: 'ɵa', value: originalOne}, {name: 'ɵb', value: originalTwo}
]);
expect(result.privates).toEqual([
{privateName: 'ɵa', name: 'PrivateOne', module: originalOne},
{privateName: 'ɵb', name: 'PrivateTwo', module: originalTwo}
]);
});
it('should be able to bundle an oddly constructed library', () => {
const host = new MockStringBundlerHost('/', {
'lib': {
'index.ts': `
export * from './src/index';
`,
'src': {
'index.ts': `
export {One, OneMore, ONE_CLASSES} from './one';
export {Two, TwoMore, TWO_CLASSES} from './two/index';
`,
'one.ts': `
class One {}
class OneMore extends One {}
class PrivateOne {}
const ONE_CLASSES = [One, OneMore, PrivateOne];
export {One, OneMore, PrivateOne, ONE_CLASSES};
`,
'two': {
'index.ts': `
class Two {}
class TwoMore extends Two {}
class PrivateTwo {}
const TWO_CLASSES = [Two, TwoMore, PrivateTwo];
export {Two, TwoMore, PrivateTwo, TWO_CLASSES};
`
}
}
}
});
const bundler = new MetadataBundler('/lib/index', undefined, host);
const result = bundler.getMetadataBundle();
expect(Object.keys(result.metadata.metadata).sort()).toEqual([
'ONE_CLASSES', 'One', 'OneMore', 'TWO_CLASSES', 'Two', 'TwoMore', 'ɵa', 'ɵb'
]);
expect(result.privates).toEqual([
{privateName: 'ɵa', name: 'PrivateOne', module: './src/one'},
{privateName: 'ɵb', name: 'PrivateTwo', module: './src/two/index'}
]);
});
it('should not output windows paths in metadata', () => {
const host = new MockStringBundlerHost('/', {
'index.ts': `
export * from './exports/test';
`,
'exports': {'test.ts': `export class TestExport {}`}
});
const bundler = new MetadataBundler('/index', undefined, host);
const result = bundler.getMetadataBundle();
expect(result.metadata.origins).toEqual({'TestExport': './exports/test'});
});
it('should convert re-exported to the export', () => {
const host = new MockStringBundlerHost('/', {
'index.ts': `
export * from './bar';
export * from './foo';
`,
'bar.ts': `
import {Foo} from './foo';
export class Bar extends Foo {
}
`,
'foo.ts': `
export {Foo} from 'foo';
`
});
const bundler = new MetadataBundler('/index', undefined, host);
const result = bundler.getMetadataBundle();
// Expect the extends reference to refer to the imported module
expect((result.metadata.metadata as any).Bar.extends.module).toEqual('foo');
expect(result.privates).toEqual([]);
});
it('should treat import then export as a simple export', () => {
const host = new MockStringBundlerHost('/', {
'index.ts': `
export * from './a';
export * from './c';
`,
'a.ts': `
import { B } from './b';
export { B };
`,
'b.ts': `
export class B { }
`,
'c.ts': `
import { B } from './b';
export class C extends B { }
`
});
const bundler = new MetadataBundler('/index', undefined, host);
const result = bundler.getMetadataBundle();
expect(Object.keys(result.metadata.metadata).sort()).toEqual(['B', 'C']);
expect(result.privates).toEqual([]);
});
it('should be able to bundle a private from a un-exported module', () => {
const host = new MockStringBundlerHost('/', {
'index.ts': `
export * from './foo';
`,
'foo.ts': `
import {Bar} from './bar';
export class Foo extends Bar {
}
`,
'bar.ts': `
export class Bar {}
`
});
const bundler = new MetadataBundler('/index', undefined, host);
const result = bundler.getMetadataBundle();
expect(Object.keys(result.metadata.metadata).sort()).toEqual(['Foo', 'ɵa']);
expect(result.privates).toEqual([{privateName: 'ɵa', name: 'Bar', module: './bar'}]);
});
it('should be able to bundle a library with re-exported symbols', () => {
const host = new MockStringBundlerHost('/', {
'public-api.ts': `
export * from './src/core';
export * from './src/externals';
`,
'src': {
'core.ts': `
export class A {}
export class B extends A {}
`,
'externals.ts': `
export {E, F, G} from 'external_one';
export * from 'external_two';
`
}
});
const bundler = new MetadataBundler('/public-api', undefined, host);
const result = bundler.getMetadataBundle();
expect(result.metadata.exports).toEqual([
{from: 'external_two'}, {
export: [{name: 'E', as: 'E'}, {name: 'F', as: 'F'}, {name: 'G', as: 'G'}],
from: 'external_one'
}
]);
expect(result.metadata.origins !['E']).toBeUndefined();
});
it('should be able to de-duplicate symbols of re-exported modules', () => {
const host = new MockStringBundlerHost('/', {
'public-api.ts': `
export {A as A2, A, B as B1, B as B2} from './src/core';
export {A as A3} from './src/alternate';
`,
'src': {
'core.ts': `
export class A {}
export class B {}
`,
'alternate.ts': `
export class A {}
`,
}
});
const bundler = new MetadataBundler('/public-api', undefined, host);
const result = bundler.getMetadataBundle();
const {A, A2, A3, B1, B2} = result.metadata.metadata as{
A: ClassMetadata,
A2: MetadataGlobalReferenceExpression,
A3: ClassMetadata,
B1: ClassMetadata,
B2: MetadataGlobalReferenceExpression
};
expect(A.__symbolic).toEqual('class');
expect(A2.__symbolic).toEqual('reference');
expect(A2.name).toEqual('A');
expect(A3.__symbolic).toEqual('class');
expect(B1.__symbolic).toEqual('class');
expect(B2.__symbolic).toEqual('reference');
expect(B2.name).toEqual('B1');
});
});
export class MockStringBundlerHost implements MetadataBundlerHost {
collector = new MetadataCollector();
constructor(private dirName: string, private directory: Directory) {}
getMetadataFor(moduleName: string): ModuleMetadata|undefined {
const fileName = path.join(this.dirName, moduleName) + '.ts';
const text = open(this.directory, fileName);
if (typeof text == 'string') {
const sourceFile = ts.createSourceFile(
fileName, text, ts.ScriptTarget.Latest, /* setParent */ true, ts.ScriptKind.TS);
const diagnostics: ts.Diagnostic[] = (sourceFile as any).parseDiagnostics;
if (diagnostics && diagnostics.length) {
throw Error('Unexpected syntax error in test');
}
const result = this.collector.getMetadata(sourceFile);
return result;
}
}
}
export const SIMPLE_LIBRARY = {
'lib': {
'index.ts': `
export * from './src/index';
`,
'src': {
'index.ts': `
export {One, OneMore, ONE_CLASSES} from './one';
export {Two, TwoMore, TWO_CLASSES} from './two/index';
`,
'one.ts': `
export class One {}
export class OneMore extends One {}
export class PrivateOne {}
export const ONE_CLASSES = [One, OneMore, PrivateOne];
`,
'two': {
'index.ts': `
export class Two {}
export class TwoMore extends Two {}
export class PrivateTwo {}
export const TWO_CLASSES = [Two, TwoMore, PrivateTwo];
`
}
}
}
};
| packages/compiler-cli/test/metadata/bundler_spec.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.0007765015470795333,
0.0002957458491437137,
0.00016891669656615704,
0.0001918444613693282,
0.00017795547319110483
] |
{
"id": 1,
"code_window": [
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n",
" return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;\n",
" }\n",
"\n",
" private _insertDirectives(cssText: string): string {\n",
" cssText = this._insertPolyfillDirectivesInCssText(cssText);\n",
" return this._insertPolyfillRulesInCssText(cssText);\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);\n",
" return [scopedCssText, ...commentsWithHash].join('\\n');\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 151
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* This file is a port of shadowCSS from webcomponents.js to TypeScript.
*
* Please make sure to keep to edits in sync with the source file.
*
* Source:
* https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
*
* The original file level comment is reproduced below
*/
/*
This is a limited shim for ShadowDOM css styling.
https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
The intention here is to support only the styling features which can be
relatively simply implemented. The goal is to allow users to avoid the
most obvious pitfalls and do so without compromising performance significantly.
For ShadowDOM styling that's not covered here, a set of best practices
can be provided that should allow users to accomplish more complex styling.
The following is a list of specific ShadowDOM styling features and a brief
discussion of the approach used to shim.
Shimmed features:
* :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
element using the :host rule. To shim this feature, the :host styles are
reformatted and prefixed with a given scope name and promoted to a
document level stylesheet.
For example, given a scope name of .foo, a rule like this:
:host {
background: red;
}
}
becomes:
.foo {
background: red;
}
* encapsulation: Styles defined within ShadowDOM, apply only to
dom inside the ShadowDOM. Polymer uses one of two techniques to implement
this feature.
By default, rules are prefixed with the host element tag name
as a descendant selector. This ensures styling does not leak out of the 'top'
of the element's ShadowDOM. For example,
div {
font-weight: bold;
}
becomes:
x-foo div {
font-weight: bold;
}
becomes:
Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
selectors are scoped by adding an attribute selector suffix to each
simple selector that contains the host element tag name. Each element
in the element's ShadowDOM template is also given the scope attribute.
Thus, these rules match only elements that have the scope attribute.
For example, given a scope name of x-foo, a rule like this:
div {
font-weight: bold;
}
becomes:
div[x-foo] {
font-weight: bold;
}
Note that elements that are dynamically added to a scope must have the scope
selector added to them manually.
* upper/lower bound encapsulation: Styles which are defined outside a
shadowRoot should not cross the ShadowDOM boundary and should not apply
inside a shadowRoot.
This styling behavior is not emulated. Some possible ways to do this that
were rejected due to complexity and/or performance concerns include: (1) reset
every possible property for every possible selector for a given scope name;
(2) re-implement css in javascript.
As an alternative, users should make sure to use selectors
specific to the scope in which they are working.
* ::distributed: This behavior is not emulated. It's often not necessary
to style the contents of a specific insertion point and instead, descendants
of the host element can be styled selectively. Users can also create an
extra node around an insertion point and style that node's contents
via descendent selectors. For example, with a shadowRoot like this:
<style>
::content(div) {
background: red;
}
</style>
<content></content>
could become:
<style>
/ *@polyfill .content-container div * /
::content(div) {
background: red;
}
</style>
<div class="content-container">
<content></content>
</div>
Note the use of @polyfill in the comment above a ShadowDOM specific style
declaration. This is a directive to the styling shim to use the selector
in comments in lieu of the next selector when running under polyfill.
*/
export class ShadowCss {
strictStyling: boolean = true;
constructor() {}
/*
* Shim some cssText with the given selector. Returns cssText that can
* be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
*
* When strictStyling is true:
* - selector is the attribute added to all elements inside the host,
* - hostSelector is the attribute added to the host itself.
*/
shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {
const sourceMappingUrl: string = extractSourceMappingUrl(cssText);
cssText = stripComments(cssText);
cssText = this._insertDirectives(cssText);
return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;
}
private _insertDirectives(cssText: string): string {
cssText = this._insertPolyfillDirectivesInCssText(cssText);
return this._insertPolyfillRulesInCssText(cssText);
}
/*
* Process styles to convert native ShadowDOM rules that will trip
* up the css parser; we rely on decorating the stylesheet with inert rules.
*
* For example, we convert this rule:
*
* polyfill-next-selector { content: ':host menu-item'; }
* ::content menu-item {
*
* to this:
*
* scopeName menu-item {
*
**/
private _insertPolyfillDirectivesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(
_cssContentNextSelectorRe, function(...m: string[]) { return m[2] + '{'; });
}
/*
* Process styles to add rules which will only apply under the polyfill
*
* For example, we convert this rule:
*
* polyfill-rule {
* content: ':host menu-item';
* ...
* }
*
* to this:
*
* scopeName menu-item {...}
*
**/
private _insertPolyfillRulesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(_cssContentRuleRe, (...m: string[]) => {
const rule = m[0].replace(m[1], '').replace(m[2], '');
return m[4] + rule;
});
}
/* Ensure styles are scoped. Pseudo-scoping takes a rule like:
*
* .foo {... }
*
* and converts this to
*
* scopeName .foo { ... }
*/
private _scopeCssText(cssText: string, scopeSelector: string, hostSelector: string): string {
const unscopedRules = this._extractUnscopedRulesFromCssText(cssText);
// replace :host and :host-context -shadowcsshost and -shadowcsshost respectively
cssText = this._insertPolyfillHostInCssText(cssText);
cssText = this._convertColonHost(cssText);
cssText = this._convertColonHostContext(cssText);
cssText = this._convertShadowDOMSelectors(cssText);
if (scopeSelector) {
cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
}
cssText = cssText + '\n' + unscopedRules;
return cssText.trim();
}
/*
* Process styles to add rules which will only apply under the polyfill
* and do not process via CSSOM. (CSSOM is destructive to rules on rare
* occasions, e.g. -webkit-calc on Safari.)
* For example, we convert this rule:
*
* @polyfill-unscoped-rule {
* content: 'menu-item';
* ... }
*
* to this:
*
* menu-item {...}
*
**/
private _extractUnscopedRulesFromCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
let r = '';
let m: RegExpExecArray|null;
_cssContentUnscopedRuleRe.lastIndex = 0;
while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {
const rule = m[0].replace(m[2], '').replace(m[1], m[4]);
r += rule + '\n\n';
}
return r;
}
/*
* convert a rule like :host(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar
*/
private _convertColonHost(cssText: string): string {
return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
}
/*
* convert a rule like :host-context(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar, .foo scopeName > .bar { }
*
* and
*
* :host-context(.foo:host) .bar { ... }
*
* to
*
* .foo<scopeName> .bar { ... }
*/
private _convertColonHostContext(cssText: string): string {
return this._convertColonRule(
cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
}
private _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
// m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
return cssText.replace(regExp, function(...m: string[]) {
if (m[2]) {
const parts = m[2].split(',');
const r: string[] = [];
for (let i = 0; i < parts.length; i++) {
const p = parts[i].trim();
if (!p) break;
r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
}
return r.join(',');
} else {
return _polyfillHostNoCombinator + m[3];
}
});
}
private _colonHostContextPartReplacer(host: string, part: string, suffix: string): string {
if (part.indexOf(_polyfillHost) > -1) {
return this._colonHostPartReplacer(host, part, suffix);
} else {
return host + part + suffix + ', ' + part + ' ' + host + suffix;
}
}
private _colonHostPartReplacer(host: string, part: string, suffix: string): string {
return host + part.replace(_polyfillHost, '') + suffix;
}
/*
* Convert combinators like ::shadow and pseudo-elements like ::content
* by replacing with space.
*/
private _convertShadowDOMSelectors(cssText: string): string {
return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
}
// change a selector like 'div' to 'name div'
private _scopeSelectors(cssText: string, scopeSelector: string, hostSelector: string): string {
return processRules(cssText, (rule: CssRule) => {
let selector = rule.selector;
let content = rule.content;
if (rule.selector[0] != '@') {
selector =
this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
} else if (
rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
}
return new CssRule(selector, content);
});
}
private _scopeSelector(
selector: string, scopeSelector: string, hostSelector: string, strict: boolean): string {
return selector.split(',')
.map(part => part.trim().split(_shadowDeepSelectors))
.map((deepParts) => {
const [shallowPart, ...otherParts] = deepParts;
const applyScope = (shallowPart: string) => {
if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
return strict ?
this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :
this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
} else {
return shallowPart;
}
};
return [applyScope(shallowPart), ...otherParts].join(' ');
})
.join(', ');
}
private _selectorNeedsScoping(selector: string, scopeSelector: string): boolean {
const re = this._makeScopeMatcher(scopeSelector);
return !re.test(selector);
}
private _makeScopeMatcher(scopeSelector: string): RegExp {
const lre = /\[/g;
const rre = /\]/g;
scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
}
private _applySelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// Difference from webcomponents.js: scopeSelector could not be an array
return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
}
// scope via name and [is=name]
private _applySimpleSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// In Android browser, the lastIndex is not reset when the regex is used in String.replace()
_polyfillHostRe.lastIndex = 0;
if (_polyfillHostRe.test(selector)) {
const replaceBy = this.strictStyling ? `[${hostSelector}]` : scopeSelector;
return selector
.replace(
_polyfillHostNoCombinatorRe,
(hnc, selector) => {
return selector.replace(
/([^:]*)(:*)(.*)/,
(_: string, before: string, colon: string, after: string) => {
return before + replaceBy + colon + after;
});
})
.replace(_polyfillHostRe, replaceBy + ' ');
}
return scopeSelector + ' ' + selector;
}
// return a selector with [name] suffix on each simple selector
// e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name] /** @internal */
private _applyStrictSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
const isRe = /\[is=([^\]]*)\]/g;
scopeSelector = scopeSelector.replace(isRe, (_: string, ...parts: string[]) => parts[0]);
const attrName = '[' + scopeSelector + ']';
const _scopeSelectorPart = (p: string) => {
let scopedP = p.trim();
if (!scopedP) {
return '';
}
if (p.indexOf(_polyfillHostNoCombinator) > -1) {
scopedP = this._applySimpleSelectorScope(p, scopeSelector, hostSelector);
} else {
// remove :host since it should be unnecessary
const t = p.replace(_polyfillHostRe, '');
if (t.length > 0) {
const matches = t.match(/([^:]*)(:*)(.*)/);
if (matches) {
scopedP = matches[1] + attrName + matches[2] + matches[3];
}
}
}
return scopedP;
};
const safeContent = new SafeSelector(selector);
selector = safeContent.content();
let scopedSelector = '';
let startIndex = 0;
let res: RegExpExecArray|null;
const sep = /( |>|\+|~(?!=))\s*/g;
// If a selector appears before :host it should not be shimmed as it
// matches on ancestor elements and not on elements in the host's shadow
// `:host-context(div)` is transformed to
// `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
// the `div` is not part of the component in the 2nd selectors and should not be scoped.
// Historically `component-tag:host` was matching the component so we also want to preserve
// this behavior to avoid breaking legacy apps (it should not match).
// The behavior should be:
// - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
// - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
// `:host-context(tag)`)
const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
// Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
let shouldScope = !hasHost;
while ((res = sep.exec(selector)) !== null) {
const separator = res[1];
const part = selector.slice(startIndex, res.index).trim();
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
scopedSelector += `${scopedPart} ${separator} `;
startIndex = sep.lastIndex;
}
const part = selector.substring(startIndex);
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
// replace the placeholders with their original values
return safeContent.restore(scopedSelector);
}
private _insertPolyfillHostInCssText(selector: string): string {
return selector.replace(_colonHostContextRe, _polyfillHostContext)
.replace(_colonHostRe, _polyfillHost);
}
}
class SafeSelector {
private placeholders: string[] = [];
private index = 0;
private _content: string;
constructor(selector: string) {
// Replaces attribute selectors with placeholders.
// The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(keep);
this.index++;
return replaceBy;
});
// Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
// WS and "+" would otherwise be interpreted as selector separators.
this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(exp);
this.index++;
return pseudo + replaceBy;
});
}
restore(content: string): string {
return content.replace(/__ph-(\d+)__/g, (ph, index) => this.placeholders[+index]);
}
content(): string { return this._content; }
}
const _cssContentNextSelectorRe =
/polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim;
const _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _cssContentUnscopedRuleRe =
/(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _polyfillHost = '-shadowcsshost';
// note: :host-context pre-processed to -shadowcsshostcontext.
const _polyfillHostContext = '-shadowcsscontext';
const _parenSuffix = ')(?:\\((' +
'(?:\\([^)(]*\\)|[^)(]*)+?' +
')\\))?([^,{]*)';
const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
const _shadowDOMSelectorsRe = [
/::shadow/g,
/::content/g,
// Deprecated selectors
/\/shadow-deep\//g,
/\/shadow\//g,
];
// The deep combinator is deprecated in the CSS spec
// Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future.
// see https://github.com/angular/angular/pull/17677
const _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g;
const _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
const _polyfillHostRe = /-shadowcsshost/gim;
const _colonHostRe = /:host/gim;
const _colonHostContextRe = /:host-context/gim;
const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
function stripComments(input: string): string {
return input.replace(_commentRe, '');
}
// all comments except inline source mapping
const _sourceMappingUrlRe = /\/\*\s*#\s*sourceMappingURL=[\s\S]+?\*\//;
function extractSourceMappingUrl(input: string): string {
const matcher = input.match(_sourceMappingUrlRe);
return matcher ? matcher[0] : '';
}
const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
const _curlyRe = /([{}])/g;
const OPEN_CURLY = '{';
const CLOSE_CURLY = '}';
const BLOCK_PLACEHOLDER = '%BLOCK%';
export class CssRule {
constructor(public selector: string, public content: string) {}
}
export function processRules(input: string, ruleCallback: (rule: CssRule) => CssRule): string {
const inputWithEscapedBlocks = escapeBlocks(input);
let nextBlockIndex = 0;
return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function(...m: string[]) {
const selector = m[2];
let content = '';
let suffix = m[4];
let contentPrefix = '';
if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
contentPrefix = '{';
}
const rule = ruleCallback(new CssRule(selector, content));
return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
});
}
class StringWithEscapedBlocks {
constructor(public escapedString: string, public blocks: string[]) {}
}
function escapeBlocks(input: string): StringWithEscapedBlocks {
const inputParts = input.split(_curlyRe);
const resultParts: string[] = [];
const escapedBlocks: string[] = [];
let bracketCount = 0;
let currentBlockParts: string[] = [];
for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
const part = inputParts[partIndex];
if (part == CLOSE_CURLY) {
bracketCount--;
}
if (bracketCount > 0) {
currentBlockParts.push(part);
} else {
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
currentBlockParts = [];
}
resultParts.push(part);
}
if (part == OPEN_CURLY) {
bracketCount++;
}
}
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
}
return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
}
| packages/compiler/src/shadow_css.ts | 1 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.9977623224258423,
0.02052055299282074,
0.00016301921277772635,
0.0007672610227018595,
0.12564021348953247
] |
{
"id": 1,
"code_window": [
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n",
" return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;\n",
" }\n",
"\n",
" private _insertDirectives(cssText: string): string {\n",
" cssText = this._insertPolyfillDirectivesInCssText(cssText);\n",
" return this._insertPolyfillRulesInCssText(cssText);\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);\n",
" return [scopedCssText, ...commentsWithHash].join('\\n');\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 151
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {CompileDirectiveMetadata, CompileIdentifierMetadata, CompileNgModuleMetadata, CompilePipeSummary, CompileProviderMetadata, CompileStylesheetMetadata, CompileTypeSummary, ProviderMeta, ProxyClass, identifierName, ngModuleJitUrl, sharedStylesheetJitUrl, templateJitUrl, templateSourceUrl} from '../compile_metadata';
import {CompileReflector} from '../compile_reflector';
import {CompilerConfig} from '../config';
import {ConstantPool} from '../constant_pool';
import {Type} from '../core';
import {CompileMetadataResolver} from '../metadata_resolver';
import {NgModuleCompiler} from '../ng_module_compiler';
import * as ir from '../output/output_ast';
import {interpretStatements} from '../output/output_interpreter';
import {jitStatements} from '../output/output_jit';
import {CompiledStylesheet, StyleCompiler} from '../style_compiler';
import {SummaryResolver} from '../summary_resolver';
import {TemplateAst} from '../template_parser/template_ast';
import {TemplateParser} from '../template_parser/template_parser';
import {Console, OutputContext, SyncAsync, stringify} from '../util';
import {ViewCompiler} from '../view_compiler/view_compiler';
export interface ModuleWithComponentFactories {
ngModuleFactory: object;
componentFactories: object[];
}
/**
* An internal module of the Angular compiler that begins with component types,
* extracts templates, and eventually produces a compiled version of the component
* ready for linking into an application.
*
* @security When compiling templates at runtime, you must ensure that the entire template comes
* from a trusted source. Attacker-controlled data introduced by a template could expose your
* application to XSS risks. For more detail, see the [Security Guide](http://g.co/ng/security).
*/
export class JitCompiler {
private _compiledTemplateCache = new Map<Type, CompiledTemplate>();
private _compiledHostTemplateCache = new Map<Type, CompiledTemplate>();
private _compiledDirectiveWrapperCache = new Map<Type, Type>();
private _compiledNgModuleCache = new Map<Type, object>();
private _sharedStylesheetCount = 0;
private _addedAotSummaries = new Set<() => any[]>();
constructor(
private _metadataResolver: CompileMetadataResolver, private _templateParser: TemplateParser,
private _styleCompiler: StyleCompiler, private _viewCompiler: ViewCompiler,
private _ngModuleCompiler: NgModuleCompiler, private _summaryResolver: SummaryResolver<Type>,
private _reflector: CompileReflector, private _compilerConfig: CompilerConfig,
private _console: Console,
private getExtraNgModuleProviders: (ngModule: any) => CompileProviderMetadata[]) {}
compileModuleSync(moduleType: Type): object {
return SyncAsync.assertSync(this._compileModuleAndComponents(moduleType, true));
}
compileModuleAsync(moduleType: Type): Promise<object> {
return Promise.resolve(this._compileModuleAndComponents(moduleType, false));
}
compileModuleAndAllComponentsSync(moduleType: Type): ModuleWithComponentFactories {
return SyncAsync.assertSync(this._compileModuleAndAllComponents(moduleType, true));
}
compileModuleAndAllComponentsAsync(moduleType: Type): Promise<ModuleWithComponentFactories> {
return Promise.resolve(this._compileModuleAndAllComponents(moduleType, false));
}
getComponentFactory(component: Type): object {
const summary = this._metadataResolver.getDirectiveSummary(component);
return summary.componentFactory as object;
}
loadAotSummaries(summaries: () => any[]) {
this.clearCache();
this._addAotSummaries(summaries);
}
private _addAotSummaries(fn: () => any[]) {
if (this._addedAotSummaries.has(fn)) {
return;
}
this._addedAotSummaries.add(fn);
const summaries = fn();
for (let i = 0; i < summaries.length; i++) {
const entry = summaries[i];
if (typeof entry === 'function') {
this._addAotSummaries(entry);
} else {
const summary = entry as CompileTypeSummary;
this._summaryResolver.addSummary(
{symbol: summary.type.reference, metadata: null, type: summary});
}
}
}
hasAotSummary(ref: Type) { return !!this._summaryResolver.resolveSummary(ref); }
private _filterJitIdentifiers(ids: CompileIdentifierMetadata[]): any[] {
return ids.map(mod => mod.reference).filter((ref) => !this.hasAotSummary(ref));
}
private _compileModuleAndComponents(moduleType: Type, isSync: boolean): SyncAsync<object> {
return SyncAsync.then(this._loadModules(moduleType, isSync), () => {
this._compileComponents(moduleType, null);
return this._compileModule(moduleType);
});
}
private _compileModuleAndAllComponents(moduleType: Type, isSync: boolean):
SyncAsync<ModuleWithComponentFactories> {
return SyncAsync.then(this._loadModules(moduleType, isSync), () => {
const componentFactories: object[] = [];
this._compileComponents(moduleType, componentFactories);
return {
ngModuleFactory: this._compileModule(moduleType),
componentFactories: componentFactories
};
});
}
private _loadModules(mainModule: any, isSync: boolean): SyncAsync<any> {
const loading: Promise<any>[] = [];
const mainNgModule = this._metadataResolver.getNgModuleMetadata(mainModule) !;
// Note: for runtime compilation, we want to transitively compile all modules,
// so we also need to load the declared directives / pipes for all nested modules.
this._filterJitIdentifiers(mainNgModule.transitiveModule.modules).forEach((nestedNgModule) => {
// getNgModuleMetadata only returns null if the value passed in is not an NgModule
const moduleMeta = this._metadataResolver.getNgModuleMetadata(nestedNgModule) !;
this._filterJitIdentifiers(moduleMeta.declaredDirectives).forEach((ref) => {
const promise =
this._metadataResolver.loadDirectiveMetadata(moduleMeta.type.reference, ref, isSync);
if (promise) {
loading.push(promise);
}
});
this._filterJitIdentifiers(moduleMeta.declaredPipes)
.forEach((ref) => this._metadataResolver.getOrLoadPipeMetadata(ref));
});
return SyncAsync.all(loading);
}
private _compileModule(moduleType: Type): object {
let ngModuleFactory = this._compiledNgModuleCache.get(moduleType) !;
if (!ngModuleFactory) {
const moduleMeta = this._metadataResolver.getNgModuleMetadata(moduleType) !;
// Always provide a bound Compiler
const extraProviders = this.getExtraNgModuleProviders(moduleMeta.type.reference);
const outputCtx = createOutputContext();
const compileResult = this._ngModuleCompiler.compile(outputCtx, moduleMeta, extraProviders);
ngModuleFactory = this._interpretOrJit(
ngModuleJitUrl(moduleMeta), outputCtx.statements)[compileResult.ngModuleFactoryVar];
this._compiledNgModuleCache.set(moduleMeta.type.reference, ngModuleFactory);
}
return ngModuleFactory;
}
/**
* @internal
*/
_compileComponents(mainModule: Type, allComponentFactories: object[]|null) {
const ngModule = this._metadataResolver.getNgModuleMetadata(mainModule) !;
const moduleByJitDirective = new Map<any, CompileNgModuleMetadata>();
const templates = new Set<CompiledTemplate>();
const transJitModules = this._filterJitIdentifiers(ngModule.transitiveModule.modules);
transJitModules.forEach((localMod) => {
const localModuleMeta = this._metadataResolver.getNgModuleMetadata(localMod) !;
this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach((dirRef) => {
moduleByJitDirective.set(dirRef, localModuleMeta);
const dirMeta = this._metadataResolver.getDirectiveMetadata(dirRef);
if (dirMeta.isComponent) {
templates.add(this._createCompiledTemplate(dirMeta, localModuleMeta));
if (allComponentFactories) {
const template =
this._createCompiledHostTemplate(dirMeta.type.reference, localModuleMeta);
templates.add(template);
allComponentFactories.push(dirMeta.componentFactory as object);
}
}
});
});
transJitModules.forEach((localMod) => {
const localModuleMeta = this._metadataResolver.getNgModuleMetadata(localMod) !;
this._filterJitIdentifiers(localModuleMeta.declaredDirectives).forEach((dirRef) => {
const dirMeta = this._metadataResolver.getDirectiveMetadata(dirRef);
if (dirMeta.isComponent) {
dirMeta.entryComponents.forEach((entryComponentType) => {
const moduleMeta = moduleByJitDirective.get(entryComponentType.componentType) !;
templates.add(
this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
});
}
});
localModuleMeta.entryComponents.forEach((entryComponentType) => {
if (!this.hasAotSummary(entryComponentType.componentType.reference)) {
const moduleMeta = moduleByJitDirective.get(entryComponentType.componentType) !;
templates.add(
this._createCompiledHostTemplate(entryComponentType.componentType, moduleMeta));
}
});
});
templates.forEach((template) => this._compileTemplate(template));
}
clearCacheFor(type: Type) {
this._compiledNgModuleCache.delete(type);
this._metadataResolver.clearCacheFor(type);
this._compiledHostTemplateCache.delete(type);
const compiledTemplate = this._compiledTemplateCache.get(type);
if (compiledTemplate) {
this._compiledTemplateCache.delete(type);
}
}
clearCache(): void {
// Note: don't clear the _addedAotSummaries, as they don't change!
this._metadataResolver.clearCache();
this._compiledTemplateCache.clear();
this._compiledHostTemplateCache.clear();
this._compiledNgModuleCache.clear();
}
private _createCompiledHostTemplate(compType: Type, ngModule: CompileNgModuleMetadata):
CompiledTemplate {
if (!ngModule) {
throw new Error(
`Component ${stringify(compType)} is not part of any NgModule or the module has not been imported into your module.`);
}
let compiledTemplate = this._compiledHostTemplateCache.get(compType);
if (!compiledTemplate) {
const compMeta = this._metadataResolver.getDirectiveMetadata(compType);
assertComponent(compMeta);
const hostMeta = this._metadataResolver.getHostComponentMetadata(
compMeta, (compMeta.componentFactory as any).viewDefFactory);
compiledTemplate =
new CompiledTemplate(true, compMeta.type, hostMeta, ngModule, [compMeta.type]);
this._compiledHostTemplateCache.set(compType, compiledTemplate);
}
return compiledTemplate;
}
private _createCompiledTemplate(
compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata): CompiledTemplate {
let compiledTemplate = this._compiledTemplateCache.get(compMeta.type.reference);
if (!compiledTemplate) {
assertComponent(compMeta);
compiledTemplate = new CompiledTemplate(
false, compMeta.type, compMeta, ngModule, ngModule.transitiveModule.directives);
this._compiledTemplateCache.set(compMeta.type.reference, compiledTemplate);
}
return compiledTemplate;
}
private _compileTemplate(template: CompiledTemplate) {
if (template.isCompiled) {
return;
}
const compMeta = template.compMeta;
const externalStylesheetsByModuleUrl = new Map<string, CompiledStylesheet>();
const outputContext = createOutputContext();
const componentStylesheet = this._styleCompiler.compileComponent(outputContext, compMeta);
compMeta.template !.externalStylesheets.forEach((stylesheetMeta) => {
const compiledStylesheet =
this._styleCompiler.compileStyles(createOutputContext(), compMeta, stylesheetMeta);
externalStylesheetsByModuleUrl.set(stylesheetMeta.moduleUrl !, compiledStylesheet);
});
this._resolveStylesCompileResult(componentStylesheet, externalStylesheetsByModuleUrl);
const pipes = template.ngModule.transitiveModule.pipes.map(
pipe => this._metadataResolver.getPipeSummary(pipe.reference));
const {template: parsedTemplate, pipes: usedPipes} =
this._parseTemplate(compMeta, template.ngModule, template.directives);
const compileResult = this._viewCompiler.compileComponent(
outputContext, compMeta, parsedTemplate, ir.variable(componentStylesheet.stylesVar),
usedPipes);
const evalResult = this._interpretOrJit(
templateJitUrl(template.ngModule.type, template.compMeta), outputContext.statements);
const viewClass = evalResult[compileResult.viewClassVar];
const rendererType = evalResult[compileResult.rendererTypeVar];
template.compiled(viewClass, rendererType);
}
private _parseTemplate(
compMeta: CompileDirectiveMetadata, ngModule: CompileNgModuleMetadata,
directiveIdentifiers: CompileIdentifierMetadata[]):
{template: TemplateAst[], pipes: CompilePipeSummary[]} {
// Note: ! is ok here as components always have a template.
const preserveWhitespaces = compMeta.template !.preserveWhitespaces;
const directives =
directiveIdentifiers.map(dir => this._metadataResolver.getDirectiveSummary(dir.reference));
const pipes = ngModule.transitiveModule.pipes.map(
pipe => this._metadataResolver.getPipeSummary(pipe.reference));
return this._templateParser.parse(
compMeta, compMeta.template !.htmlAst !, directives, pipes, ngModule.schemas,
templateSourceUrl(ngModule.type, compMeta, compMeta.template !), preserveWhitespaces);
}
private _resolveStylesCompileResult(
result: CompiledStylesheet, externalStylesheetsByModuleUrl: Map<string, CompiledStylesheet>) {
result.dependencies.forEach((dep, i) => {
const nestedCompileResult = externalStylesheetsByModuleUrl.get(dep.moduleUrl) !;
const nestedStylesArr = this._resolveAndEvalStylesCompileResult(
nestedCompileResult, externalStylesheetsByModuleUrl);
dep.setValue(nestedStylesArr);
});
}
private _resolveAndEvalStylesCompileResult(
result: CompiledStylesheet,
externalStylesheetsByModuleUrl: Map<string, CompiledStylesheet>): string[] {
this._resolveStylesCompileResult(result, externalStylesheetsByModuleUrl);
return this._interpretOrJit(
sharedStylesheetJitUrl(result.meta, this._sharedStylesheetCount++),
result.outputCtx.statements)[result.stylesVar];
}
private _interpretOrJit(sourceUrl: string, statements: ir.Statement[]): any {
if (!this._compilerConfig.useJit) {
return interpretStatements(statements, this._reflector);
} else {
return jitStatements(sourceUrl, statements, this._reflector, this._compilerConfig.jitDevMode);
}
}
}
class CompiledTemplate {
private _viewClass: Function = null !;
isCompiled = false;
constructor(
public isHost: boolean, public compType: CompileIdentifierMetadata,
public compMeta: CompileDirectiveMetadata, public ngModule: CompileNgModuleMetadata,
public directives: CompileIdentifierMetadata[]) {}
compiled(viewClass: Function, rendererType: any) {
this._viewClass = viewClass;
(<ProxyClass>this.compMeta.componentViewType).setDelegate(viewClass);
for (let prop in rendererType) {
(<any>this.compMeta.rendererType)[prop] = rendererType[prop];
}
this.isCompiled = true;
}
}
function assertComponent(meta: CompileDirectiveMetadata) {
if (!meta.isComponent) {
throw new Error(
`Could not compile '${identifierName(meta.type)}' because it is not a component.`);
}
}
function createOutputContext(): OutputContext {
const importExpr = (symbol: any) =>
ir.importExpr({name: identifierName(symbol), moduleName: null, runtime: symbol});
return {statements: [], genFilePath: '', importExpr, constantPool: new ConstantPool()};
}
| packages/compiler/src/jit/compiler.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.9492431879043579,
0.026793712750077248,
0.00016407652583438903,
0.00017264594498556107,
0.15377983450889587
] |
{
"id": 1,
"code_window": [
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n",
" return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;\n",
" }\n",
"\n",
" private _insertDirectives(cssText: string): string {\n",
" cssText = this._insertPolyfillDirectivesInCssText(cssText);\n",
" return this._insertPolyfillRulesInCssText(cssText);\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);\n",
" return [scopedCssText, ...commentsWithHash].join('\\n');\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 151
} | /*#docregion*/
.mdl-layout__header {
display: flex;
position: fixed;
background-color: #222;
}
.nav-link {
padding: 0 1em;
width: 100px;
color: rgba(255,255,255,.6);
text-align: center;
text-decoration: none;
}
.nav-link.router-link-active {
color: rgba(255,255,255, 1);
}
.nav-link.router-link-active::after {
height: 3px;
width: 100%;
display: block;
content: " ";
bottom: 0;
left: 0;
position: inherit;
background: rgb(83,109,254);
}
.mdl-layout__header-row {
height: 56px;
padding: 0 16px 0 72px;
padding-left: 8px;
background-color: #673AB7;
background: #0033FF;
background-color: #222;
}
#reset-button {
position: fixed;
right: 2em;
top: 1em;
}
@media (max-width: 480px) {
#reset-button {
display: none
}
}
@media (max-width: 320px) {
a.nav-link {
font-size: 12px;
}
}
| aio/content/examples/styleguide/src/04-12/app/core/nav/nav.component.css | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.00017504050629213452,
0.00017325120279565454,
0.00017090325127355754,
0.0001733148528728634,
0.0000013631345154863084
] |
{
"id": 1,
"code_window": [
" cssText = stripComments(cssText);\n",
" cssText = this._insertDirectives(cssText);\n",
" return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;\n",
" }\n",
"\n",
" private _insertDirectives(cssText: string): string {\n",
" cssText = this._insertPolyfillDirectivesInCssText(cssText);\n",
" return this._insertPolyfillRulesInCssText(cssText);\n"
],
"labels": [
"keep",
"keep",
"replace",
"keep",
"keep",
"keep",
"keep",
"keep"
],
"after_edit": [
"\n",
" const scopedCssText = this._scopeCssText(cssText, selector, hostSelector);\n",
" return [scopedCssText, ...commentsWithHash].join('\\n');\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 151
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {AsyncTestCompleter, describe, expect, inject, it} from '@angular/core/testing/src/testing_internal';
import {Injector, Metric, MultiMetric} from '../../index';
(function() {
function createMetric(ids: any[]) {
const m = Injector
.create([
ids.map(id => ({provide: id, useValue: new MockMetric(id)})),
MultiMetric.provideWith(ids)
])
.get<MultiMetric>(MultiMetric);
return Promise.resolve(m);
}
describe('multi metric', () => {
it('should merge descriptions', inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
createMetric(['m1', 'm2']).then((m) => {
expect(m.describe()).toEqual({'m1': 'describe', 'm2': 'describe'});
async.done();
});
}));
it('should merge all beginMeasure calls',
inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
createMetric(['m1', 'm2']).then((m) => m.beginMeasure()).then((values) => {
expect(values).toEqual(['m1_beginMeasure', 'm2_beginMeasure']);
async.done();
});
}));
[false, true].forEach((restartFlag) => {
it(`should merge all endMeasure calls for restart=${restartFlag}`,
inject([AsyncTestCompleter], (async: AsyncTestCompleter) => {
createMetric(['m1', 'm2']).then((m) => m.endMeasure(restartFlag)).then((values) => {
expect(values).toEqual(
{'m1': {'restart': restartFlag}, 'm2': {'restart': restartFlag}});
async.done();
});
}));
});
});
})();
class MockMetric extends Metric {
constructor(private _id: string) { super(); }
beginMeasure(): Promise<string> { return Promise.resolve(`${this._id}_beginMeasure`); }
endMeasure(restart: boolean): Promise<{[key: string]: any}> {
const result: {[key: string]: any} = {};
result[this._id] = {'restart': restart};
return Promise.resolve(result);
}
describe(): {[key: string]: string} {
const result: {[key: string]: string} = {};
result[this._id] = 'describe';
return result;
}
}
| packages/benchpress/test/metric/multi_metric_spec.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.0001766214845702052,
0.0001736994308885187,
0.00016890751430764794,
0.00017411765293218195,
0.0000027756334475270705
] |
{
"id": 2,
"code_window": [
"function stripComments(input: string): string {\n",
" return input.replace(_commentRe, '');\n",
"}\n",
"\n",
"// all comments except inline source mapping\n",
"const _sourceMappingUrlRe = /\\/\\*\\s*#\\s*sourceMappingURL=[\\s\\S]+?\\*\\//;\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
"const _commentWithHashRe = /\\/\\*\\s*#\\s*source(Mapping)?URL=[\\s\\S]+?\\*\\//g;\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 546
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* This file is a port of shadowCSS from webcomponents.js to TypeScript.
*
* Please make sure to keep to edits in sync with the source file.
*
* Source:
* https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
*
* The original file level comment is reproduced below
*/
/*
This is a limited shim for ShadowDOM css styling.
https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html#styles
The intention here is to support only the styling features which can be
relatively simply implemented. The goal is to allow users to avoid the
most obvious pitfalls and do so without compromising performance significantly.
For ShadowDOM styling that's not covered here, a set of best practices
can be provided that should allow users to accomplish more complex styling.
The following is a list of specific ShadowDOM styling features and a brief
discussion of the approach used to shim.
Shimmed features:
* :host, :host-context: ShadowDOM allows styling of the shadowRoot's host
element using the :host rule. To shim this feature, the :host styles are
reformatted and prefixed with a given scope name and promoted to a
document level stylesheet.
For example, given a scope name of .foo, a rule like this:
:host {
background: red;
}
}
becomes:
.foo {
background: red;
}
* encapsulation: Styles defined within ShadowDOM, apply only to
dom inside the ShadowDOM. Polymer uses one of two techniques to implement
this feature.
By default, rules are prefixed with the host element tag name
as a descendant selector. This ensures styling does not leak out of the 'top'
of the element's ShadowDOM. For example,
div {
font-weight: bold;
}
becomes:
x-foo div {
font-weight: bold;
}
becomes:
Alternatively, if WebComponents.ShadowCSS.strictStyling is set to true then
selectors are scoped by adding an attribute selector suffix to each
simple selector that contains the host element tag name. Each element
in the element's ShadowDOM template is also given the scope attribute.
Thus, these rules match only elements that have the scope attribute.
For example, given a scope name of x-foo, a rule like this:
div {
font-weight: bold;
}
becomes:
div[x-foo] {
font-weight: bold;
}
Note that elements that are dynamically added to a scope must have the scope
selector added to them manually.
* upper/lower bound encapsulation: Styles which are defined outside a
shadowRoot should not cross the ShadowDOM boundary and should not apply
inside a shadowRoot.
This styling behavior is not emulated. Some possible ways to do this that
were rejected due to complexity and/or performance concerns include: (1) reset
every possible property for every possible selector for a given scope name;
(2) re-implement css in javascript.
As an alternative, users should make sure to use selectors
specific to the scope in which they are working.
* ::distributed: This behavior is not emulated. It's often not necessary
to style the contents of a specific insertion point and instead, descendants
of the host element can be styled selectively. Users can also create an
extra node around an insertion point and style that node's contents
via descendent selectors. For example, with a shadowRoot like this:
<style>
::content(div) {
background: red;
}
</style>
<content></content>
could become:
<style>
/ *@polyfill .content-container div * /
::content(div) {
background: red;
}
</style>
<div class="content-container">
<content></content>
</div>
Note the use of @polyfill in the comment above a ShadowDOM specific style
declaration. This is a directive to the styling shim to use the selector
in comments in lieu of the next selector when running under polyfill.
*/
export class ShadowCss {
strictStyling: boolean = true;
constructor() {}
/*
* Shim some cssText with the given selector. Returns cssText that can
* be included in the document via WebComponents.ShadowCSS.addCssToDocument(css).
*
* When strictStyling is true:
* - selector is the attribute added to all elements inside the host,
* - hostSelector is the attribute added to the host itself.
*/
shimCssText(cssText: string, selector: string, hostSelector: string = ''): string {
const sourceMappingUrl: string = extractSourceMappingUrl(cssText);
cssText = stripComments(cssText);
cssText = this._insertDirectives(cssText);
return this._scopeCssText(cssText, selector, hostSelector) + sourceMappingUrl;
}
private _insertDirectives(cssText: string): string {
cssText = this._insertPolyfillDirectivesInCssText(cssText);
return this._insertPolyfillRulesInCssText(cssText);
}
/*
* Process styles to convert native ShadowDOM rules that will trip
* up the css parser; we rely on decorating the stylesheet with inert rules.
*
* For example, we convert this rule:
*
* polyfill-next-selector { content: ':host menu-item'; }
* ::content menu-item {
*
* to this:
*
* scopeName menu-item {
*
**/
private _insertPolyfillDirectivesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(
_cssContentNextSelectorRe, function(...m: string[]) { return m[2] + '{'; });
}
/*
* Process styles to add rules which will only apply under the polyfill
*
* For example, we convert this rule:
*
* polyfill-rule {
* content: ':host menu-item';
* ...
* }
*
* to this:
*
* scopeName menu-item {...}
*
**/
private _insertPolyfillRulesInCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
return cssText.replace(_cssContentRuleRe, (...m: string[]) => {
const rule = m[0].replace(m[1], '').replace(m[2], '');
return m[4] + rule;
});
}
/* Ensure styles are scoped. Pseudo-scoping takes a rule like:
*
* .foo {... }
*
* and converts this to
*
* scopeName .foo { ... }
*/
private _scopeCssText(cssText: string, scopeSelector: string, hostSelector: string): string {
const unscopedRules = this._extractUnscopedRulesFromCssText(cssText);
// replace :host and :host-context -shadowcsshost and -shadowcsshost respectively
cssText = this._insertPolyfillHostInCssText(cssText);
cssText = this._convertColonHost(cssText);
cssText = this._convertColonHostContext(cssText);
cssText = this._convertShadowDOMSelectors(cssText);
if (scopeSelector) {
cssText = this._scopeSelectors(cssText, scopeSelector, hostSelector);
}
cssText = cssText + '\n' + unscopedRules;
return cssText.trim();
}
/*
* Process styles to add rules which will only apply under the polyfill
* and do not process via CSSOM. (CSSOM is destructive to rules on rare
* occasions, e.g. -webkit-calc on Safari.)
* For example, we convert this rule:
*
* @polyfill-unscoped-rule {
* content: 'menu-item';
* ... }
*
* to this:
*
* menu-item {...}
*
**/
private _extractUnscopedRulesFromCssText(cssText: string): string {
// Difference with webcomponents.js: does not handle comments
let r = '';
let m: RegExpExecArray|null;
_cssContentUnscopedRuleRe.lastIndex = 0;
while ((m = _cssContentUnscopedRuleRe.exec(cssText)) !== null) {
const rule = m[0].replace(m[2], '').replace(m[1], m[4]);
r += rule + '\n\n';
}
return r;
}
/*
* convert a rule like :host(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar
*/
private _convertColonHost(cssText: string): string {
return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer);
}
/*
* convert a rule like :host-context(.foo) > .bar { }
*
* to
*
* .foo<scopeName> > .bar, .foo scopeName > .bar { }
*
* and
*
* :host-context(.foo:host) .bar { ... }
*
* to
*
* .foo<scopeName> .bar { ... }
*/
private _convertColonHostContext(cssText: string): string {
return this._convertColonRule(
cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer);
}
private _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
// m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
return cssText.replace(regExp, function(...m: string[]) {
if (m[2]) {
const parts = m[2].split(',');
const r: string[] = [];
for (let i = 0; i < parts.length; i++) {
const p = parts[i].trim();
if (!p) break;
r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
}
return r.join(',');
} else {
return _polyfillHostNoCombinator + m[3];
}
});
}
private _colonHostContextPartReplacer(host: string, part: string, suffix: string): string {
if (part.indexOf(_polyfillHost) > -1) {
return this._colonHostPartReplacer(host, part, suffix);
} else {
return host + part + suffix + ', ' + part + ' ' + host + suffix;
}
}
private _colonHostPartReplacer(host: string, part: string, suffix: string): string {
return host + part.replace(_polyfillHost, '') + suffix;
}
/*
* Convert combinators like ::shadow and pseudo-elements like ::content
* by replacing with space.
*/
private _convertShadowDOMSelectors(cssText: string): string {
return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
}
// change a selector like 'div' to 'name div'
private _scopeSelectors(cssText: string, scopeSelector: string, hostSelector: string): string {
return processRules(cssText, (rule: CssRule) => {
let selector = rule.selector;
let content = rule.content;
if (rule.selector[0] != '@') {
selector =
this._scopeSelector(rule.selector, scopeSelector, hostSelector, this.strictStyling);
} else if (
rule.selector.startsWith('@media') || rule.selector.startsWith('@supports') ||
rule.selector.startsWith('@page') || rule.selector.startsWith('@document')) {
content = this._scopeSelectors(rule.content, scopeSelector, hostSelector);
}
return new CssRule(selector, content);
});
}
private _scopeSelector(
selector: string, scopeSelector: string, hostSelector: string, strict: boolean): string {
return selector.split(',')
.map(part => part.trim().split(_shadowDeepSelectors))
.map((deepParts) => {
const [shallowPart, ...otherParts] = deepParts;
const applyScope = (shallowPart: string) => {
if (this._selectorNeedsScoping(shallowPart, scopeSelector)) {
return strict ?
this._applyStrictSelectorScope(shallowPart, scopeSelector, hostSelector) :
this._applySelectorScope(shallowPart, scopeSelector, hostSelector);
} else {
return shallowPart;
}
};
return [applyScope(shallowPart), ...otherParts].join(' ');
})
.join(', ');
}
private _selectorNeedsScoping(selector: string, scopeSelector: string): boolean {
const re = this._makeScopeMatcher(scopeSelector);
return !re.test(selector);
}
private _makeScopeMatcher(scopeSelector: string): RegExp {
const lre = /\[/g;
const rre = /\]/g;
scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
}
private _applySelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// Difference from webcomponents.js: scopeSelector could not be an array
return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector);
}
// scope via name and [is=name]
private _applySimpleSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
// In Android browser, the lastIndex is not reset when the regex is used in String.replace()
_polyfillHostRe.lastIndex = 0;
if (_polyfillHostRe.test(selector)) {
const replaceBy = this.strictStyling ? `[${hostSelector}]` : scopeSelector;
return selector
.replace(
_polyfillHostNoCombinatorRe,
(hnc, selector) => {
return selector.replace(
/([^:]*)(:*)(.*)/,
(_: string, before: string, colon: string, after: string) => {
return before + replaceBy + colon + after;
});
})
.replace(_polyfillHostRe, replaceBy + ' ');
}
return scopeSelector + ' ' + selector;
}
// return a selector with [name] suffix on each simple selector
// e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name] /** @internal */
private _applyStrictSelectorScope(selector: string, scopeSelector: string, hostSelector: string):
string {
const isRe = /\[is=([^\]]*)\]/g;
scopeSelector = scopeSelector.replace(isRe, (_: string, ...parts: string[]) => parts[0]);
const attrName = '[' + scopeSelector + ']';
const _scopeSelectorPart = (p: string) => {
let scopedP = p.trim();
if (!scopedP) {
return '';
}
if (p.indexOf(_polyfillHostNoCombinator) > -1) {
scopedP = this._applySimpleSelectorScope(p, scopeSelector, hostSelector);
} else {
// remove :host since it should be unnecessary
const t = p.replace(_polyfillHostRe, '');
if (t.length > 0) {
const matches = t.match(/([^:]*)(:*)(.*)/);
if (matches) {
scopedP = matches[1] + attrName + matches[2] + matches[3];
}
}
}
return scopedP;
};
const safeContent = new SafeSelector(selector);
selector = safeContent.content();
let scopedSelector = '';
let startIndex = 0;
let res: RegExpExecArray|null;
const sep = /( |>|\+|~(?!=))\s*/g;
// If a selector appears before :host it should not be shimmed as it
// matches on ancestor elements and not on elements in the host's shadow
// `:host-context(div)` is transformed to
// `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
// the `div` is not part of the component in the 2nd selectors and should not be scoped.
// Historically `component-tag:host` was matching the component so we also want to preserve
// this behavior to avoid breaking legacy apps (it should not match).
// The behavior should be:
// - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
// - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
// `:host-context(tag)`)
const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
// Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
let shouldScope = !hasHost;
while ((res = sep.exec(selector)) !== null) {
const separator = res[1];
const part = selector.slice(startIndex, res.index).trim();
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
scopedSelector += `${scopedPart} ${separator} `;
startIndex = sep.lastIndex;
}
const part = selector.substring(startIndex);
shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
// replace the placeholders with their original values
return safeContent.restore(scopedSelector);
}
private _insertPolyfillHostInCssText(selector: string): string {
return selector.replace(_colonHostContextRe, _polyfillHostContext)
.replace(_colonHostRe, _polyfillHost);
}
}
class SafeSelector {
private placeholders: string[] = [];
private index = 0;
private _content: string;
constructor(selector: string) {
// Replaces attribute selectors with placeholders.
// The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(keep);
this.index++;
return replaceBy;
});
// Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
// WS and "+" would otherwise be interpreted as selector separators.
this._content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
const replaceBy = `__ph-${this.index}__`;
this.placeholders.push(exp);
this.index++;
return pseudo + replaceBy;
});
}
restore(content: string): string {
return content.replace(/__ph-(\d+)__/g, (ph, index) => this.placeholders[+index]);
}
content(): string { return this._content; }
}
const _cssContentNextSelectorRe =
/polyfill-next-selector[^}]*content:[\s]*?(['"])(.*?)\1[;\s]*}([^{]*?){/gim;
const _cssContentRuleRe = /(polyfill-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _cssContentUnscopedRuleRe =
/(polyfill-unscoped-rule)[^}]*(content:[\s]*(['"])(.*?)\3)[;\s]*[^}]*}/gim;
const _polyfillHost = '-shadowcsshost';
// note: :host-context pre-processed to -shadowcsshostcontext.
const _polyfillHostContext = '-shadowcsscontext';
const _parenSuffix = ')(?:\\((' +
'(?:\\([^)(]*\\)|[^)(]*)+?' +
')\\))?([^,{]*)';
const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
const _shadowDOMSelectorsRe = [
/::shadow/g,
/::content/g,
// Deprecated selectors
/\/shadow-deep\//g,
/\/shadow\//g,
];
// The deep combinator is deprecated in the CSS spec
// Support for `>>>`, `deep`, `::ng-deep` is then also deprecated and will be removed in the future.
// see https://github.com/angular/angular/pull/17677
const _shadowDeepSelectors = /(?:>>>)|(?:\/deep\/)|(?:::ng-deep)/g;
const _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$';
const _polyfillHostRe = /-shadowcsshost/gim;
const _colonHostRe = /:host/gim;
const _colonHostContextRe = /:host-context/gim;
const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
function stripComments(input: string): string {
return input.replace(_commentRe, '');
}
// all comments except inline source mapping
const _sourceMappingUrlRe = /\/\*\s*#\s*sourceMappingURL=[\s\S]+?\*\//;
function extractSourceMappingUrl(input: string): string {
const matcher = input.match(_sourceMappingUrlRe);
return matcher ? matcher[0] : '';
}
const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
const _curlyRe = /([{}])/g;
const OPEN_CURLY = '{';
const CLOSE_CURLY = '}';
const BLOCK_PLACEHOLDER = '%BLOCK%';
export class CssRule {
constructor(public selector: string, public content: string) {}
}
export function processRules(input: string, ruleCallback: (rule: CssRule) => CssRule): string {
const inputWithEscapedBlocks = escapeBlocks(input);
let nextBlockIndex = 0;
return inputWithEscapedBlocks.escapedString.replace(_ruleRe, function(...m: string[]) {
const selector = m[2];
let content = '';
let suffix = m[4];
let contentPrefix = '';
if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
contentPrefix = '{';
}
const rule = ruleCallback(new CssRule(selector, content));
return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
});
}
class StringWithEscapedBlocks {
constructor(public escapedString: string, public blocks: string[]) {}
}
function escapeBlocks(input: string): StringWithEscapedBlocks {
const inputParts = input.split(_curlyRe);
const resultParts: string[] = [];
const escapedBlocks: string[] = [];
let bracketCount = 0;
let currentBlockParts: string[] = [];
for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
const part = inputParts[partIndex];
if (part == CLOSE_CURLY) {
bracketCount--;
}
if (bracketCount > 0) {
currentBlockParts.push(part);
} else {
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
currentBlockParts = [];
}
resultParts.push(part);
}
if (part == OPEN_CURLY) {
bracketCount++;
}
}
if (currentBlockParts.length > 0) {
escapedBlocks.push(currentBlockParts.join(''));
resultParts.push(BLOCK_PLACEHOLDER);
}
return new StringWithEscapedBlocks(resultParts.join(''), escapedBlocks);
}
| packages/compiler/src/shadow_css.ts | 1 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.9992243051528931,
0.05471733585000038,
0.0001619980757823214,
0.00018471463408786803,
0.21714837849140167
] |
{
"id": 2,
"code_window": [
"function stripComments(input: string): string {\n",
" return input.replace(_commentRe, '');\n",
"}\n",
"\n",
"// all comments except inline source mapping\n",
"const _sourceMappingUrlRe = /\\/\\*\\s*#\\s*sourceMappingURL=[\\s\\S]+?\\*\\//;\n",
"\n"
],
"labels": [
"keep",
"keep",
"keep",
"keep",
"replace",
"replace",
"keep"
],
"after_edit": [
"const _commentWithHashRe = /\\/\\*\\s*#\\s*source(Mapping)?URL=[\\s\\S]+?\\*\\//g;\n"
],
"file_path": "packages/compiler/src/shadow_css.ts",
"type": "replace",
"edit_start_line_idx": 546
} | /**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
// THIS CODE IS GENERATED - DO NOT MODIFY
// See angular/tools/gulp-tasks/cldr/extract.js
export default [
[
['полн.', 'напл.', 'утро', 'претпл.', 'попл.', 'веч.', 'ноќе'],
[
'полноќ', 'напладне', 'наутро', 'претпл.', 'попл.',
'навечер', 'ноќе'
],
[
'полноќ', 'напладне', 'наутро', 'претпладне',
'попладне', 'навечер', 'по полноќ'
]
],
[
[
'полноќ', 'пладне', 'наутро', 'претпл.', 'попл.',
'навечер', 'по полноќ'
],
[
'полноќ', 'напладне', 'наутро', 'претпл.', 'попл.',
'навечер', 'по полноќ'
],
[
'на полноќ', 'напладне', 'наутро', 'претпладне',
'попладне', 'навечер', 'по полноќ'
]
],
[
'00:00', '12:00', ['04:00', '10:00'], ['10:00', '12:00'], ['12:00', '18:00'],
['18:00', '24:00'], ['00:00', '04:00']
]
];
| packages/common/locales/extra/mk.ts | 0 | https://github.com/angular/angular/commit/5f681f9745077a261c7e316fbcec9415011361ba | [
0.00017556619422975928,
0.00017002956883516163,
0.00016608786245342344,
0.00016838889860082418,
0.000003929080776288174
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.