@pidgeon-ai/cli 1.34.2 → 1.35.0

package/dist/chunk-GCWCWQ2X.js

@@ -0,0 +1,2846 @@
+#!/usr/bin/env node
+import {
+  COMMANDS,
+  __export
+} from "./chunk-7XP66ZDV.js";
+
+// ../sdk/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  SIGNATURE_HEADER: () => SIGNATURE_HEADER,
+  TIMESTAMP_HEADER: () => TIMESTAMP_HEADER,
+  agentAttachHuman: () => agentAttachHuman,
+  agentConnect: () => agentConnect,
+  agentSetup: () => agentSetup,
+  agentSignUp: () => agentSignUp,
+  agentVerify: () => agentVerify,
+  appPasswordsCreate: () => appPasswordsCreate,
+  appPasswordsList: () => appPasswordsList,
+  appPasswordsRevoke: () => appPasswordsRevoke,
+  attachmentsCompleteUpload: () => attachmentsCompleteUpload,
+  attachmentsCreateUpload: () => attachmentsCreateUpload,
+  attachmentsDownloadUrl: () => attachmentsDownloadUrl,
+  attachmentsText: () => attachmentsText,
+  attachmentsUpload: () => attachmentsUpload,
+  calendarCreateEvent: () => calendarCreateEvent,
+  calendarDeleteEvent: () => calendarDeleteEvent,
+  calendarFreeTime: () => calendarFreeTime,
+  calendarGet: () => calendarGet,
+  calendarGetAgenda: () => calendarGetAgenda,
+  calendarGetEvent: () => calendarGetEvent,
+  calendarListEventInstances: () => calendarListEventInstances,
+  calendarListEvents: () => calendarListEvents,
+  calendarRespondToEvent: () => calendarRespondToEvent,
+  calendarUpdate: () => calendarUpdate,
+  calendarUpdateEvent: () => calendarUpdateEvent,
+  cardsGet: () => cardsGet,
+  client: () => client,
+  contactsBlock: () => contactsBlock,
+  contactsCreate: () => contactsCreate,
+  contactsDelete: () => contactsDelete,
+  contactsGet: () => contactsGet,
+  contactsList: () => contactsList,
+  contactsUnblock: () => contactsUnblock,
+  contactsUpdate: () => contactsUpdate,
+  createClient: () => createClient,
+  createConfig: () => createConfig,
+  domainsCreate: () => domainsCreate,
+  domainsDelete: () => domainsDelete,
+  domainsGet: () => domainsGet,
+  domainsGetSetupLink: () => domainsGetSetupLink,
+  domainsList: () => domainsList,
+  domainsUpdate: () => domainsUpdate,
+  domainsVerify: () => domainsVerify,
+  domainsZoneFile: () => domainsZoneFile,
+  draftsApproval: () => draftsApproval,
+  draftsCancelSchedule: () => draftsCancelSchedule,
+  draftsCreate: () => draftsCreate,
+  draftsDelete: () => draftsDelete,
+  draftsGet: () => draftsGet,
+  draftsList: () => draftsList,
+  draftsRemoveAttachment: () => draftsRemoveAttachment,
+  draftsSchedule: () => draftsSchedule,
+  draftsSend: () => draftsSend,
+  draftsUpdate: () => draftsUpdate,
+  eventsGet: () => eventsGet,
+  eventsList: () => eventsList,
+  eventsSocket: () => eventsSocket,
+  eventsStream: () => eventsStream,
+  exportMail: () => exportMail,
+  identitiesAccessCreate: () => identitiesAccessCreate,
+  identitiesAccessDelete: () => identitiesAccessDelete,
+  identitiesAccessGet: () => identitiesAccessGet,
+  identitiesCard: () => identitiesCard,
+  identitiesCreate: () => identitiesCreate,
+  identitiesDelete: () => identitiesDelete,
+  identitiesGet: () => identitiesGet,
+  identitiesList: () => identitiesList,
+  identitiesReceiveRulesCreate: () => identitiesReceiveRulesCreate,
+  identitiesReceiveRulesDelete: () => identitiesReceiveRulesDelete,
+  identitiesReceiveRulesGet: () => identitiesReceiveRulesGet,
+  identitiesSendRulesCreate: () => identitiesSendRulesCreate,
+  identitiesSendRulesDelete: () => identitiesSendRulesDelete,
+  identitiesSendRulesGet: () => identitiesSendRulesGet,
+  identitiesSuspendTenant: () => identitiesSuspendTenant,
+  identitiesUpdate: () => identitiesUpdate,
+  keysCreate: () => keysCreate,
+  keysGet: () => keysGet,
+  keysList: () => keysList,
+  keysRevoke: () => keysRevoke,
+  keysRotate: () => keysRotate,
+  keysUpdate: () => keysUpdate,
+  labelsCreate: () => labelsCreate,
+  labelsDelete: () => labelsDelete,
+  labelsList: () => labelsList,
+  labelsUpdate: () => labelsUpdate,
+  mailboxesChanges: () => mailboxesChanges,
+  mailboxesEmptyTrash: () => mailboxesEmptyTrash,
+  mailboxesList: () => mailboxesList,
+  mailboxesListFolder: () => mailboxesListFolder,
+  meGet: () => meGet,
+  messagesAct: () => messagesAct,
+  messagesAwait: () => messagesAwait,
+  messagesCheck: () => messagesCheck,
+  messagesForward: () => messagesForward,
+  messagesGet: () => messagesGet,
+  messagesListInThread: () => messagesListInThread,
+  messagesRaw: () => messagesRaw,
+  messagesReply: () => messagesReply,
+  messagesReplyAll: () => messagesReplyAll,
+  messagesRespondToInvitation: () => messagesRespondToInvitation,
+  messagesSearch: () => messagesSearch,
+  messagesSend: () => messagesSend,
+  messagesUndo: () => messagesUndo,
+  messagesUpdate: () => messagesUpdate,
+  metricsQuery: () => metricsQuery,
+  podsCreate: () => podsCreate,
+  podsDelete: () => podsDelete,
+  podsGet: () => podsGet,
+  podsList: () => podsList,
+  podsUpdate: () => podsUpdate,
+  routingCreate: () => routingCreate,
+  routingDelete: () => routingDelete,
+  routingList: () => routingList,
+  routingUpdate: () => routingUpdate,
+  streamEvents: () => streamEvents,
+  testInbound: () => testInbound,
+  threadsGet: () => threadsGet,
+  threadsLabelsCreate: () => threadsLabelsCreate,
+  threadsLabelsDelete: () => threadsLabelsDelete,
+  threadsLabelsGet: () => threadsLabelsGet,
+  threadsList: () => threadsList,
+  threadsUpdate: () => threadsUpdate,
+  verifySender: () => verifySender,
+  verifyWebhook: () => verifyWebhook,
+  webhooksCreate: () => webhooksCreate,
+  webhooksDelete: () => webhooksDelete,
+  webhooksDeliveries: () => webhooksDeliveries,
+  webhooksGet: () => webhooksGet,
+  webhooksGetHeaders: () => webhooksGetHeaders,
+  webhooksList: () => webhooksList,
+  webhooksReplay: () => webhooksReplay,
+  webhooksUpdate: () => webhooksUpdate,
+  webhooksUpdateHeaders: () => webhooksUpdateHeaders,
+  workspaceGet: () => workspaceGet,
+  workspaceMembers: () => workspaceMembers
+});
+var serializeFormDataPair = (data, key, value) => {
+  if (typeof value === "string" || value instanceof Blob) {
+    data.append(key, value);
+  } else if (value instanceof Date) {
+    data.append(key, value.toISOString());
+  } else {
+    data.append(key, JSON.stringify(value));
+  }
+};
+var formDataBodySerializer = {
+  bodySerializer: (body) => {
+    const data = new FormData();
+    Object.entries(body).forEach(([key, value]) => {
+      if (value === void 0 || value === null) {
+        return;
+      }
+      if (Array.isArray(value)) {
+        value.forEach((v) => serializeFormDataPair(data, key, v));
+      } else {
+        serializeFormDataPair(data, key, value);
+      }
+    });
+    return data;
+  }
+};
+var jsonBodySerializer = {
+  bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+};
+function createSseClient({
+  onRequest,
+  onSseError,
+  onSseEvent,
+  responseTransformer,
+  responseValidator,
+  sseDefaultRetryDelay,
+  sseMaxRetryAttempts,
+  sseMaxRetryDelay,
+  sseSleepFn,
+  url,
+  ...options
+}) {
+  let lastEventId;
+  const sleep2 = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3e3;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted) break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== void 0) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const requestInit = {
+          redirect: "follow",
+          ...options,
+          body: options.serializedBody,
+          headers,
+          signal
+        };
+        let request = new Request(url, requestInit);
+        if (onRequest) {
+          request = await onRequest(url, requestInit);
+        }
+        const _fetch = options.fetch ?? globalThis.fetch;
+        const response = await _fetch(request);
+        if (!response.ok) throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body) throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream()).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {
+          }
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += value;
+            buffer = buffer.replace(/\r\n?/g, "\n");
+            const chunks = buffer.split("\n\n");
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split("\n");
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join("\n");
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== void 0 && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 3e4);
+        await sleep2(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+}
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+};
+var separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+};
+var serializeArrayParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value
+}) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v) => encodeURIComponent(v))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v : encodeURIComponent(v);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var serializePrimitiveParam = ({
+  allowReserved,
+  name,
+  value
+}) => {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+var serializeObjectParam = ({
+  allowReserved,
+  explode,
+  name,
+  style,
+  value,
+  valueOnly
+}) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v]) => {
+      values = [...values, key, allowReserved ? v : encodeURIComponent(v)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(
+    ([key, v]) => serializePrimitiveParam({
+      allowReserved,
+      name: style === "deepObject" ? `${name}[${key}]` : key,
+      value: v
+    })
+  ).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(
+          match,
+          serializeObjectParam({
+            explode,
+            name,
+            style,
+            value,
+            valueOnly: true
+          })
+        );
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(
+          match,
+          `;${serializePrimitiveParam({
+            name,
+            value
+          })}`
+        );
+        continue;
+      }
+      const replaceValue = encodeURIComponent(
+        style === "label" ? `.${value}` : value
+      );
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+};
+var getUrl = ({
+  baseUrl: baseUrl2,
+  path,
+  query,
+  querySerializer,
+  url: _url
+}) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl2 ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+function getValidRequestBody(options) {
+  const hasBody = options.body !== void 0;
+  const isSerializedBody = hasBody && options.bodySerializer;
+  if (isSerializedBody) {
+    if ("serializedBody" in options) {
+      const hasSerializedBody = options.serializedBody !== void 0 && options.serializedBody !== "";
+      return hasSerializedBody ? options.serializedBody : null;
+    }
+    return options.body !== "" ? options.body : null;
+  }
+  if (hasBody) {
+    return options.body;
+  }
+  return void 0;
+}
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+var createQuerySerializer = ({
+  parameters = {},
+  ...args
+} = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        const options = parameters[name] || args;
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...options.array
+          });
+          if (serializedArray) search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved: options.allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...options.object
+          });
+          if (serializedObject) search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved: options.allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive) search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+};
+var getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+};
+var checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+};
+async function setAuthParams(options) {
+  for (const auth of options.security ?? []) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+}
+var buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+});
+var mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+};
+var headersEntries = (headers) => {
+  const entries = [];
+  headers.forEach((value, key) => {
+    entries.push([key, value]);
+  });
+  return entries;
+};
+var mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers();
+  for (const header of headers) {
+    if (!header) {
+      continue;
+    }
+    const iterator = header instanceof Headers ? headersEntries(header) : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v of value) {
+          mergedHeaders.append(key, v);
+        }
+      } else if (value !== void 0) {
+        mergedHeaders.set(
+          key,
+          typeof value === "object" ? JSON.stringify(value) : value
+        );
+      }
+    }
+  }
+  return mergedHeaders;
+};
+var Interceptors = class {
+  fns = [];
+  clear() {
+    this.fns = [];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = null;
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return Boolean(this.fns[index]);
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this.fns[id] ? id : -1;
+    }
+    return this.fns.indexOf(id);
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this.fns[index]) {
+      this.fns[index] = fn;
+      return id;
+    }
+    return false;
+  }
+  use(fn) {
+    this.fns.push(fn);
+    return this.fns.length - 1;
+  }
+};
+var createInterceptors = () => ({
+  error: new Interceptors(),
+  request: new Interceptors(),
+  response: new Interceptors()
+});
+var defaultQuerySerializer = createQuerySerializer({
+  allowReserved: false,
+  array: {
+    explode: true,
+    style: "form"
+  },
+  object: {
+    explode: true,
+    style: "deepObject"
+  }
+});
+var defaultHeaders = {
+  "Content-Type": "application/json"
+};
+var createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: void 0
+    };
+    if (opts.security) {
+      await setAuthParams(opts);
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body !== void 0 && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.body === void 0 || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const resolvedOpts = opts;
+    const url = buildUrl(resolvedOpts);
+    return { opts: resolvedOpts, url };
+  };
+  const request = async (options) => {
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+    let request2;
+    let response;
+    try {
+      const { opts, url } = await beforeRequest(options);
+      const requestInit = {
+        redirect: "follow",
+        ...opts,
+        body: getValidRequestBody(opts)
+      };
+      request2 = new Request(url, requestInit);
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          request2 = await fn(request2, opts);
+        }
+      }
+      const _fetch = opts.fetch;
+      response = await _fetch(request2);
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request2, opts);
+        }
+      }
+      const result = {
+        request: request2,
+        response
+      };
+      if (response.ok) {
+        const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+        if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+          let emptyData;
+          switch (parseAs) {
+            case "arrayBuffer":
+            case "blob":
+            case "text":
+              emptyData = await response[parseAs]();
+              break;
+            case "formData":
+              emptyData = new FormData();
+              break;
+            case "stream":
+              emptyData = response.body;
+              break;
+            case "json":
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === "data" ? emptyData : {
+            data: emptyData,
+            ...result
+          };
+        }
+        let data;
+        switch (parseAs) {
+          case "arrayBuffer":
+          case "blob":
+          case "formData":
+          case "text":
+            data = await response[parseAs]();
+            break;
+          case "json": {
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
+            break;
+          }
+          case "stream":
+            return opts.responseStyle === "data" ? response.body : {
+              data: response.body,
+              ...result
+            };
+        }
+        if (parseAs === "json") {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+        return opts.responseStyle === "data" ? data : {
+          data,
+          ...result
+        };
+      }
+      const textError = await response.text();
+      let jsonError;
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
+      }
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request2, options);
+        }
+      }
+      finalError = finalError || {};
+      if (throwOnError) {
+        throw finalError;
+      }
+      return responseStyle === "data" ? void 0 : {
+        error: finalError,
+        request: request2,
+        response
+      };
+    }
+  };
+  const makeMethodFn = (method) => (options) => request({ ...options, method });
+  const makeSseFn = (method) => async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    return createSseClient({
+      ...opts,
+      body: opts.body,
+      method,
+      onRequest: async (url2, init) => {
+        let request2 = new Request(url2, init);
+        for (const fn of interceptors.request.fns) {
+          if (fn) {
+            request2 = await fn(request2, opts);
+          }
+        }
+        return request2;
+      },
+      serializedBody: getValidRequestBody(opts),
+      url
+    });
+  };
+  const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+  return {
+    buildUrl: _buildUrl,
+    connect: makeMethodFn("CONNECT"),
+    delete: makeMethodFn("DELETE"),
+    get: makeMethodFn("GET"),
+    getConfig,
+    head: makeMethodFn("HEAD"),
+    interceptors,
+    options: makeMethodFn("OPTIONS"),
+    patch: makeMethodFn("PATCH"),
+    post: makeMethodFn("POST"),
+    put: makeMethodFn("PUT"),
+    request,
+    setConfig,
+    sse: {
+      connect: makeSseFn("CONNECT"),
+      delete: makeSseFn("DELETE"),
+      get: makeSseFn("GET"),
+      head: makeSseFn("HEAD"),
+      options: makeSseFn("OPTIONS"),
+      patch: makeSseFn("PATCH"),
+      post: makeSseFn("POST"),
+      put: makeSseFn("PUT"),
+      trace: makeSseFn("TRACE")
+    },
+    trace: makeMethodFn("TRACE")
+  };
+};
+var USER_AGENT = "@pidgeon-ai/sdk";
+var createClientConfig = (config) => ({
+  ...config,
+  ...typeof window === "undefined" ? { headers: { "User-Agent": USER_AGENT, ...plain(config?.headers) } } : {}
+});
+function plain(headers) {
+  return headers && typeof headers === "object" && !(headers instanceof Headers) ? headers : {};
+}
+var client = createClient(
+  createClientConfig(createConfig({ baseUrl: "https://pidgeon.ai/api/v1" }))
+);
+var agentSignUp = (options) => (options.client ?? client).post({
+  url: "/agent/signup",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var agentAttachHuman = (options) => (options.client ?? client).post({
+  url: "/agent/human",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var agentVerify = (options) => (options.client ?? client).post({
+  url: "/agent/verify",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var cardsGet = (options) => (options.client ?? client).get({
+  url: "/cards/{id}",
+  ...options
+});
+var verifySender = (options) => (options.client ?? client).post({
+  url: "/verify",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var agentConnect = (options) => (options.client ?? client).post({
+  url: "/agent/connect",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var agentSetup = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/agent/setup",
+  ...options
+});
+var identitiesList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities",
+  ...options
+});
+var identitiesCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var identitiesDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}",
+  ...options
+});
+var identitiesGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}",
+  ...options
+});
+var identitiesUpdate = (options) => (options.client ?? client).patch(
+  {
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/identities/{id}",
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  }
+);
+var identitiesCard = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/card",
+  ...options
+});
+var identitiesAccessDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/access",
+  ...options
+});
+var identitiesAccessGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/access",
+  ...options
+});
+var identitiesAccessCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/access",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var identitiesSendRulesDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/send-rules",
+  ...options
+});
+var identitiesSendRulesGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/send-rules",
+  ...options
+});
+var identitiesSendRulesCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/send-rules",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var identitiesReceiveRulesDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/receive-rules",
+  ...options
+});
+var identitiesReceiveRulesGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/receive-rules",
+  ...options
+});
+var identitiesReceiveRulesCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/receive-rules",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var identitiesSuspendTenant = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/tenants/{id}/suspend",
+  ...options
+});
+var podsList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/pods",
+  ...options
+});
+var podsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/pods",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var podsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/pods/{id}",
+  ...options
+});
+var podsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/pods/{id}",
+  ...options
+});
+var podsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/pods/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var labelsList = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/labels",
+  ...options
+});
+var labelsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/labels",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var labelsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/labels/{id}",
+  ...options
+});
+var labelsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/labels/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var contactsList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts",
+  ...options
+});
+var contactsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var contactsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts/{id}",
+  ...options
+});
+var contactsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts/{id}",
+  ...options
+});
+var contactsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var contactsUnblock = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts/{id}/block",
+  ...options
+});
+var contactsBlock = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/contacts/{id}/block",
+  ...options
+});
+var threadsLabelsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads/{id}/labels",
+  ...options
+});
+var threadsLabelsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads/{id}/labels",
+  ...options
+});
+var threadsLabelsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads/{id}/labels",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesListInThread = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages",
+  ...options
+});
+var messagesSend = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesCheck = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/check",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesSearch = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/search",
+  ...options
+});
+var messagesAct = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/actions",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesUndo = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/undo",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesAwait = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/await",
+  ...options
+});
+var messagesGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}",
+  ...options
+});
+var messagesUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesReply = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}/reply",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesReplyAll = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}/reply-all",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesForward = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}/forward",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var messagesRaw = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}/raw",
+  ...options
+});
+var exportMail = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/export",
+  ...options
+});
+var threadsList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads",
+  ...options
+});
+var threadsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads/{id}",
+  ...options
+});
+var threadsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/threads/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var domainsList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains",
+  ...options
+});
+var domainsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var domainsZoneFile = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}/zone-file",
+  ...options
+});
+var domainsGetSetupLink = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}/setup-link",
+  ...options
+});
+var domainsVerify = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}/verify",
+  ...options
+});
+var domainsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}",
+  ...options
+});
+var domainsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}",
+  ...options
+});
+var domainsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/domains/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var routingList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/routing-rules",
+  ...options
+});
+var routingCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/routing-rules",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var routingDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/routing-rules/{id}",
+  ...options
+});
+var routingUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/routing-rules/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var mailboxesList = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/mailboxes",
+  ...options
+});
+var mailboxesChanges = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/mailboxes/changes",
+  ...options
+});
+var mailboxesEmptyTrash = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/mailboxes/{folder}",
+  ...options
+});
+var mailboxesListFolder = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/mailboxes/{folder}",
+  ...options
+});
+var keysList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys",
+  ...options
+});
+var keysCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var keysRevoke = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys/{id}",
+  ...options
+});
+var keysGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys/{id}",
+  ...options
+});
+var keysUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var keysRotate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/api-keys/{id}/rotate",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var testInbound = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/test/inbound",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var appPasswordsList = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/app-passwords",
+  ...options
+});
+var appPasswordsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/app-passwords",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var appPasswordsRevoke = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/app-passwords/{id}",
+  ...options
+});
+var meGet = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/me",
+  ...options
+});
+var workspaceGet = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace",
+  ...options
+});
+var workspaceMembers = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/workspace/members",
+  ...options
+});
+var eventsList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/events",
+  ...options
+});
+var eventsSocket = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/events/socket",
+  ...options
+});
+var eventsStream = (options) => (options?.client ?? client).sse.get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/events/stream",
+  ...options
+});
+var eventsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/events/{id}",
+  ...options
+});
+var webhooksList = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks",
+  ...options
+});
+var webhooksCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var webhooksDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks/{id}",
+  ...options
+});
+var webhooksGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks/{id}",
+  ...options
+});
+var webhooksUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var webhooksGetHeaders = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks/{id}/headers",
+  ...options
+});
+var webhooksUpdateHeaders = (options) => (options.client ?? client).put({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/webhooks/{id}/headers",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var webhooksDeliveries = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/deliveries",
+  ...options
+});
+var webhooksReplay = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/deliveries/{id}/replay",
+  ...options
+});
+var messagesRespondToInvitation = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/messages/{id}/invitation/respond",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var calendarGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar",
+  ...options
+});
+var calendarUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var calendarListEvents = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events",
+  ...options
+});
+var calendarCreateEvent = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var calendarRespondToEvent = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events/{eventId}/respond",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var calendarListEventInstances = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events/{eventId}/instances",
+  ...options
+});
+var calendarGetAgenda = (options) => (options.client ?? client).get(
+  {
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/identities/{id}/calendar/agenda",
+    ...options
+  }
+);
+var calendarFreeTime = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/calendar/free-time",
+  ...options
+});
+var calendarDeleteEvent = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events/{eventId}",
+  ...options
+});
+var calendarGetEvent = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events/{eventId}",
+  ...options
+});
+var calendarUpdateEvent = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/identities/{id}/calendar/events/{eventId}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var draftsList = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts",
+  ...options
+});
+var draftsCreate = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var draftsDelete = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}",
+  ...options
+});
+var draftsGet = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}",
+  ...options
+});
+var draftsUpdate = (options) => (options.client ?? client).patch({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var draftsSend = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}/send",
+  ...options
+});
+var draftsApproval = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}/approval",
+  ...options
+});
+var draftsCancelSchedule = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}/schedule",
+  ...options
+});
+var draftsSchedule = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}/schedule",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var draftsRemoveAttachment = (options) => (options.client ?? client).delete({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/drafts/{id}/attachments/{attachmentId}",
+  ...options
+});
+var metricsQuery = (options) => (options?.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/metrics",
+  ...options
+});
+var attachmentsUpload = (options) => (options.client ?? client).post({
+  ...formDataBodySerializer,
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/attachments",
+  ...options,
+  headers: {
+    "Content-Type": null,
+    ...options.headers
+  }
+});
+var attachmentsCreateUpload = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/attachments/uploads",
+  ...options,
+  headers: {
+    "Content-Type": "application/json",
+    ...options.headers
+  }
+});
+var attachmentsCompleteUpload = (options) => (options.client ?? client).post({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/attachments/{id}/complete",
+  ...options
+});
+var attachmentsDownloadUrl = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/attachments/{id}",
+  ...options
+});
+var attachmentsText = (options) => (options.client ?? client).get({
+  security: [{ scheme: "bearer", type: "http" }],
+  url: "/attachments/{id}/text",
+  ...options
+});
+var SIGNATURE_HEADER = "x-pidgeon-signature";
+var TIMESTAMP_HEADER = "x-pidgeon-timestamp";
+async function verifyWebhook(input) {
+  const get = (name) => {
+    if (input.headers instanceof Headers) return input.headers.get(name) ?? void 0;
+    const direct = input.headers[name];
+    if (direct !== void 0) return direct;
+    const wanted = name.toLowerCase();
+    for (const [key2, value] of Object.entries(input.headers)) {
+      if (key2.toLowerCase() === wanted) return value;
+    }
+    return void 0;
+  };
+  const timestamp = get(TIMESTAMP_HEADER);
+  const signature = get(SIGNATURE_HEADER);
+  if (!timestamp || !signature) throw new Error("This request is not signed.");
+  const seconds = Number(timestamp);
+  if (!Number.isFinite(seconds)) throw new Error("The signature timestamp is not a number.");
+  const now = Math.floor((input.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  const tolerance = input.toleranceSeconds ?? 300;
+  if (Math.abs(now - seconds) > tolerance) {
+    throw new Error("This request is too old to trust. It may be a replay.");
+  }
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(input.secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const mac = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    new TextEncoder().encode(`${seconds}.${input.rawBody}`)
+  );
+  const expected = `v1=${[...new Uint8Array(mac)].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  if (!constantTimeEqual(expected, signature)) {
+    throw new Error("The signature does not match.");
+  }
+  return JSON.parse(input.rawBody);
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let difference = 0;
+  for (let index = 0; index < a.length; index += 1) {
+    difference |= a.charCodeAt(index) ^ b.charCodeAt(index);
+  }
+  return difference === 0;
+}
+async function* streamEvents(options) {
+  const base = (options.baseUrl ?? "https://pidgeon.ai/api/v1").replace(/\/$/, "");
+  let lastEventId;
+  let backoffMs = 1e3;
+  while (!options.signal?.aborted) {
+    const url = new URL(`${base}/events/stream`);
+    if (options.identityId) url.searchParams.set("identity_id", options.identityId);
+    if (options.type) url.searchParams.set("type", options.type);
+    if (options.after && !lastEventId) url.searchParams.set("after", options.after);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          authorization: `Bearer ${options.apiKey}`,
+          accept: "text/event-stream",
+          ...lastEventId ? { "last-event-id": lastEventId } : {}
+        },
+        signal: options.signal
+      });
+    } catch {
+      if (options.signal?.aborted) return;
+      await sleep(backoffMs, options.signal);
+      backoffMs = Math.min(backoffMs * 2, 3e4);
+      continue;
+    }
+    if (response.status === 401 || response.status === 403 || response.status === 404) {
+      throw new Error(
+        `Pidgeon refused the stream: ${response.status} ${await response.text().catch(() => "")}`.trim()
+      );
+    }
+    if (!response.ok || !response.body) {
+      await sleep(backoffMs, options.signal);
+      backoffMs = Math.min(backoffMs * 2, 3e4);
+      continue;
+    }
+    backoffMs = 1e3;
+    for await (const frame of frames(response.body, options.signal)) {
+      if (frame.id) lastEventId = frame.id;
+      if (!frame.data) continue;
+      if (frame.event === "error") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(frame.data);
+      } catch {
+        continue;
+      }
+      yield parsed;
+    }
+  }
+}
+async function* frames(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (!signal?.aborted) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        boundary = buffer.indexOf("\n\n");
+        const frame = {};
+        const data = [];
+        for (const line of block.split("\n")) {
+          if (line.startsWith(":")) continue;
+          const colon = line.indexOf(":");
+          if (colon === -1) continue;
+          const field = line.slice(0, colon);
+          const value2 = line.slice(colon + 1).replace(/^ /, "");
+          if (field === "id") frame.id = value2;
+          else if (field === "event") frame.event = value2;
+          else if (field === "data") data.push(value2);
+        }
+        if (data.length > 0) frame.data = data.join("\n");
+        if (frame.id || frame.data) yield frame;
+      }
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        resolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+// ../id/dist/chunk-PM3YNIMV.js
+import { createHash } from "crypto";
+import { chmod, mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+import { createHash as createHash2, randomBytes } from "crypto";
+var __defProp = Object.defineProperty;
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var wasmBase64 = "AGFzbQEAAAABYg5gAABgAX8AYAF/AX9gAn9/AGACf38Bf2ADf39/AGADf39/AX9gBH9/f38AYAR/f39/AX9gBX9/f39/AGAGf39/f39/AGAHf39/f39/fwBgAn98AXxgCn98f3x8f39/f38AAqsBAxYuL3Bvc3RfY29yZV93YXNtX2JnLmpzJl9fd2JnX2dldFJhbmRvbVZhbHVlc180MzZhNTFkMDYyOWQ4NGUxAAMWLi9wb3N0X2NvcmVfd2FzbV9iZy5qcxpfX3diaW5kZ2VuX29iamVjdF9kcm9wX3JlZgABFi4vcG9zdF9jb3JlX3dhc21fYmcuanMcX193YmdfRXJyb3JfMzBjODk4N2Y3YzJlZDRlMgAEA1ZVBQILBQkFAwMDBQQIBAMBAwUDBQUBBQMNAwMDBAMDAwUDBQMDBQoCAwEDAwUFBQQFAQcMAwQDCQUFBAYDBQgDAwgFAQMEAgEFBAMAAgMDAwMDAwEAAAQFAXABCAgFAwEAEQYZA38BQYCAwAALfwBBwL3CAAt/AEG8wcIACwf0AQ4GbWVtb3J5AgAMZ2VuZXJhdGVTZWVkABcOcG9saWN5RGVjaXNpb24AGgxwb2xpY3lNYXhBZ2UANQlwdWJsaWNLZXkAGARzaWduAAcGdmVyaWZ5AAUPX19hYm9ydF9oYW5kbGVyAwEVX19pbnN0YW5jZV90ZXJtaW5hdGVkAwIRX193YmluZGdlbl9leHBvcnQASR9fX3diaW5kZ2VuX2FkZF90b19zdGFja19wb2ludGVyAE4SX193YmluZGdlbl9leHBvcnQyAEoSX193YmluZGdlbl9leHBvcnQzADwSX193YmluZGdlbl9leHBvcnQ0AEMJDQEAQQELB0sND1FUR1cKpvoCVdFNAgJ/In4jAEGAAWshAyABIAJBB3RqIQQgACkDOCEFIAApAzAhBiAAKQMoIQcgACkDICEIIAApAxghCSAAKQMQIQogACkDCCELIAApAwAhDANAQQAhAgNAIAMgAmogASACaikAACINQjiGIA1CgP4Dg0IohoQgDUKAgPwHg0IYhiANQoCAgPgPg0IIhoSEIA1CCIhCgICA+A+DIA1CGIhCgID8B4OEIA1CKIhCgP4DgyANQjiIhISENwMAIAJBCGoiAkGAAUcNAAsgAykDACEOQQApA6C3QiEPIAMpA3ghDSADKQNwIRAgAykDaCERIAMpA2AhEiADKQNYIRMgAykDUCEUIAMpA0ghFSADKQNAIRYgAykDOCEXIAMpAzAhGCADKQMoIRkgAykDICEaIAMpAxghGyADKQMQIRwgDEIkiSAMQh6JhSAMQhmJhSAMIAsgCoWDIAsgCoOFfCAPIA4gCCAHgyAFfCAGIAhCf4WDfCAIQjKJIAhCLomFIAhCF4mFfHx8Ih18Ig9CJIkgD0IeiYUgD0IZiYUgDyAMIAuFgyAMIAuDhXwgAykDCCIeIAZ8QQApA6i3QnwgByAdIAl8Ih9Cf4WDfCAfIAiDfCAfQjKJIB9CLomFIB9CF4mFfCIgfCIdQiSJIB1CHomFIB1CGYmFIB0gDyAMhYMgDyAMg4V8IBwgB3xBACkDsLdCfCAIICAgCnwiIUJ/hYN8ICEgH4N8ICFCMokgIUIuiYUgIUIXiYV8IiJ8IiBCJIkgIEIeiYUgIEIZiYUgICAdIA+FgyAdIA+DhXwgGyAIfEEAKQO4t0J8IB8gIiALfCIjQn+Fg3wgIyAhg3wgI0IyiSAjQi6JhSAjQheJhXwiJHwiIkIkiSAiQh6JhSAiQhmJhSAiICAgHYWDICAgHYOFfCAfIBp8QQApA8C3QnwgISAkIAx8IiRCf4WDfCAkICODfCAkQjKJICRCLomFICRCF4mFfCIlfCIfQiSJIB9CHomFIB9CGYmFIB8gIiAghYMgIiAgg4V8IBlBACkDyLdCfCAhfCAjICUgD3wiIUJ/hYN8ICEgJIN8ICFCMokgIUIuiYUgIUIXiYV8IiV8Ig9CJIkgD0IeiYUgD0IZiYUgDyAfICKFgyAfICKDhXwgGEEAKQPQt0J8ICN8ICQgJSAdfCIjQn+Fg3wgIyAhg3wgI0IyiSAjQi6JhSAjQheJhXwiJXwiHUIkiSAdQh6JhSAdQhmJhSAdIA8gH4WDIA8gH4OFfCAXQQApA9i3QnwgJHwgISAlICB8IiRCf4WDfCAkICODfCAkQjKJICRCLomFICRCF4mFfCIlfCIgQiSJICBCHomFICBCGYmFICAgHSAPhYMgHSAPg4V8IBZBACkD4LdCfCAhfCAjICUgInwiIUJ/hYN8ICEgJIN8ICFCMokgIUIuiYUgIUIXiYV8IiV8IiJCJIkgIkIeiYUgIkIZiYUgIiAgIB2FgyAgIB2DhXwgFUEAKQPot0J8ICN8ICQgJSAffCIjQn+Fg3wgIyAhg3wgI0IyiSAjQi6JhSAjQheJhXwiJXwiH0IkiSAfQh6JhSAfQhmJhSAfICIgIIWDICIgIIOFfCAUQQApA/C3QnwgJHwgISAlIA98IiRCf4WDfCAkICODfCAkQjKJICRCLomFICRCF4mFfCIlfCIPQiSJIA9CHomFIA9CGYmFIA8gHyAihYMgHyAig4V8IBNBACkD+LdCfCAhfCAjICUgHXwiIUJ/hYN8ICEgJIN8ICFCMokgIUIuiYUgIUIXiYV8IiV8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXwgEkEAKQOAuEJ8ICN8ICQgJSAgfCIjQn+Fg3wgIyAhg3wgI0IyiSAjQi6JhSAjQheJhXwiJXwiIEIkiSAgQh6JhSAgQhmJhSAgIB0gD4WDIB0gD4OFfCARQQApA4i4QnwgJHwgISAlICJ8IiRCf4WDfCAkICODfCAkQjKJICRCLomFICRCF4mFfCIlfCIiQiSJICJCHomFICJCGYmFICIgICAdhYMgICAdg4V8IBBBACkDkLhCfCAhfCAjICUgH3wiJUJ/hYN8ICUgJIN8ICVCMokgJUIuiYUgJUIXiYV8IiF8Ih9CJIkgH0IeiYUgH0IZiYUgHyAiICCFgyAiICCDhXwgDUEAKQOYuEJ8ICN8ICQgISAPfCImQn+Fg3wgJiAlg3wgJkIyiSAmQi6JhSAmQheJhXwiI3wiD0IkiSAPQh6JhSAPQhmJhSAPIB8gIoWDIB8gIoOFfEEAKQOguEIgFSAOIB5CP4kgHkI4iYUgHkIHiIV8fCAQQi2JIBBCA4mFIBBCBoiFfCIhfCAkfCAlICMgHXwiDkJ/hYN8IA4gJoN8IA5CMokgDkIuiYUgDkIXiYV8IiR8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXxBACkDqLhCIBQgHiAcQj+JIBxCOImFIBxCB4iFfHwgDUItiSANQgOJhSANQgaIhXwiI3wgJXwgJiAkICB8Ih5Cf4WDfCAeIA6DfCAeQjKJIB5CLomFIB5CF4mFfCIlfCIgQiSJICBCHomFICBCGYmFICAgHSAPhYMgHSAPg4V8QQApA7C4QiATIBwgG0I/iSAbQjiJhSAbQgeIhXx8ICFCLYkgIUIDiYUgIUIGiIV8IiR8ICZ8IA4gJSAifCIcQn+Fg3wgHCAeg3wgHEIyiSAcQi6JhSAcQheJhXwiJnwiIkIkiSAiQh6JhSAiQhmJhSAiICAgHYWDICAgHYOFfEEAKQO4uEIgEiAbIBpCP4kgGkI4iYUgGkIHiIV8fCAjQi2JICNCA4mFICNCBoiFfCIlfCAOfCAeICYgH3wiG0J/hYN8IBsgHIN8IBtCMokgG0IuiYUgG0IXiYV8Ig58Ih9CJIkgH0IeiYUgH0IZiYUgHyAiICCFgyAiICCDhXxBACkDwLhCIBEgGiAZQj+JIBlCOImFIBlCB4iFfHwgJEItiSAkQgOJhSAkQgaIhXwiJnwgHnwgHCAOIA98IhpCf4WDfCAaIBuDfCAaQjKJIBpCLomFIBpCF4mFfCIefCIPQiSJIA9CHomFIA9CGYmFIA8gHyAihYMgHyAig4V8QQApA8i4QiAQIBkgGEI/iSAYQjiJhSAYQgeIhXx8ICVCLYkgJUIDiYUgJUIGiIV8Ig58IBx8IBsgHiAdfCIZQn+Fg3wgGSAag3wgGUIyiSAZQi6JhSAZQheJhXwiHHwiHUIkiSAdQh6JhSAdQhmJhSAdIA8gH4WDIA8gH4OFfEEAKQPQuEIgDSAYIBdCP4kgF0I4iYUgF0IHiIV8fCAmQi2JICZCA4mFICZCBoiFfCIefCAbfCAaIBwgIHwiGEJ/hYN8IBggGYN8IBhCMokgGEIuiYUgGEIXiYV8Iht8IiBCJIkgIEIeiYUgIEIZiYUgICAdIA+FgyAdIA+DhXxBACkD2LhCIBcgFkI/iSAWQjiJhSAWQgeIhXwgIXwgDkItiSAOQgOJhSAOQgaIhXwiHHwgGnwgGSAbICJ8IhdCf4WDfCAXIBiDfCAXQjKJIBdCLomFIBdCF4mFfCIafCIiQiSJICJCHomFICJCGYmFICIgICAdhYMgICAdg4V8QQApA+C4QiAWIBVCP4kgFUI4iYUgFUIHiIV8ICN8IB5CLYkgHkIDiYUgHkIGiIV8Iht8IBl8IBggGiAffCIWQn+Fg3wgFiAXg3wgFkIyiSAWQi6JhSAWQheJhXwiGXwiH0IkiSAfQh6JhSAfQhmJhSAfICIgIIWDICIgIIOFfEEAKQPouEIgFSAUQj+JIBRCOImFIBRCB4iFfCAkfCAcQi2JIBxCA4mFIBxCBoiFfCIafCAYfCAXIBkgD3wiFUJ/hYN8IBUgFoN8IBVCMokgFUIuiYUgFUIXiYV8Ihh8Ig9CJIkgD0IeiYUgD0IZiYUgDyAfICKFgyAfICKDhXxBACkD8LhCIBQgE0I/iSATQjiJhSATQgeIhXwgJXwgG0ItiSAbQgOJhSAbQgaIhXwiGXwgF3wgFiAYIB18IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIXfCIdQiSJIB1CHomFIB1CGYmFIB0gDyAfhYMgDyAfg4V8QQApA/i4QiATIBJCP4kgEkI4iYUgEkIHiIV8ICZ8IBpCLYkgGkIDiYUgGkIGiIV8Ihh8IBZ8IBUgFyAgfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiFnwiIEIkiSAgQh6JhSAgQhmJhSAgIB0gD4WDIB0gD4OFfEEAKQOAuUIgEiARQj+JIBFCOImFIBFCB4iFfCAOfCAZQi2JIBlCA4mFIBlCBoiFfCIXfCAVfCAUIBYgInwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhJ8IiJCJIkgIkIeiYUgIkIZiYUgIiAgIB2FgyAgIB2DhXxBACkDiLlCIBEgEEI/iSAQQjiJhSAQQgeIhXwgHnwgGEItiSAYQgOJhSAYQgaIhXwiFnwgFHwgEyASIB98IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIfQiSJIB9CHomFIB9CGYmFIB8gIiAghYMgIiAgg4V8QQApA5C5QiAQIA1CP4kgDUI4iYUgDUIHiIV8IBx8IBdCLYkgF0IDiYUgF0IGiIV8IhB8IBN8IBUgESAPfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiD0IkiSAPQh6JhSAPQhmJhSAPIB8gIoWDIB8gIoOFfEEAKQOYuUIgDSAhQj+JICFCOImFICFCB4iFfCAbfCAWQi2JIBZCA4mFIBZCBoiFfCINfCAVfCAUIBEgHXwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXwgI0I/iSAjQjiJhSAjQgeIhSAhfCAafCAQQi2JIBBCA4mFIBBCBoiFfCIhQQApA6C5QnwgFHwgEyARICB8IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIgQiSJICBCHomFICBCGYmFICAgHSAPhYMgHSAPg4V8ICRCP4kgJEI4iYUgJEIHiIUgI3wgGXwgDUItiSANQgOJhSANQgaIhXwiI0EAKQOouUJ8IBN8IBUgESAifCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiIkIkiSAiQh6JhSAiQhmJhSAiICAgHYWDICAgHYOFfCAlQj+JICVCOImFICVCB4iFICR8IBh8ICFCLYkgIUIDiYUgIUIGiIV8IiRBACkDsLlCfCAVfCAUIBEgH3wiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ih9CJIkgH0IeiYUgH0IZiYUgHyAiICCFgyAiICCDhXwgJkI/iSAmQjiJhSAmQgeIhSAlfCAXfCAjQi2JICNCA4mFICNCBoiFfCIlQQApA7i5QnwgFHwgEyARIA98IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIPQiSJIA9CHomFIA9CGYmFIA8gHyAihYMgHyAig4V8IA5CP4kgDkI4iYUgDkIHiIUgJnwgFnwgJEItiSAkQgOJhSAkQgaIhXwiJkEAKQPAuUJ8IBN8IBUgESAdfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiHUIkiSAdQh6JhSAdQhmJhSAdIA8gH4WDIA8gH4OFfCAeQj+JIB5COImFIB5CB4iFIA58IBB8ICVCLYkgJUIDiYUgJUIGiIV8Ig5BACkDyLlCfCAVfCAUIBEgIHwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8IiBCJIkgIEIeiYUgIEIZiYUgICAdIA+FgyAdIA+DhXwgHEI/iSAcQjiJhSAcQgeIhSAefCANfCAmQi2JICZCA4mFICZCBoiFfCIeQQApA9C5QnwgFHwgEyARICJ8IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIiQiSJICJCHomFICJCGYmFICIgICAdhYMgICAdg4V8IBtCP4kgG0I4iYUgG0IHiIUgHHwgIXwgDkItiSAOQgOJhSAOQgaIhXwiHEEAKQPYuUJ8IBN8IBUgESAffCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiH0IkiSAfQh6JhSAfQhmJhSAfICIgIIWDICIgIIOFfCAaQj+JIBpCOImFIBpCB4iFIBt8ICN8IB5CLYkgHkIDiYUgHkIGiIV8IhtBACkD4LlCfCAVfCAUIBEgD3wiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ig9CJIkgD0IeiYUgD0IZiYUgDyAfICKFgyAfICKDhXwgGUI/iSAZQjiJhSAZQgeIhSAafCAkfCAcQi2JIBxCA4mFIBxCBoiFfCIaQQApA+i5QnwgFHwgEyARIB18IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIdQiSJIB1CHomFIB1CGYmFIB0gDyAfhYMgDyAfg4V8IBhCP4kgGEI4iYUgGEIHiIUgGXwgJXwgG0ItiSAbQgOJhSAbQgaIhXwiGUEAKQPwuUJ8IBN8IBUgESAgfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiIEIkiSAgQh6JhSAgQhmJhSAgIB0gD4WDIB0gD4OFfCAXQj+JIBdCOImFIBdCB4iFIBh8ICZ8IBpCLYkgGkIDiYUgGkIGiIV8IhhBACkD+LlCfCAVfCAUIBEgInwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8IiJCJIkgIkIeiYUgIkIZiYUgIiAgIB2FgyAgIB2DhXwgFkI/iSAWQjiJhSAWQgeIhSAXfCAOfCAZQi2JIBlCA4mFIBlCBoiFfCIXQQApA4C6QnwgFHwgEyARIB98IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIfQiSJIB9CHomFIB9CGYmFIB8gIiAghYMgIiAgg4V8IBBCP4kgEEI4iYUgEEIHiIUgFnwgHnwgGEItiSAYQgOJhSAYQgaIhXwiFkEAKQOIukJ8IBN8IBUgESAPfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiD0IkiSAPQh6JhSAPQhmJhSAPIB8gIoWDIB8gIoOFfCANQj+JIA1COImFIA1CB4iFIBB8IBx8IBdCLYkgF0IDiYUgF0IGiIV8IhBBACkDkLpCfCAVfCAUIBEgHXwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXwgIUI/iSAhQjiJhSAhQgeIhSANfCAbfCAWQi2JIBZCA4mFIBZCBoiFfCINQQApA5i6QnwgFHwgEyARICB8IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIgQiSJICBCHomFICBCGYmFICAgHSAPhYMgHSAPg4V8ICNCP4kgI0I4iYUgI0IHiIUgIXwgGnwgEEItiSAQQgOJhSAQQgaIhXwiIUEAKQOgukJ8IBN8IBUgESAifCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiIkIkiSAiQh6JhSAiQhmJhSAiICAgHYWDICAgHYOFfCAkQj+JICRCOImFICRCB4iFICN8IBl8IA1CLYkgDUIDiYUgDUIGiIV8IiNBACkDqLpCfCAVfCAUIBEgH3wiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ih9CJIkgH0IeiYUgH0IZiYUgHyAiICCFgyAiICCDhXwgJUI/iSAlQjiJhSAlQgeIhSAkfCAYfCAhQi2JICFCA4mFICFCBoiFfCIkQQApA7C6QnwgFHwgEyARIA98IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIPQiSJIA9CHomFIA9CGYmFIA8gHyAihYMgHyAig4V8ICZCP4kgJkI4iYUgJkIHiIUgJXwgF3wgI0ItiSAjQgOJhSAjQgaIhXwiJUEAKQO4ukJ8IBN8IBUgESAdfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiHUIkiSAdQh6JhSAdQhmJhSAdIA8gH4WDIA8gH4OFfCAOQj+JIA5COImFIA5CB4iFICZ8IBZ8ICRCLYkgJEIDiYUgJEIGiIV8IiZBACkDwLpCfCAVfCAUIBEgIHwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8IiBCJIkgIEIeiYUgIEIZiYUgICAdIA+FgyAdIA+DhXwgHkI/iSAeQjiJhSAeQgeIhSAOfCAQfCAlQi2JICVCA4mFICVCBoiFfCIOQQApA8i6QnwgFHwgEyARICJ8IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIiQiSJICJCHomFICJCGYmFICIgICAdhYMgICAdg4V8IBxCP4kgHEI4iYUgHEIHiIUgHnwgDXwgJkItiSAmQgOJhSAmQgaIhXwiHkEAKQPQukJ8IBN8IBUgESAffCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiH0IkiSAfQh6JhSAfQhmJhSAfICIgIIWDICIgIIOFfCAbQj+JIBtCOImFIBtCB4iFIBx8ICF8IA5CLYkgDkIDiYUgDkIGiIV8IhxBACkD2LpCfCAVfCAUIBEgD3wiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ig9CJIkgD0IeiYUgD0IZiYUgDyAfICKFgyAfICKDhXwgGkI/iSAaQjiJhSAaQgeIhSAbfCAjfCAeQi2JIB5CA4mFIB5CBoiFfCIbQQApA+C6QnwgFHwgEyARIB18IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIdQiSJIB1CHomFIB1CGYmFIB0gDyAfhYMgDyAfg4V8IBlCP4kgGUI4iYUgGUIHiIUgGnwgJHwgHEItiSAcQgOJhSAcQgaIhXwiGkEAKQPoukJ8IBN8IBUgESAgfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiIEIkiSAgQh6JhSAgQhmJhSAgIB0gD4WDIB0gD4OFfCAYQj+JIBhCOImFIBhCB4iFIBl8ICV8IBtCLYkgG0IDiYUgG0IGiIV8IhlBACkD8LpCfCAVfCAUIBEgInwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8IiJCJIkgIkIeiYUgIkIZiYUgIiAgIB2FgyAgIB2DhXwgF0I/iSAXQjiJhSAXQgeIhSAYfCAmfCAaQi2JIBpCA4mFIBpCBoiFfCIYQQApA/i6QnwgFHwgEyARIB98IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIfQiSJIB9CHomFIB9CGYmFIB8gIiAghYMgIiAgg4V8IBZCP4kgFkI4iYUgFkIHiIUgF3wgDnwgGUItiSAZQgOJhSAZQgaIhXwiF0EAKQOAu0J8IBN8IBUgESAPfCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiD0IkiSAPQh6JhSAPQhmJhSAPIB8gIoWDIB8gIoOFfCAQQj+JIBBCOImFIBBCB4iFIBZ8IB58IBhCLYkgGEIDiYUgGEIGiIV8IhZBACkDiLtCfCAVfCAUIBEgHXwiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhF8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXwgDUI/iSANQjiJhSANQgeIhSAQfCAcfCAXQi2JIBdCA4mFIBdCBoiFfCIQQQApA5C7QnwgFHwgEyARICB8IhRCf4WDfCAUIBWDfCAUQjKJIBRCLomFIBRCF4mFfCIRfCIgQiSJICBCHomFICBCGYmFICAgHSAPhYMgHSAPg4V8ICFCP4kgIUI4iYUgIUIHiIUgDXwgG3wgFkItiSAWQgOJhSAWQgaIhXwiDUEAKQOYu0J8IBN8IBUgESAifCITQn+Fg3wgEyAUg3wgE0IyiSATQi6JhSATQheJhXwiEXwiIkIkiSAiQh6JhSAiQhmJhSAiICAgHYWDICAgHYOFfCAjQj+JICNCOImFICNCB4iFICF8IBp8IBBCLYkgEEIDiYUgEEIGiIV8IiFBACkDoLtCfCAVfCAUIBEgH3wiFUJ/hYN8IBUgE4N8IBVCMokgFUIuiYUgFUIXiYV8IhJ8Ih9CJIkgH0IeiYUgH0IZiYUgHyAiICCFgyAiICCDhXwgJEI/iSAkQjiJhSAkQgeIhSAjfCAZfCANQi2JIA1CA4mFIA1CBoiFfCIRQQApA6i7QnwgFHwgEyASIA98IiNCf4WDfCAjIBWDfCAjQjKJICNCLomFICNCF4mFfCISfCIPQiSJIA9CHomFIA9CGYmFIA8gHyAihYMgHyAig4V8ICVCP4kgJUI4iYUgJUIHiIUgJHwgGHwgIUItiSAhQgOJhSAhQgaIhXwiFEEAKQOwu0J8IBN8IBUgEiAdfCIkQn+Fg3wgJCAjg3wgJEIyiSAkQi6JhSAkQheJhXwiEnwiHUIkiSAdQh6JhSAdQhmJhSAdIA8gH4WDIA8gH4OFfCAmQj+JICZCOImFICZCB4iFICV8IBd8IBFCLYkgEUIDiYUgEUIGiIV8IhNBACkDuLtCfCAVfCAjIBIgIHwiJUJ/hYN8ICUgJIN8ICVCMokgJUIuiYUgJUIXiYV8IhV8IiBCJIkgIEIeiYUgIEIZiYUgICAdIA+FgyAdIA+DhXwgDkI/iSAOQjiJhSAOQgeIhSAmfCAWfCAUQi2JIBRCA4mFIBRCBoiFfCImQQApA8C7QnwgI3wgJCAVICJ8IiNCf4WDfCAjICWDfCAjQjKJICNCLomFICNCF4mFfCIVfCIiQiSJICJCHomFICJCGYmFICIgICAdhYMgICAdg4V8IB5CP4kgHkI4iYUgHkIHiIUgDnwgEHwgE0ItiSATQgOJhSATQgaIhXwiDkEAKQPIu0J8ICR8ICUgFSAffCIkQn+Fg3wgJCAjg3wgJEIyiSAkQi6JhSAkQheJhXwiFXwiH0IkiSAfQh6JhSAfQhmJhSAfICIgIIWDICIgIIOFfCAcQj+JIBxCOImFIBxCB4iFIB58IA18ICZCLYkgJkIDiYUgJkIGiIV8Ih5BACkD0LtCfCAlfCAjIBUgD3wiJUJ/hYN8ICUgJIN8ICVCMokgJUIuiYUgJUIXiYV8IhV8Ig9CJIkgD0IeiYUgD0IZiYUgDyAfICKFgyAfICKDhXwgG0I/iSAbQjiJhSAbQgeIhSAcfCAhfCAOQi2JIA5CA4mFIA5CBoiFfCIcQQApA9i7QnwgI3wgJCAVIB18IiNCf4WDfCAjICWDfCAjQjKJICNCLomFICNCF4mFfCIVfCIdQiSJIB1CHomFIB1CGYmFIB0gDyAfhYMgDyAfg4V8IBpCP4kgGkI4iYUgGkIHiIUgG3wgEXwgHkItiSAeQgOJhSAeQgaIhXwiG0EAKQPgu0J8ICR8ICUgFSAgfCIkQn+Fg3wgJCAjg3wgJEIyiSAkQi6JhSAkQheJhXwiFXwiIEIkiSAgQh6JhSAgQhmJhSAgIB0gD4WDIB0gD4OFfCAZQj+JIBlCOImFIBlCB4iFIBp8IBR8IBxCLYkgHEIDiYUgHEIGiIV8IhpBACkD6LtCfCAlfCAjIBUgInwiJUJ/hYN8ICUgJIN8ICVCMokgJUIuiYUgJUIXiYV8IhV8IiJCJIkgIkIeiYUgIkIZiYUgIiAgIB2FgyAgIB2DhXwgGEI/iSAYQjiJhSAYQgeIhSAZfCATfCAbQi2JIBtCA4mFIBtCBoiFfCIZQQApA/C7QnwgI3wgJCAVIB98IiNCf4WDfCAjICWDfCAjQjKJICNCLomFICNCF4mFfCIVfCIfQiSJIB9CHomFIB9CGYmFIB8gIiAghYMgIiAgg4V8IBdCP4kgF0I4iYUgF0IHiIUgGHwgJnwgGkItiSAaQgOJhSAaQgaIhXwiJkEAKQP4u0J8ICR8ICUgFSAPfCIkQn+Fg3wgJCAjg3wgJEIyiSAkQi6JhSAkQheJhXwiGnwiD0IkiSAPQh6JhSAPQhmJhSAPIB8gIoWDIB8gIoOFfCAWQj+JIBZCOImFIBZCB4iFIBd8IA58IBlCLYkgGUIDiYUgGUIGiIV8Ig5BACkDgLxCfCAlfCAjIBogHXwiJUJ/hYN8ICUgJIN8ICVCMokgJUIuiYUgJUIXiYV8Ihp8Ih1CJIkgHUIeiYUgHUIZiYUgHSAPIB+FgyAPIB+DhXwgEEI/iSAQQjiJhSAQQgeIhSAWfCAefCAmQi2JICZCA4mFICZCBoiFfCImQQApA4i8QnwgI3wgJCAaICB8IiBCf4WDfCAgICWDfCAgQjKJICBCLomFICBCF4mFfCIefCIjQiSJICNCHomFICNCGYmFICMgHSAPhYMgHSAPg4V8IBBBACkDkLxCfCANQj+JIA1COImFIA1CB4iFfCAcfCAOQi2JIA5CA4mFIA5CBoiFfCAkfCAlIB4gInwiEEJ/hYN8IBAgIIN8IBBCMokgEEIuiYUgEEIXiYV8IiR8IiIgIyAdhYMgIyAdg4UgDHwgIkIkiSAiQh6JhSAiQhmJhXwgDUEAKQOYvEJ8ICFCP4kgIUI4iYUgIUIHiIV8IBt8ICZCLYkgJkIDiYUgJkIGiIV8ICV8ICAgJCAffCINQn+Fg3wgDSAQg3wgDUIyiSANQi6JhSANQheJhXwiH3whDCAPIAh8IB98IQggIiALfCELIA0gB3whByAjIAp8IQogECAGfCEGIB0gCXwhCSAgIAV8IQUgAUGAAWoiASAERw0ACyAAIAU3AzggACAGNwMwIAAgBzcDKCAAIAg3AyAgACAJNwMYIAAgCjcDECAAIAs3AwggACAMNwMAC+EjAgh/AX4CQAJAAkACQAJAAkAgAEH1AUkNAAJAIABBzP97TQ0AQQAPCyAAQQtqIgFBeHEhAkEAKALkwEIiA0UNBEEfIQQCQCAAQfT//wdLDQAgAkEmIAFBCHZnIgBrdkEBcSAAQQF0a0E+aiEEC0EAIAJrIQECQCAEQQJ0Qci9wgBqKAIAIgUNAEEAIQZBACEADAILQQAhBiACQQBBGSAEQQF2ayAEQR9GG3QhB0EAIQADQAJAIAUiBSgCBEF4cSIIIAJJDQAgCCACayIIIAFPDQAgBSEGIAghASAIDQBBACEBIAUhACAFIQYMBAsgBSgCFCIIIAAgCCAFIAdBHXZBBHFqKAIQIgVHGyAAIAgbIQAgB0EBdCEHIAVFDQIMAAsLAkACQAJAAkACQAJAQQAoAuDAQiIFQRAgAEELakH4A3EgAEELSRsiAkEDdiIBdiIAQQNxRQ0AIABBf3NBAXEgAWoiB0EDdCIAQdi+wgBqIgEgAEHgvsIAaigCACICKAIIIgZGDQEgBiABNgIMIAEgBjYCCAwCCyACQQAoAujAQk0NCCAADQJBACgC5MBCIgBFDQggAGhBAnRByL3CAGooAgAiBSgCBEF4cSACayEBIAUhBgNAAkAgBigCECIADQAgBigCFCIADQAgBSgCGCEEAkACQAJAIAUoAgwiACAFRw0AIAVBFEEQIAUoAhQiABtqKAIAIgYNAUEAIQAMAgsgBSgCCCIGIAA2AgwgACAGNgIIDAELIAVBFGogBUEQaiAAGyEHA0AgByEIIAYiAEEUaiAAQRBqIAAoAhQiBhshByAAQRRBECAGG2ooAgAiBg0ACyAIQQA2AgALIARFDQYCQAJAIAUgBSgCHEECdEHIvcIAaiIGKAIARg0AAkAgBCgCECAFRg0AIAQgADYCFCAADQIMCQsgBCAANgIQIAANAQwICyAGIAA2AgAgAEUNBgsgACAENgIYAkAgBSgCECIGRQ0AIAAgBjYCECAGIAA2AhgLIAUoAhQiBkUNBiAAIAY2AhQgBiAANgIYDAYLIAAoAgRBeHEgAmsiBiABIAYgAUkiBhshASAAIAUgBhshBSAAIQYMAAsLQQAgBUF+IAd3cTYC4MBCCyACIABBA3I2AgQgAiAAaiIAIAAoAgRBAXI2AgQgAkEIag8LAkACQCAAIAF0QQIgAXQiAEEAIABrcnFoIghBA3QiAUHYvsIAaiIGIAFB4L7CAGooAgAiACgCCCIHRg0AIAcgBjYCDCAGIAc2AggMAQtBACAFQX4gCHdxNgLgwEILIAAgAkEDcjYCBCAAIAJqIgUgASACayIGQQFyNgIEIAAgAWogBjYCAAJAQQAoAujAQiIBRQ0AQQAoAvDAQiECAkACQEEAKALgwEIiB0EBIAFBA3Z0IghxDQBBACAHIAhyNgLgwEIgAUF4cUHYvsIAaiIBIQcMAQsgAUF4cSIBQdi+wgBqIQcgAUHgvsIAaigCACEBCyAHIAI2AgggASACNgIMIAIgBzYCDCACIAE2AggLQQAgBTYC8MBCQQAgBjYC6MBCIABBCGoPC0EAQQAoAuTAQkF+IAUoAhx3cTYC5MBCCwJAAkACQCABQRBJDQAgBSACQQNyNgIEIAUgAmoiBiABQQFyNgIEIAYgAWogATYCAEEAKALowEIiB0UNAUEAKALwwEIhAAJAAkBBACgC4MBCIghBASAHQQN2dCIEcQ0AQQAgCCAEcjYC4MBCIAdBeHFB2L7CAGoiByEIDAELIAdBeHEiB0HYvsIAaiEIIAdB4L7CAGooAgAhBwsgCCAANgIIIAcgADYCDCAAIAg2AgwgACAHNgIIDAELIAUgASACaiIAQQNyNgIEIAUgAGoiACAAKAIEQQFyNgIEDAELQQAgBjYC8MBCQQAgATYC6MBCCyAFQQhqIgBFDQMMBAsCQCAAIAZyDQBBACEGQQIgBHQiAEEAIABrciADcSIARQ0DIABoQQJ0Qci9wgBqKAIAIQALIABFDQELA0AgACgCBEF4cSIFIAJrIgcgASAHIAFJIggbIQQgBSACSSEHIAAgBiAIGyEIAkAgACgCECIFDQAgACgCFCEFCyABIAQgBxshASAGIAggBxshBiAFIQAgBQ0ACwsgBkUNAAJAQQAoAujAQiIAIAJJDQAgASAAIAJrTw0BCyAGKAIYIQQCQAJAAkAgBigCDCIAIAZHDQAgBkEUQRAgBigCFCIAG2ooAgAiBQ0BQQAhAAwCCyAGKAIIIgUgADYCDCAAIAU2AggMAQsgBkEUaiAGQRBqIAAbIQcDQCAHIQggBSIAQRRqIABBEGogACgCFCIFGyEHIABBFEEQIAUbaigCACIFDQALIAhBADYCAAsCQCAERQ0AAkACQAJAIAYgBigCHEECdEHIvcIAaiIFKAIARg0AAkAgBCgCECAGRg0AIAQgADYCFCAADQIMBAsgBCAANgIQIAANAQwDCyAFIAA2AgAgAEUNAQsgACAENgIYAkAgBigCECIFRQ0AIAAgBTYCECAFIAA2AhgLIAYoAhQiBUUNASAAIAU2AhQgBSAANgIYDAELQQBBACgC5MBCQX4gBigCHHdxNgLkwEILAkACQCABQRBJDQAgBiACQQNyNgIEIAYgAmoiACABQQFyNgIEIAAgAWogATYCAAJAIAFBgAJJDQAgACABECMMAgsCQAJAQQAoAuDAQiIFQQEgAUEDdnQiB3ENAEEAIAUgB3I2AuDAQiABQfgBcUHYvsIAaiIBIQUMAQsgAUH4AXEiAUHYvsIAaiEFIAFB4L7CAGooAgAhAQsgBSAANgIIIAEgADYCDCAAIAU2AgwgACABNgIIDAELIAYgASACaiIAQQNyNgIEIAYgAGoiACAAKAIEQQFyNgIECyAGQQhqIgANAQsCQAJAAkACQAJAAkBBACgC6MBCIgAgAk8NAAJAQQAoAuzAQiIAIAJLDQACQCACQa+ABGoiBkEQdkAAIgFBf0cNAEEADwtBACEAIAFBEHQiBUUNB0EAQQAoAvjAQiAGQYCAfHEiAEFwaiAAIAVBACAAa0YbIghqIgA2AvjAQkEAIABBACgC/MBCIgEgACABSxs2AvzAQgJAAkACQEEAKAL0wEIiAUUNAEHIvsIAIQADQCAAKAIAIgYgACgCBCIHaiAFRg0CIAAoAggiAA0ADAMLCwJAAkBBACgChMFCIgBFDQAgACAFTQ0BC0EAIAU2AoTBQgtBAEH/HzYCiMFCQQAgCDYCzL5CQQAgBTYCyL5CQQBB2L7CADYC5L5CQQBB4L7CADYC7L5CQQBB2L7CADYC4L5CQQBB6L7CADYC9L5CQQBB4L7CADYC6L5CQQBB8L7CADYC/L5CQQBB6L7CADYC8L5CQQBB+L7CADYChL9CQQBB8L7CADYC+L5CQQBBgL/CADYCjL9CQQBB+L7CADYCgL9CQQBBiL/CADYClL9CQQBBgL/CADYCiL9CQQBBkL/CADYCnL9CQQBBiL/CADYCkL9CQQBBADYC1L5CQQBBmL/CADYCpL9CQQBBkL/CADYCmL9CQQBBmL/CADYCoL9CQQBBoL/CADYCrL9CQQBBoL/CADYCqL9CQQBBqL/CADYCtL9CQQBBqL/CADYCsL9CQQBBsL/CADYCvL9CQQBBsL/CADYCuL9CQQBBuL/CADYCxL9CQQBBuL/CADYCwL9CQQBBwL/CADYCzL9CQQBBwL/CADYCyL9CQQBByL/CADYC1L9CQQBByL/CADYC0L9CQQBB0L/CADYC3L9CQQBB0L/CADYC2L9CQQBB2L/CADYC5L9CQQBB4L/CADYC7L9CQQBB2L/CADYC4L9CQQBB6L/CADYC9L9CQQBB4L/CADYC6L9CQQBB8L/CADYC/L9CQQBB6L/CADYC8L9CQQBB+L/CADYChMBCQQBB8L/CADYC+L9CQQBBgMDCADYCjMBCQQBB+L/CADYCgMBCQQBBiMDCADYClMBCQQBBgMDCADYCiMBCQQBBkMDCADYCnMBCQQBBiMDCADYCkMBCQQBBmMDCADYCpMBCQQBBkMDCADYCmMBCQQBBoMDCADYCrMBCQQBBmMDCADYCoMBCQQBBqMDCADYCtMBCQQBBoMDCADYCqMBCQQBBsMDCADYCvMBCQQBBqMDCADYCsMBCQQBBuMDCADYCxMBCQQBBsMDCADYCuMBCQQBBwMDCADYCzMBCQQBBuMDCADYCwMBCQQBByMDCADYC1MBCQQBBwMDCADYCyMBCQQBB0MDCADYC3MBCQQBByMDCADYC0MBCQQAgBTYC9MBCQQBB0MDCADYC2MBCQQAgCEFYaiIANgLswEIgBSAAQQFyNgIEIAUgAGpBKDYCBEEAQYCAgAE2AoDBQgwICyABIAVPDQAgBiABSw0AIAAoAgxFDQMLQQBBACgChMFCIgAgBSAAIAVJGzYChMFCIAUgCGohBkHIvsIAIQACQAJAAkADQCAAKAIAIgcgBkYNASAAKAIIIgANAAwCCwsgACgCDEUNAQtByL7CACEAAkADQAJAIAAoAgAiBiABSw0AIAEgBiAAKAIEaiIGSQ0CCyAAKAIIIQAMAAsLQQAgBTYC9MBCQQAgCEFYaiIANgLswEIgBSAAQQFyNgIEIAUgAGpBKDYCBEEAQYCAgAE2AoDBQiABIAZBYGpBeHFBeGoiACAAIAFBEGpJGyIHQRs2AgRBACkCyL5CIQkgB0EQakEAKQLQvkI3AgAgB0EIaiIAIAk3AgBBACAINgLMvkJBACAFNgLIvkJBACAANgLQvkJBAEEANgLUvkIgB0EcaiEAA0AgAEEHNgIAIABBBGoiACAGSQ0ACyAHIAFGDQcgByAHKAIEQX5xNgIEIAEgByABayIAQQFyNgIEIAcgADYCAAJAIABBgAJJDQAgASAAECMMCAsCQAJAQQAoAuDAQiIGQQEgAEEDdnQiBXENAEEAIAYgBXI2AuDAQiAAQfgBcUHYvsIAaiIAIQYMAQsgAEH4AXEiAEHYvsIAaiEGIABB4L7CAGooAgAhAAsgBiABNgIIIAAgATYCDCABIAY2AgwgASAANgIIDAcLIAAgBTYCACAAIAAoAgQgCGo2AgQgBSACQQNyNgIEIAdBD2pBeHFBeGoiASAFIAJqIgBrIQIgAUEAKAL0wEJGDQMgAUEAKALwwEJGDQQCQCABKAIEIgZBA3FBAUcNACABIAZBeHEiBhAfIAYgAmohAiABIAZqIgEoAgQhBgsgASAGQX5xNgIEIAAgAkEBcjYCBCAAIAJqIAI2AgACQCACQYACSQ0AIAAgAhAjDAYLAkACQEEAKALgwEIiAUEBIAJBA3Z0IgZxDQBBACABIAZyNgLgwEIgAkH4AXFB2L7CAGoiAiEBDAELIAJB+AFxIgJB2L7CAGohASACQeC+wgBqKAIAIQILIAEgADYCCCACIAA2AgwgACABNgIMIAAgAjYCCAwFC0EAIAAgAmsiATYC7MBCQQBBACgC9MBCIgAgAmoiBjYC9MBCIAYgAUEBcjYCBCAAIAJBA3I2AgQgAEEIaiEADAYLQQAoAvDAQiEBAkACQCAAIAJrIgZBD0sNAEEAQQA2AvDAQkEAQQA2AujAQiABIABBA3I2AgQgASAAaiIAIAAoAgRBAXI2AgQMAQtBACAGNgLowEJBACABIAJqIgU2AvDAQiAFIAZBAXI2AgQgASAAaiAGNgIAIAEgAkEDcjYCBAsgAUEIag8LIAAgByAIajYCBEEAQQAoAvTAQiIAQQ9qQXhxIgFBeGoiBjYC9MBCQQAgACABa0EAKALswEIgCGoiAWpBCGoiBTYC7MBCIAYgBUEBcjYCBCAAIAFqQSg2AgRBAEGAgIABNgKAwUIMAwtBACAANgL0wEJBAEEAKALswEIgAmoiAjYC7MBCIAAgAkEBcjYCBAwBC0EAIAA2AvDAQkEAQQAoAujAQiACaiICNgLowEIgACACQQFyNgIEIAAgAmogAjYCAAsgBUEIag8LQQAhAEEAKALswEIiASACTQ0AQQAgASACayIBNgLswEJBAEEAKAL0wEIiACACaiIGNgL0wEIgBiABQQFyNgIEIAAgAkEDcjYCBCAAQQhqDwsgAAuaIAIOfwJ+IwBBwCprIgckACAHIAI2AqgaIAcgATYCpBogByACNgKgGiAHQRhqIAdBoBpqEDggBygCGCEIIAcoAhwhASAHIAQ2AqgaIAcgAzYCpBogByAENgKgGiAHQRBqIAdBoBpqEDggBygCFCEJIAcoAhAhCiAHIAY2AqgaIAcgBTYCpBogByAGNgKgGiAHQQhqIAdBoBpqEDggBygCDCEDIAcoAgghBUEBIQICQAJAAkAgAUEgRw0AIAdBoBpqIAgQCwJAIAcoAqAaDQBBASECDAELIAdBzABqIAdBoBpqQRBqKAIANgIAIAcgBykCqBo3AkQgBygCpBohAgJAQZABRQ0AIAdB0ABqIAdBtBpqQZAB/AoAAAsgB0EgakEIaiAIQQhqKQAANwMAIAdBIGpBEGogCEEQaikAADcDACAHQSBqQRhqIAhBGGopAAA3AwAgByACNgJAIAcgCCkAADcDIEECIQIgA0HAAEcNACAHQaAaakEYaiAFQRhqKQAANwMAIAdBoBpqQRBqIAVBEGopAAA3AwAgB0GgGmpBCGogBUEIaikAADcDACAHQaAaakEoaiAFQShqKQAANwMAIAdBoBpqQTBqIAVBMGopAAA3AwAgB0GgGmpBOGogBUE4aikAADcDACAHIAUpAAA3A6AaIAcgBSkAIDcDwBoCQEHAAEUNACAHQaAQaiAHQaAaakHAAPwKAAALIAdBwABqIQsgB0HAA2pBGGogB0GgEGpBOGopAAA3AwAgB0HAA2pBEGogB0GgEGpBMGopAAA3AwAgB0HAA2pBCGogB0GgEGpBKGopAAA3AwAgByAHKQDAEDcDwAMgBywA3wNBf0oQSCEMIAdBkAdqIAdBoBBqQSBqIg0QCUEBIQRBACECA0AgB0GQB2ogAmotAAAgB0HAA2ogAmotAABzIgZBACAGa3LAQX9KEEggBHEhBCACQQFqIgJBIEcNAAsCQAJAIAQQSCAMcRBIQf8BcUEBRw0AIAdB2BpqIA1BGGopAAA3AwAgB0HQGmogDUEQaikAADcDACAHQcgaaiANQQhqKQAANwMAIAdBoBpqQQhqIAdBoBBqQQhqKQAANwMAIAdBoBpqQRBqIAdBoBBqQRBqKQAANwMAIAdBoBpqQRhqIAdBoBBqQRhqKQAANwMAIAcgDSkAADcDwBogByAHKQCgEDcDoBoCQEHAAEUNACAHQeABaiAHQaAaakHAAPwKAAALIAdBoBpqIAdB4AFqEAsgBygCoBpFDQACQEGgAUUNACAHQaACaiAHQaQaakGgAfwKAAALIAdBoAJqECkNACALECkNACAHQaAaakEYaiAHQeABakEYaikAADcDACAHQaAaakEQaiAHQeABakEQaikAADcDACAHQcgaaiAIQQhqKQAANwMAIAdB0BpqIAhBEGopAAA3AwAgB0HYGmogCEEYaikAADcDACAHIAdB4AFqQQhqKQAANwOoGiAHIAcpAOABNwOgGiAHIAgpAAA3A8AaIAdBwAZqIQ0CQEHAAEUiBA0AIA1BgLbCAEHAAPwKAAALAkBBwAFFDQAgB0HAA2ogB0EgakHAAfwKAAALAkAgBA0AIAdBwANqQcABaiAHQeABakHAAPwKAAALIAdBwAVqIQICQEH/AEUNACACIAdBoBpqQf8A/AoAAAsgB0IANwOIByAHQgA3A4AHIAdBwAA6AL8GAkACQAJAAkAgCUHAAEkNACAJIQYgCiEMQcAADQEMAgsCQCAJRQ0AIAJBwABqIAogCfwKAAALIAdBwAAgCWo6AL8GDAILAkAgBA0AIAJBwABqIApBwAD8CgAACyAHIAcpA4AHQgF8IhU3A4AHIAcgBykDiAcgFVCtfDcDiAcgDSACQQEQAyAHQQA6AL8GIAlBwABrIQYgCkHAAGohDAsgBkH/AHEhBAJAIAZBgAFJDQAgByAHKQOAByIVIAZBB3YiC618IhY3A4AHIAcgBykDiAcgFiAVVK18NwOIByANIAwgCxADCyAHIAQ6AL8GIARFDQAgAiAMIAZBgP///wdxaiAE/AoAAAsCQEHQA0UNACAHQZAHaiAHQcADakHQA/wKAAALAkBB0AFFDQAgB0GgGmogAkHQAfwKAAALIAdB4ApqIAdBoBpqEAoCQEEoRSICDQAgB0GgEGogB0HgA2pBKPwKAAALIAdBoBBqECsgB0GIBGohBAJAIAINACAHQYALakEoaiAEQSj8CgAACyAHQbAEaiENAkAgAg0AIAdB0AtqIA1BKPwKAAALAkAgAg0AIAdBoBpqIAdB2ARqQSj8CgAACyAHQaAaahArAkAgAg0AIAdBgAtqIAdBoBBqQSj8CgAACwJAIAINACAHQfgLaiAHQaAaakEo/AoAAAsgB0GgDGogB0HgCmpBBRAkIAdBoA5qIAdB8AhqQQgQJEH/ASECAkADQCAHQaAMaiACIgZqLQAADQEgBkUNASAGQX9qIQIgB0GgDmogBmotAABB/wFxRQ0ACwsgB0GgEGogB0GAC2oQLEEAIQIDQAJAQaABRQ0AIAdBoBpqIAJqIAdBoBBqQaAB/AoAAAsgAkGgAWoiAkGACkcNAAsCQEEoRSICDQAgB0HgJmpBKGogBEEo/AoAAAsCQCACDQAgB0GwJ2ogDUEo/AoAAAsCQCACDQAgB0HgJmogB0GAC2pBKPwKAAALIAdBoBBqIAdB4CZqEBwgB0GgJGogB0GgEGoQPkEAIQIDQCAHQaAQaiAHQaAkaiAHQaAaaiACaiIEEBUgB0HgJmogB0GgEGoQPiAHQcAlaiAHQeAmahAsAkBBoAFFDQAgBEGgAWogB0HAJWpBoAH8CgAACyACQaABaiICQeAIRw0ACwJAQYAKRQ0AIAdBoBBqIAdBoBpqQYAK/AoAAAsCQEEoRSICDQAgB0HAJWpBAEEo/AsACyAHQcAlakEoaiEOAkAgAg0AIA5BxIfAAEEo/AoAAAsgB0HAJWpB0ABqIQ8CQCACDQAgD0HEh8AAQSj8CgAACyAHQaAaakHQAGohECAHQaAaakH4AGohDCAHQaAaakEoaiELIAdB4CZqQfgAaiERIAdB4CZqQdAAaiESIAdB4CZqQShqIRMCQAJAAkACQANAIAdB4CZqIAdBwCVqEBwCQAJAAkAgB0GgDGogBmosAAAiAkEASiACQQBIa0H/AXEOAgIBAAtBACACayICwEEBdiEUIAdBoBpqIAdB4CZqED4gAkH/AXFBEE8NAwJAQShFIg0NACAHQaApaiALQSj8CgAAC0EAIQIDQCAHQaApaiACaiIEIAQoAgAgB0GgGmogAmooAgBqNgIAIAJBBGoiAkEoRw0ACwJAIA0NACAHQcgpaiALQSj8CgAACyAHQcgpaiAHQaAaahAhIAdBgChqIAdBoClqIAdBoBBqIBRBoAFsaiICQShqEAwgB0GoKGogB0HIKWogAhAMIAdB0ChqIAwgAkH4AGoQDCAHQfgoaiAQIAJB0ABqEAwCQCANDQAgB0HwKWogB0H4KGpBKPwKAAALQQAhAgNAIAdB8ClqIAJqIgQgBCgCACAHQfgoaiACaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdBmCpqIAdBgChqQSj8CgAACyAHQZgqaiAHQagoahAhQQAhAgNAIAdBgChqIAJqIgQgBCgCACAHQagoaiACaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdBoCRqIAdB8ClqQSj8CgAACyAHQaAkaiAHQdAoahAhQQAhAgNAIAdB8ClqIAJqIgQgBCgCACAHQdAoaiACaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdB4CZqIAdBmCpqQSj8CgAACwJAIA0NACATIAdBgChqQSj8CgAACwJAIA0NACASIAdBoCRqQSj8CgAACyANDQEgESAHQfApakEo/AoAAAwBCyACQQF2IQQgB0GgGmogB0HgJmoQPiACQRBPDQMgB0HgJmogB0GgGmogB0GgEGogBEGgAWxqEBULAkACQAJAIAdBoA5qIAZqLAAAIgJBAEogAkEASGtB/wFxDgICAQALQQAgAmvAIgJBAXYhFCAHQaAaaiAHQeAmahA+IAJBf0wNBQJAQShFIg0NACAHQaApaiALQSj8CgAAC0EAIQIDQCAHQaApaiACaiIEIAQoAgAgB0GgGmogAmooAgBqNgIAIAJBBGoiAkEoRw0ACwJAIA0NACAHQcgpaiALQSj8CgAACyAHQcgpaiAHQaAaahAhIAdBqChqIAdBoClqIBRB+ABsIgJBuInAAGoQDCAHQdAoaiAHQcgpaiACQZCJwABqEAwgB0H4KGogDCACQeCJwABqEAwCQCANDQAgB0HwKWogEEEo/AoAAAtBACECA0AgB0HwKWogAmoiBCAEKAIAIAdBoBpqIAJqQdAAaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdBmCpqIAdBqChqQSj8CgAACyAHQZgqaiAHQdAoahAhQQAhAgNAIAdBqChqIAJqIgQgBCgCACAHQdAoaiACaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdBoCRqIAdB8ClqQSj8CgAACyAHQaAkaiAHQfgoahAhQQAhAgNAIAdB8ClqIAJqIgQgBCgCACAHQfgoaiACaigCAGo2AgAgAkEEaiICQShHDQALAkAgDQ0AIAdB4CZqIAdBmCpqQSj8CgAACwJAIA0NACATIAdBqChqQSj8CgAACwJAIA0NACASIAdBoCRqQSj8CgAACyANDQEgESAHQfApakEo/AoAAAwBCyACQQF2IQQgB0GgGmogB0HgJmoQPiACQX9MDQUgB0HgJmogB0GgGmogBEH4AGxBkInAAGoQFgsgB0HAJWogB0HgJmoQQQJAIAZFDQAgBkF/aiEGDAELCyAHQaAaaiAHQcAlaiAPEAwgB0HIGmogDiAPEAwgB0HgJmogDxASIAdB8BpqIAdB4CZqECYgB0GYG2ogB0HAJWogDhAMIAdBoBBqIAdBoBpqECVBASEEQQAhAgNAIAdB4AFqIAJqLQAAIAdBoBBqIAJqLQAAcyIGQQAgBmtywEF/ShBIIARxIQQgAkEBaiICQSBHDQALIAQQSEH/AXFBAEchBAwFCyAUQQhB8IjAABA7AAsgBEEIQfCIwAAQOwALIBRBwABBgInAABA7AAsgBEHAAEGAicAAEDsAC0EAIQQLQQAhAgwBC0EAIQQgB0EANgKoGiAHQoCAgIAQNwKgGiACIAdBoBpqEDcNASAHKAKgGiECIAcoAqQaIg0gBygCqBoQAiEGIAIgDRA2QQEhAgsCQCADRQ0AIAUgA0EBEDoLAkAgCUUNACAKIAlBARA6CwJAIAFFDQAgCCABQQEQOgsgACACNgIIIAAgBkEAIAIbNgIEIABBACAEIAIbNgIAIAdBwCpqJAAPC0HQgMAAQTcgB0GgEGpBwIDAAEGQhcAAEDkAC6YYAgp/JH4jAEHQAGsiAyQAIAMgAigCACIErSINIAEoAgAiBa0iDn4iD0Kb/NGSAX5C/////wGDIhBC0rHMBH4gASgCBCIGrSIRIA1+IAIoAgQiB60iEiAOfnwiE3wgEELtp9fnAX4gD3xCHYh8IhRCm/zRkgF+Qv////8BgyIVQhSGIAEoAhQiCCAFaq0iFiACNQIQIhd+fCACKAIUIgUgBGqtIhggATUCECIZfnwgAigCDCIErSIaIBF+IAEoAggiCa0iGyACKAIIIgqtIhx+fCABKAIMIgutIh0gEn58IBcgDn58IBkgDX58Ih59IAEoAhwiDCAJaq0iHyACKAIcIgkgCmqtIiB+fCACKAIgIgogBGqtIiEgASgCGCIEIAZqrSIifnwgASgCICIBIAtqrSIjIAIoAhgiAiAHaq0iJH58IAqtIiUgBK0iJn4gDK0iJyAJrSIofnwgAa0iKSACrSIqfnwiK30gFULNAn4gD30gHSAcfiAaIBt+fCAXIBF+fCAZIBJ+fCAFrSIsIAitIi1+fSIufCAYIBZ+fCAcIA5+IBEgEn58IBsgDX58Ii8gEEKW65zvAX58IBVC0rHMBH58IBVC7afX5wF+IBR8Qh2IfCIUQpv80ZIBfkL/////AYMiD0LF+s7vAX58IBsgEn4gHCARfnwgGiAOfnwgHSANfnwiMCAQQsX6zu8BfnwgFUKW65zvAX58IA9C0rHMBH58IA9C7afX5wF+IBR8Qh2IfCIOQpv80ZIBfkL/////AYMiDUKW65zvAX58IBVCxfrO7wF+IBBCzQJ+fCAefCAPQpbrnO8BfnwgDULSscwEfnwgDULtp9fnAX4gDnxCHYh8Ig5Cm/zRkgF+Qv////8BgyIVQtKxzAR+fCAVQu2n1+cBfiAOfEIdiHwiEUKb/NGSAX5C/////wGDIg5CzQJ+fCAkIBZ+IBN9ICIgGH58IBcgG34gHSAafnwgGSAcfnwgJiAsfiAqIC1+fH0iG3wgD0LNAn58IA1CxfrO7wF+fCAVQpbrnO8BfnwgDkLSscwEfnwgDkLtp9fnAX4gEXxCHYh8IhJCm/zRkgF+Qv////8BgyIRQsX6zu8BfnwgIiAkfiAvfSAgIBZ+fCAfIBh+fCAZIBp+IBcgHX58ICggLX4gJiAqfnwgJyAsfnx9Ihp8IA1CzQJ+fCAVQsX6zu8BfnwgDkKW65zvAX58IBFC0rHMBH58IBFC7afX5wF+IBJ8Qh2IfCIcQpv80ZIBfkL/////AYMiEkKW65zvAX58IBBCFIYgMH0gGSAXfnwgICAifnwgHyAkfnwgISAWfnwgIyAYfnwgJyAqfiAoICZ+fCAlIC1+fCApICx+fCIWfSAVQs0CfnwgDkLF+s7vAX58IBFCluuc7wF+fCASQtKxzAR+fCASQu2n1+cBfiAcfEIdiHwiGEKb/NGSAX5C/////wGDIhBC0rHMBH58IBBC7afX5wF+IBh8Qh2IfCIYp0H/////AXE2AiwgAyAkIBl+IC59ICIgF358ICEgH358ICMgIH58ICkgKH4gJSAnfnwiHH0gD0IUhnwgEULNAn58IBJCxfrO7wF+fCAQQpbrnO8BfnwgGEIdiHwiD6dB/////wFxNgIwIAMgICAZfiAfIBd+fCAbICkgJX4iGHx9ICMgIX58IA1CFIZ8IBJCzQJ+fCAQQsX6zu8BfnwgD0IdiHwiD6dB/////wFxNgI0IAMgIyAXfiAhIBl+fCAafSAVQhSGfCAQQs0CfnwgD0IdiHwiF6dB/////wFxNgI4IAMgDkIUhiAWfCAXQh2IfCIXp0H/////AXE2AjwgAyARQhSGICt8IBdCHYh8IhenQf////8BcTYCQCADIBJCFIYgHHwgF0IdiHwiF6dB/////wFxNgJEIAMgEEIUhiAYfCAXQh2IfCIXQh2IPgJMIAMgF6dB/////wFxNgJIIANBCGogA0EsahAqIAMgAzUCGCIXQo6RvvwAfiADKAIMIgGtIg1C1+78oQF+IAMoAggiAq0iGUKBr8vLAX58IAMoAhAiBK0iDkK9/rWsAX58IAMoAhQiBa0iEUKXttDwAX58IBdCkrr+2gB+fCIgfSADKAIcIgYgAmqtIhJCga/LywF+fCADKAIgIgIgAWqtIhZCxPeQogF+fCADKAIkIgEgBGqtIhhC25iXnQN+fCADKAIoIgQgBWqtIhpC1MSL2AN+fCABrSIbQp6a4fABfiACrSIcQu2IFH58IAStIh1CvY675wF+fCIhfSAZQubZsYIBfkL+////AYMiEELSscwEfiANQpK6/toAfiAZQpe20PABfnwiInwgEELtp9fnAX4gGUKSuv7aAH4iD3xCHYh8IiNCm/zRkgF+Qv////8BgyIVQhSGfCAOQtfu/KEBfiANQoGvy8sBfnwgEUK9/rWsAX58IBdCl7bQ8AF+fCAGrSIfQoSpwF5+fCIkIA99IBJCjpG+/AB+fCAVQs0CfnwgDUKXttDwAX4gGUK9/rWsAX58IA5Ckrr+2gB+fCIlIBBCluuc7wF+fCAVQtKxzAR+fCAVQu2n1+cBfiAjfEIdiHwiI0Kb/NGSAX5C/////wGDIg9CxfrO7wF+fCANQr3+tawBfiAZQtfu/KEBfnwgDkKXttDwAX58IBFCkrr+2gB+fCImIBBCxfrO7wF+fCAVQpbrnO8BfnwgD0LSscwEfnwgD0Ltp9fnAX4gI3xCHYh8Ig1Cm/zRkgF+Qv////8BgyIZQpbrnO8BfnwgICAQQs0CfnwgFULF+s7vAX58IA9Cluuc7wF+fCAZQtKxzAR+fCAZQu2n1+cBfiANfEIdiHwiDUKb/NGSAX5C/////wGDIhVC0rHMBH58IBVC7afX5wF+IA18Qh2IfCIgQpv80ZIBfkL/////AYMiDULNAn58IBJC1MSL2AN+ICJ9IBZCjpG+/AB+fCARQtfu/KEBfiAOQoGvy8sBfnwgF0K9/rWsAX58IB9Cw/HEmH5+fCAcQoSpwF5+fCIifCAPQs0CfnwgGULF+s7vAX58IBVCluuc7wF+fCANQtKxzAR+fCANQu2n1+cBfiAgfEIdiHwiIEKb/NGSAX5C/////wGDIg5CxfrO7wF+fCASQtuYl50DfiAlfSAWQtTEi9gDfnwgGEKOkb78AH58IBdC1+78oQF+IBFCga/LywF+fCAfQuLlno9+fnwgHELD8cSYfn58IBtChKnAXn58IiN8IBlCzQJ+fCAVQsX6zu8BfnwgDUKW65zvAX58IA5C0rHMBH58IA5C7afX5wF+ICB8Qh2IfCIgQpv80ZIBfkL/////AYMiEUKW65zvAX58IBBCFIYgJn0gF0KBr8vLAX58IBJCxPeQogF+fCAWQtuYl50DfnwgGELUxIvYA358IBpCjpG+/AB+fCAcQp6a4fABfiAfQu2IFH58IBtCvY675wF+fCAdQvzWvyF+fCISfSAVQs0CfnwgDULF+s7vAX58IA5Cluuc7wF+fCARQtKxzAR+fCARQu2n1+cBfiAgfEIdiHwiHEKb/NGSAX5C/////wGDIhBC0rHMBH58IBBC7afX5wF+IBx8Qh2IfCIcp0H/////AXE2AiwgAyAXQtTEi9gDfiAkfSAWQoGvy8sBfnwgGELE95CiAX58IBpC25iXnQN+fCAdQp6a4fABfiAbQu2IFH58IhZ9IA9CFIZ8IA5CzQJ+fCARQsX6zu8BfnwgEEKW65zvAX58IBxCHYh8Ig+nQf////8BcTYCMCADIBdC25iXnQN+IBhCga/LywF+fCAiIB1C7YgUfiIYfH0gGkLE95CiAX58IBlCFIZ8IBFCzQJ+fCAQQsX6zu8BfnwgD0IdiHwiGadB/////wFxNgI0IAMgF0LE95CiAX4gI30gGkKBr8vLAX58IBVCFIZ8IBBCzQJ+fCAZQh2IfCIXp0H/////AXE2AjggAyANQhSGIBJ8IBdCHYh8IhenQf////8BcTYCPCADIA5CFIYgIXwgF0IdiHwiF6dB/////wFxNgJAIAMgEUIUhiAWfCAXQh2IfCIXp0H/////AXE2AkQgAyAQQhSGIBh8IBdCHYh8IhdCHYg+AkwgAyAXp0H/////AXE2AkggACADQSxqECogA0HQAGokAAuNEwIIfwJ+IwBB8AprIgUkACAFIAI2AugDIAUgATYC5AMgBSACNgLgAyAFQRBqIAVB4ANqEDggBSgCFCEBIAUoAhAhBiAFIAQ2AugDIAUgAzYC5AMgBSAENgLgAyAFQQhqIAVB4ANqEDggBSgCDCEEIAUoAgghByAFQeADaiAGIAEQEwJAAkACQAJAIAUtAOADIggNACAFQYACaiEDAkBB4AFFIgINACADIAVB5ANqQeAB/AoAAAsCQCACDQAgBUEcaiADQeAB/AoAAAsgBUH4A2ogBUHYA2opAQA3AwAgBUHwA2ogBUHQA2opAQA3AwAgBSAFQcgDaikBADcD6AMgBSAFKQHAAzcD4AMgBUHgA2pBgAFqIQkCQEHAAEUiCg0AIAlBgLbCAEHAAPwKAAALIAVCADcDqAUgBUIANwOgBUEAIQICQCAKDQAgBUGoCWpBAEHAAPwLAAsgBUGAAToAgAQCQEHfAEUNACAFQYEEakEAQd8A/AsACyAFQoCAgICAgMAANwPYBCAFQgA3A9AEAkBBgAFFDQAgBUHQBmogBUHgA2pBgAH8CgAACyAJIAVB0AZqQQEQAwNAIAVBqAlqIAJqIAVB4ANqIAJqQYABaikDACINQjiGIA1CgP4Dg0IohoQgDUKAgPwHg0IYhiANQoCAgPgPg0IIhoSEIA1CCIhCgICA+A+DIA1CGIhCgID8B4OEIA1CKIhCgP4DgyANQjiIhISENwAAIAJBCGoiAkHAAEcNAAsCQEHAAEUiCQ0AIAVB0AZqIAVBqAlqQcAA/AoAAAsCQCAJDQAgBUGoCWogBUHQBmpBwAD8CgAACyAFQZAGaiAFQagJahAtIAVB0AdqIQICQCAJDQAgAkGAtsIAQcAA/AoAAAsgBUHgBmogBUHABmopAAA3AwAgBUHoBmogBUHIBmopAAA3AwAgBUIANwOYCCAFQgA3A5AIIAVBIDoAzwcgBSAFKQCwBjcD0AYgBSAFQbgGaikAADcD2AYCQAJAIARB4ABJDQAgBCEJIAchC0EgDQEMAwsCQCAERQ0AIAVB0AZqQSBqIAcgBPwKAAALIAVBICAEajoAzwcMAwsCQEHgAEUNACAFQdAGakEgaiAHQeAA/AoAAAsgBSAFKQOQCEIBfCINNwOQCCAFIAUpA5gIIA1QrXw3A5gIIAIgBUHQBmpBARADIAVBADoAzwcgBEHgAGshCSAHQeAAaiELDAELIAUtAOEDIQIgBUEANgLoAyAFQoCAgIAQNwLgAwJAIAIgBUHgA2oQNw0AIAUoAuADIQMgBSgC5AMiCSAFKALoAxACIQIgAyAJEDZBgICAgHghAwwDC0HQgMAAQTcgBUHQBmpBwIDAAEGQhcAAEDkACyAJQf8AcSEKAkAgCUGAAUkNACAFIAUpA5AIIg0gCUEHdiIMrXwiDjcDkAggBSAFKQOYCCAOIA1UrXw3A5gIIAIgCyAMEAMLIAUgCjoAzwcgCkUNACAFQdAGaiALIAlBgP///wdxaiAK/AoAAAsCQEHQAUUNACAFQeADaiAFQdAGakHQAfwKAAALIAVBqAhqIAVB4ANqEAogBUHgA2ogBUGoCGoQFCAFQcgIaiAFQeADahAlAkBBwABFDQAgAkGAtsIAQcAA/AoAAAsgBUHQBmpBEGogBUHICGpBEGopAAA3AwAgBUHQBmpBGGogBUHICGpBGGopAAA3AwAgBUH4BmogA0EIaikBADcDACAFQYAHaiADQRBqKQEANwMAIAVBiAdqIANBGGopAQA3AwAgBUIANwOYCCAFQgA3A5AIIAVBwAA6AM8HIAUgBSkAyAg3A9AGIAUgBUHICGpBCGopAAA3A9gGIAUgAykBADcD8AYCQAJAIARBP0sNAAJAIARFDQAgBUHQBmpBwABqIAcgBPwKAAALIAUgBEHAAHI6AM8HDAELAkBBwABFDQAgBUHQBmpBwABqIAdBwAD8CgAACyAFIAUpA5AIQgF8Ig03A5AIIAUgBSkDmAggDVCtfDcDmAggAiAFQdAGakEBEAMgBUEAOgDPByAHQcAAaiEKIARBQGoiCUH/AHEhAwJAIAlBgAFJDQAgBSAFKQOQCCINIAlBB3YiC618Ig43A5AIIAUgBSkDmAggDiANVK18NwOYCCACIAogCxADCyAFIAM6AM8HIANFDQAgBUHQBmogCiAJQYD///8HcWogA/wKAAALAkBB0AFFDQAgBUHgA2ogBUHQBmpB0AH8CgAACyAFQegIaiAFQeADahAKIAVBqAlqIAVB6AhqECAgBUHgA2ogBUGQBmoQICAFQYwKaiAFQagJaiAFQeADahAGIAVBiAlqIAVBjApqEB0gBUGMCmogBUGICWoQICAFQagJaiAFQagIahAgIAVB6AlqIAVBjApqIAVBqAlqEDAgBUHgA2pBIGogBUHoCWoQHSAFQdAFakEIaiAFQYgEaikAADcDACAFQdAFakEQaiAFQZAEaikAADcDACAFQdAFakEYaiAFQZgEaikAADcDACAFQfAFakEIaiAFQdEIaikAADcDACAFQfAFakEQaiAFQdkIaikAADcDACAFQYcGaiAFQcgIakEYaikAADcAACAFIAUpAIAENwPQBSAFIAUpAMkINwPwBSAFLQDICCEDQQAhAgNAIAVBkAZqIAJqQQA6AAAgAkEBaiICQSBHDQALQSAhAgNAIAVBkAZqIAJqQQA6AAAgAkEBaiICQcAARw0ACyAFQbAKakEIaiAFQfAFakEIaikDADcDACAFQbAKakEQaiAFQfAFakEQaikDADcDACAFQbAKakEXaiAFQfAFakEXaikAADcAACAFQdcKaiAFQdAFakEIaikDADcAACAFQd8KaiAFQdAFakEQaikDADcAACAFQecKaiAFQegFaikDADcAACAFIAUpA/AFNwOwCiAFIAUpA9AFNwDPCkHAASECA0AgBUEcaiACakEAOgAAIAJBAWoiAkHgAUcNAAsCQEHAABAEIgINAEEBQcAAEE8ACyACIAM6AAACQEE/RQ0AIAJBAWogBUGwCmpBP/wKAAALQcAAIQMLAkAgBEUNACAHIARBARA6CwJAIAFFDQAgBiABQQEQOgsCQAJAIAhFDQBBASEEQQAhAUEAIQMMAQsgBUHAADYC6AMgBSACNgLkAyAFIAM2AuADIAUgBUHgA2oQOEEAIQIgBSgCACEBIAUoAgQhA0EAIQQLIAAgBDYCDCAAIAI2AgggACADNgIEIAAgATYCACAFQfAKaiQAC84LAgp/JH4jAEEwayIDJAAgAyACKAIAIgStIg0gASgCACIFrSIOfiIPQpv80ZIBfkL/////AYMiEELSscwEfiABKAIEIgatIhEgDX4gAigCBCIHrSISIA5+fCITfCAQQu2n1+cBfiAPfEIdiHwiFEKb/NGSAX5C/////wGDIhVCFIYgASgCFCIIIAVqrSIWIAI1AhAiF358IAIoAhQiBSAEaq0iGCABNQIQIhl+fCACKAIMIgStIhogEX4gASgCCCIJrSIbIAIoAggiCq0iHH58IAEoAgwiC60iHSASfnwgFyAOfnwgGSANfnwiHn0gASgCHCIMIAlqrSIfIAIoAhwiCSAKaq0iIH58IAIoAiAiCiAEaq0iISABKAIYIgQgBmqtIiJ+fCABKAIgIgEgC2qtIiMgAigCGCICIAdqrSIkfnwgCq0iJSAErSImfiAMrSInIAmtIih+fCABrSIpIAKtIip+fCIrfSAVQs0CfiAPfSAdIBx+IBogG358IBcgEX58IBkgEn58IAWtIiwgCK0iLX59Ii58IBggFn58IBwgDn4gESASfnwgGyANfnwiLyAQQpbrnO8BfnwgFULSscwEfnwgFULtp9fnAX4gFHxCHYh8IhRCm/zRkgF+Qv////8BgyIPQsX6zu8BfnwgGyASfiAcIBF+fCAaIA5+fCAdIA1+fCIwIBBCxfrO7wF+fCAVQpbrnO8BfnwgD0LSscwEfnwgD0Ltp9fnAX4gFHxCHYh8Ig5Cm/zRkgF+Qv////8BgyINQpbrnO8BfnwgFULF+s7vAX4gEELNAn58IB58IA9Cluuc7wF+fCANQtKxzAR+fCANQu2n1+cBfiAOfEIdiHwiDkKb/NGSAX5C/////wGDIhVC0rHMBH58IBVC7afX5wF+IA58Qh2IfCIRQpv80ZIBfkL/////AYMiDkLNAn58ICQgFn4gE30gIiAYfnwgFyAbfiAdIBp+fCAZIBx+fCAmICx+ICogLX58fSIbfCAPQs0CfnwgDULF+s7vAX58IBVCluuc7wF+fCAOQtKxzAR+fCAOQu2n1+cBfiARfEIdiHwiEkKb/NGSAX5C/////wGDIhFCxfrO7wF+fCAiICR+IC99ICAgFn58IB8gGH58IBkgGn4gFyAdfnwgKCAtfiAmICp+fCAnICx+fH0iGnwgDULNAn58IBVCxfrO7wF+fCAOQpbrnO8BfnwgEULSscwEfnwgEULtp9fnAX4gEnxCHYh8IhxCm/zRkgF+Qv////8BgyISQpbrnO8BfnwgEEIUhiAwfSAZIBd+fCAgICJ+fCAfICR+fCAhIBZ+fCAjIBh+fCAnICp+ICggJn58ICUgLX58ICkgLH58IhZ9IBVCzQJ+fCAOQsX6zu8BfnwgEUKW65zvAX58IBJC0rHMBH58IBJC7afX5wF+IBx8Qh2IfCIYQpv80ZIBfkL/////AYMiEELSscwEfnwgEELtp9fnAX4gGHxCHYh8IhinQf////8BcTYCDCADICQgGX4gLn0gIiAXfnwgISAffnwgIyAgfnwgKSAofiAlICd+fCIcfSAPQhSGfCARQs0CfnwgEkLF+s7vAX58IBBCluuc7wF+fCAYQh2IfCIPp0H/////AXE2AhAgAyAgIBl+IB8gF358IBsgKSAlfiIYfH0gIyAhfnwgDUIUhnwgEkLNAn58IBBCxfrO7wF+fCAPQh2IfCIPp0H/////AXE2AhQgAyAjIBd+ICEgGX58IBp9IBVCFIZ8IBBCzQJ+fCAPQh2IfCIXp0H/////AXE2AhggAyAOQhSGIBZ8IBdCHYh8IhenQf////8BcTYCHCADIBFCFIYgK3wgF0IdiHwiF6dB/////wFxNgIgIAMgEkIUhiAcfCAXQh2IfCIXp0H/////AXE2AiQgAyAQQhSGIBh8IBdCHYh8IhdCHYg+AiwgAyAXp0H/////AXE2AiggACADQQxqECogA0EwaiQAC9AMAgV/G34jAEHwAGsiAiQAIAJBBGogARAgIAIgAjUCFCIHQuzzt4oDfiACKAIIIgGtIghC5+LkswF+IAIoAgQiA60iCULuyvX/AX58IAIoAgwiBK0iCkKMk/D7AH58IAIoAhAiBa0iC0KD5oXTAX58IAdC7fO3igF+fCIMfSACKAIYIgYgA2qtIg1C7sr1/wF+fCACKAIcIgMgAWqtIg5C5uKktAF+fCACKAIgIgEgBGqtIg9Ci5Pw+wJ+fCACKAIkIgQgBWqtIhBCguaF0wN+fCAErSIRQv////8BfiISIAGtIhNC/////wF+IhR8IhUgA60iFkL//z9+fCIXfSAJQv8DfkL/////AYMiGELSscwEfiAIQu3zt4oBfiAJQoPmhdMBfnwiGXwgGELtp9fnAX4gCULt87eKAX4iGnxCHYh8IhtCm/zRkgF+Qv////8BgyIcQhSGfCAKQufi5LMBfiAIQu7K9f8BfnwgC0KMk/D7AH58IAdCg+aF0wF+fCAGrSIdQv////8BfiIefSIfIBp9IA1C7PO3igN+fCAcQs0CfnwgCEKD5oXTAX4gCUKMk/D7AH58IApC7fO3igF+fCIgIBhCluuc7wF+fCAcQtKxzAR+fCAcQu2n1+cBfiAbfEIdiHwiG0Kb/NGSAX5C/////wGDIhpCxfrO7wF+fCAIQoyT8PsAfiAJQufi5LMBfnwgCkKD5oXTAX58IAtC7fO3igF+fCIhIBhCxfrO7wF+fCAcQpbrnO8BfnwgGkLSscwEfnwgGkLtp9fnAX4gG3xCHYh8IghCm/zRkgF+Qv////8BgyIJQpbrnO8BfnwgDCAYQs0CfnwgHELF+s7vAX58IBpCluuc7wF+fCAJQtKxzAR+fCAJQu2n1+cBfiAIfEIdiHwiCEKb/NGSAX5C/////wGDIhxC0rHMBH58IBxC7afX5wF+IAh8Qh2IfCIMQpv80ZIBfkL/////AYMiCELNAn58IA1CguaF0wN+IBl9IA5C7PO3igN+fCALQufi5LMBfiAKQu7K9f8BfnwgB0KMk/D7AH58IBZC/////wF+IhYgHnwiGX0iG3wgGkLNAn58IAlCxfrO7wF+fCAcQpbrnO8BfnwgCELSscwEfnwgCELtp9fnAX4gDHxCHYh8IgxCm/zRkgF+Qv////8BgyIKQsX6zu8BfnwgDUKLk/D7An4gIH0gDkKC5oXTA358IA9C7PO3igN+fCAHQufi5LMBfiALQu7K9f8BfnwgFCAZfH0iFHwgCULNAn58IBxCxfrO7wF+fCAIQpbrnO8BfnwgCkLSscwEfnwgCkLtp9fnAX4gDHxCHYh8IgxCm/zRkgF+Qv////8BgyILQpbrnO8BfnwgGEIUhiAhfSAHQu7K9f8BfnwgDULm4qS0AX58IA5Ci5Pw+wJ+fCAPQoLmhdMDfnwgEELs87eKA358IBUgHUL//z9+fCAWfCINfSAcQs0CfnwgCELF+s7vAX58IApCluuc7wF+fCALQtKxzAR+fCALQu2n1+cBfiAMfEIdiHwiDEKb/NGSAX5C/////wGDIhhC0rHMBH58IBhC7afX5wF+IAx8Qh2IfCIMp0H/////AXE2AkwgAiAHQoLmhdMDfiAffSAOQu7K9f8BfnwgD0Lm4qS0AX58IBBCi5Pw+wJ+fCASIBNC//8/fnwiDn0gGkIUhnwgCkLNAn58IAtCxfrO7wF+fCAYQpbrnO8BfnwgDEIdiHwiGqdB/////wFxNgJQIAIgD0LuyvX/AX4gB0KLk/D7An58IBsgEUL//z9+Ig98fSAQQubipLQBfnwgCUIUhnwgC0LNAn58IBhCxfrO7wF+fCAaQh2IfCIJp0H/////AXE2AlQgAiAQQu7K9f8BfiAHQubipLQBfnwgFH0gHEIUhnwgGELNAn58IAlCHYh8IgenQf////8BcTYCWCACIAhCFIYgDXwgB0IdiHwiB6dB/////wFxNgJcIAIgCkIUhiAXfCAHQh2IfCIHp0H/////AXE2AmAgAiALQhSGIA58IAdCHYh8IgenQf////8BcTYCZCACIBhCFIYgD3wgB0IdiHwiB0IdiD4CbCACIAenQf////8BcTYCaCACQShqIAJBzABqECogACACQShqEB0gAkHwAGokAAvGCgIGfwR+IwBB8AJrIgIkAAJAQcAARQ0AIAJBxABqQQBBwAD8CwALIAEgAS0AfyIDaiIEQYABOgAAIAEpA8ABIQggASkDyAEhCQJAIANB/wBzIgVFDQAgBEEBakEAIAX8CwALIAhCNogiCkI4hiAJQgqGIgsgCoQiCkKA/gODQiiGhCAKQoCA/AeDQhiGIApCgICA+A+DQgiGhIQgCUIChkKAgID4D4MgCUIOiEKAgPwHg4QgCUIeiEKA/gODIAtCOIiEhIQhCiADrSIJQjuGIAhCCoYiCyAJQgOGhCIJQoD+A4NCKIaEIAlCgID8B4NCGIYgCUKAgID4D4NCCIaEhCAIQgKGQoCAgPgPgyAIQg6IQoCA/AeDhCAIQh6IQoD+A4MgC0I4iISEhCEIIAFBgAFqIQMCQCAFQQ9LDQACQEGAAUUNACACQYQBaiABQYAB/AoAAAsgAyACQYQBakEBEANB8ABFDQAgAUEAQfAA/AsACyABIAo3A3AgASAINwN4AkBBgAFFDQAgAkGEAWogAUGAAfwKAAALIAMgAkGEAWpBARADQQAhAQNAIAJBxABqIAFqIAMgAWopAwAiCEI4hiAIQoD+A4NCKIaEIAhCgID8B4NCGIYgCEKAgID4D4NCCIaEhCAIQgiIQoCAgPgPgyAIQhiIQoCA/AeDhCAIQiiIQoD+A4MgCEI4iISEhDcAACABQQhqIgFBwABHDQALAkBBwABFIgENACACQQRqIAJBxABqQcAA/AoAAAsCQCABDQAgAkHEAGogAkEEakHAAPwKAAALQQAhBAJAIAENACACQYQBakEAQcAA/AsACyACQcQAaiEGA0AgAkGEAWogBEECdGoiBygCACEFQQAhASAGIQMDQCADLQAAIAF0IAVyIQUgA0EBaiEDIAFBCGoiAUEgRw0ACyAHIAU2AgAgBkEEaiEGIARBAWoiBEEQRw0ACyACIAIoAoQBIgFB/////wFxNgKEAiACIAIoAogBIgNBA3QgAUEddnJB/////wFxNgKIAiACIAIoAowBIgFBBnQgA0EadnJB/////wFxNgKMAiACIAIoApABIgNBCXQgAUEXdnJB/////wFxNgKQAiACIAIoApQBIgFBDHQgA0EUdnJB/////wFxNgKUAiACIAIoApgBIgNBD3QgAUERdnJB/////wFxNgKYAiACIAIoApwBIgFBEnQgA0EOdnJB/////wFxNgKcAiACIAIoAqABIgNBFXQgAUELdnJB/////wFxNgKgAiACIAIoAqQBIgVBGHQgA0EIdnJB/////wFxNgKkAiACIAIoAsABIgNBDXY2AsgCIAIgAigCqAEiAUECdkH/////AXE2AqwCIAIgAUEbdCAFQQV2ckH/////AXE2AqgCIAIgAigCrAEiBUEBdCABQR92ckH/////AXE2ArACIAIgAigCsAEiAUEEdCAFQRx2ckH/////AXE2ArQCIAIgAigCtAEiBUEHdCABQRl2ckH/////AXE2ArgCIAIgAigCuAEiAUEKdCAFQRZ2ckH/////AXE2ArwCIAIgAigCvAEiBUENdCABQRN2ckH/////AXE2AsACIAIgA0EQdCAFQRB2ckH/////AXE2AsQCIAJBzAJqIAJBhAJqQcyIwAAQCAJAQSRFIgENACACQYQCaiACQcwCakEk/AoAAAsgAkHMAmogAkGoAmpBkMXAABAIAkAgAQ0AIAJBqAJqIAJBzAJqQST8CgAACyACQcwCaiACQagCaiACQYQCahAwIAAgAkHMAmoQHSACQfACaiQAC4wKAQV/IwBBsAVrIgIkACACIAE1AAA3A1AgAiABMQAFQg6GIAExAARCBoaEIAExAAZCFoaENwNYIAIgATEACEINhiABMQAHQgWGhCABMQAJQhWGhDcDYCACIAExAAtCC4YgATEACkIDhoQgATEADEIThoQ3A2ggAiABMQAOQgqGIAExAA1CAoaEIAExAA9CEoaENwNwIAIgATUAEDcDeCACIAExABVCD4YgATEAFEIHhoQgATEAFkIXhoQ3A4ABIAIgATEAGEINhiABMQAXQgWGhCABMQAZQhWGhDcDiAEgAiABMQAbQgyGIAExABpCBIaEIAExABxCFIaENwOQASACIAExAB5CCoYgATEAHUIChoQgAS0AHyIDQRJ0rUKAgPAPg4Q3A5gBIAJB9AFqIAJB0ABqECYgAkHQAGogAkH0AWoQEiACQZwCaiACQdAAahAmAkBBKEUNACACQfACaiACQZwCakEo/AoAAAsgAkHwAmpBxIfAABAhIAJBmANqIAJBnAJqQfyHwAAQDEEAIQEDQCACQZgDaiABaiIEIAQoAgAgAUHEh8AAaigCAGo2AgAgAUEEaiIBQShHDQALIAJB0ABqIAJBmANqEBIgAkHEAmogAkHQAGoQJiACQcADaiACQcQCaiACQZgDahAMIAJB0ABqIAJBwANqEBIgAkHEAmogAkHQAGoQJiACQegDaiACQcQCaiACQZgDahAMIAJBuARqIAJB8AJqIAJBwANqEAwgAkGIBWogAkHwAmogAkHoA2oQDCACQdAAaiACQYgFahAbAkBBKEUiAQ0AIAJBxAJqIAJB0ABqQSj8CgAACyACQdAAaiACQcQCakECEDIgAkHgBGogAkGIBWogAkHQAGoQDCACQZAEaiACQbgEaiACQeAEahAMIAJB0ABqIAJBkARqEBIgAkHEAmogAkHQAGoQJiACQbgEaiACQZgDaiACQcQCahAMIAJBuARqIAJB8AJqEDEhBQJAIAENACACQYgFaiACQfACakEo/AoAAAsgAkGIBWoQKyACQbgEaiACQYgFahAxIQQgAkHwAmoQKyACQdAAaiACQfACakGkiMAAEAwgAkG4BGogAkHQAGoQMSEGIAJB4ARqQaSIwAAgAkGQBGoQDCACQZAEaiACQeAEaiAGIARyEEgQJyACQdAAaiACQZAEahAQIAItAFBBAXEQSCEGAkAgAQ0AIAJB0ABqIAJBkARqQSj8CgAACyACQdAAahArIAJBkARqIAJB0ABqIAYQJyACQccCaiEGIAQgBXIQSCEEAkAgAQ0AIAYgAkGQBGpBKPwKAAALAkAgAQ0AIAJB0ABqIAZBKPwKAAALIAJB0ABqQShqIQUCQCABDQAgBSACQfQBakEo/AoAAAsCQCABDQAgAiACQdAAakEo/AoAAAsCQCABDQAgAkEoaiAFQSj8CgAACwJAAkAgBEH/AXENAEEAIQEMAQsgA0GAAXFBB3YQSCEEAkBBKEUiAQ0AIAJB0ABqIAJBKPwKAAALIAJB0ABqECsgAiACQdAAaiAEECcCQCABDQAgAkHQAGogAkEo/AoAAAsgAkHIAWogAiACQShqEAwCQCABDQAgAkHQAGpBKGogAkEoakEo/AoAAAsCQCABDQAgAkGgAWpBxIfAAEEo/AoAAAsCQEGgAUUNACAAQQRqIAJB0ABqQaAB/AoAAAtBASEBCyAAIAE2AgAgAkGwBWokAAv8BgIOfxp+IwBB0ABrIgMkACADIAEoAgwiBK0iESACKAIYIgWtIhJ+IAEoAgQiBq0iEyACKAIgIgetIhR+fCABKAIUIgitIhUgAigCECIJrSIWfnwgASgCHCIKrSIXIAIoAggiC60iGH58IAE1AgAiGSACKAIkIgytfnwgAjUCACIaIAEoAiQiDa0iG358IAE1AggiHCACKAIcIg6tIh1+fCABNQIQIh4gAigCFCIPrSIffnwgATUCGCIgIAIoAgwiEK0iIX58IAE1AiAiIiACKAIEIgKtIiN+fDcDSCADIBEgFn4gEyASfnwgFSAYfnwgGyAHQRNsrSIkfnwgGSAdfnwgGiAXfnwgHCAffnwgHiAhfnwgICAjfnwgIiAMQRNsrSIlfnw3AzggAyARIBh+IBMgFn58IBcgJH58IBsgBUETbK0iJn58IBkgH358IBogFX58IBwgIX58IB4gI358ICAgJX58ICIgDkETbK0iJ358NwMoIAMgBEEBdK0iKCAffiAGQQF0rSIpIB1+fCAIQQF0rSIdICF+fCAKQQF0rSIqICN+fCAZIBR+fCANQQF0rSIUICV+fCAcIBJ+fCAeIBZ+fCAgIBh+fCAiIBp+fDcDQCADICggIX4gKSAffnwgHSAjfnwgKiAlfnwgGSASfnwgFCAnfnwgHCAWfnwgHiAYfnwgICAafnwgIiAkfnw3AzAgAyAoICN+ICkgIX58IB0gJX58ICogJ358IBkgFn58IBQgD0ETbK0iFn58IBwgGH58IB4gGn58ICAgJH58ICIgJn58NwMgIAMgFSAkfiATIBh+fCAXICZ+fCAbIAlBE2ytIh9+fCAZICF+fCAaIBF+fCAcICN+fCAeICV+fCAgICd+fCAiIBZ+fDcDGCADICggJX4gKSAjfnwgHSAnfnwgKiAWfnwgGSAYfnwgFCAQQRNsrSIYfnwgHCAafnwgHiAkfnwgICAmfnwgIiAffnw3AxAgAyAVICZ+IBEgJH58IBcgH358IBsgC0ETbK0iIX58IBkgI358IBogE358IBwgJX58IB4gJ358ICAgFn58ICIgGH58NwMIIAMgKCAnfiApICV+fCAdIBZ+fCAqIBh+fCAUIAJBE2ytfnwgGiAZfnwgHCAkfnwgHiAmfnwgICAffnwgIiAhfnw3AwAgACADECYgA0HQAGokAAudCAEMfyAAKAIEIQIgACgCACEDAkACQCABKAIIIgRBgICAwAFxRQ0AAkACQCAEQYCAgIABcQ0AAkAgAkEQSQ0AIAIgAyADQQNqQXxxIgVrIgZqIgdBA3EhCEEAIQlBACEKAkAgAyAFRg0AQQAhCiADIQADQCAKIAAsAABBv39KaiEKIABBAWohACAGQQFqIgYNAAsLAkAgCEUNACAFIAdB/P///wdxaiEAQQAhCQNAIAkgACwAAEG/f0pqIQkgAEEBaiEAIAhBf2oiCA0ACwsgB0ECdiEGIAkgCmohCgNAIAUhByAGRQ0DIAZBwAEgBkHAAUkbIgtBA3EhDAJAAkAgC0ECdCINQfAHcSIADQBBACEJDAELIAcgAGohBUEAIQkgByEAA0AgAEEMaigCACIIQX9zQQd2IAhBBnZyQYGChAhxIABBCGooAgAiCEF/c0EHdiAIQQZ2ckGBgoQIcSAAQQRqKAIAIghBf3NBB3YgCEEGdnJBgYKECHEgACgCACIIQX9zQQd2IAhBBnZyQYGChAhxIAlqampqIQkgAEEQaiIAIAVHDQALCyAGIAtrIQYgByANaiEFIAlBCHZB/4H8B3EgCUH/gfwHcWpBgYAEbEEQdiAKaiEKIAxFDQALIAxBAnQhCCAHIAtB/AFxQQJ0aiEAQQAhCQNAIAAoAgAiBUF/c0EHdiAFQQZ2ckGBgoQIcSAJaiEJIABBBGohACAIQXxqIggNAAsgCUEIdkH/gfwHcSAJQf+B/AdxakGBgARsQRB2IApqIQoMAgtBACEKIAJFDQEgAyEAIAIhCQNAIAogACwAAEG/f0pqIQogAEEBaiEAIAlBf2oiCQ0ADAILCwJAAkACQCABLwEOIgoNAEEAIQIMAQsgAyACaiEFQQAhAiADIQkgCiEIA0AgCSIAIAVGDQICQAJAIAAsAAAiCUF/TA0AIABBAWohCQwBCwJAIAlBYE8NACAAQQJqIQkMAQsCQCAJQXBPDQAgAEEDaiEJDAELIABBBGohCQsgCSAAayACaiECIAhBf2oiCA0ACwtBACEICyAKIAhrIQoLIAogAS8BDCIASQ0BCyABKAIAIAMgAiABKAIEKAIMEQYADwsgACAKayEHQQAhAEEAIQYCQAJAAkAgBEEddkEDcQ4EAgABAgILIAchBgwBCyAHQf7/A3FBAXYhBgsgBEH///8AcSEKIAEoAgQhCSABKAIAIQgCQAJAA0AgAEH//wNxIAZB//8DcU8NAUEBIQUgAEEBaiEAIAggCiAJKAIQEQQARQ0ADAILC0EBIQUgCCADIAIgCSgCDBEGAA0AIAcgBmtB//8DcSEGQQAhAANAAkAgAEH//wNxIAZJDQBBAA8LQQEhBSAAQQFqIQAgCCAKIAkoAhARBABFDQALCyAFC/QGAQZ/AkACQAJAAkACQAJAAkACQAJAAkAgAEF8aiIEKAIAIgVBeHEiBkEEQQggBUEDcSIHGyABakkNACABQSdqIQgCQCAHRQ0AIAYgCEsNAgsCQAJAIAJBCUkNACACIAMQHiICDQFBAA8LQQAhAiADQcz/e0sNCkEQIANBC2pBeHEgA0ELSRshASAAQXhqIQgCQCAHDQAgAUGAAkkNCSAIRQ0JIAYgAU0NCSAGIAFrQYCACE0NCAwJCyAIIAZqIQcCQAJAIAYgAU8NACAHQQAoAvTAQkYNAQJAIAdBACgC8MBCRg0AIAcoAgQiBUECcQ0LIAVBeHEiCSAGaiIFIAFJDQsgByAJEB8CQCAFIAFrIgdBEEkNACAEIAEgBCgCAEEBcXJBAnI2AgAgCCABaiIBIAdBA3I2AgQgCCAFaiIFIAUoAgRBAXI2AgQgASAHEBkMCgsgBCAFIAQoAgBBAXFyQQJyNgIAIAggBWoiASABKAIEQQFyNgIEDAkLQQAoAujAQiAGaiIHIAFJDQoCQAJAIAcgAWsiBkEPSw0AIAQgBUEBcSAHckECcjYCACAIIAdqIgEgASgCBEEBcjYCBEEAIQZBACEBDAELIAQgASAFQQFxckECcjYCACAIIAFqIgEgBkEBcjYCBCAIIAdqIgcgBjYCACAHIAcoAgRBfnE2AgQLQQAgATYC8MBCQQAgBjYC6MBCDAgLIAYgAWsiBkEPTQ0HIAQgASAFQQFxckECcjYCACAIIAFqIgEgBkEDcjYCBCAHIAcoAgRBAXI2AgQgASAGEBkMBwtBACgC7MBCIAZqIgcgAUsNBQwICwJAIAMgASADIAFJGyIDRQ0AIAIgACAD/AoAAAsgBCgCACIDQXhxIgdBBEEIIANBA3EiAxsgAWpJDQIgA0UNCCAHIAhLDQMMCAtBoLzCAEHQvMIAEEwAC0HgvMIAQZC9wgAQTAALQaC8wgBB0LzCABBMAAtB4LzCAEGQvcIAEEwACyAEIAEgBUEBcXJBAnI2AgAgCCABaiIFIAcgAWsiAUEBcjYCBEEAIAE2AuzAQkEAIAU2AvTAQgsgCEUNAQsgAA8LIAMQBCIBRQ0BAkAgA0F8QXggBCgCACICQQNxGyACQXhxaiICIAMgAkkbIgNFDQAgASAAIAP8CgAACyABIQILIAAQEQsgAguxBgILfwF+IwBBEGsiAiQAQQohAyAAKAIAIgQhBQJAAkAgBEHoB0kNAEEKIQYgBCEAA0AgBkF8aiIDQQpPDQIgAkEGaiAGaiIGQXxqIAAgAEGQzgBuIgVBkM4AbGsiB0H//wNxQeQAbiIIQQF0LwDshUA7AAAgBkF+aiAHIAhB5ABsa0H//wNxQQF0LwDshUA7AAAgAEH/rOIESyEHIAMhBiAFIQAgBw0ACwsCQAJAIAVBCUsNACAFIQAMAQsgAkEGaiADQX5qIgNqIAUgBUH//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8A7IVAOwAACwJAAkAgBEUNACAARQ0BCyACQQZqIANBf2oiA2ogAEEBdC0A7YVAOgAAC0ErQYCAxAAgASgCCCIGQYCAgAFxIgAbIQQgBkGAgIAEcUEXdiEJIAJBBmogA2ohCgJAAkAgAEEVdkEKIANrIgtqIgcgAS8BDCIITw0AAkACQAJAIAZBgICACHENACAIIAdrIQxBACEAQQAhCAJAAkACQCAGQR12QQNxDgQCAAEAAgsgDCEIDAELIAxB/v8DcUEBdiEICyAGQf///wBxIQcgASgCBCEDIAEoAgAhBQNAIABB//8DcSAIQf//A3FPDQJBASEGIABBAWohACAFIAcgAygCEBEEAEUNAAwFCwsgASABKQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAEoAgAiAyABKAIEIgUgBCAJEEANA0EAIQAgCCAHa0H//wNxIQcDQCAAQf//A3EgB08NAkEBIQYgAEEBaiEAIANBMCAFKAIQEQQARQ0ADAQLC0EBIQYgBSADIAQgCRBADQIgBSAKIAsgAygCDBEGAA0CIAwgCGtB//8DcSEIQQAhAANAAkAgAEH//wNxIAhJDQBBACEGDAQLQQEhBiAAQQFqIQAgBSAHIAMoAhARBABFDQAMAwsLQQEhBiADIAogCyAFKAIMEQYADQEgASANNwIIQQAhBgwBC0EBIQYgASgCACIAIAEoAgQiAyAEIAkQQA0AIAAgCiALIAMoAgwRBgAhBgsgAkEQaiQAIAYPC0F+QQpBtIfAABA7AAveBQEKfyMAQYABayICJAAgAiABNQIkNwN4IAIgATUCIDcDcCACIAE1Ahw3A2ggAiABNQIYNwNgIAIgATUCFDcDWCACIAE1AhA3A1AgAiABNQIMNwNIIAIgATUCCDcDQCACIAE1AgQ3AzggAiABNQIANwMwIAJBCGogAkEwahAmIAAgAigCCCIBQRNqQRp2IAIoAgwiA2pBGXYgAigCECIEakEadiACKAIUIgVqQRl2IAIoAhgiBmpBGnYgAigCHCIHakEZdiACKAIgIghqQRp2IAIoAiQiCWpBGXYgAigCKCIKakEadiACKAIsIgtqQRl2QRNsIAFqIgE6AAAgACABQRB2OgACIAAgAUEIdjoAASAAIAMgAUEadmoiA0EOdjoABSAAIANBBnY6AAQgACADQQJ0IAFBGHZBA3FyOgADIAAgBCADQRl2aiIBQQ12OgAIIAAgAUEFdjoAByAAIAFBA3QgA0GAgIAOcUEWdnI6AAYgACAFIAFBGnZqIgNBC3Y6AAsgACADQQN2OgAKIAAgA0EFdCABQYCAgB9xQRV2cjoACSAAIAYgA0EZdmoiAUESdjoADyAAIAFBCnY6AA4gACABQQJ2OgANIAAgByABQRp2aiIEOgAQIAAgAUEGdCADQYCA4A9xQRN2cjoADCAAIARBEHY6ABIgACAEQQh2OgARIAAgCCAEQRl2aiIBQQ92OgAVIAAgAUEHdjoAFCAAIAFBAXQgBEEYdkEBcXI6ABMgACAJIAFBGnZqIgNBDXY6ABggACADQQV2OgAXIAAgA0EDdCABQYCAgBxxQRd2cjoAFiAAIAogA0EZdmoiAUEMdjoAGyAAIAFBBHY6ABogACABQQR0IANBgICAD3FBFXZyOgAZIAAgCyABQRp2aiIDQQp2OgAeIAAgA0ECdjoAHSAAIANBgIDwD3FBEnY6AB8gACADQQZ0IAFBgIDAH3FBFHZyOgAcIAJBgAFqJAALjgYBBX8gAEF4aiIBIABBfGooAgAiAkF4cSIAaiEDAkACQCACQQFxDQAgAkECcUUNASABKAIAIgIgAGohAAJAIAEgAmsiAUEAKALwwEJHDQAgAygCBEEDcUEDRw0BQQAgADYC6MBCIAMgAygCBEF+cTYCBCABIABBAXI2AgQgAyAANgIADwsgASACEB8LAkACQAJAAkACQAJAIAMoAgQiAkECcQ0AIANBACgC9MBCRg0CIANBACgC8MBCRg0DIAMgAkF4cSICEB8gASACIABqIgBBAXI2AgQgASAAaiAANgIAIAFBACgC8MBCRw0BQQAgADYC6MBCDwsgAyACQX5xNgIEIAEgAEEBcjYCBCABIABqIAA2AgALIABBgAJJDQIgASAAECNBACEBQQBBACgCiMFCQX9qIgA2AojBQiAADQQCQEEAKALQvkIiAEUNAEEAIQEDQCABQQFqIQEgACgCCCIADQALC0EAIAFB/x8gAUH/H0sbNgKIwUIPC0EAIAE2AvTAQkEAQQAoAuzAQiAAaiIANgLswEIgASAAQQFyNgIEAkAgAUEAKALwwEJHDQBBAEEANgLowEJBAEEANgLwwEILIABBACgCgMFCIgRNDQNBACgC9MBCIgBFDQNBACECQQAoAuzAQiIFQSlJDQJByL7CACEBA0ACQCABKAIAIgMgAEsNACAAIAMgASgCBGpJDQQLIAEoAgghAQwACwtBACABNgLwwEJBAEEAKALowEIgAGoiADYC6MBCIAEgAEEBcjYCBCABIABqIAA2AgAPCwJAAkBBACgC4MBCIgNBASAAQQN2dCICcQ0AQQAgAyACcjYC4MBCIABB+AFxQdi+wgBqIgAhAwwBCyAAQfgBcSIAQdi+wgBqIQMgAEHgvsIAaigCACEACyADIAE2AgggACABNgIMIAEgAzYCDCABIAA2AggPCwJAQQAoAtC+QiIBRQ0AQQAhAgNAIAJBAWohAiABKAIIIgENAAsLQQAgAkH/HyACQf8fSxs2AojBQiAFIARNDQBBAEF/NgKAwUILC60EAgl/FH4gACABKAIMIgKtIgsgASgCACIDQQF0rSIMfiABKAIEIgRBAXStIg0gASgCCCIFrSIOfnwgASgCICIGQRNsrSIPIAEoAhQiB0EBdK0iEH58IAEoAiQiCEETbK0iESABKAIQIgmtIhJ+IAEoAhwiCkETbK0iEyABKAIYIgGtIhR+fEIBhnw3AxggACABQRNsrSIVIBB+IAwgBK0iFn58IA8gAkEBdK0iF358IBEgDn4gEyASfnxCAYZ8NwMIIAAgFCAXfiAJQQF0rSIYIAetIhl+fCAKrSIaIAVBAXStIht+fCAGrSIcIA1+fCAIrSIdIAx+fDcDSCAAIBkgG34gFyASfnwgFCANfnwgGiAMfnwgHCARfkIBhnw3AzggACASIA1+IBsgC358IBkgDH58IA8gCkEBdK0iHn58IBQgEX5CAYZ8NwMoIAAgFyANfiAOIA5+fCASIAx+fCAPIAFBAXStfnwgESAQfiATIBp+fEIBhnw3AyAgACAOIAx+IA0gFn58IBUgFH58IA8gGH58IBEgF34gEyAQfnxCAYZ8NwMQIAAgFSAYfiADrSIOIA5+fCAPIBt+fCATIBd+IAdBE2ytIBl+fCARIA1+fEIBhnw3AwAgACAUIBt+IBIgEn58IBAgF358IB4gDX58IBwgDH58IB0gEX5CAYZ8NwNAIAAgFyALfiASIBt+fCAQIA1+fCAUIAx+fCAPIBx+fCAeIBF+QgGGfDcDMAuFBQIDfwF+IwBBgARrIgMkAAJAAkAgAkEgRg0AIABBADoAAUEBIQIMAQsgA0EYaiABQRhqKQAANwMAIANBEGogAUEQaikAADcDACADIAFBCGopAAA3AwggAyABKQAANwMAIANBgAFqIQQCQEHAAEUiBQ0AIARBgLbCAEHAAPwKAAALIANCADcDyAEgA0IANwPAAUEAIQICQCAFDQAgA0GgAmpBAEHAAPwLAAsgA0GAAToAIAJAQd8ARQ0AIANBIWpBAEHfAPwLAAsgA0KAgICAgIDAADcDeCADQgA3A3ACQEGAAUUNACADQeACaiADQYAB/AoAAAsgBCADQeACakEBEAMDQCADQaACaiACaiADIAJqQYABaikDACIGQjiGIAZCgP4Dg0IohoQgBkKAgPwHg0IYhiAGQoCAgPgPg0IIhoSEIAZCCIhCgICA+A+DIAZCGIhCgID8B4OEIAZCKIhCgP4DgyAGQjiIhISENwAAIAJBCGoiAkHAAEcNAAsCQEHAAEUNACADQeABaiADQaACakHAAPwKAAALIANBoAJqIANB4AFqEC0gA0HgAmogA0GgAmoQFCADIANB4AJqECUCQEGgAUUNACADQSBqIANB4AJqQaAB/AoAAAtBACECA0AgA0GgAmogAmpBADoAACACQQFqIgJBIEcNAAtBICECA0AgA0GgAmogAmpBADoAACACQQFqIgJBwABHDQALIANByAFqIAFBCGopAAA3AgAgA0HQAWogAUEQaikAADcCACADQdgBaiABQRhqKQAANwIAIAMgASkAADcCwAECQEHgAUUNACAAQQRqIANB4AH8CgAAC0EAIQILIAAgAjoAACADQYAEaiQAC+gEAQR/IwBBgARrIgIkAEEAIQMCQEHAAEUNACACQQhqQQBBwAD8CwALA0AgAkEIaiADaiIEQQFqIAEtAAAiBUEEdjoAACAEIAVBD3E6AAAgAUEBaiEBIANBAmoiA0HAAEcNAAtBACEBA0AgAkEIaiABaiIDIAMtAAAiBCAEQQhqIgRB8AFxazoAACADQQFqIgMgAy0AACAEwEEEdmo6AAAgAUEBaiIBQT9HDQALQQAhAQJAQShFIgMNACACQcgAakEAQSj8CwALAkAgAw0AIAJByABqQShqQcSHwABBKPwKAAALAkAgAw0AIAJBmAFqQcSHwABBKPwKAAALAkAgAw0AIAJBwAFqQQBBKPwLAAsDQAJAAkACQCABQcAARg0AIAFBAXENAQwCCyACQegBaiACQcgAakEEEC4CQEGgAUUNACACQcgAaiACQegBakGgAfwKAAALQQAhAQNAAkACQAJAIAFBwABGDQAgAUEBcQ0CIAFBAXYhAyABQcAATw0BIAJBiANqIANBwAdsQdjFwABqIAJBCGogAWotAAAQIiACQegBaiACQcgAaiACQYgDahAWIAJByABqIAJB6AFqED4MAgsCQEGgAUUNACAAIAJByABqQaAB/AoAAAsgAkGABGokAA8LIANBIEHsh8AAEDsACyABQQFqIQEMAAsLIAFBAXYhAwJAIAFBwABPDQAgAkGIA2ogA0HAB2xB2MXAAGogAkEIaiABai0AABAiIAJB6AFqIAJByABqIAJBiANqEBYgAkHIAGogAkHoAWoQPgwBCyADQSBB7IfAABA7AAsgAUEBaiEBDAALC6wEAQR/IwBB8AJrIgMkACABQShqIQQCQEEoRQ0AIANBqAFqIARBKPwKAAALQQAhBQNAIANBqAFqIAVqIgYgBigCACABIAVqKAIAajYCACAFQQRqIgVBKEcNAAsCQEEoRSIFDQAgA0HQAWogBEEo/AoAAAsgA0HQAWogARAhIANBCGogA0GoAWogAhAMIANBMGogA0HQAWogAkEoahAMIANB2ABqIAFB+ABqIAJB+ABqEAwgA0GAAWogAUHQAGogAkHQAGoQDAJAIAUNACADQfgBaiADQYABakEo/AoAAAtBACEFA0AgA0H4AWogBWoiBiAGKAIAIANBgAFqIAVqKAIAajYCACAFQQRqIgVBKEcNAAsCQEEoRQ0AIANBoAJqIANBCGpBKPwKAAALIANBoAJqIANBMGoQIUEAIQUDQCADQQhqIAVqIgYgBigCACADQTBqIAVqKAIAajYCACAFQQRqIgVBKEcNAAsCQEEoRQ0AIANByAJqIANB+AFqQSj8CgAAC0EAIQUDQCADQcgCaiAFaiIGIAYoAgAgA0HYAGogBWooAgBqNgIAIAVBBGoiBUEoRw0ACyADQfgBaiADQdgAahAhAkBBKEUiBQ0AIAAgA0GgAmpBKPwKAAALAkAgBQ0AIABBKGogA0EIakEo/AoAAAsCQCAFDQAgAEHQAGogA0HIAmpBKPwKAAALAkAgBQ0AIABB+ABqIANB+AFqQSj8CgAACyADQfACaiQAC4wEAQR/IwBBwAJrIgMkACABQShqIQQCQEEoRQ0AIANB+ABqIARBKPwKAAALQQAhBQNAIANB+ABqIAVqIgYgBigCACABIAVqKAIAajYCACAFQQRqIgVBKEcNAAsCQEEoRSIFDQAgA0GgAWogBEEo/AoAAAsgA0GgAWogARAhIAMgA0H4AGogAhAMIANBKGogA0GgAWogAkEoahAMIANB0ABqIAFB+ABqIAJB0ABqEAwgAUHQAGohAQJAIAUNACADQcgBaiABQSj8CgAAC0EAIQUDQCADQcgBaiAFaiIGIAYoAgAgASAFaigCAGo2AgAgBUEEaiIFQShHDQALAkBBKEUNACADQfABaiADQSj8CgAACyADQfABaiADQShqECFBACEFA0AgAyAFaiIGIAYoAgAgA0EoaiAFaigCAGo2AgAgBUEEaiIFQShHDQALAkBBKEUNACADQZgCaiADQcgBakEo/AoAAAtBACEFA0AgA0GYAmogBWoiBiAGKAIAIANB0ABqIAVqKAIAajYCACAFQQRqIgVBKEcNAAsgA0HIAWogA0HQAGoQIQJAQShFIgUNACAAIANB8AFqQSj8CgAACwJAIAUNACAAQShqIANBKPwKAAALAkAgBQ0AIABB0ABqIANBmAJqQSj8CgAACwJAIAUNACAAQfgAaiADQcgBakEo/AoAAAsgA0HAAmokAAv/AwIGfwF+IwBB0ABrIgEkACABQcgAakIANwMAIAFBwABqQgA3AwAgAUE4akIANwMAIAFCADcDMEEgIQIgAUEwaiEDAkACQAJAAkADQCACRQ0BIAMgAkGAgAQgAkGAgARJGyIEEABBACkDoMFCIQdBAEIANwOgwUIgAiAEayECIAMgBGohAyAHp0EBRw0ACwJAIAdCgICAgMCAAVQNACAHQiCIpxABC0EAIQIgAUEANgI4IAFCgICAgBA3AjBBAyABQTBqEDcNAiABKAIwIQQgASgCNCIFIAEoAjgQAiEDIAQgBRA2QQEhBEEAIQUMAQsgAUEYaiIDIAFBMGpBCWopAAA3AwAgAUEgaiIEIAFBMGpBEWopAAA3AwAgAUEnaiIFIAFBMGpBGGopAAA3AAAgASABKQAxNwMQIAEtADAhBkEgEAQiAkUNAiACIAY6AAAgAiABKQMQNwABIAJBCWogAykDADcAACACQRFqIAQpAwA3AAAgAkEYaiAFKQAANwAAIAFBIDYCOCABIAI2AjQgAUEgNgIwIAFBCGogAUEwahA4IAEoAgwhBSABKAIIIQJBACEDQQAhBAsgACAENgIMIAAgAzYCCCAAIAU2AgQgACACNgIAIAFB0ABqJAAPC0HQgMAAQTcgAUEQakHAgMAAQZCFwAAQOQALQQFBIBBPAAuXBAEFfyMAQYAEayIDJAAgAyACNgKkAiADIAE2AqACIAMgAjYCnAIgA0EQaiADQZwCahA4IANBnAJqIAMoAhAiBCADKAIUIgEQEwJAAkACQAJAIAMtAJwCIgUNACADQYACaiADQakCaikAADcDACADQYgCaiADQbECaikAADcDACADQY8CaiADQbgCaikAADcAACADIAMpAKECNwP4ASADLQCgAiEGQcABIQIDQCADQRhqIAJqQQA6AAAgAkEBaiICQeABRw0AC0EgIQdBIBAEIgINAUEBQSAQTwALIAMtAJ0CIQIgA0EANgKkAiADQoCAgIAQNwKcAiACIANBnAJqEDcNAiADKAKcAiEHIAMoAqACIgYgAygCpAIQAiECIAcgBhA2QYCAgIB4IQcMAQsgAiAGOgAAIAIgAykD+AE3AAEgAkEJaiADQYACaikDADcAACACQRFqIANBiAJqKQMANwAAIAJBGGogA0GPAmopAAA3AAALAkAgAUUNACAEIAFBARA6CwJAAkAgBUUNAEEBIQFBACEFQQAhBAwBCyADQSA2AqQCIAMgAjYCoAIgAyAHNgKcAiADQQhqIANBnAJqEDhBACECIAMoAgghBSADKAIMIQRBACEBCyAAIAE2AgwgACACNgIIIAAgBDYCBCAAIAU2AgAgA0GABGokAA8LQdCAwABBNyADQRhqQcCAwABBkIXAABA5AAuFBAECfyAAIAFqIQICQAJAIAAoAgQiA0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQECQCAAIANrIgBBACgC8MBCRw0AIAIoAgRBA3FBA0cNAUEAIAE2AujAQiACIAIoAgRBfnE2AgQgACABQQFyNgIEIAIgATYCAAwCCyAAIAMQHwsCQAJAAkACQCACKAIEIgNBAnENACACQQAoAvTAQkYNAiACQQAoAvDAQkYNAyACIANBeHEiAxAfIAAgAyABaiIBQQFyNgIEIAAgAWogATYCACAAQQAoAvDAQkcNAUEAIAE2AujAQg8LIAIgA0F+cTYCBCAAIAFBAXI2AgQgACABaiABNgIACwJAIAFBgAJJDQAgACABECMPCwJAAkBBACgC4MBCIgJBASABQQN2dCIDcQ0AQQAgAiADcjYC4MBCIAFB+AFxQdi+wgBqIgEhAgwBCyABQfgBcSIBQdi+wgBqIQIgAUHgvsIAaigCACEBCyACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0EAIAA2AvTAQkEAQQAoAuzAQiABaiIBNgLswEIgACABQQFyNgIEIABBACgC8MBCRw0BQQBBADYC6MBCQQBBADYC8MBCDwtBACAANgLwwEJBAEEAKALowEIgAWoiATYC6MBCIAAgAUEBcjYCBCAAIAFqIAE2AgAPCwv6AwIEfwJ+IwBBMGsiCiQAQYCAgIB4IQsCQAJAIAUNAEGAgICAeCEFDAELIAogBjYCLCAKIAU2AiggCiAGNgIkIApBGGogCkEkahA4IAooAhwhBSAKKAIYIQwLAkACQCAHDQAMAQsgCiAINgIsIAogBzYCKCAKIAg2AiQgCkEQaiAKQSRqEDggCigCFCELIAooAhAhDQsCQAJAAkAgAg0AIAtBgICAgHhGIQZBACEHDAELIAtBgICAgHhGIQYCQEIAIAH8ByIOIAP8B30iDyAPIA5WGyIOIAT8B1QNAEEBIQcMAQsCQAJAAkACQCALQYCAgIB4Rg0AQQIhB0EAIAwgBUGAgICAeEYbIghFDQQgCyAFRw0EIAkgDSAIIAUQPSIHcg0BDAMLIAlFDQIMAQsgB0UNAEECQQQgBxshBwwCC0GAgMAAIQJBBiEHDAILAkAgDkI7Vg0AQbmAwAAhAkEGIQcMAgtBAyEHCyAHQQJ0IggoAqiFQCEHIAgoAriFQCECCwJAIAcQBCIIRQ0AAkAgB0UNACAIIAIgB/wKAAALAkAgBg0AIAsgDRA2CwJAIAVBgICAgHhGDQAgBSAMEDYLIAogBzYCLCAKIAg2AiggCiAHNgIkIApBCGogCkEkahA4IAAgCikDCDcCACAKQTBqJAAPC0EBIAcQRgALvgMBAX8jAEGgBmsiAiQAIAJB0AVqIAEQEiACIAJB0AVqECYgAkHQBWogAhASIAJBqAVqIAJB0AVqECYgAkHQBWogAkGoBWoQEiACQShqIAJB0AVqECYgAkHQAGogASACQShqEAwgAkH4AGogAiACQdAAahAMIAJB0AVqIAJB+ABqEBIgAkGgAWogAkHQBWoQJiACQcgBaiACQdAAaiACQaABahAMIAJB8AFqIAJByAFqQQUQMiACQZgCaiACQfABaiACQcgBahAMIAJBwAJqIAJBmAJqQQoQMiACQegCaiACQcACaiACQZgCahAMIAJBkANqIAJB6AJqQRQQMiACQbgDaiACQZADaiACQegCahAMIAJB4ANqIAJBuANqQQoQMiACQYgEaiACQeADaiACQZgCahAMIAJBsARqIAJBiARqQTIQMiACQdgEaiACQbAEaiACQYgEahAMIAJBgAVqIAJB2ARqQeQAEDIgAkGoBWogAkGABWogAkHYBGoQDCACQdAFaiACQagFakEyEDIgACACQdAFaiACQYgEahAMAkBBKEUNACAAQShqIAJB+ABqQSj8CgAACyACQaAGaiQAC7oDAQR/IwBBwAJrIgIkACACQfABaiABEBIgAiACQfABahAmIAJB8AFqIAFBKGoiAxASIAJBKGogAkHwAWoQJiACQfABaiABQdAAahASQQAhBANAIAJB8AFqIARqIgUgBSkDAEIBhjcDACAEQQhqIgRB0ABHDQALIAJB0ABqIAJB8AFqECYCQEEoRQ0AIAJBoAFqIAFBKPwKAAALQQAhBANAIAJBoAFqIARqIgUgBSgCACADIARqKAIAajYCACAEQQRqIgRBKEcNAAsgAkHwAWogAkGgAWoQEiACQfgAaiACQfABahAmAkBBKEUNACACQcgBaiACQShqQSj8CgAAC0EAIQQDQCACQcgBaiAEaiIFIAUoAgAgAiAEaigCAGo2AgAgBEEEaiIEQShHDQALIAJBKGogAhAhIAJB+ABqIAJByAFqECEgAkHQAGogAkEoahAhAkBBKEUiBA0AIAAgAkH4AGpBKPwKAAALAkAgBA0AIABBKGogAkHIAWpBKPwKAAALAkAgBA0AIABB0ABqIAJBKGpBKPwKAAALAkAgBA0AIABB+ABqIAJB0ABqQSj8CgAACyACQcACaiQAC5UDAQd/IAAgASgCICICOgAdIAAgASgCACIDOgAAIAAgAkEQdjoAHyAAIAJBCHY6AB4gACABKAIcIgRBFXY6ABwgACAEQQ12OgAbIAAgBEEFdjoAGiAAIAEoAhgiAkESdjoAGCAAIAJBCnY6ABcgACACQQJ2OgAWIAAgASgCFCIFQQ92OgAUIAAgBUEHdjoAEyAAIAEoAhAiBkEUdjoAESAAIAZBDHY6ABAgACAGQQR2OgAPIAAgASgCDCIHQRF2OgANIAAgB0EJdjoADCAAIAdBAXY6AAsgACABKAIIIghBDnY6AAkgACAIQQZ2OgAIIAAgASgCBCIBQRN2OgAGIAAgAUELdjoABSAAIAFBA3Y6AAQgACADQRB2OgACIAAgA0EIdjoAASAAIARBA3QgAkEadnI6ABkgACACQQZ0IAVBF3ZyOgAVIAAgBUEBdCAGQRx2cjoAEiAAIAZBBHQgB0EZdnI6AA4gACAHQQd0IAhBFnZyOgAKIAAgCEECdCABQRt2cjoAByAAIAFBBXQgA0EYdnI6AAML7wIBBX9BACECAkAgAUHN/3sgAEEQIABBEEsbIgBrTw0AIABBECABQQtqQXhxIAFBC0kbIgNqQQxqEAQiAUUNACABQXhqIQICQAJAIABBf2oiBCABcQ0AIAIhAAwBCyABQXxqIgUoAgAiBkF4cSAEIAFqQQAgAGtxQXhqIgFBACAAIAEgAmtBEEsbaiIAIAJrIgFrIQQCQCAGQQNxRQ0AIAAgBCAAKAIEQQFxckECcjYCBCAAIARqIgQgBCgCBEEBcjYCBCAFIAEgBSgCAEEBcXJBAnI2AgAgAiABaiIEIAQoAgRBAXI2AgQgAiABEBkMAQsgAigCACECIAAgBDYCBCAAIAIgAWo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiADQRBqTQ0AIAAgAyABQQFxckECcjYCBCAAIANqIgEgAiADayIDQQNyNgIEIAAgAmoiAiACKAIEQQFyNgIEIAEgAxAZCyAAQQhqIQILIAILiQMBBH8gACgCDCECAkACQAJAAkAgAUGAAkkNACAAKAIYIQMCQAJAAkAgAiAARw0AIABBFEEQIAAoAhQiAhtqKAIAIgENAUEAIQIMAgsgACgCCCIBIAI2AgwgAiABNgIIDAELIABBFGogAEEQaiACGyEEA0AgBCEFIAEiAkEUaiACQRBqIAIoAhQiARshBCACQRRBECABG2ooAgAiAQ0ACyAFQQA2AgALIANFDQICQAJAIAAgACgCHEECdEHIvcIAaiIBKAIARg0AIAMoAhAgAEYNASADIAI2AhQgAg0DDAQLIAEgAjYCACACRQ0EDAILIAMgAjYCECACDQEMAgsCQCACIAAoAggiBEYNACAEIAI2AgwgAiAENgIIDwtBAEEAKALgwEJBfiABQQN2d3E2AuDAQg8LIAIgAzYCGAJAIAAoAhAiAUUNACACIAE2AhAgASACNgIYCyAAKAIUIgFFDQAgAiABNgIUIAEgAjYCGA8LDwtBAEEAKALkwEJBfiAAKAIcd3E2AuTAQgvqAgEGfyMAQSBrIgJBGGpCADcDACACQRBqQgA3AwAgAkEIakIANwMAIAJCADcDAEEAIQMDQCACIANBAnRqIgQoAgAhBSABIQZBACEHA0AgBi0AACAHdCAFciEFIAZBAWohBiAHQQhqIgdBIEcNAAsgBCAFNgIAIAFBBGohASADQQFqIgNBCEcNAAsgACACKAIcIgZBCHY2AiAgACACKAIAIgdB/////wFxNgIAIAAgBkEVdCACKAIYIgZBC3ZyQf////8BcTYCHCAAIAZBEnQgAigCFCIGQQ52ckH/////AXE2AhggACAGQQ90IAIoAhAiBkERdnJB/////wFxNgIUIAAgBkEMdCACKAIMIgZBFHZyQf////8BcTYCECAAIAZBCXQgAigCCCIGQRd2ckH/////AXE2AgwgACAGQQZ0IAIoAgQiBkEadnJB/////wFxNgIIIAAgBkEDdCAHQR12ckH/////AXE2AgQL7wIBE38jAEGAAWsiAiQAIAEoAgAhAyAAKAIAIQQgASgCBCEFIAAoAgQhBiABKAIIIQcgACgCCCEIIAEoAgwhCSAAKAIMIQogASgCECELIAAoAhAhDCABKAIUIQ0gACgCFCEOIAEoAhghDyAAKAIYIRAgASgCHCERIAAoAhwhEiABKAIgIRMgACgCICEUIAIgACgCJCABKAIka0Hw////AWqtNwN4IAIgFCATa0Hw////A2qtNwNwIAIgEiARa0Hw////AWqtNwNoIAIgECAPa0Hw////A2qtNwNgIAIgDiANa0Hw////AWqtNwNYIAIgDCALa0Hw////A2qtNwNQIAIgCiAJa0Hw////AWqtNwNIIAIgCCAHa0Hw////A2qtNwNAIAIgBiAFa0Hw////AWqtNwM4IAIgBCADa0HQ/f//A2qtNwMwIAJBCGogAkEwahAmAkBBKEUNACAAIAJBCGpBKPwKAAALIAJBgAFqJAALxwIBBn8jAEGgAmsiAyQAAkBBKEUiBA0AIANBCGpBxIfAAEEo/AoAAAsgA0EIakEoaiEFAkAgBA0AIAVBxIfAAEEo/AoAAAsgA0HYAGohBgJAIAQNACAGQQBBKPwLAAsgAsAiBEEHdSIHIARqIAdzIQhBASEEA0AgA0EIaiABIAQgCHMiAkEAIAJrcsFBf0oQSBBEIAFB+ABqIQEgBEEBaiIEQQlHDQALIAdBAXEQSCEEAkBBKEUiAQ0AIANBgAFqIAVBKPwKAAALAkAgAQ0AIANB+AFqIAZBKPwKAAALIANB+AFqECsCQCABDQAgA0GAAWpBKGogA0EIakEo/AoAAAsCQCABDQAgA0HQAWogA0H4AWpBKPwKAAALIANBCGogA0GAAWogBBBEAkBB+ABFDQAgACADQQhqQfgA/AoAAAsgA0GgAmokAAu8AgEEf0EfIQICQCABQf///wdLDQAgAUEmIAFBCHZnIgJrdkEBcSACQQF0a0E+aiECCyAAQgA3AhAgACACNgIcIAJBAnRByL3CAGohAwJAQQAoAuTAQkEBIAJ0IgRxDQAgAyAANgIAIAAgAzYCGCAAIAA2AgwgACAANgIIQQBBACgC5MBCIARyNgLkwEIPCwJAAkACQCADKAIAIgQoAgRBeHEgAUcNACAEIQIMAQsgAUEAQRkgAkEBdmsgAkEfRht0IQMDQCAEIANBHXZBBHFqIgUoAhAiAkUNAiADQQF0IQMgAiEEIAIoAgRBeHEgAUcNAAsLIAIoAggiAyAANgIMIAIgADYCCCAAQQA2AhggACACNgIMIAAgAzYCCA8LIAVBEGogADYCACAAIAQ2AhggACAANgIMIAAgADYCCAuUAgIFfwR+IwBBMGshA0EAIQQCQEGAAkUNACAAQQBBgAL8CwALAkBBKEUNACADQQhqQQBBKPwLAAsDQCADQQhqIARqIAEgBGopAAA3AwAgBEEIaiIEQSBHDQALQcAAIAJrIQVCASACrYYiCEIBiCEJIAhCf3whCiAIpyEGQgAhC0EAIQQDQCADQQhqIARBA3ZB+P///wFxaiIHKQMAIARBP3EiAa2IIQgCQCABIAVJDQAgBykDCEHAACABa62GIAiEIQgLAkACQCAIIAqDIAt8IginIgFBAXENACAEQQFqIgRBgAJHDQIMAQsgACAEaiABIAZBACAIIAlaIgcbazoAACAHrSELIAQgAmoiBEGAAkkNAQsLC5QCAQN/IwBB0AFrIgIkACACQYABaiABQdAAahAbAkBBKEUiAw0AIAJBMGogAkGAAWpBKPwKAAALIAJBgAFqQShqIQQCQCADDQAgAkHYAGogBEEo/AoAAAsgAkGAAWogAkEwakEFEDIgAkEIaiACQYABaiACQdgAahAMIAJBgAFqIAEgAkEIahAMIAQgAUEoaiACQQhqEAwgAkEwaiAEEBAgAkHYAGogAkGAAWoQECACLQBYQQFxEEghASAAIAIpADA3AAAgAEEIaiACQTBqQQhqKQAANwAAIABBEGogAkEwakEQaikAADcAACACIAItAE8gAUEHdHM6AE8gAEEYaiACQTBqQRhqKQAANwAAIAJB0AFqJAALmwIBBn4gACABKQMwIAEpAyggASkDICICQhqIfCIDQhmIfCIEp0H///8fcTYCGCAAIAEpAxAgASkDCCABKQMAIgVCGoh8IgZCGYh8IgenQf///x9xNgIIIAAgASkDOCAEQhqIfCIEp0H///8PcTYCHCAAIAEpAxggB0IaiHwiB6dB////D3E2AgwgACABKQNAIARCGYh8IgSnQf///x9xNgIgIAAgA0L///8PgyACQv///x+DIAdCGYh8IgJCGoh8PgIUIAAgAqdB////H3E2AhAgACABKQNIIARCGoh8IgKnQf///w9xNgIkIAAgAkIZiEITfiAFQv///x+DfCICQhqIIAZC////D4N8PgIEIAAgAqdB////H3E2AgAL/QEBAX8gACABKAIAIAAoAgAiA3NBACACQf8BcWsiAnEgA3M2AgAgACABKAIEIAAoAgQiA3MgAnEgA3M2AgQgACABKAIIIAAoAggiA3MgAnEgA3M2AgggACABKAIMIAAoAgwiA3MgAnEgA3M2AgwgACABKAIQIAAoAhAiA3MgAnEgA3M2AhAgACABKAIUIAAoAhQiA3MgAnEgA3M2AhQgACABKAIYIAAoAhgiA3MgAnEgA3M2AhggACABKAIcIAAoAhwiA3MgAnEgA3M2AhwgACABKAIgIAAoAiAiA3MgAnEgA3M2AiAgACABKAIkIAAoAiQiAXMgAnEgAXM2AiQLgQICA38BfiMAQRBrIgYkAEEBIQdBBCEIAkACQCAEIAVqQX9qQQAgBGtxrSADrX4iCUIgiKcNACAJpyIDQYCAgIB4IARrSw0AAkACQCABDQBBACEIIAZBDGohBQwBCyAGIAQ2AgwgASAFbCEIIAZBCGohBQsgBSAINgIAAkACQAJAAkACQCAGKAIMRQ0AAkAgBigCCCIIDQAgAw0CIAQhCAwDCyACIAggBCADEA4hCAwCCyADDQAgBCEIDAILIAMQBCEICyAIDQAgACAENgIEDAELIAAgCDYCBEEAIQcLQQghCAwBC0EAIQMLIAAgCGogAzYCACAAIAc2AgAgBkEQaiQAC/MBAQR/IwBB4ANrIgEkACABIABBAxAuAkBBKEUiAA0AIAFBoAFqQQBBKPwLAAsgAUGgAWpBKGohAgJAIAANACACQcSHwABBKPwKAAALIAFBoAFqQdAAaiEDAkAgAA0AIANBxIfAAEEo/AoAAAsCQCAADQAgAUGYAmpBAEEo/AsACyABQcACaiABIAMQDCABQegCaiABQaABaiABQdAAaiIAEAwgAUHAAmogAUHoAmoQMSEEIAFBkANqIAFBKGogAxAMIAFBuANqIAIgABAMIAQgAUGQA2ogAUG4A2oQMXEQSCEAIAFB4ANqJAAgAEH/AXFBAEcL2QEBBH8jAEEwayICJABBACEDAkBBJEUNACACQQxqQQBBJPwLAAtBACEEA0AgAkEMaiADaiABIANqKAIAIARBH3VqIANBtMXAAGooAgBrIgRB/////wFxNgIAIANBBGoiA0EkRw0AC0EAIQNBACAEQR92EEhB/wFxayEFQQAhBANAIAJBDGogA2oiASABKAIAIARBHXZqIANBtMXAAGooAgAgBXFqIgRB/////wFxNgIAIANBBGoiA0EkRw0ACwJAQSRFDQAgACACQQxqQST8CgAACyACQTBqJAAL7QEBAX8jAEGAAWsiASQAIAFB8P///wEgACgCJGutNwNQIAFB8P///wMgACgCIGutNwNIIAFB8P///wEgACgCHGutNwNAIAFB8P///wMgACgCGGutNwM4IAFB8P///wEgACgCFGutNwMwIAFB8P///wMgACgCEGutNwMoIAFB8P///wEgACgCDGutNwMgIAFB8P///wMgACgCCGutNwMYIAFB8P///wEgACgCBGutNwMQIAFB0P3//wMgACgCAGutNwMIIAFB2ABqIAFBCGoQJgJAQShFDQAgACABQdgAakEo/AoAAAsgAUGAAWokAAvOAQEEfyMAQdAAayICJAAgAUEoaiEDAkBBKEUNACACIANBKPwKAAALQQAhBANAIAIgBGoiBSAFKAIAIAEgBGooAgBqNgIAIARBBGoiBEEoRw0ACwJAQShFIgQNACACQShqIANBKPwKAAALIAJBKGogARAhAkAgBA0AIABB0ABqIAFB0ABqQSj8CgAACyAAQfgAaiABQfgAakHYtcIAEAwCQCAEDQAgACACQSj8CgAACwJAIAQNACAAQShqIAJBKGpBKPwKAAALIAJB0ABqJAALsQEBAn8jAEEgayICJAAgAS0AACEDIAJBF2ogAUEXaikAADcAACACQRFqIAFBEWopAAA3AAAgAkEJaiABQQlqKQAANwAAIAIgA0H4AXE6AAAgAiABKQABNwABIAIgAS0AH0E/cUHAAHI6AB8gACACEAkgAEE4aiABQThqKQAANwAAIABBMGogAUEwaikAADcAACAAQShqIAFBKGopAAA3AAAgACABKQAgNwAgIAJBIGokAAurAQECfyMAQcADayIDJAACQEEoRSIEDQAgA0GoAWpBKGogAUEoakEo/AoAAAsCQCAEDQAgA0GoAWpB0ABqIAFB0ABqQSj8CgAACwJAIAQNACADQagBaiABQSj8CgAACyACQX9qIQQDQCADQQhqIANBqAFqEBwgA0GoAWogA0EIahBBIARBf2oiBA0ACyADQaACaiADQagBahAcIAAgA0GgAmoQPiADQcADaiQAC5UBAQF/IwBBEGsiAyQAAkACQAJAIAIgAWoiASACTw0AQQAhAwwBCyADQQRqIAAoAgAiAiAAKAIEIAEgAkEBdCICIAEgAksbIgJBCCACQQhLGyICQQFBARAoIAMoAgRBAUcNASADKAIMIQAgAygCCCEDCyADIAAQRgALIAMoAgghASAAIAI2AgAgACABNgIEIANBEGokAAtzAQN/IwBBMGsiAyQAQQAhBAJAQSRFDQAgA0EMakEAQST8CwALQQAhBQNAIANBDGogBGogASAEaigCACAFQR12aiACIARqKAIAaiIFQf////8BcTYCACAEQQRqIgRBJEcNAAsgACADQQxqECogA0EwaiQAC2sBAn8jAEHAAGsiAiQAIAIgABAQIAJBIGogARAQQQEhAUEAIQADQCACQSBqIABqLQAAIAIgAGotAABzIgNBACADa3LAQX9KEEggAXEhASAAQQFqIgBBIEcNAAsgARBIIQAgAkHAAGokACAAC2sBAX8jAEGAAWsiAyQAIANBMGogARASIAJBf2ohASADQQhqIANBMGoQJgNAIANBMGogA0EIahASIANBCGogA0EwahAmIAFBf2oiAQ0ACwJAQShFDQAgACADQQhqQSj8CgAACyADQYABaiQAC3gBA38jAEEQayIBJAACQCAAKAIAIgIoAgQiA0EBcUUNACACKAIAIQIgASADQQF2NgIEIAEgAjYCACABQQQgACgCCCIALQAIIAAtAAkQNAALIAFBgICAgHg2AgAgASAANgIMIAFBBSAAKAIIIgAtAAggAC0ACRA0AAt3AQJ/IwBBEGsiBCQAQQBBACgCmMFCIgVBAWo2ApjBQgJAIAVBAEgNAAJAAkBBAC0AlMFCDQBBAEEAKAKQwUJBAWo2ApDBQkEAKAKcwUJBf0oNAQwCCyAEQQhqIAAgAREDAAALQQBBADoAlMFCIAJFDQAQVgALAAuLAQICfgF8IAH8ByICQjwgAkI8VhsiAkKA9SQgAkKA9SRUG7oiBCAERAAAAAAAGPVAIAQgAb0iAkIAUxtEAAAAAAAY9UAgAkL///////////8AgyIDQoCAgICAgIB4fEKAgICAgICA8P8AVBsgAkJ/fEL/////////B1QbIANQG0QAAAAAABj1QCAAGwtfAQJ/IwBBEGsiAiQAAkACQCAADQBBACEAIAJBDGohAwwBCyACQQE2AgwgAkEIaiEDCyADIAA2AgACQCACKAIMIgBFDQAgAigCCCIDRQ0AIAEgAyAAEDoLIAJBEGokAAtlAQJ/IABB/wFxQQJ0IgAoArC9QiECAkAgACgCoL1CIgAgASgCACABKAIIIgNrTQ0AIAEgAyAAEC8gASgCCCEDCwJAIABFDQAgASgCBCADaiACIAD8CgAACyABIAMgAGo2AghBAAtkAQR/AkAgASgCACICIAEoAggiA00NACABKAIEIQQCQAJAIAMNAEEBIQUgBCACQQEQOgwBCyAEIAJBASADEA4iBQ0AQQEgAxBGAAsgASAFNgIECyAAIAM2AgQgACABKAIENgIAC1kBAX8jAEEgayIFJAAgBSABNgIEIAUgADYCACAFIAM2AgwgBSACNgIIIAVBAa1CIIYgBUEIaq2ENwMYIAVBAq1CIIYgBa2ENwMQQb6BwAAgBUEQaiAEED8AC1wBAn8CQAJAIABBfGooAgAiA0F4cSIEQQRBCCADQQNxIgMbIAFqSQ0AAkAgA0UNACAEIAFBJ2pLDQILIAAQEQ8LQaC8wgBB0LzCABBMAAtB4LzCAEGQvcIAEEwAC04CAX8BfiMAQSBrIgMkACADIAE2AgwgAyAANgIIIANBA61CIIYiBCADQQhqrYQ3AxggAyAEIANBDGqthDcDEEGHgcAAIANBEGogAhA/AAtJAAJAIAFpQQFHDQAgAEGAgICAeCABa0sNAAJAIABFDQACQAJAIAFBCUkNACABIAAQHiEBDAELIAAQBCEBCyABRQ0BCyABDwsAC0oBA39BACEDAkAgAkUNAAJAA0AgAC0AACIEIAEtAAAiBUcNASAAQQFqIQAgAUEBaiEBIAJBf2oiAkUNAgwACwsgBCAFayEDCyADC0ABA38gACABIAFB+ABqIgIQDCAAQShqIAFBKGoiAyABQdAAaiIEEAwgAEHQAGogBCACEAwgAEH4AGogASADEAwLOwEBfyMAQSBrIgMkACADIAE2AhAgAyAANgIMIANBATsBHCADIAI2AhggAyADQQxqNgIUIANBFGoQRQALOQACQCACQYCAxABGDQAgACACIAEoAhARBABFDQBBAQ8LAkAgAw0AQQAPCyAAIANBACABKAIMEQYACzIBAX8gACABIAFB+ABqIgIQDCAAQShqIAFBKGogAUHQAGoiARAMIABB0ABqIAEgAhAMCzUBAX8CQCAARQ0AAkAgASgCACICRQ0AIAAgAhEBAAsgASgCBCICRQ0AIAAgAiABKAIIEDoLCy4AAkAgA2lBAUcNACABQYCAgIB4IANrSw0AIAAgASADIAIQDiIDRQ0AIAMPCwALKAAgACABIAIQJyAAQShqIAFBKGogAhAnIABB0ABqIAFB0ABqIAIQJwssAgF/AX4jAEEQayIBJAAgACkCACECIAEgADYCDCABIAI3AgQgAUEEahBVAAsUAAJAIABFDQAgACABEE8ACxBNAAsZACABKAIAQaCFwABBBSABKAIEKAIMEQYACxUBAX8jAEEQayIBIAA6AA8gAS0ADwsSAEEAIACtQiCGQgGENwOgwUILEgACQCABRQ0AIAAgASACEDoLCxQAIAAoAgAgASAAKAIEKAIMEQQACwwAIABB3QAgARA/AAsRAEHIhcAAQSNB3IXAABA/AAsLACAAIwBqJAAjAAsJACABIAAQUAALCQAgASAAEFIACwwAIAAgASkCADcDAAsJACAAIAEQUwALDABBAEEBOgCMwUIACwkAIABBADYCAAsHACAAEDMACwMAAAsCAAsL270CAgBBgIDAAAvAvQJ2ZXJpZnlyZWZldGNoLW1pc3NpbmdyZWZldGNoLWV4cGlyZWRyZWZldGNoLWlkcmVmZXRjaC1raWRyZWZ1c2UAAAAAAAAAAAABAAAABgAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJvciB1bmV4cGVjdGVkbHkgaW5kZXggb3V0IG9mIGJvdW5kczogdGhlIGxlbiBpcyDAEiBidXQgdGhlIGluZGV4IGlzIMAAwAI6IMAAL2NhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jdXJ2ZTI1NTE5LWRhbGVrLTUuMC4wL3NyYy93aW5kb3cucnMAL2NhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9jdXJ2ZTI1NTE5LWRhbGVrLTUuMC4wL3NyYy9lZHdhcmRzLnJzAC9ydXN0Yy80YTRlZjQ5M2UzYTE0ODhjNmUzMjE1NzAyMzgwODRiMzg5NDhmNmRiL2xpYnJhcnkvY29yZS9zcmMvZm10L251bS5ycwAvcnVzdGMvNGE0ZWY0OTNlM2ExNDg4YzZlMzIxNTcwMjM4MDg0YjM4OTQ4ZjZkYi9saWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMAL3J1c3RjLzRhNGVmNDkzZTNhMTQ4OGM2ZTMyMTU3MDIzODA4NGIzODk0OGY2ZGIvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIuMTEvc3JjL2RsbWFsbG9jLnJzAAAAAMUBEABLAAAAZgsAAA4AAABFcnJvcgAAAA8AAAAPAAAACgAAAAsAAAAGABAAFQAQACQAEAAuABAAY2FwYWNpdHkgb3ZlcmZsb3cAAAARAhAAUAAAABwAAAAFAAAAMDAwMTAyMDMwNDA1MDYwNzA4MDkxMDExMTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5Nzk4OTl5ARAASwAAAFcCAAAFAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB4BEABaAAAA4AQAAAkAAACjeFkDhHLTAL1uFQMOCmoAKcABAJjoeQG7PKADmHHOAf+24gKzDUgBsKAOAtLJhgGdGI8Af2k1AGAMvQCn1/sBnkyAAmll4QEd/AQAkgyuAO35TREDc2EajAl8D2cxeRZuZf0f////H////x////8f//8PAMQAEABZAAAAvwAAAAkAAADEABAAWQAAAO0AAAAJAAAAcjuMBbzxJAP2JcMBYNw3ArZMPgPCQj0CMUykBeCkTAFLPaMDdD4fAj6RQAN1QQ4AonPWAwWKLgB85vQDCYqPADQawgC49EwAgY8pAb70EwFoqnoDYYFEAHnVkwBWZR4BoGebAIxZQwHu5b4BQwu1AMbwiQLtRbwBMJfuBBIqbAHkVXEBMkSHARBqCQQxZwEBTwGoBSKYHgMOqLkBOFnoAWXS/AAp+kcAzKpPAw0u7wFPTe8AvdZLARCN+QAmUEwBvVV1AFbkqgCJ2NABw8+kAZVCTAOu4RABjFBiAUzb8gDGonIALtqYAJsr8QKaoGgBILulBAERrwBCVKAB9zoeAiJBNQJE7L8CLIb1BaJ73QIfbhQHMhelArrWRwDpsGAA8u82ATlZigBTAFQDh6BkAFyOeAJnfL4AtbE+A/kpVQCFgioBYPz2AJeXPwLuhT4AIDicAC2nvQGNhbMBg1bTALuzlgL5qg4Bv6NOBCQ0lwJiTRoE7ZzVAdTA0QVILlQCE0EpBTXOTwLIg5ICqW8YAbEhMgKqJssBTfd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQCis7gBAHLbADBekwD1KTgAfQ3MAvOtdwAs3SACU+oUAPmgxgHsfuoBHGOoAqnimQFls9gA4o16AXlCmQK19YYC4uQZBdU56wHXrTgDtOfSAmSAnQOAX4gBbX4zAAKptwEGgmICRLBeAXME4wHZ8pEBya0fAWkBJwEbr0UA5C86AdbgRQLOOEUBD/6LAxbP1AHJFH4DXtVgAQiwIQDIBc8B3iqAAiIhwAP25cQFgBF4AvpnlwMGNHABizhCBybi9QHYRiUGqtYJAUhDhgGSwNYBKyZwAES4SwHNWvsAleuNALWqOgB09O8AXJ0CAGatYgDpiWABfzHLAAWblAAXlAkB0noMACKGGgHazIgAhggpAd9TKwJUGfcAbX8ABqeIMALtd9sD5q3VAs0S/gIHugcBfQkHBW4qSAJuNOwCXz+NAJO/fwLMTsABDWrtAbvbTACv87sCaFmtAFUZWQGi85QAAnbRAiCeCQB4oy4DXEYoAGwqjgJu/I4Bmt+QADPlpwFI/JsDXXQMAZeg2gOb7iUBoOrPA8QAswGZpI0E4MRoAgkjGQbP1PIBYP3eArdl5QDeEn8Fo4iHAQvPjAKRYfMAgcAaAshUIQFuCk4DklGyAQMEGACh7tcBBY0hADXXDgEWtdAD5oudALPL3QP+uXEAveKsA3BC1gHJPi0DZUAIAU2uEAKEdUQBbp0OAeW7nQFY8okEtwZuAoIYlQJIEo8BNzKbAVN1vAKE200CZMm0A4feIAARkuEAAoG2AZestQDAcygCJS2UAZQTJwE/BwIBgiT+AvmfxgFUyMgBKa5gAI5tQAH58s8BUfTPAAyNdwFBjKwDWS5VAe5ZZQMSGx0BK5rGARvP3gFu+sIGTnw7AcjqewO1FjoD2XuOAqzo9gHpT+MBR2lyAUcRdAAZslEBkCYJAeZ36AC71vQBMqNyAAM7zQHy39oAXtuXAI1ZhgBnDvEB3nM8AKJ+KwLCMg8Banf/A3ciFACIi9MBOGF3ACIIxgNAESABtH+jBAq0JwODeJUBrTAdAYNmgQYiDm4B5Gu3BBSxLQMFZVECYs5UA3XRNgKOdAgAbUfGA9xMPwEq0O4CR4qDABByLgOzy4sB5I2FACZ43AHfHkUAnnS9AEJzmQNMLMwBdWnrAAiVpQHPFqUD7yjCAFr/aAFHe2kBgw4VBr6KRAMxArsCWfIrAWiCPAMgHnEAjxT8A3AOXgL4i30B4rISAVlzUgBWMXgBXNevA9xWzgBwueQA6ascAG0PngIMhYgB/f41AYBtBgCDSxMCFwUaAMzDggGCIXkAmdcTA9c+GgB+VEQDDUryAdJq3gMnMVQAJRFHBUGl/ADPMcoErHvKAby/dQWsCKcBEuK8AxVCJAOYu3UAaK2sA2io3AAnj2EACRdaAYrD3QAT/SADjRY2AAarcQPHP3gBX+CRA12b4gF2uaAD0RLcARerGgG6oKsAzQaYApD1QgHq2I8BRRWgAVWtxAP/cckBspnPBXPFmQCInKYFDxWIAlNLzQGfEBIBxb2KBHlkdAIey3cCJDPlAcCY0ADH/QoAMNJsAPNqJwGyBfkDTJkCAaS4LgDr+1wBX4VfAhhVMwFTUKwCsAmxAV4JSwKzl2kBtmvyAiEQMQCFeBkAWqXQAcj8tgPVIMAB7j53BM3JGQJwYZ8B3q/UASMz4wK2Ka0B3NHqBqRR7QHQGoUF+b0bAjRKWALg7ucAA3olA6OVHgGRrR4BAmJTACTOsQDGFoUAbZ1mA6ikTgDlfVcAMMfdAFKZiwOugfIAkAPVAXHgAgDsgAcAjUQNAa+i+AG3pfAAE6cUBXV+RQHVVSIHfmTMAe+9pAIw11MDzosRBP5V9wDHkDQBTmfqAUElHwOuS9MAnf8jA20FOgBDVOICBa2hAOi+0QCOfy8Ad3QAA7EkKgDoo70CDUm7AOqR8gBAvwoAIaPeAeCcLwCTsbIAtVT6AC8wKAGLnaEAElvjBE6CDQLO6VIFXJPtAl+ECwI/uMcB5WnJBJdBpwHZqUYEZ8fLAr31LgLzimMBim+MAz06owGyYZIDuIm7AZ3PCwGpQs8AF289Asob2gFqfFkBm6lEAVF1pQCcJhgATEY8AiKwCQDhOe4A8scUAdKaigMXTFgBvq6SBHrjJQMAonwCa2saAlQPKQNIukcCa5GNBWGQpQHUNT4FsKsCAtXAsAM5CrMA5GyKAzrY3gGmd8IBYQoBAevTRgNemY0BfMXyAmsoDACq0joAwNx9AHYPwQALWQEApvwsAD7SDgApQ+4ABA+QAGVAwgFw+oIApnOWBAj24QAqfJIENqpvA+8OZQG1Y28B4UDNA4/DOwKr8GEDzCrUAWBeAgK4EjkAHAQnA+VefgHs7MACHA1aAXzOsQILImIAfgZFATHZpQE3EPgC6KCMANEjfgH+6x0BaLu8AWMlLgDWregD5RYIAHVw+wOs5VMBZpJmAQqBfAH1QUkC6+sjAod26wTwYFcCRUHKAufNcwJ0u1IEpv/1As0esQKF8WsB7yKPALvS5wAu2SUChefsAHOIUAD1Fn4BXej7AQ6a4wFrhbgDzX3LAAZO8QLQIBgAdUHXASKe5QBQpfsDQUZIAIgANQOjycMBR1+AAexgkQHQLIMD6waLAhbX1AMGsEwCjlunAzA9OwGIrc8B0TTwAVXz3AAcSAQBZOQiAOc/9wElM+AAmLZSAZp27wJjNpcAjJsDAFs5AQGKM3gA49LHASMrvAIFP4sBqtmAAkQ9XwBaqSACl+vuAOyqYgNRXYMARbc7A/Hb8AHRS3MD5bEpAQ6VswIiyTsCxz6lATJVjAPtPG8EeDyuAkP1uQFNrD8BrpOtAmT0jgH3zRICqYsTAauDFQEmPZwBtJCHArbi4gBd+VEDN6cSALiW1QP+WHYBSuWsANpmiwCZxTYAomMqAaHrLAOsaxIAMXn8Ad1CHwJJdboEONNbAEm+PwQvOWsBnBUqBa+DnwJmD1MDhXvlAX7+3AMYT58B7hrIASu8RABlcYIAE3xPAfAwtAPMlr8AYo0MApcZRwGBvewClMKWAKnk/AGlAXcBfQR1ATFK7gDlhiYB1PyOAFTcSQNvRrMBhsOvBVhImAH/A2IHp8ZFAKqoIASpC5kCDz8xA97ufALjKXQCzgZ4AaOcFwIUZNgB0K/wA2RZMAAodFwBHnGZAEJUXQEUEMcALgu0Ac+D1AGhV5MD9PhCAbanlAL0zOoAs+1ZAm4eMQFvMk0ARsMwATzvzAGyJMQBvB0FBBwr9gCt0EMFvK1CAo/aDwTqPHQD4+VzBUjHewF6E7cDls4FA4yRZAPAjxQAe4pjAVv9oQET0IoCpOWBADNPpQEB4XQBVwI9AGyFOgCKIfkAfIxbAfgC4QDi11gBuKVpAXbxsgB6NIsB8v5MAeOkFAKVFX8BjpiQA515uAASSeQG5eJ4AlNWBwTsPpIBcs1ABHV8owJl1AkEHFPIAOV6bQBxw5UBbeKRA8anYgCrQj8Ahq0NAZiBTwIqK1QBVMQUAHHEiQFwF2UCAZ1gAGXChgI8UTQBgZLuADwiXQAMdlwDNptnALjscwBQqm8B+NJDA/yYMwKNNh4BHyp4AumeAQRuexEC0NAoBbrmpQMaT5QB4UErAeSbyAJEwm8Bg4zzAnLriwEszrMCZbCXAHsBTwN/ld0BYY8UAFez6gABgzEDMM2OAbHQBAGLOTgAAWdyA4yonQFply0AgaanACiQHQMy/OsA8jTFBPzCkAFEclAE+DCZAHCSowXFJ9MBR7yZAz3hzwGZvTIHfD6zAl5AIALO+nEB+DDZAmptfwFHjDsC+dUpAVYklwIkpaMA0kxvAPo5RADk9QMCtSc2APiKAQCBhUcBGCJKALc7LgDQhJMDYupGAZOWCwJfFRcAsA7CASLsrgHungsDftC3AW/hhwX6IUQDMKefBNa2QAJgGIQEu3+iAG9+yQNHjHMAH9u1A8+PgAGY/OgB3SXtAUVQvwErXOsAmP54ATBVuAG/mtYCv81YAOz5KQGuGTwBk1tsAud/OgG6sksAbyJjAMqVKgDZ76sBuagTBT0cVAO7K6wGZljZAVl09AGJ1OoCR1urBEQ72wEBuO0ETgJLAsHS9QIYgzcAtU9zA3OAJQH28GMC4HCtAQZttQG9jxgBA5UbAeHSNgAPGbgAwuQfAYIfYgDXCAUBdloaAP3XxwBtuaoD3NmcATVmnAEeqs4AnmwVBD5iPQJo8KQFUtDYAOqKtgW1WsoBQ64WA0TcNAFYjRwEQrOEAvJcCAGvR/0B4fXjA5k+SwBq1OMBPANgAKjwXwHYzVABIY6eArzxjACBxxgDH0Q1AV4apQP0k5IBN7tIAEEzPQEeFUMB4XScARQZkQDe3XYAthpwAXfaUQJmtrQBfM6gAHvjigNSyCoB/rCgA7vClwLRF6AEKYvrAW/CawBfjtQAvnsiAKieYgCLX+oBMKN5AV8degKOj78BKm7SAl62xgBiuSABQvsFAP22UwPO+GEAYxR6AGQKVgGSp+AAknyQASJmOgHxR3sALS0JBIapkAF/0RED+U3GAiFBzQH7EjcD3j2LBMKnlQKheqUEmPVAAW7yiQGTY3oAl/78AoUrRAF8C84CXMSFAII2vwF7ZFQBwIvyAs1KbAE3FakA5FbOAENZvgC/eb4BD+rmAvqLjgAGHwEBJWMcAR+aXgCaQdoAHXjYAxOPLwGJivwGWZyQAnY8vwQ4PVsCXjL3A2S9dAJbgAQHMnfVAEieaQAudkMAY42PA7qO0QEzwJECWyHYAVXgjgDAyjMAS0cIA0lEbAHbdTwDchNmAXf5zwKyvzoBe9l+AJaBWQBbxFoAJ7bsAeRaIgMeFmEBw36mBthDcAEKifgCjFxmAYWtEwKLIbICv+n/A2mRigEqmEsC7okXAqZXLwH82OgAcsZ9AeGd2QBF11ABt1uAAVQEDABp+90BEX24A2Mk9gBNhloCR5+pAeDHEAJQ8YYBtrqWA88qaAF1R4gAbE27AKVkTQLQPP4Br4ZIBusBkgBjT7wDFyL2ArMjVQZOZUUAPdIYAeq1TAIOMaADctX5AdFOeQCJTYoB2mHRAodHOwDDb7gDw7wjAGcL/wJfldgANTKcAcGpMgAjMBoCndQTAV8TzQK3NEEAajiZAllZ5AF+BnoDSBxGALNw7gIK2xQBw7nMAcj8+wKbEfcCCimjAf3iaAKLFmMBh/YvBIt79gBJpFwHQleoAfq3nQGWwGgAA9xEAH6BvwGc07oBjQFxAH8p/AHDP44AR7pBAOD37gHVqL8BQnx4AcERngAOEc8Bq5NwA1iIlwAbzZwDZV9vAc01QAEbCFcBJXbeAGSr/gFEYRwFjaHwAEafCAbKWUoBEK7tBPKhhANw7iIFzVpzATc9RABuVuAAKi6fAHu2VgFtzwoA/J4eAQZgCgIzC9cB6XTNAyI/ngDH6zMCNWUqAQfe9wC90XMBSUSEAysUzQBwTxgCfgqFAIirkQJUGBoBb+tMAXUUDgKH5WwB629WAaeItAcqeeIAjKmQApW+kACJODUDi49UAdLvpQAVZ0IANO7yA7yCBwEaFNcDz/vUAYnHWQCDe7oBTomlAtm2jQHe1NADntuUAF9TPAIfLVsBloQ9ADVMyAFZPtECHhHzAbBZVQI9I0oBCYjZBHuKrQLxIc4FtyqfAuvH8gP7uksCo8QnA/1LOgIjRV8EMRxLApsolwJCMXIBUvZHAQlU1wGu+mMBKYl2AQdjeQO6jcIAZKlVAW3AjwF/djgBeWlvAUiNGQBLmD4ATKaAAVEz1QDqtM8BkqcqAWKrFgCVxQ0Bhq39BfZ+bAE6vPEGsiXXAf4GtgIf3YABzIwMBG7tNgJxufEBYfobAZpL5gINigIAJixOA6mkhwCT2kABdWTzAaOnkQKMkEcA3cJyALeR+gCn3+IAYmFAAf5T3QM66A8A0OecAeV0nADsSy8DQc0pATL0fQIyLCIAwGz+Aj+VwwEMgrIDKEedAHXuOgTeozUB+hGHB1J/EgPt9QoEW9XxAJ2qVADfTBEByKT5ARvy8wE6QtsBWJsRAUrr0AOxPW8A4RBhABVs9QGWBccDtaXOARNvPgDYV9gB+eOrAtfAIQBqNCMDgqxVAXc6SwIVl2sAOFkCAwBTawBBm3ADUuOjAJvvTwSj4oUCA+BzAKBozAKRjRkFj2mAAluNcAKPoTkAsb9UAi1FJgC3licBkF10AA90PgDmwfAA8YqBAsdzdgErWaEC+E6HAHvrgwDGFVMBqm6vAEtMQgBunqQAr8pkAeAfNgCDguoAk/bfBEH5FwOCsnEEezBbAUpAHwNEpXcCre50A+QIaAAgi3ADQ4b5AC7vSQF4iBsBzyAtAjOAEgAEgzMCMLN4AE+uOgEVNiUAGg0jAyeMuwF3uGcAq4wrACknQQD2o3oAiojoAa1J6ADYexICLmzpAB1PNgCmN5MB509sBqxgrgNeCLkE9zCGAGzQ4gIPO5UDwqs8BaPlAAICQhQE8tllAlBkHwMBufUB4eQ+AvrwfQDa4/QBs08pAADSfgGeMAYBU7TlAKAGsQBLxZ0CI/iDAbegCQNwvKwBvLvLAcROygDtp1gC4RV9ABzIdwMe7+QAAozNABrq2QImNtkBa8bRAU8UWgWz0gUDI/tcAn3P0gDTw5oFVe26A1VHPwNtkeEAN11hA9xBbADUcn0CesHAAeKdigD3fswBTsrQA64z8AG9WWAAjHYxAVNIvwDzOysBr7eZAJuWrAFnaAIDDIaRAZSpdgFEq/MBIuZNBjCCxwJCDCoGY9zrA+usHAUHErABEw5bA6abWwHQ5E8HjAXuAYNHVgDaNpMB32ZYAmCzDgAdykwA0+MuAZHwyQH5L6oA1xTEA/WcywDMPxEAQfDGAVIKawJTRnwA9PFwARSkXwDrOs4D5HEsAPCWzgO4Wr0BprT2AmH4qADvqCYDK5kHA32ZBQK/Nk0CMsftAa4oHQKqkvwCJS+vAnOSHgBjuyUAp6vLArYwGgCtTX4DJvfyAGrRmwJx86IBs6/+AerJvwEpYx8BmM99AIEtyAEORDUAxc7AAzUsbgDSOgIAHKoZAYTibQOW1soBwzejBIkRSwKN52AE/BkbAV5yaAZ2OSQDQYwBAnQNoQHn/aYCnhbSACDnaAE73aUBJn6VAnhfygAmdOMDHUCRAa6ctQCK/ywAt5cNAkWohgGOElUD354iAabksgExrK4BLS/dAEyI4AC0ePYBblYoAI3uAwGBs7EAB5tGAp35xQEp0WMEDgEPAbMz0ARCihIBAdxUBNvhdAI4gzcFrDA+AokoYwBn7LcAsFGeAFJJ4QAzW3oBGpL2AE22cgOdPPUASSbZAbTeOQB1XNsCfAeMAOPFOwNoQIUAggN1A0+tnQBcdwEAHK++AY0lxwCVBzMBnOE6Axp2+AISF6cDBcyjAJ56DAT4EzQC/s/hBsfwzgEtozcCyFPKAY5jQwGdGTABf34fAXIiwwF9mNADZrupAKBT1wC5nlwAFHXOAf+8iwH9Pn0D/QUgAMttSAJPw/EAdkd7At5lAgGnG+cAtZdUAGZW0QMho2QAKXIIAln1EQJGyRgDuqxVAIumtgQaKc4BOjDUAuqKUgGfSdQBsIMrATAhfgGtViUBYaO+Aiey7AH+rb8BmSy9AIR2OgJACMYAj0V0AwVt3wGnfb4C6OayAXqwugMDZ8AAdqwZAsS/0AHJS9ID19XhADHaYQDNxl8AhihsBz/PWgIzQfMEJh93AnQd6wb/ekECyXOsA3i1SQI8RD8EsKDiAVLOAwDNZgYBybEcAjjb0wCEjbIANad2AaK9FgMu2sQAqa0TAmZu9gDEdSYAnETgAK3A6QBKI1oB50S/A3+sxAF7rdMApwhyALuBvQCCJC0AbwcNBsE+VAF/wNoFxnSLA7QjqwMImAADNszJBSsYiQJQLdoAmQL5AkFyKAHLLLcAtyaYAKwkrgFd9OwBDthoAXl+CQL1MKQAKB8uA577VQCfcMoBp0tpAf6ylwP/Od4AQouUAJU/LgF4e9cB64PWAftVXAHEnWgBQkyFAXlINgJnTzYC8X7DAezxnARtLhICJii3BWt8rgPSLYkFYzg9AswAgwJMBYwAYlX4AD2s/gEd+yED8LhtAKy+FgDnyd0B3xerAsAmGgHtMkEAuwRHAXe4twIVycYAgdGHA5SHcAEvykkC3vDEAN2evALLkOwA3NjHAeBlIgLfAoUBzHlDAmetkAIvxjYCG7EVAYQ2GAKMMjADRH/YAlkujAOtMLMBd7eSAwuOwQHcZDcAPZbAAfYEmgO/MXcB27IqAwdXsQGGmRUBWSDDAEWa6AEovosA5FziAkQE+gBqC7QAK9aQACx7kgIWYfMAzFEZBMq1QQNdov4BwUcvA8yo7wN1jhsCI1FYAa2qVQJ+JMcCYuYXA7DTbwN3a8UBouPWA7rG8wGpyAEB3EYOAGmrNQPqIVoBkdqgAHpI2ADNPl0BMcrBAIH0ZgJKM2IADYVbA85MVAC5amED6H9jANVm8AAbwo4AfNW9BCwgmAGsMUYDpTFMAo/y9QI5vCwBgJoiA5+owgDxFJAF5xdbAl4ZBQI6RtQAbbggAQu+EQBFUccCMo/SAJaEwgFGnU4B6MaIA9SuBwA79XIDuVtQAeihEgHnXC4A4z8mAxAHlgCr4ZQC/xUKAHOEgQG8kyEBHbjQA4IOagGhGYUC4cjdAq07GQbzPhUCgU2fB8wcSgK79tcG6gCbArOaYwOlzPABAt9xAkYDWQEeH9EADzxiAR3EJQCYi+0Buk3DAHDrqQDOfRwA1oueAcOyLQFNQQIBJXrqADykiQHcPaUAG5LqAB2elQFa1OIBLcxpA5UWMgErf2UGbbrSAVT6mwM2qIYBKgvFAbmDNgLRvCQG//oVAw0YXQM3lWAAH6KMAk7nPwBUGNQBH3GOAKQalQPqJOEAHjeQAC/FCACKkCYDo78rAD1vWgOp2u8AzO5aAPrOhAB1m7wBcTdJAfD8NAGxXOUBl5V0BDfA0AKGhpgAIIMcA5fcfAWjyYgAy1X7AZKCQwEZf24DAkPiAW8tWwMoj2wBcyQ3AGbJ1QE2KOwCBOqWAQbEmwGG4OcBDraYAeN3wwHEXdcB/y1QAJJ+0wLA18IADsyOAoWEtAD2GHEAa0UVAKeJHgFa2hUBrUOmAxZ3jwEhZ20DyE3PAPtzIQaPnWcCKgg6A3URjwPGBWsE2wO7ANstWwBNwfgAnGpzARdgrwEwpx4BfeFVAe73rgFEQLABwQEvAwjdQgDYWY8AGKWFAIefjwHo8f0AuDclAnAUTgAVN1sACvLUAPSjJQGnvnUByqajBqu/FgOEtcwBgO88ALSzmQasnJ8CC/tlBsiA4wKdfIgFjz5dA7tsbgB5YdAB20jKAxF5CQAwp6kARiZ9Afr7+gMvTy8B9nX3AMF5kQH6HokCt3ZKASUZ+wB3kWgBz+k8ABEVTgEUwawCRl4mAavKTQOVg9ABCUsjBOSPmwEHH4IDENo0AYftIQekVMQBSdiZBaioDgLbPJwGPZiuAjxRNAAoTqgB7L5zAs43egGAmD8ApuRGAcaAHAMVZXoAG1grAxi9EwHJZNMBCEeSAXq0RAESKWMB7mgXAZccBwDg7IgC3up5AF9LxAEmUsEBEp1fCxcbFB49f40VVzc/FIHXchl86y8EPcfuHB5NGB5tBAUA7dP1HNIYkwCWNecdRb3zHU0BAAAAAAAAAAAAAAAAAAAAABAAcjuMBbzxJAP2JcMBYNw3ArZMPgPCQj0CMUykBeCkTAFLPaMDdD4fAj6RQAN1QQ4AonPWAwWKLgB85vQDCYqPADQawgC49EwAgY8pAb70EwFoqnoDYYFEAHnVkwBWZR4BoGebAIxZQwHu5b4BQwu1AMbwiQLtRbwB13E8AyT/OQNDsrYCf9CzAHYafQICB9YB8DJNA1TLxQHSh/oDGDBkAajVtAIQWGkAU9GeAQVzYgAErjwCqjduAdi1EQMTvKoAkpxmAlbWrgFfepsB6SyqAH8I7wHW7OoArwXbADFqPQEFQtADAWpuAVDqEwPWa8ABMJfuBBIqbAHkVXEBMkSHARBqCQQxZwEBTwGoBSKYHgMOqLkBOFnoAWXS/AAp+kcAzKpPAw0u7wFPTe8AvdZLARCN+QAmUEwBvVV1AFbkqgCJ2NABw8+kAZVCTAOu4RABjFBiAUzb8gDGonIALtqYAJsr8QKaoGgBnwn8AmNu1AAOBacE6O+jARuXnQFlkgoB/Z5GBkX55ABYHjIEQzqgAb8YaAGBQoEBvzJVAwezigEl+skAc1CgAIPmcQB9WJMAWkTHAP1MngAJ/3YAcfr+AEJLLgDm2isA5Xi6AZREKwCIfO4Bu2vFAVM19gMydP4BILulBAERrwBCVKAB9zoeAiJBNQJE7L8CLIb1BaJ73QIfbhQHMhelArrWRwDpsGAA8u82ATlZigBTAFQDh6BkAFyOeAJnfL4AtbE+A/kpVQCFgioBYPz2AJeXPwLuhT4AIDicAC2nvQGNhbMBg1bTALuzlgL5qg4BMXEVA926OwFBB/EBRQZIAFacbAY1p1kCbDTbBguwFwHDLGoH7ZVHAaSMfQOerQEAMynnAJE+IQCKb10BuVNFAJBzLgBhlxABF+QaADHZ4gBxS+oCwJkMAbUwYAMNDRoAgMP5AkTBOwCEJVECfGo8ANbwqQGk40IAv6NOBCQ0lwJiTRoE7ZzVAdTA0QVILlQCE0EpBTXOTwLIg5ICqW8YAbEhMgKqJssBTfd0ANHdmQCFgLIBOiwZAMknOwG9E/wAMeXSAXW7dQCis7gBAHLbADBekwD1KTgAfQ3MAvOtdwAs3SACU+oUAPmgxgHsfuoBfD7dAIFZ1gM1iwUCQxS/AwzMsgUiw9kALzPOBSX2pQDOGwYCnVckAtk0kgN8e9cBVDwfA6oNBwDa9VgC+yM8ADfWoAOEZTgA4CATApJA6gAakaIBcnZ9APj8+gBlXsQBxY3iAjIqtgCHDAkCbKzSAcTswgHxQZoAHZwvA5hDNwHZpSIGSLSzAtlCRwVXemMC07XbA1sq5wHuAJoE9E23AV5RqgES1dgAq11HADRe+AASl6ECxNFCAa30DwKhMLcAMT3wArVdwwDH5AYByAURAYgt7QNrlAQAWk/tAyY/TQE0Us8BjhZ2AWToEgFcGkMA8sdYAyCoigGU4UgAAtEbASv1qAHc7REBHdNpAozu3QCAUPUCbv4OAt5fvgHfCfEAkkzUA2vNaAE+dZkAkEUwACPkbwDAIcEBb9a+AnKYlwAEZlgAM0r4AOLHjwLLomUBz2G9AfVoEgDm9h4DFpRFAG5YNALhtVkBvS9aAnGhUAMfdPgEsphXAUSQsQFY7hoDOCBxAQFNRQI6eTQDl+5TAjQIwQDnJ+kBxiKKAN5ErQBbOfIC29J/Ab8H9gKWI7sAw+ylAG9dzgDU94UBmoXRAZrnCgBATiYAevlkAR4TYQE9W/kB+IVNAMU/qAJzClIApexxBtLLwgE8ZPwCIwXKAXZbmQOATx0CZmerAuzXbwPWNUUE7vAXAsKV3QMl4d4A6P+0AnVShQE40bEBi+iFAJ6wLgLBcy4AWPflARxnvwDd3q8ClOssAJfkGQLZaWcAjlXSAJWBvgHUQV4CdIbgAVHGdQCd3dwAkGUkBMRyJQJnrKYCCrYAAlBIvANgvBADQwYKBMaTkQEHCXMFQNavAdmt0QBQf6YA9+UEAqa3fAFZHMwCrjvwAQop+AFsKDMBj7HDApX6fgCKW0EBeDzeAfTB7wAd1r0BfwIZAFCaogBN3GsB6s1KATWmZwNzSAkA0V4vAx3IGQEi1lkDPLCMAVLiowNKgqwAgCYRBF6JmAPVfJ8FTl0AApRSnQLCgvsBJ8pMA/p+4ACdYz4CzgfhAV9EwwCMup0BghPnAymA/gA02z0CZctIAI0HCwO5pNUAH3p3AIXykQDQ/OgDWtW2AY4E+gL410oAkh5vBaoJ3wLkeyIFW4IaAUybLQXCixwBOuBOBIcR9wBseSAETvq9AU3j/AIl8T4APq59A5pvXQEJ5s4BYcUoAf8wOQJA+g0AEvuWA9tt0gEFrqYCK4G9AOsjkwMk940BR40EA2Zr/wD3WgQANSwqAAIe8AAEOz8ARU4kBHCntAC+R8EDxp6kATkIrARMIQwCQD8DBJhNIQGr/mYB5N0EAUQe/gGSKVYBiczvAmuNEQG68ocA0tB/AEQtDgJIYD4AUTwYA6kGJAHw+BoAI9VtABaBNgMUI+EB6T04AznZBgCPfFgA7H5CANEmtwMh7gYBm5FmAF8W0wLDD5kCLVToAXQikgXm+koBGoZkBVu7wwGpxnAEdxwqAr5GQwAdUR8AHahkAamtoABrI3UAPmA7AVAMRQGH774B2/wSAKPcOgGJibwDUmZtAGAGTADq3tIBuK7NATye1QEM8dYArIGMAF1o8gDAnPsAGHUeBOBRngJ+6NoE4RzLAugblwN0KwUB8Q4vBx8UBgKI+ywCGh/1AbfWfQIneZUAup7VA1gI4wBFWAACyofhAMmuywCTR7gAEnkpAl0FTgDg1vACIwW0APuH5wGjitQA0vl0AleBuwATCDECPQ6QAZ5M0wDWM1IAWnXkAmbfywFK/A8FmUfcAxUNWwWMqGADs7aFBPkzNwLp6tQCrj+eAifwNAGevSQB1ChVASC09wESZhoBVBhhAUQV3gCUi3oB29XrAejL/wBmOZMA4weaADUWkwFIAeEAUoYwAlI8nQGQSKkAImfvAMbpLwB0EwQBpWoJA7aBUwIjsOYBImdIAtqihgT0Kp4CH5VgAqQskALJ70gC1pYFAipCJAGE168AVq5WAxnFnAEw6IcCZrZSAP2AsAGZsnoA9foKAOwYsgB2aoQAKB0pADIemAN7aSYA5r9LAI8rqgAsgxQDKw0XAez/mwGfbWQBXbUYB2bcbAI204MEYgzVAZeXkQPtBZ8CYJsIBCBsUQIAA2cEPW0iAfqbtAAgR8MBJUaRAZ9f9QBF5WUBiBzwAE/gGQBObnkB96h8ALuA9wDvkusCTguEAEY6DAG1CKMBTomFAySqCwGM81UDr+fXAcuWpAPu1ycBG1ecAgejWAGrIugEQSxmARo2KQLrY1cBKHupATRyKwJ0higEmoYaAtTPWwIihCYBEmZ9AiPjhQF1A3EDHA18AJhgSgFYks4Bpr/cAqESWAG2ZBcAH3U0AFEuagEMAgcARVDJAdH2rAAMMI0B4NNYAHTinwB6YoIAG+zqAeHiCQPN4nsBWdY7Am+HWAFa9MsDLwsmAYFsugJYcA8FZC7MA3/MLQJO/90BMkkSA34qZQHwFcoAoOMHAGky7ABPNMUBZ8rQAbQPEABSxU4DYU3LACm58QEjwXwAI5sXA841wAALfaMB+Z65AQODMAAVXW8BKnnnBUTIJAO3MLkDbu4VASYyGQNi16MBVtQeA6OTBQF/BiMBbN9uAcJMsgBKZbQA8y8wAK4ZKwFRrf0BNnLAASc3WwDXbLABCjgHAODpTAC+YsoC8Rl9ACzBXQLKCLEAh7ATAHBH1QHNO7ABBEMaAA6P1QIpN9ABPEN4BMAVowBjpHMECRR2AJzU3gKfB9kBcfVMBXQ7ewCwwlYC1A+wAE7OzwLUgTsA6fsWAWA3mAHr/w8DxFlUAVyVhQCuoHEA6mOpA5d0WAB9pFMDXh3GASEvDwNieIYBBOzBAPn3fgGSux4AMuZ1AWvZ2wOiUaYBNRmpBpl5TwMam1kGBX4RApJBIQUu6v0CGTMSBGhTxwGixOYEcPikAs/+2gC90csBo/feAv4jpQAEvPMBf7NHACXt/gNjuvAABTlHAmZISQHhElEC5NKEAe0GtAMK5a4B4t3AARExHACj18QCCHYEATLwRwBxgW0BOfDnALyxfwJ8RywFGa/zAF6pGQIa5h0CDot3AaiqugGrxUwD+0u8Aol8xABIFmABLJf5AdyRZABAwJ8Dd+/iAIGykgAAwH0A64rqALedkgBAx8ADt6xIAUjhgABNBvoBuUFDAGj2zwC8IIoD2RjyAEOKUQLsgXkBAc+WASnHEAMEFIAEnnYFArQQjwPbJg8CFkCTAkgaDQJW5DkFy3yAAhgY3wDbY8cAFksUAxIbfgCdPtcAbh3mALOn/wE2/L4A3cy2ArKeQQFRnQMAwtqfAKrfAADgCyABJcViAKikJQAXWAcBpLpuAGAkhgDq8uUA53kTBPH+cAECL14FCO8GAVCGmQLV/agDQXzgBPRfSgIbHiwCAG3cAbJZWQD8JEwAGMYuA0tNbwCG6ogDJl4dALlI6gNFRIcB5mYHAkznjACnLzoBlGF2AQ8b4QGmzo8BbbLWA7ODogCPjeEBDdpOAXGZIQFiaMwAnHJ1AafOSwLJxFMBOkBDAokvbwXD94ABiODgAp1wzwCaZP8BhiVrAsaATwN+0ZsBov65AjsO8wAf23ACHNlBAMgNdAJ6PMQB3zu4AvFZxABoEEsClBDOAEX+MAHndN8B0KBBAchQYgAlwrgCkz8iAIvwQQPYkIQBJSYtAsZ40gBssaYDn94EAtt+dwKka6ADUNz4BfCviACQjRcDqIpUAo2JTgPhdlABMxuEAz5giwGX+icAvJsPAOgzlgInD+gB7+UJA4ivGwE4SWEB2tQLAIcFogFrudUAAvlrAyfyRgDbyBkAGZ0NAENSUAPD+RcBfhSVBDFIkgJdTJQFF/tBAh7AFwS31MkBeumiBfatSAKhV9sCfYZZAowLDAKlaR0ASRvkAXF4twFBo20B1I8LAZ7nqAH/gFoAOQ46Alg0CgH9CKMBAJHSAQmBVQEutRsAZ4igAn280QEhI28A19sYAdML1gJkBXYA1cWFA96nbQPrUFYDRYteAp3BvwGbDzMBDr5zBE2HzwH4ChsFtH3pAl+sDQKp1aEBJuyKA15dVwG9gF8AfQ/OAKaWnwDjD54BzZ54AymNgABSsngBnG2DANoOLAL2qM4B03AcAHAR5AFZECUBxd5sAP7PUwMIWvMB4PSsABpYcwHMdHoEvubBArNkCwXYJWABmU6cBOrqHwHNsrIDlMD7Arb6hwD2FmkAfMFtAwHSlQGoEaoAAGBuAXQJCAEyeygBwL1jACLjoAAwUEYC0jPsAC169QIrrggArSXpA51BqwB6RdcDWVACAYJqYALicocAujF3Aq8+QANQMxEH7xTzAYENCAZ+2fMBoRsBAll28QD2xvYDNhB2AcifnQCjEQEAjGt5AFWhdgElAJUAnC/uAAmmpgFLYrUBMUoZAEIPLwCL4Z8ATAOOAQ3uuAALzzUBtsC6AasgrgG+TN0B96rbABmsMgLYCekAuH5EA7ZcMAJ+p7cBQTH+ABA/fwX9FaoBOuB/BhQwPwMZToICJ8MdAvqEcAIiy5AAaKmoAM/9HgFnKCYCXeRYAM4QgAPTN3oB3hbqAN/FfwD9tbUBkWZ2AOyZJAPT2UgBEyYYAok+PgCYjAQA5txjAQAV1AOTyecAznsJAv+q0gIyOiUDAP8OA/K3kQb+8aYAFkqEBHjYKQJew3IGgxiXA5zi5wP2BU0B9ZRzAuBcUQHdUPYCqXtZAUnHjQAdFAgBiYhGA1xLXADdkzECM37iAOV8FwAuCbUAzUA0AYP+HACXntQAg0BOAM4ZqwAA5osAmf1uAmb3pwI/KCgBKqXxATpL5AZ6870Bw1yyA4GMVgGMWTgBk8YFA8v4ngKPoo0AC6ziAIIqFQEAp48DjyQkAS9YpAKnqtwAYkfWAFvQTwCMTMkBpirWAUT/AAMFgH0BvQGMAJJT2gHW7kgBen81AL10pQNTCEIBwwPQA9RuhQLCqCwBnudFAqFAyAJaOmgAtjq7AvjkiALKhkwCYt3pAkv+1gJPRZoAQJj4AuuIygGcaZkClK8UABYjEwN7eekAuvrGAoPliwB2UK4DpH1EAJDKlALq7/gAh7h2AGVeEQF5SEYCRIKSAH/e+AFFf3YBC1LXArtKEwHkp8ICdBlCAUDqOAbTFpwCljtdAiwcGwO4fqQDHwbvAn9yYwHbNAIBYmCmAj2+fgFr3qgBS+KuAObixwA8ddoB+/gUAda8zAAMwoYCekXAAaitJAI2YlsA3ypmAogBZgCdWhkA73pAAfsG6QAHNhQBP3SuBIYlNgEOun0E4nCvAWO04QMp7fQB863iAvcSIQKqY5YDSesyAXVSIAJpqO0Az23QAeQJugCHPKkCslyPAPSqaAPqLXwBRWO6AHWJtwDNH9cAKAlkABoQXwFE2VcACJcUAxlkOgGvpcsBNHZGAAcg/gLz/vUBlJDCA3xxFwOuebUEh1TRAokGHgNYMBwCIJsOAxjwmgKMzW0FRXM+AQEoawKJmscBXd/iA5yrJgCjsRkCLHYDAQ3eFwHRvlEBdXvoAQ3VZQFoN3sCGvalADJjTAOL1iABYEFDAxcMHACuVk4BQPdgAKCHQwBCN/MBgMxgAxkGIQFhM1MFmNXQAQG4NgMY2gsCMEP2BhCVSAMLGUgEKU/WAhcEJgEbi5ABlLsXABKkhAD1VLgCd8ZoAX3aYAA4deoBDB3WAkMvCgGnmoQClybGAEKyWQPHLqsBDGNTA9G7/QGpLSoBitF8ANaijQAM5pwAUyRwBgGTQwIz13sD6Ks2AWGJPgT22icD5drsAPe/fwDDklQEpLBcARPUXgMQSuMAWCiZAcaTAQHNQ/UC7wPaATyN1QNgt2oAw+jrAl5WmgC+MM0CddHxAe943wHVHZ8Ao3+TAwzaXQBVGEQCRRRQAbwFjAFSYf4BUGO/A4NUhQNp2nQDb3ouAmgRIATBoD8DQt4nBdf9XAKwac0DlMnDAhfhCwMnonMACQdRAKXa2wC0FgACHJL8AZHP4QG0h2AAH6NwALEL2wGFDMECKk4yAEFxeQE72QYBbV4YAXCsbwAHD2AAJFV7AEeWFQPPSbwAwAunAdX1IgII5lwEoY4nAdZaGwRhYVkCXU/TBFmd8ABf3H4FZbDiABEe4AIiH38A5+hzAVVTggDSSfUDLo9yAUNBxQA7SD4BtoWtAlx5dgE7sVED6UWtAcyAsQDc9DMAGvTRAUneTQGiCGAClZXTAJ7+ywE2f4sAjuA7BANtFgHdKi0HzpJmAeuOuwQxzfUBCUpZAi9PjgDeTIIDHaY/AtkMDQMwuPQAu3FmANpl/QCZObYCH5YqABnGkgHt8TgAjEQFAFukrAE7kboCQjTNANvPgQFtcxEANo86ARX4eAGy/x4AwexCAQD/BwP8wDAB7UTZBQLWAAE/ZZIF3n0jA+lJswP4p+IA4a8KAWGiOgJpcKsBVKwFA4WMsgOF9Y4AYVp9A7nLuQHeTRcDv1xqAA/GcwPYmPgAq7J4A+OGNQCwNsEB+vs1ANUKZAEix2oAlx/0AqvgVwEN7RcD/FUaAX4ndAOraGQA6A5GA9PQigP70/oErzGlAA9MewMk2qABW4cQBQl+cgFFBeAD9vmNAjEUPAHx0r0Bwtm7AZcDcQCXXK4A5z6yAdq34QAXFyEBzLVQADm4+AEwtAEDWXtdASYAogNf+DQBU0KMACJ/5AHBigcBpm68ABURmwGavsYBw1A7AxEHjwBIHeIFxtn5AOihRwGVvskA2a9fAnCTQwOIj8cDfswBAh22UwHO5psBucw8AAp9VQHnYBkD/ln3AdT+rwHowVEAHCucAgtFCACAGPgAEsYxAIY8IwB29hIBMFj+AuMVugG1QXAB2xYBARV+NAO8NTEBXRmPBCV/NwHhZaMGzoU9AYhFrgW9dpEDOmLbA9gN9QH5iAoEU/7iAskffQHwM/sBHoOCAwGKMgHW17EB3wzuAfuVOAN7W0QBR36qAnb/ZABvh+gDDU+yAPqDxQCKxtAAediLAnYSJAEcwXoAECotAdTw6wHmvqkBxiPkAm2tSALV3fEDN5SHAr91TgaLXc8BjkGVBBQSYgFeLPQBar9NAOtVCALVbrABSK0TAp/ExwHsWpAAwaxxAcebiALjWt0AiTFKAaTd1wHRvQUDaOw3ASkfgQHB/+wALtk8AIpYuwHhUuwDUEWXAY2+EAENhggAbHowA1BAnACr84sE7CP2AHqPwQLTepICXin/BVaETQID1B8EEB9OAhQtrQIXjtkBXgkGA+JTBgBiO4ICPR4hAAhz0wGiYYABBrgXAnMcqAH4ipcDYfTwALp2ggBy+OsBaK3IAaB8RwFdJKQBr0GSAe3xqgLJxsUA0UeKAiz2bQPANJ4AhbuwAFP8mgZXvd0BqUn8BJM6fQAkRDMGKEWxAahMVgMlZMwBJTUjAK8TYQDh7v0DUFGHANIb/wLqSWsACM9zAFJ/iABBYxUCzhOIAGSkZQBQ0E0Bg8/tAw4DDwEgpm4AnF9VASS5bwGWaiMBgJdMBHFXhwGewkAEC3ofAecHZQard2ICmUfcAr45NQGn6KAH3iBjA8ecpQCXmaMA2Q2UAcVxWQCVHKECzhceAGmE4wM15l4BhK3MA1u3nQFYkPwCZSFaAJ9hAwC12psB73J3AGrWNQGkvnMBmFvhAVdqLAPPPXEAhDR8BL4bnAFtNuwFDR6mASZ/zwXkxxwAvOS8BmKd6wL12rcFahbBAbugXwBM75MAz6F1ADOmAgEzdQoCSDjjAZfB4QCEXogBZL/RACBr5QGzK7QBZNJ2AHJDmQMWWBoBWJpcAdx4jAGPcs8D+3P6ASHOSACKhX8B9bF8BVZLYQAP5VwC70ODAXV74wKReGgBkNX/BYC7RgPZdzYEABOtAhqWlAH4U0gAy+mpAY5rOAD3+SYBLfJQAR3pZwBgUkYAF8lvAFEnHgGOt04DweohAUPjjALXznQARhvrA2eQTwCk5l0C1YecAJq78gK7FIMBEW2uAJ9w8QIEbpUFI6XaAqUdEwWxLkkCXCsgAve97QJlm40EyF3DAfGL/QMOb2IBa0GjAppPvgFIrsEC9SgwAWpYCwLJYVUB/MwSA3DyQgBboMICzxK6AFEVPAC8aKcBe6ZhAtGFjgA48okCKG+CAG+XOgFv1Y0Bt6zxAyUGxAG4B3sDLQv2AvRpdwUOAqEBB84tAxHKSgNRfHMF042dAFMI0QKKD+gBqzatAjH3hADWvdUAkLhpAN/++AD/k/ABFrxIAAczNgCpGbQC27QAAVKgFACjvfMBOdHCA1ZJPABqGDEA9fncABatpwB2C8MBAH7tAG6fJQE6Ui8Es7tWAruU0AVjJYUBBnDBBIC8nAFTaoEDhOHKAg7sbwMnFGUArKwxAjI2SgH6ubgDXJvgAbP54AHmspIASDk2ArE+uABkzUgAue/9ATwP2gDEQzgB6SCrAS7b5ADQbOoDEz/oAaQ1xwGF5AUBIc1rAErujAOUnNsG7ayyA/m93wIfjtMB2Q+KBfDEUAIbJGICFerHAirt3AP1OSUAjhGOA5w+GgAr7l8CAtkGAdQZ8AEn3K4Bmc0wAhINwAH0IjYCixCbAPC1BQKawTwApoAEAyOROAGV8NsAeDORAFKZKgGM7JIAWFz4Ab0KAwI+iPIE0icYAhLKoQWsG7oB0czvAijRogO0/p8Dq3Q0AsNn3gLMRTsANRYpAdowwgBQ0vIA0rzPALuhoQLXEQEAiOFxAPq4PwDfHmICTKiiADs1rwATyQoBiuDCAJPBmgHTvQwCAMiuATGFcQFes1oArbaHBF2xcQIqWdcDh/xqA3mGUwYD9UIBUTEnAdwC4AJggbEETDtZAD0dmwHLq9wBW06LAJEhtQGoGI0BN5azAIs8UAPZJ2EAApNrAzv4SACa5i8BBlO2AQ9pogKI1FEBs7iGASfepAHcafsB73B9AD8HYQA/aOMBgToMBFk84AFT1PwAT9eoAvfdxwFzeQECI6x4BB+iuwE4azEDkioVAmrGKwE5SlcAfstRA4CHwwCMH7EA3YvCAAPe1wCDROcAsVayAnuXtAC4fCYBRqMRAPn7tQEqN+MA4qEsABfsbgAzlY4BXQXsANq3agJCGE0AFfXRA915mQKkOR4EUn08AkUmUgHlBrwAbd6dAzZ2PwHMl7oA4yGVAf6w9gHjseMAImqjAq8rTwBqX04BufF6AbgOPQAkAcoADbKiA/YLhACh5lwBQQG5AdMypQGNkkABnfLaABWkfQDVi3oBQ0dXAMuesgGXXCsAhW8FByUD7wHY//oDrz9HAUn1TQH6rhIDIDHjA/Uu+wGZIzAFfJ09AVckTgNg7JkAiLt4A3CGqwES1dkC117RAfsFPQBeA8oAAxq3Az+/KwEeFxUAgY1NAWV4BwHCTIwAvK80AxBRlADoVjcB4TCsAIYqKgPtMi8AlhL+BBOTVwMMw+8DRPcXAu3lgAOwMXACp2L7A3hH+ADzCJEC9eOZAcipsQL6i6UBC6O5A6MoqwGYnxsC8m1bAd0YcAES1ucAa521AsKTAAHCY2gDWIy+AbBCfgJpuUIAMdofAPyungC8T+YB7ingANTqCAGIC7UAgHVTA0PDXgIthMkE75hYAqM5RQae4CoBOtdDA3bDjQEjtHkCzi8IA5vS3wBlxUQB/lKNAfqJ6QBhVoUBEFBFAISDnwB0XWQALY2LAJisnQFHK1sAR5kuACcQcAPYiGEB28YZArA1MQDeWIYDfw88AM/AqQO/dNEBV07TBcfVtwEGDHoC3cs8ASBuxwL6anUC4+EEAXg6BwPbwVQGboUbAr3IyQOKh5YA6jewAzwyQQCYbKkD21UBAW+H4wCiGroAz2C5AvOIawBKmTIBxmGXAG4LVgOOda4BctTIAAXKtwDtpAoCuO8+AOx4EgJhe2MBlcnCAi3q1gC/hTEDYql3Ar27IwFzFS0B+INIBG8GewHVMbUCpekiAlzFZgL85M0BAjvJASpiLgDbJSMDqMMmAF58wQGcK98AX0iFAnfOvwB6xe8DsLtPAf0uAgH6p74AVIETAMtxpgH4H70CR53KAc9HSQPOGEgA9w8SBdFRTAFX0MADffNrAe2NeAPGeeoBiAw7AyPcewGTszwG7gwdAkIAYQEkHiYBcgFdA19n5wHEnjsBwKTwAMrKOQMXrjAAWU2bASpM1wD0l+kAFzBRAO9/NALigiUB93RdAXyEdgCt/sABButTAW2v5wH7HLYAbvldAlO4gAJLtT4EroC6AGQ1iAZrHeIA3ek6BRNjSgL/FaAEhQ0VAgk0NwMQWYwAryI7AFSldwHf4uoDBkimAXpz/wES1vYA+gdHAdncuQDBI0wDJX2vAL1h0gBy7iwBKLypAiy6mgBRXBYAhKDBAHnQYgMMUSwBuJxSBEY6FQHPcr8CMSaTApnYwwRkGRICO/rXA+iE6wFmr44BEA5cAnofbgLt8S0BmNnvAWGoLwH4VRABHK8+ATj+NgDe534Api11AhG9YAHkTDIAyPReAMaYeAFEIkUBC0GgAmQTWgCnxXgDQza5ASjavABxqDAAMmm9ARpSIAG4XaQB5PDtAUG2NQSqxVwBagnpAcd4kAFNMQoDbKppA0cEHwMb9HEBSToLAD7c9gF4msgCj9KyAX05gQEr+g4BZG8cAS9W8QE9RpYDNEkFAR0angDRGlYAiu1KAKRfvACOPB0CoXT4AbqvoACXEhAAvm9BBsmGJwNWbDEHgRpHA9sb1wJnaV0DHewfBoUA0wGOf24B1EnlAtZDpwLCAdABgxHdAzLZWgBD6zID3tKPALM1ggHpasYA2a3cA2/lGAGcml0CRsv2AS9ChQMCiOYBFt1xAupv1QCqeF8C+t0CAC2CngJoXtkB3zS0AtRELQFnJhwE855MAqDIYAfNNQ0BukOUBKk2+AJ2orIDUhQLAhcqwAGSn6MBtuhvAE3lFQFGNY8AG0wiAPaILwPaJ7YBW+DJAROODgFFtvEDonb1AAltagGqtfcBTS/uA1PSsAHUa4sAJyYLAEgVlgBIgkUAuk2bAo2FFQJGb6wC4So7A7EA1wUggPEC6fwNAbhPCAJtHkkD9Y29AqrP2gFKmkUBifYxA5ogZAB9SmkDWVU9ASLlsQM9fcEBmFa8AUl41AC+e/YChtEmAZY6LAFcRdYBDQxYA/uZpgH8z3ADO05TAeJ8bgC0YPwBD3UhAqPcUgEoARsHJKSmAaNjqQY7kEYDvqYSBGr6QgLEQTIEALMSA+xoAQMqmSMBT2+oAG6vqAApaS0D2g7NAaPpjAIqAXYA6UPDALJSnwF3V3oD0+5aAY8jfAIYjKQA+9csAoRGawFk41ACW6k3ANcqMQBytFUBDugbBavVGQI9sHsGHoUYA9+/PgRcRpkCtCpoARa/4AHHyIwD+OolAoI5jQDDONAB/YJGAx+t8AEc3McAbmRzAYPl+QDk6d8BJNjRArGx0QGkLaUC32FyAIlhqAPg3qwApQ0xAdLrzAH7BBwCRaCXAOi+NAJS+F0BK9dNBa6vswGfMkIEeDDQAj6p0QP/0cgA4LssBUiiUgAJsI8DEkzBAQo7pwEYK5oAHL6+AI28gQDo68sD6QBtATVBnwA8WOgBeP2WAvvpgwHGbikBU01HAccWOwJp/fIBFAzPA+xCvQBaxsoB4ax/ADUWygA45oQA7lW3BGy+KgLyRK4FbOSaAMixegUioLcBsDBVA1naqQH3mE4Eyf5uAvMzKwCOYkEBPpEWAEZqXQDoimsBbrM9AdKB2gHy0VwAI1rZAbaPagFhZdkDcfrdAazMBgA8lqMASawsA+5uUAHsTJkCoIz5AJXo5QCFHygBm6R3BHAz1gKA5AIGPiLzAmrj9AOtasgBU5lGBTEjEAL5StgC671CAZn5DQDmsgQB3CnuAHbjeQFdV4wC/XdcAEnv9gJ0V4AAE9ORA7Au/ADlW/YBRYD3AclNNgEICwkBmGCmANnWrQGFwAIBAM8AAL2uawGMhmQAi8HzAbZmqwLqmjMEjQV7ATuoWQHZDlwBEtYFAdOn/gIrBsoCdxLsAfxwuAO334sAKLF3ArV7WgGvpbAA903CABvqeADnANYBOiceAH1jkQGDREQBjd74AJl70gNtf5gB5CHWAYfdxQCJYQIADI/MAVApvABzT4IBSwOEBJevuwF7jQoHfMCzAQpnxgSUBi0C2lW7BeUSsgFHtpgEAsa4AW1w4AFhoeYA/mMmAzmfxQCXQtsAO0WPAbhw+QB3iC8BeoKEAKhHXwFxsCgB6LmtAM9ddQFEnWwBZQWTAjBhIQBZQW8C9h6jAXvZ3QFm+tgAs65LAjg3EgDjBewF5NWtAMlt2gEx6e8CHTeeBRiyagKab7wBXn6MAsQf7gFN8BAA1fIZASZHqADNul0CMNOMAdoAtAOFdqUAoJOGA226IwHG8yoA85J3AIbrowEE8YcBwC7BAma0TwHgBLgC8XaCAJKHsAHqbx4AMkLVAihgewJ4XioDsb/DAS2CKgR0VAgB6DHWAu16bQIFR1kB7NN7AvQNMAJ2lA4AchxWA0rtGQGQ5RACgGQ1AYWWeAKnnTIAF0hoA98xDgDsexYDlrmXAalQuAGGthQAKWRlAZkhEABMmm8BVs7qAb+gpAKke10B7tekAkIRrwGoCzsDnSk9A0e8DgPCBokBFZMdAxNnAwP0guMDeSiAAs8vGAIiJCAAmLq3A0TKFADDhcMA3jP3AKmrXgG3AKABP80SAZxTDwHFOvkC+lluATEKWAIyK9gAYvLGAfWXcQCr7MIBxR/HAeRRJgEpOxQA6mjmBJddDgP08pIG1KnwAe9mbAaep+wCmdq8BJXpygEaE/oFAUeFAZwMPwGRt8YAaHhzA4H79wAR1KcDPXuEAfZkvQCb35gAj8UhAJs7LAGWXfABfwNXAV5HzwGnVQEBu5h0AwkXFwCJw10BNmJhAPAAqAOTvH8Ac2uXBEv9qwJZhMAEkRY2At9CNgbkuuUBJrbEAJT7ggFAg2wCfwGgApYxpwLG/pQB+gaDALv+gQFUUj4Ashc6Af2EBQCk1ScAhvySAiQ1UQGIhlIAzafuAV0ttAODKKEA/m9wATZL2QCz5t0B616/ARbzMAHKkcsBFHYqA3SN/QL9AN4EKvsyAjWp6gVPRNAAlMvzApAHhwAG/gAE+7l/Ak8IgQMlI0gB0iTcASgaWQCoQMUCAt7vAQFT1wKzn2kAOnPCALp0agHl99sDgHbBAMqutwGmoUgAyWuTAuyISgDp5moBaW+oAEDgHgEB5QMAQJevA8Hu5AH9+tQAu+15AkL7YAHFHgsCtl/MBMxZigI/3SUF/t8eA7Iw0wPwyFoBptFgAziC3QAucsgDPLhCADe2GAJttiEAq77oA3FeHwAS3QgAL+f+AP9wUwB2D9cBrBkoAr/BHwHtFZIDqsF2AWTqNQKC1HAARsBrBQfQGwK02Q8H5ZXoAovsfgSPCccBC0+1ApK2ygESbbYDMNThAkqjywCv6ZQAGnAzAMHBCQEOh/kAluOCAMwA2wEY8s0A7tB1AxX0cAAa5SIAJVC8ASUtzgLvWuEBHAMvAyngTAC686cAIIQPAQQzfQCLhxgA8/DbBKvlhQH11jIE5gvPA71+UwWzo6oB9DgYBbGk0wECEMoBYjl2AY2DWQIgMxgA85VbA/w0DgAjqUMCMB5YAbIbJAOkjLcAOr2XAFgfAABLqUIAQmXHARfYxwF5xBoBDU/LAu/iUQFdHAoDUsHwAcvBgwNdD1YAxyidBDLB0QAA8rEAZrn3AJ5tdAQlh1sA36+VBNtCAQFVPOgEGGAlAeF6ogHXu6gBnZ0uADirogDo8GUBehYJADMJFQM0Ge4B2B7oAnyplAAN6GYAlAklAKVhjQHkgykA3g/zA/0SEQAGPO0BagNxADuEvQBccB4AVtDVBC9UswO5eecGGdhtAaHdawZH78MB+R85B5OHWQG4F3MFAqOdAf9v+gAZObsBoGCkAC8Q8wAMjfsCQuq4ASgSoQCvBmABn6w0AhewtwGzwVUBfHmJAZYycgPbyzwBzu8FAQAmawE27l4CRZheANXcTQF4EUUBQqS+A8rqUQAmMSUCPJB8AohOMQam9zACXqT8BGiphwL85IYEP6ZLAlFJFAPO0goA6mqWA10iWgH9nzkC24VjAIuTtAIXF7kAKTkeA7xhTAAuu98D36wlASE+XwHnkPAATWp+Aj+YWwAdYpsA4vs1AenTBQOPy94BkbDdBgPnGAKyes0EIwGGA3tGlwZf5PwArIEXAi9a0QGV4FIBVIYeAt7ELgBnceoBLWV5Aid8+gGGLfICCPmoAYtsgwOOo6sAMq3HA1fejgHIX54AjsCjAQZ1hwBvfBYA7AxBAkMmQQHirv4A9PUmAPAy0AOgP/oAKdHvBHkjEwINIeYGAJ9xAmkUfwPjzWAAidKuArPUkAFYYpoBIliLApSicAFBbsUA8SWpAEI4gwEJyVMChP27AbBwLQLD+wAAxPqXA+3o1gGW0c0AHPB2AEdMUwHsY1sAKvqDAWASQAF13iMAcdbLAXl3uANBEyQAuUD5BJFZiwCGPocFZ+llArtUGgQw+YECz9ZLA86CTQFyr+sAqwKJAZyRugE39YcBmVa1AWQ69gFsxzwDUcyGAdYx5gGM5cAB3cH7A1CIDwGglaIDFicdAQZfSwK+Ud4A8VFaA2oxyQHz050A3oyVAUDbOAK89loBnzudBS/bNAJhItcAHBG7Aa6pGARbT6EB68jCBZKP6gDl4QcFxKgOAuszNQH9eK4AxQaoA8l1qwCjFc4AclVaAQ4pCgPBE2MAQTfYAqGSdAAfztQDP5IdAZ2egwFkpYIBqxeBA3w1CQEOwRIBGjELAbSuyQGHyQ4BUROVBNpiTwIpY48GXgAwAcT5UwZmlU8B6m6IAlGALAM/KSQCV9MKArt5uwBihscAq7yzAtEL7gFBe4ICM+o9ADBxFwIFVngBdrL1AFeByQDyjdEAynJVAJQWoQBnwzAAGTGrA4lDggC2SXoCkxiCANPlmgAgm54AQWk9BLDCCQGlWVYFNVO7APkodQNsA9cDM5IsBT4vswDC2AMGDFSIAoixDQNH87oBdBF9A9I60wFcT98AWlj1AYrRbwNF3i8ACvZPA8XZsgDQ4QsBTn6zAT0rfgBnlCMAgQilAvTwlAA9M44AUdCGAA+JcwPSd+wBjPX4AwGGiAHlizoFn6T+AHJVjQMwprYBj0ZUBVS2BwItNV0ECKahASSisgMsuLwAkhwsAqhaMQB4svEBDnt/AQbxxwG9QjIBxY9lArzzhwF6GBgCSmFXAHb7mgHtNpwAq5LPA4LE9gGHQHEBl+g5APDacwAxPRsBLYFJAfypGwEnhAoFWcnBA/p58AG6zikCKsZhBJBktwDM2FACq5ZBAvnlxAJne0kBTGhgAoG0CABoezkA3MrlAWX50wBWDugBtU7RAO/hpABXDSADd0kRAYVD6QBT/rUAt+xwATBAgwHw2PMDQMHiAM7xZAJjhqYB7crFBDYNUQIffGYDJ+SxAnW1HwXmoIYBdrvKBP+NPAN+Jr0DpcmWALx4GgE2uKwADPLMAoRC5gAiJh8BuHBQACAzpQK+8zcAOkmSApqnzQFkaJgDxP7PAawT9wDuCsoA75fyAF47JwHvHWYDCVyaAeRU2wOggVAA0FrMBe/brgGdZpEFNLJMAzJsqAVS3msC0iRtBHU6OAIHHRYE7KDHAJfRnQCJRy8Aj1YgAMbyAgDUMIgBXKy6AOaXaQFgv+UAilC/Au/YggFPKwYCp8QxAP0SWwGQSXkAPZInAT9oGAG3pXACfetiAFDVYgN6PFcBP4z1Ad94rQMNxoYBzjzvAubqXAMg7hMDo3GOAbB3JgKfK6YC7ltpAlg9wgEZBEQAD4szAKSEagEhdC4Cp1/FAInUFwBInDoAiXBFApVpmgHsyZ0AF9SaAYdS4wLhO90BXpXAAFF2NAEgK9cBDpNLAViceQINEk8AgNCLAZfaPgGbWAgB0rhiAxKvewNlU+UA3EF0BZX6BAFbjtwDIfdCAbnhswKWUZcARyjsA4k/PgAGT/ADtrm1AHYyGwA/48AAe2M6ATLgmwER4d8C2+BNAQ0sewGNgK8A+NTIAJY7twGSYR0Alsy1AP0lRwCRVXcAh8i6BAGA+QFSGHwEDVePAqcz9QF8l+cBz/DFAXy+uQIvOvYEE+noAn0SYgMM/h8B9LGCA2uOIwCrffICiwwiAaShogDOzWUA9xkiAWSROQAnRjkAdszLAfEAogCl9B4AxnTiAIBvmQGLNrYBPHoPAZo6OQE2MsYAhdMdA2qKpwGsa8cDbKHBAFlI8gPNc1kB+f6OBq/KXgNPWTIEBmlCAxn+/wLKQBcBTt5sAyb5SwDxfDIA75iFAN3xaQCTl2IA1aF5AvExiQDpJfkCKbcbALh35gPYIKMBz/vkAYk+gwFOQAkCXTBxABGKMgLA/xYA5BLFAUM3aAIPzV8DLyVCAjacPwU/UkoBxzVHAu5DfQIZ4N4A34ldAQvgygMI3IQAxibrAWaNVgA8K1EBiBwaAOkkCALO8pQApKI/ADMu4AFfME8DCK/iAN4DwQMuoOgB/l1pAg0q5gAailIB0Cv0ABsnJgNh0H8BLZW2AwT60QK6PBwCMBnaAah0zQN2EngCm3STA4M1bQEMCsoEbVOnAp3biQMFA4IBMaceAzufLwGAgJ0CXQO9AAOmRABT39cAllrCAQ+oQQDQUzMDzKtCATW7PAGYZi0BdprhAPD3iABkxbIDikffActSEAEpzioBicDdA9d79AHZ2rkDurrvAfusoAPCNBYCj661BrlkcwHSTrADGgfBApPVaANZyQoBT3tCARYhugABB2MCHc4KAOXqBQA1HtIAigjcAkY3pwBI4VYBdr68AP7BZQGr+awBXZ63AlwCbAGvXUwDSGNPAUlAgQL1LkEAUPF/BvSXZgMqNdACOmbqApmvpANX8iACbiYBBP62vgNxsA8GpzyBAmft8QBaTD8APkp4A3nDbgB3BLIA3vLSAIIhLgKbKCkAp5JwATGjbwF5sOsATM8OAQIZxgEp69UAVSTWATFcbQHHGB4Cp+zDAJEnfAHsw5UARyS4A0JVqgElIxoCgnxEAe6bIwM1yaQCwxZ1By8PzQIX4B0FfXGQAnUVtgDLn40A34dNALDmsAG95dcDYiW1ATIVigMYvVkBMDClApct9wCqbN4AUMoFABtFZwLLFoEBs/w+AtEBWwGRbv4D2qIcAN/81QE7CCEAuxD0AIHTMAJqoNAAcDvRAG1N2AIhFbkD9GM4B7GLEwO3HTIDU1kTAkr6YgPgKsgBv9nNA9EQpwBjhF8BK+Y5AP4LywNivD8BdsH7Ak9pNgDVtb0Bt0VwAc+rpQMubbQBelOlAJKiNAGZCwQDluNaAZGJYQI86SkBSyo3B2qk7AKXRP4ECYyDAQlqTwLynokCQrJCArB7xgEOPiIExFgqAZVfsQOXAMYBlP5xA+BaowF82fcAEhHgAIBCeAK/GQkBMd3NADHURgDW/6QAAtEJAN002wKr4PQBXTjOAfKzAgEeW6QB5i6KAbzm3AA5Lz0BbwudBLBbmAAc5mIEYFd+AsVZkQOmT2sC+E2gAR3p5gGVFVYGOgvBAIQlJAK4lvMB49RTAayXtADJqZsA9DzqAI7rBAFD2jwAwHFLAXTzzwFBrJsAUR6cAU9IIQIR520BjWsVAnwahAGvEDsDlck6AM6pyQDQeeIAFawOA5U9XgE3OZwDjDyRASxslQPtkZsB0FUfAr8M0gJiYl0GlhCXAs653ACN6ywBn6wVAkYaHwEMQF0CGzjGALE++AG2CPEApmWUA01RhQFu3tcBvKmBAecHYQAxcDwB2OX7AHdsigAnE3sCgjHrAIRUkQCC5pQBBkq7AAX1NgG42/EFEcLkA+/KZgRoccoAm+tPBBQJsgGbAe8Ex5Q9AnP30gMw3YcAOr0IASMuCQBRQQUDM565AXx0LgNJjA0B0VysApIXRwDG4P0Ccmy0AZA6MALasRgBm/88AZqT8gD9hlcANUvlADDD3gMerzIBidJ4A88j3gER+LMBAgplA5vC+AOdzGUBZ/7FA04+BAKxrGUBYJL7AS4KnAACiaUBcwTnAPLXAQATIx0DKqFPADuV9gH7QrAAyCEDA09ujgHDoREB5DhCAXovkQKDBKQAQ66sABn9cgBXYVcB+txUAGBbyAMkfTsAAEF2BKA08QHsrAYDr7//AQBBggLevuYAZf3nA5EjbQL5HU0FMAATAmhamwEWViAB2dVBAG9dfwA8XakDB3+2ABG6DgL8ifYB1BkwAkvuAAH4XEYDYuCLALgJ/wEHpNAAzYPGAVfWxwCC1l8A3ZXeABcmqwLEbtUAGHOMBtWxdgBgNEIFdJ7tAg1AtgMtP64BnV++A+DNsQEqBY4Dq2PUAfS7kwAdM5kB43QYAh1lzwAT9pYDhecFAH2G4gFNQWIA7IIhAwRuPgAybH8DBnEWAJEUUwLBoecBgrU8ANnRsQHklNQCAoO4AHWxuwEcDh8BsGZQBDFUlwF8HzYHE52FARKziwHg6BoCIXWqA6b8qwFIjc4CgPojAEhP7AHc5RQBKMqtA2JM7gHFFuADa8bDASONYAHsnjsBaWRXAG7iAgDQ6t4Aml13AUlwpANCWwIBFJEhA2XWiQGu5mcCovamAF33dAKm4BwByQI5BarOVAJ65BEDGnh3AnYLkwWzL+EBZ8i5AqQCcgJMTtQALZqxARjEeQJRnbYAWhC+AQyTxQBf75gDCutHAFaSdwOrhtYAPIPEAKHhgQAMgngCXsgzAGnn0gM5CZQBKqjdA3vtjgDG0zICLfVnAKT4VACYRtABtHWxBEVPuQDzSiAElJzPAsTEoQX0Ne8CDl32AorwMQHDWCQHoCZ7AG3InQGuTGcBrKkiAtcBqwFxMxEAiOTCAG6WOAJp9p8AE7hPA5VN8AGbUKIAADWpARyXVgBEXhAAXAduAmF1lQH4TeYD/AqMANZ8XAIidusARjA5BRU1pgK3kD0Hsf/CANb4PQY5bvYAeRVRBqQD5ABqQBoDROiGAfLcNQIt3FUAcZX3A2CzZwG9fwsAh9G2AF80gQGqkM4BecjMA6dkkgApkJUCRTwoAHo0sQP102UBre0IAAczeAATH60Afu+cAY69ywDEgFgB1oXiAx19rQHIbDIEemQ7A/yjAwXclLUD1Ig5Bty0iQHOWDYDGyH7AUPWNAHS0GQAUapeAJEoNQDgb+cCIhz0AeHHwwLtEeYA2dmkAqid3QDHLqIBx8+jAWtzogEOYLsBdTxMALifmADR50cCKaS6AbmZMwLcq7YBj46tBOovwQAHixABX6RAAQ/dpgTaxRACgx0sA2NFdQE761gGJlGtAke+PQO6WJ0A5wsXAO11pADhqN8DmXJ0AaKY8gEYIKoAfWJxAqcTTAD+nNwCmjQFABNvoQNGWvwBrG7wAArGeQH8//ADQXvSAN3C1wJ4oxEBuwdjBL0xtgJyCYUB6BqKA9NEhAQrd3oBsmIzBJRaagJGMuYDCZl2A55GGQClV80AN4rqAO4eYQBxm88AYpl/ACJr2wJ0cqwBS7T/AvE5swHKIqwCN6IxAVID/wNw3b0BuxnkAg9YWQFGHMYCFRGVAfJ5/gNqymMB9s0OBdsvmQJqiScFYDHCAZQzxQK5OgsDaSvoBccGDgG0hUEG2+SrAWg+5wHj6rMBIb3UAvO7+QC+DVABglkBAN+FrQAJ3sYBQX9KAKfYXQGIqMYBQpEAAERmLgGsWpoA2IBLA58oMwCeERsBfPAxAOzKsAOWfMABE8G+AF+2PQCjk3wD/qUzAxooEQbVYE4CVZHaAh4kygFVCQUAbynIAe1sYQA5PiwAdbgPAS3xdACYAdwDnKW8APoPgwE8LH0BQNz7A0oyuAA1WoAD5lDCAYeBfwEVErsBLDqhA0aTIgCu+QsCIo0dAO9EsQNybjoA276xAVf1pgG9MfcDkVO4AawOJweQ12gCjd94BJTImwHTz5EBELXZAq0gVwP+I7UAd9+hAcjfXgFFBroDv0NVATGpmACQGnsBN/OzAhNEiAAUjLwC/NAFAcdzhwErrOUBm2i7AJf7pwA0hxcAl5lIAJPFawKTngUB24/OBH2ZiQFXmMUGBUSnAvufpQPuTjYBFz83AyXeXgLstwwHzMzSAgAn9gIdSucAh2wdAbNzAAB1dnQBhAb8AZCBoQFpQ40AUiXiA+3i5AHM1oECoXtkAbh56gAtbOcAQgg4A4OIgACs4EICrp28AObf4gLx20UApQ53BVGiOAByexQEoWdVATDvYwaah9cCbv+nAibE1gCQJk8B+ah9ApthnAMWNNsBlRaQACyVpQEnf7cAxE3pAXWB0gOph+YB1XfGAOnwIwDqNAcDdGYwARTMmgOyiLEBFgIDAZWCWQH7EZ8BRjwaAJBrEQC0vjwBJbY7A21HNgPEEoEDlOBXA90VmAOJFrYB+ZzNAOwt0AFOlPIBZUbRAlROrgBlkKwBl4jtAb/CiABxUH0BmASNAJuWNQPDdPUA73JJAhJSEQF8feoDJzS/ACrSngOahKUAsgUqAUBcKAEjVU0DseR2AIlCYAJy4kIAW/BFApZvUAKmruwD4mxrAbvyQQe1Uf8COM61Ay4itQPT8J4BR0tfApwoGANl0lEAq8fkA5kiKQDjr0sAFe/DAIrlXwFMwDEAdXtXAePhggBqPj8DAcarAP4kDQKQus4AlP/0AyIApgAeltsBXOTUAFzGPAI9hcgBtik7BHzubQGzo+4Fi3pSAggWWAPEnS8BmF45BFcetgJToVUEsZJ8ApOmBwMU0N8AnLbyAJt5uQBTnK4CmRB2AblT6AHfOnkBHBdYACN9fwGqBZUCowyCAZrEHQChYIgAByMdAaIl+wADLvID/9i8ADmu4gHO6QIAJruIBnm9CQHIdX8DuSTMAOcZ2ARPTmkAE4aBA5PLRAKMUX0C96XIAdaQhwCXN6YBJetbABUumgDf/pYDIpm0AXywHQErYh4B13rmA+igDAA5uQwC73EHAQQJEAIZW2wAbcbLAAiTKACBhuQDe7ooAXFihAKlhBcAUEUsBAjy7gG3NTsEg4FmAzIg8waR38gBelOzAoaQyQGMJTgFljzjAVpJnAHLrLsAUJcvA12J5wEjvzsD4NG1AUnX1QIFdrMBmDbBATIA5wBonUgBjOOaAbXiEAJf4VwBchSqAgX6TgD4S60DNFkGAf+zdgBIrQEALQjOBa2F3wK4PoUD1QtiAsQf0ASqp/QBFee1AZbauQL2qWEBpYv3ARx4lQFn+DMAPEUcAhizxAB8B9oCOWtRALjpnAP7SiQAdrxDAI1fNQHLXqUCLT01AM47cwMu7PoBSQUgAYGa7gFpIOIAebs9AQKm8QJCqqwBCtiyAxbJ/AL8bvMEx305AmzAYAMzc+4CJXnzA8g4IQLBdoIESmAZAZce5gImP/0AJC36A/oB7wCg1FwBLdHtAPMhVwLsVMkB0xKdAtNjfwHZYhACiqzvAKjJggOOwakB7ZfBAddoKQDvPaUCAQPyABbLsQKwzBYAgoHVAh4LKQP+nnkCnxlyAaFQyASclwsCmYZOAdg2/AAwZ4UEaNzFAv2oTQI0sxcAGHnwAf8uYAFqPIcCYc35AT75dwN3O9MBcbQ3AlpV7QCC1E0BOEkxAFbGlgBd0aAARc22A/NaKwAUJLAAenTdADOnJwHnAT8BDcWGBALRIgOFO8oEpmROAi7fTAS4PD4CsaZ7AYQMoQM7risEwkWQAH8vvwEiLE4AOeo0Af8WKAH1XpIAU+SAADxO4AP/X9IBmK/sAJ8VSQC0c8QCguFqAP+nhgCfCHABd0TCA6/ExgF1MKgDXKkBAHDIZgFKGP4AAI0EBow+PwKCs7sDTJybAXZWpASp0JIBz4WaA5ObOgOgeOgG+tWbAt4NKgBeMoMAs6pwAIxTlwE2d1QBjCPvAZgtQwHsrycANpdnA50qQQGx74cCVTXLAJVhLwLXIxEBRQNGAWckWgEnGq0AuDANAKPb2QNQBgEByqpsBufQXQBkyfkCVSQjAdCaHgXiyfsBAb2nAmM5AwIMgCkExGRLApbM6wOQrjsAePiVA1Q34QBy0jUCxsx3AA73SgE/+4EAQ2iXAYeCUABPWTcDdOadARhgjwDVkQUARfF4AZXzXwFxKhQAg0gCAJo1FANIPm0AsWaYBCgMzAF5JgsF+QqRAs59lAT19N4BKCBVBW/VfgKh+VYFRsZ/AVEJFQFiJwQBy0ctAUtviQDqO+cAIDBfAcsfcgEdxLUBMvGnAlxtjgBokC0A6wy1ATNwpABM/soBrQ6iAD3rkwEqQLkC6H3ZAPNYpwJJMQgAdsxCBHvWewIl3XYFkXDsAHJisQSWWccCVsVwBLiVoQIrYKUE97MUA7zb2AInPg0A846NAOXjzgGryiMDdLDhAVFuJgEq9Q4BE1NhADGrCgDfd3gAGeg9ANTwkwMDczgBkBHvAskR+wH4EvUDYnXvALgEswP17TMBEu+JA6VwpgFQvCEHt/qOATW7rQTPcMkC9SvkAWi4WAHTNMQDMnVsAf51mwAuWw8BVg6QA1bjzABTGlMBn0zjAJ8b1QEYl2wAdZCzAojRUgAmnwoAc4XJAN+2nAFuxF0BODzpAAWnaQGZxaQAYCK6AZKFJQHcY74A7qZUAxORqwLBxfsCXk6FAfv48wPgXYMDuYbEA9eZqgITdp4CiwF2AlaeDwEt0ykBkgFkAnB0TAHSf2wBZw8wAMEQZgFFM18BaoCdAImr6QBafJABaqG2AK9M7AHIjawBojpoAOm0NAHv/Q4DoXH+ASXvigIzLqYA3mUhAoK6nAJu0D4De16gAR6s/gRvrjgDumMbB0GK+wJ8OoAFm5iuAbIM9wP7VJ4AUsUOAqvIUwEkJy4Bas+nABi9IgCDspAAztUEAKHi0gA1M2kDYC27AU243wOvHfsAT6BWA3MlsgBSTdUBUlSNAeFl1AGvWMcB9V73Bat2bQGlub4Ag7V4Alb+XQOF8EkBH/WPA4qiZwOxYhIC2MxwAIDfeAM0CvMApoyWAH1QyAENbdsDWtoBAfv8LwJsnHQBcjF/AcxX0wGBytkDGVX5AQ31hgFMWakB8S3mADtirAFxSYQCTZsxAZ1+VAAxrysB/bVUA5xnIwBowW0DQt2aAMmsAQYGolgApQEdB3ub5QEdmtwFZu9cAskBbQPJxgEAXgKOASQ2LADr4p4DqfvWAbhNCQBhSvIA26OVA+8jdgHfclgCv8cDAGolGAPIoXYBYFljAeA6ZwFkx5MC3TxjAOoZOwE0hxsAUwNbBqbY6wLk6IgEZzyBAi2o7gQmv0MCSqMvBI5hYgM22KgFp+n8ASNvFgNbVCsAGshXAVv9mADKOEYAjghNAFAKrwH8x0wAFm5SA4ABwgALgD0BVw6RAfzevgEPSK4AVaNWAjljLAEsGLwCGc0PABPl0gL3Q8MAPUe4BJnHJQOV83kDJTNLAchVggIrQfoCOJPzApErOwFYHDUEIFQYA7MzEgK8RlMAC5yzAWKGdwCeb28Ad5pJAcc/jAIsDQ0BmcACAlBIKgAuoLkCK3AGAJLXlQEasGgARBxXAewymQGygPoCzcG/AaVciQI0KO8AvwHMAqetIwKM8y0BJDJtAw3ywgPin3oBr6/KAkU5SAIn3zgEz6I6AaRiXQAPbwwAHghMA4N/9gEs8mcARbUPAQnRHgADs3kA8ejaAXvHWAEC0soBvIJRAV1l0AFnJC0ATMEYAV8a8QGkorsAJHKMAMpCBQMkOJMAhQvzAX9V6AH5h9QFuLFxAlncSwNE+JICMW8yBFsWUALzJHMGoWRSAQbBBgF/PSQA/UMeAkDsqgGgEdcCPq+MADd/BABPcOkAbaAoAI9TBwEuGu4D2KmMAU1evQP/kr4Bkke6AmlNfwHonekBh1ftAc8N7AGbbSQBoWTaALSjEgK9bgkBET97A7GItAOke3sDjrxRBkXwbAEYcAsD4tozAacy6gNxT2wBHhNzA7bwYwDjV48DR9n4AWWpXwGBlZUA7oUMAePMIwC9cxoBZgjqAHBYjwGQ+Q4A8J6sAmNwdwDCjZkCJzhTAXiwLgAqNUwBi7+aBFrRXAKsDRAFBEjiAcv+lQRPuM8AZAl6AnVlqwH7ywACn882AiVI+QE4jA0BCUBrAlplNAHgtfgBi/+EAOaREQDpOBcAdwHxA9SplwFjYwkCuA+/AaxnbQGuDfsBsVgHAho7RAEJIQID92E7ABoekgGwkwoATHnPBbtYGAK4Xv4GcTfJAhcyRgR3NQYCjUKSBOPi+QFnwN4BrUTbAqK4JAOOZokBnAsXAH0tYgDrXeECN3CgAUV08wGZ+TcBgCcRAfFQ9ABXRRUBXuRJAU1CQQPB4+cAPZJXA6ybFwFvdNsC1yYLAYK6hQBe1LsAUS9bBMv+rwHdEtcCrERsAeLkTwMl3dUAo+OWBh2+EgKfswsBClpeAdyuWACj0+UBxog0AIJf3QGLvOcCinGAAXSr7AIw3BQBOhSrA+NtvAAB4SACwhCuAOP+iAGHJ2kAlk3OA9Hu4gA31IQC7jl8AKrCXQP4EPcBGJc+BwiXCgJOi7IDd/LKAhnb1QQ9fSMBjwJsB+QhUwFQLdgB4D4RAMPZfQBimZkBsrBqAoJdigFsPiQDsXkgAXf8RgDc+CUAzFhnAYDc+wHZ4wcBajHGATs4awBjcu4A3MxeAUm7AQBZmiIATtmlAQ3D+QMI5v0Buof1BBn8BwFTzRsFhQJwAiSeIATmW+0BvqrMA5cH3gJswDEEwKaSAegTtQNojjQBZhAbAf3IpQDD2QQDM72QAXqboAJWgjYBTXg9Aw04KQAZKX0DVqj1ANalRgDUqQYB2tPCAkddpAHEIWcDKo6NAIPhrAD0aRwAMUThAIhUDQGBOSgGiU04AFSWNQQ1X50Cjw2xAl5zugJ0F3YD86bxAQu6hwCyassBYNpdACv9LQCkmAQAi3bvAGABGALqmdMBp24UAzHvsABfKegAwfo1AP6gbwKHeikBYGxDANeYFwGL0dQAKr2jAMoqMgNpar0Bq0TZA+g6dQLk3PMFxAMEAiR4NgYCnIYBIz2rBqOIZAHT6A4EWa4KAsXGQQMLA0AAdHFzA/dnCADnfRIDnxzFAB64IwHfSfkBehQuAoY4JQGaDeUBd6EiAfQ9SQDNfXAAiWiGANn2HgHsjo8AQZ9mAWukvgDbda0BIiV4AsdFUAAffNoCSRugAbmaxwNGx/wAaFGfBRDIJwLSPcABGu5bAJTZDAA7W9UBClG3A4DmegFxy5EBd7RCAUeKtADglWoAd1JoA8+MKwBiCbYDzGWGARFlJgBfxaYByvGTAD7QkQGE9vsAAqkOAA33uACOB/4AEcgXA1fN3wJagTQDFLoeAo7k0gX26vgB5UUfAq+6hwHtzTQBi08rAv6v2QIf80MA8m/pACwjCQHiclEBBEcMASVpvwAHdTIBUE8QAD9EQQGdJG4DTPEDAeEt+wGOGc4AeHvRARz+7gEEgH4DWt7XAaEPvwBW8EkAdLlRBirxowLT29IDb6KbAs5ldgSnSDgDwgU0BEes8gF9Fp0HkGA7AaJ5mAKLEF8Aw/7IAlGWogB3K5ECy6xOAaXgnwBoE+0B9H7QA+E71QB12cUAmEjtANwfFwINWucBu9RAATxl9gFUGFYAAbFtAJJTIAFLtsAAZPHgALntGwG3ZVIF6iVNAfyGEwTn9noCO2qzAMMLDAJsQusBfXE7Aj0opACvaPAAAi+7AzEMjQDCi7UDhvpoAGFc3gPYlckByvF2A06XQwBnjtoDlPXvAIoqyAJPJWEBe3CnAyOKVwGBHZMD8FdOActhEwGx0RYB0eN/AmJ3UwPSGcYBELOzApBNrAZXmQ4D2L2nBGrpOwMhIfMCK3BwA6F/TwHMrwoAKBWKAmd05ADHX4kDhL6oAZGl6gG3YycAt9w2Av7ehQCP23kCPu8GAOFmNgP6EvYABCKBAYckgwDOMjsBD2G3AKvYhwNkmCsBg/tbBCWRXwIhzCYGsIxTAxeB8wNLkCUCaSQaBnSQrANCuuUDaqHVAS6jRAOUqv0AuxEPANqgpQGqI/YBYA0TAKXLdQDWa8AB83uxAWQDaACy8mED+kyCAdJNKgH6T0YBPvRQAWll9gA9iDoB7lvVAA47YgOmVE0A64MuAjivxQG4PrgES0DPAKyv0AKuSiUCiRvTApN9wgAKWVEEp8tlAxjV0QHr9TYAHiPiAwh+RgDifV4Cm3UUATj4cAHmMEABo1ymAeDW5gEReI8ANwgrAfoB9QFqYqUASmtqAjQENgFZspYBA3h7AfMFWQFy+j0B65lSBUwPEQI47loBX9/mAus0LwZllKQBeM8kBREQuQNJFEoEugtlAi4wgQMV79IBTOyBA25NzAE8SGEDxtn7ASnXzACFkckBOOaSAetkxgCSSSMCa8YUAbVP0gNRZ4gA9mywACIRPAESSnICp6pOAZzvFAOUKagAJ3kcBE6zhgPleYcDrdFiAfJ6vgCrps0C03QwBBxsQgGh3rYBDncVAsIn+QP93+QBtqXGAIW+MAB80G0Ddq9VAQjReQEwq70BwkeGAYjbMwG2W40CMJ9IACN29QNvuuMBOokfAIksowByZzwCB9WWAKIKcQPBaEgAyYN0A7FPXALK+tUCXMG9AYH/IgbSvJcChxEUAxNlUwPSzqYE5O5JAZdKAwOnV9cAm7yFA6WBSQDwT4UDsdNRAcpIowLAqKUADqTHAh3/zAAuSFsBpkpmAccqAAPBceMBQRfQAOXYZAEX7xoACuk+AXoKsgEaJK4BZNvHAS2jvgIPqCoEpTnGAxoaGgR9pecC+mxkAzzleQE5dooATM8RAg0icAJYEKgAJdBpAyLJ1wEnamUCBe9yAChn4gL1f24BPqc6AITwjgAFnlgDgEmeAV1ZkgDmNpIACC2tAE+pAQBzuvcAVECDAEPg/QPOvUAAmhxRBSy4NgNV1OAD/19JAYAh6wUzQlAD+a6bAwOzJQLppF0GW6/9AMZFVwPfai4AYx3SAD68cgEr6ggAqa/3ARZtiQPkticAwKVeAvRl2QCsWGAAxF5jAWnuCwI0fvMAXgFlAy2TAgDJfHwDjAzaAA2mnQEw++0BiPp8A2mUkgG1DcoEGz2nAtiYCALbgi0Bx+b/BTZBVwFcv2EGcPsOAg1pXAEaz40AGM8NAhQyMAG5lHQD0ivhACUiogKj0ioBQxdgA7XWCAH1dYkDQcMyAEsMUwJPjKQACaUkAeRu4wDxEVoBGTTUAAbfDAOK8zkA5nBLBfW3vwHUv0UD5Q+OAgDDxAOJqy8BPz9qBQ+p1gHOrjgFV0mFA6OFjACxDhkBkrg1AwnjoQF32PQDSE3pAJ3uiwE7QekARvvYASm4mQENy3AAkpP9AFdlbQEsUoUB85Y1A12Y6AE6XScDV5PcAU1RDQEgL/wBjRNyA1xrJwN0ENMFuHfRAeLbfwJXaewBoW4XAyOmbgFa7N0DQep0Am8T9AIJ6RoAILcGAgG/8gDanDUCKDxGAafsbwB5uX4B7Y7PAzZ+NADcgdACT8ykAUIXkALZKGwBfsqkAMshAwEBngAAJWC8Ab8xSgBtBAAAXKcKAlrahwHKQq0DlcLiAsj9BgOtZnkCzL9uBDTCBAJQKC0CImaPAQxsxgMPG+gB+0e6AbBucgCOA3UBcU2OABOcxQFcL/wANegWATYS6wAuI70D69SBAAJg0ALH7scBOq+kA5Er5wDC2TQDAt8MAIo2sgJU688A6M8iBDA0MgGlcVkDCS3YAT2tHARupfYCdXNbA39UPAKmkMsEVg3zABYe5AGxcZIBgKrmAvuZgQGQ4SsARucFAXlpfgJV9pQBbSWaAtADWwAxkT4A5BClATbd+QKx0lsAU5LiAkSSugBd0mgCDxmtAOe6JgC9eowB6A1wA2huXQD7SKoEvxffARcDygXgXeQCmJPHAmyqFgL3ZfYDsXwMAZ/+ZgI2BEEAfda0ALdgkwAtdRcCg7/5AI+wywKHtzYBkeqxAJJlVgEZe48BIdGYAMBaKQJSD30B1KxSANepkAAQDSIAINFkAVMS+QHFEewBxrrmBDCgsAFudmED7GjrAk47XAJE+QsBIqxKBRJ2RALdfKUDs0IjAUOu9gArSm8BfZBWA+PqWwDy1RgCRCzrAdu0IwAI+AcBZS9cA+/NZgFx5qsBH7nJAcH2RgN5EbsAhkbHA5QDlgF0P2cAQWh7AdM2EwEGjVgAQIbzA4c1ZwKoG7QEsDEYAm42pwTCPdcBHgFsATwqRgC5A6IDwZUoAfZ/JgK9dyYBPHcIAWCh2wEpy90BsfKkAfSfCgB0xAAABV3NAn9/swBq7fYDlKLZAVYlFAKL7sAACQnBAGEB4gAdJgoAAIg/AeRI0gIlhlwBO9rQBWckVAMKBcED8a89Ab6pLgWyk5MDb76LBnusHwICS/wC1iQPAq4bGAH/RZUBbYF2AMtd+QCKiUACJUYGAJl03gChSnsAwWNPA3U7XgE9DCsBkrGdAC6TvwAQ/yYACzMfATw6YgFuwk0Bmlv0AIwokAGtCvsAuNEyAmuCTgDktFoErQf6Ah6uPAQoqx4Cc2NSB3TBiwG6rcYC2W84Arl72AD5njQANLRdA8gJWwE3LaYCg5vLATnobgA001kB/ACiAQlXtwB+iCwBXnr1AFW8qwGTXMYAAAhoAB5frgDd5jQB9/frAYiuNQMiFcwBNOPWBedSwgALMOMDqUm4AcX7/AIrcCICgmWDB0aouwKDh30DiWhhAe64qAPyaFQBhtjiA4qQ7QC8iZYBUDiMAVWppwPBThkB2xG0AxANwQBiidQDjOCXADH0rwDBY68BEmOaAf9BPgGb0jcD8fQDAfkOlQCeWNkBis+GBvnoHAItnPsDqji4Ae4z6gSNioMBGP7zAQrJwgI+YUsE0e+iAsDIHwF11vMAGEfeAjUo6AFLt28Cjw5XAdVPiAPXxNQAhBuMAoIF/QB8bBMDG9dLAEzeNwLotj8ARKu/AjNv3gEJaU0DT6rrAI8YWAMs53kAboHgBTz2VAL8LtsD7kwhAjCUEgLlJUUCQoYWAo2bXgIendMC1CoeA/Hj9wL7sA0BJgAfAvD0/wGpLQoC/N75AN5yhAD/LwYBs6OzAVRelwFZ0VIC5DSpAdTsAAHWOOQBhneXA2/JwQBToDUCBZdCABKiEQDpYVsAcAVOBbR4NQF0Xz8H63W5AL9+iAOPd+kCtjlhBS7JuwGmpXcFLGR+AhViBgKQll8BdzaYANFiaACPbx4Ct5T5AOvYLgD4ypQBOF8WAPLhowDW9+gDRqsTAWb0MQNTZ10BQ3n0AVLgDQApTysD+M6nAdY0FQK/IBYB5G88BGRKJgEVW1QCHBwNA8Tn1wLzmsgC3ontBNKEDgJeQM4DED73AdaDeQFdF00Azcw0AlC9iAC024oBjxJeAMwrjAK7r9sAb2KPA5Y/ogHAMkcCEpI1AJItUwKxUu4BD4VUA+HGXQHIYRQDd3YjAXEy5wOh5ZwBwBoMBHEncwHN1IYExNmgAXOBXgLG19sBSt/5Bfx0tQPm12gD44L2AaZ1VgAOBQgA7x09Ae1XhQF8kokCy6jfAC6o9QCaaRYA3NShA2pFGAF22rUD8FTGAYF60wOMCJkBvbF2AGBZsgD/EDACeWBpAXQ26AMhfmkBuUOmAOg0igHSkwwEGDYHAisP1wYx7C0CvUSBAWqT4QIbXS0C640PARE9oQDcc8AA7JEYAm6oqQDgOj8DfqS8AFLqSwHgnoYA0URuAdmm2QAz4aYBu8GPAQ8HWAMJzYwAdcCcARE4JgAbfGwBq9c3AV791ACbh6gB0LKZBphESgLnPWACaIQ7AiBMxwG9sIIBCGgZBknGZgHoAXAEa9wUA1/mRgCMwoUBOJ6kApEGUAGoxGEBVbeCAEae3gE77eoBXxkaA+evYQELefgCVyPCANu0/AJJCOMAw+NJAbhuoQEw6aQBgDUvAFIOeQPAvjoAHa51A4MXIAInCoYFFTMZA+4LsANtOZICdI/vBZxldgE1VEwEzLgSAS8ESANNcFUBwDJCAV0QNAEHaYYADG1IATmc+wCQI8wALKB1AjFrwgDuQ6UDbm6iAJ5TKAJL1uoAOtjNA6pgkwEn43IBsOPxAEb5twGIVIsBKXr3Ao4JdQGwrokGR/ePAuu5fgM9GfcBLEA4A6D0BgIhOTgFaMpTAm2T0AAGZwoBSYpBA2BQZAHVriEDMYZKAW2XggJuVKwAVMdLAvc7cAH117IBCbdfAO4bCAKpzdwAw+WHAGJM7QHhWxoBUtsnAeC+xwHZyHkBPrMIA4tBzgKxz1cC+fwuAWdZbgH9vZ4DjtaeA5/1NgMzt1wBFcjCAX8hcQHRAf8A62orA6Y06ACd5d0AMx4ZAPrdGwFBk1cBTnvEAEHE3wFMLBEBVfFEAMq3+QNA1NQBCCGaAUc7UACvwjsDjEgJAGSg9ADm0DgAKBlLBk7CwgASA8gCn59zAoOP9wFvXTkDOO0LAYbehwN4o2wBeyu+Aei9zgJPtkgBz/bgARE8CQChzyYAjW1bANgP0wOHTm4AYqNoAxRQeQGasrcBf48EAGg8UgLVEA0BX+4hAZ6U5gF+gT4DMv/SAT2N7AKcN+ABcif0AMC8+gHjTDUEYVRRA6vLPQKSMjcBy+u/BDPF9AJXK9MCGr93ALznmgBCUaEAXMGgAfrjeAB7N+IAuBFIAIWoCgIVh5wBKBlnAy/KOgCnlVEDu4bvAOu1vQLYi7wBSTBSAC7a5QC9/fsAMuUMAdKNvwGA9BkBlud6AlUvvQGDtxcDJLKWATKJ/QTHTh8CFWkyBIE8AAKDo1sGFee7Aq1P7wCdZqQBv1IUARi1ZwHvCeoAAXukAYTpAAPJ8vIAPLr1APEQxwHNdJ4Cvn1bAd9WzwB5JecB4gnGAw6Z7wF46NkCSnBSAF8MOQIy1mkBgdxhBcZiJAKb0QwCCdQ0Ati0NwbSqugB1xRUA5z6hwCdY38G/80pApUkRgE2xMkBVnQAAuqrlgAbo+oAyoe0ANBfAAJ6nF0Atz5LAInrtgDM4f8D1YvSAQFzCAMcDG8ANJwBAP0V+wEkpR8CC4LTAGoSNQIpY5oADtk9AtcLXAHHxXACkibHACT8eAJqqU0CAHufB81LZgKir8QEKwHwAHi6sAIMYkwB7HzxA+eSvAHHYOAAzB8pANDIDQAV4WABrpzEAPfQfgAruPQCAatRAFVzngA2QC0BEopyAIdHzQDjL5MB2udCAP3RHAD0D60B8w52Bg6W0AO3FjIHVHDPAUpx1wU+kisBA+ETBuEXPgEN/9YCLAjNAUTFlwLRUtcB9Pj3A3/4RgDh91cAWnhGANX1XAANheIAL7UFAVyjaQEGHoUC57I9AeWVGAMRMZ4A5GQ9AnPz+wFMS1wBUduTAUuj/gKM1fYAwiWYAmAsZALIJTIF0/Q5Aq2rtwf3SnACpZweBN3dYQHyXUkC+mVkA9jZXQP9irsBjb40AzrLsQHHXjQAc3KeAaSYaAF+Y+IBdZ30AWvIEACuWuUAeQZYAJwgXQJ88dMBDe2dA6SaFQG34BYD+RiYAXBNHwD3qxcB2rHMAzOJkQHBtnIE3+qVAglvZwXIgQQC7Y5OBDMGKANs1aUCO8/9AivXRQBgYQABMC3KAHh5FgHqizABxi0iAbUyGwGD0lsBLTaAAK97aQHGjU4CQvTvAfQ2ZwJNJvIBAVz5AvquVwGKP5AAGGwbASFmEgEiFpgAL+V2AjGPYwKPqZUFdR6YArEIeQEInxICWWXmA4AddwBEJAsF57c3AgT/YAOgKcEBPoveAA+z8wD/ZA8DUTWHAIk5lQFj8KoBFebkAjC0UgEqUisAbvXZAMd9PQAu/TQAjcXbANOfwQA3eWkCthSBAKl3qgPKsosBdCi2A6sNygFAspQEB88rAHo1fwVJoTAC4taABlQL8wFjVgcF9ESGAT0rFQGYVF4BvTz6Au526AHViCUBcUxrAVxoZAGQzhcBbZaaAeRnuQDaMTIChk2LAbgBTgAAoZQBYB3pA86UlQGfqAAAW4CrAQUcEwIKb/cAFLuWA4nolQJ0PkQDPti8AerqIAYbOaABGAzxBag8vwIfg40D7J97AUvFXgJz/gMBW7NhAnhhXAGpcA4AFZX4APjjAwBQYG0AS8BKAQxa4gGOakQB0HJ/AXEq/wJJGkoB9rOWAniMPACTRsgD1SihAaC8yQOMQYcB33P8AD4vygKzlf8CgTftAqQRugMJqcICm23aA2+MewFngN8CsI5sAWYl2wN/TRIBbmwXAVvASwCu9RYDA+w+ASpAmQHjrf4A7XqEAX9ZugF7UoAC+1SuAFqzsQHz1lcBZjyiA8+CDgEKgosAzoHbAV3ZnQPu5uYBYXOfAqNrXwIy2gIB2H3GAYvKgAYJX0QDNQldAq2ZBgPKrGAERKBuAsImMQIaUNUAdn1yAEZGQwEOjkkDgnq5AfIUMgKB7SgA0p+MAcWXQQFUmUIAw35aABDu7AF2u2YBAhiFA7pF5gA4xVwB1UVeAU+K5QHOB+YAy2/mBVrpdwEIWQcFAWIBApNKhQcx9rQB47FwBTm9bAHBy+0GE9HDApMKIwFWneIAH6OLAjcHSwE9WnQAtTypAIqi1AJQpx8AzVpwAyBw4wBAl3UBseBJAa2Q2QPlzE8BFU3oA3FO6gDgOX4CCDGNAPKTpQFotowBlIQMBXpEfwLgVycF+mwIAsXBjwF5h88BqxZGBDFEdAFkrygH9mnpAqbLBwBuxdoA1/4aAqfi/QAfj2AAC2cpALeBywJj90oB1H6EANKTLADH6hsBlC+1AJtbngE2aa8BAU6RAmWaXwCAz38CM3zsAYFURwDd89MAharPAN5qxwC3VF4GWsg4AYm2cwWNYJIChIjkBGASlgI2+0IEi2YEAspnlwAeE/gBMrjPAMrGWQA3xeECqF/5AUFBRAO76n4Apt9kAXDv9AB9F8IAOie2APQsGAKuRLMBl3aaAbCiggDZcswCrH5OASDeHgMjAlsB747zBAjr1wICq5cFF9f1AacvpAbvks8CRIG0BEPzcQKPNUgC+i0OAhduqABERE8BbUZfAq1bkAEgzl8DiCkHARK7mQIi/3ABCJG5AjGdJQD4bzEBZgi+AenzqQE8VRcASie9AHQx7wCt1dIALqFsAZ6WJQDEeLkBD2IGA5jDPgFg5kcHZD1MAhnU7AOjYRACxTuSBKIXxAA4GD0EtGLBAvuT5QNhvRgBLTbOA+lS9gC3ZyYBbT7MAArw4ACSFnUBjZp4AEXUIwDQY3YBef8DAUcGwgB1EcUBfA8XAJpPmQDWXsUDuDeTAT3+TgJ+UpkAbmY/A2tSoQFou9QFT4onADz/XQNHDLoA0vsfBb2nkAPiLBMCf0PoANb5awKHkVYBgy6wAL274wHPFowA2dN0ADJRugKK+h8AHkDGAYebZACgzhcCuqLTAQ+8PwD+0DEAVVS/APHA8gGYfpEB6qKiAeVh2AFAh34Aq5TfBTMAKwMaJ70FP4juAK/EuQBi4tUDfZ/0BeGvPAKf6Y4Fs/PPATKYWQEfZRUAkBmkAoq/0QBbGXkAIJMFACe6ewM+c+YBXKfGA47V3AGznBMDGEJ6ANag2QMBLT4BaU+SAjKJYwFWZOcDrpHoAWS4AQOtCX0APyWhASRyjQEv3o4D9LqaAAWu3QI+cpsBhjegBU8fhwJ9+rMF69otAgEckQEQk0kA+b2EARG9wAHejsYDRxQPAfk17QIOCxIAG9NxAtRrOAGbk5IDX34wABfBbQElol4Ax535AheAuwHMMbICXKQqASp36wFYt+0Bx9IBA2r+KgLlCmMDoQDiANvtWwSAsssCzzJfAs3QXwP1v1kCbepPAZI98wAUenAB9fa5AmYEewDpY+YB21v8AcbeFgOy9ekB0vHqAG/6wAFVVIgAZToyAYKtnAJ2LTMBdekQAvFa1gBen9sBAwPqAWFMXAJPNuYA8uPnBjMY3wFwOHYBFIQBAarS7AQ38Z4BuXMTBwblrgAwLAAFcXKmAfNI4gPMWfQAieNLAfitOABKePYCdgMLAVB4xgOHemIBkfHdAW3CTgHM8UYB1sipAWC+LwMuZ64BYlxIAnXptAHAI+kCGeUgAd38xgDMK0cBtFSsBIVmvgJu7mEG5CjmAuLNQAbGDOEAphneAHFFMwGOnxgEprhKAgrgdAKd0OkAwXR+A9MLhQEVOowBzCQzAeceKwDrRrUBPziSAqgSVAHPAQ0DxzKwATPV9QKn0WEAv0c3ACJOnADokDoBuUq9ALqOlQI/RX8BjsuTB66XvwKH58sGobaJAKF++wLoIEIARM9CBB0cJQJccmAB/lz3ASyrRQDKdwsBu3YyAf9TiAFGUhoARuMCACDreQG1KZoAR4blAsn/JAApmAUAmj9JASG2fAB53ZYBGczVASmsVwBanZIDbIIUAEdryAPyZr0A7sKRBixYdQIHzuMEvm79AWyAFAaEVTMDh7FwBdciFgOBENADeJWqAl8TFwGmUB8BcPB6AOiz+gBEbrQC0ap3AN9spAPOT+kBGuXiAtBiUQFPRAcAg7lkAKodogMQomsBOBULAWTItQF+QaYBpYbMAGinqAABpE8AbIc7BUUygAFldw0C4gaHAqGOsweeZN4CGuDbBZ1dwwHpjYkAEBh9A9vOLwNgEWIBc24MA19zTQBb4+gD9/5PAVvlBgJXxosAzkuBAPpNzgGN9HsBikXcACCXBgGDpxYB7ESnAsa9lgCjq4oDMrwGAV4diQKT4rMAomvQA4UfUgGWZS0DgMrhAt9IkwQvipcBwkDOAuzangJpHYkC/L3pAWcPEQPBYf8Asi2pAsXhmwAnMHUDhmpzAGEmtQCWL0EBUoLlAvUmgQBJ75oCWmN/AKFvIQPt2fIBgrnDA9S/ngEoltoAhKmDAFlU/AGrRoABffjLAgAytAF7TFUF+m9QAmJC7wOZ7bYB3H6FBkjMYwFAk3cDYjinAzz4lQNzm+QB7CsOAkSJCwEV+vEBW3qPAcz58wDUGjwBL7awATAXvwHLeZgCLErVAT1aEgL0o+YBuGp0A1IjnwAMIQIDTyI+ABBXrgOsZVUAyiRRBp5FzAE/4bsEOc5eAlWQLwDlVvUCPpG+ASUFJwJs+xoEiJPqAKJ5kQOPdM4BxOi5A7a+jAFIDP4DihTyAala7wNgQrsB9LWHAt2INAD1BTMCyi9OAJhl2ABJF30A/mAhAevSSQEq0VgBB4FtAHpo5AKp8ssA38yHA8kc6QFABn8EnpBHAmOMXwRNlg0C+mt2AbY6fQEAJmwDjL3RAfWafQFxo1sBeE++A4XvbAFLL/gAo+TvABFvCgBYlUsB1uvvAKefGAEcl2wDatG8AOnnYwIbypQBrSOKA20YRAEBRbUAa2ZSAGbtBwBcJO0ByqJTATfKBgOF6ocDF/reAEFeqAL0+NIBpmzJAv6hbwLMCP4AiA10AmSwhAMq134BsIWCA51PlABD4CUBDM4VAT0ibgHtaK8BT4RvA42uSABU5bQCaLOMAED4DwPoihAA9UN7Atl51AE+X9oB1YWJAY62UgMvHAsA4XKNAdGvTAObtZYHuOUDA6KdbwXmvYsAd8q+A9lqQAFD6z8GXhqsAbsvCwHXEvsBUFRZAEQ6gABecQUBXIHQAWAPUwIIHLwA7wmkADzNmADAo2IDtxI8ANm2iwBtO3gBA8D7AKnS8AEkrFwCk9P1AbJBNAD9DXMApq7OBXG8lQHsWq0EKsfAAVdscQQzI0wAQhmUB9sEBwOV8XIDvdHoAk8yxwCXltUBEUokATUoBwATh0EDGaxFAK7tVQBjXykAAzgQACegsQHIatoCuERUAVq6PQJCj40BDPSmA2JyxgDHbqMDwBK6AHzv9gFuRBYA3OouBdM8awJoKmkFDeaYAgYFgwSMaJoB1AMGBILkogGyZBwF5ntVA7sO3wH9YOYAJpiVAWKJegDWzQMD4ZizAQWFiQCeRYwBcKKaA7PzrAEIvXMDji7cAdSG4QN9HUUAvCuJAfJGCQBazP8D5qqTABc4EwI3fZ0BCrPaA062/QEl1L8FKOt8AGCXHASGlL4AzfknBjJgiAHTLIgDQtGDA/yCFwPagBQBxYF2AGxlCwCyBZIBPgdkAbTsXgIbGqQATBZwA3dmTwDKwOUByLDXAClA9APNuE4Apy0/AaAjAAE6DI4DywmQAdpe5QF6G3AAqmltAz/QSgH6fzcFAeLGAitM0QSWmE0B0RcuBcirRQEr0+cEvSXgAeLEPgOotd4BIdMRAHfxxQHkI5gBFUUoAbHioQCUs8EA28L+ASjOMwHnXPoBQ5mqABWU8QCqRVIBeBLnA1tyAwC4PuYA4clXAZFgogO08twAmrvdBeE+qgE3ftkFdA3jAbIs7wScjZsBj91TBOrR0AAqEaUB+1GFAnz1yQJg0xgBUtamAJokCQH3L38AWtuMAaDZJgLTkz8BQVSUAc8DAQDThlkBf056Ad+bAQNRiEoAspzQA7kZMQHdA9IB5Za+AVSiNAMoVI0BNntUBlsRlgB3ExwFHxbXARsXzAON8TQD4jR9BBxMzwDXp/oGraTmAjfPaQFtu/UBoCzcASllgAGmEF4AXdZrAXVIAAJPPeoBeK99AIup+wBOJ5MC+cQxAaSzbgLeRrsBFY59AZqzigF1sCoBCq6ZAJxcZgCoDaEBaRAgBPnFtAHKoywFViAkAqCZFAd5/A8CGONQBDtYjgIQFskBms1NAyc/LwAIeo0AgBe2AssnEwEDcB0DFiSMAdHqdAI0Mj8BeKtoA5/bXgBXUg4C5ioFAKWLfwJVTiYAgjxCAsoeLQEtxHoB+TWiAYePZwLW0nIA1AegAqiYKgNtLfYEjYOHAYJHzAci4gsC/xvyA+CK1QH2LtgC9AO3Amz8SgHOGjABzDb2A9LGJAF4IzIANNjKASWLgQLxSZQAQ+eNAykvzABOdBkBBOG/AQWT5AA6WLEAeqXlA/tTyQHfp2ABsbieAfFpswH4xvAAckLLAf4kLwIsGHMHdT7+AMThugJ6jawCGVUpA+FvtwDV55cEAzsHAe6KlABCkyEBHvaNA9CNdAFncB8AWKGsAFPX5gIub5cALSY0AYQtzACKgG0C6HWGAfK+rQLw7PAAUn/sAiffoQFttuEDeq7vAIfykQEz0ZoAgwNzAtik/AE2nEUFU17/AedJLQUTE9QBX8U7Al/7IQIlx0kBQKz3AXV0OAPjERIAPopnAfblpAHzdskCVSCfAWwiiQFV07oACsHBAnnCsQB67mYDodqrAGzZoQGeqiIAsC+bAbXkCwEHnAAAEEtdAM5i/wE6miMA+fK4BkF1QgPk5XsEyCpuAoXksgK5bHYDOBOaA1GpPgNwj3MF7sQyAa0wwQOSAlQBlYaTAl7oSQBt4zQCvokKACjMHgJLNGEBo+t+AP58vABKthUBeR0jAfAeBwJU2tYBBlSWAlAbdQGfn5gCQRjdAeIKPAGNh2YAvb2WAXWzXAKDFogDd8ccAhSBTwa0CUEC2aOpBPWTxgFqJpABTq/NAcMF+gIuWB0Boy/MAyo3BgGChs8Cc2TWAGCMSwFq3JAAwyAcAaxRBQG0szQDJFTLAKpwrgALBFsARfQbAXWDXAAhmK8Di5lrAfqHKwJWigQBs+qTAniYVAPLZZsFnAkZAkdqEQJrmQABvOW6BMAIsAGtldEE7YIdAunWfgE94mYAOaMEAcZvMwEsT04Bc9IKAdkJGQOdi8YB0lK7Ak+FUwCKgeYB84WGASeIEABNa08BtlVcAbHMygCjR5MDl0W+AKwzvAH60qwBwPJxBVhZGgM+Qm8GcpgqAqAnGwM1UP4CadFzBWZ8YQLc5mIDHucGArLAeAIO2csBe55PAHCR9wBc+jABo7XBASQvjgKPvaUBLZLwAAZLgAApncgCVnnVAAFx7AAFLfoAkAxSAB9s5wDh73cDpge9AbrkhANtvSIASyzMAaI0xQJNvPEGNxSNAvOSLwXNZDMCfGuUAhrDTQKX/VoFBo+QATMlHwAidyYBBsV2AJm80wCXFHQC9EE0AbP9bgEvsdEAoWMRA3XeygBqs/wBezZ+AZA5vwA3unkACvOKAM3T5QF8nPECk5y5AeITvAN7KSABDCLOAhA5UwLLFiUDKWBiAnZmuAEDvhwCbVLaA8fMwAHIkXYEdMySAnEgYgHAwnkAaqH4Ae1YfAAX1BoAzataAfcw2AGNJeYBe8sAAp2oHgHD+BUAcLsHAUqF7wNJ4/MB+ZNGANZ4ogCnCbMDFZ4SANpN0QFhbVEB4SGzAzg0OQFArNID+EfRAY2p7gSdvZkBrf5nAmEhDgKMTOYDcIs0AQ861ACo18kB98zXAd9EoAE4mrcCLud5AGqmiQBRiIoApSszAOeLPQA5XzsCdWIZAZY/7AFevvoBqLlyAQX6OgFKaWEB19+GAHFjowGAPnAAPWqTBKLDCgIgzbYE1Q6uAYAm5wM0tt8AYiqfA/YNKAK70rEFBRUAA/89lAKILYEBWBp0An0mcgD7MvICeIaAAcv5pwKk69cAyrHzAIWNPgDwgr4Bbq//AAAUkgEl0nkBBieCAI76VAGMyM8ACV9oAQr0rgCG6H4AlAF7Ag/BlQHn6e8F1EZwAft0oALx3twBzFXjBAa5OgJ19z8Fc02xAT71yAI+EiUBajXoAjHd0wCi2wcCAV4rALY+tgKfTsgBhoyqAOu45ACvNYoCTzpNAZfJAgE/xCIABR64AKuwmgB5O84AJmMnAKxQTQL/hZcApyHxAl393wErcvwEa345A8coDQcl5RsBJu8XAZd5MwOXlvgECequAXb2BALH9SYARaHyARCylgBxOIIAqx9pABpYbAMwKmoA+6lCAEVdlQABOf4ApBlvAFq8WgPLBMUAKNUyAdRghAFXirQC45J8Abf29wBBdVYB/WbSAv15JAKIcwMHOhjYAIYSHQQ64mECr45HBAbRoQC9VDMGmfpIANVU6wMs3uAA7pSPA6kqNQFNp3UAugAoAXyxZwNE4UIA4wdYAUusBgCWLeMBECRGATECCQOKwRYAj7fnAtlFMgDsOKEB1YMqAIqRLAKH5SgBHj8jAzyR9QFkwAIC56dxApdoJgF5udoAeYvTAnbwIwJAvdkCurOiAaC75gA++A4BO05hAP/3owHgO1sDakc6AfAvIQEydewA27E/AvNaswAQwtcDvEMyARaHgQBovSUBuDnCACM+5wHb+GwADOeyAI9QWwGDXWUBkCcCAf/6sgAFEewCiiAuAsu8JgbzczQDvXFJAr5sRQEVRfUBF8uyAJdjqgBB+G8AJWyZAz8lRQAAWD4CWJSQAb5E4AHxJzUAKcvtA5B+wgHKKv0DGGOXAGH93wFKczEBBa9IAzqwywB8t/kB5ORjAIEMzwKnwMMBubAQBpbqqwJMJVUDIHiHAY3C4wEf1joC1Lt9A+cuPAG9dCoClrITATM+7QLL7MEAwug8AKwinQG8ELgCZgNfAYzpJAIoGQsBFMOmAHb1LQBD1ZUDngwSAbqk4wGgGQUADE7DASvF4QAwjikCw5s8Ad7HEgGRiJwA/HWpApDi7gLuF2sEbLW8AeVwMQJIqu0B5rfjA0/cFALBa38Ffs1lAC40xQHSqyQBVwNaAzeXjQBgu/8DKU7IAP5GRgH0fagAzESKAXzXRgBmQsgCEDTkAHXcjwLK+HsAOBKuA7mXpAEy6NABoOQrAfgdGQFEvj8AWfGyAgnlpgF63SoCHRTUAFKAAwAw0fMAd3lAAzHjnAH/bcUBZxuQAAjJvPNn5glqO6fKhIWuZ7sr+JT+cvNuPPE2HV869U+l0YLmrX9SDlEfbD4rjGgFm2u9Qfur2YMfeSF+ExnN4FthIHNlZWQgaXMgMzIgYnl0ZXNub3QgYW4gRWQyNTUxOSBwdWJsaWMga2V5YSBzaWduYXR1cmUgaXMgNjQgYnl0ZXNubyByYW5kb21uZXNzIGF2YWlsYWJsZQAAAAAAAAAirijXmC+KQs1l7yORRDdxLztN7M/7wLW824mBpdu16Ti1SPNbwlY5GdAFtvER8VmbTxmvpII/khiBbdrVXhyrQgIDo5iqB9i+b3BFAVuDEoyy5E6+hTEk4rT/1cN9DFVviXvydF2+crGWFjv+sd6ANRLHJacG3JuUJmnPdPGbwdJK8Z7BaZvk4yVPOIZHvu+11YyLxp3BD2WcrHfMoQwkdQIrWW8s6S2D5KZuqoR0StT7Qb3cqbBctVMRg9qI+Xar32buUlE+mBAytC1txjGoPyH7mMgnA7DkDu++x39Zv8KPqD3zC+DGJacKk0eRp9VvggPgUWPKBnBuDgpnKSkU/C/SRoUKtycmySZcOCEbLu0qxFr8bSxN37OVnRMNOFPeY6+LVHMKZaiydzy7Cmp25q7tRy7JwoE7NYIUhSxykmQD8Uyh6L+iATBCvEtmGqiRl/jQcItLwjC+VAajUWzHGFLv1hnoktEQqWVVJAaZ1iogcVeFNQ70uNG7MnCgahDI0NK4FsGkGVOrQVEIbDcemeuO30x3SCeoSJvhtbywNGNaycWzDBw5y4pB40qq2E5z42N3T8qcW6O4stbzby5o/LLvXe6Cj3RgLxdDb2OleHKr8KEUeMiE7DlkGggCx4woHmMj+v++kOm9gt7rbFCkFXnGsvej+b4rU3Lj8nhxxpxhJurOPifKB8LAIce4htEe6+DN1n3a6njRbu5/T331um8Xcqpn8AammMiixX1jCq4N+b4EmD8RG0ccEzULcRuEfQQj9XfbKJMkx0B7q8oyvL7JFQq+njxMDRCcxGcdQ7ZCPsu+1MVMKn5l/Jwpf1ns+tY6q2/LXxdYR0qMGURsYXNzZXJ0aW9uIGZhaWxlZDogcHNpemUgPj0gc2l6ZSArIG1pbl9vdmVyaGVhZAAAYgIQACoAAACxBAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBzaXplIDw9IHNpemUgKyBtYXhfb3ZlcmhlYWQAAGICEAAqAAAAtwQAAA0AAAASAAAAGQAAABcAAAAXAAAAQJsQAFKbEABrmxAAgpsQAABBwL3CAAsIBwAAAAQAAAAAKQRuYW1lASIBTh9fX3diaW5kZ2VuX2FkZF90b19zdGFja19wb2ludGVyADwJcHJvZHVjZXJzAQxwcm9jZXNzZWQtYnkCBndhbHJ1cwYwLjI3LjIMd2FzbS1iaW5kZ2VuBzAuMi4xMjk=";
+var post_core_wasm_exports = {};
+__export2(post_core_wasm_exports, {
+  default: () => __wbg_init,
+  generateSeed: () => generateSeed,
+  initSync: () => initSync,
+  policyDecision: () => policyDecision,
+  policyMaxAge: () => policyMaxAge,
+  publicKey: () => publicKey,
+  sign: () => sign,
+  verify: () => verify
+});
+function generateSeed() {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    wasm.generateSeed(retptr);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+    var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+    if (r3) {
+      throw takeObject(r2);
+    }
+    var v1 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_export2(r0, r1 * 1, 1);
+    return v1;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+function policyDecision(now, fetched_at, max_age, cached_id, txt_id, kid_known) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    var ptr0 = isLikeNone(cached_id) ? 0 : passStringToWasm0(cached_id, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(txt_id) ? 0 : passStringToWasm0(txt_id, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+    var len1 = WASM_VECTOR_LEN;
+    wasm.policyDecision(retptr, now, !isLikeNone(fetched_at), isLikeNone(fetched_at) ? 0 : fetched_at, max_age, ptr0, len0, ptr1, len1, kid_known);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    deferred3_0 = r0;
+    deferred3_1 = r1;
+    return getStringFromWasm0(r0, r1);
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+    wasm.__wbindgen_export2(deferred3_0, deferred3_1, 1);
+  }
+}
+function policyMaxAge(published) {
+  const ret = wasm.policyMaxAge(!isLikeNone(published), isLikeNone(published) ? 0 : published);
+  return ret;
+}
+function publicKey(seed) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.publicKey(retptr, ptr0, len0);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+    var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+    if (r3) {
+      throw takeObject(r2);
+    }
+    var v2 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_export2(r0, r1 * 1, 1);
+    return v2;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+function sign(seed, message) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(seed, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    wasm.sign(retptr, ptr0, len0, ptr1, len1);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+    var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+    if (r3) {
+      throw takeObject(r2);
+    }
+    var v3 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_export2(r0, r1 * 1, 1);
+    return v3;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+function verify(public_key, message, signature) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+    const ptr0 = passArray8ToWasm0(public_key, wasm.__wbindgen_export3);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(message, wasm.__wbindgen_export3);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passArray8ToWasm0(signature, wasm.__wbindgen_export3);
+    const len2 = WASM_VECTOR_LEN;
+    wasm.verify(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+    var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+    var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+    if (r2) {
+      throw takeObject(r1);
+    }
+    return r0 !== 0;
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16);
+  }
+}
+function __wbg_get_imports() {
+  const import0 = {
+    __proto__: null,
+    __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
+      const ret = Error(getStringFromWasm0(arg0, arg1));
+      return addHeapObject(ret);
+    },
+    __wbg_getRandomValues_436a51d0629d84e1: function() {
+      return handleError(function(arg0, arg1) {
+        globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+      }, arguments);
+    },
+    __wbindgen_object_drop_ref: function(arg0) {
+      takeObject(arg0);
+    }
+  };
+  return {
+    __proto__: null,
+    "./post_core_wasm_bg.js": import0
+  };
+}
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function dropObject(idx) {
+  if (idx < 1028) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return decodeText(ptr >>> 0, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    wasm.__wbindgen_export(addHeapObject(e));
+  }
+}
+var heap = new Array(1024).fill(void 0);
+heap.push(void 0, null, true, false);
+var heap_next = heap.length;
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasmModule;
+var wasmInstance;
+var wasm;
+function __wbg_finalize_init(instance, module) {
+  wasmInstance = instance;
+  wasm = instance.exports;
+  wasmModule = module;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  return wasm;
+}
+async function __wbg_load(module, imports) {
+  if (typeof Response === "function" && module instanceof Response) {
+    if (!module.ok) {
+      throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+    }
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module, imports);
+      } catch (e) {
+        const validResponse = expectedResponseType(module.type);
+        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
+          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module };
+    } else {
+      return instance;
+    }
+  }
+  function expectedResponseType(type) {
+    switch (type) {
+      case "basic":
+      case "cors":
+      case "default":
+        return true;
+    }
+    return false;
+  }
+}
+function initSync(module) {
+  if (wasm !== void 0) return wasm;
+  if (module !== void 0) {
+    if (Object.getPrototypeOf(module) === Object.prototype) {
+      ({ module } = module);
+    } else {
+      console.warn("using deprecated parameters for `initSync()`; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (!(module instanceof WebAssembly.Module)) {
+    module = new WebAssembly.Module(module);
+  }
+  const instance = new WebAssembly.Instance(module, imports);
+  return __wbg_finalize_init(instance, module);
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (module_or_path !== void 0) {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module);
+}
+var ready = false;
+function wasm2() {
+  if (!ready) {
+    initSync({ module: Buffer.from(wasmBase64, "base64") });
+    ready = true;
+  }
+  return post_core_wasm_exports;
+}
+var b64url = (bytes) => Buffer.from(bytes).toString("base64url");
+var fromB64url = (text) => new Uint8Array(Buffer.from(text, "base64url"));
+function jwkThumbprint(publicKey2) {
+  return createHash("sha256").update(`{"crv":"Ed25519","kty":"OKP","x":"${b64url(publicKey2)}"}`).digest("base64url");
+}
+function identityFromSeed(input) {
+  const seed = new Uint8Array(input.seed);
+  const publicKey2 = wasm2().publicKey(seed);
+  return {
+    domain: input.domain.toLowerCase(),
+    kid: jwkThumbprint(publicKey2),
+    publicKey: publicKey2,
+    seed,
+    sign: (message) => wasm2().sign(seed, message)
+  };
+}
+function generateIdentity(domain) {
+  return identityFromSeed({ domain, seed: wasm2().generateSeed() });
+}
+function identityDir(env = process.env) {
+  return env.PIDGEON_ID_DIR || join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "pidgeon", "id");
+}
+async function saveIdentity(identity, dir = identityDir()) {
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const path = join(dir, `${identity.domain}.json`);
+  const file = {
+    v: 1,
+    domain: identity.domain,
+    kid: identity.kid,
+    seed: b64url(identity.seed),
+    previous: identity.previous ? { kid: identity.previous.kid, public_key: b64url(identity.previous.publicKey) } : null
+  };
+  await writeFile(path, `${JSON.stringify(file, null, 2)}
+`, { mode: 384 });
+  await chmod(path, 384);
+  return path;
+}
+async function loadIdentity(domain, options = {}) {
+  const env = options.env ?? process.env;
+  const name = domain.toLowerCase();
+  const fromEnv = env.PIDGEON_ID_KEY?.split(":");
+  if (fromEnv?.length === 2 && fromEnv[0].toLowerCase() === name) {
+    return identityFromSeed({ domain: name, seed: fromB64url(fromEnv[1]) });
+  }
+  const path = join(options.dir ?? identityDir(env), `${name}.json`);
+  let file;
+  try {
+    file = JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    throw new Error(
+      `No identity for ${name} on this machine. Run \`pidgeon id init ${name}\` first.`
+    );
+  }
+  const identity = identityFromSeed({ domain: file.domain, seed: fromB64url(file.seed) });
+  if (identity.kid !== file.kid)
+    throw new Error(`${path} is damaged: its key does not match its kid.`);
+  identity.previous = file.previous ? { kid: file.previous.kid, publicKey: fromB64url(file.previous.public_key) } : null;
+  return identity;
+}
+async function listIdentities(dir = identityDir()) {
+  try {
+    return (await readdir(dir)).filter((name) => name.endsWith(".json")).map((name) => name.slice(0, -5));
+  } catch {
+    return [];
+  }
+}
+var TAG = "web-bot-auth";
+var SIGNATURE_SECONDS = 300;
+var quote = (value) => `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+function authority(url) {
+  const defaultPort = url.protocol === "https:" && url.port === "443" || url.protocol === "http:" && url.port === "80";
+  return `${url.hostname.toLowerCase()}${url.port && !defaultPort ? `:${url.port}` : ""}`;
+}
+function bytesOf(body) {
+  return typeof body === "string" ? new TextEncoder().encode(body) : body;
+}
+function contentDigest(body) {
+  return `sha-256=:${createHash2("sha256").update(bytesOf(body)).digest("base64")}:`;
+}
+async function signRequest(identity, input) {
+  const url = new URL(input.url);
+  const label = input.label ?? "sig1";
+  const created = Math.floor((input.now ?? Date.now()) / 1e3);
+  const expires = created + (input.seconds ?? SIGNATURE_SECONDS);
+  const agent = input.agent?.trim().toLowerCase() ?? null;
+  if (agent && !agent.endsWith(`@${identity.domain}`)) {
+    throw new Error(`${agent} is not an address at ${identity.domain}, whose key this is.`);
+  }
+  const added = {
+    "signature-agent": quote(`https://post.${identity.domain}`),
+    ...agent ? { from: agent } : {}
+  };
+  const body = input.body === void 0 || input.body === null ? null : bytesOf(input.body);
+  if (body && body.length > 0) added["content-digest"] = contentDigest(body);
+  const values = [
+    ["@method", input.method.toUpperCase()],
+    ["@authority", authority(url)],
+    ["@path", url.pathname || "/"],
+    ...url.search ? [["@query", url.search]] : [],
+    ["signature-agent", added["signature-agent"]],
+    ...added.from ? [["from", added.from]] : [],
+    ...added["content-digest"] ? [["content-digest", added["content-digest"]]] : []
+  ];
+  const params = `(${values.map(([name]) => quote(name)).join(" ")});created=${created};expires=${expires};keyid=${quote(identity.kid)};alg="ed25519";nonce=${quote(randomBytes(32).toString("base64"))};tag=${quote(input.tag ?? TAG)}`;
+  const base = [
+    ...values.map(([name, value]) => `${quote(name)}: ${value}`),
+    `"@signature-params": ${params}`
+  ].join("\n");
+  const signature = identity.sign(new TextEncoder().encode(base));
+  return {
+    ...added,
+    "signature-input": `${label}=${params}`,
+    signature: `${label}=:${Buffer.from(signature).toString("base64")}:`
+  };
+}
+var ISSUANCE_TAG = "pidgeon-id";
+var DEFAULT_ID_URL = "https://pidgeon.ai/api/id";
+var IdApiError = class extends Error {
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+var IdClient = class {
+  constructor(identity, baseUrl2 = DEFAULT_ID_URL, fetcher = fetch) {
+    this.identity = identity;
+    this.baseUrl = baseUrl2;
+    this.fetcher = fetcher;
+  }
+  identity;
+  baseUrl;
+  fetcher;
+  async call(method, path, body) {
+    const url = `${this.baseUrl.replace(/\/$/, "")}${path}`;
+    const text = body === void 0 ? null : JSON.stringify(body);
+    const headers = text ? { "content-type": "application/json" } : {};
+    Object.assign(
+      headers,
+      await signRequest(this.identity, { method, url, headers, body: text, tag: ISSUANCE_TAG })
+    );
+    const response = await this.fetcher(url, { method, headers, body: text ?? void 0 });
+    const json = await response.json().catch(() => null);
+    if (!response.ok || !json || json.data === void 0) {
+      throw new IdApiError(
+        response.status,
+        json?.error?.code,
+        json?.error?.message ?? `Pidgeon answered ${response.status}.`
+      );
+    }
+    return json.data;
+  }
+  /** Claim the domain with this key. Idempotent: a second call returns the same records. */
+  claim() {
+    return this.call("POST", "/domains", {
+      domain: this.identity.domain,
+      public_key: b64url(this.identity.publicKey)
+    });
+  }
+  /** Look at DNS now; `verified` once `_post` says this key's id. */
+  check() {
+    return this.call("POST", "/domains/check", { domain: this.identity.domain });
+  }
+  issue(input) {
+    return this.call("POST", "/agents", input);
+  }
+  list() {
+    return this.call("GET", "/agents");
+  }
+  revoke(name) {
+    return this.call("DELETE", `/agents/${encodeURIComponent(name)}`);
+  }
+  /**
+   * Publish `next` as the domain's key, signed by the current one. `proof`
+   * is `next`'s own signature over the rotation, so nobody can rotate a
+   * domain onto a key they do not hold.
+   */
+  rotate(next) {
+    const statement = rotationStatement(this.identity.domain, this.identity.kid, next.kid);
+    return this.call("POST", "/keys", {
+      public_key: b64url(next.publicKey),
+      proof: b64url(next.sign(new TextEncoder().encode(statement)))
+    });
+  }
+};
+function rotationStatement(domain, from, to) {
+  return `pidgeon id rotate
+${domain}
+${from}
+${to}`;
+}
+var UsageError = class extends Error {
+};
+var HELP = `pidgeon id \u2014 a signed identity for your agents, on your own domain. No account.
+
+  init <domain>          Make a key on this machine and prove the domain over DNS
+  check [<domain>]       Look at DNS again
+  issue <name>           Give <name>@<domain> a card   --kind agent|service  --on-behalf-of <who>
+  list                   Agents on the domain
+  revoke <name>          Withdraw an agent's card now
+  rotate                 Replace the domain's key; the old one verifies for another day
+
+  --domain <domain>      Which domain, when this machine holds more than one
+  --json                 Print the API's answer as JSON
+  --no-wait              init: print the records and return
+
+Keys live in ${"$"}PIDGEON_ID_DIR (default ~/.config/pidgeon/id). They never leave this machine.`;
+function parse(argv) {
+  const positional = [];
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("--")) {
+      positional.push(token);
+      continue;
+    }
+    const [name, inline] = token.slice(2).split("=", 2);
+    if (["json", "no-wait", "help"].includes(name)) flags.set(name, true);
+    else {
+      const value = inline ?? argv[++i];
+      if (value === void 0) throw new UsageError(`--${name} needs a value.`);
+      flags.set(name, value);
+    }
+  }
+  return { positional, flags };
+}
+var DOMAIN = /^(?=.{4,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
+function baseUrl(env) {
+  if (env.PIDGEON_ID_URL) return env.PIDGEON_ID_URL;
+  if (env.PIDGEON_BASE_URL) return env.PIDGEON_BASE_URL.replace(/\/v1\/?$/, "/id");
+  return DEFAULT_ID_URL;
+}
+function describeRecords(domain) {
+  const lines = domain.records.map(
+    (record) => `  ${record.found ? "\u2713" : "\xB7"} ${record.type.padEnd(5)} ${`${record.name}.${domain.domain}`.padEnd(28)} ${record.value}`
+  );
+  return lines;
+}
+async function runId(argv, env = process.env, options = {}) {
+  const { positional, flags } = parse(argv);
+  const [command, ...rest] = positional;
+  if (!command || flags.has("help") || command === "help") return HELP;
+  const dir = identityDir(env);
+  const json = flags.has("json");
+  const say = options.stderr ?? (() => {
+  });
+  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const client2 = (identity) => new IdClient(identity, baseUrl(env), options.fetch);
+  async function which() {
+    const named = flags.get("domain");
+    if (typeof named === "string") return loadIdentity(named, { dir, env });
+    if (env.PIDGEON_ID_KEY) return loadIdentity(env.PIDGEON_ID_KEY.split(":")[0], { dir, env });
+    const held = await listIdentities(dir);
+    if (held.length === 1) return loadIdentity(held[0], { dir, env });
+    if (held.length === 0)
+      throw new UsageError("No domain here yet. Start with `pidgeon id init <domain>`.");
+    throw new UsageError(`This machine holds ${held.join(", ")}. Say which with --domain.`);
+  }
+  try {
+    switch (command) {
+      case "init": {
+        const domain = rest[0]?.trim().toLowerCase().replace(/\.$/, "");
+        if (!domain || !DOMAIN.test(domain))
+          throw new UsageError("Name the domain: `pidgeon id init acme.com`.");
+        let identity;
+        let made = false;
+        try {
+          identity = await loadIdentity(domain, { dir, env });
+        } catch {
+          identity = generateIdentity(domain);
+          await saveIdentity(identity, dir);
+          made = true;
+        }
+        let state = await client2(identity).claim();
+        if (json && (state.status === "verified" || flags.has("no-wait")))
+          return JSON.stringify(state, null, 2);
+        const lines = [
+          made ? `Made a signing key for ${domain} on this machine (${identity.kid}).` : `Using the key for ${domain} on this machine.`
+        ];
+        if (state.status !== "verified") {
+          lines.push(
+            "",
+            state.setup_url ? `Add the records in one click: ${state.setup_url}
+
+Or add them by hand:` : "Add these records at your DNS provider:",
+            ...describeRecords(state),
+            "",
+            "The first proves the domain is yours. The second serves its keys and cards at",
+            `post.${domain}; without it Pidgeon still verifies your agents, and nobody else can.`
+          );
+          if (flags.has("no-wait")) return [...lines, "", "Then: pidgeon id check"].join("\n");
+          say(lines.join("\n"));
+          say("\nWaiting for DNS\u2026");
+          const deadline = Date.now() + Number(flags.get("timeout") ?? 600) * 1e3;
+          while (state.status !== "verified" && Date.now() < deadline) {
+            await sleep2(5e3);
+            state = await client2(identity).check();
+          }
+          if (state.status !== "verified") {
+            return "Not yet. DNS can take a while; run `pidgeon id check` once the record is in.";
+          }
+          lines.length = 0;
+        }
+        if (json) return JSON.stringify(state, null, 2);
+        return [...lines, `${domain} is proved. Next: pidgeon id issue support-agent`].join("\n").trim();
+      }
+      case "check": {
+        const identity = rest[0] ? await loadIdentity(rest[0], { dir, env }) : await which();
+        const state = await client2(identity).check();
+        if (json) return JSON.stringify(state, null, 2);
+        return [
+          `${state.domain}: ${state.status === "verified" ? "proved" : state.status}`,
+          ...describeRecords(state)
+        ].join("\n");
+      }
+      case "issue": {
+        const name = rest[0]?.trim().toLowerCase();
+        if (!name) throw new UsageError("Name the agent: `pidgeon id issue support-agent`.");
+        const identity = await which();
+        const kind = flags.get("kind");
+        if (kind !== void 0 && kind !== "agent" && kind !== "service") {
+          throw new UsageError("--kind is agent or service.");
+        }
+        const onBehalfOf = flags.get("on-behalf-of");
+        const card = await client2(identity).issue({
+          name,
+          ...kind ? { kind } : {},
+          ...typeof onBehalfOf === "string" ? { on_behalf_of: onBehalfOf } : {}
+        });
+        if (json) return JSON.stringify(card, null, 2);
+        return [
+          `${card.card.address} has a card: ${card.url}`,
+          `Found from the address at https://post.${identity.domain}/.well-known/post/card?address=${card.card.address}`,
+          'It renews itself. Sign with it: import { loadIdentity, signEmail, signedFetch } from "@pidgeon-ai/id".'
+        ].join("\n");
+      }
+      case "list": {
+        const agents = await client2(await which()).list();
+        if (json) return JSON.stringify(agents, null, 2);
+        if (agents.length === 0)
+          return "No agents yet. `pidgeon id issue <name>` gives one a card.";
+        return agents.map((agent) => `${agent.address}  ${agent.kind}  ${agent.card_url}`).join("\n");
+      }
+      case "revoke": {
+        const name = rest[0]?.trim().toLowerCase();
+        if (!name) throw new UsageError("Name the agent: `pidgeon id revoke support-agent`.");
+        const revoked = await client2(await which()).revoke(name);
+        if (json) return JSON.stringify(revoked, null, 2);
+        return `${revoked.address} has no card from now on. Copies already fetched lapse within a day.`;
+      }
+      case "rotate": {
+        const current = await which();
+        const next = generateIdentity(current.domain);
+        const state = await client2(current).rotate(next);
+        next.previous = { kid: current.kid, publicKey: current.publicKey };
+        await saveIdentity(next, dir);
+        if (json) return JSON.stringify(state, null, 2);
+        return `${current.domain} signs with ${next.kid} now. ${current.kid} still verifies for a day.`;
+      }
+      default:
+        throw new UsageError(`No such command "${command}".
+
+${HELP}`);
+    }
+  } catch (error) {
+    if (error instanceof IdApiError) {
+      throw new Error(error.code ? `${error.code}: ${error.message}` : error.message);
+    }
+    throw error;
+  }
+}
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://pidgeon.ai/api/v1";
+var UsageError2 = class extends Error {
+};
+var ApiError = class extends Error {
+  constructor(status, code, message) {
+    super(code ? `${status} ${code}: ${message}` : `${status}: ${message}`);
+    this.status = status;
+    this.code = code;
+  }
+  status;
+  code;
+};
+function coerce(flag, raw) {
+  if (flag.kind === "number") {
+    const value = Number(raw);
+    if (Number.isNaN(value)) throw new UsageError2(`--${flag.name} takes a number, not "${raw}".`);
+    return value;
+  }
+  if (flag.kind === "json") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new UsageError2(`--${flag.name} takes JSON, and that did not parse.`);
+    }
+  }
+  return raw;
+}
+function parse2(command, argv) {
+  const byName = new Map(command.flags.map((flag) => [flag.name, flag]));
+  const out = { path: {}, query: {}, body: {}, header: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("--")) throw new UsageError2(`Unexpected argument "${token}".`);
+    const [name, inline] = token.slice(2).split(/=([\s\S]*)/, 2);
+    const flag = byName.get(name);
+    if (!flag) {
+      throw new UsageError2(
+        `\`${command.group} ${command.name}\` has no --${name}. Try \`pidgeon ${command.group} ${command.name} --help\`.`
+      );
+    }
+    if (flag.kind === "boolean") {
+      out[flag.where][name] = inline === void 0 ? true : inline === "true";
+      continue;
+    }
+    const raw = inline ?? argv[++i];
+    if (raw === void 0) throw new UsageError2(`--${name} needs a value.`);
+    if (flag.kind === "list") {
+      const existing = out[flag.where][name] ?? [];
+      out[flag.where][name] = [...existing, raw];
+      continue;
+    }
+    out[flag.where][name] = coerce(flag, raw);
+  }
+  const missing = command.flags.filter((flag) => flag.required).filter((flag) => out[flag.where][flag.name] === void 0).map((flag) => `--${flag.name}`);
+  if (missing.length > 0) {
+    throw new UsageError2(`\`${command.group} ${command.name}\` needs ${missing.join(", ")}.`);
+  }
+  return out;
+}
+function help(command) {
+  if (!command) {
+    const groups = [...new Set(COMMANDS.map((c) => c.group))].sort();
+    return [
+      "pidgeon <group> <command> [--flags]",
+      "",
+      "Groups:",
+      ...groups.map((group) => {
+        const names = COMMANDS.filter((c) => c.group === group).map((c) => c.name);
+        return `  ${group.padEnd(14)}${names.join(", ")}`;
+      }),
+      "",
+      "An API key goes in PIDGEON_API_KEY. `pidgeon <group> <command> --help`",
+      "describes one command; --verbose prints what was sent, on stderr.",
+      "",
+      "`pidgeon id` gives agents on your own domain a signed identity, with no",
+      "account and no key: `pidgeon id help`."
+    ].join("\n");
+  }
+  const flags = command.flags.map((flag) => {
+    const takes = flag.choices?.length ? flag.choices.join("|") : flag.kind;
+    const label = `  --${flag.name}${flag.kind === "boolean" ? "" : ` <${takes}>`}`;
+    const note = [flag.required ? "required" : null, flag.describe].filter(Boolean).join(" \u2014 ");
+    if (!note) return label;
+    return `${label.padEnd(34)}${label.length >= 34 ? "  " : ""}${note}`;
+  });
+  return [
+    `pidgeon ${command.group} ${command.name} [--flags]`,
+    "",
+    `  ${command.summary}`,
+    `  ${command.method} ${command.path}`,
+    "",
+    ...flags.length > 0 ? ["Flags:", ...flags] : ["Takes no flags."]
+  ].join("\n");
+}
+function headersFor(command, parsed) {
+  const headers = {};
+  for (const flag of command.flags) {
+    if (flag.where !== "header" || !flag.header) continue;
+    const given = parsed.header[flag.name];
+    if (typeof given === "string") headers[flag.header] = given;
+    else if (flag.header === "Idempotency-Key") headers[flag.header] = crypto.randomUUID();
+  }
+  return headers;
+}
+function find(group, name) {
+  return COMMANDS.find((c) => c.group === group && c.name === name);
+}
+async function run(argv, env, options = {}) {
+  const verbose = argv.includes("--verbose");
+  const [group, name, ...rest] = argv.filter((token) => token !== "--verbose");
+  if (!group || group === "--help" || group === "help") return help();
+  if (group === "id") {
+    try {
+      return await runId(argv.slice(1), env, { stderr: options.stderr });
+    } catch (error2) {
+      if (error2 instanceof UsageError) throw new UsageError2(error2.message);
+      throw error2;
+    }
+  }
+  const command = find(group, name);
+  if (!command) {
+    const known = COMMANDS.filter((c) => c.group === group);
+    if (known.length === 0) throw new UsageError2(`No such group "${group}".
+
+${help()}`);
+    throw new UsageError2(
+      `\`${group}\` has no "${name ?? ""}" command. It has: ${known.map((c) => c.name).join(", ")}.`
+    );
+  }
+  if (rest.includes("--help")) return help(command);
+  const apiKey = env.PIDGEON_API_KEY;
+  if (!apiKey) {
+    throw new UsageError2(
+      "PIDGEON_API_KEY is not set. Create a key at https://pidgeon.ai/app/developers/keys."
+    );
+  }
+  const parsed = parse2(command, rest);
+  const headers = headersFor(command, parsed);
+  const idempotencyKey = headers["Idempotency-Key"];
+  if (verbose && idempotencyKey) options.stderr?.(`Idempotency-Key: ${idempotencyKey}`);
+  client.setConfig(
+    createConfig({
+      baseUrl: env.PIDGEON_BASE_URL ?? DEFAULT_BASE_URL,
+      auth: () => apiKey,
+      // Ours by name, so an account made from a terminal reads as the CLI
+      // rather than as the SDK it bundles (`src/lib/analytics/client.ts`).
+      headers: { "User-Agent": "@pidgeon-ai/cli" }
+    })
+  );
+  const call = dist_exports[command.operationId];
+  if (typeof call !== "function") {
+    throw new Error(`The SDK does not export \`${command.operationId}\`. Run \`pnpm sdk\`.`);
+  }
+  const retry = idempotencyKey ? ` It may have been sent: retry with --idempotency-key ${idempotencyKey} and it goes out at most once.` : "";
+  let answer;
+  try {
+    answer = await call({
+      ...Object.keys(parsed.path).length > 0 ? { path: parsed.path } : {},
+      ...Object.keys(parsed.query).length > 0 ? { query: parsed.query } : {},
+      ...Object.keys(parsed.body).length > 0 ? { body: parsed.body } : {},
+      ...Object.keys(headers).length > 0 ? { headers } : {}
+    });
+  } catch (thrown) {
+    const reason = thrown instanceof Error ? thrown.message : "The request failed.";
+    throw new Error(`${reason}${retry ? `
+${retry.trim()}` : ""}`);
+  }
+  const { data, error, response } = answer;
+  if (verbose && response.headers.get("Idempotent-Replay") === "true") {
+    options.stderr?.("Idempotent-Replay: true \u2014 answered from the first send; nothing sent again.");
+  }
+  if (error !== void 0) {
+    const detail = error?.error;
+    const message = detail?.message ?? (typeof error === "string" && error ? error.slice(0, 500) : "The request failed.");
+    throw new ApiError(
+      response.status,
+      detail?.code,
+      response.status >= 500 ? message + retry : message
+    );
+  }
+  return JSON.stringify(data, null, 2);
+}
+
+export {
+  UsageError2 as UsageError,
+  ApiError,
+  parse2 as parse,
+  help,
+  find,
+  run
+};
+//# sourceMappingURL=chunk-GCWCWQ2X.js.map