From 277eba70d2811e5ccf6932b55d6a20cf41e79dfc Mon Sep 17 00:00:00 2001
From: zhouhaibin <zhouhaibin@qq.com>
Date: Thu, 17 Apr 2025 13:42:16 +0800
Subject: [PATCH] sjj

---
 .env.production                               |    2 +-
 .../documentReview/SjjDocumentTasks/index.ts  |   60 +
 .../documentReview/SjjDocumentTasks/model.ts  |   80 +
 .../sjjTender/DocumentTasks/DocsDrawer.vue    |   55 +
 .../DocumentTasks/DocumentTasks.data.ts       |  135 +
 .../DocumentTasks/DocumentTasksModal.vue      |   76 +
 .../DocumentTasks/DocumentTasksTable.vue      |  286 +++
 .../DocumentTasks/SjjDocumentTasks.data.ts    |  119 +
 .../DocumentTasks/SjjDocumentTasksModal.vue   |   74 +
 .../sjjTender/DocumentTasks/caozuomiaoshu.md  | 2248 +++++++++++++++++
 src/views/sjjTender/DocumentTasks/index.vue   |  206 ++
 11 files changed, 3340 insertions(+), 1 deletion(-)
 create mode 100644 src/api/documentReview/SjjDocumentTasks/index.ts
 create mode 100644 src/api/documentReview/SjjDocumentTasks/model.ts
 create mode 100644 src/views/sjjTender/DocumentTasks/DocsDrawer.vue
 create mode 100644 src/views/sjjTender/DocumentTasks/DocumentTasks.data.ts
 create mode 100644 src/views/sjjTender/DocumentTasks/DocumentTasksModal.vue
 create mode 100644 src/views/sjjTender/DocumentTasks/DocumentTasksTable.vue
 create mode 100644 src/views/sjjTender/DocumentTasks/SjjDocumentTasks.data.ts
 create mode 100644 src/views/sjjTender/DocumentTasks/SjjDocumentTasksModal.vue
 create mode 100644 src/views/sjjTender/DocumentTasks/caozuomiaoshu.md
 create mode 100644 src/views/sjjTender/DocumentTasks/index.vue

diff --git a/.env.production b/.env.production
index 8a1e23a..2a18f4d 100644
--- a/.env.production
+++ b/.env.production
@@ -9,7 +9,7 @@ VITE_BUILD_COMPRESS = 'gzip'
 VITE_DROP_CONSOLE = true
 
 # 后端路径
-VITE_GLOB_API_URL=/prod-api
+VITE_GLOB_API_URL=/sjj
 
 # 全局加密开关(即开启了加解密功能才会生效 不是全部接口加密 需要和后端对应)
 VITE_GLOB_ENABLE_ENCRYPT=true
diff --git a/src/api/documentReview/SjjDocumentTasks/index.ts b/src/api/documentReview/SjjDocumentTasks/index.ts
new file mode 100644
index 0000000..c1f008a
--- /dev/null
+++ b/src/api/documentReview/SjjDocumentTasks/index.ts
@@ -0,0 +1,60 @@
+import { defHttp } from '@/utils/http/axios';
+import { ID, IDS, commonExport } from '@/api/base';
+import { SjjDocumentTasksVO, SjjDocumentTasksForm, SjjDocumentTasksQuery } from './model';
+
+/**
+ * 查询审计局标书任务列表
+ * @param params
+ * @returns
+ */
+export function SjjDocumentTasksList(params?: SjjDocumentTasksQuery) {
+  return defHttp.get<SjjDocumentTasksVO[]>({ url: '/productManagement/SjjDocumentTasks/list', params });
+}
+
+/**
+ * 导出审计局标书任务列表
+ * @param params
+ * @returns
+ */
+export function SjjDocumentTasksExport(params?: SjjDocumentTasksQuery) {
+  return commonExport('/productManagement/SjjDocumentTasks/export', params ?? {});
+}
+
+/**
+ * 查询审计局标书任务详细
+ * @param id id
+ * @returns
+ */
+export function SjjDocumentTasksInfo(id: ID) {
+  return defHttp.get<SjjDocumentTasksVO>({ url: '/productManagement/SjjDocumentTasks/' + id });
+}
+
+/**
+ * 新增审计局标书任务
+ * @param data
+ * @returns
+ */
+export function SjjDocumentTasksAdd(data: SjjDocumentTasksForm) {
+  return defHttp.postWithMsg<void>({ url: '/productManagement/SjjDocumentTasks', data });
+}
+
+/**
+ * 更新审计局标书任务
+ * @param data
+ * @returns
+ */
+export function SjjDocumentTasksUpdate(data: SjjDocumentTasksForm) {
+  return defHttp.putWithMsg<void>({ url: '/productManagement/SjjDocumentTasks', data });
+}
+
+/**
+ * 删除审计局标书任务
+ * @param id id
+ * @returns
+ */
+export function SjjDocumentTasksRemove(id: ID | IDS) {
+  return defHttp.deleteWithMsg<void>({ url: '/productManagement/SjjDocumentTasks/' + id },);
+}
+export function SjjDocumentTasksOssRemoveById(id: ID|IDS) {
+  return defHttp.deleteWithMsg<void>({ url: '/productManagement/SjjDocumentTasks/ossRemoveById/' + id },);
+}
diff --git a/src/api/documentReview/SjjDocumentTasks/model.ts b/src/api/documentReview/SjjDocumentTasks/model.ts
new file mode 100644
index 0000000..2f4385b
--- /dev/null
+++ b/src/api/documentReview/SjjDocumentTasks/model.ts
@@ -0,0 +1,80 @@
+import { BaseEntity, PageQuery } from '@/api/base';
+
+export interface SjjDocumentTasksVO {
+  /**
+   * 任务名称
+   */
+  taskName: string;
+
+  /**
+   * 招标文件名称
+   */
+  tenderDocumentName: string;
+
+  /**
+   * 投标文件名称
+   */
+  bidDocumentName: string | number;
+
+  /**
+   * 进度状态
+   */
+  progressStatus: string;
+
+  /**
+   * 审核结果
+   */
+  resultType: string;
+
+}
+
+export interface SjjDocumentTasksForm extends BaseEntity {
+  /**
+   * 任务名称
+   */
+  taskName?: string;
+
+  /**
+   * 招标文件名称
+   */
+  tenderDocumentName?: string;
+
+  /**
+   * 投标文件名称
+   */
+  bidDocumentName?: string | number;
+
+  /**
+   * 进度状态
+   */
+  progressStatus?: string;
+
+}
+
+export interface SjjDocumentTasksQuery extends PageQuery {
+
+  /**
+   * 任务名称
+   */
+  taskName?: string;
+
+  /**
+   * 招标文件名称
+   */
+  tenderDocumentName?: string;
+
+  /**
+   * 投标文件名称
+   */
+  bidDocumentName?: string | number;
+
+  /**
+   * 进度状态
+   */
+  progressStatus?: string;
+
+    /**
+     * 日期范围参数
+     */
+    params?: any;
+}
diff --git a/src/views/sjjTender/DocumentTasks/DocsDrawer.vue b/src/views/sjjTender/DocumentTasks/DocsDrawer.vue
new file mode 100644
index 0000000..6eba6d6
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/DocsDrawer.vue
@@ -0,0 +1,55 @@
+<template>
+  <BasicDrawer v-bind="$attrs" title="结果详情" :width="drawerWidth" @register="registerDrawer">
+    <!-- <MarkdownViewer :value="value"  v-if="type != 'html'" /> -->
+    <!-- 纯预览 -->
+    <MdPreview
+      :modelValue="value"
+      :theme="theme"
+      previewTheme="github"
+      codeTheme="github"
+      :showCodeRowNumber="true"
+      :previewOnly="true"
+    />
+    <!-- <div  style="width: 100%; height: 100%" v-html="value" ></div> -->
+    <template #footer> </template>
+  </BasicDrawer>
+</template>
+
+<script setup lang="ts">
+  import text from './caozuomiaoshu.md?raw';
+  // import { MarkdownViewer } from '@/components/Markdown';
+  import { MdPreview } from 'md-editor-v3';
+  import 'md-editor-v3/lib/style.css';
+  import { ref, onMounted } from 'vue';
+  import { BasicDrawer, useDrawer, useDrawerInner } from '@/components/Drawer';
+  import { useMaxWidthOrDefault } from '@/hooks/web/useSize';
+  const value = ref<string>('');
+  const type = ref<string>('markdown');
+  const MarkdownViewerkeynum = ref<number>(0);
+  const iframeKey = ref<number>(10);
+  const drawerWidth = useMaxWidthOrDefault(1000);
+  const textvalue = ref<string>(text);
+  const [registerDrawer] = useDrawerInner(init);
+  // 主题设置：'light' | 'dark'
+  const theme = ref('light');
+  onMounted(() => {});
+  function init(data) {
+    console.log('DocsDrawer', data, document.documentElement.clientHeight);
+    if (data) {
+      value.value = data.value;
+      type.value = data.type;
+      MarkdownViewerkeynum.value += 1;
+      iframeKey.value += 1;
+      if (type.value == 'def') {
+        console.log(textvalue.value);
+        value.value = textvalue.value;
+      }
+    }
+  }
+</script>
+
+<style scoped>
+  iframe {
+    width: 100%;
+  }
+</style>
diff --git a/src/views/sjjTender/DocumentTasks/DocumentTasks.data.ts b/src/views/sjjTender/DocumentTasks/DocumentTasks.data.ts
new file mode 100644
index 0000000..d836dc8
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/DocumentTasks.data.ts
@@ -0,0 +1,135 @@
+import { BasicColumn } from '@/components/Table';
+import { FormSchema } from '@/components/Form';
+import { getDictOptions } from '@/utils/dict';
+import { useRender } from '@/hooks/component/useRender';
+import { uploadDocument } from '@/api/documentReview/DocumentTasks';
+import { useUserStore } from '@/store/modules/user';
+import { RoleEnum } from '@/enums/roleEnum';
+
+const { roleList } = useUserStore();
+
+export const formSchemas: FormSchema[] = [
+  {
+    label: '任务名称',
+    field: 'taskNameList',
+    component: 'Select',
+    componentProps: {
+      options: getDictOptions('scheme_review'),
+      mode: 'multiple',
+    },
+  },
+  {
+    label: '文档名称',
+    field: 'documentName',
+    component: 'Input',
+  },
+  // {
+  //   label: '预计时间',
+  //   field: 'estimatedCompletionTime',
+  //   component: 'DatePicker',
+  //   componentProps: {
+  //     showTime: true,
+  //     format: 'YYYY-MM-DD HH:mm:ss',
+  //     valueFormat: 'YYYY-MM-DD HH:mm:ss',
+  //   },
+  // },
+  {
+    label: '状态',
+    field: 'progressStatus',
+    component: 'Select',
+    componentProps: {
+      options: getDictOptions('document_task_status'),
+    },
+  },
+];
+
+const { renderDict } = useRender();
+export const columns: BasicColumn[] = [
+  {
+    title: '文档名称',
+    dataIndex: 'documentName',
+  },
+  {
+    title: '模型所属区域',
+    dataIndex: 'taskRegion',
+    customRender: ({ value }) => renderDict(value, 'model_region'),
+  },
+  {
+    title: '模型所属行业',
+    dataIndex: 'taskIndustry',
+    customRender: ({ value }) => renderDict(value, 'model_industry'),
+  },
+  {
+    title: '上传时间',
+    dataIndex: 'createTime',
+  },
+  {
+    title: '提交人',
+    dataIndex: 'createUser',
+    auth: 'documentReview:DocumentTasks:tableShow',
+  },
+  {
+    title: '进度',
+    dataIndex: 'progress',
+  },
+];
+export const childColumns: BasicColumn[] = [
+  {
+    title: '任务名称',
+    dataIndex: 'taskName',
+    customRender: ({ value,record }) => renderDict(value, record.taskType),
+  },
+  {
+    title: '任务类型',
+    dataIndex: 'taskType',
+    ifShow: false,
+    customRender: ({ value }) => renderDict(value, 'task_type'),
+  },
+  {
+    title: '任务耗时',
+    dataIndex: 'taskDuration',
+  },
+  {
+    title: '状态',
+    dataIndex: 'progressStatus',
+    customRender: ({ value }) => renderDict(value, 'document_task_status'),
+  },
+];
+export const modalSchemas: FormSchema[] = [
+
+  {
+    label: '任务名称',
+    field: 'taskNameList',
+    required: true,
+    component: 'Select',
+    componentProps: () => {
+      const isSuperAdmin = roleList.includes(RoleEnum.SUPER_ADMIN);
+      let options = getDictOptions('scheme_review');
+      return {
+        options: options,
+        mode: 'multiple',
+      };
+    },
+  },
+
+  // {
+  //   label: '预计时间',
+  //   field: 'estimatedCompletionTime',
+  //   required: true,
+  //   component: 'DatePicker',
+  //     componentProps: {
+  //       showTime: true,
+  //       format: 'YYYY-MM-DD HH:mm:ss',
+  //       valueFormat: 'YYYY-MM-DD HH:mm:ss',
+  //     },
+  // },
+  // {
+  //   label: '状态',
+  //   field: 'progressStatus',
+  //   required: true,
+  //   component: 'Select',
+  //     componentProps: {
+  //       options: getDictOptions('document_task_status')
+  //     },
+  // },
+];
diff --git a/src/views/sjjTender/DocumentTasks/DocumentTasksModal.vue b/src/views/sjjTender/DocumentTasks/DocumentTasksModal.vue
new file mode 100644
index 0000000..d94e538
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/DocumentTasksModal.vue
@@ -0,0 +1,76 @@
+<template>
+  <PageWrapper dense>
+    <BasicModal
+      v-bind="$attrs"
+      :title="title"
+      @register="registerInnerModal"
+      @ok="handleSubmit"
+      @cancel="resetForm"
+    >
+      <BasicForm @register="registerForm" />
+    </BasicModal>
+  </PageWrapper>
+</template>
+
+<script setup lang="ts">
+  import { PageWrapper } from '@/components/Page';
+  import { BasicModal, useModalInner } from '@/components/Modal';
+  import { BasicForm, useForm } from '@/components/Form';
+  import { computed, ref, unref } from 'vue';
+  import {
+    DocumentTasksInfo,
+    DocumentTasksAdd,
+    DocumentTasksUpdate,
+  } from '@/api/documentReview/DocumentTasks';
+  import { ModelUserPromptssettingInfoByUserId } from '@/api/modelConfiguration/ModelUserPromptssetting/index';
+  import { modalSchemas } from './DocumentTasks.data';
+  import { TaskType } from '@/enums/taskEnum';
+
+  defineOptions({ name: 'DocumentTasksModal' });
+
+  const emit = defineEmits(['register', 'reload']);
+
+  const isUpdate = ref<boolean>(false);
+  const title = computed<string>(() => {
+    return isUpdate.value ? '新增方案审核任务' : '新增方案审核任务';
+  });
+
+  const [registerInnerModal, { modalLoading, closeModal }] = useModalInner(
+    async (data: { record?: Recordable; update: boolean }) => {
+      modalLoading(true);
+      const settings = await ModelUserPromptssettingInfoByUserId({taskType: TaskType.SCHEME_REVIEW.value});
+      await setFieldsValue(settings);
+      //不需要修改
+      const { record, update } = data;
+      isUpdate.value = update;
+      if (update && record) {
+        // const ret = await DocumentTasksInfo(record.id);
+        await setFieldsValue(record);
+      }
+      modalLoading(false);
+    },
+  );
+
+  const [registerForm, { setFieldsValue, resetForm, validate }] = useForm({
+    labelWidth: 100,
+    showActionButtonGroup: false,
+    baseColProps: { span: 24 },
+    schemas: modalSchemas,
+  });
+  async function handleSubmit() {
+    try {
+      modalLoading(true);
+      const data = await validate();
+      data['ossId'] = data['ossId'][0];
+      await DocumentTasksAdd(data);
+      emit('reload');
+      closeModal();
+      await resetForm();
+    } catch (e) {
+    } finally {
+      modalLoading(false);
+    }
+  }
+</script>
+
+<style scoped></style>
diff --git a/src/views/sjjTender/DocumentTasks/DocumentTasksTable.vue b/src/views/sjjTender/DocumentTasks/DocumentTasksTable.vue
new file mode 100644
index 0000000..2ece077
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/DocumentTasksTable.vue
@@ -0,0 +1,286 @@
+<template>
+  <BasicTable @register="registerTable" @expand="tabelexpand">
+    <template #toolbar v-if="props.showToolbar">
+      <div >
+        <a-button
+          id="how-to-edit"
+          class="font-bold"
+          type="link"
+          @click="openDrawer(true, { value: '', type: 'def' })"
+          >👉如何新增任务?
+        </a-button>
+        <a-button type="primary" @click="handleAdd">新增</a-button>
+      </div>
+    </template>
+    <template #bodyCell="{ column, record }">
+      <template v-if="column.key === 'action'">
+        <TableAction
+          stopButtonPropagation
+          :actions="[
+            {
+              label: record.childrenTasks.length > 1 ? '下载全部' : '下载',
+              icon: IconEnum.DOWNLOAD,
+              type: 'primary',
+              color: 'success',
+              ghost: true,
+              ifShow: () => {
+                if (record.progress.includes('100%')) {
+                  return true;
+                } else {
+                  return false;
+                }
+              },
+              onClick: handleDownload.bind(null, record),
+            },
+          ]"
+        />
+      </template>
+    </template>
+    <template #expandedRowRender>
+      <BasicTable @register="registerChildTable">
+        <template #bodyCell="{ column, record }">
+          <template v-if="column.key === 'action'">
+            <TableAction
+              stopButtonPropagation
+              :actions="[
+                {
+                  label: '详情',
+                  icon: IconEnum.EDIT,
+                  type: 'primary',
+                  ghost: true,
+                  ifShow: () => {
+                    if (
+                      record.progressStatus != 'PENDING' &&
+                      record.progressStatus != 'STARTED' &&
+                      record.progressStatus != 'REVOKED'
+                    ) {
+                      return true;
+                    } else {
+                      return false;
+                    }
+                  },
+                  onClick: handleDetail.bind(null, record),
+                },
+                {
+                  label: '下载',
+                  icon: IconEnum.DOWNLOAD,
+                  type: 'primary',
+                  color: 'success',
+                  ghost: true,
+                  ifShow: () => {
+                    if (
+                      record.progressStatus != 'PENDING' &&
+                      record.progressStatus != 'STARTED' &&
+                      record.progressStatus != 'REVOKED'
+                    ) {
+                      return true;
+                    } else {
+                      return false;
+                    }
+                  },
+                  onClick: handleDownload.bind(null, record),
+                },
+                {
+                  label: '终止任务',
+                  icon: IconEnum.DELETE,
+                  type: 'primary',
+                  danger: true,
+                  ghost: true,
+                  ifShow: () => {
+                    if (record.progressStatus == 'PENDING') {
+                      return true;
+                    } else {
+                      return false;
+                    }
+                  },
+                  popConfirm: {
+                    placement: 'left',
+                    title: '是否终止当前任务?',
+                    confirm: handleStop.bind(null, record),
+                  },
+                },
+              ]"
+            />
+          </template>
+        </template>
+      </BasicTable>
+    </template>
+  </BasicTable>
+  <DocumentTasksModal @register="registerModal" @reload="reload" />
+  <DocsDrawer @register="registerDrawer" />
+</template>
+
+<script setup lang="ts">
+  import { BasicTable, useTable, TableAction } from '@/components/Table';
+  import { DocumentTasksList, DocumentTasksStop } from '@/api/documentReview/DocumentTasks';
+  import { getTasksPermissionsByUserId } from '@/api/taskPermissions/DocumentTasksPermissions';
+  import {
+    DocumentTaskResultsInfoByTaskId,
+    DocumentTaskResultDownload,
+  } from '@/api/documentReview/DocumentTaskResults';
+  import { useModal } from '@/components/Modal';
+  import DocumentTasksModal from './DocumentTasksModal.vue';
+  import { formSchemas, columns, childColumns } from './DocumentTasks.data';
+  import { IconEnum } from '@/enums/appEnum';
+  import { useDrawer } from '@/components/Drawer';
+  import DocsDrawer from '@/views/documentReview/DocumentTasks/DocsDrawer.vue';
+  import { onMounted, ref } from 'vue';
+  import { DocumentTasksPermissionsVO } from '@/api/taskPermissions/DocumentTasksPermissions/model';
+  let props = defineProps(['useSearchForm', 'showTableSetting', 'showToolbar', 'pagination']);
+  defineOptions({ name: 'DocumentTasks' });
+  const documentData = ref<DocumentTasksPermissionsVO>();
+  const [registerDrawer, { openDrawer }] = useDrawer();
+  const childTableData = ref([]);
+  const [registerTable, { reload }] = useTable({
+    api: DocumentTasksList,
+    showIndexColumn: false,
+    clickToRowSelect: false,
+    rowKey: 'id',
+    title: props.showTableSetting?"方案审核任务列表":'',
+    expandRowByClick: false,
+    useSearchForm: props.useSearchForm,
+    showTableSetting: props.showTableSetting,
+    beforeFetch: async (record) => {
+      if (props.pagination == false) {
+        (record.pageNum = 1), (record.pageSize = 5);
+      }
+    },
+    pagination: props.pagination,
+    formConfig: {
+      schemas: formSchemas,
+      baseColProps: {
+        xs: 24,
+        sm: 24,
+        md: 24,
+        lg: 6,
+      },
+    },
+    columns: columns,
+    actionColumn: {
+      width: 200,
+      title: '操作',
+      key: 'action',
+      fixed: 'right',
+    },
+  });
+  const [registerChildTable, { setProps: setChildProps }] = useTable({
+    size: 'small', //紧凑型表格
+    api: getchildTableData,
+    columns: childColumns,
+    rowKey: 'id',
+    useSearchForm: false,
+    showIndexColumn: false,
+    showTableSetting: false,
+    pagination: false,
+    maxHeight: 50,
+    actionColumn: {
+      width: 200,
+      title: '操作',
+      key: 'action',
+      fixed: 'right',
+    },
+  });
+  // //定时器变量 方便在页面销毁的时候清楚定时器
+  // const timer = ref<any>(null);
+  // //页面在刷新的时候可以加loading显示 方便页面展示
+  // const loading = ref(false);
+  // //使countdown定时增加 如果增加到我们想要的时间 也就是变量autoRefreshTime 执行刷新
+  // const countdown = ref(0);
+  // //定时刷新的时间 现在设置的为6 也就是6秒刷新一次数据
+  // const autoRefreshTime = ref(30);
+  const [registerModal, { openModal }] = useModal();
+  onMounted(async () => {
+    documentData.value = await getTasksPermissionsByUserId();
+    // timer.value = window.setInterval(() => {
+    //   //不loading的时候才会执行
+    //   if (!loading.value) {
+    //     //countdown小于我们想要的定时时间的时候 定时器也是一秒执行一次 就继续+1
+    //     if (countdown.value < autoRefreshTime.value) {
+    //       countdown.value = countdown.value + 1;
+    //       //当定时器到时间的时候 去干我们想干的事情 refresh()
+    //       if (countdown.value === autoRefreshTime.value) {
+    //         countdown.value = 0;
+    //         reload();
+    //       }
+    //     }
+    //   }
+    // }, 1000);
+  });
+  const cleanHtml = (content) => {
+    // 移除DOCTYPE和html标签
+    content = content.replace(/<!DOCTYPE[^>]*>/i, '');
+    content = content.replace(/<html[^>]*>/i, '');
+    content = content.replace(/<\/html>/i, '');
+
+    // 移除head部分
+    content = content.replace(/<head>[\s\S]*?<\/head>/i, '');
+
+    // 移除body标签
+    content = content.replace(/<body[^>]*>/i, '');
+    content = content.replace(/<\/body>/i, '');
+
+    return content.trim();
+  };
+  async function handleDetail(record: Recordable) {
+    try {
+      let res = await DocumentTaskResultsInfoByTaskId(record.id);
+      if (record.taskName == 'schemEvaluation') {
+        // res.result=generateTable(JSON.parse(res.result as string))
+        const updatedHtmlText = res.result?.replace(
+          /文件名称：\S+/g,
+          `文件名称：${record.documentName}`,
+        );
+
+        openDrawer(true, { value: cleanHtml(updatedHtmlText), type: 'markdown' });
+      } else if (record.taskName == 'checkDocumentError') {
+        openDrawer(true, { value: res.result, type: 'markdown' });
+      } else {
+        openDrawer(true, { value: res.result, type: 'markdown' });
+      }
+      console.log('res', res);
+    } catch (ex) {
+      openDrawer(true, { value: '加载失败，请刷新页面', type: 'markdown' });
+    }
+    //根据record.id查询结果详情
+  }
+
+  async function handleStop(record: Recordable) {
+    await DocumentTasksStop(record.id);
+    await reload();
+  }
+
+  function handleAdd() {
+    openModal(true, { update: false });
+  }
+  function tabelexpand(expanded, record) {
+    if (expanded) {
+      childTableData.value = record.childrenTasks;
+      // reloadChildTable()
+      console.log('expanded, record', expanded, record);
+    }
+  }
+  // 修改后的 getchildTableData 函数
+  function getchildTableData() {
+    console.log('childTableData', childTableData.value);
+    const height = 50 * childTableData.value.length;
+    setChildProps({ maxHeight: height });
+
+    // 返回一个 Promise 对象，包含预期的数据结构
+    return Promise.resolve(childTableData.value);
+  }
+  async function handleDownload(record: Recordable) {
+    if (record.childrenTasks?.length > 1) {
+      await DocumentTaskResultDownload(record.childrenTasks.map((item) => item.id));
+      await reload();
+    } else if (record.childrenTasks?.length == 1) {
+      await DocumentTaskResultDownload([record.childrenTasks[0].id]);
+      
+      await reload();
+    } else {
+      await DocumentTaskResultDownload([record.id]);
+      await reload();
+    }
+  }
+</script>
+
+<style scoped></style>
diff --git a/src/views/sjjTender/DocumentTasks/SjjDocumentTasks.data.ts b/src/views/sjjTender/DocumentTasks/SjjDocumentTasks.data.ts
new file mode 100644
index 0000000..0bba74f
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/SjjDocumentTasks.data.ts
@@ -0,0 +1,119 @@
+import { BasicColumn } from '@/components/Table';
+import { FormSchema } from '@/components/Form';
+import { getDictOptions } from '@/utils/dict';
+import { useRender } from '@/hooks/component/useRender';
+import { uploadDocument } from '@/api/documentReview/DocumentTasks';
+export const formSchemas: FormSchema[] = [
+      {
+        label: '任务名称',
+        field: 'taskName',
+        component: 'Select',
+        componentProps: {
+          options: [{
+            label: '招标文件审核',
+            value: 'sjjbidAnalysis',
+          }]
+        },
+      },
+      {
+        label: '招标文件名称',
+        field: 'tenderDocumentName',
+        component: 'Input',
+      },
+      {
+        label: '投标文件名称',
+        field: 'bidDocumentName',
+        component: 'Input',
+      },
+      {
+        label: '进度状态',
+        field: 'progressStatus',
+        component: 'Select',
+          componentProps: {
+            options: getDictOptions('document_task_status')
+          },
+      },
+      {
+        label: '文件是否已删除',
+        field: 'deleteFlag',
+        component: 'Select',
+        componentProps: {
+          options: getDictOptions('sys_yes_no')
+        },
+      },
+];
+
+const { renderDict } = useRender();
+export const columns: BasicColumn[] = [
+  {
+    title: '任务ID',
+    dataIndex: 'id',
+    ifShow: false,
+  },
+      {
+        title: '任务名称',
+        dataIndex: 'taskName',
+        customRender: ({ value }) => "招标文件审核",
+        
+      },
+      {
+        title: '招标文件名称',
+        dataIndex: 'tenderDocumentName',
+      },
+      {
+        title: '投标文件名称',
+        dataIndex: 'bidDocumentName',
+      },
+      {
+        title: '进度状态',
+        dataIndex: 'progressStatus',
+          customRender: ({ value }) => renderDict(value, 'document_task_status'),
+      },
+      {
+        title: '文件是否已删除',
+        dataIndex: 'deleteFlag',
+          customRender: ({ value }) => renderDict(value, 'sys_yes_no'),
+      },
+];
+
+export const modalSchemas: FormSchema[] = [
+      {
+        label: '任务名称',
+        field: 'taskName',
+        required: true,
+        component: 'Select',
+        componentProps: {
+          options: [{
+            label: '招标文件审核',
+            value: 'sjjbidAnalysis',
+          }]
+        },
+      },
+      {
+        label: '招标文件',
+        field: 'tenderDocOssId',
+        component: 'Upload',
+        componentProps: {
+          accept: ['.docx', '.pdf'],
+          maxSize: 500,
+          multiple: false,
+          resultField: 'ossId',
+          api: uploadDocument,
+          beforeUploadPrompt:"严禁在本互联网非涉密平台处理、传输国家秘密。请再次确认您上传的文件资料不涉及国家秘密。"
+        },
+      },
+      {
+        label: '投标文件集',
+        field: 'bidDocOssId',
+        required: true,
+        component: 'Upload',
+        componentProps: {
+          accept: ['.zip'],
+          maxSize: 500,
+          multiple: false,
+          resultField: 'ossId',
+          api: uploadDocument,
+          beforeUploadPrompt:"严禁在本互联网非涉密平台处理、传输国家秘密。请再次确认您上传的文件资料不涉及国家秘密。"
+        },
+      },
+];
diff --git a/src/views/sjjTender/DocumentTasks/SjjDocumentTasksModal.vue b/src/views/sjjTender/DocumentTasks/SjjDocumentTasksModal.vue
new file mode 100644
index 0000000..623245e
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/SjjDocumentTasksModal.vue
@@ -0,0 +1,74 @@
+<template>
+  <BasicModal
+    v-bind="$attrs"
+    :title="title"
+    @register="registerInnerModal"
+    @ok="handleSubmit"
+    @cancel="resetForm"
+  >
+    <BasicForm @register="registerForm" />
+  </BasicModal>  
+
+
+</template>
+
+<script setup lang="ts">
+  import { BasicModal, useModalInner } from '@/components/Modal';
+  import { BasicForm, useForm } from '@/components/Form';
+  import { computed, ref, unref } from 'vue';
+  import { SjjDocumentTasksInfo, SjjDocumentTasksAdd, SjjDocumentTasksUpdate } from '@/api/documentReview/SjjDocumentTasks';
+  import { modalSchemas } from './SjjDocumentTasks.data';
+
+
+  defineOptions({ name: 'SjjDocumentTasksModal' });
+
+  const emit = defineEmits(['register', 'reload']);
+
+  const isUpdate = ref<boolean>(false);
+  const title = computed<string>(() => {
+    return isUpdate.value ? '编辑审计局标书任务' : '新增审计局标书任务';
+  });
+
+  const [registerInnerModal, { modalLoading, closeModal }] = useModalInner(
+    async (data: { record?: Recordable; update: boolean }) => {
+      modalLoading(true);
+      const { record, update } = data;
+      isUpdate.value = update;
+      if (update && record) {
+        const ret = await SjjDocumentTasksInfo(record.id);
+        await setFieldsValue(ret);
+      }
+      modalLoading(false);
+    },
+  );
+
+  const [registerForm, { setFieldsValue, resetForm, validate }] = useForm({
+    labelWidth: 100,
+    showActionButtonGroup: false,
+    baseColProps: { span: 24 },
+    schemas: modalSchemas,
+  });
+
+  async function handleSubmit() {
+    try {
+      modalLoading(true);
+      const data = await validate();
+      if (unref(isUpdate)) {
+        await SjjDocumentTasksUpdate(data);
+      } else {
+        data['tenderDocOssId'] = data['tenderDocOssId'][0];
+        data['bidDocOssId'] = data['bidDocOssId'][0];
+        await SjjDocumentTasksAdd(data);
+      }
+      emit('reload');
+      closeModal();
+      await resetForm();
+    } catch (e) {
+    } finally {
+      modalLoading(false);
+    }
+  }
+
+</script>
+
+<style scoped></style>
diff --git a/src/views/sjjTender/DocumentTasks/caozuomiaoshu.md b/src/views/sjjTender/DocumentTasks/caozuomiaoshu.md
new file mode 100644
index 0000000..df39fd6
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/caozuomiaoshu.md
@@ -0,0 +1,2248 @@
+## 第一步：新增任务
+
+<img src="data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAAAfgAAAEZCAYAAAB7MDdYAAAgAElEQVR4nO3dd3xUdb7/8deUNEro
+hCKxEKSpuKirsriiKHAFUcTOFVRAZJuAi4IFo7sKihTXgiwgwl5wvUjZKIqsXED5IeguCiygJEFE
+EEINLSQhM+f3x5lJJpNJI5k5U97Px4OHmTPnnPkcJPM+33LOsZ0+fdpAREREwlpubi7Jyck4nc4q
+rW8Pcj0iIiJiAQW8iIhIFFLAi4iIRCFnnTp1rK5BREQkKhiGgcvloqioCLfbbWktasGLiIjUEpvN
+htPpJDExkfj4eEtrUcCLiIgEgdPpJCEhwbLPV8CLiIgEicPhsKwlr4AXEREJIqfTid0e+rhVwIuI
+iARZVW9OU5sU8CIiIkHmcDhC/pkKeBERkSCz2Wwh/0wFvIiISBRSwIuIiEQhBbyIiEgUUsCLiIhE
+IefOnTutriEkbDYb8fHx1K9fn8aNG1tdjohEqJycHHJzj3HmzBkMw7C6nBqx2WwkJSXRsGEjUlJS
+zmkfb34O/9gMOw5AoauWCwyxeAd0bAG3dYHf/trqamrOZkT6v9AqMgyD/Px8jh8/TkFBAa1atSIu
+Ls7qskQkQhQUFLB79w8kJCTStGlT6tata8nM6NpkGAanT5/m8OHDFBTkc8EFF1b51qq7j8AjC2Hz
+viAXaZEureGv98MFTWpvn3l5eTXaPjc3l+Tk5CpfUx8zAe/r2LFjnDhxgvPPP9/qUkQkQnz//Xc0
+atSI5s3PraUb7g4ezOHYsWO0b9+hSuv3ej16w92rS2tY+fva21+oAz4mx+AbNWpEQkICR48etboU
+EYkAOTk5JCQkRm24AzRvnkJCQiI5OTmVrvvm59Ef7mAe45ufW13FuYvJgAdo0KABJ0+etLoMEYkA
+ubnHaNq0qdVlBF3Tpk3JzT1W6Xr/2ByCYsJEJB9rzAZ8YmIihYWFVpchIhHgzJkz1K1b1+oygq5u
+3bqcOXOm0vV2HAhBMWEiko81ZgPeZrNF/AxYEQkNwzAifkJdVVT1ezHSZ8tXRyQfa8wGvIiISDRT
+wIuIiESh0D+gVkQkBm34ywhmVnXCVpehzP3DL4Naj0Q/BbyISAhc84eZXOO37OfFTzOd3/HKwJbl
+bletE4Pmt/DixNtodc5VWmvkcBgNXDyr/HXWPQcLnocZvssmQc5HMHBdsCuMLAp4EZEgqzik03no
+4wCLPWEN0OyWdPMkYN8/eOINGDXxNlqxnyXj0/nx9pmMvhrY+DoPLQvSAdS2OyHnyvLfzplUdtnx
+bDP4F/wM6c8BnpCf9ji0A9r1g5x+ZbfL/Bd0/6CW6o4wERPwu3fvplmzZuVeqnL69GkOHTrEBRdc
+EOLKREQqFqj1DlVrwe8BDn1c+iTg6aE+L/46gof+6vm5eWptlBt8H0CKX+iumwQ52XApcLAtfD3O
+bM37mzELLn4cBt0JNIL7gZRxgT9m8XMQvbcmqlzEBLzD4SA7O5vLLrss4PvZ2dk0atQoxFWJiFTR
+vn/wxISPOVTmjbIt+Mse8bTKOfeu/Yjg05JfOA52DjcDvvs4T+AD6wJ0vY+e4tm2FaQ/X/FH5ETw
+dew1FTEB36ZNG06cOMGuXbu46KKLSr23a9cuHA4Hbdq0sag6EZGquIQRc35fHNhlg9rT7e7z/tMf
+Hy5nX+V07UfABL1pj8P9zUovu9+nW963i767t+v9EKyrB92TzOULx5m9AIufg/Sk0vuK5W55XxET
+8ABpaWn8+9//pkGDBjRpYj7i58iRIxw4cIArrrjC4upERCrzH2YOHcHMUssCtOA9/2018EXmDiy7
+l0hvwY+eYna/T3scrvqxgjC+E3I6m6304kl13WGn31i7b6DHere8r4gK+ISEBNq3b09mZmZxwGdm
+ZtK+ffsqP+JQRMQ61WvB+y778KD/vvxPDErvO1K0u7LiCXdUfufcMvvI9Pw3Jcns5o9VERXwAE2a
+NOHEiRNs374dgJSUlOKwFxEJb9VrwZda5jMuX9ZXTBu6sTYKDLkKu9M9Lfjq7EMt+BIRF/AAF154
+IZs3m9ecdOrUyeJqRESqoPVtvDLntlKLqtPVvsV3tnxAl3BtzSq0RG204CWwiAx4gIsvvtjqEkRE
+qqz8a+EDTJYLcMMateD9dId1Hc0u+PK66AH2xPDNbyI24JOSkipfSUQkTET15W7naPSUSlYIcL28
+1/39zJn0qc+Vc5Jwp3kDnK9roc5IFbEBLyISGcqbJOdV3p3sfk0PPmeNd7tKu+hhy9ARzIyAyXaB
+LpOr1CFImQK0gAbenwF8r4P3u0Ne5r8C3ywnVijgRUSCqiV3TJzJHee07SCG1HI14cB7mdw5+aCC
+SXQVtPhjkR4XKyIiEoUU8CIiIlFIAS8iIhKFYjbgDcPAZrNZXYaIRACbzYZhGFaXEXRV/V6Mc4Sg
+mDARyccaswGfn59PfHy81WWISARITEzk9OnTVpcRdKdPnyYxMbHS9do1D0ExYSKSjzVmA/748ePU
+r1/f6jJEJAIkJzfg8OHynuoWPQ4fPkxycoNK1+t9SQiKCRORfKwxGfDHjh2joKCAxo0bW12KiESA
+5s2bk59/hoMHo/fRJQcP5pCff4bmzStvsg7rBp1i4N48nVqaxxqpYibgDcPgzJkzHDhwgBMnTtCq
+VavKNxIRAex2O23apHL06FF2797NqVOnomJM3jAMTp06xe7duzl69Cht2qRit1ceC4lOeHlgdId8
+p5bmMSZG8N1ibN9//33k/yutApvNRnx8PPXr11fLXUSqraioCMMwOHToECdOHCc/Pz/iQ95ms5GY
+mEhycgOaNWuGzWbD6axaoh0+A2fd8O6XsHIbZB6Es64gFxxkcQ5zzL1XZ3jwWoizQ9NavCt6Xl5e
+jbbPzc0lOTm5yv+PbEak/wsVEQkBwzBwuVwRH+rlsdlsOByOKl9dVOSG3AIz5KNRnB0aJoCzFvu5
+Qx3wEdz5ICISOt7Wrdvtxu12R03Q22w27HZ7lbrmfTk9rdtTZyG/CIoMiPS/EpsNnDazW75enNXV
+1JwCXkSkGs4lDKNZvbjoCMNopH+lIiIiUUgBLyIiEoUU8CIiIlFIAS8iIhKFFPAiIiJBZsVVFwp4
+ERGRIHO5Qn8XIAW8iIhIkBUVFYX8MxXwIiIiQVRUVITbHfpb/ingRUREgsTlclFYWGjJZ+tOdiIi
+IkFQVFRkWbiDAl5ERKTWeB9KZFW3vC9nTZ9uIyIiIuFHY/AiIiJRSAEvIiIShRTwIiIiUUgBLyIi
+EoUU8CIiIlFIAS8iIhKFFPAiIiJRSAEvIiIShRTwIiIiUUgBLyIiEoUU8CIiIlFIAS8iIhKFFPAi
+IiJRSAEvIiIShRTwIiIiUchZp04dq2sQERGJCoZh4HK5KCoqwu12W1qLWvAiIiK1xGaz4XQ6SUxM
+JD4+3tJaFPAiIiJB4HQ6SUhIsOzzFfAiIiJB4nA4LGvJK+BFRESCyOl0YreHPm4V8CIiIkHmdDpD
+/5kh/0QRER9vfg7/2Aw7DkChy+pqaibeAR1bwG1d4Le/troaCScOhyPkn2kzDMMI+aeKSMzbfQQe
+WQib91ldSXB0aQ1/vR8uaGJ1JRIu8vLyarR9bm4uycnJVe4NUBe9iFgimsMdzGN7ZKHVVUgsU8CL
+SMi9+Xl0h7vX5n3msYpYQQEvIiH3j81WVxA6sXSsEl4U8CIScjsOWF1B6MTSsYaL/Px8HnjgAS68
+8EIuuOAC+vbty759MdBl5Eez6EUk5CJ9tnx1WHmsR48eZf369ezevZvvvvsOwzBo164dqamptG/f
+ns6dO9fq5917771s2LCh2tvt3r27VuvYsmULX3zxBYMGDaJZs2ZMnz6d1atX89///d+1+jnhTgEv
+IhKF/v73v/PGG2+wd+9eAC688EIAli9fDkBSUhIjRoxg1KhRtfaZ11xzDddcc02t7e9cnD59mg8+
++ACbzcbTTz9NnTp1WLJkCcuXL6d37940a9bM0vpCSQEvIhJlHnroIVavXk3z5s2ZNWsWXbt2pUkT
+83q9I0eO8M033zB16lSmT5/Opk2bmD9/fq18bnknC4cOHeKbb76hV69etfI5vvbv38/AgQNp0KAB
+Xbt25aOPPiIvL48HH3wQ79NSH3roIV577TW6devG7bffzg8//MDOnTt599136dq1a63XFC50HbyI
+hFzKOKsrCK2cSTXb/vjx4zRo0KBK665atYqhQ4dy5ZVX8t577xEXF1fuui+88ALvvPMOc+bMoWfP
+njUrsgIjR47k22+/5aOPPio+0agt9957L7t27aJTp06sXbuWq6++mldeeYXU1NRS6+Xm5vKnP/2J
+xYsXc/nll5Ofn8/x48dZvXo1iYmJtVpTeXQdvMQe1yn44VXI/bLKm3w2zwyJkecwQ3nkOHPbz2p5
+uz2fmu+nzPMsyIHu46D7p2XrnpFT+nWg45gxuQp1bi7ZV6BtfT87Wo0cDjnPwcgK1ln8XOl1Rg6H
+ncN9VrjTDOFpPovWTfJbJwIcPHiQUaNG0aRJEz744IMKwx1gwoQJdOzYkVGjRnHw4MGg1DRz5kw+
++eQT9u/fz4QJE2p1319//TUbNmzgmWee4d1332X9+vUsXLiQ1NRUli5dymOPPcbw4cN59913qVev
+HlOmTGH9+vUsW7aM6dOns3//fpYsWVKrNYUTddGLxVyQmQ7Hv4LDK+GqlVXaKtPzXXRZC5+FmyHl
+vbLrtrsB1vUuWWcJQEdYPA4GVfI56YNhwXzI9Fk2aFzJftMPwKAdfp/Vwgzlm3x3lAPdp5XsJ30a
+pPu8veQ9WPIt5AwpWX/BEc+xfgqDVldQZEcYOaTk5YzJkO7ddjWklLPtgklmjb7rA6SPhpEpFXxe
+mFj8HHRPKnmdPsn8Oz2eDcuT4X6fodZ1H0HKusr3c/8kuN/3zbbmiUH68zCjlusPhjlz5nDy5Elm
+z55d5W2eeuopHnjgAWbOnMmzzz5bq/Vs2LCBLl26FI/LP/DAA2zYsKHWxul/+OEHAFasWMHNN99M
+y5YtAXj++eeZO3cuvXr1omHDhrz00kusXr2aefPm0apVKwzDKJ6LkJ2dXSu1hCMFvFjIBVl/NsMd
+oHHlN+/e8ylc5RNYvkG54D7zv8WBHiDwZ3jOH+64HGYMCfyl/dk8M7S9QTfyPnM/d9wHM7p4ArG5
++RmfeVrr3rD0uinAfsHcx/gWwLfmcSwYDRenwMRxnhMPbw0rzJOBdjfAyN7mH9/jL3XS4uV3EkFH
+nxMGn+Py1nGTZ5sFR0rvJn0atJtU/jGEi4GrYGdPmOYN3+6wsx8snwU8bgb9xbP8NvKs4+3sznnO
+/PvKzIbmrcx9DZoEX48z93EV0K5e6I6ppnbu3EnHjh256aaq/9+77rrr6NixI1999VWt1+Mf5LU9
+Ae/uu+/m4MGDvPrqq7Rq1YpnnnmGzMxM5s6dy5tvvknfvn0BePjhh7n11ltZvXo1N9xwAxkZGbz+
++uvcdtttjB8/vlZrCifqohcLGHDyW/juSTiyqmSxzQF73yn95+eFUFjSdZjaG3JGQzswA2wS3FHV
+j/WGWRMY36WkG9v3T8Du8Bbm5y351mcfOyrpOvcJ28zVMPJbz/Jv4appMNFzbfSgaXCVX7iTA+me
+IB50edWPzft56fd5/n52lD62QTvMY/96knmi4jXoPvPv0ffvMjNAt3/YWQcXb4N0T9f7un6w9SMY
+Xdk24yA92zwBSHkecgCOwcWrYJCnSz51OFz1I3T/MehHUasyMzPp0KFDtbfr0KEDW7du5dixY0Go
+KrhGjhyJ3W4vHtvftGkTLVq0KA53gI4dO9KtWze+/NIcBmzcuDEAjzzyiCVPeQuV6D0yCV+7JsGh
+T8ouD7QM4PAKuMxnlu8BT+vWt3u+CVxcycfO8Otq92739VjYOa90V3sx316AHZDis84gT0seSrrt
+vdJHw7rRZuhyA8y4HLqvhiWe7ZcE+iwPb+u9WlLMMWOvvgdK93R43dELSk09SvHpjs+BrZ4f24V7
+F/2dkHNlyct0z7G36wc5PWHdKWjQtuzktsx/QfcPyu6u3ZWeoPe+bmv+NwfgTC3WHWTHjh07p8vA
+vNvs37+fRo0a1XZZQWUYBm63u3i+gc1mo7CwEJfLVeoJbnl5eRQWFgIlj26N9jnmCngJrZ//p9wg
+LzpTQO6+HAx36V+6OqnnUdfn9Wee1vClLSgVShXaXHqcucq6QI6ntevtHvcdo/btoseva79UYvgF
+cEV1BjzRqKLP5gWYE9C7ZJx9yXvmH/8hhVI9AKPDv3ueDyDFG9TervlxJa33aT5d9NMeh74nAnTX
+ewx8PhQFh0bnzp3ZsaP6/4B27NhBs2bN6NSpUxCqCq6vvvoKu93OoUOHALjiiis4fvw4L774Ik89
+9RROp5MFCxbwr3/9ixEjRgBw+PDh4m0vueQSy2oPNgW8hI47H/bOLfdtZ1ICjVJbUnDyNDT8FSR3
+xVG3EQkXDCi1nneC3cAuwGZPa7e5X8s0kI5wxw6/7vDK+I9r4zPu3xEWVGNX/vMH/C2YBDd5hgN8
+P2+kfxc+ZSfPpd8C6R+bP3tD/bN55uS8kS1gxljPDHLP8Xh7HIon2s0vCfdImGAH5glTO5/X3gly
+x7NhOXCwqr3NfuPy/spr9YejSy65hIyMjGpvt2PHDq699togVATr1q0r9bPT6ay1sfj169czePBg
+LrnkEn77298C0LZtW1566SWefvppli1bRt26dfnpp5/43e9+x8033wzALbfcwqeffsoLL7xAYmIi
+999/f0UfE7EU8BI6eVlgnK1wFUd8HHWaNIQmLSEt8DVK7ZoDR2DxZsDTmr+jsrHqLmYYL65u48an
+5R2oBT9jcuW7yFwNKQfga8+Qgn+Ilmp1p8ClHc0TCO+yGZNKJgNWNMluy8fmiYB/+Htb7f58W/Fb
+PHMT+kZIuIN5CaL5Q+AWfLWcCTxTfvFzEEF/JXTu3Jl33nmHV199lT/+8Y9V2mbu3LkcPnw4aHeg
++/DDD4tvX5uXl8d77wX4x3iOjh07RlFREU888QTJycnFy++55x6uvfZa1q1bR35+Pt26dSs1N8Hh
+cDBhwgQ++ugjDhyI3ocFKOAlrBzdtRdXkYtGffqU+4/zpiHw9adw1XslLVtva74iN3WBxf7fLUfM
+SW4VKZ5Vf4P5essKcyw+fXRJMF4M7KxgH+l9KD4Z8b9Ezt+MISVd/9UR6ETAfyZ9oB4J/20jxcjh
+kN4WFn5kvr7qcVj3o9naTq0HOZV8b3vH6Bd+BCSVXGbnr9rzISzUr18/3n//fd544w1uvPHGcu/S
+lpOTw5YtW+jatSvvvPMO11xzDQMHDgxKTRMmTGDTpk1kZmby1FNPUbdu3co3qqLevXvTunVrJk+e
+zNatW3n//fe57bbb+P3vf09qamqZlvmiRYv4y1/+Qr9+/fjpp59ITExk8ODBtVZPuFHAS+gkXYh5
+4Ya73FUaX3Se+UNifIW7SvWdYNexBmPGnkl2vt37pWbHe2e0d4S+mAFwWR/gIGyZ7znB8AwPlAp4
+z+Q831byHs9/K2zB14bNJUMBC4aUs47fpETvMID3UsCwd6cn3MfB6O7m/5uvpwCPw7rh0ByYFui6
+d5/u+IXeFn936BslLfiEhAQmTpzIXXfdxejRo1m7dm3A9bZu3coTTzxB586dsdvtpKenB+1ubnXr
+1uVPf/oT//nPf2q9l8DpdDJt2jTuuecesrOzufnmm3n99df58MMPGTNmDP369QNg48aNTJ06lY0b
+N3LLLbewbNky9u/fz+TJk2natGmt1hROFPASOo66kHIb5CwN+HZ+7ilOHjyCM7kNja4s/1If37Hs
+9BsgfbV597gcTzd9RTd38TVybOC7n3m78dulmJ+ViTkEsPPbknVm9CqZXZ/eJ8BOfCbn+ausBV8T
+vicLZSbSAXu+rcachXDmO8nOx+gpZiizrZweiXVwcaDgj5IWPJhj0FOnTqWgoKDcdbyXxH311Ve8
+9dZb53RpXSAVPUnukksuKff9mgT/L3/5Sz755BPOP/98kpKSePDBB0lPT2fUqFH06dMHp9PJhAkT
+yM/P55133uHGG2+kqKiIbdu20aVLJJzNnjsFvIRW6m/gzB448e8ybyU2rEdiw3qQ3BUc5bQmNpft
+eh7Zwgxbb1hXdKOb8vjfza34RjC9Iae3T3B6x6lTYMG35p3wqjsprboteP/awO8kpqN5cuM9Vv9W
+eJlJek3ga7+WfSR20YPPRLtDJa3xS4Fp1Z0UF+Yt+Kreh96rR48eFb6/dat57UlhYSEbNmyo1o1x
+KjJ9+nRLHhfre4LSpUsXRo0axZAhQ8jIyKBFixZkZWUxduxYbrzxRsBs+Ud7uIMeNiNWydsJuRvh
++Ndw8j9gFJnLbXHQ7jloVPld7SRy6WEz0elcwh1q/w53R48e5frrr+fkyZOAGeiLFy+2PNRD/bAZ
+BbyIhJwCXmKRniYnIiIiNaaAFxERiUIKeBEJuThH5etEi1g6VgkvCngRCbl2za2uIHRi6VglvCjg
+RSTkekfv8z3KiKVjlfCigBeRkBvWDTq1tLqK4OvU0jxWESso4EUk5BKd8PLA6A75Ti3NY0zU7cTE
+IroOXkQscfgMnHXDu1/Cym3mY4DPuqyuqmbiHOaYe6/O8OC1EGeHpklWVyXhQje6EZGYUOSG3AIz
+5KNRnB0aJoBT/aTiEeqAV+eRiFjC6WndnjoL+UVQZECkNzdsNnDazG75enFWVyOxTgEvIpaqF6cw
+FAkGdR6JiIhEIQW8iISPrZth8p/h/tusrkQk4qmLXkSsYxjw76/gkwxY8RHs3WMu/69bra1LJAoo
+4EUktFwu+HIdrPgQPv0IDuaUXefyK0Nfl0iUUcCLSPAVFsIX/weffAj//ARyj1W8/i+uCE1dIlHM
+efbsWatrEJEoZ1+0ENtnK7B//SWcPFHp+mc7XQr6bpIwZrPZsNls2O12bDab1eUEZCssLIzwK09F
+JJLYtnyD/dU/Y1//RcD3jU6XUJTxfyGuSuTc2e12HI7Knwsc6hvdaBa9iIRWfj62r74s922ji7rn
+JbK43W6KiooItxvDKuBFJHSyM3E8MghbUVG5qxiXK+Al8hiGgdsdXvddVsCLSGgcOYxz8J3YTp0q
++15SneIfFfASqdxud1i14hXwIhJ8+WdwPnwPtpz9Zd4yrv4Vrtdmmi/q1cdo2y7ExYnUnnBqxesy
+OREJLrcbx28fxrZta9m3Lr0c1+wFEJ+APbkBXHq5BQWK1J5wasEr4EUkqBzPjsW+dlWZ5UaHTrjm
+LSrunjf69IPmLUJdnkitUsCLSEywz3oT+/t/K7PcuOAiiv62BJIbFC9z970dCgpCWZ5IVFPAi0hQ
+2D/JwPHy82WWGy1b4/qfJdCocenlv7oejh8PVXkiUU8BLyK1zvbNv7CPGVlmudG4KUULlkKLVoE3
+bNAg8HIRqbawmUUfTjMPRaQGfvwBx9D7sPndataon0zRgiWQeoFFhYnElrAJ+Pz8fKtLEJGaOnoE
+5wMDsZ0o3dVuJCaZE+radbCoMJHYEzYBLyIRLv8Mzgfvxvbz3lKLjbg4XHMWYlz2C4sKE4lNCngR
+qTnvte7bS1/rbtjtuN6ci3H1rywqTCR2KeBFpMYcLz1X5lp3A3BNeQvjxl7WFCUS4xTwIlIjtr/P
+x/7uzDLL3S+8gnHrHRZUJCKggJcq28ucvmmkpY1hTcBlaxiT1oc5P1awix/n0CctjbS+c9hbwWoS
+OWxrPsPx7Ngyy11jn8V9/4MWVBQhVo0hzef3Zc3YNNLSAv/pM2tvgG3TSBu7xmfbSn73JCbpOnip
+HasyyCCLjJ59YNUKhmaNIW1ERuB1v59Ij7SJZRb3n5nF1J5BrlNqz7Yt5ri736053SP+gHvE7y0q
+KpL1Z3bWVHp4X/44hz49y/6erFlh/l7179MDWEPGUqD9XfQ+P1R1SqRQwEuF1oxNY9jSNMavml3x
+ij2nkjUT0lZ0prf3ddbUkvc9X1ZZpJHWPous79MYv2oFQ/WlFJn2/WTOmC8ofXmr674huMc+Y1FR
+kWHvrD70eDkLgIk901j05BrGAZDBsLSyJ8Vpvi9+nMOkpQD96d8T9s6aRAaUe9JM+/GsWT6U82r5
+GCQy2AoLC8Pizvh5eXnUqVOn8hUltLzBPGA847dPZOL3/Rn/5HYmer6gAkl7cg0rhvt+paxhTNow
+MvCGuve1Wu0R6XguzgG9sO3ZXWqxu98AXNPeBpvNosIiyKoxpI3YXs2T3L3M6duDid8DA2aTNRnz
+92jAbGYzjGFL9fsULuLi4gIuz8vLq9F+c3NzSU5OxumsWttcY/BSsfOHMm4AsHSi+cUCtB2+gqys
+LLKyZtPfs1r/mVmeZVmlwt0cHxxGRvvxrFl1F4t6jmENPZialcXsAZAxQuOHEaWw0LxLnX+433Az
+rilvKdzPhXdM3WfM3X9Mfswq2DtrWPHvIHhb72mM/12P8vctMU0BL5XqMTmLrKw1jG/v98aP2Wz3
+/JixYk2pt7xfUMO2j2dNVhZZy4fCykVkkcEwzxeWud8sZg/IYmLPkklDEqYMA8djj2D/9t+lFruv
+7obrzbngcFhUWKTKYmLPPszZBeb4u9/v2IDZZK0aX9xFn7XTt9csm0+XZZH25OxSPQDmCbP3j++E
+WIlFGoOXKlkztkep1gPA3pWLyCKN/gMgY3s2e+lRPNbXY3IWWZNLr3/e8BVk9ZpDn99A/7S94Fk7
+0LoSfhyvvID9nx+XWua+9HJcsxdCfLxFVUW4AeMYelEGE33G34vH3JcOI22p+WMnoEef8YzvA4tG
+TCSLtgxdnsVQv92pi158qQUvlVjDmLQ0hi31X76XT5dlAZ3o36cTfL+IT/262deMNS+JWzOrj9kN
+v2oOfXou4q63htLj/PNK7X/MKv/9Szix/X0+9llvllpmpLU37y+fpLkzVee5tHREBni713tOLR7e
+ysqaTaeXezCM2T7LPKHdcyhD0yrbv0gJBSX+75IAABSpSURBVLxUaM1YczIcA8aX7j788VMWfQ9p
+T46hR8/+9CeLiW/4dgh6Lt/5fhvZxct6c5enO7440FdlkAFkjFB3YrgKdK270eZ888lwyXq8a/Wc
+x9DlWWTN9M5e8d5LwvvH8/u2dFjp6+E1fCXnQAEvFerRpz9pT64ha3Jvn6V7mfMb85K3u3qdB/Rg
+zJNpsHRS8WQ57+U7aU+OoXjLtPMYOjmLNU+mkTFiDHNm9SFtRX/WPJkGZDDJ/4YeYr3vt5e51t1o
+nkLRwmXQpJmFhUULT+BnZXl+D3z1Z7a3FT+5ahPpSo/Bq2cs1ingpWI9p/pd8gbZntm8vhN8zhs+
+m/Hts5jY02yJmxOCvCcAAFlsy/Kuu4KsrDGwLAuWTuLTXuPoTxqdLgrVQUmVHNiPc/Bdpa51Nxo3
+pWjBMmjZ2sLCoo05TNXj5U7M9l6ZMmA2WTMpnpBaVb5XsxR37UvM0iQ7qaYMFi1LgwGz/YL/PIa+
+NZ5FPScybGx/snwnzg0fR/+Xh5ExIg3/23iYJwnnQZYu9QkrJ0/iHDwQ25FDxYuM+slmt/yFbS0s
+LPKZN48C6E9b5tAnbSJZA2Z7WulrSn5Hek4lK6s/Y9LSSCt+X6TqdKMbESnt7Fkcgwdi/3pD8SIj
+MQnXwmV6prtIFehGNyISlhyP/6Z0uMfF4ZqzUOEuEmEU8CJSzDF1IvaP/1H82rDbcb05F+PqX1lY
+lYicCwW8iABgW/I+9remFb82ANeUtzBu7GVdUSJyzsIm4O32sClFJObY/t9aHOMeK7XM/cIrGLfe
+YVFFIlJTYZOqiYmJVpcgEpu+347j0SHY3O7iRa4x43Hf/6CFRYlITYVNwIuIBbzXup8pmd3rGjIc
+929GW1iUiNQGBbxIrApwrbv7jntwP/uihUWJSG1RwIvEIpcLxyODsO0qeQSpu3dfXJNes7AoEalN
+CniRGOQY91ipa93dN9yM67VZoMmuIlFDv80iMcb+l8nYl/5v8Wv31d1wvTkXqnh3LBGJDAp4kRhi
+W74Mx18mF792X3o5rtkLIT7ewqpEJBgU8CIxwvbVlzge/03xayOtPa55iyBJz4AQiUYKeJFYkJ1p
+TqorKgLAaHO++WS45AYWFyYiwaKAF4l2hw+al8OdOgWA0TyFooXLoEkziwsTkWBSwItEs7zT5o1s
+cg4AYDRsRNGCZdCytcWFiUiwKeBFopXLZd6CducOAIy6dSn62xK4sK3FhYlIKDhr+gB6EQlPSU8/
+jn395wAY8QmcnjEf1/kXgn7nRWqkTp06VJSdDRqEx9wWZ506mkErEm3sb7+G48PFABgOB66ZfyOh
+23UWVyUSPSLhCajhX6GIVItt5XIcr5r3kzfsdlyvzcK4rofFVYlIqCngRaKI7Zt/4XjsEQAMwDXl
+LYw+/awtSkQsoYAXiRY//oBj6H3Yzp4FwP3CKxi33mFxUSJiFQW8SDQ4egTnAwOxnTgOgOuxJ3Df
+/6DFRYmIlRTwIpEu/wzOB+/G9vNeAFxDhuP+/R8tLkpErKaAF4lkbjeO3z6MbftW8+Ud9+B+9kWL
+ixKRcKCAF4lgjmfHYl+7CgB37764Jr1mcUUiEi4U8CIRyj77Lezv/w0Ad/frcb02CyLg2lwRCQ19
+G4hEINvK5dgnpQPg/sVVuGb+DZxOi6sSkXCigBeJMN5r3W2A0aETrrnvQ0Ki1WWJSJhRwItEEp9r
+3Y209ubDY+rVs7oqEQlD6tOLITlFhawvOMmewnyKDMPqcqrFabORGp9It4T6pDjjrS7HGsdzi691
+N9qcT9GCJdCosdVViUiYUsDHiJyiQv5+8hBX1GvINcmNiYuwyVhn3W6y8/P4+8lD3Fu/WeyFfGGh
+2XL/eS9G8xSKFi6DJs2srkpEwlhkfcvLOVtfcJIr6jWkQ516ERfuAHF2Ox3q1OOKeg1ZX3DS6nJC
+yzBwPPYI9m//jdGwEUULlkHL1lZXJSJhLvK+6eWc7CnMp21i5D8auG1iHfYU5ltdRkg5XpqA/Z8f
+Y9Sta465X9jW6pJEJAIo4GNEkWFEZMvdX5zdHnHzB2rC9vf52OfOxIhPMGfLd+xsdUkiEiEi/xtf
+JErZ1nyG49mxGA4Hrpl/w+j6S6tLEpEIokl2Umz1h/MYuq+Slep3YO2gq2nDd4x6eyMZVdlx66vZ
+dWsH4DtGLTjO44Oupo3P2z99sZih/JqV12nSWLFtW3D89mEAXK/Nwriuh8UFiUikUcBLsRtuHcKu
+ilbI2Uivz7wvOjD90Q5MB9i2kl5Hf1EqoFd/uJjsXw5kWIrv9sfZXman3zFlz3nMGaRwL7bvJ/Pp
+cAX5FL38F4w+/ayuSEQikLropcS2lVz04XfB/YzkBqVa76s/3MYlN5kt+p++WEyvLw4F9/PDnfda
+92NHcT3zZ4yB91pdkYhEKLXgJSR8u/8venuj2dV/+XEmNvw1Kz2t/DbX/Zq7F3zO7By/ln+s8F7r
+vmc37j+Mxf3gI1ZXJCIRTAEvpe3baAZweep3AMzW9vXbTvm8sZ+Ltvmtu3QeLwFQj6cGDGHtzsVM
+aTyQ6U030uuzvQz94hRZgbb76juG3dqhxocSUXyudXcNGY77D2OtrkhEIpwCXkornhAXgM8YfJvr
+BrLrOs/yKo3BH2L2Z/W57Tpg23FILW9S3XeMensbs3M6xFQr3vHqn7H/82Pcd9yD+9kXrS5HRKKA
+Al6qLuVqVg4qu/ino1W5s9wR/pOcyjDP+p0aNwvQC2Dqf92QmAp325L3sc98HXfvvrgmvWZ1OSIS
+JRTwUk2HmL3gG9oO6sUNniVZuafodFFls+A7cBvzPN3/LZnzKPAFpHW+pVRL/qcvFjMlSJWHI9v/
+W4tj3GO4u1+P67VZEAU3IxKR8KBvE6mmI/zHt8Ges5GJ+1pyWxVusHbDrUOY0xrgJNk5QSovkny/
+HcejQzC6XIFr5t/AqfNtEak9+kaREk0bkFbhhfDAtj1ktE41r3/P2UivpXu5e8DA4tZ8RVZ/OI+h
+XM2uAcfptXQldIasbR+XmWTX/7rA20eVA/txDr4Lzr/AvAVtQqLVFYlIlFHAS4mUi7j7xMcVz6Kn
+Hk8N6FAq3KsyXv7TF4uZ2PAWdnm641c+ai7731jsoj95EufggVC/vvnwmHr1rK5IRKKQrbCwMHae
+3BHDphzdy5CUNpWvGAHm5fzE443Ps7qMc3P2LI7BA7H9tIeixSsgpYXVFYnIOcjPL/+plvXr1w+4
+PC8vr0afmZubS3JyMs4qDuepBR8jnDYbZ93uiH+i3Fm3G6fNZnUZ58zx+G+wZWdR9MHHCncRCarI
+/raXKkuNTyQ7v2Znj+EgOz+P1PjIHK92TH8Z2/rPKVqwBFIvsLocEYlyCvgY0S2hPv8+lct3eac4
+63ZbXU61nXW7+S7vFP8+lUu3hMDdX+HMvuR97HNn4vrbEmgXY3fpExFLaAw+huQUFbK+4CR7CvMp
+MiLrf7vTZiM1PpFuCfVJccZbXU612Nd/jmPEYIre/V+MK/RMd5FooDF4CSspzngGOJtAXasriR22
+77fj+O3DuGa8q3AXkZBSF71IkNgOH8Lx4N24Jk7H3b2H1eWISIxRwIsEQ95pHIPvxP3HZ3D36Wd1
+NSISgxTwIrXN5cLx6GCMe/4b98B7ra5GRGKUAl6kljnGPQZdf4lryHCrSxGRGKZJdiK1yP7GFIzE
+JNyjnrS6FBGJcQp4kVpiX74MW9ZOXNPetroUEREFvEhtsH21HttHS3G98Q5E8K10RSR6aAxepIZs
+2ZnY58/G9doscDisLkdEBFDAi9SI7fAh7NMn4ZryFsRH1h32RCS6KeBFzlXeaewTn8M1cTokROYD
+cEQkeingRc6Fy4Xj5RdwPfNnqBd5D78RkejnrOnN70ViUcLrr5L/8KO4ExJBv0MiMcduD//2sbNB
+gwZW1yASWd7/Hxg8lEQ9010kZp08edLqEioV/qcgIuFk/RfQ9UpQuItImFPAi1TVjv9Aw0bQroPV
+lYiIVEoBL1IV+34CA+h0idWViIhUiQJepDLHc+HkCYW7iEQUBbxIRQoK4PAh6NDZ6kpERKpFAS9S
+HrfbbLm3bWd1JSIi1aaAFymP3Q5Nm1ldhYjIOVHAi4iIRCEFvIiISBRSwIuIiEQhBbyIiEgUclpd
+gIhIpNi8D6augjWZkH/W6mqCKzEOerSDMT2hS2urq5FzoYCPIQXuQo66TnLGVYCBYXU51WLDRpIj
+gcaO+iTY460uR2LQ5n3Q/21IvwXevAfqJVhdUXCdKoBFm8xjznhUIR+JbIZhRNY3vZyTAnch+woP
+UycukUR7HDabzeqSqsUwDPLdZ8k7m0/r+KYKeQm5IfPNFu1D11pdSWjN/dLssZg32OpKwktFT5Or
+X79+wOU1fTx7bm4uycnJOJ1Va5trDD5GHHWdpE5cIkmO+IgLdwCbzUaSI546cYkcdYX/Yxol+qzJ
+hLu6Wl1F6N3V1Tx2iTwK+BhxxlVAoj3O6jJqLNEexxlXgdVlSAzKPxv93fKB1EuI/vkG0Upj8DHC
+wIjIlrs/m80WcfMHJHacKoA56+HzLHD7/DNNawaTB5g/r/oevtwFT/eBKPiVlDCmFryISC354Bt4
+6VMoKCq93Bv2X2SZY/mvr4Vx/6hkZznQfTLs8V22GVL8lwEjx8FnAZbNyCm728/mQfdPKz0UiQJq
+wUuxTZlvMONMJSs5L+WFTtfTMsBb+3fPZwa9eOGCFtX41K3M3pJN18vasmnLWmj6O4a1qsbmImHk
+yx/gls4w94Gy723cDQ/Mg5s7wMBfwIiFUD8BnvmvcnaWAunN4arJ8PVYSAXoAl8fgKvmQc4QzJOA
+aTBoNNxUXlGbIeU9v2U7IGV1yct2N8C63tU8WAl7Cngp1rXd75hV0QrH1jJhf/lvt7zgF6Ru2cAm
+bqfqc5Ga0dKZDVzKsMuasXz7Mja1qs72IuHDMCDOUXb5+l1w7zuQ4ITThdCzPSx4CO6ZA+c1ggev
+Cby/m4ZA+mSYuBkuWwnpR0reSxlX8nP6NEinbFAvWAF9h0BOl5Jln82D9BYK9FiggJcSPy9j+Om2
+zGp3aRVW3srsLWvZGOCdjVveKL0g6Xpzn8fWMuGnrQQ8R/DdZssyRl6mkJfosC4bBr0LD18Lj3SH
+W96EO/4KbRpBvNMcn6/IyLGeH7rASJ/lez6F+wkQ1DnQfQVcCmTuME8OeA+W+K7j14JPHw0jU87t
++CR8KeDl3FXQXV/s2FomHPZ57Q37YgdYvn0DLTsp0CX6/PM7eHA+DO0G6X3NZUsegV9PM2+cM+8B
+6N428LYzJpe02BdMqqAL3s+eb4EWwA4zuLfMh/GTYIbnfbXgY4cCXko7s5bhW9aW/77TG86XMqzT
+AZZvf4NlReWvXjbQ/bWgZdwJ9h8DGpnzADbV1Ti8RL5PtsGwBWb3+wv9SpbPXm9Ouvvr/XBzx/K3
+HzkWRnrG2IHi8Xb/S9J9W+ILJgEH4NLLS5aNvwyuGue3kV8LniY+4/wSNRTwUlpFgVxmDL4FfTv9
+jr7V2X+pE4hkbm8zuKQH4Nhalp29lJEKd4kCj7wH91wBL/YvWfbccpi3AeYMgv/qbM64d9rhiZur
+sMMUWDep5GW5XfRDzNb+SM/EutTekL4FGBygG34zpKxUuEcrBbxUXaPreaGR5+eKxtP9ebvyzxxj
+f/EJxAGWb18JQMs42HTmAMtzt5La8HcVd/mLhDG3Ad5L2wuLoMfFJe89+5F529eFD8H17cxluw6X
+rB9s3ol4ZTQJUQEScgp4qaaSMfMXGl3vWea91O12ulYwpr6/8AQt48rOKGoZn8zGwx+YvQdqvUsE
+s/ul9c4cWF8XVmyH+Rvh7w+XHnP3X78iI8f5TZTzqGpXe8CJdJ4WvEQnBbxU0yH2F1G6lf1zNhuT
+2jIs4Ppbmb3lG1q2GUzLsydIreu9Rv4Q+4uS6doIOANwHiM9QwObMuezv+lg+jYKuEORiHBBE5js
+uftMYhy8/zBcc2ENdugX3uV20ZdDLfjYo4CXEkmNaHm6knX8wnz/7vlMOJHMyMsqmkiXTMtGW9n0
+03l0bedzeV3S9Qz7eRnDD5/g6iSYkbmVWe2asf9sMi0V7hKBbDYocpk/bxxb8boALnfg6+b9DRoH
+d9xXs3FyteBjjwJeSjRqz9X7P6h4Fj3J3N7mUvOa+cN7aZl8J7Mu871zXQtaxu1lhu917UnXM+zn
+bJYlX8MwWtD1skvNE4SflzH8MIy8bDBdgb675zN8ywlzzD4oBygSXNdeCH/6BAb8tWrrb94LE26p
+YIUDkBmEGe6+3f3tbtAEu2il58HHiOz8fTRNbGB1GbXicP5x2ia2troMiTEp4yBnUsXreB8280W2
+2TqviMMO17U1r5EP96fUVeXYY00kPA9eLfgYYcOGYUT+E+UMw8AWsnnHItVTLwEeu8H8I2I1PU0u
+RiQ5Esh3R/5DnfPdZ0lyhHlzR6JSYpzZQo81pwrMY5fIo4CPEY0d9ck7m88ZVyGROCpjGAZnXIXk
+nc2nsSNw95dIMPVoB4s2WV1F6C3aZB67RB510ceIBHs8reObctR1kqNnT2IQWSFvw0aSI4HW8U1J
+sMdbXY7EoDE9of/b5s93dQ3/cfOaOlVghnv6x5DxqNXVyLnQJDsRkSravA+mroI1mZAf+SNeFUqM
+M1vuY3pCF81pLSMSJtkp4EVERKopEgJeY/AiIiJRSAEvIiIShRTwIiIiUUgBLyIiEoUU8CIiIlFI
+AS8iIhKFFPAiIiJRSAEvIiIShRTwIiIiUUgBLyIiEoUU8CIiIlHIefz4catrEBERiSh2e/i3j50N
+GjSwugYREZGIUtHDZsJF+J+CiIiISLUp4EVERKKQAl5ERCQKKeBFRESikAJeREQkCingRUREopAC
+XkREJAop4EVERKKQAl5ERCQKKeBFRESikAJeREQkCjmtLkBEJFJs3gdTV8GaTMg/a3U1wZUYBz3a
+wZie0KW11dXIuVDAx5ACdyFHXSc54yrAwLC6nGqxYSPJkUBjR30S7PFWlyMxaPM+6P82pN8Cb94D
+9RKsrii4ThXAok3mMWc8qpCPRP8fmWcvLb0p9EoAAAAASUVORK5CYII="/>
+
+## 第二步：选择需要的任务
+
+<img src="data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAAAoQAAAHWCAYAAADuGZguAAAgAElEQVR4nOzde1hUdeI/8PcMqFzS
+yhxYMDfMXAPEdl0F0VJCysy8lAmVt1RQCRUDbTJJfxZ9jRQfUREVyHslxQaaW26IZKZBZrsikHmj
+J8NgNEvjUsrM74/pHM/MnLlxh3m/nmeegTm3z1yY8+ZzO4qVK1fq0IJ0uhY9HBEREXUgCoWitYvQ
+ITm31IEYBImIiKixhDzBYNi0WiQQNnUYZLgkIiJqf5oyxOl0OobCJtSsgbApghvDHxERUccgd05v
+TKhjbWHTabEmY3sxCBIREXV8DHVtQ7MEwoaGOXu2Y2AkIiJqP6wFPul53d5wyFDZeE0eCBsS1Kxt
+w/BHRETUvtnTXNzQgMd+hQ3Xqk3GloKe8TKGQiIioo5DoVBYrRVkzV/Lce7UqVOT7KgpmnvtDYEM
+iURERG2ftUBnvNzc+vYEQ4ZI+7R4DaFciDMXBK2ty0BIRETU9knDmaWgJiwzVzPIJuHm0ySB0NZg
+Zq0G0DgI2hoMiYiIqO2SBjlbBo9YCoa2hkKGR/s0OhA2RRg0Dn5ardbsOvYel4iIiFqfXLOwceBT
+KpWy2xiHO4bCptcqVyoxDnrGQfCBBx5AYGAgunfvDicnp5YoIhEREbWC+vp6/PzzzygqKsL//vc/
+AIbBsLGhkGyjWL16dYOr2myppbOlWVh6mz17NlQqVUOLRERERO2URqPBli1boFAoDG4ATO4FtoRC
+BkfrlNZXaThbwqBWqxVvL774IsMgERGRg1KpVHjxxRcNsoG1cQXsQtY0mjUQyjEOg0LN4Jw5c+Dm
+5tbSxSEiIqI2xM3NDXPmzBHzgVwopKbX4EBo7xyBxv0GpWHwgQceYM0gERERAdDXFD7wwAOyoRDg
+vMXNoUGB0N4XVq6/oPC7VqvFkCFDGlIMIiIi6qCGDBliUjtonCHswVBoWbM0GdsyobT01r179+Yo
+BhEREbVT3bt3N8kLAs5P3PSafdoZS0FQ6DDKqWWIiIhIysnJSZyOztxE1Zx6punYHQjtaae3NMWM
+tA8hERERkbHLly9DqVSKN+PpaKxdEo9h0XYtdi1jS+GQiIiIyFj37t3FMOjk5ASFQmESDAHbr5Vs
+y3JH1aR9CG3pO2j8mFAdTERERCQlzQhyGYJ9CZtOs81DaEvTMmsIiYiIyBxbswKzROPZFQgb+oLL
+DSaRPk5ERERkTJoTpGMPGpMfmDvkNVkNYUPmAzKeaJKIiIhI0NCswGxhvxabh9B4Gd8sIiIisoUt
+2YG5onGa9VrG5mYUZygkIiIiW1jLEcwSTaNZA6Et+EYSERGRHGaEltOigVAuyfPNJiIiIjlymYG5
+oXnYHAgb224vNzE1ERERkTUNyRDsb2ifJq8htGeSSL4hREREZIk9GYK5ouFapQ+htMr3+n+zWqMI
+ra6kpAQhISEoKSlp7aIQEREBAK5cudIs6zYWm4qbX6tdqUTQ9e/hzVUEE2q1Gmq12u7tampqMHXq
+VKSnp4uPaTQajB8/3iTQpaen23QMf39/BAUFYd68edBoNFbXz8/Px9SpU1FTU2O2fPn5+Rb30RQh
+VK1Wmy0HERG1X1euXMG+fftw7Ngxq+seO3YM+/bta9FQaAnDYuM51CjjadOmobCw0GogUqvV+Pvf
+/25xPZVKhdjYWEyePFlcLz09HWfPnkVSUpJN5Vm0aBEAoLi42MZnoFdSUoLx48dbDJJqtdokIB49
+ehS9evVC7969TdYXQmW/fv3Qr18/PPzwwyb7z8/PR05ODmbMmAE3Nze7ykxERG3bXXfdhX79+uHo
+0aMWQ+GxY8dw9OhR9OvXD3fddVezlolBr+U4t3YBmlt+fj6io6MNHnvqqacAAN7e3tiwYQPmzZuH
+iooKcXlaWhqWL1+O6upq2X2mp6dj9erVJvsT5OTkwNXVFZmZmVi7di2KioosltG4fILAwEBs3rzZ
+JHz5+/sjNjYWjzzyCHbv3m0S8NRqNSoqKuDp6Sk+VlNTg8OHD2PGjBn48ssvTY7p6uqK3bt3w9/f
+X7YsGo0Gr7/+usXyChYtWoSoqCiL6xARUdsTHBwMQF+BIP1dIITBoUOHmiyj9q3DB8LQ0FCkpaXh
+wIEDYs1dTU0N5syZgxkzZsDDwwPdunXDhg0bTMKQpVqwCRMmiPvLz8/H66+/jqysLKhUKmg0GkRG
+RsLFxQU7d+4Ut1Gr1bjvvvvMhiUhyElDoFqtRk5OjrjOP/7xD3h7eyMrKwsxMTF48803sWbNGnF5
+fn6+yT4A4Msvv8TFixcREBAAlUqF06dPi8uE8ppTU1ODuLg4MTSnpaUhNDRUtvwHDhzA0KFDze6L
+iIjaNnOhkGGwY2uRQGhulvGWqgoODQ3FuXPnMHXqVKxZswZxcXEYPnw4QkNDrfbfkwayoqIivPPO
+OwgNDcX169cxdepUzJgxw2T92267TXZf9913H86ePSu7rKamBhUVFRg+fLhBkEtKSkJSUhLS09Nx
++PBhg6AXFRWFqKgog/58oaGhJmGtpqYGW7duxd133w13d3eLz1euXHPmzAEAfPPNN7hw4QImT56M
+UaNGGQTi6OhoeHt749NPP4VKpbLrGERE1LYYh0Lh59YIg8Z5QafTQaFQiPfUNDp0DaEQZqRNtg8+
++CAAfbhbvXo1pkyZYnEfSUlJWL58OebMmYPhw4cjKioK6enp+O2337Bx40a8/vrr6Nq1KwBg06ZN
+GDVqFAICAmRr3IYOHYrdu3ejpKTEpDbywoUL+OGHH2Rr14TmXkvPS3hOUkJN3pdffomioiIEBgZa
+fK5yvvzyS3h7e4vhz9/fH0ePHsWcOXPQr18/k2MREVHHYBwKWTPYsXXoQOjm5mbQZFtSUoJXXnkF
+GRkZYi2WRqNBeHi4ST9A4FYfPjk5OTkGTbkAsGvXLuzatQuAvk+eMWFk8Y4dO0wGnuzYsQNBQUGy
+ffguXLiA4uJi1NbWYsyYMcjKyjJ4XsaktXpC7WBDGdc4GvefFERHR5vt80hERERtW4cOhLaS9iGU
+GyksN8WKtA+hMUt98qZNm4aYmBiDWsL8/HwUFRUhK0t+TsajR49i1KhRqKioQHh4OMLDw8X+itbs
+3r0bgD6wff3119BoNHj++ecNBtEIjENxYGAgVCoV9u/fLz62aNEig/6HUunp6fjHP/4h/m7pNSIi
+orZN2mcQMD/QhDqGVg+E1//3PoBVzbZ/uVHGQrOxMMrYXtZG0KpUKuTm5sou8/f3x+TJkzFv3jxk
+ZWWhqqoKcXFxWLNmjWzA02g0OHz4MB5//HFUVFRg5MiR+Omnn1BcXGxTE+1PP/2El19+WfxDVqlU
+OHTokMkxIiMj8X//93+yNZTSQSuA4aAcaRmEPo1ERNS+mRtAwlDYcbV4IDQeSNL1gUnNerzQ0FCx
+RkuuyViYQ9DDw8PmfZrrwydlaeqVqKgonD17Vgymlvrf5eTkYPjw4QZTyERFRUGtVlud/mXGjBl4
+9dVXARh2DLaXuWZic8+f084QEbVf5sKgtSlpWgLnJWw+rV5D2Nyk/enmz58PQD/447vvvsPmzZtR
+WVmJbt262TT6trq6GlOnTkV4uP7qKpamX7Fm1KhRYh/EAwcOmA2ENTU1eO6550wmrxZGH5vbRnjO
+TcG45i8/Px9bt26V7S+oVqvRp0+fJjs2ERG1HGtTy7SFUEjNo1UCYUsm/BUrVgAANm/ejAsXLgAA
+5s6di5ycHCxatAjXr183merF2O7du1FUVITi4mJxIuisrCyLNXTCVUiMlZSUYPLkyQgICMA333yD
+6upqhIeHo1+/frIBMzY21t6n3Kzy8/MRFxeH3bt3m7xmwtQ5RETU/ly5cgWnT5+2OppYWHb69Gn8
+7W9/a/arlQg4zUzzavZA2NrVu+Zq0aKiosQJpSdMmGB2e2Gy6G+++UYMQMIgE3tqCIX5DI3n6nNz
+c8OhQ4fEoFhbW9smB2MIo7EBmJ1rUJg6R9q8TURE7cNdd92FsWPH2hTwgoODWzQMmsOQ2HQ6fJMx
+YDiwJDAwEO7u7uJ0LK+++qrF0bqWgpm1GkJpX0NLo3MB/WCT//73vwD04bFfv35mg6HcQBk5xpNm
+C4yvfiIwHmW8aNEi9OnTR5x02nhkszTESrcxd/k7IiJq2+wJeK0dBqlpOUQglA4skZKby8+ewRDW
+agiN50G0laX+gYD55yOw1ofQ2v6NmTuWNMQSERFR+6VYvXq1TW26lpp+jS8pI73XarXiZWe0Wi3q
+6+vFe+G2alXzTTtDRERE7dPixYvh5OQk3pRKpXivUCigUCigVCoBQGw6ljYhW2pOZlOzIWVrF4CI
+iIiIWhcDIREREZGDc4g+hERERNT+/PzzzwbNxUKTsdBcLL0BlpuL2URsGQMhERERtUndu3dnH8IW
+wiZjIiIiIgfHQEhERETk4BgIiYiIiBwcAyERERGRg2MgJCIiInJwDIREREREDo6BkIiIiMjBMRAS
+EREROTgGQiIiIiIHx0BIRERE5OAYCImIiIgcHAMhERERkYNjICQiIiJycM43btywaUWdTmfTMuFn
+4V6r1Yr30lt9fb14IyIiIjJ28+ZN6HQ68aZUKqHVaqFUKqFU6uu0hHuFQmFwb/yzMUvLHBFrCImI
+iIgcnHNrFwAArl692tpFICIiInJYbSIQ3nnnna1dBCIiIiKHxSZjIiIiIgfHQEhERETk4BgIiYiI
+iBwcAyERERGRg2MgJCIiInJwDIREREREDo6BkIiIiMjBMRASEREROTgGQiIiIiIHx0BIRERE5OAY
+CImIiIgcHAMhERERkYNz7tSpk00r6nQ6m5YJPwv3Wq0WOp0OOp0OWq0W9fX10Gq1UCgU4o2IiIjI
+mLOzM5ycnMSbUqkU74UMoVTq67aEPCHNFZYyBvOHIdYQEhERETk4BkIiIiIiB8dASEREROTgGAiJ
+iIiIHBwDIREREZGDYyAkIiIicnAMhEREREQOjoGQiIiIyME5t3YBqOP4uQ74vV7/874SoLAc+OEX
+4EZ965aLiIhaRicnoNcdQJAPMNZf/1gXJ6C7S+uWi6xjIKQmce0PfRisvA6sPwz4dAdiHwJ8PfRf
+EERE1PHdqAfKqoDcEiBhPzB/OODZtbVLRbZgIKRG+6MeqL6h/3n9YWDU34Dwv7dumYiIqOV1cgIG
+eOlvWf/VnxMSx7R2qcgW7ENIjVYnaSb26c4wSERE+nOBT3f9uYHaPtYQUqMJ/QYLy/XNxMb++OMP
+XLt2DXV1ddDpdC1buHZOoVDAxcUF3bp1Q+fOnWXX4etL5vDz07HY8n62NeP9gZTPgdmBrV0SsoaB
+kBrtplZ//8Mv+j6DUn/88Qc0Gg06d+6M2267DQqFouUL2I7pdDrcuHEDGo0GKpXK5CTA15cs4een
+Y7H2frZFvh76cwO1fWwypiZzo950AMm1a9fQpUsXdO7cmSebBlAoFOjcuTO6dOmCa9eumSzn60uW
+8PPTsVh7P9uiTk6caaK9YCCkZlVXVwdnZ1ZEN5azszPq6upMHufrS7bg56djMfd+EjUGAyE1K51O
+x5qHJqBQKGT7d/H1JVvw89OxmHs/iRqDgZCIiIjIwTEQNpP4+HikpaWZPJ6XlwcfHx/4+PjA19cX
+xcXFJsuHDh2Kqqoqu49ZXFyM4OBgk31aK6ePjw8iIiJQXV2NtLQ0xMfH233spqbRaPDoo48iMzPT
+4no1NTWYMWMGCgoKTJaVlpZiwYIFqKmpMbudpf3L7Vtun8aPLV261Gq5W1tzv75SmZmZmDFjBmpq
+asTjyu1POFZAQIBNt0cffRQajUa2XI888ghKS0utvAq3LF26FAEBAWI5MzMzsXTpUqvbyD2PzMxM
+BAYG2nz8zMzMNv95Mdbcnx+NRoOnn35a9jUsKCgQ3ydL7P0cOPL7SQRwlHGzKC4uxtGjRzF69GgM
+HToUFRUV4rKgoCCUlJTA3d3dZLu8vDxERkYCAAID5cfoBwUF4e233zbZvri4GOHh4aitrcXYsWNl
+t1Wr1YiOjkZaWhqSkpLEx8rLywEAVVVV2Lt3L9566y37n3QTU6lU2L17NyZPnow+ffogJCTE6jYa
+jQaTJ09GREQEZs2aZbCspqYGMTExePDBBzFr1iwUFRUBAJ599llxnczMTJw/fx5vvPGG2WMcO3YM
+DzzwANzc3MR9Hj9+HID+vZFau3YtFi5caFKWtqC5X19BaWkp3nvvPaSkpMDNzQ1ubm6IiIjA9u3b
+ERgYCDc3N3FdNzc3bN261abyl5aWYtmyZbKPP//886itrUVERITstsJ7kpmZibVr14qPCf9IaTQa
+fPzxx3jttddsKovx8d977z1MnToVq1atQmpqqvgcCwoKMH/+fLPbCmWRK2tb01KfH4Etf5tS9nwO
+rO3HEd5PIoCB0C4/L1yI7jJ/5MaOHDmCoUOHIiwsDGFhYeLjeXl5SE9Pl90mLS0N69atg5eXF4YO
+HYrk5GSD5UJYjIqKkg2Ds2fPRlZWFgICAkz2LdT4RUdHi/dCMJTKzs5GWVmZbKAUwmRzmDFjhhiq
+5Mh96f7jH/8AAHzzzTcAgOPHj8PV1RVbt27FO++8g6VLl+K5554DAPz2229Qq9WYNm0aQkJCUFVV
+hQ0bNmDFihVwdXVFRkYGLly4gN69ewOA2DdHeq/T6aDRaLBnzx5cunQJa9euxaBBg7BhwwaUl5dj
+8+bNWLlyJdzc3JCQkIDevXuLX/xN1ddHKIe1x4zNnDmzRV9foTwajQYLFy5EREQEfH19xcefeeYZ
+HDlyBO+8806DT47G7w2gP3kvXLgQW7duhZ+fn8k2CQkJ4uuh0+kwc+ZMzJw5E5mZmQb7yc3NxenT
+p2WDRGxsLC5cuIC9e/cCgHi/bt06+Pv7Y+HChXjllVcQEhKChIQExMTEYMOGDXBzc8OIESNw8uRJ
+cV8ajQZqtRp/+9vfAADfffcdkpKSoFKpZJ9rY7Wnz4/x+2v8+8WLFxESEoLa2lp4eXlh165d4utm
+7+cgISGhw7yf9mL/UZJiILSBcRC0FAyLi4uxbt06rF+/3ub95+XloaCgAMePH4e7uzvS0tLg6+uL
+rKwseHp6YsKECQCAoqIieHgYTvSXlpaGnTt3Ij09Ha+//jrWr18vrlNdXY2ZM2ciJCTEapgTagf3
+7dtnECqrqqowYcIE9O3b1+bnYwvpF9nbb78NQP9Fvnz5cmzcuNHkS7SmpgZLlizBnDlzDL7ka2pq
+MG/ePPFkAgCJiYni/gDA3d1dPAYApKSk4LHHHoOfnx8KCgqQlZWFXbt2iScDc0pKStCzZ098+OGH
+BjVbDVFUVIR77rkHnp6eBo9XVlbi+++/N1tD3BAt/foK26nVagwePNgk9Lm5uSEpKQlTpkwxqF2S
+npgtGTRokMnnOTMzE1lZWUhJScGqVasMTsTCcxg2bJjVAKrRaPDJJ5/gvffeM3gdNBqNWN5Zs2Yh
+NjYWU6ZMwZIlSxASEiIuDw8PN3idEhIS8OSTTxoEloKCAixYsEAMMsJznjVrFqZMmYJffvnFbJgR
+dOTPj/Rz8Mwzz2DcuHHo3bs39u7da/D5iI2Nxbhx46BWq8XHGvI5SExMdKj3U4qBkqQYCG3Qfe1a
+/LxwIQDrtYTbtm1DbW2tXfs3rkkUTnZCTd3EiRNNagwBfRgsKCjAp59+Cnd3d0RFRSEwMBAZGRk4
+c+YM1q1bZ1JrKITEwsJC8TFp83FAQIAYateuXYvs7GwEBwcblM9etn7p+Pj4oGvXrigpKTFpghKa
+tX18fEweLykpwYYNGwAA586dQ0pKisE6Q4YMEX+eNWsWvvrqK+zduxcpKSlirYXxCU7OqVOnDPYX
+FRWFXbt2ie+39DiAPngOGjTIJCwBwD333IMDBw5g5MiR6NmzJwDgxx9/xMGDBzFq1CirZWmIlnh9
+hZP0lClT0LNnT7zyyiuyZVGpVNi1axemTJmCvLw8JCYmijdbSPtzZWZm4osvvhCD+rRp0zBy5Eis
+W7cO586dw5YtW0xOyEI4kNZ8Cc8rNjYWfn5+KC0tFWt+9+7di8GDB4uvm0ajwS+//CLuS61Wo2vX
+rkhJSTF4fby8vMRg0L9/f3z66afiskuXLmHkyJEmxwf0QQgAxo0bJ/uadOTPjxDQXnjhBaxYsQLH
+jh1DSkqK+FoUFBRgx44dePbZZ1FdXS1u25DPgcAR38+mIPfdzpDYfjEQNqG0tDSUlpbC19fX5m3k
+Ahpg2LdPGIgiJYREaU1JWFgYMjIyEBkZCbVajbKyMpPjubu7Y8+ePQD0TcklJSW4/fbbZfslArC7
+mViuScpWwpd4Xl6eyQnnnXfewZNPPmlSM7d3717cfvvt+O6776BWq7F161aztUAJCQm47bbbcODA
+AYOaC0v/uUvNmzdPbBYSah4s9SGyxNPTEyNHjsTHH38snkQOHjyI0aNHm9QSNJWWeH0B/Ylw8ODB
+Bic+udollUqFDz/8EPPmzUNCQoLNYdDYrFmzDMoUEhKCdevWYcGCBYiNjTX52xJeCyGoJyQk4Ntv
+v0W3bt3E5kC5Y0gJr4twDLnQLxUeHi7+nJCQgLCwMLP97oTAY64sQMf+/BgT1r9w4YLJMo1Gg+vX
+r4vr2fs5MC6nI72fzUX+O58hsT1gILSBUCtofG+spqYGGzduxMsvvwwABoM3pPz9/cWfzQ0SEUYp
+R0dHIywsTAyHcoRmXenglaSkJJNjZ2RkiDV9xcXFuHjxIsaPH4++fftix44dAPRfXi+++CIAfRBN
+SkpCTk6OSVO1lPgF0ARdYwIDA7Fjxw4UFBSIX7AFBQWoqKgwaTYRRpjefffdYk3UO++8Y1OwePfd
+dzFs2DCbOsNbIjQXyRH6GJo7CfTs2RMjR47EJ598AgB47LHHxNqB5tISr6/x8pqaGqxevRqPPfaY
+SU2sNJgJZTH3ehr3FTMmNPNdunRJfMy4hgfQ9w8TnntpaSkqKiowevRo9OnTB++++y4A4IsvvhD/
+GSooKEBKSop4bI1Gg99++w2+vr5YuHAhDhw4gNLSUvj5+Zk0kRr3JxWYe46CQYMGWVwOdNzPj728
+vb0Nvj/t/Rw48vvZYnQ6CKcJ1iC2XQyENjAOf+aajOPj4w2aMITBGwJhUIm5AJidnW2yT+NQJw2Q
+0m28vb1l+xhK9y+orq7GgQMHMHjwYAD6msUBAwZgwoQJeO2118SyhYWF4fDhw0hKSpJtsm6OiVHd
+3NywaNEiLFy4EB4eHqiqqsLKlSuxa9cuk2CVkpKCoUOH4rvvvgOgrxE4d+4cBgwYYHb/sbGxKC0t
+xZYtW1BbW2vQTAjApJ8SAEybNs2kiXHkyJEYN24cwsLCZIOfUCvQ1rTE62vMeES3uZOqQO71FGoY
+5Uj7nHl5eeHgwYNmQ6O0FqqmpgYHDx4UB0CEhITA399f7Esm/B2EhITg6NGjSElJQWJiIvbu3Yuw
+sDDk5eXBzc0NKSkpyMzMFMPOsGHDcO7cOfj7++P06dPi4AkpaSg11lY/O0DrfH7kXL9+HdOnT8fp
+06cRGxsrDuZqyOfAkd/P1iCcNxgM2x4GQjvYMsK4oZKTk8XQVVxcjJdeegnbt283CHh5eXn4+OOP
+xROVsE1VVZVdTZc7duwwCaTZ2dno1asXgoODcf78efFxtVqNCRMmIC8vT6xdbO4Z8v38/LB27VrM
+mDEDd9xxh2ytUE1NDTw9PTF48GB88MEH4uPGzUZSwkng2LFjqK2tRWxsrMG6CQkJYp9Cae0AcKsm
+y7jJWBgMZNx/ELBeKyD0EXrssccA3Goiau5ageZ+faU0Gg1SU1OxYsUKMTC88sormDdvns3TlVgj
+9D0U3htbvfvuu7JNnD179kRgYKBBrbww6KCgoABdu3ZFYGAg8vLyxOXjxo3DCy+8gNLSUvTp0wc7
+duyAl5cXunbtatLdA2iaGiVH+PwcPHgQq1evFkO7oGvXruI/DaWlpZg0aRI2btzYoM+Bo7+frYXB
+sO3hxNRtTHV1NRITEzFu3DiLzbSNUVNTg4kTJ4q/FxcXY8eOHUhISDAJih4eHpg6dSrS09Px22+/
+tcjlkjQaDV588UXcfvvt+OWXX/DEE0+YTArr5uaG+fPny/Z7tGbWrFk4efKkyYkpMTERhYWFNvUp
+vHz5sthRftCgQfjyyy9x8uRJ8bZu3TqL21dWVopf+L1790bv3r0xevRoHDx4EJWVlXY/J3s09+sr
+JR3RLd33okWLkJqaKjuxtBCwBwwYIN6eeeYZXLt2rVFlMVZbW4tx48aJv5eWlmLPnj1YtGiRSVBU
+qVQIDw/Hjh078MQTT8gu79evH44dOwYPDw9cv34dH3zwAaZNmybbZWDdunUGnxd7PjtAx//8pKSk
+4PTp0/jmm28sdrsA9F1munbt2uBjhYeHO/T72dqaYvocahqsIWxDhD6H0r5+Uh9//DHuu+8+2W1/
++OEHq1MTjB49GgBMrkQSEBCAY8eOmd1u7ty5mDt3rrXiN1pmZiZSUlJk5xWbMWOGbK2elHQ9c6RN
+UtL+atb6p0n9+OOPeP7557F161ZUVVU1qIbw+++/x6hRoww6jPfs2ROjRo3C999/3ywdyVv69RWu
+1iDsT25aGbVabXLCt9b30pIff/zRYKSnHOFvS6j9Ffj5+eE///mP2e0s1W4Bhn0nN27cCLVabdBf
+WG49OSEhIVZrTjvy50eoKZTO8denTx9xUInx63Pu3Dl4e3sbfF7s+RyY09Hfz7aGNYatj4GwGUmv
+PCIl/VKZOHEiRo8ejcjISEycONGgmUp69RFA30/QXFNIr169LA7+sOVydNLyTpw4Ee7u7i3yn5sw
+8W1sbCz+97//iY8Lx/b19cWXX34JQD8n2oABA/DPf/5TrKGTW0+OcKJZunQp9u3bh7FjxxocT7ov
+4WfjSapLSkoAAPv27YNKpUJVVZVYFukJ6bPPPsP27dvN/vcr9N80Xubh4QEPDw/ZbRozsfDXX3/d
+Yq+vTqfD22+/LfbPlE72+/rrrxts8+abbyYTaGoAACAASURBVOLChQtiDeKIESMwYsQIg+MKpPsE
+9OGhR48eBu+Rt7c3du7cabXvmLnXF9C/d8I/CmPHjoWrq6vF9UtKSjBz5kzZoCOEktjYWJw/fx77
+9u2TLZc5Y8eOlQ0cHfnzI3xGpOXy8/PDypUrZfsfenl5YefOnY3+HHSE97M5tVRQ0+l0DIWtRLF6
+9WqbPlGWPnhyf1TCvVarFT+4Wq0W9fX14r1wW7VqVWOeAzUDe75oLv05jmbyDiDfaJaaH374Ad26
+dbN7n2Tq2rVr6NWrl8Fj0teXyBJ+fjoWufezNVkKcaFppucGW/e5ePFiODk5iTelUineKxQKKBQK
+KJVKgzJIy2KpXAyehlhDSAaaMrQZX3aKiIg6JuPv+aYIWzx3tCwGQhI1xR+f3JcCmwAaz9xryNeX
+bMHPT8fSHt4zw3NB2y4r6TEQEoDGh0GdTic7L7WLiwtu3ryJTp06NWr/0uM4ohs3bqBLly4mz79L
+ly64ceNGk72+1DHx89OxmHs/G6q5w6UO+omp23qIdXQMhNSoLxWdZAb6Tk7AjXr9vaBbt27i1CLO
+zs4mXwhsUrZMp9Phxo0b+OOPP6BSqUxeq65du0Kj0UCn08m+vuTY+PnpWKy9n43Zr62Efnu2kp4T
+OJK4bWMgdHAN/UKRbuesBG5qgV53AGVVwACvW+t17twZKpUKv/76K65du8bwZyeFQgEXFxeoVCp0
+7tzZZLnw+l67dq3F5omk9oOfn47F2vvZEsz9E28uKJZV6c8NxvsQtqG2g4HQgTXky19umy5O+kAY
+dA+wt1QfCKWjzZ2dnXHXXXc1urwkr3PnzujRo0drF4PaKX5+qClIg6J0tO/eUv25wdw20vXtORY1
+PQZCB9VUYRAAXJyA6hvAE/7Aq/t12PONDpMeaLlyERFR82loYMv6rw7lVxSYNcTy9g0ZJNMeBta0
+NwyEDqgpwyAAdHYC3Jx1+O0PHWIeBDZ8Dnx3GRjnB9zvYdin0Nr+GAiJiNoHuUB2ox74tkrfWlT+
+MzDvIR20Wh10Ost9DxkKWx8DIVllbVJynU6Hrp30XwQeXYHXHgf2lwLrjgAXf9U/Dg4eISJqp8x9
+d996XKFQAAoFOjkBd98OBPkAM/+8omcXp1vnCkuDUhjwWhcDoYOxJ5TZcnUa6TrdXYBrf+ibj8f4
+6W86rbbJyslASUTUPMzNU2k7HYSAqPjzyiEA4N4J6CYZ/yL9Hpfbv739CnleaDoMhCTLllpBOd06
+A50VWtTVA7/XA/UW9ss/ZCKitsHef8ItXR5OCS26OOn7l7t0UhpvajUUCuuwtrBlMRA6kKa6Eom5
+/Wj/rA3s7KS/yR3X1mtiNwUGTiJyVE0dpkz3Jw115tcTzgtKpflg2NiyMjw2DQZCB9EUTcW2hEG5
+fdhbK8ggR0TUOE19FZOG7E8a0rRard2h0N7zFkNh4zAQkgF7w6ClIKhQKODk5ASlUsk/VCKiDk6n
+00Gr1aK+vl52XkJztYVNFQqpcZzr6417ecmztanPeLCB8AHQarXirb6+3uBnal62/kE1VRjU6XTo
+1KkTnJxk5pshIqIOSagEcHJyQn19PW7cuAGFQmFSeydXW2guFNbX18uOTNbpdOI+pHnDeF1LlRGs
+qDBkWn9LDsnevn1yYVC4MQwSETk2JycndOrUyeDcIGV8DgFato85mWIg7OAa+0ck90drKQw6Ozsz
+DBIREZycnODs7GxXKJR7zB4Mjg3HPoRk11VDjB+T/qErlUo4Oxt+pG5ogd9uAL/fND+1KRERtW8K
+AF2cgds6AdKZZpydncVuYuK6kqZaucEg5gaIMOw1L9YQdmCN+eOR+2/O+DHj//qMawZvaIErtUAd
+wyARUYemg/67/kqt/rtfSjg3yNUU2nKusbssDI4NwkDo4OwZcGIpDEo7+Ap+u8EgSETkSHTQf/dL
+KZVKg3OFLaHQ7P4Z9poNA2EH1dS1g9aWy40a+/1mg4tARETtlPF3v1KpNNv33BzWErY8BkIH1pja
+Qem9uU7A/HMkInI85r77hXOF8TlE+Jm1hK2LgZAMmAt/AuPwp9VqG/2fHBERdWzCeULuHGK8ntzP
+1PwYCDuglrg8nHH/Qf7hEhGROa1xzuB5yT4MhCSSG+kldy+3fmPnjiIioo5Leo6w91xDLYOBkGwm
+998d/3CJiMhWPI+0XQyEDsiWywNZqg20ZbZ5IiIiKXv6CzIstjwGQgJg39VKpI839x/t9ow0BPr5
+YO60CNRUV5td77KmCmNHDsWKJfEmy1Ysicfwgb4oKyk2e4yxI4fisqZKdnlZSTGGD/Q1WOfzQ3kI
+9PPB54fyTNbbnpFm03GJiByFrecMBsDWw0DYwTTHH5O0at9SP5DmEBj8IFxcXFF66iS+Lz9v83Yr
+lsTLhsOykmKMDQ0WQ1pZSTEyN65D5aUKlJ06CeBWCBWCnZz8/3wMFxdX9PDwtPMZERG1D1u/AB5Z
+C5ypbNr9yvU/b66BJgyYtuO1jMmEvfMTNtUf3Iol8difm212+fRJY00eGzN+IpavTDZ47LKmCseL
+jqHyUgV8+tx36/GqSryVuAyVP11C1q5tWL4yGVm7tqGurhavv5WC3VvTcf7cGavlFPZfV1eL6ZPG
+wtPLGyNCH0HW7u0AgNQ1SUhdk2RQ7pg4NaZHRlvdNxFRW/BpGZCSD6yeBPRtov97pecLuWsVy61P
+LYc1hNQkf3RN0Y9w+cpkFJWWIzk1AwAwcFAQCr4qQVFpOYpKy1HwVQkGDgoCACSnZqCotBzLVyZj
+xZJ4PD4iEJWXKrA/NxtPjRqBlxJeg6eXNzSVP+H69WsAoA97Oh1i4tRYvjIZnx/Kw/7cbIwZPxFu
+7u44cbwQxw4XWGyaBoD9udmovFQhlmHfwaNYtHQFtr+/Dy4uroiJU6OotBxjxk+Ei4srtr+/j2GQ
+iNqNM5XA/9sLLAgFwu5vmn2yr3nbxxpCB2Nv+DN3hZLm/M/Nt/8AeHp5i83Evv4BAICvi47hxPFC
+eHp5w7f/AHH95SuT4dPnPqSuSTKoMXzo4TAAEJuOA4MfNAhm+f/5GIA+4O3PzcbAQUFYk/Y23n93
+h8XylZ87CwCIj4kEAPTt5wsAOHO6DIB8DaFcTSYRUVtzox5IyAXC/ICZw5rvONKaQp1OJ9YYSn+m
+RrhahPRNB3E5IBxLnuhjdrVzhUXoERSI28FASE2gqcNhD5UHnn52KlLXJIlNuzXV1di9NR0A8PSz
+U9FD5SGuf1lThQ/e3QlAH+6uX7+G365dw4njhQb7lTY5J6dmYPnKZCxOeA1x0TNReuokYtUJcHN3
+t1q+iKkzEProaCyNn49ZLyxg7R8RtRtffQ9s/gyYEgSE9DNd/sqHQGdn4KVRTX9sNgG3nF+/+x8u
+A0DlFRR9lIWDFsY2+ncPxLi+DIQdSlNefaS5j2VNYPCDyHRZh/252Qh9dDQA4MTxQgwcFIRJz04z
+WDd1TRIqL1UA0PcpBIDxEyOwaccek/1uz0gzqL0Tah2TUzPEmkhr7vfrb/L8Pz+UJ9YYGnNxccXm
+nVk275+IqLkMvgco7Qss2wvsmAn43HVr2fpDwBdngczpgHvn5i2HPTWBTXFuc6xax3P4LP8ygB4Y
++VQgAu8MROATAPArijI34mBVD4ycG4XAOw23Yh9CMsvcHFEt0XTs6x+AWS8sAKBvmo2PiYSnlzcS
+k9fL1uKFT54OTy9vAPom5PPnziDQz8fkJg2DZSXFWBo/XzyGtZHFAFBbU4O50yIwfdJY1NXVInVN
+EoYP9MWpk/8FALH/oHCLiVM3yetBRNRUpgcDo/sDr+beeuyjYiDzCLB8LODr1XzHNjchNa9h3HR+
+LcxHCQB4PIB+d1pbW9gmnYHQ0dnzh9fSf6STnp0mDiIBgF+vXoWmynT+gyHDhuOJJycZPDY9Mtog
+mMkFtKJjR1BXVysODikqLcf0yGixj2DqmiQE+vmI4Q8AXN3csGnHHoMBJIdPlKH/gL8bbCMXQImI
+2oolowH3Lvr+giUVQEIOMHs4MMq/5cvCANiUhNpB+9weFMVASObZ8kfaXH/INdXViIueiRPHC9G3
+ny/69vMVp3mRTgYNAKOeGG/Qp9BWQmgUBp8At6aUEUYHF5WWi+FPjqbyJ8ydFiEGVdYQElF78erj
+wFflwOJsYOT9wAsjmv+YrXlecQTnPsrS1w42APsQUqM15R+vNAgKoUzoeyf00xOaj7e+lyMbBMtK
+ijFnarhYq2eNtF9hTJwa+w4etbrN5apK1NXVImv3dnGaHMB0hDEAs2GSiKg19bwTWDEWyDgCLH+i
++Y/neH35Wl4PVQ8AkhrCM3ux8gPjiHgZBzetxEHhV4+RGON5kIHQkTTnf11NMceUMDG1p5c3/v1Z
+kUnYe+jhMBSVlouB7/ERgbLTufj6B+DwiTLZY0jDn3A8oVbPHufPnTEIpUKtpfEE1Nsz0pC5cZ1d
++yYiailD7tXfmptWq4WTk1PzH8jB3d7dE/5PhwIf/FlT2HccliwZ9+dSC4NKzvwERVJSkk0pwVKY
+MDfgALgVFLRarXirr68X72/evIk1a9bY/GTJPGuBT2658Xsnd0kh40sLCTetVive19fXQ6VSGez7
+kuX5nYmIqIPyMhr7p9Fo4OTkBKVSCYVCId5LbwCgVCoN7hcvXgxnZ2c4OztDqVSK+xBu0nWFfUhr
+IeUeM17W8ZzD3pVZKPEYiRdm6ecY1OMoY7IR+20QERE5JgZCksVwSERErYXnoJbHPoREREREHZFw
+CTuDBw0Hlfg/vQT+p1cyEDa3qqoqTJgwAVOnTkV0tPlLnFVXV2PmzJmIiopCWFiYwbLi4mKsW7cO
+a9euhbuFS6sVFxdjzpw52Lx5MwICbLsqxuLFi/Gvf/0LgYGB2LJlC3bt2oVz584hKYnz5xEREbU/
+fTBuyRIIQ0milgRa36TvEjYZNzcPDw/k5ORg586dyMvLs74B9CFy6NChSEszvWpGdXU1IiIiTJYV
+FxcjIiICly5dwrhx49C7d2+T26ZNmwAAmzZtwr333ot7770Xffr0wblz5/Duu++iuroaH330EaZN
+m2ZyXEtYtU9ERNbwXNG2sYbQDj8vXIjua9fKLhNq+AoLC81uHxlpeq3bf/7znwCAr7/+GgBQWFgI
+V1dXZGVlYdu2bYiPj8fzzz8vHmP+/PkmtYjFxcWYPXs29uzZI1szuGjRIgDA3Llzxfu5c+di06ZN
+Bn+gH374IcrKyjBhwgSTfcTHx8uW3xIFAP75ExE5lo46drejYyC0gXEQlAuG7u7u2LNnDwB9QHvp
+pZewfft2eHgYzqVXXV2NhQsXYsGCBQbhTa7JODk5Wdyf8TEEaWlp2LlzJ7Zs2YLExESsW7dOPGZ1
+dTVmzZqFESNGIDo62uJ/Z1VVVfjoo4+Qk5OD/v37i1PLaDQaPP300+jTp49drxkAdHEG6m7avRkR
+EbVjXdpgsuCk2Na1wbet7em+di1+XrgQgOVaQsG9996Lbt264eTJkyb9Ac+fPy+uY/z4yZMnsXr1
+agDAmTNnTPrx+fvfusikWq2/JFpBQQE+/fRTuLm5ITIyEkFBQUhPT8eZM2ewfv16k1pDISQWFRWJ
+j61atQqAviaxf//+OHXqFDZs2IBVq1bhww8/RFBQEEJDQ+2++PhtnYDfb7KWkIjIUSig/+63hgGt
+7WEgbAbu7u6IiorCxx9/bBIIt23bhoiICJPBIR988AHuuOMOfPvtt5g/fz6ysrLMDkKJj48HAERH
+R4vr6HQ6hIWFIT09HVFRUXjppZdQWloqW7b33nsPgD4AlpSU4Pbbb0dGRgZcXU0vsTZ79uwGX4Wk
+kxK4yxX47QaDIRFRR6aAvmbwtk76735qf/i22UBaKyitLbQkODgYFy9eNBhIkpeXh4sXLyI4ONhg
+3aqqKgDAX//6V2RkZGD9+vXYtm2bzeWrqqrCsGHD0Lt3b0RFRQEA3nrrLZNBJQcPilcuRHFxMS5e
+vIhx48YhMjISO3fuxObNm/Hcc8+hulp/iZH8/HyMGDECGo3G5rIQERFR+8MaQhsYNxFbazIG9DVx
+CQkJmD17Njw9PVFZWYlly5YhJyfHpHYwKSkJw4cPx7fffgsACAsLw5kzZ+Dj42N2/2q1GvHx8cjO
+zgYAeHt7o7Cw0KTPokAYWALom43/85//YNCgQQCAkSNHIiAgAE899RSWL18uli80NBRHjhxBcnIy
+3nzzTbtHiN3QAldqWTNIRNTR6aDvM/77TX3LkD21hGw+bhtYQ2gHW4KgVEBAALZs2YLw8HAxDMoN
+MvHy8jKpNYyOjkZ5ebnsbeLEiQD0g07Ky8tRVFSEXr162VyunTt3wt3d3SCY/utf/8Ldd9+NIUOG
+GKy7aNEiFBYWIj8/367nDuibihkGiYgchw76735qfxgIm1FVVRXmzJmDO+64A1evXsWIESPEEcMC
+d3d3LFq0yOKE002tpqYGTz31lPj7qVOnsHPnTrzyyism5VCpVHjuueewdetWsSnZVr9zhDERkcPh
+d3/7xCbjZpCWloakpCR4e3sb1AoWFxcjPDwctbW1UKvVZgeNSNczRxhlLPjhhx8QFBRksVyPPfYY
+ACAuLs7g8f79++OLL74wO3gkKioKUVFRdg8uYe0gEZHj4Xd/+8RA2ESkE1Or1WqUl5ebrBMQEICy
+sjIA+tDo4+ODoKAgvP3222bXkyOMMpbq1asXPvzwQ5v6EJpz8OBBzJkzBwDw5JNPtmitJREREbUe
+RVJSkk1h3tKAArn56YR7oVZJq9WKt/r6evH+5s2bWLNmTYOfAOnZMuDDeB3j36U1gMLE1MJNulyn
+00Gr1YrLhPdTpVIZ7O+SfS3MRETUQXgZ1SdoNBoolUo4OTlBoVBAoVBAqVSKg0mUSn0PNmGZcFu8
+eDGcnZ3h7Owsbq9UKsWb8bbSe0s/y/3u6NiHkIiIiMjBMRASEREROTgGQiIiIiIHx0BIbdr2jDQE
++vlg7rQI1FiY9uaypgpjRw7FiiWmA25WLInH8IG+KCspltlSr6ykGMMH+uLzQ3kGj40NDTbZTjhW
+oJ+PTbexI4fisqbK7D6kx7TEeJvPD+Uh0M8H2zPSrD4v49fF3uPXVFdj7rQIq+8DERG1T843btg2
+g2RTDCqRDkCor68Xb0TmBAY/iEyXdSg9dRLfl5+Hr3+ATdsJAWj5ymSDx8tKivHS/Nl4a/0Wg31l
+7dqGurpa7N6ajn8G6icJT0lKROVPl5C1a5vBfnqoPLDv4FGrZbisqcKMZyaYfbzyUgUAID4mUnb7
+mDg1pkdGY3tGGlLXJAEABg4Kwp69n8LN3V0Mgvf26Wu1LMZS1ySJx38rcRl8+w9AD5X8CHUickxb
+vwDe+QrY+CzQ17N1ynDz5k1xAKOTkxO0Wq04MIWDSpqWs4uLi00rNiYQCm+m8QhjBkKSWrEkHvtz
+s80unz5prMljY8ZPNAl9lzVVOF50DJWXKuDT575bj1dV4q3EZSYh7/NDedifmw1PL28kJq+H25/T
+7SQmr8eMZyZgf242Qh8djYceDmv0c/z8UB7iYyINgp2UEP48vbwxZrz+ijTTI6Mx6dlpiIueafAc
+P3h3JwD5QBkTp0b5ubPi67k/NxvHi45h63s5KDt1EvtzszFm/ESEPjoa8TGRSIifjzVpb8PN3V0s
+ozkhg/1NHktOzWiS14eI2oZPy4CUfGD1pNYLgwDQpUsXODk5wdnZ2WCEsfFoZYCBsLHYZExtxvKV
+ySgqLUdyagYAfW1YwVclKCotR1FpOQq+KsHAQfrJt5NTM1BUWo7lK5OxYkk8Hh8RiMpLFdifm42n
+Ro3ASwmvwdPLG5rKn3D9+jUAwPlzZwCdDjFxajEMXtZU4a3EZXBxccVb6zYb1JL1UHngrXWb9csS
+l4nNviuWxFttJh4+0Bdlp04aPL/tGWmIj4lEcmoGNu3Yg1WJywyaclcsiUfqmiQxLFqqsdufm43K
+SxXi6yDcxoyfCBcXVwQGP4jlK5PF13LM+IlYtX4Lyk6dxNL4+Rg4KAiLE17DQw+HISZOjRPHCxEX
+PRM11dV46OEwcX/b398HFxdX8bief/GCi4uryXvDMEjUcZypBP7fXmBBKBB2f2uXhloKJ6amNse3
+/wB4enmbNBN/XXQMJ44XwtPLG779B4jrL1+ZDJ8+9yF1TZJBjaEQUoTQFRj8IKZH3ro6jLTpNjk1
+A77+ASZNyr7+AXgjeT3iYyIx45kJ2PpeDpavTDaplZRj3G9wemS0eHyhVhKAQa2o0EwsZVxzGjLY
+H/f97X6MGT8RDz0cJtYqJqdmGJStproau7emi9v1UHlg8fzZqKurxYnjhSY1fSeOF2JV4jIsX5ls
+UEsYE6c2qKHcsy8P77+7AyGD/eHp5Y2t7+WwuZmog7hRDyTkAmF+wMxhrV0aakkMhNTm9FB54Oln
+pyJ1TZLYtCsNN08/O9UggEibT/fnZuP69Wv47do1nDheaLBfaZNzcmoGzp87g1+vXsX29/fB1z8A
+NdXVYr/BlxbMEYPOQw+HITk1A/ExkUhdk2RTGLTmoYfD8O/PisRAOnBQkNhka2z5ymSET3kec6aG
+w6//AKxJ01/ZJi56JsaOHIoRoY8AAE6d/C+Wxs/HrBcWYHpktBighdcFgE19H40DaOqaJLEPI2DY
+ZFx5qQKPjwiUbbonorbnq++BzZ8BU4KAkH6my1/5EOjsDLw0quXLRq2LTcbUJgUGPwgXF1fsz83G
+54fyxHAzcFAQJj07zWBd6QCJMeMnomvXbpg8I8qgKVW4xcTdugb09MhoHD5RJtZAvv/uDrEG0rjW
+S2hGFUKPMPrZ1lHFUsLoYKGZG4BYYyfdj7Q5WRj0ItTifV9+HqWnTmJQYDBUnn8BoG/Ovf3OO3Hs
+cAGuaKoMageHhz6CSz9eFEcUC6OPt2ekiSOIhXIvX5mMf39WJPZjlHsdheZ7Ty9v/PuzIoZBonZi
+8D3AQ32BZXuB8iuGy9YfAr44C7wyGnDv3Drlo9bDGkJqk3z9AzDrhQVIXZMkNl0aD/qQCp88HZ/l
+fwpAX6Mm9Nez1eeH8sRasJcSXkMPlQe2Z6Th2OECszV3gGETr7lRxQLjmje55mGhLNKyS5uXBw4K
+gsdfvMTaztBHR+v7RgJQeXhiUGAwDh74N6qqKuHV824M79YNRUePoGvXbnh5+RuY8cwEvJW4DKmZ
+u+HXfwDKz51FTU01fvzxB/Ts2QtubobPc39utsWBPp5e3maXEVHbND0YqPgFeDUX2PnnWLWPioHM
+I0DSU4CvV+uWj1oHawipzZr07DRxEAkA/Hr1KjRVlSbrDRk2HE88OcngsemR0VZrCAXCwBJAH9Ie
+ejgMZSXFyNy4DieOFyJi3CMWa/xsJQyakSuDJfn/+Rh9+/mibz9fAPpaUE8vb5O+lIA+INbV1aLo
+2BEMGTYc4ydGiMuEpvjKSxU4lPcJvHrejeNFx3A4/1NUXqpA8PAQk+BrrYaQiNqnJaMB9y76/oIl
+FUBCDjB7ODDKdBIBchAMhNQm1VRXIy56Jk4cLxTDUF1dLaZPGmsykfKoJ8Y3eFCDdGCJtDna1z8A
+n3x+HAMHBaHyUgVmPDNBNhSmrkkSm3ilTcBNKfTR0Zg2ay66du0mPtbP19+kLyUA9PDwhIuLK8rP
+ndW/Lh6G80UIYbL83Fn49LkPv169iqOfF4gjk43tz82WbRYPGexv0keTiNqXVx8HvioHFmcDI+8H
+XhjR2iWi1sQmY2pTpEHQxcVVHPAB3GpKjY+JtDi6taykGHOmhqOurtbq8YTpWwDIjrwVCKHQ+Jjm
+mn2Fcvx69Sr8+g8waYoFTAdrmPPQw2Goqa7Gh1nvANDX9K3ekC67rq9/AA6fKDO7L+NJtYXRw379
+B+Aen3vNrkdEHU/PO4EVY4GMI8DyJ1q7NNTaGAipzRD62AkDFYzDnjCwQwh85ka3WgpF0qt+AIZT
+wZhTU12NZeqFmBW9QCyTue2Mr0Li4uKKWHWCbB9EW/sQmiNdT6752Ji1oBwy2F9szrYlqEpZCsZE
+1HYNuVd/I1KsXr3a/CVIJJrzSiWrVq1qzHMgWH5/zK1j/LtwmUFhmfQmXS68l8Iy4T1VqVQG+7vE
+S94SETkkL6P/gTUajewVRoSrhUivNiK9vfzyy7xSSQthH0IiIiIiB8dASEREROTgGAiJiIiIHBwD
+IREREZGDYyAkIiIicnAMhNRsOH6LiMjx8Lu/fTKYh/Ds3jdwUBWDOf1OY3NaHi7LbaEKQ0xUIG7X
+b4Hc/8vHX+ZGIfBOw9V+LcxAmuZhvPR4b4PHyw+sRc6fU8QJ05lw2pmOqYszUHeztUtBREQtqQtn
+OG6XxLftl2ObseenMMSMuwNAEOYsNbxOqS3z3AFnsffNfPxldhT+ZmYNn1ELseARLa4e34l92scx
+KcCt4aWnNu22TsDvNwGbJrokIqJ2TwH9dz+1P0pAXzOYWvx3xMwOwh127+IyDm7KxVkAOFOC0h4P
+4G/drW919Qrg27ur3Uej9qOTErjLFXBxZhMCEVFHpoD+u/4uV/13P7U/zr8c24yDqhgsHXcHcCYH
+b5T1x9Jx91nf8kwu/u9bwB89MHJuf5SkF+Hnv5QCl0ux6c18/Tq69/HWqVub3D8hDqPuAYBynNb4
+IfB2APXN8KyIiIiIyGbOdwTPwRwA+LkQm7MqERbdHzlvvIESS1sFRCAcJejRYySASgB9MH7iFWzZ
+7IdJL49DHwC/fJku9iE0vHQdcO3rIzjz88/4Lu0IcOcQsAthx3RDC1ypZZMxEVFHp4O+z/jvN1lL
+2F792YfwLHLS8uAZvhRB3QEsXYoJ0rV+LsTmD4AIcTDJryhM74EHht2Fnw7pV/nlu/8CD4ejj9VD
+XsO5b39G3zExGNntBN77WGt1C2qffrvBMEhE5Eh00H/339mltUtC9lLi50JsfmOP5RpBE7cjKGq2
+Pjz+6Y4hszF7iPUeiNe+zsXnV+wt8Az00wAAIABJREFUJrVHv3OEMRGRw+F3f/vkXPjBf/H36KW4
+68gbOGV9fQvOInfl+yiVPmTQh/B+PBk3DJfLVOh3/xWwXrDjY+0gEZHj4Xd/++QcNHsOAOhHCTfK
+fRi/ZAnG/Tk9jbk+hH+d8hjOf/Ityhp9PCIiIiJqCuz2SUREROTgWm0+8TP7U/GdTgfcacMUN0RE
+RETUbMwHwp8LDS5f1yM05s8RxnJ+RVH6Rhw0vtad0TyE8HsSsY/8FQD0o4x71aP+528aVnIiIiIi
+ahKK1atX29T/09Kl66TLhJ+Fe61WazQPYb14L9x4LePGs+XSgsbrGP+u1WoNlklv0uXCeyksE95T
+lUplsL9L1Q16KkRE1M55uRv+rtFooFQq4eTkBIVCAYVCAaVSCYVCfx0rpVLfg01YJtxefvllODk5
+wdnZGU5OTlAqlbL7EbaV3lv6We53R8c+hNSmbc9IQ6CfD+ZOi0BNtfmEeVlThbEjh2LFkniTZSuW
+xGP4QF+UlRSb3f/nh/IMHq+prsbcaREYO3IoLmuqrB5Xbh9yykqKMXygr0k57d2PUD5rrwsREZEt
+GAipTQsMfhAuLq4oPXUS35eft3m7FUviZcNhWUkxxoYGy4ZDIZTNnRaBmhrDkPX5oTyTUHlZU4UZ
+z0xA5aUKAEB8TCQC/XxMbtsz0qyWN3VNkriftxKXWQyhREQtYesXwCNrgTOVrV0SagmtNqiEyNiK
+JfHYn5ttdvn0SWNNHhszfiKWr0w2eOyypgrHi46h8lIFfPrcGrR0uaoSbyUuQ+VPl5C1a5vJdnIq
+L1Xg8RGBAABPL2+oPDwB6ANifEwkBg4Kwp69n8LN3bB9ZHtGGlLXJMHTyxtjxk80eX77c7NxvOgY
+tr6Xg7JTJ7E/Nxtjxk9E6KOjER8TiYT4+ViT9jbc3N3FY5kTMtjf5LHk1Aw89HCY1edHRCTn0zIg
+JR9YPQno69napaGWwBpCajOWr0xGUWk5klMzAAADBwWh4KsSFJWWo6i0HAVflWDgoCAA+sBTVFqO
+5SuTsWJJPB4fEYjKSxXYn5uNp0aNwEsJr8HTyxuayp9w/fo1AMD5c2cAnQ4xcWosX5kshjZAX7sn
+7OPE8UI8PiIQJ44XwtPLG//+rEgMdYA+7MXHRCI5NQObduzBqsRlBrWRK5bEI3VNkhgWe6g8xOcn
+PLcx4ydi1fotKDt1Ekvj52PgoCAsTngNDz0chpg4NU4cL0Rc9EzUVFfjoYfDxNdg+/v74OLiKh7L
+8y9ecHFxNXmtGAaJqKHOVAL/by+wIBQIu7+1S0MthYGQ2hzf/gPg6eVt0kz8ddExMaT59h8gPr58
+ZTJi4tQA9EHr8IkyPPRwGPYdPIpFS1ega9duAPTNz/vyj2F6ZDQAYHpktLhdcmoG/v1ZETy9vDFw
+UBD+/VmRGD6NTY+MFkPX54fysD83G/tzs8Um4v252YiJU2PTjj0GNYc11dXYvTVd/L2HygNvJS5D
+XV0tThwvRMhgfwT6+Ygh9cTxQqxKXAZAXyMZ6OeD6ZPGYtYLC8Rw3PPuv+KTz48jeHgIQgb7W+3z
+SERkyY16ICEXCPMDZg5r7dJQS2KTMbU5PVQeePrZqUhdkyQ27UrD1NPPThVr3QB9E/EH7+4EoG+K
+vX79Gn67dg0njhca7Ffa5NxUTaoPPRyGf39WJPYlHDgoSGzqNSYEWqGcALDv4FGrxzBuSk9dkySG
+RsCwyVho4pZrSici+up7YPNnwJQgIKSf6fJXPgQ6OwMvjWr5slHrYg0htUnCYJL9udn4/FCeGKYG
+DgrCpGenGawrHZAxZvxEdO3aDZNnRInNp9KbUCPYED179oKb262gJ9TaCU3NAAxq+oTbiiXxJrWD
+w0MfwaUfL4ojioXRx9sz0kxGOC9fmSzWXo4ZP1H2eQk1hkITN8MgEckZfA/wUF9g2V6g/IrhsvWH
+gC/OAq+MBtw7t075qPWwhpDaJF//AMx6YQFS1ySJAyo8vbyRmLxetvYtfPJ0fJb/KQCI/QMtDcSw
+lXRQSUycGm7u7iY1djFxarEZWko6GMTN3R1ePe/G8G7dUHT0CLp27YaXl7+BGc9MwFuJy5CauRt+
+/Qeg/NxZ1NRU48cffzAJoADE5mlzPL28G/2ciahjmx4MVPwCvJoL7Jypf+yjYiDzCJD0FODr1brl
+o9bBGkJqsyY9O82gH9+vV69CU2U6/8GQYcPxxJOTDB4T+vnZWkMYHxOJbVtSTR4XatyKSsvF0CcM
+frG3tnHIsOEYPzFC/F1oGq+8VIFDeZ/Aq+fdOF50DIfzP0XlpQoEDw8xCb/WagiJiGyxZDTg3kXf
+X7CkAkjIAWYPB0aZTlpADoKBkNqkmupqxEXPxInjhejbzxd9+/mirq4W0yeNNZm4edQT4w36FDaE
+p5e3Qah0c3PHph17sO/gUfRQeVicv9BWo54Yjx4ehvM3jBk/EZ5e3ig/dxY+fe7Dr1ev4ujnBXBx
+cUVg8IMm+5AOXpHeQgb7m/SZJCKy5NXHga/KgcXZwMj7gRdGtHaJqDWxyZjaFGkQdHFxxfb398HX
+PwDArSbY+JhIeHp5Y+t7ObJBsKykGHOmhqOurtbisYSpYopKy8Vj9+zZS3bdy1WVZucvNB7kYY8e
+Kg+DgSWTnp2GuOiZ8Os/APf43Gt2PSKixup5J7BiLJBxBFj+RGuXhlobAyG1GULfPKGZ1jjsCfPx
+CYHP3GhaX/8AHD5RJnsM6dyDxtu5ubtj8owoxMdEyk727OnlLdtMbEsfQjnWgmvIYH/xePYGTnNl
+IiKSGnKv/kakWL16tc6WFXU686tJlwk/C/darRY6nQ46nQ5arRb19fXivXBbtWpVY54DwfL7Y24d
+49+1Wq3BMulNulx4L4VlwnuqUqkM9neJl9glInJIXkZj/zQaDZRKJZycnKBQKKBQKKBUKqFQKAAA
+SqW+B5uwTLi9/PLLcHJygrOzM5ycnKBUKmX3I2wrvbf0s9zvjo59CImIiIgcHAMhERERkYNjICQi
+IiJycM51dXU2rdiYPoTCvbS/mbQPIREREZGx33//HU5OTqivrxf7EAr9B4W+g+xD2DScXVxcbFqx
+OQeVEBERERnr0qULB5W0EDYZU7PhnxoRkePhd3/7xEBIzaYLZ7kkInI4/O5vnxgIqdnc1on/KRIR
+ORIF9N/91P4wEFKz6aQE7nIFXJwZDImIOjIF9N/1d7nqv/up/WHFLjWrTkrgzi4AurR2SYiIiMgc
+5ngiIiIiB8dASEREROTgGAiJiIiIHBwDIREREZGDYyAkIiIicnAMhEREREQOjoGQiIiIyMExEBIR
+ERE5OAZCIiIiIgfHQEhtWlVVFYYOHYq0tDSL61VXVyMiIgJ5eXkmy4qLixEVFYXq6mrZbdPS0sT9
+C8fz8fExufn6+qK4uNhgu/j4eIOyjh492mCd+Ph4g7JbKmdeXh4iIiLMljM+Pl52u7S0NJOyWSJ9
+vkRERAADIbVxHh4eyMnJwc6dO2XDkBxLIVIIZJYCUa9evVBUVITy8nLxVlJSggcffNBgvbNnz2L0
+6NFikHN3d0d8fDy2bdtm8/OzFBBtUVxcjB07dmDWrFlITEw0CJN5eXmywTYpKQlJSUmyyxgUiYgc
+E69lTG1GREQECgsLzS6PjIw0eeyf//wnAODrr78GABQWFsLV1RVZWVnYtm0b4uPj8fzzzwPQh6/5
+8+cjKioKYWFhSEtLQ1JSkrivpKQkTJ8+3aayVlVV4eLFixgwYABOnjwpPh4cHIz09P/P3p3HRVXv
+fxx/nRlMDR1RcV8umpSKmJlpdLVcsDJbMAva1K65RIaVmGi0uqSm1C0zUsjMuvbDtEgtu4VmN8tw
+aQG3kowSNRFFEULNmfP743CG2WfYUT7Px4MHM+d8z5nvGbY33+0kkZaWRnh4OADBwcFOx8fExLBq
+1SoACgoKnM5jKzY2ljVr1gBYPycnJ9OzZ08mTpzIrFmzCA8PJzY2lrFjx7Js2TL8/f0JDw8nOzvb
+rs4xMTF07doVgH379rFo0SJatmzp0zULIYS4eHkPhCfSWZL4I72iJ9C3qaeCJ9mWlMjGPP15cwaN
+vwv1wzf5Mq+0lKqqJY+CueXhIbQrX73FRSglJQXQWr2mTZvGO++84xRWioqKePzxx5k8eTKhoaF2
+28eOHWsNewAJCQnW8wH4+/tbXwMgOjqa6OhoYmNj6dKlC9HR0eTm5hIREUHfvn2d6tewYUMmT54M
+aMHs4MGDTmX8/f0ZP348GzZssNZDl5mZyezZsykoKGDevHksX76cRo0asXfvXrvXCwkJsT6Oi4sj
+ISGBuLg4IiIimDlzJuHh4dZ6jho1yu56Y2NjGTp0KKmpqdb3Li0tjXHjxtG2bVtSU1OtoXLSpElE
+RESQn5/PqlWr7N5PIYQQdYvfnDlzrE8CB09iYliAXYGsLWnkhUZ5CYOlut81ndu7/MrH8zZZt3W7
+80mGd1axWCyYzWYsJ3by7noLPp5S1DGdO3fGZDKRkZHhFKoOHDhgLeO4PSMjg4ULFwKwf/9+u9Y/
+cA5a0dHRZGZm8umnn1qDHmhdxraBCkqDKGgtbe+++67b+oeHhxMeHk5RURE5OTnW7Vu2bMFkMgFa
+cIyLi2PMmDGsW7eO0NBQ0tLSSEpKsrbw2Tp69Cj5+fnWusTExGAymazdv7q2bdtag96VV17Jhg0b
+rPsOHz5sFzxtj7vtttsAGDlypDVICyGEuNidJH3pYtJaR+EXHx9vv+9EOksS08iz25jCi27Hq4cQ
+OeN2LivL6+fnkk9gWY4QdYinVrbly5dbx+vZWr16NQEBAezbt8/aHRsdHe3y/LYTQZYvX05xcbE1
+WPXr189r/dasWYOqqgQEBHgtazKZaNWqFaCNObz11ltZuXIlABkZGXTv3t2nljn9+saNG0dcXJxd
+S6cr999/v/VxbGwsw4YNc3ovdZ6CqBBCiIvY/s2kHQNa27QQhkTGExEMNOvHxHjtj2LW2jlsbKG1
+GpZ29Tqz3bdn9Tz2ANCc1raF8new/K3NHC8pGzw8nMaYMf++CSEcuRqLl5aWRk5ODmFhYXZlc3Nz
+AejYsSOzZs0CtKDnraUrLS2NrVu3MmbMGFq3bu1zl/Fff/3FrFmzvJ6/qKiIgoICayBMSEigqKjI
+Ggj1lkRvcnNzKSwspEePHkyfPp3169eTmZlJaGioU1e5bfe3LVfjL235EoSFEEJcTE6S/uVRQkID
+2Q0uWgh1J9LZmBnCkHi9FeRXPn5xFz2eusNja6CrLmMAmvbhwSm9tS7jkq5jsxn4x+CKX5O46Pj7
++/P0008zYcIEWrVqxdGjR3n22WdJTU11asWaP38+119/Pfv27QO0oLV//36CgoLcnj8uLo6vv/6a
+JUuWsGXLFrt93rqMY2Nj3S7xkpmZyYQJE1i6dClHjx6lffv2bidt6GHOcSKN3rWtT47ZsmULw4YN
+Y8OGDfj7+5OUlERiYqI19A4cOJD9+/fTs2dP9uzZY51EYys5OdlrC6EQQoi64+TWFNJaD2FSi43s
+PlbSQuhu7CCDJ9GlEl5074cL2Fvy2H5SSV+Of/AeLFhQCa8iLjahoaEsXbqUyMhImjZt6hTSQAtV
+bdq0ISwszNryBqUTRlzRu4xfeOEFAKdAWB7p6emEhIRYQ1znzp2ZPXs27du3d3uM4yQXd123GRkZ
+hIWF2Y0HHDlyJGPGjCEzM5Pg4GCSkpJo27YtJpPJaXwlSAuhEEIIGyfSSdnUiqj4LrB1IwB+kwYH
+4jwaKYtdmZDHYuY4NPTtfnG3zbMQIr20GAJ0C+nG3qOteGh0bxrZTSppTLu7J1TsosRFKzc3l4kT
+JxIQEEB+fj433HCD02xYf39/pk6d6nYx5+qwYcMG6wxePbDGxsZiMpnIyckhMTHRbTj1he14QF3L
+li3p3r07W7ZsoX///hQUFLBy5UrGjx/vchygtBAKIYTQnCR9dRqtIuPpApws2epm2ZkuRMTHE2Gz
+RVWz3HYZ244udDmG8IoBDDy6hqz83vQyQfa2r6HrKBoD5gpelrj46OsDOoaszMxMIiMjKS4uts4S
+dsW2nDtxcXFu9x08eNDrsjO2bMcS6t3AAMuWLePAgQNMmDCB/v37V/qyLrav+8477xATE0PPnj09
+lnPF17GMQgghLnxZa7VZxfEOS+T6AeQdy4MTP7NkNURN6If3uZPuNGfwxPH0beo4hrAJfQa0YOHa
+nXT+55+sPTaAUUNMaIMIhdDoC1PHxcXZLaisCw0NZe9ebfBBYmIiQUFB9OvXj2XLlrkt54rtLGNX
+vI0hdMd2bUA9rIaGhjJr1iyXk1xsF5y2Zbs8jn59tq1+ngKvHmTj4uLIyspyeX5PZNkZIYS4mGk9
+wJDCHLuh8CkoCyf2V+fs7UF8t13M2duDKFJI8e2WqFaBgx5h/LXH+HjuJlrbBMLWJQtT/3m9tg7h
+r58u5MPdzRgw+n56NjaXTCwxs0DGEFaYp1ng7so4PrdYLHb7bD9s96uqtqakvk+fKNSiRYuKXoYQ
+QoiL0LFjxzAYDBiNRhRFQVEUDAYDiqIAYDBod9LV9+kf06dPx2g04ufnh9FoxGAwuDyPfqztZ0+P
+XT2vq05uXcLiY0Pwo3kbAjN3kd7iKNCDLrfHE3+78wEeu4xVFfZvZg+tCHGz2vSpbW/z0Z6udO22
+l69XvIflgXsJbVTZlyWEEEIIIcrKj2b9GBI6h5RNEBJZ/jnFJ48fpfmgSFg/j3m7ALoR0gzyKJll
+3P1OpkwJwmy+iRuHHmDDa4tJbBrGvdfkVta1CCGEEEKIMggIm0g8oCxcuNB7XyOeuyRt9+mPbbsZ
+9a5F663rrOsQSpdxZZEuYyGEELWVdBnXfoaaroAQQgghhKhZEgiFEEIIIeo4CYRCCCGEEHWcBEIh
+hBBCiDpOAqEQQgghRB0ngVAIIYQQoo6TQCiEEEIIUcdJIBRCCCGEqOMkEAohhBBC1HESCIUQQggh
+6jgJhEIIIYQQdZwEQiGEEEKIOk4CoRBCCCFEHSeBUAghhBCijpNAKIQQQghRx0kgFEIIIYSo4yQQ
+ilotNzeX6667jsTERI/lioqKiIqKIi0tzWlfZmYm48ePp6ioyOWxsbGxxMbGOm1PS0sjKirK5XGu
+Xi83N5dhw4aRmZnpsa6xsbEu65mYmEi3bt28Hm9b3tv7IoQQQvjC78yZMz4VVFXVp336Y/2zxWKx
+flZVFbPZjMViwWw2Wz+EcKdly5akpqYSERFBcHAw4eHhXo/Jzc0lIiKCUaNGER0dbbevqKiIsWPH
+MnDgQKKjo63BLCEhgczMTCIjIykuLrY7JiQkxPp45MiRJCQkuHzdNWvW0L17d0JDQ8t6mWRmZrJi
+xQoeeughZs+ezbJly/D39we0YDpu3Di3x86fP99pW1xcnNO1CyHEhebs2bMYjUbMZjNGoxGDwYDR
+aERRFAwGrU1L/6woit1nT49dPa/r/Bo0aOBTwYoEQlVVUVXVGgQlEApXoqKiSE9Pd7vfVSi6+uqr
+Adi5cycA6enpNGzYkFWrVrF8+XJiY2N58MEHAS0MxsTEMH78eMLDw8nMzCQlJYV///vfpKWlkZSU
+xI4dO+yCWFJSkl04cyc3N5d3332Xw4cPs2bNGqf9ycnJbNiwwbpP/5ycnEzPnj2ZOHEis2bNIjw8
+nNjYWMaOHWt93fDwcLKzs+1eKyYmhq5duwKwb98+Fi1aRMuWLT3WUQghLjT169fHaDTi5+dnDYS2
+odA2GEogrBi/mq6AELqUlBRAay2bNm0a77zzjlPIKSoq4vHHH2fy5Ml2LXF6y58e9gBrS57eBevv
+7299jdzcXCZOnMjhw4cJCQmxhkhvwQ+0Ll890KWnp9OvXz9MJpPbFsnHH3+cVq1akZCQQFxcHBER
+EcycOZPw8HC71kzbesfGxjJ06FBSU1Ot74HeUti2bVtSU1OtdZg0aRIRERHk5+ezatWqcrVQCiGE
+qNskEIrKlfEDzHseCgrg/Hk4/7fNZ7P2+e+/wWzWPp8phhuGwIrV1lN07twZk8lERkaGUxfxgQMH
+rGUct2dkZLBw4UIA9u/f79SVatv1GxcXx7fffmsXJENDQ+3CnqvjkpOTnYJdq1ateO211xg9ejRp
+aWk8++yzdkHO1tGjR8nPzwdKWyxNJhPz58+3q2/btm2tQe/KK69kw4YN1n2HDx+mb9++1ue2x912
+222A565tIYQQwpEEQlG5el4FryVrofCDld7LKwrEz7Tb5O/vz/jx49mwYYNTIFy+fDlRUVFOLXmr
+V68mICCAffv2ERMTw6pVq9yOobOdQLJixQrat29v1zrnS5DKyMjg8OHDjBs3jri4OJKSkigqKiIp
+KYmZM2e67b7V66kfp7dYunP//ffb1XvYsGFux1GWpYtbCCGEsCWzjEXlC2wBCxfD+i+hTTvPZe+8
+B67o7rQ5LCyMnJwcu9m4aWlp5OTkEBYWZlc2NzcXgI4dO5KcnMyiRYtYvny512qmpaWxefNm2rRp
+Q1BQEFFRUXz88ccEBQW5/LjuuuvIzc2lqKiIlJQU2rRpw6uvvsr3339vnRQycOBAoDR0FhUVkZOT
+Y61nYWEhPXr0sDtOL2c7azk2NtblDOJx48a5rZ+niSdCCCGEJxIIRdXIOwZLFsGRQ+7L1K8P0552
+ucvf35+nn36aZ555hszMTGtX7KJFi5xav+bPn0/v3r2tz8PDw+nSpYvb4KR3CW/YsIH09HT8/f3J
+zs4mJSUFf39/Ro4cSXZ2tt3HunXraNKkCaC1Kl5xxRV07NgRf39/kpKSAPj+++8ZPXq09fUdl7JZ
+s2YNw4YNw2QyWY/bsmULsbGx+Pv7M3DgQPbv309ubi579uyhf//+Tu9LcnKyU930j+TkZO9fFyGE
+EMIF6TIWlUtV4f13YO7zUHDKc9l/TYTWbd3uDg0NZenSpURGRtK0aVOX4/KKiopo06YNYWFhrFxZ
+2kUdHR3ttcvY1+5hR3/99RcjR45k+/bt1m3Lly/niy++sBtvCNCoUSNMJhOtWrXCZDIRFhZmNx5w
+5MiRjBkzhszMTIKDg0lKSqJt27aYTCancZLgeqa1rX79+pX5eoQQQghpIRSVZ//PMOJGmPGE9zDY
+JAAedV4M2pY+EzggIID8/HxuuOEGp0Wb/f39mTp1arnHzOldtXqX8NGjR70eExsb6xRMExISXLba
+TZo0yVrm/vvvd6pny5Yt6d69O1u2bKFVq1YUFBSwcuVKxo8f7/KapIVQCCFEVZAWQlFhyrlzXLp0
+EaxI0mYU+2Lyk9DY5HJXYmIi8+fPty6voocv24WjPS287G6BaVtPPPEEUVFRZGRk2C3VkpaWxpo1
+a1yuJdi2rfvWTHcyMjIAPAZW21bKd955h5iYGHr27OmxnCvh4eE+LdwthBBCOJJAKCrEb9tWGr4w
+HWPOH54L3vcgfP6JNrawfUcY94hTEX1h6ri4OLuFmHWhoaHs3bsX0EJjUFAQ/fr1Y9myZW7LuRIb
+G8sll1zidoavqyVb9LURvdGXsbFdYDs5OdllIPQUXPVlZeLi4sjKynIZUD2RZWeEEEKUhbJw4UL3
+tyCxUZV3KlmwYEFFrkHg+evjrozjc/02g/o+2w/b/aqqoh7Po/5Ls7hk/YeeX/TqfjDvFbi8Gwzs
+A7/9Cq8lwR13+XJZQgghLgLHjh1zeYcR/W4htncbsf2YPn263KmkmkgLoSizeqkfcMlLM1FOnXRf
+qF0HbX3B4RGl2xpeCiE9JQwKIYQQtYwEQuEz5fffqB8fi/H7be4LNWgIjzwOD0+G+g73yW7QAOJn
+VW0lhRBCCFFmEgiFd+fOUS/pdfyWvAbnzrkvd8dd8PQsaNna9f7hEdBHlkURQgghahsJhMIjw47v
+8Ht6KobffnVb5nyXKyic8QIB4Td5PpmLiSRCCCGEqHkSCIVrp07iN/8FjB7uR6wGtqA45kmKbx2B
+xYdJLUIIIYSonSQQCieGtWswzH4a5cRx1wXq1ePsA2M5+/BjWBo0BLNZu0OJEEIIIS5IEghFqUMH
+MU6bjCH9G7dFzg8cyrkZz3O+bXttORoJgkIIIcQFz3sgPJHOksQf6RU9gb5NPRU8ybakRDbm6c+b
+M2j8XagfvsmXeaWlSte+C+aWh4fQrnz1FpXJbMaQ9DrGVxfA2TMui1g6XcbZp+dgCeuvfQ1t1iwU
+QgghxIXNb86cOdYngYMnMTEswK5A1pY08kKjvITBUt3vms7tXX7l43mbrNu63fkkwzvbLEx9Yifv
+rrfg4ylFVcr4EUNcDMrPru/soZpMnI95kvP3PYhFFvEUQgghLngnty5h8Sa9tS6Q8OiJ+MXHx9uX
+OpHOksQ08uw2pvBiprvThhA543YuK0tN8nPJJ7AsR4jKVngaZe7zGN5/x3W3r8GA+Z7RnH88Doup
+ibZNWgWFEEKIC1wWm48NIT6+i/Z0fypzElNLWwhDIuOJCAaa9WNivLZWXNbaOWxsobUa+nrruj2r
+57EHgObYrUaXv4Plb23meEnZ4OHhNMaM+fdNiOqlfLoW5YXpkHvU5X5L3zDOz1yA2rmLjBMUQggh
+LipdiLjd5mnwQMJbLHbRQqg7kc7GzBCGxOtdyL/y8Yu76PHUHR5bA111GQPQtA8PTuntcC9j4B+D
+y39NomyOHEaJn4Ly5Rcud6sdOmKZMRPLjbdoIVCCoBBCCHGRy+PIsUCthdDd2EEGT6JLJbzU3g8X
+oI9Qs59U0pfjH7wHCxZUwqsItywWlGVvoiS8CMV/Oe+/1B910hOcf3Ai1K9f/fUTQgghRI04uXUj
+u1v0wm/S4EBSnHZnsSsT8ljMHIeGvt0v7rZ5FkKklxZDgG4h3dh7tBUPje5NI7tJJY1pd/eECl+M
+8GBPJkydBHt2udytjojCMuN5CGwhYwSFEEKIOkSbXNKKqPh+7pad6UJEfDwRNltUNcttl7Ftx6LL
+MYRXDGDg0TVk5femlwmyt30UKjeLAAAgAElEQVQNXUfRGDBXyiUJJ38VwUuzUVYkuQx6ao8rscxJ
+gNBeNVA5IYQQQtSck6QvXUxa6yjr5BIDQN6xPG128dJ0TlboBZozeOJ0pk+/m25225vQZ0ALvlq7
+k4LfPmPtsQHcepWpQq8kPNj0OQzuh7J8iXMYbNka9eU3UNdulDAohBBC1DlaGDwyKJ7420sHBvoF
+BLaCY8DxI+S17kHe2jksdrvEjGOXsSZw0COMvzaPI3nYzyy2ddmtjPh5Ics+bsaA0Tdiwiytg5Ut
+9094eirK558677vkEtRxk1AfnQINL9W2yaQRIYQQom7Zv5k0wpkUbL/Zj+ZtCMzcRXqLo0APutwe
+T/ztzsd77DJWVdi/mT20IsTNatOntr3NR3u60rXbXr5e8R6WB+4ltFFlXJlAVVHeSYKXZkFRofPu
+m4bDMy+itmtfA5UTQgghRK1yLI3Fc9LsNvnRrB9DQueQsglCIss/p/jk8aM0HxQJ6+cxbxdAN0Ka
+QR4ls4y738mUKUGYzTdx49ADbHhtMYlNw7j3mtwKXVOdt283TH0UMn902qUGXwGzFsK1/yzZIC2C
+QgghRJ0WHEF8fITTZmXhwoU+pQRfF6bWH+ufLRYLqqqiqja3rrOuQ6h9LJBlZ8ruTDG8PBeS30Bb
+0NFGQFOYGo9634NgMFg3O34NHZ9bbMYb6l8z/cN2v/611PfpX9MWLVpU5hUCUFRUxNixYxk4cCDR
+0dFlPq59+/YkJCS4LJObm8v8+fOZOXMm/v7+pKWlMW7cOLfnbNiwIatWrSI0NNR6/JgxY3jppZes
+23x5XSGEqGuOHTuGwWDAaDSiKAqKomAwGFBKbolqKPlbpe/TP6ZPn47RaMTPzw+j0YjBYHB5Hv1Y
+28+eHrt6Xte5mWUsarX/bYLpj8GhHPvtRiPqqIdgylNgujgm7fj7+7No0SIiIiIIDg4mPDzcqUxu
+bi4REREcPnzYaV96ejpr1qyx22Yb7Lp06cLYsWNZtmwZ4eHhZGdnW8slJiYCuA2iGRkZdO/e3RoG
+AZ599llMJhM5OTmkpaW5rK8QQghR20ggvJDkHYPn4mD9R0671Ouuh1kvwWWXV+pLKorisXW4MiUm
+JjJ//ny3+1213o0cOZK4uDg6dOhAamoqLVu29PgaequeLjo6mqysLLZu3QrAhg0bXLbs5ebmEhMT
+w6JFi2jZsiVFRUUkJSUxfvx4a5nY2FhycnJYtmwZBw4cYMKECbRq1couMAohhHBPWu1qjsF7EVHj
+VBVWLodB1ziHwX90grdWwsrUSg+D1S06Oprs7Gyys7PZvXs3Q4cOZd26ddZtrj4SEhJo2bIlKSkp
+1jCYmZlJWFgYmZnO0+VbtmzJhg0b7EJaQkIC4eHh1tY8vWVQV1RURExMDAMHDrS+xtatW8nIyKBV
+q1bk5uZy3XXXAZCSkoK/vz+hoaEsXbqUyMhIp/MJIYQQtY20ENZ2+3+GJx+FH3bYb2/UGGKmwkPR
+UK/eRTdhpKioiJycHO8Fcd+yeNttt7k95oknnuDbb78lPT2dtm3bWlsX4+LiiImJYeTIkdayW7du
+tRvDqLcOgtZtPHv2bBYtWuTUPRwaGsqOHTsYO3YsWVlZMqZQCCFErSWBsLY6exZeWwBvvgrnz5du
+VxS4+z6Ie0673dxF7NSpU25DXb9+/Vi2bBn+/v5ER0cTHR3tcQJKbGwsXbp0sdv+2GOPWbuCdXpr
+oy3b1kOAFStWABAUFETPnj3Zu3cvRUVFREVFMX78eMLDwykqKuLxxx9n8uTJTucTQgghahsJhLXR
+t1/DtBg4+Lv99l5Xw9x/Q/ceNVOvanT06FGaNGniclxgYmIiWVlZ+Pv7223Pzc1l3rx5fPbZZwQF
+BdntS05O9jjBIyMjg5iYGIqLi5322bY+9uvXj169evHMM8/w5JNPlufShBBCiFpHAmFtcuI4zIqH
+Dx1alFq3hadegDvuqpl6lajOCSZbtmzBZDI5hT5X9JbB9PR0u+0jR44kISHBOgtZn5TiKhzqLX22
+PM0yzs11Xj/TZDLRqlUrr/UVQghRSiaS1A4SCGuLVf+BOc/AyfzSbfUbwMOTIfqx0tvN1QG5ubm8
+++671vUBHWVlZdGlS+ki6v7+/i67ZRMTE4mNjSUhIYFvv/22SutcVFREQUGBBEIhhBAXJAmENe23
+X7VJI9u/s98+PAKemQ1t2tVMvWrQ/Pnz6dChA2FhYT6V97ZcjeM6hFDaemgrISGBUaNGeV26xt1r
+tG/fvlzHCiGEEDVNAmFNOXcO3ngFFr+sPdZ1C4HZC6HPtVVehYp0AVdV93FsbCxbt24lNTXVZetg
+bm4uW7duZdiwYdZt+qQSx3MMHTqUw4cPU1BQ4PHOIQcPHqRv377ExcWVK9BlZmayYsUKli5dWuZj
+hRCiLqpIN7F0MVcNWYewJmzbCkPD4JV5pWGwWXNtwsiGr8sVBi+GHxB9YecvvvjCGsz02btBQUEE
+BQXRt29fwsLC7MYAxsbGWvcHBQUxbNgwvv32W1q3bo3JZCIlJYVhw4bZlYmNjQW0ySQA27ZtK9Ot
+8XRFRUXMnj2b0aNHywLUQghRS10MfyOrmtzLuDqdOqmNE0x5r3Sbnx88OAGemK6tLVgB3lrsXO23
+3ebqXsa2jx0/9K9tVd7LWAghxIXP8V7G+n2MXX0AHu9lrH8uy72MXQVCCYn2pMu4uny0SptBfDyv
+dNugofDcXOh0Wc3VqxLY/hALIYQQjuTvRO0ngbCq/ZGtrSm4dUvptqDO8OLL8M8baq5elUh+yIUQ
+QngjfytqNwmEVeXvv2HpInh1AZw9o21rbILH47QuYr/a/9b7MnGkOtcmFEIIcWHzJRRKcKwZtT+V
+XIi+364tJZP1i/ZcUeDe0fDkM9rkkQuAq6An4U8IIURlk/F9tYMEwspUUADznof/vF267ep+MO8V
+uLxbzdXLR2UNfBIQhRBClJWEvdrJ78yZMz4VrMgsY/2z7YxU21nGF4VPUuH56ZB7VHvergPEz9QW
+mL5AuAt4ttv1x/oPtARCIYQQZeE4m9h2u6OzZ8/i5+eH2Wy2m2VsO7tYZhlXDr8GDRr4VLAql525
+oOUchOmPwddfas8bNIRHHtduOVfft/e2ulRli56iKNYfWCGEEEJnNpvLHb7q169vXXJGlp2pWtJl
+XF4WCyS/AS/PheK/tG133AVPz4KWrWu2blXMXbA8d+4cDRs2rIEaCSGEqK3O2d6Ny4YEstpFAmF5
+7M6EqY/Anl3a824h2l1GrupTs/WqQYqicPbsWQmEQggh7Jw9e1bC3wVAAmFZ/FUEL82C5UtBVaFF
+S5j2LNx9nzaT+AJU0W5k27EgZrOZ4uJiCYVCCCEAKC4uxmw223XxitpJAqGvNv0XZkyBPw9DvXrw
+UDQ8Ng0u9a/pmlUZ27BoMBiwWCx2k0lsx2bo5QoLCzEajVxyySU1U2khhBC1wrlz5ygsLLQb4+fq
+9nRQOjFE3y6qnwRCb3L/hPip8Pkn2vPwYfDci9AxqGbr5UJlTBpxPIcvM4/15waDAVVVOXnyJI0a
+NeLSSy+tUF2EEEJcmP766y9rGNRbB225C31VEQYlYPpGAqE7qqp1DS+YDUWFcFkwzFpw0dxuzp3y
+hEqDwWCdLa7/x1dYWEhxcTENGjSgfv361mUChBBCXHz0ZeXOnj3LmTNnrDOLbX/v27YC+kr+blQf
+CYSu7NsNUx+FzB+hSRN4fh6MHgd1cEkVX7qNbbuP9R94fUmh06dPc+rUKcxms3X5If1Y/bOsZSiE
+EBcGV2sI6tv05WBs1wd0HDso3cW1lwRCW2eKIeFFeCtRayEc9RBMjYeApjVds0pTnlvS+dJtrIdF
+VVWtXccWi8X6y8B2v6d1K4UQQtRO7tb503/HO4Y827GDvoQ+CYM1SwKh7n+btAWmD+VAv+vgxVeg
+y+U1Xasa4Uu3satWQigNhnoXsd6iqAdFPRTqXL2Or9uEEEJUHl8Xb3YMhI4LQzu2Ejoe5+tsYwmI
+1UsCYd4xeHaaduu5jv+AJe/CzbfWdK3KraonluihznGfbSug7WedfoztNm/1lNZDIYSoXp7u7OGq
+nO1jxxBo+9ndeT21HFZGIJRQ6bu6GwhVFVYuh7nPg9kM056BcZOgfv2arlmNKE+3se0PmqtQqKoq
+RqPRugaVXk5nGyzdvaavJDQKIYRnlRmO3AU5/faltiHRsWVQbiNXO9XNQLj/Z3jyUfhhB9x5D8TP
+hMAWNV2rauNLK6K7lkB3+8A5FOrbjUajdeygq/8q9WNdPS7LNQkhhKhc7n5nu2rNczWr2FM3safW
+wfLMSBYVU7cC4dmz8OpLsOQ16BoC67+E0F41XasLhrsZx/o2x+5j2xCo77PtBvYUDqXFTwghapa3
+sX7uwp6rBagdj5GZxbVP3QmE334N02K0ULhgEYyIumBvN1dVHFsOPbUE2pb3tAyNzjEY+lIXRxIS
+hRCiapRn5q+rIOi43dM2V+cAaR2sKbUiEObn51fZuZX8E1y6cDaXfPEpxQ88xNkJj6I2aAgnT1bZ
+a9YGvoQnX2bzOo7zc9V652pNQU9jBT11D0voE0KI2sXTZA9fuoHdhUHHfa7OURHS8lg2tSIQNm1a
+Rev8pbwHc56BsP7w5Q4atu9Aw6p5pVqnvIHQ1XZvodDxuW15T+U8nVMIIUTt4an72F1LITgHRGkd
+rL1qRSCsdL/9qk0aOXkSlr4H1/6zpmtUK5Wl+9ZxGRqw7zq2fa7/QNtOLPH0mrbdya5IUBRCiOpR
+luVmbJ97C3a+hEFp0atZ3gPhiXSWJP5Ir+gJ9PXYkHeSbUmJbMzTnzdn0Pi7UD98ky/zSkuV/nEP
+5paHh9CufPV27dw5WPwyrHwHJk+F+/8FdfS/jYqsR+hpHULbbeA+FAJ2E0tsy+if9ZbEsv4CEkII
+UbPcteS5C3rewqC+3dPzspC/G2XnN2fOHOuTwMGTmBgWYFcga0saeaFRXsJgqe53Tef2Lr/y8bxN
+1m3d7nyS4Z21W5mZzWYsJ3by7noLldpRvO1bmPEEDBgEG9PBZKrMs1+0fA2OjhNM9GN1jhNJbEOg
+7Ws4BkZH0hoohBC1i6//tHtrPXRXDnzvKpagV8lOpLNkNURN6IdffHy8887ENPLsNqbwYqa7s4UQ
+OeN2LitLBfJzySewLEe4d+okzH4aDh3U7jJSR28350plthKC+1DoaXYxOIdFd3wpJ4FRCCEqly+/
+n31ZfsaXx76GQWkdrHpZa+eQkgm0CAdsWghDIuOJCAaa9WNifD9r4Y0ttFZDT3+IbfftWT2PPQA0
+p7VtofwdLH9rM8dLygYPD6cxZsy/b6LcPkyBd9+CSU9A+LDyn6eOcxccyxMKwfn+xr6ODazoLyUh
+hBDVw9NMY9tt3sqVJQzK7//Kk7V2DilEER+5izlfatucWwh1J9LZmBnCkHi9C/lXPn5xFz2eusNj
+a6CrLmMAmvbhwSm9tS7jkq5jsxn4x+CyX8kf2TAzHvr0g1WfQL16ZT9HHVGRVkJ3x3sKhfpj222u
+JqQ4PtbZlf3zMMZP12K5qg+Wq/qU6TqMG9YCYB52u8dyfsveRG3T1ms5t04X4PfBSgDOj324fOfw
+wvDDDgw/7MB8y+2ordv6fJyyfx9qcNdKr0+91xZwPvL+MtVFCFG7+doC6Mt5fBkfCJXfMlgZx9cV
+XW6PJx5g/y7rNr85c+a4HTvI4El0qYQX3vvhAvaWPLafVNKX4x+8BwsW+Haiv/+GpNfh8CGY9+86
+dbu5quYpOLoLhe7CnuM22+3eQp3dcgV/HqHeSzM5H/ccau9rnH7QPZ3Lb91HAFhuucPj612yYBbm
+QTd6LefS6QLqRz+IYWc65155s2y/NPfv45LnZ/D31HgsV/Wx31cShM/ffR80NmH8cSf1FszibO9r
+sLTxcRrW6QIa3j4E8x13c27+q77V6c/DKEcOo7Zp6zbsGVPeo17iv1Fbt8Uc9YBvdRFC1DqVGZy8
+LUnja/nKCqWifPwmDQ4kxWlzFrsyIY/FzHFo6Nv94m6bZyFEemkxBOgW0o29R1vx0OjeNLKbVNKY
+dndP8K2m32+H/yyHh6Khew/fjhFA+ZeX8bbP1SQS2+2uyrs7xtM2T/X1ts/Xbuiy/rJR9u+j3nPT
+MexM53zcc9CmHcYfd7otrzZqZN9a16Ydht8PUD/mIc58tgUal06C8lv1H/zeeAXzLbeDqYndtfha
+T+M3XwFgGRSO8cedGH7YUVr3fXtQThdoT06dxLAz3e5Yy+CbOJe43OU1X7JoAQS2wPBXEYa3l/hU
+l6pqORVCVI+yhjdvx1RVGJTQWDFulp3pQkR8PBE2W1Q1y22Xse2fcJdjCK8YwMCja8jK700vE2Rv
++xq6jqIxYPZWw4ICWL4EgjpDwmIfL0uUV0VCIfgWDAGU77djtAkprs6hHDkEgGH7d17XR7Jc1Qe1
+9zUu66wzfPoxypHDzmX+yMZv2Zs+nU8/T73ZT0PeMQD85r/gpXZayPr7zXdKN5ia8Pf816j30L1c
+Mm2y3T7jtq2ofa5Fadve4/V44vfe2xDYAsuAQRhX/cd9HQNbYBl8E2q3ENRGjbW6Xj/I+XVOF3DJ
+8zMg7xhqlyswbP/O4+srf2SjZP0MgS0wPxTtU52FELVPmf9ZLmMQ9PYaEvKqjx9A3rE8OPGzdepx
+gLej3GrO4Inj6dvUcQxhE/oMaMHCtTvp/M8/WXtsAKOGmNAGEXqQtgGOHIbxk6DhpeWulSjbWMKy
+hkLb7e66jXXWxat/2IFx3vM+1cew6b8YNv3XYxnz9OexKIq1JUz5IxsA41uJgBbwjGs/dHkeJetn
+p8B0Pu45zI6B8HQB9WY9jSF1FWqfazm35jPw0IVr+PpL6sVN1s434VGn/ZYBg7BERGJIXYUx5T3M
+UQ+g7N+HskMLW/Uvt5uWxSX33OZ0jvNxzzkFLuX77Sg7vtNaLhubMEfej+X6QU7jCetf3hpLz972
+QdWV0wVcMnE0yo7vsAy+CUPG9/z96hK34xOV/fu4ZMzdAPz99GzP5xZ1Sm5uLidP5lNcXHzBrxig
+KAoNGzYkIKApLVu2LNc53twC6zJg31E457V1pKyqL0gpikI9I3RrBbf1hOgBpdtty7g71tN5y1IH
+UTF+AYGt4Bhw/Ah5rXuQt3YOi90uMePYZawJHPQI46/N40ge9jOLbV12KyN+Xsiyj5sxYPSNmDC7
+bx3MOQhbNsMNg2X2cCWq6AQTb+dxnGVsy3HCiWXcI15bjpTvt1Mv6lbM05/3qZXJ+FaiU8jUg555
++vOcX7LC6ZhLglthGXyTy322V2D4v3fxe3U+5B3DPGkK5oeiUQpPg6tfQkcO4ffyPAypq7RzL3wd
+Gptc/no+/+wcjO3aYxl+B4qiYEx5z1pfaz22bcWw6b+YR48Dh1ZD9ao+Tu+139LXAaznxNRE63p2
+8frg5Rfp6QLqlYTB868uxTJgEPUmjOKSMXdz/pk5TmMvDf/3Ln7PTIXAFvz91vuo1w+uxj9LorY6
+e/Ysv/+eTf36DWjXrj3+/v4X/B9wVVUpKiri+PHj7N//C//4RxD169f36djfj0N0CmQcquJKViHH
+r9/fZsg4rJBxGNZlwpv3wD+aV0/r34X+vVRb+NG8DYGZu0hvcRTooc08cTHh0mOXsarC/s3soRUh
+blabPrXtbT7a05Wu3fby9Yr3sDxwL6GNHAqZzfDt/6Bpc7hnVCVcnigvb+HRWyuiztPSM566lMsT
+XM0PRVuDo9/E0QAug15Z6UFT7XIF5xe/jdr7Guu2868uLQ1FpwswrvoPxmRtaMP5WQuxePs+bmzC
+/Hhc6fGffowlItIuABsBNv0Xy/AIt93YOuX77aWtoL5OQHHndAH1JowqDYMl1/n30nfxm/oofo9N
+wPJlGuenTEc5chi/BbNRdnyH2udazs+cXyUznMWF6fffs2natCktWpSvJa02UhSFRo0a0ahRI44d
+y+X337O5/PIrfDr2QgmDroOW9/CVcVjh4f+Dz5w7Rryc2/f9ovL50awfQ0LnkLIJQiLLP6f45PGj
+NB8UCevnMW8XQDdCmkEeJbOMu9/JlClBmM03cePQA2x4bTGJTcO495pc7QQ5ByH3T+g/0HWri6gU
+Ze06BvfhzNv+spZx3KaULEmgKEqZb3iun9N63C97UQoLXZctOOVyQojaqBFc3g11/CTMbdtprV0l
+LX3qPaNQ0z7D77EJmE1NUH7ZhyHpdcg7hmXMeCxPTIfGJlzW+sghu7GMapu20KYdyk/fa2P07n/Q
+6Ybw+rWoXt4H44LSLlpf3jOP722TANRr/4ll9EMwPKL0WpoEYEl6D16Zh+H1BC5JXaVtD2yBeXYC
+6r2jUajODitRmx09epSGDS+lVSu3/UcXvFatWnPmzFmOHTtGq1atPJZN/BoyD1+kf+ZsLirjMLzx
+NTwywLFI5QZBCY4VFBxBfLD2UFm4cKFP6cDXhakdb1FmsVisy41Yb11nXYfQjHLuLHOfeAKaN4dL
+/ct7SaIMytP65ssxZTmvdSxh8hsY5j5X5voAmD/41G2LmXGC1jJnXvqu9bmy8bMynV8dcrP1eJd+
+2YvfsOvtylsGDYUruqEGX2E3c9iW4zVbZryAZdwj2pMjh5xa9vTynq4XQHl/BcanY63Pz/96zNPl
+4XdZC+/X6Oh0AcoPO1A2p2H4JFWbWBPcFfbv0/YHd8Vy03DUq/tq70FFWynFBe+XX36mbdt2NGrk
+2CV0cSksLOTw4UNeWwmHLb4wWgd94iWM9Wxb2kro64oPjqZNm4bRaLR+GAwG64f+D63BpvHA8Twy
+YcV33iZvVimj2awFgw4da7IadU55xhL6cowvrYFOZXtfg2XGCyhHDqEsX4o6Igq1a3ePxxpWvw/7
+92kteL44XYB56lMoD0/2rXwJl+c/XYDyv00YPl5jDZjqiCgs941BWf8Rxqdjscx4wWNwswy/Q9v/
+815rgFO+347x7ls81sfdfsuMF7AMvwPjv+dBcFfUjkFlDr9u/bIXZf/PKL/sQ/nuG+uEFwJbaF3Y
+t47QruV0Acr6VAypH2B4PcHuFOqQm7V63jESdXiE4yuIi1xxcTH+/hf/P/v+/v4UFxd7Lbfvz2qo
+TGUrZ3Dad7Rql4yRQFe5ajQQmo1G78vOiCpRVaFQL6fzWv7qvlpr0ukCjOs/goJTqOMnuS//y16Y
++xzqkJtRrnAfHJWCU3Ay39oyaD6Q57asztg5UAtzJa9vvYojh1A2b0TZkY7yUcmqnYEtUGOmWscI
+Gh9/GLZvhWvCAK1Vz0nbdlogatveaXIIbdthmVE609kakB+cgFrSymaY+5zWAnfXvXaHqr2vwZj8
+hjbhJfEdDG++pp1DUWDnNo9BU9n4GX6XOS/wrg65GTp0RFm+1G6bNexe3Rdj326oOQe17mNTE7hv
+DJb7xmjv1/fbUX7ZB3t2lYbTJ+PlF3gdVdYhHxciX9c+PWehDoyn0C7Q15nTEgZrhxoNhKJmlTcU
+gu/dwz6Hw8YmLOMf1ULPzm1wdV+XxQwLtHtvW1y09imfpKKkrrZrHVMANWYqnC5w24Xr0ZFDGO8I
+17pGA1toAW1gOOr12i0XlfdXYHhlrnVNQrZvxbB9q8tTqUNudt9C1qadXRBWd27DuHwpluERpe/F
+3OdQOwa5DMzqn4e14Oj4vjkETVvuAqZ+nHr9YBS96/fybs5l8o65bt1v0w51eDvU4a4vVQhxMaq+
+UCdhsGpIIKzjyrsUTVmDoe0xtuzGn94zCpJex/jUFMyrP3UKcErSYpSNn2kBz0VgVH7Zh/LTTtQR
+USi7fkLtGKS1XgGG8Q/41I1qmPsclIzv01sLLQu1WcN6CARg5zYMb76m1WdEFJbn57oOnEcOWVsP
+1Yi7vL6+9Vr+dF5A29W5lf0/o14/2OegacdDwNSpwyMwjHd/izrlm/953E/3HtoEGyHERUTuN3wx
+kkAoKrQ+YXmCoavjATA1wbJwMYYHIzE8PwP15dJuV+WTVJS5z8E1YW4DhuWeUVCyzzGkqBF3ofYN
+81gXQ0lXtF5OHwdoFwSPHMKQtFjrSg1sgWXOy6j3jnZ9wl/2YnzgTm3m8aLkMo2fU3Zu0x5c7mHp
+lsOHMDwYiWX5Kvs6VgN94W8C3KwzhdYdfWEvPSxEXVE9AU2CYO0mgVAAFV+0uqLB0OqGIagxU1EW
+LYQmTVCfm6uFwUcf0sLgWyvd/1KxGZfnNJ7n1hHwy14MTz+JZfYC112gc5+Dftdpd8bB4Vfkzm0o
+6z+yjqlTH5yAOmUGAIaZT2mh0OacyvsrUJ56QguN/90Cl3dz/pVrW0fbWXGfpFrHDyqmJg6H2NzP
+uKhkGZ1GjV3Oqqus+ziryf9x3vjCDJT9+7C8usTtTGKlU3Ofzi8ufhX5Hli0OJEffvjJaXv9+vV5
+4rFHufzyYJfHHT9xgsVvLGHSIxNp3qwZixYn0ufq3oRd24/i4mIWJPyboeGDrc+Tly3nvnujaN6s
+WbnrCjUber56Qvt8wyuu9696SPsc+ZbrY3f+DlM+rPx6ye+AC4MEQmFVGXcyKdOEEjfUKTO0WavL
+l6Ks/0gbq1YSBss1DlCnT864fwSWtRvLtCSK4c3XIG2DFgQnPFp67C97taC4O1Or35FD2jjHtA0Q
+PgzLzPlleh0laTHKi89q4xUdb3cX2AJ+/00bYwkoH6/RtrsZb1llftlrnRHu7dq8tcoK4U3MpGjW
+fJgKwMg7IyguLub1xW/Sv/91vLn0LU6ePGlXPiAggPinpgHQuVMnnn7mBZ547FHuuzeKOS++BECv
+K3vaHZO8bDlnis9Uw9VU3KqHYIDDksHvb4f2TeHyknW/j8zVPheehRlrYfX32vNXN8OiSC38uQuN
+lcb6j2kVv46oNBf/1C9RJpXZoqOfq1zn7NNP+1wyWUNt3xEKT1esQo1NWusgYHhsojbRxEeWmfOx
+fJuB+txc+xB0eTcs/2WksZ4AACAASURBVPlIm0wychiGm/rDjztQX3xFG7/oITApv5Ss3VdSD8P4
+B7QweE2Ydk6HY9UJMbB/H4a7hmG4axjKRynaeMrqdLoAw6PjtMD6ZHz1vrYQNpo3a8Y/r7uW4bfc
+zLLkN1mW/CbTp8XSoEF96/4H7r+H8CGD+O8XaTRv1oyHJzzEuvWfcvz4Cet5tn6XDsCTU5+ocOtg
+dYh8C9rMgK+ztI82M7Qw2MqkPW4zA2I+gBNFkPRNaRgE+OZXiFkF9f1g2tBKrpje0+HQ41GxU0qa
+rE7SQihcqrQuYBfndEc9nIOyPhXlg5XaQsfBXVH/NRHl7SUoH6VoAWhEFAy5URszV57Wwsu7oU55
+SguXZTneVbArWZNQeSdZe75/n3MLohvKJ6lal3JwV5T330G9ui+WJ+NR+oa5neShjp+EesNgOF0S
+jBs3dt31XVV2bsPw8Gjtbiqvv+X5GvUxkI0aV0/dxEXvk08/45NPtYlh+j2D27Ztw46dpYnn+IkT
+NGjQgEsbNrRrVQRY82Gq9fhnn58FQFLy29Zjoyc95rELujb552VaAFz0Fbx8Z2mLod4yqHtisPbx
+/vbSruBvfoVrFzifr3EDLy9ajeFMgmDNkEAoPKqMbmSPdm7Txud9sQFFX64luKsWOG4dAYB63xhY
+/xHKqwu0dQA/StHG410TBmH9US/vqk2+aGwqDSA/7oBefVz/YrlvjHZttkvR6AEGL7+Mdm6Dn/ei
+bPpc6xYGrSt38pPaOMI27bwPz17/kXVMpLrsfZSx92J4MFJ7PnQYyiepnsPWn4fhcMmtDr7aBFd0
+gxuGOBWzjiUM8tDqkbYBQ6fmTpvVp2aC3mV95BDK0tfh7SVay2DJ18Z6nV9tdAp+yvyZ2oNB4fLL
+vY6rrF6H4bfczF0jR1BcXMyi1xNRFIXA5s05U3yGM2fO0LBhQw4fPkJI925ceumlBHe5jHfeXcnh
+I0eY/OgjdudwdPzECRJefrXCdfXp+Er4cfhnZ+gcCK9Hat3CL2+Cf10Ly7+D347DC8O1xy+lwf+e
+gFZN4IenoI0J/jbDos3aPtsqKQp0aFY59asI+X1RcyQQCq+qorWQndtQRt5c+jywBfxrIuqtI1yP
+ibt1hLbvl70o61NhwzptIejtW7W1Bj//Br5M01rdSngbv6Y8EV0a6nSuXnvp6yhfbNBez7a+d96D
+OnioNbiWSUkYpLEJ9YNPtNf4YKXWZVxG6usuRojb7n9qZtnrd3VfLQg+M630PQofhjrrJaewqry7
+zPl91F9Xbl0nKsmnG/7Lpxv+C5S2EHbooE0kO3gwhw4d2nPgwG9E3HEbAFde2ZP4Du1JePlVfvll
+f81Uugr07wz3XqMFv0Wb4amSX6OX+MEUm/8Lpwwpfb7jd7h/Odx9lRYWHbVpAo3ra62ONUWCYM2T
+QCh8VqnB8Oq+cOc90L4D6tV9XbZwuXR5N9Qp3WDKDO2+v9blWbpp4UoPP23beQ1qasRdYBsar+7r
+OhDeNgI+WKkFwK7d3Zfz1a0jtGu27bKe8KjW1Xy6APSxhb5yrEv3HvbPHSenlEWHjlpQd5hFbUud
+9jREPwY/79W64tuWLJAtYVBUoluG3WTXQgjQsGFDGjRsQEbmLms5PSSCNo7wxdnawuwZmbvsQqUj
+PWTWdnf2ggZ+4Dii+tx5eHmL6xZCb8I6acfX99NC4wc/VEnVXZIgWHtIIBRlVlnB0HadwXJp4xD6
+2rQrW/jxtWWvTTvUL74tW918OKdLjU0VnjWsL4dTGdTn5novpAfF6p7tLARw841DWb7iPXbv2UtI
+9240bNjQum/rd+l8/sVGpk3VUpEeKh3pXca1Xf/O0OcfsP13CHIe6VEm08IhvCvc+Lp2zt1HtO2R
+vasnEEoQrH0kEIpyq5KuZCGEcGP1mo+sLXzzXkqgV6+eTH70EXpf1Yvde/Yy/Jab7cofOnSYpk0D
+rCHxQm8h3HIArn9Fm0hiGwjbmLRJIZ66jG0N6AK92mtdztPCIdBfewxaF3RVthJKEKy9JBCKCquM
+tQeFEMKV115/gx9/zAC0Fr7Fi15h0euJRNxxG5dfHszqNR+xcdNmGjZowCeffmZtASwuLmb3nr3c
+OLQ0JV3oLYS2Lm+prSlYeBYCG0FeEcSkaOMBPXUZX+IH3VrDlJJlTOfeAWszSgNgZG+IGVi5gVBC
+4IVBAqGoVN7uVyyEEGWhzxDWFRcXWz+/MOtFTp0qYPYs7f7jc158yTqr+ODBHE6dPHVBrC1YHr/k
+aq2F/TvDoijIytVaEO++yv0xnZrD8SKIXaMFx7l3wA8H7e9O8uqX2vn+94R2/rKz/xsgWfDCUeUL
+U8t/BsJxgWr5nhBCVETxmTO8uugNmjYN4OWF82jerBnNmzVjzqznyM8/yWuvv0FG5i6aBDSxm2Ri
+d46SQDl23MM8Oe0p6tev77ZsbTPlw9Kwdmcv7fOrX9qXGdAF/pyrhcA/S9bgfykN+pWsQfjUzVoY
+vNthkYItB7SWxsYNfJmQorj4qF7y96TyKLNnz/ap+cZTK4/tPv2x7WdVVbFYLKiqitlsRlVVzp8/
+j9lsxmw289prr1XkGkQdJK2OQlwYfvjhe666qndNV6Na+HKtrStvzlclqPowdXRexY6fPHkyRqMR
+o9GIn58fiqJgNBpRFAWDwWDXyODqPu6eAqOESXt+DRp4W55cU5FAqIdBi8ViDYRGo9EaCIUoK/lB
+FuLCUJd6BerStVaX+vXruwyEehjUP4MEwoqq9nsZyxdACCGEEOUhGaLqVHsgFEIIIYQQtYsEQiGE
+EFWmyu+HXkuoqupT61U9YzVUppaoS9d6MZBAKIQQoso0aNCAoqKimq5GlSsqKsKXMfnBLauhMrVE
+XbrWi4EEQiGEEFXGZGpCXl5eTVejyuXl5WEyNfFa7qYeXotcNOrStV4MqiUQupv5I4NDhRDi4tay
+ZUvOnCkmN/doTVelyuTmHuXMmWJatvTeJDbuOujephoqVcO6t9GutTI45gVXmUJUnLQQCiGEqDIG
+g4EOHTpy4sQJsrOzKSwsvCjGFKqqSmFhIdnZ2Zw4cYIOHTpiMHj/k9rAD+aPvLhDYfc22jU2kHuh
+XVDkyyWEEKLKGAwG6tevz2WXdeHYsWPk5BzkzJkzF3woVBSFBg0aYDI1oV27dtY18bxpVA86N4eV
+42D5Vvh8N+zPhb8v8CV56xm1MYM3hsCDYVDPoF2ruHDUWCCUJl8hhKgb9BsRtGjRghYtWtR0dSqd
+vliyrwLqw8mzWnB6MKwKK1ZD6hm0a6wMkhWqT5UFQndLDcjYQSGEqFsURcHPzw+LxWK9c9XFQG8V
+9KVl0JafAQIbQuHfcOY8nFfhQn9LFAX8FK2buKpaBj3lB8kVFVcruowtFkuZf6CEEEJcWMoTni5m
+jepJt6onFoulpqtQp1T6T6arlO4u1evbjx8/XtnVEEIIIcQF7Pjx417zg6vtonx8DoSVdYNoV+MB
+srKyfD5eCCGEEBc/22xQnrGElZVb6opqbbt3/ALoCX/Hjh3VWQ0hhBBC1HI7duxw2RIoYa5qVPtg
+Dv2La/vxxx9/sHXr1uquihBCCCFqoa1bt/LHH3+4zAyialRpILT94nlaZdxgMLB69Wr27dtXldUR
+QgghRC23b98+Vq9ebZ2A5C1HSEisHFUSCH2ZFq5/EQ0Gg/Xz0qVL+eabb6qiSkIIIYSo5b755huW
+Ll1qlw3c3brOkQTDivG+7MyJdJYk/kiv6In0beq+mKKcIj3pDTYe07c0Z/CEu+HDN9l4zNUCS1dw
+2+Sb6GjTDGw4uJlbbvmSR54fza19+xIcHExgYKAsUyCEEEJchCwWC3l5eezfv59t27Zx8OBBuxDo
+rsvY2yQTCYdl5zdnzhzrk8DBk5gYFmBXIGtLGnmhUfRrBuB6sWlb3e+ewR1dsvh47iZtpUqg+13T
+ue0yFVXVPizHt/P2xxYCS9K/qqqo2V+w5PNfAXjj+edZ7Op1mlzNHbd2pREAhexd/zE7T7ooF9CE
+JidPccppe29uv0U/XnhSuOcT1v6ov4NN6H3bcLo2drPf4X31dqzV6X18su57mt5wH9e1871eX3ED
+w7vbfBUPfcvKr7KtT4N8PJ+na7Apxb5P1/J90xu4L8z7SQ9tXcnvHd29fhnOdehbVn6Vb/fe2b+v
+AEHccN91uDyT3XviWO4Q3678Cn1vk16327+fQlSRQ1tX8tVv7vY2IagTZNOr5OfjEN+u/J1/2H7v
+nt7HJ+tO0Mvu+7mQfZ9+BQNKflZO7+OTr+EG+V1fozxNBLENc7bhz2g02i32rX94C4UVrVvdlEXq
+nBR2lzwLiYzHLz4+3r7MiXSWJKaRZ7cxhTmZ7k4aQuRTd9ClDNVQ8v/kBK2g5At7+of3WfGtStNm
+kB94M+Oub68Fx5IV7dU/vmL5xgN0ujqEJiV3B8rZ8jHfnwpi8Kj+tDu0hfe+zOfq2wfBV6nsPFVA
+s0GjuJ0tvLc5n6tvv41upjJUsM47RGbB1YwaVfIrN2cL763fSsAD/bVfwjlbWPdTMwaPup12wKFv
+3mPddwE88M923o+1fZXdP1CgKDQzGPF+16dDbHnvS7KBJlcZbW4TVcjeg4GMGDVA++VfsJd1az/l
+F29fc4/XYFsukx9OKSjNjJ5vTVWwl3Vrd3IKhaAgN9fj67koZO9Pv6MoTTDYvDeFBQUE9B7BbSFe
+/swV7GXd/07S545RdDNB4e51pH76CxG3daMRhexd9z9O9h7BqJBGaO/rOrY2fYD+7T2fVoiK6th/
+BH3yUzl+le33WyF7130JN9xGh4Pr+P2k9vNRuPsnTvYexACjUfs9srnkXxgF/vf+70AQgx7oTzsK
+yT/VjE4BRowAhfkU0ByjseS5qBVcdfvafth2EXsKg57OL3x1kvSlKRwdPIn4sICS3LektIUwJDKe
+iGCgWT8mxvcDIGvtHDa2sG819NZCuOeDuewBoDmtS7YpioKSv423lm6yBs2uI4YToFiwZP+XFT+H
+MDqmF43MZk59v5Lk5HSujbyLHqaDbEr+nAN0ZujYsbQveW1VVenY6xoCDmzny/dKW4Z2rk21Ps7e
+/J61BWTn2vfYCXQaPIbrO/h2HXVbB64fYPO0Y2/6BHxI9uHr6dAeDv2RTZPed9KhpCu/w5V9aJKa
+zZEBHWjn5Virgj18n9+JTgG/gcGA51EBh/h6xZcog0czJHsFOxTbux2YCBkQUlo0IIQ+nXeyI+cv
+Qnq4D06er0FXyJ4f8+nUuQm/4eEOCwV7+HhtFsERd8LmDznu8np8PBdAzk/sbN6JTqdOoNicy6BA
+s6YmL+8VFOZkcapzH0ICtIKm0D50+mEHOYUhdDed5sSpJgT/Qz9PBy7rDDsK/sJgkPYUUdUMKAp2
+39f6NgwGDAqgGDAU7uPLH5rRZ7RJG+je8XpGj75e+1lLPU6f0QOsP6eHtnxJduchXG/7g9I8AJMM
+Nap05Qld7loKbSeV2oZC/cNoNHrtOpbu4nI68TM/HgthiJ7tmvVjSGiaixZC6wHpbMwMYUi8Hgaz
+SJ2zix5P3cFlHl5H6zL+lY/nbrTf0awvD8VdY+021loAFZTOw3i8U8lzIODq+3mAlby3KonvAIJv
+ZvzADtYAZ/1sNKA07UfkiBAfugVOs+ujD8jzGjyEa6c5cTKAFk2NGI05/HYggCtGNiltBWvaiSua
+7uC3wwPp2MHTsfq2QnZ/tYPmfe4mcOdv5HltIezIwH/9C4CcP0AxeGphK+R0PjTv3MTDOX27hsLM
+TewI7MvdAdv57aTB/Ws2DeXOf4Vq16Xo9XOolctzFbI79QN+uexuRoTq38U5fLUpn74jryHvwHYM
+Rv1c2nUpnV2/Vzlfv80XDOVfAwLI+e0Una/uaFOuI126bGR7TjGhodrjL3YdIXRAe9fvhRBVxohB
+gd82rcC+5ziAvkYjRoMCBgNHdu1A6XM3HR2/KY0GFBTt5wIozPyIjYah/GtAe+1noGQd487hA+X7
+uRr4Grzcjfvz1kIoy81UjZM//0he6BC7nt0u3UK0FkJ3YwcZPMm5K1hRPN6FW0Gxe6QCe1bPYw+O
+rXLduHNqf46/k8RXx+33Nb1uFJMmNbaOLUxM+sz+RYJvZvxVBlDg4Ja3+W6/hytv2o+okUEYFAWD
+0Q+/WnH35gvL6Z928FuzrvRt5ocfBhfvpdHt+2t/rL4tje2BNzGuk5HM78v2dTEoCorBiJ+7A/74
+ge0nu3BjJz8PM6Z8uIZTmaTtDOSmcUEYf9qBohjcvyZuzqFzey6j0/X8sTmN/L5RDGmWz5d259LK
+/rZxeckf0gD63X0XoU1s3hcM+Pm5roPt6wQNGs9Nm5NZvrzkPJF3W88jRNUK4Mq7xnOlm72nDyoo
+ioGggeMxbE5m+ZYbGTewKZlrUkjPLymkQNry39B+Bu5mfMn3btCg8YwfVA2XIHzm7ZZzrlr8HMOg
+t3GEjq/jLThKsHTPb9LgQFKcNmexKxPyWMycTfZ7ds/ZbfMshCgvLYYK0L1Hd/b82Zroh66hCaCe
+2EbyhyqBSgCd/zWVq0vGCuo3sj7w2b/5v5/GcN9VjVE738SkSTc6tRAC3HsP/L7pO5peez9RvZxn
+LajZaSzZZsBoDKBX5EQf3xJh6/RPq0jZHsiwib3Q/mUwlv6Hbv0PXPuv37FlzPlY4FQGn28PZNjE
+Thg57fI4T4wGUIxuWgh/38iSz08Qdk8knTyez9s1nCZjYzqBN0+kkxFOGxXw2Crp6X3wdC7t+7KX
+Tf0/PxH2/+3db3AT953H8bdsPcijq5DlGh41gBzHld1CudQlQAq2LyHQGE0nQW3SpE3vDod4GEqn
+nZsbPVavD7hOQ07jM9dr/l25ytDWcTuQ69nAXUgctU0htR0wVhPodca4FkJmLjd5VO7BrqRdafXH
+xkYEfV5PbK12V7ur3f199/v7Ix7v8lDP9bxtLJx34OhPqPvSbj71MVjd1Uuv+XlOxzR33P6P3x09
+wtxne+ntMrfv6A/4yT2Ps/vTTj1/RJbQ/O8Y/PEY1wreWGFet7nrY3XX42w8eoTTf+yly3Lu/+HU
+ANNreun6BMAfGB04QcGPn3o38vhjn0Jn9K1TLPgrNW+xgBDAadgZp0yhArylUyTl4ScYDhO0TTOr
+jMNB1pbIEE4e/Y7Za8XHqszEez9P55VBLl77LPetuMHv3zyJq+0ZPC4XN4BLr32Pn76bW4ex+pf4
+p/whCb2befLLn8baV6De5SIdP8JA3Hl7XN6mbPWCLMR13on9iDd9O3j22U9Ypmeya9aAo446l5em
+hsy0YsteZiT2Fo079poBm7mubPBymZH+42QTvt77eSJk/77rXEYGIT84uzzaz/Hk/Xzl2Qdt8zP/
+Dj8+8mauALpnB3u7Su/DH0//O2817mTvmvqSn1kof3/g8miF65p/hx//R4pNjz+Ix3ps6osEy2se
+ZGdLP2OXP2D9etsRKtiGzOc2ej3U/88Ib7k28cSazDXhYf3Dm5h67TIffMZ+rEWWnHc9X352fe71
+pRH6T0yz4nM7We+t5/pl6/XhYW2Ll6n5D6ivh3dix2H7l/DYzm/jut30+Jf49Mcs64zX6b5fBZUG
+hcWyhJnXC8kIlvssqZwbIDmXhNQUA8cgtKcDT5mFXC6n4WdcgI+uZ/bQ4U0w9J3csDPg4bNbm/ju
+T3/FPVuvcGy2k2d2fixbubx257f51g6zbWHqN7z4wixbvrGduy2fceO9Ezw37cXrdts+2+UC76av
+8sRnVJQtnXnOHvkRyfv3sW91/ns+mhqu8afrbtwN5qT0ZS6kGtnU4MZdatn3E0awd6IfWy3/iX6m
+732EfX+1lu379rG9xJbV11FQZXzpP5/nLd9T7HvIod6zYQNf2behYP+K78MfmboIcJz+i9ZljtN/
+8R4e2fcQdxffOiM7l62uvUSiwnXNX7rANa7x5pF+3rTMOX2knwv3P8UTGwr3rb4OGn3evOp2Lw0f
+hwvzH+B2Z0tIEhe9NHW4cV9zgauOerelSr3eaNRvmyay3NJn+dGvmnhq33YyZ6rRhjB3fV9PX8Pl
+rcftvkYy5eLj9W7q62DavIfc84VHzEy6pYlEvcM5LlVVSfWuNTtYapiZhVQPl9qOWubxNcH4VdL4
+s/Fe4vwkbo+vCeaAqzMkV7aRHI4QLTrETH6VscHX2ceezyW5MkeuZzH2f1zNu3jswj/wz8ca6NrT
+g8dlBID2L2iet3/+X7ge+BvWWnp//PnPf8ZVZzw5ZsYtBKP6uM4FqTde4vmSP3DSwq79283C9xKv
+Pfcq9Oxn+2q4/vYrvHC+jae/sp6/SJ/llZcmaPvqk6wvFxXfyd6Pc4YHeHptncNP2axgw6YWnhv+
+Ja3mMb30mzOkWnexpq6u9LJrH2b//octE65z9t9eYHaT8V1Uos4F1NXneummz/LGhRa27F+xgJ/d
+KbUPd7Nm/35sW/n2K7xwdQv7HyweChrqqcPag3IND5dcl7H/E61P8+R9T7L/Puu6LvHac6/TlD0X
+L3H2bS/rN5gPPu+/xs8vtLDrIeM4X/rlc7zKLvY/eDdrOh7gjZd+wTvNxrLX336Diw1tbPLWUedt
+peUXrxK/vME85tc5e/wMtD7NCvW4kmVlnO//fdU+9eXnz5j/eWlpBVwX+eXzP2cKMO7dK6hLXyJJ
+iuT7/8sWF7T0ZO4Zl3iNFGdeeZ4z1pU2rKS+zun+JdVSbOxA64gL5TKHpYJBtR1cgOatdJ+KEhtr
+MfqPpOKMjvtw07AK3/gE8cZZoA1/T5hwj9MaclXGmY4mtixh4jSTNBHwOizqgvRbhzk68Uk+2fYu
+Jw//C+z5W+5bQTYonP/VDxk4naT1i9/m6TWWzOCNG9TX1/Pe9BRe32bbyWMEhC4atnydp/6ySIYw
+/VtefnHWKKTNjXG5jCfIujrLSVdXZ1bnZQLPhRzdO4zLhSv1Oi8eet0+vXUX33hoNazdwde3vMwL
+hw6Z04MceGh1ZcvaP2jBxzu/nQkuFy7XRYYPXbTP2PAATz/5GYr2lSi1D+U+s/jWld0f+7oK280U
+X5eLP73xIoeyDz4tBA88zGrrejHX493AV3f9ie+/fIjXzWPx9acyx2INOw4EOfH9QxzKrKo1yDfu
+q+UnILk1PGx46gDZfP213/LyL2CX5Tqd/83LXLzayo4DO9hhWXL+vUmuffJeWt54kWFctNyTe+ja
+ceCAbV65fZTL5jkFidbhaKzTFNAtJQ8de0LMRDL9RHx07+3FdfDgwRuJ4QixcctYhI5KB4Tzbx0m
+RojOuSiD42AMWP15rmZ+zq7tMf7+Eb+5zO8Z/u5R3vV18sznZ+g/9i60Pcrf7VybXe+N1K/54Q9O
+kXuYbOWL39rJ6ryq6vdO/CM/e5cy7iX4zR2sqfBQiYjIMvn9cb736gXj/9Yg33w4d2ee//WL/Gvy
+Ads0mOftl34GPV9jwwpzntdTZT/Gu+Wv+dp96j5fbeXaFeb/7/ReuWxgJcGiAsryXAcPHrypEZor
+GeA5f55iryudvpDPFhERkeqqpMfxQqaXW+9C55GivYyXVn4nlMyXk5nm9GVZ2xfmL19qOREREbk9
+VdoOsJLATzHA0rrpgNC5x3Fl85UKFEt90cXeU8ZQRESk+habubuZaYvdDjEsSYbwZoNCoGQG0TrN
+qti6RERE5PaxmF7ANzveoGKChbnlwzQVCx5LBYvgnP3Tly0iIvLRtJiaQJX7y2fJAkKnrN5C5y0V
+AKqaWERE5KNnKTJ6CwkEFTQuTlUHci8VRJbLDjrNJyIiIh8dGlD69rHkAWGl7Qnzl4HigV8l7QdF
+RETk9nUrsnwKIBdvWTKEC6k+dlqukmX1pYuIiNw5bqZcV0xw827b3/5ebFApIiIiHx0K5m4PyxoQ
+LkVQp+piERGRO8NSB38KJpdOVX6pZCnWJyIiIrVLscDSumVVxqoCFhERkZulQHB5VGVg6gwFhyIi
+IlKOgsDlV1fND9cXLCIiIqUoVrg1qt7LWBlDERERsVIQeOtVPSC0yj8BFCCKiIjc+RQAVt9tFRDm
+U4AoIiJy51EAePtxf/jhh9XeBhERERGpIvddd91V7W0QERERkSqqai9jEREREak+BYQiIiIiNU4B
+oYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIi
+IiI1TgGhiIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjU
+OHfZOVJxBvrPsW5vLx3eUjOmiR+OMjKXee2je28IjlmnWQUIhYP4rZOmh4gMUji9qARDkRiT7SHC
+PfYl0mMDROe6CqaLiEi1meXFSvu9Oz02QPRk0jZnYHeYYLP5IhVnoH+GLrOMSAxHiI07rL6xm749
+HXiWbftF7jzuSCSSfeHr7KN3o/0SSpwZIdkeKhMM5hgXb4KhyGjeNMtMqTgDx8BnXXB6iMjgJACx
+yKTzym0XeZr44RiTAOMxItabQqMP31wSyJ+um0Sl7DdmH915DwS29/OOa7lls1JxBvpHaMo/P8ps
+V4yQ/Ty1nDvgcL5Vso9Fzw3ngquYxHCEidZin7+AdU0PERmctR27wsLS4aHKtvxkkfnMBynzldN1
+L7IcCgK4Oes92kegHcg+4CcYikzQVuJa9veECfcYZQGPmteKWb6ISCn2ciCwO4w7HA7b5zELafsz
+Wl5gZVOiUCrm6gxJVmVfGgUd+Boh6VRYmoVbYFuuwE4MRxmZMz87W3hmMpJJmnaH6aWwUJVKJDg9
+10U4bH4P00NE+odoyHzP00NETzYRCvdmn9Kjww3Zm3jJZa2fcsY4z5oq3KbMyevrtE5PEz+/ir5w
+0Dg3UnEG+geIl/vOS+6Ddb7TRoZ7ZZnNs1w3gdZin1nhukgTPzVJ3iMTyblkZcFbKs7A4Czde8N0
+eM3r63DcDHiNdRBFGgAACCJJREFUwnO2s4/wRg/GcY0y5Ks8KBdZLH9PH91Xosxss55vuYCuZWqA
+SbNGKT02ymxniCAUPPQZSYNM2ZNkZq6Jtsz1nle+iEi+vHLALDezGcJsVsXbQW+4AzAKydHGhWUP
+JgcjZsTps1+SeYFmYLdZgE8PER1fR1/YCPbSYwNEIqNmEJcJAgKEwmFbQOHf3I1vfMSWTRzpjzps
+B4z0Rxih8syR+An2WF42b6W7McrEdBB/MyTOT+Lr7Mt+H/7N3fj6J0j0+PGXWTYrFWf0SoBAY5Fs
+sI1xHrA7TOh8hFHbex46ejpyL70ddLWPMDqVpqPEeVt6HzLSxE/NEmj3UXIrs80q+uBYlBnHmSpc
+FxiB48oAgbnZgreafOWvxfTUOZLtXdmA2LOxi8DJUaZSHXR4k8zM+VjXklmPn7Z2GE2moVlZQrlN
+pOLETjbRFTbPyeYg4XCwoMoYIDFsNBsKWpdf2aCaIJFiUlOcmwvQlSkjzXKzMEOYXSDO6Hggd0Fm
+0vdlsoFOVcaZD8wEmjbNQcKWQMGzsZc+BoiaQRwO7QOzKq4CNqrqnAtqKc8IIlY1ACSYGPexbq/l
+qHtbWNc4Uhj0FSybkSZ+bISmbX2sOjVZwffiJ2iep4nz5eZNc/UKNLWWOisq24f0WIyRlV30NY5m
+sxaOsud2mnixrXJcl3Fenmu3PnQlGBqcpXtvFzPj1oDQ2C+KZB8TwxFihAj3+JgaTxLYZnt8oq09
+ZgbJxv+xMwk6zIxuwbEQWWbWB3aDj27Lq8SZEbA8sBWTaUIS7vHbqqMDu4OlFxSpYZmkga2UaA0Y
+GcJibQcruSArUXjxg5Hu38rVw4WdTnydfYQzgej0EJFIzD5De4jwZuPfqeEII0WrszGDxpbFb7yQ
+HhtlsnEdWxdR7e60rBEchQg3Q/zU0m0nYFbLBgjdbCbYzFCEwn4YGy0//xKtKzFspPGD3iRDDu9b
+M/CLbQrh7wkTGo5gVA4sfj0iC+ehY08Yh9QAAGnzr78nDMMRIsPGQ048r5wwaoaMcze8MbdMuCd/
+jSJSKXdfp49YweQEE+OQJErkpP2dSVuHj8raDwbaA0xeWZXL5mU7lXjwO9wcEsMRBsbMIDVTVVDA
+T+8eSAyPFG9XNT1E5BRkbkKycEb7ziZC4YV3xnFc1hocZW//S8TSEePmHmTMDOZuo5nCzW1lqXXl
+FY7TQ8SudNPX44G8VrxO80b6B8AM5vw9YcLm55XdnsNGGy6j8EwTPxxhoF0dS+QWcGyjDpngzvro
+7u/po/twlKHpMEHLuW/vuGVvGJ+lDoQiC1Zk2Bmjis4ehlVWZezYhrB1K91XYmYbJjP72N5n6SDi
+NHRAYTBa7CJPnnSYN7uMGhcvjqVHbLiS8MpaLVxs2QRD/bngqFDezX0BN/XEcMQIpjKdSzLyC6D2
+UIksgrEPieFoNoN5sypeV7YjSLCyQqw5SKg9UratpFWTzwPTQ4zQTV92ezx0PNrNuWNTpDeqAJVl
+lt90yOws4us0RrLIf2BqafdxLpmGZrIdTxrIl5flziYCRGQh3GD0XiQ1xcAxCN3UU5XP0hnEWjXm
+oWNbE5FjcVq2zViyIAZbqt+h0TBgXOTnnRsKa9iMpWbJIhUEMj5WNSaZuQpkbsCpKc7NNdHlLbPs
+9IQR7OU3IRiMZMeSLHwQKS/T+Snc43AOOLZdTZfYByM7XtizPkZkfKE96itfV3rqHEmS2Q5QGZP9
+Ec6VOL8LO5l4aFiJWYjm2iVOjPtYtRm4WvHGiyyvVJyBU6sKH+IsknNJaASjLTLZJEMm8RDYHbol
+mypyJ/H4mmD8Kmn8ucTc+UncHl8TzGF01V/ZRnI4QrREm7xJhzECjYDMfsEWaA4SOh8hOugrkQUx
+qtcW2naxZIYQsFdt53qsBpvNas3xdUYmquJBuO9w06fzskhWHjq2BYgMDmWzxZmxKv3lli2o/s8F
+j4vu/V3Q+akSpfbBjz8vKF38IOeFAa59XdZOJbm2UAbjoWpV9lxMEB/z5bKB00PExgOEzAepXKcS
+P/7N3Yz2x4i39JrDzljacXrbCAzGOD3dYR5z85qzZOxFlkf+jxcYopHMI5A5DiETlpqCAKGwB1JT
+zJJkdipNF9YRIxIMOTxIqWZIpITmrXSfihIbazGSDak4o+M+3DSswjc+QbxxFmgr0TC3TJXx9Gkm
+sYwFlSc9NkBsPECgfZIRS9sn6/vRk0kCu8P0OgQHifOT+Bq3Oq67ZIbQzDjKAs2NWG7UpkyP7+Yg
+fZ0DRDODmuf3BC+17LKYLBzMvFx1c7l9uA3N2B58SmQrvR307p4hkikkbcfCTzAcYigSITskfXvI
+HJNQZDnltYM125KH8ga1n5xrIxgO2h+kps6RbA8QOBklhnWsz8XVKojUNg8de0LMRDJlilG76zp4
+8OCNTBu+0uP0lQ4IM93/u+aiZnvAvF7EtgLXbCvW2E3fthmig5OFBXJB42PnArDoTxfZLGLwbBER
+WXrWQabbHX66riAbb/8lEqeft3OipkQiC+M6ePDgjWpvhIiIiIhUT121N0BEREREqksBoYiIiEiN
+U0AoIiIiUuMUEIqIiIjUOAWEIiIiIjVOAaGIiIhIjVNAKCIiIlLjFBCKiIiI1DgFhCIiIiI1TgGh
+iIiISI1TQCgiIiJS4xQQioiIiNQ4BYQiIiIiNU4BoYiIiEiNU0AoIiIiUuMUEIqIiIjUOAWEIiIi
+IjXO/eGHH1Z7G0RERESkitx33XVXtbdBRERERKpIVcYiIiIiNU4BoYiIiEiN+38yxKZxrtrIOgAA
+AABJRU5ErkJggg=="/>
+
+
+
+## 第三步：上传文件，文件支持doc，wps，docx
+
+<img src="data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAABKMAAAGuCAYAAABMXMVoAAAgAElEQVR4nOzdeVzUdf4H8NdweHGa
+gIIlhqLiUftTxCMV1LSSyDyysjUjU3PNDqDatnvTbS10O9Z1SwvNTc2LzMhSU1MXU9E2L1SO1CKU
+IxWQVIT5/fHl8+X7/c53LhhmOF7PxwOB73znO5/5OszM9zXvz/triIuLM4KIiIiIiIiIiBqsiooK
+eHp6unoYsrqMx6OiosLBwyEiIiIiIiIiIke6fv26q4egUpfxeLi5uTlwKERERERERERE5GgtWrRw
+9RBU6jIeJlFEREREREREROQ0DKOIiIiIiIiIiMhpGEYREREREREREZHTMIwiIiIiIiIiIiKnYRhF
+REREREREREROwzCKiIiIiIiIiIichmEUERERERERERE5DcMoIiIiIiIiIiJyGoZRRERERERERETk
+NB6uHoAzGY1GVw+BiMjh+NxGTZ3BYHD1EIiIiIhcpim+F2qyYRQPzoiosePzGJFE72+hKb4pIyIi
+ItJj63FBY3p/1OTCKB68EVFjxecvItuJv5fG9KaLiIiIqD5pjyca8vukJhFG2XMAx4M9ImpI+JxE
+ZJm1N1HKv6GG/IaLiIiIyNka8vukRh1GWTuI40EeETVUfH4iso09U/RYLUVERESkr6G9T2qUYZSl
+gzge4BFRQ8bnKKK6s/YpX0N7s0VERETUUDSU90ke7u7uLh2AIw7M7N0GDwaJyNkaypM+UWNi798L
+/76IiIiouXDU+x5XvX9qlJVRgrlQidP3iKghqa/nHD6XUVNn7c2R9nJHhL4MtIiIiKgxcNTZho1G
+o0ve/7g0jKrtgZStIZTeejx4IyJnYuUmUe2Ze3MklpkLn+oSSrnqDRkRERFRXdW2Ybkr3v+4LIxy
+ZBAllmm/O/J2iYjsZevzDQMrIvMsvTESl2m/C7V9Y8VAioiIiBoyW96n2BtMOfv9T6Oapmeu8kl8
+DwkJwU033YQ2bdrAzc3N6eMjouanLoGTtec0c+syjCICqqqqUF5ejry8POTn5wPQD6UYLBEREVFz
+U9uqcWe+b3JJGFWbAylLB21GoxEDBw6Et7e3Q8ZHRGSL2gZR1kIoW0MpoubMYDDAy8sL3bp1Q0hI
+CDIyMuTl2jdStXljxb81IiIiaijMhUvm1qtLKwNnBVKNojJK78BNfAFAdHQ0PD09XTE0ImqmHBFE
+aUOnqqoqs+vYe7tEzUmbNm0waNAgpKenAzA/bY9n5yMiIqLGqK4nabG3lYEzAqlGEUYpaYOogQMH
+MogiogbJWhClDaFuvfVWREVF4YYbboC7u7vzBkpERERERE3C9evX8euvvyI1NRXffPON6jJ7Ksfr
+O5AyxMXFOfVj9ro06tUGUSEhIejZs6dDx0dEZI0tz2O2TMVTfs2YMQOBgYGOHywRERERETVLZ8+e
+xcyZM2EwGGpdOV5fgZRTu3zXNYjSXtapUyeHjIuIyJFsCaKqqqrkr2eeeYZBFBEREREROVSnTp2w
+evVqkw/ClVzVBqRRnXJOuwPbtGnj6iEREdlEG0SJ57GZM2fyuYyIiIiIiOqFn58f/v3vf5vM0LBV
+fYVVDTaMstTkV+w8N7cGO3wiaqKsPRlb6xOlDKJuvfVWVkQREREREVG9Cg0NxZ133mk2kHJFdZRH
+WVmZaoHBYICbmxvc3d3RokULh91QXZM3S6c6JyJyhtpONdaWxIpQauDAgQ4fIxERERERkda9996L
+Dz7djMIyoOyaAUYjAIMRgOgJpfjZpE2UUW9hnXh4e3urb6L6IOn69ev4/fff0bJlS5dWIFlq+ktE
+1JBYCtLFz8qvG264wZnDIyIiIiKiZio4pCNyiqRjk5qe5PV3tjxrTFImg8EAd3d3tGzZEh4eHrh6
+9aorxqWiVxXFMIqIGjJLIZRoXO7u7u7CERIRERERUXPRwtMD0OYoRvkf5QIzHJvBWCx58vT0hJub
+G65du+bQG7XE1pCJYRQROZM9vaIsVXQqe0YRERERERE5lzgWqf4yOSzRW+Z4VuffeXh4oLKysk43
+UtuDLr0Durpsj4jI2TjVmIiIiIiIGgajaXWUWO5kVsMoNzc3VFVVOWMsNuGBHBE1NLb0itIua0jP
+q0RERERE1AzIxyOi+klUSOmta/PCWrEaRhkMBqcFP5Zuh+ETETUGtkznY6BORERERESuZHRifyg9
+rjtNnhWWpuTxII6InKkuU421/aKUy4mIiIiIiJzHTCWUSSNz5fL60WDDKCKixsDeUEnZxJyIiIiI
+iMipjKJvlGuPRxptGMUDOSJqaGyZasznLiIiIiIiahDMVUShNsvtU+9hVF0PvHgmPSJqbJTT8Kw1
+MiciIiIiInIto+a7daGdgOGdLK9zWzcgVLssAoi8AfCwa3z1iAdnRNSc8DmPiIiIiIicymgEDIpf
+YYRBuUBPB2CUv3qRQXGV0RGmV6m4DOw4C/xyBejeDcAp4AyAXmGAFwCv9g0ojLKF8uDt6q8/Arjb
+dYNxkXPnziE1NRXjxo1Dhw4dXD0cIrKBXsNyhlFERERERNTg5QNbz6kX3RYBXL0M+AC45gVczASO
+6Vz1zFnAOwy4MRiAJ9ARwJZM6bJG2zOqZcitTruttLQ0pKWl2X29iooKrFq1Cvv27ZOXlZWVISUl
+BefOqf839+3bZ9NtdOjQAZ06dUJqairKysqsrp+dnY1Vq1ahoqLC7Piys7MtbuPcuXNYvHixyZjt
+kZaWZnYcRA2ZLX2gbLk+p+gREREREVHDUItjkg7AqB7S18VMoLB68X8zAf8IqUIq8gbTqx3LBf4L
+oHsr4GRuzfJGG0Y5U79+/XD27FmrYUxaWhoWLlxocT1vb28MHToUK1eulNfbt28fioqKEBsba9N4
+oqOjAcDucOjcuXNISUmxGGKlpaWZhFNnzpyBv78/2rVrZ7K+CLTmz5+P+fPnY/HixSbbz87OxtGj
+R9G/f394enraNWaixkIvZDIXPDGQauYO7gdKS0yXn8oE8vPs315+nvltukppiXR/9DTE8RIRERE1
+CxaOQ3QvMqJnWHUIpZiq1zEC6O4FeHpJIZRX9fIb2ku/jw4DIrtV/xwB9MoHtpwCAhXLGtU0PWfK
+zs7G+vXrVcuWL18OAPD19cW4ceOQmpqKkpKaN9MTJkzA6NGjcfXqVd1t7tu3Dzt37jTZnnD06FF4
+enpi0qRJ2L17N86ePWtxjNrxCZ06dcLEiRNNgp8OHTpg6NCh+PDDDzF58mSTcCktLQ0lJSXw9vaW
+l1VUVCA3Nxf9+/fHmTNnTG7T09MTkydPNjtlsKysDFu3brU4XiEmJgYDBgywuA5RY6Y3XY+akPw8
+4FedMCmkIxDcUfq5tAQYfwdw+13ARyvV681/A9i2Gfj+aM36ttiUCsx7GdjwDdAvqvbjFz78p7S9
+F98AZjxRu21sSgVeeBpY9DFw9zj1ZR+8D6R8IN1PH1/r2zq4X/qqrX5RNfvF3P9RbXXrYdt9ICIi
+omapuLhYt6ijrus6hNGobv5kxvFc4LgB6Hkz4H8FSM83s2IwMNoHOFndHwoAcAMwvL16tcsXgf/m
+M4wyq2vXrpgwYQJOnjwpVyxVVFRg3bp16N+/P7y9vdGqVSvd3k2Wqn969+4tby87Oxtbt27FlClT
+4O3tjbKyMqxduxYeHh548MEH5eukpaUhICDAbFAjQiRlAJWWloajR4/K6yxcuBC+vr6YMmUKbrvt
+NuzYsQNxcXHy5dnZ2SbbAKSqqIsXL6JDhw7w9vbG888/L18mxmtORUUFNm3aJAd2EyZMQNeuXXXH
+f/LkSYSGavvsEzU+TTFsWrJkCXbt2oUPPvgAbdq0AQAcO3YMs2fPxqJFi9CrVy8Xj7CBEKGQljLU
+8fEF3nxHCmoW/A1I/Iu0/MtUKYh68Q39IEqEKPaGH6UlwKkT6kDMGTZ8Jn2PHml62Z7vgPAeto/n
+4H5pv95+l+llly4CB/YC/QcBfv6ml4t9KsIoc/9HteWoAJCIiIianOLiYmzatAndu3fHoEGDLK67
+d+9enDx5EnFxcc4NpOzk5QeM8rOQYVXasA1/YLR/Aw+jzJ0a3VkHe127dkVxcTFWrVqFuLg4bNq0
+CWFhYejatavVfk3KMOjs2bM4dOgQunbtiqtXr2LVqlXo37+/yfotWrTQ3VZAQACKiop0L6uoqEBJ
+SQnCwsJUIVJsbCxiY2Oxb98+5ObmqkKmAQMGYMCAAar+TV27djUJiioqKnDgwAH4+/ujZcuWFu+v
+3rjWrVsHAEhISEBxcTFWrlyJ7t27q8K49evXw9fXFzNmzFBVZBE1da4KrZYsWYKVK1dizZo1CAwM
+tLp+eXk5du3ahWHDhslBFACkp6fDYDAgKCioPofbuMx4wrSSKLSt6XqTpwIHvldXS736vBSomKtE
+qm3106kTUiVWXaqc7JWfJwVE8TOl4OzLVHU1UtYJKYz68J/61w/paFpNBZhWkgFSUDX+DuCF1/T3
+i3b/x42zvv9m/BFo2w6Y/67l9QApHCQiosZJVN7GjbPtA5IvU6Xveq9RjpafJ72G632oY4vSEqCs
+1PL9qu0HXY5UWiKNo5vO6dgawvjqqF27dujevTvS09MBwGwgtXfvXqSnp2Pw4MEuCKKMgLWz6Slc
+vmS9MsrqNlgZZZ4IUpTT5BYtWgRACpZ27tyJvn37WtxGbGwsRo8ejXXr1iEsLAwDBgzAvn37cO3a
+NYwfPx5bt25Fq1atAEgPvu7du6NDhw66lUahoaE4dOgQzp07Z1KFVVxcjIsXL+pWFYkpdpbul7hP
+SqKC6cyZMzh79iw6depk8b7qOXPmDHx9feXgqUOHDpgzZw7WrVuH+fPnm9wWETVMP/30E37++WcM
+HjwYS5YsQXJysuryIUOGqH5v3bo1Pv30U1ZL6RHT34QNq6UKKaGosCY80ZvG11hsqn6zPnyU9D11
+rVShpJR1wnyF0u131d8b/WArFWIH90v/DzOfZMUTEVFjdCoT+Eui/ocU+XnSa9SDD0vhhqi87Rdl
+WxiVWn2cJl6j7J1GbmvoBQB3D5e+f7mjdpXNYrr8J+vMB1p1nebf0Kb1N1AigDIXSCmDKGvVU/XL
+tlDKEZVRAsMoHZ6enqppcufOncPmzZtx3333ydU7ZWVlWLFihUnfJ6CmZ5Oeo0ePqqbPAcChQ4dw
+6NAh+ba1xBn0Dh48aNLk/ODBg+jUqZNuz6bi4mLk5+ejoqICS5cuxZQpU1T3S0tZzSSqompLW2ml
+7ZclrF+/3myPKyJyvfT0dAwYMAC9evVCr169MH36dBQWFmLSpEl4+eWXMWLECFcPsXHpP0h6gyy8
+Wf2z3rLGas2nUuWTePOrDNVe+3PNG0t731xPm2y67NJF6fubr+lP07PXpg3S9zgnfOpNRESOF9wR
++ClbqnLdmaEOMVYuB957W3qOd0S4IcIsW9kaegHA6/OB2Y8Cb80F/rHY/rGJ6fJ9FbNxnpkF+PkB
+r/3d/u3VF0dO62/AzAVSDSeIsl1NZZROeGWpMuoG4DZv4CoayTS9hk7ZM0rvjHjKaXCCsmeUlqUe
+TP369UNqaqqqOio7Oxtnz57FlClTdK9z5swZdO/eHSUlJbj11luxYsUKuT+VNSIcGzx4MH755ReU
+lZVh9erVqobtgjaQ69SpE7y8vJCZWXMmpZiYGFW/KaV9+/Zh4cKF8u+W9hFRY+LqqcZ1JabohYSE
+qJYfOXIEANCnTx9XDKths/YpqZ+/+tNHEaDoLWuMvkyVqp70+jsBDeONpZjaZ8nA3ta3w35RREQN
+j48vsHAx8PBE4OnH1R+I7N0jfSjkqNcgMT2/Xzdg2EjzodHEMVJAZs/U7rvHAcuWSOGRvbTT5QFp
+OtyG1cD4B+zfXn2pr2n9DZQ2kBI/uyyIUjYvl3Mly9VRx3+yss18YIuZKXwd2wN5mUDrbk1gmt7V
+X38EcHe9bV/vbHpiqp44m569rJ0pztvbG/Hx8bqXdejQAX379kVqaiqmTJmCsrIyfPHFF7jnnnt0
+w6WysjLk5uaiR48eKCkpQXh4OEpLS3Hu3DmbpsWVlJRg+PDhOHPmjDy2WbNmmdzG2rVrcdddd+lW
+Zt1zzz2q35UN4JVjED2siMg5fv31V5PpdcLixYvlaqfvv/8e+/fvx7333ovt27ebPAeY20ZUVJSq
+2Xmz8q93TKekKV26qA6rRGWPdllDCKTmvWz9E98zF9S/v/OW+nfl/crPk95Yjn/A+rQGHx/T/hGO
+6Bml9OY7QPfq29i0QarY2vCNep2TmdL0Ab11iYioYYoeKb3WbFgtVUNNnipN3zuwV7pc+9qg9wGF
+mHqm/JDpTPWRuAhHxLQ7EX6NHG0ajrz2Z+l2P1lXEwzZ8qGIcGCv9dcc7Ycj2unyAHCoesbLyNG2
+3a4zNORp/fVEG0g1loqonmFAR50W0hZPxHcV2JILoCXgKX4GgFM1qzTaMKplyK31uv2uXbvKlTx6
+0/TOnTsHAHY13TbXs0kpJibGbDAzYMAAFBUVyaGYpX5Lx44dQ1hYGHx8fFTXT0tLMwnZtPr3749R
+o6QnBRFG1Ya5qXnm7r+l+05EjhMSEmK1gXl5eTnWrVuHkSOlsukRI0bg5MmTnKJnC2W/p2mTpU/u
+hAN79d+AapeZqyzatME0yNmXbv6yX3+xfdxa4T2A0JttX19URSnp3dcNq6UvS5zRM6t7RM2bd7Hf
+zFU66a1LREQN11/nAzfeVDPtemX1TI4X36hZZ1+6FH7EzwRCblRfX/mcrw1DxO9i2l30SGkbsx+V
+KntmPCF9ADNnuvS6v+hj9TS0kI62j0Pp11+kYOr2u4ABg9XbU9JOlweAHVul7xn7aqqPLL1/cMZJ
+T+prWj853PFc4DhgT5/zGvnAFjMXNdowqr4p+yfddtttAKQ5nUVFRZg4cSLKysrQqlUrm84yd+3a
+NaxatQq33ioFaOZCpLS0NKvb6t69u9xz6uTJk2bDqGvXruH//u//5NBMEGfZ06O8z46grXjKzs7G
+gQMHdPtDpaWlNehTWBI1N59++il8fHzQtWtXZGdny8s5Rc+KSxeB0WNqftcGKnXtGWXp01FHV+tM
+esj2N6PijIDaAEtZafTma9Kbcm31kR4fnYYDzugZRURETYOPL5D4F+nn0hIpcBn/gOnr2rbNQNx4
+8x9GKM+UK16H9D4see3v0m3OexnY8pU0LQ/QbyAe3FE9ju4R0jiGj7J89rwvU6XX+nH3ma8I0psu
+X1oiXS+8B/DzWekLqKn0Onq4ZpnyftenxjCtvx4oe0QB5puaNxcMo8zYskXK7yZOnIji4mIA0oPk
+2LFj2LRpE65evYqwsDCLTbcPHTqEs2fPIj8/H5MnT0a7du3w448/WqxMiomJ0V1+7tw5rFy5EsHB
+wUhISMDVq1exYsUKzJ8/XzfcGjp0qL13uV5lZ2fjiy++wOTJk032WUVFhW4vKiJynfLyciQlJeHz
+zz9XLc/JybE4za9ZT9EDpLBFGUZp1bZnlPLNsJY4m41eDyN7pgLUxYf/lM5Ct3Ax8MlHNcvFeEpL
+qqvCHqh9nyXlp8ClJVIT2oBA4MlngZXLpNt/8ll1U1pLUyb1WJrWR0REDVt+nrrnUEj1GVQPHZBe
+I/6o3w7FIU5V98oNCKyZDth/EJD3izQuS6GKaDK+Y6vlMCpjn/Td0uuodro8UDMd7unn1CGWeP9g
+bqq7rRratP4Gylyz8uYcSDGMMsNc9dCAAQOQnZ2NrVu3Wjx1eVpaGkpKSpCQkCCHL6KhuT2VUWlp
+aTh69Ch8fX0xY8YMeVqgp6cnZs2aJYdUFRUVDbLxtzjrIADV+JWKi4tx8eJFu6Y8EjU2jaVpufDU
+U0/pLp8+fTqmT59uslz0lIqPj2++QZSwL139e7+omjd5Z35SN+LU9p8Qy+yZHmdJvyjTN4D1oXuE
+9KYxeqQ6jBK++1b6fuNN1t9YioMHIW6ceh8e3C+dJSkgEFi1UXoTGjcOeHCs1Jz2bwtq3pj2izKd
+vmCJctoEUDMlgoiIGr5NqepQRPR9ih5ZP9O9vvtWCog2b6qZpj7+ASn0ys+TApcXnpaWBwQCf4gE
+Hp5mGjj5+ErX27TB8pnuNm2w3IBdb7o8AHz8b+n266u/UlOf1u8A5oIoc2fZay6shlFGoxEGi52p
+mi5lE/NOnTqhZcuWqKiowIEDBzBq1CiL4YmlUMhaZZSyt5Sls9ABUmPzhIQEAFJwNX/+fLOhlF5T
+dj39+/fXXS6CMS3t2fRiYmLQrl07rF+/Hr6+viZn8FMGaMrr6DVBJ6KGo7y8HDNnzsSwYcNUgdSx
+Y8eQkJCgan7eLOXn1ZSbi0Bq22bpzbAIUsw14tQu076pmzYZ6Nm7ZsqBPRb8DTh+tH7frN09zvKn
+ueKT6vfelr4sEQcPQnB1OJWfJ53iesNqaT+/8++aKqhuEdIpvJ9+HBg1WOq7MXOO/Z/0aqvPDu5n
+GEVE1FiIDy/EyScA2yqEzV2ufT3S+uQj6XW+/yDpRBfDb5derz78pzSObXuliqlNqdKHJds2A3PN
+vAaOHC29vn2Zqh8afZkqVXclvqh//dISKfwK7wH4t1VfL+uE6YctjtTQpvU3MOaCKKE5B1JWw6iq
+qiq4ubk5YywNjrKJudKDDz5ossyextvWKqM8PT11b8MaS/2gAPP3R7DWM8ra9rXM3ZYyQCNqThpb
+dZRWmzZt8MEHH2DmzJlYuXIl1qxZg4KCAjz00EOYPXt28w6iAOkNqDbwCW0LeFe/UQrpKE0jUwZK
+ev0nFvzNdNv2TjdTOn60bte3lXJ6nJY4QDBHHDgEBAIxmlDrVKbUeDblA+lyQArmtLfn4wv86Wng
+fxk1Z7wb/4D0Bj96pOXxERFR4xfc0bRqSNssXFS8KpuFz3tZCkcmPaS+rt7r1pmfgGdmAbu+Bb7c
+IYVL2tuc93LNB1HdIoBEG6aR3T1OCpPeeUs/jHrnLek1MM5MddOH/5RCp0UfS2elU273ZCbw4MPW
+x+AMzpjW34AUFxfj5MmTVs+aJy47efIkunXr1mx6KVsNo65fvw53d3dnjKXJsxYy1ccUu65du5pt
+cq6lNz5tE3Iisk1jD57MadOmDVasWIHt27fLfaOSkpJ0p+41e2I6WvfqN6F3j7OtRL421U8NXWmJ
+6fQ74VQmsGCeetodIO2/f70jBWkBgdIb+wcfBnqHSgGbnoP7pTe5R89Iod6mDTUl/m++I53e2xL2
+jCIialq0zcJFxauyafm8l6UqHb3qni9TgW+3SOFTUWHN8rjx0odNp06o+1QJv/5iOi3dWn+jl+cC
+D0+UAhvlWFYur6luMvfBio+vVDV89zh1GAU0rPcV9TmtvwFq164d4uLibAqXBg0a1DCCKCNqd9a8
+WrAYRlVUVKCqqgqtW7d2zmiIiMghlixZguTkZLOXm2tADgD33nsv5s+fb3H7I0aMwA8//CBXSd17
+770IDAys9XibvC9T9d+s6vWMEkI61l9/B2eb/4ZUsTTzSSlQEm+mT2VKvZ4AdRAFAN16SPtHhFA+
+vlKoBaibmevx8ZX6biT+RXpj++0W60EUwJ5RRERNXb7Oa7HeOqdOSIHJyUzpQ43xDwBH/ieFVqKa
+2dIUwJQPTF8/rPU3ih4prTPvZalKuFtEzQc24T0sT4V78GH9qinRpNwSvftQX72Y6nNafwNlT7jk
+8iDKyUzCKKPRiKqqKly/fh1VVVVo2bKlK8ZFRER1YK7RuCOJKqklS5YgISGheZ9Fz5rUtZanyum9
+URSfcDYFc98GPnhfup8fvAe8Pl8Km8wFUYAUKG3bq14mPjG1tSm5j6/tFWkAe0YRETV14ox03XqY
+X+fXPKlC6ZN10gcZorJITK0XuvXQ72s0/g5pGmDcePVyW/obvfNvICZSen18fb7UXwkA/vWx5ev5
++OpXTfWLMt8val+69N5EOWVRsOfkH/aqr2n91Oh4lJWVqRYYDAa4ubnB3d2dFVFERM2cLYGWM4Kv
+RqmstOZnc58u6vWMqm/aU19r/fpLzXdrJfKAbWXywR2lSqW48VJj0tmPSsu1U/MsOZUpvSkPCLT8
+qSoREZGeL1Nr+kVZCkTE67e3j+XXNx9f88FJyI2163nk4yu9Lj44tua1ctHHtr1O6lGejVbPts3q
+KYuuVptp/WSXG9sCv5UDv1dIM/JcycPSGeGIiIjIRqUlUlm/8P4C6bulT1/t8b8M009lgZqpfm++
+Bvj5619PSXvqa3P0phjosadMvl8UsO4radrAB+9J/Tc2pQIzOlo+MFi5XHoDWlQofVLtiGbkyv0l
+9qF2/166aH5dIiJqPMR0tYBA6WyrSgGB0nO7+ADm8+oTOlkKaA7ut/yBjTirrpYtU/B3avpT/Zon
+vcdoDifiqM20frJLe18g2B8wuAFuBsBgkH42VP8M1HzX/qxl6TJbWG1gTkRERDY4dcK078Kb7zjm
+zePtd5m/LPRm9emRrbFUsl8btfk0dcYTUin+S89KPSFWLgMOnjJdr7QEGHeH1Lg1vAfw4X8c9+lt
+71tqpiVY6kE1eozpsqwTpsuIiKhhOJkpfRd9BqdNliqA+g8C/rbAtOpm5pNSUKV8DX/yWcu3cXC/
+5Q92tm3Wn55vaQr+l6nSWfPEa97Tz0m/iynu2oCmKarNtH6yi7sInFw7DAAMo4iIiByjX5S6d4Qt
+09d69rZt23WZxqdtnm6tZL+ubL1PwR2l+7VyOeBr4exATz8njd+WN+C2BG0+PtLBwOSptXtDK/po
+2NL7g4iInOvLVKmnUHgP6YOOyAHA8y9LHzqYq+Kd8YTUf6i0enqetbPeieuY215oW9urhvPzpArh
+NZ9KIZTy7LE+vtK09FWfSMHMvJelr/iZwPBR9T9lvbFO6yeLPNwAt+pKKOV3oKY6SlvxZK4Cqq6V
+UYa4uLh6nSpo6+nNtesZjUbdr6qqKlRVVcFoNOLuu++ujyETEcksPYcpLxM/i+/ieUo8b1VWVsrf
+xdfbb1s5SwgRERER2ebLVCm86D8ISFkNxCsdOQcAACAASURBVD8AHNgr/T56jPUwRBu+dI+QqnKC
+O0pVVjGRwB8irX9AZC2MKi2pOdPrhtXSsoBAy5VP+XnShzcrl9VM4QsIBIaNBGY9qQ5pbO1HKaYu
+bvhG/0MqW87EZw/tPrFlnMpp/U8+K12/KVeGOcHw4cPh5uYm9woX3wGpf7j4UtL+bm25rVgZRURE
+RERERI2fCKJ8fGt6FK75tHahyqKPgR3bpEorYeQd5te3VX6edEKOokKpguvRx6Wp65ZCluCO0ln9
+ZjwhVVJt+EwK2oD6qxZqTNP6qVFiGEVERERERESN293jpMBDGeqI6XTak4zYol+UFByJQMaW5uOA
+tL6l4KVbBLBwMRAcYn+Q5OMrTTOfPFVq6q1X6WXrdPmQjtK0dXPTzhvTtH5qlDhNj4jIAk7TIyIi
+IiKipqAhTdNzq9O1iYiIiIiIiIiI7MAwioiIiIiIiIiInIZhFBEREREREREROQ3DKCIiIiIiIiIi
+chqGUURERERERERE5DQMo4iIiIiIiIiIyGkYRhERERERERERkdN4VFZWuuzGjUaj7s/K341Go/xV
+VVUlf6+qqnLqWImIiIiIiIiIGqvKykoYjUa4ubnBaDTCYDDI3w0GAwDI37U/a1m6zBasjCIiIiIi
+IiIiIqfxcPUA6uL333939RCIqInTVm2au0xZzQlArt4UFZ2VlZVyVef169fhyqpUIiIiIiIiV2rU
+YVTr1q1dPQQiauLqEkYppxiLMKqyshIeHh4Mo4iIiIiIqNniND0iIiIiIiIiInKaRl0ZRUTUmF24
+cMHVQyAiIiKiRs5w4Te4lZWi8qZQVw+FyGYMo4iIXKRt27auHgIRERERNXZt2wKFBcCG1cBtw4Ae
+vVw9IiKrOE2PiIiIiIiIqDELDAKmzQJ+OAgkzQZyslw9IiKLWBlFRERERERE1BQ8+DAQPQJ4aiZw
+UyiQ+ALQ8SZXj4rIBCujiIiIiIiIiJqKkBuBNV8CEb2AUYOBvyQABedcPSoiFYZRRERERERERE2J
+wQBMnw1s2g4c2g8M+QPwxovAb8WuHhkRAIZRRERERERERE1Tl3Dgy53ArKeBlA+A224F3p4LlJa4
+emTUzDGMIiIiIiIiImqqPDyAZ/4shVIdgoF/LgAG3yJ9/73c1aOjZophFBEREREREVFT17M38M1/
+gcf+JFVGvT1XqpRa+i/g6lVXj46aGYZRRERERERERM1BixbAy/OAdV8BwR2B4iKpl9TQ/wM+TQGu
+X3f1CKmZYBhFRERERERE1JxEDgS27wMemCL9fj5fOuve8Ehg/Sqgqsq146Mmz8Pd3b1eb8BoNNZq
+PaPRaPJlMBhQVf1HYTAYHD5WIiIiIiIiomahjRcw/z0gbjzw1AygqBA4ewZI+BPwr3eAhL8AY+6R
+zsxHTYK7uzvc3NxgMBhU3wEpYxFfSuayl7pmMqyMIiIiIiIiImquhsQA2w8At99Zsyz7FPCnR4DY
+aGD7FteNjZoshlFEREREREREzZmfH/DRKuD9pYCff83yY0eA+PuBu4cDB/a6bnzU5DCMIiIiIiIi
+IiLgngnAt/uA26LVy4/8D5g4Bpg8Fjj8g2vGRk0KwygiIiIiIiIikgQGASs/B958R+orpfTfXUDc
+CODRB4ETxyxv59uv62+M1OgxjCIiIiIiIiIitclTgW+/B/7Qz/Syb78G7hgC/CkeOJ2rf/1F/wB+
+Plu/Y6RGi2EUEREREREREZkKuRFI3QK8+AbQsqXp5WmfA8P7A4mzgbyf1ZeVlgLzXnLOOKnRYRhF
+RERERERERPrc3IAZTwCbdwMRvUwvr6oC1q0EhvUFXkwECs5Jy6+UA5s3AQf3O3e81CgwjCIiIiIi
+IiIiy7qEA1/vAZ75s/7l168D//kY6B8BvPGiVBkFAK+ZWZ+aNQ9XD4BIqby8HFevXkVlZSWMRqOr
+h0NkQvu4VP4ufjYajSZflZWVqKqqQlVVFSorK1FZWenUcRMREREROcTTzwOjY4HZ8UButv46S/9V
+8/PhH4DP1wL33uec8VGjwDCKGoTKykqUlJTAw8MD3t7e8PDwgMFgcPWwiCyGouaCKACoqqqSgygR
+QCmDKIZRRERERNRo9ewNfPNf4O+vAR8ttr7+vFeAO+OAVq3qf2zUKHCaHjUIJSUlaNWqFXx8fODp
+6ckgioiIiIiIqCFr0QJ45W/A+s1AcEfL6xacAz62IbSiZoOVUeRy5eXl8PDwQOvWrV09FKJGIf+y
+q0dAREREtRHs5eoRENWDyIHA9n3A6y8Aq1eYX+/dt4HJjwD+bZ03NjLr8OHDuHTpkvy7rQUhI0eO
+dMjtM4wil7t69Sq8vb1NlldWVuLKlSu4fv06+0fZyWAwwMPDA61atYK7u7vuOty/tVObnlGiV5R2
+uh4RERERUZPQxgv446PA7p1A3s/661z5HXh7LjBvgXPHRrr8/Pzg7+8vh1Da73ocOYOJYRS5XGVl
+JTw8PEyWlZWVwd3dHS1atOC0PTuJhtllZWXw9vY2CaS4f21Xl55R4ruygTl7RhERERFRk1JUKPWO
+WrvS+rorlwGP/Qm4uUv9j4ssCg0NhcFggJub1L3JYDDAYDDg2rVrKCkpQWBgoLzcUa5cuYKMjAx4
+enoyjCLXMxqNJg/wK1euwMPDw2xVD1kmKqMMBgOuXLkCLy91TTj3LxERERER1dmR/wFvvQFc+A2I
+6A1crwCuX5e+V1wHKq/jSnkFKq9Xwu16BVpX/o6tk/+CP0Z/5uqRNwot3IGIDsDYW4HZw5xzm6dO
+nUJpaSn8/PzQokULh2772LFjMBqNaNmyJcMoapiuX7/u8Ad+c+Tm5oZr166ZLOf+JSIiIiKiOuvz
+B2DFet2LThcDM1YCP+Y5eUxNyLVKaf/9mAds/BH4cDLQuV393d7Zs2dRWFgIQAqlevfu7bBtX7x4
+ERcuXEDv3r3RoUMHnk2PGia9aimyn8Fg0J1mxv1LRERERET1iUGUY/2YJ+3T+nLx4kX4+PjA398f
+/v7+uPHGG3Hx4kWHbb+8vBwAUFhYiMrKSoZRREREREREROQ4i3YxiKoPP+ZJ+7Y++Pv7o23btqrf
+/f39Hbb9kJAQdOnSBefPn0dubi6n6TU0mzZtQrt27TB48GDV8qysLKxZswYA4OnpiSlTpiA4OFh1
++ddff434+HjdM9NZkp+fj3Xr1mHixImqbVob5+HDh9GpUyfcf//9yMjIQHFxMeLi4uy6bcfLRVry
+BhRET0d8fz8L611CxrIlOD80CbHa3nkXMpCyERj/SCRMtyBd70gvS9vX2bbeNjXLcr9KxneB1sbt
+avW9fxVbOJCCJcf6YPojkfCrvl2M09le9W3tLLL1PkRgfFIswrSLL2Qg5aMj6DMtHpE2nm32p80L
+kZoJoF00pj3cF8aM5fi4cCievvNms9f5eecSZHV+FENCbB0vEREREVHjsvFHV4+g6dr4o/P6Rzla
+586dkZubywbmDU1+fj5Onz6NHj164P3330dJSYl8WadOnfDss8/q9vlRBlXvvvuu7rZFaKS9fn5+
+PlasWIGKigp8/PHHutcdPnw4Bg8ejPT0dOzYsUNe9uKLLwIAysrKcPz4ccTGxtp/px0uDLFJ45GW
+vARpN+gFF3osBSya8ClnD3YiBtMV6106kIIlhdFIGmMSb9Ssk30E6DW+OnxRhydLkncq1lyC5O+A
+dlbDHlep5/0rXMjAhu+AmGkisArDkOh2WLI7A0O6aEMsP0Q+koRIW4ZyIQMpH503s3wnigHs/CgZ
+O03XQLvo6Xgk0heXDizD0l3F0rJhjyHhLl8AgNGYi827gWGPmA+iiIiIiIiag8xzrh5B09XY963R
+aISbmxvDKGco37gRbcaOtbreTz/9hM6dOyM8PBzh4eHy8qysLHz//fe610lPT8eePXvg6+uLzp07
+m1QmiaBq4MCBukHUunXrTKqshE2bNgGAXKU1ePBgOZRSOnz4MM6fP68bZokgqz5kLEu2XA2TmoxM
+7bKAARiAfdhXpFynHWKmJSFibzKSvxqPpEFi5ZrqnvguAJCLtNQCxEyLhR9qQqjpgdZGmos93xWj
+uDpoQkAMpj+ShMgGXhnl/P0r5CLto51A9HRVhZJf//GIObYEGw6EO3YfyRVRSboVUblfJWMDxuOR
+SN/qcTyCxP7ApQPLkKpYryRjF07gN5xY9g6+0/TpumHwwxhY9AnSTlYvz/oY2UYj3nvvPcfdDyIi
+IiKiBuJapatH0HQ15n174cIFGAwGXLt2jWFUfdKGUJZCqfz8fOzZswfjxo2zeftZWVnIycnB008/
+jRYtWiA9PR1vvfUWpkyZAh8fH6SkpAAAnnrqKZOpe+np6Th48CDuu+8+bN26FePGjZPXuXbtGj77
+7DN06dLFapAkqqIeffRRVaBVVlaGlJQUBAZaTWpqTa6Gqa52idabeoVLyFi2ARirnHo1FEP1ppGN
+SUISIJ2WFICouBFyv5Kqe2LbAshJw5LvgjA+KQw48J3lgeZkIjMgpnq6Wd2cPXsWbdu2hY+Pj2p5
+aWkpLly4gE6dOtXxFmo4e/8qt5fZczySTAInP0Q+Mh7nNVVZuV8lY8NxG+5QQAyma/78Lh1Iqf5/
+jEZmchpyVfexpmorsTqIMi8X/90NDHvkGfT1lwKnqqoqAD/h63e/gLGtL0JvnYXHh5/Gtn9/BeOo
+RzEkpBG/ihARERERUZPz22+/yT+L4EjZR6qu2/7hhx/g4+OD0NBQhlH1qc3YsSjfuBGA9eqojIwM
+VFRU2LV9bQWVCI5EhdItt9yi28MpPT0dOTk5mDlzJlq0aIGBAwfi3XffxaRJk1BYWIg9e/aYVEuJ
+gOrs2bPyMuWUveDgYDlQGzt2LA4fPixXedW7tuHoE7ATmTmxCDPpT5SFI+iD8dq/nwtZOFIEYHcK
+0hCPIb+lYMl3xapVlNPn2kXfgaDjqKluQjvETItHGIBLVoaXexKICNopby8iOgYF30lTwrS3A0X1
+VNIjphPP2rZti5MnTyI8PBx+ftWT/i5dQlZWFrp3725lJLXklP07HfH9i5GWvEEK7sxOeRTTBJOR
+3HM8ksaEIWxMEpLG2HhfLmTIP8o9qZKkkDBsXCaSk5MRMS6perxAzLQkPOKvrHIqQcbyJfhOrhhb
+ioXVDQRvGDoNd7UFjBcO4ZNNRtzz0P/BeHAPTvaIwxM3A5WVAC5dRDGAGwAAZTYOmoiIiIiIqP4V
+FBTIZ9DLzs5Gv379HLbtiooKGI1GdO3alT2jGor09HScP38e7du3t/k6euEQoO7llJWVhXnz5qku
+FwGVsuIpPDwckyZNwpo1azB8+HA899xzJrfXokULTJkyBYA0fe/cuXNo1aqVbh8qAPU2NU+fHyKH
+RiD5ZC5iu6hDjNy9OxE0NMmkIil37xEgACguKkZxagraT4tHUn/9red+lYzv0AmxSUmIlSt+bG9y
+HTYmFmGIAI5nIkJU3vS3qcORCR8fH4SHh+PEiRNy0JeVlYUePXqYVEs5jjP2r1R5llkdMMl0q7LC
+EJs0He2XLZGm/Vno1WXxXvXXjKlLLJLGAcmpySiIno6kJOleqWfc+SJyaiIiAeRuXoBdBe1QbOyN
+aVP7wVczNQ8A/PpNwZyqKhirLzt7MBNoC+Rs/RhF/SbAFZP0Lv4OpPwXOFUAnKqeb96tA9AtCIi/
+DfBv7YJBERERERGRy4WHh+PSpUsoLy9HeHg43NzcHLbtoKAgtG7dGjk5OSgpKWEYVZ9ENZT2u1ZF
+RQXGjx+PtLQ0AFA1Cld6++235Z/NNSTftGkT0tPTMXjwYISHh8vBlB4xlU7ZKH3Hjh0mtz1p0iQ5
++MjPz8fFixfRq1cvBAYGIiNDqjTJycnBsGFSS/+srCxs3769Vmf2q7UuQxCzewnSchTTwnLSsKEg
+BtNNqmZykYk+6IOdOD8uCbFIQ/LeXETaEGpcOrBBarZtU+NuC3LSkJxq0nFJYmVKn5+fnxxIAUCP
+Hj3kKql644T9Gyam8ckuIWOj1DvK9JqapuWW9qe5s+cpxpuWvEHV/6r4O1EBp9jKuETId+FCBk4U
+tAN6jkNC2z1YlnEJ44yp+Oh4bzwqihF/+gbvfmFE3JzRCAUAnEFWUQS6B6SjMHIS2h74xuyI6suh
+n4GnVwMlV9TL9+ZIX6k/AO88APS9qW63s3zpYgDA1MdmmV2n/PJlvPL805g260lE9Oqjumz3jm34
+NGUJFi7+GG28vOo2GKqTosICPDVjKl6a+5b8/6S3zFa7d2zD9i2bMTvhecQ/cC8mPjjF4uPE3rG+
+lDgHcxe8j4DAINVly5cuxumcbLz65gKr23n9hUTk5/1i1+Mv89gRzJwyCfMWvI+hw2+3uu5zc2bg
+rfc/VO2/zGNH8NHi9/DX+e+obvf1FxKRtnG9TeMQZic8L+/XzGNHMPel5/Duh8sREBhkdnt9Iwdg
+4eKPcXD/XmzfstnivqrLY6CxK798GQmzHsWhjH0W1xP709xjaPnSxVi0cD4WLFpq8TFTVFiA+Afu
+xfn8X62OTbut3Tu24a25ryBl9efy34T278Ta/6XeNiyNVbst7eOvrsT+sPe5Y/nSxVi3aoVN92P5
+0sXYu2unyf+fLa9tROQ4Q7oAb44F3tsJrD0kLVv3GNDeFxi6ENidAJwvASYu1b/uwgnA+h+A3GLg
+72MB75b6t5NfAjzxGbAnx/Sy+/pK1/3hZ/3b0Vv3i8PAM+vVy1+8E5j3dc39aMjc3d3RvXt3lJWV
+wd/f36HbNhgM6NmzJw4dOoTLly8zjKpP2uDJ3DS96OhoXLt2Tf5dNAoXRANzc+HT4cOHTbapDZSU
+4ZXyOr6+vro9pZTbF65du4aTJ0/ippukI9Xw8HAEBwcjJSUFd955pzy28PBw5ObmYseOHbrTBOuH
+HyLHxiDloxRkTItH5G9pSE4FxieZhjq5X20Auk8HCqqniXWJxfTfUpCcvMHs1ttFo/oMb4pG5JCm
+l40HgOMbkKzpWxQBQHvmvMzkTKDneCR1h37olJOG5N212gH1zAn7V0tz5kKrDd719qe5s+dB22vK
+fGBlNBrx0+YFirDqEjK+B3r0BAoAoMsYPIJcfLXwN/QY2w++OCitdvMduKfHu/hiazc8cXsoSv63
+FxgwCf7Z6SiEN3qNvdfs/qgPG38EXv3C8jolV4BHlwGv3wOMvdU54xLEgZlSTP9eAID2wSG1PhBy
+JXsCkMZk0cL5yDqZian3qZ/frR18a6Ws/hwvJc5BWJdwqwGOLQICg/BQ/HSMvyMaH6xYIz8G7Pl/
+2L1jG7795iv4+ftj7apPbD7ojOjVBx+sWIPn5sxAQFB7i4+//Xv3IHLAYET06qN6zJrz6psLdMe+
+e8c2vJg4R3VfbfHqmwvw7Et/VYXBIggDgKHDb8f2LZuxfOliuw+6tX/H2r9d5eXax4s2dFEGK7t3
+bEPi7MfMBjfiupFRg+R9pQ3dbH0esZWlEEkE6nq0YVbi7MdM1lGGiQDg6+uHt977wOz/s9imknjc
+b/o2XQ6BtY+j119IxLfffGX3Y8iczKOH4ePji/LLlzGsbwSuXPldvmxMdJRqXe3+sxQmKy1aOB8w
+GrFu5SeIGjTE5nGL/flS4hyLz1Plly9j766deCh+Otp4eak+HCEi59qTA2SckYKc/Oq+KF2DgB0n
+7dvO2kNAWDvgkYHAK2nqQEgEWnpBlLguIIVM/5igDpm0Bt8MlF4F1v9PCsP+eb801vSf7BuvM126
+dAkGgwEGgwEAVN+9vb3l6XpKBoOhTiFV27ZtMWDAALRu3ZphlDPYcia92oqLi5MDn/z8fKSlpeGB
+Bx5QhUtZWVk4ceKEHBaJ65SVlSE1NVV3u3oyMjJMwrDDhw/D398foaGhKC6u6Qk0fPhwpKSkICsr
+yzl9owCgbSTipwEpHyVjp9lw4RJ+QwyGdAGyFKGPyZQtBTGN7FL2ERRD9DfyU1xeDNFDSpq6Vz2V
+T9pydQVPLtKSFdP0cjKBop2aflHVAixP1xQ9onr06AGgZppevVdH1fP+1SxVnbkQAMLGTMdvy9TN
+y+uipteU9H9jq0sHUnE0YBzG4WjNsoxdONFuGB4NA3ChZt2b77gH3d/9Alu6PIGuiEBUKFCcXfex
+2+vXi8DfvzZd3qX6/AI5herlf/8a6B8KhFh4nbGlOkAbLgFA7NgJACAfJO7avlU+SBQHC6yMcj3t
+/+/U++LQPjgE0SNGIW3jelWQINYdNCwG5eWXcf89o6xWcShDgkMZ+0wOvu2lDUG0QZm4zVatWps9
+8M48dgRvvfEyPlixBgDw3JwZJge7tlSp6N127NgJePXNBaoDXUA6eO/Wo6ccCNmq/PJlfJqyBNP+
+ZFpZKIgARxgTHSX/rQFAWUkJAoOk15uigvMoU1RJz054Hi8lzsGAwUPx7JwZZu+vuK/i/+90TrbZ
+/8vdO7Zh3aoV+Oq7/XKF1ttzX5H3y0uJc+RqF1E9pgz22ncIxsb1n6Ff1CCT54W0jet1x6gcy+sv
+JGLRwvkOC4f1QiSlvpEDTJZZCn+UgVpdK2+UQZzyby0/7xf85a9/R17ezxgTHYUFi5bi1TcXYPnS
+xVjzn2V13jfbt2zGQ/HT0S9qIHYdyrRYAask/n7bB4dY3P7ypYuRn/cLPtu0DWtXfYJ35881eZ3Q
+Pu71iA86lEQ4duZ0LkpLSxDR+xbVfeJrEZFrPLNeCowm/AE4VwIEeAGT+0tfgNRm4vzfpZ/LrgJ/
+3gg8GSMtB4CEkcCMIdLyr49LoRIghUy7EwCfVsALG2vCo2AL5yxS3q6grKqKDAWyC6Sfnx8FXLsu
+BVPBDeNE6brOnDmDS5dqOiCLMMqakSNH1ul2RVbBMKqJuHbtGrZt24aePXvW29S4iooK9OvXT66q
+ys/Px8GDBzFx4kSTkMrb2xv9+vXD999/j9DQUN2+Uo6Xi7SPdqI4oB3aFWViQ3KBIiAS/BA5JhLW
+246bMheo2NVAG7lI+wqIrWVlVGlpqUn41KNHD7mBef31jaoeez3uX9UtKc9cqNz22BikfKQ96101
+c+FedY2aoxQXBWHYXX7AgeoFFw4idRcwLL4f/ACoO0fdjIG33YDle39A//tvhXdVFYpNtlj/1hwE
+fr9muvyp6teRJ1erl/9+TbrO0xZeZ9p4eeHfn3yme5ktUxm0lRnUsIj/X2XlTmBQe8Q/cC/eeOtd
+pK5ZibfnvqI73W7Tt+lmt2tuKpojaEOQ119IxIjRd8nVF+LA2Ny4xDQ78Xh87uU38NyTM1XVNAGB
+QfL9sxSamqvyWLvqE+Tl/YyI3rfIgdKhjH2qwEAcKFsKztau+gQAcN+DD5vdH0OH3479x0/rTpN6
+/YVEBHe8UTW24I43yvcjIDBI/vvW+/+0VIUY1kX/A6jtWzZj4oNT5Nuc9MdHMPel51BUWIDCgvMo
+LS2Rw+qIXn0QOWAw9u/do9r+yeNHceZ0rklAuCXtCwwbMcrsvgCAEaPvwqcpS1B++bJDHnv2VEYp
+p5btOpRp8th0dIWSuWq65UsXI2NfOjp2vEn1uD6dk43OXbrW6TYzjx1Bxr50TPrjI/KyM6dzAQCh
+nc1PlBdT4hYvW42Fb75ucT0xza6Nl5ccfopAUxCPe0Dar527dDUbjmqrxcovX8a78+eiW4+eCAgM
+QuaxI/j2m69MprWaq+4jovoxdKH0fXcC8P1PNdPlzE3TW3tIPU1v/taa5QDwz0nS16kC4A9/q7me
++Pn5UfpVVID+dgGpaurmdsCX1Z8r3d0HCL0BWD+9Zh1xuwCw8oDlKitnCQ0NNVsZpfyuZGtgZQuG
+UU2A6DGl7O2kdOLECbRr1073uhcvXsS7775rcfuiAic6Wj2XKjg4GHPmzDF7Pe10w/py6YA4U1sE
+xiclIVZccCGjuorHtJpJ5UIGUj7aaTEkUE0jU/UnstaPSKkmwMFvtauMunDhgkno5Ofnh+7du+PC
+hQv1EkY5e/9eOpCCDRiPJMX0vA2aKZAblrU3DfKs9NqyLBMbrFRHRVSfrDDsLil5lOO2tv3wSEI/
+uUm5lm/fh/DE/xlRWVmJqlqNre5yi/SXa0MoW65TH8x9kq389FrvTb+2emfSQ1NNtqGtmNEGFiKE
+ENNJZic8DwCqfiG2TodS3g9RRaSkrarRmzakrGiwNK1IGzCIbT/30l8xdPjt8r4RFTifpizBuEmT
+8fJzT+nuT+XtKi9L27henpK3YNFSOZi44+6xWL50McZER9W5qslRFi2cb1KNpz2IbNWqNabNelK1
+TDkFrF/UIDz+8P0YNCxGvk/aaX9CRO9bUFpaYhKOAFLFkzbsKSoswLpVK+TfD+7fi7y8n+VKIVuD
+usxjR/DRv97DlSu/4+D+vXZPcRRh8atvLlD9vy9YtFT1NyUeB2dO5yLt83VIetF8UABIf4/5eb/o
+XlZUWIBTJ46rgorQzmHw8fFF5tHDyM3JkgMAQYRHInDreGMn3Nqvv0kFj6gu69ylK07n6JeeiuCv
+LhUu2ucbaz2jAOk5TOxHZagn9r14vhAVSo5iroJvdsLzuPPue7El7QvVtDkRfJpzPv9Xk2l2gLri
+7935c3Hp4kUUFZxH3JMzVbetV4kk9svUx2bJ1XDmvP5CIjL270XK6s9RWHAe8fePxVvvfyjvx8cf
+vl83FFI+hrSXbd+yGSNG36VadnD/XhzK2IfYjjcCANb8ZxlG3jFG/r9hzygi59qdIFU4iYonEUo5
+YnulV6Wf1z1mGmb9Nxd4sL807U4bRt0WVrOOMKQLMFxxUvPnRwEhfsDCb6XAqiH3jPLz84PBYJCb
+lItgShs4OTKAUmIY1QBlZWVhzRrTNwXKBua33HILevTogTVr1uCWW25RNSrPz8/HihUrUFFRAUDq
+CzV8+HDd2/L397fYaFzZM8qW8d5yyy1OqoICMpYlY2eRFISIM5+ptI1EfJLU4vrSgRQkJxfrBxaK
+9fTUnO2tOhTpOR5JSbFm19eVk4lMcrRQagAAIABJREFUZXD1G2pVGdWpUyfd5T4+Pg4Popy9f8V2
+pOCrpgdXxDjTyrPcr1KQdSGypiqrSyySzEzdq9mmpJ1uQ3R7ekaZuyOb8Y+NUlN5Y4+xsFDlKyk5
+Zm0Nh8nM11/+uHTOAfx7l+3X0dLr9SRYCoEAaZrQ1PviEDt2gvxJtpK5PicAVFPDRAXH6y8k4ucz
+NdsRn6SLg31xgCZ6FImpQCJoKCoswMF9e3HH3WNxOicba1d9gvsefBifpixRVczoEU1+lcHCzCmT
+MPIO6cGr13R3+dLFqv4lr7+QCADyvvjmy41mb095ID90+O3IPHoY5/N/xfYtm6UwqvwyACkwyTx6
+GIcy9iG4442qigFRUbB7xzbk5/2CnQeOoY2XFw7u/14e895dO9G+QzBe+/s/8GXqWoTe3AV/e+XP
+OJSxD+2DQ7Bg0VK8mDhH1RjY3GOiVavWmLfgfZSVlKC83DHVKUr2VkaJx5AyECq/fFm1zaHDb8cH
+K9Zg5pRJmPanJ1XbDwgMwujYe0yqd8ovX8bG9Z+ZhF6LFs5H9IhRyD4pPU9s37IZz730V7t6GBUV
+FuC5J2fixb/+HalrVqL88mWT8Ex535SByZjoKDl0EOvqVdD8+5PPVD2kInr1wZr/LMPuHdtsCr5E
+wGKpsqu2YsdOwAvP/AmZx44golcfVciUm5Nlsr4yoIwdO6FOvclEtaC2Is6eacXasG/ngWNYu+oT
+JM5+zOGhrrb6SQQplqpazbHWb2vtqk/g7euLqMFDEBDUHpu+Tbe5B5QlyudREeYVFqj7QIpphncO
+jTR5vPWLGoSN6z8zCYwzjx1BaWkJ+kUNkpcVFRbg3+8tQPzMJ1BwLh9FhQXIz/sFcxe8X6uxE1Hd
+DV1YE+QMvlmqPvJ0V6+jnKYHSNVOIrRq4SFN00sYWXNZ+z+rr7/uMen6yuvtyZF6PUWGmo7p7j7A
+f3PUPaaeHi5Nyfu1+pPq/qFSw3Nl5RTpYxjVQLRo0QJTpkyRf7d0FjwlvfWCg4Px3HPPWb2ut7e3
+6jb16DUg11Y7WTtrX31RnU3NCtMpdlIvJ1uEjUmqDilsnY6ns+0usUhK0vyuF55YCFWczfn713Jv
+KfV14m2sRrNlm2GITbK8tZvvSsTNJtt9BFOV1VBhd+GZZ+6SK6SqqvTroG6KmY6QykpUVpp+UtwY
+TX1sFmLHTjA7ZUdM54kaNEReJqoxWrVqjeVrN9XqYFX09RDTegApjDh1QkoxRW8e5cF+QGAQJj44
+RQ5s1vxnGSZOfli+/YDAINxxt9RMQEwhKjx/DsEdb7R6EKudghTRqw+m/elJuVIj8+hhdOx4k2pa
+VezYCdiS9oU8leXUieN498Pl8uViLHraeHlh0LAY5OZkYejw25Gbk4X4mU8gJ+skyi9fNqnM6Rs5
+AM++9Ff5+sopUgCQl/ezHBD1ixoIAHh77isYHXsP1q/+D9p4eWHSHx/BH8ePwcg7xmC/4mB216FM
+ZB47gvF3RMuBjbJPjzYQ2rj+MxQWnHdYI2nBnsooZZhpLQCI6NVHnlr1+guJqvBGPPaVvaXWrvoE
+Pj6+JgFVUIdgxI6dgL+9Ir0TtrcSRtlXaejw25G6ZqUcLLz+QiKG9Y2QD8a1gYPy/6GosABxIweb
+VM1YmnI0O+F5PDVjqsXm7Nrb3L1jG2ZOmYQPVqyRe1PVVUBgELr16CkHgAf37wUghQ56YZQy4Fm+
+dLHZChp7HcrYp6r2Ce8egel/nIisk+qPLZRnKEyc/ZgqoNu9Y5tqG8rHrzbIKym5pNuLTEtUQgKQ
++0IpzU543qSq0p6/BXN+Ly/Hk0l/wXvJNfNdRAiuV1FlSzN57YcFlojXIWV1KCA9JsdOuF/VW0pU
+cWmr5AoLzmPCA39EYFB7bD+Xr5qqSkSul/5TzbS23QlSY3PRT0o7VU9UQFVU1lQnKf1jghQ0DV1o
+/gx56/8nVTspm5b/Y4LUY2r9/9TrtvQEPkoHplUfIls76x7VYBhFRNTERQQDhaX2X8dWAYFBePzJ
+RJNmsuLgeXTsPaqDCeXZvADTqXJa2obZgNRw2cfHF23amDkjUvlllJaWIEBzEBzWJRx7d+1EcfWn
+3tppGvL979UHo2PvkSt+LBHTk8xtCwByc7JUPXkAoE0bL/j4+KKo+pN+S/dHT1iXcHyasgSxYyfg
+dE424mc+gfeS/4Yzp3N1p6AoBQa1h4+PVL8nDtyUlTOhncMQ1CEYkQMGY/3q/wCoOWPczCmTTEIe
+QL/6TauNl+I+O7hXmD2VUbWpDtELj8RjX/SWStu4Xp7iqdTGywuznkqSw7/yy5fxeOL9ulO9lAGF
+chpUwqxHEdzxRkx9bJZJBderby7ApD8+IleRiOuIvmxa2rOzWTr7m/J+aqvALBk6/HYpuNy7RxUa
+K3n7+iIgqL1ukATA5G8GqAlSY8dOwPYtmzFoWIxN4dJ9Dz6MI/87pDut0l7K5yOx76Y/8QxWffKR
+PM1SWYmk7WOUtnE92geHyBV5grKJuXKMtTmbnrnKKCVRxWip/5UtHn8yUbeqUFvxqqwQtRZGR/Tq
+g03b99o8BmU/N+04tm/ZjLfnvoJnX/qrHLxp729Erz5ySAhYfl1Sht513XdEZJ8hXaRASM+6x4D2
+vlLIJHo7ievoNScXFVUVlcD7O9Wh1Z4cYNUBqfn5uRKggy9wzy3SdEHtmffiFku3IYgwTEvZM0rZ
++Lw5YxhFDZLBYIDRaKy3+anNhbl9yP3bvIQFALtO2X8de4jqnIRZj2Lh4o9RXn7ZZFqaOaLyRMvS
+NL2AoPYoLVVP9yosOI+SS9IpaFVBj+YALrjjjWgXGITgjjfKlUVaYopax443IW3jeov3oY2Xl+62
+lP1rRAimbZ4sDsYBmNwfa0TPol3bt8LL2xudOt+MPn/oi53bvtEN4pREw2hB2ez6uTkz8Nb7H6rC
+E6WowUNM+hrpHeia07lLV7k6TVz3dE52nXrm2FLR0cbLC8n/NB+41JYyzLO1obFeGGauZ5TeFE89
+2gqu2QnPq3o4ielzf351nt33EZDup/Lx7ePja1PFU1iXcN2/xzOnc5Gf9wsCg9rr/n1s37JZt6l2
+RK8+6NajJ9au/ASnThyX+7xZU15uvqeVvbSVUX0jByCiVx/4+Phi7apPEDVoCLakfaGqdBTBz+yE
+5+W/tb+//qIqvNILhgICg/Bp6mYApg25lX872seTucooAPj5zGm535veFGlHEI3Jxd+DrY/j+iB6
+S8X072XzdEi91yX2jCJyLREqAabVSYAURJ0vMV2+J0fdqFxZGWWJCKfmxABXr0tBlC09n7Tbbcg9
+o1zNzdUDINLj4eFhdpoT2a6qqgoeHqaZM/dv8zKpH9DajlZurVtI17HX1Mdm4annX8KdQyMxJjoK
+z730V5vftO/esQ1xIwfrhh9C5rEjiBsxCJnHjiAwqD1KSi6pKnTW/GcZLl2sDqOqp7G9NfcVeZtF
+hQV4a+4rcsXQiNF34aN/vSc3zi0qLMA3X26UK7oeip+OuQvex5a0L+R1Xn8hUT4gEQf9gBSwrFu1
+Qr4tcRYmIaL3LcjL+1k+CxogTecqKylBaOcwuQeU8hP3b77ciJ/PnMbjD98vf1qvvE0xZWndqhUY
+MHgoACBq0BB5XeUZrA5l7JOnNIlpKqNj70FAYBA2fPapfP8Cg9rD18/f8n9WHUUNGoKMfenybWrP
+5GXLY0EQU86ienY2+UrbuB6Jsx/TvUzsQ0fIPHYELybOQfsOwTh+9DDuv2eUTWO3hXgs2vO3JPpA
+FRacx89nTmP/3j0ApAqO/cdPY9iIUfK0L7E/tCcQKCo4j7IS03f0r7+QiKienTEmOkq3Qbuyz9nu
+HduQsX8vInrfgjZeXngofrrq73HNf5bJTctF7x7x9yHOzKac3qs0YvRdSPngn/Jj2BZpG9fDx8dX
+9XehfE6xh+j3tP/4aSxYVDMf49mX/oq9u3Zi6n1xePzJRNXYpj42C/uPn5b/HyN69UGfP/RFTP9e
+iOrZGadzsrH/+Gmz4XjcyMHIz/tFtU+G334nACCqZ2f5717o2PEmfPXdfuw/fhr7j59WhXY3hXbG
+V9/tl8eye8c2h/5NiLE9FD8dMf17IXneqy4LogApRErbuB5du/XAooXzHX5fiaj+DL4Z8Gkpnalu
++cNA6RUpWBIVRRlngKFdpSqnm9sBB86YbkP0hRJfk/vX9JoSX//7i7q6CZBCpBlDpCCqpYcUYj1v
++cStZCdWRpHL6VXptGrVCmVlZQAANzc3VvDYyWiUzt5WWVmp25ye+7d5CfEH/nwn8OoX6uV6jcsB
+ad0QO/MIZdPq+JlP4MeDB5A4+zGbK0WGDr8dAUHt8dSMqapT0JsTEBiElNWfI/6Be+Xb/fOr8+Se
+UUDNp9fK6gBl1cHQ4bdj3oL3Vb1YFixairfnvgJA6kPTxssLjz+ZiJlTJuHdD5ejtLRE9wBZe1t9
+IwfgwanTUHAu3+x4tftm4eKPkTDrUUT17Cxf3rPPrQCkMEvPiNF3yQf8gBQmlZaWoM8f+qr2ed/I
+Adi4/jM5dIgdO0Eec2BQe5N9YGka0/70PbpnxzJXoaIMOsS0s4mTH8bMKZMwb8H7JmdZy83JQmTU
+IJtCBnNTcwDTaXqOJqZb9Y0cgK93Z8j7e/eObfLjoK5TeGoznVDYv3cPeva+BetWrcD5/F/lENbS
+PgNqGv9HjxglVzqK+6bX8Fzpn/+YL5+xUdsXSFRPin0jHgvifs5d8L7892Gt+Xm/qEEYNmKU2bBK
+UPZhEuNRVZ0VnEfHGzupAipLlM9z2r+B++8ZhfgZs+Wpl5+mLJGfQ7SUU8CsVeqIx5neY6lT55tV
+UzR79r7FZIqoLXJzsnSr0OqiU+eb0anzzdh//DRefyER5/N/RVgX0zM+1xflGQW1FWAiVLWldxUR
+uc4/JkhT49JzgZlD9CuTnllf09PJHG0PJ2uVUesekwIucRY/cZvPj5KqpBJGAruz2RvKERhGkcu5
+u7vj+vXr8PT0VC3z9vbGlStXcO3aNbkpNNnGYDDAw8MD3t7ecHd3N7mc+7f2tPtK+bv42Wg0qr6q
+qqrkr8rKSvm7M429FbjpBuDp1UDJFf11fFsB7zwA9L3J+va0Z+syN90j89gR3Dk0Uu67ETt2Ajp3
+6YpFC+ejfXCIappPRK8+WPKfdSbbVV6u7CGid1A9/v6HVL//P3v3HhX1fe///gUOl2EARZCbCt7Q
+KIpGTQC1UXRaE6vRbBtN67KX7PTslbXb7u6fe233b7UnZ5/8kvWrO7/8umra7fn92pO09exLsrQx
+tdFc8NYoSDQWUTSCeEHljigwgCjM+WP8jnPjJpcZ8PlYaxbwvb5n0GHmNZ/P++vaTNsXX31NPN/w
+fSXH6mzSnZiU7HyD7PmmvKdz9RQC+AoePjuUq+ynljnfLHme03PqVHfn8Jz+5XqMvkzV6W6anue/
+i64uWW88TkZg6RoGXCm72G2/K39yfYPb1X3z7A+05W9fcgtehkKLzaYzhaf0d1t/qpnpc/S73+zw
+Gv3ky/d/8Pe6cO6ssz+RZ5PtrhiBSnf/vqXu/49092/X89+5rymXnsftKTiTHCFMb3tOGefwPM9n
+h3L1/2x3nOeTD//ovCql8dy3YuUq/e1/2er8dyPJK8Dsyv/9X7e4XemyK65TNN947RW3503XAO3N
+X/3GOQrTNaQ3wr/uro7qqxG5pF792/6//vubzsdA8n6ONe6DMR2xPz47lKstf/tSt0GT8W/D8/8z
+vZ+AwDI7WfrfRx3T5bZ+1REiGT2XulJS45iqZ4RJl+q7397g2lfqs4veV92THHUYU/eM0VZG7yc8
+nKA1a9YM6rvQ3r7J9fUGz9fNeENnt9u1evXqwSgZQ6ylpUUdHR2KiorydymAl+6ew7oKoiQ5n6eM
+5y3XEMq4vfHGGw9VU6Wt5226cqtVeueY4491SZVj2fREx3Dl7y2Wxpgf/tgITH259Ly/DcTl4IHe
+cG3w3t+G5kBfJAX20zAwYHwFOhg4RgP2vsrJyXHOjHH9KjkGNBg3V13Nounv7BpGRsHvIiIi1NDQ
+oNbWVpnNvBMGBtMYs/T3fPiLAMXl1DFUBquhPQAA6B3CKASE6OhoNTY26t69ewoPD5fJZKKPEQAM
+AM8pTgAAAIC/EUYhIIwaNUoxMTFqaWlRc3OzOjo66GOEgPQwPaOMhvKufaOGumcUAAAAAAQKwigE
+lIiICEVERPi7DMBpMHtGAQAAACNRyCjpLi93B0WI9/WphqVgfxcAAAAAAABGjjSuQzJoRspjSxgF
+AAAAAAAGzMrZ/q5g5Bopjy1hFAAAAAAAGDAvLZJmJfm7ipFnVpLjsR0JCKMAAAAAAMCACTdJ29YT
+SA2kWUmOxzR8hHT+NnV2dvrt5L4aA3s2AXa9GpVnQ2AAAAAAABBYIkOkKbHSv78k/TZf+qRYKq2h
+qXlfhYxy9Ij6Wrr03WwpJNjx2D4sI0cJDg5WZ2engoKCJElBQUGy2+0KCgpyLnNd7ovrdg9jhGRq
+AAAAAAAgUIwJk27dcYQo3832dzXDX0iw4zEdKQijAAAAAADAgDIFS3Fmqfmu1HZPumeXuhhkgy4E
+BUmmIMfUvP6MiApEhFEAAAAAAGBQRIaMvCAF/UcYBQDDTJLF3xUAAAAAwMPjanoAAAAAAAAYMoRR
+AAAAAAAAGDKEUQAAAAAAABgyhFEAAAAAAAAYMoRRAAAAAAAAGDKEUQAAAAAAABgyhFEAAAAAAAAY
+MiZ/FwAA6JuGhgZ/lwAAAADAT2JiYvxdQr8RRgHAMDQS/gCNFA0NDfw+AGCI8dwbWPh9BBZ+HyPb
+SPlgmml6AAAAAAAAGDKEUQAAAAAAABgyhFEAAAAAAAAYMsHFdZLqinXw4EEVlLf5ux4AAAAAAACM
+YMHpcVJbS7MkKTIi3M/lAAAAAAAAYCQzSfUqu2iTJFUXHVS1xwaWaYuUmUJIhaFx7JJUXCFVN0kd
+nf6uZngZFSwlREnpydLiKQ93jKamJrW1teru3buy2we2vv4KCpJCQkIUHm5WVFSUv8sBAAAAADwk
+U1v5RVVLSshYrvS4Byvqzx3U6SqLkscRRGHw3WyRdp2SKm77u5Lhq6PT8fhV3HYEet+YL42N6N2+
+9+7dU0PDTY0aZVJ09GiFhoYqKChocAvuI7vdrvb2dtlsNtXW1igmZqxMJpO/ywIAAAAA9FHw6SpJ
+iXOVHie1lRfo4MGDKq6TYmct1/LlmZpo9neJeBQQRA2situOx7S3Ghpuymw2a+zYsQoLCwu4IEqS
+goKCFBYWprFjx8psNquh4aa/SwIAAAAAPITgzCfnKq35tA4eLFatsbTlmgpoaI4hcuwSQdRgqLjt
+eGx70tTUpFGjTIqMHD5T3yIjozRqlElNTU3+LgUAAAAA0EfBaq1VRbOkxESNM5ZGRChSkq2qVsRR
+GGzFFf6uYOTqzWPb1tYqi8Uy+MUMMIvFora2Vn+XAQAAAADoo+CD+aWySUqIj3VZHKvEREnNFarl
+vR4GWTWDWwZNbx7bu3fvKjQ0dPCLGWChoaG6e/euv8sAAAAAAPRRcIIkKUGJce4rYuMTJNlUUcvY
+KAwurpo3eHrz2NrtCsgeUT0JCgoKuCv+AQAAAAB6FhydKFmmTVWs5xpLtCySbM02P5QFAAAAAACA
+kcg0cdZyTfS1xjxRmct9rgEAAAAAAAAeikmSVFesg0XV9xd5T9kDgL64d++eauvq1NToaFoVFR2l
+cXFxMplMfq4MAAAAAOBvjneGcelavjzdz6XAVXNzs9555x0tWLBAixYt6nK79vZ2vfvuu8rKylJa
+WprbusrKSh09elRr167ttkF1ZWWldu3apW984xtKSkrqVX179+5VUVGRUlJStHHjRp08eVL19fVa
+s2ZN7+7gIFubIc1KkvYVS6evd7/t3AnSypnSiavSoRLHspzp0hOp0sfne97fOMaqdKnilvS7gt5t
+e65S+qDIffmKGdKBC707ZyC6e/euTv2lUOXl1zR2bIzGjBkjSbp2/bpu3mzQpNQUPf74PEIpAAAA
+AHiEBfu7APgWGRmp733ve/riiy9UWlraq32am5v11ltvKS8vz2tde3u7du7c6bWusrJSO3fuVGNj
+o95++229/vrrXjdjn7y8POey2NhY/eQnP9HmzZvV3t6uc+fOaeHChf2/434waax0r1MKD5H+z2ek
+f/66tDRNigiVnpvr+Nm4rc3wfYzT1x3BV/KYrrdxPd+de1JRhTQ5TvovK3reZzhobGzUx5/kalRw
+sFZ//RnNf/xxRUdHKTo6SvMff1xfX/WM7JI++fSAWlpa/F0uBtiOHTs0adIk5ebm+lyfm5vrc/2W
+LVu63M9Y19vbli1bBuW+DRbjMdu4caNstu77MxqP344dO3wu7+6+19TUaNGiRd3+fgAAXevL86jN
+ZtPGjRu1aNEi1dTUeC2fOXOmzpw50+M5jb8Rns/7PenN34VHja+/oa7LduzY0ePj1d3rFQws4/+K
+8Ts5c+aMZs6c6fO1X0//z4x9+f8QmBieMARaPvhAEWvX+lxnjGwqLy/vcv/33nvPa9mECRMkSdev
+O4bQlJeXKyQkRJs3b9bJkye1d+9eZzjU3t6u999/32v0lDEiavPmzT5HRO3du1eSnCOzFi1apEWL
+FnkFWkVFRaqurtbbb7/tdYycnJxuR3YFggkxUlmttL/YcZscJz07Ryq68WCklMEIj6LDuz7e4xMd
+N1eNbdL7p6XLdY7z1Tc7vs+Z7rjiXVFF98cMdA23bunw4T9rwYLHlTJxos6cLdbFi2WaMD5ZknT2
+7DlNmzZVTz6xUFeuXtWnuQe1PGepoqKi/Fw5estms+nFF19UQYH70L+tW7dqyZIl2r59uyTppZde
+cq7LzMzU22+/LYvFov3798tsNishIcFt/2nTpkmSSktLZbVavc5rNpv13nvvac6cOdqyZYt2796t
+3/zmN27bnjlzRhs2bBiw+zpUjMetqKhIly5d0pw5c3xuZ7PZ9Otf/1qSlJaWptzcXL300kvaunWr
+14hYTzU1NVq3bp0qKiokuf9+XG3dulUvv/xyP+4NAIxc8fHxys7O1u7du7V//36ff68M+fn5Kigo
+UGZmpiRp48aNunbtmv7t3/5tqMpFH9hsNp04ccL5+ubVV1/1+XrH4OvvqOvrHQwez9cqW7ZsUX5+
+vts2ly5dUlFRkTIyMjRlyhT9/ve/V2trq5555pmhLhe9QBg1iDxDKF+hVGhoqDZv3izJEQ59+OGH
+euGFFxQZGem2XXt7uz744AMtWbLELTjyNU3PmCpXWVnpdQ5DXl6evvjiCz3//PP69NNP9dxzzznP
+aRxz6tSpPQZJzc3NOnfunF588UW3uoxphuPGjev5gfKjnOmOEKix7cGySWMdX6/c9N7+cp30Pw88
+2LerqXxdBVprM6SxEY4pepJjKmFMhPSdzAfbPDfXcZOkv1xzn8oXiNrb2/XnPx/VvHkZSpk4UTdv
+3lRZ2WU98/TXFB7uSNjmzGnTRx/nanxykialpsreadeRPx/VM09/TaNGjfLzPUBfrF+/XpKUlJSk
+EydO6NSpU9q+fbtaW1udIZERlixbtkwWi0VnzpzRvn37tGrVKk2ZMkUbN270epG3bds2bdu2TZKU
+nJysPXv2uK03gijJ/YVgcnKyXn311cG8ywPCtX5ffE1xXr9+vd58803nC6vMzExlZ2frlVdekSTn
+4yVJu3fvdh7feLFm/B4yMzP16aefer1I3rFjh7Zt26bk5GTn7xUAHnXGBxytra0+17s+3xpcPzjZ
+v3+/JOn73/++qqurVVRUpNbWVuXk5Di3N57zjb938fHxXue5ePHiQN2lR5Lxe1y1alW3QYTFYtHb
+b7+tH//4x87t3n33XbdtjL/hjz32mL788kvn32cMPNcP0QoKCpSfn+98nef6WtGQnJzs9vNvf/tb
+tba2atmyZbLZbNq5c6ekrj+M8/yAE0OLMGoQRaxdq5YPPpDU/egoQ2xsrMLCwlRZWen1aXd9fb1z
+G8/llZWVOnz4sCSptrZWhw4dctvmjTfecH5v/CEsKyvT3/zN3yg0NFRZWVn6xS9+oQ0bNqi2tlZH
+jx71Gi3lawSXcZ6cnBwlJSW59agqKirSpEmTevzUfjCFmdyDHUNts/SrI47A6PGJkinYEUj915WO
+fQyuAZHBdYTTlZuO/SeN9Q6jfAVak+OkqS7ZnBGEHSl1BFbDtWdUwecnlJqaosmTJkmS6utvauLE
+8c4gSpLCw8M1ceJ41dff1NixYzV58iTdunVbp079RU88MTynd8Lh008/dX7/yiuvKDExUa+88opb
+wGG8MEhKStLChQudL/B9fZLo+SlXa2urW1BjvADcsWOHdu7cqT179qi6ulqB7s0339Sbb77pFhC5
+3nfXkWeeL4yMx2/ChAmy2WzKz893Pg7G8TxfGBtBk3EsY3i6sY3xwppPcwHA3Zw5c3T+/Plun5e7
+ei43PnwxRgIfPXpUkmO2wZQpU/Tiiy+qqKjIGVxJD6YAGiNYPXX1BtwIsTxr8bRlyxbt27fP7ZyP
+gjlz5mjVqlXat2+f8z1NVVWV12Pt+vgWFxdrz549bn8Td+zYod27d7u9/ti2bZuuX7/O389BEB8f
+r08//VQvvviiJkyY4Hzdcv78+R73zc3N1e7du2U2m7VkyRLt3r1bDQ0Nev311/Xaa68pIyOD31mA
+IYwKIEYw9OWXX3qFOCdPntS8efO8GpEXFRXJbDarpqZG77//vjZv3tzlaCbXaXeu26SlpWnDhg16
+7733lJOTo3/8x3/0WZsxumrv3r2qqqpSeHi4Nm7c6LM5eiBMzbtzr/sG5k9NdUyRa2xz3P77x30L
+hC7XOab3TYjxXjcrSbpS79jG1/kkKSXG0fDccyrgcDMqeJRkt7stCwoK6nnHIKmjs3OQqsJQ2bp1
+q55++mlZLBatW7dOq1evluR+G7pmAAAgAElEQVT4pMl4kWyEHpKUkZGhn/3sZ9q0aZPKy8vdwimD
+2Wx2BkzGp83Gi3jXT6QzMzOH3QuKjIwMJScne03NM6Z1JCcnKyPjQRM5442NYffu3aqoqOhxuPnL
+L7/sHMpu/A6M/Q1MzQOArlksFi1btkwFBQVuU/Ncp04bI4ANxocHxt+xnTt3OqcLdSU+Pt6rBYZr
+ENbTKBxjJJZnLcZxrl+/rtbWVv32t7995EbzfPe739W+ffv0y1/+UpKUmJjofKyNUKmrD2VcR8j9
+5je/0f79+7Vjxw69/PLLWrJkiTZs2KD09HRGSQ0yzzYRxoj4H/7wh24fbm7bts05clyS8//fqlWr
+3F5XIbDQwHwQuY6Gch0l1Z3U1FTdunXLrWl5aWmpbt26pdTUVLdtm5ubJUljxozRhg0b9Nxzz+nk
+yZO9rs9oeP766687+1IdOnTIq4G5ay2VlZW6deuW0tPTlZWVpZMnTyovL087d+5Ue3u7s9633nrL
+WV+gGjVK+vyK+7JJYx2jlTwbl//z1x0jp+ZOcN++qMIxmsq1AfnaDMeyIo8PuDzP97uCnq+8Nxws
+fGKBrpZf0+XLjjsXExOjiopK2V0CKrvdroqKSsXEOJK7i2WXdP36DS1cMN8vNePhGWHQL3/5S+cL
+g+bmZi1dutTtk8ZXXnlFNTU1zvCloKBAlZWV+tnPfqaysjJVVFTov/23/6bz589r7969MpvN2rp1
+q65cuaLz5887QxpjZFR6eroKCgqc22zdulUFBQVKT0/XmjVrupxOEWji4+O1efNm5xsDyf2NzebN
+m92maxhvbAzJycmaOXNmn15YWa1Wff75586h7JmZmSouLiaIAoAerF+/XsnJydq3b5+z6bjrhweu
+U5w9PzyQpPT0dJ8hUU+M6dnG+VwbNLuqqalRfn6+cySIJ4vFop/+9Kcym81u9+FRYYxy+81vfuO1
+zpgGaXw4ZDAaXq9Zs0ZvvfWWrly5ooyMDOXn52vbtm3auHGjpkyZ4nz9sm/fvl43pUff7N69Wz/+
+8Y8lOT5Ac/09jhkzRnv37nX+H6ypqVFDQ4NzfWFhoXM/g/G60Wh+3teLA2DgMTJqEHlOy+tpmp7k
+GIFktVq1a9cuRUZGqrm5WR999JG+973veY1AOnTokKZMmeL8A5WWlqba2lq9/vrrXR4/JydHe/fu
+df6Bi46O1t/93d959agyGKOpJMdUvQsXLmjixInO8yUlJemdd97R008/7awvLS1Nly5d0qFDh3z2
+QQkUb+c5ps65+qDIu0fT3AnSqnTHKCbP0VKX6xx9nbImO0Y8RYc7RkXtK3YfFeXrfH+7VBrn42F3
+nVroOi0wUIWGhGjp0q/o0KEjCg4OVmpqikZHR+tPH+5XYmKCZLerqrpGY0aPVlxcrK5cuari4nNa
+sXyZTCaegoYbz55RxvD25ORkHTlyRPHx8c75/kuXLtV7773nHG69e/duNTY2qrGxUdKDK54YoZZx
+LNepBp4jo1y3KS4udvakGk4NzI3G5bt373aOcDKa3X7729/udt+1a9dqbS/+lhiM6RuujBdjrvhk
+FwC8uTYuf+211/TWW285Pzx49dVXffZ6MiQkJDi37aujR4+qtbVV69ev1+7du1VUVOSzr40xWjYz
+M7PL0VdTpkxRRkaGCgoKHsnRUWfOnNEPf/hDt2VGiJeZmalr166purra+SGYEWC5MkavbdmyRfPn
+P/gg1de2GDhms1l//dd/rZ///OdufUUl6datW873mZmZmZo0aZJ++tOf6tSpU9q3b59Wrlypf/iH
+f5Ak52h7WhMEHt4JDoHehFCukpKS9I1vfEM7d+6U2WzW9773PZ8NzaOiopSamqpTp045l3tOwXNl
+BEtr1qzRmjVr1NzcrPfff7/XdZ08edLnNMExY8YoNTXV2ddKcoRe77zzjkpLS/3aN6qvvpMpxUY+
+CIBcg6iuRjEZ0+yWTJXudXY/NdDVr464/zxce0ZJ0pjRo7VieY6O/PkzVVfXaOHC+bLZWnSzoUFB
+QdLkKZMVYTbreMHnutnQIOuK5bJYIvxdNgbA1q1bdfHiRe3evVtPPvmk1zrjKnhGz439+/e79ZmS
+5BY+vfjiiz7PY7FYnA1FjaH1Cxcu9Hm10UA3Z84c/ehHP9K2bducQVFycrLeeustrxdIzz//vObP
+n6/XXntNjY2NPpu/S/KavpiQkKA//vGPzvVdTcnzFVYBAB7YunWrczSU8Xdu69atXuHQlClT3N4M
+f/zxx11+KOu63LMfVU1NjXbu3Knk5GT94Ac/0PXr1/XrX/9a2dnZbn8jbDabs2fs97///S7fYFss
+Fn3/+99XQUGB9u3bp+9+97uPTO8o4/WCp6KiIlVUVOiv/uqvJMnrConGh1w//elP9atf/UrZ2dnO
+dZs2bXI7/uHDhwk4BpDr65L169crKyvLraH8jh079MMf/tBnD7RNmza5vS9G4GOaXgBqbm7Wrl27
+ZDab1draqn/91391XhnPEBoaqmXLlvns1zRY7t696zY1pLKyUl988YWsVqtXHZGRkVqwYIGOHz/u
+nL43HJTUOvpAfSdT+pslPQdRkiNEyprsCKJMwY6r6OVMH7qaA0V0dJSeXvlVdXR26k8f7tfpoiI1
+NTXp9u0mFf6lSB/u/1gmk0lfs64giBqBkpOT9fnnn+vKlSvOaXeSnCM3i4uLZbVa9YMf/ED/9E//
+5LavMVLHmIrnqbq6WosWLXIOqz58+LCKi4vdpvMNN9/+9redfbQkqaGhwWcj9qysLOfzbnR0tN59
+911duXLFeTOGrK9fv9657N1339X27dud0xkBAA8vPj7e66qtvq50Z7FY3IKKlStXuj1fFxcXKzMz
+U2azWXv37nUu9wy1tm3bpoqKCr366quaPHmyM0j6/e9/77ZdTU2NJkyY4NVr0BdjyvyPfvSjYft3
+s6/OnDmj7du3y2w26wc/+IHbuv379ys5OVnf/va3tWzZMq8pjMbItJISxyfOjY2NeuaZZ7Rv3z5t
+3LhRNpvNGQb6+t3g4VmtVuf/FckRThmv/yZNmqRt27Y5WzgYy5gmOXwxMiqA5OXl6dChQ4qOjnYb
+DVVZWamdO3fq7t27ysnJ6XLkk+t2XXG9rKzkGOL4i1/8otu6HnvsMUnS0qVL3ZYnJSV5DXt11d0o
+rUCVf3/K+AdFjml0YSbpVhetaL6T6Zh259koPWe6Y5TU0jTH6KqR0Beqt0JCQpSd9aTu3p2vuro6
+NTU1SZImTEjWuLg4jRo1ys8Vor88L2e9bNmybrePj493u/pMZmamvvWtb7lt09PIqISEBLfmrjt2
+7HBOM8vMzNTf//3fP9R98RfXZpwzZ86U5LhKzJo1a7jEMAAEGM+RGsZI1MG4mppxpVPXkVdWq1Vb
+t251jvAxRrlOnjy511PufDVJH+mmTJmiVatWaevWrc72JNKDi3qsX79e8fHxWr9+vXbu3Omcwug6
+Mu3555/Xp59+qujoaFmtVh05ckTr1q3Tv/zLv+jzzz/Xli1bdO3aNe3cudN5PAwsq9WqK1euOFtA
+uPYn7euFWDzbFDBtz/8Io/ysvb1d7777rsrLy5WTk6Of/OQnXtskJSU5r3CXl5en119/XSkpKdq4
+cWOX2/ni2v/JMGbMGJ/TALvbx1NpaalzqkxGRsaQjtaSHoRCvrj2X3JV2+w9Tc7Tr448mKYnOQKq
+yXGO40WHO4Kmf/7Qe79DJQ+m7n0n09H83Oj99KgICTEpKSlRSUmJ/i4FA8zoLWQEKoaKigqvaXqS
+nC8esrOzdeWKo8l9bm6u2za+XhwYjE+/ulJQUKAXXnjhoe/PUHINoYxPxo1PqI03Oy+99JLbJbsH
+iq9LgwMAuuYZQhnBz6uvvup8Lk9PTx+QK5O6vtH2dTzj523btvU4Lcz1wkOPMovF4hXWVVVVOYMm
+Y+SwMfLtpZde0rRp07RkyRI1NDRo1apVzr/D169fl81mc4Z6ubm5+t3vfqf9+/dr8+bNTA0bZMYH
+msbvbPv27XrnnXf085//vE/TJAmfAg9hlJ+FhoZq8+bNvd7e12ij3u7v+YYuMjKyx319vQn0PH9a
+WprPEG2o9Gfk0eU66ReHul5/+rp7/6bLddL/PNC/2ro6n+e5gEDi2rPJ8+ctW7a4BSiuDcV782ls
+dyOjjAbm3U0rGA4NzI1Pu43pjJ5Bk/HJn3FfnnzyyQFtKk7PKADoHeN5uLW11edzp+ffv23btmn7
+9u09/q3q6XyS3D6k8PTyyy9ryZIl2rBhg7NnorGta82S3MIWPPDee+8pNTVVb7zxhtvfYavVqvXr
+12v79u1asmSJW1PyzZs3a9u2bV4X/jAeY0ZDDSzXf8vLli3Tli1btG/fPuf/DeMKeMb/wx07dnj9
+f8DwEfT1r3/d3vNmg8P10u+ey1y/GrfOzk7n187OTj377LNDWi8Gh6/RRRg4//z17tffuHFD48eP
+H5piBthQ1O7recrXOs/nLuP5ynjO6ujocH41bm+88cZD1dTQ0KCYmJiH2hcDj98HAAw9nnsDC7+P
+wMLvY2Trz+936dKlCg4OVnBwsIKCghQUFOT8XpJzmcH1e0/dresNGpgDAAAAAABgyBBGAQAAAAAA
+YMgQRsHvRvVvdB+60ZvHNiio+6logcput6ufI0MBAAAAAH5g6ujo8NvJe9szSpJXv6jh+OYZvsVF
+SdWN/q5iZIqL6nkbk8mk9vZ2hYWFDX5BA6i9vV0mE9dgAAAAAIDecO1ra/SLMr537RtlGMyeUaaQ
+kJB+HaAnvQ2NPLdzbVxut9udDxJh1MgzI5EwarDMSOx5m/Bws2w227ALo2w2m8LDzf4uAwAAAACG
+BZPJ5GxY7vpVetC83DNk6ip0ooE5hr3MSVJCtL+rGHkSoh2PbU8iIyN1795dNTc3DX5RA6S5uUn3
+7t1VZGSkv0sBAAAAAPQRYRT8zhQsrc4gkBpICdGOx9TUi//hQUFBGjMmRi0tLbp586bu3LkTkCMP
+7Xa77ty5o5s3b6qlpUVjxsT0O40HAAAAAAw9Gq7A78JGSWMjpE2Z0smr0oUqqa5J6gi8PCSgjQpy
+9IiakSgtTHX8HDaq5/2CgoJkMpkUGxsnm82m27dv6d69ewq0PCooyDGsNDzcrNGjR/scQgoAAAAA
+CHyEUQgIZpPUes8RoixM9Xc1w9+oIMdj2ltGqGOxWGSxWAapqoFDEAUAAAAAwxfT9BAQgoMkS4hj
+JM+oIMcomIFiabFp0enj+s7enQN30AAUFPRgNJQlxPGY9n5fR+M6o4ldoBoudQIAAAAAusbIKASU
+sFG9m1rWE9O9u0q7+KVmnS9S6vUrCrLbdW1CqqJD+3/skYwRRwAAAACAwUYYhREjyG7XxGtXNOvL
+M5pe9qVC7ra7ra+LjfdTZQAAAAAAwEAYhWEvpqFes88VauaXZxVla+pyu7rYcUNYFQAAAAAA8IUw
+CsPWlMslyj7+ZyXWVvVqe0ZGAQAAAADgf4RRGLYuTZ6u68kpSqqpVGJ1hSZeu6LUa5e73L5ubNwQ
+VgcAAAAAAHzhanoY1trDwnV14mQVLFgk2e1dbtcUGa32sPAhrAwAAAAAAPjCyCiMCIvzDyv1+pUu
+19MvCiNNQ0ODv0uAC34fADD0eO4NLPw+Agu/DwQ6wigMe1PLLijr5LFutyGMwkgSExPj7xIAAAAA
+4KExTQ/D2tiGeq3+6H2f6w7kPKO7phBJUl0czcsBAAAAAAgEhFEYtkLvtOm5D/5Dpo57XutOzM9S
+4ZwFOvfYHElSXQwjowAAAAAACASEURie7HY9++EujWm85bWqZOpj+vPiFZKks+nzJDEyCgAAAACA
+QPEgjGopV37uWdW5rq07q1zPZd2oK85V/tXWXp+8vviAjju3b9O1goMq7u3JdKfX58HIs6SLhuVV
+8Unat3KdFBTk+DkhWZcmTVPnqFFDXSIAAAAAAPDB2cC8tfaGbElRqsrNVaHHRoW5Ve4LkubJmh7n
+CLDySmRzW3lMuaWep0nUvBXpinVd1FKu0iqLkrPNXVfXek0nzkqzF8Sq9osCXXI9kTlFq1f3cO8w
+IqWVXVCmj4blt6LH6A9rv6kOk3tf/sNPfW2oSgMAAAAAAD1wvGtvKVdhaZTmWWcrLn22ZvfpEImO
+/bpYa28p1/G8Rq/l9VdKZUucp5SIro5br3MFZVLCHEnhmrDgKY231+vLzy7L8vhcJYbZ+1QlRoaY
+hno946NheVtYuHav+5Zazd7/oBrGjB2K0gAAAAAAQC+YpFaVF5XIFjldFqmL0U4uIqdrcVaKHoxn
+qvIeOeUl0f3HlnKVVlqUlh3re/OWchUcvyhNydITE8Nkt9tF9ITQO236qw/+QyEeDcs7goP1h2df
+0C1CJwAAAAAAAp7pYmmhrsjiCKIkKSJF2daUPhyiryOj2lR+plS2B2d0V1Osg1XVipiSpSdTwmW3
+E0NB3TYs/+irz6oyaYIfigIAAAAAAH1lCq2P0ryMaJUW3V9Sd1a5hd2MdOrnyKi2q4UqVaISI5t8
+blldVa2EjOWaFWsniILTkrxDPhuW52U+pS9n9G1iKQAAAAAA8B9TStZsx7Q5Y0ncbFmtfXlz35eR
+UW2qqYrSvMypshW4t0mvP5enUpuUkLFc6XESORQMU8suKPOLPK/l56enKz/zKT9UBAAAAAAAHpbJ
+a0lPPaOMK+k59WVkVLhSMtMltbkcv05nD5yWMhYprSlP3q3O8SiLaajX1300LL82PkUfffVZP1QE
+AAAAAAD6wzuMknxMxXNovZqvY82eGz/c1fQc6nX2wEVFZ6/QRHOrrpV5b9F27YQKbFP0lekx95e0
+6Mpf8nVFsVq9uovDYkToqmF5w+gY7Vm9UZ2jRvmpMgAAAAAA8LB8h1G90VKu/LwbGr8oWyrO1dkE
+q2ZHGKOqLJq+KFspEZLME5WWdECF5xK1Ypbn1fNiNXuFY1lX0/JabC2KiBil61/8WZdskuJnKXvq
+aPpJjXRdNCxvDTdr13Ob1B4W5qfCAAAAAABAf/gOo5pLdCy3xPceSZJUp7N5JVLaYqVESHXGOs8r
+8dWd1YGL0VqcuUKLy4/rwDn5CKS606aWZily3GhNWPCUxtvt6uzsVGdnZx+OgeHoK3kHvRqW3x1l
+0u6131Rj9Bg/VQUAAAAAAPrrIafpxWm21epcHpeQqMLCXPnqHJU4L13hkpSSpRXdlhKuiVMTdLDo
+oKpdF1um6smxktwGQt1RxelTYp7eyDS17IKe/CLfbZld0p9WrVd1QrJ/igIAAAAAAAPCEUZFpCg7
+6/4S1+89mFOzZfW1opsr8PmeTheulEwfJ4lL1/Ll6c793G5uG4YpeW4XRWJYi62v8dmw/MgSqy5N
+TvNDRQAAAAAAYCAF+7sAwOBoWP6fXg3LC+fM1xfzCR8BAAAAABgJCKMQGO43LI9udr/y4tWJk3Vg
+2TN+KgoAAAAAAAw0wigEhKd8NCyvjY3XntXPS0FBfqoKAAAAAAAMNMIo+N3Usgt6wqNheVNklHat
++5buhYT6qSoAAAAAADAYCKPgV74alt81hWjXuk1qsUT6qSoAAAAAADBYCKPgN74alncGBWnP6ud1
+c2ycHysDAAAAAACDhTAK/tFFw/JPVqxWecoUPxUFAAAAAAAGG2EU/OKpYwe8GpZ/viBbxbPm+qki
+AAAAAAAwFAijMOSmll3QE6eOuy0rmfqYPlu03E8VAQAAAACAoUIYhSHlq2F5VXyS9q1cJwUF+akq
+AAAAAAAwVAijMGR8NSy/HTVau9d+Ux0mkx8rAwAAAAAAQ4UwCkPDR8PytrBw7Xpuk9rMEX4sDAAA
+AAAADCXCKAyJp47mujUs7wgO1h+efUG3xoz1Y1UAAAAAAGCoEUZh0E0tu6An/lLgtuyjrz6ryqQJ
+fqoIAAAAAAD4C2EUBpWvhuXHspbqyxmz/VQRAAAAAADwJ8IoDJrwtlavhuXnp6fr+JNf8WNVAAAA
+AADAn0x3797128ntdnuXyzy/dnZ2ym63q7Oz0/k9ApjdrnV733NrWH5tfIo++uqzfiwKAAAAAIBH
+07179xQUFKTg4GC3r8ZNkvOr5/eeulvXG6aQkJB+HaAnvQ2NPLez2+1ut+DgYMKoYWTp0VyNr7zm
+/Lk+JlZ7Vm9U56hRfqwKAAAAAIBHk8lk8gqigoMdE+Y8QylDV6FTf8MopulhwE0tu6CFLg3LW8PN
+2rVuk9rDwvxYFQAAAAAACASEURhQng3L744yaffab6o5KtqPVQEAAAAAgEBBGIUB49mw3C7pT6vW
+qzoh2b+FAQAAAACAgEEYhYHho2H54a98VZcmp/mxKAAAAAAAEGgIozAgln72qVvD8sI583Xq8Uw/
+VgQAAAAAAAIRYRT6bUZJsRYWfu78uWzSNB1Y9owfKwIAAAAAAIGKMAr9Eltfo6c//aPz59rYeP1p
+1Xqpn5d5BAAAAAAAIxNhFB6a0bDc1NEhSWqKjNKudd/SPVOInysDAAAAAACBijAKD8ejYfldU4h2
+rdukFkuknwsDAAAAAACBjDAKD2WZS8PyzqAg7Vn9vG6OjfNzVQAAAAAAINARRqHPZpQUa4FLw/JP
+VqxWecoUP1YEAAAAAACGC8Io9Ilnw/LPFyxS8ay5fqwIAAAAAAAMJ4RR6DXPhuUlUx/TZ4ty/FwV
+AAAAAAAYTgij0CtBnZ1uDcsrEsdr38p1UlCQnysDAAAAAADDCWEUemXpZ7nOhuW3o0brD8++oA6T
+yc9VAQAAAACA4YYwCj2aUVKsBacdDcvbwsK167lNuhNu9nNVAAAAAABgODKVH89VSXPfdrKkLVZ2
+6oMwoq44V6WRi5U9rlb5eSWy+dopcroWZ05UuCSpXsUHShWVnaWUCPfNWq8WKN82VTkzY92W37zw
+Z52tdt929erVfSscfRZfU+VsWH5v1Cj94dkXdGvMWD9XBQAAAAAAhitTSpZVKT1u1qry48fUOM2q
+2XEea67mq7BpuhanmyWlKNvqfjS73d6LMupUfPCiorMyFdfFFmNnPKWvTLer5doXOmd/THOTQntx
+XPRHeFurnvvjg4bl+1auU2XSBD9XBQAAAAAAhrPg1n7sXFecq2OV47U4K0V9n7RlU2n+WdVJUm2V
+qi3JiovoaR+ptUVKGBvW57Ohb4yG5ZEtjmFzR7OWqnTaTD9XBQAAAAAAhjuTWZLqziq3sMp7bdI8
+WdN9j1VqvZqv0sjFsqabHftXJ3a5rZu6Yh2okRJlUVp2kqqOl6slqlqyVSv/YOn9jYp0yKWc+NlP
+aUaMJN1UbXOCJoZL6s2AKzy0ZS4Ny8/OzFDBk1/xc0UAAAAAAGAkeHA5NI/gqfVqvo5100vKnJqt
+bElqKVd+YZOmL0rU2dxc+Yi0Hkiap3mqksWSJqlJUqxmZ9h0PD9Bc5enK1buPaPsdrvLTWq7flm1
+LS2qzb8smVNEy6jBMaOkWPPvNyy/Nj5Fn6zggQYAAAAAAAPD1PMm3anT2bwSRc2zOhqRW62a7bq6
+pVz5RdI8Z+PyNpUXWJQ8yaKmi45NWmsrpGlzFet5aC9tqq9p0biZizUt/IYKv+zsX+nwybVheX1M
+rPas3ih7MBddBAAAAAAAA+Phw6iWcueV8xJ7vVO4UjKzJNWr+P4Sc2qWstRzo/O268W6ZJPGPWy9
+6JFrw/LWcLN2rduk9jD6cwEAAAAAgIHzkGFUq8qLbmj8IqsiLvcwNa9HdTp74LSq3Za59oyK1+yn
+JslWbVF8vI1WUYPEtWH53VEm7V77TTVHRfu7LAAAAAAAMMI8CKMqC5Vb6bE2qavdzErJypYkx9Xw
++iVOs1esUPr9kVFd9YyKWfCY6r+sUU2/zwdfln32qcZXXpNd0p9WrVd1QrK/SwIAAAAAACNQlw3M
+8ehwNCw/IUk6/NTXdGlymp8rAgAAAAAAI5UjjIqbLeswyaFqzx9TrSSZe255jp65NiwvnDNfp+Y9
+6eeKAAAAAADASNZNz6g6nc0tfNAPKnK6FvcmsHJpbC5JlrTF96+k50ubyo8fU6nNc7lrzyhJCbP1
+lekxkuS4mt6YTtlbbvSiGHTHtWF52aRpOrDsGX+XBAAAAAAARrhuwqg4zbZaNbuHA8SlW+WWUUWk
+KNua4vzR91XyYpW+4v7IpqwVSvGxnWu/KOM2dsZXNKazU52dksz0NOoP14bltbHx+tOq9VJQkL/L
+AgAAAAAAI1ywvwuAf+Tcb1jeFBmlXeu+pXumEH+XBAAAAAAAHgGEUY+gGSXFevz0Cd0JDdWudZvU
+Yon0d0kAAAAAAOARQRj1iDEalncGBWnP6o26OXaYdK4HAAAAAAAjAmHUI8TcYnM2LP9kxWpdn5Dq
+75IAAAAAAMAjhjDqERHU2ann9r6ryJZmFSxYpOJZc/1dEgAAAAAAeAQRRj0icv78iZKqK1Qy9TEd
+Xbzc3+UAAAAAAIBHFGHUI2BGSbEeLzqpisTx2rdynb/LAQAAAAAAjzDCqBHOaFh+O2q0/vDsC+ow
+mfxdEgAAAAAAeIQRRo1gRsPye6YQ7Xpuk+6Em/1dEgAAAAAAeMQRRo1QRsPy8Dut+sOzL+jWmLH+
+LgkAAAAAAIAwaqRafr9h+b6V61SZNMHf5QAAAAAAAEgijBqRZp0/rXlFJ3U0e5lKp830dzkAAAAA
+AABOhFEjTHxNlb524EOdnZmhgieW+LscAAAAAAAAN4RRI4jRsLwiaYI+WbHa3+UAAAAAAAB4IYwa
+IYyG5XfCwrRn9UbZg/nVAgAAAACAwENiMUIsP/yRoptua9e6TWoPC/N3OQAAAAAAAD6Z7t6967eT
+2+32Lpd5fu3s7JTdbldnZ6fzezikny/S7PNF+veN31NzVLS/ywEAAAAAAAHm3r17CgoKUnBwsNtX
+4ybJ+dXze0/dresNU0hISL8O0JPehkae29ntdrdbcHAwYZQP8TVV+urBD/XHVetVG5fg73IAAAAA
+AEAAMplMXkFU8P0WP4C1hc0AACAASURBVJ6hlKGr0Km/YRTT9IaxiNYW/dXe/9Thp76mS5On+7sc
+AAAAAACAHhFGDVPBHR1a98f/1IVps1Q4Z4G/ywEAAAAAAOgVwqhhavmRj9VijtChp77q71IAAAAA
+AAB6jTBqGEo/X6Tkyuv606r1Uj/naQIAAAAAAAwlwqhhJr6mStkFR7R73bd0zzS4zecBAAAAAAAG
+GmHUMBLR2qKvf/QHvf/sN2WzRPq7HAAAAAAAgD4jjBomgjs6tHbvu8pdsVr1Y+P8XQ4AAAAAAMBD
+IYwaJlYc+UhnZs/XtfEp/i4FAAAAAADgoRFGDQPp54vUGh6hs7Pm+rsUAAAAAACAfiGMCnCJVTc0
+6cpFHV2U4+9SAAAAAAAA+o0wKoBFtLYo68QxffTVZ/1dCgAAAAAAwIAgjApQwR0dWvbnT/TR155V
+h8nk73IAAAAAAAAGBGFUgFpy/LCOZeeoLSzc36UAAAAAAAAMGMKoAPRYSbEuTpmh29Gj/V0KAAAA
+AADAgCKMCjCJ1RW6azKpImmCv0sBAAAAAAAYcIRRASSitUXjaqtVNmWGv0sBAAAAAAAYFIRRASK4
+o0NpF8/rzOzH/V0KAAAAAADAoDHl5uY6vkuaJ2t6nKRWlR8vlDKylRJhbFans7mlil7kuqwHLeXK
+z7uh8YuyNNHc3YatKj+ep1Kb8bNF07IyZD+TrzLbg63sdvv978ZpZvY0jbRuSjNKz6konSAKAAAA
+AACMbCar1arWq/k61vxgYUSUVJiXq8Z5Vs2Ok+qKC1UlqSovVyU+DmJJW6zsVPfEqe5yiWxJ83oI
+oh5IyFiu9Lh6FR+86FwWP2eZZo61y26/f2u5ri/O2dXLQw4bE2+U6+LUGbIHM1ANAAAAAACMbCbv
+RWbFpWdrcWS+jlXXaaqtVIWViZpnna247o7UUq78vBLZ3BYW6kBlVzskat6KdMX2pdrWZrXI0pc9
+Al50023VjxmruyGh/i4FAAAAAABg0LlM03N8ab2ar0LNU3Zqtqwt5crPi9I8a6KqcnNV6OMAifdH
+TykiRdnWFElSXXGuSiMdo6UeTK/rXnXRQVVLkiyKcl3Rel0nPy+T7f5xxs1crDB1yt5Q2vd7G2BC
+2u+oIzhYLZZIf5cCAAAAAAAwJLyn6VmipMJjyq2crsVZKcq2OhbHWa2a3ZsjtpSrtDJRaVZjMl29
+ig9UKbGHUVC+pulJkswTtPCp8c6pep2dnerslBST1pf7GXCCOjsVcu+ebJaonjcGAAAAAAAYIbym
+6ZnjZivbOlXlxwtV25KicbX5OlZq87Vvl72ilLa4+yl9vVRz5rBq7n/v3sB8omynT0mrVw/AWfzD
+1NmhloiRNeUQAAAAAACgJz56RkmSWSlZ2Y5vU7NlTfXewjGdz1Odqiolm44p12MWXdWBKpefetcv
+Kj4hXjXNUXpywXiFuTUwD9PouVk97B3Y7ppC/F0CAAAAAADAkPPqGeXQqvLjx9Q47X4/qF6L02yP
+6Xx2e12vpun57BkVP0VTm4tU1zpe48Olm+WXpPgFCpPUu05UDy+p4prGV93QyfkDF3oZx7yROF6V
+yRMf+jiRTbcV1dTodYy+1hx6p02x9bXd1mJsUx87Tu1h4Q9dMwAAAAAAgCQFW61WLU7zmC7WUqsb
+zYlK7CGIsjXbHFfRO16u1n6VYVFa9nItXz5XCW7LwzVhcqQuFV9X280vVWybopnjhyYQGV91Q0uP
+5g7KMcdX3ejXcR4rPa9v7fpdl8fvrdj6Wn1r1++08NTxHreJra99qFoBAAAAAABc+Zym11p7Q7ak
+tG77PpktUVKzpJZG2aISZSvO1bHKrrd3n6bnYJm2WFmpNjXapOiudoydqdm1R/T52QhNWThD4epU
+Zzd1ofeMUOxG4ng/VwIAAAAAAB4VPsKoOpWV2pQ4r4dhURHRslRWqTyySVKi4tKtsqZ7b9bjNL3a
+i6pWpBLNvlZKbddO6Gx1vOITqnXp5BeyL3hciaE93KsBtGX7az1u8+/f+E6/pt35y4Qb5ZI0LGsH
+AAAAAADD04OeUSpUbtN0LZ7WqColqqcsShEpSkvKVWGpeg6uutHa0izLtLnSuYM6WCVJCUqIkGy6
+fzW9hDl66qkY2e0zNGN6vb787JjyIybp8YlND33OvjiyxNrjNk1RD8Z1rdv7XpfbjbndIEmafe60
+Mwjy5bNFy1QfG+/8eXpJsSSpZLqPtK8Xco58LEk6tHSlc1nonTZNvVyi60kTlVRxzWsfAioAAAAA
+ADAYTFard9jiY5FPXY2Gcher9BVdty43p2YpS5LdvlzLZ7ns9WSOJtrtst+/OYzV9MWLNa2zU3Z7
+Yu+K7KeBbGD+sGZdeLgwKvROm1Z98kdn6BR6p83ZhHzS1TJJ0oTKaz77T735o5/2s2oAAAAAAABv
+PntG4eHtWbOhy3ULTx3X0qO5Ojtr7oCEXK4jmtrDwrzWrTy4T7E3a3Vq7hM6lrXU7Wp4Uy5flOSY
+YujqsdJzmn/6hM/zxdbXuI3YAgAAAAAA6KtHPozqqSdUd+uPLLH6deSU64imssnTdX18iiRpUf5h
+ZZ84qpYIi3av/aaupE512y/0TpvSL5xR2eTpXtPxMr/I93mup44d1ITKa36/zwAAAAAAYHh75MMo
+SaofO05nZ83t9fZRTbe7HD00lFz7WTVGRim62dFHK/vEURXPmKODy1a6jYYyzCg5J0kKa2v1Wjfm
+doPKJk/3Wl7w5BLdKfpCS4/mamrZBX349Do1R40eqLsCAAAAAAAeEYRRkm6NjunTaJ+kimteYVRS
+xTWNr7rR7X5G0/LumpcbbiSO77GJuGfNC08dlySfo6FcLbhf+4TKa259pELvtCn2Zq1Kps7w2udO
+SKj2rNngnGq4+d23tf+rz3Z7HgAAAAAAAE+EUQNkfNUNLT2a2/OGkqZeLtHUyyXdbnNkifWhr2jX
+XUA0vaRYsTdrVTxjjtIvnNGkq2XOxuhGU/OKbs57cn6W6mLH6ZlP/6j1H/yHfrvp/6CPFAAAAAAA
+6DXCqAFycn5Wj6OrjFFF/uy7FFdfq5YIiw4uW6nE2irNulDsDKOmXL6olghLj6OdrqRO1XvPbVLG
+2b8QRAEAAAAAgD4hjJKjT5Ixxa03oppud7kusum2opoaVR87zme/pu4kVVxTe1jYoAY8ednLVHe/
+trOz5mrp0VxF3r8/6RfO6NTcJ3p1nPrYeB1aunLQ6gQAAAAAACMTYZSk2Ju1vZ5i15PHSs9r6dFc
+/fs3vtPnaXbf2vU7lU2erj1rNgxILa5i62ucIZcxEurLtJlaejRXS/IO6064Izg7wZXyAAAAAADA
+IHrkw6iyydNVExevvOxlvd4ntr5GX8k7rMbIqEGsbOCE3mnTd//tf3tND2yOGq38J5Yo+8RRSdKp
+uU9whTwAAAAAADCogv1dgD+F3mnTuRnpziAqsum2FuUfVuidNuc2SRXX9PTHH7gtuxMaptvRowPm
+SnKhd9qcU+18ia2v7XJd0ezHnd9/mTZrQOsCAAAAAADw9EiHUYuPH9Gaj953XkUu7madsk8c1YyS
+c85topoblX7hjPuypkbNP31Ci48fGfKaQ++0OXtWPf3xB/ru//e/9MP/9T/0WOn5LvcJu9suSboT
+Eup1rK9/tEeS1BJh0bp9u5RUcW2QKgcAAAAAAHiEw6ikimuaf/qEyiZPd45wupI6VS0RFi04fcK5
+Xcn0dNWPHee2rDJ5osomT9f80ycGNbwJvdOmpIprGnO7QUnVN5zB0/z7taRfOKNbo2OU/8QS3Ugc
+79zPc5RU8v0a62LHuR17+eGPNaHymk7NfULvPbdJkqNvVc6RjxVbXyNJaoqK1pElVjVFRQ/a/QQA
+AAAAAI+OR7JnVOidNq08uE+S9Nki915RX6bN0vzTJ9wbfk+doewTRzXpapkzuPps0TJNvVyizC/y
+tcdHo/Knjh3UnXCz27IxtxskSbPPndaEG+U91plRXOjWWP3m6LE6NfcJ1Y0dp7rYcV4N0qOaGyVJ
+m999W5UJjnAqrK1VEyqvqSXC4tw+9E6bnvvju84gyrgq3v+7+WUtPn5E80+fcAZeZZOnS5LiaqtV
+Ny7Bq8Y7IaE6M2d+j/cFAAAAAABAekTDqBkl5xR7s1ZHllidgZPh8qRp98OoWue6C9NnaeL1q27T
+3Opj43Vq7hPO0VFG0NMYGeUMcDzdGh2jW6Njel3n5dQpkqy6kThe9bHj1B4W3u32JdPTdaS5yS3o
+uhNuVvGMOTqxMFuSo/n6hvf/TREtNrcgSpLaw8J1aOlKnZifpclXyhR3s1ajG29r6uUSxwYXznid
+c/fab/b6/gAAAAAAAAStWbPGPpgnsNt7d3jP7ex2u89bZ2enOjs7ZbfbtXr16oeua3pJsUqmp3st
+NxqV9xT8SI7pcGHtd7wCrYe1bu97fb6y38PIOfKx6saOY0QT0AvdPYe5rjO+N74az1PG81ZHR4fz
+q3F74403Brd4AAAAALgvJydHwcHBCgoKcvsqSUFBQc6bK8+fe1reW4/kyChJPoMoqXchlKE5arSa
+B6ogSXvWbBjAo3XNdTQUAAAAAADAUHpkG5gDAAAAAABg6Jnu3r3rt5P7mv7iOdXFc8qL6zQ9AAAA
+AAAA9OzevXteU/Q8p+e5Tr/rbipev6fphYSE9OsAPRmonlHBwcGEUQAAAAAAAA/BZDIFTM8opukB
+AAAAAABgyBBGAQAAAAAAYMgQRgEAAAAAAGDIEEYBAAAAAABgyBBGAQAAAAAAYMgQRgEAAAAAAGDI
+EEYBAAAAAABgyBBGAQAAAAAAYMgQRgEAAAAAAGDIEEYBAAAAAABgyBBGAQAAAAAAYMgQRgEAAAAA
+AGDIEEYBAAAAAABgyBBGAQAAAAAAYMgQRgEAAAAAAGDIEEYBAAAAAABgyJj8XUB/tLa2+rsEACOc
+3W7v1Trje+NrZ2en86vdbldHR4c6OzvV2dmpe/fuqaOjYxCrBgAAAIDAZcrNzXV8lzRP1vQ4Sa0q
+P14oZWQrJcLYrE5nc0sVvch1WQ9aypWfd0PjF2Vporm7DVtVfjxPpTbjZ4umZWXIfiZfZbYHWz14
+0zdOM7OnabQks7nbAwNAv/UnjLLb7bLb7ers7HSGUR0dHTKZTIRRAAAAAB5ZJqvVqtar+TrW/GBh
+RJRUmJerxnlWzY6T6ooLVSWpKi9XJT4OYklbrOxU92Co7nKJbEnzegiiHkjIWK70uHoVH7zoXBY/
+Z5lmjrU739DZW67ri3N2EUEBAAAAAAAMTz6m6ZkVl56txZH5OlZdp6m2UhVWJmqedbbiujtSS7ny
+80pkc1tYqAOVXe2QqHkr0hXbl2pbm9UiS1/2AICA1dDQ4O8SAAAAAGDIuUzTc3xpvZqvQs1Tdmq2
+rC3lys+L0jxroqpyc1Xo4wCJ90dPKSJF2dYUSVJdca5KIx2jpbqb4uKquuigqiVJFkW5rmi9rpOf
+l8l2/zjjZi5WmDplbyjt+70FgAASExPj7xIAAAAAYMh5T9OzREmFx5RbOV2Ls1KUbXUsjrNaNbs3
+R2wpV2llotKsxmS6ehUfqFJiD6OgfE3TkySZJ2jhU+Pdeq90dkqKSevL/QQAAAAAAEAA8JqmZ46b
+rWzrVJUfL1RtS4rG1ebrWKnN175d9opS2uLup/T1Us2Zw6q5/717A/OJsp0+Ja1ePQBnAQAAAAAA
+wFDx0TNKksxKycp2fJuaLWuq9xaO6Xye6lRVKdl0TLkes+iqDlS5/NS7flHxCfGqaY7SkwvGK8yt
+gXmYRs/N6mFvAAAAAAAABBqvnlEOrSo/fkyN0+73g+q1OM32mM5nt9f1apqez55R8VM0tblIda3j
+NT5cull+SYpfoDBJvetEBQAAAAAAgEASbLVatTjN4wp1LbW60ZyoxB6CKFuzzXEVvePlau1XGRal
+ZS/X8uVzleC2PFwTJkfqUvF1td38UsW2KZo5PrxfZwIAAAAAAID/+Jym11p7Q7aktG77PpktUVKz
+pJZG2aISZSvO1bHKrrd3n6bnYJm2WFmpNjXapOiudoydqdm1R/T52QhNWThD4epUZzd1AQAAAAAA
+IHD5CKPqVFZqU+K8HoZF/f/t3WlsHGl+3/FvFa+ubkoim6co3hLFGZGjWzvSzHCc8cqGYe+sHSQG
+HDt5FyDOZL1wjGQDZG3YSXYd2Lu2F+vxbhLH2ThG3tkwvIaNsa3dIKEljUbULVKiSJES2aJ4NimR
+ffDsvOiD3c2+eDXZ5O8DEN2seuqppx6yu6v+/X+esh/E8XKUoeJZoJrytstcbltbLO0wvYl+xiim
+2kq0EvzDN3k4Vkll1RgDXbcInDtDdWGaoxIRERERERERkV1pdc4o7nJl9jjvHnvNKNWki0Vhr6fl
+8BXu9pE+cJWCzzuH49gp6PkhPxwFqKLKDh5Cd9Oreov33y8lEGil9fgUjzuvct3eyJm62Q3vU0RE
+REREREREdobx4Ycfbutc4IFAZtXHlwsEAgl/VlZWWFlZIRAI8IUvfGE7miwiEpHqPSx6Xfh5+DH8
+PhV+31peXo48hn++8Y1vbG/jRUREREREQj744ANM08QwjJhHAMMwIj/R4n9PtzxTCeeMEhERERER
+EUllbGyMmZlpfD5fxkkIu5VhGFiWRUlJKVVVVek3SMDtdjM7O8vCwkLO90e2GYZBYWEhBw4cwOl0
+bqiOvdT/W9Efu52CUSIiIiIiIpKx+fl5nj0bpKjIxpEjtTgcjk1nSey0QCCAx+NhcnKS3t7HNDY2
+UVRUlNG2i4uLjIyMkJ+fz8GDByksLMz5/si2QCDAwsICXq+X58+fU1NTQ0FBQUbb7sX+30x/5Apz
+pxsgIiIiIiIiuePZs0FKS0tpbGykuLg45y/8IZiJUlxcTGNjI6WlpTx7NpjxtiMjI1iWRWlpKUVF
+RXuiP7LNMAyKioooLS3FsixGRkYy3nYv9v9m+iNXKBglIiIiIiIiGRkbG6OoyEZl5caGsuWCysoq
+iopsjI2NpS3rdrvJz8+nuLg4Cy3bH4qLi8nPz8ftdqctux/6fz39kUsUjBIREREREZGMzMxMU16+
+8bup54ry8nJmZqbTlpudncVut2ehRfuL3W5ndnY2bbn90v+Z9kcuUTBKREREREREMuLz+XA4HDvd
+jG3ncDjw+Xxpyy0sLFBYWJiFFu0vhYWFLCwspC23X/o/0/7IJQpGiYiIiIiISEYCgcCemJMnHcMw
+Mroj237pj2xT/8fKtD9yiYJRIiIiIiIiIiKSNQpGiYiIiIiIiIhI1igYJSIiIiIiIiIiWZO/0w0Q
+ERERERGR/eHbH3+HO3furVleVFTEr/zyL3H8eEvC7abcbj7+g//Cl/7VL1LmdPLtj7/DhfPnuHTx
+bXw+H7/9zd/jx3/s85Hf//CPvscv/PzPUeZ0bvchbY7PRVfXIOmnSg+zaDp/nloLwE1v5wQVHa3E
+H6W7t5Nu2uhozeD43b10dkNbgnoSFKa3cwBHpA3hY/DQnNH2u1TkGCqY6OxmPFm5yiR96u6lc9DB
+hXO12LaznXuIglEiIiIiIiKSFV/+0kf86Z/9OQD/+B/9Q3w+H7//8Xfp6HiX7/7X/87MzExM+ZKS
+En71q/8OgOamJr76q7/Br/zyL/ELP/9zfO3rvwXA6VMnY7b5wz/6Hn6fPwtHswWsWs531AafJwzq
++HHduomnqYM1MRCfl1m7g4Y1lbqZGK+krWMbQkPuCcbt1VzARVdnbBCtuzM2hFPZlqDNu5R/ahRf
+ZTNOYILKhIE5v6uLm56o54NrQ4g3OweT78TepGBVFAWjREREREREZEeVOZ28+85FIBikAnjypI/v
+/fGfRNb/s3/6T7AsG5/87d/x5S99xL/8F/+c7/3xn1BXWxup5/qnNwD4yr/9lSwfwQ7wefAVV6wJ
+bvhdA9B2PhhMWVfWU3ruiXEqmzqwWYSCaH5ctx7CiahMqZzjZ3LMR2WTE3BntIWt9jzhGKKyojZG
+wSgRERERERHJqr/660/4q7/+BAgO0QM4cqSGm123ImWm3G5sNht2y4rJpgL40z/788j2v/br/xGA
+//aH/yOy7S9+9OWUw/5ym5veyFCyccIJSZVtHbRaLh56mjkfDpQ4W2mr7KS7tyKzIXup+FwMjFtU
+10cvm2SUatpzNhAFuJ8zSBMXNtQ9flyDoQDdVrdrj1MwSkRERERERLLqp37yJ2KG6UEw+8nv8+Pz
++bAsixcvRmg78SaWZdFy7Cj/83/9b0ZevuTLX/oopo54U2433/ydb2X1eLLLSWtHBxW9nUxUdNDq
+DGUnWeAe8nCAQTo747fpprci1bC58TXD7ICoOZL8uHoG8WERGwwLSjg8LSeGpQWDSdAUtSxJXwBU
+xm3teshgcRsdzrV9EiMn+iK7FIwSERERERGRrEqUGVVXF0znGR52UVdXy8DAID/z0x8CcOrUSX71
+q7V883e+xZMnfTvT6C0XnA9q0Bu7NGEgpLtzNdBhb+LCuXK8c5VUtAJ48XjBMdVL9/g4JJjzKDjH
+kYsGZ7KASOJ5kla3f8hgcRNNjBIOhrWmmEA9V/hdDxnEIjaxK9wXsfN1Rc8ZBYDPxcNBH1aTHbCF
++iSm9tDf16LphAJR8RSMEhERERERkaxKlBllWRY2y8b9Bw8j5cIBKghmTv3nrweH5N1/8DAmoBUv
+HODa3WzUnusgcoQ+F1090B6TQZNkAnOfi1EctENoIvNqGmprqa2NDYdE9hQ9x9EGeD0HaGstx3tr
+dHWhe4JxxhlPmEWUOri1W3g9B2g74WCgJ7zESWuSid9ttefpiPzmprdrFOxJKnb30tk9TmVbB9sx
+j/xekL+4uLhjOw8EAkmXxT+urKwQCARYWVmJPBcREREREZG94yd+/Mf43h//Cd09jyJD9MKuf3qD
+v/27H/CVf/OvgT04TM/nwYcjo6L+qVF83gN4AaZGoaodW5JMK2DTw8Scra2AH2/sQjo64oNfweFq
+s00Nuz4QBaHj8rkYgEgAaY3orDQAexNHiwehrYPmiU4GmKS3czDhEL3xNRltO5shtbS0hGEYmKYZ
+8xj+ASKP8c/jpVqXifyCgoJNVZBOpkGj+HKBQCDmxzRNBaNERERERET2iOhJyB897uXMmVN8+Usf
+ce7sGbp7HvFTP/kTMeVfvBihtLQkEqDK/cyoWH7vLCS4O14ittrzdNh76ezsBCyaztsAf+h53J3t
+QhlXW95eVxc3x6qjAizhQNQFztfm4KC0mOBacB6uUXxAJdUnWuPuFhhMM3NPAJTT2lEbO0Rvl95h
+Lz8/f00gyjRNgDVBqbBkQadNB6M2tbWIiIiIiIhIhr798Xe4c+ceEMxs+s7H3+L3P/4uP/PTH3L8
+eAt/+md/zpUf/B8sm42/+utPIplPPp+P7p5H/PiPfT5S157KjPK5eDgITefXkU/kbKDJPs6g18fg
+kJva1mRjxrZJWTsd9ud0dnZiNTVxYHAwdwNRMUITwp9op7rnJp6mBujpwnUiLsgnm6JglIiIiIiI
+iGRF+E54YT6fL/L4H/7TbzIz84qvf+03APja138rcve84WEXM9MzlDlzYfDXOkXNL5R5sCN097bK
+NjrO2XHdukmXq41qfAx2dbLm3nb2pkSVbIrNsoEVzCZy93bSDVTaczwQ5XPR1TXIgbYOWi0/LiA4
+t1c7rluddFXthWDb7qBglIjINjAMQ8OJRURERDLg8/v51rf/gDNnTvHrv/bvI8t/82u/wW9/8/f4
+9sffoebwYUpKS2ImNI+pw+fjt7/5ezx79hyAxsaGpGV3FXcvnd3Q1tGxjjmW/LhudUPU5NjBidD9
+uMZSD9ML3lXPl7DWhHfxA6hso6M1deucrR10tLrp7eykty1usvVckfJvEZxsvtzVReet6iTD72Ln
+7LKaLuyqIXq7jfHhhx9u69XSVs0ZFf6JnjPqC1/4wnY0WUQkItV7WPS6RDdfiL7xwvLyMoFAgKWl
+JZaXl1leXuYb3/jG9jZeREREZIvduXObM2fO7nQzsiKTY33y5Am1tTkQ9MpBLpeL48ePpyyzn/o/
+k/5I54MPPtg1c0aZm9paRERERERERERkHRSMEhHJgs1+cyAiIiIiIrJXKBglIiIiIiIiIiJZs6uD
+UeFMguiMgkRjGEVERERERGT77ZebtAQCgYyuO/dLf2Sb+j9Wpv2RS3Z1MEpERERERER2D5vNhsfj
+2elmbDuPx4PNlv5eaIWFhSwsLGShRfvLwsIChYWFacvtl/7PtD9yiYJRIiIiIiIikpGDBw8xOTm5
+083YdpOTkxw8eChtuQMHDuD1erPQov3F6/Vy4MCBtOX2S/9n2h+5RMEoEZFtoqHGIiIistdUVlbi
+9/sYHx/b6aZsm/HxMfx+H5WVlWnLOp1OlpaWmJuby0LL9oe5uTmWlpZwOp1py+6H/l9Pf2Qq0fVI
+tq9R8rO6t00Id8x+GA8qIiIiIiKyG5mmSV1dPcPDQ3i9PsrLy3E4HDn/ZVsgEMDj8TA5OYnf76Ou
+rh7TzCx3o6amhpGRERYXF7Hb7RQWFuZ8f2RbIBBgYWEBr9fL0tISNTU1GW+7F/t/M/2RDVvRvzkT
+jEpkL07iJSIiIiIisluZpklRURFHjx5jYmICl2sYv9+f80kDhmFgs9k4ePAQR44cwTCMjINRBQUF
+NDQ04Ha7ef36NQsLCznfH9lmGAaFhYUcOHBg3RlAe7H/N9MfG91ftu2aYFSyWfBTLfd4PBQXF2ej
+eSIiWyLR0D0RERGRXJKXl8fy8jIVFRVUVFTsdHO2nGEY5OXlrXs7p9OZlcCBJKb+X7+dvCbZ9jmj
+tvrgouubmpra0rpFRDYr2Xue5ooSERGRvcIwDPLz88nLy9tT5zfhIFR+fv6eOi6RRHb6f3zXZEat
+Rzhbanh4mIaGhp1ujojIhqysrGSc/i0iIiKy25imqXMZkRyxvLy84wGoaDnzzpHoblQzMzM8f/58
+B1slIhKU7I4USyceigAAFz5JREFUqZYru1NERERERLJhZGQEWF9G1HYGr/KvXLkSfHb4NJfbygEf
+Q5/ehZOXqLeHi03y8EofB9+JXpaGd4jr115w5J1L1FmpCvoZunGVvsidGB20XDxJ4MF1+j1rSwcC
+FbS9d5xDBDvm/v37WAUBKmsaM2yYiEjmks1bl25dorLRjwD9/f17cp4FERERERHZXe7cuRN5vhsy
+pPIvX76M7/l1rs6tLrQfgLvXrvD69GXay2Gy+y6jwOi1KzxJUImj5V0uNcRGnCYHn+A5fJp6O2Ry
+rVZ18vO0V0zy8Af9q8ve+oAT5cG75gUCAQKeYbp6AlihrIJAIIAx08+3v3ODL37xi3zuc5/bWC+I
+iGyj+KBVODOqq6uLS5cu7WDLRERERERkP/ibv/mbXRGECkswZ5RFedsl3i2+ztWxSY56+rj7sprT
+l9spT1WTd4jr154Qm8x0lysvk21QzenPt1GWZG3CLvLP4aUYg+DF3PzIPW4/D2Cz4PtXH+P3+6mv
+r6e8vByHw7GrOlpE9rdwACr6Z2hoiOvXrysgJSIiIiIi2+b73/8+PT09mKaZcAqknWBYlhX8uj40
+TM/3/Dp3OR3MdPIOcf3aa1ouVzN6JZgdFa86lD0VbbL7Cn3FsdlSyYeyJBimd+kU3L/G66M/ygn7
+EDc+7ccbWlvR9j5vOAMEph7ROVjM2VPVFAYC+F7c5d4w1L3VTlXRDE9v9uHGybFzTRyK3r9/nJ4e
+F/51dFJp8xkaD61jAwmZZ/xRD96aYP+9en6HEdsJ3qwqCq0e51GPl5ozjazt3thtVxeP82jAi8U0
+xK9b4xXP7gxA8xlKZ+L2nah0fPsyKZPwGOYZfzSA1w7T1HCmIUkj58d51DNF2YlmGEhwrOupC+DV
+M+7MQKnbh/3Em1QWrbZ5uiT9//D82CN6/NH7eMWzOyOhuqKfJ+mLfSrZe1v08nB2Z/TzlZWVyPPv
+fve7vPPOO1lpr4iIiIiI7B+fffYZX/nKVyKBqPjH6IBUfGAq1Z3CN2vtMD3HAbh7lSsvj/PuxXou
+XQ4uLr98mfZMavQO0feympbL4UDUJA+vjFKdIgsKoOrU52kvjx2mB4BVx9sf1K0O1QsEgsP+nG/w
+Xmnogg6wjpzmFHe596CLYSBQfpwLTYciF4DhzgqYgFVL+4kq0l9CzzPW/RCvYaKbRGzEAj6/DYdl
+YpqvmHHbKG+zVvvSKqXc9oKZ182UlqTaNrxsnrGBF9iPtGN/MZ3B36WU5nPnAHg1Axip7vYxz4IX
+7KVWijozO4b50QFe2Gtpt1xM+1Ls06qm7Vx18LgAI8HxJK4r+H85WdZOW3X4v/gVgwM+attq8bpd
+UXUFj8soTdxXrwZv0c8xzjXZeO324zxSGlWulDLnAK5Xi1RXB5/3j85S3XQocV/sU+mCUYFAIDJM
+L/p5eF0gEOCjjz7iq1/9Kj/7sz+btXaLiIiIiMje9hd/8Rf87u/+7prAUybBpO0MREGCYXpWeTuX
+Lh9l6NO7THjrqZi4ztW+BDOJk3yuKFreTT2kL6nYgxq7/0PG1pSppP39Rjy3bjAQ1yyr/gxvv10I
+QGC6j8+6+mIvFMtauFBjYACvnt1iONWNrKw63morwQiOCUQj/tZvftSF26rgiGVgsBppXe1LI2n/
+xm4bXtaPy9HC+VKDsZHE2yWzup8kG8yM4PI7aSk1Eg8RDbU37TH4x+h/YaflfAnGqCv1PklSR1jS
+uow1x/NqsB9v7Vs0W34GYtoYfHQ/vYUbABt17e1U2aL6BWO1fFwbovdT0nyelsEubt1aW89+lmwS
+88i8dnGP4bKmabKysoJhGKysrPD1r3+dv/zLv+SLX/wiFy5coLa2lry8vGwfjoiIiIiI5Kjl5WUG
+no/Q8+A2n3zyCT09PUkzn3Z6WqMEc0YBWNRfDM1h0nCJyw1rSwSH88WbZPQleLjKlb7YNaM/iB7k
+l3q+qLCq6irGZg9w6XN12ICAd4jPHoIdG6Xn3qcWYjKm3E+ucv/lWU7VFGI4j/P227HDZMKPb70F
+rwZcWHUneetwgvyomad8NmxgmhbV7RfStFISWRh9yAOXg+MXqgnGK4IBKcOMDnaYkfm/ol8Ha7cF
+5sfodzk4fqEEg4WE26ViGMHMo4QvuJkBbvb7qD/ZTknK+tIdwwJjT4dxtFygxICF4E4zeJEn6odU
+ddmobr9AdVT7+7z1nGq2YTAf18a1ZW8+7MY42U5VEZQ0X+BCaH+J+nS13xYZe3gPT+0FLjSH2vew
+i+7yU7RXF6Y5PokXDkCZpkkgEIg8PnjwgPv37wOxQ/vCMr1z356zMM2zwXHm16woorKpkeK5Zwws
+VNBa7QAWmX42gL+8lcPFqyU9o728Lg4v8/Cy18XrNdVV0txYSsH2HYlsQLK08fCy+BOs+PKpvv3b
+Lbc2zjmvnnFnxM6JNysTZ5knHcLew5Rz7fDu2GHiweHpNAeHhUcPNZ8fe8QAzft+eLjsD/6VBfLN
+NF9KLUwzuGKjyZbk1uVLr3EtQJX94MY+25Ze41rwsRhZkEdpYTkFS5Ms5pdTQmb1L60sYzN1vijZ
+dWsIztWnLjMwGXxsLofbw1DmgAbn6nrXNIzPBteX2OHFTPD6qCbZ9CeL0P0SautZMw3N/Az0A21r
+RgSF2jIEjsNQVUAw8aIi+DyGF269grdqjJjP3/gA02fPDS42rZ2vNlFmVKohetst/8qVK8Fnh6MX
++xj69Cqvj62dDyq1ctrXDOcLDdO73E5ZigupsXs/CGVBOTgYXlh5lJbZe0z46qmzArifPYWqi1iG
+QQCYevz/eDgWX+dtPh2KW2Rv4MzJwxSGshMg+E/kd93npitxewyrGMM0UV7Cevl5ef8eQ/bjXLxY
+GrXcCAU28lhN9jAwDItie3hZsm2n6X8wjKP1bZx54e0MDDO83TT9N54QSXSz6jl18jDRSTsGwWBO
+fKbJdP8NnnjrOX2xJaY8vpfcuz+0OrdY2XHePpb6GF4P3mfY0crbZcGVhhHcb/rslvjjgen+DOvy
+veRev5eGky1Ykb6Jb2OUshZap28wNLNITU1cD8W1IdxvDrtF3ut+ho0GTpXlhV4TFjXHG5jom2Hx
+SGxf70eZDNWLfwwHoOLnkAqvj59zKpP97VlWOUdPRH0Yzb7gkes1hZV1lFt5waGokddHHgdLini1
+tExeHkwNDMORoxQS/f9tYBhFVDUfpawoqs4JAzMvT+/7u1Cqb/ESpZsnW5aszvXsXwAz+JlqmiYJ
+R2ov+PBbDuwx681Qtm3U8PVXg9zqd4fWD3DHDThrqTX8uHru8CK8qfsO06GntiOphtyL7B0GGfyv
+mwYEjOTlCkuoD8eAll4xPO9jIaOdW9TbD1HACot5hzhq2YEFpr2vwDSxmQZelni15KeosJqiNM00
+COh1K9lnkH46kdDHu2lCADhkrW4z5IZxD7RUBZcDzC+vlk9aX2i/8UXMqH0l3DT40YppBh+HRyFh
+qKIgfG2Y/NwmPugUPUQvvmwy2Tj3WTtnFIB3ghdz1bSkCUR55jzgneD6fTh9sZ4kMfkMOGi5dJF6
++xQPfxCdUmWj7mgxP3wwTMXR19yfO8bFExZG6EKs7I33+ZE3QhdmPhddN+doeu84pURdzLn7uDZl
+xxb+64YYBlj1Zzl9ZO23a/vuQm/LzPPy/j089ReJiSUB4KDY7mdu3sCwhxb5Z5jwOWiwGxiptp2e
+CgaantwgZmTlkxtMVbzBxaNOWi5epCVFy4Iv6tjMqJmnnzLsOMPFlgTfsNprOH2xZs3xJT+GV0wE
+G8mN2EZyY6qMNy62kCQIzuoJejgraYapDOuan5nAj5+h+zeIjsFO3b/BRP0ZTtWsPTbTBIfdissq
+s7AXw4R/AcMIbzPD1JRFcZ2B4Qu2zzSihjGGsq9ilu0z8XPSJRM/VC+RcHAqut74x2T731cWpuif
+tHO8rS7yLWyeYYCZFznRXVpYwCjKwzTnmZ83sPJM8kx47XrEa+BQfQMGBmZe1FxqpgGGSV6yi2vZ
+Fhs90Un2jV78+q2a60DBqDjRQ7wTrH417cZWdiR47hW1kQHY7bbVz5+SZs6fb2Z+9CEPfHWcbwpm
+Ro11T0aGgr8a7GLKeZ7mQzA/+pA+du6uPyLZlNGcLkYm5RaY9s5SaC+jviB8BullzOOj2FGGI2q9
+I27LxcAyhWYB8dNEFObl4Vl04zEPcbQo/etxJ+/WJftY7OV/4iJG1KMB/mWY9cOMDybmoLUSDlpJ
+yidirgaVBp5DolmBbs5G/ZIPp45AUahOI2r7+iNQnSAz6rMZY02wa22QKZygsHaS8s1mRW3laznh
+MD3fxAs8h1tSzvtkOQ7AHOB9jedANZ7uK1x9mbz86JW19+JztLzLxXoPs3NwINmG5W2cGv8h1+87
+OHbxRDDgtaYD/Lh6BjGaL1AWuqCLXPSZRL69i2Ya4Bu6zfX4LKoYFbz5TgvB2Mg0fdcewRvv0OIE
+/4u73J6o5OzpGmz+Ee7eHqfy7Glq9nOKiNvFcxo5W5boYs7iSH0F1x4/pTLUp9MvnuOreBOnaabe
+tqyV2BuN+Rm5extPffBvkYlw5Djyf+AfYWiigsZ3rHVceKY6hlKccXdD87+4y21vA++0rInMrWmd
+AZiRScedtKasK3j84xVnOV17hndqo0tO03ftOY7I/+I0Iy8sao6E/jHdfTyeqODNlmA/T/dd4xFv
+8k5LKc66RoZu9zJaHtzW/2KIKXsVDXYT015JRe8jXDNHQn3uZ+TJc4yKs1j7+JuudMGgRNlNie6s
+F/0TX3Yj+9pbFph88piRuFugPukOf6bYKC01wHjNSPfzUPZEKU0nbeQtzDHPPPNzyxw2oLTxJHUH
+AWYZHppntK879i6xNocyo3aJZEPyUi1LdUK1mayojZTf84wUmVEzT+mbKuP45+I/X+fx+oJfDMV/
+bJhR9YHF4bdOxu0quI1Vc5KTiOwPJikynsIME8x05ZZZNEyKol+v8/PM5ds5bJrBPRkmRmS9h1HP
+HIVFVRQaK9hMW+g1u8yiUUBxoYk5b4Jp47CjGBOY842xUFCFM8kEMCYryoySrDNInxkV/ng3TbAV
+wMjM6vI3DsNBW/LySXdK8KVJAZypJTKcbt4Nj4FTKa5fozOjhl7CcKIy+WCYRupglGGE6kk9RG+n
+JXjLmORpn4fq02nSouwHcbwcZah4FqimvO0yl9sSFVwdpldOggumqaeMcoBqe/RCI/Lof/4p90ar
+qKoeo//Tz+Di56izVjvcN/QZNwa8VLa/z3nn6p2rIFjGPTWB3dG45g3QAOxN5zl7JEn0yPeC27fm
+ok60QtubwRMiM/TNgGmawZMoEp9g7Ssm4H3G7WvPYpdXtvHe8VIob+V84226rl2LXZ7JtnE7MkLv
+Lpn2txk/NMAwgAkeXZuILeho4vyZI8mHnaU6hnT7TN66tMcTW1eCoQ5RdQUPL1yXief5ba49D6+v
+oO29Vkqj6w2ngdtrOXvCw9/fvsYzCPbF2XBflNH6Xhu9f3+Na+GqKtt4ry7mhbvvZBIAShWQSvV7
+ovoT7W/vBqHCLKrePENV+Nf5cR4PQvMblYRHHiyMPWba76TxTCONUVsuvJ7G73TifPmYQcDpDA/T
+K6HxzJmYsrL7ZJrVlCwrKtPyG23Hvhb+1jUuGOUfucfdIWg4dQpn/MfTtJspLBqstZ914WyLhdEH
+uKxTHCuNXbfvz69kXzIxMcw07z/5BRQtpSkXCTwFyyz6xnm2nEdNcXHoisvENEPzjYZ+N4wCigp9
+zC3YOGD5GJubYRYgv4TDi276llc4mA+j8z5arAKWKKCoMHmmvJnJkEORrZbBMD3DhEAgWO5smvml
+wnUaqeoNBZJ6n0FZJVhR5QwzdYAsnBkVDkY11EJN/FRrHrjuDiX0R7ZL8MWcAaaZeMheJllR2Tr3
+MSzLWr2SKT7Ou8dec/UunA4Fj1KZ7L7C3ZdQfTrV3FKxwSiIvXjyD33K3cBpWjxXufsSgpObH8Vz
+4yp9c0D1KX70RHiq8ym6f3iPMccxLjXPcv3BGFS9xY+8sRpeDHiH6bo5gDeypIK2jjeIDkAGAgGm
+n3TycO2t+uJU0t6xeuEuIhJvvRlLqYJOmQSkMtnnnhQ9t0xZC+caI7MLMj/azUN/XcwymGespx+a
+26iyhcq8iEuvSsB2pJ22ak2OvFusd5idAlE7ZZq+64+ZtDdw5lRN5Aud6f7rPI76zsdqOMPpNSnk
+fkbu3eG5N/H66f7rTJZdIm2Sscge412ZpyDdBOYs4PZMMJnytCCf8qIqnCuTPFmcpzCvgkYr9gp3
+zvuCkZWoBWYJx/N8PFs5GFt2fpIni1BTXE4xsOgbY3B5CQwHTY6SpJOYL64sYzf12SrZdfUpvHs0
+dZmXr+CZG4oz/Pecm4dGJxxONoH5HFx1BydOX/NpNwU9wNkkd3HrfQrFdXCkEF4MAdXB5+F1obnW
+sUrhrDN1xnjnU4P3jyWf1mCjgaitPi8yPvzww6xf1az3QirdxdhmLtr25UWdiGyZ9WZHhX/PZH4o
+zRkl+9FGJtTMdL4DBaNEJFf4VuYpMJOMe8sxiytLWApGSZb9/VN4L00wankFRl4F54jKRIkVvJNe
+3g4m+mUybcH/7YN/cDz23CjZXJs7GYzKiXe4RJP+hjsiflhe/IVcqg5Lt15EJJ1Uk5InKhN+34me
+1Dy8PPox/nmi30X2qvV8Nmd6ErWRz3udI4jITjEITQWS629DAYJDejVMT7Itg2F6pgkNZdCQnRZt
+mbTnOkbiIFT8tjsZiIIdCkZlcvGW6TbxyzPppEzvgCUistWi37Pig+rxAXIN0ZP9biPD9NazXERk
+t8o38wgYwfmWctmKsUJ+IE/vw5J1pgErQN4e/ddLFkhaXgnNKZUm+LRT80RFy4nMqLD4DIL45fHr
+4jtUQSgR2Q7rzY5KFkTPNLNTASnZb7L9Td121isikokiCvCxgEEgGJDKtbekAKywwjIBLKNQ76mS
+dU4HjM8Gh9Xlgs28RqK3HZuFMsfa5akCUdvZtlR2LBi1keyoTLZNFoBKtE5EJJuSZUVFrw8v28x7
+mYJVspdl+lm+VSd1IiI7wTAMrEAhi4FlFlmGHPxoz8PEMgoxjdzO7pLc1FgOt4cAA6oP7Ow8Txux
+3nOR5YDB6GvonwhOoG4Ya+vYbRnkO5oZtdmAFKS/6ErUsbpQE5Gtlun7Wfx7V6o58TbTFpG9QPM8
+ich+lmfkkUe6O+qJSCIHbXCuAZ5NBgM0uR8CSH1+YxrBjKhzDQYH42/lx8YDUdt5XpVTw/QS2ej8
+UyIiW20970eJsqQgebB8M8F7kf1iKz7fdY4gIiKyNxy0wcnanW7F9troVAaZnO9s9znRjgejMs1w
+yqSOzdYjIrJZ6w1IQWZz3SVaJyJb97rQ60tERERy2VZOZZCN86IdD0ZtNQWmRGSnrTeLKVVQXkON
+RdZS4EhERET2s+2cyiBb51m7Jhi1HUNQdBEnIjtlM0OINzIXnshelY3/d72mREREZC/bbYEo2EXB
+KNiaIXuZ7kNEZLttNMiuDE+R7NA5gYiIiOxV6z3PyfZ50a4KRomI7DWbzfpM9aGgQJWIiIiIiIRt
+NKC0E1/Q7cpgVDYypEREsmW77oSnrA4RERERkf0p12/isiuDUWG6lbmI7BUKsovsDgriioiIiOz8
+OdGuDkaBLuBEZG/Re5rIztjpEy4RERGR3WC3nBPt+mBUmCb0FZG9REEpke23W062RERERHbabjsv
+yplgVDQN3xORvUKBdpHtsdtOuERERESybTefD+VkMAp0AScie0/8h4Xe20TWZzefcImIiIhst1w6
+F8pfXFzc6TaIiMgmKGglIiIiIrJ35VKQKVP5BQUFO92GbacLNRERkdy3F0/ERERERPajnB2mtx46
+eRURERERERER2R3MnW6AiIiIiIiIiIjsHwpGiYiIiIiIiIhI1vx/l+CeLaT4EacAAAAASUVORK5C
+YII="/>
+
+## 第四步：点击确认，开始任务
+
+<img src="data:img/jpg;base64,iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAgAElEQVR4nOzde1xUdcI/8M8ZRgFR
+FBS8kIkXMqTp4haGRZlaWqzh6mbP5pq5j2haWiEFsfXUZmuwovloSYVlWvp7MnFFl81SyZVW063t
+MotoKuIFi6tXBNSZ8/vjcIYzM2cu4AwDnM/79ZrXGc9tvucwMh++txHeeOMNEV4kil49PREREbUD
+giD4ugiq9N44KcMPERERKSmzQVsKRTpPn5AhiIiIiJxpS1nBIzVCbemCiIiIqO1rKzVE1xSEGICI
+iIjoWsl5wheBqMVByNMhiKGKiIio/fFkeBFFsdXDULODkCcCC0MPERFRx6D2mX4tYaa1a4e8MmrM
+EQYgIiKijs+XTV3N5XYQammIac5xDEpERETth6ugcy0dolsrTLkVhFoSUFwdw9BDRETUvjWnWayl
+wcbb/YY83jTmLODYbmMYIiIi6jgEQXBZC9TWms30nTp1crjRE81azQ0/DEdERERtn6sgY7vd0f7N
+CUTeCE9em1DRUQBytS+DEBERUdunDCXOAoq8zVFNkC+GzCs5DELuBhJXNT62AcjdQERERERtlzLA
+uNMp2lkgcjcMeSM0qQYhT4Qg28BjNpsd7tPc1yUiIiLfU2v+sg06Op1O9RjbUOOrMOSxmaVtA45t
+ALrlllsQGxuL0NBQ+Pn5tfRliYiIqI0zmUyoqanB/v378cMPPwCwDkTXGoY8ScjKyrJKNO7UyrjT
+/KV8zJo1C2FhYZ4qMxEREbUTlZWVeO+99yAIgtUDgN1S5k4Y8lRg0rnexZo7IchsNlsezz33HEMQ
+ERGRRoWFheG5556zygau+g23ZleZZgchNbYhSK4Jmj17Nrp06eKJlyAiIqJ2qkuXLpg9e7YlH6iF
+IV+xCkLNnePHtl+QMgTdcsstrAkiIiIiAFLN0C233KIahgDfzTtoCULNPaFafyD532azGXfeeadH
+CkhEREQdw5133mlXG2SbIZrDE2HI7aYxdyZCVD5CQ0OvuXBERETUcYSGhtrlBZmv5hds0fB5ZwFI
+7gjFIfJERESk5OfnZ5lWx9EEi609hF6vLIQjziZKtA1BtgmPiIiISFZVVQWdTmd52A6rd/XVHa0y
+s7S7nIUiIiIiIluhoaGWEOTn5wdBEOwCEeD+d5m5s90Zl32E3P2SVOU6udqLiIiISEmZEdQyRGv3
+FWrWPELuNKGxRoiIiIgccTcrtFaW0LX0hdQ6SSvXExEREdmy/T5SR6PImnvOlnJaI9SS8fy2EyQR
+ERERyVqaFbyVLa5pHiHbbQxARERE5A53skNr5IoWfemqs85NDENERETkjKsc0e6+dNUWwxARERGp
+aWsZ4ZqDkFpya2sXSURERG2DWmbwZW5wGITcKZTahIpERERErrQkQ3ijP5FbNULNmdyIYYiIiIic
+aU6G8Hau8FgfIWXV1oXvN3jqtO1KUVERRo0ahaKiIl8XhYiICABQXV3tlX2vla+bxGQenVla1u3W
+KS0qTEukpqYiNTW12cddunQJ06ZNQ05OjmVdZWUlEhMT7YJMTk6OW68RExODESNG4Omnn0ZlZaXL
+/QsKCjBt2jRcunTJYfkKCgqcnsMT4Ss1NdVhOYiIqP2qrq7G1q1bsXfvXpf77t27F1u3bm3VMORM
+q80s7Y2TtmbCe/zxx7Fv3z6XQSA1NRW33nqr0/3CwsLwzDPPYOrUqZb9cnJycOTIEWRmZrpVnpSU
+FACA0Wh08wokRUVFSExMdBqgUlNT7YLRnj170L9/fwwcONBufzlMDR06FEOHDsV9991nd/6CggJs
+3rwZM2bMQJcuXZpVZiIiatt69uyJoUOHYs+ePU7D0N69e7Fnzx4MHToUPXv29GqZ2kItkNI1ffu8
+rxQUFGDOnDlW6yZNmgQA6NevH9566y08/fTTOH36tGV7dnY2XnnlFdTW1qqeMycnB1lZWXbnk23e
+vBmBgYF4//33sWzZMuzfv99pGW3LJ4uNjcW7775rFzpiYmLwzDPP4P7778e6devsgk1qaipOnz6N
+3r17W9ZdunQJu3fvxowZM/D111/bvWZgYCDWrVuHmJgY1bJUVlZi4cKFTssrS0lJQVJSktN9iIio
+7YmLiwMg/eGs/LdMDkEjR46026YF7TIIjR49GtnZ2fj8888tNTWXLl3C7NmzMWPGDISHhyM4OBhv
+vfWWXQhwVusxceJEy/kKCgqwcOFCbNiwAWFhYaisrMTMmTMREBCAjz76yHJMamoqhgwZ4jAkyAFG
+GX5SU1OxefNmyz633XYb+vXrhw0bNuCpp55CRkYGli5datleUFBgdw4A+Prrr3Hq1CkYDAaEhYXh
+0KFDlm1yeR25dOkSkpOTLWExOzsbo0ePVi3/559/jpEjRzo8FxERtW2OwpDWQxBwDUHI0ayQrVXl
+NXr0aBw9ehTTpk3D0qVLkZycjHvuuQejR4922T9HGUT279+P9evXY/To0bhw4QKmTZuGGTNm2O3f
+tWtX1XMNGTIER44cUd126dIlnD59Gvfcc49VgMnMzERmZiZycnKwe/duq4CTlJSEpKQkq/46o0eP
+tgsply5dwurVq3HdddchKCjI6fWqlWv27NkAgO+++w7Hjh3D1KlTMW7cOKsgOGfOHPTr1w/bt29H
+WFhYs16DiIjaFtswJD/3RQiyzQuiKEIQBMuyNbW7GiH5Q1zZNHX33XcDkEJNVlYWfv/73zs9R2Zm
+Jl555RXMnj0b99xzD5KSkpCTk4OLFy9i5cqVWLhwIbp16wYAeOeddzBu3DgYDAbVGpaRI0di3bp1
+KCoqsqt9OnbsGE6ePKlamyI3azm7LvmalOSam6+//hr79+9HbGys02tV8/XXX6Nfv36W0BMTE4M9
+e/Zg9uzZGDp0qN1rERFRx2AbhrRcEyRrd0GoS5cuVk1TRUVFSE9Px6pVqyy1FpWVlZgyZYpdPx+g
+qY+Oms2bN1s1WQHAxx9/jI8//hiA1OfGljxSbO3atXYdqteuXYsRI0ao9tE5duwYjEYj6urqkJCQ
+gA0bNlhdly1lLY5cG9RStjVMtv2jZHPmzHHYp4mIiKgjaHdByF3KPkJqI7/Uhoor+wjZctbn5vHH
+H8dTTz1lVStUUFCA/fv3Y8MG9TmV9uzZg3HjxuH06dOYMmUKpkyZYumP5Mq6desASEHl22+/RWVl
+JZ544gmrzuEy2zAYGxuLsLAw5OfnW9alpKRY9S9SysnJwW233Wb5t7N7REREbZuyTxDguAO1lngl
+CF344VMAi71xagDqo8bk5jF51FhzuRoRFRYWhry8PNVtMTExmDp1Kp5++mls2LABFRUVSE5OxtKl
+S1WDTWVlJXbv3o2HHnoIp0+fxpgxY/DLL7/AaDS61RT1yy+/IC0tzfIGDgsLw5dffmn3GjNnzsSi
+RYtUa6SUnbEB687myjLIfZaIiKh9c9QxWuthyCNByLaDdLdbHvHEaR0aPXq0pQZDrWlMngMoPDzc
+7XM66qOj5GwIeVJSEo4cOWIJZM7612zevBn33HOP1VD4pKQkpKamuhzGPmPGDLz88ssArDu8NZej
+5jBH18/h80RE7ZejEORqaH1r8PW8Qu2yaUzZX2bevHkApE7NP/30E959912Ul5cjODjYrdFUtbW1
+mDZtGqZMkWbDdjaM3JVx48ZZ+hh9/vnnDoPQpUuX8Nhjj9lNuiiPJnN0jHzNnmBb01NQUIDVq1er
+9gdKTU3F4MGDPfbaRETUelwNkW8LYciXPBaEWjPR/elPfwIAvPvuuzh27BgA4Mknn8TmzZuRkpKC
+Cxcu2A1Zt7Vu3Trs378fRqPRMoHhhg0bnNbIyLNG2yoqKsLUqVNhMBjw3Xffoba2FlOmTMHQoUNV
+g9UzzzzT3Ev2qoKCAiQnJ2PdunV290yeAoCIiNqf6upqHDp0yOXoMHnboUOHcMMNN3h9dmmZL4bL
+22pREPJ1NZajWpOkpCTLRIgTJ050eLw8yeF3331n+eCXO083p0ZIno/Idq6dLl264Msvv7QEpLq6
+ujbZyVgeXQfA4VxB8hQAymY8IiJqH3r27IkJEya4FWzi4uJaNQQ50trhqF02jQHWHaZjY2MRFBRk
+GVb+8ssvOx195SyQuKoRUvYlcjbaCpA6UX///fcApNA0dOhQh4FIrQO4GtvJHmW2s1XLbEeNpaSk
+YPDgwZbJEm1HqinDm/IYR1/TQUREbVtzgo2vQ5AvtNsgpOwwraQ2F09zOvm6qhGyncfIXc76/wCO
+r0fmqo+Qq/PbcvRayvBGRETU0QmLFy9WbeeynfpauTSbzZbpsc1mM0wmk2UpPxYv9t7weSIiImqf
+nn/+efj5+VkeOp3OshQEAYIgQKfTAYCliUzZVOas2awlTWq6Zh9BRERE1EEwCBEREZFmtds+QkRE
+RNT+1NTUWDWLyU1jcrOY8gE4bxbzxOgyBiEiIiJqNaGhoewjRERERNQWMAgRERGRZjEIERERkWYx
+CBEREZFmMQgRERGRZjEIERERkWYxCBEREZFmMQgRERGRZjEIERERkWYxCBEREZFmMQgRERGRZjEI
+ERERkWYxCBEREZFm6a9cuaK6QRRFu+fy0mw2W5bKh8lksjyIiIiIbF29ehWiKFoeOp0OZrMZOp3O
+8q3z/PZ5IiIiolag99aJz5w5461TExEREXmE14JQSEiIt05NRERE5BFsGiMiIiLNYhAiIiIizWIQ
+IiIiIs1iECIiIiLNYhAiIiIizWIQIiIiIs1iECIiIiLNYhAiIiIizWIQIiIiIs1iECIiIiLNYhAi
+IiIizWIQIiIiIs3Sd+rUSXWDKIp2z+Wl2WyGKIoQRRFmsxkmkwlmsxmCIFgeRERERLb0ej38/Pws
+D51OZ1nKGUKnk+pp5DyhzBXOMkZL8gdrhIiIiEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhI
+sxiEiIiISLMYhIiIiEizGISIiIhIs/S+LgC1HzU1Nbhw4QIuX75sNeEmERF1XIIgoHPnzujWrRtC
+Q0N9XRyPYxAil65cuYLTp0/D398f4eHhCAgI4OzhREQaIYoi6uvrce7cORw/fhz9+vWDo2+laI/Y
+NEYunT59GsHBwejTpw8CAwMZgoiINEQQBAQGBqJPnz4IDg7G6dOnfV0kj2IQIqdqamrg7++PkJAQ
+XxeFiIh8LCQkBP7+/qipqfF1UTyGTWPk1IULFxAeHm63/vLlyzh//jzq6+vZX6iZBEFAQEAAgoOD
+0blzZ9V9eH/JEb5/OhZ3fp5tTffu3VFRUdFh+gsxCJFTly9fRkBAgN26yspKdO7cGV27dmVTWTOJ
+oogrV66gsrISYWFhdr/8eH/JGb5/OhZXP8+2KCAgAJcvX/Z1MTyGTWPklCiKdr9Iz58/D39/f3Tu
+3Jm/ZFtAHoHh7++P8+fP223n/SVn+P7pWFz9PNsiQRA6VE0jgxA1W319PfR6ViZeK71ej/r6erv1
+vL/kDr5/OhZHP0/yPgYhaja1WiJqPkd/VfH+kjv4/ulYOlotS3vCIERERESaxSDUDAsWLEB2drbd
++h07diAyMhKRkZGIjo6G0Wi02z5y5EhUVFQ0+zWNRiPi4uLszumqnJGRkXj00UdRW1uL7OxsLFiw
+oNmv7XmFSDMYkLi6zMV+ZVgzyYC0XSqbTqxB4qQ1UD+DdJzz86ucW+2cNusK090pt695+/4qzrA6
+EQbLftLrqp6v8bUMBncfaShUO82JNUg0JGLNCRcFUyhMbzxnYznLVifCkK56dqtj1K6jbHUiDM14
+/bLVie3g/WLL2++fQqQ5uoe70hTvJyea+T7Q9s+T3MWGZDcZjUbs2bMHDz74IEaOHGk1odSIESNQ
+VFSEoKAgu+N27NiBmTNnAgBiY2NVzz1ixAh88MEHdscbjUZMmTIFdXV1mDBhguqxqampmDNnDrKz
+s5GZmWlZV1paCgCoqKjAli1b8Je//KX5F+1x8cgwrkSaYTzSBhqRMcqdYwqRZpiL4uRtyJsRYbOt
+DGsmjcemCY3bdq1AFlKwTbFf2epEjD+cAuOieIevULZzEzBhJSIU58w6LG0bb8hS7DkehqXAINWy
+tAVevr+yE2swdymQkj+98Z7FY17yIIxfvgbzRsnrZBGYvsmI6e4U5cQaJCYUO1ifhRIAWQkGZNnv
+YfmZlK1OxPilJZZ1RqNcmkKkLQVS8h2/D5yVa+5SICU5GlnPrsHYTYpr3JUGw7x8BwdK7xdHZW17
+Wun9I2914/+mlWa8D1ydRxs/T3KX5oNQzbPPInTZMpf7ffXVVxg5ciTGjh2LsWPHWtbv2LEDOTk5
+qsdkZ2dj+fLl6Nu3L0aOHIklS5ZYbZdDUlJSkmoImjVrFjZs2ACDwWB3brmGZ86cOZalHIiUcnNz
+UVxcrBqk5BDlDWsmGSxhQtU8A+x+3UTNxEyswqrDyn0GISXfiIR3DDCkr4TxSXln6Zds8Xwj8kYB
+QCHS5hUjJT8DEWj6JbstylVJC7FiaQlK5F9yUSnYtsmI6SfWIPFZYGXjL8nCdAOyotrOL7zWv7+y
+QqQlZAHJ2zD9+qa1ETNWImXreMxdPdaz9+jEGiQmbMKkfKPV61lKk27AXKy0vGbEjDwYZ0g//7mK
+/cpWZyEfJchX+QAdlLwNKYfHY+7WxhVbpXuXsMKIjFHS9UavMGL6KGDQYQPGTwK2yR+eozJgNGYo
+S4Q0Qz6ik4uxCZMQvbQYCcYMtCB+eZXv3j/ObMJcgxR0gASsVN63Zr4PCtMNmvp50rXRbBCyDUDO
+ApHRaMTy5cuxYsUKt8+/Y8cO7Nq1C9988w2CgoKQnZ2N6OhobNiwAb1798bEiRMBAPv377ebsDA7
+OxsfffQRcnJysHDhQqxYscKyT21tLf7whz9g1KhRLkOMXBu0detWqzBVUVGBiRMnIirKZUpoMUst
+QONf+SmqvzzKsGbSXGBZnuKX2zN4RvFL1PJX6SIjjABwoqRxhVTTICtMl/4qzbgewK40jF8ajZXG
+eGC12t+NCrvykR+V0vSL8Brs378fAwYMQO/eva3Wl5eX4/jx4w5rBFuite+v8nz5E1bCaBd2IjB9
+00oU29QmWH0gOROVgm02//2k2p1orDSmIN+QhkKra2yqbbAvi61CrFgKpNh9iEq1GRgYgfgZRhgX
+Nf57hVx+RW1H4/XELzJiZboB4w3F1h/UlpoE6QN80OpEbMJYZBgHIc1gwFwMQkp+nuqHuKwjv3+U
+74P8BAOyJqyU/kjZOhcG5fsjeRuMM0qQZmiKYS15H8Qv0tbPk66NZoNQ6LJlqHn2WQCua4U+/PBD
+1NXVNev8tjVHcmiRa2YmT55sV0MESCFo165d2L59O4KCgpCUlITY2FisWrUKhw8fxvLly+1qieRw
+tG/fPss6ZTOZwWCwhLlly5YhNzcXcXFxVuXzmuvHYlJUFvJ3ZSDe9i/DEzuwCZOw0vaXyYkd2HQY
+wPJEpCEP8441NXfIlE1Wg5JfQ/RWNNXqNP6Sigdc9jko/AJIuDHLcr6E5BQUL5X/KlVvGkNUCoyb
+7Bt7BgwYgM8//xxjxoxBRERjQ1tZGXbu3Ilx48a5KEkLtcr93Ya8GSVIM8yVQqPDpgy5acUAw4SV
+MC6Kb/xAcvNaTqyxPC1bnYjxWydhm1EKqPEr8mEwGJCwwthYXinY5Fldm3WzprIpY5AckhU1fVid
+JYU6+b6dKEExgGjLueaiOGoQSpbaNokkYOUKYK4hDU9OyMc7VkEvH3MtH+LK40qamnMa742tDv3+
+sQSTLETn52HszsZj5HuxKw2G5dFYOSMCQNO5WvY+kMupwZ8ntYhmg5C7srOzceDAAURHR7t9jFow
+Aaz77sgdrJXkcKSs6Rk7dixWrVqFmTNnIjU1FcXF9n0ogoKC8MknnwCQmsyKiorQvXt31X5HALzW
+HKYuAtPnJ8DwRSEyRln/sih8JwvR8412NTGF72wCooCSwyUomZeI6HypuUNNYboBWYhFhtGIDMtf
+qs7/UlOKX5SBeCQAW/ObqrxnuNWjxU7v3r0xZswYfPbZZxgzZgwAYOfOnXjwwQft/ir0nNa4v1KN
+W77tL3zV2oR4ZBi3IXrSeKmpxN3+H7ZXNcOmTKMyYFwBGOYZUGzV98fqKEtNR2G6AVkHB6EEkxzW
+9kXMyIOyzku+L/mNr5Hnom+TNH4hA08tkl4v/wEn/WoaP+id1Tx25PeP3avOyMM2JGK8WvNcY4BJ
+QEvfB9bl1NbPk1pCs0FIrgWyXdq6dOkSVq5cibS0NACw6pSsFBMTY3nuqPOzPOpszpw5GDt2rCUU
+qZGbr5SdsjMzM+1ee9WqVZaaHaPRiFOnTiExMRFRUVFYu3YtAGDXrl147rnnAEgBLDMzE5s3b1b9
+DjGvGDUPKcvHI22X4hfLrjTMPZiCbXa1BYXIxyRMQhaKVxiRgTQY3inEdDc+UMtWz5U6ZrrdJ8EB
+Zx0mXTSjRUREYMyYMdi2bRsAYPz48Za/Br2mFe5vvNz0YVGGNc9KfYXsj7TpIO20A6pNXxA7UnOG
+8mj7v+jl/h+N/zixBvkHB0l/qQ9cgcTVZViJuVLNgvxffFcaDPOgeO1C5B+chEk3ZqF4/jZEL5+L
+NWPkQG3dFOSov1i+Wr8apSjXf0x11PdPs0VFY5DN6zbvfaDhnyc1m2aDkG3ocdQ0tmDBAtTW1lr+
+LXdKlsmdpR0Fn9zcXLtz2oYZZXBSHtOvXz/VPkTK88tqa2vx+eef44477gAg1STdfPPNmDhxIl57
+7TVL2caOHYvdu3cjMzNTtWnOOyIwfVkKEhMSsSY/D9NL5A8h+0BRmD4XeGAbcLDx78hRGdh2LBEG
+w1y7s8oGJaNxJIii0zOkKvmVgH0/BEh/bdo2peQb8qUPzwegHnh2pcGwvEU3wMta4f7ashmh57Iz
+udr9dDRKDLZ9i5yHpcJ05QdWGda8AyRMAIobry9vVCHSDCVIWDEdEWhsfhuVgZUTDJibngDjoniU
+rc4C5udh0BdZKEYEpm/Kk4ZYN45qGjthEDYdKwNGlSB/6yBMyre/TqswZne/2up7B/DJ+0dVMVZM
+MiD/sPR/Vx6k0JL3gbZ/ntRcmg1CMndGjLXUkiVLLGHDaDTihRdewJo1a6yCzY4dO/DZZ59Zgop8
+TEVFBebNm+f2a61du9YuiOXm5qJ///6Ii4tDSUlTu3tqaiomTpyIHTt2tE4/IQC4fjry8oHEBAOy
+HP5CK0MJUjBvFLBD8UvGrnpcQa56L9u5CSWwH8pamF4CWHVsbPxrUDpzY82FNDLE0jS2Kx84nGXT
+P6iRi78C5T4A48ePB9BUFe71vwK9fH9t1lqN0AOA+EXbUDKpOcOunWvqW1Ro1XHWlbLVc7EpaiVW
+YpNiXZbUt2kUAMW8MfGLViLBMBdpDxiRgEmYNwoo+aJpe8SMFCQYsrDmyXhMHxiNkuU7UDawGPlR
+kzBPpenVEzUImnj/7EyDYWs0VtoNZI3GvE0ZyAAa5wsqRoqxZe+DEq3/PKlZOKFiK6itrcXrr7+O
+hx9+2GvNUZcuXcLkyZMt/zYajVi7di1eeuklu4AUHh6OadOmIScnx6q2y7ukYaslUYMwCPmYqzqZ
+WQSmL2rZ6K2IGXkwGo12NRLxi4wwGt3tM1SINHnCvagUbDMaYVQ+ViQ4Pbq8vNzyi27gwIEYOHAg
+HnzwQezcuRPl5eUtuKrm8O79tXql9LkoTl5pc0+lWoXieQ4mRDychfG2kycmZKFEbd9rUHI4Gilq
+cx4tU7tuaf6j/OVrMGiG+vaECSXYtLMMGBSNQYeLseKLfCTMV7+HCSts3i/NeO8AHf/9U5g+F/ko
+QdZWqW/NIGc7lxSjxK55zH3xmv95UnNovkbI2+Q+Rcq+PEqfffYZhgwZonrsyZMnXQ6xfPDBBwHA
+buZog8GAvXv3OjzOtonPW5omuEvASqMRlhk6Tqxp/OvTxYRkiknUHLGqerfqj+Kq/4lSPuYaipGS
+nweUtKxG6Pjx4xg3bpxVR8iIiAiMGzcOx48f90oHyda+v9L8PE3D59WGx8+dpNKJ9JqmKFCO3FGX
+8IC0jF8k3QHLaMHrpyPP6LiLrLPaDOl8xsb3z3TkGQuRZgASVEbBNe3nwKiMptFpDnTk9488z4/R
+qLhLA6MBubO0zf0pO1YM3Jhg835x/33gSEf/eVLLMAg1k3KmaCVlZ+nJkyfjwQcfxMyZMzF58mSr
+TtHK2aIBqR9Qamqq6mv179/faadmd742Q1neyZMnq44i8wZ5wrZBjkZ2KD6gpOnuS9Q/LF18kDWN
+amr8QJ6w0mZCNDfsyke+MjSVoEV9hByF1t69e3v8l15r31/5PNKHZlOfq4QV9sPjC9MTsePE9KYa
+IycfGsqZoAHpeuw/gJrTR8gBZUC2zCLuhJMP+PzGD2O7iRjd5WC4dUd+/9h3tgcwKgEJ8+z770kS
+pHnA7Na18H3QwX+edG2ExYsXq37drfJbcOXn8tJsNkMURYiiCLPZDJPJZFnKj8WLF7dC8cnbfvrp
+J9xwww1W606ePIng4GAflahjOX/+PPr372+1jveX3MX3T8ei9vNsq9Q+G9z1/PPPw8/Pz/LQ6XSW
+pSAIEAQBOp3Uc0cQBKul7XNbzrY5wj5CREREpFkMQtRsgiBY1RhSy4iiqPrXC+8vuYPvn47F0c+T
+vI9BiJotICAAV69e9XUx2r2rV68iICDAbj3vL7mD75+OxdHPk7yPQYicUvvrMjg4GA0NDbhy5Qr/
+8mwBURRx+fJlNDQ0qPbl4P0lZ/j+6Vhc/Tzboo5We8VRY+RU586dUV9fj8DAQKt1YWFhOH/+PC5e
+vMhfts0kCAICAgIQFhaGzp07223n/SVn+P7pWFz9PNui+vr6dlNWdzAIkVPdunXDuXPnrIIQIP2y
+7dWrl49K1fHx/tK14PuHvOncuXPo1q2br4vhMWwaI6dCQ0PR0NCAM2fO+LooRETkY2fOnEFDQwNC
+Q0N9XRSPYY0QudSvXz+cPn0aDQ0N6N69O61BdQsAACAASURBVAICAjpU+zARETkmiiLq6+tx7tw5
+NDQ0oF+/fr4ukkcxCJFLnTp1woABA1BTU4OKigpcvnyZ/Q6IiDRCEAR07twZ3bp1Q58+fXxdHI9j
+ECK3hYaGdqjqUCIiIvYRIiIiIs1iECIiIiLNYhAiIiIizWIQIiIiIs3Sm0wm1Q3KUUHyc3lpNpst
+S/lhMpmsnhMRERHZMplMEATBbhoWURSh0+kszwFY9lHu62z6lpZM7cIaISIiItIsBiEiIiLSLAYh
+IiIi0iwGISIiItIsBiEiIiLSLAYhIiIi0iwGISIiItIsBiEiIiLSLAYhIiIi0iwGISIiItIsBiEi
+IiLSLAYhIiIi0iwGISIiItIsBiEiIiLSLAYhIiIi0iwGISIiItIsBiEiIiLSLAYhIiIi0iy9rwtA
+7cfbu4G8H4DiX4DLJl+Xpn3p7AdE9wESbwGeuqdl5ygvL8fZs2dQV1cHURQ9W8BrJAgCAgMD0aNH
+CHr37u3r4hARuY1BiFwqrQZmrQd+KPN1Sdqvyybp/v1QJoXJ9x4DInu6d2xDQwNKS4/B3z8AERHX
+ISgoCIIgeLfAzSSKImpra1FVVYVDhw4iMnIg/P39fV0sIiKX2DRGLjEEedYPZdI9dVdp6TGEhIQg
+MjISXbt2bXMhCJBqhLp27YrIyEiEhISgtPSYr4tEROQWBiFy6u3dDEHe8EOZdG9dKS8vh79/AMLD
+209zU3h4b/j7B6C8vNzXRSEicolBiJzK+8HXJei43Lm3Z8+eQa9evbxfGA/r1asXzp494+tiEBG5
+xCBEThX/4usSdFzu3Nu6ujoEBQV5vzAeFhQUhLq6Ol8Xg4jIJQYhcoqjw7zHnXsrimKb7BPkiiAI
+bW5kGxGRGgYhIiIi0iwGISIiItIsziNEpDENDQ346fAR/Pyz1Empb98+uCFqCOf9ISJNYo1QC1RU
+VGDkyJHIzs52ul9tbS0effRR7Nixw26b0WhEUlISamtrnZ7DaDQiLi4ORqPR7fItWLAAkZGRePTR
+R1FbW4vs7GwsWLDA7eO97c3JwNE/AY8Md73vI8OB4peB1Pub1qXeL61z53j5HEf/BGyc6f6+b062
+X/99uvuv2RbV1dVh1fur8fT8ZGzdmo+KigpUVFRg69Z8PD0/Gas/XIuGhgZfF5OIqFUxCLVAeHg4
+Nm/ejI8++kg15KhxFp7kwGS7zWg0YsqUKfj5558xYcIEREZG2j3kY7Kzsy3rhgwZgtLSUnzyySeo
+ra3Fli1b8MQTT1z7hfvAyIFAgwnoFgCc+jNQngEkjwFCg4C3pkj/lh+24UX26b+BtDzgtv6O91G+
+3oUGIPd74O7BUvhxdUx7cPr0z3jl1dfRqVMn/CXjz5j62H+hb98+6Nu3D6Y+9l/IfON1iCLw6mt/
+RnV1ta+LS0TUajTfNFbz7LMIXbZMdVttbS3+8Ic/YN++fQ6PnznTvprhV7/6FQDg22+/BQDs27cP
+gYGB2LBhAz788EMsWLDAEkxqa2sxb948JCUlYezYsZZzGI1GzJo1Cxs2bIDBYLB7DbmGZ86cOZbl
+nDlz7MJUbm4uiouLMWHCBLtzpKamWo5vq24fAHx5CHhpq/S4ezCwdDKQ+x2Qud16Xzm49A12fL7H
+7pAeSj+fB57+BPjqqPR6Ryqk56n3A5evSqGob3fPX1trOX7iJLKWvIlpv38MsXfcjk1/zUPBl//A
+r4bfCgD46+atGH3fvfjDjMexZ+/XWPjnDKSlpqAPvzOMiDRAs0HINgCpBaKgoCB88sknAKRg8sIL
+L2DNmjUIDw+32q+2thbPPvss5s+fbxVa5CClDDlLliyxnM/2NWTZ2dn46KOPkJOTg4ULF2LFihWW
+15TPOWrUKJchpqKiAlu2bMHWrVutylVRUYGJEyciKirK9Y3yodT7gX7dgV/ON627a5C0/GeJ/f5f
+HQVuXdR07BN3Av+TL9UIKTkKU29OBgb2BP7W2Ar5awMwIBTITWra560p0gMA1v8LeC732q7R22pr
+a/HmsuV4dMpvEXvH7Th2rBT/2P0VFr3+KoKDpcQ4edJEvPzKQtx26y0YGXcnTCYTlr65HK+/9io6
+d+7k4ysgIvIuzQah0GXLUPPsswCc1wrJBg0ahODgYPz4449WNTcAUFJSYtnHdv2PP/6IrKwsAMDh
+w4eRmZlptU9MTIzleWpqKgBg165d2L59O4KCgpCUlITY2FisWrUKhw8fxvLly+1qidRqruTXSU1N
+hcFggNFoxPLly7Fs2TLk5uYiLi7O7jpaU1d/61Ah+6kCiF8qhZXf3QH464E+wVK/na6KvrzKcCJT
+1uz8s0Q6fuRA+yCkFqbuHgzcN7Tp33IIW7pTCkuPDAf+OB748zb787Vlq97/EHF3jsDdd40EABwt
+OYY7bh9uCUEAEBwcjDtuH46jJccwcGAk4u++CydPlmHd+v+HGU887quiExG1Cs0GoeaSQ8lnn31m
+FyA+/PBDPProo3YzAG/cuBE9evTAwYMHMW/ePGzYsMFhLY6yqUu5z9ixY7Fq1SrMnDkTqampKC4u
+Vi2bXKu0YMECFBUVoXv37vjggw9UZyVuC81hFxukfjuOQsWz90nNUqfPSTVCg19pXhj56qjUpHb7
+APttvzYA/zwq7aP2egBwxwDgu5P2zW/tTadOnewmNnRngkZBAK5cueqtYhERtRma7SytrAVS1g45
+ExcXh1OnTll1kN6xYwdOnTqFuLg4q30rKioAANdffz1WrVqFFStW4MMPP3S7fHLn6sjISEs/pMzM
+TLvO0sqyGI1GnDp1ComJiUhKSsLatWuRnZ1tGT0ml3fkyJGW8rVV/p2A9/dYrxs5UOr/Y9tJujxD
+fRRa7vdSJ2tlZ+c3J0vrcr93/nq/XSU92rvp03+Pffv+ha++ki5uwIDr8cOPRqtwZDab8f33P2LA
+gOsBAF/u2o1vv/0O0x+f6pMyExG1Js3WCNk2hblqGgOkmpeXXnoJs2bNQu/evVFeXo7/+Z//webN
+m+1qXjIzM3HPPffg4MGDAKSancOHDyMyMtLh+VNTU7FgwQLk5kodT/r164f9+/fb9UmSKYfE19bW
+4vPPP8cdd9xheb2bb74ZEydOxGuvvWYp39ixY7F7925kZmZa+iu1RROypeYqpedy7fvkPDIcyEiU
+am9sa4m+Ogr8v38Bs+6WapX6BAMP3yzVRClrg9RerzAZuEHltiub85RNcW1VUJcuSE6ej8y/LIWf
+nx/i4kagX9++eD71j7gpZhhE0YyiomJcd10EooYMxj/37EXelq1IT3ue8woRkSZoNgjJ3AlASgaD
+Ae+99x6mTJmCkJAQbN68WbXzdN++fREXF4f169db1ts2eynJoWbJkiVYsmQJKioqMG/ePLfLtXbt
+Wrswlpubi/79+yMuLs7SjwmQAtfEiROxY8cOn/YTaq6NM4Eh4U3hQxmCHNXeyE1b80YBDVedN8cp
+xS+1/nd77SMEAP2vuw5/fPEFLHlzOQ4UH8T0x6eiqroGpaXHodMJiI+/GyE9uuO9VR+gtPQ4XkpP
+Q69ePX1dbCKiVqHZprGWqqiowOzZs9GjRw+cOXMG9957r91kh0FBQUhJSWnVbw2/dOkSJk9uagMy
+Go1Yu3YtXnrpJbtyhIeHY9q0acjJyXE5oWNbsuOQ1O8nNwnYPs91CAKkADPrbikE+eulpjHl5Ixa
+0bdvH7z26ku4evUqXkh7CZ9+movy8nKUnf4Z//d/n+LFP76CAH9/vPJyOkMQEWmK5muE3JWdnY3M
+zEz069fPqhZInvSwrq7O6bw8yv0ckUeNyU6ePInY2Fin5XrwwQcBwG7maIPBgL179zo8zlntVFv1
+TqG0fC5Xarrq6g+cPKO+78aZQPwQ+07ZqfdLtUPJY4DCIx2jH5C7unTpgtmz/huP103F4cNH8Et5
+OQDgV8NvQ9SQwejcubOPS0hE1PoYhJxQDktPTU1FaWmp3T4Gg8Eykkue3XnEiBH44IMPHO6nRu0r
+MPr376/a9ObsGFs7duywdLaePHlyq9ZSAU2BRI3a8HmgaQi9M/FLm5rGACkc3T0YeOtRqUN14RGg
+d5r9cZnbm5rLNs6UOlrLfX20IjAwADfffBNuxk2+LgoRkc8JGRkZotoG5agS+bm8NJvNlqX8MJlM
+luXVq1exdKmLTzJqF9TCBHlOeYbz7d9992/cdlv7/IKz9lx2IvKe5ORk6PV6+Pn5QafTWZbyA4Bl
+KU/3oZz2w9kUIO5MD2KLfYSIiIhIsxiEiIiISLMYhIiIiEizGITIqU58h3iNO/dWEAS7r8hoD0RR
+bFFbPRFRa9NfuXJFdYO7naVFUbTqKC0/qGOI6g0c+NnXpeiYonq73icgIAC1tbXo2rWr9wvkQbW1
+tQgICPB1MYioDbp69SpEUYTZbIafn59lKQiCTzpL6x39snIVhERRtFwIg1DHNS6GQchbxsW43ic4
+uDuqqqraXRCqqqpCcHB3XxeDiNogf39/+Pn5WR7KkWOCIFgFIo4aI5+beRcwrK+vS9HxDOsr3VtX
+wsPDUV9fh4qKcu8XykMqKspRX1/ncP4rIqK2hEGInArQA3+ZzDDkScP6Svc0wI3pTHU6Hfr3vx41
+NTUoLS3FxYsX22SfIVEUcfHiRZSWlqKmpgb9+19v+YuOiKgt48zS5FTXTsDAnsD6mcCavcDnRcDh
+cuCK2dcla1866aQ+QeNigOlx0r+7dnJ9nE6ng7+/PwYPHoLKykqcOnUS9fX1bS4MCYKAgIAABAd3
+R0REhFXVNhFRW8YgRC718AfONkgf4NPjfF2a9q+TTrqn7vLz84PJZEJYWBjCwsK8VzAPEQQBfn5+
+vi4GEZFbGITIJb0O6BUIXLwC1F8FropAG6uQaPMEAdALUnOYOzVB1scK0Ov1lq+zaWu1QTK5Fog1
+QUTUnjAIkdu6dmr+hzh5DkMGEZHn8bcqERERaRaDEBEREWkWgxARERFpFoMQERERaRaDEBEREWkW
+gxARERFpFoMQERERaRaDEBEREWkWgxARERFpFoMQERERaRaDEBEREWmWwyB0dOsbeO/rs43/Oof9
+qzKw5Yi7p71wzQUjIiIi8jb9okV5eDQ9EYOVa2v2oeA/vXDr7B6OjzzzDVZvFjHx8cH46eNV2F0l
+rRZFEQi5E4sXe7PYRERERNdO30tl5ZF/7kTVTVMQG+rosBL8bdWXwLBJALpj+O+fxa3mEny2vBC9
+HnsUN3U1ea/ERERERB6ir7JdU7MPBcZeGPPkYLX9gZr9eP+9AuDeWZhxRzDMZjMYe4iIiKg9sqkR
+Oot9uTtRBbV6IgAHtyDjPwfQ897Z+ENssNQMRkRERNROWdUInd27ATsRg5iwctWdi4uKMey3afj1
+IDNDEBEREbV7uqa6n3M49J/emJJ0L/rY7HT0b9koqAKiJ6fi4SGtW0AiIiIib9E11Qh1x4ikRFjn
+nCPIe+MNFN04B6MdtJYRERERtVc6x/nmKPLeKEDf2S86rAU6t381lm47plhzBnvWZ+O99wo8W0oi
+IiIiL9CPMRThk603IX2C7SixwUh8UVrnqDtQdVU1Qnt2wr8/XibNIzT015hz33UwmTiOjIiIiNo+
+fa8J6Xjq6/ewaCtUwpAz51BTAYTfcF3jPEJmmEwmhiAiIiJqN/TdAeDOWUh3ult3xI4ahoyNmTig
+rB7qNQr/PQiwnkjoAn789GNwamkiIiJq6/T2q3pgRNIs++HxQx5GauoEAIDZLA2fF0VRZULFbrj5
+kVneKi8RERGRx/Db54mIiEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhIsxiEiIiISLMYhIiI
+iEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhIsxiEiIiI
+SLMYhIiIiEizGISIiIhIs/T19fWqG0RRtHsuL81ms2UpiiJMJhPMZjNMJpPlQURERGSroaEBfn5+
+lodOp4Ofnx8EQYBOJ9XPyEtBEKyWts9tOdvmiD4gIEB1g6sgJIoiRFG0BCAGISIiInLF399fNQjp
+dDoIgmAViFojCLFpjIiIiDSLQYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiINItBiIiI
+iDSLQYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiI
+NItBiIiIiDRLCAkJERE2Fk8lxaI7AOAI8hYVoM+TSYgNkXYSRREAcPbrHGRX3ocXHhoIURQhiiLM
+ZjOO/n0JNhdb73vu3LlWvxgiIiJq255//nn4+flZHjqdzrIUBAGCIECnk+ppBEGwWto+t+VsmyP6
+9PR0F7scwZaMAvSZlYQbHOwROe5ZzL/fjDPffISt5ofwiKFLswtCRERE1NocNI1VYec7eTgCAIeL
+cKDXLbgh1PXJzlQD0QO7ebJ8RERERF6jt/rX4TwsOgjEoBfGPHkTinL2o6bPAaDqAN7JKJD2ET/F
+X/7TdMiNE5MxbgAAlOJQ5TDEdgdgaq3iExEREbWcftGiRdIzw6OYgiL06jUGQDmAwUicXI333h2G
+R9IexmA47iNkMgHnv/0Kh2tq8FP2V0DInVi82IdXRUREROQG/VPp6Y2dpM9hX04v3HJXT/zypbTx
+7E/fA/dNwWCXpzmPowdrEJXwFMYE/xv/95nZm2UmIiIi8ghFH6HuGJE0CyMUfYF63DkLs+7s4fIk
+57/NQ2G1F0pHRERE5EV655uPIO+NT3FAucqqj9CN+E3yXagqDsPQG6vBeiAiIiJqT1wEoSFIfPFF
+POxiHqHrfz8eJdsOorgVCkxERETkKZxZmoiIiDTLRY1Q8xzOfxs/iSIQMsSTpyUiIiLyCn13h5vO
+YX/OSuysslltM48Qhv0Gz9x/PQBIo8b6m2Cq+c7zJSUiIiLyMJUaoSFITB8ifWdY0ouIRdP3h8lL
+s9lsM4+QCZEPzEd/kwkmE4DuN7feFRARERG1EPsIERERkWYxCBEREZFmMQgRERGRZjEIERERkWYx
+CBEREZFmMQgRERGRZjEIERERkWYxCBEREZFmMQgRERGRZjEIERERkWYxCBEREZFmMQgRERGRZjEI
+ERERkWYxCBEREZFmMQgRERGRZjEIERERkWbp6+vrVTeIomj3XF6azWbLUhRFmEwmmM1mmEwmy4OI
+iIjIVkNDA/z8/CwPnU4HPz8/CIIAnU6qn5GXgiBYLW2f23K2zRF9QECA6gZXQUgURYiiaAlADEJE
+RETkir+/v2oQ0ul0EATBKhC1RhBi0xgRERFpFoMQERERaRaDEBEREWkWgxARERFpFoMQERERaRaD
+EBEREWkWgxARERFpFoMQERERaRaDEBEREWkWgxARERFpFoMQERERaRaDEBEREWkWgxARERFpFoMQ
+ERERaRaDEBEREWkWgxARERFpFoMQERERaZbe+eaz2J+TjZ1V8r974r6k30Lc9A6+rGraSxTFxmdR
+eOjJMYjwQkGJiIiIPM1FEJIM+20aHh5yFHkZBZZ10ZOeR8IgEWazGSaTCeaab/HR38wI8VpRiYiI
+iDxLv2jRIpXVMZjy4sMY3JwznanAGfTyULGIiIiIvE+fnp6uuqGpuQs4sDEDBwAAPdFHudOZb/Dh
++7tQ3bhvVMJYdIMJpuMFICIiImrr9HmL8nBTeqLT2h+1pjEAQMjteCJ5uNQ01thEZjIBGDDam2Um
+IiIi8gi3+gipKd60GMWNz607S8ei+tOPgcWLr710RERERF6kL0IRihYVKVbFYIqLGiIAiI6JRnF5
+b/z348PR1aqzdDdEPDLLm2UmIiIi8gh9DGJUm8ZExXPVPkJD4zGqPBdHzgzHrcFA6f5C4MZp6AbA
+5P1yExEREV0zNyZU7InRs9OQlvYIoq3Wd8ft8WH4x5Zvcf7YNmypjMevbwv2UjGJiIiIPE+laUzS
+6765SLqzCj9XwXqkmNLgX+M3h7LwQV4o4h9/AMEwsTaIiIiI2g3HTWOiCBzehQPojRgHsySe278a
+fz1wI26MLkbh2o9h/v3vYOjq9TITEREReYTTUWNnq8vR874pwN8ykPEfAIhGTChQhcZRY8MmITk5
+EibTODxwfwk+W/42skPi8Ls7Klql8ERERETXQli8eLGotkE5oaL8XF6azWaIoghRVHzFhmUeIemx
+mMPniYiIyMbzzz8PPz8/y0On01mWgiBAEATodFIXZkEQrJa2z2052+YIv32eiIiINItBiIiIiDSL
+QYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiINItB
+iIiIiDSLQYiIiIg0i0GIiIiINItBiIiIiDSLQYiIiIg0i0GIiIiINItBiIiIiDRLX19fr7pBFEW7
+5/LSbDZblqIowmQywWw2w2QyWR5EREREthoaGuDn52d56HQ6+Pn5QRAE6HRS/Yy8FATBamn73Jaz
+bY7oAwICVDe4CkKiKEIURUsAYhAiIiIiV/z9/VWDkE6ngyAIVoGoNYIQm8aIiIhIsxiEiIiISLMY
+hIiIiEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhIsxiEiIiISLMYhIiIiEizGISIiIhIsxiE
+iIiISLMYhIiIiEizGISIiIhIsxiEiIiISLP03jrxmTNnvHVqIiIiIo/wWhAKCQnx1qmJiIiIPIJN
+Y0RERKRZLmqEzmJ/TjZ2Vsn/7on7kn4LcdM7+LKqaS9RFBufReGhJ8cgwgsFJSIiIvI0t5rGhv02
+DQ8POYq8jALLuuhJzyNhkAiz2QyTyQRzzbf46G9msEGMiIiI2gv9okWLVFbHYMqLD2Nwc850pgJn
+0MtDxSIiIiLyPn16errqhqbmLuDAxgwcAAD0RB/lTme+wYfv70J1475RCWPRDSaYjheAiIiIqK3T
+5y3Kw03piU5rf9SaxgAAIbfjieThUtNYYxOZyQRgwGhvlpmIiIjII1o8fL5402IUNz637iwdi+pP
+PwYWL7720hERERF5kb4IRShaVKRYFYMpLmqIACA6JhrF5b3x348PR1erztLdEPHILG+WmYiIiMgj
+9DGIUW0aExXPVfsIDY3HqPJcHDkzHLcGA6X7C4Ebp6EbAJP3y01ERER0zdxoGuuJ0bOTEBti20eo
+O26PD0PWlm8x6K5fsKUyHtPGBEPqJERERFpQXl6Os2fPoK6uzmqQTXskCAICAwPRo0cIevfu3aJz
+vL0byPsBKP4FuNzOPw47+wHRfYDEW4Cn7vF1abxHpWlM0uu+uUi6swo/V8F6pJjS4F/jN4ey8EFe
+KOIffwDBMLE2iIhIAxoaGlBaegz+/gGIiLgOQUFBEATB18W6JqIoora2FlVVVTh06CAiIwfC39/f
+rWNLq4FZ64EfyrxcyFZ02SRdzw9lUrh77zEgsqevS+V5jpvGRBE4vAsH0BsxDmZJPLd/Nf564Ebc
+GF2MwrUfw/z738HQ1etlJiIiHystPYaQkBCEh7es5qQtEgQBXbt2RdeuXVFRUY7S0mMYOvRGt47t
+aCHI1g9l0jV+Mc/XJfE8p01jZ6vL0fO+KcDfMpDxHwCIRkwoUIXGUWPDJiE5ORIm0zg8cH8JPlv+
+NrJD4vC7OypapfBERNT6ysvL4e8f0KFCkK3w8N64dKkO5eXlLpvJ3t7dsUOQ7Icy6Vo7WjOZsHjx
+YtVGXWVbr/xcXprNZoiiCFFUfMWGZR4h6bGYw+eJiDqkQ4cOIiLiOnTt2rGbAC5evIiyslMua4Ue
+WKGNIAQAt0Rce63Q888/Dz8/P8tDp9NZloIgQBAE6HTSd8LLza3KZldnTbAtaZ7lt88TEVGz1NXV
+ISgoyNfF8LqgoCDU1dW53K/4l1YoTBvREa+VQYiIiJpFFMV23zHaHYIguDUSrr2PDmuOjnitDEJE
+RESkWQxCREREpFkMQkRERKRZLf7SVSIiopZY/tZKfPfdD3br/f39kfzsPNxwQ5TqcdU1NXjr7Xfw
+9FNPomdoKJa/tRJ33P4rxN05AnV1dfhL1pt44P4xln/nvL8aUx/7L/QMDfX2JXlNYbK0jF+qvn3j
+TGn521Xqx35zHHgu1ztl6ygYhIiIqFXNf3ouNub+FQDw28m/QV1dHVa8lY34+LuQ/e4qnD171mr/
+Hj164KU/pgIABg0ciD++9CqSn52HqY/9F17/cyYA4NZbbrY6Juf91aivq2+Fq7l2G2cC8UOs163/
+F9A/BLghXPp3eYa0vNgApOUBn/5b+veyL4G3HpVCj6OwRM4xCBERUZvQMzQUd428E4AUkADgp58O
+Y/Wajyzbp/3+dwgMDMC2L7Zj/tNzMWf2TKxe8xH6X3ed5Tx7v94HAHjh+eRWvoKWkWtzlLU7G2cC
+vYOB3mnSukeGA68lAB9+3RSCAOCro8DTnwBLJwOp9wOZ21u37B0BgxAREflE/t+3If/v2wDA8p1e
+ERH98K9vvrXsU11Tg4CAAHQJDLSqRQKAjbl/tRz/8iuvAQDey/nAcuyTc+c7bWprS+4eLAWf5buA
+Nyc31RDJNUGy5DHSY/2/mpq8vjoKxP7F/nzdArxf7o6AQYiIiHwi4aHxVk1jgFTrU19Xj7q6OgQG
+BqKs7DRihkUjMDAQUUMG48O163D6558x/+m5VuewVV1Tg6wly1r1eq7FXYOAgT2Bt6ZIzV9LdgIz
+7pRqgEqqm2qDMrdLzWC9g4Hv04G+wcAVE7Bil3ptUH8H3xVKTRiEiIjIJ9RqhPr3l5q4Tp48hf79
+r0NJyTFMTJwAALjllpvx0h+vQ9aSZfjpp8O+KbQX3D0Y+N0dwLFqqUboj+Ol9Z31Uu2PTK4NAqRO
+0I+tbmoys9W3O9DNXwpM5ByDEBER+YRajVBgYCACAgPwo/E/lv3kcARINUZv/FlqBvvR+B+rMGVL
+Dldt3eRbgQA9cMFm/eWrwNKv1GuEm1F35gAAG6NJREFUXBk5UDreXy+FJWW/IrLGIERERG3K+Afu
+x+o1H6HoQLGlWUy29+t9+GL7TryQ8hyA9t80dvdg4PYBwL+OA5E9r+1cqfcDY28E7l8hnbPoZ2n9
+owxCTjEIERGRzyg7PBcfPITbbrsF85+ei18Nvw1FB4qR8NB4q/3Lyk4jJKSHJRy19xqhr45Kw97f
+nGwdhPoGS52dnTWNKcUPAW69TuorlHo/0CtIamYDpKY21go5xiBEREStSjmhYsJD47HyrWVY8VY2
+JiZOwA03RGFj7l+xY+eXCAwIQP7ft1lqfOrq6lB0oBgP3N+UDtp7jZDSDeFNnaV7dQWqaqWh8X27
+O28a66wHovs0jSLLSAS2/NgUfB4dDswfxSDkCIMQERG1KnnEl6yurs6y/NPCRTh79hz+/PqrAIDX
+/5xpGSV28uQpnD1ztl3PFO3MTxVS7dDdg6VJEo9USDVGjwx3fMygnkB1LZCcKwWmjETgu5PWs0lz
+0kXnWvRdY4IgeLocRESkYXX19Vi2/G2EhPTAm0sy0TM0FD1DQ7Ho9Vdx5sxZLH9rJX40/gc9QnpY
+dZ62OkdjkJrx37OR8vyLCAgIcLhvW/NcblNImXyrtFz2pfU+8UOkeYUG9gR+OS+ty9zeNIfQH8dL
+Icj26zbkSRe7BbjX0drXWjtjCAsXLhTVNoiiaPdcuRRFEWazGaIowmQyQRRFXL16FSaTCSaTCcuX
+L2+F4hMRUWv77rt/47bbnFRTdCDuXKs8+7NW2E7y2Fzz58+Hn58f/Pz8oNfrIQgC/Pz8IAgCdDod
+BEGwhCHbpe1zWy0JUfqAAPWpJ10FITkEmc1mSxDy8/OzBCEiIiIiW/7+/qpBSA5B8hJonSDUoqYx
+T7wwERERka8zhEeCEBEREVF7xCBERETNIgiCVfeJjkoURbdqKzr5tUJh2oiOeK0MQkRE1CwBAQGo
+ra31dTG8rra2Fo760SpFhbdCYdqIjnitDEJERNQswcHdUVVV5etieF1VVRWCg7u73G/cTa1QmDai
+I15ri4OQo57cvu70RERE3hUeHo76+jpUVJT7uiheU1FRjvr6OoSHu64CmTkSGNa3FQrlY8P6Stfq
+CbZ5QS1TtBbWCBERUbPodDr07389ampqUFpaiosXL3aIPkOiKOLixYsoLS1FTU0N+ve/Hjqd64/J
+AD2QObljh6FhfaVrDOiA30fRAS+JiIi8SafTwd/fH4MHD0FlZSVOnTqJ+vr6dh+GBEFAQEAAgoO7
+IyIiwjKnjStdO0lfdbF+JvDhXuCLIuBwBXClnU+p18lP6hP0QAzwRBzQSSdda0fj0SDky6otIiJq
+PfIEumFhYQgLC/N1cTxOnuTPXT38gbMNUmB4Is69Y3Tnz0L0D4Do77pDtq910knX6AltLSs0Kwg5
+GjLJvkFERNoiCAL0ej3MZrPlmwY6ArkWyJ2aICW9DugVCFy8AtRfBa6KgKtbYu7SFSHPPgFddQUu
+3z4SV24fiYbb4yAGdbuGK/AcQQD0gtQc5q2aIGf5obVyhdeaxsxmc7PfSERE1L60JDR0ZF07NSc0
+6IGcD4GZU9H5/f8F3v9fKX1E3wSMGAnEjgTi7gZCQr1Z5FZlNpt9XQQ7bgUhtZogOcU5Wl9dXd0h
+q0uJiIg8Rq8HVq0DZk4FvvxCqkY6YJQeq9+V9hkcJQWjO+KAu+4BerffXtnV1dUOa4GcrfcmhzG+
+OS+s1t535MiRaygWERGRRvzra+D6AY63Hz0MrF8DPPcksGZV65XLC5TZoCV9hTz9hauAB5rGbGuF
+5ET3zTffIC7OzR5jREREWnHlClD4JbBtK7D9M6Cm2r3jHp8JvPCyd8vmZd98841qzY8v+xl7pI+Q
+fFHKx4kTJ7B3716GISIiorpLQMF2KfwUfAFcvNC8438zBVi42DtlayV79+7FiRMnoNfr7TKDLzU7
+CMkFlr+MTq4Nsq3i0ul02LhxI0JCQnDjjTd6qrxERETtw/nzwPZ84LO/AbsLgIb6lp3n178BlmZ7
+tmyt7ODBg9i4cSP0eil2OPp2CnnZmuHI7SDkbOi8MgzJQw9FUYROp8N7772HyZMn46677vJcqYmI
+iNqiqkqp1uezrcDeQsB0jbMqPvAQsDwHaMcj8/75z38iNzcXfn5+lozg6Cs2bLVGIHIahAThHPbl
+rMTOSnlNT4ye9Qiw6R3srFSbIGEoJswfh+sV1V26k7vw0ENfYu6rj+PXsbGIiopCr169ONySiIg6
+hrKTwN+3SAHom30tO8etvwLi7wOM3wO7dkjr7rsfyFnnuXK2ErPZjKqqKhw+fBj79+/HyZMnrcKP
+2gNw3XnaW6FI76imR2nYIy8iccgR5L1RIM1xAGDYb9MwYbAIUZQe5up/YXWeGb0UNUJi6Xa8+8VR
+AMDKV1/F22qv0/1XSPz1jegKALiI4r/l4duzKvv16I7uZ8/hnN364Xj4Ifl4cubigXxs+V6+g90x
+fEICbuzmYLvNfXV1rMWFg8jf+m+E3PsYRka4X65/4F4kDFP8FMv2YP0/Si3/jHTzfM6uQbEXDv59
+C/4dci8ei3N90rK963H8ekev34xzle3B+n+csbp31vcVACJx72MjoXomq3tiu18Z9qz/B+St3W99
+2Pp+EnlJ2d71+McxR1u7I3IgUIpbG/9/lGHP+uMYoHzvXjiI/K01uNXq/XwRB//+DyC+8f/KhYPI
+LwTubUO/6/tePIfh5WW4rfwU+p8/2+zjfw7qhuKevXGwV28cCg1Hvf7/t3euUVFdZx//nXPGYBKF
+YQBBuc4YRASriJckivHyxuvrLY0mNWJqGmMuy2XSla6ut/mcth/6djWmXdbEVmOsTWKaeMlSa70l
+otEo8hojynVmuIhGBAbwloi8H2YGzsDcUBCU57fWLGb22fs5e2/OPud/nn3rA0Vl/DrvJBagMDyS
+dwyh3FyxovMzf5v4G+CsFzF60aP3Auk/gcTQneatIxjefvttL8FpLPrNPB7pSCZqL1BDNLgK1JD3
+TzYeaSbcBLWRM3hxYpxTMLlWIG0u+5IN+0oxZ6YR5lrFvCJnGycdSUzJnkBsZQ6bDtSSOXcyfLmV
+XEc9psnZzCWHTQdryZw7h9TQ2y53L6SS0/WZZGe7bjUVOWz64muMSyY4bz4VOew4ZWJK9lxigcrD
+m9hx1MiS8bGB0+rPciaPekXBpGoEXp2+kpxNB7ABYRmabjn7Rs6WR7IgO8t506s/y47tOykM9D/3
+WwZ9vNPkORQUk+Z/Cf36s+zYnosDhaQkH+UJ1haNnD1lR1HCUHV101hfj3HUAuakBbi9159lx1d1
+jJ6XTWooNJ7Zwdadhcyfk0o/Gjm74yvqRi0gO60fznrdwdfhS5gQ59+sINwpCRMWMLp2K5cz9Ndb
+I2d3HIAn5hBfvgN7nbN9NJ45Rd2oyWRpmvM+ctAl3RX46p92IInJSyYQSyO1DhNmo4YG0FhLPRFo
+mut3N5FYd5mRVeVkXKxgwJWODXauC3mQc5ExFERFczYihvq+D3oc1wBDUxOJ9bVYjRH8ZdxkmjVD
+t5Y3EN66t/Qft+AJJIL82b8bGN56662AHqH8Lb8jH4AIYlxhiqKg1H7D397bT7UrbOiC2RiVW9yy
+/ZuNBWksXTmSfk1NOE5uZt26Yzy66GnSQ8vZv24PpVh48oUXiHOdu7m5mYSRYzCWHufAplZPQO72
+rS3fbQc3tbzx5m7fRC5gnvI8E+NpsSH4Ip6JWbqfCaMYbfwM2/mJxMdBZZmNsFFPEe/qsowfMZqw
+rTaqsuKJDZC2hfp8TtaaMRutoKoBurQrObTxAMqUpUy1beSEol+dNpS0rLTWqMY0RltyOVFxlbR0
+34LBfxncNJL/f7WYLWFY8bMibn0+27YXkzz/KTj4GZe9lidIWwAVp8iNMGN21KDobKkKmMJDA3b/
+N1YU47CMJs3ojBg6fDTmvBNUNKYxLLSBGkcYyYluO/EMtsCJ+quoak95fxbuX1QUBY/r2h2GqqIq
+gKKiNp7jQJ6J0UtDnQvYJUxk6dKJzra29TKjl2a1tNPKnAPYLFOZqG8oEUZC7/KQCqW5mUdqLjGi
+qowRVeWEX78adNprfR6g0DSAgqgYCiJjuNg/zOO4t5KYay9xoV8Y7z42lSZDH98L/XUityM2fHmG
+9JOl9GLI/dE0LWAXWXeMFTJsfXsr6b+Zx2A/kZxdYyVs+90+zwOmsfzi12NausecHh8FxTKT182u
+34Ax8zmWsJlNn7zPUYDkGSyfFN8iXFr+aipK+DgWLUgLwv3ZwHefb6E64ANX8E4DNXVGosI1NK0C
+a6mRlJ+GtXo9ws2khJ/Aen4SCfH+0rrDGjnz5QkiRi8kMtdKdUCPUAKTli0DoKIMFNWfR6WRhlqI
+sIT5sRlcGRpP7+dE5FgWGo9jrVN9nzN8OE8tG+4sl+LOX5tcebXVyJmtWygcvJAFw91XcQVf7q9l
+7E/HUF16HFVz23KWS7F4r6uKQ+v5D0+yLMtIhdWBJTNBFy+BRx7Zx/GKawwf7vz+n++qGJ4V570u
+BKHL0FAVsO7fiGcPmZGxmoamKqCqVH13AmX0QhLaXpSaioLibBdA4+nP2ac+ybKsOGcbcK2/Z/mv
+SXfletZu3SLlUhU/OW9neFU5/X64EVS6m6pKqSmKogGDKIgaSJkxgmbdwzuYrIc2NfHnrOk0PRDS
+bZ6gYAWHr3E9gTxCPWnavBv3PDa/u8MpKB7fmoH8T39PPm29MKk89eYELn/wPl9e9jwW/ng2r73W
+v2Xs0Jr3d3ueJHkGyzNUUKA8Zz1Hi/zkOnwcz/w0CVVRUDUDhi7bMe3+peHUCaymoYw1GTCgeqlL
+zWf9eqZ1h+3leOR0XjRrnD7Zsf+LqigoqtYyrbIdZXkcr3uEaWaDn9H9QZTBcZq9uZFMfzEJ7dQJ
+FEX1fU582HDj05bWrjxlB/dSO/YZpppqOeBhyxnXum+D6wFiZNzCpxkepqsXVAwG73nQnydp8nKm
+H1zHhg0uO4sWttgRhK7FyIinlzPCx9GGcgVFUUmatBz14Do25EzjxUnhnP7XxxyrdUVSYO8GK842
+sJDlrms3afJylk/u+hI80HSToVUVDK+0MayqnL43fwyYphmoDI+gcMAgiqJjKY0YwE2ttYHejpDJ
+jzcDXbgJaCcQaGsMbx6etiIo0DihtucJJJjuVFAZznCGM2+f0QWl8UwAD5ECDEsfRv6FGF75xRjC
+gOaab1j3WTORihHLsjfJdI0Fcm+wVrr7T3x06nkWZ/Sn2TKd116b1s4jBPCzZ8G+/yjhjz7HMyPb
+j8Zttu1l7TcqmmZk5KKeM4jsXqLh1Cd8fDySmStGYgRAa30ja2m9zre8tp6Q9mkBx7fsOR7JzBVm
+NBq8pvOHpoKi+fAI2fexdk8Njz27CLNfe4HK0MC3+44ROWMFZg0aNAX8eqH81YM/W87rcqQu/3tq
+HmPxVCMa9W3y2D7u2i3/Qn12ET8JA/PUFaxwnc9bnbbW21W+3bKZS2NXsGKqK39b1vGvIYtZNKJn
+7GIt3Mc4vuWTj76mtt2BcFe7bW0f5qmLeWzLZg5WrGCq7tovO7CWIssKpiYClLFv7S7abdJkeozF
+C39CZ13RfX/4gWHnbQyvsDOkqpw+twJPc6/uF0pRdCzFrs+1Bx7wOH6/OWB9iR5/cX0JIcDDQ+TP
+M3S3PUWGNNJIf2s+g/14hM5s+S1OqRRJy1ZvQ59gyoVPKKwdy5jwZkqO7EdJfxmjotAM2Hb/kc/y
+W204zX/Anw+3MW6aQPbPRqAfA6spCnXHNrPWxyxExRTd4kYVOkI9pz7+B0ciZ/Hqq/p9bdzeFP2D
+VkVVTERHuMN8pbWz9+OjRM16xSVUXLZaHtp29q7ZSYuDz/Q4zz3j+f9WFecbY1tRYt+3hp3Vj7Pk
+1Wke8XGc4qPNR1pvvENm8cpU/2WoOPhPjkbN5hWL5vec7WlbHrDvC9KW4xQf/buG8YunYdTXjeZD
+JFqmMTtlDV/br5CR4VFD7fLgPm+UyYhWvpejynies7jbhJGMmeMp2G3nyijPuhaETseUwc9ezWj9
+bdvLml1FhD86mwyTRr1d3z6MDE4xUeC4gqbBqY93woxnMXpc3852O37xs4wI09k8pt7xfb/f9Wuk
+VVhJKyvFcrESLcC40sa+D1IcHUvJwHiKYmJxPOQ5aKM3PIOCFUO+vELu3x3xAAU6V2fT4oHzPo1e
+ASKZ+vJLjDMVs/W3rdPnwcjYSdH8/rNvGDLpAp9enMLLs8NaOtEGz/4Vb85yjR2qOcGG9RfJen0G
+SbpzNJfu4p0iEyaDoc1+ZWAa/zzPjZJbeOfhIG/zP6h+fCUrzW2PRRIdUcv39QYMEa6gOjvnaqIY
+H2HA4C+ttdgpcnatwaM3c9caiobOYeWTg5mxciUz/ORMU2nXNWb7z7scjVzKyule+nciMlmyMrNd
++XyXoYKCQoCdrCnUp9nJmsIhzFk5nSTfuXN6Y1q6pWwUB2nLYTtHLbUc2byGI7qYRZvXcO7xpTyX
+2b5smgpRkaY23YomIgbAOccVDIaWJwPFhSaixxkw1CqgqGgGXdeh5hys6hEmCF1NXR7/+CaapStn
+4L5SnWOEWtt3fV0tiknDYKilukZhgGZAU6HIdQ8Z8t9zXJ5TXVew5uUaD5KwxnrSy0oZVlZC/PdV
++Hus3jD0wRYTS+nAeEoGxnHRGOFxXNpSK8F0Y+m9Qf6my3ekG8xfPm4XL11jTiKnvMZLj1Zz4RKt
+M8Xw/KIkz2Phud/x108jmPrSXIxKc8vWG604yN3xJcrEFxmsG9V869YtFNX5puBedwic3WSqAjWH
+P+Ddtt4jD1KYt2qG66FjY/c722DuKmaYoT73Q9afTWfZkgxC6/L48IPvSH8+mwyjP3v3OdZj5DCR
+ZYNVLzMRwskcn8I72/eQ6qpT24kcalLnYVFV/2kHz2TVqpm6gHryNq3n4njn/yIYVAVQtdZZV3V5
+HD6XQtaq8A7MmvBXhiQsq1bhkcvcD1l/OYtV03xLICcaKvoZMRZm+rXlLP93qcvIHpPNqjF6WzZ2
+v3OI6JZr0UZeromMTJfgt+5mx7kU5k131rNtzztsYx6rpiVhGTeRwx98walkZ9r63MMURqQz3qSi
+mlJJ+WIbx+yZrjqvJ29nDqQuI1xmEghdivN6/6rNnqEb381xfTORkgoohex5dwcFgPPeHY5aZ6Oa
+GqqtjWQpkDLXfc+wsZsacj58lxy90YgYNNXb/as9UXWXGWYvIdVezMCaap/xmhSFiqiBlA6Kp2Rg
+PJUDBnJL9/yS1uMfX2v/6GfQBvIU+RNBXT02yE1L15h7zSAPr1DxQc4QTZrJWw6g7uh7bPluGMPS
+89n/3vvw0nLGhLfuQ+b45u+sPVhN6lO/YplF5wlqbkbTNEqLCjBFTvCoNKcQUojIeoGlo314hOpO
+snHDRefDyZUZRXG+MaiqrrJV1dVt4RZcd1hb9zKKglJziA2rD3mGp87j9elmGDyLF7I2sn71alf4
+fN6Ybg4ureeJOlzfbfuRURQUpZDtqws9I0ZMZFn2KHyOAfZXhkDn9J27gOXxtNW+X9y3LYXvD29g
+dYvgT2H+GzMx6+3ismPK5Pl53/Onjas55KqLF5a668LCrDfms+tPq1ntNpU6n9fH9GblL9wdjGQu
+fYMW/2ztSTZ+AfN07dRxYiOFl1OZ9cYsZulSOkrPUDtsKCmHN7AdhZQhrS8bs954wyNuMAyqvkiq
+rZhUezERjvYjltxcNEVROige66AEbDGx/Gjo43G8Nz8mgiGQ98abONJPq9eH9ZRZY8qE8AnNvoSQ
+4+h7fMwzTLn0Fz45Dc6FFp/gsnvbjfSF/M+cR1xpStj++y3kR07h5SeqWPNpPqQ/za9nD26x21xz
+nL+vO0Dry0MqT705G3ObLrnSXf/L5/kEYCjzfzkLyx1WgCAIgnCHlOzkj9vOOb+nzueXM1vvzI7j
+G/hb9USPMHCQ+8HnMPfnZIa74hyqCXgaU9Yv+PkYp8RSmptJuFhJSmkRQ+3FhPlY4LCufyjWQQlY
+YxMpHZTAtTYLGQodJ9C4obbfvR0L5P0JRiR1lpBS/vCHP7QbLRbMwoRt4/j6HWx4R84tCIIg9D7U
+pibM58tIsRYyxFbMw9evtYtzNaQvtkEJ2OISscYmUhcqntGuIpgZZB0JD2S3o3GC5bbHfrUdXO3O
+lH4n+rboxw+1Te8vnSAIgtA76XPzRyxlVlKshSSXlRLSZoHDHzUD5QPjsMUlYY1N5GJElG5SD34H
+RwudQ7DjfIIRPN2hAbwKIe8zyIKL508g+Sugr2PiIRIEQehdhNy4QbK9iJTSIizlVgxNN1uO3VIU
+qgYMxBqbiD0uiYroQdzSrSshwqfruF1PzZ2E3W4+OoJPj9CdiiHAr8dIH6bHly1BEATh/uWhq1dI
+sRUxpKSAxPNlqK7FeAGqwyOxxSVii0ukLDaRH/p4LmQoT4nu4XZmdd3pekFdoQk6ZVkEX6LJn0gC
+794eET6CIAi9g9AGBymlhQwpKSD2QkWLoGl4uD+2uCTscYlY481cfehhj3TylOi53E7PT3c/9/0K
+IW9enI7G9Sd8pDtMEAShdxFRU+0c7FxaQPSliwBcDwmhyJyMPd6MLS6JGqO3NVuEnkRneHA6IoC6
+Uix1+kKZ/sRTIG+Qt3iCIAjCvU3MpQskF59jSGkBEXU13NQ0KgfG8dVjk7DHJXEhKsZjp3Z5Atzb
+3K2FEDuLoIRQsOOF2qYB34InmPFBgiAIwr2H0txMbFU5Q0qcnp/+jfVciIqhyDyEvfFmKgfFeezU
+Lty73A2vTlcLp6CvxI50k3lLF0zanqYSBUEQhOBQm5pIrLCRXHKOZGsR1x8IwR5v5kDWk9jjkrgR
+EuIRX+72vYM7ea7fLU1wVyX57YopQRAEoefR5+aPmO2lJJecI+b7Ki4MGIg93syRcRNpfLh/d2dP
+6EbuJcdGh4VQZ4gZ6RYTBEG4Nwm5cYPB1kISy20Ymm5yflAcx0Y/TrUpqruzJnQTnS167raI6rSV
+pe+Ue0k9CoIg9CYeunoFi72Eh680gKJQPiiBf6ek06zfRLMb8yfcP/SYlaWDRbq6BEEQ7k/6Nzgw
+OuoI+fEGNzUDBcmp7XZqF4TOojudIZ22oKIbEUWCIAj3Lg9eu0rIDze4HtKX8rjE7s6OcB/TU3qC
+umQdIRFDgiAI9ybXHnyIaw8+1N3ZEO5zeooIgi6aNSYeIkEQBEEQ9PQk8aOny6fPty24CCNBEARB
+uP/pqcKnLXd9aU8RRoIgCIJw/3GvCJ+2GK5fv97deRAEQRAEQegWDH379u3uPAiCIAiCIHQLauAo
+giAIgiAI9ycihARBEARB6LWIEBIEQRAEodciQkgQBEEQhF6LCCFBEARBEHotIoQEQRAEQei1iBAS
+BEEQBKHXIkJIEARBEIReiwghQRAEQRB6LSKEBEEQBEHotfw/u+uTBtmdJeoAAAAASUVORK5CYII="/>
\ No newline at end of file
diff --git a/src/views/sjjTender/DocumentTasks/index.vue b/src/views/sjjTender/DocumentTasks/index.vue
new file mode 100644
index 0000000..663f324
--- /dev/null
+++ b/src/views/sjjTender/DocumentTasks/index.vue
@@ -0,0 +1,206 @@
+<template>
+  <PageWrapper dense>
+    <BasicTable @register="registerTable">
+      <template #toolbar>
+        <!-- <a-button
+          @click="downloadExcel(SjjDocumentTasksExport, '审计局标书任务数据', getForm().getFieldsValue())"
+          v-auth="'productManagement:SjjDocumentTasks:export'"
+          >导出</a-button
+        >
+        <a-button
+          type="primary"
+          danger
+          @click="multipleRemove(SjjDocumentTasksRemove)"
+          :disabled="!selected"
+          v-auth="'productManagement:SjjDocumentTasks:remove'"
+          >删除</a-button
+        > -->
+        <a-button
+          type="primary"
+          @click="handleAdd"
+          v-auth="'productManagement:SjjDocumentTasks:add'"
+          >新增</a-button
+        >
+      </template>
+      <template #bodyCell="{ column, record }">
+        <template v-if="column.key === 'action'">
+          <TableAction
+          stopButtonPropagation
+              :actions="[
+                {
+                  label: '详情',
+                  icon: IconEnum.EDIT,
+                  type: 'primary',
+                  ghost: true,
+                  ifShow: () => {
+                    if (
+                      record.progressStatus != 'PENDING' &&
+                      record.progressStatus != 'STARTED' &&
+                      record.progressStatus != 'REVOKED'
+                    ) {
+                      return true;
+                    } else {
+                      return false;
+                    }
+                  },
+                  onClick: handleDetail.bind(null, record),
+                },
+                {
+                  label: '删除',
+                  icon: IconEnum.DELETE,
+                  type: 'primary',
+                  ifShow: () => {
+                    return record.deleteFlag == 'N';
+                  },
+                  danger: true,
+                  ghost: true,
+                  popConfirm: {
+                  placement: 'left',
+                  title: `是否删除文件?`,
+                  confirm: handleDeleteOss.bind(null, record),
+                },
+                },
+                {
+                  label: '下载',
+                  icon: IconEnum.DOWNLOAD,
+                  type: 'primary',
+                  color: 'success',
+                  ghost: true,
+                  ifShow: () => {
+                    if (
+                      record.progressStatus != 'PENDING' &&
+                      record.progressStatus != 'STARTED' &&
+                      record.progressStatus != 'REVOKED'
+                    ) {
+                      return true;
+                    } else {
+                      return false;
+                    }
+                  },
+                  onClick: handleDownload.bind(null, record),
+                },
+            ]"
+          />
+        </template>
+      </template>
+    </BasicTable>
+    <SjjDocumentTasksModal @register="registerModal" @reload="reload" />
+    <DocsDrawer @register="registerDrawer" />
+  </PageWrapper>
+</template>
+
+<script setup lang="ts">
+  import { PageWrapper } from '@/components/Page';
+  import { BasicTable, useTable, TableAction } from '@/components/Table';
+  import { SjjDocumentTasksList, SjjDocumentTasksExport, SjjDocumentTasksRemove,SjjDocumentTasksOssRemoveById } from '@/api/documentReview/SjjDocumentTasks';
+  import { downloadExcel } from '@/utils/file/download';
+  import { useModal } from '@/components/Modal';
+  import SjjDocumentTasksModal from './SjjDocumentTasksModal.vue';
+  import { formSchemas, columns } from './SjjDocumentTasks.data';
+  import { IconEnum } from '@/enums/appEnum';
+  import {
+    DocumentTaskResultsInfoByTaskId,
+    DocumentTaskResultDownload,
+  } from '@/api/documentReview/DocumentTaskResults';
+  import { useDrawer } from '@/components/Drawer';
+  import DocsDrawer from '@/views/documentReview/DocumentTasks/DocsDrawer.vue';
+  import {ossRemove } from '@/api/system/oss';
+
+  const [registerDrawer, { openDrawer }] = useDrawer();
+  defineOptions({ name: 'SjjDocumentTasks' });
+
+  const [registerTable, { reload, multipleRemove, selected, getForm }] = useTable({
+    rowSelection: {
+      type: 'checkbox',
+    },
+    title: '审计局标书任务列表',
+    api: SjjDocumentTasksList,
+    showIndexColumn: false,
+    rowKey: 'id',
+    useSearchForm: true,
+    formConfig: {
+      schemas: formSchemas,
+      baseColProps: {
+        xs: 24,
+        sm: 24,
+        md: 24,
+        lg: 6,
+      },
+    },
+    columns: columns,
+    actionColumn: {
+      width: 200,
+      title: '操作',
+      key: 'action',
+      fixed: 'right',
+    },
+  });
+
+  const [registerModal, { openModal }] = useModal();
+
+  function handleEdit(record: Recordable) {
+    openModal(true, { record, update: true });
+  }
+
+  function handleAdd() {
+    openModal(true, { update: false });
+  }
+
+  async function handleDelete(record: Recordable) {
+    await SjjDocumentTasksRemove([record.id]);
+    await reload();
+  }
+  async function handleDownload(record: Recordable) {
+    if (record.childrenTasks?.length > 1) {
+      await DocumentTaskResultDownload(record.childrenTasks.map((item) => item.id));
+    } else if (record.childrenTasks?.length == 1) {
+      await DocumentTaskResultDownload([record.childrenTasks[0].id]);
+      
+    } else {
+      await DocumentTaskResultDownload([record.id]);
+    }
+  }
+  async function handleDeleteOss(record: Recordable) {
+    await SjjDocumentTasksOssRemoveById([record.id]);
+    await reload();
+  }
+  async function handleDetail(record: Recordable) {
+    try {
+      let res = await DocumentTaskResultsInfoByTaskId(record.id);
+      if (record.taskName == 'schemEvaluation') {
+        // res.result=generateTable(JSON.parse(res.result as string))
+        const updatedHtmlText = res.result?.replace(
+          /文件名称：\S+/g,
+          `文件名称：${record.documentName}`,
+        );
+
+        openDrawer(true, { value: cleanHtml(updatedHtmlText), type: 'markdown' });
+      } else if (record.taskName == 'checkDocumentError') {
+        openDrawer(true, { value: res.result, type: 'markdown' });
+      } else {
+        openDrawer(true, { value: res.result, type: 'markdown' });
+      }
+      console.log('res', res);
+    } catch (ex) {
+      openDrawer(true, { value: '加载失败，请刷新页面', type: 'markdown' });
+    }
+    //根据record.id查询结果详情
+  }
+  const cleanHtml = (content) => {
+    // 移除DOCTYPE和html标签
+    content = content.replace(/<!DOCTYPE[^>]*>/i, '');
+    content = content.replace(/<html[^>]*>/i, '');
+    content = content.replace(/<\/html>/i, '');
+
+    // 移除head部分
+    content = content.replace(/<head>[\s\S]*?<\/head>/i, '');
+
+    // 移除body标签
+    content = content.replace(/<body[^>]*>/i, '');
+    content = content.replace(/<\/body>/i, '');
+
+    return content.trim();
+  };
+</script>
+
+<style scoped></style>