diff --git a/src/main/recorder.js b/src/main/recorder.js
index a7370f9..a61712e 100644
--- a/src/main/recorder.js
+++ b/src/main/recorder.js
@@ -14,6 +14,14 @@ class ScreenRecorder {
     this.mainWindow = window;
   }
 
+  // 重置录制状态（用于前端初始化时清理可能的僵尸状态）
+  resetRecording() {
+    this.isRecording = false;
+    this.recordedChunks = [];
+    console.log('Recording state reset by renderer');
+    return { success: true, message: 'State reset' };
+  }
+
   async startRecording() {
     if (this.isRecording) {
       return { success: false, message: '正在录制中' };
@@ -33,11 +41,11 @@ class ScreenRecorder {
       // 发送源ID到渲染进程
       const sourceId = sources[0].id;
       this.isRecording = true;
-      
-      return { 
-        success: true, 
+
+      return {
+        success: true,
         sourceId: sourceId,
-        message: '开始录制' 
+        message: '开始录制'
       };
     } catch (error) {
       console.error('启动录制失败:', error);
@@ -45,19 +53,30 @@ class ScreenRecorder {
     }
   }
 
-  async stopRecording(videoData, taskId = '') {
+  async stopRecording(videoData, taskId = '', customPath = null) {
     if (!this.isRecording) {
       return { success: false, message: '当前没有进行录制' };
     }
 
     try {
       this.isRecording = false;
-      
-      // 确保videos目录存在 - 在应用根目录下
-      const appPath = process.env.NODE_ENV === 'development' 
-        ? path.join(__dirname, '../../') 
+
+      // 获取应用根目录
+      const appPath = process.env.NODE_ENV === 'development'
+        ? path.join(__dirname, '../../')
         : path.dirname(app.getPath('exe'));
-      const videosDir = path.join(appPath, 'videos');
+
+      let videosDir;
+      if (customPath) {
+        // 如果是绝对路径直接使用，否则拼接应用根目录
+        videosDir = path.isAbsolute(customPath)
+          ? customPath
+          : path.join(appPath, customPath);
+      } else {
+        // 默认目录：应用根目录/videos
+        videosDir = path.join(appPath, 'videos');
+      }
+
       if (!fs.existsSync(videosDir)) {
         fs.mkdirSync(videosDir, { recursive: true });
       }
@@ -71,9 +90,9 @@ class ScreenRecorder {
       const minutes = String(now.getMinutes()).padStart(2, '0');
       const seconds = String(now.getSeconds()).padStart(2, '0');
       const dateTimeStr = `${year}${month}${day}_${hours}${minutes}${seconds}`;
-      
+
       // 如果有任务ID，使用任务ID_日期时间，否则使用日期时间
-      const fileName = taskId 
+      const fileName = taskId
         ? `${taskId}_${dateTimeStr}.webm`
         : `${dateTimeStr}.webm`;
       const filePath = path.join(videosDir, fileName);
@@ -83,12 +102,12 @@ class ScreenRecorder {
       fs.writeFileSync(filePath, buffer);
 
       console.log('视频已保存到:', filePath);
-      
-      return { 
-        success: true, 
+
+      return {
+        success: true,
         filePath: filePath,
         fileName: fileName,
-        message: '录制已保存' 
+        message: '录制已保存'
       };
     } catch (error) {
       console.error('停止录制失败:', error);
@@ -98,8 +117,8 @@ class ScreenRecorder {
 
   // 获取videos目录路径
   getVideosPath() {
-    const appPath = process.env.NODE_ENV === 'development' 
-      ? path.join(__dirname, '../../') 
+    const appPath = process.env.NODE_ENV === 'development'
+      ? path.join(__dirname, '../../')
       : path.dirname(app.getPath('exe'));
     return path.join(appPath, 'videos');
   }
@@ -113,14 +132,18 @@ ipcMain.handle('start-recording', async () => {
   return await recorder.startRecording();
 });
 
-ipcMain.handle('stop-recording', async (event, videoData, taskId) => {
-  return await recorder.stopRecording(videoData, taskId);
+ipcMain.handle('stop-recording', async (event, videoData, taskId, customPath) => {
+  return await recorder.stopRecording(videoData, taskId, customPath);
 });
 
 ipcMain.handle('get-videos-path', () => {
   return recorder.getVideosPath();
 });
 
+ipcMain.handle('reset-recording', async () => {
+  return recorder.resetRecording();
+});
+
 // 使用全局变量方式，避免webpack模块转换问题
 global.ScreenRecorderInstance = recorder;
 global.setMainWindow = (window) => recorder.setMainWindow(window);
diff --git a/src/renderer/components/dispose.vue b/src/renderer/components/dispose.vue
index 2cf2eda..fd631ff 100644
--- a/src/renderer/components/dispose.vue
+++ b/src/renderer/components/dispose.vue
@@ -125,11 +125,11 @@ export default {
   methods: {
     // 获取配置
     getConfig() {
-      this.$axios.get('/admin/get_config')
+      this.$axios.get('/web/get_config')
         .then(res => {
           if (res && res.data) {
             // 合并数据，确保所有字段都存在
-            this.iniData = { ...this.iniData, ...res.data };
+            this.iniData = { ...this.iniData, ...res.data.data };
           } else {
             this.$message.error(this.$t("dispose.errorRead"));
           }
@@ -139,23 +139,23 @@ export default {
           this.$message.error(this.$t("dispose.errorRead"));
         });
     },
-    // 保存配置
     save() {
-      this.$axios.post('/admin/get_config', this.iniData)
+      // 构造 query string
+      let params = [];
+      for (let key in this.iniData) {
+        if (this.iniData.hasOwnProperty(key)) {
+          // 使用 encodeURIComponent 确保特殊字符正确传输
+          params.push(`${key}=${encodeURIComponent(this.iniData[key])}`);
+        }
+      }
+      const queryString = params.join('&');
+
+      this.$axios.post(`/web/update_config?${queryString}`)
         .then(res => {
-          if (res && (res.data === "success" || res.status === 200)) {
-            this.$message({
-              type: "success",
-              message: this.$t("dispose.successReserve"),
-            });
-          } else {
-            // 某些接口可能返回 { ret: 0 } 或其他形式，视具体情况而定
-            // 这里假设200 OK即为成功，或者根据res.data判断
-            this.$message({
-              type: "success",
-              message: this.$t("dispose.successReserve"),
-            });
-          }
+          this.$message({
+            type: "success",
+            message: this.$t("dispose.successReserve"),
+          });
         })
         .catch(err => {
           console.error(err);
diff --git a/src/renderer/components/recorder/ScreenRecorder.vue b/src/renderer/components/recorder/ScreenRecorder.vue
index b7fa8b2..e7938e7 100644
--- a/src/renderer/components/recorder/ScreenRecorder.vue
+++ b/src/renderer/components/recorder/ScreenRecorder.vue
@@ -3,7 +3,7 @@
     <template v-if="!statusOnly">
       <el-tooltip :content="isRecording ? $t('recorder.stopRecording') : $t('recorder.startRecording')" placement="top">
         <el-button size="medium" :type="isRecording ? 'danger' : 'primary'"
-          :icon="isRecording ? 'el-icon-video-pause' : 'el-icon-video-camera'" circle @click="toggleRecording"
+          :icon="isRecording ? 'el-icon-switch-button' : 'el-icon-video-camera'" circle @click="toggleRecording"
           :loading="loading" class="record-btn">
         </el-button>
       </el-tooltip>
@@ -43,7 +43,9 @@ export default {
       timer: null,
       stream: null,
       currentTaskId: '', // 录屏开始时的任务ID
-      autoSave: true // 是否在停止时保存
+      autoSave: true, // 是否在停止时保存
+      videoPath: '', // 录制视频的绝对路径
+      customSavePath: '' // 存储启动时传入的保存路径
     };
   },
   methods: {
@@ -86,6 +88,7 @@ export default {
 
         this.stream = stream;
         this.recordedChunks = [];
+        this.customSavePath = options.savePath || ''; // 保存自定义路径
 
         // 创建MediaRecorder
         this.mediaRecorder = new MediaRecorder(stream, {
@@ -100,7 +103,7 @@ export default {
 
         this.mediaRecorder.onstop = async () => {
           if (this.autoSave) {
-            await this.saveRecording(options.savePath);
+            await this.saveRecording(this.customSavePath); // 使用保存的路径
           }
           this.recordedChunks = [];
         };
@@ -130,7 +133,22 @@ export default {
 
       try {
         if (this.mediaRecorder && this.mediaRecorder.state !== 'inactive') {
-          this.mediaRecorder.stop();
+          // 创建 Promise 等待 onstop 回调完成
+          await new Promise((resolve) => {
+            // 保存原有的 onstop 处理器
+            const originalOnStop = this.mediaRecorder.onstop;
+
+            // 包装 onstop，在原处理器完成后 resolve
+            this.mediaRecorder.onstop = async (event) => {
+              if (originalOnStop) {
+                await originalOnStop.call(this, event);
+              }
+              resolve();
+            };
+
+            // 触发 stop 事件
+            this.mediaRecorder.stop();
+          });
         }
 
         // 停止所有轨道
@@ -161,33 +179,47 @@ export default {
         return;
       }
 
-      try {
-        // 将录制的数据块合并为Blob
-        const blob = new Blob(this.recordedChunks, {
-          type: 'video/webm'
-        });
+      return new Promise((resolve, reject) => {
+        try {
+          // 将录制的数据块合并为Blob
+          const blob = new Blob(this.recordedChunks, {
+            type: 'video/webm'
+          });
 
-        // 转换为base64
-        const reader = new FileReader();
-        reader.onloadend = async () => {
-          const base64data = reader.result;
+          // 转换为base64
+          const reader = new FileReader();
+          reader.onloadend = async () => {
+            if (this._isDestroyed) return;
+            try {
+              const base64data = reader.result;
 
-          // 发送到主进程保存，传递任务ID和可选路径
-          const result = await ipcRenderer.invoke('stop-recording', base64data, this.currentTaskId, customPath);
+              // 发送到主进程保存，传递任务ID和可选路径
+              const result = await ipcRenderer.invoke('stop-recording', base64data, this.currentTaskId, customPath);
 
-          if (result.success) {
-            this.$message.success(this.$t('recorder.savedSuccess') + `: ${result.fileName}`);
-            this.$emit('recording-saved', result);
-          } else {
-            this.$message.error(result.message);
-          }
-        };
-        reader.readAsDataURL(blob);
+              if (this._isDestroyed) return;
 
-      } catch (error) {
-        console.error('保存录制失败:', error);
-        this.$message.error(this.$t('recorder.saveFailed'));
-      }
+              if (result.success) {
+                this.$message.success(this.$t('recorder.savedSuccess') + `: ${result.fileName}`);
+                this.videoPath = result.filePath; // 保存视频绝对路径供外部使用
+                this.$emit('recording-saved', result);
+                resolve(result);
+              } else {
+                this.$message.error(result.message);
+                reject(new Error(result.message));
+              }
+            } catch (err) {
+              reject(err);
+            }
+          };
+          reader.onerror = reject;
+          reader.readAsDataURL(blob);
+
+        } catch (error) {
+          console.error('保存录制失败:', error);
+          this.$message.error(this.$t('recorder.saveFailed'));
+          reject(error);
+        }
+      });
     },
 
     startTimer() {
diff --git a/src/renderer/components/work/AdvancedSettings.vue b/src/renderer/components/work/AdvancedSettings.vue
index cfcc11a..533ad8b 100644
--- a/src/renderer/components/work/AdvancedSettings.vue
+++ b/src/renderer/components/work/AdvancedSettings.vue
@@ -17,13 +17,6 @@
 
             </el-form>
         </div>
-        <span slot="footer" class="dialog-footer grand-footer">
-            <div class="footer-buttons">
-                <el-button @click="handleClose" size="medium" icon="el-icon-close">{{ $t('common.cancel') }}</el-button>
-                <el-button type="primary" @click="handleSave" size="medium" icon="el-icon-check">{{ $t('common.confirm')
-                    }}</el-button>
-            </div>
-        </span>
     </el-dialog>
 </template>
 
@@ -81,8 +74,8 @@ export default {
         },
         handleSave() {
             // 验证加密狗计数
-            if (this.form.is_dongle_count) {
-                if (!this.form.dongle_count || this.form.dongle_count <= 0 || !Number.isInteger(this.form.dongle_count)) {
+            if (this.form.enable_dongle_counter) {
+                if (!this.form.install_dongle_count || this.form.install_dongle_count < 0 || !Number.isInteger(this.form.install_dongle_count)) {
                     this.$message.warning(this.$t('work.dongleCountRequired'))
                     return
                 }
diff --git a/src/renderer/components/work/TagMetadata.vue b/src/renderer/components/work/TagMetadata.vue
index d4cff12..555715f 100644
--- a/src/renderer/components/work/TagMetadata.vue
+++ b/src/renderer/components/work/TagMetadata.vue
@@ -45,39 +45,63 @@
             <div class="sub-title">
                 <i class="el-icon-edit-outline"></i>
                 <span>{{ $t('work.metadataEdit') }}</span>
+                <span class="field-count" v-if="tableData && tableData.length > 0">({{ tableData.length }})</span>
             </div>
-            <el-table v-if="tableData && tableData.length > 0" :data="tableData" class="metadata-table flex-grow-table"
-                :empty-text="$t('work.nodata')" :show-header="false">
 
-                <el-table-column prop="name" min-width="110"></el-table-column>
-                <el-table-column min-width="240">
-                    <template slot-scope="scope">
-                        <div v-if="scope.row.type == 1">
-                            <input type="file" title="" accept="image/*" :ref="scope.row.origin_name"
-                                :data-name="scope.row.origin_name"
-                                @change="(e) => $emit('image-change', scope.row.origin_name, e.target.files[0])" />
+            <!-- 卡片式布局替代表格 -->
+            <div v-if="tableData && tableData.length > 0" class="metadata-fields-list">
+                <div v-for="(item, index) in tableData" :key="index" class="field-item"
+                    :class="{ 'field-disabled': csvIsExist && (item.type == 3 || item.type == 4 || item.type == 5) }">
+
+                    <!-- 左侧：字段名称区域 -->
+                    <div class="field-label-area">
+                        <div class="field-info">
+                            <div class="field-name-row">
+                                <span class="field-name" :title="item.name">{{ item.name }}</span>
+                                <span v-if="item.sideLabel" class="side-badge"
+                                    :class="{ 'side-front': item.sideLabel.includes('正'), 'side-back': item.sideLabel.includes('背') }">
+                                    {{ item.sideLabel.replace('[', '').replace(']', '') }}
+                                </span>
+                            </div>
                         </div>
-                        <div v-else-if="scope.row.type == 3 || scope.row.type == 4 || scope.row.type == 5">
-                            <el-input v-model="form[scope.row.origin_name]" clearable size="mini"
-                                :disabled="csvIsExist" />
+                    </div>
+
+                    <!-- 右侧：输入区域 -->
+                    <div class="field-input-area">
+                        <!-- 图片类型 -->
+                        <div v-if="item.type == 1" class="image-upload-wrapper">
+                            <label :for="'upload-' + item.origin_name" class="upload-label">
+                                <i class="el-icon-picture-outline"></i>
+                                <span>{{ $t('work.selectImage') }}</span>
+                            </label>
+                            <input :id="'upload-' + item.origin_name" type="file" accept="image/*"
+                                :ref="item.origin_name" :data-name="item.origin_name" class="hidden-file-input"
+                                @change="(e) => $emit('image-change', item.origin_name, e.target.files[0])" />
                         </div>
-                        <div v-else>{{ scope.row.origin_name }}</div>
-                    </template>
-                </el-table-column>
-                <el-table-column min-width="90">
-                    <template slot-scope="scope">
-                        <div v-if="scope.row.type == 3 || scope.row.type == 4 || scope.row.type == 5">
-                            <el-button size="mini" icon="el-icon-upload2" @click="$emit('open-csv')">
-                                {{ file_name ? file_name : $t('work.binfile') }}
+
+                        <!-- 文本/条码类型 -->
+                        <div v-else-if="item.type == 3 || item.type == 4 || item.type == 5" class="text-input-wrapper">
+                            <el-input v-model="form[item.origin_name]" :placeholder="$t('work.pleaseInput')" clearable
+                                size="small" :disabled="csvIsExist" class="modern-input" />
+                            <el-button size="small" icon="el-icon-upload2" @click="$emit('open-csv')"
+                                class="csv-import-btn" :title="$t('work.binfile')">
+                                <span class="btn-text">{{ file_name || $t('work.binfile') }}</span>
                             </el-button>
                         </div>
-                    </template>
-                </el-table-column>
-            </el-table>
+
+                        <!-- 其他类型 -->
+                        <div v-else class="field-value-display">
+                            {{ item.origin_name }}
+                        </div>
+                    </div>
+                </div>
+            </div>
 
             <!-- 空状态占位框 (当无数据时显示) -->
-            <div v-else class="empty-placeholder-box">
-                <span class="empty-text">{{ $t('work.nodata') }}</span>
+            <div v-else class="empty-state-modern">
+                <i class="el-icon-document"></i>
+                <p class="empty-title">{{ $t('work.noTemplate') }}</p>
+                <p class="empty-hint">{{ $t('work.selectTemplateHint') }}</p>
             </div>
         </div>
     </div>
@@ -150,4 +174,235 @@ export default {
 .template-select {
     width: 240px;
 }
+
+/* ================== 现代化卡片式字段列表 ================== */
+.metadata-fields-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 4px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+/* 字段项卡片 */
+.field-item {
+    background: #ffffff;
+    border: 1px solid #e5e7eb;
+    border-radius: 10px;
+    padding: 14px 16px;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.05);
+}
+
+.field-item:hover {
+    border-color: #cbd5e1;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.08);
+    transform: translateY(-1px);
+}
+
+.field-disabled {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* 左侧：字段名称区域 */
+.field-label-area {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    min-width: 180px;
+    flex-shrink: 0;
+}
+
+.field-info {
+    flex: 1;
+    min-width: 0;
+}
+
+.field-name {
+    font-size: 14px;
+    font-weight: 600;
+    color: #1f2937;
+    margin-bottom: 2px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.field-name-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.side-badge {
+    font-size: 11px;
+    padding: 1px 6px;
+    border-radius: 4px;
+    font-weight: 500;
+}
+
+.side-front {
+    background-color: #e0f2fe;
+    color: #0369a1;
+    border: 1px solid #bae6fd;
+}
+
+.side-back {
+    background-color: #fce7f3;
+    color: #be185d;
+    border: 1px solid #fbcfe8;
+}
+
+/* 右侧：输入区域 */
+.field-input-area {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+/* 图片上传样式 */
+.image-upload-wrapper {
+    width: 100%;
+}
+
+.upload-label {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 7px 14px;
+    background: linear-gradient(135deg, #f3f4f6 0%, #e5e7eb 100%);
+    border: 1px solid #d1d5db;
+    border-radius: 8px;
+    cursor: pointer;
+    font-size: 13px;
+    color: #4b5563;
+    font-weight: 500;
+    transition: all 0.2s;
+}
+
+.upload-label:hover {
+    background: linear-gradient(135deg, #e5e7eb 0%, #d1d5db 100%);
+    border-color: #9ca3af;
+    transform: translateY(-1px);
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.upload-label i {
+    font-size: 16px;
+    color: #6b7280;
+}
+
+.hidden-file-input {
+    display: none;
+}
+
+/* 文本输入样式 */
+.text-input-wrapper {
+    flex: 1;
+    display: flex;
+    gap: 8px;
+    align-items: center;
+}
+
+.modern-input {
+    flex: 1;
+}
+
+.csv-import-btn {
+    border-radius: 8px;
+    border-color: #d1d5db;
+    background: #ffffff;
+    transition: all 0.2s;
+    max-width: 140px;
+    overflow: hidden;
+}
+
+.csv-import-btn:hover {
+    background: #f9fafb;
+    border-color: #9ca3af;
+    transform: translateY(-1px);
+}
+
+.csv-import-btn .btn-text {
+    font-size: 12px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    max-width: 100px;
+    display: inline-block;
+}
+
+.field-value-display {
+    padding: 7px 12px;
+    background: #f9fafb;
+    border-radius: 6px;
+    font-size: 13px;
+    color: #6b7280;
+}
+
+/* ================== 字段计数 ================== */
+.field-count {
+    font-size: 12px;
+    color: #9ca3af;
+    font-weight: 600;
+    margin-left: 4px;
+    padding: 2px 8px;
+    background: #f3f4f6;
+    border-radius: 12px;
+}
+
+/* ================== 现代化空状态 ================== */
+.empty-state-modern {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 48px 24px;
+    text-align: center;
+}
+
+.empty-state-modern i {
+    font-size: 56px;
+    color: #cbd5e1;
+    margin-bottom: 16px;
+}
+
+.empty-title {
+    font-size: 15px;
+    font-weight: 600;
+    color: #64748b;
+    margin: 0 0 8px 0;
+}
+
+.empty-hint {
+    font-size: 13px;
+    color: #94a3b8;
+    margin: 0;
+}
+
+/* ================== 滚动条美化 ================== */
+.metadata-fields-list::-webkit-scrollbar {
+    width: 6px;
+}
+
+.metadata-fields-list::-webkit-scrollbar-thumb {
+    background: #cbd5e1;
+    border-radius: 3px;
+}
+
+.metadata-fields-list::-webkit-scrollbar-thumb:hover {
+    background: #94a3b8;
+}
+
+.metadata-fields-list::-webkit-scrollbar-track {
+    background: #f1f5f9;
+    border-radius: 3px;
+}
 </style>
diff --git a/src/renderer/components/work/WorkMain.vue b/src/renderer/components/work/WorkMain.vue
index b39128d..aaed75c 100644
--- a/src/renderer/components/work/WorkMain.vue
+++ b/src/renderer/components/work/WorkMain.vue
@@ -13,17 +13,12 @@
             <!-- 右侧功能按钮 -->
             <div class="header-buttons">
                 <!-- 录制组件 (绿色圆形) -->
-                <div class="recorder-wrapper" v-if="isRecording || high_setting_form.is_print_logo">
+                <div class="recorder-wrapper"
+                    v-if="isRecording || high_setting_form.record_screen || high_setting_form.print_record_logo">
                     <screen-recorder ref="screenRecorder" :task-id="upload_disk" :status-only="true"
                         @recording-started="onRecordingStarted" @recording-stopped="onRecordingStopped"
                         @recording-saved="onRecordingSaved" />
-                    <el-tooltip content="打印" placement="top">
-                        <div v-if="high_setting_form.is_print_logo" class="print-logo-indicator">
-                            <img src="static/images/luzhi.png" @error="onLogoError" v-if="!logoError"
-                                class="logo-img" />
-                            <i v-else class="el-icon-printer"></i>
-                        </div>
-                    </el-tooltip>
+
                 </div>
 
                 <!-- 高级设置按钮 (白色) -->
@@ -168,6 +163,7 @@ export default {
             switch_cont: true,
             switch_tag: true,
             submitLoading: false,
+            sysAuthCode: '', // 系统配置授权码
 
             // 新手引导
             guideStep: null,
@@ -191,25 +187,31 @@ export default {
 
             // 高级设置表单
             high_setting_form: {
+                // 基础配置
                 priority: 0,
                 fileSystem: 0,
                 target_work: 0,
                 color_type: 0,
-                s1: false,
-                s2: false,
-                s3: false,
+                formatFile: 0,
+
+                // 开关选项
+                s1: false, // 生成MD5 HASH文件
+                s2: false, // 打印MD5到HASH字段
+                s3: false, // 失败打印标签
                 s4: false,
                 s5: false,
+
+                // 密码相关
                 pass: '',
                 repass: '',
-                localfiles: false,
-                formatFile: 0,
-                Span_USBcard: false,
-                hasAddFile: false,
-                is_blend: false,
-                is_record: false,
-                record_path: '',
-                is_print_logo: false,
+
+                // 功能开关
+                localfiles: false, // 本地文件
+                Span_USBcard: false, // 允许跨卡
+                hasAddFile: false, // 预设内容拷贝
+                is_blend: false, // 混合模式
+
+                // ISO/ZIP 生成
                 is_generate_iso: false,
                 iso_file_name: '',
                 is_generate_zip: false,
@@ -217,10 +219,17 @@ export default {
                 is_zip_encrypt: false,
                 zip_password: '',
                 zip_repassword: '',
-                copy_hash: false,
-                is_dongle_count: false,
-                dongle_count: 1,
-                auth_code: ''
+                copy_hash: false, // 拷贝HASH文件到存储卡
+
+                // 屏幕录制（重要：确保字段名称一致）
+                record_screen: false, // 启用屏幕录制
+                record_screen_path: '', // 录制路径
+                print_record_logo: false, // 打印录制标识
+
+                // 硬件管控（重要：确保字段名称与提交逻辑一致）
+                enable_dongle_counter: false, // 启用加密狗计数
+                install_dongle_count: 0, // 安装次数（默认为0而不是1）
+                auth_code: '' // 授权码
             }
         }
     },
@@ -276,6 +285,8 @@ export default {
         }
     },
     created() {
+        // 重置后台录制状态，防止刷新后状态卡死
+        ipcRenderer.invoke('reset-recording').catch(e => console.error('Reset recording failed:', e))
         extendStringPrototypes()
         this.upload_disk = genTaskUUID()
     },
@@ -328,15 +339,15 @@ export default {
                     this.high_setting_form = { ...this.high_setting_form, ...savedForm, ...defaults }
 
                     // 仅在路径为空时初始化默认路径（兼容三端）
-                    if (!this.high_setting_form.record_path) {
-                        this.high_setting_form.record_path = this.getDefaultRecordPath();
+                    if (!this.high_setting_form.record_screen_path) {
+                        this.high_setting_form.record_screen_path = this.getDefaultRecordPath();
                     }
                 } catch (e) {
                     console.error('Failed to parse high settings')
                 }
             } else {
                 // 无缓存时初始化默认路径
-                this.high_setting_form.record_path = this.getDefaultRecordPath();
+                this.high_setting_form.record_screen_path = this.getDefaultRecordPath();
             }
             this.juanbiao_form = getNowFormatDate()
             this.print_flag = this.dice === 1 ? 2 : 1
@@ -352,6 +363,17 @@ export default {
                     this.guideStep[this.currentStep].show = true
                 }, 200)
             }
+            this.getSystemConfig(); // 获取系统配置
+        },
+
+        getSystemConfig() {
+            this.$axios.get('/web/get_config').then((res) => {
+                if (res.data.code === 200 && res.data.data) {
+                    this.sysAuthCode = res.data.data.AuthorizationCode || '';
+                }
+            }).catch(err => {
+                console.error('Failed to get system config', err);
+            });
         },
 
         // --- 高级设置与录制 ---
@@ -391,8 +413,9 @@ export default {
             const recorder = this.$refs.screenRecorder;
             if (recorder) {
                 if (recorder.isRecording) {
-                    recorder.stopRecording(true);
+                    this.$message.warning(this.$t('recorder.recording'));
                 } else {
+                    this.highSettingVisible = false;
                     recorder.startRecording({
                         savePath: recordPath || this.getDefaultRecordPath()
                     });
@@ -440,7 +463,8 @@ export default {
                         if ([1, 3, 4, 5].includes(item.type)) {
                             const defaultVal = item.DefaultText !== undefined ? item.DefaultText : ''
                             this.tableData.push({
-                                name: item.name + this.$t('work.front_tag'),
+                                name: item.name,
+                                sideLabel: this.$t('work.front_tag'),
                                 val: defaultVal,
                                 origin_name: item.name,
                                 type: item.type,
@@ -457,7 +481,8 @@ export default {
                         if ([1, 3, 4, 5].includes(item.type)) {
                             const defaultVal = item.DefaultText !== undefined ? item.DefaultText : ''
                             this.tableData.push({
-                                name: item.name + this.$t('work.back_tag'),
+                                name: item.name,
+                                sideLabel: this.$t('work.back_tag'),
                                 val: defaultVal,
                                 origin_name: item.name,
                                 type: item.type,
@@ -991,14 +1016,12 @@ export default {
                 '&zip_file_name=' + (that.high_setting_form.zip_file_name || '') +
                 '&is_zip_encrypt=' + (String(that.high_setting_form.is_zip_encrypt) || 'false') +
                 '&zip_password=' + (that.high_setting_form.zip_password || '') +
-                '&copy_hash=' + (String(that.high_setting_form.copy_hash) || 'false') +
-                '&enable_dongle_counter=' + (String(that.high_setting_form.enable_dongle_counter) || 'false') +
-                '&auth_code=' + (that.high_setting_form.auth_code || '');
+                '&copy_hash=' + (String(that.high_setting_form.copy_hash) || 'false');
 
             data += '&is_blend=' + (String(that.high_setting_form.is_blend) || 'false');
 
             // Log path logic
-            if (that.high_setting_form.record_screen && that.$refs.screenRecorder && that.$refs.screenRecorder.videoPath) {
+            if (that.$refs.screenRecorder && that.$refs.screenRecorder.videoPath) {
                 data += '&record_path=' + that.$refs.screenRecorder.videoPath;
             } else {
                 data += '&record_path=';
@@ -1006,16 +1029,31 @@ export default {
             data += '&is_printer_record_logo=' + (String(that.high_setting_form.print_record_logo) || 'false');
 
             if (that.high_setting_form.enable_dongle_counter) {
-                data += '&donglel_install_count=' + (that.high_setting_form.install_dongle_count || 0);
+                data += '&dongle_install_count=' + (that.high_setting_form.install_dongle_count || 1);
             } else {
-                data += '&donglel_install_count=0';
+                data += '&dongle_install_count=-1';
             }
 
             // File Type Mapping
             const fileTypeMap = { 0: 1, 1: 2, 2: 3, 4: 4 };
             let apiFileType = fileTypeMap[that.file_form] || 1;
-            data += '&file_type=' + apiFileType;
-            console.log('提交参数预览:', data_param + data)
+            // --- DEBUG: 输出提交数据 ---
+            console.group('任务提交数据详情');
+
+            // 将查询字符串解析为对象，方便查看
+            const queryString = data_param + data;
+            const params = {};
+            queryString.split('&').forEach(part => {
+                if (part) {
+                    const [key, val] = part.split('=');
+                    params[key] = decodeURIComponent(val || '');
+                }
+            });
+            console.log('提交参数对象 (JSON):', params);
+
+            console.log('高级设置表单:', JSON.parse(JSON.stringify(that.high_setting_form))); // 深拷贝打印
+            console.groupEnd();
+
             // Submit Flow
             if (this.isCopy) {
                 this.submitLoading = true
@@ -1047,9 +1085,8 @@ export default {
 
         localUpload(pathName, data_param, data) {
             let file_path = []
-            // 注意: 这里使用 getLists() 可能需要适配 legacy 的 filesList 结构
-            // 如果 filesList[i].path 是正确路径，则无需更改
-            const list = this.$refs.files.filesList // Prefer direct filesList if available like legacy
+            // FileManagement 组件不直接暴露 filesList，需使用 getLists()
+            const list = this.$refs.files.getLists()
             for (let i in list) {
                 file_path.push(list[i].path)
             }
diff --git a/src/renderer/components/work/sections/AdvancedFeatures.vue b/src/renderer/components/work/sections/AdvancedFeatures.vue
index c3ce91a..2da5a6f 100644
--- a/src/renderer/components/work/sections/AdvancedFeatures.vue
+++ b/src/renderer/components/work/sections/AdvancedFeatures.vue
@@ -95,18 +95,15 @@
             </div>
             <div class="g-switch-item">
                 <span class="g-label">{{ $t('work.installDongle') }}</span>
-                <el-switch v-model="form.is_dongle_count"></el-switch>
+                <el-switch v-model="form.enable_dongle_counter"></el-switch>
             </div>
         </div>
 
         <!-- 计数器详细 -->
-        <div v-if="form.is_dongle_count" class="mt-10 p-10"
+        <div v-if="form.enable_dongle_counter" class="mt-10 p-10"
             style="background: #fdf6ec; border-radius: 6px; border: 1px solid #faecd8;">
-            <el-form-item :label="$t('work.installCount')" label-width="140px" class="mb-5">
-                <el-input-number v-model="form.dongle_count" :min="1" :step="1" :precision="0" size="mini" />
-            </el-form-item>
-            <el-form-item :label="$t('work.authCode')" label-width="140px" class="mb-0">
-                <el-input v-model="form.auth_code" size="mini" :placeholder="$t('work.inputAuthCode')" />
+            <el-form-item :label="$t('work.installCount')" label-width="140px" class="mb-0">
+                <el-input-number v-model="form.install_dongle_count" :min="0" :step="1" :precision="0" size="mini" />
             </el-form-item>
         </div>
     </div>
diff --git a/src/renderer/components/work/sections/HardwareControl.vue b/src/renderer/components/work/sections/HardwareControl.vue
index c31262e..27cff61 100644
--- a/src/renderer/components/work/sections/HardwareControl.vue
+++ b/src/renderer/components/work/sections/HardwareControl.vue
@@ -8,14 +8,14 @@
             <el-col :span="12">
                 <div class="hardware-box">
                     <div class="mb-10">
-                        <el-checkbox v-model="form.is_dongle_count">
+                        <el-checkbox v-model="form.enable_dongle_counter">
                             {{ $t('work.installDongle') }}
                         </el-checkbox>
                     </div>
                     <transition name="el-zoom-in-top">
-                        <div v-if="form.is_dongle_count" class="ml-20">
+                        <div v-if="form.enable_dongle_counter" class="ml-20">
                             <el-form-item :label="$t('work.installCount')" label-width="80px">
-                                <el-input-number size="small" v-model="form.dongle_count" :min="1" :max="999" />
+                                <el-input-number size="small" v-model="form.install_dongle_count" :min="0" :max="999" />
                             </el-form-item>
                         </div>
                     </transition>
diff --git a/src/renderer/components/work/sections/RecordingSettings.vue b/src/renderer/components/work/sections/RecordingSettings.vue
index 8e88e41..40afe5c 100644
--- a/src/renderer/components/work/sections/RecordingSettings.vue
+++ b/src/renderer/components/work/sections/RecordingSettings.vue
@@ -8,22 +8,21 @@
             <div class="grand-switch-grid mb-10">
                 <div class="g-switch-item">
                     <span class="g-label">{{ $t('work.enableScreenRecord') }}</span>
-                    <el-switch v-model="form.is_record"></el-switch>
+                    <el-switch v-model="form.record_screen"></el-switch>
                 </div>
-                <div class="g-switch-item" v-if="form.is_record">
+                <div class="g-switch-item" v-if="form.record_screen">
                     <div class="flex-align-center">
                         <span class="g-label">{{ $t('work.printRecordLogo') }}</span>
-                        <i v-if="form.is_print_logo" class="el-icon-picture ml-5 logo-icon-active"
-                            title="luzhi.png"></i>
+
                     </div>
-                    <el-switch v-model="form.is_print_logo"></el-switch>
+                    <el-switch v-model="form.print_record_logo"></el-switch>
                 </div>
             </div>
 
-            <div v-if="form.is_record" class="path-box-container">
+            <div v-if="form.record_screen" class="path-box-container">
                 <div class="path-box">
                     <el-form-item :label="$t('work.recordPath')" label-width="110px">
-                        <el-input v-model="form.record_path" :placeholder="$t('work.defaultPath')" size="small">
+                        <el-input v-model="form.record_screen_path" :placeholder="$t('work.defaultPath')" size="small">
                             <el-button slot="append" icon="el-icon-folder-opened" @click="selectRecordPath"></el-button>
                         </el-input>
                     </el-form-item>
@@ -59,12 +58,12 @@ export default {
                 properties: ['openDirectory']
             }).then(result => {
                 if (!result.canceled && result.filePaths.length > 0) {
-                    this.$set(this.form, 'record_path', result.filePaths[0])
+                    this.$set(this.form, 'record_screen_path', result.filePaths[0])
                 }
             })
         },
         testRecording() {
-            this.$emit('test-recording', this.form.record_path);
+            this.$emit('test-recording', this.form.record_screen_path);
         }
     }
 }
diff --git a/src/renderer/lang/cn.js b/src/renderer/lang/cn.js
index d2981a3..6a83d2f 100644
--- a/src/renderer/lang/cn.js
+++ b/src/renderer/lang/cn.js
@@ -8,12 +8,15 @@ export default {
   recorder: {
     startRecording: "开始录制",
     stopRecording: "停止录制",
-    recordingStarted: "开始录制屏幕",
+    recording: "录制中",
+    recordingStarted: "录制已开始",
     recordingStopped: "录制已停止",
-    savedSuccess: "录制已保存",
-    startFailed: "启动录制失败",
+    startFailed: "启动录制失败，请检查设备权限或确保未被其他程序占用",
     stopFailed: "停止录制失败",
-    saveFailed: "保存录制失败"
+    recordingCanceled: "录制已取消",
+    saveFailed: "保存录制失败",
+    savedSuccess: "录制已保存",
+    recordingConfirm: "正在录制中，确定要停止并保存吗？"
   },
   networkAuth: {
     title: "网络路径认证",
@@ -532,7 +535,7 @@ export default {
     hardwareControl: "硬件管控",
     installDongle: "加密狗计数",
     installCount: "安装次数",
-    authCode: "授权码",
+    authCode: "加密信息",
     inputAuthCode: "输入授权码",
     addContent: "添加内容",
     addTag: "添加标签",
@@ -582,6 +585,8 @@ export default {
     pleaseUploadContent: "请添加拷贝内容",
     uploadingContent: "正在上传拷贝内容...",
     uploadFail: "添加出错，请完成添加后再进行提交",
+    noTemplate: "暂无模板",
+    selectTemplateHint: "请先选择一个标签模板",
     submiting: "正在提交",
     submitSuccess: "提交成功",
     sizeExtra: "错误!当前文件已超过最大容量",
@@ -589,4 +594,5 @@ export default {
     waitCalculate: "请等待计算",
     dropBg: `data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAlgAAAGuCAIAAADDJ+8SAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQqWlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4gPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNy4xLWMwMDAgNzkuZGFiYWNiYiwgMjAyMS8wNC8xNC0wMDozOTo0NCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnBob3Rvc2hvcD0iaHR0cDovL25zLmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VFdmVudCMiIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczp0aWZmPSJodHRwOi8vbnMuYWRvYmUuY29tL3RpZmYvMS4wLyIgeG1sbnM6ZXhpZj0iaHR0cDovL25zLmFkb2JlLmNvbS9leGlmLzEuMC8iIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIDIyLjUgKE1hY2ludG9zaCkiIHhtcDpDcmVhdGVEYXRlPSIyMDIyLTA2LTE5VDE5OjQ1OjU2KzA4OjAwIiB4bXA6TW9kaWZ5RGF0ZT0iMjAyMy0wNS0yMVQxNzoxOTo0MiswODowMCIgeG1wOk1ldGFkYXRhRGF0ZT0iMjAyMy0wNS0yMVQxNzoxOTo0MiswODowMCIgZGM6Zm9ybWF0PSJpbWFnZS9wbmciIHBob3Rvc2hvcDpDb2xvck1vZGU9IjMiIHBob3Rvc2hvcDpJQ0NQcm9maWxlPSJzUkdCIElFQzYxOTY2LTIuMSIgcGhvdG9zaG9wOkhpc3Rvcnk9IjIwMjMtMDQtMjRUMTE6MzY6NDUrMDg6MDAmI3g5O+aWh+S7tiB0dW9femgucG5nIOW3suaJk+W8gCYjeEE7MjAyMy0wNC0yNFQxMTo0MToxMCswODowMCYjeDk75paH5Lu2IHR1b196aC5wc2Qg5bey5a2Y5YKoJiN4QTsyMDIzLTA0LTI0VDExOjQxOjUxKzA4OjAwJiN4OTvmlofku7YgdHVvX3poLnBzZCDlt7LlrZjlgqgmI3hBOzIwMjMtMDQtMjRUMTQ6MzA6NTYrMDg6MDAmI3g5O+aWh+S7tiB0dW9femgucHNkIOW3suWtmOWCqCYjeEE7MjAyMy0wNS0yMVQxNjo1NzoyMCswODowMCYjeDk75paH5Lu2IHR1b196aC5wc2Qg5bey5omT5byAJiN4QTsyMDIzLTA1LTIxVDE3OjE1OjU4KzA4OjAwJiN4OTvmlofku7YgdHVvX3poLnBzZCDlt7LlrZjlgqgmI3hBOzIwMjMtMDUtMjFUMTc6MTc6MTArMDg6MDAmI3g5O+aWh+S7tiB0dW9fZ2Lmi7fotJ0ucG5nIOW3suWtmOWCqCYjeEE7MjAyMy0wNS0yMVQxNzoxOTo0MiswODowMCYjeDk75paH5Lu2IHR1b196aCDmi7fotJ0ucG5nIOW3suWtmOWCqCYjeEE7IiB4bXBNTTpJbnN0YW5jZUlEPSJ4bXAuaWlkOjk0MzU4ZWY1LWFiYmEtNDY5NS1iMzhmLWVkOThjZjU1NDU1ZCIgeG1wTU06RG9jdW1lbnRJRD0iYWRvYmU6ZG9jaWQ6cGhvdG9zaG9wOmU3MzcxNGRhLTBmMWMtMzY0Ny1hMzlkLWE4YjZmZmJjZDczZiIgeG1wTU06T3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOmYyYmQwNTNmLWQ1OTctNDgyNy1iMjk5LTc1MTZiNzYwY2Q4ZCIgdGlmZjpPcmllbnRhdGlvbj0iMSIgdGlmZjpYUmVzb2x1dGlvbj0iNzIwMDAwLzEwMDAwIiB0aWZmOllSZXNvbHV0aW9uPSI3MjAwMDAvMTAwMDAiIHRpZmY6UmVzb2x1dGlvblVuaXQ9IjIiIGV4aWY6Q29sb3JTcGFjZT0iMSIgZXhpZjpQaXhlbFhEaW1lbnNpb249IjYwMCIgZXhpZjpQaXhlbFlEaW1lbnNpb249IjQzMCI+IDxwaG90b3Nob3A6VGV4dExheWVycz4gPHJkZjpCYWc+IDxyZGY6bGkgcGhvdG9zaG9wOkxheWVyTmFtZT0i6KuL5rOo5oSP77yaIOWmguaenOS9nOalreezu+e1seS4jeaUr+aMgeaLluaUvu+8jOiri+m7nuaTiuS4iuaWuea3u+WKoOaWh+S7tuWkvuWSjOa3u+WKoOaWh+S7tuaMiemIleOAgiDlpoLmnpzmi5bmi73mlofku7bmlbjph4/lpKrlpJrvvIzmnIPlsI7oh7TpoIHpnaLnhKHpn7/mh4nvvIzor7fogJDlv4PnrYnlvoXjgIIiIHBob3Rvc2hvcDpMYXllclRleHQ9Iuiri+azqOaEj++8miDlpoLmnpzkvZzmpa3ns7vntbHkuI3mlK/mjIHmi5bmlL7vvIzoq4vpu57mk4rkuIrmlrnmt7vliqDmlofku7blpL7lkozmt7vliqDmlofku7bmjInpiJXjgIIg5aaC5p6c5ouW5ou95paH5Lu25pW46YeP5aSq5aSa77yM5pyD5bCO6Ie06aCB6Z2i54Sh6Z+/5oeJ77yM6K+36ICQ5b+D562J5b6F44CCIi8+IDxyZGY6bGkgcGhvdG9zaG9wOkxheWVyTmFtZT0i6K+35rOo5oSP77yaIOWmguaenOS9nOS4muezu+e7n+S4jeaUr+aMgeaLluaUvu+8jOivt+eCueWHu+S4iuaWuea3u+WKoOaWh+S7tuWkueWSjOa3u+WKoOaWh+S7tuaMiemSruOAgiDlpoLmnpzmi5bmi73mlofku7bmlbDph4/lpKrlpJrvvIzkvJrlr7zoh7TpobXpnaLml6Dlk43lupTvvIzor7fogJDlv4PnrYnlvoXjgIIiIHBob3Rvc2hvcDpMYXllclRleHQ9Iuivt+azqOaEj++8miDlpoLmnpzkvZzkuJrns7vnu5/kuI3mlK/mjIHmi5bmlL7vvIzor7fngrnlh7vkuIrmlrnmt7vliqDmlofku7blpLnlkozmt7vliqDmlofku7bmjInpkq7jgIIg5aaC5p6c5ouW5ou95paH5Lu25pWw6YeP5aSq5aSa77yM5Lya5a+86Ie06aG16Z2i5peg5ZON5bqU77yM6K+36ICQ5b+D562J5b6F44CCIi8+IDwvcmRmOkJhZz4gPC9waG90b3Nob3A6VGV4dExheWVycz4gPHhtcE1NOkhpc3Rvcnk+IDxyZGY6U2VxPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iY3JlYXRlZCIgc3RFdnQ6aW5zdGFuY2VJRD0ieG1wLmlpZDpmMmJkMDUzZi1kNTk3LTQ4MjctYjI5OS03NTE2Yjc2MGNkOGQiIHN0RXZ0OndoZW49IjIwMjItMDYtMTlUMTk6NDU6NTYrMDg6MDAiIHN0RXZ0OnNvZnR3YXJlQWdlbnQ9IkFkb2JlIFBob3Rvc2hvcCAyMi41IChNYWNpbnRvc2gpIi8+IDxyZGY6bGkgc3RFdnQ6YWN0aW9uPSJjb252ZXJ0ZWQiIHN0RXZ0OnBhcmFtZXRlcnM9ImZyb20gaW1hZ2UvcG5nIHRvIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AiLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjdiZGE5MmZiLWIzYTItNDU2MC04ZjBiLWEyNTA1NGQ5NTRlNyIgc3RFdnQ6d2hlbj0iMjAyMy0wNC0yNFQxMTo0MToxMCswODowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIDIyLjUgKE1hY2ludG9zaCkiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOmU2NmMzMzY0LTBlYjktNGRlYS04MGI5LTU0YTU2MDgwMzUwNCIgc3RFdnQ6d2hlbj0iMjAyMy0wNS0yMVQxNzoxOTo0MiswODowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIDIyLjUgKE1hY2ludG9zaCkiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249ImNvbnZlcnRlZCIgc3RFdnQ6cGFyYW1ldGVycz0iZnJvbSBhcHBsaWNhdGlvbi92bmQuYWRvYmUucGhvdG9zaG9wIHRvIGltYWdlL3BuZyIvPiA8cmRmOmxpIHN0RXZ0OmFjdGlvbj0iZGVyaXZlZCIgc3RFdnQ6cGFyYW1ldGVycz0iY29udmVydGVkIGZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFnZS9wbmciLz4gPHJkZjpsaSBzdEV2dDphY3Rpb249InNhdmVkIiBzdEV2dDppbnN0YW5jZUlEPSJ4bXAuaWlkOjk0MzU4ZWY1LWFiYmEtNDY5NS1iMzhmLWVkOThjZjU1NDU1ZCIgc3RFdnQ6d2hlbj0iMjAyMy0wNS0yMVQxNzoxOTo0MiswODowMCIgc3RFdnQ6c29mdHdhcmVBZ2VudD0iQWRvYmUgUGhvdG9zaG9wIDIyLjUgKE1hY2ludG9zaCkiIHN0RXZ0OmNoYW5nZWQ9Ii8iLz4gPC9yZGY6U2VxPiA8L3htcE1NOkhpc3Rvcnk+IDx4bXBNTTpEZXJpdmVkRnJvbSBzdFJlZjppbnN0YW5jZUlEPSJ4bXAuaWlkOmU2NmMzMzY0LTBlYjktNGRlYS04MGI5LTU0YTU2MDgwMzUwNCIgc3RSZWY6ZG9jdW1lbnRJRD0iYWRvYmU6ZG9jaWQ6cGhvdG9zaG9wOmY2MGZlMmNlLWE4ZmUtZmM0Yi04NzgxLWUxMzZkNDhlNzZlNSIgc3RSZWY6b3JpZ2luYWxEb2N1bWVudElEPSJ4bXAuZGlkOmYyYmQwNTNmLWQ1OTctNDgyNy1iMjk5LTc1MTZiNzYwY2Q4ZCIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pqzgs6YAADuCSURBVHic7d37Uxpp/i/wh0tjAAUUkIsi6hCNmquTbGYmk9nUfM9862xt1f5N379pq7Zmz86enMzk6ug6SYwalXARRBBQQOlO+gH6/PCZ9HTAqEnUTOZ5v2pqSjsNdCP0u5+7SdM0BgAAICrzxz4AAACAjwlBCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQrN+7AMA+L2b/c+8qqomk+nX3zV2bnysr69X36HVai08W9zd3TNbzIwxraVJNunc+Jirp0ffp9lqra3FS6Uy7cM0pjFtcuJcr8ej79NoNJ8tLe3t7ZnNv96hNpvNoUgkOhQ56XMEEBmCEOAQtdpuXZb1X60WS0trGXfQNG2nWq3VdvUtNpvUar2xj4mx2u7edqVi3PjqlfrGPiYmy/L2zhv7hILBDz0BADgQqkYBDqGXz/RfTczUvo/pzX1M7Tswxszm9o2mjt0sZsvBrw4Axw7fMQAAEBqCEOD4ace+IwCcGAQhwCFazabx12az2dZGyBjrbDXUtPaQa7UOiT1NY41mo21j881XB4Bjh84yAIeIRoeazabenqdp2pmuM8YdzGbzSDSqKAq152maZrFaznR1tT3PQDjk6unW2/w0Tet2Oo07mEwsHAr5vF79tVqtltvtOomTAgCdqfO+FQAAQByoGgUAAKEhCAEAQGgIQgAAEBqCEAAAhIZeowCHWIu/ePnqFfXk1DTNarEMRSJOp+PYX6jVamUy2dre3q+9RjWNMRYKBr3evmN/LQDQIQgBDpFKrysvX+q/mhjz+bwnEYSapmU3cuWdHePGrq4uBCHAiULVKMAhrNY37hclSWqbWfTkXosxZrG0zz4KAMcLQQgAAEJDEAIc6s1JJ05sDorOxSgA4BQgCAEO0RZ8LU3TTmaybJOpc30npCPAiUNnGYBDnI2Nct74tSMnYyaTyeE4Uk+Zly9fFoulnWrVdLQ4a2naq1eq3X6GGfKwsFWs1+tHebmWplktln6/3+1xSx1tjQDwNphrFOBEVKvV+ScLe3t77/QVM5lMbZnZttL9oSwWSygQuHTxPHrZABwRqkYBjh8NhNjd3X3XG01N01pveteXbjabuXy+vL39rg8EEBaCEOD4qaq6/eZwwNPUarXKZQQhwFEhCAGOn6YdvgzviXqPoiSAsBCEACfAxNp6x5xo58/OJ0dfU4CjQ9cygENkNjYavKF35DSbTP1+v91uf6cnsVgs/X5fl8127OVEE2O12u52pYKObwDvB0EIcIi1tRd7hgEMktXidDrfNQhbrdZgOBwMBo776Bhj7MnThfLHa5IE+NShahTgEKb2X/cb934ELe2k2u1QEgT4EAhCgMN0NPe95/OcXF6hUhTgAyAIAQBAaAhCgEM0mw3jr41Go4USGMAfCDrLABwiOjT08uUrk/m3Feod9jMf+6AA4NggCAEOcTb22cc+BAA4QagaBfjkNTvmkWk2MbMMwFGhRAjw+9VqtWRFOdPVZT1wWSWvt89sNuu9WTWN9fZ6TuHwAP4YEIQAx++45jczmUzr65lqdffc+NkDsi0aiUQjEX1aNUwxA/BOEIQAx89sNh9LGppMpmazWSyXqrO1yGBoKDLU09O9724H/AoAB0MQAhziRSLZbDb1dGm1WuFwqKf7t0DSNG09k3358qXZbNb3aTYa+zzXu6PeqipXXyTX81vFyOBgdCjSZbMdy5MDAEMQAhwqlUrXFUX/1WI29/X1GoOw1Wol0+labVffYjabTyCrtHpdfr6yWigUPhsZCQQDFjM6uwEcA3yRAA5htrzxNbFYLGZT+xenbYvJ1LEO0/HZqVTnf3k89+RpEavvAhwHlAgBDvW7a3JrMVbIbW5vFcPh0GcjI93dzo99RACfMAQhwKeKNxrp9cxWsRSNRqKDg11dXR/7iAA+SQhCgEO0Ws03f21pHQtJtC2xpLVap7YihKIoz5+vFrdK0aFIOBQ0o+EQ4B0hCAEO0dfb19PNX/ca1TSNWcwW4w4mk8nv9dq7zvwaQibGNK26u3eaB1ne3t7e2clu5GKjI15vH0ZQABwdghDgEJcunn+j54umtcWM2WyemDjHNI12MzH26tWrn+f+I5/ucWqatlUsbu9sDwwMjEaHenp6Tvf1AT5VCEKAQ7RXNu5X2DK/2U30uAbUv4dGo5lOr5e2igODA5GBgTNnuiwWy+EPAxAYmhMAjl9L005yQfrD1RUlmUovr6waRzcCwL5QIgT445Akqbvb6erucbvdLle3w+GwYQ4agMMgCAE+bVaL1el0uNw9vR6P2+Wynzlz5gzWDQZ4BwhCgE+by9UzffmS3X4GPUUB3g/aCAE+bbXd3Uq1ihQEeG8IQoBPW6PRiMdfqKr6sQ8E4FOFIAT4lJhMpp7u7rYRHZVaLZVa/1iHBPCpQxACfEpGh6NXP7/i9rjatqez2d1djJQAeB8IQoBToWltyzm9h5FodHxsrKe7OxqJmN+c5k1RlEQqpZ3WBKcAfyToNQpwGswWy85Opdlott6SVZqmmUwmb1+fw2Hfd4fh6NDkxDhNExMOBjdzhUJxy7hDbjM/EA77vN5jP3iAPzYEIcBpaLVaiVS61Wq9bQdN0ywWy+fTl9uCsNXSGGPD0aGpiXP6ZGlWq3V0JLq9s80bDX1Pzptr8Re9Hg/mVAN4J6gaBTgBHTOstVqtZrOpvR2jQmHHDKUmxgbDYWMKEr/fFwqG2l61VN7ObmyewPkA/JEhCAFOxHs01plM7TnYaDRCweD5qcl9C3mxz0bs9jeKj5qmvUgm6/X6u784gLgQhADHz2aTPO72jp3vwWKx+Hxem03a91+7u53RSKRt497eXrG0/eEvDSAOBCHA8TObzaFQ8F3b6lod69ofOl9MdCjS6/Hov3Y7HJPnxsOh4Du9LoDg0FkG4ET4vN5rn1/ZzOertd3Olr9OGtPMZrPV+m5fya4u28jwUOVJ1Wq1RgYHokORnu7u9z1kAEGZMPAI4ORomsZ54+jzgFoslvZ1gA/TbDZXV9f6vN5Av/+djw8AEIQAfwCtVutd4xMAdAhCAAAQGu4iAU4QbjQBfv/QWQbgeLx69Wo9u2Exm10ul8/bxxhrtVq/PHlqMpn7ej1DkcGDay9brdZOpVKr7Q5Hh/TOoqXy9k6lEuz3OxwOzBcDcEIQhADHgzcaz1dWNU37/Mpl2rK7t7eR22SMaVprODp08MM3cpuPny5omtbb6/G43bQxt7mZSq+vrsWvfX6l34++MAAnAkEIcDxskmSz2RqNhj6wr1QqM8a6bLax2Gecc31PTdNUzs90dRkHS7hdLqpHXc9k9SB8+fIlY6zX40EKApwcBCHAh6KFI6ySZDIxk4lRFWir1cpsbDDGXqnqzOx/NKZpmkYzaDNNazSbn1+5HAoGaGV5qyQ5nQ6/39dqNvv9/kaj2Ww2Wq3Wzk6FMRYOBVVVfT0fKWs2Gw6H49Cx9gBwROg1CvChshu5F4mk2WKuVmuaprldLqtk7ff5lp6vSFarz+fd26trmmaxWs50dZlMpmaz+fLlqwtTkz6f9+e5/1SqVavVajFbeINbLBaTydRoNJrNVl+vJ1/Y0jTNarVazGazxcIYazQakiT9+euvJGn/edcA4F2hRAjwoRqNxu7entlspnUkdvf2zCbTbm2XMXb2bCw2OvLo57mdnZ1B38CF85MdjzaZzWazyVyt1RhjvR43zb3dbL7azBcYY319vT3d3S9fvixsFRljoWDA6XRi1CDAMUIQAnyogYFwoL/fbDbduXu/2Wx+8/VX6+uZeCLpdrtioyOMMUmy8kajx9XDGGu1WqXytiRZqSnx2udXGGPVWu2new9sNumrL65T79BEKv1scclqtV65eMHpdFZrtcJWsaura/ryJXQfBTheCEKADyVZrZLVqneHMZvN/X5/pVozm02JZCo6FKHoqtfrLxLJ7EauWquNn41REFJTnywrjLEzZ85QUa9el5+vrDDGhiKDTqeTMfbqlcoYs1osSEGAY4cgBDgeFovFbDI1NG3m57lQMHDh/OT/+/FueXvH7XbLsswYe5FI6jtTvOlo5fp6Xb734JHFYmk0Gg67o9ls5vMFm802FvtM5SpjzG4/c7rnBCAEtDQAHINGo7GZLzQajWazubu3JyvK7u4utRref/ioVN5mjLldrs+vXKbVIdr6fFLfUZPJxDnfqVQq1WpkcODc+JisKNvb24yxl8pLxtiZM/Z9XhsAPgxKhAAfKruRW43H9/bqjDHJah0ZGc7nC5v5QqvVMplMfp/v5cuXu3t7n42ODIRDq/E4Y6xtrV0aLxgKBi5dOP/46UJ2I8dMJrfLxRjb3dvTNK22u8sY6+l27vPyAPBhUCIE+FCSJO3t1W02m9lsNlss4WCQRhYyxrqdzi+vX/N43IwxVVVrtV1qDjSb32jqq+3uMcaoO+jLV68YYzZJcjodDrtdUV4WtoqVSpUxRs8DAMcLQQjwoXp7PefGzn5x7WpXl63ZbJgt5j9d+5wmWqM4pNG6mezGvYePms2m1Wo909WlP7zRaOzV9xhjToeDMUaL1Le0lslk8vm8jLHFpWVZlu32M/qMMwBwjFA1CvChbJI0djbWaDRaLU3TmIkxp8OhqpwxRtNV0IQyVJ6TJGlkOOp0OvSH13Z3FeWl2Wx29fQwxl6pKmPsTNcZxthQZDC7kavLMmNsJBrFIHqAk4AgBDgeLU17owOMpjHGqE+M/UxXd7ezr7d3cuKcZLWurK5t5gvjZ2MUh9mNnKZprp6enp5uxhhXOWPMarEwxrqd3WfOnKFOp8xkammaGTOrARw3BCHA8TCbzC3DhIVUHcp5g3M+NTkxqZ2jalJFeZlMr6uqypg2ffmSvkKFx+Pe3d3drlRUVTWZTDabJMvK46dPf01BxpaWn29ubg6Ewy5XT09PT5fN9jHOEuAPCEEI8KF29/aSqbSiKKqqWiwWCsMzZ7rMZrOiKPcePPJ43FaLVWOaqvKdnR0aLDEUGWy1Wk+ePuOc22y2fr///qOf6Z8sFsvy6tr29jbVr06eG3+lqolkaqdS3alUbTbbza++QBACHBcEIcCHOtPVldvMU4a5XD1dXV2MMYfDcW7sbDK9Xpfler3OTCamaSaz2Wq19vX1RiMRn9fbaDSCwYDyUhmORkPBQDKdrtV23S7XyHB0I5dTVe6w2ycnxsOhEGMsFAjEk8lyqTx+NtY2Hh8APgRWnwA4BuuZrKqqbrer1+MxrjLYarVevnrFNMZMjGma1WqVJKlzNL1VkswmU70u0woVjLFms5nN5fp9/rbZZPbq9baFDAHgAyEIAQBAaBhHCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1B+PFx3vjYhwAAIC4E4alSFCWT3WCMcd5QFEVRlEQydff+A+W12u7uwuKSoij6QzLZjfnHTw54zoXFpUQyddJHDgDwR4VlmE5Vubw9Oz8/FosxxlLpddqoctUm/bra+HB0qFKtVirVL69f0x/1cGZ2ODoUCgYYY1arxBi7e/+B8WmNz8AYu3njK0nCenUAAEeCIDxtiqLEE8lwMJjL5xljsizvVCoD4TD9azQScbl6EsmUJEm/PHna+fBup/Pmja9qtRpj7MnCs+HokNvlYoxVa7XVeHxqYsJht7tcLgQhAMARIQhPFdV52u12RVFK5W3GmCzLG7nNs7HPaIe6LDsdjsjggL4z6ygRzj9+XK/LB7zKcHRodGT4JM8DAOCPA+WG08N54+HMrMrVsVhMrxdljKlcXYu/oJ8lSUrJdVmWx8fO2u12fR9JkvRfr1+7WqvtpjOZfV+FypRtr/t/79wZi8WQjgAAnRCEp0eSrN/e+ub2nZ8kSbo6fWV5ZYW2O5mDfnA4HOfGxhoNvp7JMsbyhYLeoVSWZepl4/P22e32aq1WLJaGo0NtL5FKr3vc7rYgBACAAyAIPw5Jsha2iucnJ/QtdVkuFksXpiYlyRoKBhlj6fUMVYGqXN3IbeoPpKKhylVjsZKoXN33tf73d//rhE4EAOBThyD8mDqTjDGWLxQeP134r1u3rl+7Sltu3/npbOwzajg08vt9bVs2crmTOE4AgD8wBOHHIcsKY2w4OiRJ0ustMhX7cpv5fr//0G6fI9FopVr1+3yp9Do9jyzLI9Fo555oIwQAOAAG1H8EqfT60vMVxlhdlivVqv4fY4zzxlaxGA4F9RH31HeUc67/Wi5vp9LrQ5HBwlYxFAxMToxv5DaDgUAynXY4HIvLy+Xy9kc+QwCATwdKhKeK84bKVY/HHY1E7j+aiY2O2O32Wm23WqsxxlSV5wsFxpi3z3v3/oO9el1/4LOl5WdLy/RzoN8/HB2yWiWbTVpeWZUkyeNxLywu2iRbMBBw2O3VWs3r7dMfizZCAIADYBzhaVMUxW63c954vrp6bmxMkqzl8jYNro9GIowxWZGDgQDnjUaD7/sM+jgKfTAioQ6lJ38GAAB/KAhCAAAQGtoI4d0YJwQ/3mfo3N65Loe+RVGUWm33A4/k6D78rMUkzsoq4pzpH5Llf/7nfz72MYilVtv9fz/djX02esAOq/EXW8Vi53/1er2310O7JZKpbC4X6PevrK6tZ7I09LBTJrvxfGV1cCCcyW78Z/7xyPBv3Uo5b6jqq0ajUd7e3qlUa7XdWm03ny9s5gvG15qZndM0jWY0ZYw9X13byOX0l7t956eFxaWVtfjb/pMkST9mxpiiKD/cvjMUGdS7y75teya78cuTp8YDNm5JJFOFra19z/qfP/x7IByi5+G88Y9//p/RkRGL5R3u+RLJFB2zoiiNRkNRXt7+8adQMNhqtRqNBmOmtmf7+z++7zyjtrP7/l//9nm9Dsdb667//o/vHQ6H/j7v6/adn6xWa9s+iWSq1Wo5HPZabXerWKK/o/6fiZm6uroYYzOzc/YzZw44AKO79x82m03jH07X9nlYWFwyfiyNOv+CRFGU56trW8XizOyc2+3q7u5u26Fc3s4XCr29HkVR8oWttjNSFIUekkimdiqVfV+60wFfk0PPaGZ2zmq16MfZuUO+UKAv174HbJOkAz4b8HuAzjKnrVQu9/v9+q+37/xk7BTzt7/+hWaNodlHjTORyrKcSq/rQyA2cptnY6OMsWQ6ffnihfc4kkw2SwMZPR53pVJVuToQDjsdDofDwRij60K5vL1TqUxfvpxIpuqyzBjjnG8ViwuLS/QkbStdJJKp1Xj8v27d0jfWars0Jw7hnDPGNvMF46XBZ+jawxij/WVZ1n9ua/7kvJFMp3s9Hv0wGGMet5uGWk5NTCyvrE5fvsQYyxcKvR7PO01BrijKRm6zUq2GQ8Gl5RV9+9z8L/SD0+nQh3jqfrh9x/jrlUsXO8d9frizsc8Wl5fbntntcs3Oz1+bnpYVhfoeJ1NpY/y8x0xDly6cv3P3XmRwsO2t47xR2CpOX77MeeP7f/3wl//+ru2Bxr+18S+oH2o8kahUqvTX/8t/fydJ1r//43vjM1y5dNHn7Xuy8Iwx5vN66Yw2crlej4c+mU6H411PhzE2OjJy9/6DfKEQDATe6YwYY/W6TL24qUne6XCk0uv6BzgyOJBez3g87kx2g3Nel+VKpcoY83jcdORTExMn8WGAY4QgPD1U6KGfsxs5xth3395ijN344rrX22f8V5Wr9P2XZdn4s/5UtdpuXa4HA4FEMqWq/Oe5eeMLdTudw9GhuixfmJrsPAwaVvhft26NjgyPjgxTtx3G2OWLF+gaMf/4iSRJ9NWNJxJjsRj1ZfW43cVSqV6XpyZ+mxDHeKFUFOXZ0vL5yQnjxmqtRsdvVJffmDQ8t7lJc+g8nJkdCIdUztvO3e1ybeZTqfS6ytWZ2Tm/z9fr8YRDIc65fj1yu1zGS2p2I9ftdDLG9up1ffvIcHTf98TIbrffvPHlwuKSw+7QpyzYq9f1nz1ud+ejvvv2VltPpUQypXf0Jfcfzeg/n5+cOMqwzraQ6NxIz3Nterpaq42ODEcGB2q13Y1cjvphHfGZR4ajsiwXtopt+3z/rx+M+1yYmsxks4MDYUmyJpKpQH/7aFfOG8a/tfEvqKMblIXFJafDoT9cf/dmZucYY3a7/cvr1+KJ5OjIMP29isVSbHTU++YNU5uZ2Tn9FOgr0Pb+M8aM35Rup/PbW98cekZ37z+g2YBT6fW6XKeFYvx+n37PwRijBWQq1arH7b4wNUn3Z/qRH3DM8DuBIDw9drv9b3/9y937D8/GRoOBwN//8T0tLtjJJtnoamuTpHpdNv5MO6QzGZtkUxRlNR6nedraYi9fKKzG4+fGxjqfPJPNOh1O+sJnshup9LrH4746faVaq+m/0gPL5e16XY6N/lrgkCRpcXn5z1/fsNvtdCFru5Q/fbbY7XS2bYwMDhhvhxVFSabSNG5E30i323fu3rs6fcVut+vHVq//dlK0fyq9PjE+/mBmhg5Dn3OH84YkWf/2178YD4yi6E9Xp+mO4W13Bm2ovy4FCb3zVIp1OhwUulRWXlhcoosgMZYIqThI9xn6Wf9w+w7d8Rx6AEZ/++tf6Ifbd366dOF858MVRVlYXLowNSlJEl1/6YaJbm6I0+GgSNBzgp6W4ofeGSrjrqyuMcbGx87qj11ZXZMkST+RVHqdbgiKpVJhq6inKT3/lUsXY6Mjc/OPr05fttvtxr/g/OMnfp/viAWjhcWl2OjIubExvcS/V6/n8nnqXG08I/2lb3xxnb1+58vl7ScLz+j9zxcKa/HEzRtf6k+eLxRym3nK46Oc0ZfXr9HyL26Xq1qrRQYH795/cHX6isvVw3mjWCzlNjfHYjFaHAbdtj9RCMJTxXmjLte9fd5abddmk95v1UDKkm6nczNfGAiHR0eGO1eoDwYCjC2Ut8udDy+WSgPhEGOsVttdXF62SbZisUTLItokm3EJp1w+v1ev3380MzgQliTpycIzKgtmshs2SVqNx0PBgP7NTyRTdJ1dWV3byG3SlYL+KV8oGOsYGWMPZ2bpB3o5SbI2GlbGmCRZjYtMqVy9fecn+vnmja8oh+x2+1gs9vTZIl27K9VqbnNTVTld7IxlxI3cZqDfT5P40N36Ud7e+ceP6QZflmXjclfG+fBu3viKvaVUR2Wa9/PLk6fGRSiNpUxj/bmR3W7nnN+9/3Dy3LjH7eacb+RyY7FYsVRijIVDIcYYpTLdNPi8fW21uEY+r/fJwjNjECbT6T9/fYN+zmQ3qGRcLm8Xtop0eJ23RP1+38OZWXqLyPzjJ3QY7M22gGdLy4H+35oJdE6H48d79y9fvEB/srX4C6rp1ZsMfN6+0ZFhveClf0g6efu8j+UFGrNEW3Kbeb/P905nxBiTJMnlcjkc9kw263Q6JMlK/ae+vH6NVkZbjcdtkm1yYryt6hU+CQjCU1XeLtP0aZnsGy2FbQ6uGo0nkoF+f70uG7+ryVRaL6DQBXokGjV+54miKIWt4sXzU4wxl6vnv27dYq8bC8discjgYL5QuHv/Id3RnxsbCweDs/PzE+NjyyurnHMKTpWrToez1+PR0yhfKFCl6LOlZZ/XK0nSnbv39JwIBgJul4subXqXBFlWZufn9dCiTnfLK6vhUMjYZPj02SJtkSQr51zl6qOfZwfCoZ1KZWZ2TuUq5zw6FNGDlnOux8lf/vu7TDZL795WsRgbfWsHJaPr167SFXb68uXnq6v0tjudv7VLTYyPH3oHQ/1E2jYaq0bZ6ypx45a3tSzSNbft4TabRPMkTF++tLC4RJfpp88WR6LRUDAQCgZ+vHff7/MZPySHHrbX2+d0OjLZDTqMRDLV6/HoEbIWf0G1zdVa7fzkxNtKP5Sj+ihYRVEkSdLL4t/e+obKx/rHo7P6l7Y77A5XoGdhccnpdMRGR6xWSZblYql0YWpKPxHbYZ1QJMk6FovFE0k6gFptd6tYvDA1dfQzos7JVDXKOd+r17udTrqTU7lK4Xfx/NTDmdlvb32TLxRu3/mJ5r6nStF958GH3xsE4amSrFJ2I+f3+YqlEt2tt6Fv3VgsRglhrBql+31qkDde+kln65fb7Uqm021BuJkvBPr99IVXFGU9k02m01QQlCSJ6tM45w9nZr+8fs1ut+fy+bFYrFqrxUZHXa4eKlVQtJwbG6O2w3J5++e5ebquUYXS6Miwz+udm/9lI7f5xZ+u0YoZY7FYej2jdzNZXlnt9Xjogqu37jgdDn22ObJTqTDGKtWqXmYdCIc2cps2yUZXH7/P19aL8sqli8FA4Pt//SBJ1lAw8Gxpmd7Ad+0zIknWYrHk9/uMvTOeLS3TbQR7c7ofo3Ao1Fkh/H5Vo4QmHqKuJbQlk93Q17BkjF2YmqzVdufmf/F43EORwR9u3/nu21vXpqefLDzbyG3SbY3KVektVfFGVPPs8/Zx3liNx/XiIOcNp9Ph9/nqsvy21s1EMqWXm2niXJWrlBnGkv3yymq30/lsablSrepVlG1GR4YVRZl//KRel69OX344M3s29tnF81NPny3+3zt3qD2bc36UjjNUmZkvFLx93rn5Xy5fvEBv41HOiGbAZ4yNRKPjY2cTyVSxVKLPsP7zzOxcvS5T7YXT6aDWTcZYbHSE88aDmZn3q/iB04S/0Knyevtu3fx6bv4XlavTly937mDsWlKpVOtynTG2Fn9hXGjiwtRUrVY79LWodpTat3QbuU19FUOrVaJEYYwVS6WdSoU65lF3lbn5x2djo1TK7HY6JyfG6WLqsNvpCCXJGhkcoKJPZyWhy9Vz88ZXj36eTSSTVEQYHRkulkorq2t0QalUql9ev0Y7x0ZHJ8bH79y9NxQZrNZqxoJssVjyuN0OhyMcDMqKshZ/MToyLEnSWvwFxXmxVCqWSnqJbadSiY2O6sURu90e6PdTafXQd2xfxWKpvQ8JY4yxC1OTB7c4UkvVt7e+6fyntzX4vU1uM9/W95Vzrp8yReBAODQcHapUq1S2jieSHrdbkqSBcIim8VNV7nK53jZdkc7l6hmLxR7OzO7V6ze+uK4XkiTJev3aVaqEN3ZLIXRDEOj3639TxtjDmVmbZLt04bxxzEYmm2WM+f2+gXBoq1jqrNUnd+8/pDEwHo+bzqhYKnHOVZWPRKPePi9jjGblPfTdkyTr1ekrd+7eox40etXlEc/oz1/feDgzSx1WqQW9VtuVJOtqPE4tBdOXLyuKMjf/C1WTSpK1UqnS286Yoqr84CEx8HuAIPwIqEbl0c+zV6cvt/2TXpLIZDcqlSqtZe/xuDnnE+NjBzTFG6tG9dLh//7ufxk7rzPGjL0GJMl688ZXC4uL1Ivh9p2fwqFQpVqty/KFqalGg9vt9j9dnZasEm9wh91B6etyufQ+C5nsxuLy8tsq9CTJanw5xhiV4SrVar0uU4mTtlOnWfo5GAgUS+ViqURlhbX4C4fDQc8vv3kuhC73Drv99p2frk5focu9oig226/jCFWVM8b2HT+XSKY2cpttB6mjQxoIhxyvix2cc70IePvOTzdvfJXJZqkPzvzjJx63e3RkeP7xk2gk8n4lv33lC4XsRu7KpYvGjcam0FK5zBgbHztLtQWUl7Is2ySJ3gTah7pEKopClYEHo2a8tklrdcbRI/u2qDHG5h8/8Xjcfp/vycIz49+6Uq1OjI/FE0lJkuid7yxV12q7O5UKfTsezsxS1y3O+UZucyAcKpZKNDEhY4wSUeXqweMjq7Vat9O5V693dmA++hkxxugv/mBmxibZ9PoMvYXbbrcrikJ1+G0DBzlvPPp5dqdSOaFxNfCBEISnqlzenp2fpxWRZmbnqAqlre1HUZTllVWqEaJxS9OXLyWSqYczs36/LxwM7nttOsrAgDaKotBzGr+ZsdGR5ZVV6he3mU+txuOMMRqrkNvcHAiHjeWStfiLo4+RqtV2N/N5lauszlSurmeyPq9333OhDujGDg5vMxwd8nm9LlcP5X08kRgZjkqStbwt2yRbrbZLw9H+dHVar7w1PrxSrVK/oU6VSvXHe/dtkq1Sraq8vRSVSKY8HrckWX1eL/XOpbEloyPD0UhELwgaR26wjj/0UVC188hwtO1N3iqW+l9XElSqVaowSKXXJ8+N00Zan+vShfOz8/M+r/fZ0jL1q5SV37r/6L1mqCuKoijxRDKZSg8OhL/79hbnjeWVldV4fCAcPnQwRtsxLz1fcToddCvDOf/x3v2piYlgICBJ1n3rQo39d8KhUKlc7nY6qd/KcHSIXtrv8z1bWp48N74aj1P3q7FYTJKs+r0OM/Q20sOeum5JknTpwnmXy/V8dfXv//h+ZDgajUTeY3glY0ySJKfDyRjbqVSodytNHaxy9e79h/1+n7GrkS5fKHDOr1y6mNvcRBD+DiEITw/nDep4Sd8Eugm9fecn4zhCGpA+Fou1XS+o1W15ZWXp+UpnObJNubzdds3VL8f6D4F+/06lQpFMHehVrlJjHuUuDVHweb10n/tk4ZnT6aCspQHFC4tLKlcP7SNH+bdVLNXleq/Hc2162uvtK5e344kENU9SO02lWrXZJH08yYWpSeNRsddNMvSvkmTdq9ep2YkapVSu9no89bp86cJ5OsfBgTBVGNKF6dbNr58sPOOcG69Tb+tBQx1kvrp+fW7+F2rwo8HUnHM6SGp4Y6/bHRVF8Xm9dCTU36RW2/V6+/TBD23oyNsGYLCOXqNk/GyMjrlW271z9x5t7HY6hyKD9HOlUqW+lJcunC+Vy+lMhjHm83rpYL66fj2dyYyfjfEGp3dGryU2Dp9YWFyiBlG9JdJuZ9evXaV0/P5fPxxl4GMmu5Hb3NypVKhFjTZSVfbi8vLi8vJAOLzv7VrbOEI92mOjI6XyNn3SJEk6PznhcNj//PWNUnlbkqTI4CCdkd7sbRw+oc9rY+zATBXaK6trc/O/7DsxQptabTedyVCHl4XFpY1czulwDkeH6CPx9Nnij/fu//nrG9VajbbnNjeps8xa/IXeiEt9aNfiL6gR4eBXhI8Ck27/vlB1nF4SqtV2S+XyCS2oqxe56FLYVh1Uq+3qlw+KAeOdbL5Q4LzhdrkOva2u1XaXV1b8Pt++05SUt8vVak2SpLos61PDGF9CkqyUtXSQeoGY/lXfWd/tWBjfGSpxUh4ww/w1vx+JZEp/bzPZDRoo8lEOktZRaRskSjhv5AsFh91+lErjTHZD/2hRFL2trvKk0d/dJknUsO12ubwdsyAZ3+q3LRqD8YW/cwhCAAAQGlaf+FR9rHUY3sZYPuO8cdKT8WM5iN+Jk/tDtz3zUV4IS0DA+0Eb4Wmr1XYfzMwcsGQ81QXt+096BRENI6MeGeuZbF2WO/sgUL9wvUIpXyjIsnLAeKml5ZW2GbRJ2zAAasvUW79qtV3OOQ1s+PbWN1RTtLC46HQ4jK1xVGXX+br7VuJRU9MB7TfUA8LYF/H90Kl1zgbytqNljFG3kX0rZmdm5/T5MPUZXA8QjUSqhw2Dobaot/0rddZv20jTYx4wxYk+2ey7jm/Ta8j1CsDNfCGVXteHTFBfm7ZHUTcu+th0zshKnW87j4TGhFydvqL/08OZWf1X/cQXFpf0j5DxSwHwThCEp+24Vp8gB6zD8HqxiF+vyLIsqyqnjZ0tLsFAILeZ18f8tR0wda2kiSj1Pho66gfLGEskU5VqNRgIVCrVaCRi3KdSrVYqVb03P6HOfu/UmkVdamlCbX2eNvaWFSEOfaonC888HvfS8orb5TJeoGn8ftuMBzR2IjY6IklWWVbqsqwv8uB0OKjHv+vtI8baVoRgjJXKZeO0bdQjg4Z16twul95BphNljP4RunLpot7XRp9dOtDvb3tnJMnqdDgz2ey7trrJsrK4vEwjU/Uj14fMM8aGo0N0h3TACIQ2w9Gh56urnT1oqLuvvuIHjUbQf6WZ+fKFQrFYOjc21rlcyfG2GcMfHoLw9BzX6hM0f8fB6zAsLC7RWjCJZDKZSp+fnLBJEnWjoEB1u1z79uZfWYvrP9P9ezKd/ur6dcZYMp2+Nj3dtr+syGOxmD5s3+/z1Wq1vXqdLmTs9TXrXd8r4ySfOhq2OBAO0/tG4olkpVI94vRpOho6QsdGQ1OMfQsPRY8K9PujkQjn3OvtoxuRu/cf0A7D0aELU5PGklOg3x8bHdGfgXLX+M7cvf+QuiO2vZZ+spw37ty9d+vm13ohSe9ke+OL6/obbuyqqne17ZzybadSMQ7ge1sHVyOvt+/PX9+IJ5LhYJB6dcqyrFZUfbYH6qqqKMpGLkez97E3O8d2Tq9D0760DZWZf/yE+hKn0us0iKhYKk2Mj+nTeTPGyuXtx08X6APZ+WV5v6WaQFgIwtNzXKtPRAYH2YHrMDQanAKPMUaDwX1eb6lcdjgcPm/fJueMMercr6/Bpl9bqd5Mr7nNZDdUldP4ZVXlenZSt3V9vaeNXI4xViyVHA5HsVQaGY7GRkeo3oyOljHGOecdA/JI54pFrGMKyiuXLqbS65cvXpCs0vLK6sT4WKm8/XrpjMvvVEdK9cB6QtP/H8zMjESjoyMj9FaoKt+3dnQ9k61Uq9evXd3IbU6eG+ecP1l4dnX6Ck11HQoGqHMpnfXd+w+MxX3jaDm6yaDZuWjLXr3OOTdOnEbVm/qpcb5rs0n66hxvY8w8Yxm0s2j4rqiSluo5Oz+fjLFqraaXX/UlnG58cX3fqlF9ep2zsc8284XRkeF//vBv+jDr8wo5nY5SeXst/mIgHCqVt+lXKu09WXhGi0/JikIFyrblSgCODkF4qo5l9QlJsh66DkNkcICu4zSBNdUpqVxtWx1NkqyBfn++UNALIplsllZcI/p1mcaq61c0vQBBo6l6PZ6dSoWuiTTWilZF8Hjc5e1y27SoRsVi6fadnyYnxo0lkpXVtZW1uDGeCR0k5416Xf7x3n2nw+nxuN/pwke94elNSKXXjTWTNsm2VSzpqxzTRM9tDw8Hg/FEwuN2J5Kpulxfer5C84DrpTE6a+NKe+cnJ2iBns18gX6ggh39a70u05wAc/O/UMkvnkg6HY5QMPBwZpaGHOiNkbIs2yQbze+q8+03GiHQ7794fuqAVSb++cO/abpO+mt2vtWdOG88nJlVuUqzHenbacwc/UwTUtO9EXs93jSXz7cNfqVZePRf9c/eQDhMs2MHAwGqz5ckqVKtUjlP5Zx+pdLezRtfNRp8dn6+3+/XD8C4XAkWgoCjQxCeqmNZfYIxdug6DJw3OOf1ury8ssoY+/L6tVJ5u1KtXpiabJuvOTY6+mThmZ4xNB0J/ZM+PRtN3jF9eZ/VDefmH9OckIyxi+en4onkWCy2Go9z3qChgbT0xHomS7MwtxkIh4Yig23luWQ63e1sb8TivJHJZmllYL/f1+/3JdNpm03SD7JtFft90ZJMX16/Vq3V2noYUjkjkUx5+7xul2tu/rGxDVLndDqGIoOl8vbUxESxVPK43W6Xq1QuS1KIrv6VStU40bkkSTQjwbOl5derVr3R+UWSJEmyqlylomSlUvW43fqJpNczxkWpmOHWRD/sg0/ZSJ8Hrt/vL5bKwUCA6myP8iSSZP321je37/wkSdLV6SvLK7/e3DjZr5WQDodjcmK886bH7/MmU2nju03zGBjTlISDwfuPZmgyd2NS6vPN6ltqtV273f5wZrbf76fpAPV/Ws9kGWOdHyqAAyAIT9WxrD5Bk3ccsA6DPmW+0+H0+3zZjZy+akznetleb5/H46a5sBcWFwfCIb0Jh3M+OTH+89x856yhurOxUc4bi8vLY7FYqbzt93mDgcBGbjNfKGwVi9Rlxm630+08dZah2b0ZY6rKVc7bLliZ7Eavx0PxbAxCWlApOhRxu1zxRHIjt0klV+qGs1Op/Onq9KHXPq+3T1YUmriuDeeNTHaDYmnf852ZnYsORaiQEQwEGg1O87KGgoFR10itVkul1xVFUbm6byntYHpluPF2h705BybNQ12X5bYJzw4ocBvOjjscDo/bTbOWe9zu1Xj8wtSkcRL2o5Mka2GraJwkpS7LxWIpHNxnCmzJKvV6PDQhKmOM5gjdtznW6+0L9Ptp+lbjdr/fp3JeL5Xqddnj+TUg44kETTeTLxSMldjUNK5y/t6TqIGAEISn6lhWn4gORcKh0AHrMLhdLppYizEWDAS6nc6r01dK5XJdlqnprq2t7sLU1N37DzZym07nG2Me9BwqlbfbulroDXjnJydS6fVej6cuy3QNCgYCA+HQWvyFTbIZu0V4PG6q1KrXZSoztV3vGGOKoiwuL391/brL1eN0Oiie9YOhQuHS8orf79P7tuQLhY1c7vzkxFHqwThvGEtUVJXXtk9uc3PfrjoqV+t1mVLH6XTQyjuMsWKxRH1WJUmKJ5LGBfx01VrNOIHce8hkN+pynWYNpZ6rB+xc2Cq21Ytyzm2SFAwEFpeXy+Vtep5yebsu19+7/rCzSPc2N298SWVi1tFrWkfdl2iRr30HlsiyTMVlxpjb5SqWSnQn5Ha5jD3F6E7C43Zj8SM4OnxWPoIPX30ic+A6DMb1walGizFmt9vv3n9AgygGwqG2GdQkSdqpVCRJ2neqa59h2szOcYSr8fiwb4i6/9FID1oFcPxszPgk+npGKlf1a6gx4Gno2FgsRivaUDFXkiQ9j+cfP2aM0WAymse5Uq1u5HI0f2nnG6K3hOlb9HeDMXb3/kOaP7Nc3q7WavqrUG+jzXyhWCrpSw8yxqiXKbXz0Vukr5BOOwyEQ8+Wlv909beOtcPRISqjr8UTdPzhUCgYCIwMR9tCUa8A1+ePNlIUZS3+guaYNm5fWV2jAGjrAKz3i0kkUxQMW8XS2dioJFkHwmE62b/99S+JZGokGt03MOYfP2kbCWpENcy0huXrLfK+Vd+d6Eg6t9O81fT5p3GcsixLkmR8Cf1dCgYCtBwxY8zl6klnMpxzGkpLO9CXiDqsvsd89CAaBOGpOrnVJ9rWYTBe3RRFocu6ylWP5L5+7erK6lqpXHa5emgdIs75cHTo5o0vE8nUj/fu03iMIw7vc7l6/vz1jbn5x6vxuE2yUerQorvJdJrWl0gkU51VsqRYLCWSKRqNQKsGjo4Mc87n5h/fvPHl1ekrc/O/FEul6cuXafU4/W3s9XhoSmXqZ9j5zFTJTMv0dJp//GQgHKJSJmOMFh+n6z5VjY6ODFeqVX1lc0INfvSWyrJCGUNj5mjS7V6PJ7eZ10clRgYH84UCTfb91fXrpXJ5cXk5lV43LnnBOee8YZNs1Dcnnkhyzo2D6BVFmZt/7PG4aa1a41lQKyx7c/hE25rAkiRRyY/eCv102tbdbbNVLHYOlSH6TYyxQC93FO7b0PtstUrGOmdZUfQ/j7GkSKdAq1joXYIP6BRKy2C1TfupKEoylb7xxfX7j2YQhHAwBOHpOa7VJ2hJNtr+tnUYaDGBgXCIfvB43NGhCJWxqMv+cHTonz/8u9/vN45dGx0ZpkxKpdfX4i+OMnULzbPMOR+LxYqlEhXaaKm5RDJFqV+pVvVVZBljakU1/lqpVimPb938mgqp42Nnt4olKrPevPHV/OPHj36epaUVqEVQ5epAOHzwgu90Yd23uDMzO7dTqVQqVRqOqaq82+lMptPG0idjbPryJUVR9FXX9+p1h91Of0daoYmWjXU6HBu5TfqrjY4Mr6yuUWmVmnIZY/oyRi5XT2RwMJPNrsbjegjpnVf1vjlFxujA2OvZUvx+H13KrVap2+lcXlmlchK1wlIZ99tb3xhjMl8o0Jj685MTpXJ5LBbLFwqdS1voNajGgQ2/3kN0vLdUaPN43NFI5P6jGZpcu1bbpWpMvSxL76G+BIokSfoaEcY/x3B0qG21DVooSuf19g2EQ7TCMGOsUq22LfJnRDeL+seeMWa32wcHwvcfzQwOhN/2KACCSbd/X46y+sSh6zBQdxKbJA1FBttm4VIUZT2TbbvifwjqiKivfpAvFIqlsn4DnkimDrh46Y7S4ZMWF/R43H6f19vn/ZAWIP2o9F4t1LGzrfxHlNeda4wrJ9CyGPo+meyG8RTyhYJklaq1msNh3/dQqbGT7jmoHL/vQfq83nQm0zYLnWLo7HPExRyOEdWc03RFlO50J8QYO6HOKZw3EskkLQnZtq5F2ySC9L2gjz26jMI7QRACAIDQsPoEAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgNAQhAAAIDUEIAABCQxACAIDQEIQAACA0BCEAAAgNQQgAAEJDEAIAgNAQhAAAIDQEIQAACA1BCAAAQkMQAgCA0BCEAAAgtP8PvKbLdDGO//AAAAAASUVORK5CYII=`,
   },
+
 };
diff --git a/src/renderer/lang/en.js b/src/renderer/lang/en.js
index 5da6352..90966b8 100644
--- a/src/renderer/lang/en.js
+++ b/src/renderer/lang/en.js
@@ -522,5 +522,18 @@ export default {
     nodata: "NO DATA",
     waitCalculate: "Please wait",
     dropBg: `data:image/png;base64,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`,
-  }
+  },
+  recorder: {
+    startRecording: "Start Recording",
+    stopRecording: "Stop Recording",
+    recording: "Recording",
+    recordingStarted: "Recording Started",
+    recordingStopped: "Recording Stopped",
+    startFailed: "Start Recording Failed, please check permissions or usage",
+    stopFailed: "Stop Recording Failed",
+    recordingCanceled: "Recording Canceled",
+    saveFailed: "Save Recording Failed",
+    savedSuccess: "Recording Saved",
+    recordingConfirm: "Recording in progress, confirm to stop and save?"
+  },
 };
diff --git a/src/renderer/lang/ocn.js b/src/renderer/lang/ocn.js
index 393cdc5..f416dae 100644
--- a/src/renderer/lang/ocn.js
+++ b/src/renderer/lang/ocn.js
@@ -505,4 +505,17 @@ export default {
     waitCalculate: "請等待計算",
     dropBg: `data:image/png;base64,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`,
   },
+  recorder: {
+    startRecording: "開始錄製",
+    stopRecording: "停止錄製",
+    recording: "錄製中",
+    recordingStarted: "錄製已開始",
+    recordingStopped: "錄製已停止",
+    startFailed: "啟動錄製失敗，請檢查設備權限 (Please check device permissions)",
+    stopFailed: "停止錄製失敗",
+    recordingCanceled: "錄製已取消",
+    saveFailed: "保存錄製失敗",
+    savedSuccess: "錄製已保存",
+    recordingConfirm: "正在錄製中，確定要停止並保存嗎？"
+  },
 };