briyah 1.1.2 → 1.1.4

package/dist-sdk/server/src/library/library.service.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryService = void 0;
+const common_1 = require("@nestjs/common");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const errors_1 = require("../common/errors");
+const REMOTE_TIMEOUT_MS = 10_000;
+let LibraryService = class LibraryService {
+    getLibraryDir() {
+        const dataPath = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'briyah-data');
+        return path.resolve(dataPath, 'common', 'library');
+    }
+    assertSafeName(name) {
+        if (!name || !/^[A-Za-z0-9_.-]+$/.test(name) || name === '.' || name === '..') {
+            throw new errors_1.ValidationError(`Invalid name: ${name}`);
+        }
+    }
+    normalizeBaseUrl(baseUrl) {
+        if (!baseUrl)
+            throw new errors_1.ValidationError('URL is required');
+        const trimmed = baseUrl.trim().replace(/\/+$/, '');
+        if (!/^https?:\/\//i.test(trimmed)) {
+            throw new errors_1.ValidationError('URL must start with http:// or https://');
+        }
+        return trimmed;
+    }
+    listLocalPrompts() {
+        const dir = this.getLibraryDir();
+        if (!fs.existsSync(dir))
+            return [];
+        return fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => ({ name: d.name }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    listLocalFiles(folder) {
+        this.assertSafeName(folder);
+        const folderPath = path.join(this.getLibraryDir(), folder);
+        if (!fs.existsSync(folderPath) || !fs.statSync(folderPath).isDirectory()) {
+            throw new errors_1.NotFoundError(`Library folder ${folder} not found`);
+        }
+        return fs
+            .readdirSync(folderPath, { withFileTypes: true })
+            .filter((d) => d.isFile())
+            .map((d) => ({ name: d.name }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    getLocalFileContent(folder, file) {
+        this.assertSafeName(folder);
+        this.assertSafeName(file);
+        const filePath = path.join(this.getLibraryDir(), folder, file);
+        if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+            throw new errors_1.NotFoundError(`Library file ${folder}/${file} not found`);
+        }
+        return fs.readFileSync(filePath, 'utf8');
+    }
+    async fetchJson(url) {
+        let response;
+        try {
+            response = await fetch(url, { signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS) });
+        }
+        catch (e) {
+            throw new errors_1.RemoteFetchError(`Failed to reach ${url}: ${e?.message ?? 'unknown error'}`);
+        }
+        if (response.status === 404) {
+            throw new errors_1.NotFoundError(`Remote returned 404: ${url}`);
+        }
+        if (!response.ok) {
+            throw new errors_1.RemoteFetchError(`Remote returned ${response.status} ${response.statusText}: ${url}`);
+        }
+        try {
+            return (await response.json());
+        }
+        catch (e) {
+            throw new errors_1.RemoteFetchError(`Remote did not return valid JSON: ${url} (${e?.message ?? 'parse error'})`);
+        }
+    }
+    async listRemotePrompts(baseUrl) {
+        const normalized = this.normalizeBaseUrl(baseUrl);
+        const data = await this.fetchJson(`${normalized}/api/library/prompts`);
+        return Array.isArray(data?.prompts) ? data.prompts : [];
+    }
+    async listRemoteFiles(baseUrl, folder) {
+        this.assertSafeName(folder);
+        const normalized = this.normalizeBaseUrl(baseUrl);
+        const data = await this.fetchJson(`${normalized}/api/library/prompts/${encodeURIComponent(folder)}/files`);
+        return Array.isArray(data?.files) ? data.files : [];
+    }
+    async getRemoteFileContent(baseUrl, folder, file) {
+        this.assertSafeName(folder);
+        this.assertSafeName(file);
+        const normalized = this.normalizeBaseUrl(baseUrl);
+        const data = await this.fetchJson(`${normalized}/api/library/prompts/${encodeURIComponent(folder)}/files/${encodeURIComponent(file)}`);
+        return typeof data?.content === 'string' ? data.content : '';
+    }
+    async copyFromRemote(baseUrl, folder, userPromptsDir) {
+        this.assertSafeName(folder);
+        const normalized = this.normalizeBaseUrl(baseUrl);
+        const target = path.join(userPromptsDir, folder);
+        if (fs.existsSync(target)) {
+            throw new errors_1.OperationFailedError(`Folder ${folder} already exists`);
+        }
+        const files = await this.listRemoteFiles(normalized, folder);
+        if (files.length === 0) {
+            throw new errors_1.NotFoundError(`Library folder ${folder} has no files at ${normalized}`);
+        }
+        const contents = [];
+        for (const f of files) {
+            this.assertSafeName(f.name);
+            contents.push({
+                name: f.name,
+                content: await this.getRemoteFileContent(normalized, folder, f.name),
+            });
+        }
+        fs.mkdirSync(target, { recursive: true });
+        for (const { name, content } of contents) {
+            fs.writeFileSync(path.join(target, name), content);
+        }
+    }
+};
+exports.LibraryService = LibraryService;
+exports.LibraryService = LibraryService = __decorate([
+    (0, common_1.Injectable)()
+], LibraryService);

package/dist-sdk/server/src/room/room.d.ts

@@ -19,7 +19,7 @@ export declare class Room {
     private currentSpeaker;
     private isPublished;
     private isLoading;
-    private onStateChange?;
+    private onStateChangeCallbacks;
     private onError?;
     private currentSituation;
     private onSituationUpdate?;
@@ -66,6 +66,7 @@ export declare class Room {
     isRoomAdjourned(): boolean;
     setArtifacts(artifacts: Artifact[]): void;
     private parseAgentResponse;
+    private static coerceMessageAction;
     private getAgentAiResponse;
     perceive(agent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): void;
     moderate(moderatorAgent: Agent, message: RoomMessage, onResponse: (message: RoomMessage | null) => void): Promise<void>;
@@ -82,7 +83,8 @@ export declare class Room {
     setRoomStoreService(service: any): void;
     saveMessages(messages: RoomMessage[]): void;
     saveMetadata(): string;
-    setOnStateChange(callback: () => void): void;
+    setOnStateChange(key: string, callback: () => void): void;
+    removeOnStateChange(key: string): void;
     notifyStateChange(): void;
     setOnError(callback: (error: Error) => void): void;
     private notifyError;

package/dist-sdk/server/src/room/room.js

@@ -25,7 +25,7 @@ class Room {
     currentSpeaker = null;
     isPublished = false;
     isLoading = false;
-    onStateChange;
+    onStateChangeCallbacks = new Map();
     onError;
     currentSituation = '';
     onSituationUpdate;
@@ -197,6 +197,7 @@ class Room {
         let targets = [];
         let content = response;
         let situation;
+        let normalizedAction;
         if (typeof response !== 'object') {
             needsModeration = true;
             const lines = response.split('\n');
@@ -219,14 +220,21 @@ class Room {
         else if (!response.action) {
             needsModeration = true;
         }
-        else if (response.targets) {
-            targets = response.targets;
-            if (targets.length === 0) {
-                if (response.action === app_types_1.MessageAction.WHISPER) {
-                    needsModeration = true;
-                }
-                if (response.action === app_types_1.MessageAction.RELAY) {
-                    needsModeration = true;
+        else {
+            normalizedAction = Room.coerceMessageAction(response.action);
+            if (!normalizedAction) {
+                logger_1.logger.error(`Agent ${agent.agentNickname} produced message with invalid action "${response.action}"; routing through moderator`);
+                needsModeration = true;
+            }
+            else if (response.targets) {
+                targets = response.targets;
+                if (targets.length === 0) {
+                    if (normalizedAction === app_types_1.MessageAction.WHISPER) {
+                        needsModeration = true;
+                    }
+                    if (normalizedAction === app_types_1.MessageAction.RELAY) {
+                        needsModeration = true;
+                    }
                 }
             }
         }
@@ -234,7 +242,14 @@ class Room {
             return new message_1.RoomMessage(agent.agentNickname, app_types_1.MessageAction.MODERATE, content, [], null, situation);
         }
         situation = response.situation || undefined;
-        return new message_1.RoomMessage(agent.agentNickname, response.action, response.content, targets, response.name, situation);
+        return new message_1.RoomMessage(agent.agentNickname, normalizedAction, response.content, targets, response.name, situation);
+    }
+    static coerceMessageAction(raw) {
+        if (typeof raw !== 'string')
+            return undefined;
+        const lowered = raw.toLowerCase();
+        const values = Object.values(app_types_1.MessageAction);
+        return values.includes(lowered) ? lowered : undefined;
     }
     async getAgentAiResponse(agent, onResponse) {
         let answer = null;
@@ -433,12 +448,15 @@ Recent Message: ${message.getContent()}
         this.notifyStateChange();
         return id;
     }
-    setOnStateChange(callback) {
-        this.onStateChange = callback;
+    setOnStateChange(key, callback) {
+        this.onStateChangeCallbacks.set(key, callback);
+    }
+    removeOnStateChange(key) {
+        this.onStateChangeCallbacks.delete(key);
     }
     notifyStateChange() {
-        if (this.onStateChange) {
-            this.onStateChange();
+        for (const callback of this.onStateChangeCallbacks.values()) {
+            callback();
         }
     }
     setOnError(callback) {
@@ -751,10 +769,15 @@ Recent Message: ${message.getContent()}
         }
         this.addRoomMessage(nextMessage);
         this.setCurrentSpeaker(nextMessage.targets[0]);
-        let agentsRemaining = this.agents.length;
+        let agentsInProgress = this.agents.length;
+        if (agentsInProgress === 0) {
+            this.processingInProgress = false;
+            this.notifyStateChange();
+            return;
+        }
         for (const agent of this.agents) {
             this.perceive(agent, nextMessage, (message) => {
-                agentsRemaining--;
+                agentsInProgress--;
                 if (message !== null) {
                     if (message.action === app_types_1.MessageAction.THINK) {
                         this.addRoomMessage(message);
@@ -766,7 +789,7 @@ Recent Message: ${message.getContent()}
                         this.pendingMessages = [...this.pendingMessages, message];
                     }
                 }
-                if (agentsRemaining === 0) {
+                if (agentsInProgress === 0) {
                     this.processingInProgress = false;
                     this.notifyStateChange();
                     if (this.pendingMessages && this.pendingMessages.length > 0) {
@@ -775,8 +798,6 @@ Recent Message: ${message.getContent()}
                 }
             });
         }
-        this.processingInProgress = false;
-        this.notifyStateChange();
     }
     filterConcurrentMessages(messages) {
         if (messages.length == 0)

package/dist-sdk/server/src/sdk/briyah.d.ts

@@ -19,6 +19,7 @@ export declare class Briyah {
     private validateEnvironment;
     private initializeSingletons;
     init(): Promise<void>;
+    private static readonly ALWAYS_REFRESH_FILES;
     private seedCommonData;
     getAppService(userId: string): AppService;
     removeUserService(userId: string): void;

package/dist-sdk/server/src/sdk/briyah.js

@@ -128,6 +128,9 @@ class Briyah {
         this.userServiceManager.onModuleInit();
         this.initialized = true;
     }
+    static ALWAYS_REFRESH_FILES = [
+        'config/model_prices.json',
+    ];
     seedCommonData() {
         const dataPath = this.configService.get('BRIYAH_DATA_PATH') || path.resolve(process.cwd(), 'briyah-data');
         const userCommonDir = path.resolve(dataPath, 'common');
@@ -143,6 +146,14 @@ class Briyah {
             fs.mkdirSync(target, { recursive: true });
             fs.cpSync(source, target, { recursive: true, force: false, errorOnExist: false });
         }
+        for (const relPath of Briyah.ALWAYS_REFRESH_FILES) {
+            const source = path.resolve(packageCommonDir, relPath);
+            const target = path.resolve(userCommonDir, relPath);
+            if (!fs.existsSync(source))
+                continue;
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.copyFileSync(source, target);
+        }
     }
     getAppService(userId) {
         if (!this.initialized) {

package/dist-sdk/server/src/shared/shared.module.js

@@ -17,6 +17,7 @@ const agent_store_module_1 = require("../ai/agent-store.module");
 const room_message_module_1 = require("../room/room-message.module");
 const story_store_module_1 = require("../story/story-store.module");
 const balance_module_1 = require("../app/balance.module");
+const library_service_1 = require("../library/library.service");
 let SharedModule = class SharedModule {
 };
 exports.SharedModule = SharedModule;
@@ -35,12 +36,14 @@ exports.SharedModule = SharedModule = __decorate([
             published_rooms_service_1.PublishedRoomsService,
             user_service_manager_1.UserServiceManager,
             user_service_factory_1.UserServiceFactory,
+            library_service_1.LibraryService,
         ],
         exports: [
             published_agents_service_1.PublishedAgentsService,
             published_rooms_service_1.PublishedRoomsService,
             user_service_manager_1.UserServiceManager,
             user_service_factory_1.UserServiceFactory,
+            library_service_1.LibraryService,
         ],
     })
 ], SharedModule);

package/dist-sdk/server/src/story/story.service.js

@@ -231,7 +231,7 @@ let StoryService = class StoryService {
         await this.roomStore.loadRoomsFromDirectory(roomsDir);
         room = await this.roomStore.getRoom(story.roomId);
         if (room) {
-            room.setOnStateChange(() => {
+            room.setOnStateChange('story', () => {
                 this.emitStoryStateUpdate(storyId);
             });
             room.setOnError((error) => {
@@ -400,7 +400,7 @@ let StoryService = class StoryService {
             if (userAgent) {
                 room.setCurrentSpeaker(userAgent.agentNickname);
             }
-            room.setOnStateChange(() => {
+            room.setOnStateChange('story', () => {
                 this.emitStoryStateUpdate(storyInfo.id);
             });
             room.setOnError((error) => {

package/dist-sdk/shared/types/app.types.d.ts

@@ -141,6 +141,28 @@ export interface UpdatePromptFileRequest {
     content: string;
     fileType: 'prompt' | 'json';
 }
+export interface LibraryPrompt {
+    name: string;
+}
+export interface LibraryPromptsResponse {
+    prompts: LibraryPrompt[];
+}
+export interface LibraryFile {
+    name: string;
+}
+export interface LibraryFilesResponse {
+    files: LibraryFile[];
+}
+export interface LibraryFileContent {
+    content: string;
+}
+export interface LibraryDefaultUrlResponse {
+    url: string;
+}
+export interface CopyFromLibraryRequest {
+    url: string;
+    folder: string;
+}
 export interface ProcessTextResponse {
     result: string;
     latestMessage?: string;

package/docs/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJx1jc0KwjAQhN9lzqkliq3sO3jxWnoI7dYG0wSy8VTy7hL/KIKngZ1v51sRQ0gC6hrd9gqRJ8dDssELaEWj2xLeLAzCmUXMlaFws34E7Y+Nwj06EKxPHCczsNRvajenxUFhcEYEhCRjVd6qL1rK2boxsgd1Wh90nxVKbpyXEJZfr96fPt7nOku9wf6KX4ec8wMBuFA6"
+window.hierarchyData = "eJx1jc0KgzAQhN9lzrGa0ErJO/TSq3gIutbQmEA2niTvXtI/pNDTwM63822IISSG7lrV9AKRJkdDssEz9IZWNSW8WQgaF2I2N4LA3foRWp1agTU6aFifKE5mIK7f1GFOi4PA4AwzNBKPVXmrvmgpZ+vGSB66k/Io+yxQcue8hrD8eqU6f7zPdeJ6h/0Vvw455wf4B1Aw"

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "eJytnWuT2ziypv9L+WtFn0ICuvU3d7fntHf74mh7ztmzjokJlsRScS2RCpKyu6Zj/vsGAFICki/JpFjfHC4wEyJf4pJPIvnXXVl8q+6+//zX3Zcs3919v76/y5Njevf93a9pVSX79O22zor87v7uXB7uvr9L8/Ox+o/ob98918fD3f3d9pBUVVrdfX939+/71p5aXgy+/el//f73P34bNfUm2f2/4lzmscn7u1NSpnnd6Rn09e7/vPvx75/ejftK/0y35zqd4+vX339698dbibNjsUvLZJ63D3//4Zf3H38ed3Y6Px6y6nmOrz/e/fL2f8Y9lekheZnt558f3//y7rdPQnf/rLKDtT/D68eff/+7wF31XJzn+fnw7u3/Fvg5pcmXWX7+5+Ond78KHL1UdXqc4+nTz+9/E/yi+jnLZ/2i//75/ccP7/4Y9/TtOatOaTndF13Hu7d7ryfvqrHzH+5/B0e4haKLjW2RV3V53tZFOWDpTdwMd9l3J+jqA5mLn8T+8Tf77wEvrlHuG93sI9t+yUV+rg1v8ZV9TMuv2XbYT1ZdGt3i43Aovn1Mk3L7POjFNqvaZrf4KevsKdnWkl/UNJ33u6oqq+pkULtvwka3+KjrZPuc7t62HR701TROgsYzfP4tO6Qif09Nwxt8PSaHJN+mgkfWtJz1xB7TfZa/b4aAcHGF/Nm2WdT2Bo/bIn/K9oKf5xvO+nXbMk3qdPd2UI9No+RGPe7Saltmp7GbFze7xU9WJY+H9Af/0H98TrdfBv355o1Gtk3z2/3+mpRfzieBx2Pb8AZfT+fD4ccir9M/69FXzbbd+rYz3rbnrKqL8mXI0bXJDfaz3ZBp99dbrFb2LpXF4ZDufnj5+XxMBrWXVdtL88eX56b5TX4/+JV8OvyzqlPQ7AY/XkN/+O1JrxvfanATM+Llz5/9s23WZIN6OyZ/Nko4Xlvf5vX3c30615+KL2k+5rJwTeu26S3+il16GFufuUa3r5mKU5on2ZCDS4tbrH/L0/KPoji+H1Sda1YWxfHWt+pUFsdT/aOdwD99+mXIlW+5tS3r+jDH29+Kwy4dXKD7dk9tuxs8lWlSFXmW7989PRXl4Fx4aZq2TW/w10zZY5prmt2uOvsyJvv0p2zw/jWtdtmNd89vUYVLJN949hqpTo+nQ1KnrtGw6tumbudzq/Lrok4OPxbVoDZco61vdKuP97lo4HNts3zmyOesjK9bXLM5qxZnQDqmu8bzR/Wvqd2xf6yLcvAd882qppnMDz2YayQi2e0+FT8W+de0rBIr6J/HF0zJblcX2+CaqSuouAduS9Xu9sY3X8m15c3efiq25+NwCKbxtru2vMHbNsn/SKtTkQ++4tskLy+tbvFSHE8jt+7a5Ab7u/SQNmPV8A7INkv2N9+tXSpVgm85TwlPWZ5Vz6O/yjeb8av2ae4C8e+PyX7wXW4bZk3Dm3zVb6eET/ZpfXsEhXv+W1Eek7pOd5LV9j6tn9r2k9fb3PMfyTehzzL5Ns9bO/Wnuw9u3Ta4Tbq0PbVtb/CYF3X29PKxTur0x+ckH9aQb1zZxtu28Q0+T2VqGwp+Y9tyzi+skq/DC0n/91ssp/XvufDWVWltQ+Uz75wNV4zfNdtqzh2ry+zYTNTvn35L093wft02b+bo7Clvm88YyySh+rbt9Gh9AEp+KLOXpBtD9//9KqgkMCViJU2PBgbg7G+JtfDSFwINPdoB2A27RfkyFgkd93w6SX2eTrO9uX20fbe6Yy7z5vbRVdPyVm+DUWXuUBRZHvV5iYU5hVZC55fQmFszVPN6keVZdyAJHTYNbrJdvc+zOksO2b/A8BE5qbKo5S3eyvRYfE3/XqWl5D761ucqLefdv+r5XO+Kb909fegsaCT00R2iJPqM2rzi4NW1O2Ekizve/zLIffvGr+Hz7eEwyW1y6I/VDXsOH6iNRHbc2v98lUd2MSR6Rq4v/Vv3D2m+y/J9s/gd8JXsdiff9nhpe5NH+2eROxuofT1f3Tmmz1n/HDPorSwzsAgNnLQNptt2bO5tmOHwa1KDxIBAGfaKKNXh2Fxxg/dDmpTCO+nazr6XTbigbxt/ddcEDMZ28eO+ht/Yxk/pG93iw5LdRx8Aqd7no958cz/9Z/nNfp+yfCe4i7bZrHtoB1rb1x+LMwiFXB3ZAda22zbtbvc0pMHWy23asx56Ax+xk9F4x4ifH5LKCQ/hicjTY1I58Q0RihFfP/bmOUSexjMdxvycS9vwo00PBNQqdubbVpe2N3n8zyLpzvGRn71vcZN1R8790It2q5Efh83H89hGPAKYE3kZIDhjlgfYfOxCQOdHfP2S1GlVC2eNfVofXPvZM8c+rX/1actFiQOzkddj23Y4OjvicVwZc/TwITlXYw/s1La5yYP98y9pgihz5MU+nUPb7mZPjR7wvr/jr1XD4N5f4NVxsL7NVcerw2Fj+8YRrx+z+pxAGhy5q4Jmt/npZ9yxo3HKPeLpUwOSexItIm8tdB7Jthjx+F9ZlT0eUuGE/NW3njcvPyf57pC+9Yc6BGOXb98cApk1dnlL7/wRD7Hn5kjIK3huJgex52aOmOU5q/xy7pM/QdPnMKv8iq4eOmgz7OdDWWzTqsry/fv8Q1nsy7Qa+olZdbpckOWn6wW3+LZ/bRQ1OJJnlX1dkqDldG/BqZ0+N6MHe4bsj8OkqyM5Sxry6Ca3AS/t32+wnJbbdHjXHjS5wb5/QwRbsKblrF1YmSa7btbF1Uf791ssV+fBJc6lwXTbFs0JhhzbbNZI4/3UyS6pk1E/l2Y3+BHsUKtZO9RKtkOt5u5QK+kOtZq/Q61kO9Rq7g61mrBDrV5lh1qN7lCrGTvUamS/WN28X6zS+pcisfHeYfOHS6ObfIzsnaoZeyeH7t+V5WAI3TH7tGl0o4/LSv/vp93wzOszBNrm57b5rX5Fk7A4K2HEnyR2UAXw8lY/ot1oNXs3WqXS6ESVzo9LVJN2odUr7UIr2S60mrsLrYS70Gr2LrSasAutbt2FcpQ3RKuav70a2Avtifle28GeTOAEJ6V33CXD+egCT+60VU/Qjf+yeiziNuIry3fpn+Oe2mY3+4FZSh03o7PUiJcqzftGvMjPpd3tngZHhNiZaFQY8VcnpY0+jXu7NrzdV3a0ocJjN5u/6y1oOsUfz87+OU0kb3KSP/uGN/uyYEr4Ils4dcu7DFKmZK+zz5i64Y3uBDOFr4EVyi1vQiekKRWnDWnepM+OR7lErc/XUGlW+Z8pGCyrum05ydsiqJvjDiTlT8XFW5bXafmUbNvkTvvHwflSUNih1+aU+g6ul31uM8uRDhKH2bFpebMrviIcciY67T7oDlSWGHAoLTAx5LK3hEC/32mVBIacb3vPQfd7n3gYesg9Ovzf71hcA2DIZXCivN/T2EHAQQcAJA94kp71HnLZdya63+2ko9FDroUDz7zxBp717XcmP/I75LTv2G+/30mnf4dcd8+T9jsVHisddYeOlo54FZ8wHXU+Ub0TD4Ey950JuQ1z+LOEVb+eeUP5RB3ERyaYfiM7TNXp/82ywr0QSmxSNyRyG+iNWHqTOiWS4UCv5JIc6FYkz+6Rk7A7l78OCpHn/TYlcAQWbe7v46V1z8+5drHPZXQC+VMRpx4NeY8OJNfFyClRYUc6h5NHezB+SHnUdXNAuEkEvR7tlnSiubZJDo2undmdj9FR9PEujBxDF7i1va/tKZUO9h307i6zx1XGzySPd8IxMrEIffO50vNWPoytY6Bv2XJG2IU/wuzqUdeDydVSl3KVueazReasTNaYu+qVJLZLt4cst/SpTLa17Fk312yDa2533y0oMOhZUFhA6jSo9DfBd1D271W78MPLe7wJG+3G48vQHlDYlR+fk5P48dsLtpcLZjv2Kvpb6bma6P279MFf+1R6yjbnZfQmm3FvkiaaUe81FDF12I06MHfYBUdoRl3PHHa9kYmP/XWe9NRh11/1asNuuNC00p8wBoZLTav82eNh8S236R/uMdgqStE52aGuNBf6WnnXC2/tSLrLaqn8bNuZ4kvz6lz6ycenYCSHw2MSFNsccu+ubbJZbU7G9dp53fHpBTf1xucavFJn/jwVpV91/xRm2g11wl3itDCYdTfuvD0d9pOtiXDA+1vmvD0strtcMtc5L38lcD5a/UrsvNl0vztmtXBWbvvQxGHSy5Wv1JVJT2E8GCRy3wIVtzQApQZHetIyFrc6kJQgnNQp2xPxTckC/zPvyoSYiDtyODcmcnV5kyibDrymLCesVS3Qnr1Q9S7l+yPvdPbeyJ4ZOxT1h0MP6up6PR2K+nQYolwip5OWwNbta6x/wyorFjG6eufSDrQXZsGFr9ERl5t2a2dcstrrdOiPJN81u6P3u1Q0G7sSZ/YqX+zJX/V6Xfjh5T/TvJQqhPXk8WXfXDynQ/YwTid/fqQf9ljOeHk7qXvpnr3xPHOj3jidtihyyfyvsSYKMkamTQBBzu2rjP4w21fchZl3wel/yq6xObD58gp7xtZ9b1JOj+vMt5/r9qaHH1ZRf5Wn/xEWcZd34jWef3vs8IZb0R5AfL174faKU7pQ1YNl9CWOP5VJXvnMxB9ePiQvx7h29XAn6uvFjy8nf/HccTHokFQUdXzJDOdTA0n79LX4UOP8Q5k+pWU6YY1i/Z+iq27tQna8xAnsLu3/ZidJF/xVTo52c/avbKAe93gXbI7X7ry9hpI/FeKI4uXiy4q9LuZu4g9Z5bfOk5Yn9iq3eX6NBcqlC9Ncz3bpsy3lTn3O5Wy38KNNY75lH3ASdaDZkYp9b6/tZ7r1mp3i+HrFHNeuhvW0h+2qWb/K877uUMXOr3vUV3T+31n9/HFbnETzL+vFt6x+rpprX6E7jv1MvRuXi16tA7feEX/1696TiXdj9n2Ia8SKncdFYmd2wm6OxK7LpvEch3aizeSvYXVpPtfpy+TJNdqHvUoXXAhkmv99e8ls59MGX78Heo3BN1zuit2HC945HXA1QqSI0DWeyQib6jGf0j9Fa/umee2bz3DqdoniVWx7wdyVa1voxKci+9ClyH9T9sRel12vm9uNCZsqaeEVsXOxyHzzmTIr021R7oJtrMS1v6iOLrq9Axbki5MQfPO5iQel42FT98/+qlfaQtuD+V3wIOtGBcjDq3UlRA/TuxOyh7ldkr4JrvHs96CpQSAa9lzruWNe88GlCTGD5or5gQJfbskXhpywkPKX+VqR8xdU3tqEh3w+zp1Uy3P+AX9XZsjzOZd+Yma0A7Y61ASKbJvPx8iNUzlHbtzOBsnWzhSSbNu/Akp2biexZOf4NWCyNXRDZNRe9nqhUXuwHZUdGepAmovK5Y879zWJxPO5bz53PvdWglWMhRNn0a33l4ZB+fbSeZ2ZurjwV81YXIRHoob8Nn+Tn8t7LHZ4dgotvWla9fS47VDfEWt7sqDAY1Pk5drwNke9R3EjL8PJWiMuvmbpt76IWOTl2lDsCD3kTk1C4LBtI3/orQh76Bqy+6a9Zgiq8U73uB879A79i86+Cztg54HelD/o3V4hEs6Y62N2TD+99EQyoWt7Rf0yFL0Uuh57PWK3r/Jrq+xfE1w2ree5PJ/sHvKnPnwNHftrBsvtDbiP3tvohOXgeWrYUv4Ot2cye97hfutv2iuH3mT8MwZep15xDXRk/KUa60Z468MPMP1+6oX2oNmEm57UyYekhqVR+gy/sRed/EX4Z6Ke93Qgzb/+/jUty2yH1569nUjzr0Vw4eyOHIr9Pqz+KenD9ZrZ7ivHs/P9QNpybzfaa8eSmCd053z97Jz7bKEt41Sc61+z/FxPfFDBN+ncdw1rb+p4MXVLZ8P3pNmh9uV7BX+WvxfNNva3M9ztc5Nvmub5uX+7H/Zy2OmnrMb7wD63dXPBFMfsBvbvti9/nLAET7Zfeg+FxPbehG17+9/07rbVF3MoWXaNusQlh5ingelo3EH1o6SOE/dYySs5jXahbwJkPgfnu1EnVVDTst9HNVDSErmIxH0tDjC0egHNJmw/9r3rlj67vnDbkERAv4d+oQ2hjP/AsNWUF7pbF33c9BtJlXTQ+Z5OlHEBXIH/kTK4g667N9jFvcfvcNRMfov9p6kHfl7X7pvmoMDID4z7jX+hjTz+kuEyQu3f5L/lqS/jKDL1ZjjL6NIl3ONf/NJrYF0ct5gw9Rd5VeAJGJh8c22OfwfraO8yOHk84PJyyOm1+Rynh/QrLvmIXLaNZzks9n0xbuiy2A8GuHudhkIZCCtLilkPVZbuMTVWWHpiUek+L2MVaCfVk+5zMlxOelqR5z4fI5VtJ9Zb7vMyVs52uMyryyLq22Fc/jhh3z28Zo0titas1x72Ber6CrwyZ8PlXUfd9C0bmZfBZeOok2tV2DE/Y/VjkavwwccAdmj6xy3lkkijT3fIDL8Z/pRHT+f7FlhpdT7AcWeoB5erbuxCfLMvWWTDd7rTTH6b/Zc3B2aFPutv/JVjzBH9hr430pt63zcS9/akuXB4cJ7QkaEn39OF0ccudj5Yw7LX/3gFy6ldGKlfOdwTSfXKqR0aq1053CNR5crhLrFXcyBD4fpX+YvYN1EwW8MzRdCtvqmiL82e+xnOqIeO8A3inxGAPptGk7Yl06yOLhC7Pb79FkaOpXey6xbf0MEyvqDZK+xU+6yObFpRnwd/XW8Fs/Dvr/ZOXa2J3irfuRtFEfgS6YE767tZEjHEDSfIof94UL/lN2Png3Dv8S8dqVwQ/HlydFJksA1LDn/2o+3hkMMJ7mY5G4lNdjxKP9044nYffuRwyN/otw5HHGHU0HEz8rmvMSfDXzjoehN840Dgtm+46vgbHK0Ejmr8EbUhlxO+pdZ1zl/pvshB+7eJL/OPxRmvBCJ7b5r60ueRzxQNbbSHZH51NKrx6Z/viB2MPIBb4hGxg1GBDYQIwkorQ5MTaid/8EPfG+i1PP65Adj5W3Zq/X0Y36qNdCK82Y5muK+cvvvasxxmTSZGYPpy2ZBVH34ZzGXj/R1+umLHY1EIodvuB+TGHI9/oUvqesp9vvEWd4TTVxXs8ke5WDKRqTeDFcWufZo4eDEng6PXqJOifk7La42En9JqK/DprrrWSdj5q27sgs0RuvRA2AF7zcX/ZPddafRM0Zc/Tpij+z+mFlsb/ZjatWe9rj72h8I7zsaC4ePuyrqtmIKXUdylaz+W6jDqdjtQN4R5HC0ZInE2UC2k626sUMiow+Y7AbvhMiXMcXvRa3QAr8CYwznPLzsczlVd2rMQcu0EF80WUHYpw9KXJc+dX4qwCMbWwU/HvXc1nCQuq6xteqMz29+JN/lyyexbPDxVyRbao05Oab7L8v3H836fVn3wlHlsrqnCa25035+CxHyObBpHHVW2BHKZCSakN0HTW511vpA84G30E8mj7gZ3Eczd+NZB5m6E7SCvEqIjcz7GcZB3Eb0Zd38u89/Ox0ccYuZ+z2Wet41vdGjXZPLBxx0fvGHcAWs3XtpueHPY035Seri/bmQ66XdzXTlIRkT8827e1A12TLjDm9qpoe3ecH9G937jXekopq1N2iTHD8sFNZZrZfxx9NqXPgv4a255EAM9GX0KI53oPILeiqzXv054Ic+l7cvHU5p8GRjtrlbfNFdUlysGfprvao9rl2bfX5+B+3XNRyozjDv1uSgjx+a5a3+R5OD8eAcG8pW527E05XFn40uGwJ1wzTDuULJo4H7Fq4Zx96JlA/cvXzcMduAyjw/Ob4Hzy1Q+Pptxx3hgGB6Rr02mZNiPjjfBeDdc/pn38+ahn7sVDvgC10PDfMfr6OAOHYZPbqQmV/DnCXG0Yx/n4ubeXJri3xD2rm8GcYcldm9l/prWyTyXbgrawmNyXY/Xxjc7xIGejquBsVrg5DhQ4aHjKmh8s8PTUGX1jsfxUuoCl1VvwZaOv5ECLQJnvtaKVJlN63nKtMO58H7appNvZs/I0XxLbAii9reesCK3M+UNxt+0F47+VP5D+joyUo9/tD+S4vyibtHDZqUWxDKu4hLFdpZoE6HcX9Ad/8d9c7Lk+7/u7Het7XP//o6+099t7u7vnrL0sKvuvv/chgu3di3qBu7LJ7n/0TT7r3RbF6Vt7Fv/x8Pd/eeH+8XqO23MP/5x/7m92P3B/Udr4/o/7kJ1d/9ZoQtV50IVXUh3958JXUidCym6UN/df9b3C/qO9DK6UHcu1NGF5u7+s0EeTedCE124uLv/vEAXLjoXLqILl3f3n5fowmXnwmV04eru/vMKXbjqXLiKLlzf3X9eowvXnQvX0YWbu/vPG3ThpnPhJhaA1YOC2lFd8SimHicfrB8goFhByupCQQ2prohUrCJltaH0vTHf6YWKL+4KScVKUlYfCmpJdcWkYjUpqxG1QApWXUGpWFHK6kQt7836u/WKdbsrKhWrSlmtqBX03BWWipWlrF4U1JbqikvF6lJWMwrqS3UFpmKFkdUMQYVRV2EUK4ysZggqjLoKIzZGuUEKj1JgmIoVRlYzBEcq6iqMYoWR1QxBhVFXYRQrjKxmCCqMugqjWGFkNUNL9GJQV2EUK4ysZgiOXNRVGMUKI6sZggqjrsIoVhhZzRBUGHUVRrHCtNWMhgrTXYXpWGHaakare6O+o0V8bVdgOhaYtpLRBGezrsA0mwjdTKjRWKDBXBgLTFvJaCgw3RWYjgWmrWQ0nBJ1V2A6Fpi2ktFL+Ju7AtOxwLSVjIYC012B6Vhg2kpGQ4HprsB0LDBtJaOhwHRXYDoWmLGSMVBgpiswEwvMWM0YhZ6z6SrMxAozVjMGKsx0FWZihRmrGaNht7sKM2y55dZbeMEFVlyxwozVjIEKM12FmVhhxmrGwIWX6SrMxAozVjNmBV5n0xWYiQVmrGTM+t7Qd8s1e1JdgZlYYMZKxkCBma7ATCywhZXM4gF5XnQFtogFtrCSWcA5ctEV2CIW2MJKZgHnyEVXYItYYAsrmQUU2KIrsEUssIWVzMIgaS+6AluwNb1b1ONVPVjWxwJbWMksoMAWXYEtYoEtrGYWcBW26CpsEStsYTWzgEPYoquwRaywhdXMAips0VXYIlbY0mpmCYewZVdhy1hhS6uZJVTYsquwZaywpdXMEips2VXYMlbY0mpmCRW27CpsGStsaTWzhEPYsquwZaywpdXMEq7Cll2FLdnO0W0d8d4RbB5jhS2tZpZwklx2FbaMFba0mlmuYbe7ClvGCltazSyhwpZdhS1jha2sZlZQYauuwlaxwlZWMyuosFVXYatYYSurmRVU2KqrsFWssFX/TnLVVdgqVtjKamYF5bnqKmwVK2xlNbOC8lx1FbaKFbaymlnBAXDVVdiKxSdcgALKcwVCFLHCVlYzKxze6CpsFStsZTWzggPgqquwVaywtVMYlOe6q7B1rLC11cwaynPdVdg6VtjaamYN5bnuKmwdK2xtNbOG8lx3FbaOFbY2vfJcdxW2jhW2tppZQ3muuwpbxwpbW82soTzXXYWtY4WtrWbWUJ7rrsLWLAq27v/NIBAWK2xtNbOG2l53FbaOFbaxmllDbW+6CtvECts4hUFtb7oK28QK2ziF4RBeV2GbWGEbq5kN1Pamq7BNrLCN1cwGanvTVdgmVtjGamYDtb3pKmwTK2xjNbOBIZZNV2GbWGEbq5kNlOemq7BNrLCN1cwGynPTVdiGxVpdsBUqbAPCrTzeakWzgRLzf4svD/6vud7qZoMDeQ8g6PrAoq4PVjobHMt7AHHXBxZ4fXDz5UNPxBjEXh9Y8PXBjWgPOGr8AOKvDywA++AisA84cvwAYrAPLAj74KKwD3Bc9H/kBlgg9sFFYh9wBPkBxGIfWDD2wY1wD1CA/o/cAAvIPriI7AMUof8jN8Bk2MT9sQ5R5L8T+nex/wcsRBj9Z0L08f8HrEREADgC8Aygh10gCsAxgOcAffwCKJGjAM8CehgGogEcB3geoLASERHgSMAzgR6WgagAxwKeCyisREQGOBrwbEBhJSI6wPCAchF/pbASASFQDBEo8hQKKxFQAsUwgXKRf9XDNwApUAwVKBf9V5hxKEALFMMFyhEAhTmHAsRAMWSgHAVQmHUoQA0UwwbKkQA4FSvADRQDB8qxALxbVgAdKMYOlMMBivCLAPCBYvxAOSSgMHJRACEoxhCUwwIKYxcFMIJiHEE5NqAIvwiAJSgGE5T2QBS/CIAnKAYUlPYyxC8CYAqKQQWlvQzxiwC4gmJgQTlWoDCKUYAtKAYXlOMFSuMXAfAFxQCDcsxAafwiAMagGGRQ2m8+sBIBZ1AMNCjHDhRmMwqwBsVgg3L8QGE+owBvUAw4KMcQlMZKBMxBMeigHEdQmNMowB0UAw/K+KAKViJgD4rBB2X8thcrEfAHxQCEckxBYWajAINQDEIoxxVwIE0BDKEYh1COLSiDlQxYhGIwQjm+oAxWMuARigEJ5RiDwvxHASahGJRQjjMozIAU4BKKgQnlWIPCHEgBNqEYnFCONyjMghTgE4oBCuWYgzJYyYBRKAYp1MLnimAlA06hGKhQi0V/pgpAFYqxCuXwg7JgCSWcACEyXqEcglAWLoGkE4AsFGMWymEIZQET6gEQIuMWyqEIm0Knl98pQ8wAECJjF8rhCLXAyxOALxTjF8ohCYVhkwIIQzGGoRyWUAu8OgAYQzGOoRyaUAuYmKEAylCMZSiHJ9QCKxngDMV4hlr6xCWsZIA0FGMaymEKhQGUAlhDMa6hHKpQGEIpgDYUYxvK4QqFQZQCeEMxvqEcslAYRimAOBRjHMphC4WBlAKYQzHOoRy6UBhKKYA6FGMdakX9+WeAdiiGO5TnHT1LdUA8FEMeylGMnhw2AD0Uox7KgYy+NDYgQwY+lGMZODFLAfShGPtQK69CPKcA/KEY/1AOaeAUKwUIiGIIRDmqATOOFGAgikEQ5bgGzhtSAIMoxkGUQxs4gUcBEqIYClFrGhjNAQ1RDIcoRzhwQowCQEQxIqIc5MA5MQowEcWgiHKcA6aIKEBFFMMiypEOnCWiABhRjIwoBztwrocCbEQxOKI8HcF8WAE+ohggUWs/COKlLWAkikES5bgHvoGAkiiGSZQjHz03EIASxUiJcvCj5wYCVqIYLFEbPwL2pLMCATJgohwDURh1K8BMFIMmauOHQDyPAW6iGDhRjoX0LGcAOlGMnaiNTyXG8yDAJ4rxE+WQiMLkWwGEohhDUQ6LKEy/FcAoinEUclxEYQJOAKQQAynkwIjCFJwASSFGUsiREYVJOAGUQgylkEcpmIYTQCnEUAp5lIKJOAGUQgylkEcpmIoTQCnEUAo5MoKzoQiQFGIkhTxJwWSdAEkhRlLIkxRM1wmQFGIkhTxJwZCcAEkhRlLIkxQMygmQFGIkhTxJwbCcAEkhRlLIkxTMvAmQFGIkhRwYwSCWAEghBlLIgxTMzQmAFGIghTxIweycAEghBlLIgxTMzwmAFGIghTxIwQydAEghBlLIgxTM0QmAFGIghZpDFljJAKQQP2fhQcoGKxkdteBnLTxIwUyd0HGLznkLJ0TM1QkeuWBC9CAFs3VCxy74uQsPUjBeJ3T0gp+98CAF83VCxy/4+QtHRhQG7ISOYPAzGP4QBgbshI5h8HMY/iAGBuyEjmLwsxj+MAYG7ISOYzCWQtof+cFKBCyFGEshh0YIA3YCLIUYSyGHRggDdgIshRhLIYdGCAN2AiyFGEshh0YIA3YCLIUYSyGHRggDdgIshRhLIYdGCAN2AiyFGEshh0YIA3YCLIUYSyGHRggDdgIshRhLIYdGCAN2AiyFGEshh0YIA3YCLIUYSyHjD6D1HOUCSmQshRwaIQzYCbAUYiyFHBohDNgJsBRiLIUcGiEM2AmwFGIshRwaIQzYCbAUYiyFHBshDNgJwBRiMIUcG6GeQ4QAphCDKeTYCPUcJAQwhRhMIcdGqOcwIYApxGAKOTZCmHATgCnEYAo5NkI9hwoBTCEGU2jhj0NiJQKYQgymkGMjhAk3AZhCDKaQYyPUc8AQwBRiMIUcHKGeQ4aAphCjKeTgCPUcNAQ0hRhNIQdHCBNuAjSFGE0hB0cIE24CNIUYTSEHRwgTbgI0hRhNIQdHCBNuAjSFGE0hB0cIE24CNIUYTSEHRwgTbgI0hRhNoaU/nIuVCGgKMZpCDo4QJtwEaAoxmkIOjhAm3ARoCjGaQksfxsZKBDSFGE0hB0cIE24CNIUYTSEHRwgTagI0hRhNIQdHCBNqAjSFGE0hB0cIE2oCNIUYTSEHRwgTagI0hRhNIUdHCBNqAjiFGE4hR0cIE2oCOIUYTqGVPyrec+gaKJHxFHJ8hDChJgBUiAEV8kAFH10kQFSIERVygIQWWImAqBAjKrRa9+deEUAqxJAKOUZC+AwkAahCDKqQgySEz0ESoCrEqAo5SkL4LCQBrEIMq5CjJLTAUgZYhRhWIYdJCJ+JJMBViHEVcpyE8LlIAmCFGFihtS9cgKUM0AoxtEIOlRBG1ATYCjG2QmuvRCxlAFeIwRVae7aHpQzgCjG4Qo6VEEbUBOAKMbhCjpYQRtQE8AoxvEIOlxBG1AT4CjG+Qo6XEEbUBAALMcBCjpfQEisRABZigIUcLyGMaAkAFmKAhRwvIczICAAWYoCFNr6MBlYiICzECAs5YEIYMhEgLMQICzlgQhgyESAsxAgLOWBCGDIRICzECIt2wIQwJNKAsGhGWLQDJoQhkQaERTPCoh0wIQyJNCAsmhEW7QkLZtUaEBbNCIt2wIQwZdKAsGhGWLQDJoQpkwaERTPCoh0xIUyZNEAsmiEW/bDqTVfQgLBoRlj0gxcixMUaEBbNCIt+8ELEtTcAYdGMsGhPWHqeIiAsmhEW7YAJYcylAWHRjLBoB0wIYyoNCItmhEU7YkIYU2mAWDRDLNoRE8KYSgPEohli0Wox8BgBYtEMsWhHTAhzLg0Qi2aIRTtiQphzaYBYNEMsWvkKQ/hdAohFM8SiHTEhzKk0QCyaIRbta1lhTqUBYtEMsWhfzwpzKg0Qi2aIRfuaVphTaYBYNEMs2te1wpxKA8SiGWLRvrYV5lQaIBbNEIv29a0wp9IAsWiGWLSvcYU5lQaIRTPEomlgSASERTPCoh0wwTWjAF/RjK9oh0v6ykYBFfJyV3poPEQVr3jJK49XMKfTqOwVr3vl8QrmdBqVvurUvvIqxG8iLH/FVOjxCuZ0GpXA4jWwPF7ZwLxqjcpg8TpYvhCW5XTIAFAhr4Xli2FhTqdROSxeD8sXxHrAQkIlsXhNLF8UC3M6jcpiMbyija+8BhORNMArmuEV7WiJxpxOA7yiGV7RjpZozOk0wCua4RXtaInGnE4DvKIZXtGOlmjM6TTAK5rhFe1oicacTgO8ohle0Y6WaIWVCPCKZnhFN2dV8LsA8IpmeEX7syr4jIEGeEUzvKL9WRV8xkADvKIZXtGLgSMCGuAVzfCK9mdVcIa/BnhFM7yiHS3RGHZqgFc0wyva4xU8KwG6ohld0Q6WaAxLNaArmtEV7Y+q9MwrgK5oRlf0wgsRjyeArmhGV7SDJRrTVg3oimZ0RS/8zNxT2xAIkdEVvfDJ2bi+IaArmtEV7WCJxrRVA7qiGV3RS1+QEo8ngK5oRlf00gsRjyeArmhGV7SDJX33ANAVzeiKdrAEJghrwFY0YyvaoRKcIKwBWtEMrWhHSnCCsAZkRTOyoh0o0Zg2a0BWNCMr2p9T6XmRAFnRjKzopV8hwhx5DciKZmRFO1CiMa7WgKxoRla0P6fSM6IDsqIZWdErGvgJgKxoRla0AyUaA3MNyIpmZEWvzMDiBJAVzciKdqAEH1TQAKxoBlb0ajkgAwBWNAMrerUauoeoYCoTouMkGucMaABWNAMr2p9VwTkDGoAVzcCK9qdVcM6ABmBFM7Ci/XEVnDOgAVjRDKzotRdiT91YIEQGVrQHKz07BQBWNAMr2nESTT0GgBAZWNGOk+D9JsAqmmEV7ShJT6VhQFU0oyp6vRrQMaAqmlEV7SCJ7qnQDKiKZlRFO0iicdKEBlRFM6qiN/7QFB4PAVXRjKrojRp4hoCqaEZV9IZ6nyFgKpoxFb0ZimQDpqIZU9EOkWic9aEBU9GMqWh/aAUfG9KAqWjGVLRDJHhVAIiKZkRFO0Cie2peA6KiGVHRG69CPJYBoqIZUdGbzcA+CxAVzYiK8WdW8CFgA4iKYUTFOECi9fLeLL/TizUzAKpJM6JiHCDROO/FAKJiGFExD75qORxNDSAqhhEV48+sYCEbQFQMIyrGARKNE2cMICqGERXjAInuK+cNKkwzomIcIdE4ccYApGIYUjH+0Ao+g2sAUjEMqRh/aAWewTWAqBhGVIwDJBpn7hhAVAwjKsYBEt1TWxwQFcOIinGARPfUFwdExTCiYhwg0T01xgFRMYyoGGX6BmQDeIphPMU4PKJ7ypQDnmIYTzHKyxC/ioCnGMZTjPIyxK8i4CmG8RTj8IjuqVkOeIphPMWogcIOBvAUw3iKcXhE48whA3iKYTzFkOoPwhrAUwzjKcbhEY0zhwzgKYbxFOOPrOCzmAbwFMN4iqHezbIBNMUwmmKof7NsAEwxDKYY6t8sG8BSDGMpxrERjTOnDIAphsEU42EKzpwyAKcYhlOMxyk4c8oAnmIYTzH++yE4c8oAnmIYTzG+9FfPvA54imE8xfgPifTM64CnGMZTjP+YCM7dMoCnGMZTjC/91fcTgA4ZTzH+oyJ9PwEIkfEU43kKzh4zgKcYxlOM5yk4e8wAnmIYTzGep+DsMQN4imE8xXiegrPHDOAphn9npOEp+Hsf6FMj/Fsj/mMjcDBBHxvhXxvxnxvBgwn63gj/4IhjIz2DCfrkSOebI25OxtlzBn52hKnQsxScPWfQp0f4t0c8S8HZcwZ9foR/f8SzlJ4XCX2DhH+ExKwHXiT0HRL+IRLjVdjz6RagQsZSjEMjGufvGcBSDGMpxh9VwctbgFIMQynGoxSc/2cASjEMpZiF7l3bAZJiGEkxnqTg9EEDSIphJMUsvAzxUARIimEkxXiSgtMHDSAphpEU40kKTh80gKQYRlKMJyk4fdAAkmIYSTGepOD0QQNIimEkxXiSgtMHDSAphpEU40kKTh80gKQYRlKMJyk4+88AktL+n/vS59e0rNPde//Fz8+f79ovQP9198/mM6CWuDpP9ougtm7b93/9+/7OwtXv//r3v69fAHX/3Tpxf7Nek93uMTkk+TaNbK4eApsbIzV1SvNdlu+PaVUl+8jienk1uN5I7ZWFbdE1troa2zzcYKyKrK0Da0pqrS62hX06VWIfyLP/8Gto9vqx17/uFiQ0+/+Kcxk/3eA5yGzs3edeAwtBP5SwH9bG1n/w+2rIBj4vlrT0vu+bb0Ff7diEnasdrafYiR6cjedfDa0n3J8sfyqie7Q0wU1aTbDUCqq8fFI5tBr0zxZQElt1F0XveGBI+DY6O9n2S8fWIhwu/NW2vpvYKHsG6/AZCM1kx2KXHuJ7FXZrpf2VNmQlM1il5deMDWLBkKOW7Q81rWXhIHQ4FN+qNCm3z/EAGfa2tb2QmTx23qzwx9t1kMjM6QR/dDgbbIQvV1lmX+MRNrCyET7Uss6ekm30w2ze/1UdD8If1hhio8YqfNkflpNMHdM62SV1EhtchgaFz64xiO78OnzZxdaqGgyRNqh6FYQS3reqstbY6B/JQWanrpPtM3qcCx1MaUJpRcbqojs9rcIpbiN8DM7q5b/DLgYj5aJ5123hsulW0Yhuc++vmlFTbkG6u2gnshgstEj4nBt7T9khXshQcCdJNoc9JtsvnZWLTYq+/kqS3bxmFQleDAruGcnGksekSu1ybZeVccc24cqhmbwsKRcZTfdZnuVVXZ47i2gKlE26Hc+Fv7zYxbdvpcOBRfggyuwliaaYcOgUTs/eyLbIn7J9cbK/MdbHOnyuSvjrApvg4YYvhPA5bJP8OU3KeE0SzqdL2Qpnm+T+HY2GzkUwlS5ko8n2OTnVackXhfZ8RPAayB5BYys/H2NTKjQlvE/eVLzcMjqcGGTaagzVWX2IX8xNOJqR8K4/J2WyrVP2YoaSJ/Ft95b4ClWHz9CGySdZY/fLhPdL+gzT7Zdo/XxM6nj9F0pDuMjaHtKk7NuDhvoQbre3xfHE5+dgRbOQvd6NlWbHd93QxlN0uIXcyAILjeHO5KLC0dEW9JQZ6xl+KHi8UgEXeVXEL4LN/L/K1whVUjRTSREPZeHPa2aSdjuzbhYkfit4f6ekA1SR13zZtAgjNItmC2Iz4v0/hHtYa7ksDod09/jyfD4m8XNfhjuolfS5u5jVuUpLtIS0xVqDxy9bkW7LNKlTsHRchIsn4ThxtQVXeJtQClooBWdzl8R7n7BzzVLFxqjlBk9lcTzVT8VhF4+2Kty5kHCB4U3a8Sc2tQpNTfm51hS+g2FEQAtfSmcSDBbrsHvCgfZqC/XPnpUK+idUtbPZL+pN2M0JPzkeOyh8ObT0aZzLMs230X3T4ZtrhNFHb6iuTmnyJRacxaHBhCy7ZXa/fUrqaNq053aDFajQULo9ZHkKFx626nBw52XDaWNw17dkCFcfwj3eLj2kYIQKl7XtGE3C2EVjEsgtXLYJN8yNsWDnGN/FcOf4IH0s3OTjSxzFUOHmgIShPG+2WbLG1sI9mjB8d7HmH/RTWRy7g0y4LSJhsMUbbkbozu0Mh37hIj0y2B3yQ35CwnWsN8mH/HCpvmnCojRJ5uAOhrOIMEDtbfUOqSGVISVVebUts0f/HlZZ3vnpwYMWLmO9yVMnXhA+jktsuV18PbTLMWr/IYyW7dLe0FtwOxbSNyk0ZqXfXUGFcV4SRgR2WZU8HtIm4OM2S/EkFpgU3mRv8ZiUX86neL4IbAl/dfMfLHocDh5aqtDiW34okp3Tu+2c/Y84uBrOPsLpLN1ldWcZtolCd7Jfmub2psVx44cwSG5kokvz6lw270yd1Ok2ORxsXDDuYDiUCwPJ3rD9rQN2w0FdGABN86/F17Qssx2Lf4aDpJbexbKMF2E6BGRa+K45K/XLKV5p6tCScKub/pluz3W8og5ukdDGqSj91ptTDxWOgSSMEtsJ7pBVMbN6CN8oLVOENcSjPRSu8fVDO4YKh/xOENwe1QtegYfG3Er2yj9l+Q4uuYInKXyQT1meVc/dJWEw4i6Ed80tBxh2DaW1Eto5Hw4ulPBn3WUH4UQgM7dP87RM6jQ7svSMZTAqLmWvdGsLAesQEAnDGvs0uufh4L+W6WpvJ89OICyche2X7aSWYD5FGGkQBkJaW3Zqzw5V/GKHi05htLq1B9JXVNg9EoasW3tNiDM9ZjVfxYfJHyQM2TGz7HeHawRh6Lk1GMdgQwYhjCZZQ26wKMoXEJ4MY53CEchZbEy57Yr/ZyeLI0RhJGR0oW17LSOR4WJGuHKzFg9RIke4mVrLuwWTGcJwiDC5wtpCnDVUiRKGzKytIXa7DAampdgkSLejMCRFwoXu1VT/22Y/vxEYFg8yPfw11JwShqf2ab21t9AuAaO7FwZvhaTV2uoGBughgrfiFxeTrHD5YD8IIjXWRyjCWK0whO7NdSP+4d1fyu8YCk6r8GVXwsCqNdYbI1ShhpUwBrpP66eiPCZ1ne7Q4L4M5LsU621fJHFuWfgWKGGQcJ/WDojgfLxQckoY0NunbFOqQq0pYdjNWqlO58dDVj2nzFyYQicMt+3T+uCi5X1kUoVsTAnDbvu0thl+pQ1wd4MO4SZVCeNt+xQ8hHBMF4bZ9ml9Ss4Vv3PhqyWMrllLh6I+HWJoRuFTICFAsrZgKJHCu0/CXFlrrRWIX+agcSl4CCuxVi52bR6Ny/eJexsu7oToJ7RqRdhjOVzlafErXCb5rgn5Zrs0zv8LH7r9atFtJh9f9mlexg9NhSspIS5xlr/BQTAYa5ZiBdhbiTPOVLjY0OJHbw3yCD+FyeUkDAI0tsAehkJ4TkY8MlhzhzThMfPwMShhhLuxNrCkUlHKgXjU6RtfKQw3kTD3gNnjSysVPmIljHY2Nq2wURafis4RCKMz+7Su0pw/lzA+YL/OLrWU1edubkqUbyGMYFtjfmZiC1wVJdoLA7qNtReYAB0moZMwINsa7CSkhVnn9vtaU4wNKTocW438yQZmmaTDkdVMeiYvp7LYl2lVoY5GybLCA06tXReCjq2F46ARj4N1UlqbsaLD920pN5UeT4cmlYItDaNTGsJQtrWYHe1wcDzF3Qtf3aV4lLZTXeWjYI8vp+Tl2MUqUW6vucVyrJwoD1d4EGKf9mYbUZQfJky+aeydyvQptZkVTNxxXo94vP6aVdnjIYVTsoqOqgjpCt/l6DCEq9tUMy080fac5Ds7hboDaHAfEB15EZIab7VBGthquIYX4ghvtVk0Yqvhel4YCwUxUB0mAAt/sd0z+rV8nEET9MgIF13sTEiYtqTuGuS8aR4ztdxk3WbF+2M793dGtUeehBCaL5RtnaZr34WxguxwOFf1dQPIz7eE+UnCxYTjDO7gGN8J2vo3gTnZhJMdL5DMxln/lcXkOSL80jvnro1iNuHEsGifkXCgzPIsElEIyoTIpz3ukO66mgzPPApT7jObLbo7b68ZNXXRPT4SZQAshJarBkDz86/hnK+EGCKrBvNao3Os1L5Awhtaed3E8gtfEOGqMavs482SQ/avOBgR5hKuZYNOVp3KYptWVZbvs7xdQcW3MRSiELv0xJl0BH6bgWjdglZhzD+r3AbVzzcsGkPRiWXh4FD5dVm87gn3BivZvfTRMHDoXIdTlRbG+zuxtchiuBEywt3zIf0an5zVYWhEC3cFh/bcIQ4RRHk3wiT1i0lmKtwLCA8lOFP+jHBsLJyQaSF70Zyx3iNz4axKwmQPaxEdzqFwYCEh3G+MgURUCl80EoJ0a+46UTJ74WJYKuCsCkKTzF64EhaG55m9b1n9XG2LOG/GfpI1MCwb8wPD3XQJ+43WwKL8HYks9nQ2fFeEOQFX06yb4csiRDzOVhzujWya8J0RRlusTRcMii2F74pwl2st2RVCxrQTHnAm4Za0tfWCB63waBxJR/vWpAviMnvh6yJMPLnYA69fmFdOwhOd1l64uWUWw/dkJXxPij2HDDqMhGthAOhQ7PdZvo/z78LsQ+E2trEDjqvqkKRoYaTV55CWLNajo5wwoaE/mx0h2mFGmX2yG3ZM/izO9elc18WXlP3SMG+xzSYW1jOBK5Vw32raikDCHKPGYDf7KTAqe7kaS51dkQ6351o4ccB9/jKqudDuhYVnIlBRCB2WbDHCvcsxO6Y895PCZbwWYtNOVRQdBt21tDvWCo8d6xAJaGHYCm+2w5dcNp00LDg2E1hpFC/MYorJMg8shHEWYdy0A5bD0k1qsWlfyHar+NB0WKt206Pbfyza6MvychCzff3W7VmAzaW4TRuYEQ6VeVFnTz6QvX1OcpZ0GYxIy7asjzCLqzileZJF9zGq6iMzUj+n5XUlaw9OxLvG8MkIkzCKb3ladqPjoSnhtslB/3iXGW4OhTlXzgpP3icTnXiQvaQwnK7D8cwI911NzbXqvLckkI3ZOjwmbIRR21NablNWEEiFkXQlDJacyvSUlDD2FMx4wnVubAye7AzpnRZuD5vIiU2Kjh9quKwXJh8GtnD/wqFTuKFrozndMFs41JEwg87fPJeQV9fRVBNuE4TkHaes6DBip4UbjqspkPmmw4CQFq7sg00mfBbh66+Fa+e+03nhxsi0ofl1O0vIxXPdauIuh/IW5uw0u0y+a9Vh9qURLsGaXWb0ywMrU2w0Vfh8pk+k6nDAImHCZGsUnSMMcZ1q52mS3j1vuDPih2F9EobiyzSJ6wSpEDEoYappmSZVkWf5Pn16YmHoqGYYtSqUPZYy3RblLsCy8c8NN+vCmHSZHpK4HubVhuyFcBb+WdkjQ/HcEUwdUkNFsuvkIVJYzoyE260yPRZf3alVVAwp0K7Ynr2gl1+H5cxIWF3Rpu90E/Vis2EoQli2KTYbZurFpsOYhFh9Vdo5E0nh4XkSHttxlrpT5SI6RypVjasthQBXCHNpLRujyrQ6H+JpLaT+ut1maGG809pj25aQuylh5qk341NiUZwuRBQkLGHqbXaeZ5gkQ8IawNxIeLJeeuNxrqEOR18tHdS6W5EwkV63wRsjzGTwbxHbqUegf8J9ApEgFa5ilTB+EGYWwnVIBACF1arKc96/G6AwQYmElYWrJN6hhJEb4arTmkAHSkJuSMIEmsYWOFEScnYSFlO11mDEKyRzSpgP7o11g10qZHNKGBe1xmDeexiAIGFNNGcMJ76HO0QSisyaG0rdCiVCwihhZY/KlVn8iobrPyPML+quwUMmr5ft+L9qw0zCxS9IsA0XNmp5iU0J36s076u7TmF8goRVVcE6SYdJu1oIhXsOQkYFEYWqQ6c/VciWlTCmX/WcNlThGK6EZwuq3nN3KgTLShh0rfqOfumoQp1sSq8Gj36FeEUJA3IVOKcVUhUlDEJUnVNVIU1RQmxUpbXdIzCgpcJYtxLm5lfgpFIYTlVylRZ5pzqFCmOfSpjt4Uxd0ufPpx2Lxasw+KOEANAb7QlGB7+3jYQrYSJ4uMuIOxm+U8Ls76r3cEi4W1bC7O+q/xiHCschJUzwq0aOXIQEWomH756DEiF+VsJU6Kr3oESInpUQJ1WDGe9hFF0JEy6rGCxSWANBCyMq1XNxjtMsrzaEIns+17w0UFhRTbhvx48tjACopWr3F8L7k/2L1S8PdyvCI5NuxI9+W/DTZBbcLJnv0dH3sM6XFgKKzlkOHa7YjXSgqZP6zDh8yKik6xL4gkR1h4WjtI0zuAE//ZryT6+EoV9h6bLmiGK8Ww0j6boZmY10qkXHKHU4RxphUQB4vElHYXThcejGEk9L7t7B8D0yQn4VHUhqNorAcpjLLt2SwSNJOgx5Gemy8WKq27VwX22k8/pLVadx2byrEeF9cyZ6Su1H5TVlXUJHrsIQplq2eybhvNZOQyCDIDqZIHsC/ZOajk6QCMNnFh8CYho8BWG+XP2c5XG1tajog8wGPFAWSl4tL/kMzU7TtMdTjG4zHITLtbqo2aGmsIKOESJTZ2VbxPXKoiMi7Rd72sMyatNukpeXc1OXUN7lNwi1Zb1nOUz0ig4KtOvidZvxtVFtJ9py0Ze60cK9h/PdLaMYJcUItWMt9eWrhYxu8dD+jPamtgeP9PJyC9t/CLc+PRxKL6NJVfhDrraafD4Y0wxL3Bth6nbfKUYd1i0ywkTrusyOTQezpzxNd+xUSHDLhQTcHqXJz8dHXss5woTC97JT2TAcJR8ur3t75ExfdCsb8vyWtEvollFVOllfvS0W9NDh/TPC1BBvKXzKnRUjhXZJWBnQ2+1lfmG9OxImbZ5PNnzB9/W0js4MysYQ1y+QWRcGFY0wX+pii0dEdAiDjHCBbK1dVnid/LI4gUU2c1uL7GeGd98ID4QEONin1mTHtDjXxyw/17xEaZi6JqREX1NbX85FCaJROOipcN3zNUu/8aMRYSaIFtZt+vacVSdebSNYEgh684/7u1N2somq6d33n//x73//f1FKXts=";
+window.searchData = "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";