diff --git a/backend/_i18n/de.yml b/backend/_i18n/de.yml index 08d48473..f38c16e8 100644 --- a/backend/_i18n/de.yml +++ b/backend/_i18n/de.yml @@ -1,5 +1,22 @@ # translate theme pages +strengths: + title: Unsere Stärken + innovative: Innovativ + research_based: Forschungsbasiert + inclusive: Inclusiv + socially_relevant: Gesellschaftlich relevant + innovative_text: Wir fügen ständig neue Projekte hinzu und gebrauchen neue Methoden für alle unsere Projekte. + research_based_text: Alle Lernpakete basieren auf fundierter wissenschaftlicher Forschung. + inclusive_text: Wir konzentrieren uns darauf, alle Kinder zu erreichen, mit besonderem Augenmerk auf die Geschlechterinklusion und die soziale Inklusion. + socially_relevant_text: Wir suchen Projekte, die zu aktuellen Ereignissen und gesellschaftlichen Themen passen. + summary: We develop innovative workshops and educational resources, and we provide them to students around the globe in collaboration with teachers and volunteers. Our train-the-trainer sessions enable them to bring our hands-on workshops to the students. + main: Wir fügen kontinuierlich neue Projekte und Methoden zu all unseren Projekten hinzu. Für diese Projekte suchen wir immer nach einem gesellschaftlich relevanten Thema. Darüber hinaus stellen wir sicher, dass unser didaktisches Material auf wissenschaftlicher Forschung basiert, und wir achten immer auf Inklusivität. + quote: + text: Du machst etwas Praktisches, du lernst mit Hardware zu arbeiten und du kannst etwas Neues schaffen. + name: Matthias und Bruno + affiliation: 4. Jahr der weiterführenden Schule + curricula_page: title: Unsere Unterrichtsthemen read_more: Lees meer diff --git a/backend/_i18n/en.yml b/backend/_i18n/en.yml index f7778448..1f898c46 100644 --- a/backend/_i18n/en.yml +++ b/backend/_i18n/en.yml @@ -1,5 +1,23 @@ # translate theme pages +strengths: + title: Our strengths + innovative: Innovative + research_based: Research-based + inclusive: Inclusive + socially_relevant: Socially relevant + innovative_text: We continuously add new projects and apply new methodologies in our projects. + research_based_text: All learning materials of Dwengo are based on profound scientific research. + inclusive_text: We target all children, making gender inclusion and accessibility for disadvantaged children a priority. + socially_relevant_text: We look for projects that fit current events and are socially relevant. + summary: We develop innovative workshops and educational resources, and we provide them to students around the globe in collaboration with teachers and volunteers. Our train-the-trainer sessions enable them to bring our hands-on workshops to the students. + main: We continuously add new projects and methodologies to all our projects. For these projects, we always look for a socially relevant theme. Additionally, we ensure that our didactic material is based on scientific research and always keep an eye on inclusivity. + quote: + text: You make something practical, learn how to use the hardware and create something new. + name: Matthias and Bruno + affiliation: Grade 10 + + curricula_page: title: Our teaching topics read_more: Read more diff --git a/backend/_i18n/fr.yml b/backend/_i18n/fr.yml index e3b68924..08a0b1d7 100644 --- a/backend/_i18n/fr.yml +++ b/backend/_i18n/fr.yml @@ -1,5 +1,22 @@ # translate theme pages +strengths: + title: Nos atouts + innovative: Innovatif + research_based: Fondé sur la recherche + inclusive: Inclusif + socially_relevant: Socialement pertinent + innovative_text: On ajoute fréquemment de nouveaux projets et utilise de nouvelles méthodologies dans les projets. + research_based_text: Tout le matériel de cours de Dwengo ASBL est fondé sur la recherche scientifique profonde. + inclusive_text: On se concentre à atteindre tous les enfants avec une attention particulière pour l'égalite de genre et l'inclusion sociale. + socially_relevant_text: Nous recherchons des projects qui s'inscrivent dans l'actualité et les thèmes sociaux. + summary: Nous développons des ateliers innovants et des ressources éducatives, et nous les fournissons aux étudiants du monde entier en collaboration avec les enseignants et les bénévoles.Nos séances de train-Trainer leur permettent d'amener nos ateliers pratiques aux étudiants. + main: Nous ajoutons toujours de nouveaux projets et méthodologies à tous nos projets.Nous recherchons toujours un thème socialement pertinent pour ces projets.De plus, nous nous assurons toujours que notre matériel didactique est basé sur la recherche scientifique et nous gardons également un œil sur l'inclusivité. + quote: + text: Vous faites quelque chose de pratique, vous apprenez à travailler avec du matériel et vous pouvez exécuter quelque chose de nouveau Cre & Euml; + name: Matthias en Bruno + affiliation: 4e milieu + curricula_page: title: Notre sujets d'enseignement read_more: 'Lees meer' diff --git a/backend/_i18n/nl.yml b/backend/_i18n/nl.yml index 05af16fe..1c1482aa 100644 --- a/backend/_i18n/nl.yml +++ b/backend/_i18n/nl.yml @@ -1,5 +1,22 @@ # translate theme pages +strengths: + title: Verrijk je lessen met AI en robotica! + innovative: Innovatief + research_based: Onderzoeksgedreven + inclusive: Inclusief + socially_relevant: Maatschappelijk relevant + innovative_text: We voegen steeds nieuwe projecten en methodieken toe aan onze projecten. + research_based_text: Alle lespakketten van Dwengo vzw zijn gebaseerd op gedegen wetenschappelijk onderzoek. + inclusive_text: We richten ons op alle kinderen en jongeren met een specifieke aandacht voor het evenwicht tussen meisjes en jongens en leerlingen uit kansengroepen. + socially_relevant_text: We zoeken projecten uit die passen binnen de actualiteit en maatschappelijke thema's. + summary: "" + main: Al onze pakketten zijn gebruiksvriendelijk, maatschappelijk relevant, wetenschappelijk onderbouwd, én inclusief. Leerkrachten over de hele wereld gingen hiermee reeds aan de slag. Jij ook? Verken de lesthema's op onze website! + quote: + text: Je maakt iets praktisch, je leert werken met hardware en je kan zelf iets nieuws creëren. + name: Matthias en Bruno + affiliation: 4e middelbaar + curricula_page: title: Onze lesthema's read_more: Lees meer diff --git a/backend/config.ts b/backend/config.ts new file mode 100644 index 00000000..8fd8ec3f --- /dev/null +++ b/backend/config.ts @@ -0,0 +1,10 @@ +// Can be placed in dotenv but found it redundant + +// Import dotenv from "dotenv"; + +// Load .env file +// Dotenv.config(); + +export const DWENGO_API_BASE = 'https://dwengo.org/backend/api'; + +export const FALLBACK_LANG = 'nl'; diff --git a/backend/package.json b/backend/package.json index 096d748d..29c7ecbc 100644 --- a/backend/package.json +++ b/backend/package.json @@ -14,14 +14,15 @@ "test:unit": "vitest" }, "dependencies": { - "@mikro-orm/core": "6.4.6", - "@mikro-orm/postgresql": "6.4.6", + "@mikro-orm/core": "^6.4.6", + "@mikro-orm/postgresql": "^6.4.6", + "@mikro-orm/reflection": "^6.4.6", + "@types/js-yaml": "^4.0.9", + "axios": "^1.8.1", "@mikro-orm/sqlite": "6.4.6", - "@mikro-orm/reflection": "6.4.6", "dotenv": "^16.4.7", "express": "^5.0.1", "uuid": "^11.1.0", - "express": "^5.0.1", "js-yaml": "^4.1.0", "@types/js-yaml": "^4.0.9" }, diff --git a/backend/src/app.ts b/backend/src/app.ts index f0d1b32e..cf50860e 100644 --- a/backend/src/app.ts +++ b/backend/src/app.ts @@ -3,14 +3,16 @@ import { initORM } from './orm.js'; import { EnvVars, getNumericEnvVar } from './util/envvars.js'; import themeRoutes from './routes/themes.js'; +import learningPathRoutes from './routes/learningPaths.js'; +import learningObjectRoutes from './routes/learningObjects.js'; -import studentRouter from './routes/student'; -import groupRouter from './routes/group'; -import assignmentRouter from './routes/assignment'; -import submissionRouter from './routes/submission'; -import classRouter from './routes/class'; -import questionRouter from './routes/question'; -import loginRouter from './routes/login'; +import studentRouter from './routes/student.js'; +import groupRouter from './routes/group.js'; +import assignmentRouter from './routes/assignment.js'; +import submissionRouter from './routes/submission.js'; +import classRouter from './routes/class.js'; +import questionRouter from './routes/question.js'; +import loginRouter from './routes/login.js'; const app: Express = express(); const port: string | number = getNumericEnvVar(EnvVars.Port); @@ -31,6 +33,8 @@ app.use('/question', questionRouter); app.use('/login', loginRouter); app.use('/theme', themeRoutes); +app.use('/learningPath', learningPathRoutes); +app.use('/learningObject', learningObjectRoutes); async function startServer() { await initORM(); diff --git a/backend/src/config.ts b/backend/src/config.ts new file mode 100644 index 00000000..8fd8ec3f --- /dev/null +++ b/backend/src/config.ts @@ -0,0 +1,10 @@ +// Can be placed in dotenv but found it redundant + +// Import dotenv from "dotenv"; + +// Load .env file +// Dotenv.config(); + +export const DWENGO_API_BASE = 'https://dwengo.org/backend/api'; + +export const FALLBACK_LANG = 'nl'; diff --git a/backend/src/controllers/learningObjects.ts b/backend/src/controllers/learningObjects.ts new file mode 100644 index 00000000..4295326a --- /dev/null +++ b/backend/src/controllers/learningObjects.ts @@ -0,0 +1,60 @@ +import { Request, Response } from 'express'; +import { + getLearningObjectById, + getLearningObjectIdsFromPath, + getLearningObjectsFromPath, +} from '../services/learningObjects.js'; +import { FALLBACK_LANG } from '../config.js'; +import { FilteredLearningObject } from '../interfaces/learningPath'; + +export async function getAllLearningObjects( + req: Request, + res: Response +): Promise { + try { + const hruid = req.query.hruid as string; + const full = req.query.full === 'true'; + const language = (req.query.language as string) || FALLBACK_LANG; + + if (!hruid) { + res.status(400).json({ error: 'HRUID query is required.' }); + return; + } + + let learningObjects: FilteredLearningObject[] | string[]; + if (full) { + learningObjects = await getLearningObjectsFromPath(hruid, language); + } else { + learningObjects = await getLearningObjectIdsFromPath( + hruid, + language + ); + } + + res.json(learningObjects); + } catch (error) { + console.error('Error fetching learning objects:', error); + res.status(500).json({ error: 'Internal server error' }); + } +} + +export async function getLearningObject( + req: Request, + res: Response +): Promise { + try { + const { hruid } = req.params; + const language = (req.query.language as string) || FALLBACK_LANG; + + if (!hruid) { + res.status(400).json({ error: 'HRUID parameter is required.' }); + return; + } + + const learningObject = await getLearningObjectById(hruid, language); + res.json(learningObject); + } catch (error) { + console.error('Error fetching learning object:', error); + res.status(500).json({ error: 'Internal server error' }); + } +} diff --git a/backend/src/controllers/learningPaths.ts b/backend/src/controllers/learningPaths.ts new file mode 100644 index 00000000..903451be --- /dev/null +++ b/backend/src/controllers/learningPaths.ts @@ -0,0 +1,62 @@ +import { Request, Response } from 'express'; +import { themes } from '../data/themes.js'; +import { FALLBACK_LANG } from '../config.js'; +import { + fetchLearningPaths, + searchLearningPaths, +} from '../services/learningPaths.js'; +/** + * Fetch learning paths based on query parameters. + */ +export async function getLearningPaths( + req: Request, + res: Response +): Promise { + try { + const hruids = req.query.hruid; + const themeKey = req.query.theme as string; + const searchQuery = req.query.search as string; + const language = (req.query.language as string) || FALLBACK_LANG; + + let hruidList; + + if (hruids) { + hruidList = Array.isArray(hruids) + ? hruids.map(String) + : [String(hruids)]; + } else if (themeKey) { + const theme = themes.find((t) => { + return t.title === themeKey; + }); + if (theme) { + hruidList = theme.hruids; + } else { + res.status(404).json({ + error: `Theme "${themeKey}" not found.`, + }); + return; + } + } else if (searchQuery) { + const searchResults = await searchLearningPaths( + searchQuery, + language + ); + res.json(searchResults); + return; + } else { + hruidList = themes.flatMap((theme) => { + return theme.hruids; + }); + } + + const learningPaths = await fetchLearningPaths( + hruidList, + language, + `HRUIDs: ${hruidList.join(', ')}` + ); + res.json(learningPaths.data); + } catch (error) { + console.error('❌ Unexpected error fetching learning paths:', error); + res.status(500).json({ error: 'Internal server error' }); + } +} diff --git a/backend/src/controllers/themes.ts b/backend/src/controllers/themes.ts index 442eb982..4b59751e 100644 --- a/backend/src/controllers/themes.ts +++ b/backend/src/controllers/themes.ts @@ -1,40 +1,17 @@ -import fs from 'fs'; -import path from 'path'; -import yaml from 'js-yaml'; import { Request, Response } from 'express'; import { themes } from '../data/themes.js'; +import { loadTranslations } from "../util/translationHelper.js"; +import { FALLBACK_LANG } from '../config.js'; interface Translations { curricula_page: { - [key: string]: { title: string; description?: string }; // Optioneel veld description + [key: string]: { title: string; description?: string }; }; } -/** - * Laadt de vertalingen uit een YAML-bestand - */ -function loadTranslations(language: string): Translations { - try { - const filePath = path.join(process.cwd(), '_i18n', `${language}.yml`); - const yamlFile = fs.readFileSync(filePath, 'utf8'); - return yaml.load(yamlFile) as Translations; - } catch (error) { - console.error( - `Kan vertaling niet laden voor ${language}, fallback naar Nederlands` - ); - console.error(error); - const fallbackPath = path.join(process.cwd(), '_i18n', 'nl.yml'); - return yaml.load(fs.readFileSync(fallbackPath, 'utf8')) as Translations; - } -} - -/** - * GET /themes → Haalt de lijst met thema's op inclusief vertalingen - */ export function getThemes(req: Request, res: Response) { const language = (req.query.language as string)?.toLowerCase() || 'nl'; - const translations = loadTranslations(language); - + const translations = loadTranslations(language); const themeList = themes.map((theme) => { return { key: theme.title, @@ -48,9 +25,6 @@ export function getThemes(req: Request, res: Response) { res.json(themeList); } -/** - * GET /themes/:theme → Geeft de HRUIDs terug voor een specifiek thema - */ export function getThemeByTitle(req: Request, res: Response) { const themeKey = req.params.theme; const theme = themes.find((t) => { @@ -60,6 +34,6 @@ export function getThemeByTitle(req: Request, res: Response) { if (theme) { res.json(theme.hruids); } else { - res.status(404).json({ error: 'Thema niet gevonden' }); + res.status(404).json({ error: 'Theme not found' }); } } diff --git a/backend/src/entities/classes/class-join-request.entity.ts b/backend/src/entities/classes/class-join-request.entity.ts index 2f9fc341..0ae38cd1 100644 --- a/backend/src/entities/classes/class-join-request.entity.ts +++ b/backend/src/entities/classes/class-join-request.entity.ts @@ -1,6 +1,6 @@ import { Entity, Enum, ManyToOne } from '@mikro-orm/core'; -import { Student } from '../users/student.entity'; -import { Class } from './class.entity'; +import { Student } from '../users/student.entity.js'; +import { Class } from './class.entity.js'; @Entity() export class ClassJoinRequest { diff --git a/backend/src/entities/questions/answer.entity.ts b/backend/src/entities/questions/answer.entity.ts index 34558612..f0b67a54 100644 --- a/backend/src/entities/questions/answer.entity.ts +++ b/backend/src/entities/questions/answer.entity.ts @@ -1,6 +1,6 @@ import { Entity, ManyToOne, PrimaryKey, Property } from '@mikro-orm/core'; -import { Question } from './question.entity'; -import { Teacher } from '../users/teacher.entity'; +import { Question } from './question.entity.js'; +import { Teacher } from '../users/teacher.entity.js'; @Entity() export class Answer { diff --git a/backend/src/interfaces/learningPath.ts b/backend/src/interfaces/learningPath.ts new file mode 100644 index 00000000..1e2cc6ef --- /dev/null +++ b/backend/src/interfaces/learningPath.ts @@ -0,0 +1,98 @@ +export interface Transition { + default: boolean; + _id: string; + next: { + _id: string; + hruid: string; + version: number; + language: string; + }; +} + +export interface LearningObjectNode { + _id: string; + learningobject_hruid: string; + version: number; + language: string; + start_node?: boolean; + transitions: Transition[]; + created_at: string; + updatedAt: string; +} + +export interface LearningPath { + _id: string; + language: string; + hruid: string; + title: string; + description: string; + image?: string; // Image might be missing, so it's optional + num_nodes: number; + num_nodes_left: number; + nodes: LearningObjectNode[]; + keywords: string; + target_ages: number[]; + min_age: number; + max_age: number; + __order: number; +} + +export interface EducationalGoal { + source: string; + id: string; +} + +export interface ReturnValue { + callback_url: string; + callback_schema: Record; +} + +export interface LearningObjectMetadata { + _id: string; + uuid: string; + hruid: string; + version: number; + language: string; + title: string; + description: string; + difficulty: number; + estimated_time: number; + available: boolean; + teacher_exclusive: boolean; + educational_goals: EducationalGoal[]; + keywords: string[]; + target_ages: number[]; + content_type: string; // Markdown, image, etc. + content_location?: string; + skos_concepts?: string[]; + return_value?: ReturnValue; +} + +export interface FilteredLearningObject { + key: string; + _id: string; + uuid: string; + version: number; + title: string; + htmlUrl: string; + language: string; + difficulty: number; + estimatedTime: number; + available: boolean; + teacherExclusive: boolean; + educationalGoals: EducationalGoal[]; + keywords: string[]; + description: string; + targetAges: number[]; + contentType: string; + contentLocation?: string; + skosConcepts?: string[]; + returnValue?: ReturnValue; +} + +export interface LearningPathResponse { + success: boolean; + source: string; + data: LearningPath[] | null; + message?: string; +} diff --git a/backend/src/mikro-orm.config.ts b/backend/src/mikro-orm.config.ts index d180bce0..5a4bcabf 100644 --- a/backend/src/mikro-orm.config.ts +++ b/backend/src/mikro-orm.config.ts @@ -3,21 +3,45 @@ import { PostgreSqlDriver } from '@mikro-orm/postgresql'; import { EnvVars, getEnvVar, getNumericEnvVar } from './util/envvars.js'; import { SqliteDriver } from '@mikro-orm/sqlite'; -const entities = ['dist/**/*.entity.js']; -const entitiesTs = ['src/**/*.entity.ts']; +// Import alle entity-bestanden handmatig +import { User } from './entities/users/user.entity.js'; +import { Student } from './entities/users/student.entity.js'; +import { Teacher } from './entities/users/teacher.entity.js'; + +import { Assignment } from './entities/assignments/assignment.entity.js'; +import { Group } from './entities/assignments/group.entity.js'; +import { Submission } from './entities/assignments/submission.entity.js'; + +import { Class } from './entities/classes/class.entity.js'; +import { ClassJoinRequest } from './entities/classes/class-join-request.entity.js'; +import { TeacherInvitation } from './entities/classes/teacher-invitation.entity.js'; + +import { Attachment } from './entities/content/attachment.entity.js'; +import { LearningObject } from './entities/content/learning-object.entity.js'; +import { LearningPath } from './entities/content/learning-path.entity.js'; + +import { Answer } from './entities/questions/answer.entity.js'; +import { Question } from './entities/questions/question.entity.js'; + +const entities = [ + User, Student, Teacher, + Assignment, Group, Submission, + Class, ClassJoinRequest, TeacherInvitation, + Attachment, LearningObject, LearningPath, + Answer, Question +]; + function config(testingMode: boolean = false): Options { if (testingMode) { return { driver: SqliteDriver, dbName: getEnvVar(EnvVars.DbName), entities: entities, - entitiesTs: entitiesTs, + // entitiesTs: entitiesTs, // Workaround: vitest: `TypeError: Unknown file extension ".ts"` (ERR_UNKNOWN_FILE_EXTENSION) // (see https://mikro-orm.io/docs/guide/project-setup#testing-the-endpoint) - dynamicImportProvider: (id) => { - return import(id); - }, + dynamicImportProvider: (id) => import(id), }; } return { @@ -28,7 +52,7 @@ function config(testingMode: boolean = false): Options { user: getEnvVar(EnvVars.DbUsername), password: getEnvVar(EnvVars.DbPassword), entities: entities, - entitiesTs: entitiesTs, + //entitiesTs: entitiesTs, debug: true, }; } diff --git a/backend/src/routes/learningObjects.ts b/backend/src/routes/learningObjects.ts new file mode 100644 index 00000000..416602b5 --- /dev/null +++ b/backend/src/routes/learningObjects.ts @@ -0,0 +1,27 @@ +import express from 'express'; +import { + getAllLearningObjects, + getLearningObject, +} from '../controllers/learningObjects.js'; + +const router = express.Router(); + +// DWENGO learning objects + +// Queries: hruid(path), full, language +// Route to fetch list of learning objects based on hruid of learning path + +// Route 1: list of object hruids +// Example 1: http://localhost:3000/learningObject?hruid=un_artificiele_intelligentie + +// Route 2: list of object data +// Example 2: http://localhost:3000/learningObject?full=true&hruid=un_artificiele_intelligentie +router.get('/', getAllLearningObjects); + +// Parameter: hruid of learning object +// Query: language +// Route to fetch data of one learning object based on its hruid +// Example: http://localhost:3000/learningObject/un_ai7 +router.get('/:hruid', getLearningObject); + +export default router; diff --git a/backend/src/routes/learningPaths.ts b/backend/src/routes/learningPaths.ts new file mode 100644 index 00000000..ce580745 --- /dev/null +++ b/backend/src/routes/learningPaths.ts @@ -0,0 +1,27 @@ +import express from 'express'; +import { getLearningPaths } from '../controllers/learningPaths.js'; + +const router = express.Router(); + +// DWENGO learning paths + +// Route 1: no query +// Fetch all learning paths +// Example 1: http://localhost:3000/learningPath + +// Unified route for fetching learning paths +// Route 2: Query: hruid (list), language +// Fetch learning paths based on hruid list +// Example 2: http://localhost:3000/learningPath?hruid=pn_werking&hruid=art1 + +// Query: search, language +// Route to fetch learning paths based on a searchterm +// Example 3: http://localhost:3000/learningPath?search=robot + +// Query: theme, anguage +// Route to fetch learning paths based on a theme +// Example: http://localhost:3000/learningPath?theme=kiks + +router.get('/', getLearningPaths); + +export default router; diff --git a/backend/src/routes/themes.ts b/backend/src/routes/themes.ts index 3185640e..388b3e38 100644 --- a/backend/src/routes/themes.ts +++ b/backend/src/routes/themes.ts @@ -3,7 +3,12 @@ import { getThemes, getThemeByTitle } from '../controllers/themes.js'; const router = express.Router(); +// Query: language +// Route to fetch list of {key, title, description, image} themes in their respective language router.get('/', getThemes); + +// Arg: theme (key) +// Route to fetch list of hruids based on theme router.get('/:theme', getThemeByTitle); export default router; diff --git a/backend/src/services/learningObjects.ts b/backend/src/services/learningObjects.ts new file mode 100644 index 00000000..d1d34ad2 --- /dev/null +++ b/backend/src/services/learningObjects.ts @@ -0,0 +1,134 @@ +import { DWENGO_API_BASE } from '../config.js'; +import { fetchWithLogging } from '../util/apiHelper.js'; +import { + FilteredLearningObject, + LearningObjectMetadata, + LearningObjectNode, + LearningPathResponse, +} from '../interfaces/learningPath.js'; +import { fetchLearningPaths } from './learningPaths.js'; + +function filterData( + data: LearningObjectMetadata, + htmlUrl: string +): FilteredLearningObject { + return { + key: data.hruid, // Hruid learningObject (not path) + _id: data._id, + uuid: data.uuid, + version: data.version, + title: data.title, + htmlUrl, // Url to fetch html content + language: data.language, + difficulty: data.difficulty, + estimatedTime: data.estimated_time, + available: data.available, + teacherExclusive: data.teacher_exclusive, + educationalGoals: data.educational_goals, // List with learningObjects + keywords: data.keywords, // For search + description: data.description, // For search (not an actual description) + targetAges: data.target_ages, + contentType: data.content_type, // Markdown, image, audio, etc. + contentLocation: data.content_location, // If content type extern + skosConcepts: data.skos_concepts, + returnValue: data.return_value, // Callback response information + }; +} + +/** + * Fetches a single learning object by its HRUID + */ +export async function getLearningObjectById( + hruid: string, + language: string +): Promise { + const metadataUrl = `${DWENGO_API_BASE}/learningObject/getMetadata?hruid=${hruid}&language=${language}`; + const metadata = await fetchWithLogging( + metadataUrl, + `Metadata for Learning Object HRUID "${hruid}" (language ${language})` + ); + + if (!metadata) { + console.error(`⚠️ WARNING: Learning object "${hruid}" not found.`); + return null; + } + + const htmlUrl = `${DWENGO_API_BASE}/learningObject/getRaw?hruid=${hruid}&language=${language}`; + return filterData(metadata, htmlUrl); +} + +/** + * Generic function to fetch learning objects (full data or just HRUIDs) + */ +async function fetchLearningObjects( + hruid: string, + full: boolean, + language: string +): Promise { + try { + const learningPathResponse: LearningPathResponse = + await fetchLearningPaths( + [hruid], + language, + `Learning path for HRUID "${hruid}"` + ); + + if ( + !learningPathResponse.success || + !learningPathResponse.data?.length + ) { + console.error( + `⚠️ WARNING: Learning path "${hruid}" exists but contains no learning objects.` + ); + return []; + } + + const nodes: LearningObjectNode[] = learningPathResponse.data[0].nodes; + + if (!full) { + return nodes.map((node) => { + return node.learningobject_hruid; + }); + } + + return await Promise.all( + nodes.map(async (node) => { + return getLearningObjectById( + node.learningobject_hruid, + language + ); + }) + ).then((objects) => { + return objects.filter((obj): obj is FilteredLearningObject => { + return obj !== null; + }); + }); + } catch (error) { + console.error('❌ Error fetching learning objects:', error); + return []; + } +} + +/** + * Fetch full learning object data (metadata) + */ +export async function getLearningObjectsFromPath( + hruid: string, + language: string +): Promise { + return (await fetchLearningObjects( + hruid, + true, + language + )) as FilteredLearningObject[]; +} + +/** + * Fetch only learning object HRUIDs + */ +export async function getLearningObjectIdsFromPath( + hruid: string, + language: string +): Promise { + return (await fetchLearningObjects(hruid, false, language)) as string[]; +} diff --git a/backend/src/services/learningPaths.ts b/backend/src/services/learningPaths.ts new file mode 100644 index 00000000..2a9f15a3 --- /dev/null +++ b/backend/src/services/learningPaths.ts @@ -0,0 +1,61 @@ +import { fetchWithLogging } from '../util/apiHelper.js'; +import { DWENGO_API_BASE } from '../config.js'; +import { + LearningPath, + LearningPathResponse, +} from '../interfaces/learningPath.js'; + +export async function fetchLearningPaths( + hruids: string[], + language: string, + source: string +): Promise { + if (hruids.length === 0) { + return { + success: false, + source, + data: null, + message: `No HRUIDs provided for ${source}.`, + }; + } + + const apiUrl = `${DWENGO_API_BASE}/learningPath/getPathsFromIdList`; + const params = { pathIdList: JSON.stringify({ hruids }), language }; + + const learningPaths = await fetchWithLogging( + apiUrl, + `Learning paths for ${source}`, + params + ); + + if (!learningPaths || learningPaths.length === 0) { + console.error(`⚠️ WARNING: No learning paths found for ${source}.`); + return { + success: false, + source, + data: [], + message: `No learning paths found for ${source}.`, + }; + } + + return { + success: true, + source, + data: learningPaths, + }; +} + +export async function searchLearningPaths( + query: string, + language: string +): Promise { + const apiUrl = `${DWENGO_API_BASE}/learningPath/search`; + const params = { all: query, language }; + + const searchResults = await fetchWithLogging( + apiUrl, + `Search learning paths with query "${query}"`, + params + ); + return searchResults ?? []; +} diff --git a/backend/src/util/apiHelper.ts b/backend/src/util/apiHelper.ts new file mode 100644 index 00000000..76d166c8 --- /dev/null +++ b/backend/src/util/apiHelper.ts @@ -0,0 +1,43 @@ +import axios, { AxiosRequestConfig } from 'axios'; + +// !!!! when logger is done -> change + +/** + * Utility function to fetch data from an API endpoint with error handling. + * Logs errors but does NOT throw exceptions to keep the system running. + * + * @param url The API endpoint to fetch from. + * @param description A short description of what is being fetched (for logging). + * @param params + * @returns The response data if successful, or null if an error occurs. + */ +export async function fetchWithLogging( + url: string, + description: string, + params?: Record +): Promise { + try { + const config: AxiosRequestConfig = params ? { params } : {}; + + const response = await axios.get(url, config); + return response.data; + } catch (error: any) { + if (error.response) { + if (error.response.status === 404) { + console.error( + `❌ ERROR: ${description} not found (404) at "${url}".` + ); + } else { + console.error( + `❌ ERROR: Failed to fetch ${description}. Status: ${error.response.status} - ${error.response.statusText} (URL: "${url}")` + ); + } + } else { + console.error( + `❌ ERROR: Network or unexpected error when fetching ${description}:`, + error.message + ); + } + return null; + } +} diff --git a/backend/src/util/translationHelper.ts b/backend/src/util/translationHelper.ts new file mode 100644 index 00000000..f4443531 --- /dev/null +++ b/backend/src/util/translationHelper.ts @@ -0,0 +1,19 @@ +import fs from 'fs'; +import path from 'path'; +import yaml from 'js-yaml'; +import {FALLBACK_LANG} from "../../config"; + +export function loadTranslations(language: string): T { + try { + const filePath = path.join(process.cwd(), '_i18n', `${language}.yml`); + const yamlFile = fs.readFileSync(filePath, 'utf8'); + return yaml.load(yamlFile) as T; + } catch (error) { + console.error( + `Cannot load translation for ${language}, fallen back to dutch` + ); + console.error(error); + const fallbackPath = path.join(process.cwd(), '_i18n', `${FALLBACK_LANG}.yml`); + return yaml.load(fs.readFileSync(fallbackPath, 'utf8')) as T; + } +} diff --git a/frontend/public/assets/home/inclusive.png b/frontend/public/assets/home/inclusive.png new file mode 100644 index 00000000..0f0215fe Binary files /dev/null and b/frontend/public/assets/home/inclusive.png differ diff --git a/frontend/public/assets/home/innovative.png b/frontend/public/assets/home/innovative.png new file mode 100644 index 00000000..57fada35 Binary files /dev/null and b/frontend/public/assets/home/innovative.png differ diff --git a/frontend/public/assets/home/research_based.png b/frontend/public/assets/home/research_based.png new file mode 100644 index 00000000..a96d18ac Binary files /dev/null and b/frontend/public/assets/home/research_based.png differ diff --git a/frontend/public/assets/home/socially_relevant.png b/frontend/public/assets/home/socially_relevant.png new file mode 100644 index 00000000..cb63c227 Binary files /dev/null and b/frontend/public/assets/home/socially_relevant.png differ diff --git a/frontend/src/components/MenuBar.vue b/frontend/src/components/MenuBar.vue index 1a35a59f..fe2b3563 100644 --- a/frontend/src/components/MenuBar.vue +++ b/frontend/src/components/MenuBar.vue @@ -1,7 +1,186 @@ - + - + diff --git a/frontend/src/main.ts b/frontend/src/main.ts index bc0c3d42..7f6db814 100644 --- a/frontend/src/main.ts +++ b/frontend/src/main.ts @@ -14,6 +14,11 @@ const app = createApp(App); app.use(router); +const link = document.createElement("link"); +link.rel = "stylesheet"; +link.href = "https://cdn.jsdelivr.net/npm/@mdi/font@5.x/css/materialdesignicons.min.css"; +document.head.appendChild(link); + const vuetify = createVuetify({ components, directives, diff --git a/frontend/src/utils/base64ToImage.ts b/frontend/src/utils/base64ToImage.ts new file mode 100644 index 00000000..9ec9ac34 --- /dev/null +++ b/frontend/src/utils/base64ToImage.ts @@ -0,0 +1,20 @@ +/** + * Converts a Base64 string to a valid image source URL. + * + * @param base64String - The "image" field from the learning path JSON response. + * @returns A properly formatted data URL for use in an tag. + * + * @example + * // Fetch the learning path data and extract the image + * const response = await fetch( learning path route ); + * const data = await response.json(); + * const base64String = data.image; + * + * // Use in an element + * Learning Path Image + */ +export function convertBase64ToImageSrc(base64String: string): string { + return base64String.startsWith("data:image") + ? base64String + : `data:image/png;base64,${base64String}`; +} diff --git a/frontend/tests/base64/base64Sample.txt b/frontend/tests/base64/base64Sample.txt new file mode 100644 index 00000000..2d5b7b46 --- /dev/null +++ b/frontend/tests/base64/base64Sample.txt @@ -0,0 +1 @@ +iVBORw0KGgoAAAANSUhEUgAAAfQAAAH0CAYAAADL1t+KAAAmCXpUWHRSYXcgcHJvZmlsZSB0eXBlIGV4aWYAAHjatZxpkhw3koX/4xRzBDh2HAer2dxgjj/fQxY5IkWZmt0ascUqVWVGIuDub3F4tDv/89/X/Rf/dB+KS7m20kvx/JN66mHwTfOff8b723x6f79/bvr6zn78ufv+i8DXyNf4+UUrn6/27edfb/j21Qbf5T9cqK2vX8wff9HT52toP13o64OiVhT4Zn9dqH9dKIbPL+zrAuNzW770Vv94C/N8vn69/7MN/Ov0112h62d5fu3DT/+dKru3M58TQzjRoufvENtnAVH/RhfH+2bw68QLLRa+5xfv5/VrJWzIr/bp+z9dm62lpl++6IeofP/Ofv1z93O0Uvh6Sfxpk8v3r7/8ubP866i8rf/DJ6f2PU3Cj3kVvlb00+6/zb+73XfP3MVIha0uXzf17Vbed7yOcCR9dHMsrfjKv5lL1Pen86eR1YtU2H75yZ9l3QLhupZs27Br531dtlhiCseFyjchrBDfD1usoYcVFb+kP3ZDjT3u2IjlIuyRn4bva7H3sd0v9z6t8cnbeGkwLma85bf/uN99w70qBTPfvu8V6wpBm80yFDn9zcuIiN2vTc1vg7/9+fkfxTUSwaxdVol0NnZ+LjGz/R8SxBfoyAszXz81aHV/XYAt4qMzi7FIBIiaxWzFfA2hmrGRjQANlh6omUkELOewWWRIMRZi04I+mrdUey8NOfBjx88BMyKRqbJKbHocBCulTP7U1MihkWNOOeeSa26551FiSSWXUmoRKI4aa3I111JrbbXX0WJLLbfSamutt9FDj4Bm7qXX3nrvY/CZgysP3j14wRgzzDjTzG6WWWebfY5F+qy08iqrrrb6GjvsuMGPXXbdbfc9jh1S6aSTTzn1tNPPuKTajUDtzbfcetvtd3yP2ldY//TnN6JmX1ELL1J6Yf0eNX5a67dLmOAkK2YELLhkRLwqBCR0UMx8s5SCIqeY+S6Uy4FFZsVsmyJGBNOxkK99i50Ln4gqcv9R3FxNP8Qt/LuRcwrdb0buz3H7VdS2aGi9iH2qUJvqI9XHa0Zo/A+u+vNX91e/+N2v/w8XiiOLZ3P0q7XJtsS6uN94a6Oo/exEPm2KfVbFfojN9b6vr+7nH/zm12k1rwucuHHaLgui2LeH6htLC+tUEDlOItuIYN+dZO28b85YbJBRh9jP1EcDk+4+NZu7bZObYx6lKaG6p/gdzs5TN20nh7jvDPfMXAb57TNZ0crcPZAH/Kr3Q2IuKNt2vGlsfpVCvLbmOTutusc6+SIgzoUZdqUaTp82WdJFtdS9F7k+5zVyOxfXfUzr1m5lseAUS709Z9/nMj6DdWSWntue91BJs7HWyz5QfmW2SkTgOQQHF+pGcXR2J5aREpDczyGHq1Y5erYRY51zGpcfO4MTFBw0RwnkM8NOYefAduhCB7C+Yfq4y1h+p7OpDQpr3r6rvyNe6uaGsXawuediWwCMyPZRlRbZGBbvIsW3r7+RxcwbQBiblxdLP132cca+hA4REXAP+2tx8KXPNngZtZcBMjbEjbT7zItPpOpXiaGOe1KcG0DZJwIJGUYnGQt7r5/eVS/gVc9YlY/0Y3XCXV2zCw0ScmML7poxSdHeALLsDSXB5Jdgsu7aANA1rRHVmEobu+TWd4q211nOZo3+zB7zXKUJwPoCJrhV8HPcHDdZmebe6V6hQIgAUwLxSStUxGZfO2sIrp9peyYlBC+0U/gyar++HRAszVHmHK2cWwvJdYRdxI3yhCcz6e5rHrxpuMVrSeqKHq2ilsMN7rMO10QMldKNBUxCiH5C9wCWFtcE9ybCpZ4SZo6JonCkGu9bhbLIdna5bCPxDLzrjnYWwQxz5NpLsAXIZa2Zm06U7aT8tFeNkDoWTJGSx23dvE6q9fAhgx24gQQn3S4kAO4jFsOpVkc4DVC9jfjCCNIL1HlzysDJdp1IRRDfq+hNZHaewG6BUsCnQhaU/rZ6ZbY6ciGzPe7abJGxi94BCPso6y/pGkAHgpWtRxbdeZ3lxM1aX0STfT9pnXPaOCo4ynUTEsRXB4864EQu1WEd/ooNQcbCl/alnQyHIXT64q2VSu1UKLtzWstk784ngBKgKhrbQXj6jjT8F7+yJweACiUCBCuSe4X6ve6+QAxiHNm8ScmXW9bQniot6+YWWBlFBRyMXtZF4g6qTKs+ocCKRlJemHayvnApqbiK2C3BfqnBcWTaRLrB4Cgp20rYFHuY64QxkqV+xIRkN9kSHRGUO6s4Rb9Ev1aG9D6aoebY2bw+CHyCwHNchBfyjWdUFslNsLtACHBG9W/UObeakRKTCujhEs4C1R7K3D+sniteSmwe4AiDCMtPgIZglJxsti6yckD7eOUIKpBRizRaVAwlQZFzb0iYkxAdKAFr7FvnBuoDqtEnTB4PF9p+uMYOLL/4zAbS+lNvJAnzaelUtENowDK5wFanV8qoB9QN4WPby84k6q4rUbTcq4RMuGNvIHKiUbxiMWLn41Uczci/SmJ6OFAqL4at+FZidEjibrc18IjtC4lAsmMrzorwwg1RxCkQacg8ocTAu6N9Xe0C6wcCglVVUudyC/Bajw9GIvRAPqx59coMtoecAlXNTthZYL+AHWHGz8+yggJImKbHsEQaLFnXUZvc76i8hZuu6DkQLwJlGT+1Vuqe6jmeOyNPr3W2CjaiflIDhtGGdheFOBy01eDRCLhRVLs0chtoYuG8o8A36UQQnhy/RkBOuK8iiPNZU2JPShJZ7CLcZ0SqJqzn6SAYCU6CSWeClpDM2nNAxTDAPoOinv1u0BwouujbUQPfjeGIYYgNqUuabl50NqKQpQWQF6KBDFiwHwPwR4AgSddYWg/kVurCkJID6GGALW0QdSJrJ6oKDob1B4RfCD63srnBSniAjCXbVyJlNqunbNEkl9ziM6jQ7fQiVQb05LcWgqEmvOBm3dx9v4hmqzeXRpaKFU98UcTUcgNJqhnhKlOz4fhdyJoalwzShiAAUICScsA54xY2oFbbUaGD5vMoVTaSoXDnlbyfKZGQ+XaYut/E7/csWBOy45D63G9TTRqCqDc8QCCxWNsQTKPA8IOgz+mbyML9SBIClibv28Izbpj8Qha1ehD/vlvtmINDBl2tl5S205D2wCGg1RuxyhCDIxBQy2WrubM+qGzfFRU8hJZIlUV5tI1swJFGfgJNoPokVZBDW5+YxGugO2IMbTUrIgSFKV0IAeliHbxf5QRQYfmTjJvisxCAkoGQcSsYi3P9HOk42DOYlBF1unHEXDBemLUo0vtBNarRgIJ6wWOgAB/TwE3UEqm4w0Kaj36dR8hAVCRbK9gzPrSEsh5hfAT8r78immsDL/BYFVVyuvNU5gJoCU8IoLaXFyJuca3p+UVvlI7o+xqfRrzAa/RaJzxdMoobmAksdz6IPeo5E5TeAIBQelPcWDJufQcyH6busL4wcGDsSMPb+5xeGmeDZAaYOgTNHnV3ASqrXmBzFOmz57hUCpt0uFyUS/XXfoncfEeNG4BEhWfqCI00HYUgAUaM90pBXtQ6VvmBQQRFoccOPZJ+UscBfQSy9YLeoZzAIRIqEeftuCn5YgRiINVgokSCwOlEe0NTAQ0k5EAsUTVnQPe2a10hWIlKA8QVqsvMrQFCFcQD+bBAJuprgG+UJ1IdJ4somQFmEqjDLxvWJ7wIFf2GlJQxAGyTIwfYhIrkZSkP+TLwsw+mJ7MDJAr0B8Ph2biHjZpEWnotiriRiRvrUoBylwgfC8JKCxIXoQabekmwBCad/QjAAEvvmUVT4ILediJ6sPnrZc5Zt43lSKwOokb084ZPITIC2D0KocIQiCVp3cHeSx7xpsSnIV08NgXs4iP7KwOgNiWSAeoj96l2VIb07mQBME4vER2+GgmBJ0WYIm0wiiBbHEXaFtC4lD6A5GYThIJeAlReBfwgqkK/GX0DniIb9FHsvCUytQAHs040LXchv8l62Y+AqpUIIeGT+hXIfyQNyW9K63d9QIgsQ6Mm1kGxI9eCYPBGv6GKlBo84GN15MIG0wK8WKDcTtp3LRjIXY0MBqsD1ViJpmh8koPUwFLiQkkFd9QwGVjRAG+j3AgZ90TC4IEQBoSU4vTicl7GhpyhYAPYkFGZ8hYkcSooOAQZwqM7dACabAmiPK/A1SOO1QJA+39Qg/zLUJfn45HvL2HlaLo/MhWk5e6tD6D2wDNGXjeSFLIA4IF/rkkqDJn1CJ51MqGJZB5DZIDd2CZqpmzkde57uXb4HIQpNMGeNXEiOBgwKhFRg5AYuqVxIrdzMvRN4afplVhgfJE/JLA1O1B2m6zPpQBK4z6EvNRJs5a7HC21SOacOV+WgX6FPfARiB1xQbxgOE7ZhUAMK/Y+ezknCh+hgC9/MA8gZGTXLgs6AfO7WmrysLdJDlGPlG5Vx5PqJ/z7cQYaFe3Giu/upCx5hz3ZH2OAKK7przwCQq42BxMF1TgecrEJ6EWqvEVCvxoa1fOpEaqfSDHkawXU5DiR3uyjp3AnFWyIPHfkB8EtaXpCVvJBlBauQwiLR2onL4CnSlaT0wV5ueKU4/SouiNIoRa2Y9nlnC970AEWUdkMF80tSI0+Q7+6K26iJnQxUDqQEPwHjokSmH17StylwE12mWuc4iwJrgIRkfZEPOKk1OhLoCn3J1uXkZOoVnYa545prdJj0H93IK+hNRDQ8RG3F9hP9qp6tZTAxIXqBvLDhr1IX7ah3MlacFMPcfkspACYjbAm56Ub4CqxEiFC9O2L/AKmSSGQgCweh/1Bmw2YARZQewWlQnD7EmZrV2EXNWhgGwjmZEKCIuu4iIt/IwUIFmoCXz6PzGnPA4aNwCIqbaGWqYjiIBkcAMKeG6jUbCcFYFVUH6I64M4G6r9H8hbZTLIe+MxQydUDJuisEFibYbOQ8Wq24msuni00hCLo6hG9uDroBEiDbAf1mKgR+RTgPEEYahQaOpo1+Fw9lD2BA7l7Ag8Jk4pkHKBWj/Il5EK4yEvdvH6d2X4KGW9NYcAZ4bQqK4by70nioAwB01YV4e/s+g0/hA0tgK65EQZ8NQst6oCIb7ijrkXuhgY75mCPxVbO5dlkzCQmHri0JWIsQBN/yZNTwk39tobcz3nhslrYFEHwmHzw5jpYyOD7AbpD7AgcrjnUCA7K9oZNUv9Pry9k9Hyq/3hDRKmNDR6BIhB6dgnZKvPAuhsWASePKL4C98pNEnlSWiqV7CVnBVLWSCI8UZ0kwHjE0QeKbam9GRH/s8oUZsxQTmm0jLCXL1FvbMTWJEsAWZvsbjmwYlcuwBwgHJrSEblANhD5C4QnXHSm2A2JQLpcWbhVcbw7oU0LXm8i2tDnOdwFsYDEuFZ2ZbtF4cWNUU29q0s1AVjgVR0SlCv8cuS6qEqscyJ/gHQPtF7MgR3kNO7C4G5DsVGzGxlNeDLqivgXWBc6WShmCMSTsbXxPXItRnAl8VcAFjsqqaofAuS26iAsmdlZuakrq681ce0Fo1LAKCkMpDpnatkAfwq3B8zxYgWZCW4hLxAejpzpQQ3ICl/dzXsohIxUQys/PazjhhRP4o4TRqPDvL6QHxgjUBPgobrx0e7T5eaTfmq/gyZUxowbiFNTi+inj4FABcJlasFBm0r+GYFex+awQYjDJiaN2EVWesIkUzJ/N7E5BcyNUIPgQCm4DCl/DLB4bZ5YJCTc9jAP2k5iLQGEBUN1lLs6odtqgVdcF0VYDcVqAcWVMv6G+MejNifCBjTFi0gEAnHcagBjDUWrUxVT6xlE6dRUPNjdrIVcCcYLmF81jRGmKGqwqaXV3JU7Ai29erD1opAiOUTSUX81qBVXSpoDwxCIQJawlIMi84iE6fjHo3NidrzFyFESEshNRumgGZvVRM6loyzkd2wrmDnqfb32lYQzOjkN5RFZyxGoBcGxAwDuBAQ3XAO8R2pPjmJKnaDs+PdqqIGiTcYbSYZnwuUtpszlJY+woVV2vIL4cO1YYC7sR6YVi2y1Wi8wboDndk7K5U2yCNIWWEDpUOUggYM3ZkV34deQ2l7ZExboFNWNMXZarUmgRG4FF0VFoNWpMYxin0vn1RUQLcF1Lrua2rSALfIpqpexKfXazbABoamZkUMmEFg5CjlcnOlc3MCa8BuScGHL3F6xUK4GNKAmniWGFmDicbkuOcHq4Hqu3qXPdDyH6wAUdkMhd9AMtClxu3SpRKhBOAzZEQGSVs0HpRJikJgFdS4sEpGCTiY9yWFLz9SrZaBOwpiO7+CQ8YC9qxWgLmwWSVcpdE9tAJr4e/TbUjRIZZ1nkNSxgA8DATBwk2w2HwHLBeT4KrYHSbAQFVBMXbv7Kl98QES8UD8THJAYY9UZbZeQ81fhsuuaKnapWzYlZqaEIISFpV2toPbbyQhcggQev34lvpLMIJdZz11W0QooxYz0w55kNURg7I1uXIkfe+T4q3lxst5N5GBwE1DvUPHPo3lVLB8w1X0YzkuVHSxLAQGRMwebGjKXxEyAr/6SNSCfIBaumXnqLBnHby2lb9MhQM107CK8NojL3ES5EQGYBozhswpWJynbSUgwEUxOM0o4o8K91PzrHSIBz6qOvC7AGrBbkJTlFXlmXeMOHYJAHBc8USO3kUTosU9fiKIGj3dCnIMJGGSXFkQY1aggjFANnFQgpg90G7Km3d4vKRamkS6QE6RBCmOZbiCk+GiU3kr4fsxFyO+wC4RVAytZRxbwlqyAGsx6dWKHPcQUqIfkW+LuDgZzXbgp67DSKfbhSOkLObByUBYGiC1CYlQk6OB6aJPFBeSVA2oeIY/ZfU1B8thPQY0jXxIK7/JxOvExhIZxH5F8uZLx6igkqBzIzppMglWXJJOaqEMGDkvL2qa7GCF5LhA0gWgLBEQSRoJIZhFQHWN2GXKPV8YSDbV9/I0ZDU0uQJqFPWiIiAQRooiM/dfpR1xIyIw10alZz1GNBZymRG1QHysuqWvYYMnwIdmLgam5uAPVXtFKZ+FbjejDpbBdcAsCYEzMPnnREAskdlAhLOIIZarUn7zfcg7O7xVwSbj8q4NfpAeuU9WhvUV1EyV8btPowQXwkMgwViu7R+wit41bjuDodRhpdF+kHqkRZAEqDehrlc+NBryb2jjqY6LhcS0bnZASMAin4TO9mmTYBuTx+Bxtx/Iz+UeLK3vEy2naNNwbqj2pI6dxKhVYfO1Ko5prwa57pCl+pEjpIpCK5paOIJ96GV4nQqOrNTu0O4ADehaLwnLZBxab0BQy566yCbCCMl8iAta/hyUOUexoManQqrCxY/D2LVu93CO/IKxC3VLpbP12NyCa0F0YmELuQPzvzrCDpiaCaf7rNB0YVfVVW1U+UppNHaTUkkcWk0HXraZjnrhXIXurWjAe/7oSe1Te4B8BDLLpMH3XHAtJSsnyeQQFV02B46h9cXBDyguDhIwDtoAOcOwMzJQsMMYbh4etAFtRmkNaC81AgV31zdhBbi7jr5MzXKGBTiDLRqLxh0wVyUN1IYpjMG2VD8NFQDByB1unbW2Wga+KAT1FOkVH4YFBGCM157J00sDRQP/q3bMQLDMq3oIGAfC4qYKYBsFXdRrRLvyJVAn6KBy8mc5kH2jDCeEmyuo+jgioxhnEnvUd1L3jkCV5nQhoXtZ0xtPBTTZbggDrM6jtg5qDTA47emEnFEnW2U2tOn8F88NCMqkJGzw6hPVlEAZYPqc5VF4G2TE7uJ0OceLpQMTCnvaQ4aZleJkN6oPH0GLxT/JndWjY1WKakyD7HP4Pl6VmSVTTC2WAzPBHfRMJ8FlZ6WhLRxvwgZgbzQBcAhgDmbz5vUmLc6E2lb++rS63HcAldcioAnKJGCNNqU/WiQ5GY1zKD1sFV09pQtEoInJ5d9ajPegMq1zVH4g2JLfGxo0S+D0EjeI5NL+oj1yk3CTjh059CnhKNTlTGwybCuurXYIk8e9M0uuwRIe6p4PxiLBuasxCalVQpymlpCBP1Ti2zeHAYPSghnLWNYFFaANIv6Lb/tQrFKKDOfTg0jFf9bhIHTAFnTVNHbuX47IcDXKi1omy06laRviVLoEDv6oVlj9nuaS7F98IKcgNea+SMGHIQTSUg3aa+u0wrBoCA5rt7KPuH5EjApigfMOW2lRr1NTnHhqfweaQy1v0A0k7ygMz35uO2wBghDsi75DaQd3o8xyYCXoA8gaJSg+HKh6tDc4MlJ1fIIU7V8f/eQfppJaUyOqpqg8yQLOQdRAKHgLcBELlsUgHtQ9QerZWijFJD7mV4xsVbbZ1Z0frD9AuKI5Yw0GXlhA3yGlqPMWNfV/ScEvpKJIvepegluTk5wYASttoRkddRg0eAB8YVBap43XNvVEfuHbYx3S03rA9G5DwGz69rlD9+PRMVA/CgkygNOBSOaK9qRXIAyi5lB4wWa8GcnVAHWUF4bubJHSx6+FEcrDzsTdGTBtypnad5JzpYTAqqo7XOY1Nx6r8/nN+9PMJk9M3Se1BggKtH8wE5CvwXqQSvqmq47zUW8AxIFp0wNTwUpOPJsrYMnA5kUcZaF5qp4MwV3iug4YkoiCj4Ne67oAB2fp6NHyCcq6VYjPTz9AhOq1Ow0214w2YoMyAGHKva5eVrgljMTR+ee7zksigqndS9jIXOvLpfBB7z07gjt6BRfJstQpEJ2eIBq8WRLiZOOJ+wlWXAd9IjANm5bADkCIbgUJoGp0ojiQEx4B1VIHOkdQwQjuSs1T2rTqfrzrEQ0V5nbBuKiI/xNTpJNhDQuyh6UPIl3XiKFmODtMTKRkAWlYDzMG9t++HdDqch+Wo+SAzx8qDIFWeHBRgszXfqe4COCg3qT5x1lgDzuejvTVrDcrlrYFVEDKTZ57bh+O2lKDf+B8yG3EB50bUQwTWQRLNlVWU68RCmMZICo5tqautccqjHkcQEGjUhJzj7leqrmpkYGNO0XzDvxaIphsILc5ahwoqB+QJ8De5Na+mtc4TgIoFduqUeWloilvD0QIICN6SeOlrwaYOFmGXovJfXb8s7c7SkvqYxmXZ0EmUuxesEsbpdNIWIx+JqWsT1xaFfGo/QZ35SUsPj0s4tIqAyg8Q8aLBS5Jhx5Ah7IWza5o80GiO2msbJ6GTpojEwwwPjc0rW4TcUNpMU7NXvQN662UgX1AJ1p2GDL1OlIU81FoAjEjj02OMVw9CQJD6U9q08kYIqFbUJwScvUiZG0BnHW6NdGtn45D19IP0yxVldu5UgwEE3i/YTS0a7skn9R7f+GS5yB7uX/O0Eagl7SBohEe8u3Gz6iJqNkPt0a6TBJB75Niq/C6RY6WrSIE2IPCiTfDR2C23Wc2Et5dGO9D1iECp+SJBkGQ3FAREJ3Ima9Anc0OdF5m6A9xYlmI61JpeCwKNrG4D+4R0kYdESZW7gXa0yIZINzZmXvUjti9dc3k+IVVRHlmPltTiPAaBBcBpEjQ+D81x2DujlTzrarYVORThGJhw+5RlzGo2acwCgagLsdk6yphv3J2SLbXgOVVBOLwDqlKDrFNDxtVQ8IhusqSV18bJEl5aLRFZrmlORnNLvOrO3ZXnRqZCW+/4VyxLnmM695a7Vc/41aNOG+G07t97zIVC6upIXm1FvKJag9nXpVPQXTR2ZQNivF0djoKXX8hnJZCOGS7IjkmosqKa1RkasUYH6ZxTh6Y542ojzq7U0Qxd04XwGrUrp0XNe5IaR0hrFnRyabU7jVuv+2YQ1GqZVT54aABd4rpiQI9PhZ2EpkhrqC1gmqtSdw7ED3ocvZ2jYATjXXVIWvLXwJvpxEE4Eqd6cRr2vprDwqJXBHnUcI1O6XwHxjQ5UHzmQsFWz6pwOYJSdGaRZBk7u0r9UCBDjgRmCGqBIiz4DfZTs+krL00XTTBbvSYACOX1tiOTfhn7YQhA8Q3EyrYiIL+MIY7q18PRTufW4KmiYzqI1mM7qEHev+Nlj6DdLDE/dPZq8AJ3pD6kXEQLmGygFWCvjl/wmeR4rgtHhlkFN8G5gkrpaqSo81RgU7YZVJaeQQkIY6tadzqE8socNy71isylujDzGCJ8kdgD7h46s3lngVAJISHxfYb063vKIwsuBlI8v8kXx4+8hic3PB3kMpqOLpckXtb4yyGxNYukIwE4vE+1vgESHdKClKBD85drOz2Rw51pKMC8BmyQsdxXRjCDMOywvHRVT5k7qe+AFtDD2JMTfD/Vn6NQm4sKDlZBnc6sY5suX4sL1uFP1YTwCKYT4g5BFsOiQISJzeF6fen8ARYnsRxFTaLlGdAg82l+6o3Czl7n25edsY521JE4gk7jaApooBxa1am87296ejsAQe1wbjtNgPDqcZQUUeIIyKzRb02t4IJG0gjFy7T7JjMSTgEW7LirgnF0pAFM8Qw/2/zOifrQwEQtEIraV/WoIay1IleaPIOUIwTBArgP05kTF2IheHstSo9WaNpKvWW/AKUbrAY5H02cIeq8+mNwHYJb5yJEB6c7n0Oe5iDcDvQiIW3xDqQ1N7A0n2V6lhEVj6/UYwGSiL0+18569NSXGlIG4GY5ONxRoDbJeHKwNT4AcNgaRzu6KY3nKZfwMoVSen12+fqBixi8gD1J+GMcpivQINJBnpnyAFgwaOAGKo4bIggTAW7qMMu8ok0LWxRCxmXo+baIupkaarrOMmYQ4NURu6aG+C88JKBIkDFfScOoshRZ1KjhjhWRuB0i1fyrMAz9i0QHaqdO5W4l83GxgDLRVe9B6Q2bHHUw2DkuDkuD6mQL3gdj3RPWZ5Jmnn3dbrL/ZOpSe/poojEpHXDbZ74GEmLDZBGectKELsRGQeJOegX5D/xcwarh9BQBCm0hGysfXmFw0+hBVctSsTxoWQ0iqOQW0mlozkKt686N+JS4Ox0puLORYBr2ez18r3MzZDkO16NHAFpkiphscOdrokiw+fdoGBf2BMskAjqyO7kUnxocpGz/5K+MT7LGfkHamqsIEMHfzly7v3kBPtvHYXDDU22kJTyyNM47i9q5GpVmVT44zZteDYVUHaQOlfgRQ6pziRBHKlF8ej5ODxVqvOSb7akYMgpHs9E6LXEg4Ju4JH/VxgqadyPPUS2o0fisPXm+wDRwv5G2fkeNwCKYNKXYekMsF7UPa1VnXw0FPcSDG0KJndmwXFnEh9hOXPOeojOv9ygBv9HpPVWDkhmxTTVm3X7DDTG9y0MJ2hw9AyFpozLD3EBSUDUGG9+wRTNYvzVfDQ6dm+FR1PRdb8qnFD3QgKRCJiBP8Oea6idPMdl25EWOuiUJcxHeCDCqlC2pph0ngbtDW/asQL/+l7pY6jQidFgo7AZCQyntKc0uN72Th8xIS66FGAeTKB/qzelJA1SdkH3iu4NUZwHhwfMmRByYhGA4aPHcFe9iR1EiwqWF5zUIsoJ9LoJimJp3pqUuEvtNdXq2C7moeR/5WowKG/54p47PNKlafxrRvhomQso7dg+5ij7RgxNHz9exNWyKGt6JMqZwI9+r3YZk2S08wcFuEWvZiw27pjVBSGMPdL5dqiblkx4faYaxApC8hppxdjp+XHr4syuAXI94QAjYpnCaHnFbAFs03MSeGgnuOlDvch4a7CM3iMEIaj+P+4Sp9KzOezU+jFbAaG6YvolJgtPc5NLZLskTpEf4SJ0Lqhmf1MJV/5X8mqwKiS78jZrUQwvaARkS6YKgwUIoIDo1XkrDAZ8D5mg0AFYzhFqB0Ltq6I8aMj0sBBVM9V7HxsWLkkZJrpGJiM1JuhS7UZ1+wFcjaho0hkzPAK+oFSKGzaDsRjl6migB5Wy45N5XbyQRyL+bx/37r+7zTcOpRHUpevlBHoISmrE1AS8UpXVSbGPzfkBg6lncGilwHOSRSMUYAdhIT01n67xs7jdwQUR07DyxmlzyPQyGfqZ+qh61o9iUNnkBGclJmLwJM83n9MA2XT3NRLT63noQe+EhTv0847X9g2KL2InJf/Hyq6kAvJIjd458+NXA/xlLTIviz1nTcMQWhp9CwKVZJlJL2AIRH7SrB3TAJArwzbFhpLLGu629c6CsOc3crowERIoY6+RC+mpjldL+YsOd/wci9uOFIIirE5SlFAax7lH3tyNQESKVmpgJugXVhuYgojq0Usoaq1cPxKFNYbaiY0BqBB+pntXtKV310TwY0cADxQIGaWlQIndiTHHs4LceXkLlxLmc9Vi5VtYTAqmhnUyDaR344/VIynBfcfEStYxMc18aa1860kR3otIbpsnMTU3IZx0/qpEF1+lpmaZZy06WoD/0KIsH3UhM/C55+spYQ5uwB7RH5gUi7UCtKXtIzK1r3A398MPkY6mfZ017bHJGmqr61W47/5+HjdS+zSHKMkZOloB01JHUxnHfWNQ5WFddsdaOzsk0heqrSUQn4NGCDoqSzlDswGtQ8XgNIp1VUGhsNz4eo7nUk7gkdKzqIEW0DbKtIg+ARdJEU5yB5FZfFifvLvYBekYYnzfgRNrPqyfpkD4XW7kwJQLfbE0NLk2egoNVWQSwFQInVL2eCyFCNWZdbjhy6hOg0EjF0XSMHvRaWnvplCRCgETT8NZ6DTF04L4yseMeNxMoD/RPOXbghFsi17q6lWaocnJD/H113Acan6XHbis46zXpNlp9ORxQtXqQYVHhh8w+bXpJ2KyTzZO8+iRTDeiGJggEIetRz6GmRrlk7tYkkoipB0d6LB3mHIld1GlsGlYhMPdjulqRc3lPgEB3V1IVK1iGTvuXOoSQNzr2NX1H0sOsVJTpmYTHMmpjalIT4RQ0F9OlXfV/X5FxfUWPfUbJzqOp/vdx3mV2S09CfEZim44xKOClAW0NzHU9poKi6Cg73ZZktmnaU/avKmZVD+j1Aa+RjB2Dmvx72L6CaUAvspio2cJA8IvI5Zbm6GFeaBlO0LjFgOo0F0rBr+7ICJapR+bP4lddU0xqJLxx4+z/5UcS3e89u6hnVceupglg7N0TzxpPAUY6EdAEMDTuySAUqRFNHw6/bSZ+TXLW//iK/qkLUSDUlPtfCjD2/BgveCIAAAGEaUNDUElDQyBwcm9maWxlAAB4nH2RPUjDQBzFX1OlItUOFhFxyFA7WRAVcdQqFKFCqBVadTC59AuaNCQtLo6Ca8HBj8Wqg4uzrg6ugiD4AeLq4qToIiX+Lym0iPHguB/v7j3u3gFCo8w0q2sc0PSqmUrExUx2VQy8QkA/QhhEVGaWMSdJSXiOr3v4+HoX41ne5/4cfWrOYoBPJJ5lhlkl3iCe3qwanPeJw6woq8TnxGMmXZD4keuKy2+cCw4LPDNsplPzxGFisdDBSgezoqkRTxFHVE2nfCHjssp5i7NWrrHWPfkLgzl9ZZnrNEeQwCKWIEGEghpKKKOKGK06KRZStB/38A87folcCrlKYORYQAUaZMcP/ge/u7XykxNuUjAOdL/Y9scoENgFmnXb/j627eYJ4H8GrvS2v9IAZj5Jr7e1yBEQ2gYurtuasgdc7gBDT4Zsyo7kpynk88D7GX1TFhi4BXrX3N5a+zh9ANLUVfIGODgEogXKXvd4d09nb/+eafX3A1Tvcpu/zjHgAAANGmlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNC40LjAtRXhpdjIiPgogPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4KICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iCiAgICB4bWxuczpzdEV2dD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL3NUeXBlL1Jlc291cmNlRXZlbnQjIgogICAgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIgogICAgeG1sbnM6R0lNUD0iaHR0cDovL3d3dy5naW1wLm9yZy94bXAvIgogICAgeG1sbnM6dGlmZj0iaHR0cDovL25zLmFkb2JlLmNvbS90aWZmLzEuMC8iCiAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgIHhtcE1NOkRvY3VtZW50SUQ9ImdpbXA6ZG9jaWQ6Z2ltcDo1MWNlZTYyYy02NzYyLTQzNDMtODgxOS0wMjJjOTEzODJhMWUiCiAgIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6YjYyY2I4ZTktNjM3Yy00ZmMwLWE4ZDQtNDA3OWExMmEzMWVlIgogICB4bXBNTTpPcmlnaW5hbERvY3VtZW50SUQ9InhtcC5kaWQ6OGY5MTI2YzAtNWFjMS00NTFlLTk4ZmYtMmZjOTJkZTE1Mjg5IgogICBkYzpGb3JtYXQ9ImltYWdlL3BuZyIKICAgR0lNUDpBUEk9IjIuMCIKICAgR0lNUDpQbGF0Zm9ybT0iTGludXgiCiAgIEdJTVA6VGltZVN0YW1wPSIxNjc2Mzg4MTg4NjA2OTYyIgogICBHSU1QOlZlcnNpb249IjIuMTAuMjgiCiAgIHRpZmY6T3JpZW50YXRpb249IjEiCiAgIHhtcDpDcmVhdG9yVG9vbD0iR0lNUCAyLjEwIj4KICAgPHhtcE1NOkhpc3Rvcnk+CiAgICA8cmRmOlNlcT4KICAgICA8cmRmOmxpCiAgICAgIHN0RXZ0OmFjdGlvbj0ic2F2ZWQiCiAgICAgIHN0RXZ0OmNoYW5nZWQ9Ii8iCiAgICAgIHN0RXZ0Omluc3RhbmNlSUQ9InhtcC5paWQ6ZDZjMDg3MmUtMmQ0Yy00MzRmLTk1Y2ItNWQ1MjEwMzA0ZjFiIgogICAgICBzdEV2dDpzb2Z0d2FyZUFnZW50PSJHaW1wIDIuMTAgKExpbnV4KSIKICAgICAgc3RFdnQ6d2hlbj0iMjAyMy0wMi0xNFQxNjoyMzowOCswMTowMCIvPgogICAgPC9yZGY6U2VxPgogICA8L3htcE1NOkhpc3Rvcnk+CiAgPC9yZGY6RGVzY3JpcHRpb24+CiA8L3JkZjpSREY+CjwveDp4bXBtZXRhPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgCjw/eHBhY2tldCBlbmQ9InciPz4rIMvtAAAABmJLR0QA/wD/AP+gvaeTAAAACXBIWXMAAC4jAAAuIwF4pT92AAAAB3RJTUUH5wIODxcIXY7uUAAAIABJREFUeNrsvWmMpdl53/d7zjnvcreqXqanp2chh+SQw81cREYLGVHWQtmUbCuKAQcKZNmSPhhyJCWIgzhCkCABHMAfAkdAoiiGDCSSZcmRZCewmWixllCLRUqkRVKjIWlSHA5nptk9vVfd7X3P8uTDee+tWzXVM03ZkofU+QEzXX3r3uq66/882/8RVVUKhUKhUCh8SWPKQ1AoFAqFQhH0QqFQKBQKRdALhUKhUCgUQS8UCoVCoVAEvVAoFAqFIuiFQqFQKBSKoBcKhUKhUCiCXigUCoVCoQh6oVAoFApF0AuFQqFQKBRBLxQKhUKhUAS9UCgUCoVCEfRCoVAoFIqgFwqFQqFQKIJeKBQKhUKhCHqhUCgUCoUi6IVCoVAoFEEvFAqFQqFQBL1QKBQKhUIR9EKhUCgUCkXQC4VCoVAogl4oFAqFQqEIeqFQKBQKhSLohUKhUCgUiqAXCoVCoVAEvVAoFAqFQhH0QqFQKBQKRdALhUKhUCgUQS8UCoVCoQh6oVAoFAqFIuiFQqFQKBSKoBcKhUKhUCiCXigUCoVCEfRCoVAoFApF0AuFQqFQKBRBLxQKhUKhUAS9UCgUCoUi6IVCoVAoFIqgFwqFQqFQKIJeKBQKhUKhCHqhUCgUCkXQC4VCoVAoFEEvFAqFQqFQBL1QKBQKhUIR9EKhUCgUCkXQC4VCoVAogl4oFAqFQqEIeqFQKBQKhSLohUKhUCgUiqAXCoVCoVAEvVAoFAqFQhH0QqFQKBQKRdALhUKhUCgcx5WHoFB4+aGnXSCnfeMU5MQPkaOLCoVCEfRCofAnId562pd69MeOSKseafyLCbYo6GnXkHu7faFQ+NJAVFXLw1Ao/DsQ8a1OK4KgwwW7Qr29/ilv0yNtP7qtnBKoI3L8sqNvHBdy4QU/o1AoFEEvFAqnBd66kXC24s3u15LFW3YDct38OVwhh9wkBLPzszZqbYG0FXg50nQ90nYZvjgu6C8U+CLuhUIR9EKhiDicSKFnIVY5LtKKoprFNGkW6KhgB1FNCRBFFNKOOCtgRNEkqCgGGTQ/x/xI7npNw/HAIvk2BlBBhHzJIO5mI+hyIn4vkXuhUAS9UPjTLeInInHNl2yuk4YvBIiAxgRG0KQkhhEUycVyFUETyJCPT2zS8lnoRYQ4/EPWCDqIt6hihK3Ay1EwTlKwMgj7IOayjd71KIrf3k6KuBcKRdALhS9zIT8tEh8i7t0rJYWoWYRBB1E1RHT7fQP570BKOc0eVTEioAlVJWIwIigJTYq1BtVEVEMNBBQroMZiNKEiGCNIUkxWeDBH9XqTVT3fho3A6/Zy2Qp7idoLhSLohcKXYzS+E5brIOzbeveQIldVArn0LaqknFsnqiCaq90JIaVEEtComBjprMFGJWrCmZww9yGiAjEolRWiMYSQqKyQEBzgSbRq6K2hUSVai5JAhEagV6V1DisQU8IaQcQc5fIHgTcoYuQF0ftG3DkR9RcKhSLohcKXrJDn+veurucoe1ML1zRE2kMnuhm+HzQhCTRBLznpLkFZxxwV9z5iNRGNEDBI17Ooa0wMNAZMSqy94kYNVefpXL6sMzXnbWIVhXUMtHVFYwQjQkSJCI5EYy1iBKNgncGQUDFYBKzBbaJ3kSH1n/+zGxEXwezW2ouwFwpF0AuFL71o/EjIt41tQyp9UxfXTeo8KXF4i1kj9D4RNGEQVj4QxWBTIkYhWkVDQqLSK6xjhzU1PoJ2C7qqpVotCbbGYOlDT11bHIYA9MnjxLDvDCuVnB2wllGKJBFMbbBRwAmzyjFPMKsNBrCS/4vWUudEPtYYKmsQI1glZxYAMxwQzF0i9o3+FwqFIuiFwstHxJVj8+GbyzdvGx3EXDU3tonq9nshJXwCkxQPpJiIKae8JSmtKjf7QJcUYw0x9MTekDCsloeoVthKSTjq1ZqlMzirLFPLVFd4hIhhqpHnTcUUZdV16HjEnk/4lBg5YeUM+yLMrcHGnqodc8ZakvdoW5OAaeoZjVrWlWOkCWstGGhsFnyxWaLt0KRnBMTYbRreCCUVXygUQS+8rCJQTpiavJiN2M5cs5647dZ99LRX18v4w35XxLNQ70Tig4APU2THxtA2ETrDuFmKiWWCWhPzEEhB8cYiPtABtQ/Mo7BedYgBYxw+Jq5HZaLCKkTCasmzXtC1kpaePi44nBturBOHKVIDt9YeK5Z9ayAFqlENTnjFpEZGNU4jD0yE2d6YSWvwCmsM5xqDesFVhkljWRvLTBIBYa91eGOYWENlwaJYY0lOqEUwYna9anIEv1trl5KGLxSKoBf+2MX6xS/cVfDTlPxusn1c+XX3/0OnmG6FXDYN1lsjFPkiP/h3f4sXu+yLfpwGkU5pEG5VYkogZuhMzyn1zRx5HiHL1i5J89iZovQpYWNkoRaXEisgrXq8rVj4wKQx3Fl4VuuO3tU0a8+tLvLstQNCn/j85w54Yg1PHnieT/923p5G4KvGFa/fr3jtgy2TvZaLE8elMyNs7Fm5htbAVAyMDZU4VGB/3GBCQKxFaksrghpwJov6ZnbdGMk1eYZoffPcvswPcIVCEfTCl4Zw68m/bhzIdpxJ5Hgkfa/7P+5FGDdinnbOCFkE8u8gcjRrbeSFEZ2+5B38IuRcTv1yS1JFUx4XSynn0H3KX4eYqAR6FWJKiBhSUpwzJE05Oh+uEzWRsByu1ywDuAgLFF2u8euOuhkRUs+t6Pj8lQMWzy/5xM01P3vVs4jpT/T1si/Cu/ctb394yuOvnHJ+VjMat7iUh9T3asNSFOcck9oyqSzTSnJ9XQSxDusMMoy7yWY0bjhAiOwc1k660BUKhSLohVO0TU+X7V2hPnlV3TE1OX55Vl8zGI8MJdNB+3WIuY7cxzn29yyMidzdnbaz2Lmje2N+IgJuKLo6I8g2qpPjs84n7svunTgp4XdbRvaS3uW6icazGMeUxVlTok957iwM98tEJUruQg8JKqOsgmIlN7mRhMOQiBLwyx7aCfPlgtoLvg/c9J5r1zo+ennOz3xuwfN9/KKf98YZ3tRaHjPK4ahmLyZu1Ab6iA1KMMJnlpHPd4Ev9p39VSPHe1/R8vpXnUFHhgemI6IIl5qKtSYaK9SVpbLCZNJum+UaZ7D2xLy6CHYQ+E2GYJONKRQKRdCLgL/gL3pigceRKItINjU5tqhrkOWdcFxO1IcRk2ep5Ch03xXxYZYpm5kYiENYnZLmru6djm9JOf28+TeN5k5vFaiMIZJrr1bA2UEMhg7q0++uHtsytnFLO5n9l01a/ISMH0vtDzPXquT5b4WgikZl7SO9KlEh9QEZjF3UJIgWY8g1bs2Nb3uVpY+JRdczInFrHTFBmIsSnHD56Tm/+dlDfuXZOc+Gl47CX9VY3jRxvPnBEcYJrzvfMmobZiNLbBzBQIPB+ES37BmfHaOrNTEmQmuQVcJ7QWzk8vU1hz5x5zDyiZsrnru15ne6l37Lf925hm94cMRjj1+krXvOzWacsQp9ZOUcMyuY2jJrKiqBuraIFdxOtsUMgm45flgrol4oFEH/0yvkJ13IjkXe2Qd819hkE3zGQUyRYR5aBmEdou8kkuvAQ1RdAbqxEJVcI96IoepRA1gW0xyhJxlGmmLMoggYhc5HsEIfFNGUo9ph9Kl1hmZbaM0+5JUxWQyGSM+S7U5FjzrKd6VwY126sTfdSrccf+y2af3N9zap/2EuXHVIqw9p8xiVRVTUBzqfSEYQHzAJVighCsYlNCbWqsxCIlpH8JElSjfvqJ1yp+v57U8s+H+fWfLRw/5Fn+Ov3Kv49x+Zcf/U8pr7RrQjh6uFZB3GWFJShMREDNSONkXWCrVRvDG4EEjWENeBiNCLwYfAGWdYi8Ef9lALN7rEWQtXF4kbl2/xiZXyseeW/Kvl3TMFzgj/0aMz/tKb7mNvr6IaVZwfNRyueqaNw4aIm9Tc11ikclSaMNZmIRdFjMmd8Zt6u5S6eqFQBP1PsYiznXk+HmHndHb+wgyuX/mjH1RTNjGRPHakepS+3vx8GRrAkuSmJg0JMULYpM9jxDhLNdSVk5Gt21nYLPxQ8IMBicZISrn2HBV8SDnNrin/skGJFmo31F5JiCYqa6mtRQVqm1O1uvnwl9xsJkPdPW0PGgzZhJwu3ywZ2diWbk42MqQgZNhUkiPEo8cwqeKjEjd186j0feBw7fEpYcVgVVmrslorRiMYqJ2wWEc6VYL3aBfppzNuP32DD12e81N/OOfOXRrazhnhz10c8dZXTHjd/RXtdMrYBoxaOnGMm4QmA42jEWFfE6GtkCREH6gs3DGOMZG+91R1k2v6MbHCUBOJKT9HKQQOkyAhUhtYGMc4BkQT19ZK8pErBx2fv77mI08d8CuH4dTfuRb4ntdM+No3n+eSKDKpOTsbE5IwsoozjmCFc2OHrRyNE4wOjXI7KXg5WVopwl4oFEH/ck6n70bhuzVv1XS0OXszJrWTWN54jUaAFPNarUHksx94QhR6IzQp/wwvYFPCxxxNqSoYRWP+R6212R7UmtwQ5hx4D8bmCDcqnbHYFHApG6L4zpM0R70rr1TOYqOnF4fxkWrSkDQwskIazEsqI9QC1tncXGUNQo7co2ZzFgPD4eTocUkbx7K4s0Tc5mY14WijWFTBGUFTwhizrfXHqOhg/tLFSIwgKXF70XHYJ6IIIQXURyQa5qrMhmzBUqDrErbvuD5f8PP/uuP/em5x6nNsBL5rKrz9Tfdz7lzDo2cdoWrAGKqmQro1WleccQbBkCqH9j2jpqYLCefAA2OTPdtTEpxJBDHUqiwRXEj05NWpdUpDOUToQyKqMu4Dc2fxXeBG7znfNiy7nmUUNKwx0XFrEfjtz9zk/352yZX+heUBK/ADr5vx7rc8wHRiER8ZTafst4b7rHIQEqPKMaotthJGNj+faSh9uOxGs+2I3zRJSsnDFwpF0L+covGNkKfdUa/h70mzbWiAocGM7QiVUfCaEM2ibTZRsxm6sn1Arc12osbSk3DkiFmsQFTEGtYpEr0SRGnJ9fFqUNFehBjyPLLEREyJuhbmXcJawatSx0SHQXzAx0RD4nav9CYvEnF9R1U3GAdnaosCvqpwqtSVQzQyqisqK6gYZGhAM5oFWVPMtflhYYgOs3BJNfuO23xwMZpLDNEKLikq4KzB5buaMxIIISkRSD4QUn6s5j4gQVl0PdpHbs7nXI2O9a01KQn3nR1xIXmuKOyPKj53dcH7n7jN/3OzO/X5fffY8U2vmvKW184Y1RUTW9PaSNu2gCc2LTFFJm1FjEprh98faFtHQKhEMAY0BsRWaEw4I/SAA6IIVUokEZKCjxFNiYih8xFrFIPBaOKwz9mItPbYxjLvPF4EjYau6zB9wIfEFwI8d3XFb336Nr9y6F9wvy5Uhu972z7f+Jr7qCcWjTCdjbFAY5XDqEzbir3W5eY4yeUcJ0NN3ciR45zI0Qhc0fVCoQj6l66Q7yz1GEQ8bZZ4wE5dXLcd6CnlUSkVIWkixc1uzhwJhRhJmuvQIURMVbGed/ja0hpFQ87RL7tI5SxdDCSxVKI0CW4HsC4hSRBrgcA6JGZisG3NYtWhxrCOiVHKFqatKncEpghrgRgS69Wa3lU8f+WA331uwbU7gUrgDY/u8fWv3mPatlQTy9rD/sgSEKbWkKzBpIizJi8cER1c2IQ+xCFVK6yTp8FQm9zI14tFNVIbIYacTXAGNES0cjTWgGQ7Vivgk2A10QXNRjA+IH2iM7BeeZ45WPGLH36ef/jMkm5In7/CCd/86j0ef3DEhz51i5/7wulC/r6HZnzDo1MeutDyCjqqc2dZGWVaVeCgcjUjTXjyopTK5ANJY8z2AFcbQa2lMrlnwQxrVK3kEbtkBKuKGOhS7oHYNClKTHkFqwg+5mxFHyIxJnxSxHuCCnc81MlzKyi1V3DC1UVgLIF1r9zoOq7f8Pzyp+/wSzdf2AvwVWcavvOd9/O6B6bsV0JqLCMrzERYaSK5mjO1pbEKxsIg4m5IxVc2G9UcifsQre9aHZw2ujB8726OCYVCEfTCvxshZxDzYQ/25oq5qW2Tctc8UmWEGHP6GR+IxqAa6X1EjCGqoe89KhaIdD6SbMXIdxxEGIngrXDolYmL1MlwuI64xrGKiYlE5uQU+e0otDhmJpCShSYxX8CZCg4XByzqEdOmpuuGIn5IEBPrPlJbZRmU33ryBj/86YMXPA4P1IYffu+DvObhsxhVagfOVCQSIyP01uFiJFklmRrjA+BZaUVtEikZ+qioBRuhrnPdv/cRLFTWQlRGCP0gguIMZqi1O2NBIzEGEMsyKilCSMp87bly2PPD7/8sv7EI9/5mEviPL7S89XUzXv/QiPOzM3gfmIwtxllq45g6RU1+blQFZ21etuJMngAYMhBODMjGYtWgQ39jjt4TR/vPcmOi4WjMkKFfImnCDuluFDTlNapxk/EIkZCUhY/0y551iESFEBKr3qMYlj7iU+TgMPDU9Tk//+k5Hz6lzv43Hp3ybV95ltbVNKOaCRbGjkYSt7vEtKmZVUJlLV5gNHjEGxFqIxhnsZL948Uc3Tt2BfsFqi2nXXRS8wuFIuiFf7siLnBimUdOBW/6xWLKaWPP0eB3j+JSnuMOKY+UxRCIIXdfx5joAvihXm6jEjCsup6pEdQEYrTcCMoselKIXDHCzDmWGqmur5jeP2URLGm9pJNAmnt8MyLcmRPaGo+yOIQzlWBMYOEAXxGs8rBzrEPkZlLGTcM545nFxHWUZXT88ieu8ONPre/6uOwb4R9884M89OAeyVgaFKwjGWijp4+KbRq6kGiNslZDkzzRaS4vxMBhMtxva27FSGMToUu4ylFXFRqz+DUWligjVaJxTMYOVSH5SMpKh8bISi29Gsxqyf/0i8/wM1eW9/wc/4UHRrz7VVMeuzjl3ERo64bUGM4ay7QW1raiFqE2kKzBoUPGQMBYnMnNfc6aTes+G3s9Y9gaAsmOP4A9FrzqVuDS1mdetq59dhhjTEcnyNx2ILm7PyikkOhC4GCVWCw6DlTBx9xwuO55zhu8X/Gx5zw/++QNrp5ojv/3zlR891ec442XZqiCbR1Vgroy9AFcbdkbOSpjsdZQuVwicM5QD/axlTX5tbw1INoVaNlueD2Zmn9Jv4Ei7oUi6IU/joicQcC3lqGqkIaoihyp507zRNcF1FhEEwRlrTkyX6lSaaITg6qw7BN16Fk7y3odiaGnthUxeJYocbnihncs5p7bq8TnrtxmbWpGfeAjc88n5pF13DVt/SJfSGSBeaR1vH5kmY0tP/PcSwviX3hgxPe95xLtuKV1ltQHbAWihlRVdCHkiDRBF2F0uGDVVjROmVUjnp4fEmmxnWdWKVpXiLGY1QpTtVSmxzcjWp8IY0sT1tTOUdcV86hMjGOdAimABqVDeeoLC/76Lzx9T/f7q882/PW377NfCxfO7pMEahLj2ZhKEuNxkxecCNQGbFVhhnGuilxL3grUpqtfBSNHBj+6a6PK0EOwGSHc9lHkdHz2mR9KM5u5hl1TQM3xPVtP+izs2e0uoghdTKQUmXeRrvPcXkZ8CNw5WNNVAovA9VXH7zx5wD+6djwNvy/wt956H1/x6hmpcuw1Dh8Ss9bl8kZS7GTExAk1ClYYOUtrDTiTewiGKN0NpjSbaHs34jbDfTWyI/dDX4UcWxTzQoEvdfpCEfTCFy/kHNW/hwb0HBklPUqzD0YsSYSUIqScCl0JxF5RTRxq/gCv+izOCcEHpYueqkscEvHrnv2q4XOLxHy14vJtz/XLB1z2ykdv9DztEy/HZ7oS+PFveZD79va47tecrw1WGg66nkoizy4grHtuLXr6g8jTi56rnfLUYUfjE8+k3AA4GtZ/VsBDjeXx/Yq9/YaH2g5nZjz28Ix25LI5jCaqdcDuTXECU5u4uQ5QGeo+8cFP3eBvf+TmPf3+P/LuC8z2R1zac/Su4f5GqUc1lbWMKkdlBWsNzm5m77OIb0RZZDDbGV4PdgjHZQjSN8okOx4A9/T6G3725jW3eUEmjub6ZThYws6QwI7JTgqR4ANrVcIqcb3rub0MsOq53AWm44aPf/YOP/HELZ494Xr3na+Y8N43nGPfKqGpaCvB2lzCWWnk3LihdQpNzchanIFRZalqiw7uc5uUfFLFbaJ1ldz8OLyHzPD4qDJkMo4a62Qr4EcXyEl5L2NzhS8jXHkI/vjEfBOSb6xFN/7mabuZK0dHxIQKhKD0qnR9IKUESTlQGIfIOsFBzIXUsA7MnRIOV9xaQFiu+KXLHdevzvnAQcJ/CZ3RvMJz80hT94DhyjywuHaTT94RPvTMIU8sIot7WFCymwt4LgR+ZxHg8mq4ZAUfeZ5HrfCGCyO++tKIB8eJGZZpa3GV4pLQeVh3nujsvR9IjOHCmTFqYVIJ1lgq63CiVJWlEmgbl1eOWrObFc6z2Ua2M/RGzDbbjuxEknI34Xmh/e7m1bdJTZvNQhzZnuC3PzgvyRGSZFe//Ooyw2Ei39hVFhMTyUbGI8sDM+Xack283ROXHe98YMSjU8M/+YOb/OKNo9r6T35+we/c9vzgV1zgPuc57PPvNbMO0zjWyzWhqhgTmNeG/VpYh0gCamfootKoEiRbAwfZmA8nJA6HIZMdC0WG7FY8isDtcJgxwKaKkR+PbCi0XR6z8Wcowl4ogl64W4r9+PpNHTqXcyRkhs1d/TALrjGy8LmmbkgsPSRRUh/pfEIjLFcdPcJBCjx9Y8WVyys+emXJL9zs/2ipGYGzreNrzzU0leE1teFaVM43hmmbiGoQV9OGQDurWPTKYUwcLjtetddwY76msi2fn3v2UA5QDlYdk2TxFRze7nn/wb15lU+amt99+g6feHbBB290XI1/PAeSz0Xlc1eW/PxQG399e8ibL415z/mK6UN7nK0Th2qRytzTz9s3wrn7pqS+w9WWdjKllURjBOtc9jjnKAqXQWWt7Pqe73zNkQ/60avppWRGTqSVT4k+RXeedzm2l0fN4KRnBJMS0QgGzStSUSQkWutYWZvdALvIuWlD3Y5YLnuuXpnDTPgP3naBBz57m598asXmWf/XBz3/829f5nvfuM8XDiNPe5gk5aGLI950acJerYgFGxJeHdFaOjE0IdBUeawxWkM9pCc2o29qwKpCMlibpx823QIMPQFqzCDoOfMlR40IW8vj4aFAJPdkaInYCyXlXuBYev24mMdhBEl3auVJcje2TxBiIMa8P3sdEr7P0Xp/uCRYh6TA0yuYXz7gg08d8P4b3amGH6dHj8K7po53nm+QEVyctTyyZ+nqhlHjMEFRaxATmKmhNpaFE7rlklFlmRtDFQ190jxe1a3x7R70PVgl+LwApLaGfac8HQxnqoq5RtY3V3z/b1x96Rcg0BhhfQ9RuAg83hoeH1e8ZuY4xBArw3mJ2EnNfB3pVwnxnlsefu2O51p3b4eKV48c73hgxNc+MmZ6xvH3fvkqTyxfvMP9ex8a8Y3vuMiDE0fV1lSVZWwtk5HBOUdbWZwTKmMwzmzXjJqdNLBwwlTl5LacE986bW+9cPqymhemjE4ePncMjHbcBxkySJry+tiNEU8fcnNm10e6kFj5SLf2LLqOp66v0Zs3eXZR8b9+4oArL+FZ/8pK+E+/6iKPXppwflzROJNfSw4cQkfufHc+QS2YZBi5oWkSpTVC5SyuqcDkUoGzFlLCDql3Y44i+d2lP9vshR2cD43s1OaPq3oR90IR9D/FUTl61GUcNo1uKeUO45SIYTAziTHbjKqga8+dEAClWwWuBYMYuHltycc+foXfuOH58PrFhckIfNu5hovnKl65X/HKixP2xw0LVzEVpe57RKCrKpxGAoZWHEKPcQ2H3qPArHJEhXnn887r6JFJwzQlkjFYk+ikwhjDuLbIoicQud0F1moxfc9hEPo+8IHfv85PPLf6Iz2mFnj7mZq33l/z0NkRrz3fMG1r1tZwLgViW1FXFr9Y4kxL0kS0Bk2JpQZip1wYG24tI5dvBZ5feT5ydc3v3lxzfe5f9N/+G/e32Jnyo5/tudvb47FK+O/+3COcrS2zvQZRYdRaxrWlrhzOWdra0VjZ1oOdOellflw1Tt8u/6KafGqsri91ub6IsO+cTtP2P8nWvykRk7KOyton+nWg63pur3u6BN2649qNJVeur/mJTx3yyZdYAlML/MjX3s+DD0wxrWPPWNoqOx3WdYuTYczOWoySRw41Iap0KR8EQ1T6mHDWMKsNISWapqKtHc7k3gVFsyvd4C+/2VBgh4OU3bjXDYero4a6koovFEH/U59iP2p6G5zJUkJV8SHhFaLvUDXcWaxBKlbeM/eJOgSeu93xB1eWfOhzc37x2upFBfx951ted7Hl0vkRj10ckaxh1tSY1Yr1eET0HRPbslcLnVFsH/Jyj6D0YjFEzGAliq1Ze8+kMrh6WJpiDFMRkskLVHwUQh+oVdHaEUJkngzqA2HVYa1l7iN18iyXiefmC375w7f5ucN7m+U+Wwl/8cEJb7jgOPPQPq9sHVXsMdNxXt6SLFonZNljrKMatfiYCKHHieDVYqxHemEtCQlCjyC+Y5EslUZue+XWIvCFa3OeuLLin1/r7tosuKnRnuR9Z2q+/SsvsTdyXGyEWMPUOZI1tG1D44RxJTSVo6ktjbPYQdDNsC72bkKhdxFmuQehvtvtTl7n7nvmdyYxNsZG26mMREgQYiLGxKoPLIPSLzv6BNfnnrQ4xNsRT8/XLJ67zQ/9wfwln/NvOOP4vnc9yP3nR8yjpSZh6tyLMJPEEktMkfMjR1h7tHIogViNsH3PmWnFIkRSym6ENuUVt3OfOFvnXoZRW2Mrg3MGi8GYPN9/5DWfRwOP3lvywlW+RdgLRdD/dIl52s735mUmcTDz8Ak6H7BJueOVKKDrni4GgjoO5wusKv/qk7f4Pz55wMfvkurw8XU4AAAgAElEQVS9ZIV3X5rw9kemPH6pYm86ow8+p6xJjMZjzoYAtSEmwYqhtgmMELHUKbFOEawiOKZWoKoIITKzimtrUoysxNFoIpG7rlNKJGNRn5d+RGMxJBY+4MTy/LKnCpEuKL3vWS4jRhLLesSdGzf5qY8e8ps3Tj+cjAW++b6Wt1xqePPDZ6iNoR0rzcgysy0LC2eMIUSQNjvCVWT3tEB2ROuGKLIygkjCe4hW6QNEHzFDtsSLslrmaK5brVhqZH59xdM3PL/w7Irfu4uJzKXK8BcfniJt4jUTw5mzE87MZtTimVlhXdVUJtFWFSOJVJMx08oyroVRZbHWYq3gTDaPeSmLU71Lev3k9+QuuiynXE95EfO1E9bDu9H6dgpjs7hmGGnru8g6KHdWgXXnubPoIfR87vk1/+cnD/j1a6t7Hn/8e1//IJM2TwHsjVv2VFmoYmPC7deMfKR1lttqcLFjWU95oIqs+sjUGloHtxE0GRqjTEYVwQRMsiQfsQqLkJjVlmbcMmoMrRgY1r1u1g8aZ7bZIdnZ5b5duytS0vCFIuhf7mK+mSVPSY/VzWMYRoBiZKlK6hLLdYc4w/z2ipACz3vh408+z49+asHVU2rjBvgrD7U8/uA+b7xUYcZTHp0I16PQGMvEQjKJmbU5QhRhnhKNM4RomJo862tQrKuGlZYgNs8Fb7qjnRk8xAWimOwbnxIiOYIPQzNfr0JjlRASy6DEPrGIHb5XliHBOtLPFzyf4HCh/P2PXOf3T0lx32+Fr3u05c8+doH7xpaRQG0VqSzjqsaMa844QY1QG4MlsUp5dtlUFh3G1Voiah0+ZptbNRB1s6hGkRBZiaGPCV33BGOZklj1ykFMNF65EdbM+8TzN9Z84HNL/sW1F5rhXLDCX37djHc9us8ay/nW5PWzIbDfWlCYjRvakZBM9jAf1Y7K5q5tZyzWma2onybo+iLizSnR+t0i/JOHAO6Scn/hzz9eR9/8sV0xm5TOJ0LKboDLtedwFYjeswrKh/7wBv/9B69nr4Qvgu94YMSZsw10gTtRSN2KWVvz3CJyrjGcAW60hn3jeHiSjXrG+xNElPtHFjebYFUxeIJx1MlTtRV7TcOISBRLNEqj2ZHvyjywVwtnpyPOjBxJJG8UHMbfKmfQwQNgmDQcdryX1a+FIuhf/pF5Otqr3aeczlvHREyw7j3iEweqpHXPMhhW80NurCueu3bAT3/0Oh+avzAyfLUzfOurJ3zdo1P2L56hT4GaxJlxgxGwCGOxBMC1jk4MI5PwWGpRGps3lhkNYGuqYXsZIrjNB/XGjUs2DmObFGs2ckmDCck6eAzDFrSUvcDX5G7i1coTRVn3CT/vuCqC3ljw80/e5B8+u+JkxvrNVnjXq6f82dfO8LMJNvTcP2owKkwbw7gSaEZgoCIyMQLW4RFGkkhicTsWaSJgrc3LWcjus9bkFLFH6BOkPrDwEU0RweJXPYuodD6wjgkblflqTXI1h4uez9zp+fTTB/yTqy/0af/mWcU3vGmPcVPx6YOALANnTOLM2Za3PjKjcZbJ2RG1dZxtLT0wbRy1EZyzOLtJ8cpdhVteInKH02vsd625n5Jj150b7RrPbJwM8877o9uHoYbe+4iPic4n1mvPnWRYrHou31rxX/zzz3I5/Ml+nIyN8LqR4e1na956qWFyfsSj589wqIkzCq42NEmpJ4ZxFLrGMW4dS5/o+7znfjYbcXZSgSrO5gOXk40z3Y6wyynNdYVCEfQvcTEfPvQ2SzRCypvQ/CDsPkEfFfqe3kcOANMFnokCh4d8+mrHr3/yNj97ipPaK53wXe98gK97qKWdjliqsFdb2r4jtY7xyBE14dTQ1BWDIyxqHa1NVM4hqjm1O4i2DHZjsnHTQnbmdDeNe5s5ntwI5YctMSGEraFHjIkouaGPBAdBWfQJH1aEHlyX+PT1JT/5u8/zgRN1cxH4/sf3+YpX7mHbmosjxcZIO5uRUPYqQ1sZgjHY2tFaYWQNUQTjDPUwoO2G1ZubzIHuKJnEBMZsHdWiZu97E4YehqSkmA9hfQgkhXmv3OoDy8WaG4uA1UQ49PRpxXN3hH/65E0+eqK561UWsIanTmRU3tFa/rOvv58/8+gFnIW9kSMZR1U7RppwtaM2uZa7MUR5qUa2u0Xv9xTV6ykiPly+MZzZGMbqzna/YVI7T33vlJJ80nyIi4nkAwfryMEq0sXEb/3eZf7r37v5sniPPmSFt5yreeuDE97w6B7tqOVCLRibGxdHfSBVlumkwaTEKkK/WHF+f8Jo1lKZ4dBrNitfc0i+3QpHidYLRdC//CLzIdUe4iAsKbJOMjS/KX655nZ01N0Bd1aGpIFfeuIWP/bEzRfMWr+hNXzH4/u867E9zLhiJA47bnAJogTapqVpcx3cmrxkJK+gNFTOZAMNm/eZG5NtMR1HnzjbmdvBUSsNphqbj28dvDW9KikkItkKtE8JUrYjJSW6mAgirNeBKHB9taZZQ9/1/MaT1/nfPnXIjROvqO+4f8R73nSWS6NA3UxYjyc80ASkqrECexakqakMNM5mb+/BHcRu7T+PDiQbO9Nh5mi4B5DSMHakOpiH5M1lBiWoIprvdz+4oRETAejWOcuw9LBYrjlcdSzna1Z3PAsrfPDpFb/69CGf8y/9Vtmzwo9/y8O88dGzeHGMKsOkcRgDbeWoh8zJ0Vz66SIt9xJ5nyLyeiK3ftyx8GijH7ujavmpPbqFHk/rR/LSgd4noiaCTxz4QL8O9EE5XHl+7Nee4aeeXfwbvb/OGLjUVjxQCXUIeJczGzcTXPORp9cxHzy/SN66X/NNj4x584NT7hs5LpxrUGNpRJi0Fu8qrBgW6w4flYvThvOzerDilW2JxEieZbcno/Ui6oWXCcVY5o+o7FuzmMH/OkeACR+VZRfRpHRiiasFB2vDs37FT/36Vf7ZleP1WWeEH3ztHu97x0XGzkAI2KahGVfUCEGEPedoRPLWLZMbrVDdbugyDDU+2I7kbOZpzXBJ3gE+2GNurURlG65Fhm1cmtdt9ilfnpISEWIKrHow2nFATdX13AyC9YFbh5Ef+eBVfvX68ca3t4wd3/cV57l4aUI7qrFBGdVwxnTstQ3eVrQurwkdOUOqLBW55myHTiQdHqOMAXTH7WtoTdbshGa3yzzy9RPgVFGV7YiSKIxMXoweh9u30wbvIw0B2hpnLHujlnmzpgnCu1/X8I6LLT/5qUN++/qLj+EdROUnf/MK/9W5MfW+Q5zFR6UZxDIkcCZvTduMR72YRL3YFlFOXq4vTKnrThp9uzdAhjLRNjIfRHyoIStpcK3Lh6BsC5trzCHmOXE7qH7SQGUUH+IX/Tb6nosVr73Ucv+lKS4I+62jU8Pe2LFMyjr01G3LBLg17znTWmKCw0Xkjvcsu47LtyO3n1/xaweep7rTZ98/dqfnY3d6eOI2f35m+KbHz/LQK/eoRw0XEBrbQYDxyDKtHfPOc+fOkvMX9pjUBjBYmw+Czmxm1zeR+mBKU0S9UCL0L7Xo/OhDMabNjG72vdaU6PrIss/dv33v6fvEzaXn2Wtzfvq3L/Mr8+MP9bdeavlrb7vIww/tM9FAJ47xJJtjxMoxM4amdrjBaYzt/ughuku69QZPmh3ItiM3bKw9j4T72HwtO4eSlBvgYsy/e4i56U0sLFYel5Q1iUUQVssOayvmnWeJ8IdPHfD+jz/Pb57oEP/Lrxrxve98GCs9bW1YVhPubx1iYGItWhlqgcbmDVu5dglqLLXZSWXulAg22Yej6DVH7TqUCrYGLbtRKFnQN89hSnlPuM2angUvJfqgmJhYx8Ri2RNEuHWwYiWw7ITn79zmxuUVf/v3bt/T6+Uf/aVHeOMj57HOMG0s+7VDBKq6orbkLIvIC9Z9nibkd4vUT6bWdaeTLVdM8t9TGvoL9ESNfBul63BITQTJ7nZJQZOiZrBHHV4r65CnOEKMLFc9XVBWy8C/+Mhl/s6Td17ycRmJ8OaZ4Vteu8drzo2xFVg1uFHLdGLwmjhvHT25Oa1OHX00aOsIXcJWhtYrnUKoLb5bsOgEE+FgGbl9a80nvjDn966v+ZeLux8y3lkb3vPYlG95bIY5N6Gpa8aaECO0TUUS4eY8MG0ND+y3jJoKGQ6XGzc/syn/bA7URdQLJUL/EorKdz5Mlc2MeXbUWoVE73tCNMy7wO3VmioJz1xb8l/+2mVu7TQL7Rn4W2+9wDteP2MGhBQwjWOiQqXCeNSQjOCsoTWJJIbaWlR0uzJTyFGCDAO0OVIftnUNgm52xEGOuV9tIrOcSvXDjLGosAoRScq694QkGE0sYkJ9IoTEOllW8xUYeOLzh/wPH76WV7vupJy/901neM9rz3G2FpKtaaYNZ8TQGkNT5z3f1uZMgwxrM2WoW4rsRj9HH567yemTqzKzfaccl8Oh2UvIh51B80litgczx2b/vGArw9oITpWmsUS1jBuPixExib1mzA3x9/xy8V2k1sDaO+rGkobu6aQJVbOt/cuLRNxySlp9+9wfKwEdfbEV8k0WaXidgqLpaG29kLMxfYqYBGHIWjgic1WqJPTDbvp1VLwIblPXCIlVUELKhRCphUsPTuAeBP0H3nSG1z8yxQicHVcoDiuRyShnZ8y4RhKcHzUkMZhoGWNyFmBikHVgYYWJBUyFqS2LOqGauG8G8/taHnvllK9Zd3xvJzz7hQX/+LOHfOLw+HP34T7x4ScP+N8/PeevvXbM177xAc6NYUKFpSdWNQ+crenWkc9cmfPI+ZbZuB1ei0MvStJt1kt3fGOLqBeKoL+ctXzzgbi1cd2MqIHRxCoqMUR8sixXPesQIMCvf+om/+OHr3G4E3q9c+L4m19znnOXzmPpoW6YthWmMkwNVFWFq0zusrXZCKO2sv00F2OwQ/1cMOwEecdcyE7I313OKLn5bTNa1w+d4MHnA4oXgwbl9iIyUs8BFl2sGJuODzwx5+9+8uDYz3vvGcf73nk/b3tgRF1Z6nbE1EFnLI2BWe0QEVzlsDbH19VQS9ah6cjuRDpyovFIT+653nzvbh1jkuXebBsIwEqeWTea/cOMZiteAZwapHKMrEG7gLQO44UuBh4YOS6PzT2/ZhrrOKDiPpc7xF2MGAONscMh5R6zQqcI/bGVvLvz4hy3GdbhMLO5fkgJY6APw5a/oYlwHhPe98PBsEY00mme474dPb0zOOPwIdKlPNsoMdHgmWNxCK+/tMd/8uaOH3nixl3vz394seWdr5zgXc1ZPKZ2OSIOgquzVe7IWWpJGCf0BlzdkJJSG4NJEZk22KjEBMTEuqm44DyahLUKs2hYTFu0r7lkHa84N+GxV+9x7daaX3p6zseeWfDczuH6lk/88JNzfukzn+WvvvMi73x4zMJYbN/Tyz4jgftnI67fXLHycHFWI06oyb0FkpRIPqQeHbSkdMAXiqC/bFPtHPldJ4U4dErHmHK6uk+EPqAhcCvAYt7zhWcP+bsfvs5q51P5ux8a8S3vusj945pQKyNGXNivIQmuttQi1M4g1mTP76HeKeT6udls5do2usmxvc/HBFxOT91u78smFat5q1uMikbyWlaf54y996xQvjDv6ZeeNnZc2G/5Zx874Ef/8LgL2Lc9MuW7/sw5zu41TCuDbfPKzMYI08birEGMpTbD+kuTO70Nsq3rGzmS7dPsUeUuun2akOtuZkJ3DwVDrX0Y0VMRRPMFavK+sYTBVZZGlSSWuo/0krh4rsaJEF6iSrVvhf1xzT6R3lUghsYYnLMEBavZvOSlXncnn7tjUfmOgKeh/MOQeQkpDdG6IMNik6RKitmCeJ0E4z2dCl4DLiTmlWPU9/R45iq4GJhIxIvBq4HgSdYRu562VrpksOLo8PTrSOMsf/71+zQa+V+evEO/8xgJ8N2PTHjvmy9gXGIygtqNgEhlHHtnRlhrGNUVjVXENmCEkRGclVwSSTAWQ0iaXz8oa4Q9In1oIEUmBhZdYi8pnatIPiC14aKxzEZTvv/imOuvW/LU5+d84Kklv7o+qrk/2Sd+6F9+gW/cr/jOdz3I+ZEwjh1uJPS1MJ21hFXHH64DD903ITqlRvHW5EUxQ78KGzHXMtZW+JOn1NDvITo/mjfPqek0jKYRA3OvRB/p+kDfea6vOn7/C57/9lef5vZOJ/vffNWY971tn3bvHJdGiXFVo1VFbQ21VVLtsqAPzlV2O9Y0dNiao6+PR+F39wO/G5tRuxgVHxMxJLqQWPtEt+5Z9JGDxZo/eOaQn/v4Tf6/2zl6cyK8rTV8eHW8NvmDj435hrc/zMxFmM3YJzAd1bStpXGOsct1cDHghhLBrr3mUSf78Rr/H8eCjGPR7U725aiXQOl8JKXEwit9F5n3gcXa05H4x7/+HP/gMwcv+m/80FvP8+1f82B2LXOOZtxkVz5naCq3tYDdjEG9WH1cTvzeytG4ZF6eMlgNKyTN/QGScl9B3Ebr4GPMDZziWMVISIFG4OYSmuDp+p66ruk1INGyViVVwjIYpqnL8/PO0flIQFCx2JCoTS7bLKOyjMooBu50ylNXDrm5ikxbyyvONZwd5QZBNY7GKm1laJ2haRyucoxcPvDU1lBVufnRGju8B4fFsJJFM4WEWoMOpQMU+pSzZfOgOM3+Ah6L7xNBldAFtFuz9InYBZ5Xx/WnD/ixP7jJk/54M50T+IG3XODr3nyBmVHGtTJpHM45ogrWe86cnVLXhtbaYRRUqe3mNX3UAV9EvVAE/eUm6MNsdki5IWgT0a58pPPKsutZd54bS+XqtVv8579yhas7HxI/8PiUb//qV9JUyqStaERo6orKQWsttjLbXdnO5NGzXYvQF6af/+iCt/ngjwn6kDe++ZhYrnu6PmFRbqwC7/+dy/ydj954yZ/337xhj3e/40EqSVQCs8oyGtWM24qqzpF56/IqzE1jn0g+sOSIXIaZ7J0Mw5/ApqvdzvBdg6AQE13Km+RSUOZ9wseePsDtXrl6uOanf+0Z/unV07vdv+ehCX/1va/gbFszclA3FVXraBGaKo8YWmu2DVUn0+kv9gtvyj0hsV344+PQpBYiFUI/3J+YcrMfw1IgL4YQ82sy9IEQIne63Pw4mSSWcwUfOTAV8c6SeR+4bRRZgSSP7DVUa6FqlVdMHDoecWeVsLHHjBpC7Dnjau74gEZlZLMHe2WEoIAYJo2lEZDKYKylcbnENLLCqHZYZ6mGJkk2Uwxy5C2vQ/1ak+aJj6HBMWIwMSBG8AkkBlYxP0brrkcweIRFH7Mf/dpTq7JIys15z0c/c4O//6k5N05siPumvZrvec9FppOas61FmjFnJ46KxJ3DjgvnJ8zaCic5kyCbspExbBxli11soQj6yzA6z529g3FMVHwMrNeBPkQOuoQPytX5mh/91We3+7YBvvPxfb71TRd4xV7NtDaMW4sFqnFL7YTKWqrBikpIWMmbuTYNbqdtf/o3+YDY3JcYIn3Kf66ioiEw98Jy1fOZy4f8lf+fvTcPti2/6vs+6zfsvc9whzcPPUvdotUaWgMSEiCJBCHADCkSRw6EyTFlHFdCkXKcBLAdmbJdKeJUcMX8w5iiEhfgcoENCgYESGgABJJBLSG1pJ6HN9533x3OOXv4/X4rf/z2Ge5793W3ZKlVoLurXvXt+947756zh7XWd32Hf/vo8xaZf/hVx7h7c8CJjYrReMC6F46XBeryvtx5Q+FdvxvPGnDXy+yQpdRObkQbePHgylWjoKgsJt6uC7RdZBogpI5ZHdmdRkoNXIzKn33iKj/78C6P97a2bxh7/sZL1viqB08zHBcMvOC9o+ileFVh8dZirclKhX7l8EIRBdU5uzw3YzGl3HyE7IGQ5kTHoHQasarMVNC2y9Oq94SmpZkp6z5wKVp8Up6+vMfFizs8swOP7DT89vXnJ/6tWeHrTlbcs+E4cWrEKzaF0WiQM8udo4gN+6oM+oSzYAu8EWqEDS9U3jAoPdZA4SzGzqdzsuKhL4g9aWRBaMyKBF00ubFXNsy5LQviY8qrk6zcgKaLiCot0M0augghRWadsjdt2J91dEn59/9hi1+8weypsMK7vvI0L7tvg5NeGDvPqHAUDp6edrx0c8T6yIMRvICaLLk0R+z3o+NLcBzt0J/vQc8yoCI/RPLvhjx2EEKORN3dn/AHH9s6UMy//mTBt7z6FC87NqTtjdINSjGqqFwO7LB90pMRAWP7Qi691eRKoftCPhQ0E3oM0GDQ0NAGZdoEgibe97ErLyhYYzaFU/dU+C5RJsVqDrxY94Zgste8JAWXNc2r2nIzZ6f3TUaGnldA5hsYYc/lX/4f1dGudBAGskBcIVmLS1CgaGsZesWMLc6VaJ345tfdxtc9cJxLezXFcMi5DYMzHkmKs0JhXJbZxYjzDmMMYvsHvRxuFnOrLPNVmWTs3dqmXSJqpI2CxIjtFQpqlJAMMSZqVcqo7HeBto7sJMuorfngxZYnnt3nY89M+L2d9nP+zPai8uuXZnAJ+PQeAN97ruLek5bzd5zg9CirG+qkeBK+MKQAa14JCskavLcYEZzLASneKN67hfQyM8dz06N9g5dUEWdyUWd+zcjC0nieTGCMxYjibPZwd7a3HmoSUng0gsVipaNwA8Yu7+b/xtffw2sfucq//PAVHukRtjYqP/rHl/gfdma86eUn0c0CvBKjcHZgeWRrxj0oa0OPOIPpG+Z5UzrncRzp1I+Oo4L+JS/qyx0kSYkpERVCSBiBnSZD1qHreGxm+L8+sdQon3GGH3jTaU6tVVQehqKsDwY4bxBn8DLPZ15C67aHoOcs6C+GC5Uyj2NRgiYk5R1jFyJrDq52hv/vEEvaQwv6dk0ZlJkvOVUYRk4IRlARfM9cV6EPgekJWik/6bT/Wvv3edB2lINkP52r6POfv6kYf6GK+9zW0/TMdAsFgveGXfGsOaVJkTUvNL7AWDi/NqLsAtFamlbZHDjEe0wXsN4yKCxYh0gvcepRFw55H6uStNVzNc8lD31x72JWJ0ibaLr8edVNwKeESmIfw2QWqKxhezpFrNDNJjz0ZMMfP1nz21drvtCw3C9eqOECrH1iyne+bMwr79zg3Ibn5MAzmXWUpcco2MJSWZCUUGsxVnDWLidaltf+PNJ0ri3IhkKAzVO57Q2SUm+KM/dlyLdrTyrtZZGdKuuV0BaGognUnYKzzEKkGlfUdU5DvP/2df7pyPNrf36FX1rx8v8/P7XLt+4G/svXHOOOYxXXh2uc8HB2s+Ti9oyoyvrQU1pIfRdi5gY0cyXG0UL96Dgq6F/aEX0uCYo9pGdS3le2MaL1lN3WYGYNv/TBC6xafv/ga9c5efIY6y7DzbaoEJ/3a05y6pPAwlZyQaSRGzXjX+iJdD495NLhrIC1iO3NVZqGOqUX9FqX2sRw4Oh6I5hgsvROrc1Epj6Sci7jmRudkLJBzNwjXki5aC9MY3qLV11taFY94HrjnC9wszN/bSNQWEMHeEnU4tiw2fa2mLUEYxgZ8MYx6xLDwjFDWB8Z1FmUrGUvvMcYyc5wYhZmMoIcmlN+ExFuHl0KdGm+8snoSmo7pm32UbcpF8hJF6mbwH4HKQbqIlLXhk9e2uc9D23x/umtz+s9peX1J0ruOF1ym7OU6yXWwKYVZODY2puydV3RZsZ25/jAM3t8bJItjg9M70n56U/tUTy8x/fdVvF1rz3DmY2CaRegzFGorRFKA9Yv/QOsCJogWbCLfTk32eMuPps5aiO5cEIO5YHe/nj+m70aoFQIIhQm4VzJsO3Yaw2mNUhMFOOCYtqwr4bxEL7ta8+y8Yltfv7hXeaOv7/x7BTXRr7zVcfZuLuksRVl03FiVHBtZ4pxY/zAYno+hliz4GaYvsgf1fSj46igf6ng9nkMquaJNvV7uSDC9brLsHtR8Jknd/i9y0uS1PfcMeKr7z3JBjXrfogrHaMCjLVZU95L0Ey/HzRmRYr2RTanmBfXueypU8GJYRIzWpC88JbNgl++2jzva925aWm7xOaoIpLldlGFGCPOGdQoc6K/U0UXFSubcizCYTSTnEipl5n1cj2Zu7/p4vNBBSOHh4R+IR6Wc66CMeDIXvADm21iS4QwHFDERBTBt0JRGRBhmGJv6ZoQbyico3AZfXFmvjPvWc9ycCJXbs4yn38jpaxE0Jj959suEFJeX4S2Y7dJXJt0fPLChKuX99nznrvXS152qiJe6/jVj1zjV64dfi7fuel44HTFPfedZACcPzkihYZyWLA/bRmVhk4MKSqn1iumZ4TjRC6r4a33HyPGGZ/cjly/XPOrj014fIVU1ir8zNM1v/7sk/w3LxnzNa89wcR5qj5qtklgukDhbEYvUs6pD0mhl4JlSaHeRCzTlal99Zzp4vKS3tE4h/lo/xqacsEPOSOVDW/xJjKtW2wIiLUcM4r1YwYx8fUvP8lLT4z4yT++uEiR+7WrDVf+9Cp/twROb+JLJboRG5XnmcvXKc4dZ+Czvl5iIpkerZpnD+gR8/3oOCroX5KinlialsQ+baoNkaaJFMZyHUHbhg9+ZvtAfXnjA2Ns5Smdpy4KTnmDJU9q1ppcyESwvczFcBCG/WLe75lrNAdze6/2LmeKhy5QiuUN9x/nlz9w4Xlf61X3HEe9JRkYGSijgsvFN6pioyFJwljJU2Wvv05JMXbJdEqSpU+CoClijOmjTpfWmtojJCKSIU1WA1v6d3YL97XPp6gLudEqnJCSICZhRFhTQaQ33bGGNik+RaIv8SSSyUztuZuYMStN2wrJ8YVA3nN1hUjfSMbckNVdJIVIC3zkM1v8H394hWdvCC15sLR8rI3cSHndFPiv7hzx2q9Y5/zpDUzbYUTYPL5G1wXGvgRbsDG2GAdWHDZENCQ2B0IXhTNiqYvEGgXumKU6X/PWV5zm48/u8luP7vOBFb/7i0n5Z5/d4ysv1fzt1z8j3EgAACAASURBVGxQnD/BfmE4MVI2sOx3yigmjLeI5IYg9p+XpnxtzP0XdOXczC/jpanxDZ+tZL3/3GtAVRexu6KGmDKZcG3ocR5CbVCXaLuOolGm0XCsNJhzQ37sbbfzrz/8DO/dyz/fB/c6rr/3Mj/6jUNOH/fM9mbIsORkWfL4pQn3nlujoCe6aob/FcXOXZCOivrR8UU67Lve9a53HX0Mh43o+WmQFvUvT54pJXaahKZAM408sT3jpz66xaR/cH7HuQHvuG8DNxqyOSoYSsJ6i/GOqrCLzOXViW2VCStf9LemPUs6R4mGlPKDMwRCCrRYNtYLLj+7xyOTcMvX+ZFXHufBezY4NnAMnQVNWUvvLIVAlBwkY3oUoEsJ28eWqjEQI22EwNwcpZ9GVdHUR7/Ooeiki70o/ap09VwtYOpbGNF8fkV9zmfos+IXLnaCsbmJkaQUBkzh8S673rn+l7eCMzk8ZylBvPk8C4cb5sz15iFBiIkUe3lhl5Am0gF/9LFL/NAHLx9wIlysQ25I8xsZ4W/dPuD7vvZ23niu4o7TFQ6PHxWMNivWNVJ4Q+kNySnrhUGco7RC6R3DEsR6iqqgSInKWYy1VNbgRCkGwunS8ta7Brz8eMl4Enh4xa/g2Tbxm0/NGMcJLzk14mSA4A0+RTCKE0gmB6G4vngnuCF/fGnaMv/gZOXXjdD8QhPOSuxpnza4uuLw3uK9Q1DaCMk4Cpf3SCkkbGV47UnP05canunJcleC8swTO7zklGewNqJwYJ3DhI5Z0zGqfL9WyijDQq3Cwevg6Dg6jgr6i1XXe9iOpESUNkEImq1ee+3VJz9zjV9dIZH9d286zR0nBqw7i3VQWYMvPAMLtr+ZXS9rmZuLvFg399xVLM5DZWIihcg0RrokdCES20RF4oHzY9y05WPXD7KgB0b4sTec4htedZKh9xhVGpfNQYp+6rdGiCGhKaIp28qaBHVIzFI2E590EekbitBGpM+lhkRISiBPN21KIGaxIlDNT+S4so+cW8LqCm79BSnssizuc6OfeXSmg+wdYE12v4MsQbQG43JRmrPajZlnuN9cdA51gmPpZDd3gYuqtDGSEtTWcGl7yt//rSfZic8/63/3Gc/feeMpXv/yUxwrhfW1Ab4cMHIwqDzHDGANG8Mye+wPCkpnKaylcBbvDZJAbL52MULhHKWBosgZ9kMRUlKsc5weV7z27nVePvI8uzVjq/8ZE/CRqwG9OOW+24a0pifzOaWLJq+g+kCYNCcPLLCYg6ZDcpgPvnDo78mCiCgH5J9GWDTsBigKm41/UiKhSOrAOsYIZlzxig3Ds1canu2L+jNBCZdrXnHPGB+UrjTYomB3v8aXFjHZh2HZta3e70dF/eg4gtxf3GKuy69DX0CMQKGBrWnDlRl86Mkls/2EN9x1vKIrh6RBNhFxRYEXsNaCgBOTQ1XkCzNJfq7FPPU6XY0QotIkocvh5xRiMIWyp4bjYvnut97J2192na0rM66K5e6h4cz5MSd6Eti4FDyWOkWKlFCTJ/9JZzDGQptIJAoMUyeIZo/7XTF4SVzGMCYSxFDhSbGhScKwcjQh0YpS9I5gSt6zF4ASMSKE2KewLfNic6znvDQKn1e05eoOWxZm8TkyNM2Li80Z9NKvDZzLBKgl6mKWE2Q/GeoNu/NbFnVdnjMFupQ5B5oyJ6HtlGcu7fJEm17QDf6NbzjLycrRimFjUDCSSDIwHJQYVcpBxSZ53zvMF2f2DBBFxRBDgFGZXdpitsNtu8SsgyImnFWcKyiDYgqH6wKT/ZqvvmfIfSfP8+4/v8L/c2G5x/+VqzWP/v5T/E9vu40T6yP2W2GtEnanDePKE+vAoPAkI31mQgIrpAjW5lOtq7D1qtpxxdt/Ps0flAVmtYUgRMAbFjp+UmLgBbNWodMWoxEviU4jk1ZJm2N+8Gst6UOX+cheRq/+3W7H6P1P871ffZqThaEpYXNc8vjWPvedLfASeyOh3DykBLaX0clROT86jib0FwFtXxTB/GsOHHZt3p+HnCOJdMpP/4erbPcTyDef9bzhJWNOW0NVFZTOMPYgvXmGUTA2Q3+yYuX6ojQnqQ9hSdl/vklZBtU0XV8sEp1m9nQT8iQYRBgOHKfPbnLuWMXxE0Mqb4kopbfYlEjGE4g0rcnTdxcpItR1S4yJSTSEZobGQJgGpk1ipsJOHUAM+21HM40gyk4AGxKTJpBEmE1nYD0hZsmgiGTTkJSNQUQFtYJJi+q7KIa60i3JTV/fXLhXoe5bDuuyMmEt9NJzbXmG5OcrlKVigUMA9Vt/a3Htza+/lAlxbYrUCWg7mqh86pl9fuvJ/edv5IC3375GNbSse8vQO4phSVlku1XvLKU1WG+zfMyajEA4ixPBSv4z84hb068cSiMUhcUVHm8yPO0slN4t7JFxBa5wvPx8wUsGBZ+8NGPaf7zPzhKXL0951aanMwWNRgYSaJPgxdD1mQmoElRvWEfJSnE++HnKoQjLDd/rvzE3bzoQSq85IrVwFhXDtA5I6fDqMDFSW8/LTg555MKEaz1R7uO7gc0G7j5Z0RWOSiyFN0x3Z2yMyzyZ9/t0Y1YQh6Mp/eg4mtBfjKKuSwJOv7/VBG2MtAKNCk2IPHZtwiMrU9L9Z0sGrmQmBpMSA2OIYqkkx5AaY/rYUzkgTfviIw0Zso0p9dN4yslqPW6937Sg4FVpRUhdJCVl7IRkErttw9BaTNMRrGPoM1O4CUpIAbqW1nmMCrspcjq1TGLElgNc3GcmgVka0Kmj3JmyV3ZIaJmqY2N9gAsNdqLsiQXJD3AbE9Wg5NrejMpkEx7fRIwVvBMKa4GI6RLBGrwKEnI+aDbeyxO9UYjSM+MX+/aDojFdhevnA988pWzVbF314FS9lNUvoX+50VZ2XlT0hlouhzPjZLXu5PPjDGgUihSYiuI1ouGFR7mOhtlT38WIc1AZsA4KI5SFy9JJm6NFHIoag6SU7VVl2SWpki1OyY5oJineQGmLnHPQGKYpIz9IST3r0JQwpuSBuz0/Tss/f2ifR3vI+n3XWnbef5G/93XCKHmaUYntWnZTYpgcrctpgwFD6iKVzbJAo5kRfyAMhYNcitXPc/XcriYTzlUX8zBDo0JHJst5J6wPPc4MuXxtytALXekw2jEeCz/w5nP8+B88w7Rv5n/qszvcf0K49yXnaDctQxO53AZOzDrWhgUxZU18DrjL6FFGeI4q+tFxVNC/aMfqHjP1D2xFUI2IczhNGEnMnGW3PZiZdXuRvaoHlaeymnPMTf/gWCHoPH+w6Re2OUlzP+8IMUVi7JnoQGhbQlQ6YDcJdn9K8AWWlNO4WsEDnfZ68tRxTUpOdAES7E1qhsMhvum4aJThTHk4KXt7LU09Y9IktrdmXNKIaSPbrTAlccoqjXEIkTtHJX7oub0U1k8OGfjEmWNj2i6gLegg0YjgSVRlybBTkguUzqEiWCeosxmS74to0FyUbf9xzw1shMyLWHWmk578OK/ZSw2A5DS6uWlJz8gXls6BzCVJc6ld/+AWPVicl/nnK82EcFORV13FCaSfUMEZ6AqPdAmNgZeeGQNXn/f8f+XQcWJUcmZtiNLhCgcYSjGok1zNevKeanZZE1HU2MwZWLkXpLeXTb2fuu2DwI1Csg41lnVNFBbq4NiOEJ2jrlvOOgt3nuaH10f8zJ9u8dB+5mb82aTj5//oMv/t157munUc88LIJDrt8MGihaPsE+6mqhQKhTMYSQv5p/S7DbkZbnnee31uZWR7eN/1RTdq5oIMCse5U2Mu7DRIE/AowZXcN+z4H19zgh//yPIc/M8f2eWnNipaO2ZUFmysDXnsyoT7b3MMjMmKBZYk20XTdlTUj46jgv7FhNyXZV1EMCnrjq0m6hSzp3bTEmaTA3/35Ok1OlsyDoovXGaRx4Szdim9Mi9etuIiIlQ176Fj72yXyP7ebWA/hJxWVdfstpakgp90zExg0zmmIthOIdSkGCgLz6yDzzSGc3HCFo7HH9ni6Unk0rN7vHc/8vgsvMCfcE64O6iTNgLffKLgvnMVL92oeOD2TYiBaFpm5Ziu9HgLxaCArmY4KLExIkS09FgHKSacMYR+927707qEWedneVHBex8S7Ys+vfdA/p6dT/KyqG6Y1eYggZj+gR37MtEXxLk2WpMupkFZ0VctL4VlkZd5IAnZoCSFbCwTxVEODKePK99154h/9eTkOT/hv/7AMSoHs66hKH0ms9k5wS3br/qeG2JMnnnNyq5gjmgYWd4b2U0v8zFEc5G3vSwsYXCmRLpAdcpR1S17mqh39xkaGJ4c8oNvDPziH2/z4V5F8ftbNeX7L/J9bzlHsTag3m+xhSF4IRHRGDDGUPks+awBi8kf+jzh7IDcYVXSdnizvvhe32Ql1d70J5/HTMgTjM/cl9NrBdoFHBBaiKXw6uOWv33XiJ9+Ip+DaUj8i49e50ffNmIjRbAdkNidhcynQRBn+nPLQrFhXgS56tFxVNC/zEF3Fm5nkGFqo5ofIk1gbD0zPfjxRedQIsF7xFqCs6w7s9CZGyMv+ruYk+FC7/6WQqQNCekiTgUJkZQMTbA8tbXH9nZL6CInTo4o1gyOxMRYSguzZLl8YY9t9nj8UsNnrjW8Z6vhC+0jmhTefbWFqy2wywl3lW+/fcDr7jvG3WcMOp1Qm4LzIuyLYgNY02ExSP9gNsYQbT8tdwFjc3HNATEGFUU0rz/mRiWxn+oPGtBmol3Xd0fZfjR/P+oNcrmYCGL6qSu7lYV58U75/+PSuD5L84SDsqZ+15P6n8CIEEM2rfEoyUPdAr7ku996F7u/+Qi/sXW4ccwPvXSd19wzwtmSda8ZOZKEwVKZbJ5TmBUeAMvAnEVzxUEDnMU5InsKqGjWWfeZ67khU0aFJQQ46wtGzrLvlG6auFAH1irPD7zpNM0HL/HndWao/PtrLS/7zA6DrzD4wuHrliIpbbS4UhDvwVpSSFSqdOKIZAtl+glbDmnODygHng+ZW0FxbG//i0LZ38OnNofsXNshGMOag2dTxX/yoOez+4nf28ra+z+7WvOJh69x5rWnaQJsDD0Xr+wxGhyn8tl3X4zBKWSQ4Yggd3QcFfQXoRr2D+B+MlGTb0BvBHGOlCYMODiJlupRIj6BJo+XPIMW0DcDLy4JZj6hx37giApRE13Me+rrXSImx4Xdll/6wNP86sVVD/frfMXA8f0PbnLXZsXD+w0ff3qP9z7T8nSXPqef41Rpeb1N7DjPmYGl7iLBWkZtS9PBQ63yTLj1a26FxC88PuEXHp9wYuD4X167wV2nN+hKoRRlz1hMSpRemMaOgbFYSSSbAVknYLpcvJ2BIKnPYFckz3oL+VJuCJQk0ueHQ9Q+NSwkAkopSofgjUGi0pnshOdQ1GXYXFPKe2aBGFm8Zobv08KXPM1Da+ZGNCsufvQNiJhc6MVCoYloYShQVMrf+Wt386pPbPHeh7f5w0lEgO84VfENrzjB6+9Yp/aCMxHKCmMhGkPhDWot1hnMik7+sAQc4ZCvezb/6g469de3KCQDRMi2C5ZhCX5zQOsCxiSup5IiBb7v1Rv8/Y9cJ/axrv/yL65zfGC448yA8+OSug2cMEpoHa0oIXbYQcEkBTCWQjIz3zJHWJb2qjc68LHCfj9sapeeK6BzvToZfk9z+N0aBqVgTqyzs73PNHhGJUz2ZrzzgTWe/XDDp5r8Pn7849s8cNuA9TMjRrYkKezXHZVYUuFwfQSumDkok33n9ShD/ej4jzyO4lMPK4LM9do5rjGkHGQymXbELrIzC1zZnvDQhW1++H3LzPCf+dbbufPEOmcHlvXKU1UOX3rKvuX3tjcame/Uv8jvI/Vxm21IhJRoukRIkcmsI0RDN625OO34sXc/xkf3bg2Tv6m0/FETn7szFOE1a5771g1vum0TERhvFLiNAceAkckkuIE3uBSptaM0jmdqg4sdEgN71wN7Ch+/2vDUpQm/c71b+r/f2CR4w9+6f8TrX3aGtdKgzlN5pXQOAwwLy1gg9IYvGnv3ttJhUn6sFzaT8Azaa8UNbY+DppRAM++gNEpQwbmMACRVVGy/3074lBneoS8o2isZVKE0SzZzlthlSZg9YDCjWGt6i1KziJdNPSEzhKxMmIVE0ARtYNLBTBXtIhal7lq2px3jQUnrLceJNGopvKXoq+6GN7iywDmbs9lXjG+WReTW/A49ZM5dcA76L+L88+lXBiHl4tV2kb2Y0L0Jj86gvbjDrggfe3qff/7Q0mnx5ZXjlZuW46VntF7wNfdtcmajZDz0NK1ybOxQMZSlZ2QF7y1Fr/tfRcCeD26XGxQR85XY/DdSv6oKc7kg2ViqTcq0iTx6cZembmmDITRTPvF0zT/+2LXF67/9eMUPvf127twYYExiZ3fCPXeeonSOwpt+xSHI3P5Zlil8i1wHXhz3yKPjaEL/K9zi9NOQZEJUlksZQqcYb+jqgGjElw4fzEGouIXBtGPbQuENEh3SRYwzWEl5R4tZhpB8ke/SuTeHGCHGbPDSNRGJsKcJF+FfffTycxZz4JbF/K0jywPnB7zizJDbTq/jxpaN2Yytao3j2mKtw3pHkxJr3jPsp/A6Gdb8gDpFznpFo8VaGB0X7u4S994WGdSb/PUETz12jWd2O37x6RndikXclS7xvz20xysfnfI9923w+vuOIdPAvve4qkJSZGIcvktU3iGaUDEM64ZaDNolGidYyVGbFI4UWhwJSYaWhDWWoIkY8qQcu4imhBdhqglvYOAM05DQNlE6YabKUCytKt4ZrqP4BEWZfeGNMUiKJCtoEhwRUxSkqP1qJhF6BvncmlcFkmRY2Udh3zmsKGuamEmO8g04BkPHustJdnvJcHLgcdZSaaT2DmsSmEyws73H/EHDG3nOBc5h5fEAa7xHGyQJSbRfcStB8jXoO6UtS26TwJUz61y9uMXLThi+//yA//vZDFl/sg588mJgzqv42U9s8w/edJK33H8KMZZZl3f1gxCx1i6SENXKwWCbQ+B24SbBwg33/lJ5MDegcSbLVrOqwWBIpNJy3/GKj16BQbPPflFy7qzwLU973n0tqw/ec63mLY9cYfTK81RWaI3leh3YHFtiSBQCWIuXRATc3LjIyMLvQvrgGZmnzH0RkwaPjr8ax5EO/TkeXdLD1aYnr3QhEWNgJ1m6puNqgHd/dmfx9968aThzcsxGmS00rRXCwm26lzSJ3JRzDl+cvO9MhptPm0KnWY7WIPgmcHF/yj/54KUDKXHPdRjgzcdLvv+uEd/9xnN87b3rPHD3SV56fsDIwKAaYgcFZ4eC9wWDAsaFxVeWondOG5WesipRSZjCs+GVymYW/UZl8SZROIs1hvVK2Dxecfe5Md94tuL+kYX9wFPd8ge+3CnvuTij3Gu459iAOmR4O2BoZ1MMlhAjGoQYW6ZBmKWISZH9CK0obRuZ1dmKdr/tmHSZ6LYbIswCrRViaNCmJRrP3qQhidLUNU0T2O9qChUuNzM0CHXsmEVwBCaNkiRSt4rGQBezumAOw7e93E7J2nrEoCktPPdTP+lK75bXIRRkcp2GhLGWDat0xjIuLFYhWsdG6aDwWIk4YxkVDmsthXNZU95P52buh/CcV+BKpO2NprWySjJc/r9ZycjLHMI87SaU0LZMozAeVHTesbvX8qFbhAE1Cu97asob1i2n1xxaFoxLAy7r1a3t1wUrvg5yc49+UE642vGKHJzOV1ubBX9VlnbDxuB6omJlhZ2Q1y1lSpzeMHzwmdnifrqwHXj7uYJ2NEK9pakTx4Y+S/nmK7CYMrKRckhR1+9+Vo2tlm71h+Mnq8rKo+NoQj86DhvTe4Zzv/LM5isiNFGhbXGqVMXBW+hibWhjx1adEJMjSQvNHmOdJCRZhEQSs4iLMgfCQfnCduKSIT0l5Vxm75E6oJKnvul+x258YdX820+UfPVrT/GKEwWTVjgxsGwYoHLEwjLw4CpHmiUKX2CKyAAHzjBAaRXGKe+ROxFG1pMMxFiSHLhhJn8lcuLWwHdoazg3KNndbzl+aszGuuXB8+u87tEdfuuZCZ9e8Qr/maem/MmVGX/zweOcODXk7FC5FoUmdnhg3wTWSDjbIc6znYRSaqrCEeuGuiwwLdkwR2vQkt12hrUWf3GPKIaaiB8pXQeVtlzfjZTjiiGWrWZKLC1JW5Ir8BK4UidqaynVMDYdNlqibTGtAyINivWeKIoRi3YJa8FbIZocpC39w1/7bIFsYWqIEolOsCk7t5U+G6K0Vhk6y0AidYy40lM40xfxvKO31vQmOHLDVC6HFHK5YSa/adZdNgOL7JE8rRsjRDVYk4jJYCykLuLEsm4TW50wnAb+7SN7z3nttcDPf+QqP3H7mLEksAUSAZuLYCSbDVmbDW70xoFbn2Miv/HLORTfJ73NdfhmIUtIuQnylrVRxd0knrg8IVSOszLinS/p+NnP5PfzcB358DNbvLwqOL0x5PL2jHMjix+UuaPrU/x8zFaz1gjeKnXMCIp3lqS6mNrtItxnaaSUm5H+GXIEzx8V9KOP4LBSPv96tTPOelvvHUUR2ekKjheBU5XlSs/U3bpWY9OYwhRcD4GmsYwLSLHFxRwbmVzPorUGNZDkcNmK3Nibfx4366JVEEPUHFE58yXFrGFPBF/6F/xar7l9wCuPlxw3wvrIYkxkfTxkZiwbri8+IozWKtQLknIBEWcIHVRo1jcLqGYyVqfZvq5LOe9bRGhtoogRkwq8TexMWqxRJlE4WTi2jeFND5zgwfOWP7oQ+dnP7C5+xj+rlR/7k2v83Vckdm9T1pynjZGqTKw5ywQ4kQzboYOY4e6tFjQJQ59ousjutKWyhnZ7wsX9Fh8DXZcoo3IdoW6nVAPLfkgMEmwOp+y3kcGopLSJ5EoqN+PMmmfSGjZGHdMJFJXjWgx4TVjn6ArPuiZC6FhzBkLEWIvrOoLrI3YFqsLTaIb5jYDrJZSldTgi3kGboExgNLLmDRNVysKhKgyc4DSjAfQT7TIs5oUhVTdD2Lq4J27aq8uSqS89kpAXOgmnuWGpjcWlgErgcqt85gVY2P7hfuCpSaRaS8S9GRujgphcdgm0Fs/NAMMLYQfpgal3blSTGxldgd4NSrImw/u9emRoEjKukGnDeAKXm8Cb79vkk89O+eAkPxN+7uMN/+Bkw21rBadHhv1pQylCKh22bnG+YDtECsnhLiHmoJraCDYmBtaQrMlqDBGMWaJ9c/SAeeLg3Cvg5n7l6Dgq6F++cPuCIdszeZOm3hwmD9ZtB40m1Bnecazk/72Q2eH/7lrLfxEc3aRhNB7QNYE6Bbw3JCxiIiTDzAteFWcMzi4r+irgd5PDmB5e1eX5OhMRhJQ19DFRJWXmLSXKeHPMq4aOh6bPrxu/41iFN4mZryid4osByVvWvO3znzPa4E2GhzGCakJU8IWQUsRZ3+uFcwBHpY7Us7pJLCw+Z11A1dCEDifCLCjDtqHTEmkjVUqUm5u8ZTPwskHkXzxc80y/599Pyk88tM3/6pWtpExnkV1rOD0oecnZktZaQtfhjeWJqbLGjId2ldnelMtbM56cKR+rI036/Lmi1ghfVwDjitvHyj0bFXedHmPWC06KpRgJozZwqWsYjSpidKwZw54DU0fKgSGIY+SVphEqEtFYnBG0N4ARwLq8TggCpVVSskQDI8mTfWFs3sHabOFqzEoCmdxqZ64rjaSsXI+rprjLK3QZX3pzUTcipH6yjH2B9yIUJOrSMQrK7u70BX+ue00gAeXCECBfa1YTKvaWxnvPJ1db3vc3ANt97GrW4K82KIKxhiQOH5WXro95pN5lc1Ax2dvjW1+xyQc/nMmyT3WJv3h6wu3HClJVsb3dcNI61hOU1pDaLpNWNbsyjj10xlGIUjpLi+K0jxQ2glHhQN7LnNWvSx6D3DC5H9nLHhX0L++KzrKIasqWqdkkRum6hJIYEblUB15+uoC+oO83gU8/u81dd25StoGqiJTOMesMlURSC8kkkiakyC5nKWTylM4NJlbkNaALXfAcatMbNmnPBbNJ34AYY0hRqZyhSxGfAp2zDIvEd75ik4f+5Lkdx77pVMWr79zEGCU4y2hgWTcGKS2uT5TyVrJO2thenwyozbArUGIImnKiVp9ilx9Qy9QbSYmkwqjwNG1gUHk676hiIkbP/rTFJUM9Ckwnu/hQMju1wY8cG/Bbn9jm168uIfh//NHrN72Pu7zwbfeu8fGrHY/vtjz+PMz9z/eISfndGqhnvZlbDeSf587K8rZTJbdvFNx/YsTm8UTlDLvGwlpJpR27ewUbA2XPGkZdYA8YuIRaQ1KDdaY3QslTaEFfZAy9610/4dMz6hMk29vZzmnpcvjOfF7YVpX4eqCML330Dp/ll/A7/TU9j46VPs/Al579/YbKCZvj6gV/ruergrH3RNcrOEKkcIagOftczPNN4S/wEXAgyW/5rkSWvgFz+DtpwhWOe06MefjCFm3pOX6i4OuH1/ndab6+/s1ndnjwJRWnnccpFAIhdphkmVlD20SSKEOBNirGJWpjkZRQa0lFtrv1GDxClyIYi0GxK0k0Rm4MrumL++cRUHR0/OU8jkhxN930upSz9LKVTF4BDYE6JLqQ2K8TpQlcbhK/+9RyyrjbC1WMbA9HFM0UbxydGLqQqERoEKwzS0KOLN3K5grClJY57DrPZF8xBr/xcXpY+MjqgziSp+Vsdd5PVyE/bc+fHDK7POGh3cO9wd8wcvzw226jWPeURcFa5Si9w/oc6lGVjqKX5EkP5Rqb3cSsMQt7zuxJbhbNiel/WVmxFBWhCwFBsDY3IWKyD32lQgBs5TIAajxdDH0Sm+W2UcdJhIf2bl2kdxJ8+GrD49PA9filUWvuBOVjux0fuFzza0/s8csP77K33bDdRsQoMwzDWY2z0MwSdDmvXqwwaRKGOdXwvwAAIABJREFUnD6WQ1sySW5hRp+UKEJUXUzNmrI7YdJltvsB8pcc9LVf5a/L6sqHwyd6OWRZdFgATkiKYmgj1BFazRCylci//uR1ng90P19Yvut1x1ELVb8uGjqLWIM1JvtDzMNznmMSv1WZPzCpy8Em5sDf16X5TpKMmHiUIIay8DQ7HSEmZhj+9GoNwG6CBwROnx1hU2TSKc7ANGWTpyt7sz6F0RDVEpKwn7LvRYgBwRBjIokQUkYLjSbm9n0Jyfa7K4ZYK+bFBz+Fo8J+NKF/uVR07Yt5Zuau6NBDog0xp5MlwaQAMbKTDOc2Sl5VwkM9SffnnpjBEzOOmW3eec+Id7zScnodUumZpoQVmHWCM0ptDE6FIJJjIVlmsHuTZU4Z5te5lfgi6Uukt6pM/dQgetO4Pt+1OVGSMVg6krWUwZKKvBeufMUPfetLecVHL/Bzf77Fo705xtAI77x7xH/2lbdxfjPLn3xpqZzB25wFXvr8ELK9LMn0E1x2alvZt/ZaWwXcnMDTO7IFVSy6sF0trCWqYkMimDxdCIaZKF6V2LW06qisUJclpp3iTMDUBW+8e8yfbm3xcP25T963e8O9A8v5sefsMUtZDTlmI6bPyG4Lx6Br2BgU1NsTGI0wGplEUJPodmdcTYb9JtI2get7iUdnkb/Y79h/juZBVfm1Z6fw7BQ+Cl81cnzNCcf4nk3+2mnHdDCACLUZZB/+xjCzwmZh0V561vQwbAJ8TAs8dpqEYXYuzfJLFdT1TnaLyFnFrGjQ9UBre+P0ffMkrjeUfeXGuNL8hTPZqMeTz+PQKk1UNo6t8w+/8gz/6E8uPef5+aHXbjKuBlREhoXDIwSF8XwVJrfeGctzjeCr77MfYxfWHLJg+S3+a8zcH0Awmo18IsrAQLKCDDxOLF91JvB7j1o+3aNAH7jQ8OBeDZVhNJny6K7lE0/u8d5nplypA688XvK2l6zx6jvWGQ8sEUvw0Iqhix0DB16gMiYnIXoLnWI1YbwjpMzBmDf7iSx5wyybLnNgLXLkTfdX8fiyNZbRG+5vFsU862eTKl1fxOuQcnRqUHbqjmZas9907EV49KkdfuQPrxBvcXt859mK7/2a03hfkArPwBuODQuqPjFMFslhgM1TrGim5Eifna59pGNfG5ezU+88ZlcMKZbw/LJgzA1mQt+cRBFCF2jaAOSELAktW51hb2+GbyN+fcDGAEITKUw28iiqnMxlVBiUFmfAWLv89/tQEpHDp4EDKWb0DnY9MS6HqeQ9uialTkqKiVi31Ait9RQ7O2wlw6wLTBqI7YRgha2tjievdfzB4/t8YKd9Qef/W04PeOCYsDkqKQaJ4ydOUuqMO0rPvsmxoCZ2FFUFGploZt9vOgtNS1CIvYVbSV6d7GmWwh1LDZ0tcVZ5dntCQ8Fk0nFhp+XC9oxPbbX8WR2f1zH3LQPLO14y4v471jh7fIQpPFMRCgKl8xhnKHtnOpuUqjA0XWQglmSVjtxweWsoLSBK5VzfiGWnO/OcBDm5gc+++l+9eXd+C/g6xJSJjyEQQ2KniVjtqJNh1iipnvDT77vITz+ye+hr/Oi9a3zbf3o3I6PYwjEqHdZZhk4w1lHYbB601NQv7VRv1KbD0s529cpc4eofKPhLSds8hnievqjEpCTJ90iIkVmC3UnNx5+4Rq2O9//FFX7hsaXX/rveeJyXnxzz0QtTfuHPt7h8CE/jO86W/Ndvvo2xS1Rra5gYMUaovGNQCIU3eGcQZxkJdCJ53eCyFFGMZFldf/PNLX1ldfWxwp84Is4dFfS/OsVcdYFW6nz3qDkbPCh0KZG6xH5MpC5St5EuRbZmkTiNPLk14X//g2f4ZP3cgOE/evUx3nDfJmuDgmpcQkwMTbbxNFVBWTiiMSjK2BgiCr1W2MvK1GMMBTnWEulZr5KhOdunjyx37subdZ6rHWJ2HKsjkAL7XcJ0mVTlxLCfFAkp241aw8gkZmqwUSnK7CxWOIPpNbjz6Xzu0CXyHA8JXY0p7eVGqnnaYBlG0sZE3UbECqEN1Emh6dhNwnS3IYSa6+IYTGqeudry3if2+O0LNVc+RxLbP33jWb7idEELjGxCygFjb3AWqsJSt2CdIsbSYgkoJ7Rj39oc02od2rZULksRd7uAx9CljhQc6gwdgtOQORjGMd2taRCqlLg06bg8CTx2aZf3X2x5rL31zy/Atxx3vO7eMfffdYozNuKtoysLRiZRiqHW3Fy5EHDeEIxQWENQw0AisXCsO4s1QulzUIjtz6Wbr0oOTXRdEuD0EEOZWxb1FS5nTLmpbLpIF7OqIcZAqFv2o8nSyS7x8JPbvOfha/zKkxOMCN9z15C33H+cV5xfw5YFlUmo92yKYkuH846yb4LzLWEW70E+h2eB3Ig0rMTsquhKylx+3dRft1ETsX8/miJNl9huE9eu7vHpJ7dpush//6Glk+Q7zpa8/WWneNf7n17kwh92vPNkwdtfd4LNwQAkcce4wo8KApFxkT0FugTiHBIjReFQwFtD5Swqc1WEYMgOht5mWN4YWUznRo5g+KOC/pe9kK/uoVfgdV0x8ZiHMrRJabtICCnDpm3H5VlApx1bXeDxJ3f5e3985Xn/3VcPLP/w609TjddJqaMYDjlmFbUwKgp2g7JpFFd51gzUqkQ1FAbUCaWxYAQH2Uhjnq1uzYLtKj0pKg/6fRcuy6kj9ZNv6B+uMSlNBNVASkLoSX/OJLpksJKnId91tGLw1uIsGXrvpyFnlw8NbsGaXgibFhk3uWHQPjRmbnEaEhAijWbHtGkd2U9K2wZSnYixBRK7k5ZPX53w7o/v8ZtX6s/7WvjJt5zk3nNroAZbwNgXxJioCs/AKbZPxQoI+AzxNqHDpJzBVqfMttae3OfEoF0gItTWUHQhIwwk9lqhTUoyUKbILAnSdeyLx7Y5Y35ne8KTFyf8/jMT/mR66wbxtZXhW155nFffcRxvE8ORp4qJnTYxKg2dKyjoqFJkZgvOGEUKi5SeUgyDMqNBhTP4vsC7Xpc+v34OMtdXC/phWfJysHrfYNU2tyBO/bXXxUBIBukCk6R0QVGNTNpEE5RuWrOvcHzgKFXZS3BiVIAYBqIE7xiYhPWewtqcYja3r2VJBmN1Ol+ZuHXlyly8zxWEXZc5twfWIrLy/Jg7+C3Xcok2KNM20IbI/mTGZy/PePbihN/51HV+Y7tdNLzftOH4zevPn2X/z958mrs2FUfBRC0jC4UTbjuzAR66OuIKw7gqiTEXeiOCNYnK+cw78Vkq67xdvEHbT+rzYm7MEok5mtaPCvpfwmKuC0vUuZPawmKz/5MxCTElQghEhd060DSR3bqhBlzdsT2NvPdTW/zkJ3df0L//c+84z7l1T8QwHpRMVNnA0BqD85FxNPhS8N4hqgRraY2lIOAwiDeUki1SKxGiEQpnISnWzOE0zYV+sSOT5aS+yg2Yw4W9g1cMkYY+PUv78NCUm4cFPbaf+PLDM09Ec3OSmxaVeuPnnqfxVa/vHrekS/2Urkpo8s+hdcPMGOppoGkTYwk8tt3ymatTfv/T13n35cNdxdatyX7hz3MuDPCz33Q754YVrgRfFgx8JvCNTJYGVN6jJsMblYVGNcfgRkW80IY5nJkyAhKzzl+sIcWESl7Z1DhiG2hCYNrEnPbmHHUzI0RLJNGpEOtEJTW1wJPbyoUndvjTKzUfmh1e3O8tDP/5bQMevHed8bCiiR2dswgRZ4doWzMeVpjKcYZEMS5pnWXdCqW3iLMMrVA4g7WmLwY3Qu9yoIyv5tDxXJO53Ay7a7/2iX0wUJuAGOlCZNYExFpsiFwOCZeg1MQUYeAMlB6viVLBV47CgHEO35vkOCvLYBsONpaHQe7clG52w9Zfb71OmD9HUj8AzIt6G/J76ZrIhetTZkl57NHLPHpxxj95ePq5P5iBuwrDy0eOcxuGu04N2XSWauDYXB+wURqKkWXDOFTAFiVCYOwdai3eGgauX6u43HQv/OJ7jwPb69tu9I4/qut/eQ/35VTM51P54mZMKWvNU4bbQ0wYyTK10HRELPshUsdE0MjAW2aTlthEdmJkf9K+4J/hExdnfHZryjFrGZYOR2K2MULbhtGxDaZjS7fXsmFy5vLMJY4VA6YoPtVQDggFlDj2U8fIGpoIhQbEF5QWHELsvWpTjAtW+VxHSy+5mbPrPdnYxvmcOKYxs6lVMzznXSbgJASfhcUL/28jKxD7jZ+1cJBk2CMgsecmSP97MUHdZS/rNiopBZqYuD6NEKZMWjAm8b6LNe/5w2f53cnhpfrbNx0P3rnOK0953v3pXX7xqdlznou/eeeYU8dKqh5+ts4w8JaBhaosiM4wcoIzNpP1UqI0ku1rRegSrGmfpqapDyLJiXyQHcaapJg5YVETXdCeqNbRtYkY1pgFCF1kmhJd2merc4yN56XjmvsePM1t04Zv2Gr47IUZH7o847GVt//ZNvETj03wT0z5rttK3vLACeJOze88usu/efbpXgYpfO/5Ad/8Vee5f72iVCUCXdtRGUOrqd87Z1e3W2HVchNj+pCpfOkNe4sKlRtB1YSJSmGENglYi3E5CEcLy9haRJU2ZoLk2Cp1lzBVJkJ6a3A2N5Smf80DO+GbJ5YDJNHFO1oJYjnU/nWhCV2+wQPJbf15BnIkqiopKLOY8E6Is8joxIhjseDMZ2dc+hxVFQo83qb/n703j5Ylu846f/ucExE53HvfXHOppCq5SiWrSpKhLA/CsmThQWIwuN2GljE0DW1sGjCsRTN1s9xgWL28aBuWm9F2N03T3TSDGmMbW0ZCnkCeJCSh0VKpJtX0pnp3zMyIc87uP86JyIi8ed99VZKsKvvmWm+9927mzYw4GXH23t/+9vfxaF3Dc8CjCY0qnOFbzjheeWHMzadH3PnKM1Qhck5JXgNTgy0NVgIHwVJGTyFJStnmd3YZJYs2BXXT07o+GXE7qdBf5IFce1l1hp57ELTGdhwkQ2dBO9JY4yPzeUMTI36vYccqO3NhsXuNKI5HH3mOv/LR/c/5OEsjfOWm5dXnp5yZKGcvbPLguSn7CqcnBotgqiJBjQGKwiCVY2wtrrAEjVRZra0Qk6oVIk7SdJpIGh1TYzog0mSHikAShJEs9tLaYbYbl829+rbn1ifWHJc8xdZGNFfmKDRtcG9CqthECIvAzIDfm7GIljrWXGoKrn32Gu/8tWd45xqI8ozAH7pni9fcd5qNqmBSL7Cl48pc+cfve5qffW59svX1pwv+5FtextmtUTIpqQybZUHhDCOXOALWGIwzFGS/9Nw/bX3tWwg25rl6zVrfIcZuvULWY7cIdYw4khgRcdl+8D4SQmQRFHHQeGXWePz2nHnjeWJ7H4KyHR3s1nz0Ss2/efKAz84PCwElq09dO/51mxH+/jfewT13nULKEo2RzXFF6ZTSWKrSpko3V27SEzLXFch9wIk4buPvjby30Ltm/fK29eNjMg0yKE0UmhAhJv35WYhslibJo+aLsjDJ676w0ht/HLaXhg0fGQT1jsnOCsGvb4LScjpY9s3b771dhzZRTT30hMbMfGS28Mxqz9XtOTv7C67tH/Bj77/G/3el/vxv3sDbNi2vvW+Te+84y21nJhQSGdtEGtws0sJXpcEWlqlL3JvS2TwZkyp3K8mi1xjTXeOcQPAnAf1FE8hXqsPYs3gMQbsNJqBoiIhA03gaD7OoSB2oRZiH1DuvG89itmD/wBNVuPjcAR+7XPOZp3b5qavNF+QcjMAbT1d82e0j3nDzhHNnx5ipQYJJ4hTjKo0kVSWViRSuwGlErOCcTUHaACESsl3nkvEqeS582Ws3suyjLStvRVoIv/ec3BAK0lbhkRjbVkba1Bc+MdvndcM8Qr1o0P05i6Ki9gue3a35J++7yL956oBVrtvECN/58jFffv9ZRs5RlIGxG1FHKA0sMGwvPO//1BX++Sd2eDx7t99SGP7gfZv8rvvOcer0JCU4o4Kt0mAwFAVMygIxBieanLxEsKKdUEfUXMlmBzSjEPqBIldxVlJw7Vt0xiwdrBmi9QohhDRrrIrP4SN6wfuQBEZiw4Fx1Fd3uXzguXgQ2W08n768yyc+M+Pde/6Gr6e7SsMPf9Md3HzLKYppSVUUVBqZji3GWEqbZWFFBhXtmk75kf3yoYi6HkLu+3wVH+laPwEwMVBnJ5dISkgtBkPAG4czQpGV7oyRrt0zYOhfhw2n2vs+Bgz2/It94fde0nZU0qptctJyAxrPLEA9r3lu1nBtFtide/zunH/38Wf5R48sntf9/z2v3OKzi8BT12oe2/c8eQzp84wV/utXjHnN/Re4MIKtyYjNQhDrqEaGQi1FZaiKMqk5OouTzIi3tmfn2rNxPYHgTwL6FzuQtxW45gqgI7qRNovQVldksYsQOujXBs8cg61r6ihcmtdcq2FE5KMXt7n67AH/8bEF/367/g0/twdGlodetsEDt46575Ypo4lB64ZqY4OtwqaK3FisKpRlujlVE0s+S9haY8gy4UkyM1fc1qXKzJmeN3OHX653sDoqmPeTqK5i1DSCNsve0guvRN+g3jNbBPal4MrlPayf8+7PzPjnH73KI82w1hwJ/J67T/PNX7LJhalgRhXWONCGjVHBvrdUDoKJxGiIPjI/mLM/i+xbw8tPFYnU5yxFUeAQxCgja7CFMC0rMFDaxPw2vXFAzSSEvpFOy4xua9ioSz3trjpsHbNEiMssp6scY56siDH14b2Choj3ufWDUB/MmIul8bDXROa7B5ja83QDjzx5jb/7yT0uHtxYYP8fv+wcb3voFjbKkrKAcVkyLVIPPQX07MAm/S7zEmpWvY6z16qOelvlyrBa7wdDH7VTr/M5sMes6W/zGtkV0lYHsYt0Cer10Lm26m6NViQLGEkvoA/IcPQkWXpMuEHO0kvSfIjUIfXQ60XDTq2Eec2lWc1iXnN5LzJrav7su59mdoM77e+/fcy3PXgWowXNCMYo29ueJ5874LO7kZ94bIcnvB7V2eDbbhvzli89z11nLKc3xkhRUErDqBzhRiVVDJRVkTgxNn2hLknfdYJP/eT9pFI/Cei/4dB6P4ioJuKNhvSzJmSFLSSPSKUqSVBmPmJ8YB6Vg3mDDcpOhIMmsHtln49f2ubXHp7xY1dqnu9KffvLN3n9zRVuZLFe8Ba0CZSV4wDD5bph9+I+82hoDjwfurrgwzdgVPHA1PGWV27y226ruPvUJnvjitNFA1SMiBgbOZCKaQn4QJl1wIMDYyyCMLKpElVrkr52duQSuXHzjlVEpOUn+LZvHlJADxqpfURj5GDRICGyr8Jiv6GOwmJ7j6cOav7FL13mnVcPVzJvO1fx9i+/jds3DOfKSDGa4qNnPKoo8ix8K5PrFw3iHPsqGL/Aq8UrTCUyE8vUQVFYyqBQWKZVYnpbI1Rdf3ZpK9rfxfsqa7oaxXRZy0puNwxg6vx8yGRAHRCw2spVulZQyEpwcyDOGvZiRBeBg9pztQ44VeL+gmcjfP97nuKjs+OD+re+fJM//zvvwFrDRlmxtVFQWENZOIyBIluqDtrILfSuR48jHsKBV/vqffidYWCPUTs0hxzUOy2D/IEm/9usoEStMUnLF4irH9u22zo4fjmCRgejD0L4IHivQxjotd5DJpjWIVLXgUXtqWvPrleubs+ICk9vz/jEo7v84EevcSMzGe+4UPEND92CMXDaBCbTMTMNTKywuz9jc7zBtcbz8JPX+PXLkfc8tsPDa/YMEfijr9jga199nlecr5CgGGeZTgpcWbJVGaIGqqpinMmF2mfBd9X68Qn9yeMkoH/e4fWY4TvfzjP7iGjqT8ZWtCT/IwSljpHglYUKJngWdWDPG6Q+4OocPvHkNX7i4zv8x+tU4w9tWh46N+b0qYJbzhi8t1zZ89wkkXOnS+pzG2xKwSYeHFzZr9koK0Qj6iwuBupFkrva9MpTaonzmqd2G5797D4/e3HOh3aO/vxNK/yRu7d48L5z3HXKUmjNuJgys4ZplpbcKgsqTTezz9WKscLYQS2ODauMSkeRjWKsGTpy3ShHoT+eFDMa4lO5nngJC88MYe4bdueRytfs1IqtAz/569f42x+4dEhR7Y1nHd943yZfefcFNsYOZy0xKm4kjHCULmt4W5vkbYkc+IjzATGCLRx7c5+IbWKoJAWtxqYRqI3S4rJ8aJnhXJer1P7G+HyzSx3EcF3qCOgyCQgxhcqgS7nONlCFEFPCGbOwURRmBwtUlV0f2ZktsE2gWdRsY/muH3uMizegS/8dt4/47rfdSzl2nCugtBbjLFVhKItMnDJHzaMfAa93i6RHvk6PiPUDFKMX5FlBwRN/owf/ilwvb1g5vF6oHrxwCa2bfuLSO9brVf0xowlp3DOy8GkOfT5vuFZHFrMF2/s1v/zYLt/3q9cfbf2qieHVp0pedc8WN12YcF4CwTisFbbGFXOf9CoKP2dT0pjrrJ5jC8esgcuXrvFP/tNzvPe5w+2/c87wna89wxvvPc+pcdIluDARjBsxHiWXuqIwGKNUznWa8NYMOQonynInAf035NEG8tDCdvkGq6OmjdFHTLZwXPhIKcLCR4IqhUT2Djy1WgievWszPnJpn3f956u8a2d9xfOW0yVfcXPJXbeMuWUk2I0tTPAonktq2XIOI4mQFo3QGMMpC8YbzCgZLmxWFd57dgOICUwIHARlrMqje56xtRQosxoubh/w5LWaTzx5wL+6Wh+50/7xuzf4untOcectE56bw3iafDVFYLOAPeuYZDGRiYApFFxBaYSysIydxbkl7JpmzU1PFvQ6MHvUZcWSe8NGTJoOCJEmKPjA7rxBY+TarKaulYt7NT/8H57h3ZeGrPS7BP7oa8/xuledZgpMJwVK5Mx0lDSvRwUlJrUZrMmyscm4foHBaEjCGwoLH5gUhnmEsQFnoRHD2NmuKnVGDo1uyZHb+vWjua5JOFfDXRe42vHJqIOZbVXFAk17fftA3URmeYZ7sfDJVhblme193vnLV/inTx1Pzvyeezf5w2+8CzcxFKOKLZcDuU3nP8roxPUIj7K2HD/iBWuC+WoV2d99+gnQYPVlRXO9gwvWm8v0A7b0vBn6rPYBGa5/hF3/vA/Vr1+MqEoTkrfDvIl5NNGzVwdms8D2tQO+698+ylPH0Gy+7kLJH/ltZ7HOMZ2MKaOyMbEJLats0gvwEVM5ZrUysgkV2J9HGomMNPDUtQX723N++lP7/IsnD18Lv/+mkv/mq+9gdHpMhWdzY0LlBIswLgyjnNy2wRxjcLlSN20SdVKpnwT0L2gw115lHpSmaWgQ5rVHYjJPWPiICYE6BuaNYjHs+YARpVGPNkKzO+fDz3l+7oMX+bE17GhnhW9/+YQvue00D5w21IVjWrpEIGKBalKsumwKxj4zmg2cLR0SQSQio4KJEaxPFgq1S/1uyXfJzn5NWQk+QN1EfIDCRMLM42PkSqOEuecjj27zrsdnfPAIvfLvvHvMm++/hcZFRqVlHIFSERyiUFYFmyNDhcFUjiDCTaVFnOKsY+wMxtmkLJUD3JHBPM+Ux/xdEFNQ97lnHhQOZg2gXJ1FQvTsXttnHpRnHt/l7/zqZT640gt8+80j3vHAec6fq5hMKzariqa0jDRSlGm8rDKGiFLmmdp2L/aZpGRJGx7WYFWTyYs1SAgUzhKNocrz5m1Vumwz9PkDz7Pvs1Ir6poJ6B76PpzCSKBG7ilnwmY+H0jjbfMQmTdJK34/wKIJ1LMF7/3UNn/tl5899hD/97ffxYN3TBgXBePxiInLCU3pcG5pcHIsyWxdabz6Xz26oOc6QX6wXMdR6AechmEw71jpPYInPVviLMIwaJOsOw9dd0y6VMBrYnJ9m9eRRV2zNw/UTeBKo3z4kav8+Z97+tjvxQA/9Oabuf3sFJywUVZMUIqxY6M0zBEmZUKnrAghZYE0MeJQri2gOZizMHB1rjz9+Dbv/ORVfuGaX+GhKD/wxgvcd+dpTk8cB6bg1NglhM4aNgpD6ZKLm8kysolMe8J+f6k8XrJz6C1U195UTYzEKBzUHheVS3XDhhh87QnWERcpk75qIlXjuRwtU4ns7Tf8wocv8QMP7x/aXG5xhj9wz5T7X7nBHac2QWGrLMClmeSZRjZdSakwM5Y7NGCCQawlAmNRahGcdVRZ2pWipHCKiYZK0knMAmxNRxQxoA521BOyd7QdF+wGmNoAZcnXPjjlVS+/xkcuBd7/mR1+dnuY/v/Dz8z48Sce5dseOMPrb5miI8dz23MuPnXAoih55dkRd5+tCOOSqcuwK5GFL8AlVyeMEMV0I1vSN7LoOdFFehVmrjZpZXPrSAyeplF2ZnWyRvWwuxDe9aln+bsf3hsc9wUjfPeXXeANL9/g/PlTLELg9NgQjeWUg3HpkChUbqlU17HO8wZrAMl92LIwuV8NxqXkzmQEoq3cTIbYRZYiOaub1bqYdqgQVdZEIFnx8loGeCPakcZUVmRQMs5c5H57Mv9IPU4hEaQ0GMaSOAk6GvEVrxS+5dEd/tWzR8/ff/s9Wzx4xyYFgiuSOAvWZlOdPK99ZHQ+4uTliACty//LmvisR7TfO7qhHO+O1tdrX9c/VpaEOHT1c3XZfz8ia4gsSX1tOz+udhlIxkntHxWDsw2LAFuhZrFzY0qGEfBFiS2EcRSsg6pwTMcFRWEYQbIddum1NipYy95CEQKndMGuqzgXYKv03PWqLe65Zcobn97jH/3aJa7kA5+r8Cd/4TLveMWcd7zhdiajmgMU4xWpHAe5dTkqCzQmi9ioWYXApKmOjmR4EjtPAvrnN5grMWalMSWpneX+7UHwSB25LKT58tk8aZnXDaV1PL03w6ryiWsNP/LBK3xwd5jJVkb4Q3dv8vZ7J1Rbp9iYVoysYGzAisUaCBjGxmCtUjYNVkxyOwpQOIhYMMpYhJFIRtzcAAAgAElEQVRJztTOuU6UJQg4VZwIHqUJaR5XI9iiwQVldx44IDJqAt4a5gtF65rNquLBW+GuCxVvu7jPe55c8K6eDOpTjfKDH7jKm07t4Kclv/z0Af1C+PecKfnWL7+Ze2/f5Ow4sutHYBXXeGoDlTVZJEV73G46J+w+NNwqzrW67KrQxMAsJBgyek89r7k6X7CzEP7p+57hJ1YCz+/YKvjjrz3Hq+7Z4qCxFDRMx46RUew4IQvOGJxLM/uSyTshs/aXvVAh2jQehoLTNOcuCCWtoI5ZBjHoIOZWVW8dx+uoSlMBbhjfkhUj0sy67r1Bx6LPo3JdpaSKt0KpQogGVxXEJjDViPiIGRd8x9fcRvWrl/i/Hx0qF1rgz71iyu/72pdRKbjNitIZAkKhEWOL5EUvMjzGGyHAreYA69oLQ3v0Y9Z0vVCRcFjbDWWNY9ryHVqoXHpoSTu6NphYl1boaEgF6E95RI2DpLZtjyy784Iakoa+Lwi6wJYF01Fxw3vaBWeYVBWlg43CpfnwGFHN46WlocziMCEEFhHGI0MdlTEVZYxIITQ1zIzj3Omar69Oc/+m5Z99dId/+8xBt07/9JE9NDzJ733DbdzSLKgnisTI3IyRGMF4CmNQk65Bl61v2z1h1fTm5HECuX+OUHtSeWtCCurzJhCistcosV5QL+DyYoatlR0R4jzgY8RoZD73TIzykx+7yj98ZHZozvk7bhrzpt9+C7ecKihKy7RybBhDVUBjLMYIW5UQ1KbLOgSikZSdo0Q1lCaiGJwBjAXRTN5KBoalTZuLA2LesFvRjSYrqbXStMErTQzsLpRZPWO/Duzsp95/FINZHHClVp68NOdffnybTzXxhtbwTiv88Nvv5PTZimpri61RYniXBsbZ9MJY20HRy3GjnuRliARNXusKLKISFg37Cs0sMA+BMJ8znyuPXNvj7//cRX5p3w+27z/9JZu89YELnN0sWZQFZ0Rxk5JThcMIlKXN/urgbOrrtSNkaobz88v+9KDeG4iGtB0Ec4Tc5Y1sVM8vkL+AHvyAWKdLJCqkaYF5E1L/tk7iRx7JqnM1n3nqGk88tWAveG4fW+64fcptt55h5CwlCa0wIoycMh6NwQqjLNZizfNoN7Ra7fTnuY/uj69W8f3nnw+y3yJGsUci1J7aWzdtkL9b7X1Zw1E8WTGAXUfaO4wqCEsSX3sP1CETP0NkJyh6UDMLkWcu7vD2f/XIsUt5z9jyQ7/7LrbGBa6wlKOKTQOudFhr8r2Y+CyGpUBWAsSSNwAhUDfKrGmI0eOM4dLOAqewXUd+5kMX+aFP7g4+963nKv7w19zO+Y0Rt1VKOR5TOKFyQlVaKpdIk23ia1uSnDmZUT8J6J+3LY9e3zyRruZeqX0An8wfnr52QOPhme0DPvjYLp98ap8FwunNkq/cEt79ZMOPrRCxzjnD//TQGV51x2lGRUk5ScYPUYTx2DFGcU5wZUmhECTN0Ip1SEwBLYhgY8QaSWIZmhjlna66SbuYtaYjlJl2NjartkmvBIhBCaTn6qg4hdpHFhpomsjVvTkHO57LBw31/oxdMTxxacaPfHybK/74r/WNpwr+6ttfxk2np7jJiC0jjAuw1lIUqY/eQtEttN46Z/mgA/vTRUgQcGgCe3VDMIZL8wV7l+Y8frnh+9/3FJ/tHdO9pfBffNVtfP1dIzZtBdMxG8aj1jEpBGstIyOoNYytydK1ghHtxmn6CmHLkTIdBMR1cGxXL8v6DVuPK1D1C32N6xDOzwhIE2JHwgo+0GTVtf06IFHxYvDRo2qTP7ZJMrWnCsEVFhdACsOkSGiH7QRlzIBDcOQJHhH11uulrwnig/OTY9H9I1se/SxCVmxPe+S21YxiaTWjXVLXzr2jsTeSKL3Z9MOARdt+bzk8ixBRH5n5yF4dAGVeB/Zq5f/8mYf5B4/uXff7/utvuImvuf8CE+OZTMaITTr7hRVs6ShtslG2A+JkOg8FjCoHIWKiUme1vfn+HI+wt2iY1w1X5vCZh6/yQx+9xtO9pP+tG44/+NW3cu8ZpTh9ntIGNicjNgtHUSRirDPLcbb+SOvSDOfkcRLQPwe4PcTYzX/GoOw3gdB4rtWK8Z6DeeDXPn2Fv//LF/nP8+PHed5+k+XrHrqDl48NZ4qS8akyzSSbyLhwjI3FVAXWGUaS7AhdvqhjiF31p5CEXdrnACutWMsyogz2RF3xrVLwMS5JPZnsZSTN02s+74Mm0MxrFjNPDTx7MEMbuDpTnn3iMn/xw3s3tJ7/7Pe9gnsvTBBrOT8tGFVl8lvOHtoipqtGWoMNn0cBFz5igLn3xBDYb5I7Wag9zy0Cpgl88pHn+Avve5a93lX2ss2Sv/vVt7B5fsx0ZDDjiokIZmTT39YytgbJ8p6lkbyWSx35fpW9CmgfZRSz+tz13LyPfItj57lusLR9nkF92d5QmiYwD1l5L3h2Fg2lKmILCgtXDxqMMbnNYDClJQATgcJZJoVBjaGwKSFqfdEFuI4B+pGR+3prqC9wJXQd9J7FYYYYf5vELa8F7WVe3TH0oP941Pfb65kr61sJLcrTl7L1mtQkNSgHTUIDfVC29wOz/X3+1k89zo9fXT9++sdevsk73vIyzhfCTITNUYEzMC0s1llKmwyZTObgSNYqgMQdcqSkJOSEOxJZeGjqQIyBnTrSLGouxYiZRR65tMPf+cWLfKpn1/tAJfz33/gK7j1dUI/GnK8s05HFFpaRJdvTZlMmSWI/siI+c/J4cTzs937v937vS6+H3toxCiEGoialrUW2YHz6uTnf9TOP88Qx8POWwF9+6Czf8LpbOD0ZcaFQNjYrrLFsFo7xtKSqSsaFZVTYpKSGUEgmqQAuq6y1+tJdtZN9mpcz3csZX+lUyCTro9NV8a0kq8mflQhbYE3yLG/7ncaa5EduDIVVgo+EquCcEa6FyE89dmMa8w+dKbjjti3GYhgVSePZ2nQMbf88ZKnOpkkVYozLanERkoDMXgjEoOAbtmtldrDgPZ+4zP/wq5fpb2XfenPF933d7dx0qiRMS8aVxTnH2MC4KiitMCochUuErVZfPLHR6ZSsBlVCx1yiJ1u6jCqd45wc5nOt/NqAyCU3FMiv13ReF6LkhkLcoOPeU+xrT6ZbAyOUrqAoLGoTM0CsZbNyzI1l6oSxUcQIkzLNNhubGO3WLjfpvivfukXqYHLoes7HrYAcszpynQTqsNTsOmWbpfRNv/JeByb0WzLDnETWoDfrMwvp/d2NcOVkW2Pi6/jWN6HxeDFo4Xj9K85yb6E8e23BpSZ96u85V/HdX3Urb3vNmTwy5rClY9NAWSYt9sq1gTTf88YMRHWsSQgiuUonc3s0m9j4nH3EqJhomYwMVixvuHPCM88c8NksSHMxwOVnd3ntuQmnNuBg4ZHCUcQGrzYHcAPEREKl5+R4UqW/qB4vOVKcZsOE5GMciSrMZg1ESd7VMfKTv/QUuzfgbvSnXn+Wu27aJApcIHCqTIz1cpz656O88Ym1GLv8PZMNUEQkMWH7qmL9bVsOb2EDl2lZ7pbL6ijJgbabkLYOXyFiDDhNn29ChMqhqtQzz9Z4jJvNueQct1Y3TsaZYJgo2JHhQITTRgBD7SOlBZ+ky5O+eIz4KNR5RLAgVemzoDgf2KmTY9r25QPe/dg+f++jVwef9Wfu2eItD55lbzTm5lHCECfGMCmT37oaS2HJGvOaLR+XCIfkJErkcMA7ajxqHbNajoDSjyRr6edSkd9owD+6Qk/XVvo8m91zjEATwUaDqFCopHl156hi0lnYylV68jy3FJKisc0V19LY5PhRJIFDbPH2sPSIklyfRz4U1+cRvWnAVhVOVhKP5eha34PlsC+csN4UVa+PJqwQ/1kCAjnJUoLmJMsopRhoIFSOjQYKp2w4y5tfdzNf++ozXFwoZ61hNCnYaxq2JhUUwlgFdalFp0ZAUrAu8xQGZFc0gWDAxJYrkCrmRhIXpzBpU1cVTGmRGqpRiXGBWaOUk5KXO8N3f/Wt8EsX+aVrSZnxF655zr3/It81vZNJFWj299meTNiUAMHiiZTWdJwOMYkBb2TVsPbkcRLQXyD23pLSxDk0KpPgeXru+ZEnb8x/+GwdmMqCqR9jJyWMDL4smbrkPOVMkkTNUTtZQEo2LckEFTqo8oiL+oigPtgkZaWibHWvs461qnZWqBoFq5FohFIVLSzEkm1RJBpubhZc2nCMjTCLxyc1F26aonhMNJSmwIohAi47iEUFQoJ4m6A0i4ZoDCYou3VEokdVeGq/xntYxJqf/8w1/t4nhgScv/TAJm9+8BxiS846TVaZlWFalpS5WiyKVp1OBlrdrcf7ukB+IyF0nbjJUeSnQ4HkyMB93DDbC+qAdcF8eKw6qNQNgjFxqdEfIyqpz0pM1VuZSYNWE/HSSmYsm6USXqe+JtdpeB+R+HRa7Svr1Wm3tLmqDpOUo7b+61foGVLvJ2+yJMO1OuxyBNTfyr2utroOBev+x61W7Cucgf4vGDShR2qRqMxLSxmgNoGygdoIt08clwvLLWXklBP2Q+DWjRHBJStlECbOYYWUfFl6zPreBEY7Rtq2oTRFV6s5y4iJKBysxQlsFDA3woYxjHykLtI1cWFi+M6vuoln3vMkjy5Spf6vn51x7hcf5ZvfdCcmFEx8ZE8D1o4Y26xuKCmJAaHQHrnwhCD3oniYl+JB9zW1xQnOGZq6JgDb+/Nk1XkDjz2NjMYbFBsVkzLmSidRTYosOpIIMomxXmQVpVaMpO8LLr3SXGQIy133z+oP6EkumsQoNTngiRGcBZNnqY1JoyyFNZwuDVsjg6lKJuMJf+JVp489/7ddGPElFyaUtmDs0iZCUFynO665Mod5E2gaz/7Cs1c3zOaeHR/YO1jw6G5D7YXd/Tk//cHL/FAvmJfAX/nSU7zurrOUdsTpacVoWjEZJ4jfWYMtU78wy1cszz2vd1dF9iCQ1REzOab3fVTlJkdV7Pp8K+vPfTtrRWKXQHILbvbRoVSRGZM0+J1NVZwxiXtQWYNzuf9q0r1RWkl/nMntHOnW1cB1eQZdgNP1wVLX9JtZG8yHb6zXSdQPNShk6ck+gPwHF8HyAHWgt09vNRmMXEnvWekl2LGXPMXr8APpJZnS43dUNo2w2qIgloaxhdpZRpXj3IbDF5bp5oSNUUEFlIVjNHEULunqF7lnbiXZ9662hiT7UFgZBv0kLSAY57pWnTpDWRicBT9yVEahcrjNKWe3LH/5a27l5nIJP/7o0zU///HnmNc1LGqaWpk3ysJ7YuueSOrXex2qHp48Tir0FxzS26olxNRnRR2qkc3qxk+pcTYLdXhqnVA4x8glwltsN1SzYlYi9CazOdyzfcF12bqI1CozpUzYZKEHUMpsNBMNjBzsGovTQBGgKC3f8uBZPnbxgHddXm/b+MqR5b97653YkaMqhNoYxlGxhaEBimwg4oF53VAZw8FC2as9jQreR1Qjex7cIjCyC3764Wv86Kf3Btnin3v9OR665zSTrQlFJYxHZUoenFI61ynSuYT0Y+jJr64hva3rhR73/6NG0tbCrPr5rrpf2HU9tH8ZqJ93UG+LYKiAS/q3Ca6lHe8yS8Gdvi3mSnK0eroDrtlx63VUBa/XzxFkzfoO6uwW1m5lWDvC27L8l1Z6uP8da7+v3k+MdEg+7WV0GdgYVOOaMwdhOSrX/U5vZK7bI2K6Fx0Gialp1vITSiK1CqaJRJTTgEcpnEGtJj5DqwWQIKnlPdD7TgwQlnfCcuWys6JR6Yi5YoSGZLWsIlQuXQMjhW2vSGwYjSa4M57veegcf+N9F9nLi/C3PnyV+26eoLdYbiPQzOfMTIWLydDIGOlJFdObjDiB3k8C+gusZVp3LUXQOiAjh208k40Jb78w4icvHa/SdNf5MbWBDSe4QqhioImuY7CblT/S69n9RhBBlgWIdPCmEc1Zu0GJVFE4kIIRAZyj8oqdWmaF8Ke/4W5e/+Fn+f6PXB1UGn/kzinf9qbbuX1SJsMTAhVpVr7RlOUHIPq0oVmxXJ0t8AvFLmr2veEDj17hA4/NeGrmuXkElSv4fz47JOL9tYfO88Adm0xMgxPlQlmiFioLpWnlZen6udLqSCM9hEPW9jLlc7x61vdZP/9V941V5avHIYMRL10RpemPXbXhzBya65Yhj2ww3ncD112f8X1MlXojP9fVEbOVarmfwwpLvfUOkemHDO0FZUB0jTxN1+fWw/B7r4WxNMahw9lFddAL0wxld338FjGQ9NlLJbk8VmkMURQXFGkz1aBMKsmpeKRMMkiUkrzenUltLrLoUZ8i0CckoiuaC/nfFiEKqCalR4kJUcSkEdNRDsTiPZUKVVmwv2gYV8Krb9vkv30g8gMfutyBJP/Lzz/N3/zml7M9KijE0DRzptUGPgZctASNefw2WQPbThTpBHr/opa6L7Wxtag97fYQ0ZBGMxZN0jzfXggPP3KJd/zUE9d9n//yrinf/tBNbDjLdGtMYYRRYXDOMLLCZFwmuNI5XI9d/cUUU+j3dYOCxsTqr2OkrtPYzCzksSZVxtawWwcu7i6Y79dIHahOV5wZWTbGI5wzbGigdpbNyiamC4knoEiS1K0b5nXSp7+8M+dTV2f86Hs/e6wn/F984DT33r3FOVtQTQrOjQtOTRO0X1YZCXG221iNTSpYrU0ma4L59cRf9AbC8BES5L9h8+XXD+erx7b8n66kIUNxlKFIylF3sxxraM/ACbYvAHM9xzRZs/aR4bTAYancpXHKQF99TTq1ank6eDb30WXwagY1+SCB6KR2VzzflEGPupcF5Wo8j6gx9FBvj0tXCAOteqKqojHS5EpWc8/ZtoW4aNdiSohLMkdREUyusvuCOtqScPvSdtpLbFqnw7wSMffVQ4zEkLQzmgDNbMF+7dmpA7ODyLyeETz8xAee5h8+tkT0vvnOKX/od9zGnWMBWzEaOc5PC8qioHBJpbGd8GlbZCes95MK/XkGM7rsXFVpYjJP0SgYr5gQue/OU/zNL1/wV3714toN7g/cXPGO196UsutRyaIJUBiMttmxyWYj6YaMeRTli20huMzYJWtHSyLPIJjCMTeBEUopytgHgsCFScHEKQcbFRMicxWmZbIMFSvEYJgWDkMSkbC0Ou3JQ95oJDjDzv6CfWP50X//BP9+5/r2UX/i/k1ed/cG03GFdYZTY8Nmmfq9xklSzOsRs1qFMumrt61E5utJsApHk6rkOkH9ixPEh6F8KWvaB9uH3OxhKNUVXvaK7accvl/aOLWWMyBDnFnXJDlH2ZOulcIdnKGsRUJkJWCuhwdWSIHS8zHvHZjpr1JPLa6tuiO91+TKOhXbOpSq1eXai/bPILHYpdf6aK/T1iUvJQo90p1JjHSNilpDmf8dRZCoiJVcnJjEkclBPuZ9zWYYvS1gWsGfflDv1PJYehl0/vEkHwCjSmz9za0iUYgGdFQSojKNih1HjHXsziKve+BWHrz6JB/eTff3v35in694+DlOveIMW6egMqANBONxpkjv1XrKx5yACCeysCcB/fjiob3r2o0pGQUYxCi6iIhxBDxbpWFb4Wu+7Db+8fkJP/uxi3z0SsPVOnL/puUr7prwmrvP4ZxlFAKLpmFLJImYZJaqOlgExRGIJrHcjU2b7ouhS9SRAk2++TEEDYzVsigiqDAXxabZEqwpmI4Fl7P7yggxBMS6JCRj86xpK9yhEGMaVfMIvk7qd5/62LPHBnOAMzElDpUYzhQFEwFbOsQm721jcoXTV506Jpiv63+zJqAI64lvrFSMX7yK/LBb96pl6PCcZBCyZRDwZS07u6voWFaFMgDjh4p5Mqh0WdHuX79Ucp2fHWU926/Wu6p4Vb51Zd48iamQg9fKlIIMpV07Qlsfqu734ltjERlW5atz6ZoXsp9sDebV29GtjrG37PO3zbA0pZIKA5u9G1oEqiXt2U4fIX0Hrj3WtvJe+Y5NDuJtkE+gvQ6GYWmDvmQ5aoEm31+RiEQoLdw0rbiogjQREUsoLDfXc/7wl13g+37haZ7LPboffv8Vbt1yiEScVtgpjGIBPlC5ND0hmpwNtfu+TnD3k4B+TDBX1Y69HrP/eYwhzVs6ITYR4wqi9xRzxcTA7efH/IE33sFBrZS+YUfTnRVQdueeGkXE0pRQeqGxOaP1SmEi+8YxjUpllKg5M+bFYR/YbppG0nhbaS1BIkYTM99ai/ia4BymgNgECknzqoUBKUtKl8RrnATEOCSrTiXXNKVWRULEIixC5Ocf272hY3tkX3lQ4JSAsx7nCkbOYNxSmMeabDpBb3xqDT9Bj4HPj3qNHlG5H/vGX3BwXY/o2ffDtq5U5DKA2g+dRC+Qt+plrbJfG/C6SrU3bmlyuJCe1v1Rwfs45GPddyJrnh0A4/0xt57aYh+K75PcWE1pdN1o4kDpgSh9AKLvvJJm2lmjLtc+H3tEVNMLlCEH1PZzTW90rv9l9Fnolh4xYZC06GAUr/1pzD/Pt2LHkWgZ9R3i0iU1bTKzRFokt+ZMXmSXe/xGDIsY2KgsRktEBWMCBxTcboXfffeUf5LJrQ975Rcf3uNbbjvLfq2MnMdbx2kCtTGMLDQopbaSyydV+klAPyaia8+8JPWFtMu4HckXeKFgYsD7SIyB/SbiNBG9dn3ANwFfRxqv/LuP7PCezx5w0SuvGll+510bvPn1t3DLCJwoEc+iTnOhPoSsZx4xGNS+eLicbWXb7kFGDB5BQwQLakpijIwVohgwhpExEEOSBBWDNamC7zZWm36/MHTZfUnN9qLhP169MTvIT+01jCdTfAmbWGxZ4aMybfuOfWGerh06rMzXzYdfbwztOBnRzymQC58T+/3wXDnQ638Pa+HD/t39ka3Dmmj0jHOSDClZY18VmkS2wBnDQlsyXVLds5l5aLPUQr9nu27J+jKqumZG/9Bcfy9waS+QLcfOegiFLind/ap7laMuA/LbcJQtl8+DFGrdBEl/Tn7tsefgbdasQewFSM3HH3UJB0RaJG/lepUu+ufTzKTFFWGEdrbciCTIvlWS7K1daxvc+loYsj1whtjbyYC+Q1xXiETFkyaDpqWgERqvGA9SRy6Uwtfff4GPPjnj/bMkm/0jj+zx2++6wt23bDIvhY0Y2WuEjQKijxSFzVbFiRynclKlf7EeL8o59KVjVjYt6QJ6lnzNxiDJsCLdUE0T2ffpglUFo8I8Bi5vN4yNYF3BI895/ux7n+Z/+8wej9WRWVT+04Hn+z9+jT/9L3+dpy/uEec1RMs8O1tpVGKIg+N6sbEITZ5JtzZV34UzlC7Np1fOYKyhKsvEdJUkrVoVNs2nmqW8ZNfLViWQmLB1VEK0VIXlK89XN3Q8D2w4zhployyZjyyFBpx1ad2yyUTrkmaOqMzlBqBe5fAc9PWqxut/cfo8npIbvpKHVe0QM9Aj3lMGlboeUcXTzYe3MKzP5jlNE5g3ycRFY2QeUgsphnz/aLIdXviYjXZ6Ff0RZ5rg8SHrXdcwFKT/09V58B7Wvazi9LDmrKy/Cjoof6Wqlp6+q7DCzNc192x/frt7XpciO23A1raqXyYmRvrtgXaEtUeuW7F1ld7XKLQMejphLF1BoyxLp0WyAdRQES8lG0HpjGW0V+kbZMklyFNA5LaLiiS9B0mf64BxZRk5MBEmlcUrjEv4/a89tzwuhXd/co9FiHhjCLMFGiJN7ZnHmPfcnJR9UVpZJ48XdUCnC+bLijwq+KCoRnxU6pCq8ZmPzJrIolmwHyK7BzX1IrAza2hCIFaGa7MFT17e4R+8/yLbRyhFfKqO/M/veZzt7Tn7dYN1Di+CDwFjE3NVs+jMi/GCNT03pM4ZyRoqaxkXSTSmMEKVFHOwNomMFNYmsZGeDCjGoGKom1S92yI1vR+8aXJDx/KKW6eojRTaYE1BVVls3pRaUZ7Wh7y/ia+D0YXrO6H1BTd0tU87vJxuqInxAptC14HYWanHc/W04vQthybO+/3zFbhdl8hu7HwNFB9TEJ+HQK2w8IFZE7E+UvuG7RA4CEoIUDeBOgTmjSfG0BkeaVzjUCbDz5Qjky7pl+8rfIVlWa59xnjHJO/NZa26pnGYyNgngS2l/LWD1Y2sSQS1x+DXPjquy8C3Qh6M+duJHSdh+Lkx/0KXIEjvrNuefX/GnN44XS/haZOl1mRFNVe5PdJbzOx502nKZ9930shbR0JUiCYds5Nc7Yvme7CVUBZCllWeTkpcVSAhJOEqDF9y84jfddu4W79/8dQ+n33kGmF3weUoLOomCctEaGLsiIghWykrehLXTwL6SvXV26zSxRypA4QQ8F5Z1MpB3rRmHuY7u4QQWRC4Wnue3q1ZXLnKo5drfu4TOzx1jL77z297fuWJXaJG/DxASAz3lIQq8OJWRBJZVusuG6wYm6rwogvihqK1RDStGl07ktcS09KdWqIYm9zlEMuXPXgrr55cv0vz0NjyurtOU7qSsbGccrAICd4d92066VmYyjBgK9cxSeFor+p+gF+tjr5AK772zfU6P1vlbwtDcZR1Y2t9n/QhdKxLK+GoRB+poyZC46xh1kDTeGofmc0CcRbYnQVmi5pdrzQ+4LOXtw8QwhINGxy7Xn8sUNZdiOuezzJnsmJ5uuyf6yGM4vCKaK933nt9L8grQ8W6NiExMlSDiyz70H2WQuunoGi3Qa4atwyTEjoBnwFHL2qXaCzFaJYV83LenS4wi7YHajKk3yMC06m7doiC5mShiStXVkzvF7uNPpHoWoU5YwxOFJvd9s5UBnGOUWWZOqiM8LtedWoA27/zYzvszyO+jgiWRe1Ta6drR+gyH/uC3ncnj6MeL6oeepegkyqFtkKPMV2YPoL6iEbY8x4/q6kxzGtlvw5479i7usuTB5GPP7nHB67W/Mox89Krjw9dXPCm6PGFo2lqpq7sbFCDtqzyF3Qms8oAACAASURBVDflo5uR7YwklLYj2Ic5V/uLonSOb5WBXQulQjSRsnSc1znf9w138dfe9RgfPPCHPvcrx5a/8E0v4/zpipE1hMoyVzhbCK4U1PZV4FjrfrYaytaNqHEMDC83XJV//vTXDwfy1TGzZZV+1BjYsNfe47+vIRS0AckraTPP885Nk7zRZ3UDhaHwsBNrKiNsezglCdkylSWIQwjpe3cKxnY08aWb1uFlvJF9WleOudNTbwlkPWWYbhyt53/ab5MIOlBy01XLc9EB96JltstqAtQ7dpsDYzfL3mPMS9epT8dqehfr8jU50ekc/7Rj7LckRCvteG1vxr2j2adiQTpO/JLh383f6zDNi1mP//Asrg75CL3kQmM7RpekWq0xhBCTqUwex40GxqOSzaZhZ1/wBczmB5zanPIn76n4Xz+duDM/s+/5xmf2ec24INSKLcf4AN5HpJDkA6F0x20+DyqaJ4+XcEDvgnkWYgg5mCupj90EaFSZH9R4r2xTIHu7PBUNZmfOL3/8SX7oM55d/8JTQ2kavJagyhnjktRiiBRWOm/wl8oleohwxtEjRV0iIMntzEdLKbAwUOXxQDsdc9dtBT/wrffyvo9d5H2f2ubTjfLaDcdvu2eTL7/7DFunp0kP3ygTkyYEkjKPyS5q0lUq6+D147TW9QgYfm0weR7B+PORjPanx/v1N2ukYHTlrPrBfnBma3IOzSVoCMmIg5C8sfd9oBKhrj3Xmog0EcWjXnlOhUosO6UwwuIaYU5g7CymCMy9YYxgnF32lFmyz2/M9HUlM+8c0pYXox5KbQ5/cdoLkKiuTYZ0IFG7kqAKhwRl6FXpMfZSp9wGiD2S30BeVpbUxRCXc+iRZcUf8+u7xKRlpa98jzowwskptsberHyLDqTzDYfaEu1yJFU401bzKt15DWRpe72SiGLM8toRSf4QTVCcgegDG5MRi7DgTNNgp2Nms8iDd29hH150E0Y/87HnuP++m9lZzDkzqpmFSGlLXCNoaQkimBhRZ4dygyeP31oBXXv3dEuECzlTD0FZhEhTB+Y+MA9wrfZI7bm0H/ilT13iB//zNer4uWM8FyYVZYxYsewJnFFwxqTAHqEw13eNeqk+um2zq54j1sAIQyMlEPDBc3pU0njPG19zjm963W3s+oYNZ5jHwFY1whiYWodaEsQvEWstLivtDSr0I0LrOsj9KLnWL+Yo2mpdvhq6103J66EV55ASXIdbHmGfrpkAF7MSWQu7mwA7vmYRhK3Q8ORMed9HnuG9j895fL/h/tMVX/fKLX77fWc5PS0pxKBas2gKbGXwMWKiSRWxNVla9gWuSI901lW/w3HpZbgS6SERKy8azJGvzANIjwWvWbiFYWdMciU+gMNbURbTSrqmY7adQE0/L1kG95bAGVWXYjUtmqCsKNC1bxIZEvl0mTnnY7H9a6NNOkLrPZ6vpX4PPh/rgPzXwvtGem0I7fqqkd5onU36FIZknhQwGBepvLJZOZ6dO+xsAUYYlxv83rsXvPPhbQB++rkFv/PxS7z+5i12guPmyrBoPLEomGqkiJI4OLrkCJxU6b8VK3Rduk21jFvR1C+PUfG150Al9W32Fvg68ImdwP/xi0/wvmuH4d+zBr76TMWrNwzjM1OeeG6fH31sduxh3H/3KYyNVOKojMW6BIVZTZUrIr8pg3lbzZu8gTqbOm4LAlYMZRmRGcxjw4XJGJlYrsxhs6qYhoAlkeds4cB7rC2YWlBbYEU6l69Br/II0PsoBbJ1I2o3Dq9/4YL5qvTo+qMe1uyrXl86lDVZr7HaC1ZRU6Jbh7RRL+qGea3JM7ue8ytPzvirP/M4jzWx+/RPP3PAjz9zwJs/cpW/9Pa7uHVzhJaOmVG2fKAxgpWIMWZFF/74NsVgDnsdVC+DG33wLq3iWUQTpNxPeFZ05eNwhHvJEu/JoHbBu2/u0rc+7WWDbbUt2s5+d13vrsqNrbyraoKRW9W2nvZ77KEEbesg9oxlTHvsRnJvXZYjZj0hmS75MWbJIxKwnV5ACsYqSjCCyQevvbaZylAGN/RgcBXBRCXkcj3mpEYwOKdsCFxZOOqmogqBpoi87a5N3v2ZbXbyGv7Kx5/jgdtO0cz22bFTxhg2Sgg+UJSOICTHRumZx59E9N86Ab3jUGSFMnL/HFUaFZqcqYdZw7W5os7x6DMzvv89n+UzvQ0L4IHNkv/qS7a46VxJOXIEI0xquPPWMZ+48jT/Yc8feRx/8M4pD9w+QW2RGOFW8BEql2RL5TdxprmsaJZa6lGUQgSfq5ODUcHYB+qoGFMxUZ+EeaqCKUopwkIUNyooC4exkpykbFo502P76jEhQo64RlZh+i9WMNceO32dxCkDexVhSOPqB++lAqGujKSt6z90hK8YiRpBA/uN4mNyD9SF55k95W+sBPP+473Xas791GP8ubfdyfjUFuMCFrlTPcZ0pCtVGaqurU2rhnjKcG5cVkXcu2uMPiEsv986hm5fg6WFudvkQRlO8y9ftwziy5GuZWagK0E0zXT3vklhoNSWFNqWGYRmhTurfcLaEoXortUVsR6RtL8tEQlZBvp2JXpVdfubluEsf6tHrz1lxyW5ULtZeZPH4jQu4XeTIQCTj711SrMmiUqJsVyYFjw1X6ARCm8YTeFNN1X8+LNJ5/3/fXLGW67s87qzY6aSNOlrlII0jy4xEoxJLYEToZnf0Id5MYUUbUfUMqzlFXyMLOqGHR85aBpOWbj6zB4/+N5hMH9obPmbX3WB73nzzdx3W8ntp0a8vHTcOS3Z2nDccXbCn3nzzXzT2fWz1H/sjjF/9GtfxkZRJqOSwhI094CtSZuJkRtyq3qpPQaJSs/LvbDJQMUZKJxjyzlGpWOjtJQ2acCfKWHaGtpUhknlGJcOh1/6ubcV+gqjXThazW0dUVaOKPhe0Al/Tsnn6ljW0Oq0L22ih9PWlfCnK9S5I46xQ+KzHkNOA+posBqog9LsL9iZLfiFDz3Drx8RzNvHv7xa8yuP7UGzYBYEGxMKFTRmIafeDPahjWIpANP2ZFdnuKVn87lUrFtW8wNGOnLo++6Nlg9Z66uLoz3/+N6892GHtf7npGOLsqoRL127D1pSXUYLWZLjRDVJRK+bn2zny3u6863dssnQf+qdp0AXWrXH3GZpWxHLc5ZOjS7298hM0O2usW5sLSUJIcZUlWuSohVJvfmoy3l5kaWnukExWea6MnB+OkovLoUYIl999+bgCvhPH7/MTohcPJhjQyTWniZGYsyCRZkD9UXshZ1U6F+0ylCX3rqtIpwgND4QQmTuIcxrrMIndhf8X792kQ8tlhvW2zcN3/GmWzg9tmxtjNnxwlgCVVGCCGUEHwJnz5ziT719k2985Dkef2bGsyHypadLXnbnlFfdtMV0VLDI9qHTqBRGscYhWaa0C3i/iWD2tQFTUiCOKjgUxOCD4oiodUiIBGBiE1w5FShIozaSpWWNSVB7q9duDKxrVtyIIpyuKVpfuEdgH6d9IWvWH63qT45rFzCO2sQOn6OuzzYGEqXr1yXESIxZOMYroWloonJQK+96dO+GzufhSwvecD+MD+b4qWNkS1RT8toG5fYRGQrkqPb8zFalVHtCMW2PubNE1d4aqvYc1TjGda0Hufdf2xeo6bFbIu1EinTQtelD6bqs9kX6KgG52u4CeW/mvPf9y7L93lX/bWLR/jzGVP1HTXtV6OsO9OD20JttN70gbaSX9OkSOeumbXKw1k51bkm3VEkS10swpKeZb5YL59ueff4+nAE1lvFIoLCMFpE4HfMyW/LWjWu8OyOc731ixltf33BQlpwJiWg5EYEQCMZmJMDSy/dOSvTfKpA7K/7EaQeJhBCwUTlQxUfDtcbz65+4xI89s+yFv/XCmG993WluOzehwWCNYbIxYhxrNq1lZi2ubpiPCpzC9iJw/92n+NJXnMfZwLSyoMK4tPjScSpfeKYsMDYQjeBaKFqGcoovWVgdrruBLqF3RU0ydTEiEJOOtReD1YRcJKJt2qSMJIjdkDZPk9sUbTBfJx5zpNY66/3KP3eI/XML5ro2Jer3w1njhnZY6HW9pnvfb5tD7cfBzLMRNAgVyr7G7hdKX/PBmb+hc7q0uyBiqY1wRgVP6tWWGcodJFLtz3q9UWUp17ocI2uhX+mpnNHR0s3KqvSZ/32UXvvftVmy5deOrXXfztKT2+jq9S4dyU1l+bkiPbRF40BBTmSpuhb1cAq8JOAl7kIYcteWV0An65q9KLTXTug+M7065ivDdKQyRWMaPe3Pu3cWtWKWCVLXGmhbAOk/NhcjPo+wtTPv0RhMjEmz3hhCCBDTmljgjtMTHr20R6GWeVzw4O0j3v3JlCx+slE+8Pgu3/iaEXWMFMHj64CvstO7kNjuYgbXy0lM/00MuS/nzpfylYrgozLPIjDbTcA0kXLecHF7xt/+8LXu9+8phG957XledtOYog5MSoubVNxZKmc2xoymBWcrRzGp2DBgNHB+WnD71ohxBWe2xmy6golzUBRUmYFdFI5KIoUpKDNUbGQpQPFSDuQcAWWvY423SUyqsJd/SmOorKEwQmklidbk55wVnDVYu/y91kntesezDv5fZ+X5+UXv9Aae1xUvtMOV4+FxMw5B7bpWKPWIxFaPruoH0yBRmUUonGUeoM7F19dMbyxPv3OrZKowKgy7Jo8bYaizAliHhORRqrbaXkrE6hIP70HXLSzcR9/WidkqwwqdNcqhIqtwjA7HG6UPqR9WDmzRhU47vi24zbLP382UL/XmBlKyGmPnoja4fnvZZezPpmv//TJJrZcctIuS7o1ETkukPOm5vLXwevZNl6GaY5JnTuNosfvM1DZp2wktWJJal9pDW9JMO6pZNx4CS0U5MYbKWUZVwZmtEXuNZ3Nc8lWvOMUptwwZH3l0nzpE5j4wCybpIYjgfUz8gi/UbXvyeHEG9KF4RLt5xE7jOKhiVMB7ZoXj00/scrmn9vbHHzjDy86m3cec2mCjsGyNSmRUMi4M1jmwhmkh2FHFaDLGOotzjumkZKMq8OOC0dRxxiWf4lHlKAqHqwoqZ3AuKaytBqWX0uNIAxPtbbh6NAJsJMnJWrMM1v8/e28ea1l2nff91t77nHOHN9TYNbC72UWyW5xHDRQlhrYmyJItyZbEGLbhIDKMGEGCIEYAB3ISMIgTyHEg23/YcWLBkB0BliFYMiJIshiHohSyRVGcSXEeuruq5xredN+955y998ofe5/hvnpV1SRbUrNQV1Cz3nt3OPecffZa61vf+j5r07kprMFZQ+EMhRVsDuKDvKvcthq/nVPaHWOvvGgr8A6V+bqBqRxTgY/q6yMCrrdHIW6ZeY0nn45oiYwn2owIS68YcQQ1LBDecuGFSfS+8tycOrRoDBRicYXtDTZGU2Pr6mfKTQppfeV7zHW9HeHx2J75MWjEOFrLiOK+xlwfwe7HJYdklji5+pUcRDUH486VTUayeN08ejxy4/eiLeOgL4PLWe9i1xmr5ODckcQ6t7tOmEZHLQLDwEXoPiOOzkbs6ezpnhTtEo302YE0ny4xe5V342w6nCMBbND+OJJ6nCBmRMXL53prWmHF0Bys2PU17zg/yMH+xtWa3T3PYVOj6ll5Q9P6fBySEoega+569x53c4XekU46GCoOZJ/gI6sgXG8j+43nuf0l7//8qDp3wiMPnmRSbrJ58iQzEebziq3CsFE4itIxLSyTwlCVBdPSsVVZtgtDVTm2yoKJFbacYeYs5aRkXjqK0lJJWOv/WhnkSr+VqvK1amEUvG+KEEevydiFpt8IJFfs9EYuLotTWBkCuM0+zTIyyjhaMckLgNhvOp5vpMD+ps7fzXafciRUHXUQH8+hHzeBq7f7DrcxfD96PqJqIj3lP04BkZCCgYFHXrXNqyf2tt/vR85VXDo3A7HYIBQSaduIRfsRKc0jpDHPvPcGLnFwP0QHIajuWsUjwT+O1l7UdU314yZH5AiJ7uiT1gTXbhoLkLWebTwmc4wyBNPu+E0OgGPIHZKEahfAfU50otw8x2AyXJCq3IGkF8NYiT87pMnIaKVXokvVdgrCCVA3fcAe3bIy0pWP6bhC35pJSUQYZ2D5no2j44oy+u45wejY7h22EzS1dSZOuLhV4J0FV/EdJwf0J6jymSs3mLoC0wYCIaMBoe/Jj8mc9x53eUAfAk83gpFWqUZFNAn+b5mIj8L+jUPevz/0Bt/98CZnti3TKbRtiykdU+ewNvluuwwDl4XFOMvUGVxpcaWlcoaNKjmRzSeOSWF7mKkwQuFchtqH/38pV+fdptltujFr39/6/waILjGmR5t13/qgN6NZf+XgGtYrvvXKb+uiMXcqqo+rxl4aQjE3V9ljhrquhXA9UiMOm7ccp8N+XI+hg4P1TgmwjrrFkjT2o7LINna2bWijcI7ATz506yr9L52q+BvvfBnzqU3kqVJomohB8UBHkA9xWCcxK9P5PsCTHd7Ixi4xm3N0gjcZEs5rMWh6reb/DaP3uenUjPv348p/5NsyZr6PV2WnQx9zYjDuL3emKF2A7tnnuVI1fXFxcwvlKOQ+1owUHQhzktsQXbLVCb2odvK1g8bGIBorQ699hBBETWpxfQKxxsgfCHmGo54wg2uiKknqNctppwRFkwlMhu47+1chie0YlMJmwl2InN2eMZk7zhTCay6UnKmGu/jTX1vy5IHn6n4DbZt18g0xxrxGbr307z1e/Id7KUSj/ibOggsSI14FCS2rZcOSyFee2l172XdcnGKDUtqSaeWYTSxikymJtd2oh+mhfDFpgwnGUHRjHx3c5FIvK9186QYx1vSQ5ksxmK/p3veb7tgda31yWG4yhh7JaK6pbRyPiRtZ1ywfSXGvAdF6fLv5ltD60eL0KMT7jZ0Z+SbOq6xBt7o2YLZ+/tb/u06bO2q6cqvqe82Te+3360I1OrLzDJp7nVFpIxgfk4a7KK2PXN9b8dnnVmuf92NnZ9xXBl7/8i1e+cA2E2dwGNSCBBAb8TgKSazsNiaf9I49LZrgXCRNPiQodV1BJjKouYW8FoxkmDgO0qcdRG0kj171BLRc4csoUMoxEsF9MMwz2X0AHD5fRuS3saxqF7DHN0TMQVFjht7zPR87FjkJ9jaduMt4Bnx04brn9L/rWOy5Px2F7KA2OtZOa52hzy+ja+9IHvdxdPzpddp7zouCmvzeGjMlNZ8jjSCSJFnzuehH5br9Iwd2r93+F/N5j1BYtA1sb055fq9mRy0/eGbCv34yEZN/7XrNT6488/smmLLg8LBlY25ogNKl82h0IB/eE5m5ywP64A4UUZLP+SpHBS+G6AStLR+6Omyn31sKcnaDMK1wJoBYJgJVYZBMBimMrPkukz3S3VhsgjROFXQgvdmRDrK8RNfeegDvHLdiX7pE1na+tUweGQaueoKQHpmolgEtMxmeHJNsxnXLGqAso98duX/lDiFXX7QU/htlsesx7ttD83ZcteuIm82R190s5XqbFENu98f1Xq6OgnqHtWqG3ltVfIi0jbJ3Y8Fnrzb82vW2f6e/cLrkJ7/9NBNn0NJhrGNSGSoxGOfAKlK4FEiiYmzuB8f0zX0HR2dhkjC2He0FS9III2Fw+epG1OJIVa0LJJg0ERFNt84Yes4qfZIvvU56t8Zk5CIr/Xk4aiQzXndhdLV6hnhXVeeqt9eZ0GGkrBN9SZcqs8FHCYkwEHptX0kPOutRk0FLpxbXkegkpukR7aQZczXe7V0xDvdaq4olFRtJ+GXsRGswGokmm8gYCCHtaeRxOFFJvfmoBBlL1caBma/Sy2yr5vMVIh7BibI0wqwqkI0pJxY1rz43gxzQgyofe2afeSmcClBVJUXbUrgSjWlvDhIxYnphoHuPuzCgHx2hShtArnCiEmIgBM/yENxin0/fGCqO195fMj1scZtTbOGYWQPOEKJinekDlxll2/0mwaA01d3k1gxJdW/p+RKF1lHNUGjuuSn4ELPFbOyVtZLetCbkIe92VqSvAJykjdrkjchqguH6TT2TEqMYrCT4lVxpSG+MoT23YC0ujRy21iS6b9Ez1WP/IX9iZ1WP9Xrjph768V32cWV/a17AMRH/eI/YUf95LeHtLD9zoIghzaGD4kMgxJbnFi17vuHRJ+u1Y/i++2dELNEZTklkXgDWoiYFpnmKAHnGOaJqWUalyiNTlsSUtrk/q0AQoewU2HJQT1A6WaBG8Rp7GDl2SbUYxICN0BiTJiMkaaOqJF/vbl2Nm+FKTFrro943XXUu63NsMtI8F5EsZ6y9rLH0o2iMzF+GBKRDDDSuG6L0MqqMLF9jgqljisq9I1rMPejOeKXjHqgIYmWsWZsLijwHHzsJ2cQncjk50RhT8hSH5MlI50SZE4oYsSbrCMQ0gqiSev+WmEbZJCUGmI69b3OVn7kQySuaEDMs30bwEec9p2eOp/Z3qTZdvxYAnn92QXv/FrSBovTEYGh8GsfrrrVBEdvVHPfG1+7qCn3N9TmrGAWEUCvBwvKg5spISGY6nbE8tcFZAiYWaCctKukGMNb0FbaRwXNb1+DMm3fel/oi01HfMUQlhJh7ltA2AS8gISImbRIJbQgpuTGG0LUYsk40ecPRqDSkDaATv/C9+EXqhamMWNxZ/9pmXDRqGleLMY/YqPSGFz3KoXIs4nY8vP5C5WfkRQjmHIHU13sNR4Vibp40l5Ehyx0OW27xVY6U+GvBfAQTh6D4GGmDgg80rdKESHvY8szCs9pZsr8PH9obLIP/yvkpF85vMZk5WlHKsoColJJkPo01GQoexs0OY4KJg7XYGFIQywiPjxFn0vxzbbNKnYIbweMt0HjfC81EHxBrsCIEPAShsoaJiYQgqEmM6EISBh9Hve0O9u7cx8wajDQSnGG9cu7nyKGXQ7Wjv0XGArUj2dqOra46mlVnJLmaE4yO1Ge6azQkFD0snq+fJ1XsamQQt+kCdNJtGiRu82cFkn5DPKoraAwaAohJgVk6cRmT0IWO0JgyCgTFSRKmiaMTlo7f9MRHH3MLB8PKB5wImgsFIrRYfGjZ3pqzs1zy46dLfvVqWmcfeLrhpxzYmFTlIsqyboiTEvEhaVkUlqDSk/zuRfS7LKDLkYIsCRgJQdLNYVVRpxgPzWyd4HNxVjBrD4mTExRFEkUonKHIbE6TZyvlOI3tb9GFNCa7eU12smleP21NbYyoD6gYNHiC2NQrU6UUEg3GWipjQBIBylkh+Dzjag1tDGkDEXAIrRGmAp5uZx08m4ts4NHkar7N7+Mk+69r54csI/hf+lGhW1LdbwujHxU4/+aq8lvO33OzF9p6f/wWZfUdYPU7KWaNdRnkSDDvmOY+dhC8EGJgtwnU3lMfJCvLX/rc9f79ShG+9/Vn2ZikBHDbCTcwnLMRAixRilCjRhDraEKG1TUizrJ3uGSzSBMnrnQsfcQbx6Y2IA4jwkpIz9dUXRaFgBpaHxMJrpNK9SFpfFsDavAVtDkAlSaNPwZrqLIEadfLTqzyDMvrekJpdCDBychmTXsUKSdhuUqP2WO8Vyxcd1Alt5szDB973oiO+uSS7wMd9++lW9f5TYysSdnZXG33nvC5UhbR/tggXSNrsrBMx4hXTUlyfhhNPuaS2xEiQghka1QdjGBybyN2ZjWS+ulWsjdG5inFmNaUqOJDQkYFqH3AxIzYWINtA1tG2LeOoii4//wUckD/8spz5VpNdZ/DH7Y4W1A6iHVLXRWUavAm4iB5wB+xdL73uIsg93GVrrl3E62hXQbqEKkEVkf8zcstx6nZlDZEQqvYSZnFFKDoUl65e8gXXb88ZLZwiIr3ygrF+OSDrQpaB6wE9gKIBmpj2Syg9R6KAhMibWyxhU2jZiFB6pXCynskRmxhaCPE6PEmJQXdzGvXG7TWEGzaUJLFZsw698lMx0ruOGYiUJdciYwqIv1Gqmx5YU/R29fjsgaZjwVNOaKrrmujSesQ/XHd8lvE93Xu1O1vhlEwJ6MnMUPYIVfRdRtYNZHFKnCwaHlmt+FG4/nUlX0+N+LC/fSlOQ/MLVebFefnhlXjmZrAoik5MQPxntY5oleiBKrGY4xFrcGgHLZKrD1OYoLcFVba0KgysYqVllUTmDibRU4Kao1o21L7iDVK4xVjHTa0OGvxTSQaw8w4Qt3gqio7MkGpkeAsEcWZtDYlJ4HjGf9OcCWOER8dROU6NbsuqKeANkj+xlEWl/rqOtLI0bXEat34RYhGjvOb6Zn5Seq1czlL891hZN/aVe5xBOurMTk45wQlu7J1ff01Yox0nBdyiyS9eewY61iMxKxLH4lhqNQFaGNKAmrNrmuq+CZQ5y/lW89UDHVQlEDwiRzn1bCQJDrkHbzi9AQYiMqff37FfdsVdQBrG6pZkdALHyms4l1yiZMQEbHHEHXvPb61IXddBynTzdcRSmA6sRw0lp22pjziM1EGaFtlNk+660XuK5neoGDkfyXf6sGc0YhQdtUKyQPb+0AIShs8okLTtjSuINQtxgqu8ey0FqLHBKhUaArYiJFgHTa21B62S8NKDU48tRemxrKoI1IJJihTp+wjiDUUYnAacTFtuE6UGEMycZEEn5KrmyZGnDXZNnKs5a5rqkIvarZ+mz78sI/LMUF+PdyPnyvH5g1667pcjr+Ox7pOHTfWM2Zj0+m2K3VQ2qalDUIMgcPDlr1re3gt2N1b8C+fGHrnZ5zhLzxQcLAMbEyEhSbhmVItQSM36kC18gS7wlZTTLS0ailcIC4aaiMUVUWNcq32+EXLdOLQ2sPGnCvLlrModbNiwziWIqxiZLPIrmMh5HE2jzEhvd9yhRhLUVq2xWOsxWvEx9RX9zEyFYMjEsTmanodWusxEpP6vUblCDN8YKjLmmGK9EIxHRwvuaIdFGoHPXo5Aq/rSJhleONREyZX6CIDimUzz8UyaKWnnnrM8H3mEChdNwAAIABJREFUtuTnDfav0kP+/TieDBr1ahLRLeiAMkXNcHyMYAxRM58mowkdQiCaRtEMiXuzCgpZHvsw973364DTwD7QtkIUJYbActkiIXC2aLi8dBRWUvsH+PLTB7ztkS22CoM3aex45ZXKRlYI4gPWGaJ1PZJwr0q/mwJ6R1RTXZNxVIVaFV+3hKJA6prnFodrL7XGYBxpDtckDergPc66fJPIXUO86MQngh/IKjFEDn2kEFg2DXuNYkJkzzdwGGjrlpW1Sac+Vz8SIgdNzXxacUMVaz0uBqKxPL9saa1lo4BVHdBJwQJgEZmFwH5VMFePRGitsHJC5RxtUCaVZUKC9Btj83sKwSTYPoTYb44dF0gyRClyh374nQTnv65qXm8Cz9dduWStL77ePddbwuO3C95rR7PeebilTfRAEE3P8d01j5o26wi1V57bq3l6Z4krLOXhgvd+bR8/GmT/gW3Dp3aF+080zKZTJESqQli2LXuNcm6SkjQbAmW7ZHdlmdctB4vAYVvzhJ1yst3l6mHLVlFQ+UOqWcUhjlA0PFh5Lktgr9zgQqGpqqsXbMwLrq8M8yqwdxhpfOBLT+3w/sf32a2V+0vLWx7e5vsfPklZGjYrYX/lOWmUWkwK0DG5g4WOzMlIPHeglifZ1LFCfqeZnltukWGkTWXQoJex0MkotzRGRrKt4+5ON66WYfBMlhusUDtoPV0vk6tz0wVnSdevl0KOeXokvy5k9EBksGftpyti7NdqNDJiyNNR4zL6ABJZU0HApp52Zx4TSNyIqMkVLWokRLBtzW6T9olWhYLAMiqxVQiBJjPeKyMsRQjLgo2w5Ie3HL9+I01TfGXPc/nxPYoLW8xUuTAxHK5aKlegkvwybO7Tj2W071Xpd0tAHyXenciD18QStRiWKM1qhTn0nHLl2uvmLiat6VXAVwUuBgwuseRHhNdv9ZDeQXMhZ/YhRoJPM8IuKAc+cNgqkxh59PPP8b4vH/ArzxyCwnefrPiLD2/z+gc38QqHIpyZWpqDFQ1Ca6ExjsIsmS1A54aru4FFUcJqyaZvkWLCAlgGZQNl0tTYjRkceqSM2ElJWDU0ZUEZlSBKZRN8aJ0lZF0AovZzwcZ0jHt6lapuA5MXMrz+DSRE3ASRH9clP0qJG8+Xr//uJp1Sjg/e3CJfGc9T6zGoVT+WGHVot6jiW88qKs9fP+Sp3ZqiMCyWgU98ZckHbrRrH/nL1zxcu84FI7z70gbf/7bTrIJSt4Y6Kk88s8v1AB++WrM8aPn8gedrh+3XfX6nheGd25azleVVp6fct1kx27Jc27Xsr1b8u49e432L0D//D2n5tasrfv0z13nPj7wc5zKhMiR1xuAD3iRIx+YZsz6A9dT0oRU1HirU3CM3o3HMseZ8N4KpRzKvLjnL7fGh5GVM2JVc9Q6Mdhg5lY2FgUwiCaKdrGxm7udkoJv7Hju/6QhR7D7eokRj0rGbhFx2fJZO9U1JKnfkyl2VFDhzC0w6Ce2cbCRxmTS1smrSqHAM6W++jTRW2A2RSWw5rJNaZonSBmXllboBEcuNlbLbDNfic0vPz/7BVX5gY5e//PbTnHBbVIVFQ56SaYVWDWIjhbGZZHivSr+rAnpvh5DFJCDrGUtkLsINsZjKEYqw9qqnF56HVHDGMCESXZmkDRnUkYYb/FsXdu9NLnKlpgptUJqmYemF2HpCG/hH77vCv/rquvDOozdqHv3wc/zY5QP+8ptPIqLs145Yt3ztYIWVkt3ViqWWXF4q7aLh0gSCtdQop6cONfucmMJ9VcG16ZSHt4TVQYOdOqrWU8cIokxr5cCQSHaTEmeEKnhUXC+cUYoMvUONmXGf9z+5STrkRUqHbmXXerxn2jG+bsfPlt+pFy53BAuOBR86NjbaVeVJ4COoUjeRg5Vnd+HZbxpKPPv7LY/fCPzDr93aLvXpqPzjr+zzzNLz8sLw4f3A+6+vXrQ1umwj770agRaeHN7327dKwsrz8eZ4X/Y/3G/5B7/5OP/jDz/AmbNTrrcVG06pJEux5sjbzU4b0nno9dJ7edVO5D19juusRLvbvv9ZejVEm/vcOpbszfwQPcYS0HeJYUwEwLGVrObW09glL4YsFqMD74R8/NJD7YrJY26an+d0IPzRD66NBJviYPVqyQilpopbOrg99bYIcWT2K8O4HQIhBHxMYlrL1tM2gbapEbXs7B7yyccWPHVjxQ0PJ7ZL3nl+xtaGY+UD1xQ4jPzvn9rnsSbcdF3/w0HLF9//LO95p/Dql29yGCeUAaoqf39N6zpYO6BV9x53S0A/Io2ZR52sCPtiOF3A9ZXn3Hxj7VUbPqa+7WRC0yql8cSiQmIi1FkZ3+jfutV530PPEnBBIwHFOUv0kWAMv/GZ524K5uPH//30Ibtt4FkVDndrnvDfWNlrgddPDN91dsor7pvywIPbnC0NXysLLrmWLRNZiMH4yF5ZslkIrmkoygJrFHEmQ+6pWjDZdx7pIExZm1X/OpfQLcK23gSxy2jufF1L7yj0PnbZPgYuOGYzWssdj1blemvwoe+bj5wHQ24Ch5ArpxC4sfRcOWjQVljWnri34t98eu8FIRn/5qnln+j6/chodO5Wj/fvt3zgKzv8R5VjY8tBUdG2yqRMAlFtnqUWSQIoGmOa3CCpp3XscsleqZ0q2ziR6/rw2o145QA6Xjqmg+qParRnzYdORrabzQ6ax/dEaBWcCagqRRa0UBFcjvqJwGb6D+zkrWNONpJ9qkn+5r3KXRKxEUnjpVY6AmAmopr0PbuZdYzNvJWRbG1u7Ltc/rddYdBGQlBCCKwCSefXR9po+NQTu/yzDz7Np+v1JOyfffIa//VrT/C2S1ucCco//8TVY4N593jCK7/48Wv87JkpJ0xDsT2lbSOuMLk5l4Ru0tzrvcddE9BHBFGytgRGhNY3VM6yXLVURYmP60IZX22EB2vYXAWaSUnApLnOwmbhhETGuisIcfnmTKIi0pNNNCgHK8//+ZFn7/g+v3u1/qaPJQCfXEU+eXkBlxfw0au8Y274/ldssbi4ycOnKyZzx9WVUrVLDo3HzSZMVoGJc+x7y6yyFCiafdTDaJMdw9Vfl3Oy3gywD93OdWuV41ju3KQPJyOzU701Ef+YkXg5ruyXm03Ubk7aMmt7VJmDEBqPj9Co8uxuzfN7DUXrWS0aDg5r/t0XFnx2Fb6p6/oyJ7x86vjOi3NK9WyeqmhNyelK2DDKrrOckogVy56PLFawXzds2cDhXuCT+4EbB0ue3Fe+2Mav+/M/+eQh3/16jwcOFytkWjJVaH3EOItVxWcRo5iFT5oQcNbmcb5UnVqTg3XWIu9UHztnEzGCRvoxru6CxEyY64lzjLTr8xia7/XQ6fXq25jUE9N+FXHGsPKpcnZW8DJSnxPFGUNUyUp73didIjbxXDrTlpSgWCQO/rU+y2GnhECOaPoPnAsrqc/eRnB5Bi9GksZEhNaH1FKwhugDXpWG1Be/fH3J//z+p3gqHs8X+fnP7vC3o/LyLeG9N+68n/zeTsNf262Zb01YHa5ws5It4wgRjJX+Gtwr0u+qCn3Y0FLWnedNixJbe4K1ePVslpFHJoYvrrK9wfUF23GDOhTMCHjjaKPisr+vjuZUj2UWv8SrcjkSqGLMnAGN1BGkSSNll5874Cmv3/QCmBmhBCaZQ7dS5VBhdYe3fnQRefTTO8ind/jhLcOPv+E0Dz24jbqCOClgobQ0yCRiK8dqqcTCUIkmyc8RlGrNYHfx9QZ1PabmvRla12PC/q1sXUd/kTtX5sf9fLMb2PEHPu6ZByUbmKQ/RhFWdcNz+y27uwdYEXa8Z8N6PvTEIf/hRvN1X+/vnMGb75tzcsvywIVtzhYwK4XN6RSxlkMVJnhQj6smrJqawljaIFwisMKyMpG48jiFVx42zMMmN6Tg6o0Fe8Hx9LVD3vv4AZfDndfmXhNxUiHRE73BVZEWQ0GCkBsMkoMnMVWvqwglmu2VlcKkcSxUKZzBIliTlQ8z/N1xxJNSeQ6H/UjbIGIjOXkNCppFdTrNh7orHEKkQPAGmggTK9QkAZ0oUIRA5SxioFWLHSEFnUhTZ5XatQEQM8zNd0E1RqzpdN+HkbkYNPlVdPlm1qD3IUHullzFx7zSoyaJVyNpHM2HpCnRJjJtuWz59Y8/f2wwHz/+yRf3+C8e3njBa21VB2aFwQRhwyZhq8p08/fmXvS92wJ6X7HkqnpMThErzIzheVViUfJ991V88YkEG35g1/MTsyRxGLwiTYMxZc761ulM30rB/FaFoDEGayIhJgbqqrBMmsBy8cI39D+zafm2s1NKgbOnNrh4ymCKgs280YXScrJwFFXB3v4BISri4TAqV5cte9cXPHsA//rKkutH4DYFfmsv8lsffJ53fHqHH3ndGd5waZOqqIiVIzSGynvmc4OLsGgjU+cwNvUyY6+d3emFv/CgrjeJzegR//I+TbgpxA/vcLMdZg+RyC0W7a1M5kfVuq77dKyrInajadkVL6u49jredYjUdcu1RWC/aZmVlqf3W6ZR+b3HlvzS418/hP7nz5S8+81nqLbm3Idn10oyNXIT3OqQYiJUOFDDZL5JaAKzckbwkQalFIs0yglRnreGIJaNKiY9+P3AK+eOtnS8anPOld0Vl6/dmWQ3M5GpNagpqTZSEI9NoC0S2cvaFNBaFQpR2jaNXDUx0IhgMGhImvaFgVUdExmLJDNrRLExe33LMMMQO9c1WTe8HVCSVElLjDSZu6JtjbcOmxEET6RGWDZC6UKC2kPAWEuTWenORsRKdp8DiyTxK8kJRw9RdvrymuRxO5GnTiNfwMSIisFJt24YjaalyldzG72Ncc2IJcQsnBOUWsF7pfWBpcBOHfiVK4s7Xqs6Ko/vv3BEaLuwiC0opzYlTyHQWkcRFDX3avO7KqCP98WkbGSwMcFUpREWXmitslk6FsuWM1sFkDaxT+w03NjznDyRIHYTlaUqJsDUjDyRewrpS7uXfid7Qc03dVSlrCYslkuCES6cmLzgz/ixN53kwswRq4IT8wmtBibWEGZzTmtLGwyFgzJG3PYUdQLBctYaHvENz9x/gqpRfuCtnuWNQx59tuFLVw747Z31pOLRvZZHf/9pfvRzV/mJN5/k0oMnWJmCrUqpl4aTVYFaQD0TLMaYbEhBbyoRdQjqt0vJxmNox/uOyzoDeu03x1PjdBzEbxW0x4v3OD6frqPuekSfvdPgH2xvWVOE8yGys/TcWNRcrxW7WHKtjizrlsf3Av/4s7trx/L2qeNDh/7O8PpWSeUiExc5sAUnJ5ZJ4WgEJuWE0jnUGjbV4EVpsgojhUkoSlRaBz4YTriCEJSmcCx84OJWy04o2IoQWPGO8xW//QIC+ne86hS7q4aTDjCOw6pgq7uHgcanRF995CAb0xSZPFi3AXEFbZGyoUKEiTVZp0EoXG62jAxdxslV7K3dEv2MLMfaOcWFEAgq1G2AoOw2EVd6Kq80AsZ7aixTEQ7rGrWOwllaDcwkBdg6I1CdnXNH6Otm0LWrvmOeFBeTNeENRgQfE4lPs5iDSEpupF/AibXuNICxiQeQWfExJGe8kBnz3go2Z5UueowkPYm9/SXhBQJ9E5f91e/wfBHY2J5gfQsO6qpkagWbXS3vsdvvRsh9tBlaEnHDWIP3gcoo+z5t7MWk4PR9c2AvZYrAlesHnJtPWIllY7PChHSje6Do4ni+WV7qVflR+dHOmnQ8q+2AFYZlq9iqJDaeM6cqvvNExYd3bt/T+t654+RGxZntghYH05JzRdJq3iojLY5ZYTFi8FE5ESKttcyNcmPpmZaWE7HC7O1zbnvCM4XyUxe3aV69xZ9/dsETT6/4V48teNYPPdTf2Gn5zd99jv/m4RVve8s5XFD81GLwzEtLEy1eHDNJojTWJOlJoybLX8IwxnNzUD86VS5rv+GI4YqOuup6zFYy6rDLMajJrZRnj/zce1ofl6jpetKQEWJiiD2Rqw1JtWtv0bBoGkLjORFq9sWwj/DM/j5/70M7a0f+Mw/PeM2ZOX/w6PO35cZNBN7+qi3mZcmsdBQFTCaOEsN2ZYjGMbGpAozR4FSoADGGOkRKjVgMk2wI0hpBfEsdhK3okFhxOjbsYjhfl1Qbm7zzylf5/3ZvHdS/e7Pg2x+Ys70xxZpIlef4NGQpFCO5lQbL1hNEKaNyKJL3C6Fc1WmMyzrEGmoUl93J2pCgdzK82wVUzSZDqskoJQbtVQx9VPCeNkpSosx6D02IhNazaoWFMzRtoIgBY5RWIupTLX0YhbkVVhJo1TLNLm1RBgW4rtXSq8kxiNFIPjZISIHJtHkR6bXQRWPfmuo0a2N2Mys14I1BNdnfxjjcSzEEokJpDHvGpuDaNkyLFx4Gzpws+Sve80tP3X7P+Uv3T3nw9Byxyiy3GAoSMuFMdoS793jRH/Y973nPe/40I1oHdobsu0zO/poMy9QR/KrmRFHwS58ddKq/rXRcunSCxhicGGxRUNgUAF1yLMhOYNIzqOUlFsw5Eh+OUxCL2Wih86U2UVnFgCA04nhkq+C3v7xDc5uc6W++7Syvvn8TYwpm04Jtq1TW4pxhe1oxKy3OOqaFYcMZQlUwL8EFqJylaCOmtFQThxhhVjgm84qptZyaGV71sk2+44ETvMJ6PnWjpR1Flkev1Vx+asHrT085WSkiBdFHRAoMULrRuTC2z2KMyACUy82ab8Nfjyufb04C5MhPeovVILdpjR9lrcsxLPZjx9F06OgnCd8M7WYTjq7NdLhquL6KLJs6zWMH4frKsAzw+NP7/E8fvk49asr/p6/Y4Idfd4H5rOBCafnwc8tbfqe/8+1nec0DW2xPCyazktIVbDnBOqFyBRMnzKylKh2FMZSlpXQGW1i2ppayKDCFZVo6qtIycwacY3NiKayhUiW6gjIEnDFYC687V/LcsyseP4a4964TFf/9n72f6tQGhUseAGJLRJLErFel1YhRQwiBg9pz0CpN9OzVgTpGXBPZNYIVh4mw8klhrjJ5MoQsQmXMyAmw00nvkv1hDt2nHgiR5E0QotIq7LeeVau4tuagjjz6hWd59I92+MOv7PDppxYs28D23BKiJHdCfB53E1w/2C7ZuGgk9Z7ZwElgxQyywyJZsEbWpGVlzRthMJnr9R169CeRZ2NMMs0ig+VtS5qcONSEiAYjuAI+9/gBT74AguWPPrjJK8+VrK63PHaLkcR3bDr+8x+4xPbMMXGCuALnDIURrJEc0NO/5Z6yzF0U0GXYertdsbOHBMGHgG8VicKibfnolUOer9OiM2L4vke22DBQmyRJOrHgCpdv1mxg0Pmay0sc5Lnl6FW2q8wEoBWClaQat2ojL5tGXn1qwqeuLNg7gps95ISffcd9vP2hk2wYYWPmcBPH5qRkw1kmkwJjDRMjuDLPigvMraESoSiSMMxkVqSNvXRY5yjLkkISzyGWjtIZThZw6fwWP3r/BhsHNR8/GCDgJ1eBLzx+wEMbJdONklBHqilUGggkD2pnuupFsjLY4ON+k+raMUmRHBN1RynBkVlzWPdJu5mIyB1G4+U2vix6JMprrshSIKe3uc2jwngfOFi27Cw9B3VLs2pZLiN1UA4bz+UrO/ydP7y2lij9tfMT3v22c5Qzx8xFHjw753tOV+xeW3F5tNF+z3bB//DWM3zPa88yMQZTOaalYyqKKw3TqqQoHU6AIgXnwhmcEZy1eZ5asdbmTRgKSVC8E4gYXIxEK+m1RVIzq9WyWVrecP8m33Gy4IJG7rPC952f8tNvPM3fePN9bMwdG5MCJ6R15fIseJ7uaFvFa6BtFdEWqSMf/NINfv0T1/j533+Gz35tj+v7Sy5uVUxKwTmDRJ/VCC1YwWYvd0NiuvcBNF9E7fedLAITlISwa6rI64gNaWTuC8+v+F9+6zH+xZcP+PD1FR/bafjI1RW/+bV99q6ueO2FOZVEMAVNVMosoIKkNuI4fe+U4gypzdjJDNtsqNJ5tptR5th1/42Mk/7koqZIT47rvpsxhpBFiWzsjFxCUrlrIz4GogpBLeenlt/82t4dt6lri8B3nZnwyIUpD5jIl/cDdV6X21b4W49s87fecZGLWxXWgnOOsjSUJq8Zl9psRrKV7r14/uKGVFXVP9UYpp3HcydrmgguTYysmsh+7dlZ1BzWgQ994hn+7idv9K//xR9/OW86t4EPyqntKWVpmBUFxkpiu8qQDXYQlfwpx+xR64tbhvBewjJV50EV7yONT5t80Ei7avAYFl5Z1oG2afnIl6/x1af2iUXFwycdr3hgm9kkVd1SWGaFZaMo8Cb1wpy1lNaChUqEtneN0mGsJNJbLMZIdmlKqnW0nmVUGiz7S0+tHmkiTXPIRy+v+Kd/8DyXR6NMToT/7e1nefUrTnFmaqmqgnJSYI2w6UzK4p0k/fdc3XQykWa9ODnGsXxcmbPmizaWBz1O2vW28MmtCHAjB7WbfNfyLdVtyrELUp1NZSbEBVVWbWB/2aK151CF5WHDrqbZ4ObGPh+7suTnPr27hsD8Jw/M+ak3nmLz1JxQN5TTEsSyChH1LTt7nus+8PJNl/TXnWXTmTQO5ZSpdZQWqrJCXLIy7ca+TNbjTD7fJret6JNsyTKoqZiNaXxLlegDizZCGwgoTYA2eBZN+r6tD3iUylm2ndAIOOsonFCJUOceuCIYsSxaj29DMhQSuLFf80/fd4Vff/5mUZwzzvAPf/BlvPbinHIyQa1lasE5w8wmlKFyJo9sm26SredLqCYVOJ/5CxqTxnnbtBx4oa49zx16fv7ffoH3Hd66iv3r90/5q28/TzWpkMpQlQVTB1ulo3QpIRJrmBiyYcqw4EwWhpFsLNVJPps8emZMQhBcZ13cs+NTQO84/J06XTc1EjT2CUtQiG1IGu4+pGTJCweLhhACv/Gx5/j7n75xR1mDH9h2/MRbTjMBookYtUhheej0lOm0QJxjZpWJc3grbJWW0lmKsqDMlbozknvp9x53TYUurG+c3UYb8qYoQGwCkTRX2e6v+LUnBl33V24UXJwbcBapSgqSjGRpTcpuu8q8g3D/lAK63uIHXf+h/ymO9CljBwd25ylGrCZoLzFcI1NnCAZOn5zy5kuneesDcy5e2ASjuKKiKixbTiidxZYFE2twNmXLZQ7sRhKL2Eki5pg8xysmwZaFSZuOyefWFYbKGrQsKWOgmJaoMUxpUFNyflbw/Q9O2b3e8OVM2IrA7zy54E0nLSe2Zuzu7oIr2SwsQZLlo1uLl11FNUrG5NjON3eyVRVuIw1/p/7HMSS5Y+1WVdcEgTRD6jELlIS8pn2IeIHDZcvBKuC9cqMNNLVP1XvT8mwN7/3sLv/o83uMQ8h/fGmLH3rb/dw3FWal0FQVVYbIJ9OCqROqjQlnT0w4MS3QsqKyQlEVOISyLJiWjqKwWJvGiKxN1zVd7zRrYLLoR/c7M0quOqhaRCiM9IHH2FSFdUxsQZg4iysLisqgtuCkgQPrwDjmkyK9dwST0YHY27Eq3liWTWTp4V/8v0/wq88dr3B3GJU/eOyAP3NxwnRSYEoHhcV0pkFWQMyaq6l00HsugKNK1kaAVVCiT6OiizZV5x/6xDP8wuXbM8E/ued541bBqRMVOEOhimuVwmryjJdEjIsjSlhQUDEYjSCWzpLFdOIcmSCKgDPJ+jTJzWYkU6Q3VNf8tzDicrgOi8o8pRA6176c6oaIx1IjnN+qeOeZiu2ofPXAUwBvOl3xF1855caNlus5N/9qHdk5aHn9mTlnTsyotiecmpT4skAR5tMCZy0FQlk6qtJhnaXI3yEFczMgDfcedwnkvtYfTXdbWoypQmxDTMpKrbICZGL4/Ff2eDrPXk8OPW996DQnZiWmbbBlySRht4gdVJa6fpMgf3oQz9FAPgrYmrXatWc8a28SEToCVdT+760mqM4YRXzaACqXSE2tKlulxUdhuyrYLC0VEVs4ppWjlEQEKp1JVUNOgrqNWvOmk/pbGRbTmNjOYjA2EY2sCEXhUASX/S0dsCGGwkeYVBxMZ7zlhEWXLZ/dS+SoAHzs8iEXpvDAuSnRVpR4mhCYYLAuosb1Xs8dWiAy9BFvP/AiL9wxfcxKlNv8bRTwB0+PoVLtyHAdFhE7md58nXwYMIEQlKWP7C1a6jp973rhWTUR33rqGDg4VH750Sf55SvrpkT/5as2+cG3neXEvGJrEgmmYntiUSNMTapwq6rAaMQ5B86wWRqMGNQYJs6wUVqq0uKcY+oEcRZrwHW9ZhkQLSO5iuqEn/p+r/RGI4hixWT3sK4XnIlgwRMFtirbO/MFMWAtp4sUPE3hqJxQ5BYZYpAQWERDbDxeDF947Bp//zM3bnsp96My9ZE3PLCBWMPMWkxOWNCcbHTJiEivqkYmmxG1h6NDVFY+En2kjkobW/7B7z7FM82dhXMuTUoePjeBJrIUYSaKl1ShhhBxzg4GMgxVaif5mtZRntUOWWveJLJe1/E3YoiqKWkypv8eTiSNqWl3rTp3t4xdaVLcQ5VWlQqTZG1FmOS1PZ0ZXveyOe96+CTvfmSDd12Ycf7EhNedLvnUU4dp0gC4fBhg1fBt983YALZKoTaGUxOHEDCuYFIYps5QODu0cYzNyaHcg9vvxoB+nLdw3zfO0NK+tezUnnkU5HDB711NweGxOvDO8xWnT0wwCqoRWzqsM9gsVpLmuNei+p9Ila63qsZ1GGXqtLt71nP+zhpiP74VOn3pqH3lbvKNGxUaSZ04Q6TFMi8taiy2tIn6ZVN/elaVGJuqldIlFnBhUjC3IhlyTVWa6TfwzA62tt/g6f+eWLXOdO0NqKxNmXeRzv9cGkw14TUXNzlTN3z4egKODxU++NQh3zWD+85O8VGZF0VSsNLknueMyRrYY2EQWetfy7Hl8/EGLzdZlI8JbSNDnyMib7dUdhssM7vr2j5/AAAgAElEQVRKS0eyrfS6474TiYnQtoFF4zlsA8EH2hBo1LCKkcX+dZpQ8IHLS37lQ0/z3p11dvjffGSLP/fW88xnFacdlCKUVUllYVqmzTNYmwihYtiepP73vDDMS4MxMKsctrAYayhN6ouncSrTk5SGW2X93z1wYUwPzXeVeXcy+6TLJFi1tY6N0oB1mAClE+ZFwcREisIyKRLUb53DSCLCmagsFLRuaUVYLFs++KVd/uDqnfXnH18EfvINJ6nEYjRQWYMx6TtqDngd4VKz9rrp9NBzUG1DxKA0GXoviOzuN/zcR59/Qff9iZnjgbllVghGhcY6jCpGA97ZdD9l5CPm5EFGJjExt6ZiSD4JkgOxHSvEZSIcJhHcTD75oROoiTF/v5Scex2MWohZ2CbP5VsB03jaEKEo2NDAyjg2CsNpA8sAs9ISZxNes2n40jMr9vKi/9IisB3hdfdP2YmW+ycWS8S4JP1sC0thBYyhkCSNazIR7h7c/sfzcC+ZIxl7F2sWV0BZGksZA2cmjt2V55UPnUQ+t+g30o88tserz87Y2JpiixLvI61TjEu9MpthLTumRP0xp4a6Fkh0LVmJo6Hk0GUu+UZVkdSbVjAh9rCaZm/jkHuxbbZANERK65KWdHRESTZKE6N4FSgdViNiXLJmlJTcOCOplyhDprxOGpQ+6mWZ7CRaoZoNFRLZxuUeuxcoC0fbekIhFNiktiUF9xUOEwI/+O33swyP8QtfTUzsJip/78M7/NzJDS7et8kWNY0qJ0oopKDJG71qRKKCSWhLWiJDpT5A3tqPAw3nW4dxQF0P5KJyE7Et6s32LOOe+NhqPYzUxnouSGZIxz5pS4HcA772NDESGs9qlSpxjcIqeK4tW2DOv//sdX7hCzvDGgFe4Qx/++1nec2DJygNbM5saoGUJTObe9s2JT8bGmiN42TmPGwVFhtjaqkAhUn6+Ql9yYE8K4iZHiST0eidrN0zY+EdQbLdaIJ5nUDMc9JihdjCZqFYFVqBcmbwwWQHsQmFegKG0hjQQMgkLqsRI5FaQJuG4GF38cKki683gaiWhcKJmD83O6R1EqkdCa0jXoa8pvtZcE1M8GnpuF57NBo2SsfDU8eXlnee9b9+Y8Xz10u2ipJp21KgtM5xII6J8bSqWByRiImkyl077lw68R4y6pFm0Lv7XqyBEImSTU5UsFaSaExm6Jvcm1aRfu/r7FwhBfCYA3yb9S0aZwlRmUugnU/ZbD1tgAMrlIUiredCUDYuzvmZoPyvH7vOMq+RX/zqHm86IbzpwS1u6JRpaNk0KeG1JB5GlRHADi2Q29gH33t8q0Pu441DhwvdMd5TA7lNln8qlIXluSf3+fIydRafOfC88+KEyUaFKkycobTaw2tdL7arJPoq4o89kI/+O6rCO4KU12yukMUsoiaLwphJZ6pwGCIFsOr0IoE6KC4maD3GpATlvSfSBWglWEdpsxhIYZkVDvKN5UyC3LseqMuNxV5PXQb4fWCZZ/idgY/QtTA68pxBwdrMgLbEGDHG0igIgW0RXnZ2A7mx5NP7vodJV88ueeOFkpaCiVFaYyk1VfyiEevsuobL6NiOjpH17lf5fPs40uVONmZ9H3udCyrHUhfHeu5rbZD8es1e5WQVMOnGC8k69QFWdUtoGlatZ1kHQlQOg7JsFB88e/uRG9cP+dXfe5L/66nDNUTgXVuG/+odL+OhSyeZTQOVTeM/87JIsLkVXGGZZLJX6UwaGTP531b651hr+5Ehl/vlNhNGzQil6OmEo3PcS6Ifc766Sr4bD+3Gr7rjcLny15CCl3UJNUvHZvtKLdmTJtg7RNj30LSR2DQ8d6Plgy+gQn/FxPJX33SWWWWJVnHiUjKTq8LSpGTUygBBm1z5QmoBBElSV01QltFQWDhsA2ZvxQev3TmxeKaN/M7TSx6/tuTBLcuJzSn4FqoSK0pLUk2zgCeT4DoErh+1S2O8ZGhdZNC+TP32XNFnpKETrnDOpIrfJH2DZNVqRjOWaU1bk33cssa9SGKeV9K5IgoTAxvOgApVCb6asC1wYmJ5ZG74naeH6/G+ZxvednbC2c0SUwrzwqYRVKAq0vezmeXe8TC454d+Nwf0m8VATJfBxQTzLUOSn5yGFmMs/8/lZBl5EJXvnMPJ89uUpeKACiHkSsQJaAe9dxsPLz70flNVrvTqbuOA7hnsIX1+TohQ+yQw4lufpDYV2jbShGRvWEel9jGZLbSBOkTaukEUap9m75umIVqHxkA0JIavSYHN2rSRpV54gvVA+mqyuwq9K5mM2svdeTPSK7gNhLU8bjZKmrpNydqkEW+NsgpKNXe8fC60z6/4XNbl/3Id2Nhvef3FCWZWUQQlNwfTucxw8BAwZK1iHBMJw2gqIESljal/DVB7TZwM7awkB8TjqGZcN0YUc/UWRtcvxDQ+6GOHtqTKI2gkiKHxkVWItE3g0AeWQVk1AR9Twra/c8ChRp5fNqj3fOhzN/i7H7l6k8PVzzy4wbvf/jIeurjBphPm5QRXBDanU4wo0zK1N5xZn+QoM5Pa2tRSMRnmLGyCnLvZX5uhc+lg9Rw4TD+jr8O51mF1dBI9XRPErBFh0uu6+66Dt23fi8/HlDf3DhmQTOSKIQnb7CxaCIksaIDnD5a876k7B/S//qoTvPGBGV4ihSuZVy61kHILQEzSeZdRwqIjV73kV54CIT7QCsQQ0GjYPDnnvZ+/dkd/g+7x1CrwvssL7gPOVEIdAxVCI4bKJHGVGIe00ea+spo8aZIJqskSXgbv8M5MJo/iqU8iMw4F0X52XWRATzrxmVKEIAajqVUW4oCKujwFoDYlfM4I4gyzwvVJvJXUNjg/Ldl2wkfyxEFUeOZazdvOTZhuTFIiXUCZlenKLPNsRsWUjNTy7sX0uyygy5FyS5HcexSC5n6QT3Z7sQ2YieGrX93tjUme2/H80IMTrDOsYlqQkyIvXDuq8IYi9EUlyOmRQN7BrX0gz0SpIJ0KVoLWfa7w6pjsGMOqJYihjtC2LVHhoFVcSKNNqHCw2GepkR2vqHP4gyUL65BmxYEYvETUp/7aqg6ZUZtIcW2IiRCbj8+aYVI76tHesoyR97UWdcdyNmOxC8k61Qyez4IkzWYxSV+79VCUvPzMjD98Yp/dHGw/tt/y2ipw9twcbRqW0TC1Bm8NpaGfUGAkBtJ9bCedGjLL14dscxk1m2qkEbsQYm9yk8YAsy1nNw+uOjRIek5DSrqG32lf2XVsZN9B8NmRq/WRVRNoQ4LWV42njkLdBJYrzzUcYdXyxScX/B8feI5ffupwTXbzvDP8d287xXe97jRnNirKiaCmpIgNUlU4a6lcIhc5Q9//Nib1K01XFec+aec6JiJZZISe8LiuOT8QCbqANxbPWR8DlCPKt4NgSpf4MW7lJCILTkyqELMToulA5tjNUceEaARwIXAQBe+VsnJ8/Kt77NyGk/aqQvjP3nWBzdmEGXBqXhFQJpIqV5tZ+H21m2e9O6JfzIEzZiW2RiQ5lpmIV8Om9bzl9JSPPrbf95DHj+8sDD98ccJnDkJ/L0Xg959bcvlqzaUycN+8hLKECD4EXOEgJHVM6aZ7Yk6Ssp+65jaIYZhVRxSb9xa1gomgJhFaNWoez7OJpJmnFoRU0SddgdgnZGjSFQgdxyD/zkoqBqwxOJTCmNQuMClpnpWG+UHDZxYJbXu6iWwuWl55oaSsKqqQlP9sWWaNCTOge4z4GfeC+t1ZoXcX9yi8CgmuM9EnGNpHDI5CWn43Z+3PBuUNE+HCxoTWGoy1lJAcvcZ63kf6Nt9sUNfRf3QM+3Zw7KhCjzEFh6Apq161gShK45MCljYtSw/qWxZNSxsamoXHW+Fg2dIuWw48XFt5yigEv6ReRkJREYLH15FoFO8FaT1KpBWD9ZFlG5J0rI8UMd2QrSQjB9Mhct3WPLoAY76BHBkX65WqGCB5ZKjdTK4u0pgOLOuWHVOiApMicK4q+J0rB/17fv75ljde2OD01FGVJV5DMu3IByQmj1WNEsCub9hV5CEojQ/UWbYzSckqQZT9OmJz9dh0CVQ3GpkDSshSbl476H6A2TXP9wqpXdJ7YwdltarZ9Yr3gVUTCStPrZE0cCk8u9sSfc3TBw1Xnq/5l7//NP/8S3s8ecRu9IdOW/7bdz7Apfs3qERwE8uGLZi4wLR0lLllUkiqvCWjIIVNUKazA7nN5uBleqgzV9Qj6KWbY+6v7YgV2F1JlXVv+DX5etX+fhorfq1/Vjct0U1YmWHdjPgGkDXTIyw10raBncWSxns+9kfX+Y1rtzYiesPE8rPvusiZ01M2S0eclAnFsIIUFsEMSYQxo67BEfOfkbZAzEpvNmd8rS3Y2JzwZy9tcS54dpeBQx/5npMlP31pk5966zkevH+bd84922L4o/2h336lDvz7p1ZcmlimkwIJLWVVcOgbSusS65wUWHsLVemMVaRHh2zmKHToH8Zk3of042pKSqxVEsEQkcRD0SxrG5VoTRbSiVib+C4m99clT8EYwLhkd0x+TmkFZwuCSdY2Lzu/wY0r+zyRFY8+vt/ybTPHue0JE2uYFgVB6VEjZ2TY41/CKp73AvqL1kUfW05KTxYJMRILi28CK4FFEM5Xwu9/cZednA0/d6PltZc2OV3YnqQzKV3alDPBLnYVhI43K74h+UHtCxMdybTqUC2G2Js8xCQsT9sEGv//s/fmwbZdd33nZ0177zPc+Q1672meLEueZBmP2GBsg23cDJ2BbqArXaFCEqCohiTdqaaaLtKddKqgkmaqOAS6TGi60xQNJEBsgw14kqcgWRKSLFu29DS88b777nCmvfda69d/rLXPOfdJsgQNFVDp/CO9+96d9tl7/X6/7+87tNReaDyMZy0hGurxjBoN0eMbOJg27IxaZr7mYM8zmdVoH/nKuX32J4HtSzN2d1ouHox46qChnuxyIBrGLWMpiLFlkiFnNa0xWLQVpq3gdaAJCXLv0II2T1dxydBiwT84XNTVFZOauuIaZvlygquNIsS8Z9cWHVpKIuIqhj24xhjuPp+kWfsC++cnvPbaISvGcCBpEtVaoa3J3b3k5Cm1JOtLB5XEyDRzCsKsRRuTWOQ+rTHqNjDynblLJEhI71vMsHpmout8/7U5hhdJuvEQBe9TIxCDoNuWUZv+buxD2ln6iG9qpl6xPQ3o4Lk4rrHi+czpEZ++f5uffHCHx66w2LzRaX74zi3ed+dxylKz1jOIcwyMoSqSzKuwSafdaTET/yFByZAKuFbLHIfFfxeys8XD1k2nc3KSukInoBbJdSLP4dY3R0sWzWCXQzBHdzoof27nyyHSXyfvi97TiDCaNcwmgVErFBqefGKfH/+Tvbkk8Aar+cajFaes8ObNiu+8eZX/5g3HWV9xrJQFQYSBUxTaoIzJhST7KujsQjhnVGZyZWaHd2NwauQiBSpd61xxBoUFJZw82uM7rl/j3bdv8I6bVzm2VVJYoWcCaxtr3HjNCjevaMz2hNNhcV784dkpo50ptx8d0LRTSlPSaA3BY7XONJnk9+DnU7ma78BTtKtKZLOllYeX9DkmN5k6M+hFLT2tOn2e6EQH1JDUMCpJ5JwGrdLfO0nQuxHSNewUMSTCoLaK0DSoNnLLUPOHZ2Z0mozPn5vw1lMlK8MeSkNRKDCOUhJh1Bm9WOeohYXzS7v0P5+X/cv4Q80PBRGMAmc1oQkJgm3geClccgV/644NfuL+5O9+fx344qOXWb3tCOsI1gj1gbA5KGnE41SaZMQIYjRBUqZxskhcIoX9GSD2uAyx58Q4SLnFQRLpbTprMFozmwlCy7hND+XlekJoFcbUjNrAdDxldwaXxjMePDvl/G7Dl3ZaHmmfTwN7iTtKw8aK5o61kpcd73Hi5Aq+bglrlk1RRGUgRAoHEyUYZShiRLskS1NBU9p0EPgQ0Nokpu08JWZ+Ss8PFFlC53XeJystGHT2kk6ThRXoVZZmErFNw6o2vPuWIV++OOa3zqSi/rG9hq974BLve+0RqrUBk8YTKbEmogVqqylVmizm+3+JqfELQt0GTIxMfUAkUmbXQZRiNEuH5rhJvvSFNogOiNGIihCShCq0aYpMB2eypo0xRdcGlSMp28BENLFpE5TvGyKWEuEgCLOmpUHx+OXAY2d3+PcP7fPZ8TMdxqxW/J1b13jL7RtsDCuKEJNPvzaUIgx08uSug2YkQi8veq2PWfYUCVqnIiWLdUiCaOUZ0rvl8JlDQXYdyWou3VNLUA3z4BmWJvUrl2Qyb+qWSYVJVRHnLHNhyckFv5Rp3uSscURjTKAU4dz2mF/6wu4hy9u/cesKb75lFYmpaIe+ZtVZBlUyljKFQmmL0RFlHBawKrGtYaFc6Bq3GBd+Byq74jmTODdTFUEszrXoRpjEwFpRMDTCjoUjgHifiLjKI2JYc3CuFl579Spff23FbZ++xC88vfDY/+D5KQcffYLve8cp6iKyOh4hKz1iW1P0LT1jiGkczihfil8tMmJQqGzlqlOuu85+7RIjUaciLCrZwCYOSprwQxSsTrIIySqiJsTErTEmn1upcHtROHRyE5D8catoYqBQaWLf2hgwizPWrxry16+v+eXHEto2jvCRP97m2DtWU1a9szhpGZWOHgk565j7upPfLWykXnq9aCD3Jdh9+bAQuuSxTHgrTEo88p4jG5Z7v7LLpYxu3XOp4T1XFaiey7u81L0WotDZDKWRjpXN3OB0ASE/X/b2YeLblez10MmUMoTrg6fxaaKbNkmDPPOBSZMKw87uCJzDj2Y88vQen33oEj977yV+8cFdPvz4mHsuNXxpHLgUXxgT52IQnphE/vhyw4efnPD/PnSZsxem+GlD5QzboymTEDgIisrAdNbgTOrYnQheKVSI86LQsd+73/uQQmCJYKgO6cPV4qousNm0v0QnONuYBIWXFbce7fHFL1/mfO5X7r5U8/p1ixtWFNpQqMSU9STIriP6xA65EUXtAz4kolHTCnszzywIowCjEKlnM6bR4KInSkIkYutR2jBpIrWEtCP0kvIDRKhbn7gMsUW1kbFEZNYwqj3jVmGnNcYH9n2Sn1k85/ZnhJniqe0Dfu+hHd7/+XP85lNTnm7lGQ3rf3vjCn/7tZu85dQa/b5DRvuUxtGGyKBw9IiINYkV7T1GKUJsMcZiJaFLroMul0bvKyHMQ0GVSysnJcsos3oWKz055KOv5oPi4vmMSw3AsrHOfAffreWXv78sVAiSd1Sz1qNQjBsPbcuF3Rnnp5H/89Nn+aP9RSP07ccr3nnHOhQVhVMUg4oBmqpn0c5idSIFDkqLsoYqkwJVZvWjyWjMYre/iNRd+lkzX8LG7pJEJkpTRqGVkHztFRin0c6x6qB0BWISidcUmn5hmATDndcNuW215DNnx/PG5Ik2Odvd1FdsbvTZE2FYWNCGQoTGqLQv1Ik8q1B4pahIklWduSom78UlypyPELvoVAFDBJ9sflxXROdQvVBm1zry1zEqxbaqPEgVBhqt0D5p85Wo3Ejkr0FAjQMbA0PcnvHlbLzzwDhwmxWu2qpQdQtVQU8Jxipc/vw54VarlwhyL9qCfhjPy4SyvFPKLfVeI/ScpvFTxq3lmrU+HzmdQgVagXrccMe1KwRlWDURjcE4GAVNlfOFgySylM0U20NkOaX+FMW8C9tIU3mbZVISklHDJKRDbTKpCeIZTZLznW89+2PP9sGIP3z4PB/4zCV+/kv73L3TcKn987XWf2wW+eSFGb/+pV36By220hwZaCQWVETGaLRP3tVaCU3I+cwZopU8TS1nSxwOTFGHQ1C6A7773G5Rj6QEKBQOwRgLOhAOZlx1fMBHTu/Pa8mj52ruOl5wZKiJAfZR9HLTEfXCrzqESNP6tDYIQt22zNpIaKZMZ8Lnv3yRT9x3kU99cZeHHt9jv205WlqCKKyKTJuARGGGwTcepxLJLbaeEYZ2MkWCZuwjl8dTQlQ0dSRGT9Cw2wZME9mdzDizU/Ophy7wk1/Y4QOP7HHPTs3+FaCKU4rvONXnR998Fe+4rs/KVg+xhp7RNKbCmYBGaD2ESuMjtE2bkCmS5W9yZ0uStCbD2SmpLBetjJQcoqcv8yKuBFsO2aEyZ3svZ9ktCvzyuuWwFCoHHM6fH1E5EhQ1J4gJXepX8kkICMEnFGTUBAiBUROpfeChr+zy/q8srFZvcYp/8A3X0Bv2KIHeoEeBUK2WyWTHQukMpTNUzlBojXV67qCms9C+U4mpTumgsgKGtGJJeul8/2ozjzM1yqAUlJm7AIoVpwlK01PgnMI6lyx183u0XjmmATZWCt5+pGRvZ8rprGYYBeGPnp7wysJzYrUktC0rzjBTljL74XecCGU0VpJ9rFJCzHyStFfP1zpL2iR3WjarWZRWiNZEdPKz0BpCWJDwVJwz52NMcrqIZJtcM38vg1IJrlchOdXFgNGG2bTBFIbr1wo+9ORo3tRNLte87eZV7LCiUGnIKUkERXQyOlpOkPsrEaD1V+D1nzWc5bkK53zyzfGFIunwDm2avPbbgB83nJ+0jOrAr/7hE/za+YWs5afesMWJk5scqzSlifR7BVE7XGUpjVBoRU8rqtLOLTE7vazRz54AJFcU85h/vhiXkppicnmrQ6JDjXykbSPTSUOpFJdHNQca6oOWDz18iV97dJ9d/9yX/yqjeNXAcO1KwdaxilPrBW0tGOsYFMKFScDqtK+tminbI+GPd1se3ms4+BpT/fvWHO+9aZWrb95ktaexRcGxQUEdhKFVlP1kH1paO5cb2cyQ7ohunWMcV4Bly82OiOCXrlOIiVsw8Z5L0xk0ip2Dhv2Z52MPXuJfPLyw93z9asEPffNJrtsY4Ixjs0qpcNoZimycgWRpmo/MvKB9pEX48tP7/MLHnuJDl59JpHr30R5/801XcV0B0nNI0zIYOELUFEYxEegTaFVJbFu81qxLZDdAjAFRlnHbokZTHt7znLnc8NHHDnjwa5iOXFsY/tqNA97+slWaqs+JGAkFaOPolYrJJGB14HyAgTJM6ykXRpHd/Za2FY5slNx+YoBxlo2BY7cVjleG1miKwjEgpsS0LAmz3XS8RNRU6sqpvEO+loq2OiRZXkqaPxxHKyJLpHi1sMHtCvxylGxuOkK3m47JayEEIaBoQ2C/9rRtZK8W6knN409e4p98ZpsncvErFPzPX7fJK2/YYKg1ShlcX7NuLV4pBpXBK0WpNaUG6zoHvLTu0Rl67u7SznY1abj13Gxm3nx2/BPI8kdoY5z7DtRRMCHgM/fEIvio0CZp5yUmRHHshUaE2dQz8ZGLBzM+cd9FPrBk6auBf/L6I9x14xZBK67qWQY9TasUg6KgtAmBsXOCYXJ1JGvIYwRnFmZLSU2jIQaMSYRi0QKic3OSLLXnnvySSHMgKGOyR0Yim3ZuehIz+uLT+9H4yMgH6hCYTgPnz+8yCprPPnKJf/3Y4nf78ddt8JZbjnNkACvDPs4oBmWBLgxVlrFprbK0UL00pb9YC3pHNlsUzMQ89j5JvaatZ3dUM5l5dg5aTm+P+MGPnlkQZyrDP33zcfRWSc9Y1oyhdBpbKKocTFFqjXGaUqePGaNxRs/1oIdsQK9gsnfkt7kMKp+cTYj4EKljxNcNe+MkhtmPiulBQ30w4re+OOLXH9tn9BwF9+0bBd96bZ9jx4ac2iiYWoMLihaf4OZsp2nQBKtp68hUFG0dECMUEjm3P+PybstT+y2ffHyPe54jIep7TvR5+53HuGlLUSnDYDikUKAt2LKgsDqlsnWsarJFrF5IoQ6R5riC8Z+14ckwJEGsbfDMgqKpW6Y+0tSe0WjG5YsH/OJ9u/z7s4t943dfM+Bb3nCKkwPD5sDRs4aqsIn4sTSZNLVnP6TEr+2J55//xpf5o9FzF9h3rGh+6BuO4XWPIZ6xKyiNSfddoVlRMTUbcco6ip1oefTCmINxw6O7nnvPjvny82RHa+Ctq4533b7GDUcHHOtXYAWjDf0YMEPLqFH0Q8N+MBQhMKsbzo0jv/L583zkimbkLUPLD3/T1dx4apVKYmJLa42xhtKAc5ZeTvTSeoGgyNLCW0m3MpFDHvRwZdiMPCOtrnPRi0plY5NMIMv/1Vfs6jspWKci6AqphPQ8t0DjhbpumYlmOh4RZi1feGrEb9+/w29fXJi4fP8ta7zntcdYsxHdc/Sdo1c4rAhOK0qnCSTtfZHZ1GQtfBcCopHMGmcRrrO0EpAoiWGekSnvI1qptOePID45N/osa/OiknmQxOy+lu2XReFjpJWkgFAi7PmAnnoOQqDdn/GhBy/z84/uH7pXfvy1x/i6WzdYLQXbs6zYgsJarFOp+GVTHJVz1a1NxVdJnE/MgiIajQ0JCUOnxk7HxdrSy4IAKTFg0Elvnxn1NkZiMu9DaUGiwpMQzVLBpImoHPnbeBhPW85dHrMfGi6PPD/28QvsZuj9Jqf56W+7jt5mn/VewaYDa13iHBQWA+humFqSOb70ehFB7uqKXXpHyDGkwyPmiczk7jloRVVqVqY1f3w5cS13vbASI9dtVQRj6WnFJMSkgxVBRNMKaYeUCXGmSwDi8K74kL/8UtRrzNnWIR8GtQhNE5jOGtpamIqiqQMzP8PXwh89comf/uxFPnpxNt/jd69XlprvuuMIP/T6I7z1tiOcPLnCyoqmsJaBVvQGhkFVslKUDAohoKlKC1rhnKFvPINBYpL6wrJRWU6ul1y/aXnbzWvcuarYMoaH9g77gz8wavngo3sMxp4bjwzAQU8Z6qjQoQHJdph5z75IrjtMwlqWkl1pF9qVhciCwUv2pg5A4wOiNVI5btoqOf30mDPdLm6/5VQM3HaixzgmtntoJM1TOhWeaRPwEgle4YPwhQcu8P7HR197DdEIx4yhkpZLjeLywYTRvufSzoiDnZrPnd3n81/e43ce2RUtcocAACAASURBVOM/PLTLzz2ww0efGPGJc1Me3K3Z+RqoymvWK/7urUP+9q1rfNcbT1Ks9NhaVaxUBqMt2qbTckyaJluSGU2DcOmg5X/82Bm+8CzNyJNN5A++vMdbNizHVwxeW6JOiXdJj54PfaMPKxAUc9hY1BUNqvCsromJVKfmDbKg5jtxvTSri+p8xp+ZNLskkcis8VwYRfAomjbJBmcx0oynXK4VF3cnPHb2gPd/dTHl3TzU/IPXbcFKwXqvh9OaUmlKl7wNqgzhWpsKeGkVypgl7b1aNCed9/zyDjcTAaIkjo10HvXdDkESM97oJYZ5dlgssg/+PP/AaJxK7nwuKz6MAh0FiQGtBOUs12wUXGMid+emRYA/OjvmOtNw/dYAE4QgmloJTvLToxL83q0gu6gWTVoTqWyeJXM4JjXf3kdMsl1EYvYgyKx4ssd9oRNKQQhpuu+MhSJ4DVaSH7sXQXRqfBwJfdASidoya2BLw1VK+GT+vS5H4S7TcuzIkGbaUFvLUAvW2GRjm730zZz3oQ5zb156vYhY7kswoVFpP90lg2kDtArtFG6mMMbyTXds8fmnp9yTHcg+cHrM+Z2GMcIUxW0nBrznllVu2OgRrUE1ga1SEaKhRWF9XIQGXOFCdogAlx3CJO+cYkx6Zy/CtG7R2rJ/MMM7g98bcXoq/OY9T/DrZ54J/769b3jfq9a48aZjbFYKvOBMhv1dhQ0eKWCgLSFElNZ4XeLwmMZTFg7noXU9Goms9SNVE2l6jlgHRBXsieZVNxzh5VfXvOvmDT53eod/85WFxWgrws8+esC92zN+9I1HabeG2GFFExWI55h11D4ipuv20y7P6OSHHnOxODTuXTn9kAt43qlXRtEqzVBA9QqqOEP3DEb1+S9fvcH9d29T507q57+4y8k1w1uuXSHElktVjyNtoA4pkKT2HjAEiTQx8ntPjF7QPfazD+/9udyrWiu+63jBDVevc8cRi6tKtiqDcppLAbYGjoEXytIxDZHSaMbasaY1k0lLHcGEyKz1fPTBHZ6qn1vNsBOFn//sBf6n9WvYdEKvZ5N5jkqwdMxOO1ov7l+dC29cYrYrxSEpmizJomSJzz5P6ZpD53ORA5K7OqMWZKuOOBczi3zueT9PsUl7Wx9jMlZqAs0srRUmu2PO7tf8yoOL96/Uip94zTFC6diIGkuLLXoJkTAJnVA5+9vkbIK553/nhtj9vvHK1Vm+ZfVCcx+XJ3nN3NxfqyS/dBqiUZilMCVD+v1N5vmEENH58wsUdT63jDUY7ymatG54+yuOU9fwM0uT+v/xwIiNquTOa1cxpmDTJ7dBXTiMhZAsH+cNkhVJq4Ru5I6JzOYlacp9TIW7CYJD5nnpXYJhzl8lSEjnS26AVEYrotEYCUmd0K0qYmpmolKUKJRTrGrDqC6oleflpwa8+vSE+7LhzD95aMK/uHbMyzb7lD5SK4vJyoZ0zRKKZ2TheSAvMd5fZKS4+ZS+xEDtSmuKRWISIhMPJgTOTmfYaLjzSMV/OH2wIFc1kdNN5EwTuf/SjN94dI+be4brtnpsFJpGpaALQzqYVIbc1VLc6pU7885wJGT5xywKvvEcTFsaEbb3ZxzUAe/HfP6xET/18bN8cu8wPHvXwPJjr93gvV9/LbdtlfQRhpWhcCXGalZ7Dm8NPatYLUoAqsKgrKV0ihVn0Nmb21iNIVJZC7nzLZUiaIXRhnWjmBjNMCpU3/HyY33ecaqP85GHlyb2J2aRux8bsVpqrupZhqWiLCz7M09UCoOeR9EarQ97oV/Bfj+MtqhDufepCWBO2Gkk4pVhNmspnOLkWo9X9xQfXNoz/sHTU1a14vbNHmttYFZW1FFogmcmCTqMUZC65afv2WYU/uK2SFcXhtdslfxX163wnS9b4++87jhvumbITccKipUVrIYjg0Ry6htPUTqKnmEagLbG+4AozWzaEGYtdVDUEjhz0PJPv7DzvN//dB15142rrA9KlG+xVtGzLgvNdVqZqIVz3zLhbRlaV1f6qWQFQQfNi1qYMs3Z3x0yo9Xh6b5TorEo+GqOasU5uTWElFOQLI0jB22y4929POHMnufD91/gk6NFQ/MDt67xiutXKKsepjSsVSWiNb3CUCVv2fmaweTJGL0wSMlVKDk05mSxQGenmpngnQXyHIFTc5lmcq/LfgQZizdd9nvnhpevh+0c2TptP8m5Tee9tVIyRwmCUuxL5KojPY4B/yn71I8FHjw75euOGVbKMhH2MiPd5NREH9N7ZbIJTfdwaRLi5XIKokRJyXu6W4uk99JqIYQE26esg4jSBqM0MbtM+RDy75zec6dk7jkfSDt2rxSOSIMFiYz3p8QQmSrDNQb+IHOaaoGXlZqrrt5Cu4gVnVPw8vtkcqKjWlJovESOe/EVdLVU1bui3rHJJe9jlQiTJtDXhkYC29YRtyc8Onnu/eZHnh7zzaua4WqJdhpxBkvScpoMv6slgobIQmPewe1CIskEH5n6tEufzDytD0xrYTSt+eCnzvK/PrjPztLAVWnFP37FBt/7xhOcOLnC0b5DjKPfK1HOsFEk//WidAyUwhUWYy290lCWBX2jqDKTtygcg8IycIbVQYVzml5pcYXFWUNBQBWOOgQGRUFU0FdwEKBXKl65UXF7T/HUnmcnF8B9gY8/PeFamXHtqRVG44bVvgNRFDqbyEqcy59C3kMckkZxhQxliRnd7XCl68Kzb7VH0bOWMZo2RtzGKi8zkY+dXRT1z16YUUwa1o8PsbplNvNULu39JrMWowyN0nzl8d2v+f6/oHtPKd40tNyxanjbZsF3XVfxPa9c593X9/juN5zibSf73LDZ54bjA4Y9Q2kMUlmsUqxZoVYKO+xjrUsTltIoH9nz6XA1bWSiDLHxzELEoXn83AF/cHb2gn6+txyvuP5YDxsUVWnmjWhHVpxbu14ROiNXHJPdflzPfb/VHBrrNMLzwj03F1oKhc+fN2fH58LXzfhxiUQXQsdyFxof2W0jzbhhNh7z6NNj7r805QOPL/gTb17XvO32o5zUkZXVAlU4dBQGrmssU7HSmTG9MCpZRLuiF8jEPGUsw+tddChdPHG3TpoT5HLwTJZZ6W7xrhVuaec8L/Kkqdbkxsbk+1znEAklitLqFNCiYeAjOkRu3CoZXJ5xb16zHAhc3Gm59eSAoSTlSeVMWgsYlYph9tnVMaJNIvHN+xdS5LTTGp9XXHM5W+Y8qMz4T+5wam5LrWKKjO2MnFye+n0m+Zmceuh0Sn2THNUaSAV6FiIKobLw+IUZ57N3xpe3a7715gGFKIalxhUuIXude5wsVgZ/UVkbL0Huf1mmdFnAf1on6UVQiqg0zgiD0lCFwIErKC7t8+mvYRHZvX7x3h1+7PpVjJRUQiLUdBO46SIxF7fTckqaoGibloCiaT0hwKgJtMoQvObi2XP8zv17/PL5w4fzezYd737TtVy7btlYKelLQJymr6Gydm4SstKx7EuL02pe+AxCsBaVJWSGw6NWYdODUVmLdwH6A6aiiT1D0wj7MTAKka1hyWwq1GuOV5SOf7Re8dEv7vJrSySkf/bQhGbyJO961TGeaFtWBn0UJSa0FEYRi7R3kxDn01rsEpVYWE9eUSUTvJkPFkikImc0K4XQYNhSMG41A99Q3nKEvz/1vP/h3flU+f7HRuxMnuRdr9ri2HrBvlIMSoOPhtgEdlvPG04N+eD280+633tNn5dvaWrbY6hS5rO2QqOFgTRcfdUmU4RNV3LZRzadojGaXgC/VjIMLW1l2J9GdK9iPQZcTzGaJgOPWd2yagLWp1StblobzzwXxNPXjgso9i6MOb8z5WeWJFrP91pTKWtbDctk/JPRougDprD5eVFL0LIsRGhLOrV5sM0SV6UzmDnMqMvubkthH51e+9C+cynJLmZDnhSCo4gxscLb2jNrAraN7LWeC+NIExs+/dWDQ8/9X7tji+tKIZYFewGquqYsHbOQ1BcShcoYfGaja6OyJ38yctIkJ0SlIc7JALHzSJsPCbKkQTdK5j97l/nu8zpBZwdIRfKy0EuyQKWyyUt+Dmwij1OgaIJQIslTIAaM1gy0QoZgnWVnXPPON53goY+d5dM76cy4e7/lus+e4W/eeYSVapV61hKUMMAwKxSlsziJee23QBpUju9FpVWYAE1M3u1GaaJKUsdebsY7hYIlR7Bmi+WQGwQJkdZYLJFGyTwv3lqhMOnrRQHlA7G0VLst+9ow0YpvvbrkvkdSk3IxCqefOmBw2wZNKxxMWzZKTXQ2kZ9RqVkwz7QXfun1YoHcl6b0TtPcSdmCpESkmfc0TYLvdlvh9MUZ//Gp59+hfrWOfPtt66xbi8RIVSistZkYp+YkFzrJhkjyQRah9p4YFTPvmXih9QHfwqVZzcHelP/tM9v8x4vTQ9/v++/Y5Ltff5yb1hwb1tBzCmMd1qUJe1gYnLYMKo0pDM4anNUpKSt32Z3eOP2MKddachRkp//tZGTapnLvcnJSVVqq0rDec9T54IpRMQwtI6O54/pNbm1mfHJ3AcHfvdsi+zNec+sWde3RStOGSBuSSUUdZEGYysSnZSLjsp3jocCXvHdekCTSx1sEFQNtRj/KfsWxIyVXB89nt+t58Xlw7LnnyTE3bZQMC0VsPGUbUKUCr+itVDzw2N4cdXi218t7hu95wzUc2yy47kSfq/sVq0PH0bWK6yrH2tYKPWXSwYUjFhptYFUS+dFYhSsd7bRmrXC0saUCDkj2mF4ijoieBYxOzGAJLfUkcFC3PHZxxiNf3uZXPrfNr54ecfd2k+NdX9gz8b13HefYwCWCVlnQM6BV2inbOctdLc3ly6IzdWilNX8fZBFacug9ZAFf6zzxzqf45V00ixwDJQs8wGc3vygpS8CLsD9Lu+HzF0ZMJp5PPDnlgxcXDfDfu7Hi9msGeGux1jEo0/cKxlE5iD7iXHIitEbPfwKt1ZJVand76RwTque/b/e8pIFzEU/aGecY1fnUp4n9EACsU/MvXcJgbnQk+6pfSS+c+9NplZLecqTtLAgNKWnRi+L2zZLHnhpxId+3fzIOvHJN4zZ6iNIMCpstXRMJUjJXIuYGTBMp8jkhKk1qIatSYkYQuo/H7IrXFX9PFwIDIQSMAisQsmYdrdExWTk7lZqItpOiKog6cQXqNqJDdpkr4N6npozzNblcC994so8nUhWG0lkqTT7D1Jyr8Bcdcf1SQf9LUdXVoX2f5AjLQHoi2uDpG8WDj1/mkxfqF/Rl33fTGusrBX1tUKXFKUkSCrWIA5Ucl5kc4CJNSObh05B08QcRLu81qGbC+e0pP/uxM3xyZ/H9j2v47994Fd9yx1GOrRZJbtMzuNJRWlgtE3zunKV0Gq27zOrE3O3iTnX+f6UW0ZeqM8zID2XnhEV2elK5GbAqZxBrg3WanhbKYY9KK3Z8pK8V9WzG9cdXudZF7t2u6TjWD4w86syI208OmfqILg2WJIMx+SgPWV5o9YIVrZdYq8vOYvN0r0MucpkJrNKUYLVCfGDaNKxWhhvXC+7aqnjgqfE85eogCh85PcIeNJw60kd0pNWOWd0yDA23XbXCmTMjzj1LUX9Nz/IjbznOVQNNIdBaw1EnNEpoUJTO0Drw1hLFUNmUVBfayIozHCiDy0EwXQFpJdBg6ClhN3r6YhmRErXORxjtjfmTp8bc88UL/NQXdvntxw+4e6flYvzT7/q/81TJt7/qKrRVDAtNYZKJisnNWxePurzqkCsiQzvdVpe813Vdy8ljy6lky5o2rZ4pTxM5TIJM++mUmBiTSQPeB3yMTFrPuIk8tT0iTBu+cnnCzzy0IIa9om/5jlvW0VWfNsDm0KBRNFFj8/dSBuJcaaATBEwqLCYTvUR1a7q4CHnKz1DsHpVM7lMxEU7JsaVa6bkVbMKn07QbczHvnAq10oeuk1LqEG8BbTKEn5jygcQhCSLJplYU3iSv/KHz3LzZ5+NPjOYqmAfON7x6y3D9ekXtI9okWLwwidWvsg97auASehnz0zZ38ZO0Vw/Zx55MYjRaz204NWHBgncWJSm8yUhHjkuNiyhN8CE3FsmcKYjJfBqh1YrZuGXqhUprSiXcmxHTpyeet1/d4+rNFYyx9DPEaG3yitdaLQJ85sEtLxXoF11BX67nMcN6bUisd0iSDYkK33qmTeR3T78wlvPfe9URNtcHaEuabHLUaliS5sSQHeBy4lJoA40P7E8DU+/Z35/Q7k/ZbjW/8AdP85H9xYT7hhXHj775KC+7ZpW10kLWYPZ7jspoVsqkh3d5j5RSsnIqVVfA56ES5Btez4tld/N3B3E3MXUmDcktTM+vXZKuZN0ygjOwOajoa5My2gOcXC25YaXgCxem1PlQuX8S8JPATUcqpA4MCksInqbzatcmwao+EEiEuWWDkrmkTXFFjrmaE6kSWzi5wDklBG0wVqPb9PdrmwNed1Tz9NkxZ5aUdw/st/zWo3voUcOq02gd8L0BfaN44w1D+rOW1Ri5IIpvWXd87+2rvPdlm2y6htArKIKgbMEMoW8MrihYqRS7UVO2wqB02OixStEPwswYxGqKGNitG7xESgW19+gQGNfCWuv50k7D5XOXuOcrI37z/sv83H07fOipCZ/bj0yeo4h/05GK77lljWN1zUPPEbr95hXHD37TdfSGhqGzaGuJptMp5xhVtciNh8P+6ocOyGVp6CF++2Eb3+UCyFLDpq4k2Mki3rPTrM8P+pBibcdtpG2F89tjlA/Uo4ZffvCAs82CaPL9twy49tiQVqUwJd3McB5C6ZDgiVrRhNQwREXyLs+Npc4yUpb04gkxyWqMLve809DnVV7MhV1DlmomGD2r1ggdEa1bPcy7GknOgsrk9UNqpqNkqWf+t4pEIouZfa6yJKAhpcpVVjOdCkdWSk6VwsezF8NEYHR5wmuuXWGgW0IwFFVBtAoXO9g8F22dCHwqf/02k/vm+QqAVnGhUMg2zyhoSFHT6XmNoAzGgBY1z9TonnG0Ts95jESlkRBwonOyG/imRaLgVaBqAr+3xAu5ziquP96j33MggUpblM3XWi/S19RyguNLrxfZhL4MFcqCYa4U1E2kkbTXCdoSVOD3H9lj9jyDzzuO9fgvXnMMIeCspVdaSmvSAZGLZoz5YfUx6YS9Z+RJdqEiHNQBgme6V/NvPnmGDy4xxt9SGX7grUc5fnSdzWHB2kpJr9CsVQUF0CtscvSyOtk7qgUZzygzd1A6dECz6GD1nBGqlrThy/+WeXypnttZpgQ6pZIVpNWJoGMNDFZ6tKFlMtlnverxiqMV956bMsvF56G9hqt9y8tP9Wm8EKxmFvK0kQ/IwHIBWZDL9FJ++jMiWTsCU/6TyzaVNuTNplVoZRlYTTkouPPaNTYQ7tmeLa9teWCv5XcfPyBcnNJvWgYuUJclN25VvPOWNd559YBX3jDgWFmiDdS2wmkh2JKBE6RwTDNhqI2KQevxRcGsaemXDl+3XJi1CDG56WnFpVGknrVENJd2xjxxseXBx/f5nYd3+dkHtvn1x6d84mLNYxPPc1ncvG3V8d4TJT9w1yZff8Mq1x3rc/tNm1wdAxf2Gi7nOldoxT+6Y4Pve+tJTqz36RuNsRpnoJevWWH1fGXU7X+7xql7ihaTtVr6cwqAUdm0pJs2D0/d6hllvyPRzeOCOzxAOolTSqiTGJm1wtRHxEcujmZMx57Hx8Ijp0f85vnFeurbjlRsHbOc25lRTwI6CCfKgsIpZiiaWfLZr4LQosAHfC6qXtJE2cSY77fk8x8j8xVABguI2QyqI66xxHRPkrtu954WB0bL3HxGZSb4POxFJZXMsj1e9wh0mu/ug7qL681s95R4GAltoCUyI1BVlss7M05nYueTNdxWOVbXVyiIKAtVJCXIkTw1lEk56I1KaJ7KGeeS8w9MJrH6lJNKGwQTUnBSDIHC6LkGXDqSnGSJXkikt5h5CiiFm68tcqOiYnKsQ7NTR2aTA7alZM0KFy9MeTLbWcss8t7b1yitpQd4l4yitMScu54bK6WeNbb5pdcLqJV/2ZzinuvVwd9NCMnqs/E0rTBqA00IjCaeJkR+994L/NR921/za/3ye05x+9VH2KgEV5XpMERRFTqRebIPdYiRme+iMz3Kw5lZSxEV02nDzDf86t1n+bdPLA6lNw4dP/L1JxiuVxwdlrhCWLGWqu8wSifGqkmmIr7ronMx1xyWzB0af17QRVocwot8dsmOVt1hlqpEG1NS06hNe/G69owmNY9sT/AHM+4/O+H//uI+Z5Zg6//hdUd5/Q19ejiKXklfQ1katElBDqVz9KymcJbCmbTDt3ruvLf8XnZFoHMR811+fEZCxm0khsDUC6NpC02gDp69JnL+8oh/958u8fvPQYCstOK9Jyr6KyXXrRtODit6lWbVC1IYdoKnNJojVcHAOKazhpEJDF2R5EUm+duHqBi6wNm9lNRWGsWZvZozI8/BXsOXDmqmk/AMV7fnem0azR1bJa/bKlk5ssKrVyJqMGTYV8zGNcP+gP3QUPnA9rSlqZOB0vHVgo31EuNKeloYGE2toedMirV0Bc6mYBLmNpodmVTmk7Na2qfDgmwal/LTJE+6y7vxDh3rCvphwt0i0ARJiFmIQuyc1WJqgpsQqQ+m3H9pynS/YTJu+PHPb7PnF9P5mtHshcM6/FevFvzgXUfYXLVsFJpRNASl2eqnKbIWxbCAlV4PUPRUzha3htLk/XJ2TEOlKVvpjsCpCCplOqi5UUtEaUUeRhccgxiz6UxCziQmJ7kggs0M9xgVaCFKJsblqTVktAAUrY9zp0mJQu0jo3FD3bbsTVqmTcuTl1v+4cfPMs3P3rFC8c/fdyM3rTgGOhnq9PuOaMBZS9mR27RGbFoLBFFYkvGW+IA2mtB9PAa0tbSSA14kJaB5UbgY0l6cRPSzkq6PVwv2ZAwhIaRKoaPQSky/v49cHDWcP7fPKAQutvClr+7y/q8sUNN/+c5TvOaaNY6v9+iZxBNaqWyy6dUKm+W4Wr0Uq/riY7lfUQBi1kuFeXgC8wzhfmmQUeA77tzC+8D//uDlZ3ydnlb8yzcc5eU3HMFIRMoCyaQRZ3Vir+Y8cN8GahRtG7M/uxBji2ki+wGcBD782XOHivlNleFHv+EYxzcG9FdKtFFslAa0YIxLOlmVJi6Qude0UhzOB1ZXEJiexcvrSl5Bqv1yKM50Dm3rTrYiBJ2hclLhGqBoNQQxDIPj+q0+k9LQasf3CPzkQwsDlv/r3m3Onu+x3wonh5bXXbPCjdevYq2jWzdaDeJDCpQwHVmuk7GpJWZwOh21ThOBTmdmmmKsZqCEukkTgw6GWWXRMygN2Njnh99R8Z7tlg994Ty/t3PYAW8Whd94egos3pvXrThuWivYqiKDwrJmNbuVZlSU3FhERiFywU8Iuw2NFkbGMK5bfAw8dT7wgI88MvYvuLfqXnetOF6+VdFfLXjZuuGojaxurnFkUNL4FGxhNbiVCuM9RwuH9AvWhwUTMRQSmaCQGBmUafEYYsQ6R2FycIeRQ8SibsLWyxN6JorFeY+4RJaTrmjL3N6V7MFObrwWwStdKEgOWhEW+vT8h8giczwEj8TArG554qBh1Qh7TvPZx/YPFXPgGcUc4L79hv/lE+f4h3etIeuOUPUIRnNpXxALR0qFUo5pO6LsV+yLQRmFjz4lhaV9E6VOhbiNEWs0bXbYc5C1XOn5CVl7PvfAUEBM1b1rhbTE5BCZUa+YFRu6w+glxZo0OcYWSTv6NgilgVnUOBFaBYUkS+pp0Bib0KhrJPJ9Nw/4uUdSIbzQCJ978CIn79yi6PcQBaVEiOm+CEm3RwCsD8kQRmdregFj0tlmlSJmK1wBKq0JMWQPguRJH4wlxoDWEZPSW5gGRWmzhbOSzPNJlL/aNygFszakOGar0UWBi5GrSmFwvAdLBf38zhR/co3LB1OK9WFy6wwBrWzmASwcDK885156vQgm9EPxpDERjUIU6toz85Iys0UIjacJUKu0+z5zccTHv7TDF89P6ReWO68d8OZbNljtl/R6jqFJ08aKM1DYOdROTKz5ANR1ApLHPtDOPK33bLeCTBue2Bnzg394Yf5znrCKn3jLMa65eo1jPY3qlaxpcGXyCS/LZMxgtc6wKHNolEP2qX8+ycCybMfTHdhL0ZUxJuaxD0LtA42P7DWR8f4MHyO74xnn9ho+fd9FfunccxMN33e8x498y/X0K01fBYpqwFrfYJylNHrOtDdKPaM1mcO1ncY/T+hzH/gQmHhhMmvRUZgIxHrKZCb4WcPIQ601j54b8ydf3eP/OTudTzX/uV5vGBhu3XBce3yVk/2WzbLHrhgGBrY2hxxbU4AjKmFgIlPRqEYonCa2nkbDwCgmURNicparVQoTMlajrWJgLZVN17Zby5hMjJuTD+Xwcbhwe1OH7g91ZWMoi7zTrtjHJcvUmA6NtJY6dK8pQq7wdQhYFG0UxnVL4yPnRzVffWqPDW146Kld/vF9fzqnvjcWmhsHhplRnOhrioHl1iM9TmwMcQNDJSlHvuj1UaahX1SZSKoxMU2ovbz/VVkFUlidCrpdxKvqjgeSfc+tVgRJccfzdjTvygNdAU9Z5Co3UYvrL91wn69hQqJakpQMnzLhZ1ExOxhzMPOMWsV4NOJMLfzrj5+bO64ppfjAt17L8c0h6wVUztGvFFolL3+VI10LnRQjhTEpUlglpEnyasbElDCorCG0Ieel558nG0YZpfAxNeXkn700mmmUpLQBWpLVssqKo9ClTgbPozszDnYm1E1gIpp/9amnuX+a7pZv3Sj4+994gsGRFY6tDRjqtPYcFgZtEk/ILq0bX9Kjv4gm9OV40pDzxr1P/s9dIlCU1GmOrMUYYU0r9mctp7YG/PU3DRCEtWxbOgHWK4e1hr6KzFwBOu3aIOlMTUzGveC9tQAAIABJREFUFwC+bTnwCvEeZp7LWhOmDeNp4Gc+dRjW//5XbXHyxIBBoVGuoFKWsjKUpc3FWmdr2a6Qy3yaejb/ev5/1iW1HLGx5CZFjokEnXysddLIxmxL6irHfhuROOXq9ZI33HGED5w/Q3iOvu93zk8pfv9xvv9dN2AGJZXRtBicT4lzog0SBcnmH1dW9I60pZemwpiZwUobVgrB6sSX6IVAVD3ECrF0lMB0VnPXVRUvPzXk3XtT7r8UuHxmh49tex6ahr+we1MBtxSaNx8pWRlaepXl1hM9DqLm5NCh6oAtKrRxbPUUx9cG+CBslIYDBI3BERk4Q6yyxrnnGObpLvoAoim0SoxhA1EbekXak3ZGJm6eQ9ANyDJ3BYO5u2fmZ6mui5/D5aLkkClQ976IdKYkcshlruNALGvYVWTOCo95SvciiE/hH9PpjMvnLqJMjydHNb+2lMj1Ql+faSKfaa6c4EccMdv8jWt6vOqGDY6uaHpYVh0cNJ7gW1Z6LpFJi7SuM0pRChhnmLUhrS4UKKPQMbnthRCTlSyS7VQzSXa+Xkj/J5IKHNK54+VGR4HEyDLb3EiCsbWK9IAmJhjbxJT+qHolo5lgtafQlqt7kW+/ech99+3OB5tPPnyJb/u6gj1tkt2uK3FGcMpgFUmFg2CMwUdyKpvBamEGlCI0krgqyke8TnJMfIpk7TwIIoCxmBgJ2eHOZz5OaFuUNvm+UBRKMwl+zjEIounNap7SitVSU2nhrUdL7s9I5od3W/6W0ayGiIwn6JXe3IFSiaSV10s4+4uvoC/brQYR2tYTUXiJxDagFTQkv2cvEaMjuhVa0WAt67pmp4V+4bBRaI1h05IcpwgEDEMN6OSKJPNM82RM4VthGiKzOhKJzFQgHsyY6YJ/+9kneWTpcPmB6/u87sZVNp3ClC7pyJ3GWo0RsFZnuVneDelUXLW6opA/bzH/00FQamk+61AsjZp7d4ds6ajFE5WmpzwHBqRtUMMezXjG6fPT5yzm3es3zk559/k9rrr1KN5kFymn06Qdk2b3ymlx2R60Qyj0UoHp2MiCSulMStF6xdhHnLR4SeSf3kqffTdDY7HG8pphoLy25O0NXNqtOXfQsF0r4sGET+0Gnho3XI7CC8GlKq04ahS39QzXDy221KxVsLrZ56r1FbZkwq6x4AODqk9oa4pZZFOBOzqkqAz9ytEnTTErhaNwmo1scGJskfXAghZFAxTBM1WKgbHz4BNrDSpGPFBog1GSVjWmkyTmaaYjrMVI7Jy3VKfRPsxdUJ3LGx1xawG5d05+c4/3pYhVmZuqdFbnmQvREVZJMO8sJkLatK25uDtjXw/Yn3gePDvmniU1yKbT7LTxz3xObAfhXz0+gccnvPNoxXvuaHnFsSEjo+hb8C2IeLYaqB0o7Wis0IshqSuMpkHho6K0at7IxJhNk1hI86xStJJkcCoX+s6UJ6T1+XwFEdDz1YeROLdVFaXwIeYAHEGshcaDVvT7htAoVFTsNYFbrxnyLacnfHg3cTR+87Ex33hTzdqJFZoQ0T4lrLU6+7CrtI4UEYqOd6RSGlspAY2iVIo2S90kBoKYnGUfMZL828nhNCEb5qj8ZgtgrU0rBaMxMdJIQjraIBgdUSJUqz3WOSAezLgYC4qVRZnxIlzcnnLEOIJL3hbGaRoRqtRCze+7l1zdX0wFnRx8EhPJRpSmaZPblITIfhBcDCgUbVRIE9lHUyhPGaE1FlckGLIh0qsMFRAkYjNpqyPDhJhiT71SND7B+r4NzGaBelZz2QcOLjScmbQ8fXCZD11aHEh3riled+MGZQFjbdnSCmcT69iiUDZBeXYpQ1zN9eNXTOU832T+Z725F/N6J0fSeVKPCB6NVYGZ0lQ6EquK3WlLDdz79AuTAf7JV/d45Q3rFO2Utj9A2ZJejFkGJPPVwvy3WP61506iKf1ORGEzBB8kpcsZp4hGWHeRwmpmTcBI0jVvVhWzGOhbw9o0cslb1grFcLVia+ZZJQCrfFM0EGoOVIE+mFLoyCXR1B56RjA+aY0LBWOn2aoMhJZoDasKmHliVWFRzKKnjQM2lOdcv6QIgdXNVa4rYb10GOswpCmopzXGGLRJSWOlMuRTNL0TMU12LgmB0/QdF2RJIZGfqi48I8PCneJh0erl66vn7/ahorucgNa5vi0Y6t3OWFA5lk3opiY1/3daLcHyciXPJf1PEIE2MG4aLhx4LvqARdNMa/7d0j71BqP4r28a8M++ePCC7rH3Hqk4P2t4eAqTZ9m3f+TijI9+7Bz/3TUVt736BMdKhdEepQwXq4Ji5unblsYrxCW5qlIG2/rkUqYcXgtV1ujpTNS0SqElEJSZ68xFZ1RFVHZvzLp1rZGQ9OHELuUu281mJ7ukV4+JRd41XwLKWIaqpbGKyTSw4ix3XTfkw7vJ+XA7Cp97dIdv3ujhrOfyFI6ugkRHiCn+mZiutZD4Mt2qqyXD6V3OuTYYY9H5+/sYc2OX7lEVPc5qYgBPSmHTGe4x1tC2LaIMOjvrKUCMxWkPMXAEzW6vjx57blpNtkvd64mJ8Co8re3TtCFFV+v0nixHL6vlDOuXXn91C3q3N/eS2NghRkII+Ky9OPAxyzCEqQhOPA3JAlZbwTgNIWkzDcJaoamjUPUsrdL0bZaaqCVIzGpiHQk+EH2knQW8D3zhsRG/dP8lHn4Wf3Cr4O/eeZRqvcJYy9BoCIklXBiwNnli20wIM0ukpT9dIX/+9uf5C/4Sv3muMU5MXo3M/esnOQa2sBCs4Qsv0Bf99EFgRVmUsogyuOhRzqWEtWfxEX82zKGbHE2G3Ocko5g8ogudJp9eoXDO4r3HGk2NYBpoRRNtgW49IQiV06xomIgFpdiIgQk9hhHorxKamlVn6Xkh6gBR0QbBlo6DCEUbKHoFooRWwLgCjyR2LokbMbA9rulrytJSRQgme6srhf3/2Hv3WMvy7K7vs36Pvc8599a9VdXvmW7Pg3k1M/gxxGPGwNgyFk7iiIABBxT+iCKCUEKQkFCiCPFHIH8kRIj8gRQlSpREIigiyCEyhIcJ2InxCw/2gF/z8Hhmemba/a6qW/eec/b+/dbKH+u399nnVvV0EzyYtvpKLVXfunXuOfu11vqu70OMlQRMDNVKTh0Jn7ptQVwjtIjRVi46MzTJTDScTGEmOc8yO/qg7bc29S3c4Zb+7IvrZCrOB6VVm8bRWbe81KTrlKZ2ND359K/KHGxSmw58r6AB7hfj/qtXbPrM5dUVP/blC15bRM/+nmcf4d1P9PAmCvpa4Pd+8xmShT5F7t0rXN6v/MMvX/J3XjiWMf6lL+34xpef49//6G3Ozjf0Kzi9e8k+R7QTbqx7ZFB2ZmSr1C5RtZJqJUlgUEjixTmINYa8u6ZpTE41nPzSm72sEVwL38KC5eBn04iIzT9e3XBHWhFXrUgUVlUJq8ydquyu9qQ+sNsa3/LOG3z8l+/x483r/W9+ZcuHv/GSUVY8HoVR40xyHNWTDA3DYnD2vfn9ZOYkWKmV2pLppNY2xXtDYmqMaqzNqBIoRUm4GiYHY2hDlhbDJLqeflBKyw6IaqgFVjnxWspINULYs8N4to/84t6fJa+8dEX3kdtYNXbiv0+rQW7KgCizR8DbX2/xgr7cm2t194Sx+qReSmEoxn4/clUcqtnujTtXI7bf0/fCk6c9QzEke5faiXAVApvs3eSqucGFKEQLbmCh0jS1I2qwL5V7Bv/kM6/xp3/ypdd9r7/rsY7z2zd4fBOxEawL9FnosjTNq8xGK2lmsoNcH7j/hXlc8s/5c3bklxxjYNRKCkYXDYnGeafoGHlXL3z1TZjvvfc0oKVwlQJrq2SLc0Qi1+JbHnhHB5+OOWc7TGWpOXepObs7LApZHzMWBbGApML90R38NhId5i+FctKRi3I1Gidd5rQUJMGoAY2ZmgLJjGiRfSkIHSJwszNWnXuHWzVuJGHfRVJKPJYhrToKhXVeA9qS76IX64ZISIiH1Uf7OwlyOPbhAH2nozPihSE0O9IQZN6FLx0DG5reYFGZIV1l4iUcZ5/P/wY7HnwWf9Cjby08z9trT8x392g/wO+DaZvQG+Q/GuNeGUWwix3PXRR+8IsH1cF3rYUPPLXm7NaGP/qeU/6HX/naSNC/9f5zHrl1goTMSozVxri5VZ565pzvffk+/+8X7vPXFgl9//Sq8Kf+0Yv88fee8Pg68+nXttxcr7j5xJrf8VTlfJU46SPbfeE0GCVGLi1wqkYUZYxCZ4pIdKOYZvQ0RcAy+ahPO1/VQzpdCO4xX93dbVrnJQ7JdqpGNKMkQYoxmhfUiLFZJXb3B/p1Yre75Dvfe4Mf/6eu2vnlfYXP30GffZSgmWFfkC5ASHQSGC247bD6daEiDI1zIZ5jTEYYx0pOkaKehpdNsBAJqtQA+7EiwSAmKq4Tj2oMqTlRokg1hhgRU5fKiSfp5S4hw5ZhNFYW4TTyzhtpLug//fKO79kZjzPyRMpYCK2p9WeRWjMMWkQPvD2kv1ULepsIJhJcVUUI1HFgUEOGAhT6IvzYp5/nr3zqHj9596AD/mPvucHv+9gTPHl7jZmxD5ETCe5j3CQbMUz+zm5jWvHfs8qRsVYsRr7yyj3+k3/8tfXsf/fFgU98/hVuvu8R+k1C+h7QeV8+PaLDdYuuhw3X/1KO7LW0rdlxTposKZJzZrt3561E5dufvsGP/8Jrb1zQ33mDvRmnMXp2vQUUBQmzQ9cskXqIIkWu4QwmcpxTbcyylmo01y6H+TYYFjPrDobiaxkdlSEF1ISxVPrc9obWCHtJKEnYjwVLiR5F04rbOXKlSmeeZPXouse0krtMEKFHGUJgI4B0bYeaCJPZBkZq/AGdAmmqG/jU1tYs9c0HY6CDrtvNXqZiT9MYNz/1xfmUNinHtv+eJucwwe1qSLCZr9B8RWZF0JH/+uJMzAS31oCG9lkm1PjgyAajuf/3PPm3Qvbq/YH7lwOg7GLiZz/zwuw+CPA7PnjCrRuJTR35XR99gk++dEgcu/71PTc7/t2P3GRNIHcFkQQ7JdzoeLJsyY+c8n298C3vPOUH/tkr/OOrOg8H/+1R6M0ePneXj6wi/+F3vINnU+YkCXuEvhohOk/HQqSf9J/qxXzegU855O0GUmvnYI5NpeXEO0pBW5vk+Xgp2Z8SWItt9gTShJlxQse9EYiFuBuo6xXvemTk8SC82DwbfvTlyh/YDlysOs5jYBQ3aqElUBbxJlXFTXKiQB1HupQZcTJxjG7+k4OH2FgQxCoxRrBKiubH2ZRVcIOZvQhp0bjtg7jZjQmDGqUoIQRWQRhFGKyw6Xqev9jx5KMn8LJPBl+6HElD4ewkAgnVgoRVK+STle3bxfn/z9e/ck5xunCDG6vHLt7b7bk/KFkrFxUud5X/42ef58/85Kt8ZX8MCX/yzsBf/8XX+K6nVjx5vnEpSfTIvxCELkVis1ud9ezqbnPj1hGAK4Rf+vmX+dtfeeMELCvKt7z/UVbRiSerLrLJ0b2Ok1u4xuaxHR6SGf4v70uO5zI5fG+CTQH2o1EstIQleOSk40d/+S4XX0MO9m2bxO//2BOsc8D6jtvRU5v6lJo3vjdRD3z+hQnOwyZ3WQSETHyDyf1uKlyOhjYtP0aO4v8F4XSV6HNktU6crRInvefJr7tIXiX6VeZ0nTnJidPTFeenPedd5PykZ7PquLHpyFE46ZpRjvies4vB934RgkRS9PVAFKFLgSrNW70F/cRG4w0CIYaZ7R8X/tVcQ3BCC9k4OAAeGOYqMrMijEPkpLSdt82KAR4wkjmSsc1ExMPrT1DntP5YEuJia7Amd8BZM6xKbTuEWo37+5HnXr1P2e3RAl96bcdf/MWDTO0P3s584lvfw1murHLiVh/51vc9wpPjyGfvDGzbL/yGJPyRD5zzh779aW6c9txAKSmTA5x0HTUJIUSyGYXKY+vIR585gfuFX7osr3u9vliMT33hgt/9VM+jNzqGmDyCNbghTWhytxniaEjTFEBkzSWuztLAZisrjiJN/IaW59RUJY0LYuoIivgzadrDW9Ore5RtJRZjSIl7VztOozFeKv/swrk7X7iqfNeHHue8S6wj9F1CTKk5o9Xok1BaLkKQw7VRW9c4SQ5jCPN7UVNqCkRtA0hoTYH5v7MQKKO6W1yt1BB9NWRQJDA9HlKK7MbC1f0tIpGiO8L9kav9yE+0RMetwcef2XDjZO3kz5g4mbLsG1P47Xz03wATui2ePFUNM6WokgV2IfDyZWXQyq88f8V/9TN3Xvd19mr8Z3//K/yP37/m1s0TJCdMKyk6hCttNTtNeUGdaTwGkGSc7JTPvvrmsql/5JWRP6WFsUDsVk4YMWOd4tHD+AEB9q8D9nGsQD6UzhggKgyqdMHYBYfSNl3gyUc7/svv/gb+1N/9Ii8/pKh/dJ34M9/9DDc3HSer7JN0isTo0GWQ6DfndYDiDYr5vMNtRSma7zKtte5Jm4VmbESshjBogxZz9odNiEIvoA056aPHefbiJjbFEhKsQZSCZbegnBLkaAlV4vm9DTmYDDwbmWdRaA3Ictg1Tw/6aW8+XwqzzoxFstRkE2qLafxQsie69TSZy6JYzJN1K+p6VNSnMJFpJ67zCkTb71C1GamZmN60Yz5Rt60Vc2kOaTqtxxpHZKjOa3n17pZUlPs1MO5H/s+ff/Xo3H70I49zOxc2qcMIrAM80QX+8Cee4d/4WOXl+3tOAW6sOLXCSZ/dfW0VudkLvXhx7NW4T2DfG5twShlG4jDyvR865wdf3FG+hpThy9X4nz/5q/yx845bKUHXewBJrc48RzELDQK2JtsK87ohIKh4oa/aHNlwFHDUhoqYZ343y3QSRpHoMa7Bkac5xrTxHWp1L3VJ7sJ2Y3PCvYsLHrnVwVd8pXC3Gs8/d4enPvI442iksVJT5FSVFL0PyZNRjgXMqls9V/VUwykrvlYwl7TlGDAV0ELBDWh0cZkWgZwErUbqAnWs7qpZCxI8BjUL7LSSrLIKxle1EKzn1q3Ejf0xifFGqfSpUIisY0bbe57JmpPv/tul/K0Puc+9tTkDfTcadSzOCr0/8Dd+5sU3fJ3PXBV+7ov3+PjJipVA6IKnDdmxp7ibLPjsF8Rv6GIOkb7ZtfSJGGmzYZXbxGTNH5vwIAnu1+GIPqg0Pnh2hya5IQirJFxJ5BQwq1zsBdPC+55Y8d/9nm/g//ncHf7W5y55bV94oo/8wWdv8p0fPGO9OSWbb25TdA/o3CbMKYhCrjU09mBtP0DAD6MYLI/hVCzlwIpNLR3PGdo+pcb2IBVTpEm/TII7ZrXX7sSJl+6jP9VMPSq6sxmLHHbG0QL12vQwXTISxK8BYYbE54mXa6EmzMmlLe2rSfoaRGGL40V70E2fXxvRUqcXsEPS2FJrzmLqxg4s9vn4TslxtkxQazGo5sdGr/0dU/xm4zVYVXaqXFzteW0/ujTLjE++cMWPLKxx/9Azp3zz7UhUsJRIOgLGpuvpTZDTwO11aslgjoBc1MCmg1UMnsPdfmdsqYsmmUuUaIVeMz99b/81i/n09QMvjHz/UDkryuXFJeF0RW8Rq0aNQlabd+RT/Kg0jsReZPYeF5creHFvsLekwFgDnRkB90OnFEKa8uoDpaprvWOc5X4hBU5UuWx75EsbWPeZ99/y6XWK2f30vcI37UfstGfYK5sY0WZPO1Qhe20mJB+MvKF02mRt18lkptObsh8rOQp7AkmMrMYuCF2pPtUnby9DABtB1LBgHhCEk/0qlVQKY8pcrU9Z7y94ddiiXaIvx4iJqdJvA+ncKKqMjVOgEo4y0X3987a7zFu2oNM6W8xJcaMZpVY3cyjGq6XyY6++uYjUL7xwyW99VtERQh/9QTdrSw8pRE5YEbYh02HsbODps56l1OL1vv7td2wYJXMjQE2ZPrawhIdA2792Rf0BbvjX+DmWm9mJ57zYo3thzMEJggmFlNCqRJScEwORR24nvv/bTvlD31LY68iYV6RgbJL7WverTCdGyMKKg9ZejEXy1/FU/kAM50PW63adezDte5cQcdvvIs1lrkl0CDSyziH4YaqioaVF1ZY3P6GrkcNDBdyaV1uRnUlmTe6YJp32tTVKWBTjaeJd/tz8vUOe7KLAL1jkdnwMpOmDp+k7THKoNj2zMI6ZD1kLMtLFsZN5AmpXgyx8AuRw9Cd2t/u3t2O7IM1rq/LFjGEsWFFeu3PFKgTujJWLUfh7nz/cQ+8EvvNDN9icbRhiZB2E3PWEEBp6JnTF4ZeM+HRcCreyu+JFgS4ESgqIKjHDXivESNBK0UA1ZbPfv+m7aCxKEWOjHqNao5AltnhZQVXJ0SFlmaWARmrWt4nK2JLZdEJmgk+y6+j+7qUZOIUuQZ20/kqp7uimQCfCIBBqJYWI5I5xt+PJYNwT4bFbN/iOsyv+wR3/bD/x5Ut+97fcprsayaeJNUJUj/FdibEzIcTAStz4Z1QlhkTF6KKw12mLn8io784bV2MoxSObiVgU1FzKOYyuAihiaEqstLIf3fueZsYluWO82sMwIlVZW2S7M1bn/dGxf/li4B4QJLEqFe0T0awhcTJfZ79+K8q35lf4V66az/BhY1+bpx2NVWEYybuR195kjvT9QakyhTQ4aWOaKJjIQy1gQKuRgzB0mbxa8Zvf9wib+MZX0ic+eItHVoLaSMLI5jrWNMWiTrau/yJXpbw+KM3rysHsiGT14L85vKvQJs8QfP/cBSFK4iRH+i5wa51ZZ58oQk7U1HOrC5yjLmnJgVUUUt8Tpcm2ggcvSDhIrK5vG16P+CJyPKlzjQjGIm1uklPN5L62l47TxB1abnxwC9ow77UjKfiuPQdXIaSGJniB8ZxtaT8fpiSzOO3ym9RvIvC09Upc7FdkOZlPu/FWbGfkxli0WcepdMvIFJ+4m5xnkkPZwRVOOFjm6gT/L0ad6X3oPLnbgrS5uD51SiazgxUsc/bKrDWfpGyGB7FUC1ztRgYR7u1BovH55+/ysxeHyex737Xh/Y9uoCi3VpFNn+hSZBWMTfad9ekqcJojJ51HC9/oI6scWXeJHB2KTinS5eQmKn0k58Rm1WMpc5YS69PuTd9aZymzCpFxHdEQMPXZYTRtRjnOWEcmOe2EWDg0XNvx6FoyW1jY6o1q7FuDKU3bV8QRSM8Actg+mYL5syPESBTltPPPdr8KcSjUXeHDjx0+1y9sC3q30q0iaRSGWhnUrV+ruHc9qoylWdg2cmg0z1pYxeh2sXiYTUDI+LS8TtkhezOkepNbEDQniEYIERsHthKQFNkp1OyriVoGck7cWAVO1DgPsEJZXbvZBWGMlRyD6/BViFMjLQvo7e2vt25BtwWBZ+r8T1OgipOrBhPiGr7lNL+p13vvY6fcjHAVwYhuZSlC1QPrStpDv0tufZgpmAjveGTNX/jtT/K1kPc//aEzPvqbzuk2HTf6nvNV8hzhBXy7SAL8F+tzXndCf3hTtIy8lON5bOaczxNjK0YpujlFCJC6xKqPbASyVM43a95xGpFVx6MnK3oRpFtz83TF6eQeJR4Ny5TjPmmmr3MkHvK57CHfP5rSzXhYZM0hO/lADZtYsk6WO46hDU17H4MnYsXpZ2Thid4c9UKQg690mIpfaASq9hmZtPPXVgayyINfFkaZYoCXq4fjZPLmOHqN0Hj43BPs6r1Dw36MA8HODufbn4tT1vdi/66Tw9vEcp9sW300Dy3uc4by517jkJJXamNThsAwFp6/GhFgr8rdUvmrn7k3f4KnUuDbv+lJtM9sTiOn4gZMp11ite4IMbDJ7gi46hJ950U99R2bPpFjYNVF1smTCqVN68k7LGoI9MlRuPc8snpTt9VvOUmsOkPLyFppjaivF3Jbl02SxCbUcuLaQt8vuIFUCc6C02n104g6CfdIn3bScToHasTk0rfB/Nocm4f6zjzjvtPCKgmlS5z1kcduHE+5X3n5kpfvjVRz+1idnmmq7EohizcMtChoCcGNYGLgqlT33sdloUGM+xLocUTUjWgUaQW3qpJKZa/CvhZCSPSNxLeKEKuvUCQkT5CsLnG7WDticLE/htxHSSiJYV8cCQrGgFt6W0MP5G2q+1u7oMuiANFIa7vRs4dHyXRJuLQV/+Z7T97wtaII73/Hht24J+Ne2LF92hgWLMogs4Sni0KfAmutRISPPfsI//33PM3vODtuIN7fR/6bjz3K9338GR4LgS4Km5PeU45SixxrheDrd6S+djm3oyZpEoAd73CvT2lTQfAwFT8PtUvO1GckrNZs+kjKgbFLrNfJXfG6xKrvWPeJiEONKcpRPrfw+plxIg+fzI8wCHmdLkceMvHbIfH7wCBvBkKzVMw/tLSdN4uCv5yoJ9h8KvDMTnuL37dgqk9uatJG2vAQxaLNhLSWPS4PwajkcI5oaMDhcx3q7GSRPE2Q02E5iqhtUr/ZLc6aTGmxurAGzU92p9BS15Ajtrvq1Jv4eS14iM6dq5FchcGEbtjxs1+64nMLL/3vff85Zx1simCxJ4RWIpOveya3sJwdOUkBQnLEqI/uvJiT2ymn6CqC2rTiwWBtIH1gvUqcnp/y7z3zxs+I3/fhc26fnBBSguDT6NhiU6MYtTWDtV1LoRWwgHkyo7R1Qzv+og25mAiG07XSSJEgs3Rx5OCgmDiQLwmBLnhxXJsvBmuXudRA7I6JZXeG0c18QuVeUYIFdjtPBMwugCebryQIzrCfpMA9bkkrwL4YxSq9VnaGf7YmfdnjjpyxGdB0wbPWUzP2KqpISM7aVx+GihnbUqEYq1Gx6O9t+TVsB05N0aqEaogKplNoVThG6N4e1N/CO/RF8MNosApQR0OkssVlPx951w1+73NX/I2XX39X9p9/9DYnJx1Un5arVjSkBidPvubNxS0F6lDbtBax3pOE1mHDN38g8xeeOuFjCYDhAAAgAElEQVSLL255cVd512ni8VuZ1emGIM5kT8HQUsgRcvad4ATXisjXnRBnD4DxByPQJZh7PLfbA4SzECAR5vEwdhmtIGthVV2DKwp9BzvLJFP3ri9lhp+DhDlv+vpnf737cnYS/eeyvZVjApdMbmeLzgCbZVnLFz9KJJNDQ3PYVR++P68sWrGUh2w8wpJ8Jswe6Q3BPuSQX9uJH+DZhxEXH9xB6AzZy6ItaJnmi0S9pUTR1GY3xAkenpzlartK6uQ0Nxdumwv4NM07kcnhYmuhSAaMCldD5e79PWjhROCrJfAPP31QodzqAv/6h85Zr9eENZwFQ7rESQxII4lNDnq04CI1R0KcvGWMTYYl5i5oK1xjXZLSS2CHcjoaV0k464Q//O1P8MI/+Cp/+6WHq1X+xLtP+cRvfswLmSRiSkhQVslRPBVhhR3p9Yu4nLPgTpPFmvujeRZ4bVyM2jqu0DSAAS/80tLKqjaHRpOm1PBAGGtNwx43h7E+MuwzN4pyP8Gj656nsvD86Ofjclfp+8R+hE2GXVXWudnKKlh0bn3fYmFrcMZ7NNfyqio2VnISOguMOKk0hRZNXYwYItUKpTRejAnbxqmQYETF140SuIqJVJSCUAel33S8dH/gcquUcnxV107YG/Q5ock94+dBa5nJ+/aU/hYv6BPJSVyqVKO3t1mEbEKpWyRkPvahc/7Gjz7Idn8yCn/ko0/wbR864+Yqktbd7Em9tHqVhVQoNDMQxkrNCZHCGIxcjRKEfLriQzdOeF8ZCRbYB5ftbFaBroKkQJcTORkSvXsNwvEU93Ur5vY6ijg7IsDZQ753vNFqvtNhuihklrF5/ldlQDgN/lA/jUI0t52suSMHjiFqWWisH/Ib/3ndn5bRn4c59yAZe1gSGNeKvCxe64AiL5Xah/p5HctY9gmT7PFolbAktzWpmsywujy0UM+65sV7WErRZvKm2gNIhdlU+KZivkhXazv3au4h19w02/PRZsLXlBbmxjRuU2yL+y+oHsSOjZAnzbvbcEUIpXLnYsddArko2yp89st3+NRCpvQfv+8Gj0chrN0DwtYdQZoBD5NETglNWmIWiMHm6VYR+ugog5O1muKgMfqTwInAkCInWombHlkl/uT3vIdPfPZl/trPv8bPXhYiwnc82vPv/JZbPPvOM7rVipVVNHvQSEoRlUjPQZpnIlj1DHVpXrzW+AkBayY72oxldF7LKEa1SrJINW26b38wTBN8rTrb/jqZwsl12Zxgl0JCcuXObqQbKn0vfPxmzw+0JuUX7hi/fVd4dJOpY+U0Voqs3aa4OSh2Ed+RqxIxRvG8+Ig2+VwgVGMfpt/p/AEx90/QWppLI2SEbRlIuXMXuuCrts4qO3UccKzqbnMx8sp24DRGYgjcqcPRtX+7V1aqrDHGCme9tKRFv8RjQ4Z4mxT31izodo3uFQVKDMhYCRLogBxxzWJUtteMI/74M2ueeceGdz95zpOnGelWJFFCLXQxIcEv5BAO4O8EiaUYsaotRtQh/l4LQx3Z5EzMgVeHyklIEKHH84hHgZrhNAbWXWyv1XbSC1OHr9/xOi7PSx2/ycNnW3mDpiA0qDUGoyeAGIoySiCbeFfOcfxr36a8HJZGKMew9fWmI/Bw4tsxdiBfg0EnR9VUFqPzpNm2xTRqiyjLuTgvgktkQTpHDu5pwjV72mVB5vjzTWYik7vaVNSVB0P0ph3rdQqdzgE2skAvJl50e9A1CdUhuvywD5/kZLWqezlMU/jiLAeM1GCqutCwTyYeLF5n2UmU5tdAVWrLw95tC3f2IzcExpzYXu34Xz97sGB9dxd55t232W5WnFplEwO1FnKfPC3RLcaJklrD5A6OEJAWU3oU8cZiZaDOzq5WCDlxMlauNpF+NNYYdy3wOz/8BN/0rlOqCWddZtMFLgRfCyVjrYEyeQRIUzsEJ0ZKC1KZFpPTo6Nqdbeq4nniQYL7s1f1imgKBquYvCmwg6Jaq6MbEqBOK0CMQEDEzbSm+6LDc9hvxcjd04De3XHWH47Dz93ds0nCHkUksQ2RjTpSkJuO53L0NSKTlt5cTjj44hoNQqpGjhP5TwkE+rGyTYHY7u0+QzEh5MRQq6tbEKooO4vEUNirr0OK+D780XrFa5p5ZTtwnfVU4yl3U8+jwXkUpep8nwR5G2X/DTWhT1GakzGGTmEDAmOtDCp8/vmDL/Szq8gnPniTs9sralFW60QfIfWJdd8RYkFiIrTd+sGdSw77+tD2zY3oomSCRIbqFrRdTqw7Y1uMdRfpm1f2SZccBp3Y0+HY5ejr1f5MpWvam5rY9Bxpk99xEQmL9yPXJnOT41QumSH4NslaIAebXa9mW1KYJ/HUXj/MxdWOYfHFZPswQ5llZKItaWLLQrt8nalULdnzS2c0W6wdJhh5jgzlCEo9mnwbKYw23U7hGmG5HlieWlvI8eTQKCwbLLl2cTeeEgEa7H241sPyGM0SPX+F2KZv1UOi2hRkNEXVlrbkrg1qVxGsFpIERlH6IAwIQzF6ESyG5tUtc7RumPb103XVXtsd4VrDbcoAXI3VZX/7iprxhS9f8tmFe+P3vXfNe251nhseYJMDKSVnVc+e9NIiZJ2YlsWDRpiIaG1XHTkwTUUVkUAU9ddTowTYjIWxE3Y747TPLoVKp1SDrlb2MbAB+nXHqAZWyTHTJyfWIZONqx8Hbc1Tmps1R1Riqc0O1o9NDJPMz3fQvbg0zKNrA1bd5rW06b6b3P6aB3wwZdDi9sZ4gpt0GS72vDAMnCY/ft3mcGzvjZXXtgOcnvFEUFKFEqAjOHFSIIvv+FcxMo4DObnfX235AVEcYdwrBK0++JixTWFGcmJVL/bJzWcCxijBpXliXFoLaykFcCTlfnGE4P7FnvVqg22PXTe7VeDRXKnF2O2Us5MMWgkxPdSL4u2vt2hBn7Oam2YcFXIwxhAZ8RSzst3z9xf782+8vaLrE6nC6a2V61UTbILQBSNJokvOYA5hyYg+kFYIrm0NwZmnIQjBHJrattCGCpz0fqH30W0n+xgatL7MO5djKdDXY19uC3lRe6hMf9b2XiOyMENpiVlBZutUWTKoFt+xxe5wnn7b1MmCSHUo6odiKnKtSC+qsb3OIn065xzNpss7+kGG+/RidvwLF9P6IdHssGe2N8iju4ZZHDVAS3lYgwYXELwE31fbEbmtrTGuac7naFM4pJjJ0u++Hf9Fd+ApaAd3lymOczrf2tze6ljZtferpaI46ezSCtEiu2Bzwt4QhFiMFKcJzlcmTqiTg65fJ5e+QDClNJLddjtyORS6Ahe18tp2xw9++mDxusqBj7znJrWHWyljKVLNCZMhBhDFYnRv8RBBfP1V2oqhWiuUdkiPsxCcoS+eECABshojrukuGFI8Paw0FUM3nb0Kq6Z/vxorfYK4zmw6h/r7ACrBJ/XgPu7WrrGh3QShOnQtDYIvgDSf/pB8ys0N8pmbQDcBYA+k5iKn9bCPsonnIcmb46qeiEbhPEeGLNwbhL6M7HUNOHy9B+7vB57e77i3XvFUdAWERPHGQCfzHyOESk65+dFXeoQ9njOgGCuBbUg+wUNLnfM0tkErOUYnTkbXp1MqJjCqo3VjVSQlxjIyltFXOV2PJhiGPZd6rBd6ygZn18fIaQyIueHT1CC/nbT2G6Cg2yyv8pshTt6+FqAMrBQuqLx8WXmhHHZ0v+WpTKayOTuDUsknHV0WrEtIEnLTHMe4gIJlAe22B1SzgXLGqXpSlAJZHA5KrVhn87CGPCUDRYebD2SwX/tivizAs9544UxVVVFzWLRUD0koWjFxuC/OWvPQ/JKXjmUHKLYuit5kQOKSJmYzk3k3PZPRDhVR7fpEekxwkYeh6a9D6jtMxNeIdQ8ly9jx3187/nPTYHa0s+Z1VgIPuzZt0QDO+d+L5mpi03kQii1iSeXgsMZhOl/qzY3jvclRaIrZHIYSOKSrzQ1cm8hLNQYJUCpDLX4Xqa+dahLuKayCkCOMZmyCzNIPs0bubE3IBDlIM/lAFVVlbO57tVRe3BnbolgpDEX54q/u+Se7wwT5Jz9wTrfuOR2VvvffK1HchjTgngW0hK2GoOhiJRNbc+H3oFCaUY4FL4zjhCQJlNic1kJEk5Jk1RpeYSWKanVjFRE2wehzJrR4YzVvLObnw2TuE4VkQsElfGoKMZDV77s5GGeGVBpnIfhzRMWJZxOiE00JEqjSiqn6ek/Ur5YkRilGjQGGQkqBu7uBrsucjlsuRTmPh+feaPDkOnBXjafKyE57ukkcL07XjzEQtLKvigQjS6CGQFGX0KmCZI+BjaZUnCPTmxJTopaBdQwUUxKCaGVsYSw5QVVxpAOPglWDqxHCMHChsBfh6Rs9n/7qgSSZg9Df3DAQISfGlMgtMjU34pEJb8/ovyEm9LYzVJmCJnzflKLwVQyj5wvbY3b7+WnH2dmKS6s8edYRga7PrEVJIXkOcJCD2cgiElKnXWH7cym+46ptl7WrsGodesDoTKlNdxzDITCEtn/7+hTz5UN+CrDxyWxUN/bQdkOJCFdDoQ+B0SCgpOBWldGgi8YQGrs/+nsOrTCU1tCklmomIlQcZu0Ezza3gy1JWBQpUY+NnIqNyDGsf8Q6n+o8D64BjlX0rYkxOeIELLHv6X0u8+Wnoj5dS7aAxZdH9BBxwrEu4Fps43G067GsbCaytaI47dbDUUOyXCO0yS0sofmDNnnyzp7sW5cY/tTsBDtI0UpVxuq7z7G6pnqswraqJ22NhW3OlG0lBaUGoewH8mrFaMHZThhRIqP6Q5tZ0ua7AZ2bhlbM1bi3H0kouSgXozIa/M3PHKbzE4GPvn/DU52wOumJokiOSEoEUbAwEzGLNQb7ggVxIDQ6bF1psL8vsRmlEenawrVrxC2JQmgkTgHG0dhkoWpCUEKIxLboCDHSa6XEeJgOVZF4sNx1hzht78ev87Eteye+STCnrZu6bWoI7nURaoHkK7nRFFpzUPEEsxEjWqESCGrsG6JQakUMqimrPnJnq1ysT7ksW9b7V49ug+2YOE+Rkh2TPwnNjlYO8l+Pi47sLVBKIYZ2dGJj7Y++V68h0Ikb0UhbF0hI7EslRJfcDQW6AL0okUANQq2eV1/U2CmE7UgOiXTngmDCKgu/uj20yR9fuTQv1kKnESiorDDfe87H9u1S/htkh+5Oif4wiw3+KTFwGhOXa+iH/RG56OZJoCbhTIyOwCa70X/ILRlL2gNjIXq2GZ5u4Qqq83/F3OShjoUeoVh1KA6oktp0qtigrLvUYjoaTPtrGN57LbX6UMzVH+a1VqoaQ61U8WnMqpEMLoeBIu7YlhSCVEZgNNf1tvmNbspvbjtTBAbaVDFBdgEG9Z36ZMozyZ7mmiNAqZ5i14rQ5Md90IcLS2vTIA5fyzIw5npDNO+95UBiWzRlMvmWL0JKjtjm2LWF96GwT6uFA2PdDp7pdkAo5oIqiwK+yHA/rCgOdq/KZCMrRyuICV4NzWlt2hGbHmvi5AGS4JI94VOllkZ8M7cwrdUwi1yNhaFWggq7ZITtFToKcZU5KwMhZIZSqQIxR7ZFURG64NOjNDe0gyvcAilpcPx2MLjaEvFo0M+8eslPLFzh/tgHTrndrSnRs7rjKhKag5kRyOJFOgaXStX28WOzz5ugbiG2VYb6tWVO2vL341nlDsNDih7fukogVVrqnbmDmhkiEREhNWTAr8NAmhrcBps44a42JcFBCqghNMJu0/UbpAyl+vkLLQQoqXgoihgMIxoTkYDGgNTqOQfNWa62ZlVDW+UIrAjsQqWvASxxb7jkVhhYB+PT3QrnrfvxOukDcazsQuLRVNhK5kSVrQSSQTJX7kStZPFnG3iITJ1Mb6rftytphEo1QhfR4uz90JALFPrkNr+rGCgEhqqsosvhKkLq4Jf3Hnj1vMJTt055pRR+9sWr+Vn27nesqV1HiJltDmzCZPV6cK9UOCalvv31FivoC9xx2tnWIDAqMRjDaGySUa4Kv/LKoaD/1tPI4+sTSG4+kYLvZbrssJ5MLl+yiC9lsXs039mZWSPACWUolNoISBOcaZUSAkMaHSKssI7B9bHmO7tmff1rsD9/wMF8LuY2FXP1B/jgwduM+4EikWQFq8LVdvSdJUIXYYiRTo2chH1Qj5MtyigQqYQ2res0BzY9cK3Wpif3p56lQ+5G4hraloamDQZ0AxRnQsfQSEMT4W3OOZ/ywW0xqE8a1GM/c5GFB71cc2FZ7NFnLfqS/HZ9Db/gBkzGLksC4VSs5zouh3MxTd4TGY1FIpRyrejPUOw1gmCzq9WjlkPaZH4o+HNU6kPE+d7QNYtXVXZjMwwZlUGUy2HPSRVeLYP/vqGyjR0n1bhfoITCza7j6mpgc5rYE5EUkKpukwtzxrfi4TYTolXNuNzuKcOAdokXB6MT5e/8wsGzPQg8+/5HyTFw6yQ33oa5G2PzZC8YKfgcNpFKxdxf3xs0Z5mbHKJIY0NBijhiNBVzGvdlonVa8e9PGQ0henLadP4keINYJNC3xkxFXUEQYrsmw4EYiZu/iPq3SyOTjShSPB88TPt3jZSp8UbpU2Js1n/ZYIvMstCIoUGQ6trtjFGqy8em/lfrwM2csAIv3rvgzgKc7AS2VxVZZ25GJ6b1VakSWCfzqVpAxhELAYuBGAtq0YemYmhw2eAo/hyMIZKlsC3KGldLZAlchsBGlFI9rXA0xSyi1mB48eMadiP9sOdqP/D4KjFud3z2lUue08N9+8R5z7lWJCgbEwaJnDQ5n6W21lrUgbe/3uKkOG0LyqCGpMi4r/QRrioQIl+6f9gjbU46VJVHQ0fNHSm7i1QAuuA66SmLezn56hQqUQ2biuNYEROuiieu9cAr1dgEuFLhtI5oKehq7dGEAlqMkAJVD3ooucbMvrYgflNMggOT3eZiYuYFs1SdZUnD6NDiTisWjFqMq2FgNNhvC6fB2NIelDExqtATsVDpcmQsI7nL2FAZUySpH/fQR6r5o70URwD6AGNVUgjs1Fy3ipICVHF7yBijJ9WJNAMSz0a36rvPihFtKm5ueOHJpAc5FhwCRuyIeTZ5aD9EzmY2O+RJY4yzKOrz605HtUWIPtAfyMJ+VZZDs81Jbs5UX2jNJ2LgNb9zrknQpt8yFfNZWz/pnWnrj8WFMpnGTMi7tv28KQ6xq+vBd6MyjBWqIkReKpUvvVz4/Jfv8sXnL9EU+IanTvn4u8545KzjtYs9ZyeZiyJ00ZBaG6O9BQupUduHq/gEpgJlNO4NFTRwfxjR3cBzdwp//5WDgcvvf7zn8aikdaTG5FatRCR4EZrseSey5qQl11mT78dhslpNyOyB7qidUSYTnGY5PKrNTH1S2xHj8jaI9I30N5E5FehbB+668IDVSmqNKKaHMCeF3TRxVM/8Rj0udDpXxbwgTfC7IGQFDd4UdNGtVLOpO1+Ir7hEoYZEp4WxSSDqqI2DYehqRWFkNwx0m8AwHo7z010k9kJKHr6StSAibFJiUG9QuhQZY6BP4sqBkIi1NkmgE4En5MFJs06nzarsJGDBHeBW5tedNifJ2pZKEjzdrVRF1LhzNdBl4Ut3jLNNR4zG1Svj0RPu2cdOsZRZbTIqxioFshopTXL88HYhf6sX9CV7O+D7WmVKWvPktSuLFBl46fJwgfymzsgrwSyyiYFkRpdicy5jJqkdEa4mUlmzNxyrMRTfW+1LYdz7HvIOI50FXiBwZsZLKXKbyDBUBgn0yTjJeDcrh8Qul4RcW7QeicNfD5df+q0vgOiWQKdmWFWf0NS4KpVOYL8vXO4qtY68tC0899W7vHZfeeI08tgTN7iRIjkad2uh2wunyfOTN2NBOuH+bvTCWZQbUdhWGHcDXY7NptKwkKBWToJQg7NfRzX66Fn1pEQXQEthGI3Y/N1zkoMlJoHcHswm/n1k+tThwKRvY/NxcebIGGaSBU6T+PJnryeVLSdwm5niRwnkx9r4icBnS+hPFpK7g3/61GxJ+8tZOs2xlfGS3Df7pl9n6LeJdGlkMxXzyQlOWiNSVDFTxqrsq6LN1vNSFVH44Z9/kb/4yVe4Wk74X91y+1Mv8+e+7XG+9d03GKjoZuPhRyrk3K5h9bhZd5bTGUWoRbkYCqUUDKOMBYLwE1+6e3QVf/cHzlmfr5DUkaP7POTYEu9ac5WP0q4VteAxnNbGYFVCFKgwNgVBbkY6fkAUpRHKJJCnY9yia3OzabOG+EwSs+lBEIHOfDJWFCQhzeYVMYp49KnLAF0aV6uRAxR1C9hRvZHtrTqiKLRJuxFEU2zrOWFf3TY1usQANTfuqQI93thanSS0SqitSb97RVVlLIpqBwvju2dOI95zR8gdoT3NR4lk8UWgmhFagMpquteCoOqs8kEhtoZdWyOSZLqIHX3QEDwcy5Q+ZkYrrEW5r07AzLjd674NG796Z8/T54l1Fi53wo+8dnhef+NJ4sknV5z1kW5f2ZyvSNWgDwf9//y0fruqv2UL+kxOEuadHW3PUxFGIG1HtkPlK/XwkNr0mVWKdH63uHVk25vzMMZzm8yr+cN3NuAoyq4qu21BTdntlB/7/Gv83V+8w//9yo6TEPjd71jzfR+5zTe/+xaxd+bvMApd1zOqNnOItuOL1y9HeUMO+/LnbFHUFRrM3kh8qk4AKsZFKVwNBruRv/7JF/iv/9lrRyDA+/oX+A8+fJNvfN85fXJ/55cvA/1mRbGROCT2CDkJ5WqHZGEnHRIj968GVp0yxMww7jlZ95Tdjl0pbFJHSsZu8AJ/MxYuQsa0+i62VjaiDJrc4CcEolVqcNtMJvOdhpZI29WmiQw53diT8GAR+bmE1uUNDrE8pGFcfvOBmsrCRXAhn5n17NeaC47O3KHoBzm+ro/WAI1gqYssPG37Ypa+7EtP/nZcSlu3TND7fqE7v9wr7AqffO6CP//TLz/0Snu1GH/iH73AX87Ch58+4Wav6KpvUiqjBIdqc5PCRXNURs0bscuhtCbCCVK7K+V/+9z9+fX/yGMd73jPbddM2x6jZ5V9irQgmIlrsFuXFgzGEAnNZU2YlAhQqysvoraC04qtNkg+TgYvOiEcBwe30tiFByjeJ3sz9R22SQsggRASofqkWtpxz7LIfRf/HaJQ48GvIgK5Vndbk8aoD9J82n1Y0CDERtArEkim7ItnmmZxm+UivjKI1a+Iy2YEVDSyzZn1bqRPla8q/IP7BxXBbzsN0PXkAMPgSNuVCCemSIwz6VPHikShjpWaM7VUUgzsDVLytWFu6pXSHr5ZhA7YmhvKiCgmkcGMDcLFxPAPod2/YBW+eH9EtBIscrEtvHhP+dS9g0vcdz+9YTdWSpfRLroyIbZV2xQi9DYp7q1d0G3x6JMF3CrmBK89guTA2GdevHM161QBbp4miiT2ER5tdoSmhZjzDK89sKafGOLtQtztR/aDYk2q9vJV5X/6e1/kry7Ma+5X5Qeeu+QHnrvkz37Tfb7/Y09i6xUjzhTuMTTSfIkbdPrQXfrDJFVylKclS/eumbHdduftwbsfRi73fvOVYeDP/dBz/OBXLh84tp/bK//pP3mVPzsq3/gNN4hS4WRDvbriToqE/Z7RKjdWHdutcbGPYFfEFCkCpxYZ91fcD6BlzytD5dG4gmyUewNplUkiPL+HE3ZoCmz3e1LqCNGlULsYiBE6UczciKTLkahKDbEZBrkr19g85anaDHoWZCyxowf+g3K3ZmHLg1nr85/nzchyoXFtJTKR7BZsd7VruHw7LwekgFagZZbqGQfG+pKpPunhQyME6syUX5rLzLhA+9mDVM7MEaVSPJ1qO7Q/Axdl5H/+qRfe8J776z/9Mh981xnbUigXSj7JmCV3ShTx3ap5NnxokPZ2rwxXe4axMesVfuzTLzEuDuJ3fuiMEwp9yKSu5yRN/txeUIFWAJuapZEHJ2+EqiDBf280Y7To9jIC1t7bRELQmGbOhXIgR5a2wonaPMzbDlxrJTbkwRrULPO+e4ri9a5uX40cIhY8oxsDbdclFhxEQLCWmIY6B2DX1gdJnECazcl5yRxtLASkFcGhViQnpFRqI5k6sdGNX66GkRoUDcpLr+4oIfH8sJCtaSTUSg6Rs+TPnD4IqVQsR0Qczck5YENhjJE6jk1u66uMJJNnReXSEhmcA9BipiNGVSHGhJi6AU0MSMuRryYwDuwq3Ls/cP9ix9NP3mR/94pTK/ytL907uu4+8MyGR1LkJEY6HDUJ0SNxj0Kc3nZ9/Y2xQ5cFLFcVYqzIHvajEaTyyMmG+4sHSFCIdWQlmSsCpxhRwwzmPdA8TF23GWhlb+a74T6xuxq4UuP/+slfPSrm17/+/Kde48nzzG979nFWG5duFK3k7Bc9NouTeP2ZcdnM2NH2nGtw+7ySVcW0UhsZLWQY95Uf+dzdhxbz5dd/8XN3+I8uB0LqOM8XfHGM5IsdMSV+5d6W9/WJX25Pyse7xIsFztcw7AtdijyaIpuzNeuV8vTqknK64tE+cdsCFwFOh8K9FDlZJfbWcaNsuYyAdJyL0G8Sd4ozhNc5Aa5zTaWwC4EuWIMIq0+qDZqPs4Jgsf+W61R0O9bpXwNn7CGcBl1ovGV2yuOYKS+LqfzauZHmI64cJ5yFJQN/CeXPu/IFz65Jhg/a8kOe+aFh8IerTsYq5ilXk2CjMyfCjeJSol/48gWfGvUN77Mfvl/4oy9f8b533iQUnz4tqLukmFGt8U5Mm+oEhv2IpcRJKVwMW/Zj4AeeO2DA33mWuP3YDYRATpWT7NKwOYFOPPM6qMvnPLls0dTIwaNdavVCLE66FJvIYi3FzoyiQkYWdrl2CPlpaIbhhctaqItW15LHGJlGy9yiR/34+utJaNlozgJ1hNDcTS6ZzeerFDfKqeqoUjBHz3IM1GBEPGmsNneN0EiHnShF3AZXEcpY53s9lspYlWFUVnvj6sv3m+sAACAASURBVHLPLne8+MJxcXz8iQ5R2F9esTs/R0dj09Lq9qp0LTmvjEoXo0egise9UpUdhqkQU+B+hU1WtkMlK1gMnroWI1YqoxlJhE6MWn29kNQow4gBK4Sf+cprPNZH9oNSUuDFO8YPfvVwffyux9Y88+Q5KQm1jnR9T0jB8x8eaLbfLuVv2YJ+TSJ8yAsWZayRFCqbOnBZha0de7hHE9QCu20lb5QcIyriF+BD40udoQlClYjUve9+toXBhKsXL/hLv3TnDd/zX/npV/nWDzzGOFTW2UE1VWOojfhj5hOYvD71jcWuyB7IRWORZ92mCAlNjztSi7htYoEf/pkX3xgFMfjLn78Crh769z9EXfzf66XYXTzwnU0Qfvvtjvc/csKZ7Xn8qVt80yPKK6tT6rjnkdPA3aK8Mo6crno3Jxkqq1VHrCOx7SclRrBKSs4SzhPbPTRBYPC5O0zEJpbQ9PXFzYEvd03uzlEcSvPqVpj5D7J0tpuDTqY8bBYSueO1yGQ4M03gM6N+wdBfogtL4xhdNHdBDgTIg8f8ITWtNqTGyZGwb79jN1SsVi7Lm3fBtlFIIRI3gcGMrM4Lr+ZkR9SNRywIF/uRe/sBQ3ml+nrg819+lRcXBk+/832PcHuViKkjEKghNkfFMK9MqjUXNPGJtoqf0Yhh1VrhD1iIroUWzxRXc1i4ClhViviuui52IdIsTaWlzE1rC9d7O/EtxOANkvlePeL37HQ9IbQ0MhB1l73B2oNS3NdBJxyosfcxd2czkybDVAYisVaGEP3fyMHgJYfIVZgCUtp5bt7xQ3HymoigQ+FeDJS85lHb86MXh3MbBB65saLvMyEmhlrYrDO1DGylQ4MwVJeGSmp55jEwFPeHryG0rHaoRTnJgXt7oa+K5ozVSk6BUD1oZRx9tbC3tuPfu9RRY4SqfO75e5wpnD6y5qWLQjDjp375gruL6+O7P3SbEzNOcqZf9Z5uCTM6M8Hv8HqRyW9/vYUg9wUb2ZqLEdL8o42SOqJVbFuIcngIjo3AEceKxIoWQVM/a3stypFZ2cwhNgVV9oh3mSKYVn7pxas39Z5//KrwhVeveOaRE6gjNzc9Y0sWqmZkk69RyI+2rtg12tb1YzJVl9q8p0cL1FIceh8rP3xRft3O3ZUaP/Tynh+arHg/c8lpEH7zecd3vXPFh5+qnJ+tWJtyMQjP9Mo9SeiuEjrH99ZdZR+NHFze1iOMBl3yXaQ1MliMMrvRxcmhTo4tW6/vzK87sS1bp6U0zh5iFaftIaPTv7FrxDo7GMEEsbYHv57rbs1GVebpc2mtJ9euiGXEqdux+lSOOpek1upFqCiDQSlwOcCWyLgvDWB+c18aBayQxgh9R5cmD/PANDJLgH1V7u0KqLHVgNWB/cWO/+XThwbvmwJ863tPOAnur75eRTqMJLHJ1Hy6ixM/QY3gKSxeYKU5suFweGh6cF1EuU6GSoRwMDVqxbxxwudgDzuYEZC0nZvqMq1JkNLhawo/122H3ZQU0fyzb6sRYyBqoRJBndeTBYaiHmpSD3a6BTzcRBVtVqtate2gAzm1RMPqChDDiWdWjW0zsVE1rhTuDpU8jGz3MFbhS3cOu+jf1gur81N+9eKKJ8/WnARhp5VeMlGVDGiM5OAubxk3u1lJS+8TIcTsq0cKtnP0aIyJzlxS6KZa7g7YRz/+oVaG6qseU6WUyt2LgS/d2/PBd547wbYWXnhtx//+1QPK+R03Ms8+tSKdJk/8CxEJ5ooBOaCyE6L1dj1/y0PuxyWsNuanNH1nHQtUZVMrH0zCzzVi3KjKfQI3Np3vuWKaWcU0oozLq46DSgzxzHIKpEAYC30p7HbDmy9me2Msys2UfWLQ2qwo4yyher3tuT0wT7J4yB9K//yem04zBuFSnD0WayWX4UAAfJNoSC+wSoGzLvDtNzvOoiAR7gyFy9jRX15wp888jfLVIfNLFyMvNOOSN1Mu7qvxU6/t+anX9vBzd3kiBf7AU5l3vWPN8M5HeHqtfKWDfgjcpjCkFansCbnHxgHJga5LbAelS5HQgkhEDwEoE0QrixS1B0xY5oI/mQnpvCu1B9Ne5pMzxZpOlsATp2NqIqv6zjc097SD9au7ESoH6NC15W0BY76flEaKM/NCNsvWFt7bU/KYtgW+c6z8Te6qslcjDQP3qjOVX9oPlMsdp5vU8gi+9qT+r60jH3ziRrN89XuhGuTG/wgTORWoQyWIcTkaYpWh7Hn11ft8emHz+l3vO+HGjZ5LoE+RWyFgKRJiIEVHqkKb0sM0YjKZyUzM90aKbaSCWVZornqxNmVTnR0uZqiYw/g4BB+aPWxo58EbgIipYsEHhaBGTaF5rPu+GxNGCfPeOTXibGwWu0WSF/ogdK3ydNERM4mTRZCb1KA+jBRTQoDkqQrsSiXktDAqktnVyESg/n/svXmwbelZ3vd7v2Gttfc+4723b/dtXXWrNbTUao0WEgg0IBABJDnEYEEI4BBiUsSJE5sQx3YmgitlKhWTSmzsShkzUzEuMMYgUYAihEBG1oiQWmPT83inc+85Zw9rfcObP75vD+f2bbXi2CkselepunX73HP22Xvt9X7v+z7P70kMQ6avFtpFyAzzyLWQ0AX8wUZB/4rbtunyAucE31oO54Gd7Bj8QGM88yxMSPRZGbWOGCLRWAZROhXIsfA3RLBJwVrGFNqkIhxnQTUWN48o85SJUu6di0WNfQ2Jw6h87uFDnnfLFn0fiYsCt3rPZ4853rgGv/qFe2w52HZtQWXbuoaxsurSbV3DPFvJvyxG7uu7qlCoTkaKMMqlyNak4eqVKb4rPvPl44GjzOtzIqUBIx6jAaStXOelzcc89UZfxR+ts8wXxXd+LSi7292X9JyNwF5T1OEzA7u54BCGXAhr3ugJoR8bcrcbnT5PFne9zva09OiWTmfiLJcXGWNBmoZvvHnEP3nsmScLP3jXHi+7dcTWvidNldGoxVlDCIHOGYxGsJ7R1s3MomGsluPQM5WGbSIH054UlcFCupL4wvGCfpaYzgd+82LPw/2Ni8iTMfPjD/fwcM/EH/Jtz53wqtt2ePkdOxxmRS7PmUxakma2iUyM0Pdl3Kka8SWTlgT4XKAhrsJBVra2GxV24YQ2QTeLuV6XaV4LwbLjT7X701x2t0vA0PJrQs05lxVQaAkG0crKX7+jZv2t67/ndTSprpb6FUFcE9LqyDivfpfSnVcXFYJyLWb6aeSxeUCuTZFkuHQlcivKI89wLXzva87iOylebGvJJKy1pbCYshM21V99FCPzQRmbzHShDMHx7gcWG6sN4c4XnEVDoGssIydE42hrIHzI0FFyUmWVXre28sW6V88bqkVDSVRL9fubpeo/pVKETPWhVziKiGBd8XUjJaa0HNpL+plRxdgCfc2pAGHichyuy3VOObUZA0Mq3aOt/AEjxZIlpnjIrTGEaqkt39eUyYJUh0Ddq5tsGChMC+fK1+RKvsu5BEYNKdL3uUCjUmHm55hpUmIelbPW8HsXT+7Pz+22hCHhxh7TJ4ITehW2o5YAHldYEc4J/RBoXMEy+xjprSOnEmAVVIuALik2KdYbYlSMxmqtKx58Qci5iC9FIIXM1WlkuugJyCoQ50iVBx465F2X1t35v3+q5SvvPM1NEyGnRNs2uMbgTbEG2upOOhHP9GxR//IQxa2LWemOskBsHf2QOdU5LkXlrrHhE7PSHeRFLBdhVkZqi581a4n+vEF854lDRM4c9ZmIRRXaNnNqx/Mcb3j0GYRFf/amEd5Zckh4b/Gu3Ky8SAkxkBtYptATY+CnSj/kRPk5iUMtb1ZQmCfBeU8MgrFz3vyS/Wcs6Hd5w0tv32FiDbutZe4Mk9Yyyhm7PS7Kc51zqC1dVnbGhtl8ytZ4xFkSl6Pj5q2EjEZ0VpDTmTu1rDg6b/j3euGBJ66iYcGDh4aPPX7Iey8+ddoxDZmfve+In73viLd88hLvvHOXc+e2uTbMuWO3ZZocoYdmlKHtagZ3QVU6Z8roVMvNcEkAXIadPAUIs/HiL4u3Chv89w1tHWVXvEKd5uU/S/ENKSNaui6p2o0oikMZKLYlFS353BTYiVnp65Ywm5MZ6VSU7QlhHaVwaD0khFxG0lo79XnIHC8i0+mcy1d75pKZD4ZFFB564pi//9kjDp9hjf5DL9vj7hfuYY1FXfGHt8ses4JUtGoLZkNEh3Kw7nH02vPg44f82qX1e/sdt404t1Vyt2U8Zku0ZHkbj6IlB6DCnUoeTAGRGCkWPDF1olWRwkudwtJpsPTse5TBVDuaZgYKEzxTxvU2le6QOhkwVWDoq9885bQa80sV/C2viVwDaIwpfnhMWfu4KgrMGBq70fVrorGGoKUASzGroiIkIzgxeGKNfS2QFlvDWJwtiW79ULgSUq12fU4MCDFmrswjR2I50p6Uhc89sS6QtzeWmyeGRgyLmRJ1oO0sIsoxlkbBxoh4S5sS0RpyLAffXiyNGLAwHwKNc5iYGCgn1z45csyoq+r2nElavfopQVJmCsMichQCIIy8MvSRgxR48HLgf75nffgYGeHtbzjPbSMYcIwbyz4ZEaUxJU7Wrlouc4IZ8uzj3/KCLpXAVf5ZCGRxyLRJOYwRiblCTtZ/56GDQJ5npt7S9YlsoDeGxlls7QCScmIsvamm3LKCpsyhZIxYRrsjfuDVZ/nvP/TE0z5Pa4RvfvkpRp0HYxg1npSKwETErhQdTw0FO5klptftfk/sd28wqhcpHUdGSZJKh+46vuLFLX/9yTk/es+VG7/JRvj+153lzHbDjlWCePZby5bPdH5MlMw0C9bvcDYFctOgYjgzHnFtHlBreZ4kQmoZUHIItN5gMRy1yqBwxsH+C/dRDC8/POJrXrTN9w2Bzz0258LFGb/8yIJL142Bf+dyz+/8wQXesHXAn/8zp/C2oY0LtjrLPBv6sKBtLaKWbDMihZvvrFSAT0WVmrWwbYmNrE1vDdBYp6BtrjWWwrNlx56XQqplGEnS6sEuFkeNscRmAj0ZTbUwm7I7DRS1b2GaGLKwXhcURgomr71wskpR0/r7UHGjy9Fzge9oyswXkZASB0eBoIFFn8mNwy8W2EG5575jfvzBk6LFb9tv6Jzh944juwbu3La84SVn+Orn7aFNSRorqZ1S0KAs8aoVqarCMGRmMTKfBXIuHfvHr4QTV+jrzm8zaTtGKF2IMPaIlVLI605+Gc1aphxF+GZEV6EnWglrWYstilTU4o1dBrMUYZmT6lFXwYquchRsTqix4JYCwlyDU8oO3krFxqriCtUVY4pYzFSdhrGOkBKWjJXSiWteo2qV8pqtCG9ZycbiTe2uKZHLOSViTS5z9TTZlL3ZiiGg9dASshJSWSl4hCuDEhaJNC9WWgM88uQR//eG//zBIfFLH7nIq158hpef32KWA1kto1h/p8WA9ZbWOwKQq7WtTCGqcDeX3zGTmWNoKEhoUsJKZtEX3LVoohHDLAnTIaJiGKYDh/2CLsMsKd57LswHjuYD//vHD9jAhPC3XrHDuS3wY0vXOra8JzeekaSyolpaUzdTKp+t5l8mHfpSVVzhIaKKbRxxHtm1wpNGmMSBV77wNL94oRTcD/WJ+RA4G0u2sXNC5+qNoe4gzXXxnSJr9GShEwnbHg4D7DnhjXdu89emC/7+Z66d2AMB3OGE73n1ac5uFcVr44UQIqORQ5wtftgVW/ykMOtkjhgbIZ56A3f6mnNuatepBmwqlrWy6+yLlSTO+Xe/+hbO7Dh+7hNX+MRsLZL7llMNb3vFGZ5zdovTrZANtE2xD42NoBY659hzpTORUO7qYsuJeW/s8EgZzUdlZATNDjWWdgi0KkxEuRYyvrGkpMx399gNif1GeO7elOO0xzcOwsXHp/za5y/zrovDiYLw+8eB33//k7zt5iO+665tXnTHGRYSSL3BOMtRDoyaljhkOgGwuNqdLwNiTI3KrKyOdffNkuK2vsSMXHeYWqakVdFCqN1wSJlBC06XKtLUIVUYSOkMj1JRDxvNdN7QF1wZna2FrP73ZaJfklLUNxXzihBTwlUffopFi5FyYJ4hznqOQkJDIgyRmQgpCsMQOD7o+eXPHvPr14k5/6Pbt3jrnaeYTIRvNsIp5xmMcLo1aFc8v74mgzXGoqYcFo2WzGvNmcUQOernTHuDTUXX8tjVOb9437oDe82plrtfeBPeJIZRx1b9vbH1YGstUaXgX1OuKNUyuo6Va15CWsxqpSQ1AMbackgyNeEn1/cq50S0jiaVfAWj9e8v8a5S7I7Lz7tLmd6WkbxJZXUimgBTduSm0ikrVtiKsIiRBlOjU0vxK2u6RCvFhkY9oOWlsnK5+y85xeWwkUpuuGRlyAnr6vcpIgByBfeoKouoyNCjxhDDQCeWBy4E/o/PPNWS+u7jzLs/eoG/MQRed36LRVsgWc5EWlvQrf0Qa6JiOVS2RlfPd1qVwjlSrGgiMCi9yZhciI+hTquOsxJyZugji0VkhrDnPIugZb8fAp+/MOMnP3eNqxv63O+/fZvXvPwmOtcREKwUoaTViPWu6CrMUl/x9I6gZx//thb05V04L4uvYHJEReizoXHCkXHshpOq7qsXjzm7v8fIGWaDkp0ykpJx7KroKC9tRfWg4OpIr0fw1mCzoXOQtKRPveXVN3PnuS0+cWHGr3/mgPsrPePOieeFew3WenqE7Vw6sSgGI2bF5t6sICpPp2HX67TOTxXFLU8GRiioRlNhEs5i6rg7uQnaZ970inN85YtP88SVY2JSurFnq3XYLDTeEI3BNYaxKdnPo8aSvSupTEax3qGNrUETRfXfGik2IhHEFiynZBjUkLqGvRzJtmHPBmYpsWfLTnN3YhmyYrbH2NkCZ2Dv9hF/6dyt/LmDOZ94qOen//gahxsHpnc/OeM3n5zxvfdf5U0vO8st+xOShJKWRyBVgVUwhq0VQa7ckN1SXLU8FMq6C5cNzrps0N5Wgrll8I0uU/fKmDvGTIyRrMo0Kt4afIxEbMmArkrnQI9zjozBmMTYJAZ1qCkeZ6SqtuupIWwGwKSMqWljgdKRxagsUuZoPpTdb0zMomJCYtoHpuLQRc/nnpjz85+8zGcXJw+dP3DXHm9+3hi3O8ZIYL/pGJuMs5aRlJxRO/J4U/Qo1kjJAq+/U0wJh+HaPGKzZeKVw6D0MfPJPz46cXm/8XxDzgMj49iquwvjpSSNUXzmvh62lrY+qW4FyVrIbEsYTC7XeK6TC5vr+yhlMSFiaiqdwedUk+EqZU+ErAnNSltqU1m95JIv7gVyYpXcl3GYXEa/aEkItDmjRgixxC4rZaWy7DgTxdvNkqmvRctRdt+KWFuEjPWaNqa8165OImT5d7MQamwxKeFVmdfkRAQWxwPJeRZHc372M1eY6tPvUP72Jw/4sZFwO0q/3ZHnCT8qYKDjZBjnRPYWkwwatRwuc9l3K1SoUzlsNAgplwnDEIol0mui75U+RloD83nEOuHqEFjYhl2NvPv+Q372gSmbS8rvOu34s6/YJwRLdJmx8+w4g/OCOFuBTJVDICd3i8/W9S+Hgr6J1Kx70rJHBCeZziq9eBZeuenWPWCNtnwyw90LOJ5n9kaOISneKl0FchTL6Lo3NlVcmo3QuJJoPsuO1pZT6fZkxBOHC7a3HO84fQa9uuDvPVQ6oN85Cnz3CMQ5JqZ0M94WVKOmVPCzxlx3SHnqHv264e+JrlyvQ9UKrJLQjNFyE84wb1pGQ6TXzJnWcS0EJBtuv/UUMUT6GBCxNL6h7QyjIZEag3NC6y0ihpEpYQtiykgUa4t6u4qj1K4PWiq27Fe1wDWKart0VtJ5OvGkJJwdKbNUgihChG3rys15CMSx5Y7JhOfdOnD3Xad5+L4r/Pinr3KQl0Eg8I8e7Pnok4/y7a86xd237XJ65JgtDNYWAtaWZnppUYHGli5JRciWVYZ4rvYvY2TlR94YAp14K/LGmD2mmmRXI3UjhiEEYswcD4JxBpnPMaZ4f0fGkoGFCJoj3ltmKTM2So4K3haqmeYCS0JogUUue/acCn0r1aKwqMKjXJCABeeKFmznkBBVjg4O+YU/vMp7Lp/UKOxb4Ydec4a7njNhNOlADDY7OidsuQbVzMgXVLFI9WEb1kTDmolhMsxiJCnMQyaQGbJydRr4pQfWmNe7R45vvfssOM/WVkOKkbYZoVlpbKGwLSN01axHJpFyeDDL6Uo9BCeKCn1Z2FRKUQ+yzIBPiDWrSUoB1ZTOOtZM9IUKwZRxvCrl86gUVwC5kNFEcJlVfKkRXTkQDOU9XuY9LB0xxQ9fDocDRf2OphJ2ZGqqWfWkW2tKJnpIYKtKnkLLWzknKt1OpXD5Y8ykGDgelGmlyn3swWMeTM/MFXjfYz3vmBgmWg7xB7OAmXQ0mriimQkWlYhdDLhRy0KFMTA3MKoY3OMIjgKRSiFxLSSIyhw4zpnpAKTAETDMe0bZcPniMb/yhUM+cnQyfOXt5ya8/VWnGd20RYcymrRsNw7rCyXPSHl9S86GrrrzZ3EyX0YF/XrL0bKThhLpp6K0Vhg1MN+xPG/ieaCGtPze/VNe+YJ9biUxE892ikBHyBQCmdaUrnoTkHoBtdYQtPCrG2eIWRiJQReBUw6GTjgMgdvOjaAW9CErDz8ZGN+eGfDsRMV2Fi9FtWmXoh7WhUTkZKnWG+zHOdGV6w1fIFNzm8UZFjHTiSE2Fhmg18R+67CtcKFX9pxn2pdxqjSlO5DGMPaG1lqMtdVOVP5bY2RVAFdRlVUcJCt6WRkn5nojzVlLEEUu6VdWlWgLvnLLGsiJQTO9c0jOBAvnVZkZ0Gh45a7jBa86xWtfvMd7PnqBv/vAerT4h4vMH37wEj94qectrzgL1pafVTO7R0Ok87bsfisFLKal/aWOPjdhMcu9OidDXpavti6tYblgTTVnjjPkFJn2gayGoT/micPAwTzigtLstNw2sqgYRh1cE8t2yuXG1UfEWoLkMjY2BkdCxDLPuST9VWV+TOVmvsgGmzNDpo5MEyGW3PvDIXN4eMxHH+n5mc9e49p1q6A3nur4zlec4aabWva3HSPAeIvPII1j7IRkfMHvimKtY1yjM021lMVcLJ7ZGqbzyGxIYCDOBkJMfPKRKZc3fu733bW9In0dp8x45BALo0qH01VqllQXQl7Z98wymlgKFS7XkXZYBuykTJYSfgIUyxRlBy85lUSznIlGVvayIAYrpevtdVnUi9pbgGAoQSAmEzC4qqI0ueoblhGuFVO7xMZKjXLNWkA2GTC5BLKMKsTK1wmMlXq4TAXn6mpuu5LIpoj3UsgFIxtiScir2+0UEv1ijqphSPC5a+FLunfef7BA/D4CTLOQvOPxaU/TdnhRJiQWGhAcXZ9IOfFEFEZOmRqDV0skMeTMYhHRYWCWHS4HjgYhSqYZMlMBn4WHr0Y+/9BV/umFp5pY//Lzd/ia528z2RthszAZWcaq2KUbxAp+dd9ZNlry7O78y62g60Z/aqSIVwoozIJNGBFSyoy9ZTbLfO25jp++t1zwf3hxRjpeMG0MI3qGrQ6JZV/ltMAsljvSpThu2aWLKSN3NIMrHah3ls5FQvSkqGxPPGYjm/oLl4553fO2iCpMDXiBcYl6Xgmzlt7iFa1Sri/VwkbcyAl1+/WFXKqwxshSwa0lAEUVUQO+/n8UomGrFTpjmNdduxcliWHcOtSU1YUoBZhhpPqAl+OvagWjjjIr9GMJclEpv2+uUnILiC8RlKpVLW0NQyoEOG+VJhcDeVMBLKLKzHl2fE+TW7qR5RterTz/XMtPfHrKPdfWpLofu/eIj19e8AOvu5nm7DanbWBnYSjhWQWW4V1RGEvthpY7cbcSvK25+ie6gGXIi2qZsOga4hIy0KeilA7KhYMpP/UHj/NPnziJBP6e27Z456tP45oJkkPZu0fPwhm8ifjG0Ugp6L0IGnoyBUSSK91sthiYq2BI2FRgHUdDZBqVw5Bp08An7z/mZz57xP03cF/84Mv3eN2dp3Cd55RTJrZhbJSFE1oanDN4b/AieONqME7xTGv9fKyy2BX6EFmEqqyPA7MkLKaRX/rUmqD4pla4+8W7KJZkHDs2s1WBJrr02VN8+lYodjMt14bRqkHQIkgtSWjFTZBTRq1ZH7wpB61lRrqpnW2JVzUr8JRK8ZUbUv3cFQFfrgS8wQg+FUGbppLcFo2s6HWGcm0mrcW7ClfM8pNZP/tWDL1KdUSUrh6UhWaaKpjLdVVg0bI7p9y/HGUEP5DxufAYRYptVHKiV4M1DSFkmtDz+PxLgwR9cpb49Y9d4o7Tlped26YZecYSii1u1HBhOiU7j9fI3AvqHDLMGMTTz2ZcS64E5jhDigPWOsiZaZ0SLWZzrmbLxx+b8tHH5nximm7YcPyXd+/y79yxw2LU4k1BahtrsN6U906WPnOp98oN3/mz9fzLcIfOmrK1PMGVSEGDt4nWCQlDMxJe95wtfvreouq9rHDx0pSd7Y7UZOaacLkUqKSleG3S4paBH6Zm+6rmSs0yjBshosgghM6xZROjNObNuw2/c7UUmg88vOAdz5+yeyZhum2SKvOkOL8cy+kNwTIn9+WbqNcvesrZKOy1+8SU8V4GK4VOJyaQs6F3DhsS1mR2sbg60jLWYk3Z51nnMKKrnHgjnNjbL/fPBkGtqcpnrcrnOpa1NZihwrqcWaIv18KirBRvcCo70nZkkJTovePmnJimjskiEtRw026D2zvP33zegvd/5An+zy+shVe/cxB47Hcf4y+/+Tzd3LG129L3pRjYUYtNiSAWU/euue6si995vTtfHoj0urQ0rTa1JVY1ogwh0wscLQIXrg38lXc9wEPDU4vpzz10zH2XZvzg19/K6a2GaDzJZRoDOlTVsHfMUyh2LRzWRIYpZF8mLYuotDEgCAuJHMdix3r0ypRP3HvMzz08Xcz2YgAAIABJREFU5egGo9c377d89+tu5bmnHLlrOeUzMwTfODCw780KK+qt1NFmmcj4ZcdbKW4FiFR89MeLRI4lJtWpRXLPB+474r6N7vytLz2FTQ4zMnRmwJquAFZq1mvxzpc0tJWLQIBlYV+99sIQU7H/mRLXS8z1YJlr7nmB8JR0NiU7CzFjTC4FPitIqiLEtcy05B/AQigjbWsxuUBRtHaMzpR1mYghV7CMJkBtucZjGfOrQrBCm7XY5xJ4U6cQMWGNI6JYih2rr/ecUA8KfQJLRlLGUUh8NidizsxyEV4ukhBCRlPmA/cecc+XWNBR+NVLi7KF/NyULS98y36D8Qe88DkTjO+4Y6vHCDRbYxb9gi0vzHoh1VXW4WzATTyLDEdXpxxd63nycMED0XD1cs/7nmlasEwYtIYsFt85WlPWS0aE1tS13nJeUxsJNg7azz6+3EbuS9ualg/qEirhRRnE1IAKsLbj7ps6tq2sbnS/9fkjvveWHeZjx5lYqEh9hlGKZMpYdFnUVzzwGpTgjZAxxFxSmWgcbWrxQ8LPexh5vvq2yaqgf35QDjTRmgl7VclsrNTgh7JTdfCULn2d/c1G5u+m/E1vIBJkHfO5UdRlOX5OFfMonqyZVsupP2LYa4SUC3LS1VOxVIEQUkalSyWwnlDdr98Po2tLmNQksVx3oW6p4telPancoMtAwaxY5V6Eto6Y1Th2pSTGtWroJ47deaCfjGnInPGWrdfcxPPPdvz0hy/xmVpEP7fI/HfvfYQfesNzeLXz7EnpdqxLZZEeE139fZbse1tTw5bd3pKRvpqKbHLV6+ucNEPKZa8aEl1Ufu73H71hMV8+PjDLPPdDl3jna8/gJoYWw0Ij4xSZqcfOZoy7lmnKHHqlm88Q63EhE1UISZmHiFPh3lng4oU57/v8Zd5/7cY/8+7O8s5X7PP1L9qnbyzdkPGuHNr2Rdh1iviGzpaCbVn7v8UUAV4B9ZRxt9TELbIy6wNDVOZ9xAKXZpELl+b86n1rS9xXjB0vvH1C05TOv+tc6fIpArGhBp5QtRYhVrFbLmjVxgjzWEJTMKUgLy1mBQhjsJSuuhTuuoQXSlpfZLV7dhUu1KuhyYWgZytONdUQJqtFfzKEosWJaktwSSr5CN6VQ5yrSFNTQ02sFtZ9NsI8G8ZZS0jLMqWsTiSwliHnoiuxlkUMWGMZRLAx0tf1W9SEUyFqmfzEmJhroWB2WUkhcLjouXgc+IcPTf+V76XHQfmFC3XK9Wh/oll6lRdesNciMWN9EQ0fmHINMgt8ZBa4kv7Vfu7/9slrvHi/5fwZoY2WWetoktKJInZ9uHa1O+dZm9qXf4e+HoWWTteawq12ooixpD7Q5sDUW952fswvPlgu/F+9PPDnA2xHw0Ew7BEIRnG2KWPhuuf1KwqJrKIqMSXoQVzp6AcyoW0YE9DtMZePIy+5fRf+aO3z/qN755y/WckxYbytVhlWY9tcg0Q2x71cjyLdpInc4KLWjUK+OgXXkaYY6ti83LRLcJQt4746/kehrRaa5RjU1A6tjNnNiqFnTjyNug44IVRZjwrMxolD60Ri+afLFLOsa3GfqUEYTY3hLHszj2kyXmE+LotJ2884No7tieP55+CHvs7xC39wgfdeK66GqyHzI7/7CD/2pvO88MzAeDICA53CvivQEStUwlcmObvqzG90UsobuNUMxKyklBhCvdkiPHrY8ytPzp/xkv3HTy54y8GM09ZxPLuMGW8hAm4a6TvPtdxjQ8Jr5Nh3cO2Y3rfM5pFPPXLAtSPlnoOe9x88PXr45SPLG190mnfcucVkq2NuhTMG4qhhUjO5XeMxrkBQhGIXS1L2xctDrLPFxy0skbMZySUX4LiPpCGRjWWxSFgiH37giIc3Ql/e/tLT7HeOtnVsGzBJsY2CcSU7IUZEq+JbpI7Di0Mi5EzMhZwWNZfiXEfRNishC06qxiCVz6aNuSQNGotnCfcpn6sSRypIDByLQ1JJKotSgkUUGGzRL/RaQlUcmZgLcz03wiJknMlo8ULSCPTl6RafesiMjS0hLSkx1ImHxHKFz1IqBxiEIYQCF4oJZ2BOPUDlCFFY2AyxiCKP1eLDgj7CQQjMoxKz4933XCZ/ibfKbzrdMHKWT13u+UL84n9LFT4+KB+/sPg3duv+9KNTzty0xUIyWyniGocTS0yKt+vp6Aq89Ww9//It6JsEtWX6Vcgg1iKqjHwpTlfE040z33Tn/qqgZ4UP/9GTvP6159h1Hb1tsFVcYg04UxK8cvW5LkW3slkcl8Iva+hixHlHmAX2RoLXhq870/LeGkLyzx7v+QaB+XSGGEvwxW+7REmJWRazjZH59Yr36wv5dVxYuQ41pxsdMbKBMRUwuezokjmZKRxrp1qKaBFAsbq5bz4H2chh3xCSnXgOG355kesWCcuxm9RdY+m4tOZI22ovcrbsPdUW+puEdYd9nFv2Cew5y7btuGiV/+qbns/W+x7mn9eiOmTlRz/wCP/L191K9p5mVhTMi0bwDLTOY2zZqfqqfjfKSe/ACi9aXh+yVitjIZoFm8hZaEPkwhPHX/L1+w8+fcxLd3rOd4ZgDph4AVtER4OxXJ4PTGLiYlS+cHngk0fhRBTw0z3euud4/Qt3uftF+5xZJGLT0DSOiUbUWcZWaBtL50tSWmvrnrKe0hojqw7a1CkXOde9uawCSY76SB4i85DI/UBOhscuLPjZh9Ye9zfueF58i6MZNYixLBD2vC0iMzISy3TIlDAy+rxEOcMQExIDPZYQE7RCiJCNxcWBSDloRGvIQyIbg3NwHDI+J2xb7gepHkxnWelywthqjcsDQSGkgDeuiMT6gPcNA4lMsWy1aik5KxkJBdUba0BKZ5SFFoHnkCBX73TIWuxnpvAnJBdB5rCcoLFMSbOEWAh0fSjOl5iL2M/mIsALKTOLiYBliMJC4Hgw6HTKP/+jK7zvcD3e/razHfu7jp+6d1pwxBuP77p9zBteeoZTIRJd4tGpcuHywCNXFjxyHPnQNDLo/7d78rYRXrfj+ci1gWtfwve67zDxDptJfcKMDNFaIjCpTpqlCHPlZnq2Bv9p6NBZ2VJKIarkKm+Yh8jEZC7mzN6ZjreOLe+pGNiff3TOW165IC+EReNwIWGtIZBxUroHtIpszHKsLCd205ozLgu2cRzF4tcN13oMyjfevst7L5Wo0of6xEP3X+Hu89s4haMh0fiIppJHrJRo6aSyGk1v9rV6o9H6piZuM5ZbNvbvqtedaqVMBmwVzl33Um64ztZhF9fty1X1RF7hUzjzy4K4JJyxzu8+8fWbHPVl2JVZU9GEIuTDCHn5unih1Uy0hq3WMFXwWREs+6c7fDC882tvZ+fDj/Pz910D4JGg/MjvPsHf/sZzDG5E7oVkHUNIWOvLnlJAXTkILocyyyeYl1ODeo0tX5tMRqzFSiJpwDtDsOZLvmz/8GDgDw+Gfy0fgbtGljfdus0bb5uwt9/gxh2GOd22pxs1dN7gxOOahoaEawosxmoubOyqgaDuzpdiU4My5I3oVi2TiXkfSrpbgs4ITzphfhz4pU9dZhPR//V37bDvLGdaS5AisIw5I94V+14qBLBGlR4t4/ycmVZa2jRCK4kBCPNEI5AlcRCVJkHQTGcsxyhOBTtEFio4FXKONBRF+p4oI2OYp4ymMv1ZxMiQC0hmxlCANiFixDJooblZA40mjrOls6ZAVSiTnSTQx4x1dh2firJMcRGqrTMrsYoafbXY5cr5VxKaC2xKgWmCJpXAkyQwjZkYEiOxzIcFI5SrCzBxzu/98RG/dnE9In/9xPKOu7bpGsvLzm7z5GFPDpnGwfPP7zBqEj4p40mLOkvjZ9y+b3jt3DNYz3f1qVghFS5ME/MrRxy7jvk0kCmWxKtDZN9YJhNDl4VT2y2aA6O9Cc/zirTQtsKj77vEtf6Z5wbJGMRa2q0RE4nl3pKUnAuJ06w0Os8W8z81ojiW+NcVIKRYUAK5dCFBmbiE18xbX30L7/nAowBcisr777nKN7xphy4lxlmZO4cXiDlXJbQtOcwYzKoAVktFJWdZa8iScVmZWEMcO3ost55v4GPrYvWeB6fc8bx9Yt9zRgx0lmwtOWWysSQtp3ldlpONIn3DynmDP5MTXbyegKTAyZOuytqHvcmXvTGBaSMM4YsgmnRjob6WG8lKOHd9AV/J/GS9OrEiZTLC0nGwjPIqXmwnSy2xMmkdKSRGHnak5ZrOeL5JfNtX3EKcB/7x46Vb/Owi8TO/+yTf/nXnuWPXFWFRsnQ54bJFTemErK3ouKXndRnQUvUAS452BJKUVK7oPLbP9Jp54Znu/7fr/tv3Gm67qeFV57bZ37V4p7STbcSX5LJtt1f2veJoSLTWFRa7Kf7e4jqwNZio5nXXi0i0WL6yVBHYKmhVCSEwjamgXbOSNJIOIh988JDfPlhDnP7iLZbX3HGGHZvoo+BaJUdIDtqcOU5KIwkVy9QIOSjzHBlTrHh9Tgxq6EUxQ+LYGEYqEAcO1NJpj1PLkQVxDUKARaJtBU3CkTh2bGA2ZIamY9BAn4UdpxzEHoNDc0LUrNwYC+s4nPfYGLFtx54rHaNJmXnM0FhMDrgKO8m2pJ4ZV6Yaqd6DXPXJ5wwxDjjjK3LYlM/7ktGvuQT6GGEYIiRlnsHESJ8SwTuMZi6HhM56jmNmCAMfvn/B371/PQ06LfCtL99jfHaPXQ2M24GbT29jsjLpGmZR8c4zbi1hscCKZeYabht5jibgI+ycgtECLhrlxc5B2OY4e7xPTI8CezaTGk/jPH1OEDLX8Nxse/oUmUnHLEQmYrh71/DZC89c0F+21xD6yHYbmLaeHWcLLrkKalW+yL3v2ceXaYfOendrhJJkJIXuNhfBeEH6huNJ5rbdxGtHjg/Py43nH9w/4+4XTLnr1jGHzrA7LDhOvnCYG1v50WUErLXTNJstZq7irgStsYRGGSXD4SxwbmvMX7x1xE88Wsa/7350yvde7rnpXENMhkUf2bYWxJBVcbmM75dorVzJVk+ZWF9fQTdn5qI3qLA3mIaz3pEux/PFesaNzHA3/JHrfz+5TV+Kx9Yt+DpeVDd+mRsZ72Qj4zivRvNaU7cqqpVlZymEugvZMpb5MNB1HSYFTqWBv/CqfY7mkXfVGMl/djXgPn6F73n9LexKYsdHrPHMo2PUOSyKlVyCQXR9ONn0F6T6vBDFa2KeFQkZ9ZZGM+P9Lb7z1jH/1zOE33z1yHKmEd6zUOZ9etrXu/GWt3bCzshy267nlpu2eME29PvbbGewLuBdxxCUycTjVemc4JvCJ1Xr2NISItK0JeWrkbJqMZUjYOoHZ7VRqWsPyevUOKtFwKY5M18ktM8cREVD4sog9DHzk585WD3vfSe84oW7dCbhRg0SM9IY5ksEbyopXHGRoDEczocigEuZSxHEZXIGE8ooP6P0wxHJtyyMYcdmrqYGGQI6BGZj4RQZu4gczgLZdyziwCGJM6Ic9krvPSkP2EUmJctRnGGtZWThaJERZ/nspRkPPnyNOY7n7jhef+cpbmoMZtKSEbqsBISollHMdMaQEFyuuejOFBSwKeTEjMWYpuztKZx0lTIFTLmo5WNKDCERU2Ya6/UfA0M0hMWCIxW2RZiLZz4/5p5HZ/yvnz3J4f/PXnmKu85NcCQOsmGyNeaUKtmWKNS9HQ9DKNqI8ZjGwJ3iGTDsa2ZBYjIyDB6emzLZKa7r0KGQAke7HbZSIoOFHTUlGlcdo1yse6OstBSu/lfdtscvX7j0jIfS59++xc64IaWBkWtoNdNW1LY165Xcs/X8T9vInbWq2lCUpWqE1glGHXmstIvAeNvxn/yZfT78gYsAzLLyy/dc5j/dbdn1kQPvOE0kBlgYQ6sJvC0im5r0kzeLYg2CXoo2nDEEK5xpiijrK+7aWxX0XuE3H7nKO3bOcNMkMdCSY2JhhLEqqZ5Kl5GMNxSB3CAGTlf7bL3uP+jT1fan/fOnFHNVvhg0eV0EtKZdnfx6qalYujkZqLvYNeVvPR7YWNGvyGBl1F/HnDmvhIkKuCSoF1QyO7ZhnhIBZQvPIsC3vmKHT3/wgPuH0l/+0v3XeN35MS874zCndhln8I1lETOT1tbELC1BKdVKJxtOA1OdB6YCczoDvRPaYWBwlklreOfrb+bTv/HwCUb+5uONY8d//OZb2PEN78wBSYnLwbAvA4NzbHnDWWPJI2GRBI2gLWyrp2uUeYLTTnBiabpR2TM3guuK6CyZwrRvq0vBapkiWWtxdTNuK6FsyQ/w9TC3ov5VmprkXK19Qp8Si6FgZZe56xHFzY75Ox+5yKbI/i/dtcVLz+7SAIsg7G155jHTOgui9EMCIwxZSUNimAe8NVwclFGOiBH6oFwbIs4K82nmKFoeuXjAMOu5jOPwaMEowpWcuRCFTiMXsmVC5pXblsvZIKo8b2S4qnDXmZaswq2nJqRwlcnuDiYHhpB48kD5+Y9d5IPHJ98z94kr/K3XnOHNrzzLWGCeBZ8dWEWJ9LnBUGyQ3hR7meREsBZjHC4mcKUrH7Q4C4iRIZX9uGpgyGUnPw+RWV+gOaLQxwgBUoocatnff/aJgR/99Emc7t+4a5eXPnebQyyucdxigJCYi2O7NUTrsVmxnacXy64pjHmcY5QUTJnuWLF0FhbeYFLAWM+WKnnUMY5KMLkcgBY9tB02wrYzzEPCJaUPWhkGwnNvGfGfv2ibv/eFo6e9d/yVl+xybrelF8PIOjorZFP+Z+t9XIRnme1/Ojv0UhCWQBe1JZLQqmBsgU8kY2BvmztN5Bs+1/DbNdLxXY9O+aaHrnDni25iZwhMtexSsRZvBJOKEKd+XlciMyrPW0TqaD7hgWRtgaW4jjtuNrxp7wrvrxa2f/mFQ9780rNM1OLSAMYX040qmkBc3Vcuu/XrWbA3SGO73sG+tlp9cSHh9cVcn3an8bTC+pV2YZXmXl8XWcFH5Lonf53lTq/j1G+w7ZW1ylV1XUjRqijWIiZ0WTGNrdYmpXUNB/MB3d7mtudafigkfuiDB8zrj/onH7rArd94O0TFXp2ztyvsd2Wn3jlBja0Z1MV3zIbocikONFpGrMFAI0JqPLII9Go4f3ab//Ztz+e3PvoYP7ExFjUCP3DHNl955w6pa9nulJG2GHHclhYc5Y5uu8WrsgiRwVl2vMWkTO9LtGhyylaA0cgzWyyw3tJ4i7cFcOSAURVqOlOCQsQ7RIsnezVWt7boBpYHwWobTLlCjbJWhncZI8eYmfelO58dz5k3njw9ZhGU33hwxgevrIVZ33Fzwyueu8uhZralpZPM4WLGtnH088jCKq1tuNQHdhCGfigJfr3FHx5zgHIwg39xYcblS3PuuzrwqXn8Eu8E5eD28eMbfP1KrHcFEeFbT0/ZG1lOTYSfu3fOEzdQfUeFv/GRS/xPOfLNr3kODOXwOCYzU2iGxKiz9cpOKJZsLE1MaB3XNykXiFMqQrlelVFWprms14aYEWomADCdD1y82nNxnjltQScNz20N73vkKj/+qats/mbfc1vHV961R86J3cmI1pc9/KgVRq4l50jXWqhceYuhNcoID2IYJNPYEipjrSEuEtvWYJ3jWAzbVrGaiVbwIoTY0467cn/sGuZRabMirmFkM0eLgZwtbSd87V2n2GrhH35+yuXrbJzffdbxmpsdExHGBsQ7EpV/YMrUcrk+ffbxb7Buqqr+SXxiyxu+VtGO1lFhSBmyMp1Hrg6JFBKPX53yyOWBv/rbD3FU4RfeCj/zzbdx66mOzkZG3Zhx6xFn2GocrnG0ywV1hatQKU95mV2NMswDgzFcu7ogLXq+MFX++N4L/DcfXVvY/uZr9nntnbdwi4XJTsNW1zDpbLUPFVWnM1IAMLIei8uNZk/XVdrlu3OjMnqjkftTC3mNfWQ9as6ZG+bE68YEQdb9+GpAvRyfs7GnF1kjVL/YOH95UNJNwZ+uw1SWvmEoY+GclJQT8z6TyRxMB+wQuaxCOpjzrk9c4u/cu4bPfOcL9vi+rzpHM/bc5Ax23DB2gnWGrhKrkAJUKft0WcEw8pLjniGEspeVEJnlRKoj02kfCTHzhUcOuDDP7JvMzbsdpvVMpASAhKxkcThbGO7OGBrn0NizlYXBWTpNROcx3jNKAwvrkZxovalEv5KEZ0yxVXW2TBaSCsYud+Kyijo1dq1nUMokKC0DgbKumOSqRWkdcsGbLVLi4Dhgcubw6oxjYzmeRj538Rr/4wcvr17X5zrDf/2Gm7lj2zJBiad2kJzxRkgSMKmAja6pY0RkFstI957HrnIwC7z7gQWfurz4E3d/OSvwk2+/jf1btvGNo7WWUc6YTmicRbXwE9QYAoaGBLZkh6styso+RpZYlNgHBoEwJBZZ0CEwHwY+8seH/NTHL3NPvzZ3nzPCV512/MrFk7CWbzk/5nu+4hwja7Bbli4bxJeDW+tciXF1Dgt4yXVVBUYLAtc7T4yJ1oIai6SIWM8ihWIdDAk1gkvl7ydr6BMEaxnnSIw19S0bXApkawgxcRwNknquqWd6dEy7yFw67PlrH7vCsq6/85Yxb3vJhPPP2WNHoBm3bDXCeDLCeMfEm9Ltb9wHn33863/YH/7hH/7hP6ljd9nY5lYNVb0Bl06uSYmoSraWnZFw1ht+77G1je2+h6e84JYxTdsycQLGIqacbrVGb1qz3gVLFRCtxsI1oEMw9DmWqMnG0TnDh+69ytV6Mevlnte+YJtTnZKNwzmBnDHOrke8soxVlRNq8xPWsY3qulnIr2uuT4rR+OKhBitgTD2gpMpv1Rotu8zhXt70l12rbq4+RNYxZSuxm34RcYvccDIgJw4xcuJAc9LSVwExlIKcEzTO0ifFYzgWwx278PiTC+5flBvlPQcLvu78hG1JmMbTWFgg+Ir3tHYZaWvWM6Dr3QVa1zA1mMZqGXHnVFj/1hraznF6f8K5rRa31YHAeHtEEsvECH7csNcI3cgz9o7WGra8xTSW05OW3Hi6RvAWOu/xriSetdbinaWxFi+C87Z4nStHwNSYX5WySy92yzLKXU9UWGUImErRWWZua32PyUqIicMhMBsSi2HgOFuOpz2XZpGf+tBFLm1Q6f7qi0fcenqH0e4IiykkuiHjvIFgGLISjwfaFLn86CEf/9wVfvFjF/hH9x7zgccXXPgSOnEn8OLGcEtneePpjq/dddy533HXBF61N+KlW45X7TW8dFwmHDsovXJCff//9jEFbt8y3Hl2UtjtRhFv8MZiVFbkQ2OEph6JkxEazSDlM+NTJklhxSsFmRtU6GNinjL/4jNX+OsfusjF6yh/xwqfnZ3scN95W8e3vWQXO24xEtltLJPG0ongu7bkwDtLYwzeADHTNA48GGsLd0DLiDzmgl3NYsma8VKcMKPOFmW+k5o+WQq5zYp3BaBTwqaUULvrjMWlQvwbaSQOGbYavHE8+uScR2pF3xXlruftclvrmTWeyaSldYUJ0TqLlRJxayvW91n/+Z9CUdzaslUxgcuBokixobSOGBJjlMbBG+7Y59sePOSXKzjh4/PIL/3LJ/gv3nwenOUaPdsJUmNocmDiLNFXZXstUrWpKYIhwFjHIgS6ruVaWGDjnL2dhu+5e58f+UTp0n9/UF774DVOvWgXZ5RxGFhIAyHSekdcJYJoyfE2m/tnThYWnrIqf0q3znVnAH2G1zEvf69clOS5RIuVQl5XDiLF32tF6r6ZVU6x2cyKq3anFcJW1zT6JWp18yAhG3EzunGAWYJByjlhiZqlCtXKycIZKVAhK4Xo5cuuc9RHhlM7fPPLE+99/+Or7/+LH3qc73/LecyQURPYiYU21nmzWt4vkZ8rZr2sn6GtN5pIoeuJzZhU+OBJDGMn9J2ji4o2DWTY9YZFyjStY8v6QiLD4QooHWcNHldullLG56jQ1nVSQEiu8t6ltNi2igaTmFWgianXjzWFJ6CyBPZUNXY95OZcXndDgfnEXEKJYirve8zK0bwoxad9QgL0fSSGxK9+9CKf2bAmve38hP1zLZ3vydFw6B1mCBxkYXsR6CMcTXseu3jMe++d8VvXhmf8TD9/5Hnr2Y7d/YaxN5zb62icsNN6cAZxEVkEaFpC3zMxDZdTYAtPHwPHapiYBcM0k1rHg1cjh0fHXJ4qB8eJ3z2IqyndMz3aBEETKQpb3tGK2bhWTSmixpJyJbtppqdY5GzKBFNIjCX+tMT8JlPIfI9fmfM/fPTSl/Q8/sPbxrz97n2mTUtrYOyakkjmHaB4JzTiUc1EhLF3zCsTf8cIx7kmzTmHyUprDfMMjRN8SCTji4YhJbwaUs50qkwl49sGiaVz77A4C32CPESSCkEUZ+FoCLRB2dtuuXY0x8bIC3YbPnhcpgx/cBR5ZxAOjcU5g/jSPFnvig7q2a78T3dBXzVq9a4vAlhBc6kI3haU4s7IE7uW6XzBrib+3Nec44HfepiPTktn8JuXerrff5T/4PW3cG7bc6V17JDJeJSIz4aJN6iTqsQuN/1VA5oSjTX080jjDGbUcXR1xstun3DmUwerbua9nz7gjadb9s9YFrbFDj1x5AhRmbQeNCN2mSpUVNd2sy29Tr12fbGWG3zZanrxNOP3VeBGLd4luKSsLQyUXO66V825HDZiVa14I0XtvxFiIytLmqwK+5pGXwv/dTvzG60OlhOUTXfdynZHhfFUVKitXWmbMtpZjntlPHG46cBLnrPFd9w65herAv03Lg+8/ckZTdtwShNxe0KjmZxLwXNSjia5jvntahVQTlla0+SMlkjW1jmMJNSMGGmJOZ0kwCayOFIuO/pRDbYxAt5aoHi5rSkJY4hhZIWYMr5S+3Jl3jst9qplPK6taDutL0azTPGyxTlhWFJQyyFoycM2y/eyXg8DoFEx5OL5phT12SKU4JUQ6JMQj+ck3/Cue67y21c3PNAzZLXtAAAgAElEQVQ7DX/h7i20GxFyRqcZ8ZHGCYv5nAuHwu9+/irve7JfCRRv9HjLluemmztet9dy6uyIWzpHboSUiu3KGEEkkmLGqiFnwXf/D3tvGmtZdt33/dbae59zh1fvVVVXz2ySzaHZJCWSEkWxaVlDZAvyKMmyrcRGYMtxEsAwMiCjY2dAgEAxYgSGAzuO80lOgsAOFEOxBEeQaFkWKU4iJZEUm+LcTTa7q7u6uqb37r3nnL33yoe171DVLbJt60vAugDJx6rq6nvPvfesvdb6/3//BZsKF2eJ077j4VPjRh1ZHkX6CY7jnGesMOtmPC6nvHRywuM1sFkNfO/phv/8U68OBqQYkyYW6lCmdfOHS2zkwNAsgO1zmRrieZONIhWrHj+7yYUoymqYMIMzE37rqRu8mnPFExc6vuexCwx9x/1qSN+hVL9fYKToQsdNrXTBo1oTFaJSirEWJTV6VWjPVUWYleJrmi5RVKm50plgychTgZRIuCJ/I8oRYEk53Yze8c9iy4+v5JC4sFDGVBnXhdT3kCKvX9x+nadp4lgKgUA3jLDsETOShjYROHTD3K3u31oj95ftmNvdvxUSVSXIfmxbxoxFJYTKuy92PPnMiisNV/m5s8xwdcNbLyQildHwrGLJlAwjQqiFEY8/1cYabyFh5CqIKDemjIwTgwWsGkeW+egV70qez8YbemN+3DGFwiL1/vy0uZ5bBKkcwkyE2/afh6PnO4fX8go771ea1gt773o1B14UPGu7VA+pGCsMuVDa6CDXyoiRt10JW3TrtlDvn5gcjstfYbwP+2JzOH3QgxdwiH28HUgnt43nbRvwont7odRKyMY6BpalcDIz/slXVjtU5ubGyB9403nOZrGpuX1cnZrVoJp3uds3QDhU3jaFvjYYizhxLoiffLNBlzwBsNdKiom+jb+7GOmiJ5h1UYlB0SZkS8G76KDeWYctnbAVatkmUDWBm7QKEtvP/hlqLPZtHO/B2Wm7HtE2Csbq7tpv1ym5VsaxcKtUNBu3CthqoIryS599kZ8+YLUnFf7ko0cMElgDSzWGOvH8aNw6q/z6U6f8vU9e5Z9fn7j+CqEx33uh5yfeesJPvvEcf/CdF3jH6y/wpksdfRLCIjEHFos5GvBUrtRx1HXMO6HrEjEpobHp+yBIgNTNqQU0KbeqMkvKuTphQVnMOjpRLp1ELi5mvPTCmi+/CgjKjz92ntefdKQ+sFZfj0TcQ27iIBwwhjbmruZ21giggYpRcqYLgZtT3fHla6n82mdf4pM3v3n86QL4/tctOSeuPj+JlZgii3lyvkD01UsfXXWv6rkUta1TOhVydWZ91wmTRBQjBHHSXsNJOrWv0rep2VQhaSXgFLc1LkDtQnQSXohQCpM4ZXMjSjA/4ddSWa0rL5TCB5/bY5H/xOvOMbtnwfk+Yl2ki4E+hZbqSKPEyQHH/e7jW6qgc1AgthXADgqgNQKZqTLWCpMHN8yOZjz2wIyPPnXqEYDA51eZj3/1lDefn3GyMM6VkbV2Hh6BUhquManzxqHpa82wYmwQQq2cTZmh65nGiYeO5jz17CnPtj3SV16a+JHXR2LtmGw7Ot6L0WLL8vYR6r6Y3G4L+waraV7mcHvFn83Rbq0ou7o5l0KuxpALtfjdfmzquGnKlOpd99AoYqXWVojlQCwn+536gTjrcEpwB032DmndgfBObu/a9+K6LZZ1/++qrZ0X85GxqTIHVmcjs3Nzzq1GPvaSd5dfGQrvuag8cLygirLsI9EqFmK7IbpNMQq3YWxtpxVoi4KWUpfaTl1DowlWF03F6GKwEJWgStfG+iEGovh4MagQmwdXD7LZXdivLWRnG5zS1hu6P9poQ2VuLWn7C7f9H9mBmBB2XHqrW32ET2ZKNVZj5dpQWG9Grq9HNqcjp2Pms0/f4G985sZtn7Fq8OEXB/7pM2f84pdvUa6sOX/U8ZmnbvG3PnWVD780cPOOevlwUv7MG475i991P3/o8RPecGlJf88xR0G5EA2ZLwgI8y4QZ4lOjPk8ubUpRkSERVQ25tz5LijzTsEiXVKOZj39MnFPHzjfB46WHcd9IvQdx30kp57eArlUlvPEL3/9G4eb/Ph9c/7odz9Iii5wm/eRpbqYrGsKcPCkumiGFQ+JUfzANphrbGptQsOWwz7mSleND37+Gr99+s31A5ei8sffcZGz1HE+gqbEUqBPAYlCEnVkrBhVHMQ01UJs2o7tdMYPq0o0TyYoomhp1tHiIsaI51kQQjucChs8gS7FCKIMJaOxc0CObSNmlQ7HLi8o3CxGH+DmlVP+6Qv7Ncs7753zyPnILCZmnXIUhJCCRzRvBcHc3sjcfXyLFfQ7vduHZDIfabaOXYwxBP/NPLI4WvCOC4HPf33FS62ov1Tg/c+cOdXt/JLzNjk60oxphFx9dJgNqih18uI3RcWmzKpUxqDU1ZouBcaxsNDABy77yPeWQRkDbztRNjFRFGZRmz3OoTahggXdcc/l4AW+EgFW7viPfZMiv08N27oCfHdaiot2ggnXNwNSoA65dRXGlI2hGrGMTC27mOp2O1XdLb+33ewdmTF3EO3glV9N69Rv19cdOPlk12myOyT4H976q00UVWPImTEElmSWy8T7v3CT7cD48osj733DMUsKJQqdBGJoRbmJ7YR98dw/S+/ebbfP9wPkfj/l7YrS+OhBdmRBDerdpPrPqkJstLa09dirIMFvbtubnIOOvLhvL4i2Yr7VGRhuNdPbxIq2OwD5NMQDRzDx97uN2KdcGYbCOBTWY4WSGSUCma88dcp/88lrfLNwrc9tKv/0mRWfvDFxZ8/5+5aRn3zXJX7iXed53xsu8uBRpJ919ALLKEwpcjTvmCcldF6ce4Q460m1EqMSxcWGqoHzSVl2gaNe6bvEch44t0j0UVgmIaWOLiqdKprcRVKpHEfoUmUIHcsZPGLGR64Or/h6vv9c4t/+wUc430d6ha5P3oGLujiukRBVhVQqpkCI5GJoLR4IUwrZodRYrZgJuUCpnu3+5RtrPvrC8E3vb3/oUsebHzjiUlJqDPRB0S7ShcBQjZkKuRayuJ3RrJJwUVtqY/eC0GlFg6vz62SUqKTWiUvyCWMRF7oxjHQaMfMky9xiXgWlU4Fc/HVJwHImqDIVow/C2WRo8ef03I0VH3h+3H27v+848Z33LVjPey6kQOgjnfoBzb86LUjnbkH/Vu/Q90XPDrLKMviH2loYh1XQQJDIRKYP8L7XnePLT59yuY3fi8GHn19z44UVD1044jhUBklkK6zzyDD4F/RsrMiwprSudpIKRSibESNwOgxYSNx3T8eNZ1d8qamtn7wx8vZ5x6VZ5Z5lz2RGKd7dJbwYiei+oHGQU/0KY3e5Y1/OK+zK71TOmTuH3EbVPMdTdfr6OGZyFgbxUeLpZk0ePaHqnLp3OZgx1dbNNtm74mK5XdCL3J7lvusYD5wJu5H7y56s7dYO+1FLK6SHr33bLTdFPtsuvsJUBYmB0xq4uR45pvDxxiF4bqp81/meB44CYbFkXidSDC3zuo2uD+yD2pLnpDkotBV9dsK59mfbKD6G7V57231Ii6Jt9sTt+7m9Tk0vYe2fR7fJfK66368ltrt177jAWiKeA5C2Y/ZqclvQjK9V/C+cWvDKWCoBYTNmxur74WkYOR1guLXmM1+9yV/5zZco/5JK8e84ifz5ty75N979EG94cM75WYdRkK4nYJxfzkmdkrrIUVB69SkEIXhhDkbXd3R9YpY8O7vrfLzs7obEqOIFYeupFr/ORX1l0anb+SRGshWkwGjKSRIeuNTz+Lme89V4cZ3ZGLxjHvl3HjvHv/6e+zl3MmMehRoCfR/QLIRgjoBtys6AIV1CmsNDVSgxEEpmCh4dJrWi1VibMLV1TTHhuO/4+c9f/6aHpZ/4zvt5zckM08oyBboYmOFK+hgjfQSJgXkrtCF5kJGJkscJTZGo6ocJBcuZLmxvLp4CKbWp2mv2sXmKlJqxoEwqTKb0VGQqDMkdItWUVP3QsMGYibTQGacgvrgq3Fyd8RvP+7UFeMdR4C2vO+Goiyy64Pa6TtsBNbSV0QHL/W5F/9Ys6ByMfPfFXdrNjSZIEixou/FVKkoKgXOznvc+eky+uubJs/0I7KlV4Ve/fIN7KxzNYEiK5IhpZTNWSp24WZWcDe0SMhRWw8RQPHBlLBUdCsN64OJx4FefWe2+vJdvjHRdYrnoiKWQIkzZ6KOy0YCaC7JC80brwRjqsHyL/O4K9t/Nqrbdf+cGsxnGAsW4WXxycXMQVnnDNBllHBgGY1U8GGOlUKcKMbDJhV6FIurFpVZiS0zaDdLvOG3sbP2vMFmxO7jy1vQEdbszPyz2u8ObF/CdA6G9/2puv8tVUatYMC6mjp/90n50PGwK3/OGEzorDBK9UATx/GzVnQgv7CH4mG1XOrYLodkv2H00HqWNYdv4XpqdTMGT5A6tCrLdxUsTKznydMezF6fTSdMHbH/dDj7noekvpKnfbEvwE4/ltOrSydrwfdosXTT62+lUGMaJW8PkFLch8+z1gZ/62FXO6r94NX9nEv69t57wJx+/yCMXZizmHcukaIocd4mUlH7eMYtOsjvpAlWUvlO6qD5KVrcyya578ylWwIjq9r2K0ZkXM5piP4lDl7b6GW3vVy6VrktIrU1ZLXSaeOD8jPc+3PFjbzvmJ995L3/sHZd4/SML5oueIyAkz3XYHpT6xh1PbTU2C0o2c/1EqV6Iqh9GE0KmkMUnBIqywoi1IDEyi4HHU+GXnv3do3f/0muPeOJNRxx1kVmKdDPX+GiIPvnpkxd2EUy9KK5Lm5hVKFGZNACFWtmthgpCqoXYYFxrgU79y5bbd6yiiPnn10zoDMYgzMT1RFYqNk6MCrOQ/LCdlNPsq4VNrphEPvr1M261U+G77pnxhoeWnFtErO+I6msUDaFNnA4Dt+4W9G/pgi53FPWdWnq75911kUZKkalWZl0iyoQMI+96w0Xe3lc+8vxmFyk4GHzgyoZf/+It+mx0w4Z+FuiDEYpxY+2dTjnd8ELNCIk8DVzZVGTIpJaF/oHfucmTN6cd8enFYnzkhTWXnzvlrQ8smyUECL6PK0HozUfvYtuOUW7rTL/RY9fwvgxC0+JKG4yntE590zKdS4Fhs6FMwtWzkQ89+QK/+OmrfOgLN3jxdGJeC4tlzybAUQXTSjA/KCnmfmiRXaF6mbBN7tiX2+2iNz0wuIscHFx2r+tw/iIvH+tvk+XYYnUrJU9kU2YY5eaGTzch0tOrzBOvOeaBCzM6Kha8+/ObnH9ewoEAj4YApvrBoVptSbi2i4bdW9i3++/981WVxknYtttuK9LW5e/WCW3SQRMfboFG2ngAIrKzqtlWQNksbsVshxEttewCjIp5rruZ88Snppk4W0+sgDxmhk1lWA88c/mM//IjV7hyQFH7gZPEU8OrS+D+M4+e44m3HDNfJm71C+Z9Zdb3HHeBmgLLKMyjJ7/1yTkCfZKdvS7gY/bt9Ga7q1bV3WrHfKQBqsS2ntH2Z7ahMh1bgaxT9JIYowTm0VdmQfwAJymiaUaqlTEpkgMnScl9oiuV2CcWSZBZT9d8lyJCVDAVSim+xlAPtwnRvdqDCVIFLRNJvPCrB58TxsxgwsX7lzxxlPjClTUvHVzve5LwV991ifc9do5u1tMHpXSRBRBToLYCH5vwQszvD8WMUBwlmwWmNjKvpXIuKVN1V4TWytRiSz1QxoOpqvn1rZhPRCisizlIB8hRCBXGJsQUUUYEKz792GSQmpkssClGyJlnrww7FsQbFokn3nTsAtEU0KDMo/89KLvJlbKfXt19/N4+4v+fnuxe/7Pfc8b2RdN241sAo1TO95F1gTh1hPNwWoXf/9i9/PULc97/yZf42St7etVXq/F3nvQgim8/d4Mfe2jOay/03HN/4rotIFfOa+FqnFjdHDg6njHEymYz8bHffom//7VX3pV96ObE19//DP/d999Huu8EmaoLtESYeoilUEIg1+qdYlNBv9Io/ZXU7XdSZLeP0hC2tRpjrVgunGUjWCFb4FPP3+Bv/7Nn+dQh9OPyGn4L/qM3HfNn33c/5WTBkIVZhHmtmBg1F6qY58K2LvvOtcBuEH8wbpdDKtxWHHbwAip37uS3nvFDApqLE6s4IKivBQSGlEhWicvMH/yO+/g/v/bU7iV97JPP8eYH3gipMisjqxzpolCyF4cS9tMCq3W/yqlyQLeDuvWuV3/yqrXZcHQ3kt9hXdp0JLVs9W0ATIR94lz7WXf2SNvZ6ULryCr7Yl5VG+DIp0/bQq/4WqW0gJBqQi7uXlhPlVIdcrJaFdZnK25eX/Hf//p1rkz74vLjl3r+8Nsv8Cv//PKr6wCSu0JKMS51lZlGlsGwLnIk7KYWXQyebtiKI8U9+bKNbQ0thx3oRMmNFqjVcCmMTzM6hWE7QakeE5yalzKpuzhiFaYizGIhZ2Ee/MAzD4HU9VwZMovYE2rlZB4YYvA8+ORo3UAgmBH76AfhrdtAbOc0iOYAl4Ix5n1y47D9EKkQorBYZ64l6KPSFeNdb7nI//TIEc+/eMoztwqPHkUunZ8x9cKRBSxUFimwlpYMqAo5U9MMckWkkhXMnLK2ksCs7JHJZSpIUFbNbjaIC0eDQzQg+Ocvm9EFGCfXG2UV0EiaMmYrShE0doyhaWesMkomWWSjgRAFGzJ1giiFMK0Zhg1pto8XTpuRlSlLIBdYJqOUSoqhCfdeeX149/GtOHK/o1Pfbda36vc2iiUEv/G11C7rlKrRka9iXDw3482vO+a7F8qztwZeuAM39cJY+dWrAz/3zIrPPr3i81fO6KfM9VI5O81oNSQY43rkczcr/8uTN/lGOI0b1ThaFx661NFpoHaJI5z6pEHo1L94eiA6u20xzStZ1uy2TviwqNaWolWqB59QCwVlmCpnY+HySxv+8j95mqd/F+/wh18auLdUHjwSZn0ip+jX1SAmL2LauMx6h7Bl9zxtvzLYrkV2U+YDQdw2Y30r9rI21t5Z2+zl735tr11bjnU1kFy4Ofk04ezams83dfEnTws/8OARy3NzYnWV70xbnGPYj/yLeYxqrh59WaySG3Vn2AoSWge99YsrW77+7c6LAjtAzVbFH7YFGncglK0V8EAZWNukhlrdamcuAqzs1fHuQ5cdDnn7HA33ndepkoHTnKlD4dqmMq3WlGI8c23N//DBq3wp7y/qD51P/PnvvMh8GXjyqbOXEc1eUcT1unO89kJP6iLLWe/2pC4wUyGlyKx321QUV/xvg3ocLCK76Ybh2gDV/WEqCVTVdoBTNLSpRytehmtkunbNigipXSehEjUQMCYRUowUDwpD1KlrREWCcmRuce1Cs1VFRwObFSJCTG2CUB1oNQJ9EKZiSHHQkZnuTqiyzZzAGIMi1ehLRsQPDCc9yKzj0Qs9911YQhTmIVBn0YV4U+Fk1iFidF3HXIWpFlAlK3TZC/I4FBQn/8XtQQ7DcmEikMxZ8hKjp76JT+YWAkWELhfW2aE9WKXWggVjY5E07+kbcnkRhakKIeNQG/x7gRmjwDpnhsG4fOOMzc3Cb93y79ujfeQ9j11kqZmT2LkeIUVUrfEG5ECDc7dD/5bv0O8sXt757RXiRRWr5pakEJhVB8dELaQ8wUlPupl5wyxx/m338LY338env/g8H316xc889/J4zE9tCmwKv/zC7Szq46A8nGCNcetVrCF/8YUNf3DIDLMC61OuzxdcypWhCau64irWuB3b2rbQHYaayL4IIq8omttS7vZIV2EzZEr1sAYz+MBvXeZ6/sbj1b/+5HXe8ugRdlTppzWy7EgpUAtkhdTwsduO0my/I99hXW9TqrOz0e3satKINcaBcMj32NtXtrfLecEVBa1CEaMGJVlBg3d3l2aKTJU//Pojfu7AG/uJL77AxfOJ0kceUuXmBBdD8+EK1OxK8twsQGK1jSmNGtwBYOLrEatGzhAiO3GdqneVZbuKOMD5bSEvNKAPO/Rve+ntzdru2bciua3gU2vZjTRqu6C5/Zo0apj6uhytldVUKLmwGT1xbDNVpvXIs9cG/qsPXuHFg535H71nxk+89z7WKsxT4IcePeEzn7v2DT8X56PwzkfOYUlIsxmzTuiBme8fdil9srUomUceT7oXUqo5AU/MvdLW9rgZ2mFtH/KjjWpoBFQrUto4XpzGBkbRQKx+QKYYmgIL9bHzgsApyjkg1MJR8/ybOeff2mfKEJwM3bEpBa1G1yxipbruwo9SxVciKFE8bS3TmO/Fu/YUQyMwRqY8Moqw1Mii8zCVcazUqJx0gSH75+boXOdrIAJYpqofnINVQlVOS20hSULImbGtbQQ/ZHg8KYzVd+dTVaoVeiKRkUESVow1Sp8coKTFyHgH30cPbClqHBdjZYpZRQOsJ39HxpwZijDLGYuJL5ytWMyPuZ6v7D4fv1UqIsWjpMtEb4G20WePobrbnt8t6K9U1FsxlzYOdSDHdgcJXTVCHynVSEkYU2A0Y7n0L+iRVQKZd7zxPh5/3cD3XRn4zLO3+O2vnfFrZ9/YP3qzVBeZvcrH88V45lYmzAoPN6vJrXFirh3znMkpuke0Hu51vXQHOSSq3d6Zy+Gu+qBf3351ohVKiASp9LlwOmT+xy9/c4pWMfjKs2c8fGnJiLAcMtInskHChTVqe8b+bRz2g+CWl0FvDiE6dvs/IwdTl60wbaec3/6+7RGoUoxNdQjKuVnH5mzDYt7x8Gvm/Mi9M/5xW6n89BdP+e7Hzrjn/nNkTSSMW1NhUY0xejdVwJX9zTNXcqZDGWohm5CCZ2J7sTdSLcxT8Pcrhn1YitXdezdVDshY7AKAgvn1E28d/TDTDi07H34Ttxkew2ltR779y2rr3qQaYykM1bCpcjZNXBkyF8ZMrpVhqDz59Bl/7ZPX3K3QHj9875wffeJezuUV/fwCVeD733aBzzx/xi9d/93nTX/1uy6RlpGFKiE6FS+lNpKOwQ8lIh56FCOlVqo5mATaDlg8zjaIMdVGgfTdAdbSD6NCzYUSQ3v//eCbzTAVLBc0KqFAaeATxQ9forpD5kqtzNt0qcRIF1x3sdVL+HTMaZRBBGqmb5OEipLzhIofHU6n6nkQwFmFVM3tiVYo7XycQqBUY4ZANAbpWLbrHgWCVpadcIqPz0tS5uKHtaLBWQTmK4iVZUQDY/b9lFY/5JXcRvQlUwSUyMaMWColwlSMTgtiyhCMQmSRM2OCMSspBtZjZgaE6A6YWQqUArXCKvoxvFp1N46CSWRWC7dqoYiwmnx6sT5d++F+L5NlDkg3o5spIbmzxw53bWwPrncH73cL+jco6jsgic/o/GxvhgZXzNYYUSvE4iSogc4tNtNEqpHjGHjzg0f8pfcMfPxq4bnLt/jC5TW/dW3g02vjXzWS7plnznjrg+e4PmTmaWQRO25Njnc8124oUb1DLaGNI6lklMBBfGrrfHbioUNJeRPFoYJUMFVSgvVqwEw4Ww+82nC9zWkhWKTrA9opZZwIfaJWI2iD0tpeVGaHgj47fH/u0AJs42nlMBt9H9e69efXbS9rPqLe67/dYpbV6HCb1jwqw6wnn42IBH70Tef5x1d8J7wy4WNPb3jo5IjeivvHBSYRZCpEdRa7ipDHiaJKZ5VcC4MII8J6MjqZWhIavjuV6l2UGEXbKL5Niuq2U5fDYCHbkdtqU3YbB2jeNmaujfq1fe2O6K1Oi8tGY4Uw5OpdejY2w0SuxovFCFU4q4GvrTOf/cItfurTL912/X/sgRk/+d33Mphx4fwJxYxJA+c75d/9wddw8eNX+IdfvT3z+p3zwL/5xIO8/cEZvbhSfdEFglRqDVvpP13jfpt44YyyXwNt1ekiglVYSaVvY9wqQoyu+I8lM1aH9SSDqU1AtE14grluZmOFqIHequfFF5yUNlX6LlCzf8bG2kRuNI1EEIIGd080bUho43vVQKqFoRg2ZlKf2uQFulrYVB9rx22AD8I8KmUou92zWUFmkWkDUQtzUUYzkghDjWjInCegakQLhAB9zZgKEo1pMiappAo5ZzbFkAqnuQCBozIy1sQ6++dpLYXzaqwVwgQxKjfLyLKLlBKgGrcCLEqkC8J6LG5znAV0dOdKFKHgaON5u5eaCl01qvoYfkCYi09E1NbkPHHh3BHrtAf43E8hDZW4cE++TcaoxjLcTpt8ZZXQ3ce3fEFnV+CahY0WJ2m+M0pNMYwGUqxQAzpXNlPlfKespsLSAlmVUZQHbeRaOeKxhwa+/VzgiXc8yE9uNnz5ZmEYjE9dO2OxcYvIlZsjN6fKz195ddGQf/drZ9jsRX7grSf0OXA2ZI40sirG3IyzXDiXQhP7HbDkW1dS2eZ2N8W0HbS4d0BfrG47IkgaWJWIBGPe66u/rJ1hm4GSOrLNyEGZtWu8LcR2UKRv+4Ju4TGtFT8s8tvnWg/SWuwQXNu84Ntf364etgrysp0+iDGp0quPnudRGIORUuCBR+Y89qnA58/8T/+T37nG9771hD4EjoaRWzXSJ2fray6UFim7mgoS3b99LRtLyawkcqFWhjqRYyK2G3kxmElhTWx2PseDunjOhXTBvCvd6gKK7PPh60FHvg2MKbli6otfUY9jpboAz4r7f2sxxmrUsXixyhOr4ulqOmY2qzUvjoFf+8Rz/K/P3P7Z/LOvXfKj73yA5dyYaaRb9EgeUVVGgfvinH/rX3uEP/L8Da7cmMjFOJkrj7/2HJXEoMIyGrOYEIGu69AAfQPmOEcnEJqCP2BkBCm2E6/mdjFSC8optWLmoikpBY2BWalMIozm652MMZXmTzcfdUdRqrgjwaoRpFEYk2AlU0VZCITkvPKK0HVKLpXQRGGmgmnYWV+tTfmSCdJHTG3H9a84GS5LEyYqbGpx8Is2l41CL5FNNeYJjqwd/Fvwrr4AACAASURBVGqkq257ixKoxe9J8xigVKbYEUqlmlvgyN71F6A3YzRhGjPHnQGRmyXTAacSWdbMSHZhnyYmCp1ESnHQTJBKqcpYC0OCHof9LKpxFlwhn0WYJBC0+rSgCjFGhmLcnDILE0ZzoZwAqw0cqTHUNesDPbBopET/bofqcbMJ14VICLtxotxdnt8VxX2jffpOcHUglNt5iG17OvTRoCJ0wT3BIQQfF6qxTMpA4HwfqblS+0QXPQ71oaWwPAq8+XjGay9EXn9vz+vum/HoxcjZqfHUKr+q5/rxlwYeIPPw+cS5FFnniUXqGbYwCLZjWtntje1gay77Pv1l4sBDyfu2kOYKdSzkFJBqrIpw67lbPPkqkJR/8V33sjzXsWiAi6PQDkyqHvmpe3jK9srvu2572fOSgz35Pjp1/zq50/998NjiZ28Le9nu2RtopgBWKl2IXBtGLs57fvUZXy9cr8aDAd52IbDG+dY5RmIxBvOoySkbN4eRKcONkn2kP1VKNgYBBmMyYWMuWFOrjNJAKLafJuyEgLKP5a0NnrNdNdj21ZhvGKvtc8tdf+cHhq1iXq0yeW13DG7JTFXYlMxqLKxyYTVmrq02fO0W/PQ/e5qfvXr7e/xXHl3wJ37/I8xF0XnP8bmEjoW+T2h06t08dczVODmZc/H8nNfdt+She48QCZzMYG4OctIQSb2LT6NAn2ID7oSm4G9JebWtTdTFaKFNKLZZDFbKTgi4DcahNvqj6oHo0ANINAhDqX44sEotQtc+g1mNLhcfT5sT5EpLo0shMYki5ghUTIjVnQFRA2qFgFJroUrDosZAmTLSpmVb//+WiWDbqY5BjkosXux6FSqVLK45kRCR4uuDJKAx+sA/qB+Oi+/rrTkiMGOwQMa4NWZC8QK5mgqbIbORzLjJ3Bh9zZKDIKORQ2RThEgTE1Yom4maAlGVlJR5F1x1oT7JyDYy18TNqiwC5FKIpTDl2j6hhpowo6K1MlZlI5Hh1hnLaNwaKl99bsXnm7D4ey8m3vbYeTQGTjqlixGJgRDa/eGA535XFHe3Q/+mhX3rRTf2tg5xh4qzwYt3ZVhAI4RszJOwqcpYhAuhUFR4MMw5Lc2XPCucTZWjYSCrUnXOmAvnauVy3PAX3hVYfXjko6evvFT/Qxd7fuGl/TH2b3/ujLlEfvhxT25bjyMpRjZDxqrvAWepzXCDwx+8hWhq4Cb/Vtnvog5V8NuxvOEK+kEFpompFkwDP/Yd9/B//7/PfMMVwh9/aMH9Rx3jaAzJyVhnOTFvYqNaZAc3cT+13IZoPWjS7/jvPRxFD3QCe9W7cGeqi5rt9r9yW7iLNGFVYKoFrRBmHSEPLBYz3vuw8qY+8MXB35dPfOkW73p4yf33zOjPJpJETtVjTG9Mnkw2r8ZUMp+7OXLt8k1qNu49WXDxnp5lF1moEdXH8ZtsLDSwHovvkjVT2006BC9SsGPWkFvH6iA3V7I7JKd6vC2efifqQKBKgxdVY9JKyMKNKVNV0bORIsKNbIzZWOSJ61PgVz79Ev/gC7e4eqB5DCr8F99+iR94fEkU43gBeeYjap15cIapoqVQppESIosowEQKkRHhKDRIySyhpTCL7jGuKqRmt+zVmfHSKHqlOMltrG16Vnxvvj3IlWLEENwKGRSqK7irCsWCW1JFKGRUIlWEqUAXXDkfNIB6Fx9a51haF1jU9spqjFKypweG4DnxAaiRRKYWQVFGYAbkklENDLmiJoyjL3xKMJI2B4R6fn1tpzUx2eGds1WstkCeKEwCqU9MU2nBR4WAYFahuvZgKhmNMEzF10jVC/KRKtdzQYbMohqfeWHNL3/mRX7+hZF1Nd44i/zp1y9597dd4qHOQCqjGHUS6HuO2ncztGnQ1Y1xTxCGyZgnpY7KoEovhU0Vpil7dnlyfYapEqhcL+ZM+Sgsc+HrGZ4fEt0ManKwDcDpCOPpxKXlEVkjxSD600LCQWjT3YH73Q791Rb1XacuezKRr85kv8NpKlltcaYq7AAIMxVnKkcf45oJfRRmMUAQui6ixb/ktVSOFh3vvq/j0S5w+TRzre22fvzBGf/hOy7yfd9+zDuOEr98QIz60IsD41nm0knifBAXOfU9YsWFUs2OpEEp5rtaa6ATDgRiB4qrl4narMWkbgEzTJmpGMeLjjf1ygeePXtFLKUA/8E7L7GywvKoJ7UUpiBG30e3XDVa2g70I3IbBnZnWdtvxm/v1l+2MZDdbn/X9e/0AbITRu0BNrrb4fvLtx2XIFeQOvptczPy0Rf9MPXMVHniYsfrF8ppl5ipIGNmhRCrsTbjyqbwjz76df7rDz3PLz6z4peeXfP/fOUmv/zZa9yfC/edJKIVTCPr2rLgm9BNgneSu1uW+QGltqwAa0XMGtVNGwNcgMncay7Vi30xmHIhl0ouhakx2W+NE8OQWZnAZGxWIzfHwheurvlHH3mW//2rK9YHJ7XvOYr8te97mDc8siR1HYs+oPOeqLAMQuw6grhnOgQlxOAagyb/Xib3knezjhqUBb5zpXXcSaCPbiurogQrSBBquy7iKZ++U2/o4aje1SZt5D8NPr0QbWP09tmpRq3FFSTV1xdK9QOs7TG9Pib3vz9s2fciSKle1CX47j5nwMf0Qf0AlRuwhSaWs/bcBV/j+ARvTwDcngW6XBgAqQVi8F+vBsEdB9SKqWu7B1WkFhZJWbcPcGykNI1CERegbeMCcxNADtPA9Y1xVCobM37lczf4T3/tMk+eFrbOw2u58sEXBz775Zu8+6E5ixiIIgxV6YG1OcHOYiSI0gts6kSnwkYCEoRRBaaCNL+4teeXO0EyrGthrgpjYUQYy8QL1zfMkxFXmX/4tQ23Gtfgneci3/v2e3GHoNF1Sh+U1Gyi20z0ux363YL+Lz+Cl4MUrW3edvshtDGQh2TQIi69sw0htijMttcOgVlQap44CoFBhZMu0M8jpMS33b/gfW885kdee8RfePe9fPejJxxdnLOIM2wmPD6L/NrlfVH/7Zsjs/XEmx8+IkVhg1CrIybH5iWvtXgn0tLT9oVPdoEodkcxr7b3gleEnMuOsK4INcJr7lnyXRcj91nhbIShwnigXns8GW+5tGA1FaLAmBKzLvo1jI49FQ445HaYoNTQpHZIjZOmc9j28rI7dLHd+d8prtueVw4odLsx+/ag0NLEBEdyjtYsi2bYOHL/yZL3f/E6q6YQrzdGnnj8HkLOBFGm4DftVS5MFX76n3+Nn37q5SldZwa/cmXDazvhwaWSYyQAE8ZM3KpUDazWPefePM/dmsXImhhumIoro3H/+1CbZqA6hGPKhbF43G2mMgwenJOzA002GcbVyJXTW+RaeP9vX+W//fWr/M4dzow/dW/gL/++B3ngnjkXTIgJjpY9M4zlPEGIhKB0kR2Wtm9gGIuRuTqOtYtKxEVdph7eYSkw34bdtEAQTyoMu8+jT5AqZfsZMEHUdlZHxANObKd+l/30ohrSrmlteF7DLWIGDG2Ik6wi5o6CIEJuAjvHQAfGirtHzAi4VU5VmwGNHfVQGpmvVIMQt/wTR8qK2z+d5+4HnaIBra37bSsfa0hfCUpVZWnGBu9QXVwAURSrfk+pTQ8iuYCmxiLIzeteqCFADNyaMk9f3fAff+DZ3/We90I2rr6w5j2vmZE6dYGd+uQlBSFQ2EwZBVJQVhU68fS0VCGrsACyKKJ+mAxVKKWtlqqQRZhLZrWqvPDSGcciqCkf+/qKF5sN9rvvnfNtjy5Y9j0Jc0Z/9IPD1tLpccF3w1nuFvR/hW59exrcgixop0T0IA+7/V5Qv3H5KDGAwCxpgyIoKQVCVLTl/Ebx8bh2kb6PhFliqZHSJcpkpFiZpRnH5yJv6+BjL2x2iNjP3Jx48bkVr51XFrNEqu5NXxZjaurdkitYKxq17F4Pxk4QtBOWNbqamd84t4r/2pChasV91KUQ5j1vf2jO+x455kce7fn6s2uembzwfeR65r33zFie77ikxmkBrwHBx5sxNYypj/JU5YC/vh2e32Gva79nTbldt19o2yeL0brsbZSqC6vkIOTF9vGm7eAg5sKlon7DGBow52YJJCmUMfMbrUt/aqy856Tj/MmMivkBTaBk+J3PXeVvPPmNfdgfuLzmvffO0OTMgCLus7JcPa89bEE1O7UgUy4u/sqVUipWDWl7WvcRF/fAV+M0O7J1rDh73QJhKpyOG148dZTrWVBeunHG559e81MfusIv3pHo9eZO+M/edsIPv/s1pMWMEoXZuQWzeWAWIrFPxGYzS+17EIML2VBFo9K36dB2qjVTV/Z30THAXcvbNtEWL7s/iG0FjajjbJN6MNFUHKeTcO+1NVGcqdKJMLWdtL+Xrvbvmgc9GIzqn9vo3lS3GYpPEAgQQ2xqdhexWa306ofjpIEikAP0URhzs2RViFaZKkyl0odIKZnQoDelQd4zzinQlny2Jfe5MDPQVXOMM4IV98/nree7lr1wtRgpuMYgqR/gNbg1TdqOuhZjqpn1aGwG5wr8Xx96js9+EyvtVzaF95wPXDhZ+nMOwd9Hdd9g0IAmf6NmIbC2wgzoawWMASUGXz9ivjLahOAQqZKpAaIpz28yZchcCXM2mxU/9/SKLZvrDzx8jtdenHG8SHRRWLTgmHgQDayyn8LdLeh3C/q/Ure+TfjajnwOfxbdZ66rbPO424l+l6jVuuQQmLcZmVimix7DOJpwLkX34ga4NA/cqIFZnTgKlUcu9Tx2z4Inv3bKafsSfHmd+fQzG+7pI5eiITFSY8CaAErMWE3Gpt0cbetQtv2eutLG6ofj7brnOBuu7jWgWCEXj3UdcqWsV0waCF3PRy7vu9N4uuHxh07oDDYhkrpAqH7ImKtHsyJth3rAQ5cDMRjcHjizVapbO61XeeWQGU8B9RFdPdT7HYrjtpQu2/vic/OB51IoVsAqD88jP/vFm7siWzaF9z7c8ZJGZqWwKYUs8DMff57feRXixtf0ylvumxPHAXB2+qY6ynTKvu+vU2UqE1MxcgGmyiRKyWWHmV2NEzlDKZWb2cjTSMlQqJxtCmMuDKsVQ0ycbSbuGSee3hR+/bMv8jc/dpV//OyK63eQ3X70oQV/5XsfZH7hiJNlx3IZubePzGfKvEuAF7Q+tCCjLRxny5NXZzTE4OlcffSCY1Hp1MmGUaFLgS3Hs9PW2R3oVyrQi/v6d5+HnWagwYYa9jYB1QqikazavNXNHtj2KBXcDtdUCIofBpJBlkAQZZ0zCae6mRQ0RMR8ZRYMhloRE2oWYhPMiRXXLUghaaS0VVxGGK2SJDAJxGrU1JGzT2R6gZJdvxGmAik0kVzT7qgfUodiTLjwVqq/5hFhocpZFawWB9tkY8SRvmPJzfKV2ZTCrQn+1m9cYXgVbtM3Hs944/09GMyjsUy+MrDi+32JgdqwtVU8F6FKpJQNMXWIq/SgJd716lZODQEplWGaeOnGwEilbiovnK15/3P7A+UPPjTjdQ9f4CKZZVRCr8QQbruH0qahd8NZ7hb037vCfhCUIQ34sR3FawuRsDZ+1C2qsNkttrnWKoK2fWKISoyBIoFZ9JSmfuZWlfnMlbTLUOkkcHJhxvvuSXzy8mZHbLtWjV/5+in9euLSSSQN1cU54jfW9VRgy+c2o2ujZpW6G0VGY+dhrttUpSa2MjMEv4lpEQ92qEaXK5voI8LXHwWuXF3z1Nqf0xcG416tnL+04DhVNDuRTdVvtCE61nKLa7XG7N4V9jYnV/brgl362oH/fDtK36Wu7UrFgcr98L1str1DSI1IG9WiUAqlFiqBuUKuSjdMfKIJE7+8yjxxItyz7NxvHgN5zPydT7zI2au4aS6l8vZ7I9eyMDcvfrkaw7Q9QRXqOELXU8aMjZmrZhSMqUyMY6GWwjp7BvWNzUisQl5lTseJmo1bZyO5VjKJK7fWXH7hlJ/7/HV+6mNX+ODzG07vKOTf1Sn/ybvv44++535kPufCLHKxqyy6GRIhhkSvjjTt8IK23T2HIAfJcR6QYhhdFz0MJ/jVD8G/L9FXrn5zDm31YhVx71dbETk5rezCY3wVlLRNUhDWhlvNzKgSMTMShrbMAGlpcluNSym1uVRoue/V0adB0ZIJMVHFyGPF1NO9tvhca0EthovvSsMNjxKIColAxq/BVDIpbAN1fExOLaRa0aSehV59752iMjbLq4fr+A5fC6wbH20r8uwUVqYujLOmzxkykhK53WNC9WncaMaIEbIxrNf8H5+7+aruc9+5VN76ugsUg+MYyMVDoVJUjEJvQuwCEwHLhZDcmtYTkOD0uE3wYKuaKxJbFoEBBMoEX7q2YlE8V+FWgV890Ab9+bce89aLM8JyxqxLrsmIbukMB/dXkf1k9O7jbkH/vSnshxF+u59lt1/Xbdfh7UvLvVb3HLvKzrnmKizaiXbe+RgztcjAGFx52wdFTTiNHaEYD5zveeKhGel04NO39l3hb96Y+OTTp8R5x/3HgRAjL61HQnBIhZgz2Vc5k/NEqU4aE4NaPKTB6nZUje8vG/9bpBX66jfNyRwPmYdKrHBzzJxLlY9ennZiud+8OvC+k8C9855NlLYnbECRrZhNhare7R2mcR4WXL197r675ndSZ2SbeHYQw+od3QGpRrYcdNtOtXdziaihWYu8K7qWhTIVHk7Gz3xlT8hbr+A7HjvGaqIPzm3/hc9d59arCBz72qZy/cWRziovjZX+nFKrepdVKzYW1qkjrAbW2bi1cRHjZsjcGiayBsZ1pgRlPYycTTCcbVyXNVVeWI1EET751DU++5Wr/M8fvcL/9qVTfvOl8WXZ5e/ulb/4bUt++InX8pYLHSdBsNQhCZYxoVFJMTq8JCqdNGZ5S77qW/cbqgeneBRtIDb2tzbuQQiugWj6tF03H9Rz2qfiUcDFIDUzd6YixUfbEZBamVSxZhmL7TAXt2ADdWW3qQvTolUkBv+sFt+9lmYN2/77Lfg4XoOLJKcqxC62UX3bp1sLUrEG+4nus+7UD8EjfjApgNaM4Ar3qoFZLZjCaIEahDq6I0GDq8O3h+QeYTBzLY6JI523i6fiHvERdwJouxbZhKFZs8+qH1SH6gftmcGtsbiwcDI++dTpq+Lsf//DS779/nOkpJACKSpDNTRnauyoVAZJHIcmzCuFUSpzUa6NnhyZLCOm9DFymit5M9CliA2ZsRrPrTNRAomJy5dP+bVre2ntn3rsAt1J5GSWqAH6oIgGkgJBd82RHh7u7z7uFvTfk8J+UOHloKAfCja24/jtqXKr41L1XPBOhS54QlqXHI4RgpBiYBGFWYqkoPTi3dGi82AT8JjH45OeB7Tyiat73Oa1Ynz42VPKiwNBCxcQCJVVjqynESuFm6MxVWVqxX2Oq2un4qCOXIVpl7jm+91V9dYmU5EpIyacVRfOrHNGRZkvIm+dd3zg+f2p+0tXR77nQT/Ri1WsKiIFJPpYVJ3nLbLtpF/uMDio8k3Ydzuf/mXah7Yft9veI73NzpbZ+pkd07kVpUnLxz4bK7MQfP/bK4trZ3y88Xqf3hS+47jjNRcSaHKx4OnIJ66Pr+rz89Sm8uErI7/y9TUf+uIpz7645sbNNeuzidMhkw3qMHJDRs6s43qeOFdBJGODcWvIdGOlnq155rRw+fqKz371jE9//YxfePIqf/M3rvLzz6z44IsTL72CFeE9i8i//7YL/NB3PsjbX3vMuT6ymAemFOjnyoWoHM8S2imdKn1sQinD9R8GNXi8q6M9/frW9tkPza7kyu5GHQz+Z8RaPnct1MZm939OW0a7eWwsHoqSRR0wE7b+fffao0ptpG+kEoox4GItGsBFDzQiYvhzzU6gK7XZC1QJSNOMVAfPiJLNi3lU2Ji2lEP3omuVXdBOaM9JxQ8NZgXEefBTzuSWEFdqoQtKiNsDgyvxFQ/J8QS4SlWwug8PMm1agzoRVFs2gH9HoihMxScHuVBKZW3CugglJupYKePIaiz85kvf/LP5Z951L4voO/skylEydwl0im9JnA1AgSgZbR26CnQS2JTsmojJyGVEi3/LpirkoAxnK+pqTew89ObalZEP3tg3JH/ujTOOT46Yp0gPpC4Rou5iU8Nu1bkXKN99/N4+4rfyi5c7/s9Ojbv7TduNkE22SVdekEKLQa1tz261Ip228ba1NCm/seVQKbXSTcYsGkQYqvCOB454zXHgfY8c83c/cpmPHXjZf+aFNT/zwpo//ZolT7zlHt56aWKF0IWBsUCqHeuYqEPhxtnAudkcpLKcd8xlJGtEbQIThrZrnmohZ+XMApthIpTMzaEScoVp4sqLhX/w+WsvE9v8/Y9c44+9814efHDBOJxhukRjYUqBmCsbcyykiO5G7NvcbpqVaBep2q7tFuW57eC3rrRdbGjzqm8BF4fp6CK0cT87kI60Wb0VIyjMZwmGiWc0UjXyQ9/5Gv7eM1/aTRF+6TMv8eg9c46XwrwK737jeeQrt/6FEb+Xp8ovXF7zC3ekj3ZBeLwL3DcTrItMtXBfjByr8dS6MubCJ9d1Z/l5NY8/cqnnhx9b8PiD5+gITH2iS4qmSKdGRyWmjoX4eqgTpdPGP2+dbDVpYBYvLLHto321IbsddS7u5hJtyYXWDmzqxVPUGQkFc5U6jXwTlNKKlo/RvRAnq1uyCEW9kE61+u8bjDHQizBVIGSi+dSrhrBTw0sppEXPMIzMFFYlbGc6zmQPgakUkjQvf3T+e4cT+KRUBiIhGEOuzGOzogUlT84ykBAJBjdrZtlFcvH1W1eNEn3cvike8Zqp1EqzgblbJo+VZfI1jGIkVcbq+GLTgFhlhmsFVrn6QadW1sG5GEdmrMqEYWwErlrkiTde4Le/vuKj6989QOLPvemYh5dK0Ojj7v+PvTeNsS67zvOetYdz7lD1zT2QbHaLbJJN0RQHk5poDbZlS5YQRXYUJAZiILLjOI7jJAiQAIn/JTECZLIQQIL9Q7EcI5EiWbEsC7AG21JkW1Y0WKTMJsWmyCbZZDd7+qYa7r3n7L3Xyo+1b1V9FCVRiWxrqAM0Uc2ur76601l7rfW+zxuN+1UYo7PlrQeuHOIWzaIBm2euZNhIxoIBGdSYRmGuvmNfZ2hz4VSVCSGHyOmpw3OevXDGeNsYePTha4SYsBSR1NF5CqS9TuPz3Hcvr8sO/V/0SP78n3NrlVzo5MN+v76PBDwTzQXSha/3o6UcA4MEYoSMMUfnKldTx2eu4N2PX+GpAB+8PbG7UFU+fFT48U/cZ3rxmOujMaRIlsD9Ehi0klNg2+Bku2NXlO2m8uKudeqYsCswq1Kqca+ClZndXGnqyWmnU0Nj5qVXNvznP/8Kd+uvLmnPzsovvXDKl99I3FhlanaoR3K641mgjEOoQrfg2AXIzPlOHfYK9nMozedOTvYoTkzPnvO9DS+cgWzkrMs/U9Xvq7V4adrMjawVrJHbzKI1fuFVvwt9alK+4kbmavbCeH0ZeCoLP3nBWvjg7hz+0psPeee1zMnEA5nin+9qBi9V5dmd8onTyqc2jQ+fFN5/XPnEtvHcpN4t/QZvyG+4lvm2L7nJf/EHHubLv/hRXnN9SR4ieR0ZFwOrMbEYIksRVsuRRQIkYgJpiO4J7+sixLHrFkJfg4SzQ1Hok5E9ApXgxToEt4PZRbugNt9j090TIk4765qPDqj3n9jpb6GH31ht3jV3XkPuFq6gBtqoGFkianrGvxfxotdiQpvT3ooJEfXHtV/T7Efd4tY7VGnia6KmzTn9yQ8IQ4pOm+tK+dgnC9pxvVmkd9q+zyf4BK6pr3g0xfNAqOZjdHd9NIxIC757N/EgnjEGdua++Dl65GlGGDo4SUrtf0aZS2NuidYKTJVDCq+9mvjx5z//e/PPfNGab377TYYAi2VGox/LDkc/iTVJXbcSoRZX35vSkhAlu5/elKEZu1rJqsxaiRaZTR3HTOazd084rcZdq4Rpw48/N/Ni/xx80xOHvPHRJetl4koSNCVSFJbRJzHp4v780oN+2aH/tujiL+yCLwqy7ExhbmcdvGGYQjA547M7lUu4psI2DhzERKnKGOCmbrnxjkd57xet+aFfPuJ/e/bBgIwfuF34gX/yKo8Nka95wyFffytz7TVr7s4TJcJUE4dZOBElx8DzJzORxhggpQUhwpAqc4uUIizbjpdNuErhaFf4nz9wl1+vPf1sM77vmdv8+d9/i8ViQLdbNsMSywIZR2Q2Z5jr3sq25zbL/t8/J4zlYtwq9kBxcaFduLAnlzOBTpDzg0Lbp2mp0bppPeDioiEFjMQ0T9TFyFc9fpW/+cwJm/44f/BDd/kPvmrN1dpIy8xTb32E/3418n0feIVfvKB4/8MPjXzjU9d418Mjn2yJr/79xt1XTrl9p/DJTeXnXpn44IkHpPz/uRZB+PKrmdffXPD2G4knXneFR2JiCrAYhTwokew2rAQDPkKXGDkcYSIgEZL5uBq1s2Iuem4vFHVmtwR/QqXbxAgR0+YTqBAIBAq+z7b9zVh9N72I7pyQrmov6qz6UJUQhSb70FHXbljo/BbzLjwFnxhsGqx6dF/FDweqBjGirWLqFsGYArF54rxD1oLbr1oPgQlgpfW0toBq8fdYNVpwNnzWRqMRQqDV2nfwe0iUv/F0nhmHyK4aMSZMw3k8swlVetJbbfQS3icgEVMlNiWKj9GjCGFuaICj3YZxHBHJ1M3cDxdGq4ENsM6B1iINZRcSEowwCzEHXtxGXto9eCf6xhuZJx8ZeOrWAbeuDhwm98GrCLEFcnL1fMhO+xOBlVWOY+RqzmyYEItMc2FAaWnBTgrjGNgVn1TMVUkqHKkwTRNyOjH0NcXMgvdvzl0xrysTV5eBkEfyEBwJ3Fn78Twm8bKQXxb038bF/gK8Zj+uN7lACeujv7PoU/PwhtaUHDIlFE6TIDIQs9COjINHrvFnH7rC8I6T6wAAIABJREFUVz95wt9/+hW+77MPBmx8Zm58zzP3+J5n4Fa+zR99eMFTVzI3H15S18Z6XLLD2Erg4Rh4eVPZzceMo1B2hdGE9Qo+fgSrUTiZlU/e3/HJ3W+cB/uTLxfe+9yWrwyZNka2cSbPwkzyGx2GSWKMgWR4MehaBN+F2nkcao8qlU7Csb3PvKNg9/Y0Y4/07VnpPR4X07MuvXWFsWBsqxek1owUoKCEccV1mdHrmX/r9Wv+xnN+I/qZ48Y33r7P28dr2FZ4+CBy5YkDnnr9mt1Gub+buXUQIWeSGrIIvKa4WPLGo8Ljj8BbWuRbkrGdZnaz8OK9HUUDd+5tuTtVgip3Tho7NSZV0iJzMygaIw+NMKbMa1+3ZmXC+uaKZJVrY8YGiMVIw8haKywHtBkPL5IrxJNPfIYu2JQgLPYHn+SzjrB3IPQknCydH971CK0pMezHw71D34cBtdanME5NE7U+meoj9a6AL6ok3DkRG7SzDI4+whYH0OzFYLOAiPMMrBkLM6a292Wbq9HFLWYpRlqr0AK1d9RBIpKNVGHX3PFRgESkRt/T7lSJ5qjd1KcI2fphoR8Ac05Mxd/zQbyYNzHyOFAkELXRECrG2NxuVqSRRWi1h42IEptjX61WrClTHjE8Se4E4SBHmCrjsKCYA2lyHpi1MFdhCEpucK8KqewoIZJphLkxUd0BUpW/96Hz1Lw3LgNf/+6HeGyMFDxbXdcDy7mw6Qr6cQmtBmIwcilIikwpcRhgW4xogdwaU86MY2KeJ65rZFMKVQJrCWyif85ihXlbOR6XbHaV1+1O+enjByvz9dceMpmwFmWaJ4blARKSf06ja1xiuJy5Xxb030md/IWwlDMeWuzEsBA8dUqA5Lv2RGIlflONLaKrxtQmTmbjyUfXPHk18U33TvmlT0/8tY/eP+ss99erRfne5zfwPPDL97kShLcsI2++Grk6ZpI0rqfEMTAG5ZTANYRXYsbmRtjOvDwrP39n+oIf5//44Xv8ZyenfNm7X4tMARHFTBkjbKfGOkXKhcLQ+kGnGT7GxHfjKq6ufqBY76++X//cMYl0tfJ+ElLhPA5WvTDUoj0QxahNCDET5olNaYRofPOXXOF7P3165uv9Wx8+4UseWhLGQDlWZD1yM1TuhMj64JCBxlINvTpyWo0FRrbKahzZtoY04yAP3FxE7lfh1o1EKYH4xALdVlZDRs0o40CmsSGSdctmEtbmRWO4foW63bJcRFTdIZHHyBCVMAgpLnx9s4SCC5yG4HagQRx6EpMXi7YncrEfgUDq5BftByuz1l+fiDR/DSJQqyNoQxc7qPNVSSmAeuG02s4S/dqe4NYtoC2eR+BaUyesZYelSDRKP8g11e51VlfLG2eUN6uVGCI5BqbaEEkUEWJtvu8PASuGmpIsoKIsQ2Q2YwRamxlDQpuP2HNI0CoSIYdArf6+nNVTE3MS5togRjLKZEo1iLUy5OSTpwiruTHjX9P896zi0KZqgRQGylDJJrRiTIvEoL7amgYf3+cMooWmiWjCJiSqVkr1PHNLI3Uq3G4w1ka2xC5N/MTHj3j6wirs33jqOo8vPFOdAMtFoomwzZlrg3fQdYY8+sRlOSRmFWIwZiJiFa1CWwzkaszbLakFdtaYBZYibGsPjUHJCVotpDZzMGZeKCMfuXc+QQzA46+9wbWcnQKYloSu00gpnMGjLq/Lgv47trDvc9ov5gBL9C409JStlFwJLHNhao3DdWQsA8MiIrsd94dDXnO45E03d/yxdz7Cj/7KPf6fZ+/xT+9/fsXrkRq/cFr5hdOKAzL/xVzf/lzhLy7u8rW/7zoahI0V7FRZrDPHm8oiQcuRRY40Odt2M2lHswYvIKUL3zx7ptuM6NngvTvvT9le+uQ599B3tR7/WPbYVIXaPdAmxtSU3BoV34GetiUyZL7p9Qf84HNuY/vgSeX9n9nyzrccMiyEdVMWKXNj8CSy0yaMwUghMCRhacYmjEQxrtTKGL2ALvMC2+1QWbMcKkdxCatKNOO0CbeSYjmz2DR0WLNee+yvSSAOAc0rVtE7YTHIosRlYhJhjAETYRkCFoWixtgzrJVITHubV+iAHdx90ZxP3rSL2HDv+zJGdtWfG0kODLK+Y4/9sCSh2wj3NL4YCLX1aVQgiHbLpPoIPIQeyuLrjjFEz5NXtzh6GlnoRL+GNLcWNvPPgJrndMeYCFHZ1ULaJ59p3y93m1zrjHYxPxzMVdHou/pJImMzNCWn9qk6bQ6HzpQIqe+yJSpbM4aUMJyhHxAWEco4OCBqLkwq5D17vbof3nIkNP+Zozm8KZk/D0RHLg9RMCkkSWzFY2QHi8w9uOeKVTZVSRKoAZh3KIFDCtvWoDaevTPzzz5zPtp+zzLxRY+ssFaoB2uW1gW5BsshU1MkamUxDNTaGIfIHBKBQprhBGfZSwZKYQAkZd/9x8BIYKoQkqBtYmOZUHbcrsJaAxKN4xT49NH5RO/JKwPXcqB0Z8IquDA1dZue784vm/PLgv47fBxvfRa/B9eI7JPf9t7qwCIoaYikHKlVnXVsQswrZG5Ya7T1NTid+RPvuMk3v/Uqz2yUF5+/w9MvbPmHr8zc/U0opX+rru/46BEvb5Q//p5rXMkjq2Xjbk2stSFDIKhxtC2MDsb36FUMS4683INk1LgQNnMxHNa/qn2wvmfUq1mP4TS0R0uWptBcOV4blNKYiCzEOfVJ1bO1VdE88dVffIt/9sIJz/U1+U9/8pR3PrFjKwvqmJGpsFiPNFUOYmRMHkkZ1cfWQ4AhJOrg9hx/YStXVivKXFnFQKsz42JgCoGhVgiJIcLBkNk2mGtjRMiLwK5FxmXE1AhzZVgOSAIlcFPE6WfB1xecEbfEb8Y9klTFKW+huy5UDEnSmePuKjAgi4NLghhNYgeIRO9iuxK79tjMLMYMHjbSiwa4Yr1JT0OTc21DBCQlQqvMYkT23bfS9gJRYLKIRJ/QFAJDa7jsyv3rtYJYZMb92S141nlr6gp284NJECVLYEcf0efI2Gr/gBlLEZ/EiLpHPbiupSFEbZSQGGqlBWMIff9cG6aBKiDWsBzI1thaco1EH/M39QP7QiI7fHogTSnaiPjueWcC6ujTLLArRh48rrVNM5uUCMmZ9ruYiKESt0ohoxj3dif86EeP+OQFD/o3PLHksUViygOixmKMlBBYRH98ASWmRFPjyiDci8LQZgiBKsL1qEwaqVrBEpsAqVZSCpzUwBCU7e6URRzYSYZauL1pLDBO5kaeZlITPnR83lR8zWsXzGPjYFwwirsNqvj78+LSXC5L+mVB/10zhhe/SfoI3kMRmoCqqz+HzsQeEwyzdwEpD8xzgF0lDAGNkWkx8qblzFsPrvG1T93i39ud8uI2ce9k5vmXTvjoxljsGj92d+J+/fVFWo8OkS+9lplR5q3xk8fl1/3+r7g28LP35jPt3Pd/5oRfOZ74j770FmWXOKiGrgaSBlqcIeY+Yp2QIbEIQvGkG7IYagETH6MjTroLZ4E61kEjPWjGzinxzQS1RmlufWq1MlvwiEoTdnOj2MwiZ04UFlY5BQZ1DcFjK/j61634rk9tAPiH9wvv/cyW9zzeWC6vMgyJHHzkGHNGpIeHhMA6iI+AOzY4ds98DD7WHGJEIxy62ZqVGXNObp/qaNorWYCBqg3DuL5IWFNihjYOgKuitcN61sH1CKFnp+8hMI1esDuJS3tKipk/d2Mv7Natfeq+M3+eu+AwhtAxwp50VsxI4kK3XQe6yNl5UVGDFjywqLn5m+zDcyQGRm1+COi+8WbQYiKZop0RngRSNTQnrJnv3xUs9r1uEJIo0nDqX4iMwc7U9sHUk9DaTI2DM+ljwEpl3jspUPfPB5/YjCFwPDeG1NPUQiZrI0ePeA3aaBKd0Z6d8y5NXSEviUhzNG+K7My8y1f110iVZhVBSZJQiTSLDCjbjjw2bSSM7VTZElikgaZKEGVXjdAmtgqtVJbNeGVb+OQrlZ+4wOr/unXiLW+8wUlt3BqFRc6uSwnGMkdqM+Zuu83dmbOaCkogSOPEhGhCZfbHVQs1JU/5a7CIik2VcblmapW1KhutHJ9sWUhgfZC5vxN++cX7D9wXvuqxKzySs+sium0xilsCpUODzrkflyX9sqD/bijqvWj5G5wzWAYhUDopSmIAC4TRATGmhuRAiPs8ZVgUZTmMlBxYpMTcloy7wjtfe4X7jx/yzSlCiPzJk4mrorxwWhkQSm2EINwOgdfmQKkzq5A5nWYsRGwu3Psnr/D+X0Mc940Pj/zpL3uUX3z2Hn/zI0e80BXd779f+E9/4kX+2/dc4S05cipCzo0hRoZV5GgzoTmyngobAuvs7NiWA4iSgne3Rfb2FhfitH66D+rFBfWxfO12ttI8DUvNk8nmUskxMm1nTkqhtsDdzYY7xzO37225dbjg2tWRzU64GuGrnjjgJ57f8mw/9PydX77Lmx59jMX9E6bDJcuYKdFtcvsAnoU4YGWFYMkJaCqhN4TNQ0P6J6oFAfXO+Up0FXXo9ikkEIPQJGKtq66DeMiH04mcZa9CEC8ag7jNMXSvv3a0qPXxhnYioLa+Bzf3Se9jeFElNaNJOBOguajNu7oizlYYYmBu/haNvTjOfcWRxGlntfMDVByN2tTH/bXpWZTuHiQyC4RWsZQR8716NKMEg6okUYI5UYxSsJw9rtcgRWMKsYskhVHw2NroI/KkkabFd1mlQk5ImbEYfMQfouesB5+IDRlGM4pFkhaQwNQnaHMnvC2Sc8tH8Y53rsZiEHYSGKRhrbILyTv95MjaRXD+e7bASZtZ5ZEUjK3BGDN5rkwhUJIyaOAKfrAdonC6a75eMqgV7ofI8dGWl1/e8f0ferBw/oEvvspaK9euLXqEqrEesiN4Y+AgerZESwODKpuu4VmGyPFm5nAV2VggN8AaYcwsyuxc39gPyp53y9KELcKuJeI4UI5nni8FWy74zP3zieDVIIyHgROcTrhIQs6BUcyf/z06+zKM5V/KdelD/5dY2eWBUIJzb/Z+FBWQM+KahEDuRDozI0fxKMsQSDkiITCFSIrCeoy06AEcoymzJA6WI0OorJaZh8bIwTpx5erItZC4usysEhyuFuSgDEPgymrJux9b86gon7hXzgR4Ty0if+Gd1/jX3/EIdSE8fmvBVz6c+PRnd7zYR4HF4MdemDh5Zccbr2d0TGxmD7XYNh+9BmuIwtHUyBHm2Xfbam7xCb071y4mVD1HuzbTM3+zNWUyLwa69+zWhpbG0VTZFqPtdvyTZ+7zl37yBb7nI/f4sec2/ODHjvj5j93jsXXgkYdWaFpwncZPv+IugttVeX0OPHlTWC8XxOzM/vWYsBBZRefXjyGgqYeHdAYBPR8+7dkFJqQUCDEwZA8UySHQxEgpnTEMIubMgihnaX8tnDPyk59iCBI8ptP/ImheTNXPOdQe32n04BsRWt/FqylxP+GIjlLd97Ctd8fSVyBZAjT1A0BnqasKC+yMQY74Dj+JMPTHHaLnvmv3sTfx2FI16d2aK+2DKtVqF5Ht6XRGUu2HoQTir3UrnmpmfUJgIlTxfXEKjmqtGJKy0+YCaNGe6AYaUx/ji+ee98CXiYhYQYP7yFtr/YOpLIIgFij44bqZCw+1qYv2cqaqIj1xbYFPSrZNECIxCkhCzNc/EiOLpuz6ummunudwPDsop1SltEoxYWPCUTFeuT/B6X1++Ffu8zMXWMR/6skD3va2h1knSGPiMCc0JUh7TLVHxNYQGJOys8BKlUbgKEbGIOQAi9CYqtGCsCuN0ozl4Oi34mdNdFccPNSMz9zfMMwTr0rgaojs7h/z3R/f+mcQ+DNPLPmKN1whLpYsknv+hzExhtCDf8457nKJfP0XX2bMzC6fhn95l539z3lE6D7u9OLXTd2W1VrD9jcVhFZmTBJBPKwF8zFpNL+z1wAbNVbqHdfGjKiNEzLrwdWqkchunskxclwD0IhzY6uB07pj14x2XJgEHr65ZinGrnl606Y0KBPHGvl7P/0C3/3ig+K7LPAX3nDAF3/xQzx5I7FrkZsrZbCApoCqK98XObGKMLfOGQ9CGgKI43H3SWxNldxFcQHzzkRgOxXMArvSmGvhdKckM07KzN/9Z6/y1z52/Gu+Bv/l26/ynieus1hE/rsf+SQ/s/GpxCNR+I5veB2rqyOr5YIrY2AZI4sheiEWdexp9JuU9OQoh6T5mkRNvIji3bmqdTKbTxj61N130sH557E/1r0Azbq6PHbC2z5xTtVTy0If1Vf1/zh1IluUQMP/vtk8CS2FHsrT1eSEcB5mI4HYqXLmbz5CFKhKE0WCj8QR7+xTF3OZQos+KYjd017630FVSvTpxVkUrvqUQEqjmTH356+JI2atNCy4yrxJJOACOXp4CqY0dRHp3A8JY58QoOYYYNOzMKPQKXURpRI6oAg0JCgN7d3/3A9GxMhoholRfYaOxEAK5vjVLn4JQ6RWZ5kHUyaJDMGQZhyrQ3uCenLawjxe18QV9asUOFLjsE+TJvPo1VLArFCL8MLxxNGLt3nmfuXbP3T+/n3TMvI//LEvYj2AxUQSYzFmJARGaZAyC1Wm4Ja10FcYm37/0K53CB3wMrVKMVgMmWpGK8qiW12nplwVYzMrR2qc3t+wNeGVk8JVZp5+qfA/PX3v7Hf7K++5yfve9QjXFhlbZA5iYLVIxOhak3BW2C+BMpcd+u/qvfrFBDI5457vO4l93x5DcFJW8K9TkB56ICxiJCdxoVbyH7vMkWWEYXQC12pIDEPkIPoCa70cQI2QEuTEQfIbv8clwtXVgsOcWK4Sr7m2JBI4GBPrnFCDwyEwZGEzG+9501WeXESeeWXHSe+oFfjZuzM/8/H7rLczh8lZ2pnE1IQwKVtRajV2GpjUFcGnU+XerJS5MU8zU4VWCtq7/GAwu+Gck1KZqzKXym4uCI63vXcy84lXZ/7yL776674G//Tlia96zZK4zFwLyk+95F36qYFuK1/28IqafC8eM+ScCeL2rxAjmPVUMT1/HTvbMvREMOnK3hhcJ+Cds3P/RTx7Wjyq+oxIuO/2Q/dun3fc/S3ToS6tat+X+nM09w6+oEzq75/Ui6yqd+RRhNZDTFK3pQXxUbx2clx2hxEzwQ8u5iuGoJ4LELsLYe+VVrpKXfxQQlNCSiTpK4aunC+toU2d395T0KTT5ULnB7CPBu4L/z09rmjz7HXr/Hh1kWQViME4UWHoZJkZ63ZQF76p4cK/PjlQc9m1e6LjWXpgQpmJaPNDgEigaqNKpGEM/TBQzYWHe5DOkIRtcWdFNPeoKzA058mruXbGpy8BmSulKJYCs/lEYS6FsmvcffmYOu14+l7jf3n6/plOZSHwF999i0ceWrIIbhNdrQeWQSitEZcDwRRyhNaI/b5RqhFDgxQ4LEbJniiXIl06qYQqHo/s8xqyGacCWT2f/vRkx1aNxdFECpVPtYF/9Mwdnuuez8MU+NPvvUleLMliLHNguRwZ/QUm7FPvZP95uBy7X+7Qf5cX9Yug89g7CzvLg5bOhvfvsx6qAZC7LW6WQAwKJHLyfXOy4PvOZFRtJPHinptnLqfVQKtKxJgIDOoWHsFDT2IMxDG5fSoqyzE4FWs2ltFgDgzXAye7wvveeoMnX7Pkx37hNv/7C5uzx3hbjb/y0WMOfuWYr35kxfvefJUveTiwDAsmDVxVZU4N97g14hCpU2EbhZOizFI5bca1aJAzmLE2F0y16ujPed4RklHmRKuKaeNnP373N3z+FXj2s6c8cS3x5W+4xh/6xCk/eeSq3b/9mQ1f+5oXefKtj7MxIWwaI400BI/07EllKj6ibh1PGnrH6aEc0tPuvCuP5jf00oxFdO+yid+coXfHToAhSkDRM3wt6uPqJk5484z1RqlKioEaIqiynSqSXbDnfrJGM2UIgUWKGIo2J76F6Aryg+CpX2I+/XHmSu+azRwNW5WQ5Ay2Xy1Q+94/ibAxV5pT6wWBnbsZUAev1JBcONc1JDEGanU8scV4Xsg7ajY2mMzRxNIL7SSGSHJhofnIvdXCioA2D1jB/BBV+q5eJJBCo6jQmjHEyqS+tqoCEow6zUgaaNYYpKvXI8SmJNyXbeY2PZN0FmucY4BaGCQ4QIXA3IyQwlk6XAWYlQkIQUlibINQpsYkQuyTg0/d36EWuX8y80MfuvdAauG/++Sapx5bsRQhBWVKo3vWY2C5GqCY89hrY0zJtTgWOEmBW1Kps3KslVXM2HZDCCMbXH8iY8A0sA6wZWArgavTjtk8IlejUU8UWQZ2FZb3T/jH9881Nn/msRUP3TjkcIzkdUZSR8oG/2zssyxEwuVN/7Kg/x4p7mf3SjljyV6gZnu2dLclYb4XxfbngG4N6bvVZl5KRByDmqIxqHffFgIhm8esilCH6FxsM5oaKSeSNlozphyYSmOwhubE2E//61Vio0YdMuPcyGOgFQMS3/ZHDnnnJ17i7/zzY376gk/+xOBHXtzwIy9uePcy8r7Hl7zx6opHX3PArTqx2cEuLjncTCyisIkuFFvOMyF3/+7JzLYZd9QLVTIopbKpxvFuRyoTJ8OKUZQffWn7BT3vH7pb+NIQ2O62fPNbD/nJn7t9thL5qWcr73iDEnSCVWbTCrENXcXdi6K5S0Fi6KE9HlAi2HnK3H6EizGKp9RV9kXbC3/aK+j76NoFYJEoRukJYuDwGMMV22Leid2fKhFxW1we2E6VQGEXA6KFOAw0ArvqxYrg3XPtQrGp+eTHEH9OzUVVgcCs3aMe948tUHte90KgmMf5LsQFfZKS+8q7tsFSAjNqUKIFNArSiuNG+4Sjmh8oYp9WSF8zzdZT1MQPD0NwIR2tUbv/PppRJaGqDpQJgdxcQBjCgKoSzL3cB2lgizGL99faXM9hJqzHBZMJY22u3+hUuzkmD10qhbA/uFBIQBVnug+S/BDUjGqNyQLLqSJ58M/qXJhDItnMcUlkjWysMZixLcZCKy/dn0itcu94w19//zEfv+BM+dbXLfiGdz3MrZDYBaPFzJrW41hhVZQxCVt1+2Bq7qjItZFpDl5KAYsLpslIqwMoE60pLQ/oNDFG584HiZR5S7PICNxrlaCRIRR2ItgOnn3h5IHP0JseXzNkD5yxubIYFq7zwel5+xucXJg4Xl6XBf33Rsf+QLPu3bf1am+9szGRTkrzfafuoypj7JKo2PPDg4NBDEK3GO139DlFag+FaH1EGJuHU5gJJGNtsMpQSL4rBmRIBGDZKjOBliPaCsdt4toq0Uz5/Y/f4D2PHvBLn97xvR++zc8d1Qce5/u3jfc/cwKccCO9wh+/PnDl0RWPrHdcvzFyACyHRIpQaFgRbm8aV7IwTYUhwC5G2rZwbwtzmynbwnP3lA/fe5WjU+PO/IVJQq4vhFUeGAncev2Sf+cTR/wfr7ht7/+6XXnvp4947xPXmE92jIcDOiqtid/8tMe9te6J7/tiungvhH0iX8+s6YvksL+59ddy6B7y0A9yQ9+10wWEqQvQCoJo84hcM0wDu7lB8yKyTYJsT1Hz0Jxr5tjWuTn0xa1EynJQF2LFxBKhiquuI42JQO6CNjPI0bGd+936LIaYMYhPAYJ5x23BDxSzROeYm79XTIQcArsGiGIWaMEnLcncapf816T2yVENwmCKxeSWMHXVe8MIypm/vLaGhkRQZ7erCaFOtDSACRmltup/IGROqvn3dm/8HlCjGJM4F6H1Q4sq3RFQaDGBCjVBaEoJyVkKCsvUOKl+8EqiVPPI1RAC01yZg+A5owXVyNwUVBlQ7hallcYnXjrm+bmQEX7g6VM+NJ13v3/w1oJvfedNVqVyb+3i1cNonFgk58hBEopEtmakVsgxIlSn3SmkGDhpxiIHdzdgnM6FMWaG6HS8EEdam8li7JrrDcSUo2pMpzuaFixltqczd+bKD98+/2z90YPM6193QGjKeDhyOOTzqOP+PSE8WMYvS/plQf89W9jpkae+Y3+wuO8zTczkbDy3lzaKSC/Cbm1CIO7H9iLn5Dp1trKe2eXc56vqcZgQyH0iEH2Z71CcYUSaIk05lsTNlbPA782NcLimyshXrBb8vjce8MFPHfP+Txzx/Z/1Md7F6041/vorE7wyXZhWCO88jDy+Hlg15eYIGiNHs7FKwqYoOzU+tlWePi799/z/dj1xOHJDGrdbYSOBP/yuG/zdf/Ayx/1nft+H7vLorZEnriyYDcLcyBmaq7QozUjRxWfp7EbWd+Hdc224GnxPtjP1/em+qEUR77xTt76pubBOIqpOvjPzPIBS/QA3dcX10Vw9JKNsuX1S+ORxZVmMWw+tSOtADYn1Wjg6nVgvM00Ea8YqhbP3jJjQ+u46Kb2Ldpa6qVsI1TzXWzASbkOjv5+0Cy/V+16KuT0sN0PFztTdjoNtSFG0++sjhjWIqaF9Z75qiqVIK57VrcWgVaoKGjoYSHCanBmlKSklNECQjFbzPbE1wjAQmh96RAIVT1ozU6ZZfX8fg4+WcZwtIlinAhZJfrjKgaYwkihATZFsnlw4tIqlyFT9YF0C7HqErKix1spM4z6REbe+TbvC6f2JfHTClEdyqfyND97j6dPzw+9XHmb+/Jc+TDiIlDA4oTB4LvnhytPRisJAocbAHCKquJJdIeVAbMJKlDvVWEdPXcxNOc2JRZndlmeVXR6oQLPKMiZOp4qV5g2DCseiHFjjHz2/4dP1XHX/DW+7yqFGSoqOBE5OVBzDeZDSxYTKy2p+WdB/zxf2/Rd2IaPdB7hnM3e3BNk+wOTCoYALaWdngSj95CxylpG9PwmYSces7iEu56P/Yr2z6RzWlJzcdRWYY6SWmVuSmTGOthAOhFTg3U9c4b0PH/CtJvzMp474+V+5w/992vi16rCZ8YGjygc+p7P/rb6iwLvedIUdcPOhQ442jSCRP/WGNX8r9MxHAAAgAElEQVT1WR8rfuCo8MFn7nLjPY8hs+8/GSNTU5Y9DKV1xbrne/veO+yfy+C+XlN1IdgeGdhH9VGEqe9a9YKKvzu4qH2n3DpMRs3YNpBihNZDX+7s+O6fe4kf/Ozmgcf3b752xbd91aOUUolJ+n47MgUhqJIGoTRI/Q3VuupOm+sqpI8c5v7eia1iMVGsoeYWqJNmBNEzEmLqWd+BQDUlEildE2CtnRW81IWgpkYRsKLkIdPmRovOWg8pYK1CjKSOp9Wmbl2rSl4GpLYzYV0lMhfPRBjbTA2J0BX1QwhUE3IEmhfCMah33ihDBU2JYXBO/XauTHlECR7hqi4eHAfFCqTaKKqsYkbFDzFjCDSt1KbkYtTorpO7CgsglYI2ZbNTXr27YR0DRylix4X/8xfv8PR8XijfPES+7X2PkAdXjM91wnRkp3Dr+oJWK5oHbK7+2UdZDJnjKkjInEw7bAwsaNQQWTRjgYOaWoyMrfjnu8JGC4dN2eXImkaoys4ad3cVYvCJSW28OlV+6sJ77MsWkcdfd4U8ej7DMjhBaMh+CMqfB/V6Wc8vC/rldWHPvt/vwvk+6rzw2xlmdv99ATp05HN+yK86OchZh3+2ubcHi2zuxDK18xGB9CIWgjAGB98EIiLBIzJTQkKjHHgIyTetAu978w3+/anwyvPHfOL+ln/w/I4PbSu/FcbJJ8bIH7yRuHVzxZ3jxnd/6ujX/N6//KUP8fj1BWIwlAZjIqH8obfe4B89vz0bfX7fx0/56nfsqGnNNghpu+P6OKKpP/YeM6rqu3THlPoY1rttFzGGswfoe4/YO9kYvPMN6rYrj/70UIugrqRW8660qiLVYSFT8wS3/+pHn+PD068GAf3ACxs+8sPP8d98zSM88po1d1riUJVlCjSUVF38NkXfu6bmvuQIBAXd/w7WDx4pMaj72K26X3nsJ8lkzu234tjipg1rzjcOBlNf/SyGQCz+PExVySki0U+hokoOnuGdo1Fs/5wCFkhVGRLMRSAm5l3BotPjdhaQWlkGD4nZSmIlTrGTKMzN7WihGjtxV4ERKSi5Qu2v5enOg0iWq5HtrnhOu3oQT1Fh01wsl4qzBEptLIKnzQWMbfCs8ZiF1BqosdHIaY+yffFoR9s1pqaciLLbwHd84DYfvVDM3zpG/uuvfBhbJRaiRFVWy4EhBIYYmIqyDpFaGykpRSJjjNimshoTad5xJUfuT42UGzsfXXBcG4tZqRlWOTCpsRiUxoJZjQkhWOL+PLGdjNmqayGqEnaFj9wpfObCGfub3n6Lh66MXBszMbmjJkQPvUni05oksU8DL6v5ZUG/vH79zr3/y1kd7OrePQL9c0/F9qs+U/arf2Iv7nbxVNA7fegscHN8STMhqdIkMAahiPudJ+UsQjWrMOTI6W7iIC/YBeP6DC8fDNy4uuCLy45v+LIlup345Csn6Lbw4tw4ujvz4my8ejzzKXUyWO1o3DevEg8NwnqZeMuhoENmucws12uuy8QyB27XyjqPvO5K5Ls+fJcXL9S7dy4T/+G7b/K2p24yZAe4zCKE0lisFpgGvu6tB3zol5zQ9Xwz/sbP3+bPvi9T78GtGwMnc2MZE7L3l4uQzP3xgu9vVZ0lkKzbEWsjRE+HE8cDknA1tvbXTjtNUHExnHRxpBAorXnEZwrYaUGK8dd/+jOft5jvr6e3le/9wKv8yVXm+lqoh0umqbFcRErwE9oi9LCbbo1TItEKJtGhNL3I59poBhYSIUCrjZSSo1J7BnoxmFpzv7N4+FAIENQV8dZ6UpoZuSv9BYi1UVOiaGCRjG2tfc+d3FUQlRYCCfOhd8pMLbEQB9dkUyqwCcJChEELswUkRUe+DoE6FSYRhuC8/GqVhlPolkUhQRwj0gKtmovxZmPMHnVsSRibj+qPY0CnmcOc2eETj21/TgTPX9/2eFqRytFOuPvqMXcMrqv7vZ+7O/PDH7jDR6fzk+w7kvCffPUj2NUlV4NAEnQIHIRESn0q1uAeymFMECJ1OxEGJQwgohxbcitrmahkFsEoszKLcZIzLfmYvcaB43ki1YkiiZSFrTa2U2Vnjro1K6DGp7fC3/74uRjuXcvE2584YEsiirIYlyQJDCl07YivLORz9umX12VBv7x+k6P5B8b0v8aoSy4U6c//x+WBA4PsG0uxXnCgx6MhPYd8iAELbh2aY4ZWGUzYzcZyteCkNA4PFpwU40b1DgkLyAz3hpEvv7Vgqo3WfNC/pvDytmISuTfPXF8IJ1NimWBhym45IGbMRblJ4HSp5LKk1sAj0QgV3vGWW3z7G69yejJzZ1d54uaS9UHmkUVkyIEdgkXICleysFGPvHz7G67zJz6z4wdv+27/hz51zL/2+JIrtxZ89nTk+sopdbMIK0uetBVDTyxzSpz0Z1jx4A0Lwn67EYKDTkonqNEV08R41qV7zGc9i4c1VebJ7VebkHj5/gk/9MLmN3x//K2XJv7Q8cyVFLnXTrm2HjlQfLydk/8O0S1gsQmFSowRazCbsUIpIgwpUbSRmhIFaogOyMEPdbPAGI1thZA8llVbY5ECRUJ/LtyrLQolwLDn8cdEFohZmFpjETNzbUSr1OJ+cW0NDZ6oZrOSUGqMZ8K4ZPQkOOlce095y9HdAZITsitg7hkfDHJIbHsnX9UYrJJVmEOkVGVw87RHw+7f70HJIbFJifsIy1aoalRLVGAdIpvaaFbZ7JSNKfPJzLHBtQjNhKdf3vKdT98/4zYAfMki8Oe+/FGuX12SgrEYBgzXSAQxVibsWmMdEtuUYSrI4OJLtdjDYJQoDdOISmTdlCMEGzLWKodUTlUou0rIgRoDuwJBGqm6h/9oMoIWUmxMAY42W555dealC+FPf+BNV7m+jKyWMAzOuI8huU7HXAPyIETmsqhfFvTL67e0m5dfr9P/An6GdU884oCOPY7WPa9+RKjq0ZPLJG4PEiGmgFb1QBOMQ1EWSZgJLCUzseVwsWSzmxiXI7vSoAo7hWXMXFsErpclQwhcKRPjcqCasp69OLAQUooczhNlCOzGgFohLxLSYJyNerDiMWmMGDVAyhly4roIW/UObqtGmYwrofHwcsE3vf06P/hTL549D9/5gVf59q9/giEX32nPxiK5NUp7txn7IaoqnjLWs98JF1caegZOCSl6UlyPSq21IQm3j2lz0psYk3XyW/Sff43Kx+7svuD3wcnRzPHVJYvSYHaff8oe0OLTFrc2hVYJKbqGQvpkoPvEC0buBbiZY0b9YCeI+a67NGPs8aLRw9jZqJxFtqbWSFEo4qlqMw4UimNCugpbMCZVYvQQkZYDtEZOgjVBqjp3wCKxHxprMuaQiCjFBFpx3GjMzNp8/C0QhkQrM0KixYyVmZQzcZGI6iTEEozcGqsxcbydPdZ1ruTo1LxIwrSxIECZ0ZRxYH8DhGkuzMV46WRHKJWTk8YrAQ4DvHpS+ecfucP/+uKDAUjvPsj8x1/7GCtpLHOEVhgXwmnNLBeRoDAln5hUKwwW2OTMMgjXx0ppjaPayObulaU47W8bXZ8wdIrhNkSyNtpyJM8VjZFh8DfVyVYxayxVOa2GkainR9xh4G8+e851+JqDzNe99QaLKNyIEYbIIkXHUUef5iDenZ9Z1S6r+WVBv7x++x0OHlTe7+X3cmZ3S6Hja3vHvkdwqgRIsLLGnFxpu8JvMvFgSTO4sszsTLi+8LQrGKjBqEVZa0FCYLVaUmtjTaStIMfgKVmtUZcLxpQI8w6rmTEYyxQZlktuz8oiDr7zJpLGgESH2SzH5OAVDcTBmI6FG1kYH7vGn33Thu/6mO/hP3Cs/IOP3+WP/L5b1Hkir0emooxZqMXjKksUQvU9ovX9scsbFJPeBdOjYztGVcx57goMKfZQGmEILo6b1VcCMQQ/ANTiUB35wkUHBpwqLLKwtcDQjGrKKBNhNbqFrBTmEEm9Ey0GQ1CqQSwV27Nq9l2XBFozoilVgnfR5mP8INaDanrWvSqhp55NBCJGC2DFWC5GTHtOOUIgEa2iISKtkX1OT6uu2ajJbZRanQ44Bxgt0mhuG5OZOo5sS2GhyqBKi8IsESszOY5EGsUUliNtUqIaFiGkgW3x4r1pyhCjZ47H6MFBwQV5AWhaiR2m08w1AWNTbm9mjnaFMhdOLTC1xmtWCz724jE//PRdfnbzYMzxt9yM/Ntf+TDLwcjDilUyGomcEktTsvrBL3Y2QIuOGh5MkWbc18oyDeQcyXVCUvZDjSpFMsvgegY38PVVR1XmGLDiNrWohlhj2lamGJjqRNju2DbhHz/zIOTmW952yJVlIBHYCazwVVvs7AXbw5A8M/E31TxcXpcF/fL6V9Dx74E2e7W99VN46CFyTe1MPR8FQpQODAmMUQhJmBSiJDalMZjSLLEkMItimsnNCVyDCbscHFOrynqMrsAWpRBYm1F71zSbcLhecjq3Lkrz3/cgGssY2Rksg/nvEszxuSn7lCEJB1VJy5GyqxwOgW95x01+5Nn7PK/+yL/z6fu8+8nrXImwyxVpkOJIy/7fh+qsbzAPO+lIVzUnqsmeQtaVCvRAkeCQd5oprSo5iNvV+k0YoDVDxIlwEpTX3Ry+4NdtG4RUdhSNtBSxCZY5ELJ3fxl/4fY2R1E3qaE9NS16E9oMQooUdRvdKLAL0ScftZzBj5pEsgizmuemmzBEnwRIra50q0YK0IqPzkcqOboaPi4GylQpEVQyVv33ERNar+wx+U5+HAJ1V4kpEoJx0iKjwMKMpg0JwrYoi0EIMWFa3eIWAkkbJJCqzJOhKXDVHD1MyASd/aBqQArMk2Li04YowlSaI4dbY1sad08Kr05QcmA1K2POnM6Fn/3oq3zfxze8UB4s5n/uqWt845uvsFpHqgxIcj7+uBw4qcIBrSefNWJyauNsxso8bz1YREOkmT/erUVCUWxQSJFlrZQ+gVGEFqPbH4NhszL1hL66mTjdNjRGklQkDtzdGc/f2fL3L1hKv/WRBW9+62sYByEuMlcWgXEcsIiLG/t6IPT9uVxW838l1yXL/fL6TRf2cwvdOZ957zkNcs4zP9ulGUj0KMUU9qEmji5NMRJTImZhDIExCSm6yCaNiXFMhBhYJE+fS0FI48ASkBz7ISExJmGInti1CkIOQkzRkZlRyMmFVavRg1ZSjuT+O0gXalU1lmPgpFUmWXBYJv5pv6ntFPRU+YrXLbmLYTGxotv5BN9LqvY8d/8n2P6w48Vy/5yw3413LoCJINqRsrFjWs3//6Tq6Vi1sQueSqc5o/8ve28eK1t23ed9aw/nnKq6de99Q7+eXjfZ7GazSYqkpVASZYmkRduSLTmyo9ix4QQQYFtRkASJoiQehCgGnERBPMC2EiAJ4tiwDDlBJkW0ZFuTbc3UFHFoqkmKpEj2/MY71HDO2XuvlT/2ufe9brZIjTZJ1QK6+/a79Wo4VXXWWWv91ve7ueX9J+Nnfb/2+sybLzosNLgm4sYMIkRvlDETGk9xoVbjqih+Mpypu+FqkNXOYTmu5ArXcUIaMjK9p+UuQaZOq3mButseqLv5wbs6YqCaoxSFkjO4enGRfJjAMUqoC3DnPvR4R+sdTicRn6+0hQLMgrCy+v6WktGpI2IugHdEB8NYRwrFqmVqPzn3oWAh4saREhyDE7x3k/VtZG2Fba6vMaix1VrVXyvQbxI3b204Kpl1EfymxxXQbc9JgR/80BHf/akNp3eVuUsn/PWvup+3PnoBQ9Blh9PCPTEiFOYiBClE7xiyo3GV/JjNKECSgDNftwYKjL6uzBXxIBAajw71Is0wRoS9ICwQNpbJgzKI1k7NdqAQ2EglH262Izc2iUEL/9UvHnPm23XohG9/22WuXJqzmDXsN45FDDgvNOIgTI6BUzfp7Hyw67jvEvouPp8Su7w0sSOcgyRkMmWAytQWpjnzlMREavswiEN8hZg4V2fPjXc0rq7cBFd9sL2vJ/UQqnuTD57o5Pw23rvJgxskVH/o6OrtY/B00dN6R4wV6dk6mRy13ORAVnf1S6nubkun3HsQ+ZVPnvLstFr0y8cDX76E+y8d0LlKErPp8WqhW/fQC/U5nYXzDis6rUxRd9oNTCZPdaut6uzcOf7XMXU61IgibHF4zTjvKQivOnR88FNrrr2s8nt5fGRT+NjzI7FtaF3mcOEZxy2lOJwIg1r1BC+pkgWDq8mdinctUlvxWcCVyjYPVESt95VCmK1ejBXn0GLnCn0vgjMlqVQoi68GJ1m1VuwoBEdOWi1YTZE8wY0C5OkYORRTJWXDiWMsFQRjpa7/qRqNZobJOCVOO/yUiogtWu1ZJt0c2aqVazSjiGG54KOnL4ZXg6SMzgilkF2d3aOliupy5mZf2N7eECyzLYrL1Xxmhcf6xAduZf72L1znveuX8hS+Ys/zn37pFa5emdE4mDeOZdvSQ93WaDxb55lJdSH0Ta3Aqy1rHRk1pkTv2KZUxzxDYm4wXYMwisOZMGA0KVPU0TvPap3qjNsUp9WVLhdlO6Ta/ciJW9uEEHn3L93gV7d3Nij+8zdd5NHHLmIiHHYts1jNg5oYCKF+d/1kxCJ3CeJ2yXyX0Hfx+Z7YJ0/3c4XrecU+ITed3HUFL3Wf3U1V6pT8feWjTu5ydcfbqGQ7maAsMnlWBxGqfbcjBkecvMbD2e+CxztH9NVQI5z9Mz0XNyV0J0zrVdVvfZWFOPTs7UV+9FPr89d7fDryxKWOGCM+BiK1bW1njlrU1bQgUu1QtfLKndSZeJiU1X5abTIz5K5ErjnX56S1IstZp+rXqtgsFTa5Ol09drnl0lh433F6yfvxJy9Hntrq+abDC9n4mRfWjGvl1Y1R2hkzF5DGYRg6Gn2M1Y7VlJkZRyrEM2awGI5aUdukj7CsOC2UKTmj1d+eUs5fU0lafQKcUlxAVAmmtTq36kOgAnmC54hUpb9Ihbo04kEr6Y2i1cP8bJMgV58Bn0utyL0jqNTHVSYrW5DocFNyjE7JGcJEQKy3UcZiJHW0KCrVha3PdY6kCbaqbPrM0XbkdD1UJ8DtlpVEtqmOmm5sE6c313zPk0f8X8+s2dw1e/YC3/bIgq/91y5xZekZQ0vX1bUyVWMveLJmzAmt1M2A0FaTmiZWEuMswFAg5JFWlV4c3eQcl9uG0QlDn5gF2GqiFFdHLGNCJ9mLdx6XlcF5cj9wYo4yZrbFyNuEucJ7nu75vufufN7/+JWWb/yKq7SNZ78L7DdCjI62CXShersFd1ad3+G272xS/xWdj3d+6Lv47Q57yQ/GXUA6mCrSOzc+23yX8xbfOdr27GcRZFJli8g5OOfs57MHs0mUV+ylO/hnJ9U6rr5TPZx1QrOBFGWbM6aw6UdOemM1jIRs/M8/9Sx/96PH54/0X7z5Im97/ALtsuFy65EQaIKw18TqxBWqD7r39UIiZ5vsUKc2r5OJAV/dqQJQJmSvTv7VTurOdi7VfrRPhpTCVgt5KPQCJ9tCGpWjmyuOtpnBC69bOq5r4NaNLd/71DE/tXqpqvrACX/2sQO+6vUXubAs9Llh0VXcbAyegDBv/SRuE8KkWPfT3j42sei9YLmQXGDhjZIndPB0gg9TlyEbqHgCNeFn8UTLRFdp6ioyOb5VI5qCUnDMfMW1JtWJPCacjpnO1zUtxCjqKFaBOVIKm1JBPt6MaFVXkUxwmmsXxlUVf8kZQuWyD+aYaSK7wJhSbelP7m+WjaMxMWzr3zdvDH2mRbm1NZJk8tY42fT89NOJ/+euRHgWv/9C5GvfvOTxew4ZcLSNo3O1up2HmvwCdQVzOW9YYyy9Y5ML6qrGw4tVrUkAp8KQC6FtyOttFXhO/gBlKLh5AAmQetomcmNT0JJpY8D1I7fN0RbjZOgJoeVovWXsM0LhYzcGvvP9J+ffmde3jm/7yos88uAF9pvI/szjF3MOnBJioGni+XfrzPPc7TzPdwl9F78bEvt52r0717/sdvay2t/Os/vduNuXrOTdldTl7sR+10PLXWQdedn91xmxVtFRMTRlTseCpsTpeuDWYFy7dcpf+KfP8qtTB/X+6PiLX30vj12Ys7/XcTCLqBMWsc76RepYIEg1IXEG6hwNkCYmulNFHSTV87kjZqirmFOZ8KijAkVrO7kUcsrkrNUPXo1ehdU4Yiq4bU8vgYVmUlZOcuanf+WEv/OxNS+ftj/ceL7p8QWve+QCV+aBuTj6ABICcwfqA12so49idf88Tl2UQhX9dc5PFyJKRmmnDXyb3PuGXHC+JnNzlW8uWcmxAl4CihNXVwGnajh5Yx9hpVUHUaSOHFSVkjIxVJa5unpxFNqWkhJJwZvgxcgmqKu2sNustN6TciZGzyYbe1I4KcJMCylGgiq9gPWZESWbYxwS0idumKezQu9qtyCr4gqs1ysGjXzg2VO+56NrVi87iz4chW987QW+6HWHLHOP7xo631RtSAw4r3TO0bgqEg2TccvYOKIFgleKbyj9itB0pEGZRc+2JNzUybDoGbLQYvhSyFlg5hgVbMwkqSMEp7Cd9unXWVkP1YlOzRhXiZsnPcl5vvNnr3Or3Hkh3/X2+3j4yoyHLuwxW7R0jRBDYBkhxIABjbszXhNxu1b7LqHv4ndLcpeXJfk7f2afdmPj03O7nFfsL/3Vp//fp93jXb+V8+djU8s7F60CpVyqpWc2ToZCv+45HTM3Mzz5yzf58z9/7fy+vvmhBX/6y66gi5YLXURiYK/1eCdEP630nbX1MVTcRE6rz8w5PwnPalJ3IpXZL5Nl6rRiZFDtLtUYslKGkYTQj5lSKm51XZR+NHIqbE3Yd4VBhVaV0yR88mTLD/ziDX70+NNFdG+Kjn/98X2+6LX7mMKlZcdQMq1rOGismnVaZtY20wpdwLuqaG6EuuaWDR8dndSVvWJVnW0IcXKa8wiD1eRsrnZFoq/QmHJmSpAUk2o1WzSTnCPi6VXZi8I6TTAeO1ujVETl/PiFyYY2xYjkMs3OYSEwUFcHfIiUrGS502qXlBnE2K5GvKt7dDkKfVZ0m2iiJ5mQNiODM66tMu/92DH/+4tDhQK9LL7hgZY/88ZLLGae07aldYXlvKGMMPMKTVf39l1dc/ShajgwiDqCbxiK4nMiNh7wFFdhOd48Ljh8GkHqsTdnBO/YmhCUyu9NmXGs+OGVOloPtzcZrwUvcNJXh7WjbWYYM9/5c9c5vkuP8a2PL/matz3APHgWXcv+PLAXXd2QcO68IvdezslwZ3vnu4S+S+i7+N1avb/kDz8dUvvZP8G/VnL/LI8/sevVmFCtVTylZuRi9ENhM2Y2o7LajGz7gb/1A5/kH901r/7v334fr73/kNgWmq5j2Tmi8xx0ofp5T372PjhkUmcHtYpUnWbqrav+306mObIZeVLE4wSX698bcqmVlyo6FrZqiCmjSd2Jx7CirKVafbYIx/2I4mgFNmr89MeP+aGnjvj5dXrFw/jvPLrkD9zbct9DF2BM2CzSF2M5a8AyzhybGNi32vKdM5HBMIYJ7tJ4qSrr4GgdrA0WoXqGR+9QEZwa4zR+UKmJvUxCNyfCVut/o0G2idqG4Z0wljPgTsUBb1CC8wxqtFqd6IrzzMVAK0a3lHqRlKZuTcl1F31THF4UUsXFBs2saJAyMmQh+sJ2MGyzZVDj2gaefOaUv//M9hU/U+86DHzdF13kkSsHXLbEeh7qmMI7QjZy27LQTBOFEiLz4BhVsSIgmTDx6dMATSOclmo+s56sXSV4xBmHKXFjUJYC25KRpsU7WGchmLLJhcMojOrJKFkNPyaOUyU+ljFxY2tsTtZsBuWvvveI23dV5t90dcY3fcWDxFCYX9jn8l4HOdMtGlrncN5VYee0dXLWat8l811C38UuXrGS/5dyQTHN79WqUK2oUUqhKAxa2GwzJ1lJ68TxrWN+6VbmL/+L584FT2/q4L/8mlexOJixDI5l64hdwzx4Qjizsa1Mc6SueonZNPOse9t+OglmrSQ5TzVlCZPNaRDDijFOCvys9QKkKIhmRjUyRk61RW/i0JRQEQZxlFJwmy1DiIxjZp0zP/exFT/70dv81OaVv/pvWUb+xKvnXH34kKUp7SISg4BrKtfcBAmGK0J0OrXn67qbqIFUl7VqHVuV7OTJ+9yE0Phqpyoes8wGx0KNfrqgcw7ayVkNU2gDMmTc5PjmpDq+mFYdQhOUNInTBlX8ZJCTx0KTRm4RCF7YDIkWx81sHIaKqpVs3O57QtvgxsLaG5KMXoSmKMNY+OiLW37s46f8zCq94vH6yv3IH3rdRV77wJzDeWBdzcqYN0YTO6IZSQqtiyycsa7knkrMyyOdCBLrpyWJEINhSSiaacTTO4emzHwSueEDEjz9ZgudZ1OEmQjiDDYZ9TA4T0mwKYkmK9ui9E446UcOx8RN4BPPDPx3T95+yWv5usOGb/maVxGj8tD+Hl0jNDHSRaFrYnUHxM5Fp24nhNsl9F3s4nPl4qG23Sffbz3zg1f6UUkTQ/1kTOTjgZvrxA++70X+xkfvmFX8mdcd8Mdfd5FuP9C2M9rW00VjGQIhVNCMOcH7CmEZp2zuqfvpiCObEbxHSyWPBRFyKUgM1exiEgJs0/T8pkq/oJga61Hx031uK+m02rcOiVM1ZmascxXVFVNubwv9NvGr10d+/EO3+KerV7ar9QJvP4y8/ZElly5Ers5nxJmw13jERdzQs/GeRQyYFxZGpaqZTUqpqtBehEBICTetGo5mZHU03s6ZYho9osqglQtPgiSGZaVrA4M5UkrMg8eZkFNCXZ2td+LYiCfnRHCCqmBOySpEMkcJwlhX09JYmfAlKzYZufRDpmsjOQ2AMBTHMy+u+NCLa9797MAtfeVT5B+82PAlD855wyMH7AWI5ljOIypGGMEvGsw7GDOz4LDo6IvReaPDoa1nHBJt26I50yCsXXXj895zaywceKFsE34WIdUOhOLGqJIAACAASURBVAVIQ/WCby1Vgl3wHBflEOO0wCplEoKkBAW2WShaCMOa546N/++5Df/gmZcihL/p6ox/4yse5HA+IzawXDjmsV6gNrEKPM9b7S8Rwe2q811C38UuPhfa/pMyXmFy4qotdzBKyqyTcbJNrDZbbvWFYd3z1//xs/xEX/d0O4Hv+qr7efDqgoN5hw+OZRD2Zy3ZjC7K+cqdE4+J3oG0MOFDvSNijDiiwGjgVHHeAdWu1PuKW82TN71aYSx2LvgbU8FPTH2Cw1QBwcZM1roCdpoLWwMbFecTxxtlHDLPXN/y7o8e889fHPhMW+3v2Av8nns7Hr644JFXzRkzXGqFm6NxYeGZ49mYVBc0qZasrS8EqYp1Sl0x897RWK7wlhiIkzK9V0GoqvZelbkK2U94X++r53YrJPWMeSC4yFAKc6AfEs4HohR6rZ0BdZHQb9hI5ERB00iHIFSanY4jKwq4hnK85kO98PHrG977zJqnxlc+EgH4I5c73vHaOYv7L3GVDaO1zDpHm4zcebwVrI20CF0IjDhaCl4huSrcC7HhZLslxIZ9Z6RcKXijVbOTUTKuL/iuI2Wd3lPoMLYGqpkFkZNpiO8sTSwE4fZE10t9ZiOCP17TNy23xzXbm8b/9uET3veyscuffXSfP/Hmy9zTgV4+wJfE5b0FrQcfPc20DirujBnhdsl8l9B3sYvPxaR+p0rPpa69FavV7zgqq6wMQ8/zJ5nx9oonb438Zz/+/Pl9fPl+5Nt/3yUOZ0uaRaRrI13raUNAxVjECmtxVBGRV8XF6i0uk7kLUK1U617YxNnWurdeqhe5WCHjKmwEpS93cLuu1NWqpFZbos4jRfHRM257TidvbK+ZdRZMK0L02rYQxsRGlHLq+D8/cotPXlvzcyf5Mx63y05424XIE/d23Ds37nvofi41Cd8bt2ctsu5ZtJHbGFdbzzAk9mYNxwVmZIIPVb+QEyKBvc5z0hdms8jKhG4Y0KbBQt1Bn6mSEMY04mPAlwzRk0slqvQ5E52CeRIFhyM6Y72tGwLeGcNYECtY09KmxK2jkQ+dZD74iSN+9LQwlF/7VNgG4dse3+eRKy2H+zPmbSBhzJumOrHlQmgaGhTfOFzO9NLQ+arPCBgeYyuG+YYuF8QgtA7GQvJC5wq9awmFSc1udObIDcgWTikcBMcwKqkUJARGVXABLDMWJWWPaGY1Kq31VfnuAx+6MfDUJ4/5nmde6tIXRfhv3nqBRx+5xKuWDW10uHnHgTNoPI1M5MboqumNnJEe2bXadwl9F7v4HK3Sp3W3rIaWamOqZgy5qst1SNzcjryw7hk3xrt/+ln+12fvnBy/402HvP7RC1xcNOzNA/ttpAmOuYPYxroE7wV1dfaITcr2CY1bJtGXlgLe4SZ4izqHaamKcKnzcz8918p8r5Q5Sm1xW6l+7GsTGhSnhqEMEnBjZjBDc1WWb4oxFiUK5NWINnV17Mam55NHA09eS7z36TVPrtOv61g+tog8sQg8vifcf2WPSxc67t8TVuqY54FVaWj3mpr8cqHYSFwsCGacloKYI6jh53VW2w8Zl5RZE1iNhXkUxqSEWNvqQYRTdbQl0QeHjYm1Gvuzltl2ZEthrS1+XHE7g21HbpwUfu7GyMeub/lw+WxnR/iTV+e85UrDI1cvMZ8LY2/kKMxypusisalGP/O2QccejycGR+8D0YzeQRgTjfP0KKN4Oh+IZGIIpFT3zAcvtNkgBpxlNgmCjRTxqESaUoE2Q9sQUiJqYSzC2AZ0zOTtSPKOsO3BC10xXhwcN4fCez51xA98asvJyy5YvnjZ8B+99R7ueWCPe9uAm0UOohGbliDGrA045ydwU6UfntHg3E7Vvkvou9jF53JSP6uUq0BOMYVkhmblNCvrVU/fZ64Pyu3rK/7SjzzNr6YJiyPwD//AVQ6XLXsLz7zx0DYsu0DnPNnVnd3galIXMZxV1boTh3PVta6Iw2lhZGrN4iqlzaade9NqMOOFMVdWui+KC2EyxpmqfYGUM05r+76vMFkc4EshZWWtblrwU4YMkka2KgwFbBiQAsdZuX5jzZPXE08/d8o/3uhv7AQDPNZ6fs/Fls4X7ruwx5Vg5A6u+BbZb3CNowwbmv0DfC40mpkZlBg4HZW9ztiMjjlVJDc2LXHTkyZjm3Vw7Clsi3G6KWyGkaNBOT5N3Fz3/Oxt5WPb/Ot6vl7gnRc73vnwgocuzTnYD5DqxRaN0sYGr4V505DVKN6xCI6tGVGVpmsqUlWVJnj8qBiF0QV0VIJkYmjQIMxLoccxb2A9gncTetZ7vMFGQIeRKJ510WpRWgoqnnHay3c41hhzJ6xSwjL0/Uh0jief2/A9Hznl45tPvyD75lfP+cY37NPee0DTzQgGB52wFxyxrWMQ56vmwSb8bJDacq/birtkvkvou9jF52pSv6tKV7Pz9jsGfSqUUhhH5VafuDYaRzeO+eVPHvGXf/Ho/D7+2KXAN73j1Vzwyv7hghSFfakuWosu0kpF3CJS17qotqTO6voXWufO3oyCw4vRqzGjmok0lT5TiXcISQAcYdqpbpyjnHnTa7VtTZOlqaV6EVBKnpTw1XErWKXT9cUR8sDKezbbkYUIx+IZ+hENgW6TcGnk2a2yTpkPPtfzwWtbfvYkkX4bjn8THF/cOl69CPimJrCrTWG7Eazz4D1lGNiLgUHhAwM80QkfP83cGJUPbzO/2VPZE63nLVca3nJlxuP3tXhp0aK0+w0+KMG3eDW2Y2LeRrLzXGmEPhc0ekJWkvd1R15hU6obX+MNS5nkm4qdVUdRZS8aVgQNlUgnxShdpBsypzEQqYr1thQ2uRBdZBAjlMQ21738FsFc4XQ90lkFAel4ypE1PPfihnc/eZv3bD/9eHz5MvLvfclFXnN1nyjQHCyITlm0TVXKN4Em1FVH81KfizDBY3YiuF1C38UuPh+T+lSlK5CLkXOhT4VVXzBVPnWypdkm/pefeJbvee6OWvg/ecOSdz5xmfsudGhxzBce8Z6DKDjnsWn4GKZZpL8bZ+tkUqrXujlOlbgr9Xe9VRZ8NmiskKXeX9BSLTKLkqUa3ORp/p6tPtZmzIiDlgqLQazuQOfKSKcUNlrvy5mQxkQx5ZhAmws3ihIMGhX6cUvnIytNlKJ84oUNp7czHzgd+eBx4qObzOfyWeX1rePNy8ijD8y5fNhx78Kz1zVYLswXgeOh7r4fLBqGVFAcBDjsAiVnvHkaX4VhWSCXQgihWr3GwMlmxDlPbIXNunDQFE77gsQWK4WCo/NWkbQ+kFUIKbNtm+n9gYUHLcpmSByr0YZIkzPbZGxFaKIn9z1jEW4n5aJXPvjRE37kmS3vWX96N+Le4PgPvuQe3vKaPQ6cY9Z6LhzMGXAsnDHvIirQxYqSbZyAGXGC3pxV5TKZN+yS+S6h72IXnx+tdwxTo1hdE2PaUR+TshoT62HkdJ04ut1z/fiE//jHbnMz63nL9ru++gGu3LPHYTD25x0SPIedOxcTdcFX8p2T8130YJlCwExBhMYJZQK36JjBVyOMotW73E3uclkNV6qNWJpOun7C9iQDTZniA7GKzPFWbzuMimKMUn3qcykMQJuqh3mvSi6ZmQjHY+XSqyk2jBXu0jaMKbEdCo0K6yAkAnFcsTpas6ZBR+WTpyMfv5n4+MnAJzeZm/prQIV+B+KyFx6IwmP7DW+4f0ZoGh5YOhZtYLnXcjoo7dzjzbNkxAePlYI1dV0w+0g3CdrmPrAtmb3GU5xHNJFdS8KQXJAgbLOBFjozjsfEzFWwjIlwrEoeqy1al0c0hqnidTjLxK7BqTCmgdMebBboTFFVFqasVTAcoRTWY6FvBBPHtRd73v/8Kf/kU2teeAVl/oETvvHRA/7oGw/xXcPF/Q4fhWDCXuvonKObBeL02Qyuuh9WdEIVwbmXOyruThW7hL6LXXy+VOlnjPcz2MyZCn6rSk6Fo9WGIpH1Sc/qZMMP/8oJ/+37bt5pay4C3/rOe7l0aZ+5F7pZgw+Oma+zyGYyBoleGLLR+Wr7qb46zVm2avBihmgBCThRtEw2ptOud3BQTKaLD6WZ/NSL1p100AqpkepuhlUcanSBtUGTMplJkCe+2rhibLSuiqlUimjJmSwOLUoxq7PjXKoNaRBMQVXZ5Eo28+pY50zICd92DOsRiTAU43id2WwTJ5tEz8CmRGw0enEsViNPlYEL1nA0Zp4dhWtZORSIYtw0mIuw76qhyaUusJh7mmzETlg2gTDzXNFCXgReO/dsFw2z5PDRWDeR5ZgYXSDEhkYyl/Yabq1zpdiZ0DolZyFFz6EzGi+k4Fk4YzSHlQp42RbFB8/NbMxMUSvMnJCSsC6ZtMq0y8gKI20VGQaKh2WoFwGNE0ZqRwRXqXfJjFCgNI6+aGX+j8pRLjQGrSsMSTlFuPmxY/7ZzcRP3Bo4fYUzeBT4+gdmfP0bL/H4Q4d0kikqdMsZjRpN9DTRs4jVqW7m6hiHyb8esYp4FdlhXXcJfRe7+AJovWtFj6pVTGlWY8yKpsztDGkcub0aSKnw/T/2LH/z6Tuq93/7wY4/9nsf5uFFJWu54Oi6luig7VrCWZWtSqHayEaBSHVeM6TS5SyTrbbRpSh4jzlIY6YJDlSrYYpzYHW1y2mp7X3qnnopRp6U9TJ5mUvKSAhscoXSOKsdgZJryz1LtRZFalcgoqTi2DqBISNSEIXgPGvNjL2RHNyDkcTzQsqQrYJVSk9THJ1ltmrE2DJKpqxGiJFbGTqvqDWkIeG9MSNxwxqWvnC0ytx/YcZQIOeEGzfsh46b6rl02DAen1LaBYqR1Jj1ymrPE7UwmLF0npnz1T2ugayO4JWxOC41YD4ijXBLhQMz5lFYq2PuAe9xpeB8mFrkxkjkUArXVGjOvACyscKxrz2rJBzluvM+aOGZa2PdcmgC918ILM1hbjKgEcgULnUtG1W6PrEWuBAd17KQ+sRsJrx4PHJ0c8v7ryf+ybWek/zK4sTXBuEbXt3yZa+9zMXLM5quRUxZxrqSZk1g5oRZrAx2J1KphtPY5wzlKmeV+WTIs0vmu4S+i118XrfeqxWrUkr9OauikzFKNUKB1WrDi7dWfHyj/L0ffJafv6vt+Rfecom3PnqRe/YDwVXCWoyu+kgLOB8QN5nOeE/AQLX6wYdAMSNOX8+s1VbUW52rm1Wjl+Jq9VRyIcRAzhUVF0QmYE6dhTIBa3xWUqhJKiCogyFTW/KqlFKV8MWMLA4pCe8dKSlqjpIT4NDo8GNiLXVMEE3IWiqu1ltVoJNwvXE8gOsC2vcci+NiDKxKwRvMvLDeVrOX4gTtMwHFdxGc59qQOKSAQmwDachIDNxMxgWfOFFofEuXRnIn+LHUvexkNIuOXjPLpIxe2BfjOuDFsSfKom0pYmhwjMlQH7jgEi4EYvREEwZVOjGyeHpx7JXEFqOJTQXFlFzNT9DJFc/YbrYMyfND77/B//SJ05foCf7whYZ3veGAS1dauiR0USipTO9xYmGRE+dp5h03bm/40LU1zz+74aePRp79DHvyX3HQ8IceO+BNjyzYbxtibNhzRusFP29onKdp6ppkDI7o6lgHV48H2Dksxp/NyXeV+S6h72IXXyhJ3ewu85Zppm4GqSjDmMlD5rQocUw8czry4esr/vwPP8/JhAptgf/xbRd51asuIs6zNw80sdpnRifMomc0qzah3lcLzVhJa0GgMK0MmXImc3KTG7xgVTEPVRSnk3ObD7TTcx2nlbjsIJb6qswJGzXaqvwjTxW4FyjZMDEEj6pWqlkxes1EHAPKwoQyXQSsUmYmxqjG3ISt1jHB2urKX5MytJAymHjcWAjLltPtSBRhux3Y80IyJTcNflNIktlrA7f6hLOW/aDcUkOGyii/D+OoCSiBNm1ZmTCMQjNrMDH2ihK6wJCV4EH7BE2g7wvLvVCpa64hkXAu0FoVoJ2qsJyoaGnM7M3nWCi0odqRtlKPSS9GFx3OHGMuuJw5TUoQY91XBgBF+Ns/9jQ/emt4xc/WAw6+/UsvcXnZcKqZWddxnBO3bg2UHt53Y+DDq4FfXn3mRfnXeuFrH2754icucnU5o4v1QjFEYba3x54UCAGxTNO1ROdonBFCwDs5/wx5qT875+rs/EzJDrtkvkvou9jFF1brvbqxTSYupTLeDVj3iWFIrIfCeps53RZ+8UPX+fb33jq/jzd2nm952708cmXGct7QGTTLDo8yCx58oPFGmpJ4V8+oteWPUBAiVexWzBDn6kxfFbO6mmbB4VNhNKNxdSUqCdWRTA3z1VZUtCrqixligpvEcOZcXWuTQnGOMFagTVKjaMZlJeFIZz7caqg3FqYcWcRKYlMgqCCW6cWzl3tKbBiTUjQRmpbtNrM1RUrhkhO2TihekeLIFmhNOR5G/KzjZDsy94VDy5yGBSUN3NN5Tm9tOV20RA30w8gyKhsfiWNCiqedKYNFMIcPwjoVZrEa37QWOc4993aetTS0eWQTW5ZNdbUrOdPEwKxxbEbDBBbeo4tIkELnWxqrTnE5V/c5K4ksILFhdTKwNeMn3vcif/PDJ5/xs/Xo3PP1D7Q8PQiS4R+9uCHpZz8V7wn8kfsbvvL1B7zpwSWiQlRP0wQ2bcO8NRqJtK1n7gXLBd8EnHO0YfosTf7lOiXvMFXkbleV7xL6Lnbxhd5613Pf9HqSrxW7klJhXWA7JHQYWW+V52/c5v/4hdv8g+fuWGy+Zdnwl951H/Ou42DmWc5DrbWdsB8dxQcaA7E8CZRqHW5OKMUIMiXiqX3upc46UaVXgSBIruI9EUeyOhoQK3hqBd5EGFNN5DgYijITz6CKek/QQj8JAVUh5UIoCXOerHA8Zva8x6xMowePSrVs9eYgjzgRTidCmlpl44+mZBfxWpDNiDSOtO1JTQdZaUncFmOvBLbBc7Qxsg2Ebc9pLwwJnk/GrBiu9bx4Y4PTCmH51FgpfrfN0VLfnxgEK8aVYLQCvm24MDMenHWExjFvC/ceLDkIcD0re53n3rnwKys47DyxGMvOEXyEMeO9Q1zGtx3ee6KrNMGM0HigGDfWA40JvfcM24G/+O5P8LHy23dafSQ6fv/VOW96YMFDDyy5xynJO/YOF2zXIxejMcaWto0sPYgpTRMqr37isOOqN73BORzmnPgmZ/+/Q7nuEvoudvG7oEo3u0OQ0ylJplIo2RhyZtMnxjFxOjpu3T7l7/z483zfjTst1z+4H/lz77yfvf2OuTfCbMZCE6Gb0Tij9Y7RDO/B+0p9Eyd0Z3Q4ExAFE8RDzpAAP/moB6ge41oV1DqtrPXeE6EmeFFcrtSzk6Q0VtggLKhteErBJge30TwhZ0yUbYImeDYIThMmju1gREsMPpCSEJ1xkjNJDV+ELg9TNwCOHXQFrm0zLkEcRl44HekRro/GyY2BDyjc2GZW8C9lh/3RILzhYsPjFyMX9hyvurhHsUKMLSqKhLpW1oiCE+Y+MIuChEAZMt4LI8o2GzFt8WHOkJXnjwa+5Z89+1t6bg974bErM778/pbH7j3ksBMutYq1LbiG2AgxBFpvNAhdFxAMTyH6QAxVANh6q+LIaZVRzkhvMq2lnSXzXVX+BRNhdwh2sYvPdMnLlEytzhqdq4hVlNY7sjNEwrkqvrNEu2j5U2+/n5s/+Aw/uanT7x8+SfT//Fn+9Jdd4cGlY995tjHgc2YAkgOJDmeC5kIXPZtkqFQKmdOCOke0mmDbKVk23lVYSa6KdC/CqFXghjl8VjbZaBqhL0IoWvfbx8JWwDSzxlM8rPvCrHEcnWxxbUfE2AvVqrRPBV+MlYPTVG1KTY0uKDeTko+2PN/DeLqlN+Vko9waMi+uMk+P8NxYPqfe1o9l42PXBrhWL7oeb9e8456Wt7wqcc/hki5ClwqlmyGS2DcjS4QYubDXcTBzlFTwMdDrIXnbI+LIVn7DJ+C3HkS+/MqMmc889up7eOgwEGKkLcq8bdhaxb7GALPOM+LoYqApCd8EDGi9A/HVl37qLnnnAKksdlylvU2f6Ze316c/3sWuQt/FLr7Aq/TpX3WePinAJ4vVrEoqxtBnejEsFU6PRoYATz9/wl/54Wd5sr9zkv+a/cgf/dJ7eM2Vhp4ZD7SuYj+dghpNDHRR0AJt9BSD7AqoR6aVNKiz9FSMxjsGATc9H1Wt++O54FU4ESFZNQjRCJorYEat4HHczsrcGT0ONyZASQSWqXDTO2xUTihcUsf7b65Jw5ZkDbeub7m5znxkU/h4XzjV3/nTiPfC413krZ1w8aLndA1JlI1v6LRwaCOnvsVp4dh7dCz4VPiplfJin3/dj/MNV2a863UXefT+OTMtaBvZax0jjr3gwHs6D/uzgIoAjtVqQLWw7kf+zX/4Kzw3fnbm/bd/0R7vfOgCn4qRZYA9L+x7RboO50qttIuwmDU0XcRSxpzDN4EZ1Q/dA95V170QQr3wpM7HnXNTNW4vnZFLTd9ydsG6+4rvEvoudvG7L6mfieMqcEattsArRa7Qj5m+GGkzcmMzkobEC0cjf+VfPMuH+jsn+Nd1gf/wLRd57OqCWfBIEMJeR1QjOlAnNC4gonRNRLVMa0RKb4GoSi7V/COb4bRM4Jvq1iaustw3JeNcU1XkRQkmjNuEOEfrjCOE5mTNUdPic2IRIsdFyUNh2w988lR58YVTPnWa+YV14Ub67T1VLL1wX+d5yzKyCI75zHFxFgmLlkv9CYsr++hswVwTsybSpRG/6EgZlo0nmrJCuNUnLkZh9J5NESRlZj4SfbVELSIstPDcAON6zZNHPae3lfc8v+ap7a9dUb9j6fhTb77I/Q8dEASWbcQ5z9I7Bgd73tG0lQa3BiQrx9vC//vzz/LX7gINvVK8YRn5r99xHwTYawNNiMw8lHlDFwNddDTFyE2gdXULoRHHAHQiNNFNZ3Ah1hIcpXZo3F3ltr9rXn5HuL6ryncJfRe72FXpL2W9W2WuW6lAlkErRa0fCus+cVqMmHp+/pkN3/2Tz/Ez6zvJQ4B/9/F9ft/j+1y4OCe4gHhBszJvPF6E1tfHFDFcCMiEgC0VVUPEuJGFy9EYhlq9FcCljAShzw4bqnnK6aqnmTdIdBytcyWbJVhvlWeONwyD8t6jxAeubfno8Ftvjz8chccOOu6dO5aN5/7DyMUQmC0DFxrolnNcGomdg77g9xsCDSOOZrOlhKrMjqWwVsG7Qmhr+/skew5FiY1nmxKjRFx0MIxEL7hUiI2xlpa4LYx5oDSg2tIKaErkUGAQPrEauHljzc98fMP33xpf8bX8udfs8fY33suyNe6PkRIgdBGsupzFeUPSghdhlRzb1Ya/9v2/yg/8Gmtr93nhO95xH4/ftySlxN6iBeBw3kD0LD0kCSxdITSR5BwCzJ2Qp9WyOPXVVaQ6wQn4aQviPHG/TOxWgQe7qnyX0Hexi10wFel37ahbxbFqnV+nogxaaWb9Srm5GRhM0aS8cHPF333PdX7o5ktP8l9zueMPP7LkofsWdHsNUQznI3vBsOhpckFdQFCKauVre8GS0YdAGXooSpJA8NBnQfJAmtbrYjPD68jKPCerkRePe7arzPXVwE88v+aXN7+5r38bHF8581w9iFw6jFy9uGSdeh7qGg73Ag9eWHDdCSEPVTFeMl1sWZK5mRVrOxDH4bAlzlt6EUiF0EU265G2c4ScKaFhHj2rbYK23k9wnplX1jnThUhJha16pIz0pQoW92aBIRUyYBLYo9ADrWU2BVBY+cAyGtdXyswGnjvNvPeXrvH3nh+rSPCueHwW+OYvucQTjxxgY2Fv1uARmih0QNs6Io6TDELh+qbwvb/wPH//Q8ds7zrFfu2lln/rDRd48Oohi1YITWQetPqoR6FrAiUEOu8qTVA4r8B9dUbBakMd76ZZ+d3Vt9xVkXOWvHeCt11C38UudvEZK3XVWq1nM2Rqw/e5mpvkcWQ7ZJI6bp5uyOa4vhn4qfe+yN/6yOmn3e/X3z/n6x9fcuVih286FijiwIeIkuscVIUiwl4UbhfHzCpbXkw58Q1t2rAZ4XDWcnqy5oUkvHA0cOu5U55dZX7k9Dc+635163liL/CaCw337wX2Ly85iMq9l2ZQPM4ypfGQFN/Csuto1wMaHWM7R9YrpG0JUXAeXBLMC40zNGUWs8hmUGIbQWq3I3jDtNrHqghJHAsrZBNUXO1QaKFY5c/7XCo73nksF4IIvdR9/d6ERbBKd8vCGKuqP+X6fvkmkHImUhBVrm0Gbt7Y8JMfOeW7P7VhuOtweRG+43UzHn3tvTRd4MG9COIxU2bzyJ5TVAIJJZuDfuSTt1bcuDmQnOeeTji82CIucnHmaZ0nk3HesYiBLkYkVPFa9I4gEHwFDflJyFamlH5mYyp3JWq5q90u7MAwu4S+i13s4tef1M+q9GmuntVwaiQMHQtjzpwWIfUjWTO3s+f0aMtHnrvNX33PTV7IL/3qCfDOw4Z3XV1w9eqSh/eVm6Mnhsh+4+lLQiQSysjtpEQE5z0380jTG8+fDDx/c+CZ1cDP3kg8/esQZp1FEHis87zxyoLXX/Jc2O941V5L54yDwzknZaQLLU1w9EMhthHvjVaMRYFNgOgckhUfPdlVYM609o4LDjdkctMwx8gOJNfqs4iCc8S6XAdqiHc451DN1HsQMnaOuU2T7/swKq5kBgNRIzpjVcCrUMSYC6gzVDw6bQJ0ocrGugyrWUBGxZWCxYbj0w1JhJkoTz19zN94zw2eusuOVIB//3X7/N4nDpgF4XLXoSHQeiE2wl4TyAhBlZU5imVKcbQlcyyOmJTZzCMizACiY1Ezd63Kg6+MdX9mWXqmWK98//N1M2MSuk1d9N18fBe7hL6LXfxWkvq0n34ukquuY4JRFIop/TaxVSGnQlJhvd1wag65dcr3fuiY/+Gp41e8/1bg7YctV5cNr7nc0lmBdMJGhgAAIABJREFUmWcB3CiO9WrDMAhP3er5+Eb5aP8bm3tfCo6vvnfGvZdmvHGRuXx5CftLFmT2neBcIViLRWiaCP2A6xp8U7nncwfOEmOo1pvZHHNvlU7nhIii4nDUZBoFUEVjmC4gpK5VCaClWstOQBznqpdJQPAestb9eitVt9CboCmzLUpwQr8dORnrHn0K0Jin5II64aBx+CKoGEOprm1DG9iLng7DNNH7SPTg1EFKnI6J1NeLjpPTE37o5475rqfXLzl+3/r6A77uiw6w0NE6JXQNDUJoHXOpbH6vNWGf9JnoHGPKtF0kW4UGHQZHEGHeeNQ7GifnFDfv78Kw3p2w76K+nM/G7xqM75L4LqHvEvoudvGbSep3Wa2eVetZJ+FcgWRajTcExj6z2W4ZzZEHZROF4/XAtWe3/N9P3eT7nt/+jj7Xb7gy46F7Wp649P+z92axsmXnfd/vW2vtvWs40516YHdTZDdJSSRFkTI1ixYVRklsKnaShyDOQ5QEiR8sBDaQhygJnFCBYSQSAgMOoMQvRhw4DqI4SiIZsCwbkkVZEiWRlDiqSTabZLPnO5+hau+91vq+PKxdVedcdje7bYqkzPUD+p57655dp06d2/u/vun/zbh2uePBZeCO7zgwLatWvXDYwaCOWVZyE+jEkzrH0ozkHCGAaknzeikFXB/Kas/RNQSUPIl4Jw51ZRd4mPbDmDO8gTlHM8mQbcaptgelshxGbVMtLu5mqsXuVnOZqzeDFBOrlMljBlV+54nb/Prjd/j/rvckhR84avkLbzvibY8e0XpXOr5bz5hgr/MsvZAl0ErGdx6NiqWET8oL0VAV1n3kbMz85h/d4uc+cbFz/We+64h3PHrIrJvhXenEb0LD1YMWXCkZnOVyQOlEOE3K0oOYQRPoXGloC8HRCATvJkF3OLfLCWzS6sLuFzkXglcRr1RBr1S+ZqLOlHov4o6VbWMGZbWmGillFEg5E3Pk5qkRxsR1E1yOfP7pFZ/4zE3+yY2Bx19DqvyleNey4dsvN3z/gx2XD5bc1zn8vIWl0HiP18BBK6zJDCkyX8xZisMLSAiQFeeEbBnnG2ZeMTxNKN7vnfjSkT852zkTQvCTCANOCGYkY2tmspl9dmzGqyaRl51QidnkY78TLM06ZUFgzEXQh6iMY+QsCxYjKWb+9m8/x//8+O2XfD9+4FrLf/HDj7A/L41nCVjOOg5nDu88M19q0845IJNwnI6J3I80Cmem9NH43cdv8NO/e4PzN8z/4Qfv59uuzri8v8B5ZRECvhEeOpqRs5FDwE975rNC8OXrBO9xGN6XskmQ4rHup/WlcE8afafvVcQrVdArlT82UZ+UfbPAxWzTMFc2oGlWkgkpKykm1qoQlfWgrNNAwhNTZtUnxvXA03cSH3uh56nnTvijlfLFlxgjE4HHZp53HgT29lu+/bBj1igPXF7CpT2WOXO5K5vCfBO4Lwi3VOmcxwdX1pWacdg2qCWabkZjigZHM3mVd54SmftS1zYpyz1sMisxK6YmKr64j5nivCtCbaX+6zfLYDCQ4lG/jdilpItFZBLzadPrNgotC2o0K1GNmLWMByZFVbnbGyknfvVTN/gvP/jsK/6M/sobFvwr77zKcjknekfbKpddwDrPXgiI87R+er0yHcTMWA1Gv+oZcJwdr/jw5+7yX//hLlJ/cxB+5ofu4/DaHouZx7UdRx3MZg17M49Qom2ZDiqNKxkKP60p3Qi4d3LByU1eYsasinilCnql8nWL1Ke5dNstcNk0zKkCFFe5BByvEt4JGnvW2ROHkU6MG9FwUbmD4CIcNcJnTkYOnefGcc/RTMjiuHQ0Z26Gt8RdExZBkcbR4XHS4OcOtxrxTYcnFpvYLpAdzEKLk4wzj7dM23rEebKDFkEcJUr3HrHiKQ+7pR5sI0gjm9BONW83RdxmRfDFTbZkVta4Mgm0k3MnIdnG41MDnWybDpFSO09m5Kz0GTRl+jiSR+MkCash8p/8b5/kU8NXz2r8L3/6GpcuH3C5M8bguS84JHjCsmVPBDpP64oPejlxKGlUCI5nVhk9G8lx5Jd+/3n+5hO7bWr/2qWG//y9D7MOLddmmdC1OOe4etCxaBv8lKII04x4WfhSxLvYCU9WrPeIt1URr7xGqpd7pfK1OBkLGKXluOyWFhBfGudyxnsBcyhGI+D3GsaoDK7jkhnHoQOFoy6TT3s6B3LQYs5429zTxMz9R3uMarQx4RrB+cB+59jLpT48JGMxdyyl4dRgfikQTEkywyel7QRzDQHDQldS4eZpXGlFLytapw1cTrb7sYupbJGYQHFe28hOM41TuWnX+jZhLtN7IaC48pwIdq5evq0Hy71RBmxCVZ265BXDm2FM42s5kw2eu3n6qsQc4PeePOXHOseLsmQRI0/PZ1xrjMWQOBU4ElgHxyJMguod5hxuTBw1oAeeG2cNf/rthzx9PPKLL/YA/OrtyLs+c5cff+shK+lo1HEoSsyKTc1tNjW8+c1HkXPliJduaKtiXqkReqXyjYzUp182jnJmO0c51MgYZsWnc51KKl01IwpnuUT1lsvGtFXM5GzEnAmzAFnwKaEhQBygbVgE6AeYzQKGYBYR39BO0a74shc8bbrGgxByxgVPRghTunsjtM6VsgHYFFVTxPoe61An57aiye5Qg10UaNmEmvco1C6h/hKydS6C39jsZlXGpIxZWQ8jYzTimPnkkzf4d//hq99uFgT+g2uB73nrNQ6PWh7uGvaXQrdY0kwHkrYLU5e5m8x6lJgzJ2slj5FgmU+/cMZ//A+fZkjlMPFtjeOv/vgjvO4gcLhsaZ2jE+P+a/t0IWyNYZpN49tm61lV7UqN0CuVb9ITMlOjl22HhfFMaXhXGsigzEbPG09SxflAxjhMxqiOrErrHLnx5Gzsi5GzYF6RrqPPxrxbbMVyuSd0XlAEb47sHJ0UccrT+tRuchULQG4apqC8JLidTKn1qXPdTaLtZKqFyy7Nfq6sa+eF/Pz3fkHleVnBlouf+ZWHowvpZ9mWM2Zty9lqXfbJHyxe088nGfztFxO/eP05fvJtRxy8+QjvWzQYiYifd5AS+65FJGO5dOT70KDdwNq39H3PQ5f3+Ol3XOZnPnoDgC9F5Y8+d5PL7zjkYAyc+ozr5pyuEm4/lFE+P0Xi7vySlErla4f/wAc+8IH6NlQqX1tR3zZ2TZHtZjRLzsmYY3dzhzK+FBw03oMInXcEYNZ4uiB0XZmXnrUeJ0bjS0f1snGI8zQOXCgfJXi8h8YJwcu0lWuzccumdHoRmDCthb2YDp42dcm9+7M3iz7O/bf5rqY/c26rl1y4jgsjWMIrp5XPl9rVShf8oLBKgDhyNmYBPv/0KU+epdf0M+qB332x5+b1FW86aosN66yjTbG40YlHVPFNIKmV1x2VFsGcI+WB+4/mPPWFm3xpsoD/6O2R9z96Ce1afOPxKZMQjhZNORRNM+YX37OaWq9UQa9UvvmFXS4KO5zbQ70ResDETanXIqZu6n4O3hMm9zB1xYQkBCE4oXWethFa5whTJ7p3ntaVQ0JwIOLwpSOr1LlFMFeuF9nVczfivhVv2dV2Lwj4uQPKeUV+KaH+WrFtMpzKFs4MycqgCe+gp+E7jlp+47O3OX2F4uF/+91H/JuPHtH3A19a7WruT64zX3jmlNdd6thrlEHLIpwgpW6PE+ahFAcGNcRBNMEs4xPEpfDBL60AyMCeGW+5OmdphjbGvGnAw7zxk/Pbbo0pcs5zvVL5GuDqW1Cp/PELO7IT801zlHeC847GSfnPbxrSyliTbOaUpWzXaoMQKJ/rvRAmwd4I8yYcdr5c38guMvdboT/3tTeiLtNO7XMRudyzdvPlous/bjESNq/TYQhBDIJjERyNlTWxb7nm+es//jCPdF95O7vmhZ9++yHveuMe3/W6Of/Ze17P//iD13ij373yj/bKf/+bz/PM8yNJM8S+1CJdWY0bY8kIdL70IkQxxHn61vOe+/Z5x2G3fa7/4/Mn3B4ymhMWMwash+JFIECa1u6abU4r9f+Pytfw/5faFFepfH3YjmMxDbjZ7n5+fpa9OKNpiajNyFOafmu8IqUjzb2EHejW29t26fHz40+ytRizrzAskW/S98ymVbU5l+U3Y1IUY1wNjDiOk3G8SozrkY994RZPPnfK4AJvv+x53SNHvL71DM44M89CBsbB8cTpyN/7vRv8zu1++7Xe3Dr+8vse5IceWLKaL7gkRjuf0foyY++dkVUYhshosIpGPB35x59+kf/mI7vZ9L/6jkv8wJuvEJaBwybQtZ6HL80JraeZ7F7FbbIxNe1e+dpRU+6Vytfr9HwuWhc5X3dmGw0ju/S429z4L0TTxUrUy8b3+1yd3n3ltZvI2l1Im7905P3N+p7Z5Dij00FITAkIOo2EZc3seyGhPHBpxtvfcMTbHt7jofv3mQeYzTtyKKtSswQue8fewYx3XfW0J5FPnJb6+61svPhiz7uudZgJbXBoimUcz3laKRMDUR0xJzQbY07s7c/4w8/f5ea0bGfWZ77/sT18NtqZZ+bKvPus9aVBcttXwYWff6XyL0pNuVcq3whh57yYynYW2U83en+POO/q3XJBzMvjbJd6XGhcY9e4dqHmzZ8sAXHTgWQz9tUGjzponRC80Rk4lPuWLVf2GlzjeHCvZRY8D+zNCK1jNvMs24b75i2ybLm813B0/2X+/R95mD/34Gz7tT58HPm/P3mbJgg3VOgtI2aoZkY1UkosnTFzDb51EBoOgvD+Rw+2z/GrdyOP30iYV1ZDZGVwY13MfTaHE2xnRlTT7pUq6JXKv0RR+0aEOdcBLReidc79+Vy9G7nQ0CZysXHt613z/mN7n84dYhChE1dsZsUTukA36/DB0YSGK8sWaRsWy5au8+wHx1EXWCxamtYz7xpmCZYtLOeBn3rP63nfcjfB+3e+eMbHHr/JySqR18ZxzmTNiCYaHNF5JEDrPLPGaNrA977x8MLrfe7GGToKQ1LWOrnfZd16/k8eRNSCZ6UKeqXyrRC5n+si50J3ubxih7mce75/ad6b6fssUboU8XawaAOLtmGvgb02sJg3LINnr3XMgzBrA82iZdEF2iYw7zx7XWC28Cxbz2LZcGXp+YkffGBrcQvwv378JnF1inlB+4yoYwTWQFajnVbGMir7piznnvddarfX/+ZTp/RO8CaEfoXPSh9zEfMpOj8v5lXXK1XQK5VvAZGHl460v9XqrruegtLZ74MnOGHeOEIbcMGx9LDsPG0XOJo3tMGx8I42OOaNMJu1xYbXBzrn8N5jwfGWqzP+2lt2afM/7JV/9PgJx3fXNNEYYsbUETCCZVwQZj7T7XcMbaDd83zfI3vb63/vOHJrLAtYTp0nmnE25m35I5tt3HGnDQCVShX0SqXyLSXqbHsHyqifo/FlHems8QTvaZrAPJTHF42nazytl+LW5mA5Cyy6wFxgb1Ya1Q5F+Z633ce/fsnvouwvHnOajDtkHLlY+OayYlYUgm9xCF3n2DPPI5cvutbdefGYaEZnRlCj19KxL1YmDDYb3SqVKuiVSuVbM2txTtSDB+enZjnv6NrJVW/6PZOgzxpPCMWoxwRmwdHNZ/gsdI2HwwUHC+Pdb9pF6Z/vM3fWiUE8vZU1rr24MhJohpdMY7AUTy+exx7c49Fmlzf5xHNroimajX4YkJxJpkQrK3U304abmfQq7ZUq6JVK5VtW1J04wmSYE7yjcSUy96E8PvPFRS94hw++HAKmiYA2CE3roe04aBw2W/LWawvCuVrGF794hzCO9BFccBAjiOG8B+/wXlirMUNZOeWdB7vmul9/YU0+M9YxQgisx0gccykd+KloYrZZHlt/qJUq6JVKpQr7+TE+P9nh+nMrS70I4dx0gPMOQZgHYdkWX/zToeeRK4e89/Kuue0zdzMhZWZpZEhK9g0ZR8q6dQpqvJAkcc0J3/mGS9trn1onbowDeyHQOk/IkKbtbDrZ2bLZ/16pVEGvVCqVl14Cc97KdmPms5nvZ7NzfbLHdSI8tGzQeMZ3X9vVwn/lRs+tfmTsAk1S3Lgu62yDQzKYD0SBPXGIh/ubi6/r6VtrXhiNcUiMWVklZciG226YN8xqW1ylCnqlUqm8OrHfGN3KZjVsabALHsz5YseaPbFpubzY3RZPsnE7e3IfEVG8C7RmDDkTGmHmYd97ZnsLRhd4+KHlhbWoaW3M1yuGNCBBGFLC5UxWmaL06ROrr3ulCnqlUqm8alXfrixFN172xW1uMBgbTzvruDbrLlx6epw4GZUsnmhK8p7Ge9QEpHTFJyc0Emhaz5863KXsH3++R5YLej8np8wqFetXmKxsrWp5pQp6pVKpvHaMku6eVsQG5wgqzCyjOdLgWdwzfrY+HVAPx2PEtQ2WFSxjZDTnMk+uI3sy0Ijw1tnutvrJs8TtwfCmjHjmIoxZQa1sdMMu+AlUYa9UQa9UKpWvEqDv1pqVjXUmxmgg3kETCEGwsefSfsN951zjns7C2GcWZqQ+IgI5Gc4FtPE4yYDnBM9SjQdfv7+99rN9JoxrToYBZ1o63a2sZS09cVJ2vZtVg5lKFfRKpVJ5FYH5hRWy4sqDzZT6blxZjJNDYHH3hEvdTtD7m2dc0szKN2Qtq20bLwRnZSe7C7ROWDSefj7nSusvfO3TOyNHbUNjhgsNljI4QbfD55tNeJVKFfRKpVJ5FRE626UoGHh2++LVQ+Mccw965YDXL3bt6uOodJ3gTMGBek9OxpCLCK+BfRPMN8xMeWh28WvfHjPD0JOCA1GGmNgk1+3ckcMuPlCpVEGvVCqVl1V1O/dbKQ1qrQiajHXOxeQ1Z15/sGts++Rp4oyGMcMqw0yV0UGHYhhzjF7gMCji4cpRd6HT/fYqY92M45TRUelFwITNFPq9i1oqlSrolUql8krY+cU2Jc0dTDGBJjR0PtB1Dstwdbm7NX5slXh2tSakyH0BIkKQgJnRSKnBS9twOwExsXAN7z/YRfhPn0V0GPG94lTxORVfeAPV3XqWKuqVKuiVSqXyWqL0qTnODEwcQlmYsggezYI2sL/cja6pwbE6bpjnxWQMKZNRchZS2UYPObNUw4cADdx3sLv+iesDd8aItQ0jQkqgmlFgE8p/K27Pq1RBr1QqlX8hPRc5p+ti07IVZTQhiLDfBi7ni9cdZM9ByszNSpTtwIXyXMmMIIZ4QVTJXYsnbq/9gxH2zNE4LTvXTREDy4qbInNlVz6vgXqlCnqlUql8FTXfiuWU31YT8A5zjiaUXee9KXJ00Vzm+u0ztFFWBNQ5UlTMpHTICygOFaNZNsQx8cbLu864MSu3VyPOt6QxEvGYGc47kCLmmxdWR9cqVdArlUrlNd35Sg3dSRH3BtAE6svjlxYXBT0e9+TkcXkgZxCUbIbXUkefOSM7T1ToJNAcLC9c3wbhbFwTnMNy5iwbKWeSXozJ5cKpo1Kpgl6pVCovH6YDYuXmZ0y71VGs8TAYCxyHPl30ZF80rNNIGzyIMmbBYThvRBN6hJkZh0nJSXnTwcUtLY9fH+nUkcxIllEFEbfbiU5pdbdN516lUgW9UqlUXl7Kz5vLbNzcnRniAxITtB4wQtfxSLcziHn2LBERTqMyquLaAFlRSlNdcEYTHNpAXgbGxUVVHs4idwYl4WhM0DEiZmjKk5e77Exga4ReqYJeqVQqr46NrYsgJOeIKeG8x3zGnGfdCm89Z/j29I2R5BziAkjDOkaib+hjJgmkJGjOnKhnrkJngf2wE/WzMdJppjXlbhTWKZE1Y95vDxVsneOqpleqoFcqlcpXj9SnFvfywfACTRNwHhweb4o7XXNwLm2exsShwVwzDYk5ApYI3jNz0HhPEwKz1oEkXOP4ntnuRPB8D1/OwmiZZWMM2eEk4E3LGlUubl2rWfdKFfRKpVJ5VTe+kuC2ydFFpUTJHUYrnoNZw/0Hu071D50pp1m5mcGiEkxpxdGiqDqcU1SMLmVCihx5z9sv7QT9N2+OXMuJ0RwaDTSTzMhW9rLr1HUvU3xeI/RKFfRKpVJ5xfC8fDCRqZBuOHEEoPGOKJ7gFOc8Vxc7Qb4dM5qMJiUkNPRWDGeSONQZpgIOkgvsLRcMrac7t6TlJGZGD6bCII4+g0sJVUMn9VarqfZKFfRKpVJ57ZjhRco6VBOiwYEkUiv4hUO8P/+prLOiFllhqBmqSsqGM0G80DrPzAtigjPHQw/Pt9ePBsPK6BpDc6ZBWU8r4GQTnU92sHVJS6UKeqVSqbyWQF2ETEl3O4zO4JSAmMPUsXfP3XG4e8bct2ifMBzihIbi/taYYgbBQ58jC4s81C0uXP/i7WNUM2LFy70fE6Jsl7Ns969VMa9UQa9UKpXXIOpT1t2VX1h7RwMsPCycsTi82Jp2Z60c55F5N42bZcW7cigw52D6/UHb0Xnl/msd/tww+yduZ4bBCAbehByNYYrSDcjVArZSBb1SqVRec3x+4fcBozUjSuYsg2bh/vuvIOcE+fHbkRmB9VpJ4ogC0cBbBgRvRhBh7QXvW/qc+Ylru075Z+9EzhzcxTGqcqYZL0raboG7Jzqvil6pgl6pVCqvTs7dtHUtiRC80IaGpUAO4IdT3r5/bnRtlcjDwJCNnCJjBlRQ3CTqhnPQesdKPLNmxpUH9rfXf/D2QL8a6Ej0UixgYxZQLY51Wx2fBtjq7FqlCnqlUqm8sphvAm8BTMBtbFgNXBtwCjJf8u37YXvtJ08jUT2XnGE+0GColHZ3FQcihAAzDLVIY8qb7nGM6+8oY18+Z4jKekyYlSa7zLQffeqgrxF6pQp6pVKpvCpxL0V0sTKDrgiNSBlB845myLx1byfoz51FBo2sTDDLRDOyAmKYOJyBmacHLs0a9hfCY2+4xDnDOR5/8YxoCUEhO8YxlVdixV9epu1rNTivVEGvVCqVVxumY5iV1LY4EBOCM1zOOMtcXgT27tttTXs2Gs8NsJ4OAD5nDCVpqcG7xiFZ2XdlvnxU4UoQfmy5u83+3vWBtleGaIzeuDsOjGqTyYxOkblNRjPVYKZSBb1SqVRebYwOIqgJzinSNgytJ3dzTlOkbS7eIsNZz6zxuASDCU6FIELKhqrgWs+gngQw87hGeOejl7bX//btgRdj5lShUZghDEkRLfvVYbuqvYp5pQp6pVKpvCo5FxAnJSUuFIOYpHgf2BclOM/9y/mFa564G3n6dE1GaB1kzWxc2EUVNNO0nk4crTpIwkNH7YXnuHE8soiRIWfGVDavpWlrW956u8s0n16j9EoV9EqlUnnF2Ny2Umxl25l3ODOanAlRmbWBcBh4uN3dJs+ikcyxcrDOGZ1uos4LFhxZAl4cjRitQNM2PHD/nEfPbV775DM9d1aZlQkrM86GiJqSVc4NoZ+T8arolSrolUql8lJivrv5uY2oC3hAvUO94ILQYBxY5p2Xzy1pebbnQK1sWssCzhETCA5Uy6IV8fjWIW1g32Ve33n+7P278bdfevaMuyoMY8KGzK2TRM5KzGlrKZut1PetinmlCnqlUqm8NPdqpKc0xJlBI9CqEkMgSsPcPN9xaRddf/bugOQ1qTeijqSoRFFk8nBtgyAacaFhFM/gPKdN4C1v3NXR7xrEG2eEfmSwjPeO43UkigMFEdn6ujNlEKquV6qgVyqVystE6GVqTRBXZtCdKw9KE1ABWmhmwrc9cHl77R017px4siZQYUZmNCEnEOdJaoS2xTnhSIzDxvFAB1ev7vHYudT9P/jiGVGLI50nMY4jXsvsWjYlG5PP/O4UUkW9UgW9UqlUXkbVt2NrUlaqikDrBZ/LClUvMA964dInbh2zinCcHIM6Qk4kMdQSqoqq0goEwILjBMdDV2b8+MPd9jl+5WbPrVsrhmzc6jP9KjGqEZOClQgdLbF5WdxSFb1SBb1SqVReRtOleLVPq85Ep853M9pFw1wzwTc8ct8eB2F3q3x+pcwaw4VSgR9jGTtrcAQfiu6KkINHgFlKdKx5xxt2aXcDPv7iCSFm1gnOYub2nRUpKQnZ7kY3nWblq5hXqqBXKpXKywbo0x+KsIsH854sgk+ZNngGisD+uft2jXG/8KU1YsJJHxnNCI0jaumaRzNhMocxV8biZoslg804OprzvbPdV/4HX4zczJnGC0EgxsRaDYuRPJnLqBnKZgtbbZKrVEGvVCqVV7wJihSR90BwDkIgYniUy0vhO16/c4y7sYp86k7PvoM+JYahLFdRBIfhguCmtawz72la4bBruLzs+Avv2tXjn0rKJ794TD8op6kI+unJGX0yJGs5dOgk4hea5CqVKuiVSqXCPcH5Ts2nzLZ3ZYxt6R1HTYtGxxsOwoXrnn1m4G7KBFdm0PMYyWqYC5AVcY6ZK8X5uQhN45m1xne+4QrvPrfB7e9/9pib2TEOmfEsssoeS5neIE1z7qq6qQpsa+lV1CtV0CuVSuVeUWdnNCOmODU6gDaAF+YeHlo0XPW7dPkzd3vCADd64WZWkvc4NdS07GSV8nxtG0jOoSS8eFzO/NtvOdg+zxeHzJc+9xwxeO66gKpy83REgIwrr23jGDe5yFkN0ytV0CuVSuUeJT93I/ROiru7K0LaaCLHxBiE40uHfP/VnQ3sR549Ze0ie5po1ZOzcmaKw/BmaFIEwVtmLwjz0HI4Dywvdbzjzdd4V7e79f6dz54xHh/Tq3H7uOc4Gv2YWCdlyEY0iNmKmE+GM1XTK1XQK5VK5Z7IXKY/CCV97gDvSx3dnDCXwL4N/ODDu8a4zwzGjduRUY1l7tkjQ5atD7s4AVfq8SqOgDEoHLgWC8aff/d92+d6Lhv/7I9OmaWBxjKnOXH7NJLGSMTK9jWhLIApBu819V6pgl6pVCovre6bYfRSP1cRQjb25gETY4bw8MOLC5c8/uwZx8nok3A8ZkQzSQUVh8cIIhiCQ2lmgav9AgtEAAAgAElEQVRzD6pc7Rp+5NEj3nmulv7zXzrjMzeV08FgNXDjuKdXIasQVbGsIMVoZtsBX0W9UgW9UqlULoTpmw/gBOfKGFluBOccofMEMx5o5/zIpZ05zIefOePsbORkHRmDp89G0lLrRgQFsmWCc3TOoT6wWLbMZo6Zc/xX33ftwkv5+5+4wSjKkBSXEy/cOGPsE2nMpSEuW5lLn+bUOTejXkW9UgW9UqlUTZ+K6SKUJaYGXiCYkMUzd46ma2HmeO8juzr6P70TuZMUIaMxoyhjTNMYnKA5F6MZ73AC3WROE1TJObH/4CH/6Rv2ts/3oTsDv/6Ju4gKQ4Z02nPrdM2QMjkbgypZjZwzqtN8ul0U9SrsVdArlUrlW1vUNzV0bNqY5hDnaLzDW0SCo8F49HUHF6579ovH3M4eL46zXFLiw1gWtYgrG9i8led0GE0XmHWBq0d7zFPkz3zXFfbOrVb9W1845unrPTdWCXXGC8cDZxlOYhHxbFZq6bqJ1neiXk1nKlXQK5XKt3B0fu4XEXCCpxjMOC9gGe87gjj8vOOxZeBHlruZ9F988oRmjKxSxA8jKSuKkhX8VEOHksZvgkOYOuElc3kZOGyE/+7du9S7GfzdD7/A3WFkiJGm9dy9eYb2kTGWSN3MEIxkVmbfJ1Fn0zBXU/BV0CuVSuVbV9ht4y0DTlABZ9CFQMyZWRdo00DTwfc+drS97pPrxMfvDEg01q5FBMaoZFWwsh8dQE0IwH4TaNsOaTzz5Yyjq0u++9FD/q3X7VL5vzMov/yHN1mlwOlxhBz59N2RVTSGMZYUvIJNKfiUS+RemuV2c+pV1KugVyqVyrdelD79urGB9ZQUuTjjYNYwiDCfdaRuxrtfv1cc5iaeeOI2zyRPTiN31wkRYTAhq0132BI1iwgOYe7gYNbgvSd7x/5C+Pd+4HW8++jcNrbrA//Xx67TD4ln18qejbxw+4xVVFJWhjExZiOXDS6Ysk3B2/m6eq2t/3Mxue1u/fSzlTKHqn1TlziqoFcqlUoJzHGT6JY96QLiUIQjlIOmATMe2u/4ift3I2x/75me05OedBYJCKejIiliJmgGo6xlNVWygO8CWR0hOOZtS+haHj6c81PvfYTFua1uv/DUKb/1B8+xjol1DzoqX755Shwz63FkSIplI+tGeCDlkh3YjLbZuW65KuqvQsgN8iTcWbVkP7Kh2UjT+5q0lDo2Yv/NJOxV0CuVSo3Sd8X0XTndFUMYHxzSBhLKwaxhPvO853W7aHqtxu8/fp0RsH7AAc8PSpzCPHEOFcE7Nz230LYOHzxBjLU5ZgEe2m/5uR9+4EL0/z890/N7T56w7nuyJs6i8fTNM/o+k2Mm5siQlWRFcDa+72yiyGm0zaj19VcTjW8i8aRGzCUbElNmzEXcY1LyNJ6YNsK/PTx94/Ef+MAHPlB/pJVKpbKVd0QgqeEQ0lRd7yeTlzFDe7jgy08d8+UhA3DrOPGexw5o2sA6eA5FySLMwuTH7qSI+jSfHihNd4IyF4dvHKI9913a42ESv/F8v301v/tizyMIh8sOcZ6zbJwNmYX3hDagGH7rY1teq4mUNPz2nLI7rFzwvJV7Vsl+C4j3vQ9s1tLmKfJOBjoJeNLSfGgKqhBTaWqM58oZcu55Zfq3UwW9UqlUvrE6fvHGb6BOcKaMZjgF5yHGyJ6HZcz86nMrAG5n401+5I1XFyxJtI0niCOJMGscToQGiFrSos4ZzkoHfBaHZWNIjmxwZdnwcDB+64WdqP/2jZ6H08Aj1zrMHF1ORC94ARUrhwMTkJKCd1Km65WSEUBtEm/ZfX/n/sxu4dyfeIG/V2RfSsU3D5kxpdenkUCFGDMpWzEKipmk5XOzKXny/kMMNSm9CpOCO/nGi3oV9EqlUjkXYZ3XAJ3+4BAyEHPmWAOtg9E5Pv7FY27l8tnDifFDb9hnGVoG8TjNeO/KOlZXRH3TcGfiUKBxQvAOMaV1jl6Nedvx2F7gSif8zvPr7Wv70O1Eezzw8OUZsfWQ4Hg1oArzptjKRsA7h2UthxEEM8WmbXI2qdiFjW3C+VD+wuHmm03kv0KsX/EvLn6fds9/m/p3Vt32H4wxkQz6MaIm2+kBohLNyLk8Fs3ImslZcSLYdIDaCLmIfEPesyrolUqlcl60prT07sZf7tQOiAnEGbHvaRpYOM9vPnsGwLNJeWfjuHx1zhpjvysi2zhopMyim5SGu4AhMkV4VtLwijBzxihGkMyb7t/nsWD85vNrpiCRj58krr+w5k2HLfNguEZIY+ZsULwYwTlMZdNcX1677fr41YyvyLObbD7lK3T9K1IX8pV/83KC/1oOAl9xtni5T5ie1b7yL3bNaTJF3hvxNpsONDa9H9PPdZNSz0aflDxttetjJqfM2ZhLD8IYwXs0ZgYrZRdJEXWC4MEUUQNxTP9UirB/A0S9CnqlUqncI+YXHprCvFJTTzg1RgnEBA8sHL/2ubucalGTj98aeO9bjjgK4HJmxONDYK/1ZCc0spEk2d70caVhzryQsjELjiQO5x2XFw1vWXo++Nya6Uvw5VH59DMrFiLsdw4NHSEIz948YRY82jhajExZ5LJRSTPb5oXzZivcJlI99+2fPwTYywq5vPz791XV+dVIO5MzwMXw+6Wa+raeOtPfbDbemSmqnDPe2bnqRS0jf0m1rKZVZZ3KhICOmT5n4qicKoxqpBRZqaDDwMK50qNgHsxwImSxbQZGxO0mJb7Oil4FvVKpVF4iSt+K1qZbXcpSlGTQG3Qa6aNxkDO/db3Uu8/UuNpHHntwHw2BWetR8ahmZsERpvBtF72WxjsoUbyIEgQaceA8nSTmrfF9l/e49eKKZ1IRrTtqfOh6T3saeWDhcY2wbBpeXCXW68iYAO8QMywpSQwTV76PKVL1UkTNKKeMbJsIfpej3hjV7B6WC3PtFz6+XLj+VUL182K8S4nbdp5+04Fuuvv6m3S5bmfvS3d/tt3PK6lO31updye1bV+BlVk/RlU0KX0y0pg4HcvEwGpUYkroMLIadIrUM2MIkDMMxtgKqzGzCI5ogjhXVu8KZckPU/9CFfRKpVL5Rqv6Lo277YSebtiNGOsIrcCDV5Y88fRdnu5LYvzDt0feeXXJlT0P4uksgRiddzCl3Z2Bc9PWNAHnHWZGK6W+Lk6KYYz3NN2CS3vwA49eIt5e8Uenafv6PnWa+MQzZ9w/Ju4/aujF4TPokDhJiewdHkfMIGLkXF6jqeKmwwlSxA4xRBwipXmveNbY9gCi52bbhYumNRvhLFpaSglq5xR+K8DnRXlnhrNLj7PNRGxS43n7+1LPtmnmXu28kQ5kkymxXjrWHaBafPVNy7rZpCCqZGCMmTEpZ9nIUTnNIDEx9onjdWQYjWfvRn7j8Rv8zuO3+cgzp6zPRq51HttrEBM6K02JjQnZQSuCOkegTDZ8vRvkxKxa+lcqlcr5gHIjIMUZrDROZS2dzkNU+qScrEfiqNy4dZNnnu/5j37jxjZi/dErHX/pvQ9wZd5yqQGZdex1HfNlw17wpTHOTSlaM5IJnYesMGZjyJmcYb0eGEWwMfPcmFnfWvORT13nZz97TH/PnfvH9wLvf8dlHrqyYD5rWOfEzAsHi47FrOVgEWg7EPUE75h5YTSjcULrXenaFqN1jkw5AMgUvTsnk4iXRTNyLlLfVimmju/z5ia6aRbbHIvs4rlJpyqAGmhp0i9ZhakOvjkSOIFo4A2yCJ6SXZDNiN50ElAT3OYFqDIgNKql7i0lgs5qDLkcTmLKrFOmHzM5lWh9lUu0/gdfOuZnf/86t/PFN/owOP7GD97P93/nJaRrSN6z9I5F6+i8IzSexnu8L6UU93UU9BqhVyqVyr0BuuwsYTeCkif7VjGjUUOdx8VIbhecuIb9s54/vBsB+NI6cyVl3nptSd92ZWTNjKUDHzw2iZKZgHd4KWKuUiLLMnZm+MYRUsY1pctr6YTXvf6Ad9434/rNNc/2un3dT47Kr3z5jPWtNSEo865jWCvzkLk9KKena04GLeI8jCTnaBBQZVRjnAQ0TZGvKycZdPp9Ca5LGj9vxNkmBzybYmOFPAnYJv29qVunTQrfNo5su6g8U7zzN+l33RwYspGleOGzyRBsZ8ONbEqM5eAVpwOXAjEWV76UlKTGKpfSw+mQGLKx7hNjP4I5TsdMjCMpjZwOMIyZTz6/4qd/+/mvODQBDGr80lOnfN+B5zA4mnlDM29xuYwP+rCZaCiHi69n2r0KeqVSqbyUqE+qvkktu030LkICRoPkHY1mFgjXrjZ84sljbk4R3Udvjbx9H64eCt48nUGfFemaIpZT9FYi4cmARhweQ8XRCNu6bDZX+tRCIKjjMGTe9+bLPCCOp26sOD4nPJ9dZX7t6RXhds9BJwxN4GjouRszq3Um9pERIydDiJwmX6LirKwRdBjxFCEerdSnk5a0eM5K3ITPptuUvWDkKZpXpIiuFlm26bHN/vatix1sBVqYbGs3aXzV8nyaJ0e2ydjFDFLJkAhCPybU2NbCV2IMa2VNhrGMoa3w9EPiuE+MOdFnh6ly2kdWY2TMyounEU1wHDNnQ+RvfPC57Tjiy/HczYEf/s5DFvM5OgzQBPa8lCyBL1kYN/VMfL0kvQp6pVKpvIyqb4R9m2JWK7VRM4IUR7GYjZUDHwceOZzzq1862T7F9duJtz14wDx4xDM11SmLJmwtZk182fYmIGrY1FCVneCdkLMSnBCcMHNAyrhZw4HA6+5b8N43HHDfGPnY3bHUmyc+vUr8k2dXfO7LZ/SqiHiCG8m+JY7KC0PibJ25nRRiwk8Rb/aeYcz0OFxMpVs+G0NKqAgpJsYpR66qDEoReYopiwgMYyzd5Ag2WdKWSD2TUjkP9FlJKWOTA1ukWKv20/D/EDMpK6tkjNNjOWaGmIhmrMc4ObhlxlFZ5R49y/QKsyFxIrBej9wdEkM0lq3ndFDuDiMkYT1G7mblzmok9crxkLl9c+ALL6z4pefWX/WfxzOj8v7HDrkyBy+BRePAO9rG46T4AYhIEfWv1z/ZWkOvVCqVl2aTEjazYgc6/X5Qg1g2nq1T4vgscRKN0ztn/D8fuc7fevJ4+xw/ennGX/7TD9HMHdcWLa717LeeS3stXhziHK2Xqau+pNyzCFkV70pkmlUZxrIcJI6Js5RpVDECd1OkPx34/I1TPv7kKX/zcycvOS0mAu89bPmhx/Z54LDhMHiia7h/AWcjzGbGGBquBQjzOcsugHfMGAmuAVO8bwAjNQ6JStsIUSF4TyegGDEq7VQXb7wwUhbdeIQYR0Q85hzeMiscbU6M4mgDDL3RBCmHmqRYyrjguKMZScbMJttV3zIOZ8wkcCYejYnoHNiIRiWIkqRjjxFR5SQGNCsjkesE7GTg+NkznhmM4+OR3zmJfOw0EvNrk8P/8/2v59FHr3Loja5rmGE0XUMbHE1wpYbuvn4RehX0SqVSeSVR3wi6bbZslVptSkrOykqNflDWxwORNTfuGH/9H32JDx7H7XP8h2884P1/6hLXFguGpFzea9mfe/ZmHfNG8FKiO8GKnatzuKnuXG7UEDWDFkvSVVJajJMhc7YaQIShX9H4wOdvKZ964kV+7vHTssL1Zfizh4HXX5nxwP1zLi8CRwEWLmBB0BCI68gyKCE0LBcNzWwOZC7Pinj3bQfjiM+GzBtWKeFcQ5NHVDzeQ3SOTqfu+jaQhkjnHRYz6gNLS4whsI5TwT0rKxUWzuga4bYKCzVSVswJfsyM8wZNmUXsWSUh+pIhSAhxMOaW0WXL9RsDp/2KkxPj+mnkC8+f8MTa+Ohp/JptSPvf/8zDfM8bL0MXmHUNC++YhTLN0DWe4KQKeqVSqXxTCTq7eeisU2OWGlGVFJXT9YhY5sXTSK/K5798wl/7p8/xhbhrWvupR+f82FuvcXk/kGczLrUN87mwP5uxaB1eimNb4yYntCm9XzzDtSx2US2bv6ykt2NMDAZrdUhO3M2CnvR0+YznhxmPP32bD3/mDv/vcXrF73Eh8D2HDd91peHoYM7leeDKAbTZ4cSIYUYTPL4/hcU+XhJLlzgJHXs5sbdcQuzRxRzvgKQ0bUvMmaPGs04Jcw3eC11KDAluC1x1JUoPMeHagFPjOAsujXTB02vg5pi40mVO1hHXzIm379A2nnx8xjN0XD8eSD3cGI27Jz1PDcqnbo/c1D9eabuvcfzyT34nXefZa4Sum7Fwgu88TfC0voh5TblXKpXKN2WUXj7mjXFJLj7gp4MyRmUdE6cnA2lIfPL5E/7Srz9X3No2ov62S7zvO46Yt4EWY+9gzrVZILQN88YTwrSHnalDmt2ct0zd3ynG0phnAuNIFsGycZYVnzLHIrh14uysJ4bA6dnIk8/e5QvP9fzyM2ueGPVVfc+dE96757m03/HgQUvnlfsOZjAPeEk8kD1f1Mg1gMWCvXRK75dkyewNA2fzOfuWGZqG3I808w5zEE8ji6AoHWMwSAm36lmHGSuEVmB9tyc3gXTnjOeiMWa4lRQblU+vlE+vyvrYrwXfNfO85VLHQ51j/4ElXVSev7vm5584fcXrfvaH7+N973iApYP9vRnmhFnwzILDOyFMH6UKeqVSqXwTCfr0i53bmZ0nQ5OkSlQj9onVMHI9OaRfc7vPfPTzp3zgQ8+W3egTf/HbFvzoux9g5uFwPmOvUR64coCb6sxd43FSvMEbKYYoIjJ9/dIxHkQZ09RUp8aYlcEgpYwYrNY9LZ7nsrKP4/bQE83Rn4489eIxN4+Vf/blE37t1vjP/Z44ER6cBb59bjw0C5wOSrNwXF50+HVkdL7YqjplL3huYewPiaYThuS42Sf60LCfIs8P8JGzkVX845GjAw/v2Wt4bN+zXAb2loHF0QGPtJF4sCjjZ0npByM5JarwSx96hr/7wku/P3/lOw/5yfd8G7NW8IuWhZRxxC442uAJzhEcOOeqsUylUql8U0bp51LvOi32AIjTpi5Nyq1RWa9HYr8ipoYPPnmTD3zo+rYeDvAX37DHv/quqxy1gdB55ggHRx1t17B0QmgcwYdSf51m31WLiUowQwXUlEyxc/XAmJWYilnKaILTVBrIFMaYyqhan4jSMMYBVeXpU+PWc3d5+vlTfvuO8tHTeCGj8CeJIy+8rnHcfxB40/0HPHQAR+Z49KjDGuHS1ZaTk5FLB/us+xV7vuWkaZglZT1mDmfCahhYu46FZY4TPP7UXf7xZ+7wB3cjIvBvXGn50bdf4l1vvo/ZvGEvZ4bgmJOZL+Z472kbIUzb9b6e9fMq6JVKpfJao/SNDayWpR4boR6Tlrp2SvR94vY6IWNiXEd+4Yljfv6j14nnnu/PX+v4d77nKpcv77E3C6gq9+8HmnnLYQhENWZtwAulfu6K+UpWxYAgbjsr7i0TTdBk9JZpkLI9DCGMiVOMDoGkDFq6wBXPnSFzlozRCdpH8nrNiyeZJ+8M9CeJp+6sefxu4nNjJn8DlcIJPOSEa8vAm/da9vccDy8bgvf/f3v38iPZedZx/Pu8l3OqurvcPRfbYZIQWyYySBEoSrwiLMgGJKIswyZCYoWyyV/ACrFinb0F/AFZIEWwIAIRKUSQEAmkEIiSGHBsJ77MTF+q6pz3wuI9p7rmYudie2Yc/z7SzGh6qmqqq2f6V8973vd5eHLVE3pYHB9w1Hes0obsA3k7Miwj14MjmSc6I9eRkqFfdiwCXJxnjqwwhsCYMr1znFVYjoWtVVKqbJ2xyYXDanQnC/xYuHLg2wpKqfhF4DBUqo/0DsJUobfr5w/2dVKgi4j8nKFemPqD19YvPJW2Cz7l0mZ3DImSM69sBtYXUIcN//HiOV/8x5fYv4L9iVXgDz95nd+4uqCPkeArq9WS40XAe8PFyMpP599DaBvOcFQqY576lGPtPDeAGTlnDAe5HeWqBUYHPe1M+zolvPO40o6AnedCoLDYZl4cjZWrjK7wWoLl2YZxmrV+e73m1unAj09bG9wxG+frzAubLauLyg9y4dWx8srYxpFCa0Zjez8K0HVGNMcTveOpaNB5bnjjWu+47T1PHQc2NXKwMK4EMMs8frKiP/IsQmDYFqIN9CGwKZ5tCJwMA4fLgAfOKvTBE/PIOgSOMEYKyy5yGB03sxEodLXiA4yjYd5IBSiJkivrlPExcGjGa2MiVqAYy4VnufCsqydY5Sg4FvNu9tAaBbXl9ladP2gKdBGRXzDUS6mthWnJrZNahZIq2zGxzoXtNnExtAYpr50nvve/t/nTr7/Mrb3d7x9wxueefYznnjmm7yIueJ5YVK6uDjmMjurB9z0dBfOOnGvbbDWNAM3jyGAeTxsXihnBYKyF4GObqlbatLIQHFYTCaPmwja3IS3bXMgu4kisx0SsHjcOnNJ6lJ+tM8kFFiWRq2eTBrbecZK2+OzYeGM42zIue6KDRXEMi8D27AJzgdMKni39CNevL7l1M9F7Y3SZcYTjDgYX2Vqmc0sWXSJvjXNvXCHgLLeGNzXxpPMMVum7wM31llUfSdlYBvDRMRaIwQMQXBs4U4ZE8EYIkWyZaL69+QE2GTwZjyOXRM5tZaMzSLRWsHXqX9/3gUMrjDhCdHRmxNCq8eCM4Kel9ocwOlWBLiLyi4T6PPJzGtnZhreU6YhZq3w3Q6JuBja1sh0r59vMrdun/N9Z5kv/8CLfOr9zt/nvX4n80cefYHEYwRur1YKjZc9qYRwET6ayiH6edQY5U7xjSJVYK8UZwzaDOYqVNr4ztKp14SrZWoNZ7y+Hq1iF5ByUTE2FUh3FQ0ojcYStTSPUh8Q2Ruo2UXy7pr9NI+YDyTmW40j2Ha5Wqsv03jgdDZdH4pBwqwVDqixc4Pb6jOAihhEWS0LZ8noyrtbMEA1LhW7ZwfkWtwi42FOGLd4FXGhvnraupzOINUFwVOcIzmMUonMUc9OUtsrSGzm3ITTsdd8z51q3v1qxWkhM0+8K7bIElW2m3b5UPBXnPQtfKObb0jptukzwbTTufEztYYS5Al1E5G2EOlyO8iwVSs6tmUutbIpR8jSic8jklFhvRgx48dYFz3/tZb78o82d35DN+JOnDvnUMydsXOHa0ZJrJ+0MeNcHUimsoieUQpmWkhfVuJkzXQU/PbExeGKF0AfICXygdSY1+mmjXZhGubbwcYxU6jhSq1G8azvmnaMOIyF48mZkA3TBkXwkp4GFd9waCj5G4rhhLLA1z1F02PRYY67QReI4YrVw4Rw1dnR5pFggWGXpjFPn8bWAcyxzZkwVfxAp2wTR0QHBu9Yr3uquEvaAo1DnmeQO5mN/rhpjrQQ3Vdy1ggOrre+up5Kmhv0OWJc2eAdnbeBLLdRc2/K5GXFeSre2vO6N3dE0P0/Pswe7EU6BLiLydgN9+mkeszrP4Z4DPVUopbIdC3kcWVfjfD2yJXP7fMNwUfne91/jz759i9fSndX6h3rPZz56xHNPHsDScePoEL/q6Ckch55NHokYFxgHlhkKWG2VeaWSRqPv4HrnKdY6vzkqsQt42mx2m+aM9tG342/Tsbw6fXZjgVAyiXYNPVXwLrMtRq0O79oEs2iOoRayeTyVbSmsQmWdPTElLHouciI4j88jWx9Y1GnKWxfoansMb5WhGDZt2Eul4AxicFQci1pINYGPBOcoQLBphGtpFTc2j6Rl6sXfmvW0iG9fq2Bt9vyul/48R32+jFKnUwXTPeYTDd61/ux+mnOOM1ytlycR7MFvglOgi4i8w5X6/nG2OoV6ahe0SRW2KcM4cnNss7dDddwqkDYbXnn1guf/9cf87Uubex776aXnsx99jI9eW7DqHdePVxwvPKkmig9t5/s2tR3Z2XAeTs8GKo7HjyPXjhbEiy1uteCiGtemPul9F+id4bzbXXNvk8FaqIORa8WmGamlzov0rclNye3onFFIOMI8w3wOFgzvYNua32OhDXt3DqwkCoHqKmHeie+szUK3SsFBSeDmneltRvs8Mz1YpdRp9p0Z0WjPdR6EUgrzmncx8FOoz9Pydplr89idu9+ktVGx08tAK+rb13c+V27TfaceQA+1Klegi4i8C5X6XOXOPd9LLpiDlFvTl4ta2GwSIVde2RZIme04MhTPCy+8zpe++SrfPhvv+TtOvPHZq56PP3Odxx5bcHIcqENi6Q0foY6Vb/zwlL/5zk2+uW4d1J6Ojs8/e8LvfuIJrqx6lubwHQQ8rgscOHBTi9I5kGyqcEupu8/NmLrkcTmnfcwV71uCW2nL1o5Kmc7Mm7U3Ms6m+01h3LrVV3ypbTmferknwByuFtx0HK+aYbXA1ArXzLXQrwVz1gJ2GgIzvxlxQJ2XG+yyLp+De//a9n4Ht/2QZx7hunsB5mS/vP8c6JcT+R4NCnQRkXch1MteA5pS2qarlCqlJIZi5PNziou8cbZmGBN5SJyNlX/+71P+6j9v8v3t/VubPrv0fPpq4IMfOOKpD53Qjxc8/283+cqbjPz87aPIn3/mwzz5+IpsjqVzLJcRZ5U+eLrQlt/9XqW5q1T3qlSmKhz2QnTaQ+D2X4cpQKEdU6ONft9V/lgbqVqngLwjWHdvCJiCfp5BP70pYNonMK0o3BFed4Wrze8TptvZfnjbftTfnYp3fDL3Sc1HK8QV6CIi71KozyE3h3qu7cgYJbeJYAUsZS6GkU2BkBO3R+P2ek2xQE2ZF97Y8p0f3OTL37vNd9dvPljlmc7xxKHn62+Mb/nc/vjDB3zhd26wuLKiPwh03rOk0i880bUxn95fDhKZr6XPZ8dtDvH5c5261TEH4nT7eaOgm5a5d4XyXnVcLwvhO6vj3W0uo7be8WdT6Wytzp8f0O7OYuOutfX5z+ze0L6zMH9kg1qBLiLyiFTq8zI8cNkLPmeGDKVktkNlWyvldINbdpytR84qrM82fOtHF/zTd2/ydz++eFvP7S//4EP81keuYEIKMVIAAAXlSURBVDFyFB1HfetoFqMn+jdvhnJ3QlxW2pdBfncg7od12Vuqnm80bSS/407z6kCZrllPZfr8y72ha/cJ6vtV2r9Egf3TBP0XFBF5hyqkXXq0rdbzddZSW/vWnDNuXj/Gs3AwFkfwhcWYuHhsSR1HjpaG27aNZb/3q4c89/SKz7/4Ov/18sBXfnjON8/Tz/3cTs8ztSTKYPgQceZw5vbS1nbBul8a71fWzINi3qTUrVwudc8B6vYfzi4/tnvsu4LX9ir/Oj2Y495q/H5V9k/92ijQRUTk5wr2Xai3atOmXePBO3IFV4zi21nn6I3NWPF9x+gT1UdqrnjLPOYOCXlkuR354I1rXDvZ8ImnD/n325Xzn6z5l5cu+PubP9vENBsyg19wHFpopyHhew8ZnPe7jV62l373Lovb/dfK7/6Q3Wcp/GcJ1/vez953waxAFxF5xEK9bZJu1bp31s48W6Wan85OQ65GHxypGod4SvD0BeJ2oAYo2TjpI6frhO8OORgXPHeQKTcW/PqNQ7721RfZ/gwXTl3vWaWR3EVGHDF43HR2O89Nad4ieO0tP3hvzt9viXv/Nu+HJfAHzeklEBF5l0J9V3XaNE6TXQOSuU1ocC39u+Dog6f3nhiMvo/0XcAvOnxwHCw7fAhE7+mPPLglN64u+dxHVj/1efzawvPs01dJvhKm8+BL2nAX7wxv9rbLX+Otq/K7b6MwV6CLiLznQn2+Vjw3I9m1LfWt81jwHg+YN5w3eudYRUfftYA/7jtWC8eTvWPVB46858pBZTxY8OmPXedq/9bfyr/4qRs8vgj4Al2M9MFI5lpvc+6ciCbv4X9r2uUuIvLgzN9x5+Eu7bhX3TVvaefXpw50pZJLa+065EwZCqcpYzlT1iMvrRPeG//zypq//sbLfPWu6+m/0nv+4pPX+dhvPklwrepfRsM5T+8rfdfaqHrfepE7U6Qr0EVE5BcI9roX6LY7/7076jYdcau1kgpsx0weM5sCZRzYVMeQM5tNZnN2wQuvXvCT1wfGGHj2OPDBD69YHh1wVApx0VFrxnvjsAt0MeKjo3Nt/Kd/iFPCRIEuIvLeDvXpp91IlHq5cWzXba5UUqmkXMi5MOYCFYaUGVLmPBUswRulYrkQYmBZEkN0uAQnvYMQiTljvecwGi5GIm3wSZiW/VWdK9BFROQdCva5Zt8Ffb1sUNNCvTLmxDpBrYUhFcowtnnsOMwc5ylz4j3rUlgtAsk8uMrSjBg8y2AQfBvI4ozo3UOd4S3vHB1bExF52JUV7I35bJPH6ryRbrqmvjtWZn4aNerwrjCaI9VKoDImOO4D0TlKyrgAh3mkhI4uOKJzON825kXvLud3K8xVoYuIyIOp2tu19DbwJeVKqoVcIOdKzYlUwLy77CdfIHrAOaJvu+C9o+2od61zndNSuwJdREQeUKjv/WbeKFdrZSxQSwv1SiXVOnWYg+ocnjbPvLrW4tVbxbn5enlbbn9U5niLAl1E5H0X8PN19VIvq/Y0hXwbltICe3e2fOoG56fe8jZV5WY6d65AFxGRhxvsu4ludXdu3eaRppXLGeRTb3a3d63c0DVzBbqIiDxyFTtTqO9/bJpsupt0piBXoIuIyHsq3O/+Dn/HL/JLTsfWRER+GaozJff7noaziIiIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIKNBFREREgS4iIiIKdBEREVGgi4iIiAJdREREgS4iIiIKdBEREVGgi4iIiAJdREREgS4iIiKPlP8H1XBgiR0WabsAAAAASUVORK5CYII diff --git a/frontend/tests/base64/base64ToImage.test.ts b/frontend/tests/base64/base64ToImage.test.ts new file mode 100644 index 00000000..3bf1abb9 --- /dev/null +++ b/frontend/tests/base64/base64ToImage.test.ts @@ -0,0 +1,24 @@ +import { describe, it, expect, beforeAll } from 'vitest'; +import { convertBase64ToImageSrc } from '../../src/utils/base64ToImage.js'; +import fs from 'fs'; +import path from 'path'; + +let sampleBase64: string; + +beforeAll(() => { + // Load base64 sample from text file + const filePath = path.resolve(__dirname, 'base64Sample.txt'); + sampleBase64 = fs.readFileSync(filePath, 'utf8').trim(); +}); + +describe('convertBase64ToImageSrc', () => { + it('should return the same string if it is already a valid data URL', () => { + const base64Image = `data:image/png;base64,${sampleBase64}`; + expect(convertBase64ToImageSrc(base64Image)).toBe(base64Image); + }); + + it('should correctly format a raw Base64 string as a PNG image URL', () => { + expect(convertBase64ToImageSrc(sampleBase64)).toBe(`data:image/png;base64,${sampleBase64}`); + }); + +}); diff --git a/package-lock.json b/package-lock.json index 2cbd1995..4679ab57 100644 --- a/package-lock.json +++ b/package-lock.json @@ -32,11 +32,12 @@ "name": "dwengo-1-backend", "version": "0.0.1", "dependencies": { - "@mikro-orm/core": "6.4.6", - "@mikro-orm/postgresql": "6.4.6", - "@mikro-orm/reflection": "6.4.6", + "@mikro-orm/core": "^6.4.6", + "@mikro-orm/postgresql": "^6.4.6", + "@mikro-orm/reflection": "^6.4.6", "@mikro-orm/sqlite": "6.4.6", "@types/js-yaml": "^4.0.9", + "axios": "^1.8.1", "dotenv": "^16.4.7", "express": "^5.0.1", "js-yaml": "^4.1.0", @@ -53,206 +54,20 @@ "vitest": "^3.0.6" } }, - "backend/node_modules/accepts": { - "version": "2.0.0", + "backend/node_modules/@mikro-orm/sqlite": { + "version": "6.4.6", "license": "MIT", "dependencies": { - "mime-types": "^3.0.0", - "negotiator": "^1.0.0" + "@mikro-orm/knex": "6.4.6", + "fs-extra": "11.3.0", + "sqlite3": "5.1.7", + "sqlstring-sqlite": "0.1.1" }, "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/body-parser": { - "version": "2.1.0", - "license": "MIT", - "dependencies": { - "bytes": "^3.1.2", - "content-type": "^1.0.5", - "debug": "^4.4.0", - "http-errors": "^2.0.0", - "iconv-lite": "^0.5.2", - "on-finished": "^2.4.1", - "qs": "^6.14.0", - "raw-body": "^3.0.0", - "type-is": "^2.0.0" + "node": ">= 18.12.0" }, - "engines": { - "node": ">=18" - } - }, - "backend/node_modules/body-parser/node_modules/qs": { - "version": "6.14.0", - "license": "BSD-3-Clause", - "dependencies": { - "side-channel": "^1.1.0" - }, - "engines": { - "node": ">=0.6" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "backend/node_modules/bytes": { - "version": "3.1.2", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/content-disposition": { - "version": "1.0.0", - "license": "MIT", - "dependencies": { - "safe-buffer": "5.2.1" - }, - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/content-type": { - "version": "1.0.5", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/cookie": { - "version": "0.7.1", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/cookie-signature": { - "version": "1.2.2", - "license": "MIT", - "engines": { - "node": ">=6.6.0" - } - }, - "backend/node_modules/depd": { - "version": "2.0.0", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/encodeurl": { - "version": "2.0.0", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/escape-html": { - "version": "1.0.3", - "license": "MIT" - }, - "backend/node_modules/etag": { - "version": "1.8.1", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/express": { - "version": "5.0.1", - "license": "MIT", - "dependencies": { - "accepts": "^2.0.0", - "body-parser": "^2.0.1", - "content-disposition": "^1.0.0", - "content-type": "~1.0.4", - "cookie": "0.7.1", - "cookie-signature": "^1.2.1", - "debug": "4.3.6", - "depd": "2.0.0", - "encodeurl": "~2.0.0", - "escape-html": "~1.0.3", - "etag": "~1.8.1", - "finalhandler": "^2.0.0", - "fresh": "2.0.0", - "http-errors": "2.0.0", - "merge-descriptors": "^2.0.0", - "methods": "~1.1.2", - "mime-types": "^3.0.0", - "on-finished": "2.4.1", - "once": "1.4.0", - "parseurl": "~1.3.3", - "proxy-addr": "~2.0.7", - "qs": "6.13.0", - "range-parser": "~1.2.1", - "router": "^2.0.0", - "safe-buffer": "5.2.1", - "send": "^1.1.0", - "serve-static": "^2.1.0", - "setprototypeof": "1.2.0", - "statuses": "2.0.1", - "type-is": "^2.0.0", - "utils-merge": "1.0.1", - "vary": "~1.1.2" - }, - "engines": { - "node": ">= 18" - } - }, - "backend/node_modules/express/node_modules/debug": { - "version": "4.3.6", - "license": "MIT", - "dependencies": { - "ms": "2.1.2" - }, - "engines": { - "node": ">=6.0" - }, - "peerDependenciesMeta": { - "supports-color": { - "optional": true - } - } - }, - "backend/node_modules/finalhandler": { - "version": "2.0.0", - "license": "MIT", - "dependencies": { - "debug": "2.6.9", - "encodeurl": "~1.0.2", - "escape-html": "~1.0.3", - "on-finished": "2.4.1", - "parseurl": "~1.3.3", - "statuses": "2.0.1", - "unpipe": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/finalhandler/node_modules/debug": { - "version": "2.6.9", - "license": "MIT", - "dependencies": { - "ms": "2.0.0" - } - }, - "backend/node_modules/finalhandler/node_modules/encodeurl": { - "version": "1.0.2", - "license": "MIT", - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/finalhandler/node_modules/ms": { - "version": "2.0.0", - "license": "MIT" - }, - "backend/node_modules/fresh": { - "version": "2.0.0", - "license": "MIT", - "engines": { - "node": ">= 0.8" + "peerDependencies": { + "@mikro-orm/core": "^6.0.0" } }, "backend/node_modules/globals": { @@ -266,75 +81,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "backend/node_modules/http-errors": { - "version": "2.0.0", - "license": "MIT", - "dependencies": { - "depd": "2.0.0", - "inherits": "2.0.4", - "setprototypeof": "1.2.0", - "statuses": "2.0.1", - "toidentifier": "1.0.1" - }, - "engines": { - "node": ">= 0.8" - } - }, - "backend/node_modules/iconv-lite": { - "version": "0.5.2", - "license": "MIT", - "dependencies": { - "safer-buffer": ">= 2.1.2 < 3" - }, - "engines": { - "node": ">=0.10.0" - } - }, - "backend/node_modules/merge-descriptors": { - "version": "2.0.0", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "backend/node_modules/methods": { - "version": "1.1.2", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/mime-db": { - "version": "1.53.0", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/mime-types": { - "version": "3.0.0", - "license": "MIT", - "dependencies": { - "mime-db": "^1.53.0" - }, - "engines": { - "node": ">= 0.6" - } - }, - "backend/node_modules/ms": { - "version": "2.1.2", - "license": "MIT" - }, - "backend/node_modules/negotiator": { - "version": "1.0.0", - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, "frontend": { "name": "dwengo-1-frontend", "version": "0.0.1", @@ -366,368 +112,10 @@ "vue-tsc": "^2.2.2" } }, - "frontend/node_modules/agent-base": { - "version": "7.1.3", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 14" - } - }, - "frontend/node_modules/asynckit": { - "version": "0.4.0", - "dev": true, - "license": "MIT" - }, - "frontend/node_modules/call-bind-apply-helpers": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "function-bind": "^1.1.2" - }, - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/combined-stream": { - "version": "1.0.8", - "dev": true, - "license": "MIT", - "dependencies": { - "delayed-stream": "~1.0.0" - }, - "engines": { - "node": ">= 0.8" - } - }, - "frontend/node_modules/cssstyle": { - "version": "4.2.1", - "dev": true, - "license": "MIT", - "dependencies": { - "@asamuzakjp/css-color": "^2.8.2", - "rrweb-cssom": "^0.8.0" - }, - "engines": { - "node": ">=18" - } - }, - "frontend/node_modules/data-urls": { - "version": "5.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "whatwg-mimetype": "^4.0.0", - "whatwg-url": "^14.0.0" - }, - "engines": { - "node": ">=18" - } - }, - "frontend/node_modules/decimal.js": { - "version": "10.5.0", - "dev": true, - "license": "MIT" - }, - "frontend/node_modules/delayed-stream": { - "version": "1.0.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">=0.4.0" - } - }, - "frontend/node_modules/dunder-proto": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "call-bind-apply-helpers": "^1.0.1", - "es-errors": "^1.3.0", - "gopd": "^1.2.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/es-define-property": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/es-errors": { - "version": "1.3.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/es-object-atoms": { - "version": "1.1.1", - "dev": true, - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/es-set-tostringtag": { - "version": "2.1.0", - "dev": true, - "license": "MIT", - "dependencies": { - "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.6", - "has-tostringtag": "^1.0.2", - "hasown": "^2.0.2" - }, - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/eslint-plugin-playwright": { - "version": "2.2.0", - "dev": true, - "license": "MIT", - "workspaces": [ - "examples" - ], - "dependencies": { - "globals": "^13.23.0" - }, - "engines": { - "node": ">=16.6.0" - }, - "peerDependencies": { - "eslint": ">=8.40.0" - } - }, - "frontend/node_modules/form-data": { - "version": "4.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "asynckit": "^0.4.0", - "combined-stream": "^1.0.8", - "es-set-tostringtag": "^2.1.0", - "mime-types": "^2.1.12" - }, - "engines": { - "node": ">= 6" - } - }, - "frontend/node_modules/get-intrinsic": { - "version": "1.3.0", - "dev": true, - "license": "MIT", - "dependencies": { - "call-bind-apply-helpers": "^1.0.2", - "es-define-property": "^1.0.1", - "es-errors": "^1.3.0", - "es-object-atoms": "^1.1.1", - "function-bind": "^1.1.2", - "get-proto": "^1.0.1", - "gopd": "^1.2.0", - "has-symbols": "^1.1.0", - "hasown": "^2.0.2", - "math-intrinsics": "^1.1.0" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "frontend/node_modules/get-proto": { - "version": "1.0.1", - "dev": true, - "license": "MIT", - "dependencies": { - "dunder-proto": "^1.0.1", - "es-object-atoms": "^1.0.0" - }, - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/globals": { - "version": "13.24.0", - "dev": true, - "license": "MIT", - "dependencies": { - "type-fest": "^0.20.2" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "frontend/node_modules/gopd": { - "version": "1.2.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "frontend/node_modules/has-symbols": { - "version": "1.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "frontend/node_modules/has-tostringtag": { - "version": "1.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "has-symbols": "^1.0.3" - }, - "engines": { - "node": ">= 0.4" - }, - "funding": { - "url": "https://github.com/sponsors/ljharb" - } - }, - "frontend/node_modules/html-encoding-sniffer": { - "version": "4.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "whatwg-encoding": "^3.1.1" - }, - "engines": { - "node": ">=18" - } - }, - "frontend/node_modules/http-proxy-agent": { - "version": "7.0.2", - "dev": true, - "license": "MIT", - "dependencies": { - "agent-base": "^7.1.0", - "debug": "^4.3.4" - }, - "engines": { - "node": ">= 14" - } - }, - "frontend/node_modules/https-proxy-agent": { - "version": "7.0.6", - "dev": true, - "license": "MIT", - "dependencies": { - "agent-base": "^7.1.2", - "debug": "4" - }, - "engines": { - "node": ">= 14" - } - }, - "frontend/node_modules/is-potential-custom-element-name": { - "version": "1.0.1", - "dev": true, - "license": "MIT" - }, - "frontend/node_modules/jsdom": { - "version": "26.0.0", - "dev": true, - "license": "MIT", - "dependencies": { - "cssstyle": "^4.2.1", - "data-urls": "^5.0.0", - "decimal.js": "^10.4.3", - "form-data": "^4.0.1", - "html-encoding-sniffer": "^4.0.0", - "http-proxy-agent": "^7.0.2", - "https-proxy-agent": "^7.0.6", - "is-potential-custom-element-name": "^1.0.1", - "nwsapi": "^2.2.16", - "parse5": "^7.2.1", - "rrweb-cssom": "^0.8.0", - "saxes": "^6.0.0", - "symbol-tree": "^3.2.4", - "tough-cookie": "^5.0.0", - "w3c-xmlserializer": "^5.0.0", - "webidl-conversions": "^7.0.0", - "whatwg-encoding": "^3.1.1", - "whatwg-mimetype": "^4.0.0", - "whatwg-url": "^14.1.0", - "ws": "^8.18.0", - "xml-name-validator": "^5.0.0" - }, - "engines": { - "node": ">=18" - }, - "peerDependencies": { - "canvas": "^3.0.0" - }, - "peerDependenciesMeta": { - "canvas": { - "optional": true - } - } - }, - "frontend/node_modules/jsdom/node_modules/xml-name-validator": { - "version": "5.0.0", - "dev": true, - "license": "Apache-2.0", - "engines": { - "node": ">=18" - } - }, - "frontend/node_modules/math-intrinsics": { - "version": "1.1.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.4" - } - }, - "frontend/node_modules/mime-db": { - "version": "1.52.0", - "dev": true, - "license": "MIT", - "engines": { - "node": ">= 0.6" - } - }, - "frontend/node_modules/mime-types": { - "version": "2.1.35", - "dev": true, - "license": "MIT", - "dependencies": { - "mime-db": "1.52.0" - }, - "engines": { - "node": ">= 0.6" - } - }, "node_modules/@ampproject/remapping": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz", - "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", "dev": true, + "license": "Apache-2.0", "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" @@ -738,9 +126,8 @@ }, "node_modules/@ampproject/remapping/node_modules/@jridgewell/trace-mapping": { "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" @@ -748,18 +135,28 @@ }, "node_modules/@antfu/utils": { "version": "0.7.10", - "resolved": "https://registry.npmjs.org/@antfu/utils/-/utils-0.7.10.tgz", - "integrity": "sha512-+562v9k4aI80m1+VuMHehNJWLOFjBnXn3tdOitzD0il5b7smkSBal4+a3oKiQTbrwMmN/TBUMDvbdoWDehgOww==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/antfu" } }, + "node_modules/@asamuzakjp/css-color": { + "version": "2.8.3", + "dev": true, + "license": "MIT", + "dependencies": { + "@csstools/css-calc": "^2.1.1", + "@csstools/css-color-parser": "^3.0.7", + "@csstools/css-parser-algorithms": "^3.0.4", + "@csstools/css-tokenizer": "^3.0.3", + "lru-cache": "^10.4.3" + } + }, "node_modules/@babel/code-frame": { "version": "7.26.2", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz", - "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-validator-identifier": "^7.25.9", "js-tokens": "^4.0.0", @@ -771,18 +168,16 @@ }, "node_modules/@babel/compat-data": { "version": "7.26.8", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.8.tgz", - "integrity": "sha512-oH5UPLMWR3L2wEFLnFJ1TZXqHufiTKAiLfqw5zkhS4dKXLJ10yVztfil/twG8EDTA4F/tvVNw9nOl4ZMslB8rQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.26.9.tgz", - "integrity": "sha512-lWBYIrF7qK5+GjY5Uy+/hEgp8OJWOD/rpy74GplYRhEauvbHDeFB8t5hPOZxCZ0Oxf4Cc36tK51/l3ymJysrKw==", "dev": true, + "license": "MIT", "dependencies": { "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.26.2", @@ -810,18 +205,16 @@ }, "node_modules/@babel/core/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/generator": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.9.tgz", - "integrity": "sha512-kEWdzjOAUMW4hAyrzJ0ZaTOu9OmpyDIQicIh0zg0EEcEkYXZb2TjtBhnHi2ViX7PKwZqF4xwqfAm299/QMP3lg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/parser": "^7.26.9", "@babel/types": "^7.26.9", @@ -835,9 +228,8 @@ }, "node_modules/@babel/generator/node_modules/@jridgewell/trace-mapping": { "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" @@ -845,9 +237,8 @@ }, "node_modules/@babel/helper-annotate-as-pure": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.25.9.tgz", - "integrity": "sha512-gv7320KBUFJz1RnylIg5WWYPRXKZ884AGkYpgpWW02TH66Dl+HaC1t1CKd0z3R4b6hdYEcmrNZHUmfCP+1u3/g==", "dev": true, + "license": "MIT", "dependencies": { "@babel/types": "^7.25.9" }, @@ -857,9 +248,8 @@ }, "node_modules/@babel/helper-compilation-targets": { "version": "7.26.5", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.26.5.tgz", - "integrity": "sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/compat-data": "^7.26.5", "@babel/helper-validator-option": "^7.25.9", @@ -873,33 +263,24 @@ }, "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { "version": "5.1.1", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", - "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", "dev": true, + "license": "ISC", "dependencies": { "yallist": "^3.0.2" } }, "node_modules/@babel/helper-compilation-targets/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, - "node_modules/@babel/helper-compilation-targets/node_modules/yallist": { - "version": "3.1.1", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", - "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", - "dev": true - }, "node_modules/@babel/helper-create-class-features-plugin": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.26.9.tgz", - "integrity": "sha512-ubbUqCofvxPRurw5L8WTsCLSkQiVpov4Qx0WMA+jUN+nXBK8ADPlJO1grkFw5CWKC5+sZSOfuGMdX1aI1iT9Sg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", "@babel/helper-member-expression-to-functions": "^7.25.9", @@ -918,18 +299,16 @@ }, "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { "version": "6.3.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", - "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", "dev": true, + "license": "ISC", "bin": { "semver": "bin/semver.js" } }, "node_modules/@babel/helper-member-expression-to-functions": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz", - "integrity": "sha512-wbfdZ9w5vk0C0oyHqAJbc62+vet5prjj01jjJ8sKn3j9h3MQQlflEdXYvuqRWjHnM12coDEqiC1IRCi0U/EKwQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/traverse": "^7.25.9", "@babel/types": "^7.25.9" @@ -940,9 +319,8 @@ }, "node_modules/@babel/helper-module-imports": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.25.9.tgz", - "integrity": "sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==", "dev": true, + "license": "MIT", "dependencies": { "@babel/traverse": "^7.25.9", "@babel/types": "^7.25.9" @@ -953,9 +331,8 @@ }, "node_modules/@babel/helper-module-transforms": { "version": "7.26.0", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.26.0.tgz", - "integrity": "sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-module-imports": "^7.25.9", "@babel/helper-validator-identifier": "^7.25.9", @@ -970,9 +347,8 @@ }, "node_modules/@babel/helper-optimise-call-expression": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.25.9.tgz", - "integrity": "sha512-FIpuNaz5ow8VyrYcnXQTDRGvV6tTjkNtCK/RYNDXGSLlUD6cBuQTSw43CShGxjvfBTfcUA/r6UhUCbtYqkhcuQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/types": "^7.25.9" }, @@ -982,18 +358,16 @@ }, "node_modules/@babel/helper-plugin-utils": { "version": "7.26.5", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.26.5.tgz", - "integrity": "sha512-RS+jZcRdZdRFzMyr+wcsaqOmld1/EqTghfaBGQQd/WnRdzdlvSZ//kF7U8VQTxf1ynZ4cjUcYgjVGx13ewNPMg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-replace-supers": { "version": "7.26.5", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.26.5.tgz", - "integrity": "sha512-bJ6iIVdYX1YooY2X7w1q6VITt+LnUILtNk7zT78ykuwStx8BauCzxvFqFaHjOpW1bVnSUM1PN1f0p5P21wHxvg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-member-expression-to-functions": "^7.25.9", "@babel/helper-optimise-call-expression": "^7.25.9", @@ -1008,9 +382,8 @@ }, "node_modules/@babel/helper-skip-transparent-expression-wrappers": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz", - "integrity": "sha512-K4Du3BFa3gvyhzgPcntrkDgZzQaq6uozzcpGbOO1OEJaI+EJdqWIMTLgFgQf6lrfiDFo5FU+BxKepI9RmZqahA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/traverse": "^7.25.9", "@babel/types": "^7.25.9" @@ -1021,34 +394,30 @@ }, "node_modules/@babel/helper-string-parser": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz", - "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-identifier": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz", - "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==", + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-option": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.25.9.tgz", - "integrity": "sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.26.9.tgz", - "integrity": "sha512-Mz/4+y8udxBKdmzt/UjPACs4G3j5SshJJEFFKxlCGPydG4JAHXxjWjAwjd09tf6oINvl1VfMJo+nB7H2YKQ0dA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/template": "^7.26.9", "@babel/types": "^7.26.9" @@ -1059,8 +428,7 @@ }, "node_modules/@babel/parser": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.9.tgz", - "integrity": "sha512-81NWa1njQblgZbQHxWHpxxCzNsa3ZwvFqpUg7P+NNUU6f3UU2jBEg4OlF/J6rl8+PQGh1q6/zWScd001YwcA5A==", + "license": "MIT", "dependencies": { "@babel/types": "^7.26.9" }, @@ -1073,9 +441,8 @@ }, "node_modules/@babel/plugin-proposal-decorators": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.25.9.tgz", - "integrity": "sha512-smkNLL/O1ezy9Nhy4CNosc4Va+1wo5w4gzSZeLe6y6dM4mmHfYOCPolXQPHQxonZCF+ZyebxN9vqOolkYrSn5g==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-create-class-features-plugin": "^7.25.9", "@babel/helper-plugin-utils": "^7.25.9", @@ -1090,9 +457,8 @@ }, "node_modules/@babel/plugin-syntax-decorators": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.25.9.tgz", - "integrity": "sha512-ryzI0McXUPJnRCvMo4lumIKZUzhYUO/ScI+Mz4YVaTLt04DHNSjEUjKVvbzQjZFLuod/cYEc07mJWhzl6v4DPg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9" }, @@ -1105,9 +471,8 @@ }, "node_modules/@babel/plugin-syntax-import-attributes": { "version": "7.26.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.26.0.tgz", - "integrity": "sha512-e2dttdsJ1ZTpi3B9UYGLw41hifAubg19AtCu/2I/F1QNVclOBr1dYpTdmdyZ84Xiz43BS/tCUkMAZNLv12Pi+A==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9" }, @@ -1120,9 +485,8 @@ }, "node_modules/@babel/plugin-syntax-import-meta": { "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", - "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.10.4" }, @@ -1132,9 +496,8 @@ }, "node_modules/@babel/plugin-syntax-jsx": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.25.9.tgz", - "integrity": "sha512-ld6oezHQMZsZfp6pWtbjaNDF2tiiCYYDqQszHt5VV437lewP9aSi2Of99CK0D0XB21k7FLgnLcmQKyKzynfeAA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9" }, @@ -1147,9 +510,8 @@ }, "node_modules/@babel/plugin-syntax-typescript": { "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.25.9.tgz", - "integrity": "sha512-hjMgRy5hb8uJJjUcdWunWVcoi9bGpJp8p5Ol1229PoN6aytsLwNMgmdftO23wnCLMfVmTwZDWMPNq/D1SY60JQ==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.25.9" }, @@ -1162,9 +524,8 @@ }, "node_modules/@babel/plugin-transform-typescript": { "version": "7.26.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.8.tgz", - "integrity": "sha512-bME5J9AC8ChwA7aEPJ6zym3w7aObZULHhbNLU0bKUhKsAkylkzUdq+0kdymh9rzi8nlNFl2bmldFBCKNJBUpuw==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", "@babel/helper-create-class-features-plugin": "^7.25.9", @@ -1181,9 +542,8 @@ }, "node_modules/@babel/template": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.26.9.tgz", - "integrity": "sha512-qyRplbeIpNZhmzOysF/wFMuP9sctmh2cFzRAZOn1YapxBsE1i9bJIY586R/WBLfLcmcBlM8ROBiQURnnNy+zfA==", "dev": true, + "license": "MIT", "dependencies": { "@babel/code-frame": "^7.26.2", "@babel/parser": "^7.26.9", @@ -1195,9 +555,8 @@ }, "node_modules/@babel/traverse": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.26.9.tgz", - "integrity": "sha512-ZYW7L+pL8ahU5fXmNbPF+iZFHCv5scFak7MZ9bwaRPLUhHh7QQEMjZUg0HevihoqCM5iSYHN61EyCoZvqC+bxg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/code-frame": "^7.26.2", "@babel/generator": "^7.26.9", @@ -1213,17 +572,15 @@ }, "node_modules/@babel/traverse/node_modules/globals": { "version": "11.12.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", - "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", "dev": true, + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/@babel/types": { "version": "7.26.9", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.9.tgz", - "integrity": "sha512-Y3IR1cRnOxOCDvMmNiym7XpXQ93iGDDPHx+Zj+NM+rg0fBaShfQLkg+hKPaZCEvg5N/LeCo4+Rj/i3FuJsIQaw==", + "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.25.9", "@babel/helper-validator-identifier": "^7.25.9" @@ -1234,9 +591,8 @@ }, "node_modules/@cspotcode/source-map-support": { "version": "0.8.1", - "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz", - "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/trace-mapping": "0.3.9" }, @@ -1244,411 +600,131 @@ "node": ">=12" } }, - "node_modules/@esbuild/aix-ppc64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.0.tgz", - "integrity": "sha512-O7vun9Sf8DFjH2UtqK8Ku3LkquL9SZL8OLY1T5NZkA34+wG3OQF7cl4Ql8vdNzM6fzBbYfLaiRLIOZ+2FOCgBQ==", - "cpu": [ - "ppc64" - ], + "node_modules/@csstools/color-helpers": { + "version": "5.0.1", "dev": true, - "optional": true, - "os": [ - "aix" + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } ], + "license": "MIT-0", "engines": { "node": ">=18" } }, - "node_modules/@esbuild/android-arm": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.0.tgz", - "integrity": "sha512-PTyWCYYiU0+1eJKmw21lWtC+d08JDZPQ5g+kFyxP0V+es6VPPSUhM6zk8iImp2jbV6GwjX4pap0JFbUQN65X1g==", - "cpu": [ - "arm" - ], + "node_modules/@csstools/css-calc": { + "version": "2.1.1", "dev": true, - "optional": true, - "os": [ - "android" + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } ], + "license": "MIT", "engines": { "node": ">=18" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^3.0.4", + "@csstools/css-tokenizer": "^3.0.3" } }, - "node_modules/@esbuild/android-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.0.tgz", - "integrity": "sha512-grvv8WncGjDSyUBjN9yHXNt+cq0snxXbDxy5pJtzMKGmmpPxeAmAhWxXI+01lU5rwZomDgD3kJwulEnhTRUd6g==", - "cpu": [ - "arm64" - ], + "node_modules/@csstools/css-color-parser": { + "version": "3.0.7", "dev": true, - "optional": true, - "os": [ - "android" + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } ], + "license": "MIT", + "dependencies": { + "@csstools/color-helpers": "^5.0.1", + "@csstools/css-calc": "^2.1.1" + }, "engines": { "node": ">=18" + }, + "peerDependencies": { + "@csstools/css-parser-algorithms": "^3.0.4", + "@csstools/css-tokenizer": "^3.0.3" } }, - "node_modules/@esbuild/android-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.0.tgz", - "integrity": "sha512-m/ix7SfKG5buCnxasr52+LI78SQ+wgdENi9CqyCXwjVR2X4Jkz+BpC3le3AoBPYTC9NHklwngVXvbJ9/Akhrfg==", - "cpu": [ - "x64" - ], + "node_modules/@csstools/css-parser-algorithms": { + "version": "3.0.4", "dev": true, - "optional": true, - "os": [ - "android" + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } ], + "license": "MIT", "engines": { "node": ">=18" + }, + "peerDependencies": { + "@csstools/css-tokenizer": "^3.0.3" } }, - "node_modules/@esbuild/darwin-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.0.tgz", - "integrity": "sha512-mVwdUb5SRkPayVadIOI78K7aAnPamoeFR2bT5nszFUZ9P8UpK4ratOdYbZZXYSqPKMHfS1wdHCJk1P1EZpRdvw==", - "cpu": [ - "arm64" - ], + "node_modules/@csstools/css-tokenizer": { + "version": "3.0.3", "dev": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/darwin-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.0.tgz", - "integrity": "sha512-DgDaYsPWFTS4S3nWpFcMn/33ZZwAAeAFKNHNa1QN0rI4pUjgqf0f7ONmXf6d22tqTY+H9FNdgeaAa+YIFUn2Rg==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.0.tgz", - "integrity": "sha512-VN4ocxy6dxefN1MepBx/iD1dH5K8qNtNe227I0mnTRjry8tj5MRk4zprLEdG8WPyAPb93/e4pSgi1SoHdgOa4w==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/freebsd-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.0.tgz", - "integrity": "sha512-mrSgt7lCh07FY+hDD1TxiTyIHyttn6vnjesnPoVDNmDfOmggTLXRv8Id5fNZey1gl/V2dyVK1VXXqVsQIiAk+A==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "freebsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.0.tgz", - "integrity": "sha512-vkB3IYj2IDo3g9xX7HqhPYxVkNQe8qTK55fraQyTzTX/fxaDtXiEnavv9geOsonh2Fd2RMB+i5cbhu2zMNWJwg==", - "cpu": [ - "arm" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.0.tgz", - "integrity": "sha512-9QAQjTWNDM/Vk2bgBl17yWuZxZNQIF0OUUuPZRKoDtqF2k4EtYbpyiG5/Dk7nqeK6kIJWPYldkOcBqjXjrUlmg==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ia32": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.0.tgz", - "integrity": "sha512-43ET5bHbphBegyeqLb7I1eYn2P/JYGNmzzdidq/w0T8E2SsYL1U6un2NFROFRg1JZLTzdCoRomg8Rvf9M6W6Gg==", - "cpu": [ - "ia32" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-loong64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.0.tgz", - "integrity": "sha512-fC95c/xyNFueMhClxJmeRIj2yrSMdDfmqJnyOY4ZqsALkDrrKJfIg5NTMSzVBr5YW1jf+l7/cndBfP3MSDpoHw==", - "cpu": [ - "loong64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-mips64el": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.0.tgz", - "integrity": "sha512-nkAMFju7KDW73T1DdH7glcyIptm95a7Le8irTQNO/qtkoyypZAnjchQgooFUDQhNAy4iu08N79W4T4pMBwhPwQ==", - "cpu": [ - "mips64el" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-ppc64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.0.tgz", - "integrity": "sha512-NhyOejdhRGS8Iwv+KKR2zTq2PpysF9XqY+Zk77vQHqNbo/PwZCzB5/h7VGuREZm1fixhs4Q/qWRSi5zmAiO4Fw==", - "cpu": [ - "ppc64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-riscv64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.0.tgz", - "integrity": "sha512-5S/rbP5OY+GHLC5qXp1y/Mx//e92L1YDqkiBbO9TQOvuFXM+iDqUNG5XopAnXoRH3FjIUDkeGcY1cgNvnXp/kA==", - "cpu": [ - "riscv64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/linux-s390x": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.0.tgz", - "integrity": "sha512-XM2BFsEBz0Fw37V0zU4CXfcfuACMrppsMFKdYY2WuTS3yi8O1nFOhil/xhKTmE1nPmVyvQJjJivgDT+xh8pXJA==", - "cpu": [ - "s390x" - ], - "dev": true, - "optional": true, - "os": [ - "linux" + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + } ], + "license": "MIT", "engines": { "node": ">=18" } }, "node_modules/@esbuild/linux-x64": { "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.0.tgz", - "integrity": "sha512-9yl91rHw/cpwMCNytUDxwj2XjFpxML0y9HAOH9pNVQDpQrBxHy01Dx+vaMu0N1CKa/RzBD2hB4u//nfc+Sd3Cw==", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.0.tgz", - "integrity": "sha512-RuG4PSMPFfrkH6UwCAqBzauBWTygTvb1nxWasEJooGSJ/NwRw7b2HOwyRTQIU97Hq37l3npXoZGYMy3b3xYvPw==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/netbsd-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.0.tgz", - "integrity": "sha512-jl+qisSB5jk01N5f7sPCsBENCOlPiS/xptD5yxOx2oqQfyourJwIKLRA2yqWdifj3owQZCL2sn6o08dBzZGQzA==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "netbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.0.tgz", - "integrity": "sha512-21sUNbq2r84YE+SJDfaQRvdgznTD8Xc0oc3p3iW/a1EVWeNj/SdUCbm5U0itZPQYRuRTW20fPMWMpcrciH2EJw==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/openbsd-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.0.tgz", - "integrity": "sha512-2gwwriSMPcCFRlPlKx3zLQhfN/2WjJ2NSlg5TKLQOJdV0mSxIcYNTMhk3H3ulL/cak+Xj0lY1Ym9ysDV1igceg==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "openbsd" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/sunos-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.0.tgz", - "integrity": "sha512-bxI7ThgLzPrPz484/S9jLlvUAHYMzy6I0XiU1ZMeAEOBcS0VePBFxh1JjTQt3Xiat5b6Oh4x7UC7IwKQKIJRIg==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "sunos" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-arm64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.0.tgz", - "integrity": "sha512-ZUAc2YK6JW89xTbXvftxdnYy3m4iHIkDtK3CLce8wg8M2L+YZhIvO1DKpxrd0Yr59AeNNkTiic9YLf6FTtXWMw==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-ia32": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.0.tgz", - "integrity": "sha512-eSNxISBu8XweVEWG31/JzjkIGbGIJN/TrRoiSVZwZ6pkC6VX4Im/WV2cz559/TXLcYbcrDN8JtKgd9DJVIo8GA==", - "cpu": [ - "ia32" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">=18" - } - }, - "node_modules/@esbuild/win32-x64": { - "version": "0.25.0", - "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.0.tgz", - "integrity": "sha512-ZENoHJBxA20C2zFzh6AI4fT6RraMzjYw4xKWemRTRmRVtN9c5DcH9r/f2ihEkMjOW5eGgrwCslG/+Y/3bL+DHQ==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ], + "peer": true, "engines": { "node": ">=18" } }, "node_modules/@eslint-community/eslint-utils": { "version": "4.4.1", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.1.tgz", - "integrity": "sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==", "dev": true, + "license": "MIT", "dependencies": { "eslint-visitor-keys": "^3.4.3" }, @@ -1664,18 +740,16 @@ }, "node_modules/@eslint-community/regexpp": { "version": "4.12.1", - "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", - "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", "dev": true, + "license": "MIT", "engines": { "node": "^12.0.0 || ^14.0.0 || >=16.0.0" } }, "node_modules/@eslint/compat": { - "version": "1.2.7", - "resolved": "https://registry.npmjs.org/@eslint/compat/-/compat-1.2.7.tgz", - "integrity": "sha512-xvv7hJE32yhegJ8xNAnb62ggiAwTYHBpUCWhRxEj/ksvgDJuSXfoDkBcRYaYNFiJ+jH0IE3K16hd+xXzhBgNbg==", + "version": "1.2.6", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -1690,9 +764,8 @@ }, "node_modules/@eslint/config-array": { "version": "0.19.2", - "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.19.2.tgz", - "integrity": "sha512-GNKqxfHG2ySmJOBSHg7LxeUx4xpuCoFjacmlCoYWEbaPXLwvfIjixRI12xCQZeULksQb23uiA8F40w5TojpV7w==", "dev": true, + "license": "Apache-2.0", "dependencies": { "@eslint/object-schema": "^2.1.6", "debug": "^4.3.1", @@ -1704,9 +777,8 @@ }, "node_modules/@eslint/config-array/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dev": true, + "license": "MIT", "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -1714,9 +786,8 @@ }, "node_modules/@eslint/config-array/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -1725,10 +796,9 @@ } }, "node_modules/@eslint/core": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.12.0.tgz", - "integrity": "sha512-cmrR6pytBuSMTaBweKoGMwu3EiHiEC+DoyupPmlZ0HxBJBtIxwe+j/E4XPIKNx+Q74c8lXKPwYawBf5glsTkHg==", + "version": "0.11.0", "dev": true, + "license": "Apache-2.0", "dependencies": { "@types/json-schema": "^7.0.15" }, @@ -1737,10 +807,9 @@ } }, "node_modules/@eslint/eslintrc": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.0.tgz", - "integrity": "sha512-yaVPAiNAalnCZedKLdR21GOGILMLKPyqSLWaAjQFvYA2i/ciDi8ArYVr69Anohb6cH2Ukhqti4aFnYyPm8wdwQ==", + "version": "3.2.0", "dev": true, + "license": "MIT", "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", @@ -1761,9 +830,8 @@ }, "node_modules/@eslint/eslintrc/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dev": true, + "license": "MIT", "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -1771,9 +839,8 @@ }, "node_modules/@eslint/eslintrc/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -1782,30 +849,27 @@ } }, "node_modules/@eslint/js": { - "version": "9.21.0", - "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.21.0.tgz", - "integrity": "sha512-BqStZ3HX8Yz6LvsF5ByXYrtigrV5AXADWLAGc7PH/1SxOb7/FIYYMszZZWiUou/GB9P2lXWk2SV4d+Z8h0nknw==", + "version": "9.20.0", "dev": true, + "license": "MIT", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" } }, "node_modules/@eslint/object-schema": { "version": "2.1.6", - "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.6.tgz", - "integrity": "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" } }, "node_modules/@eslint/plugin-kit": { - "version": "0.2.7", - "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.2.7.tgz", - "integrity": "sha512-JubJ5B2pJ4k4yGxaNLdbjrnk9d/iDz6/q8wOilpIowd6PJPgaxCuHBnBszq7Ce2TyMrywm5r4PnKm6V3iiZF+g==", + "version": "0.2.6", "dev": true, + "license": "Apache-2.0", "dependencies": { - "@eslint/core": "^0.12.0", + "@eslint/core": "^0.11.0", "levn": "^0.4.1" }, "engines": { @@ -1814,24 +878,21 @@ }, "node_modules/@gar/promisify": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/@gar/promisify/-/promisify-1.1.3.tgz", - "integrity": "sha512-k2Ty1JcVojjJFwrg/ThKi2ujJ7XNLYaFGNB/bWT9wGR+oSMJHMa5w+CUq6p/pVrKeNNgA7pCqEcjSnHVoqJQFw==", + "license": "MIT", "optional": true }, "node_modules/@humanfs/core": { "version": "0.19.1", - "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", - "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18.0" } }, "node_modules/@humanfs/node": { "version": "0.16.6", - "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.6.tgz", - "integrity": "sha512-YuI2ZHQL78Q5HbhDiBA1X4LmYdXCKCMQIfw0pw7piHJwyREFebJUvrQN4cMssyES6x+vfUbx1CIpaQUKYdQZOw==", "dev": true, + "license": "Apache-2.0", "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.3.0" @@ -1842,9 +903,8 @@ }, "node_modules/@humanfs/node/node_modules/@humanwhocodes/retry": { "version": "0.3.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.1.tgz", - "integrity": "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18" }, @@ -1855,9 +915,8 @@ }, "node_modules/@humanwhocodes/module-importer": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", - "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=12.22" }, @@ -1868,9 +927,8 @@ }, "node_modules/@humanwhocodes/retry": { "version": "0.4.2", - "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.2.tgz", - "integrity": "sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18" }, @@ -1881,8 +939,7 @@ }, "node_modules/@intlify/core-base": { "version": "10.0.5", - "resolved": "https://registry.npmjs.org/@intlify/core-base/-/core-base-10.0.5.tgz", - "integrity": "sha512-F3snDTQs0MdvnnyzTDTVkOYVAZOE/MHwRvF7mn7Jw1yuih4NrFYLNYIymGlLmq4HU2iIdzYsZ7f47bOcwY73XQ==", + "license": "MIT", "dependencies": { "@intlify/message-compiler": "10.0.5", "@intlify/shared": "10.0.5" @@ -1896,8 +953,7 @@ }, "node_modules/@intlify/message-compiler": { "version": "10.0.5", - "resolved": "https://registry.npmjs.org/@intlify/message-compiler/-/message-compiler-10.0.5.tgz", - "integrity": "sha512-6GT1BJ852gZ0gItNZN2krX5QAmea+cmdjMvsWohArAZ3GmHdnNANEcF9JjPXAMRtQ6Ux5E269ymamg/+WU6tQA==", + "license": "MIT", "dependencies": { "@intlify/shared": "10.0.5", "source-map-js": "^1.0.2" @@ -1911,8 +967,7 @@ }, "node_modules/@intlify/shared": { "version": "10.0.5", - "resolved": "https://registry.npmjs.org/@intlify/shared/-/shared-10.0.5.tgz", - "integrity": "sha512-bmsP4L2HqBF6i6uaMqJMcFBONVjKt+siGluRq4Ca4C0q7W2eMaVZr8iCgF9dKbcVXutftkC7D6z2SaSMmLiDyA==", + "license": "MIT", "engines": { "node": ">= 16" }, @@ -1922,9 +977,8 @@ }, "node_modules/@isaacs/cliui": { "version": "8.0.2", - "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", - "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", "dev": true, + "license": "ISC", "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", @@ -1939,9 +993,8 @@ }, "node_modules/@jercle/yargonaut": { "version": "1.1.5", - "resolved": "https://registry.npmjs.org/@jercle/yargonaut/-/yargonaut-1.1.5.tgz", - "integrity": "sha512-zBp2myVvBHp1UaJsNTyS6q4UDKT7eRiqTS4oNTS6VQMd6mpxYOdbeK4pY279cDCdakGy6hG0J3ejoXZVsPwHqw==", "dev": true, + "license": "Apache-2.0", "dependencies": { "chalk": "^4.1.2", "figlet": "^1.5.2", @@ -1950,9 +1003,8 @@ }, "node_modules/@jridgewell/gen-mapping": { "version": "0.3.8", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz", - "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/set-array": "^1.2.1", "@jridgewell/sourcemap-codec": "^1.4.10", @@ -1964,9 +1016,8 @@ }, "node_modules/@jridgewell/gen-mapping/node_modules/@jridgewell/trace-mapping": { "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" @@ -1974,46 +1025,41 @@ }, "node_modules/@jridgewell/resolve-uri": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", - "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/set-array": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", - "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.0.0" } }, "node_modules/@jridgewell/sourcemap-codec": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", - "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==" + "license": "MIT" }, "node_modules/@jridgewell/trace-mapping": { "version": "0.3.9", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz", - "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==", "dev": true, + "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.0.3", "@jridgewell/sourcemap-codec": "^1.4.10" } }, "node_modules/@mikro-orm/cli": { - "version": "6.4.7", - "resolved": "https://registry.npmjs.org/@mikro-orm/cli/-/cli-6.4.7.tgz", - "integrity": "sha512-jaEm8olUP7h/kz4AZyu21TJ8P1qAGgdyvFYG+J5eGAtPsdMN8ZMQJJy2m6DZcHNbuyllCVdzp3XT6MAzG+uwMw==", + "version": "6.4.6", "dev": true, + "license": "MIT", "dependencies": { "@jercle/yargonaut": "1.1.5", - "@mikro-orm/core": "6.4.7", - "@mikro-orm/knex": "6.4.7", + "@mikro-orm/core": "6.4.6", + "@mikro-orm/knex": "6.4.6", "fs-extra": "11.3.0", "tsconfig-paths": "4.2.0", "yargs": "17.7.2" @@ -2026,40 +1072,9 @@ "node": ">= 18.12.0" } }, - "node_modules/@mikro-orm/cli/node_modules/@mikro-orm/core": { - "version": "6.4.7", - "resolved": "https://registry.npmjs.org/@mikro-orm/core/-/core-6.4.7.tgz", - "integrity": "sha512-ZePm7IRpW6/tGC6axCezI1/5YA3+MiDsbEj5KHgXDIxzHnftVfL3nbYlPlr0pW/UQSL5QcRqXxHIQz4P2OlFhg==", - "dev": true, - "dependencies": { - "dataloader": "2.2.3", - "dotenv": "16.4.7", - "esprima": "4.0.1", - "fs-extra": "11.3.0", - "globby": "11.1.0", - "mikro-orm": "6.4.7", - "reflect-metadata": "0.2.2" - }, - "engines": { - "node": ">= 18.12.0" - }, - "funding": { - "url": "https://github.com/sponsors/b4nan" - } - }, - "node_modules/@mikro-orm/cli/node_modules/mikro-orm": { - "version": "6.4.7", - "resolved": "https://registry.npmjs.org/mikro-orm/-/mikro-orm-6.4.7.tgz", - "integrity": "sha512-lRB92yekDcdQEHloNY9LWfNLyKd3WajxPSe3jBvyVR9gMIO7YsjhqxL0mYvoQi8MQzXcUTi1EkWG05IM3gidIw==", - "dev": true, - "engines": { - "node": ">= 18.12.0" - } - }, "node_modules/@mikro-orm/core": { "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/core/-/core-6.4.6.tgz", - "integrity": "sha512-xVm/ALG/3vTMgh6SrvojJ6jjMa0s2hNzWN0triDB16BaNdLwWE4aAaAe+3CuoMFqJAArSOUISTEjExbzELB1ZA==", + "license": "MIT", "dependencies": { "dataloader": "2.2.3", "dotenv": "16.4.7", @@ -2077,10 +1092,8 @@ } }, "node_modules/@mikro-orm/knex": { - "version": "6.4.7", - "resolved": "https://registry.npmjs.org/@mikro-orm/knex/-/knex-6.4.7.tgz", - "integrity": "sha512-IH2imlCzEzPyjMGmAn/9yEP4wRxKHczCiPfI7GWAVI2dRToox1MFpQzBW1x/m+3Dvwz8jXVakHVANN7KPZBi5w==", - "dev": true, + "version": "6.4.6", + "license": "MIT", "dependencies": { "fs-extra": "11.3.0", "knex": "3.1.0", @@ -2109,8 +1122,7 @@ }, "node_modules/@mikro-orm/postgresql": { "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/postgresql/-/postgresql-6.4.6.tgz", - "integrity": "sha512-ZcuGp6n/SPzkHPANksjdLPyeu6jT7WCg3ueNViVrxdsguCi+/grz4I+hbOQDXV8uNHCAUOw6+WP2ndcVEYkZZQ==", + "license": "MIT", "dependencies": { "@mikro-orm/knex": "6.4.6", "pg": "8.13.2", @@ -2125,40 +1137,9 @@ "@mikro-orm/core": "^6.0.0" } }, - "node_modules/@mikro-orm/postgresql/node_modules/@mikro-orm/knex": { - "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/knex/-/knex-6.4.6.tgz", - "integrity": "sha512-o6t67tFH/GuPZCCEtKbTTL8HDXNgB2ITjButCTZLwteL0qI9yE/f7K6K+dEUKW+hAL3KRvc2BQeumvCVWFeISg==", - "dependencies": { - "fs-extra": "11.3.0", - "knex": "3.1.0", - "sqlstring": "2.3.3" - }, - "engines": { - "node": ">= 18.12.0" - }, - "peerDependencies": { - "@mikro-orm/core": "^6.0.0", - "better-sqlite3": "*", - "libsql": "*", - "mariadb": "*" - }, - "peerDependenciesMeta": { - "better-sqlite3": { - "optional": true - }, - "libsql": { - "optional": true - }, - "mariadb": { - "optional": true - } - } - }, "node_modules/@mikro-orm/reflection": { "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/reflection/-/reflection-6.4.6.tgz", - "integrity": "sha512-7mL7HFVnaOOhDNgLjjndWyeJUtOl2wKn0spSqB8uRjS4XtwNEGVZNkW5YD1t/x7TJ99wUhe+oRDiySciiJSeBQ==", + "license": "MIT", "dependencies": { "globby": "11.1.0", "ts-morph": "25.0.1" @@ -2170,57 +1151,9 @@ "@mikro-orm/core": "^6.0.0" } }, - "node_modules/@mikro-orm/sqlite": { - "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/sqlite/-/sqlite-6.4.6.tgz", - "integrity": "sha512-BvoLd6qge2N4P2w9yjPP8+Ya5dxxnZrS6W3B2xm0m8BUesWnaCg2pmGXQpzFjrpYMg40mZ+RJWRTPq4M2Nl4lw==", - "dependencies": { - "@mikro-orm/knex": "6.4.6", - "fs-extra": "11.3.0", - "sqlite3": "5.1.7", - "sqlstring-sqlite": "0.1.1" - }, - "engines": { - "node": ">= 18.12.0" - }, - "peerDependencies": { - "@mikro-orm/core": "^6.0.0" - } - }, - "node_modules/@mikro-orm/sqlite/node_modules/@mikro-orm/knex": { - "version": "6.4.6", - "resolved": "https://registry.npmjs.org/@mikro-orm/knex/-/knex-6.4.6.tgz", - "integrity": "sha512-o6t67tFH/GuPZCCEtKbTTL8HDXNgB2ITjButCTZLwteL0qI9yE/f7K6K+dEUKW+hAL3KRvc2BQeumvCVWFeISg==", - "dependencies": { - "fs-extra": "11.3.0", - "knex": "3.1.0", - "sqlstring": "2.3.3" - }, - "engines": { - "node": ">= 18.12.0" - }, - "peerDependencies": { - "@mikro-orm/core": "^6.0.0", - "better-sqlite3": "*", - "libsql": "*", - "mariadb": "*" - }, - "peerDependenciesMeta": { - "better-sqlite3": { - "optional": true - }, - "libsql": { - "optional": true - }, - "mariadb": { - "optional": true - } - } - }, "node_modules/@nodelib/fs.scandir": { "version": "2.1.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", - "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "license": "MIT", "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" @@ -2231,16 +1164,14 @@ }, "node_modules/@nodelib/fs.stat": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", - "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "license": "MIT", "engines": { "node": ">= 8" } }, "node_modules/@nodelib/fs.walk": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", - "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "license": "MIT", "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" @@ -2251,8 +1182,7 @@ }, "node_modules/@npmcli/fs": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-1.1.1.tgz", - "integrity": "sha512-8KG5RD0GVP4ydEzRn/I4BNDuxDtqVbOdm8675T49OIG/NGhaK0pjPX7ZcDlvKYbA+ulvVK3ztfcF4uBdOxuJbQ==", + "license": "ISC", "optional": true, "dependencies": { "@gar/promisify": "^1.0.1", @@ -2261,9 +1191,7 @@ }, "node_modules/@npmcli/move-file": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-1.1.2.tgz", - "integrity": "sha512-1SUf/Cg2GzGDyaf15aR9St9TWlb+XvbZXWpDx8YKs7MLzMH/BCeopv+y9vzrzgkfykCGuWOlSu3mZhj2+FQcrg==", - "deprecated": "This functionality has been moved to @npmcli/fs", + "license": "MIT", "optional": true, "dependencies": { "mkdirp": "^1.0.4", @@ -2275,15 +1203,13 @@ }, "node_modules/@one-ini/wasm": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/@one-ini/wasm/-/wasm-0.1.1.tgz", - "integrity": "sha512-XuySG1E38YScSJoMlqovLru4KTUNSjgVTIjyh7qMX6aNN5HY5Ct5LhRJdxO79JtTzKfzV/bnWpz+zquYrISsvw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@pkgjs/parseargs": { "version": "0.11.0", - "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", - "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", "dev": true, + "license": "MIT", "optional": true, "engines": { "node": ">=14" @@ -2291,9 +1217,8 @@ }, "node_modules/@pkgr/core": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz", - "integrity": "sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==", "dev": true, + "license": "MIT", "engines": { "node": "^12.20.0 || ^14.18.0 || >=16.0.0" }, @@ -2303,9 +1228,8 @@ }, "node_modules/@playwright/test": { "version": "1.50.1", - "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.50.1.tgz", - "integrity": "sha512-Jii3aBg+CEDpgnuDxEp/h7BimHcUTDlpEtce89xEumlJ5ef2hqepZ+PWp1DDpYC/VO9fmWVI1IlEaoI5fK9FXQ==", "dev": true, + "license": "Apache-2.0", "dependencies": { "playwright": "1.50.1" }, @@ -2318,15 +1242,13 @@ }, "node_modules/@polka/url": { "version": "1.0.0-next.28", - "resolved": "https://registry.npmjs.org/@polka/url/-/url-1.0.0-next.28.tgz", - "integrity": "sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@rollup/pluginutils": { "version": "5.1.4", - "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.1.4.tgz", - "integrity": "sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==", "dev": true, + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", @@ -2346,9 +1268,8 @@ }, "node_modules/@rollup/pluginutils/node_modules/picomatch": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz", - "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -2356,264 +1277,39 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, - "node_modules/@rollup/rollup-android-arm-eabi": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.34.9.tgz", - "integrity": "sha512-qZdlImWXur0CFakn2BJ2znJOdqYZKiedEPEVNTBrpfPjc/YuTGcaYZcdmNFTkUj3DU0ZM/AElcM8Ybww3xVLzA==", - "cpu": [ - "arm" - ], - "dev": true, - "optional": true, - "os": [ - "android" - ] - }, - "node_modules/@rollup/rollup-android-arm64": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.34.9.tgz", - "integrity": "sha512-4KW7P53h6HtJf5Y608T1ISKvNIYLWRKMvfnG0c44M6In4DQVU58HZFEVhWINDZKp7FZps98G3gxwC1sb0wXUUg==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "android" - ] - }, - "node_modules/@rollup/rollup-darwin-arm64": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.34.9.tgz", - "integrity": "sha512-0CY3/K54slrzLDjOA7TOjN1NuLKERBgk9nY5V34mhmuu673YNb+7ghaDUs6N0ujXR7fz5XaS5Aa6d2TNxZd0OQ==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "darwin" - ] - }, - "node_modules/@rollup/rollup-darwin-x64": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.34.9.tgz", - "integrity": "sha512-eOojSEAi/acnsJVYRxnMkPFqcxSMFfrw7r2iD9Q32SGkb/Q9FpUY1UlAu1DH9T7j++gZ0lHjnm4OyH2vCI7l7Q==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "darwin" - ] - }, - "node_modules/@rollup/rollup-freebsd-arm64": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.34.9.tgz", - "integrity": "sha512-2lzjQPJbN5UnHm7bHIUKFMulGTQwdvOkouJDpPysJS+QFBGDJqcfh+CxxtG23Ik/9tEvnebQiylYoazFMAgrYw==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "freebsd" - ] - }, - "node_modules/@rollup/rollup-freebsd-x64": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.34.9.tgz", - "integrity": "sha512-SLl0hi2Ah2H7xQYd6Qaiu01kFPzQ+hqvdYSoOtHYg/zCIFs6t8sV95kaoqjzjFwuYQLtOI0RZre/Ke0nPaQV+g==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "freebsd" - ] - }, - "node_modules/@rollup/rollup-linux-arm-gnueabihf": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.34.9.tgz", - "integrity": "sha512-88I+D3TeKItrw+Y/2ud4Tw0+3CxQ2kLgu3QvrogZ0OfkmX/DEppehus7L3TS2Q4lpB+hYyxhkQiYPJ6Mf5/dPg==", - "cpu": [ - "arm" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-arm-musleabihf": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.34.9.tgz", - "integrity": "sha512-3qyfWljSFHi9zH0KgtEPG4cBXHDFhwD8kwg6xLfHQ0IWuH9crp005GfoUUh/6w9/FWGBwEHg3lxK1iHRN1MFlA==", - "cpu": [ - "arm" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-arm64-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.34.9.tgz", - "integrity": "sha512-6TZjPHjKZUQKmVKMUowF3ewHxctrRR09eYyvT5eFv8w/fXarEra83A2mHTVJLA5xU91aCNOUnM+DWFMSbQ0Nxw==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-arm64-musl": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.34.9.tgz", - "integrity": "sha512-LD2fytxZJZ6xzOKnMbIpgzFOuIKlxVOpiMAXawsAZ2mHBPEYOnLRK5TTEsID6z4eM23DuO88X0Tq1mErHMVq0A==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-loongarch64-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.34.9.tgz", - "integrity": "sha512-dRAgTfDsn0TE0HI6cmo13hemKpVHOEyeciGtvlBTkpx/F65kTvShtY/EVyZEIfxFkV5JJTuQ9tP5HGBS0hfxIg==", - "cpu": [ - "loong64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-powerpc64le-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.34.9.tgz", - "integrity": "sha512-PHcNOAEhkoMSQtMf+rJofwisZqaU8iQ8EaSps58f5HYll9EAY5BSErCZ8qBDMVbq88h4UxaNPlbrKqfWP8RfJA==", - "cpu": [ - "ppc64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-riscv64-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.34.9.tgz", - "integrity": "sha512-Z2i0Uy5G96KBYKjeQFKbbsB54xFOL5/y1P5wNBsbXB8yE+At3oh0DVMjQVzCJRJSfReiB2tX8T6HUFZ2k8iaKg==", - "cpu": [ - "riscv64" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, - "node_modules/@rollup/rollup-linux-s390x-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.34.9.tgz", - "integrity": "sha512-U+5SwTMoeYXoDzJX5dhDTxRltSrIax8KWwfaaYcynuJw8mT33W7oOgz0a+AaXtGuvhzTr2tVKh5UO8GVANTxyQ==", - "cpu": [ - "s390x" - ], - "dev": true, - "optional": true, - "os": [ - "linux" - ] - }, "node_modules/@rollup/rollup-linux-x64-gnu": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.34.9.tgz", - "integrity": "sha512-FwBHNSOjUTQLP4MG7y6rR6qbGw4MFeQnIBrMe161QGaQoBQLqSUEKlHIiVgF3g/mb3lxlxzJOpIBhaP+C+KP2A==", + "version": "4.34.8", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, "node_modules/@rollup/rollup-linux-x64-musl": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.34.9.tgz", - "integrity": "sha512-cYRpV4650z2I3/s6+5/LONkjIz8MBeqrk+vPXV10ORBnshpn8S32bPqQ2Utv39jCiDcO2eJTuSlPXpnvmaIgRA==", + "version": "4.34.8", "cpu": [ "x64" ], "dev": true, + "license": "MIT", "optional": true, "os": [ "linux" ] }, - "node_modules/@rollup/rollup-win32-arm64-msvc": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.34.9.tgz", - "integrity": "sha512-z4mQK9dAN6byRA/vsSgQiPeuO63wdiDxZ9yg9iyX2QTzKuQM7T4xlBoeUP/J8uiFkqxkcWndWi+W7bXdPbt27Q==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ] - }, - "node_modules/@rollup/rollup-win32-ia32-msvc": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.34.9.tgz", - "integrity": "sha512-KB48mPtaoHy1AwDNkAJfHXvHp24H0ryZog28spEs0V48l3H1fr4i37tiyHsgKZJnCmvxsbATdZGBpbmxTE3a9w==", - "cpu": [ - "ia32" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ] - }, - "node_modules/@rollup/rollup-win32-x64-msvc": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.34.9.tgz", - "integrity": "sha512-AyleYRPU7+rgkMWbEh71fQlrzRfeP6SyMnRf9XX4fCdDPAJumdSBqYEcWPMzVQ4ScAl7E4oFfK0GUVn77xSwbw==", - "cpu": [ - "x64" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ] - }, "node_modules/@sec-ant/readable-stream": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/@sec-ant/readable-stream/-/readable-stream-0.4.1.tgz", - "integrity": "sha512-831qok9r2t8AlxLko40y2ebgSDhenenCatLVeW/uBtnHPyhHOvG0C7TvfgecV+wHzIm5KUICgzmVpWS+IMEAeg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@sindresorhus/merge-streams": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/@sindresorhus/merge-streams/-/merge-streams-4.0.0.tgz", - "integrity": "sha512-tlqY9xq5ukxTUZBmoOp+m61cqwQD5pHJtFY3Mn8CA8ps6yghLH/Hw8UPdqg4OLmFW3IFlcXnQNmo/dh8HzXYIQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -2623,8 +1319,7 @@ }, "node_modules/@tootallnate/once": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz", - "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==", + "license": "MIT", "optional": true, "engines": { "node": ">= 6" @@ -2632,8 +1327,7 @@ }, "node_modules/@ts-morph/common": { "version": "0.26.1", - "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.26.1.tgz", - "integrity": "sha512-Sn28TGl/4cFpcM+jwsH1wLncYq3FtN/BIpem+HOygfBWPT5pAeS5dB4VFVzV8FbnOKHpDLZmvAl4AjPEev5idA==", + "license": "MIT", "dependencies": { "fast-glob": "^3.3.2", "minimatch": "^9.0.4", @@ -2642,39 +1336,33 @@ }, "node_modules/@tsconfig/node10": { "version": "1.0.11", - "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.11.tgz", - "integrity": "sha512-DcRjDCujK/kCk/cUe8Xz8ZSpm8mS3mNNpta+jGCA6USEDfktlNvm1+IuZ9eTcDbNk41BHwpHHeW+N1lKCz4zOw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@tsconfig/node12": { "version": "1.0.11", - "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz", - "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@tsconfig/node14": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz", - "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@tsconfig/node16": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz", - "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@tsconfig/node22": { "version": "22.0.0", - "resolved": "https://registry.npmjs.org/@tsconfig/node22/-/node22-22.0.0.tgz", - "integrity": "sha512-twLQ77zevtxobBOD4ToAtVmuYrpeYUh3qh+TEp+08IWhpsrIflVHqQ1F1CiPxQGL7doCdBIOOCF+1Tm833faNg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/body-parser": { "version": "1.19.5", - "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", - "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==", "dev": true, + "license": "MIT", "dependencies": { "@types/connect": "*", "@types/node": "*" @@ -2682,30 +1370,26 @@ }, "node_modules/@types/connect": { "version": "3.4.38", - "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", - "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", "dev": true, + "license": "MIT", "dependencies": { "@types/node": "*" } }, "node_modules/@types/eslint-config-prettier": { "version": "6.11.3", - "resolved": "https://registry.npmjs.org/@types/eslint-config-prettier/-/eslint-config-prettier-6.11.3.tgz", - "integrity": "sha512-3wXCiM8croUnhg9LdtZUJQwNcQYGWxxdOWDjPe1ykCqJFPVpzAKfs/2dgSoCtAvdPeaponcWPI7mPcGGp9dkKQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/estree": { "version": "1.0.6", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz", - "integrity": "sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/express": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/@types/express/-/express-5.0.0.tgz", - "integrity": "sha512-DvZriSMehGHL1ZNLzi6MidnsDhUZM/x2pRdDIKdwbUNqqwHxMlRdkxtn6/EPKyqKpHqTl/4nRZsRNLpZxZRpPQ==", "dev": true, + "license": "MIT", "dependencies": { "@types/body-parser": "*", "@types/express-serve-static-core": "^5.0.0", @@ -2715,9 +1399,8 @@ }, "node_modules/@types/express-serve-static-core": { "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.6.tgz", - "integrity": "sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA==", "dev": true, + "license": "MIT", "dependencies": { "@types/node": "*", "@types/qs": "*", @@ -2727,20 +1410,17 @@ }, "node_modules/@types/http-errors": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz", - "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/js-yaml": { "version": "4.0.9", - "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz", - "integrity": "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==" + "license": "MIT" }, "node_modules/@types/jsdom": { "version": "21.1.7", - "resolved": "https://registry.npmjs.org/@types/jsdom/-/jsdom-21.1.7.tgz", - "integrity": "sha512-yOriVnggzrnQ3a9OKOCxaVuSug3w3/SbOj5i7VwXWZEyUNl3bLF9V3MfxGbZKuwqJOQyRfqXyROBB1CoZLFWzA==", "dev": true, + "license": "MIT", "dependencies": { "@types/node": "*", "@types/tough-cookie": "*", @@ -2749,42 +1429,36 @@ }, "node_modules/@types/json-schema": { "version": "7.0.15", - "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", - "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/mime": { "version": "1.3.5", - "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", - "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/node": { - "version": "22.13.8", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.8.tgz", - "integrity": "sha512-G3EfaZS+iOGYWLLRCEAXdWK9my08oHNZ+FHluRiggIYJPOXzhOiDgpVCUHaUvyIC5/fj7C/p637jdzC666AOKQ==", + "version": "22.13.4", "dev": true, + "license": "MIT", "dependencies": { "undici-types": "~6.20.0" } }, "node_modules/@types/qs": { "version": "6.9.18", - "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.18.tgz", - "integrity": "sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/range-parser": { "version": "1.2.7", - "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", - "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@types/send": { "version": "0.17.4", - "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz", - "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==", "dev": true, + "license": "MIT", "dependencies": { "@types/mime": "^1", "@types/node": "*" @@ -2792,9 +1466,8 @@ }, "node_modules/@types/serve-static": { "version": "1.15.7", - "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz", - "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==", "dev": true, + "license": "MIT", "dependencies": { "@types/http-errors": "*", "@types/node": "*", @@ -2803,21 +1476,19 @@ }, "node_modules/@types/tough-cookie": { "version": "4.0.5", - "resolved": "https://registry.npmjs.org/@types/tough-cookie/-/tough-cookie-4.0.5.tgz", - "integrity": "sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@typescript-eslint/eslint-plugin": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.25.0.tgz", - "integrity": "sha512-VM7bpzAe7JO/BFf40pIT1lJqS/z1F8OaSsUB3rpFJucQA4cOSuH2RVVVkFULN+En0Djgr29/jb4EQnedUo95KA==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/regexpp": "^4.10.0", - "@typescript-eslint/scope-manager": "8.25.0", - "@typescript-eslint/type-utils": "8.25.0", - "@typescript-eslint/utils": "8.25.0", - "@typescript-eslint/visitor-keys": "8.25.0", + "@typescript-eslint/scope-manager": "8.24.1", + "@typescript-eslint/type-utils": "8.24.1", + "@typescript-eslint/utils": "8.24.1", + "@typescript-eslint/visitor-keys": "8.24.1", "graphemer": "^1.4.0", "ignore": "^5.3.1", "natural-compare": "^1.4.0", @@ -2837,15 +1508,14 @@ } }, "node_modules/@typescript-eslint/parser": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.25.0.tgz", - "integrity": "sha512-4gbs64bnbSzu4FpgMiQ1A+D+urxkoJk/kqlDJ2W//5SygaEiAP2B4GoS7TEdxgwol2el03gckFV9lJ4QOMiiHg==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/scope-manager": "8.25.0", - "@typescript-eslint/types": "8.25.0", - "@typescript-eslint/typescript-estree": "8.25.0", - "@typescript-eslint/visitor-keys": "8.25.0", + "@typescript-eslint/scope-manager": "8.24.1", + "@typescript-eslint/types": "8.24.1", + "@typescript-eslint/typescript-estree": "8.24.1", + "@typescript-eslint/visitor-keys": "8.24.1", "debug": "^4.3.4" }, "engines": { @@ -2861,13 +1531,12 @@ } }, "node_modules/@typescript-eslint/scope-manager": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.25.0.tgz", - "integrity": "sha512-6PPeiKIGbgStEyt4NNXa2ru5pMzQ8OYKO1hX1z53HMomrmiSB+R5FmChgQAP1ro8jMtNawz+TRQo/cSXrauTpg==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.25.0", - "@typescript-eslint/visitor-keys": "8.25.0" + "@typescript-eslint/types": "8.24.1", + "@typescript-eslint/visitor-keys": "8.24.1" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -2878,13 +1547,12 @@ } }, "node_modules/@typescript-eslint/type-utils": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.25.0.tgz", - "integrity": "sha512-d77dHgHWnxmXOPJuDWO4FDWADmGQkN5+tt6SFRZz/RtCWl4pHgFl3+WdYCn16+3teG09DY6XtEpf3gGD0a186g==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/typescript-estree": "8.25.0", - "@typescript-eslint/utils": "8.25.0", + "@typescript-eslint/typescript-estree": "8.24.1", + "@typescript-eslint/utils": "8.24.1", "debug": "^4.3.4", "ts-api-utils": "^2.0.1" }, @@ -2901,10 +1569,9 @@ } }, "node_modules/@typescript-eslint/types": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.25.0.tgz", - "integrity": "sha512-+vUe0Zb4tkNgznQwicsvLUJgZIRs6ITeWSCclX1q85pR1iOiaj+4uZJIUp//Z27QWu5Cseiw3O3AR8hVpax7Aw==", + "version": "8.24.1", "dev": true, + "license": "MIT", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -2914,13 +1581,12 @@ } }, "node_modules/@typescript-eslint/typescript-estree": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.25.0.tgz", - "integrity": "sha512-ZPaiAKEZ6Blt/TPAx5Ot0EIB/yGtLI2EsGoY6F7XKklfMxYQyvtL+gT/UCqkMzO0BVFHLDlzvFqQzurYahxv9Q==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.25.0", - "@typescript-eslint/visitor-keys": "8.25.0", + "@typescript-eslint/types": "8.24.1", + "@typescript-eslint/visitor-keys": "8.24.1", "debug": "^4.3.4", "fast-glob": "^3.3.2", "is-glob": "^4.0.3", @@ -2940,15 +1606,14 @@ } }, "node_modules/@typescript-eslint/utils": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.25.0.tgz", - "integrity": "sha512-syqRbrEv0J1wywiLsK60XzHnQe/kRViI3zwFALrNEgnntn1l24Ra2KvOAWwWbWZ1lBZxZljPDGOq967dsl6fkA==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.4.0", - "@typescript-eslint/scope-manager": "8.25.0", - "@typescript-eslint/types": "8.25.0", - "@typescript-eslint/typescript-estree": "8.25.0" + "@typescript-eslint/scope-manager": "8.24.1", + "@typescript-eslint/types": "8.24.1", + "@typescript-eslint/typescript-estree": "8.24.1" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -2963,12 +1628,11 @@ } }, "node_modules/@typescript-eslint/visitor-keys": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.25.0.tgz", - "integrity": "sha512-kCYXKAum9CecGVHGij7muybDfTS2sD3t0L4bJsEZLkyrXUImiCTq1M3LG2SRtOhiHFwMR9wAFplpT6XHYjTkwQ==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/types": "8.25.0", + "@typescript-eslint/types": "8.24.1", "eslint-visitor-keys": "^4.2.0" }, "engines": { @@ -2981,9 +1645,8 @@ }, "node_modules/@typescript-eslint/visitor-keys/node_modules/eslint-visitor-keys": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", - "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -2993,9 +1656,8 @@ }, "node_modules/@vitejs/plugin-vue": { "version": "5.2.1", - "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.1.tgz", - "integrity": "sha512-cxh314tzaWwOLqVes2gnnCtvBDcM1UMdn+iFR+UjAn411dPT3tOmqrJjbMd7koZpMAmBM/GqeV4n9ge7JSiJJQ==", "dev": true, + "license": "MIT", "engines": { "node": "^18.0.0 || >=20.0.0" }, @@ -3006,9 +1668,8 @@ }, "node_modules/@vitest/eslint-plugin": { "version": "1.1.31", - "resolved": "https://registry.npmjs.org/@vitest/eslint-plugin/-/eslint-plugin-1.1.31.tgz", - "integrity": "sha512-xlsLr+e+AXZ/00eVZCtNmMeCJoJaRCoLDiAgLcxgQjSS1EertieB2MUHf8xIqPKs9lECc/UpL+y1xDcpvi02hw==", "dev": true, + "license": "MIT", "peerDependencies": { "@typescript-eslint/utils": ">= 8.0", "eslint": ">= 8.57.0", @@ -3025,13 +1686,12 @@ } }, "node_modules/@vitest/expect": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.0.7.tgz", - "integrity": "sha512-QP25f+YJhzPfHrHfYHtvRn+uvkCFCqFtW9CktfBxmB+25QqWsx7VB2As6f4GmwllHLDhXNHvqedwhvMmSnNmjw==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/spy": "3.0.7", - "@vitest/utils": "3.0.7", + "@vitest/spy": "3.0.6", + "@vitest/utils": "3.0.6", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" }, @@ -3040,12 +1700,11 @@ } }, "node_modules/@vitest/mocker": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.0.7.tgz", - "integrity": "sha512-qui+3BLz9Eonx4EAuR/i+QlCX6AUZ35taDQgwGkK/Tw6/WgwodSrjN1X2xf69IA/643ZX5zNKIn2svvtZDrs4w==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/spy": "3.0.7", + "@vitest/spy": "3.0.6", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, @@ -3067,18 +1726,16 @@ }, "node_modules/@vitest/mocker/node_modules/estree-walker": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz", - "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==", "dev": true, + "license": "MIT", "dependencies": { "@types/estree": "^1.0.0" } }, "node_modules/@vitest/pretty-format": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.0.7.tgz", - "integrity": "sha512-CiRY0BViD/V8uwuEzz9Yapyao+M9M008/9oMOSQydwbwb+CMokEq3XVaF3XK/VWaOK0Jm9z7ENhybg70Gtxsmg==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { "tinyrainbow": "^2.0.0" }, @@ -3087,12 +1744,11 @@ } }, "node_modules/@vitest/runner": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.0.7.tgz", - "integrity": "sha512-WeEl38Z0S2ZcuRTeyYqaZtm4e26tq6ZFqh5y8YD9YxfWuu0OFiGFUbnxNynwLjNRHPsXyee2M9tV7YxOTPZl2g==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/utils": "3.0.7", + "@vitest/utils": "3.0.6", "pathe": "^2.0.3" }, "funding": { @@ -3100,12 +1756,11 @@ } }, "node_modules/@vitest/snapshot": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.0.7.tgz", - "integrity": "sha512-eqTUryJWQN0Rtf5yqCGTQWsCFOQe4eNz5Twsu21xYEcnFJtMU5XvmG0vgebhdLlrHQTSq5p8vWHJIeJQV8ovsA==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/pretty-format": "3.0.7", + "@vitest/pretty-format": "3.0.6", "magic-string": "^0.30.17", "pathe": "^2.0.3" }, @@ -3114,10 +1769,9 @@ } }, "node_modules/@vitest/spy": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.0.7.tgz", - "integrity": "sha512-4T4WcsibB0B6hrKdAZTM37ekuyFZt2cGbEGd2+L0P8ov15J1/HUsUaqkXEQPNAWr4BtPPe1gI+FYfMHhEKfR8w==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { "tinyspy": "^3.0.2" }, @@ -3126,12 +1780,11 @@ } }, "node_modules/@vitest/utils": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.0.7.tgz", - "integrity": "sha512-xePVpCRfooFX3rANQjwoditoXgWb1MaFbzmGuPP59MK6i13mrnDw/yEIyJudLeW6/38mCNcwCiJIGmpDPibAIg==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/pretty-format": "3.0.7", + "@vitest/pretty-format": "3.0.6", "loupe": "^3.1.3", "tinyrainbow": "^2.0.0" }, @@ -3141,24 +1794,21 @@ }, "node_modules/@volar/language-core": { "version": "2.4.11", - "resolved": "https://registry.npmjs.org/@volar/language-core/-/language-core-2.4.11.tgz", - "integrity": "sha512-lN2C1+ByfW9/JRPpqScuZt/4OrUUse57GLI6TbLgTIqBVemdl1wNcZ1qYGEo2+Gw8coYLgCy7SuKqn6IrQcQgg==", "dev": true, + "license": "MIT", "dependencies": { "@volar/source-map": "2.4.11" } }, "node_modules/@volar/source-map": { "version": "2.4.11", - "resolved": "https://registry.npmjs.org/@volar/source-map/-/source-map-2.4.11.tgz", - "integrity": "sha512-ZQpmafIGvaZMn/8iuvCFGrW3smeqkq/IIh9F1SdSx9aUl0J4Iurzd6/FhmjNO5g2ejF3rT45dKskgXWiofqlZQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@volar/typescript": { "version": "2.4.11", - "resolved": "https://registry.npmjs.org/@volar/typescript/-/typescript-2.4.11.tgz", - "integrity": "sha512-2DT+Tdh88Spp5PyPbqhyoYavYCPDsqbHLFwcUI9K1NlY1YgUJvujGdrqUp0zWxnW7KWNTr3xSpMuv2WnaTKDAw==", "dev": true, + "license": "MIT", "dependencies": { "@volar/language-core": "2.4.11", "path-browserify": "^1.0.1", @@ -3167,15 +1817,13 @@ }, "node_modules/@vue/babel-helper-vue-transform-on": { "version": "1.2.5", - "resolved": "https://registry.npmjs.org/@vue/babel-helper-vue-transform-on/-/babel-helper-vue-transform-on-1.2.5.tgz", - "integrity": "sha512-lOz4t39ZdmU4DJAa2hwPYmKc8EsuGa2U0L9KaZaOJUt0UwQNjNA3AZTq6uEivhOKhhG1Wvy96SvYBoFmCg3uuw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/@vue/babel-plugin-jsx": { "version": "1.2.5", - "resolved": "https://registry.npmjs.org/@vue/babel-plugin-jsx/-/babel-plugin-jsx-1.2.5.tgz", - "integrity": "sha512-zTrNmOd4939H9KsRIGmmzn3q2zvv1mjxkYZHgqHZgDrXz5B1Q3WyGEjO2f+JrmKghvl1JIRcvo63LgM1kH5zFg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/helper-module-imports": "^7.24.7", "@babel/helper-plugin-utils": "^7.24.8", @@ -3199,9 +1847,8 @@ }, "node_modules/@vue/babel-plugin-resolve-type": { "version": "1.2.5", - "resolved": "https://registry.npmjs.org/@vue/babel-plugin-resolve-type/-/babel-plugin-resolve-type-1.2.5.tgz", - "integrity": "sha512-U/ibkQrf5sx0XXRnUZD1mo5F7PkpKyTbfXM3a3rC4YnUz6crHEz9Jg09jzzL6QYlXNto/9CePdOg/c87O4Nlfg==", "dev": true, + "license": "MIT", "dependencies": { "@babel/code-frame": "^7.24.7", "@babel/helper-module-imports": "^7.24.7", @@ -3215,8 +1862,7 @@ }, "node_modules/@vue/compiler-core": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.13.tgz", - "integrity": "sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==", + "license": "MIT", "dependencies": { "@babel/parser": "^7.25.3", "@vue/shared": "3.5.13", @@ -3227,8 +1873,7 @@ }, "node_modules/@vue/compiler-dom": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.13.tgz", - "integrity": "sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==", + "license": "MIT", "dependencies": { "@vue/compiler-core": "3.5.13", "@vue/shared": "3.5.13" @@ -3236,8 +1881,7 @@ }, "node_modules/@vue/compiler-sfc": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.13.tgz", - "integrity": "sha512-6VdaljMpD82w6c2749Zhf5T9u5uLBWKnVue6XWxprDobftnletJ8+oel7sexFfM3qIxNmVE7LSFGTpv6obNyaQ==", + "license": "MIT", "dependencies": { "@babel/parser": "^7.25.3", "@vue/compiler-core": "3.5.13", @@ -3252,8 +1896,7 @@ }, "node_modules/@vue/compiler-ssr": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.13.tgz", - "integrity": "sha512-wMH6vrYHxQl/IybKJagqbquvxpWCuVYpoUJfCqFZwa/JY1GdATAQ+TgVtgrwwMZ0D07QhA99rs/EAAWfvG6KpA==", + "license": "MIT", "dependencies": { "@vue/compiler-dom": "3.5.13", "@vue/shared": "3.5.13" @@ -3261,9 +1904,8 @@ }, "node_modules/@vue/compiler-vue2": { "version": "2.7.16", - "resolved": "https://registry.npmjs.org/@vue/compiler-vue2/-/compiler-vue2-2.7.16.tgz", - "integrity": "sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==", "dev": true, + "license": "MIT", "dependencies": { "de-indent": "^1.0.2", "he": "^1.2.0" @@ -3271,14 +1913,12 @@ }, "node_modules/@vue/devtools-api": { "version": "6.6.4", - "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-6.6.4.tgz", - "integrity": "sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==" + "license": "MIT" }, "node_modules/@vue/devtools-core": { "version": "7.7.2", - "resolved": "https://registry.npmjs.org/@vue/devtools-core/-/devtools-core-7.7.2.tgz", - "integrity": "sha512-lexREWj1lKi91Tblr38ntSsy6CvI8ba7u+jmwh2yruib/ltLUcsIzEjCnrkh1yYGGIKXbAuYV2tOG10fGDB9OQ==", "dev": true, + "license": "MIT", "dependencies": { "@vue/devtools-kit": "^7.7.2", "@vue/devtools-shared": "^7.7.2", @@ -3292,9 +1932,7 @@ } }, "node_modules/@vue/devtools-core/node_modules/nanoid": { - "version": "5.1.2", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.2.tgz", - "integrity": "sha512-b+CiXQCNMUGe0Ri64S9SXFcP9hogjAJ2Rd6GdVxhPLRm7mhGaM7VgOvCAJ1ZshfHbqVDI3uqTI5C8/GaKuLI7g==", + "version": "5.1.0", "dev": true, "funding": [ { @@ -3302,6 +1940,7 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "bin": { "nanoid": "bin/nanoid.js" }, @@ -3311,9 +1950,8 @@ }, "node_modules/@vue/devtools-kit": { "version": "7.7.2", - "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.2.tgz", - "integrity": "sha512-CY0I1JH3Z8PECbn6k3TqM1Bk9ASWxeMtTCvZr7vb+CHi+X/QwQm5F1/fPagraamKMAHVfuuCbdcnNg1A4CYVWQ==", "dev": true, + "license": "MIT", "dependencies": { "@vue/devtools-shared": "^7.7.2", "birpc": "^0.2.19", @@ -3326,18 +1964,16 @@ }, "node_modules/@vue/devtools-shared": { "version": "7.7.2", - "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.2.tgz", - "integrity": "sha512-uBFxnp8gwW2vD6FrJB8JZLUzVb6PNRG0B0jBnHsOH8uKyva2qINY8PTF5Te4QlTbMDqU5K6qtJDr6cNsKWhbOA==", "dev": true, + "license": "MIT", "dependencies": { "rfdc": "^1.4.1" } }, "node_modules/@vue/eslint-config-prettier": { "version": "10.2.0", - "resolved": "https://registry.npmjs.org/@vue/eslint-config-prettier/-/eslint-config-prettier-10.2.0.tgz", - "integrity": "sha512-GL3YBLwv/+b86yHcNNfPJxOTtVFJ4Mbc9UU3zR+KVoG7SwGTjPT+32fXamscNumElhcpXW3mT0DgzS9w32S7Bw==", "dev": true, + "license": "MIT", "dependencies": { "eslint-config-prettier": "^10.0.1", "eslint-plugin-prettier": "^5.2.2" @@ -3349,9 +1985,8 @@ }, "node_modules/@vue/eslint-config-typescript": { "version": "14.4.0", - "resolved": "https://registry.npmjs.org/@vue/eslint-config-typescript/-/eslint-config-typescript-14.4.0.tgz", - "integrity": "sha512-daU+eAekEeVz3CReE4PRW25fe+OJDKwE28jHN6LimDEnuFMbJ6H4WGogEpNof276wVP6UvzOeJQfLFjB5mW29A==", "dev": true, + "license": "MIT", "dependencies": { "@typescript-eslint/utils": "^8.23.0", "fast-glob": "^3.3.3", @@ -3373,10 +2008,9 @@ } }, "node_modules/@vue/language-core": { - "version": "2.2.6", - "resolved": "https://registry.npmjs.org/@vue/language-core/-/language-core-2.2.6.tgz", - "integrity": "sha512-7IQTvwVOvhYSzcizZ2hAdqJjI+SaJS2GO7EnDlSlQ77drwl5UzNa2IZm9pO9MdMxrlw24CGI/Lo3xpCjM26veg==", + "version": "2.2.2", "dev": true, + "license": "MIT", "dependencies": { "@volar/language-core": "~2.4.11", "@vue/compiler-dom": "^3.5.0", @@ -3398,16 +2032,14 @@ }, "node_modules/@vue/reactivity": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.13.tgz", - "integrity": "sha512-NaCwtw8o48B9I6L1zl2p41OHo/2Z4wqYGGIK1Khu5T7yxrn+ATOixn/Udn2m+6kZKB/J7cuT9DbWWhRxqixACg==", + "license": "MIT", "dependencies": { "@vue/shared": "3.5.13" } }, "node_modules/@vue/runtime-core": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.13.tgz", - "integrity": "sha512-Fj4YRQ3Az0WTZw1sFe+QDb0aXCerigEpw418pw1HBUKFtnQHWzwojaukAs2X/c9DQz4MQ4bsXTGlcpGxU/RCIw==", + "license": "MIT", "dependencies": { "@vue/reactivity": "3.5.13", "@vue/shared": "3.5.13" @@ -3415,8 +2047,7 @@ }, "node_modules/@vue/runtime-dom": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.13.tgz", - "integrity": "sha512-dLaj94s93NYLqjLiyFzVs9X6dWhTdAlEAciC3Moq7gzAc13VJUdCnjjRurNM6uTLFATRHexHCTu/Xp3eW6yoog==", + "license": "MIT", "dependencies": { "@vue/reactivity": "3.5.13", "@vue/runtime-core": "3.5.13", @@ -3426,8 +2057,7 @@ }, "node_modules/@vue/server-renderer": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.13.tgz", - "integrity": "sha512-wAi4IRJV/2SAW3htkTlB+dHeRmpTiVIK1OGLWV1yeStVSebSQQOwGwIq0D3ZIoBj2C2qpgz5+vX9iEBkTdk5YA==", + "license": "MIT", "dependencies": { "@vue/compiler-ssr": "3.5.13", "@vue/shared": "3.5.13" @@ -3438,14 +2068,12 @@ }, "node_modules/@vue/shared": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.13.tgz", - "integrity": "sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==" + "license": "MIT" }, "node_modules/@vue/test-utils": { "version": "2.4.6", - "resolved": "https://registry.npmjs.org/@vue/test-utils/-/test-utils-2.4.6.tgz", - "integrity": "sha512-FMxEjOpYNYiFe0GkaHsnJPXFHxQ6m4t8vI/ElPGpMWxZKpmRvQ33OIrvRXemy6yha03RxhOlQuy+gZMC3CQSow==", "dev": true, + "license": "MIT", "dependencies": { "js-beautify": "^1.14.9", "vue-component-type-helpers": "^2.0.0" @@ -3453,9 +2081,8 @@ }, "node_modules/@vue/tsconfig": { "version": "0.7.0", - "resolved": "https://registry.npmjs.org/@vue/tsconfig/-/tsconfig-0.7.0.tgz", - "integrity": "sha512-ku2uNz5MaZ9IerPPUyOHzyjhXoX2kVJaVf7hL315DC17vS6IiZRmmCPfggNbU16QTvM80+uYYy3eYJB59WCtvg==", "dev": true, + "license": "MIT", "peerDependencies": { "typescript": "5.x", "vue": "^3.4.0" @@ -3470,19 +2097,28 @@ } }, "node_modules/abbrev": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-2.0.0.tgz", - "integrity": "sha512-6/mh1E2u2YgEsCHdY0Yx5oW+61gZU+1vXaoiHHrpKeuRNNgFvS+/jrwHiQhB5apAf5oB7UB7E19ol2R2LKH8hQ==", + "version": "3.0.0", "dev": true, + "license": "ISC", "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": "^18.17.0 || >=20.5.0" + } + }, + "node_modules/accepts": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "mime-types": "^3.0.0", + "negotiator": "^1.0.0" + }, + "engines": { + "node": ">= 0.6" } }, "node_modules/acorn": { "version": "8.14.0", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz", - "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==", "dev": true, + "license": "MIT", "bin": { "acorn": "bin/acorn" }, @@ -3492,18 +2128,16 @@ }, "node_modules/acorn-jsx": { "version": "5.3.2", - "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", - "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", "dev": true, + "license": "MIT", "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "node_modules/acorn-walk": { "version": "8.3.4", - "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz", - "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==", "dev": true, + "license": "MIT", "dependencies": { "acorn": "^8.11.0" }, @@ -3512,21 +2146,16 @@ } }, "node_modules/agent-base": { - "version": "6.0.2", - "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", - "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", - "optional": true, - "dependencies": { - "debug": "4" - }, + "version": "7.1.3", + "dev": true, + "license": "MIT", "engines": { - "node": ">= 6.0.0" + "node": ">= 14" } }, "node_modules/agentkeepalive": { "version": "4.6.0", - "resolved": "https://registry.npmjs.org/agentkeepalive/-/agentkeepalive-4.6.0.tgz", - "integrity": "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ==", + "license": "MIT", "optional": true, "dependencies": { "humanize-ms": "^1.2.1" @@ -3537,8 +2166,7 @@ }, "node_modules/aggregate-error": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/aggregate-error/-/aggregate-error-3.1.0.tgz", - "integrity": "sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==", + "license": "MIT", "optional": true, "dependencies": { "clean-stack": "^2.0.0", @@ -3550,9 +2178,8 @@ }, "node_modules/ajv": { "version": "6.12.6", - "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", - "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", "dev": true, + "license": "MIT", "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", @@ -3565,16 +2192,14 @@ } }, "node_modules/alien-signals": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/alien-signals/-/alien-signals-1.0.4.tgz", - "integrity": "sha512-DJqqQD3XcsaQcQ1s+iE2jDUZmmQpXwHiR6fCAim/w87luaW+vmLY8fMlrdkmRwzaFXhkxf3rqPCR59tKVv1MDw==", - "dev": true + "version": "1.0.3", + "dev": true, + "license": "MIT" }, "node_modules/ansi-regex": { "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -3584,9 +2209,8 @@ }, "node_modules/ansi-styles": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", "dev": true, + "license": "MIT", "dependencies": { "color-convert": "^2.0.1" }, @@ -3599,15 +2223,12 @@ }, "node_modules/aproba": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.0.0.tgz", - "integrity": "sha512-lYe4Gx7QT+MKGbDsA+Z+he/Wtef0BiwDOlK/XkBrdfsh9J/jPPXbX0tE9x9cl27Tmu5gg3QUbUrQYa/y+KOHPQ==", + "license": "ISC", "optional": true }, "node_modules/are-we-there-yet": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-3.0.1.tgz", - "integrity": "sha512-QZW4EDmGwlYur0Yyf/b2uGucHQMa8aFUP7eu9ddR73vvhFyt4V0Vl3QHPcTNJ8l6qYOBdxgXdnBXQrHilfRQBg==", - "deprecated": "This package is no longer supported.", + "license": "ISC", "optional": true, "dependencies": { "delegates": "^1.0.0", @@ -3619,41 +2240,47 @@ }, "node_modules/arg": { "version": "4.1.3", - "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz", - "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/argparse": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", - "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==" + "license": "Python-2.0" }, "node_modules/array-union": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", - "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/assertion-error": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz", - "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" } }, + "node_modules/asynckit": { + "version": "0.4.0", + "license": "MIT" + }, + "node_modules/axios": { + "version": "1.8.1", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, "node_modules/balanced-match": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", - "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==" + "license": "MIT" }, "node_modules/base64-js": { "version": "1.5.1", - "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", - "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", "funding": [ { "type": "github", @@ -3667,53 +2294,79 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/bindings": { "version": "1.5.0", - "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz", - "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==", + "license": "MIT", "dependencies": { "file-uri-to-path": "1.0.0" } }, "node_modules/birpc": { "version": "0.2.19", - "resolved": "https://registry.npmjs.org/birpc/-/birpc-0.2.19.tgz", - "integrity": "sha512-5WeXXAvTmitV1RqJFppT5QtUiz2p1mRSYU000Jkft5ZUCLJIk4uQriYNO50HknxKwM6jd8utNc66K1qGIwwWBQ==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/antfu" } }, "node_modules/bl": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", - "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", + "license": "MIT", "dependencies": { "buffer": "^5.5.0", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, + "node_modules/body-parser": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "bytes": "^3.1.2", + "content-type": "^1.0.5", + "debug": "^4.4.0", + "http-errors": "^2.0.0", + "iconv-lite": "^0.5.2", + "on-finished": "^2.4.1", + "qs": "^6.14.0", + "raw-body": "^3.0.0", + "type-is": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/body-parser/node_modules/qs": { + "version": "6.14.0", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/boolbase": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", - "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/brace-expansion": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", - "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" } }, "node_modules/braces": { "version": "3.0.3", - "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", - "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "license": "MIT", "dependencies": { "fill-range": "^7.1.1" }, @@ -3723,8 +2376,6 @@ }, "node_modules/browserslist": { "version": "4.24.4", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz", - "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==", "dev": true, "funding": [ { @@ -3740,6 +2391,7 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { "caniuse-lite": "^1.0.30001688", "electron-to-chromium": "^1.5.73", @@ -3755,8 +2407,6 @@ }, "node_modules/buffer": { "version": "5.7.1", - "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", - "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", "funding": [ { "type": "github", @@ -3771,6 +2421,7 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" @@ -3778,9 +2429,8 @@ }, "node_modules/bundle-name": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz", - "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==", "dev": true, + "license": "MIT", "dependencies": { "run-applescript": "^7.0.0" }, @@ -3791,19 +2441,24 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/bytes": { + "version": "3.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/cac": { "version": "6.7.14", - "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz", - "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/cacache": { "version": "15.3.0", - "resolved": "https://registry.npmjs.org/cacache/-/cacache-15.3.0.tgz", - "integrity": "sha512-VVdYzXEn+cnbXpFgWs5hTT7OScegHVmLhJIR8Ufqk3iFD6A6j5iSX1KuBTfNEv4tdJWE2PzA6IVFtcLC7fN9wQ==", + "license": "ISC", "optional": true, "dependencies": { "@npmcli/fs": "^1.0.0", @@ -3831,8 +2486,7 @@ }, "node_modules/cacache/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", "optional": true, "dependencies": { "balanced-match": "^1.0.0", @@ -3841,9 +2495,7 @@ }, "node_modules/cacache/node_modules/glob": { "version": "7.2.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", - "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", - "deprecated": "Glob versions prior to v9 are no longer supported", + "license": "ISC", "optional": true, "dependencies": { "fs.realpath": "^1.0.0", @@ -3862,8 +2514,7 @@ }, "node_modules/cacache/node_modules/lru-cache": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -3874,8 +2525,7 @@ }, "node_modules/cacache/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", "optional": true, "dependencies": { "brace-expansion": "^1.1.7" @@ -3886,8 +2536,7 @@ }, "node_modules/cacache/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -3896,19 +2545,46 @@ "node": ">=8" } }, + "node_modules/cacache/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.3", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/callsites": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", - "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/caniuse-lite": { - "version": "1.0.30001701", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001701.tgz", - "integrity": "sha512-faRs/AW3jA9nTwmJBSO1PQ6L/EOgsB5HMQQq4iCu5zhPgVVgO/pZRHlmatwijZKetFw8/Pr4q6dEN8sJuq8qTw==", + "version": "1.0.30001700", "dev": true, "funding": [ { @@ -3923,13 +2599,13 @@ "type": "github", "url": "https://github.com/sponsors/ai" } - ] + ], + "license": "CC-BY-4.0" }, "node_modules/chai": { "version": "5.2.0", - "resolved": "https://registry.npmjs.org/chai/-/chai-5.2.0.tgz", - "integrity": "sha512-mCuXncKXk5iCLhfhwTc0izo0gtEmpz5CtG2y8GiOINBlMVS6v8TMRc5TaLWKS6692m9+dVVfzgeVxR5UxWHTYw==", "dev": true, + "license": "MIT", "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", @@ -3943,9 +2619,8 @@ }, "node_modules/chalk": { "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", - "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" @@ -3959,25 +2634,22 @@ }, "node_modules/check-error": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz", - "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==", "dev": true, + "license": "MIT", "engines": { "node": ">= 16" } }, "node_modules/chownr": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz", - "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==", + "license": "ISC", "engines": { "node": ">=10" } }, "node_modules/clean-stack": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/clean-stack/-/clean-stack-2.2.0.tgz", - "integrity": "sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==", + "license": "MIT", "optional": true, "engines": { "node": ">=6" @@ -3985,9 +2657,8 @@ }, "node_modules/cliui": { "version": "8.0.1", - "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", - "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", "dev": true, + "license": "ISC", "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.1", @@ -3999,24 +2670,21 @@ }, "node_modules/cliui/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/cliui/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/cliui/node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, + "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -4028,9 +2696,8 @@ }, "node_modules/cliui/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -4040,9 +2707,8 @@ }, "node_modules/cliui/node_modules/wrap-ansi": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", - "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", @@ -4057,14 +2723,12 @@ }, "node_modules/code-block-writer": { "version": "13.0.3", - "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-13.0.3.tgz", - "integrity": "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==" + "license": "MIT" }, "node_modules/color-convert": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", - "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", "dev": true, + "license": "MIT", "dependencies": { "color-name": "~1.1.4" }, @@ -4074,14 +2738,12 @@ }, "node_modules/color-name": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/color-support": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz", - "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==", + "license": "ISC", "optional": true, "bin": { "color-support": "bin.js" @@ -4089,28 +2751,34 @@ }, "node_modules/colorette": { "version": "2.0.19", - "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.19.tgz", - "integrity": "sha512-3tlv/dIP7FWvj3BsbHrGLJ6l/oKh1O3TcgBqMn+yyCagOxc23fyzDS6HypQbgxWbkpDnf52p1LuR4eWDQ/K9WQ==" + "license": "MIT" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } }, "node_modules/commander": { "version": "10.0.1", - "resolved": "https://registry.npmjs.org/commander/-/commander-10.0.1.tgz", - "integrity": "sha512-y4Mg2tXshplEbSGzx7amzPwKKOCGuoSRP/CjEdwwk0FOGlUbq6lKuoyDZTNZkmxHdJtp54hdfY/JUrdL7Xfdug==", + "license": "MIT", "engines": { "node": ">=14" } }, "node_modules/concat-map": { "version": "0.0.1", - "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", - "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", - "devOptional": true + "devOptional": true, + "license": "MIT" }, "node_modules/config-chain": { "version": "1.1.13", - "resolved": "https://registry.npmjs.org/config-chain/-/config-chain-1.1.13.tgz", - "integrity": "sha512-qj+f8APARXHrM0hraqXYb2/bOVSV4PvJQlNZ/DVj0QrmNM2q2euizkeuVckQ57J+W0mRH6Hvi+k50M4Jul2VRQ==", "dev": true, + "license": "MIT", "dependencies": { "ini": "^1.3.4", "proto-list": "~1.2.1" @@ -4118,21 +2786,49 @@ }, "node_modules/console-control-strings": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz", - "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==", + "license": "ISC", "optional": true }, + "node_modules/content-disposition": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/convert-source-map": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", - "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/cookie": { + "version": "0.7.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.2.2", + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } }, "node_modules/copy-anything": { "version": "3.0.5", - "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-3.0.5.tgz", - "integrity": "sha512-yCEafptTtb4bk7GLEQoM8KVJpxAfdBJYaXyzQEgQQQgYrZiDp8SJmGKlYza6CYjEDNstAdNdKA3UuoULlEbS6w==", "dev": true, + "license": "MIT", "dependencies": { "is-what": "^4.1.8" }, @@ -4145,15 +2841,13 @@ }, "node_modules/create-require": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz", - "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/cross-spawn": { "version": "7.0.6", - "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", - "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", "dev": true, + "license": "MIT", "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", @@ -4165,9 +2859,8 @@ }, "node_modules/cssesc": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", - "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", "dev": true, + "license": "MIT", "bin": { "cssesc": "bin/cssesc" }, @@ -4175,26 +2868,46 @@ "node": ">=4" } }, + "node_modules/cssstyle": { + "version": "4.2.1", + "dev": true, + "license": "MIT", + "dependencies": { + "@asamuzakjp/css-color": "^2.8.2", + "rrweb-cssom": "^0.8.0" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/csstype": { "version": "3.1.3", - "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", - "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==" + "license": "MIT" + }, + "node_modules/data-urls": { + "version": "5.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "whatwg-mimetype": "^4.0.0", + "whatwg-url": "^14.0.0" + }, + "engines": { + "node": ">=18" + } }, "node_modules/dataloader": { "version": "2.2.3", - "resolved": "https://registry.npmjs.org/dataloader/-/dataloader-2.2.3.tgz", - "integrity": "sha512-y2krtASINtPFS1rSDjacrFgn1dcUuoREVabwlOGOe4SdxenREqwjwjElAdwvbGM7kgZz9a3KVicWR7vcz8rnzA==" + "license": "MIT" }, "node_modules/de-indent": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/de-indent/-/de-indent-1.0.2.tgz", - "integrity": "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/debug": { "version": "4.4.0", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", - "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "license": "MIT", "dependencies": { "ms": "^2.1.3" }, @@ -4207,10 +2920,14 @@ } } }, + "node_modules/decimal.js": { + "version": "10.5.0", + "dev": true, + "license": "MIT" + }, "node_modules/decompress-response": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz", - "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==", + "license": "MIT", "dependencies": { "mimic-response": "^3.1.0" }, @@ -4223,32 +2940,28 @@ }, "node_modules/deep-eql": { "version": "5.0.2", - "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz", - "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/deep-extend": { "version": "0.6.0", - "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz", - "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==", + "license": "MIT", "engines": { "node": ">=4.0.0" } }, "node_modules/deep-is": { "version": "0.1.4", - "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", - "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/default-browser": { "version": "5.2.1", - "resolved": "https://registry.npmjs.org/default-browser/-/default-browser-5.2.1.tgz", - "integrity": "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg==", "dev": true, + "license": "MIT", "dependencies": { "bundle-name": "^4.1.0", "default-browser-id": "^5.0.0" @@ -4262,9 +2975,8 @@ }, "node_modules/default-browser-id": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/default-browser-id/-/default-browser-id-5.0.0.tgz", - "integrity": "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -4274,9 +2986,8 @@ }, "node_modules/define-lazy-prop": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-3.0.0.tgz", - "integrity": "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -4284,33 +2995,51 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, "node_modules/delegates": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz", - "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==", + "license": "MIT", "optional": true }, + "node_modules/depd": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, "node_modules/detect-libc": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.0.3.tgz", - "integrity": "sha512-bwy0MGW55bG41VqxxypOsdSdGqLwXPI/focwgTYCFMbdUiBAxLg9CFzG08sz2aqzknwiX7Hkl0bQENjg8iLByw==", + "license": "Apache-2.0", "engines": { "node": ">=8" } }, "node_modules/diff": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.2.tgz", - "integrity": "sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==", "dev": true, + "license": "BSD-3-Clause", "engines": { "node": ">=0.3.1" } }, "node_modules/dir-glob": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", - "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "license": "MIT", "dependencies": { "path-type": "^4.0.0" }, @@ -4320,8 +3049,7 @@ }, "node_modules/dotenv": { "version": "16.4.7", - "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz", - "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==", + "license": "BSD-2-Clause", "engines": { "node": ">=12" }, @@ -4329,6 +3057,18 @@ "url": "https://dotenvx.com" } }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/dwengo-1-backend": { "resolved": "backend", "link": true @@ -4339,15 +3079,13 @@ }, "node_modules/eastasianwidth": { "version": "0.2.0", - "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", - "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/editorconfig": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/editorconfig/-/editorconfig-1.0.4.tgz", - "integrity": "sha512-L9Qe08KWTlqYMVvMcTIvMAdl1cDUubzRNYL+WfA4bLDMHe4nemKkpmYzkznE1FwLKu0EEmy6obgQKzMJrg4x9Q==", "dev": true, + "license": "MIT", "dependencies": { "@one-ini/wasm": "0.1.1", "commander": "^10.0.0", @@ -4363,9 +3101,8 @@ }, "node_modules/editorconfig/node_modules/minimatch": { "version": "9.0.1", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.1.tgz", - "integrity": "sha512-0jWhJpD/MdhPXwPuiRkCbfYfSKp2qnn2eOc279qI7f+osl/l+prKSrvhg157zSYvx/1nmgn2NqdT6k2Z7zSH9w==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" }, @@ -4376,39 +3113,56 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/ee-first": { + "version": "1.1.1", + "license": "MIT" + }, "node_modules/electron-to-chromium": { - "version": "1.5.109", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.109.tgz", - "integrity": "sha512-AidaH9JETVRr9DIPGfp1kAarm/W6hRJTPuCnkF+2MqhF4KaAgRIcBc8nvjk+YMXZhwfISof/7WG29eS4iGxQLQ==", - "dev": true + "version": "1.5.102", + "dev": true, + "license": "ISC" }, "node_modules/emoji-regex": { "version": "9.2.2", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", - "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } }, "node_modules/encoding": { "version": "0.1.13", - "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz", - "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==", + "license": "MIT", "optional": true, "dependencies": { "iconv-lite": "^0.6.2" } }, + "node_modules/encoding/node_modules/iconv-lite": { + "version": "0.6.3", + "license": "MIT", + "optional": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/end-of-stream": { "version": "1.4.4", - "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz", - "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==", + "license": "MIT", "dependencies": { "once": "^1.4.0" } }, "node_modules/entities": { "version": "4.5.0", - "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz", - "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==", + "license": "BSD-2-Clause", "engines": { "node": ">=0.12" }, @@ -4418,8 +3172,7 @@ }, "node_modules/env-paths": { "version": "2.2.1", - "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz", - "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==", + "license": "MIT", "optional": true, "engines": { "node": ">=6" @@ -4427,31 +3180,64 @@ }, "node_modules/err-code": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz", - "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==", + "license": "MIT", "optional": true }, "node_modules/error-stack-parser-es": { "version": "0.1.5", - "resolved": "https://registry.npmjs.org/error-stack-parser-es/-/error-stack-parser-es-0.1.5.tgz", - "integrity": "sha512-xHku1X40RO+fO8yJ8Wh2f2rZWVjqyhb1zgq1yZ8aZRQkv6OOKhKWRUaht3eSCUbAOBaKIgM+ykwFLE+QUxgGeg==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/antfu" } }, + "node_modules/es-define-property": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/es-module-lexer": { "version": "1.6.0", - "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.6.0.tgz", - "integrity": "sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } }, "node_modules/esbuild": { "version": "0.25.0", - "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.0.tgz", - "integrity": "sha512-BXq5mqc8ltbaN34cDqWuYKyNhX8D/Z0J1xdtdQ8UcIIIyJyz+ZMKUt58tF3SrZ85jcfN/PZYhjR5uDQAYNVbuw==", "dev": true, "hasInstallScript": true, + "license": "MIT", "bin": { "esbuild": "bin/esbuild" }, @@ -4488,17 +3274,19 @@ }, "node_modules/escalade": { "version": "3.2.0", - "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", - "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", "engines": { "node": ">=6" } }, + "node_modules/escape-html": { + "version": "1.0.3", + "license": "MIT" + }, "node_modules/escape-string-regexp": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", - "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", "dev": true, + "license": "MIT", "engines": { "node": ">=10" }, @@ -4507,21 +3295,20 @@ } }, "node_modules/eslint": { - "version": "9.21.0", - "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.21.0.tgz", - "integrity": "sha512-KjeihdFqTPhOMXTt7StsDxriV4n66ueuF/jfPNC3j/lduHwr/ijDwJMsF+wyMJethgiKi5wniIE243vi07d3pg==", + "version": "9.20.1", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.12.1", - "@eslint/config-array": "^0.19.2", - "@eslint/core": "^0.12.0", - "@eslint/eslintrc": "^3.3.0", - "@eslint/js": "9.21.0", - "@eslint/plugin-kit": "^0.2.7", + "@eslint/config-array": "^0.19.0", + "@eslint/core": "^0.11.0", + "@eslint/eslintrc": "^3.2.0", + "@eslint/js": "9.20.0", + "@eslint/plugin-kit": "^0.2.5", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", - "@humanwhocodes/retry": "^0.4.2", + "@humanwhocodes/retry": "^0.4.1", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", @@ -4566,10 +3353,9 @@ } }, "node_modules/eslint-config-prettier": { - "version": "10.0.2", - "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-10.0.2.tgz", - "integrity": "sha512-1105/17ZIMjmCOJOPNfVdbXafLCLj3hPmkmB7dLgt7XsQ/zkxSuDerE/xgO3RxoHysR1N1whmquY0lSn2O0VLg==", + "version": "10.0.1", "dev": true, + "license": "MIT", "bin": { "eslint-config-prettier": "build/bin/cli.js" }, @@ -4577,11 +3363,41 @@ "eslint": ">=7.0.0" } }, + "node_modules/eslint-plugin-playwright": { + "version": "2.2.0", + "dev": true, + "license": "MIT", + "workspaces": [ + "examples" + ], + "dependencies": { + "globals": "^13.23.0" + }, + "engines": { + "node": ">=16.6.0" + }, + "peerDependencies": { + "eslint": ">=8.40.0" + } + }, + "node_modules/eslint-plugin-playwright/node_modules/globals": { + "version": "13.24.0", + "dev": true, + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/eslint-plugin-prettier": { "version": "5.2.3", - "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.3.tgz", - "integrity": "sha512-qJ+y0FfCp/mQYQ/vWQ3s7eUlFEL4PyKfAJxsnYTJ4YT73nsJBWqmEpFryxV9OeUiqmsTsYJ5Y+KDNaeP31wrRw==", "dev": true, + "license": "MIT", "dependencies": { "prettier-linter-helpers": "^1.0.0", "synckit": "^0.9.1" @@ -4609,9 +3425,8 @@ }, "node_modules/eslint-plugin-vue": { "version": "9.32.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-vue/-/eslint-plugin-vue-9.32.0.tgz", - "integrity": "sha512-b/Y05HYmnB/32wqVcjxjHZzNpwxj1onBOvqW89W+V+XNG1dRuaFbNd3vT9CLbr2LXjEoq+3vn8DanWf7XU22Ug==", "dev": true, + "license": "MIT", "dependencies": { "@eslint-community/eslint-utils": "^4.4.0", "globals": "^13.24.0", @@ -4631,9 +3446,8 @@ }, "node_modules/eslint-plugin-vue/node_modules/globals": { "version": "13.24.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", - "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", "dev": true, + "license": "MIT", "dependencies": { "type-fest": "^0.20.2" }, @@ -4646,9 +3460,8 @@ }, "node_modules/eslint-scope": { "version": "8.2.0", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.2.0.tgz", - "integrity": "sha512-PHlWUfG6lvPc3yvP5A4PNyBL1W8fkDUccmI21JUu/+GKZBoH/W5u6usENXUrWFRsyoW5ACUjFGgAFQp5gUlb/A==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" @@ -4662,9 +3475,8 @@ }, "node_modules/eslint-visitor-keys": { "version": "3.4.3", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", - "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^12.22.0 || ^14.17.0 || >=16.0.0" }, @@ -4674,9 +3486,8 @@ }, "node_modules/eslint/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", "dev": true, + "license": "MIT", "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" @@ -4684,9 +3495,8 @@ }, "node_modules/eslint/node_modules/eslint-visitor-keys": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", - "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -4696,9 +3506,8 @@ }, "node_modules/eslint/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", "dev": true, + "license": "ISC", "dependencies": { "brace-expansion": "^1.1.7" }, @@ -4708,17 +3517,15 @@ }, "node_modules/esm": { "version": "3.2.25", - "resolved": "https://registry.npmjs.org/esm/-/esm-3.2.25.tgz", - "integrity": "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==", + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/espree": { "version": "10.3.0", - "resolved": "https://registry.npmjs.org/espree/-/espree-10.3.0.tgz", - "integrity": "sha512-0QYC8b24HWY8zjRnDTL6RiHfDbAWn63qb4LMj1Z4b076A4une81+z03Kg7l7mn/48PUTqoLptSXez8oknU8Clg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "acorn": "^8.14.0", "acorn-jsx": "^5.3.2", @@ -4733,9 +3540,8 @@ }, "node_modules/espree/node_modules/eslint-visitor-keys": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.0.tgz", - "integrity": "sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==", "dev": true, + "license": "Apache-2.0", "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" }, @@ -4745,8 +3551,7 @@ }, "node_modules/esprima": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", - "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "license": "BSD-2-Clause", "bin": { "esparse": "bin/esparse.js", "esvalidate": "bin/esvalidate.js" @@ -4757,9 +3562,8 @@ }, "node_modules/esquery": { "version": "1.6.0", - "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", - "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", "dev": true, + "license": "BSD-3-Clause", "dependencies": { "estraverse": "^5.1.0" }, @@ -4769,9 +3573,8 @@ }, "node_modules/esrecurse": { "version": "4.3.0", - "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", - "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "estraverse": "^5.2.0" }, @@ -4781,32 +3584,35 @@ }, "node_modules/estraverse": { "version": "5.3.0", - "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", - "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=4.0" } }, "node_modules/estree-walker": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", - "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==" + "license": "MIT" }, "node_modules/esutils": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", - "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", "dev": true, + "license": "BSD-2-Clause", "engines": { "node": ">=0.10.0" } }, + "node_modules/etag": { + "version": "1.8.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/execa": { "version": "9.5.2", - "resolved": "https://registry.npmjs.org/execa/-/execa-9.5.2.tgz", - "integrity": "sha512-EHlpxMCpHWSAh1dgS6bVeoLAXGnJNdR93aabr4QCGbzOM73o5XmRfM/e5FUqsw3aagP8S8XEWUWFAxnRBnAF0Q==", "dev": true, + "license": "MIT", "dependencies": { "@sindresorhus/merge-streams": "^4.0.0", "cross-spawn": "^7.0.3", @@ -4830,37 +3636,92 @@ }, "node_modules/expand-template": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/expand-template/-/expand-template-2.0.3.tgz", - "integrity": "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==", + "license": "(MIT OR WTFPL)", "engines": { "node": ">=6" } }, "node_modules/expect-type": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.0.tgz", - "integrity": "sha512-80F22aiJ3GLyVnS/B3HzgR6RelZVumzj9jkL0Rhz4h0xYbNW9PjlQz5h3J/SShErbXBc295vseR4/MIbVmUbeA==", + "version": "1.1.0", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=12.0.0" } }, + "node_modules/express": { + "version": "5.0.1", + "license": "MIT", + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.0.1", + "content-disposition": "^1.0.0", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "^1.2.1", + "debug": "4.3.6", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "^2.0.0", + "fresh": "2.0.0", + "http-errors": "2.0.0", + "merge-descriptors": "^2.0.0", + "methods": "~1.1.2", + "mime-types": "^3.0.0", + "on-finished": "2.4.1", + "once": "1.4.0", + "parseurl": "~1.3.3", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "router": "^2.0.0", + "safe-buffer": "5.2.1", + "send": "^1.1.0", + "serve-static": "^2.1.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "^2.0.0", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/express/node_modules/debug": { + "version": "4.3.6", + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.1.2", + "license": "MIT" + }, "node_modules/fast-deep-equal": { "version": "3.1.3", - "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", - "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-diff": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz", - "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==", - "dev": true + "dev": true, + "license": "Apache-2.0" }, "node_modules/fast-glob": { "version": "3.3.3", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", - "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "license": "MIT", "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", @@ -4874,8 +3735,7 @@ }, "node_modules/fast-glob/node_modules/glob-parent": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", - "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", "dependencies": { "is-glob": "^4.0.1" }, @@ -4885,29 +3745,25 @@ }, "node_modules/fast-json-stable-stringify": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", - "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fast-levenshtein": { "version": "2.0.6", - "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", - "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/fastq": { - "version": "1.19.1", - "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", - "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "version": "1.19.0", + "license": "ISC", "dependencies": { "reusify": "^1.0.4" } }, "node_modules/figlet": { "version": "1.8.0", - "resolved": "https://registry.npmjs.org/figlet/-/figlet-1.8.0.tgz", - "integrity": "sha512-chzvGjd+Sp7KUvPHZv6EXV5Ir3Q7kYNpCr4aHrRW79qFtTefmQZNny+W1pW9kf5zeE6dikku2W50W/wAH2xWgw==", "dev": true, + "license": "MIT", "bin": { "figlet": "bin/index.js" }, @@ -4917,9 +3773,8 @@ }, "node_modules/figures": { "version": "6.1.0", - "resolved": "https://registry.npmjs.org/figures/-/figures-6.1.0.tgz", - "integrity": "sha512-d+l3qxjSesT4V7v2fh+QnmFnUWv9lSpjarhShNTgBOfA0ttejbQUAlHLitbjkoRiDulW0OPoQPYIGhIC8ohejg==", "dev": true, + "license": "MIT", "dependencies": { "is-unicode-supported": "^2.0.0" }, @@ -4932,9 +3787,8 @@ }, "node_modules/file-entry-cache": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", - "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", "dev": true, + "license": "MIT", "dependencies": { "flat-cache": "^4.0.0" }, @@ -4944,13 +3798,11 @@ }, "node_modules/file-uri-to-path": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz", - "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==" + "license": "MIT" }, "node_modules/fill-range": { "version": "7.1.1", - "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", - "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "license": "MIT", "dependencies": { "to-regex-range": "^5.0.1" }, @@ -4958,11 +3810,44 @@ "node": ">=8" } }, + "node_modules/finalhandler": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/encodeurl": { + "version": "1.0.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, "node_modules/find-up": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", - "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", "dev": true, + "license": "MIT", "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" @@ -4976,9 +3861,8 @@ }, "node_modules/flat-cache": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", - "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", "dev": true, + "license": "MIT", "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" @@ -4989,17 +3873,33 @@ }, "node_modules/flatted": { "version": "3.3.3", - "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", - "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", - "dev": true + "dev": true, + "license": "ISC" + }, + "node_modules/follow-redirects": { + "version": "1.15.9", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } }, "node_modules/foreground-child": { - "version": "3.3.1", - "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", - "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "version": "3.3.0", "dev": true, + "license": "ISC", "dependencies": { - "cross-spawn": "^7.0.6", + "cross-spawn": "^7.0.0", "signal-exit": "^4.0.1" }, "engines": { @@ -5009,15 +3909,57 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/form-data": { + "version": "4.0.2", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/form-data/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/form-data/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/fs-constants": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", - "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" + "license": "MIT" }, "node_modules/fs-extra": { "version": "11.3.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz", - "integrity": "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==", + "license": "MIT", "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", @@ -5029,8 +3971,7 @@ }, "node_modules/fs-minipass": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz", - "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==", + "license": "ISC", "dependencies": { "minipass": "^3.0.0" }, @@ -5040,8 +3981,7 @@ }, "node_modules/fs-minipass/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "dependencies": { "yallist": "^4.0.0" }, @@ -5049,39 +3989,25 @@ "node": ">=8" } }, + "node_modules/fs-minipass/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC" + }, "node_modules/fs.realpath": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", - "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "license": "ISC", "optional": true }, - "node_modules/fsevents": { - "version": "2.3.2", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", - "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", - "dev": true, - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, "node_modules/function-bind": { "version": "1.1.2", - "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", - "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/gauge": { "version": "4.0.4", - "resolved": "https://registry.npmjs.org/gauge/-/gauge-4.0.4.tgz", - "integrity": "sha512-f9m+BEN5jkg6a0fZjleidjN51VE1X+mPFQ2DJ0uv1V39oCLCbsGe6yjbBnp7eK7z/+GAon99a3nHuqbuuthyPg==", - "deprecated": "This package is no longer supported.", + "license": "ISC", "optional": true, "dependencies": { "aproba": "^1.0.3 || ^2.0.0", @@ -5099,8 +4025,7 @@ }, "node_modules/gauge/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", "optional": true, "engines": { "node": ">=8" @@ -5108,20 +4033,17 @@ }, "node_modules/gauge/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT", "optional": true }, "node_modules/gauge/node_modules/signal-exit": { "version": "3.0.7", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", - "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "license": "ISC", "optional": true }, "node_modules/gauge/node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", "optional": true, "dependencies": { "emoji-regex": "^8.0.0", @@ -5134,8 +4056,7 @@ }, "node_modules/gauge/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", "optional": true, "dependencies": { "ansi-regex": "^5.0.1" @@ -5146,35 +4067,64 @@ }, "node_modules/gensync": { "version": "1.0.0-beta.2", - "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", - "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/get-caller-file": { "version": "2.0.5", - "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", - "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", "dev": true, + "license": "ISC", "engines": { "node": "6.* || 8.* || >= 10.*" } }, + "node_modules/get-intrinsic": { + "version": "1.2.7", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "function-bind": "^1.1.2", + "get-proto": "^1.0.0", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/get-package-type": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", - "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "license": "MIT", "engines": { "node": ">=8.0.0" } }, + "node_modules/get-proto": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/get-stream": { "version": "9.0.1", - "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-9.0.1.tgz", - "integrity": "sha512-kVCxPF3vQM/N0B1PmoqVUqgHP+EeVjmZSQn+1oCRPxd2P21P2F19lIgbR3HBosbB1PUhOAoctJnfEn2GbN2eZA==", "dev": true, + "license": "MIT", "dependencies": { "@sec-ant/readable-stream": "^0.4.1", "is-stream": "^4.0.1" @@ -5188,9 +4138,8 @@ }, "node_modules/get-tsconfig": { "version": "4.10.0", - "resolved": "https://registry.npmjs.org/get-tsconfig/-/get-tsconfig-4.10.0.tgz", - "integrity": "sha512-kGzZ3LWWQcGIAmg6iWvXn0ei6WDtV26wzHRMwDSzmAbcXrTEXxHy6IehI6/4eT6VRKyMP1eF1VqwrVUmE/LR7A==", "dev": true, + "license": "MIT", "dependencies": { "resolve-pkg-maps": "^1.0.0" }, @@ -5200,19 +4149,16 @@ }, "node_modules/getopts": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/getopts/-/getopts-2.3.0.tgz", - "integrity": "sha512-5eDf9fuSXwxBL6q5HX+dhDj+dslFGWzU5thZ9kNKUkcPtaPdatmUFKwHFrLb/uf/WpA4BHET+AX3Scl56cAjpA==" + "license": "MIT" }, "node_modules/github-from-package": { "version": "0.0.0", - "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz", - "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==" + "license": "MIT" }, "node_modules/glob": { "version": "10.4.5", - "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", - "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", "dev": true, + "license": "ISC", "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", @@ -5230,9 +4176,8 @@ }, "node_modules/glob-parent": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", - "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", "dev": true, + "license": "ISC", "dependencies": { "is-glob": "^4.0.3" }, @@ -5242,9 +4187,8 @@ }, "node_modules/globals": { "version": "14.0.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", - "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -5254,8 +4198,7 @@ }, "node_modules/globby": { "version": "11.1.0", - "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", - "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "license": "MIT", "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", @@ -5271,36 +4214,64 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/gopd": { + "version": "1.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/graceful-fs": { "version": "4.2.11", - "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", - "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==" + "license": "ISC" }, "node_modules/graphemer": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", - "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/has-flag": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", - "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, + "node_modules/has-symbols": { + "version": "1.1.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/has-unicode": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz", - "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==", + "license": "ISC", "optional": true }, "node_modules/hasown": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", - "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", "dependencies": { "function-bind": "^1.1.2" }, @@ -5310,24 +4281,32 @@ }, "node_modules/he": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", - "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", "dev": true, + "license": "MIT", "bin": { "he": "bin/he" } }, "node_modules/hookable": { "version": "5.5.3", - "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz", - "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/html-encoding-sniffer": { + "version": "4.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "whatwg-encoding": "^3.1.1" + }, + "engines": { + "node": ">=18" + } }, "node_modules/html-tags": { "version": "3.3.1", - "resolved": "https://registry.npmjs.org/html-tags/-/html-tags-3.3.1.tgz", - "integrity": "sha512-ztqyC3kLto0e9WbNp0aeP+M3kTt+nbaIveGmUxAtZa+8iFgKLUOD4YKM5j+f3QD89bra7UeumolZHKuOXnTmeQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" }, @@ -5337,62 +4316,68 @@ }, "node_modules/http-cache-semantics": { "version": "4.1.1", - "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.1.1.tgz", - "integrity": "sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==", + "license": "BSD-2-Clause", "optional": true }, - "node_modules/http-proxy-agent": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz", - "integrity": "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==", - "optional": true, + "node_modules/http-errors": { + "version": "2.0.0", + "license": "MIT", "dependencies": { - "@tootallnate/once": "1", - "agent-base": "6", - "debug": "4" + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" }, "engines": { - "node": ">= 6" + "node": ">= 0.8" + } + }, + "node_modules/http-proxy-agent": { + "version": "7.0.2", + "dev": true, + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.0", + "debug": "^4.3.4" + }, + "engines": { + "node": ">= 14" } }, "node_modules/https-proxy-agent": { - "version": "5.0.1", - "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", - "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", - "optional": true, + "version": "7.0.6", + "dev": true, + "license": "MIT", "dependencies": { - "agent-base": "6", + "agent-base": "^7.1.2", "debug": "4" }, "engines": { - "node": ">= 6" + "node": ">= 14" } }, "node_modules/human-signals": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-8.0.0.tgz", - "integrity": "sha512-/1/GPCpDUCCYwlERiYjxoczfP0zfvZMU/OWgQPMya9AbAE24vseigFdhAMObpc8Q4lc/kjutPfUddDYyAmejnA==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=18.18.0" } }, "node_modules/humanize-ms": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/humanize-ms/-/humanize-ms-1.2.1.tgz", - "integrity": "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==", + "license": "MIT", "optional": true, "dependencies": { "ms": "^2.0.0" } }, "node_modules/iconv-lite": { - "version": "0.6.3", - "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", - "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", - "optional": true, + "version": "0.5.2", + "license": "MIT", "dependencies": { - "safer-buffer": ">= 2.1.2 < 3.0.0" + "safer-buffer": ">= 2.1.2 < 3" }, "engines": { "node": ">=0.10.0" @@ -5400,8 +4385,6 @@ }, "node_modules/ieee754": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", - "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", "funding": [ { "type": "github", @@ -5415,21 +4398,20 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "BSD-3-Clause" }, "node_modules/ignore": { "version": "5.3.2", - "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", - "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "license": "MIT", "engines": { "node": ">= 4" } }, "node_modules/import-fresh": { "version": "3.3.1", - "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", - "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", "dev": true, + "license": "MIT", "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" @@ -5443,17 +4425,15 @@ }, "node_modules/imurmurhash": { "version": "0.1.4", - "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", - "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", "devOptional": true, + "license": "MIT", "engines": { "node": ">=0.8.19" } }, "node_modules/indent-string": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", - "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "license": "MIT", "optional": true, "engines": { "node": ">=8" @@ -5461,15 +4441,12 @@ }, "node_modules/infer-owner": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/infer-owner/-/infer-owner-1.0.4.tgz", - "integrity": "sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==", + "license": "ISC", "optional": true }, "node_modules/inflight": { "version": "1.0.6", - "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", - "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", - "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "license": "ISC", "optional": true, "dependencies": { "once": "^1.3.0", @@ -5478,26 +4455,22 @@ }, "node_modules/inherits": { "version": "2.0.4", - "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", - "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==" + "license": "ISC" }, "node_modules/ini": { "version": "1.3.8", - "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", - "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==" + "license": "ISC" }, "node_modules/interpret": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/interpret/-/interpret-2.2.0.tgz", - "integrity": "sha512-Ju0Bz/cEia55xDwUWEa8+olFpCiQoypjnQySseKtmjNrnps3P+xfpUmGr90T7yjlVJmOtybRvPXhKMbHr+fWnw==", + "license": "MIT", "engines": { "node": ">= 0.10" } }, "node_modules/ip-address": { "version": "9.0.5", - "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz", - "integrity": "sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==", + "license": "MIT", "optional": true, "dependencies": { "jsbn": "1.1.0", @@ -5507,10 +4480,16 @@ "node": ">= 12" } }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, "node_modules/is-core-module": { "version": "2.16.1", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", - "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "license": "MIT", "dependencies": { "hasown": "^2.0.2" }, @@ -5523,9 +4502,8 @@ }, "node_modules/is-docker": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-3.0.0.tgz", - "integrity": "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==", "dev": true, + "license": "MIT", "bin": { "is-docker": "cli.js" }, @@ -5538,25 +4516,22 @@ }, "node_modules/is-extglob": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", - "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/is-fullwidth-code-point": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", - "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", "devOptional": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/is-glob": { "version": "4.0.3", - "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", - "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", "dependencies": { "is-extglob": "^2.1.1" }, @@ -5566,9 +4541,8 @@ }, "node_modules/is-inside-container": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/is-inside-container/-/is-inside-container-1.0.0.tgz", - "integrity": "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==", "dev": true, + "license": "MIT", "dependencies": { "is-docker": "^3.0.0" }, @@ -5584,23 +4558,20 @@ }, "node_modules/is-lambda": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-lambda/-/is-lambda-1.0.1.tgz", - "integrity": "sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==", + "license": "MIT", "optional": true }, "node_modules/is-number": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", - "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", "engines": { "node": ">=0.12.0" } }, "node_modules/is-plain-obj": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", - "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -5608,11 +4579,19 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/is-potential-custom-element-name": { + "version": "1.0.1", + "dev": true, + "license": "MIT" + }, + "node_modules/is-promise": { + "version": "4.0.0", + "license": "MIT" + }, "node_modules/is-stream": { "version": "4.0.1", - "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz", - "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -5622,9 +4601,8 @@ }, "node_modules/is-unicode-supported": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-2.1.0.tgz", - "integrity": "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -5634,9 +4612,8 @@ }, "node_modules/is-what": { "version": "4.1.16", - "resolved": "https://registry.npmjs.org/is-what/-/is-what-4.1.16.tgz", - "integrity": "sha512-ZhMwEosbFJkA0YhFnNDgTM4ZxDRsS6HqTo7qsZM08fehyRYIYa0yHu5R6mgo1n/8MgaPBXiPimPD77baVFYg+A==", "dev": true, + "license": "MIT", "engines": { "node": ">=12.13" }, @@ -5646,9 +4623,8 @@ }, "node_modules/is-wsl": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz", - "integrity": "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw==", "dev": true, + "license": "MIT", "dependencies": { "is-inside-container": "^1.0.0" }, @@ -5661,15 +4637,13 @@ }, "node_modules/isexe": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", - "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", - "devOptional": true + "devOptional": true, + "license": "ISC" }, "node_modules/jackspeak": { "version": "3.4.3", - "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", - "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", "dev": true, + "license": "BlueOak-1.0.0", "dependencies": { "@isaacs/cliui": "^8.0.2" }, @@ -5682,24 +4656,22 @@ }, "node_modules/jiti": { "version": "2.4.2", - "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.4.2.tgz", - "integrity": "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A==", "dev": true, + "license": "MIT", "bin": { "jiti": "lib/jiti-cli.mjs" } }, "node_modules/js-beautify": { - "version": "1.15.4", - "resolved": "https://registry.npmjs.org/js-beautify/-/js-beautify-1.15.4.tgz", - "integrity": "sha512-9/KXeZUKKJwqCXUdBxFJ3vPh467OCckSBmYDwSK/EtV090K+iMJ7zx2S3HLVDIWFQdqMIsZWbnaGiba18aWhaA==", + "version": "1.15.3", "dev": true, + "license": "MIT", "dependencies": { "config-chain": "^1.1.13", "editorconfig": "^1.0.4", "glob": "^10.4.2", "js-cookie": "^3.0.5", - "nopt": "^7.2.1" + "nopt": "^8.0.0" }, "bin": { "css-beautify": "js/bin/css-beautify.js", @@ -5712,23 +4684,20 @@ }, "node_modules/js-cookie": { "version": "3.0.5", - "resolved": "https://registry.npmjs.org/js-cookie/-/js-cookie-3.0.5.tgz", - "integrity": "sha512-cEiJEAEoIbWfCZYKWhVwFuvPX1gETRYPw6LlaTKoxD3s2AkXzkCjnp6h0V77ozyqj0jakteJ4YqDJT830+lVGw==", "dev": true, + "license": "MIT", "engines": { "node": ">=14" } }, "node_modules/js-tokens": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", - "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/js-yaml": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", - "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", "dependencies": { "argparse": "^2.0.1" }, @@ -5738,15 +4707,60 @@ }, "node_modules/jsbn": { "version": "1.1.0", - "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz", - "integrity": "sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==", + "license": "MIT", "optional": true }, + "node_modules/jsdom": { + "version": "26.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "cssstyle": "^4.2.1", + "data-urls": "^5.0.0", + "decimal.js": "^10.4.3", + "form-data": "^4.0.1", + "html-encoding-sniffer": "^4.0.0", + "http-proxy-agent": "^7.0.2", + "https-proxy-agent": "^7.0.6", + "is-potential-custom-element-name": "^1.0.1", + "nwsapi": "^2.2.16", + "parse5": "^7.2.1", + "rrweb-cssom": "^0.8.0", + "saxes": "^6.0.0", + "symbol-tree": "^3.2.4", + "tough-cookie": "^5.0.0", + "w3c-xmlserializer": "^5.0.0", + "webidl-conversions": "^7.0.0", + "whatwg-encoding": "^3.1.1", + "whatwg-mimetype": "^4.0.0", + "whatwg-url": "^14.1.0", + "ws": "^8.18.0", + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "canvas": "^3.0.0" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "node_modules/jsdom/node_modules/xml-name-validator": { + "version": "5.0.0", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18" + } + }, "node_modules/jsesc": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", - "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", "dev": true, + "license": "MIT", "bin": { "jsesc": "bin/jsesc" }, @@ -5756,36 +4770,31 @@ }, "node_modules/json-buffer": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", - "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json-parse-even-better-errors": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-4.0.0.tgz", - "integrity": "sha512-lR4MXjGNgkJc7tkQ97kb2nuEMnNCyU//XYVH0MKTGcXEiSudQ5MKGKen3C5QubYy0vmq+JGitUg92uuywGEwIA==", "dev": true, + "license": "MIT", "engines": { "node": "^18.17.0 || >=20.5.0" } }, "node_modules/json-schema-traverse": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", - "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json-stable-stringify-without-jsonify": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", - "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/json5": { "version": "2.2.3", - "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", - "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", "dev": true, + "license": "MIT", "bin": { "json5": "lib/cli.js" }, @@ -5795,8 +4804,7 @@ }, "node_modules/jsonfile": { "version": "6.1.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", - "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "license": "MIT", "dependencies": { "universalify": "^2.0.0" }, @@ -5806,17 +4814,15 @@ }, "node_modules/keyv": { "version": "4.5.4", - "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", - "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", "dev": true, + "license": "MIT", "dependencies": { "json-buffer": "3.0.1" } }, "node_modules/knex": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/knex/-/knex-3.1.0.tgz", - "integrity": "sha512-GLoII6hR0c4ti243gMs5/1Rb3B+AjwMOfjYm97pu0FOQa7JH56hgBxYf5WK2525ceSbBY1cjeZ9yk99GPMB6Kw==", + "license": "MIT", "dependencies": { "colorette": "2.0.19", "commander": "^10.0.0", @@ -5865,8 +4871,7 @@ }, "node_modules/knex/node_modules/debug": { "version": "4.3.4", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz", - "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==", + "license": "MIT", "dependencies": { "ms": "2.1.2" }, @@ -5881,28 +4886,24 @@ }, "node_modules/knex/node_modules/ms": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", - "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==" + "license": "MIT" }, "node_modules/knex/node_modules/resolve-from": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/kolorist": { "version": "1.8.0", - "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz", - "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/levn": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", - "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" @@ -5913,9 +4914,8 @@ }, "node_modules/locate-path": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", - "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", "dev": true, + "license": "MIT", "dependencies": { "p-locate": "^5.0.0" }, @@ -5928,45 +4928,38 @@ }, "node_modules/lodash": { "version": "4.17.21", - "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", - "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==" + "license": "MIT" }, "node_modules/lodash.merge": { "version": "4.6.2", - "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", - "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/loupe": { "version": "3.1.3", - "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.1.3.tgz", - "integrity": "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/lru-cache": { "version": "10.4.3", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", - "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/magic-string": { "version": "0.30.17", - "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz", - "integrity": "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==", + "license": "MIT", "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0" } }, "node_modules/make-error": { "version": "1.3.6", - "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz", - "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/make-fetch-happen": { "version": "9.1.0", - "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-9.1.0.tgz", - "integrity": "sha512-+zopwDy7DNknmwPQplem5lAZX/eCOzSvSNNcSKm5eVwTkOBzoktEfXsa9L23J/GIRhxRsaxzkPEhrJEpE2F4Gg==", + "license": "ISC", "optional": true, "dependencies": { "agentkeepalive": "^4.1.3", @@ -5990,10 +4983,45 @@ "node": ">= 10" } }, + "node_modules/make-fetch-happen/node_modules/agent-base": { + "version": "6.0.2", + "license": "MIT", + "optional": true, + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/make-fetch-happen/node_modules/http-proxy-agent": { + "version": "4.0.1", + "license": "MIT", + "optional": true, + "dependencies": { + "@tootallnate/once": "1", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/make-fetch-happen/node_modules/https-proxy-agent": { + "version": "5.0.1", + "license": "MIT", + "optional": true, + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, "node_modules/make-fetch-happen/node_modules/lru-cache": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6004,8 +5032,7 @@ }, "node_modules/make-fetch-happen/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6014,27 +5041,67 @@ "node": ">=8" } }, + "node_modules/make-fetch-happen/node_modules/negotiator": { + "version": "0.6.4", + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/make-fetch-happen/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "1.1.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/memorystream": { "version": "0.3.1", - "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", - "integrity": "sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==", "dev": true, "engines": { "node": ">= 0.10.0" } }, + "node_modules/merge-descriptors": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/merge2": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", - "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "license": "MIT", "engines": { "node": ">= 8" } }, + "node_modules/methods": { + "version": "1.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, "node_modules/micromatch": { "version": "4.0.8", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", - "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "license": "MIT", "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" @@ -6045,16 +5112,31 @@ }, "node_modules/mikro-orm": { "version": "6.4.6", - "resolved": "https://registry.npmjs.org/mikro-orm/-/mikro-orm-6.4.6.tgz", - "integrity": "sha512-Lr3uFK06O/4F/AtQAsuYD6QH7DgmUooSVFVGf1y02IuiKVFKOMJ4iKimkRMyoA+ykKhgYIp8WiaEqbWJVuz4Vw==", + "license": "MIT", "engines": { "node": ">= 18.12.0" } }, + "node_modules/mime-db": { + "version": "1.53.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "mime-db": "^1.53.0" + }, + "engines": { + "node": ">= 0.6" + } + }, "node_modules/mimic-response": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz", - "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==", + "license": "MIT", "engines": { "node": ">=10" }, @@ -6064,8 +5146,7 @@ }, "node_modules/minimatch": { "version": "9.0.5", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", - "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "license": "ISC", "dependencies": { "brace-expansion": "^2.0.1" }, @@ -6078,25 +5159,22 @@ }, "node_modules/minimist": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", - "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/minipass": { "version": "7.1.2", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", - "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", "dev": true, + "license": "ISC", "engines": { "node": ">=16 || 14 >=14.17" } }, "node_modules/minipass-collect": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-1.0.2.tgz", - "integrity": "sha512-6T6lH0H8OG9kITm/Jm6tdooIbogG9e0tLgpY6mphXSm/A9u8Nq1ryBG+Qspiub9LjWlBPsPS3tWQ/Botq4FdxA==", + "license": "ISC", "optional": true, "dependencies": { "minipass": "^3.0.0" @@ -6107,8 +5185,7 @@ }, "node_modules/minipass-collect/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6117,10 +5194,14 @@ "node": ">=8" } }, + "node_modules/minipass-collect/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/minipass-fetch": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-1.4.1.tgz", - "integrity": "sha512-CGH1eblLq26Y15+Azk7ey4xh0J/XfJfrCox5LDJiKqI2Q2iwOLOKrlmIaODiSQS8d18jalF6y2K2ePUm0CmShw==", + "license": "MIT", "optional": true, "dependencies": { "minipass": "^3.1.0", @@ -6136,8 +5217,7 @@ }, "node_modules/minipass-fetch/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6146,10 +5226,14 @@ "node": ">=8" } }, + "node_modules/minipass-fetch/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/minipass-flush": { "version": "1.0.5", - "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.5.tgz", - "integrity": "sha512-JmQSYYpPUqX5Jyn1mXaRwOda1uQ8HP5KAT/oDSLCzt1BYRhQU0/hDtsB1ufZfEEzMZ9aAVmsBw8+FWsIXlClWw==", + "license": "ISC", "optional": true, "dependencies": { "minipass": "^3.0.0" @@ -6160,8 +5244,7 @@ }, "node_modules/minipass-flush/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6170,10 +5253,14 @@ "node": ">=8" } }, + "node_modules/minipass-flush/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/minipass-pipeline": { "version": "1.2.4", - "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz", - "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==", + "license": "ISC", "optional": true, "dependencies": { "minipass": "^3.0.0" @@ -6184,8 +5271,7 @@ }, "node_modules/minipass-pipeline/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6194,10 +5280,14 @@ "node": ">=8" } }, + "node_modules/minipass-pipeline/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/minipass-sized": { "version": "1.0.3", - "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz", - "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==", + "license": "ISC", "optional": true, "dependencies": { "minipass": "^3.0.0" @@ -6208,8 +5298,7 @@ }, "node_modules/minipass-sized/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -6218,10 +5307,14 @@ "node": ">=8" } }, + "node_modules/minipass-sized/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/minizlib": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz", - "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==", + "license": "MIT", "dependencies": { "minipass": "^3.0.0", "yallist": "^4.0.0" @@ -6232,8 +5325,7 @@ }, "node_modules/minizlib/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "dependencies": { "yallist": "^4.0.0" }, @@ -6241,16 +5333,18 @@ "node": ">=8" } }, + "node_modules/minizlib/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC" + }, "node_modules/mitt": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz", - "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/mkdirp": { "version": "1.0.4", - "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz", - "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==", + "license": "MIT", "bin": { "mkdirp": "bin/cmd.js" }, @@ -6260,39 +5354,34 @@ }, "node_modules/mkdirp-classic": { "version": "0.5.3", - "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz", - "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==" + "license": "MIT" }, "node_modules/mrmime": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz", - "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=10" } }, "node_modules/ms": { "version": "2.1.3", - "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", - "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==" + "license": "MIT" }, "node_modules/muggle-string": { "version": "0.4.1", - "resolved": "https://registry.npmjs.org/muggle-string/-/muggle-string-0.4.1.tgz", - "integrity": "sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/nanoid": { "version": "3.3.8", - "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz", - "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==", "funding": [ { "type": "github", "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "bin": { "nanoid": "bin/nanoid.cjs" }, @@ -6302,28 +5391,23 @@ }, "node_modules/napi-build-utils": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/napi-build-utils/-/napi-build-utils-2.0.0.tgz", - "integrity": "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==" + "license": "MIT" }, "node_modules/natural-compare": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", - "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/negotiator": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz", - "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==", - "optional": true, + "version": "1.0.0", + "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/node-abi": { "version": "3.74.0", - "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.74.0.tgz", - "integrity": "sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w==", + "license": "MIT", "dependencies": { "semver": "^7.3.5" }, @@ -6333,13 +5417,11 @@ }, "node_modules/node-addon-api": { "version": "7.1.1", - "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-7.1.1.tgz", - "integrity": "sha512-5m3bsyrjFWE1xf7nz7YXdN4udnVtXK6/Yfgn5qnahL6bCkf2yKt4k3nuTKAtT4r3IG8JNR2ncsIMdZuAzJjHQQ==" + "license": "MIT" }, "node_modules/node-gyp": { "version": "8.4.1", - "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-8.4.1.tgz", - "integrity": "sha512-olTJRgUtAb/hOXG0E93wZDs5YiJlgbXxTwQAFHyNlRsXQnYzUaF2aGgujZbw+hR8aF4ZG/rST57bWMWD16jr9w==", + "license": "MIT", "optional": true, "dependencies": { "env-paths": "^2.2.0", @@ -6362,14 +5444,12 @@ }, "node_modules/node-gyp/node_modules/abbrev": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", - "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==", + "license": "ISC", "optional": true }, "node_modules/node-gyp/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", "optional": true, "dependencies": { "balanced-match": "^1.0.0", @@ -6378,9 +5458,7 @@ }, "node_modules/node-gyp/node_modules/glob": { "version": "7.2.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", - "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", - "deprecated": "Glob versions prior to v9 are no longer supported", + "license": "ISC", "optional": true, "dependencies": { "fs.realpath": "^1.0.0", @@ -6399,8 +5477,7 @@ }, "node_modules/node-gyp/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", "optional": true, "dependencies": { "brace-expansion": "^1.1.7" @@ -6411,8 +5488,7 @@ }, "node_modules/node-gyp/node_modules/nopt": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz", - "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==", + "license": "ISC", "optional": true, "dependencies": { "abbrev": "1" @@ -6426,39 +5502,35 @@ }, "node_modules/node-releases": { "version": "2.0.19", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", - "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/nopt": { - "version": "7.2.1", - "resolved": "https://registry.npmjs.org/nopt/-/nopt-7.2.1.tgz", - "integrity": "sha512-taM24ViiimT/XntxbPyJQzCG+p4EKOpgD3mxFwW38mGjVUrfERQOeY4EDHjdnptttfHuHQXFx+lTP08Q+mLa/w==", + "version": "8.1.0", "dev": true, + "license": "ISC", "dependencies": { - "abbrev": "^2.0.0" + "abbrev": "^3.0.0" }, "bin": { "nopt": "bin/nopt.js" }, "engines": { - "node": "^14.17.0 || ^16.13.0 || >=18.0.0" + "node": "^18.17.0 || >=20.5.0" } }, "node_modules/npm-normalize-package-bin": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/npm-normalize-package-bin/-/npm-normalize-package-bin-4.0.0.tgz", - "integrity": "sha512-TZKxPvItzai9kN9H/TkmCtx/ZN/hvr3vUycjlfmH0ootY9yFBzNOpiXAdIn1Iteqsvk4lQn6B5PTrt+n6h8k/w==", "dev": true, + "license": "ISC", "engines": { "node": "^18.17.0 || >=20.5.0" } }, "node_modules/npm-run-all2": { "version": "7.0.2", - "resolved": "https://registry.npmjs.org/npm-run-all2/-/npm-run-all2-7.0.2.tgz", - "integrity": "sha512-7tXR+r9hzRNOPNTvXegM+QzCuMjzUIIq66VDunL6j60O4RrExx32XUhlrS7UK4VcdGw5/Wxzb3kfNcFix9JKDA==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^6.2.1", "cross-spawn": "^7.0.6", @@ -6482,9 +5554,8 @@ }, "node_modules/npm-run-all2/node_modules/ansi-styles": { "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -6494,18 +5565,16 @@ }, "node_modules/npm-run-all2/node_modules/isexe": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.1.tgz", - "integrity": "sha512-LpB/54B+/2J5hqQ7imZHfdU31OlgQqx7ZicVlkm9kzg9/w8GKLEcFfJl/t7DCEDueOyBAD6zCCwTO6Fzs0NoEQ==", "dev": true, + "license": "ISC", "engines": { "node": ">=16" } }, "node_modules/npm-run-all2/node_modules/which": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz", - "integrity": "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==", "dev": true, + "license": "ISC", "dependencies": { "isexe": "^3.1.1" }, @@ -6518,9 +5587,8 @@ }, "node_modules/npm-run-path": { "version": "6.0.0", - "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-6.0.0.tgz", - "integrity": "sha512-9qny7Z9DsQU8Ou39ERsPU4OZQlSTP47ShQzuKZ6PRXpYLtIFgl/DEBYEXKlvcEa+9tHVcK8CF81Y2V72qaZhWA==", "dev": true, + "license": "MIT", "dependencies": { "path-key": "^4.0.0", "unicorn-magic": "^0.3.0" @@ -6534,9 +5602,8 @@ }, "node_modules/npm-run-path/node_modules/path-key": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz", - "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -6546,9 +5613,7 @@ }, "node_modules/npmlog": { "version": "6.0.2", - "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-6.0.2.tgz", - "integrity": "sha512-/vBvz5Jfr9dT/aFWd0FIRf+T/Q2WBsLENygUaFUqstqsycmZAP/t5BvFJTK0viFmSUxiUKTUplWy5vt+rvKIxg==", - "deprecated": "This package is no longer supported.", + "license": "ISC", "optional": true, "dependencies": { "are-we-there-yet": "^3.0.0", @@ -6562,9 +5627,8 @@ }, "node_modules/nth-check": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", - "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "boolbase": "^1.0.0" }, @@ -6572,19 +5636,42 @@ "url": "https://github.com/fb55/nth-check?sponsor=1" } }, + "node_modules/nwsapi": { + "version": "2.2.16", + "dev": true, + "license": "MIT" + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, "node_modules/once": { "version": "1.4.0", - "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", - "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", "dependencies": { "wrappy": "1" } }, "node_modules/open": { "version": "10.1.0", - "resolved": "https://registry.npmjs.org/open/-/open-10.1.0.tgz", - "integrity": "sha512-mnkeQ1qP5Ue2wd+aivTD3NHd/lZ96Lu0jgf0pwktLPtx6cTZiH7tyeGRRHs0zX0rbrahXPnXlUnbeXyaBBuIaw==", "dev": true, + "license": "MIT", "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", @@ -6600,9 +5687,8 @@ }, "node_modules/optionator": { "version": "0.9.4", - "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", - "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", "dev": true, + "license": "MIT", "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", @@ -6617,9 +5703,8 @@ }, "node_modules/p-limit": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", "dev": true, + "license": "MIT", "dependencies": { "yocto-queue": "^0.1.0" }, @@ -6632,9 +5717,8 @@ }, "node_modules/p-locate": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", - "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", "dev": true, + "license": "MIT", "dependencies": { "p-limit": "^3.0.2" }, @@ -6647,8 +5731,7 @@ }, "node_modules/p-map": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/p-map/-/p-map-4.0.0.tgz", - "integrity": "sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==", + "license": "MIT", "optional": true, "dependencies": { "aggregate-error": "^3.0.0" @@ -6662,15 +5745,13 @@ }, "node_modules/package-json-from-dist": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", - "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", - "dev": true + "dev": true, + "license": "BlueOak-1.0.0" }, "node_modules/parent-module": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", - "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", "dev": true, + "license": "MIT", "dependencies": { "callsites": "^3.0.0" }, @@ -6680,8 +5761,6 @@ }, "node_modules/parent-require": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/parent-require/-/parent-require-1.0.0.tgz", - "integrity": "sha512-2MXDNZC4aXdkkap+rBBMv0lUsfJqvX5/2FiYYnfCnorZt3Pk06/IOR5KeaoghgS2w07MLWgjbsnyaq6PdHn2LQ==", "dev": true, "engines": { "node": ">= 0.4.0" @@ -6689,9 +5768,8 @@ }, "node_modules/parse-ms": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/parse-ms/-/parse-ms-4.0.0.tgz", - "integrity": "sha512-TXfryirbmq34y8QBwgqCVLi+8oA3oWx2eAnSn62ITyEhEYaWRlVZ2DvMM9eZbMs/RfxPu/PK/aBLyGj4IrqMHw==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -6701,9 +5779,8 @@ }, "node_modules/parse5": { "version": "7.2.1", - "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.2.1.tgz", - "integrity": "sha512-BuBYQYlv1ckiPdQi/ohiivi9Sagc9JG+Ozs0r7b/0iK3sKmrb0b9FdWdBbOdx6hBCM/F9Ir82ofnBhtZOjCRPQ==", "dev": true, + "license": "MIT", "dependencies": { "entities": "^4.5.0" }, @@ -6711,24 +5788,28 @@ "url": "https://github.com/inikulin/parse5?sponsor=1" } }, + "node_modules/parseurl": { + "version": "1.3.3", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/path-browserify": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz", - "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==" + "license": "MIT" }, "node_modules/path-exists": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", - "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/path-is-absolute": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", - "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "license": "MIT", "optional": true, "engines": { "node": ">=0.10.0" @@ -6736,23 +5817,20 @@ }, "node_modules/path-key": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", - "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/path-parse": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", - "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==" + "license": "MIT" }, "node_modules/path-scurry": { "version": "1.11.1", - "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", - "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", "dev": true, + "license": "BlueOak-1.0.0", "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" @@ -6764,39 +5842,41 @@ "url": "https://github.com/sponsors/isaacs" } }, + "node_modules/path-to-regexp": { + "version": "8.2.0", + "license": "MIT", + "engines": { + "node": ">=16" + } + }, "node_modules/path-type": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", - "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/pathe": { "version": "2.0.3", - "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", - "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/pathval": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.0.tgz", - "integrity": "sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==", "dev": true, + "license": "MIT", "engines": { "node": ">= 14.16" } }, "node_modules/perfect-debounce": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz", - "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/pg": { "version": "8.13.2", - "resolved": "https://registry.npmjs.org/pg/-/pg-8.13.2.tgz", - "integrity": "sha512-L5QkPvTjVWWHbLaFjCkOSplpb2uCiRYbg0IJ2okCy5ClYfWlSgDDnvdR6dyw3EWAH2AfS4j8E61QFI7gLfTtlw==", + "license": "MIT", "dependencies": { "pg-connection-string": "^2.7.0", "pg-pool": "^3.7.1", @@ -6821,40 +5901,34 @@ }, "node_modules/pg-cloudflare": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.1.1.tgz", - "integrity": "sha512-xWPagP/4B6BgFO+EKz3JONXv3YDgvkbVrGw2mTo3D6tVDQRh1e7cqVGvyR3BE+eQgAvx1XhW/iEASj4/jCWl3Q==", + "license": "MIT", "optional": true }, "node_modules/pg-connection-string": { "version": "2.6.2", - "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.6.2.tgz", - "integrity": "sha512-ch6OwaeaPYcova4kKZ15sbJ2hKb/VP48ZD2gE7i1J+L4MspCtBMAx8nMgz7bksc7IojCIIWuEhHibSMFH8m8oA==" + "license": "MIT" }, "node_modules/pg-int8": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz", - "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==", + "license": "ISC", "engines": { "node": ">=4.0.0" } }, "node_modules/pg-pool": { "version": "3.7.1", - "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.7.1.tgz", - "integrity": "sha512-xIOsFoh7Vdhojas6q3596mXFsR8nwBQBXX5JiV7p9buEVAGqYL4yFzclON5P9vFrpu1u7Zwl2oriyDa89n0wbw==", + "license": "MIT", "peerDependencies": { "pg": ">=8.0" } }, "node_modules/pg-protocol": { "version": "1.7.1", - "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.7.1.tgz", - "integrity": "sha512-gjTHWGYWsEgy9MsY0Gp6ZJxV24IjDqdpTW7Eh0x+WfJLFsm/TJx1MzL6T0D88mBvkpxotCQ6TwW6N+Kko7lhgQ==" + "license": "MIT" }, "node_modules/pg-types": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz", - "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==", + "license": "MIT", "dependencies": { "pg-int8": "1.0.1", "postgres-array": "~2.0.0", @@ -6868,24 +5942,21 @@ }, "node_modules/pg-types/node_modules/postgres-array": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz", - "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==", + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/pg-types/node_modules/postgres-date": { "version": "1.0.7", - "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz", - "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/pg-types/node_modules/postgres-interval": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz", - "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==", + "license": "MIT", "dependencies": { "xtend": "^4.0.0" }, @@ -6895,26 +5966,22 @@ }, "node_modules/pg/node_modules/pg-connection-string": { "version": "2.7.0", - "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.7.0.tgz", - "integrity": "sha512-PI2W9mv53rXJQEOb8xNR8lH7Hr+EKa6oJa38zsK0S/ky2er16ios1wLKhZyxzD7jUReiWokc9WK5nxSnC7W1TA==" + "license": "MIT" }, "node_modules/pgpass": { "version": "1.0.5", - "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz", - "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==", + "license": "MIT", "dependencies": { "split2": "^4.1.0" } }, "node_modules/picocolors": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", - "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==" + "license": "ISC" }, "node_modules/picomatch": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", - "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", "engines": { "node": ">=8.6" }, @@ -6924,9 +5991,8 @@ }, "node_modules/pidtree": { "version": "0.6.0", - "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.6.0.tgz", - "integrity": "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==", "dev": true, + "license": "MIT", "bin": { "pidtree": "bin/pidtree.js" }, @@ -6936,9 +6002,8 @@ }, "node_modules/playwright": { "version": "1.50.1", - "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.50.1.tgz", - "integrity": "sha512-G8rwsOQJ63XG6BbKj2w5rHeavFjy5zynBA9zsJMMtBoe/Uf757oG12NXz6e6OirF7RCrTVAKFXbLmn1RbL7Qaw==", "dev": true, + "license": "Apache-2.0", "dependencies": { "playwright-core": "1.50.1" }, @@ -6954,9 +6019,8 @@ }, "node_modules/playwright-core": { "version": "1.50.1", - "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.50.1.tgz", - "integrity": "sha512-ra9fsNWayuYumt+NiM069M6OkcRb1FZSK8bgi66AtpFoWkg2+y0bJSNmkFrWhMbEBbVKC/EruAHH3g0zmtwGmQ==", "dev": true, + "license": "Apache-2.0", "bin": { "playwright-core": "cli.js" }, @@ -6966,8 +6030,6 @@ }, "node_modules/postcss": { "version": "8.5.3", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz", - "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==", "funding": [ { "type": "opencollective", @@ -6982,6 +6044,7 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { "nanoid": "^3.3.8", "picocolors": "^1.1.1", @@ -6993,9 +6056,8 @@ }, "node_modules/postcss-selector-parser": { "version": "6.1.2", - "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", - "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", "dev": true, + "license": "MIT", "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" @@ -7006,40 +6068,35 @@ }, "node_modules/postgres-array": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-3.0.2.tgz", - "integrity": "sha512-6faShkdFugNQCLwucjPcY5ARoW1SlbnrZjmGl0IrrqewpvxvhSLHimCVzqeuULCbG0fQv7Dtk1yDbG3xv7Veog==", + "license": "MIT", "engines": { "node": ">=12" } }, "node_modules/postgres-bytea": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz", - "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/postgres-date": { "version": "2.1.0", - "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-2.1.0.tgz", - "integrity": "sha512-K7Juri8gtgXVcDfZttFKVmhglp7epKb1K4pgrkLxehjqkrgPhfG6OO8LHLkfaqkbpjNRnra018XwAr1yQFWGcA==", + "license": "MIT", "engines": { "node": ">=12" } }, "node_modules/postgres-interval": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-4.0.2.tgz", - "integrity": "sha512-EMsphSQ1YkQqKZL2cuG0zHkmjCCzQqQ71l2GXITqRwjhRleCdv00bDk/ktaSi0LnlaPzAc3535KTrjXsTdtx7A==", + "license": "MIT", "engines": { "node": ">=12" } }, "node_modules/prebuild-install": { "version": "7.1.3", - "resolved": "https://registry.npmjs.org/prebuild-install/-/prebuild-install-7.1.3.tgz", - "integrity": "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==", + "license": "MIT", "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", @@ -7063,18 +6120,16 @@ }, "node_modules/prelude-ls": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", - "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", "dev": true, + "license": "MIT", "engines": { "node": ">= 0.8.0" } }, "node_modules/prettier": { - "version": "3.5.2", - "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.2.tgz", - "integrity": "sha512-lc6npv5PH7hVqozBR7lkBNOGXV9vMwROAPlumdBkX0wTbbzPu/U1hk5yL8p2pt4Xoc+2mkT8t/sow2YrV/M5qg==", + "version": "3.5.1", "dev": true, + "license": "MIT", "peer": true, "bin": { "prettier": "bin/prettier.cjs" @@ -7088,9 +6143,8 @@ }, "node_modules/prettier-linter-helpers": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", - "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", "dev": true, + "license": "MIT", "dependencies": { "fast-diff": "^1.1.2" }, @@ -7100,9 +6154,8 @@ }, "node_modules/pretty-ms": { "version": "9.2.0", - "resolved": "https://registry.npmjs.org/pretty-ms/-/pretty-ms-9.2.0.tgz", - "integrity": "sha512-4yf0QO/sllf/1zbZWYnvWw3NxCQwLXKzIj0G849LSufP15BXKM0rbD2Z3wVnkMfjdn/CB0Dpp444gYAACdsplg==", "dev": true, + "license": "MIT", "dependencies": { "parse-ms": "^4.0.0" }, @@ -7115,14 +6168,12 @@ }, "node_modules/promise-inflight": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/promise-inflight/-/promise-inflight-1.0.1.tgz", - "integrity": "sha512-6zWPyEOFaQBJYcGMHBKTKJ3u6TBsnMFOIZSa6ce1e/ZrrsOlnHRHbabMjLiBYKp+n44X9eUI6VUPaukCXHuG4g==", + "license": "ISC", "optional": true }, "node_modules/promise-retry": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz", - "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==", + "license": "MIT", "optional": true, "dependencies": { "err-code": "^2.0.2", @@ -7134,14 +6185,27 @@ }, "node_modules/proto-list": { "version": "1.2.4", - "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz", - "integrity": "sha512-vtK/94akxsTMhe0/cbfpR+syPuszcuwhqVjJq26CuNDgFGj682oRBXOP5MJpv2r7JtE8MsiepGIqvvOTBwn2vA==", - "dev": true + "dev": true, + "license": "ISC" + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "license": "MIT" }, "node_modules/pump": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.2.tgz", - "integrity": "sha512-tUPXtzlGM8FE3P0ZL6DVs/3P58k9nk8/jZeQCurTJylQA8qFYzHFfhBJkuqyE0FifOsQ0uKWekiZ5g8wtr28cw==", + "license": "MIT", "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" @@ -7149,17 +6213,27 @@ }, "node_modules/punycode": { "version": "2.3.1", - "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", - "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, + "node_modules/qs": { + "version": "6.13.0", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.0.6" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/queue-microtask": { "version": "1.2.3", - "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", - "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", "funding": [ { "type": "github", @@ -7173,12 +6247,42 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" + }, + "node_modules/range-parser": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.6.3", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.6.3", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } }, "node_modules/rc": { "version": "1.2.8", - "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz", - "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==", + "license": "(BSD-2-Clause OR MIT OR Apache-2.0)", "dependencies": { "deep-extend": "^0.6.0", "ini": "~1.3.0", @@ -7191,17 +6295,15 @@ }, "node_modules/rc/node_modules/strip-json-comments": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz", - "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==", + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/read-package-json-fast": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/read-package-json-fast/-/read-package-json-fast-4.0.0.tgz", - "integrity": "sha512-qpt8EwugBWDw2cgE2W+/3oxC+KTez2uSVR8JU9Q36TXPAGCaozfQUs59v4j4GFpWTaw0i6hAZSvOmu1J0uOEUg==", "dev": true, + "license": "ISC", "dependencies": { "json-parse-even-better-errors": "^4.0.0", "npm-normalize-package-bin": "^4.0.0" @@ -7212,8 +6314,7 @@ }, "node_modules/readable-stream": { "version": "3.6.2", - "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", - "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", @@ -7225,8 +6326,7 @@ }, "node_modules/rechoir": { "version": "0.8.0", - "resolved": "https://registry.npmjs.org/rechoir/-/rechoir-0.8.0.tgz", - "integrity": "sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==", + "license": "MIT", "dependencies": { "resolve": "^1.20.0" }, @@ -7236,22 +6336,19 @@ }, "node_modules/reflect-metadata": { "version": "0.2.2", - "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz", - "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==" + "license": "Apache-2.0" }, "node_modules/require-directory": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", - "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/resolve": { "version": "1.22.10", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", - "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "license": "MIT", "dependencies": { "is-core-module": "^2.16.0", "path-parse": "^1.0.7", @@ -7269,35 +6366,31 @@ }, "node_modules/resolve-from": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", - "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", "dev": true, + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/resolve-pkg-maps": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/resolve-pkg-maps/-/resolve-pkg-maps-1.0.0.tgz", - "integrity": "sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1" } }, "node_modules/retry": { "version": "0.12.0", - "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", - "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==", + "license": "MIT", "optional": true, "engines": { "node": ">= 4" } }, "node_modules/reusify": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", - "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "version": "1.0.4", + "license": "MIT", "engines": { "iojs": ">=1.0.0", "node": ">=0.10.0" @@ -7305,15 +6398,12 @@ }, "node_modules/rfdc": { "version": "1.4.1", - "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", - "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/rimraf": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", - "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", - "deprecated": "Rimraf versions prior to v4 are no longer supported", + "license": "ISC", "optional": true, "dependencies": { "glob": "^7.1.3" @@ -7327,8 +6417,7 @@ }, "node_modules/rimraf/node_modules/brace-expansion": { "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "license": "MIT", "optional": true, "dependencies": { "balanced-match": "^1.0.0", @@ -7337,9 +6426,7 @@ }, "node_modules/rimraf/node_modules/glob": { "version": "7.2.3", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", - "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", - "deprecated": "Glob versions prior to v9 are no longer supported", + "license": "ISC", "optional": true, "dependencies": { "fs.realpath": "^1.0.0", @@ -7358,8 +6445,7 @@ }, "node_modules/rimraf/node_modules/minimatch": { "version": "3.1.2", - "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", - "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", "optional": true, "dependencies": { "brace-expansion": "^1.1.7" @@ -7369,10 +6455,9 @@ } }, "node_modules/rollup": { - "version": "4.34.9", - "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.34.9.tgz", - "integrity": "sha512-nF5XYqWWp9hx/LrpC8sZvvvmq0TeTjQgaZHYmAgwysT9nh8sWnZhBnM8ZyVbbJFIQBLwHDNoMqsBZBbUo4U8sQ==", + "version": "4.34.8", "dev": true, + "license": "MIT", "dependencies": { "@types/estree": "1.0.6" }, @@ -7384,33 +6469,49 @@ "npm": ">=8.0.0" }, "optionalDependencies": { - "@rollup/rollup-android-arm-eabi": "4.34.9", - "@rollup/rollup-android-arm64": "4.34.9", - "@rollup/rollup-darwin-arm64": "4.34.9", - "@rollup/rollup-darwin-x64": "4.34.9", - "@rollup/rollup-freebsd-arm64": "4.34.9", - "@rollup/rollup-freebsd-x64": "4.34.9", - "@rollup/rollup-linux-arm-gnueabihf": "4.34.9", - "@rollup/rollup-linux-arm-musleabihf": "4.34.9", - "@rollup/rollup-linux-arm64-gnu": "4.34.9", - "@rollup/rollup-linux-arm64-musl": "4.34.9", - "@rollup/rollup-linux-loongarch64-gnu": "4.34.9", - "@rollup/rollup-linux-powerpc64le-gnu": "4.34.9", - "@rollup/rollup-linux-riscv64-gnu": "4.34.9", - "@rollup/rollup-linux-s390x-gnu": "4.34.9", - "@rollup/rollup-linux-x64-gnu": "4.34.9", - "@rollup/rollup-linux-x64-musl": "4.34.9", - "@rollup/rollup-win32-arm64-msvc": "4.34.9", - "@rollup/rollup-win32-ia32-msvc": "4.34.9", - "@rollup/rollup-win32-x64-msvc": "4.34.9", + "@rollup/rollup-android-arm-eabi": "4.34.8", + "@rollup/rollup-android-arm64": "4.34.8", + "@rollup/rollup-darwin-arm64": "4.34.8", + "@rollup/rollup-darwin-x64": "4.34.8", + "@rollup/rollup-freebsd-arm64": "4.34.8", + "@rollup/rollup-freebsd-x64": "4.34.8", + "@rollup/rollup-linux-arm-gnueabihf": "4.34.8", + "@rollup/rollup-linux-arm-musleabihf": "4.34.8", + "@rollup/rollup-linux-arm64-gnu": "4.34.8", + "@rollup/rollup-linux-arm64-musl": "4.34.8", + "@rollup/rollup-linux-loongarch64-gnu": "4.34.8", + "@rollup/rollup-linux-powerpc64le-gnu": "4.34.8", + "@rollup/rollup-linux-riscv64-gnu": "4.34.8", + "@rollup/rollup-linux-s390x-gnu": "4.34.8", + "@rollup/rollup-linux-x64-gnu": "4.34.8", + "@rollup/rollup-linux-x64-musl": "4.34.8", + "@rollup/rollup-win32-arm64-msvc": "4.34.8", + "@rollup/rollup-win32-ia32-msvc": "4.34.8", + "@rollup/rollup-win32-x64-msvc": "4.34.8", "fsevents": "~2.3.2" } }, + "node_modules/router": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "is-promise": "^4.0.0", + "parseurl": "^1.3.3", + "path-to-regexp": "^8.0.0" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/rrweb-cssom": { + "version": "0.8.0", + "dev": true, + "license": "MIT" + }, "node_modules/run-applescript": { "version": "7.0.0", - "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.0.0.tgz", - "integrity": "sha512-9by4Ij99JUr/MCFBUkDKLWK3G9HVXmabKz9U5MlIAIuvuzkiOicRYs8XJLxX+xahD+mLiiCYDqF9dKAgtzKP1A==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -7420,8 +6521,6 @@ }, "node_modules/run-parallel": { "version": "1.2.0", - "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", - "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", "funding": [ { "type": "github", @@ -7436,14 +6535,13 @@ "url": "https://feross.org/support" } ], + "license": "MIT", "dependencies": { "queue-microtask": "^1.2.2" } }, "node_modules/safe-buffer": { "version": "5.2.1", - "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", - "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", "funding": [ { "type": "github", @@ -7457,17 +6555,27 @@ "type": "consulting", "url": "https://feross.org/support" } - ] + ], + "license": "MIT" }, "node_modules/safer-buffer": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", - "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + "license": "MIT" + }, + "node_modules/saxes": { + "version": "6.0.0", + "dev": true, + "license": "ISC", + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=v12.22.7" + } }, "node_modules/semver": { "version": "7.7.1", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz", - "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==", + "license": "ISC", "bin": { "semver": "bin/semver.js" }, @@ -7475,17 +6583,77 @@ "node": ">=10" } }, + "node_modules/send": { + "version": "1.1.0", + "license": "MIT", + "dependencies": { + "debug": "^4.3.5", + "destroy": "^1.2.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "fresh": "^0.5.2", + "http-errors": "^2.0.0", + "mime-types": "^2.1.35", + "ms": "^2.1.3", + "on-finished": "^2.4.1", + "range-parser": "^1.2.1", + "statuses": "^2.0.1" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/send/node_modules/fresh": { + "version": "0.5.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/send/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/send/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-static": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "parseurl": "^1.3.3", + "send": "^1.0.0" + }, + "engines": { + "node": ">= 18" + } + }, "node_modules/set-blocking": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", - "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==", + "license": "ISC", "optional": true }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "license": "ISC" + }, "node_modules/shebang-command": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", - "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", "dev": true, + "license": "MIT", "dependencies": { "shebang-regex": "^3.0.0" }, @@ -7495,18 +6663,80 @@ }, "node_modules/shebang-regex": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", - "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/shell-quote": { "version": "1.8.2", - "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.2.tgz", - "integrity": "sha512-AzqKpGKjrj7EM6rKVQEPpB288oCfnrEIuyoT9cyF4nmGa7V8Zk6f7RRqYisX8X9m+Q7bd632aZW4ky7EhbQztA==", "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, "engines": { "node": ">= 0.4" }, @@ -7516,15 +6746,13 @@ }, "node_modules/siginfo": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz", - "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==", - "dev": true + "dev": true, + "license": "ISC" }, "node_modules/signal-exit": { "version": "4.1.0", - "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", - "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", "dev": true, + "license": "ISC", "engines": { "node": ">=14" }, @@ -7534,27 +6762,6 @@ }, "node_modules/simple-concat": { "version": "1.0.1", - "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz", - "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==", - "funding": [ - { - "type": "github", - "url": "https://github.com/sponsors/feross" - }, - { - "type": "patreon", - "url": "https://www.patreon.com/feross" - }, - { - "type": "consulting", - "url": "https://feross.org/support" - } - ] - }, - "node_modules/simple-get": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-4.0.1.tgz", - "integrity": "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==", "funding": [ { "type": "github", @@ -7569,6 +6776,25 @@ "url": "https://feross.org/support" } ], + "license": "MIT" + }, + "node_modules/simple-get": { + "version": "4.0.1", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", "dependencies": { "decompress-response": "^6.0.0", "once": "^1.3.1", @@ -7577,9 +6803,8 @@ }, "node_modules/sirv": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.1.tgz", - "integrity": "sha512-FoqMu0NCGBLCcAkS1qA+XJIQTR6/JHfQXl+uGteNCQ76T91DMUjPa9xfmeqMY3z80nLSg9yQmNjK0Px6RWsH/A==", "dev": true, + "license": "MIT", "dependencies": { "@polka/url": "^1.0.0-next.24", "mrmime": "^2.0.0", @@ -7591,16 +6816,14 @@ }, "node_modules/slash": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", - "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/smart-buffer": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", - "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==", + "license": "MIT", "optional": true, "engines": { "node": ">= 6.0.0", @@ -7609,8 +6832,7 @@ }, "node_modules/socks": { "version": "2.8.4", - "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.4.tgz", - "integrity": "sha512-D3YaD0aRxR3mEcqnidIs7ReYJFVzWdd6fXJYUM8ixcQcJRGTka/b3saV0KflYhyVJXKhb947GndU35SxYNResQ==", + "license": "MIT", "optional": true, "dependencies": { "ip-address": "^9.0.5", @@ -7623,8 +6845,7 @@ }, "node_modules/socks-proxy-agent": { "version": "6.2.1", - "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-6.2.1.tgz", - "integrity": "sha512-a6KW9G+6B3nWZ1yB8G7pJwL3ggLy1uTzKAgCb7ttblwqdz9fMGJUuTy3uFzEP48FAs9FLILlmzDlE2JJhVQaXQ==", + "license": "MIT", "optional": true, "dependencies": { "agent-base": "^6.0.2", @@ -7635,42 +6856,48 @@ "node": ">= 10" } }, + "node_modules/socks-proxy-agent/node_modules/agent-base": { + "version": "6.0.2", + "license": "MIT", + "optional": true, + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, "node_modules/source-map-js": { "version": "1.2.1", - "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", - "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } }, "node_modules/speakingurl": { "version": "14.0.1", - "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz", - "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==", "dev": true, + "license": "BSD-3-Clause", "engines": { "node": ">=0.10.0" } }, "node_modules/split2": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz", - "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==", + "license": "ISC", "engines": { "node": ">= 10.x" } }, "node_modules/sprintf-js": { "version": "1.1.3", - "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz", - "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==", + "license": "BSD-3-Clause", "optional": true }, "node_modules/sqlite3": { "version": "5.1.7", - "resolved": "https://registry.npmjs.org/sqlite3/-/sqlite3-5.1.7.tgz", - "integrity": "sha512-GGIyOiFaG+TUra3JIfkI/zGP8yZYLPQ0pl1bH+ODjiX57sPhrLU5sQJn1y9bDKZUFYkX1crlrPfSYt0BKKdkog==", "hasInstallScript": true, + "license": "BSD-3-Clause", "dependencies": { "bindings": "^1.5.0", "node-addon-api": "^7.0.0", @@ -7691,24 +6918,21 @@ }, "node_modules/sqlstring": { "version": "2.3.3", - "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz", - "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==", + "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/sqlstring-sqlite": { "version": "0.1.1", - "resolved": "https://registry.npmjs.org/sqlstring-sqlite/-/sqlstring-sqlite-0.1.1.tgz", - "integrity": "sha512-9CAYUJ0lEUPYJrswqiqdINNSfq3jqWo/bFJ7tufdoNeSK0Fy+d1kFTxjqO9PIqza0Kri+ZtYMfPVf1aZaFOvrQ==", + "license": "MIT", "engines": { "node": ">= 0.6" } }, "node_modules/ssri": { "version": "8.0.1", - "resolved": "https://registry.npmjs.org/ssri/-/ssri-8.0.1.tgz", - "integrity": "sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==", + "license": "ISC", "optional": true, "dependencies": { "minipass": "^3.1.1" @@ -7719,8 +6943,7 @@ }, "node_modules/ssri/node_modules/minipass": { "version": "3.3.6", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz", - "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==", + "license": "ISC", "optional": true, "dependencies": { "yallist": "^4.0.0" @@ -7729,31 +6952,39 @@ "node": ">=8" } }, + "node_modules/ssri/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC", + "optional": true + }, "node_modules/stackback": { "version": "0.0.2", - "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz", - "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/statuses": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } }, "node_modules/std-env": { "version": "3.8.0", - "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.8.0.tgz", - "integrity": "sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/string_decoder": { "version": "1.3.0", - "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", - "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", "dependencies": { "safe-buffer": "~5.2.0" } }, "node_modules/string-width": { "version": "5.1.2", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", - "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", "dev": true, + "license": "MIT", "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", @@ -7769,9 +7000,8 @@ "node_modules/string-width-cjs": { "name": "string-width", "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, + "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -7783,24 +7013,21 @@ }, "node_modules/string-width-cjs/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/string-width-cjs/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/string-width-cjs/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -7810,9 +7037,8 @@ }, "node_modules/strip-ansi": { "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" }, @@ -7826,9 +7052,8 @@ "node_modules/strip-ansi-cjs": { "name": "strip-ansi", "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -7838,27 +7063,24 @@ }, "node_modules/strip-ansi-cjs/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/strip-bom": { "version": "3.0.0", - "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", - "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", "dev": true, + "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/strip-final-newline": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-4.0.0.tgz", - "integrity": "sha512-aulFJcD6YK8V1G7iRB5tigAP4TsHBZZrOV8pjV++zdUwmeV8uzbY7yn6h9MswN62adStNZFuCIx4haBnRuMDaw==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -7868,9 +7090,8 @@ }, "node_modules/strip-json-comments": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", - "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" }, @@ -7880,9 +7101,8 @@ }, "node_modules/superjson": { "version": "2.2.2", - "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.2.tgz", - "integrity": "sha512-5JRxVqC8I8NuOUjzBbvVJAKNM8qoVuH0O77h4WInc/qC2q5IreqKxYwgkga3PfA22OayK2ikceb/B26dztPl+Q==", "dev": true, + "license": "MIT", "dependencies": { "copy-anything": "^3.0.2" }, @@ -7892,9 +7112,8 @@ }, "node_modules/supports-color": { "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", "dev": true, + "license": "MIT", "dependencies": { "has-flag": "^4.0.0" }, @@ -7904,8 +7123,7 @@ }, "node_modules/supports-preserve-symlinks-flag": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", - "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", "engines": { "node": ">= 0.4" }, @@ -7915,15 +7133,17 @@ }, "node_modules/svg-tags": { "version": "1.0.0", - "resolved": "https://registry.npmjs.org/svg-tags/-/svg-tags-1.0.0.tgz", - "integrity": "sha512-ovssysQTa+luh7A5Weu3Rta6FJlFBBbInjOh722LIt6klpU2/HtdUbszju/G4devcvk8PGt7FCLv5wftu3THUA==", "dev": true }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "dev": true, + "license": "MIT" + }, "node_modules/synckit": { "version": "0.9.2", - "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.2.tgz", - "integrity": "sha512-vrozgXDQwYO72vHjUb/HnFbQx1exDjoKzqx23aXEg2a9VIg2TSFZ8FmeZpTjUCFMYw7mpX4BE2SFu8wI7asYsw==", "dev": true, + "license": "MIT", "dependencies": { "@pkgr/core": "^0.1.0", "tslib": "^2.6.2" @@ -7937,8 +7157,7 @@ }, "node_modules/tar": { "version": "6.2.1", - "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz", - "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==", + "license": "ISC", "dependencies": { "chownr": "^2.0.0", "fs-minipass": "^2.0.0", @@ -7953,8 +7172,7 @@ }, "node_modules/tar-fs": { "version": "2.1.2", - "resolved": "https://registry.npmjs.org/tar-fs/-/tar-fs-2.1.2.tgz", - "integrity": "sha512-EsaAXwxmx8UB7FRKqeozqEPop69DXcmYwTQwXvyAPF352HJsPdkVhvTaDPYqfNgruveJIJy3TA2l+2zj8LJIJA==", + "license": "MIT", "dependencies": { "chownr": "^1.1.1", "mkdirp-classic": "^0.5.2", @@ -7964,13 +7182,11 @@ }, "node_modules/tar-fs/node_modules/chownr": { "version": "1.1.4", - "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.4.tgz", - "integrity": "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==" + "license": "ISC" }, "node_modules/tar-stream": { "version": "2.2.0", - "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-2.2.0.tgz", - "integrity": "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==", + "license": "MIT", "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", @@ -7984,71 +7200,82 @@ }, "node_modules/tar/node_modules/minipass": { "version": "5.0.0", - "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz", - "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==", + "license": "ISC", "engines": { "node": ">=8" } }, + "node_modules/tar/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC" + }, "node_modules/tarn": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/tarn/-/tarn-3.0.2.tgz", - "integrity": "sha512-51LAVKUSZSVfI05vjPESNc5vwqqZpbXCsU+/+wxlOrUjk2SnFTt97v9ZgQrD4YmxYW1Px6w2KjaDitCfkvgxMQ==", + "license": "MIT", "engines": { "node": ">=8.0.0" } }, "node_modules/tildify": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/tildify/-/tildify-2.0.0.tgz", - "integrity": "sha512-Cc+OraorugtXNfs50hU9KS369rFXCfgGLpfCfvlc+Ud5u6VWmUQsOAa9HbTvheQdYnrdJqqv1e5oIqXppMYnSw==", + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/tinybench": { "version": "2.9.0", - "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", - "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/tinyexec": { "version": "0.3.2", - "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", - "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/tinypool": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.0.2.tgz", - "integrity": "sha512-al6n+QEANGFOMf/dmUMsuS5/r9B06uwlyNjZZql/zv8J7ybHCgoihBNORZCY2mzUuAnomQa2JdhyHKzZxPCrFA==", "dev": true, + "license": "MIT", "engines": { "node": "^18.0.0 || >=20.0.0" } }, "node_modules/tinyrainbow": { "version": "2.0.0", - "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz", - "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==", "dev": true, + "license": "MIT", "engines": { "node": ">=14.0.0" } }, "node_modules/tinyspy": { "version": "3.0.2", - "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-3.0.2.tgz", - "integrity": "sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=14.0.0" } }, + "node_modules/tldts": { + "version": "6.1.77", + "dev": true, + "license": "MIT", + "dependencies": { + "tldts-core": "^6.1.77" + }, + "bin": { + "tldts": "bin/cli.js" + } + }, + "node_modules/tldts-core": { + "version": "6.1.77", + "dev": true, + "license": "MIT" + }, "node_modules/to-regex-range": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", - "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", "dependencies": { "is-number": "^7.0.0" }, @@ -8056,20 +7283,47 @@ "node": ">=8.0" } }, + "node_modules/toidentifier": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, "node_modules/totalist": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/totalist/-/totalist-3.0.1.tgz", - "integrity": "sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, + "node_modules/tough-cookie": { + "version": "5.1.1", + "dev": true, + "license": "BSD-3-Clause", + "dependencies": { + "tldts": "^6.1.32" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/tr46": { + "version": "5.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "punycode": "^2.3.1" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/ts-api-utils": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.0.1.tgz", - "integrity": "sha512-dnlgjFSVetynI8nzgJ+qF62efpglpWRk8isUEWZGWlJYySCTD6aKvbUDu+zbPeDakk3bg5H4XpitHukgfL1m9w==", "dev": true, + "license": "MIT", "engines": { "node": ">=18.12" }, @@ -8079,8 +7333,7 @@ }, "node_modules/ts-morph": { "version": "25.0.1", - "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-25.0.1.tgz", - "integrity": "sha512-QJEiTdnz1YjrB3JFhd626gX4rKHDLSjSVMvGGG4v7ONc3RBwa0Eei98G9AT9uNFDMtV54JyuXsFeC+OH0n6bXQ==", + "license": "MIT", "dependencies": { "@ts-morph/common": "~0.26.0", "code-block-writer": "^13.0.3" @@ -8088,9 +7341,8 @@ }, "node_modules/ts-node": { "version": "10.9.2", - "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz", - "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==", "dev": true, + "license": "MIT", "dependencies": { "@cspotcode/source-map-support": "^0.8.0", "@tsconfig/node10": "^1.0.7", @@ -8131,9 +7383,8 @@ }, "node_modules/tsconfig-paths": { "version": "4.2.0", - "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-4.2.0.tgz", - "integrity": "sha512-NoZ4roiN7LnbKn9QqE1amc9DJfzvZXxF4xDavcOWt1BPkdx+m+0gJuPM+S0vCe7zTJMYUP0R8pO2XMr+Y8oLIg==", "dev": true, + "license": "MIT", "dependencies": { "json5": "^2.2.2", "minimist": "^1.2.6", @@ -8145,15 +7396,13 @@ }, "node_modules/tslib": { "version": "2.8.1", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", - "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", - "dev": true + "dev": true, + "license": "0BSD" }, "node_modules/tsx": { "version": "4.19.3", - "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.19.3.tgz", - "integrity": "sha512-4H8vUNGNjQ4V2EOoGw005+c+dGuPSnhpPBPHBtsZdGZBk/iJb4kguGlPWaZTZ3q5nMtFOEsY0nRDlh9PJyd6SQ==", "dev": true, + "license": "MIT", "dependencies": { "esbuild": "~0.25.0", "get-tsconfig": "^4.7.5" @@ -8168,25 +7417,9 @@ "fsevents": "~2.3.3" } }, - "node_modules/tsx/node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", - "dev": true, - "hasInstallScript": true, - "optional": true, - "os": [ - "darwin" - ], - "peer": true, - "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" - } - }, "node_modules/tunnel-agent": { "version": "0.6.0", - "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", - "integrity": "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==", + "license": "Apache-2.0", "dependencies": { "safe-buffer": "^5.0.1" }, @@ -8196,9 +7429,8 @@ }, "node_modules/type-check": { "version": "0.4.0", - "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", - "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", "dev": true, + "license": "MIT", "dependencies": { "prelude-ls": "^1.2.1" }, @@ -8208,9 +7440,8 @@ }, "node_modules/type-fest": { "version": "0.20.2", - "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", - "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", "dev": true, + "license": "(MIT OR CC0-1.0)", "engines": { "node": ">=10" }, @@ -8218,11 +7449,22 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/type-is": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "content-type": "^1.0.5", + "media-typer": "^1.1.0", + "mime-types": "^3.0.0" + }, + "engines": { + "node": ">= 0.6" + } + }, "node_modules/typescript": { "version": "5.7.3", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz", - "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==", "devOptional": true, + "license": "Apache-2.0", "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -8232,14 +7474,13 @@ } }, "node_modules/typescript-eslint": { - "version": "8.25.0", - "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.25.0.tgz", - "integrity": "sha512-TxRdQQLH4g7JkoFlYG3caW5v1S6kEkz8rqt80iQJZUYPq1zD1Ra7HfQBJJ88ABRaMvHAXnwRvRB4V+6sQ9xN5Q==", + "version": "8.24.1", "dev": true, + "license": "MIT", "dependencies": { - "@typescript-eslint/eslint-plugin": "8.25.0", - "@typescript-eslint/parser": "8.25.0", - "@typescript-eslint/utils": "8.25.0" + "@typescript-eslint/eslint-plugin": "8.24.1", + "@typescript-eslint/parser": "8.24.1", + "@typescript-eslint/utils": "8.24.1" }, "engines": { "node": "^18.18.0 || ^20.9.0 || >=21.1.0" @@ -8255,15 +7496,13 @@ }, "node_modules/undici-types": { "version": "6.20.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.20.0.tgz", - "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/unicorn-magic": { "version": "0.3.0", - "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz", - "integrity": "sha512-+QBBXBCvifc56fsbuxZQ6Sic3wqqc3WWaqxs58gvJrcOuN83HGTCwz3oS5phzU9LthRNE9VrJCFCLUgHeeFnfA==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" }, @@ -8273,8 +7512,7 @@ }, "node_modules/unique-filename": { "version": "1.1.1", - "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-1.1.1.tgz", - "integrity": "sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==", + "license": "ISC", "optional": true, "dependencies": { "unique-slug": "^2.0.0" @@ -8282,8 +7520,7 @@ }, "node_modules/unique-slug": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-2.0.2.tgz", - "integrity": "sha512-zoWr9ObaxALD3DOPfjPSqxt4fnZiWblxHIgeWqW8x7UqDzEtHEQLzji2cuJYQFCU6KmoJikOYAZlrTHHebjx2w==", + "license": "ISC", "optional": true, "dependencies": { "imurmurhash": "^0.1.4" @@ -8291,16 +7528,20 @@ }, "node_modules/universalify": { "version": "2.0.1", - "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", - "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "license": "MIT", "engines": { "node": ">= 10.0.0" } }, + "node_modules/unpipe": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, "node_modules/update-browserslist-db": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz", - "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==", + "version": "1.1.2", "dev": true, "funding": [ { @@ -8316,6 +7557,7 @@ "url": "https://github.com/sponsors/ai" } ], + "license": "MIT", "dependencies": { "escalade": "^3.2.0", "picocolors": "^1.1.1" @@ -8329,44 +7571,53 @@ }, "node_modules/uri-js": { "version": "4.4.1", - "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", - "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "punycode": "^2.1.0" } }, "node_modules/util-deprecate": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", - "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==" + "license": "MIT" + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } }, "node_modules/uuid": { "version": "11.1.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", - "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", "funding": [ "https://github.com/sponsors/broofa", "https://github.com/sponsors/ctavan" ], + "license": "MIT", "bin": { "uuid": "dist/esm/bin/uuid" } }, "node_modules/v8-compile-cache-lib": { "version": "3.0.1", - "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz", - "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==", - "dev": true + "dev": true, + "license": "MIT" + }, + "node_modules/vary": { + "version": "1.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } }, "node_modules/vite": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/vite/-/vite-6.2.0.tgz", - "integrity": "sha512-7dPxoo+WsT/64rDcwoOjk76XHj+TqNTIvHKcuMQ1k4/SeHDaQt5GFAeLYzrimZrMpn/O6DtdI03WUjdxuPM0oQ==", + "version": "6.1.1", "dev": true, + "license": "MIT", "dependencies": { - "esbuild": "^0.25.0", - "postcss": "^8.5.3", + "esbuild": "^0.24.2", + "postcss": "^8.5.2", "rollup": "^4.30.1" }, "bin": { @@ -8432,9 +7683,8 @@ }, "node_modules/vite-hot-client": { "version": "0.2.4", - "resolved": "https://registry.npmjs.org/vite-hot-client/-/vite-hot-client-0.2.4.tgz", - "integrity": "sha512-a1nzURqO7DDmnXqabFOliz908FRmIppkBKsJthS8rbe8hBEXwEwe4C3Pp33Z1JoFCYfVL4kTOMLKk0ZZxREIeA==", "dev": true, + "license": "MIT", "funding": { "url": "https://github.com/sponsors/antfu" }, @@ -8443,10 +7693,9 @@ } }, "node_modules/vite-node": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.0.7.tgz", - "integrity": "sha512-2fX0QwX4GkkkpULXdT1Pf4q0tC1i1lFOyseKoonavXUNlQ77KpW2XqBGGNIm/J4Ows4KxgGJzDguYVPKwG/n5A==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { "cac": "^6.7.14", "debug": "^4.4.0", @@ -8466,9 +7715,8 @@ }, "node_modules/vite-plugin-inspect": { "version": "0.8.9", - "resolved": "https://registry.npmjs.org/vite-plugin-inspect/-/vite-plugin-inspect-0.8.9.tgz", - "integrity": "sha512-22/8qn+LYonzibb1VeFZmISdVao5kC22jmEKm24vfFE8siEn47EpVcCLYMv6iKOYMJfjSvSJfueOwcFCkUnV3A==", "dev": true, + "license": "MIT", "dependencies": { "@antfu/utils": "^0.7.10", "@rollup/pluginutils": "^5.1.3", @@ -8497,9 +7745,8 @@ }, "node_modules/vite-plugin-vue-devtools": { "version": "7.7.2", - "resolved": "https://registry.npmjs.org/vite-plugin-vue-devtools/-/vite-plugin-vue-devtools-7.7.2.tgz", - "integrity": "sha512-5V0UijQWiSBj32blkyPEqIbzc6HO9c1bwnBhx+ay2dzU0FakH+qMdNUT8nF9BvDE+i6I1U8CqCuJiO20vKEdQw==", "dev": true, + "license": "MIT", "dependencies": { "@vue/devtools-core": "^7.7.2", "@vue/devtools-kit": "^7.7.2", @@ -8518,9 +7765,8 @@ }, "node_modules/vite-plugin-vue-inspector": { "version": "5.3.1", - "resolved": "https://registry.npmjs.org/vite-plugin-vue-inspector/-/vite-plugin-vue-inspector-5.3.1.tgz", - "integrity": "sha512-cBk172kZKTdvGpJuzCCLg8lJ909wopwsu3Ve9FsL1XsnLBiRT9U3MePcqrgGHgCX2ZgkqZmAGR8taxw+TV6s7A==", "dev": true, + "license": "MIT", "dependencies": { "@babel/core": "^7.23.0", "@babel/plugin-proposal-decorators": "^7.23.0", @@ -8536,33 +7782,72 @@ "vite": "^3.0.0-0 || ^4.0.0-0 || ^5.0.0-0 || ^6.0.0-0" } }, - "node_modules/vite/node_modules/fsevents": { - "version": "2.3.3", - "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", - "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "node_modules/vite/node_modules/@esbuild/linux-x64": { + "version": "0.24.2", + "cpu": [ + "x64" + ], "dev": true, - "hasInstallScript": true, + "license": "MIT", "optional": true, "os": [ - "darwin" + "linux" ], "engines": { - "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + "node": ">=18" + } + }, + "node_modules/vite/node_modules/esbuild": { + "version": "0.24.2", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.24.2", + "@esbuild/android-arm": "0.24.2", + "@esbuild/android-arm64": "0.24.2", + "@esbuild/android-x64": "0.24.2", + "@esbuild/darwin-arm64": "0.24.2", + "@esbuild/darwin-x64": "0.24.2", + "@esbuild/freebsd-arm64": "0.24.2", + "@esbuild/freebsd-x64": "0.24.2", + "@esbuild/linux-arm": "0.24.2", + "@esbuild/linux-arm64": "0.24.2", + "@esbuild/linux-ia32": "0.24.2", + "@esbuild/linux-loong64": "0.24.2", + "@esbuild/linux-mips64el": "0.24.2", + "@esbuild/linux-ppc64": "0.24.2", + "@esbuild/linux-riscv64": "0.24.2", + "@esbuild/linux-s390x": "0.24.2", + "@esbuild/linux-x64": "0.24.2", + "@esbuild/netbsd-arm64": "0.24.2", + "@esbuild/netbsd-x64": "0.24.2", + "@esbuild/openbsd-arm64": "0.24.2", + "@esbuild/openbsd-x64": "0.24.2", + "@esbuild/sunos-x64": "0.24.2", + "@esbuild/win32-arm64": "0.24.2", + "@esbuild/win32-ia32": "0.24.2", + "@esbuild/win32-x64": "0.24.2" } }, "node_modules/vitest": { - "version": "3.0.7", - "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.0.7.tgz", - "integrity": "sha512-IP7gPK3LS3Fvn44x30X1dM9vtawm0aesAa2yBIZ9vQf+qB69NXC5776+Qmcr7ohUXIQuLhk7xQR0aSUIDPqavg==", + "version": "3.0.6", "dev": true, + "license": "MIT", "dependencies": { - "@vitest/expect": "3.0.7", - "@vitest/mocker": "3.0.7", - "@vitest/pretty-format": "^3.0.7", - "@vitest/runner": "3.0.7", - "@vitest/snapshot": "3.0.7", - "@vitest/spy": "3.0.7", - "@vitest/utils": "3.0.7", + "@vitest/expect": "3.0.6", + "@vitest/mocker": "3.0.6", + "@vitest/pretty-format": "^3.0.6", + "@vitest/runner": "3.0.6", + "@vitest/snapshot": "3.0.6", + "@vitest/spy": "3.0.6", + "@vitest/utils": "3.0.6", "chai": "^5.2.0", "debug": "^4.4.0", "expect-type": "^1.1.0", @@ -8574,7 +7859,7 @@ "tinypool": "^1.0.2", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0", - "vite-node": "3.0.7", + "vite-node": "3.0.6", "why-is-node-running": "^2.3.0" }, "bin": { @@ -8590,8 +7875,8 @@ "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", - "@vitest/browser": "3.0.7", - "@vitest/ui": "3.0.7", + "@vitest/browser": "3.0.6", + "@vitest/ui": "3.0.6", "happy-dom": "*", "jsdom": "*" }, @@ -8621,14 +7906,12 @@ }, "node_modules/vscode-uri": { "version": "3.1.0", - "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz", - "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/vue": { "version": "3.5.13", - "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.13.tgz", - "integrity": "sha512-wmeiSMxkZCSc+PM2w2VRsOYAZC8GdipNFRTsLSfodVqI9mbejKeXEGr8SckuLnrQPGe3oJN5c3K0vpoU9q/wCQ==", + "license": "MIT", "dependencies": { "@vue/compiler-dom": "3.5.13", "@vue/compiler-sfc": "3.5.13", @@ -8646,16 +7929,14 @@ } }, "node_modules/vue-component-type-helpers": { - "version": "2.2.6", - "resolved": "https://registry.npmjs.org/vue-component-type-helpers/-/vue-component-type-helpers-2.2.6.tgz", - "integrity": "sha512-kFdh3gw9DN+h6d/JEQfW8GbNG4XHwiJSJO1T3Akx1QtLT0tS/4njk4JpAzQ6i9PvOwALg3ESMnS31xr2wXluXA==", - "dev": true + "version": "2.2.2", + "dev": true, + "license": "MIT" }, "node_modules/vue-eslint-parser": { "version": "9.4.3", - "resolved": "https://registry.npmjs.org/vue-eslint-parser/-/vue-eslint-parser-9.4.3.tgz", - "integrity": "sha512-2rYRLWlIpaiN8xbPiDyXZXRgLGOtWxERV7ND5fFAv5qo1D2N9Fu9MNajBNc6o13lZ+24DAWCkQCvj4klgmcITg==", "dev": true, + "license": "MIT", "dependencies": { "debug": "^4.3.4", "eslint-scope": "^7.1.1", @@ -8677,9 +7958,8 @@ }, "node_modules/vue-eslint-parser/node_modules/eslint-scope": { "version": "7.2.2", - "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", - "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" @@ -8693,9 +7973,8 @@ }, "node_modules/vue-eslint-parser/node_modules/espree": { "version": "9.6.1", - "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", - "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", "dev": true, + "license": "BSD-2-Clause", "dependencies": { "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", @@ -8710,8 +7989,7 @@ }, "node_modules/vue-i18n": { "version": "10.0.5", - "resolved": "https://registry.npmjs.org/vue-i18n/-/vue-i18n-10.0.5.tgz", - "integrity": "sha512-9/gmDlCblz3i8ypu/afiIc/SUIfTTE1mr0mZhb9pk70xo2csHAM9mp2gdQ3KD2O0AM3Hz/5ypb+FycTj/lHlPQ==", + "license": "MIT", "dependencies": { "@intlify/core-base": "10.0.5", "@intlify/shared": "10.0.5", @@ -8729,8 +8007,7 @@ }, "node_modules/vue-router": { "version": "4.5.0", - "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.5.0.tgz", - "integrity": "sha512-HDuk+PuH5monfNuY+ct49mNmkCRK4xJAV9Ts4z9UFc4rzdDnxQLyCMGGc8pKhZhHTVzfanpNwB/lwqevcBwI4w==", + "license": "MIT", "dependencies": { "@vue/devtools-api": "^6.6.4" }, @@ -8742,13 +8019,12 @@ } }, "node_modules/vue-tsc": { - "version": "2.2.6", - "resolved": "https://registry.npmjs.org/vue-tsc/-/vue-tsc-2.2.6.tgz", - "integrity": "sha512-TI6eAnWPatONEpVAZt1etbSrh8tDpHOLSlRqKGudOK5WKVnBGzHXUi0KR4UCsf2o5P+5285w4HF+5avhfH7IMA==", + "version": "2.2.2", "dev": true, + "license": "MIT", "dependencies": { "@volar/typescript": "~2.4.11", - "@vue/language-core": "2.2.6" + "@vue/language-core": "2.2.2" }, "bin": { "vue-tsc": "bin/vue-tsc.js" @@ -8758,9 +8034,8 @@ } }, "node_modules/vuetify": { - "version": "3.7.14", - "resolved": "https://registry.npmjs.org/vuetify/-/vuetify-3.7.14.tgz", - "integrity": "sha512-L5oD0x3Wrp49Khp+16dRykAFUZq6WXqX7OHLTwXnyEliJ48ERC9WfEtN0YOuEIhor/b2IOZXl+11fs/m452/Lw==", + "version": "3.7.12", + "license": "MIT", "engines": { "node": "^12.20 || >=14.13" }, @@ -8786,11 +8061,79 @@ } } }, + "node_modules/w3c-xmlserializer": { + "version": "5.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "xml-name-validator": "^5.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/w3c-xmlserializer/node_modules/xml-name-validator": { + "version": "5.0.0", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18" + } + }, + "node_modules/webidl-conversions": { + "version": "7.0.0", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/whatwg-encoding": { + "version": "3.1.1", + "dev": true, + "license": "MIT", + "dependencies": { + "iconv-lite": "0.6.3" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/whatwg-encoding/node_modules/iconv-lite": { + "version": "0.6.3", + "dev": true, + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/whatwg-mimetype": { + "version": "4.0.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/whatwg-url": { + "version": "14.1.1", + "dev": true, + "license": "MIT", + "dependencies": { + "tr46": "^5.0.0", + "webidl-conversions": "^7.0.0" + }, + "engines": { + "node": ">=18" + } + }, "node_modules/which": { "version": "2.0.2", - "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", - "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", "devOptional": true, + "license": "ISC", "dependencies": { "isexe": "^2.0.0" }, @@ -8803,9 +8146,8 @@ }, "node_modules/why-is-node-running": { "version": "2.3.0", - "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz", - "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==", "dev": true, + "license": "MIT", "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" @@ -8819,8 +8161,7 @@ }, "node_modules/wide-align": { "version": "1.1.5", - "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz", - "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==", + "license": "ISC", "optional": true, "dependencies": { "string-width": "^1.0.2 || 2 || 3 || 4" @@ -8828,8 +8169,7 @@ }, "node_modules/wide-align/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", "optional": true, "engines": { "node": ">=8" @@ -8837,14 +8177,12 @@ }, "node_modules/wide-align/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT", "optional": true }, "node_modules/wide-align/node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", "optional": true, "dependencies": { "emoji-regex": "^8.0.0", @@ -8857,8 +8195,7 @@ }, "node_modules/wide-align/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", "optional": true, "dependencies": { "ansi-regex": "^5.0.1" @@ -8869,18 +8206,16 @@ }, "node_modules/word-wrap": { "version": "1.2.5", - "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", - "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", "dev": true, + "license": "MIT", "engines": { "node": ">=0.10.0" } }, "node_modules/wrap-ansi": { "version": "8.1.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", - "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", @@ -8896,9 +8231,8 @@ "node_modules/wrap-ansi-cjs": { "name": "wrap-ansi", "version": "7.0.0", - "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", - "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", "dev": true, + "license": "MIT", "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", @@ -8913,24 +8247,21 @@ }, "node_modules/wrap-ansi-cjs/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/wrap-ansi-cjs/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/wrap-ansi-cjs/node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, + "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -8942,9 +8273,8 @@ }, "node_modules/wrap-ansi-cjs/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -8954,9 +8284,8 @@ }, "node_modules/wrap-ansi/node_modules/ansi-styles": { "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", "dev": true, + "license": "MIT", "engines": { "node": ">=12" }, @@ -8966,45 +8295,65 @@ }, "node_modules/wrappy": { "version": "1.0.2", - "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", - "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==" + "license": "ISC" + }, + "node_modules/ws": { + "version": "8.18.0", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } }, "node_modules/xml-name-validator": { "version": "4.0.0", - "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-4.0.0.tgz", - "integrity": "sha512-ICP2e+jsHvAj2E2lIHxa5tjXRlKDJo4IdvPvCXbXQGdzSfmSpNVyIKMvoZHjDY9DP0zV17iI85o90vRFXNccRw==", "dev": true, + "license": "Apache-2.0", "engines": { "node": ">=12" } }, + "node_modules/xmlchars": { + "version": "2.2.0", + "dev": true, + "license": "MIT" + }, "node_modules/xtend": { "version": "4.0.2", - "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", - "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", "engines": { "node": ">=0.4" } }, "node_modules/y18n": { "version": "5.0.8", - "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", - "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", "dev": true, + "license": "ISC", "engines": { "node": ">=10" } }, "node_modules/yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==" + "version": "3.1.1", + "dev": true, + "license": "ISC" }, "node_modules/yargs": { "version": "17.7.2", - "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", - "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", "dev": true, + "license": "MIT", "dependencies": { "cliui": "^8.0.1", "escalade": "^3.1.1", @@ -9020,33 +8369,29 @@ }, "node_modules/yargs-parser": { "version": "21.1.1", - "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", - "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", "dev": true, + "license": "ISC", "engines": { "node": ">=12" } }, "node_modules/yargs/node_modules/ansi-regex": { "version": "5.0.1", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", - "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8" } }, "node_modules/yargs/node_modules/emoji-regex": { "version": "8.0.0", - "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", - "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/yargs/node_modules/string-width": { "version": "4.2.3", - "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", - "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", "dev": true, + "license": "MIT", "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", @@ -9058,9 +8403,8 @@ }, "node_modules/yargs/node_modules/strip-ansi": { "version": "6.0.1", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", - "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", "dev": true, + "license": "MIT", "dependencies": { "ansi-regex": "^5.0.1" }, @@ -9070,18 +8414,16 @@ }, "node_modules/yn": { "version": "3.1.1", - "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz", - "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=6" } }, "node_modules/yocto-queue": { "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", "dev": true, + "license": "MIT", "engines": { "node": ">=10" }, @@ -9091,9 +8433,8 @@ }, "node_modules/yoctocolors": { "version": "2.1.1", - "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.1.1.tgz", - "integrity": "sha512-GQHQqAopRhwU8Kt1DDM8NjibDXHC8eoh1erhGAJPEyveY9qqVeXvVikNKrDz69sHowPMorbPUrH/mx8c50eiBQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=18" },