diff --git a/collector/.gitignore b/collector/.gitignore index c8adfb61602a6432bcd71425fda2682344fa4ebb..6303e0308010020fc95d87b545ce1f95f5d46ff3 100644 --- a/collector/.gitignore +++ b/collector/.gitignore @@ -51,6 +51,13 @@ pipeline.db # 手套工具包(第三方 SDK 本地参考,永远不上传) stouch_glove_toolkit-Stouch_Glove_Toolkit-beta/ + +# 夹爪上位机程序及原生资源(同手套工具包策略,整个目录不上传) +online/ +# 夹爪随包交付的原生资源(从 online/ 镜像而来:厂商 SDK/二进制/ORBvoc.txt 共 785MB, +# ORBvoc.txt 单文件 138MB 超 GitHub 100MB 限制,且为第三方二进制,不入库) +# 触觉 Sightac SDK 例外:core/gripper/sightac_sdk/ 已 pyarmor 加密,随包入库 +core/gripper/native/ lite_package/* !lite_package/start_lite.bat !lite_package/start_lite.sh diff --git a/collector/README.md b/collector/README.md index 9d1a99e2d35bfce88392fb852a31fcfed5891888..aba2b8713014923408c9d35f93f761c825c8c87a 100644 --- a/collector/README.md +++ b/collector/README.md @@ -1,6 +1,6 @@ # collector — Multimodal Data Acquisition SDK · 多模态数据采集 SDK -![Version](https://img.shields.io/badge/version-1.2.0-blue) +![Version](https://img.shields.io/badge/version-1.3.0-blue) ![Python](https://img.shields.io/badge/python-3.12-blue) ![License](https://img.shields.io/badge/license-TBD-lightgrey) @@ -361,6 +361,27 @@ are documented in [docs/index.md](docs/index.md#开发约定). ### Changelog +- **v1.3.0** — UMI gripper support (Fays S80M stereo SLAM pose/trajectory + + Sightac left/right tactile force with 250×250 force matrix + DECXIN + RGB; gripper group in the device panel, hidden when native resources + are absent), dual-gripper recording (rig1 keeps the legacy slot/column + contract, rig2 is prefixed `gripper_2_`; per-rig CPU affinity + partitions with zero shared physical cores + dedicated raw-stream core + + 30 fps empty-bucket watchdog). SLAM pose convention corrected for + the new ORB core (X=right / Y=forward / Z=up, pose relativized to the + origin — no first-frame jump). Stereo preview steady at 15 fps with + automatic raw-stream reconnect; trajectory merged into the episode + parquet instead of a txt sidecar. The gripper no longer depends on + `online/`: native resources mirrored to `core/gripper/native/` (not + committed), Sightac SDK shipped pyarmor-encrypted, + `tools/import_gripper_calibration.py` imports per-serial calibration + for a new gripper. Multiple S80M cameras distinguished by serial / + USB topology path +- **v1.2.1** — large-file upload no longer killed by the 10 s timeout + (the send-body phase used the connect timeout; now uses a read-timeout + window); closing the upload dialog lets the task finish in the + background (manual uploads share the main window queue, duplicates + skipped) - **v1.2.0** — minimal one-click deployment edition (`start_lite.bat/.sh` + `venv_lite` whitelist env, ~750 MB): connect devices → record → upload only — no login/playback/task page/skeleton solving. Devices: D435 @@ -699,6 +720,20 @@ i18n 文案经 `tr()` 翻译、PyQt5 信号参数用 `object` 封送大整数、 ### 更新记录 +- **v1.3.0** — 新增 UMI 夹爪全链接入(Fays S80M 双目 SLAM 位姿/轨迹 + + Sightac 左右触觉力与 250×250 力矩阵 + DECXIN RGB;设备面板夹爪分组, + 原生资源缺失时自动隐藏),支持双臂双夹爪同录(rig1 旧槽位/数据列契约 + 不变,rig2 加 `gripper_2_` 前缀;两 rig 独立 CPU 亲和分区零共享物理核 + + raw 流专用核 + 30fps 空桶看门狗)。SLAM 位姿坐标约定按新 ORB 核修正 + (X=右 / Y=正对 / Z=上,原点后姿态相对化,起始不跳变)。左目显示稳 + 15fps(奇偶抽帧)且 raw 流断线自动重连;轨迹并入 episode parquet 列, + 不再落 txt 侧车。夹爪脱离 `online/` 自持:原生资源镜像到 + `core/gripper/native/`(不入库),Sightac SDK pyarmor 加密随包, + 新增 `tools/import_gripper_calibration.py` 搬入新夹爪 per-serial 标定。 + 多台 S80M 按序列号 / USB 拓扑路径区分 +- **v1.2.1** — 修复大文件上传被 10 秒误杀(发送阶段 socket 超时错用连接 + 超时,现改用读超时窗口);上传对话框关闭后任务在后台继续完成(手动上传 + 并入主窗口共享队列,重复提交自动跳过) - **v1.2.0** — 新增极简一键部署采集版(`start_lite.bat/.sh` + `venv_lite` 白名单依赖,约 750MB):只做连接设备→采集→上传,无登录/回放/任务页/ 骨架解算。设备:D435(1280×720@30 RGB / 848×480@30 深度)、UVC 摄像头 diff --git a/collector/config/__init__.py b/collector/config/__init__.py index 94bb4dd0a075b3b11aad1269ff2f703ff9839f3b..5e32f278056694b1a1bd4791d2c98613e74637d6 100755 --- a/collector/config/__init__.py +++ b/collector/config/__init__.py @@ -3,4 +3,4 @@ 版本号集中定义于此:settings.APP_VERSION 及其他模块均从这里取值。 """ -__version__ = "1.2.1" # 修复大文件上传被 10 秒误杀(urllib3 发送请求体阶段 socket 超时错用连接超时,服务器慢读停顿超 10s 即 Connection aborted,现已改用读超时窗口);上传对话框关闭后任务在后台继续完成(手动上传并入主窗口共享上传队列,重复提交自动跳过)。 \ No newline at end of file +__version__ = "1.3.0" # 新增 UMI 夹爪全链接入(Fays S80M 双目 SLAM 位姿/轨迹 + Sightac 左右触觉力与 250×250 力矩阵 + DECXIN RGB;面板夹爪分组、资源缺失自动隐藏),支持双臂双夹爪同录(rig1 旧槽位/数据列契约不变,rig2 加 gripper_2_ 前缀;两 rig 独立 CPU 亲和分区零共享物理核 + raw 流专用核 + 30fps 空桶看门狗);SLAM 位姿坐标约定按新 ORB 核修正(X=右/Y=正对/Z=上,原点后姿态相对化,起始不跳变);左目显示稳 15fps(奇偶抽帧)且 raw 流断线自动重连;轨迹并入 episode parquet 列不再落 txt 侧车;夹爪脱离 online/ 自持(原生资源镜像 core/gripper/native/ 不入库、Sightac SDK pyarmor 加密随包、新增 tools/import_gripper_calibration.py 接入新夹爪标定);多台 S80M 按序列号/USB 拓扑路径区分(--device-serial/--device-path)。 \ No newline at end of file diff --git a/collector/config/i18n.py b/collector/config/i18n.py index 2fb1f74d2ec3eb97259aa2d5c76449ed622539ae..1a67f2d5fdd6c0f74bb340d28c170ad0982bd0ef 100755 --- a/collector/config/i18n.py +++ b/collector/config/i18n.py @@ -404,6 +404,33 @@ _TRANSLATIONS = { "✅ 第 {}/{} 条上传完成: {}": {"en": "✅ #{}/{} uploaded: {}", "zh": "✅ 第 {}/{} 条上传完成: {}"}, "✅ 上传完成: {}": {"en": "✅ Uploaded: {}", "zh": "✅ 上传完成: {}"}, "[上传失败] {}: {}": {"en": "[Upload failed] {}: {}", "zh": "[上传失败] {}: {}"}, + + # ── 上传硬化(进度可见 / 续传 / 清理 / 退出确认)────── + "⏳ {}(上传中 {}% · {})": {"en": "⏳ {} (uploading {}% · {})", "zh": "⏳ {}(上传中 {}% · {})"}, + "⏳ {}(排队中)": {"en": "⏳ {} (queued)", "zh": "⏳ {}(排队中)"}, + "☁ 开始上传: {}": {"en": "☁ Upload started: {}", "zh": "☁ 开始上传: {}"}, + "☁ [{}] {}": {"en": "☁ [{}] {}", "zh": "☁ [{}] {}"}, + "☁ [{}] 上传中… {}%": {"en": "☁ [{}] uploading… {}%", "zh": "☁ [{}] 上传中… {}%"}, + "☁ 恢复未完成的上传: {}": {"en": "☁ Resuming unfinished upload: {}", "zh": "☁ 恢复未完成的上传: {}"}, + "☁ 已恢复 {} 个未完成的上传任务": {"en": "☁ Resumed {} unfinished upload task(s)", "zh": "☁ 已恢复 {} 个未完成的上传任务"}, + "☁ 跳过恢复 {}: {}": {"en": "☁ Skipped resuming {}: {}", "zh": "☁ 跳过恢复 {}: {}"}, + "☁ {} 已在服务器上,无需重传: {}": {"en": "☁ {} is already on the server, no re-upload needed: {}", "zh": "☁ {} 已在服务器上,无需重传: {}"}, + "🧹 已清理上传残留临时文件 {} 个": {"en": "🧹 Cleaned up {} leftover upload temp file(s)", "zh": "🧹 已清理上传残留临时文件 {} 个"}, + "本地文件不存在": {"en": "local files are gone", "zh": "本地文件不存在"}, + "服务器地址已变更": {"en": "server address changed", "zh": "服务器地址已变更"}, + "已上传完成": {"en": "already uploaded", "zh": "已上传完成"}, + "已在队列中": {"en": "already queued", "zh": "已在队列中"}, + "上次进程中断前已入库": {"en": "already stored before the last shutdown", "zh": "上次进程中断前已入库"}, + "POST 返回失败但服务器已入库": {"en": "POST failed but the server already stored it", "zh": "POST 返回失败但服务器已入库"}, + "上传中断但服务器已入库": {"en": "upload interrupted but the server already stored it", "zh": "上传中断但服务器已入库"}, + "服务器上已存在本次会话,按成功处理({})": { + "en": "This session already exists on the server; treated as success ({})", + "zh": "服务器上已存在本次会话,按成功处理({})", + }, + "有 {} 个上传任务未完成,确定退出?未完成的任务将在下次启动时自动恢复。": { + "en": "{} upload task(s) still unfinished. Quit anyway?\nThey will be resumed automatically on the next start.", + "zh": "有 {} 个上传任务未完成,确定退出?未完成的任务将在下次启动时自动恢复。", + }, "发布时间:": {"en": "Published:", "zh": "发布时间:"}, "请在任务选择页面选择一个任务。": {"en": "Please select a task on the task selection page.", "zh": "请在任务选择页面选择一个任务。"}, "任务进度已更新: {} ({}/{})": {"en": "Task progress updated: {} ({}/{})", "zh": "任务进度已更新: {} ({}/{})"}, diff --git a/collector/config/settings.py b/collector/config/settings.py index 5262e4613a6fd31448153ee6c89e50f3c4534064..223f096d0293480d137665892c62f371905f3842 100755 --- a/collector/config/settings.py +++ b/collector/config/settings.py @@ -11,6 +11,7 @@ from config import __version__ as APP_VERSION # 版本号唯一定义在 confi BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) DATA_DIR = os.path.join(BASE_DIR, "data") RECORDINGS_DIR = os.path.join(DATA_DIR, "recordings") +LOGS_DIR = os.path.join(BASE_DIR, "logs") DB_PATH = os.path.join(DATA_DIR, "pipeline.db") KEYPOINTS_OUTPUT_DIR = os.path.join(BASE_DIR, "keypoints_output") @@ -460,6 +461,12 @@ UPLOAD_AUTO_SYNC = load_upload_auto_sync() # 录制完成后是否自动上 UPLOAD_DELETE_AFTER = load_upload_delete_after() # 上传成功后是否删除本地文件(持久化,启动时从 server_config.json 读取) UPLOAD_PRECOMPRESS_VIDEO = True # 上传前是否把 videos 重编码到低码率。开=HEVC(libx265) CRF 档再压(tools/hevc_test 实测 CRF30 体积约原录制件的 7%、SSIM 0.967;大会话必备)。关=原样上传 CRF23 录制品(无二代有损;60min 双目 ~7.6GB,上传带宽/后端超时需能承受) UPLOAD_VIDEO_CRF = 30 # HEVC 目标码率档(x265 CRF 越大越小;30 实测体积约 7%;仅 UPLOAD_PRECOMPRESS_VIDEO=True 时生效) +UPLOAD_SESSION_SNAPSHOT_LIMIT = 200 # 上传前后拉取的会话列表条数("POST 是否已入库"的判据;服务器现有 ~26 条) +UPLOAD_RESUME_MAX_AGE_HOURS = 24 # 启动续传窗口:更早的未完成上传不再自动重传 +UPLOAD_RESUME_SKEW_TOL_S = 60.0 # 续传判定容忍的客户端/服务器时钟差(秒) +UPLOAD_TMP_SWEEP_AGE_HOURS = 24 # 启动清理残留上传临时文件的年龄门槛(小时) +UPLOAD_INFLIGHT_REFRESH_MS = 1500 # 上传对话框 ⏳ 状态刷新间隔(毫秒) +UPLOAD_LOG_THROTTLE_S = 10.0 # 主窗口上传进度日志节流(秒) # ── 任务服务配置 ────────────────────────────────────── TASK_POLL_INTERVAL_MS = 30000 # 任务轮询间隔(毫秒) @@ -476,3 +483,15 @@ HAND_DET_DEVICE = "cuda" # 检测器设备 ("cuda" / "cp HAND_POSE_DEVICE = "cuda" # 关键点设备 ("cuda" / "cpu") HAND_TRACK_MAX_HANDS = 2 # 最多追踪手数 HAND_DATA_DIM = 21 * 2 * 2 + 4 * 2 + 1 # 展平后数据维度 + +# ── UMI 夹爪(core/gripper 包;原生资源随包在 core/gripper/native/, +# 缺失时设备隐藏)─ +GRIPPER_SLOT_STEREO_L = "gripper_stereo_left" # s80m 左目(桥接 raw 流,仅显示不录制) +GRIPPER_SLOT_RGB = "gripper_rgb" # DECXIN 1280×960@30 +GRIPPER_SLOT_POSE = "gripper_pose" # SLAM 轨迹视图槽 +GRIPPER_SLOT_FORCE_L = "gripper_force_left" # Sightac 左(热力图+力曲线) +GRIPPER_SLOT_FORCE_R = "gripper_force_right" # Sightac 右(热力图+力曲线) +GRIPPER_STEREO_DISPLAY_FPS = 15.0 # 左目显示节流(SLAM 取帧在桥接进程内保持 30fps) +GRIPPER_SLAM_READY_TIMEOUT_S = 45.0 # wait_sdk_ready 上限(SDK 运行时重读标定) +GRIPPER_FORCE_MATRIX_DIM = 250 # 触觉力矩阵边长(250×250×3 int16 行差分) +GRIPPER_TACTILE_MATRIX_MATERIALIZE = False # 矩阵逐帧拷回主进程开关(默认子进程直写) diff --git a/collector/core/api_client.py b/collector/core/api_client.py index c875f64b5c443d6ca9efc2255cea56df10ecff93..c463575e64fb697b2f7a9e709c1367ab0fd011da 100755 --- a/collector/core/api_client.py +++ b/collector/core/api_client.py @@ -12,18 +12,46 @@ HTTP API 客户端 —— 对接 Data Acquisition 服务器。 from __future__ import annotations import os +import socket import time from typing import Optional, Callable import requests import urllib3 from urllib3.util import Timeout as _Urllib3Timeout +from urllib3.util.retry import Retry as _Retry from requests.adapters import HTTPAdapter CONNECT_TIMEOUT = 10 READ_TIMEOUT = 1800 # 大会话(数 GB)上传 + 服务器解包入库可能耗时数分钟,设 30 分钟 +# TCP 保活:对端(服务器/中间网络)静默消失时,阻塞的 recv 不会自己醒。 +# 没有保活时 Linux 默认 2 小时才报错——上传线程会静默挂死(2026-09-09 +# episode-012 事故)。60+15×4 ≈ 120s 内探测到死连接并抛 ConnectionError。 +_KEEPALIVE_IDLE_S, _KEEPALIVE_INTVL_S, _KEEPALIVE_CNT = 60, 15, 4 +_TCP_LEVEL = getattr(socket, "IPPROTO_TCP", 6) +_KEEPALIVE_OPTS = [ + (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1), + (_TCP_LEVEL, getattr(socket, "TCP_KEEPIDLE", None), _KEEPALIVE_IDLE_S), # Linux + (_TCP_LEVEL, getattr(socket, "TCP_KEEPALIVE", None), _KEEPALIVE_IDLE_S), # macOS 别名 + (_TCP_LEVEL, getattr(socket, "TCP_KEEPINTVL", None), _KEEPALIVE_INTVL_S), + (_TCP_LEVEL, getattr(socket, "TCP_KEEPCNT", None), _KEEPALIVE_CNT), +] +# 常量在本平台不存在的项直接丢掉:Windows 旧版 SDK 无 TCP_KEEPIDLE/ +# TCP_KEEPINTVL/TCP_KEEPCNT,退化为仅 SO_KEEPALIVE(系统默认 2 小时)。 +_SOCKET_OPTIONS = [o for o in _KEEPALIVE_OPTS if o[1] is not None] + +# 只重试「连接阶段」错误:DNS 解析失败/连接被拒/建连超时——这些都在 +# 请求体写出任何字节之前抛出,重试不会重复发送(POST 不在 urllib3 的 +# 默认重试方法里,必须显式放行)。read=0/status=0:一旦开始发送或收到 +# 响应,绝不自动重试,交由 UploadManager 的「查服务器再决定」逻辑处理。 +_UPLOAD_RETRY = _Retry( + total=2, connect=2, read=0, status=0, redirect=0, + allowed_methods={"POST"}, backoff_factor=0, + respect_retry_after_header=False, raise_on_status=False, +) + class _PatientSendConnection(urllib3.connection.HTTPConnection): """连接子类:请求体发送阶段用读超时窗口,而不是连接超时。 @@ -49,6 +77,22 @@ class _PatientSendConnection(urllib3.connection.HTTPConnection): finally: self.timeout = saved + def connect(self): + """建连阶段固定用 CONNECT_TIMEOUT。 + + request() 已把 self.timeout 抬到 READ_TIMEOUT,新建连接若照它 + 建 TCP,则"连接超时"实际是 30 分钟(服务器不响应 SYN 时线程 + 静默挂死)。这里临时换回连接窗口,建连完成即恢复,发送阶段 + 的宽窗口不受影响。 + """ + saved = self.timeout + if isinstance(saved, (int, float)) and saved != CONNECT_TIMEOUT: + self.timeout = CONNECT_TIMEOUT + try: + super().connect() + finally: + self.timeout = saved + class _PatientSendHTTPSConnection(_PatientSendConnection, urllib3.connection.HTTPSConnection): @@ -67,6 +111,9 @@ class _PatientSendAdapter(HTTPAdapter): """把发送超时加长的连接池装入 session。""" def init_poolmanager(self, connections, maxsize, block=False, **pool_kwargs): + # socket_options 只能经连接池的 **conn_kw 传到 HTTPConnection, + # 由这里统一注入(http/https 共用本类,一处生效)。 + pool_kwargs.setdefault("socket_options", _SOCKET_OPTIONS) super().init_poolmanager(connections, maxsize, block=block, **pool_kwargs) # PoolManager 默认指向模块级 dict(多实例共享),须整体替换实例属性 self.poolmanager.pool_classes_by_scheme = { @@ -88,8 +135,9 @@ class APIClient: self._session.headers.update({"User-Agent": "DAQ-SDK/1.0"}) # 大请求体上传时发送阶段的 socket 超时改为读超时窗口, # 否则服务器慢读停顿 >10s 会误杀上传(见 _PatientSendConnection)。 - self._session.mount("http://", _PatientSendAdapter()) - self._session.mount("https://", _PatientSendAdapter()) + # max_retries 只放行建连阶段错误(见 _UPLOAD_RETRY)。 + self._session.mount("http://", _PatientSendAdapter(max_retries=_UPLOAD_RETRY)) + self._session.mount("https://", _PatientSendAdapter(max_retries=_UPLOAD_RETRY)) def close(self): if self._own_session: @@ -212,7 +260,14 @@ class APIClient: # ── 查询 ────────────────────────────────────────── - def get_sessions(self, limit: int = 50) -> list[dict]: + def try_get_sessions(self, limit: int = 50) -> Optional[list[dict]]: + """GET /api/v1/sessions;**失败返回 None**。 + + 与 get_sessions 的区别:None = 查询失败(网络/认证/非 200), + 而 [] = 服务器上确实一个会话都没有。上传前的快照必须能区分 + 这两种情况,否则查询失败会被误判成"服务器是空的",POST 失败 + 后任何一个同名会话都会被当成"新出现"而误报成功。 + """ try: r = self._session.get( f"{self.base_url}/api/v1/sessions", @@ -221,10 +276,14 @@ class APIClient: ) if r.status_code == 200: data = r.json() - return data.get("sessions", []) + return data.get("sessions", []) or [] except requests.RequestException: pass - return [] + return None + + def get_sessions(self, limit: int = 50) -> list[dict]: + sessions = self.try_get_sessions(limit) + return sessions if sessions is not None else [] def get_session(self, session_id: str) -> Optional[dict]: try: diff --git a/collector/core/device_detector.py b/collector/core/device_detector.py index 42e1c2ecbdb79ad519d7f6cf8f59832e18786c3d..60e2033ca13645e708f85b34ce4b63a1c92f091f 100644 --- a/collector/core/device_detector.py +++ b/collector/core/device_detector.py @@ -35,14 +35,15 @@ from core.camera import list_v4l_devices, _is_sdk_device @dataclass class DeviceInfo: """已连接设备的一条描述(跨线程经信号传回主线程)。""" - key: str # "uvc:{by-id前缀或索引}" | "d435:{rs serial}" | "s80m:ftdi" | "ble:{MAC}" | "usbglove:{serial}" - kind: str # "uvc" | "d435" | "s80m" | "data_ble" | "ble" | "usb_glove" + key: str # "uvc:{by-id前缀或索引}" | "d435:{rs serial}" | "s80m:{sn}" | "ble:{MAC}" | "usbglove:{serial}" | "gripper:{serial}" + kind: str # "uvc" | "d435" | "s80m" | "data_ble" | "ble" | "usb_glove" | "gripper" display_name: str # 设备内部命名(by-id 解码 / rs 权威名 / 蓝牙广播名 / USB 手套) serial: str = "" # 设备序号(无则为空串) video_index: int = -1 # UVC 设备的 /dev/videoN 索引(其它为 -1) by_id_path: Optional[str] = None # /dev/v4l/by-id 永久路径(有则填) backend: str = "" # 打开后端(开关打开后由 CameraWorker 决定,枚举时为空) address: str = "" # BLE MAC 地址 / USB 手套串口路径(非 BLE 为空串) + usb_path: str = "" # S80 相机的 USB 设备拓扑路径(如 1-3.4.1,spawn 选相机用;其余为空) rssi: int = 0 # BLE 信号强度(排序用) user_name: str = "" # 用户命名(枚举后由 MainWindow 从 device_names.json 填充) @@ -53,9 +54,11 @@ class DeviceInfo: @property def group(self) -> str: - """面板分组: "camera" | "glove" | "other_ble"。""" + """面板分组: "camera" | "glove" | "gripper" | "other_ble"。""" if self.kind in ("data_ble", "usb_glove"): return "glove" + if self.kind == "gripper": + return "gripper" if self.kind == "ble": return "other_ble" return "camera" @@ -145,10 +148,11 @@ def _list_uvc_devices_windows(max_index: int) -> List[DeviceInfo]: def _list_uvc_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[DeviceInfo]: - """UVC 网络摄像头(排除 RealSense UVC 节点与 FTDI SDK 设备)。 + """UVC 网络摄像头(排除 RealSense UVC 节点、FTDI SDK 设备与夹爪组件)。 - Linux: sysfs 只读枚举(/dev/v4l/by-id 分组,轮询安全)。 - Windows: pygrabber DirectShow 枚举(见 _list_uvc_devices_windows)。 + 夹爪组件的 Sightac/DECXIN/FTDI 相机由 libuvc 服务或 Fays 桥接独占, + 绝不作为通用 UVC 相机出现。Linux: sysfs 只读枚举(/dev/v4l/by-id + 分组,轮询安全)。Windows: pygrabber DirectShow 枚举。 """ if os.name == "nt": return _list_uvc_devices_windows(max_index) @@ -158,6 +162,8 @@ def _list_uvc_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[D continue if d.get("is_realsense"): continue + if _is_gripper_component_camera(d): + continue # key 用 by-id 前缀(跨插拔稳定);无 by-id 时退化为索引 prefix = str(d["video_index"]) if d.get("by_id_path"): @@ -198,35 +204,110 @@ def _list_d435_devices() -> List[DeviceInfo]: return [] +def _ftdi_camera_groups() -> List[dict]: + """sysfs 只读扫描 FTDI Superspeed Video Bridge 节点 → 按物理相机分组。 + + 每台 S80 相机 = 一个 FTDI USB 设备(接口 1.0 = 双目对、1.2 = IMU), + 多台接入时按 USB 设备拓扑路径分开。返回每台 + {"usb_path", "serial", "stereo_index"}(按节点名排序,不 open 设备, + 轮询安全);无 FTDI 返回 []。 + """ + v4l_root = "/sys/class/video4linux" + if not os.path.isdir(v4l_root): + return [] + groups: dict = {} + order: List[str] = [] + for name in sorted(os.listdir(v4l_root)): + vp = os.path.join(v4l_root, name) + try: + with open(os.path.join(vp, "name"), encoding="utf-8") as f: + if "FTDI Superspeed Video Bridge" not in f.read().strip(): + continue + # device 符号链接指向 USB 接口(…/1-3.4.1:1.0),basename 即 + # 接口名;父级 1-3.4.1 为 USB 设备节点,serial 文件在其下 + iface = os.path.basename(os.readlink(os.path.join(vp, "device"))) + except OSError: + continue + if not re.match(r".+:(\d+\.\d+)$", iface): + continue + usb_path = iface.rsplit(":", 1)[0] + serial = "" + try: + with open(os.path.join("/sys/bus/usb/devices", usb_path, "serial"), + encoding="utf-8") as f: + serial = f.read().strip() + except OSError: + pass + idx = int(name[5:]) if name.startswith("video") and name[5:].isdigit() else -1 + if usb_path not in groups: + groups[usb_path] = {"usb_path": usb_path, "serial": serial, + "stereo_index": -1} + order.append(usb_path) + # 双目对取接口 1.0 的第一个节点(与 read_stereo_rgb.py 口径一致) + if iface.endswith(":1.0") and groups[usb_path]["stereo_index"] < 0: + groups[usb_path]["stereo_index"] = idx + return [groups[p] for p in order] + + +def _find_s80m_by_id(video_index: int) -> Optional[str]: + """S80M 双目节点的 /dev/v4l/by-id 永久路径(无则 None)。""" + by_id_dir = "/dev/v4l/by-id" + if not os.path.isdir(by_id_dir): + return None + for entry in sorted(os.listdir(by_id_dir)): + p = os.path.join(by_id_dir, entry) + try: + if os.readlink(p) == f"../../video{video_index}": + return p + except OSError: + continue + return None + + def _list_s80m_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[DeviceInfo]: - """FTDI 命中一次即返回单条 S80M 条目(SDK 配置写死 video0/video2)。 + """每台 FTDI 命中一条 S80M 条目(多台相机按 USB 序列号区分)。 - 序号尝试从 by-id 条目解析(FT602 通常无序号 → 空串)。 + 序列号从 USB 设备节点 serial 文件读取(FTDI 出厂默认 000000000001, + 可能多台同号 → key 追加 USB 拓扑路径兜底唯一);无序列号时同样以 + USB 路径兜底。usb_path 供 spawn 传 --device-path 精确选中该相机。 + sysfs 扫描无果时退回旧版 _is_sdk_device 单条逻辑(老环境兜底)。 """ + cams = _ftdi_camera_groups() + if cams: + # 同序列号多台 → key 用 "s80m:{sn}@{usb_path}" 兜底唯一 + seen: dict = {} + for c in cams: + seen[c["serial"]] = seen.get(c["serial"], 0) + 1 + infos: List[DeviceInfo] = [] + for c in cams: + if not (0 <= c["stereo_index"] < max_index): + continue + sn, path = c["serial"], c["usb_path"] + if sn and seen[sn] == 1: + key = f"s80m:{sn}" + else: + key = f"s80m:{sn}@{path}" if sn else f"s80m:usb-{path}" + infos.append(DeviceInfo( + key=key, + kind="s80m", + display_name=f"FaysSense S80M ({sn or path})", + serial=sn, + video_index=c["stereo_index"], + by_id_path=_find_s80m_by_id(c["stereo_index"]), + usb_path=path, + )) + return infos + # 兜底:sysfs 名称不符的老环境退回旧版单条逻辑(key 保持 s80m:ftdi) for i in range(max_index): if not _is_sdk_device(i): continue - serial, by_id_path = "", None - by_id_dir = "/dev/v4l/by-id" - if os.path.isdir(by_id_dir): - for entry in sorted(os.listdir(by_id_dir)): - p = os.path.join(by_id_dir, entry) - try: - if os.readlink(p) == f"../../video{i}": - parsed = _parse_by_id_entry(entry) - if parsed: - serial = parsed.get("serial", "") - by_id_path = p - break - except OSError: - continue return [DeviceInfo( key="s80m:ftdi", kind="s80m", display_name="FaysSense S80M", - serial=serial, + serial="", video_index=i, - by_id_path=by_id_path, + by_id_path=_find_s80m_by_id(i), )] return [] @@ -347,20 +428,28 @@ def _list_ble_devices() -> List[DeviceInfo]: def detect_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[DeviceInfo]: - """五段枚举(UVC + D435 + S80M + BLE + USB 手套),各自容错,整体不崩。""" + """六段枚举(UVC + D435 + S80M + BLE + USB 手套 + UMI 夹爪),各自容错。""" devices: List[DeviceInfo] = [] + gripper_devices: List[DeviceInfo] = [] try: - devices += _list_uvc_devices(max_index) + gripper_devices = _list_gripper_devices() except Exception: - pass + gripper_devices = [] try: - devices += _list_d435_devices() + devices += _list_uvc_devices(max_index) except Exception: pass try: - devices += _list_s80m_devices(max_index) + devices += _list_d435_devices() except Exception: pass + if not gripper_devices: + # 单设备架设:夹爪在场时其 s80m 只经 ORB 桥接进程打开, + # 隐藏通用 S80M 条目,避免同一 FT602 被两个通道双开。 + try: + devices += _list_s80m_devices(max_index) + except Exception: + pass try: devices += _list_ble_devices() except Exception: @@ -369,6 +458,7 @@ def detect_devices(max_index: int = settings.DEVICE_SCAN_MAX_INDEX) -> List[Devi devices += _list_usb_glove_devices() except Exception: pass + devices += gripper_devices return devices @@ -457,6 +547,63 @@ def _list_usb_glove_devices() -> List[DeviceInfo]: return infos +# ── UMI 夹爪 ────────────────────────────────────────── + +_GRIPPER_USB_VID = 0x303A # Espressif ESP32-S3(CDC-ACM 控制板) +_GRIPPER_USB_PID = 0x1001 +# 夹爪组件相机(Sightac 触觉 ×2 / DECXIN RGB / Fays FT602),libuvc 服务与 +# Fays 桥接独占,绝不进通用 UVC 列表 +_GRIPPER_COMPONENT_UVC = {("0c45", "636f"), ("1bcf", "2d4f"), ("0403", "602e")} + + +def _is_gripper_component_camera(d: dict) -> bool: + """按 VID/PID 识别夹爪组件相机;VID/PID 缺失时用 by-id 字符串兜底。""" + vid = str(d.get("vid") or "").lower() + pid = str(d.get("pid") or "").lower() + if vid and pid: + return (vid, pid) in _GRIPPER_COMPONENT_UVC + by_id = (d.get("by_id_path") or "").lower() + name = (d.get("name") or "").lower() + return any( + token in by_id or token in name + for token in ("0c45_636f", "1bcf_2d4f", "0403_602e", + "sightac", "decxin", "ftdi superspeed") + ) + + +def _list_gripper_devices() -> List[DeviceInfo]: + """枚举 UMI 夹爪控制板(303A:1001);原生资源缺失时隐藏整类。 + + 资源缺失(core/gripper/native/ 未随包交付)返回 [],夹爪条目与组件 + 相机排除同时消失,主程序退化为纯手套模式(P0 验证:改名 native/ + 后条目消失)。 + """ + try: + from core.gripper import paths + if not paths.gripper_resources_available(): + return [] + except Exception: + return [] + try: + import serial.tools.list_ports + except ImportError: + return [] + infos: List[DeviceInfo] = [] + for port in serial.tools.list_ports.comports(): + if port.vid != _GRIPPER_USB_VID or port.pid != _GRIPPER_USB_PID: + continue + serial = (port.serial_number or "").strip() + key = f"gripper:{serial}" if serial else f"gripper:{port.device}" + infos.append(DeviceInfo( + key=key, + kind="gripper", + display_name="UMI 夹爪", + serial=serial, + address=port.device, + )) + return infos + + class DeviceScanner(QObject): """后台线程扫描设备(sysfs 只读),经排队信号回主线程。 diff --git a/collector/core/device_manager.py b/collector/core/device_manager.py index f2e607fc591b6afbd94374aba2523b86f123a9c1..2c34b0810bde945982b5dd37df30f8eb75f48e6d 100644 --- a/collector/core/device_manager.py +++ b/collector/core/device_manager.py @@ -10,9 +10,10 @@ 注册表级纯口径(离线测试直接注入假条目即可) 注册表条目形状(与旧主窗口 _workers 口径一致): - kind ∈ {"uvc", "d435", "s80m", "data_ble", "ble"} + kind ∈ {"uvc", "d435", "s80m", "data_ble", "ble", "gripper"} d435/s80m 条目由各自 manager 的 new_entry 构造 - (core.d435_manager / core.s80m_manager),uvc/ble/glove 骨架由本类构造。 + (core.d435_manager / core.s80m_manager),uvc/ble/glove/gripper + 骨架由本类构造。 """ from __future__ import annotations @@ -49,6 +50,13 @@ class DeviceManager: "sensor_column": role, "glove": glove_widget, "label": label} + @staticmethod + def gripper_entry(slots, label: str, serial: str = "") -> dict: + """UMI 夹爪条目:6 个网格槽 + ESP 序列号(fays_serial 开链后回填)。""" + return {"kind": "gripper", "slots": list(slots), + "label": label, "serial": serial, + "fays_serial": "", "sensor_columns": []} + # ── 查询 ── def get(self, dev_key: str) -> dict | None: return self.entries.get(dev_key) @@ -90,13 +98,18 @@ def build_device_meta(entries: dict) -> list: "slots": [], "sensor_column": e.get("sensor_column", "")}) continue - if e["kind"] not in ("uvc", "d435", "s80m"): + if e["kind"] not in ("uvc", "d435", "s80m", "gripper"): continue d = {"key": key, "kind": e["kind"], "name": settings.device_name(key) or e.get("label", ""), "slots": list(e.get("slots", []))} if e.get("serial"): d["serial"] = str(e["serial"]) + if e["kind"] == "gripper": + if e.get("fays_serial"): + d["fays_serial"] = str(e["fays_serial"]) + if e.get("sensor_columns"): + d["sensor_columns"] = list(e["sensor_columns"]) meta.append(d) return meta diff --git a/collector/core/egodata_writer.py b/collector/core/egodata_writer.py index ac3f6d92b258e1843a91c68a8cf38e1ab87d4de7..3774b6376c060f241f3cf745be7aa63b91b3e0a5 100644 --- a/collector/core/egodata_writer.py +++ b/collector/core/egodata_writer.py @@ -158,6 +158,7 @@ class EgoDataWriter(QObject): self._present_sensors: set = set() self._present_imu: bool = False self._present_glove_imu: set = set() # USB 手套 IMU 稀疏列(按传感器名) + self._present_gripper: set = set() # UMI 夹爪稀疏列(slam_pose/state/force/matrix) # 深度多槽位(D435 第 n 台 = d435_depth[_n];S80M 传统路径兜底 # settings.CAMERA_DEPTH):槽位键 → depth image_key self._depth_slots: Dict[str, str] = {} @@ -349,6 +350,7 @@ class EgoDataWriter(QObject): self._present_sensors = set() self._present_imu = False self._present_glove_imu = set() + self._present_gripper = set() self._reset_stats() self._last_task = task_name @@ -546,7 +548,8 @@ class EgoDataWriter(QObject): hardware_ns: int = 0, imu_samples: Optional[List] = None, glove_imu: Optional[Dict[str, tuple]] = None, - glove_kpts: Optional[Dict[str, np.ndarray]] = None): + glove_kpts: Optional[Dict[str, np.ndarray]] = None, + gripper: Optional[Dict] = None): """写入一行到 data parquet 缓冲区。 Args: @@ -565,6 +568,12 @@ class EgoDataWriter(QObject): glove_kpts: {传感器名: 63×f32 骨架关键点(21×3 米)} USB 手套骨架快照,回填恒写的 observation.{left,right}_hand_pose 占位列 + gripper: UMI 夹爪稀疏快照(P3/P4),键值: + slam_pose [x,y,z,qx,qy,qz,qw] + gripper_state [open_pct, gripped, fz_mn] + gripper_{left,right}_force [fx,fy,fz] mN + gripper_{left,right}_force_matrix int16 行差分 + 量化变长列表(P4 泵线程预编码,无新样本不写键) """ sensors = sensors or {} row = { @@ -629,6 +638,32 @@ class EgoDataWriter(QObject): row[f"observation.{side}_hand_pose"] = [ float(v) for v in k] + # UMI 夹爪稀疏列(P3/P4):本 episode 出现过的列才建列。 + # 键按后缀定类型(_slam_pose=7f32 / _state/_force=3f32 / + # _force_matrix=int16 行差分变长,P4 泵线程预编码后原样落盘); + # 双夹爪 rig2 带 "gripper_2_" 前缀,rig1 旧键(slam_pose / + # gripper_state / gripper_left_force…)契约不变。无新样本不写键。 + for key, value in (gripper or {}).items(): + if value is None: + continue + if key.endswith("_force_matrix"): + row[f"observation.{key}"] = value + elif key.endswith("slam_trajectory"): + # 本帧窗口内全部轨迹点的扁平 8 值列表 + # [t,x,y,z,qx,qy,qz,qw]×N(float64 原样落盘) + row[f"observation.{key}"] = value + elif key.endswith("slam_pose"): + # 后缀不带下划线:rig1 旧键是裸 "slam_pose"(无前缀), + # rig2 为 "gripper_2_slam_pose" + row[f"observation.{key}"] = [ + float(v) for v in value[:7]] + elif key.endswith("_state") or key.endswith("_force"): + row[f"observation.{key}"] = [ + float(v) for v in value[:3]] + else: + continue # 未知键不落盘,防静默错型 + self._present_gripper.add(key) + cs = connection_status or {} for did in self._device_ids: row[f"status.{did}"] = cs.get(did, "connected") @@ -795,6 +830,23 @@ class EgoDataWriter(QObject): cols[name_v] = pa.array( [r.get(name_v, [0.0] * 16) for r in rows], pa.list_(pa.float32(), 16)) + # 稀疏 UMI 夹爪列(slam_pose/state/force 定长;matrix 变长 int16) + for key in sorted(self._present_gripper): + name = f"observation.{key}" + if key.endswith("_force_matrix"): + cols[name] = pa.array( + [r.get(name, []) for r in rows], pa.list_(pa.int16())) + elif key.endswith("slam_trajectory"): + cols[name] = pa.array( + [r.get(name, []) for r in rows], pa.list_(pa.float64())) + elif key.endswith("slam_pose"): + cols[name] = pa.array( + [r.get(name, [0.0] * 7) for r in rows], + pa.list_(pa.float32(), 7)) + else: # _state / _force + cols[name] = pa.array( + [r.get(name, [0.0] * 3) for r in rows], + pa.list_(pa.float32(), 3)) # 手部关键点占位列(后处理回填,恒写) for pose_name in [settings.HAND_POSE_LEFT, settings.HAND_POSE_RIGHT]: name = f"observation.{pose_name}" @@ -906,6 +958,24 @@ class EgoDataWriter(QObject): "dtype": "float32", "shape": [16, 4]} features[f"observation.{sn}_imu_valid"] = { "dtype": "float32", "shape": [16]} + # UMI 夹爪(P3/P4):定长 f32 列 + 变长 int16 行差分量化的力矩阵 + for key in sorted(self._present_gripper): + if key.endswith("_force_matrix"): + features[f"observation.{key}"] = { + "dtype": "int16", + "shape": [settings.GRIPPER_FORCE_MATRIX_DIM] * 2 + [3], + "encoding": "row_diff_quantized", + } + elif key.endswith("slam_trajectory"): + features[f"observation.{key}"] = { + "dtype": "float64", "shape": [8], + "encoding": "flat_points_8_txyz_qxyzw"} + elif key.endswith("slam_pose"): + features[f"observation.{key}"] = { + "dtype": "float32", "shape": [7]} + else: # _state / _force + features[f"observation.{key}"] = { + "dtype": "float32", "shape": [3]} # 手部骨架关键点(21×3 米,恒写列;无骨架数据时为全零占位) features[f"observation.{settings.HAND_POSE_LEFT}"] = { "dtype": "float32", "shape": [21, 3]} diff --git a/collector/core/gripper/__init__.py b/collector/core/gripper/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..fa752baa42f708f330486402fa9e31be27ee887f --- /dev/null +++ b/collector/core/gripper/__init__.py @@ -0,0 +1,15 @@ +"""UMI 夹爪 rig 集成包(从 online/gripper_version1 分叉)。 + +原生二进制/SDK/标定随包交付在 core/gripper/native/,触觉 Sightac SDK 在 +core/gripper/sightac_sdk/(pyarmor 加密);本包导入时先把 fays_runtime 的 +路径常量补丁到 native/ 下(见 paths.patch_fays_runtime_constants)。资源 +缺失时主程序通过 paths.gripper_resources_available() 隐藏夹爪设备条目。 +""" + +from __future__ import annotations + +from core.gripper import paths + +paths.patch_fays_runtime_constants() + +__all__ = ["paths"] diff --git a/collector/core/gripper/affinity.py b/collector/core/gripper/affinity.py new file mode 100644 index 0000000000000000000000000000000000000000..2017d84b467fa562ec761373a99c36c4b1867bad --- /dev/null +++ b/collector/core/gripper/affinity.py @@ -0,0 +1,118 @@ +"""夹爪 CPU 预留(P5 补丁):主进程掩码收窄 + raw 流接收线程专用核。 + +P5 只绑了 native SLAM 进程与触觉进程的线程;主进程(GUI、力矩阵泵、 +x265 编码子进程、各采集泵)的线程仍可漂到 SLAM 分区核上抢占 +fays_input 抓帧线程 → raw 流突发空桶、显示 <15fps、SLAM 取帧 <30fps。 +(后续探针实验定论:损耗主因不是主进程争用,而是 rig1 任务集含毒核 +6——见 bridge.py 分区表注释;本模块掩码收窄仍保留,防止主进程线程落 +SLAM 分区核或毒核。) + +本模块职责: + - reserve(rig_index):主线程掩码 = 当前掩码 − 该 rig SLAM 分区 − + raw 专用核。之后创建的线程与录制开始时 fork 的 ffmpeg 子进程 + (start_episode 在录制开始时由继承掩码的线程调用)继承受限掩码, + 不再与 SLAM 分区抢核。 + - release(rig_index):退还该 rig 预留;全部 rig 关闭后恢复完整掩码。 + - raw_cpu(rig_index):raw 流接收线程专用核(SMT 兄弟核,与轻载 + 触觉核共享物理核;接收线程负载极轻,只求不被重线程抢占)。 + - pin_raw_thread(cpu):raw 接收线程启动时自绑(线程级掩码独立于 + 继承掩码,可扩回专用核)。 + +机器 <24 逻辑 CPU 或掩码不含所需核 → 不预留,回退 P5 原状( +bridge._select_cpu_partition 同款回退口径)。 +""" + +import os + +# SLAM 分区(与 bridge.py 常量一致;独立重复一份避免 import 环)。 +# rig1 任务集已改为 {4,5,7,8,9}:核 6 因 SMT 兄弟 18 挂 xhci 摄像头 +# 中断风暴(流式期间 3000+/s)被整体移出任务集——主进程线程也不得落 +# 该核(风暴会拖慢任何实时性敏感的线程),故预留集合仍含 6。 +_SLAM_RIG1 = frozenset({4, 5, 6, 7, 8, 9}) +_SLAM_RIG2 = frozenset({10, 11, 13, 15, 22, 23}) +# raw 专用核:物理核 2(rig1 触觉右)/ 物理核 3(rig2 触觉右)的 +# SMT 兄弟(12+2=14、12+3=15)——触觉线程约 40% 单核,raw 接收 +# 线程负载极轻,共享物理核无碍 +_RAW_CPU_RIG1 = 14 +_RAW_CPU_RIG2 = 15 + +_state = { + "baseline": None, # 首次预留前的主线程完整掩码(恢复基准) + "reserved": set(), # 当前已预留的 CPU 集合(多 rig 并集) +} + + +def _all_cpus(): + try: + return {int(cpu) for cpu in os.sched_getaffinity(0)} + except (OSError, AttributeError): + return None + + +def supported() -> bool: + """本机是否支持预留(>=24 逻辑 CPU 且完整掩码含全部所需核)。 + + 必须按 baseline(首次预留前的完整掩码)判断:首台 rig 预留后 + 主线程当前掩码已收窄,若按当前掩码判断,第二台 rig 的预留会 + 因专用核已不在当前掩码里而被误判为不支持。""" + cpus = _state["baseline"] if _state["baseline"] is not None else _all_cpus() + if cpus is None or len(cpus) < 24: + return False + return (_SLAM_RIG1 <= cpus and _SLAM_RIG2 <= cpus + and _RAW_CPU_RIG1 in cpus and _RAW_CPU_RIG2 in cpus) + + +def raw_cpu(rig_index: int) -> int: + """rig 序号(1 起)→ raw 流接收线程专用核。""" + return _RAW_CPU_RIG2 if rig_index >= 2 else _RAW_CPU_RIG1 + + +def pin_raw_thread(cpu: int) -> bool: + """raw 流接收线程内自绑专用核;失败返回 False(调用方记日志)。""" + try: + os.sched_setaffinity(0, {int(cpu)}) + return True + except (OSError, AttributeError): + return False + + +def _apply_mask(logger): + if _state["baseline"] is None or logger is None: + return + mask = _state["baseline"] - _state["reserved"] + try: + os.sched_setaffinity(0, mask) + except (OSError, AttributeError): + return + logger(f"[CPU] 主进程掩码收窄至 {sorted(mask)}" + f"(预留 {sorted(_state['reserved'])})") + + +def reserve(rig_index: int, logger=None): + """打开 rig 时预留其 SLAM 分区 + raw 专用核(主线程调用)。""" + if _state["baseline"] is None: + _state["baseline"] = _all_cpus() + if not supported(): + return None + rig_set = _SLAM_RIG2 if rig_index >= 2 else _SLAM_RIG1 + _state["reserved"] |= rig_set | {raw_cpu(rig_index)} + _apply_mask(logger) + return sorted(_state["reserved"]) + + +def release(rig_index: int, logger=None): + """关闭 rig 时退还预留;全部关闭后恢复完整掩码(主线程调用)。""" + if _state["baseline"] is None: + return + rig_set = _SLAM_RIG2 if rig_index >= 2 else _SLAM_RIG1 + _state["reserved"] -= rig_set | {raw_cpu(rig_index)} + if _state["reserved"]: + _apply_mask(logger) + return + try: + os.sched_setaffinity(0, _state["baseline"]) + except (OSError, AttributeError): + pass + _state["baseline"] = None + if logger: + logger("[CPU] 夹爪预留全部释放,主进程掩码恢复") diff --git a/collector/core/gripper/bridge.py b/collector/core/gripper/bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..d78d4295af720b12d068b10d270c1c3e5d2bc9fc --- /dev/null +++ b/collector/core/gripper/bridge.py @@ -0,0 +1,811 @@ +"""夹爪 rig 与主程序的 Qt 桥(后台线程采集 → 队列信号回主线程)。 + +各采集线程(SLAM stdout、raw 双目流、RGB 读取、触觉结果泵)只向本对象的 +内部事件队列投递;由**唯一**的 emitter 线程串行调用 pyqtSignal.emit —— +多线程并发 emit 在 PyQt5 下存在竞态(实测 RGB 线程与主线程同时 emit +触发段错误),因此所有信号出口收敛到一个线程。主窗口用队列连接把信号 +调度回 GUI 线程。open/close 由主窗口的 _open_gripper/_close_gripper 按 +生命周期顺序调用(见 main_window)。 + +帧类事件(rgb/tactile/stereo_left)走 latest-wins 单槽: +GUI 卡顿时只丢旧帧不积压内存;控制类事件(log/error/opened/closed/ +pose/state)入队列保序。触觉录制数据不走本桥信号(P4 的 record_queue +直连泵线程)。 + +P2 已接入:UvcCameraServiceManager 相机组选择 → Sightac Flash 参数缓存 → +DECXIN RGB 常驻读取线程 → 触觉输入/计算双进程(spawn)。 +P3 已接入:SingleFaysLease.acquire 全链(USB3 速度校验/官方探针/flock)→ +SlamProcessController(wait_sdk_ready 等 [FAYS-CALIB] 标定标记)→ +FaysRawStreamClient(双目分包拆分,只取左目投 UI;IMU 原始数据不外送)。 +P4 已接入:GripperSerial(? 握手 + C/I/F 信号,失败不拆已就绪链路)、 +GripState(10ms 力检查循环 + 300mN 锁存)、力矩阵最新值(录制泵线程 +30ms 轮询 matrix_seq 取走,int16 行差分编码在泵线程完成)。 +open() 在独立线程执行(相机服务启动/首帧重试/触觉 warmup/SLAM 初始化 +都是秒级阻塞),ready/error 经信号回主线程。 +""" + +from __future__ import annotations + +import os +import queue +import threading +import time + +import cv2 +import numpy as np +from PyQt5.QtCore import QObject, pyqtSignal + +from config import settings +from core.s80m_manager import s80m_drop_watch, STEREO_DROP_ALERT_RATE +from core.gripper import affinity, paths +from core.gripper.fays_runtime import build_fays_runtime_env +from core.gripper.fays_single import SingleFaysLease +from core.gripper.control.grip_state import GripState +from core.gripper.devices.gripper_connection import ( + ConnectionState, + GripperConnectionController, +) +from core.gripper.devices.gripper_serial import GripperSerial +from core.gripper.devices.serial_command_worker import SerialCommandWorker +from core.gripper.devices.tactile_discovery import TactileDiscovery +from core.gripper.devices.tactile_process_manager import ( + TactileProcessManager, + TactileState, +) +from core.gripper.devices.uvc_camera_service import UvcCameraServiceManager +from core.gripper.recording.fays_raw_client import FaysRawStreamClient +from core.gripper.slam.process_controller import ( + SlamProcessController, + SlamState, +) + +# ── P5 双 rig CPU 分区(本机 Ryzen 9900X:12 物理核 × SMT,兄弟对 +# (0,12)…(11,23))。rig1:触觉 0/2 + SLAM 任务集 {4,5,7,8,9}—— +# 物理核 6 不得进入:其 SMT 兄弟 18 挂着 xhci 摄像头中断风暴 +# (流式期间 3000+/s),热角色落在 6 上会拖垮双目取帧(实测 +# left_orb 在 6 时空桶 23-29%,移出后 0.0%)。background +# (local-map 线程,40-90% 单核负载)必须独享核 9——与 track +# 共享同一核会令 SLAM 首 pose 无法出现(复现 2/2)。input 与 +# track 均轻载,共享核 4。rig2 独立分区:触觉 1/3 + SLAM +# 任务集 {10,11,13,15,22,23}——两 rig 零物理核共享。机器 <24 +# 逻辑 CPU(或进程亲和范围不含 rig2 分区)时回退 rig1 表共享 +# (见 _select_cpu_partition)。 ── +_TACTILE_CPU_MAP_RIG1 = {"left": 0, "right": 2} +_TACTILE_CPU_MAP_RIG2 = {"left": 1, "right": 3} +_SLAM_CPU_ROLES_RIG1 = { + "fays_input": (4,), + "fays_prepare": (5,), + "fays_left_orb": (7,), + "fays_right_orb": (8,), + "fays_track": (4,), + "fays_background": (9,), +} +_SLAM_CPU_ROLES_RIG2 = { + "fays_input": (10,), + "fays_prepare": (22,), + "fays_left_orb": (13,), + "fays_right_orb": (15,), + "fays_track": (11,), + "fays_background": (23,), +} +# rig2 分区所需的全部逻辑 CPU(触觉 + SLAM 六角色 + taskset 启动域) +_RIG2_PARTITION_CPUS = frozenset({ + 1, 3, 10, 11, 13, 15, 22, 23, +}) + + +def _select_cpu_partition(rig_index: int) -> tuple: + """按 rig 序号选 CPU 分区,返回 (tactile_cpu_map, slam_cpu_roles, 说明)。 + + 亲和范围不含 rig2 分区(如少于 24 逻辑 CPU 的机器)时回退 rig1 表: + 两 rig 同表共享,功能不受影响,仅性能退回共享(待 probe 实测)。 + """ + if rig_index >= 2: + try: + allowed = { + int(cpu) for cpu in os.sched_getaffinity(0) + } + except (OSError, AttributeError): + allowed = None + if allowed is not None and _RIG2_PARTITION_CPUS <= allowed: + return (dict(_TACTILE_CPU_MAP_RIG2), + dict(_SLAM_CPU_ROLES_RIG2), None) + return (dict(_TACTILE_CPU_MAP_RIG1), + dict(_SLAM_CPU_ROLES_RIG1), + "[Gripper] CPU 亲和范围不含 rig2 分区 " + f"{sorted(_RIG2_PARTITION_CPUS)},rig2 退回 rig1 核表共享" + "(双 SLAM 同表,性能可能受资源竞争影响)") + return (dict(_TACTILE_CPU_MAP_RIG1), + dict(_SLAM_CPU_ROLES_RIG1), None) + + +# 轨迹滚动窗口(与上位机 PoseState 2000 点上限一致) +# 显示轨迹窗口上限。GUI 用锚定索引 0 的固定网格降采样(见 ui/pose_view_qt.py), +# 依赖窗口头部不滑动——窗口一旦滚动,网格顶点索引会整体错位导致全线漂移。 +# 60000 点 @30fps ≈ 33 分钟,典型会话不会触发;存储侧轨迹由 SLAM 进程独立写盘, +# 与此显示窗口无关。 +TRAJECTORY_POINT_CAP = 60000 + +# 队列事件名 → 信号属性 +_CONTROL_SIGNALS = { + "log": "log", + "error": "error", + "opened": "opened", + "closed": "closed", + "pose": "pose_ready", + "gripper_state": "gripper_state_ready", +} + +# 帧类信号在 emitter 里的派发方式(slot 名 = 事件 kind; +# 右目不投递:只显示左目,SLAM 解算在桥接进程内部完成) +_FRAME_EMITTERS = { + "rgb": lambda self_, payload: self_.rgb_frame_ready.emit(*payload), + "stereo_left": lambda self_, payload: ( + self_.stereo_frame_ready.emit(self_._stereo_slot, *payload)), + "tactile": lambda self_, payload: self_.tactile_ready.emit(*payload), +} + + +class _SerialLifecycleAdapter: + """传感器链路已由 bridge 先行启动;串口连接器只做状态适配。""" + + def prepare_connect(self): + return None + + def connected(self): + return None + + def connect_failed(self): + return None + + def disconnect(self): + return None + + def verify_prepared_control_port(self, device_path): + return None + + +class GripperBridge(QObject): + """One open gripper session; owns workers, emits events.""" + + stereo_frame_ready = pyqtSignal(str, object, int) + # slot("gripper_stereo_left"), bgr ndarray, host_monotonic_ns + rgb_frame_ready = pyqtSignal(object, int) # bgr ndarray, host_monotonic_ns + tactile_ready = pyqtSignal(str, object, object, object) + # side("left"|"right"), heatmap(320x240x3 RGB,worker 已 BGR→RGB), + # force(fx,fy,fz mN), + # force_matrix(250x250x3 float32) 或 None(矩阵回传关闭时) + pose_ready = pyqtSignal(object, object, object, object) + # pos(x,y,z), quat(qx,qy,qz,qw), trajectory(位置点不可变元组,新点追加才重建), + # timestamp(SLAM 秒,与轨迹 txt 第一列同源——轨迹并入 episode parquet 后 + # 每点 8 值 [t,x,y,z,qx,qy,qz,qw] 需要它) + gripper_state_ready = pyqtSignal(object) # {pct,gripped,fz,...} + opened = pyqtSignal() # 相机组 + 触觉 + SLAM 链路就绪 + log = pyqtSignal(str) + error = pyqtSignal(str) + closed = pyqtSignal() + + def __init__(self, parent=None, stereo_slot="gripper_stereo_left", + rig_index=1): + super().__init__(parent) + # 双夹爪:每台 bridge 发自己的双目槽名(rig1 保持旧名 + # "gripper_stereo_left",rig2 为 "gripper_2_stereo_left"), + # 主窗口按 dev.key 路由到各自条目。 + self._stereo_slot = stereo_slot + # P5 双 rig CPU 分区:rig1 旧核表 / rig2 独立物理核分区 + # (亲和范围不足时回退 rig1 表共享,见 _select_cpu_partition)。 + # cpu_note 等 emitter 队列就绪后再发(_log 依赖 _events) + self._rig_index = int(rig_index) + self._tactile_cpu_map, self._slam_cpu_roles, self._cpu_note = ( + _select_cpu_partition(self._rig_index)) + # P5 双目取帧空桶看门狗(30fps 口径,复用主程序 s80m_drop_watch): + # raw 双目包按 wall 时钟 1/30s 桶计数,空桶率超阈值告警一次; + # 录制开始由 main_window 重置(与 s80m 口径一致) + self._stereo_drop_watch = { + "last_mono_ns": None, + "dropped": 0, + "elapsed": 0, + "alerted": False, + } + self._lock = threading.RLock() + self._stop = threading.Event() + self._open_thread = None + self._rgb_thread = None + self._uvc = None + self._reservation = None + self._tactile = None + self._rgb_camera = None + self._lease = None + self._slam = None + self._raw_client = None + self._opened = False + # 双目 raw 流拆包状态(首包判定模式,open 期间有效) + self._stereo_mode = None # "side_by_side" | "paired_packets" + self._stereo_pending = None + # P4 串口/夹爪状态(heartbeat 与 grip 循环线程写,信号出) + self._serial = None + self._serial_worker = None + self._serial_controller = None + self._grip_state = GripState() + self._latest_force = { + "left": (0.0, 0.0, 0.0), + "right": (0.0, 0.0, 0.0), + } + self._last_state_payload = None + self._last_state_post = 0.0 + # P4 力矩阵最新值 + 序号(录制泵线程轮询,序号变化才取走) + self._matrix_lock = threading.Lock() + self._latest_matrix = {"left": None, "right": None} + self._matrix_seq = {"left": 0, "right": 0} + # SLAM 轨迹:有效位姿逐点累积(滚动窗口,恒存不可变元组快照) + self._trajectory_points = [] + self._trajectory_cache = () + self._matrix_first_logged = set() + # 事件收敛:唯一 emitter 线程串行 emit(多线程并发 emit 会段错误) + self._events = queue.Queue() + self._frame_lock = threading.Lock() + self._frame_slots = {} + self._frame_pending = set() + self._emitter = threading.Thread( + target=self._emit_loop, + name="gripper-bridge-emit", + daemon=True, + ) + self._emitter.start() + if self._cpu_note: + self._log(self._cpu_note) + + # ---- 事件投递(任意线程可调) ---- + def _post(self, name, *args): + self._events.put((name, args)) + + def _post_frame(self, kind, *payload): + """latest-wins 帧槽:GUI 卡顿时丢旧帧不积压。""" + with self._frame_lock: + self._frame_slots[kind] = payload + if kind in self._frame_pending: + return + self._frame_pending.add(kind) + self._events.put(("frame", (kind,))) + + def _emit_loop(self): + while True: + name, args = self._events.get() + if name == "_stop": + return + if name == "frame": + kind = args[0] + with self._frame_lock: + payload = self._frame_slots.get(kind) + self._frame_slots[kind] = None + self._frame_pending.discard(kind) + if payload is None: + continue + emitter = _FRAME_EMITTERS.get(kind) + if emitter is not None: + emitter(self, payload) + continue + attr = _CONTROL_SIGNALS.get(name) + if attr is not None: + getattr(self, attr).emit(*args) + + # ---- 生命周期 ---- + def open(self, esp_serial): + with self._lock: + if self._open_thread is not None: + raise RuntimeError("GripperBridge.open 已在运行") + if not self._emitter.is_alive(): + raise RuntimeError("GripperBridge 已关闭,不可复用") + self._stop.clear() + self._opened = False + self._trajectory_path = None + self._grip_state.reset_latch() + self._latest_force = { + "left": (0.0, 0.0, 0.0), + "right": (0.0, 0.0, 0.0), + } + with self._matrix_lock: + self._latest_matrix = {"left": None, "right": None} + self._matrix_seq = {"left": 0, "right": 0} + self._trajectory_points = [] + self._trajectory_cache = () + self._matrix_first_logged = set() + self._stereo_drop_watch = { + "last_mono_ns": None, + "dropped": 0, + "elapsed": 0, + "alerted": False, + } + thread = threading.Thread( + target=self._open_run, + args=(str(esp_serial),), + name="gripper-bridge-open", + daemon=False, + ) + self._open_thread = thread + thread.start() + + def _log(self, msg): + self._post("log", msg) + + def _open_run(self, esp_serial): + try: + # P3 全链租约:ESP 唯一匹配 → rig 内唯一 S80M → USB3 速度校验 + # → 官方 SDK 探针读序列号 → flock → materialize 运行时 yaml + self._lease = SingleFaysLease(logger=self._log) + selected = self._lease.acquire(esp_serial) + # 轨迹 txt 由桥接进程直写;录制结束后 main_window 拷贝到 + # meta/(P4)。open() 置 None 防旧会话残留。 + self._trajectory_path = selected["trajectory"] + assignment = { + "esp32": {"serial": str(selected["esp_serial"])}, + "fays": { + "product_serial": selected["product_serial"], + "physical_usb_path": selected["physical_usb_path"], + }, + } + self._log( + "[Gripper] Fays 租约已持有: serial={} " + "usb={:g}M".format( + selected["product_serial"], + selected["usb_speed_mbps"])) + + self._uvc = UvcCameraServiceManager(logger=self._log) + self._reservation = self._uvc.select(lambda: assignment) + discovery = TactileDiscovery( + sightac_root=paths.SIGHTAC_SDK_ROOT, + logger=self._log, + ) + # Sightac Flash 参数入缓存:TactileProcessManager 的 + # _resolve_inputs 依赖 cache_snapshot(),必须先于 start + for side in ("left", "right"): + camera = self._reservation.camera(side) + discovery.cache_external_flash_params( + camera.node.video_index, camera.flash_params) + + # DECXIN RGB:claim 内置首帧重试;成功即启动常驻读取线程 + decxin_camera = self._reservation.camera("decxin") + ipc_camera, first_frame, actual_format = decxin_camera.claim() + self._rgb_camera = ipc_camera + self._log( + "[Gripper] DECXIN RGB 就绪: {}x{}@{}fps {}".format( + actual_format[0], actual_format[1], + actual_format[2], actual_format[3])) + self._post_frame("rgb", first_frame, time.monotonic_ns()) + self._rgb_thread = threading.Thread( + target=self._rgb_run, + name="gripper-rgb-read", + daemon=True, + ) + self._rgb_thread.start() + + # 触觉输入/计算双进程(spawn,父进程不建 TouchSensor; + # materialize_force_matrix:力矩阵回传主进程,P4 泵线程落盘) + self._tactile = TactileProcessManager( + TactileState(), + discovery, + cpu_map=dict(self._tactile_cpu_map), + materialize_force_matrix=True, + publish_result=self._on_tactile_result, + logger=self._log, + ) + self._tactile.start_connected( + left=self._reservation.camera("left"), + right=self._reservation.camera("right"), + asynchronous=True, + ) + if not self._tactile.wait_ready( + timeout=self._tactile.PROCESS_READY_TIMEOUT): + snapshot = self._tactile.snapshot() + details = "; ".join( + f"{side}={getattr(snapshot, side).error}" + for side in ("left", "right") + if getattr(snapshot, side).error) + raise RuntimeError( + "触觉双进程未就绪: " + (details or "超时")) + + # SLAM 桥接进程(stdbuf+taskset 包官方 ORB 二进制,stdout + # 逐行协议;wait_sdk_ready 等 [FAYS-CALIB] 标定标记) + ipc_dir = selected["ipc_dir"] + + def slam_runtime_env(): + # 原生二进制按 KSQ_FAYS_IPC_DIR 定位 raw 流 socket/位姿 + # JSON(默认 /dev/shm,会与租约的实例目录错位); + # 原程序由 FaysInstanceManager.runtime_environment() 注入 + env = build_fays_runtime_env() + env["KSQ_FAYS_IPC_DIR"] = ipc_dir + env["KSQ_FAYS_CALIBRATION_SERIAL"] = ( + selected["product_serial"]) + return env + + slam = SlamProcessController( + SlamState(), + executable=selected["orb_binary"], + vocabulary=paths.ORB_VOCABULARY, + settings=selected["orb_yaml"], + device_config=selected["runtime_config"], + trajectory=selected["trajectory"], + work_dir=selected["work_dir"], + native_log_path=( + f"{selected['work_dir']}/slam_stdout.log"), + runtime_env_factory=slam_runtime_env, + cpu_roles=dict(self._slam_cpu_roles), + on_pose=self._on_slam_pose, + log=self._log, + pose_paths=( + f"{ipc_dir}/orb_pose.json.tmp", + f"{ipc_dir}/orb_pose.json", + ), + ) + slam.start() + self._slam = slam + self._log("[Gripper] SLAM 桥接进程已启动,等待 SDK 标定…") + if not slam.wait_sdk_ready( + timeout=settings.GRIPPER_SLAM_READY_TIMEOUT_S): + raise RuntimeError( + "SLAM SDK 初始化超时(未等到 [FAYS-CALIB] 标定标记;" + "确认夹爪 USB3 头插在 USB3 口)") + + # 原始双目/IMU 流(AF_UNIX):双目分包拆分 + IMU 批随左目 + # raw_cpu:接收线程专用 SMT 核(P5 补丁,见 core/gripper/ + # affinity.py)——保证 native 30fps 取帧不因接收侧丢包而降频 + raw_cpu = affinity.raw_cpu(self._rig_index) + raw_client = FaysRawStreamClient( + f"{ipc_dir}/orb_raw_stream.sock", + on_stereo=self._on_stereo_packet, + logger=self._log, + on_error=lambda message: self._log( + f"[Gripper-Raw] {message}"), + on_reconnected=self._on_raw_reconnected, + raw_cpu=raw_cpu, + ) + raw_client.start() + self._raw_client = raw_client + + # 串口(P4):8 次 ? 握手 + C/I/F 信号;heartbeat/grip 循环 + # 自带线程。所有传感器链路已先行就绪,lifecycle 只做占位 + # 适配;握手失败不拆已就绪链路(日志可见,触觉/SLAM 保持)。 + tty = str(selected.get("esp_tty") or "").strip() + if tty: + serial_owner = GripperSerial(logger=self._log) + worker = SerialCommandWorker(serial_owner.send) + worker.start() + controller = GripperConnectionController( + ConnectionState(), + serial_owner, + worker, + _SerialLifecycleAdapter(), + on_board_update=self._on_board_update, + on_grip_check=self._on_grip_check, + ) + self._serial = serial_owner + self._serial_worker = worker + self._serial_controller = controller + if not controller.connect_sync(tty): + self._log( + "[Gripper] ESP32 串口连接失败: {} " + "(相机/触觉/SLAM 链路保持)".format( + serial_owner.last_error + or "handshake timeout")) + else: + self._log("[Gripper] 未找到 ESP32 串口,跳过夹爪控制") + + if self._stop.is_set(): + # 启动期间被 close():回收后不再发 opened + self._teardown() + return + self._opened = True + self._log("[Gripper] 相机 + 触觉 + SLAM 链路就绪") + self._post("opened") + except Exception as exc: + if self._stop.is_set(): + # close() 路径触发(如 wait_ready 期间被回收):静默退出 + return + self._log("[Gripper] 启动失败: {}".format(exc)) + self._teardown() + self._post("error", str(exc)) + + def _rgb_run(self): + while not self._stop.is_set(): + ok, frame = self._rgb_camera.read() + if not ok: + if not self._stop.is_set(): + time.sleep(0.005) + continue + self._post_frame("rgb", frame, time.monotonic_ns()) + + def _on_tactile_result(self, side, heatmap, force, force_matrix): + if side in ("left", "right"): + try: + self._latest_force[side] = tuple( + float(value) for value in force[:3]) + except (TypeError, ValueError, IndexError): + pass + if force_matrix is not None: + with self._matrix_lock: + self._latest_matrix[side] = force_matrix + self._matrix_seq[side] += 1 + if side not in self._matrix_first_logged: + self._matrix_first_logged.add(side) + self._log( + "[Gripper-Tactile] {} 侧力矩阵首帧回传 shape={}".format( + side, force_matrix.shape)) + self._post_frame("tactile", side, heatmap, force, force_matrix) + + # ---- P4 串口/夹爪状态(heartbeat 与 grip 循环线程调用) ---- + def _on_board_update(self, snapshot): + """串口 STATE 响应 → GripState 板字段。""" + try: + self._grip_state.update_firmware_state( + dict(snapshot.board_fields or {}), + updated=snapshot.updated) + except Exception: + pass + self._publish_grip_state() + + def _on_grip_check(self): + """10ms 力检查循环:双路 Fz 阈值 → 锁存 → 状态事件。""" + event = self._grip_state.evaluate_forces( + self._latest_force["left"], self._latest_force["right"]) + self._publish_grip_state(event=event) + + def _publish_grip_state(self, event=None): + snap = self._grip_state.snapshot() + left = self._latest_force["left"] + right = self._latest_force["right"] + try: + fz = max(float(left[2]), float(right[2])) + except (TypeError, ValueError, IndexError): + fz = 0.0 + payload = { + "pct": snap.percent, + "gripped": snap.grip_latched, + "fz": fz, + "event": str(event or ""), + "board": dict(snap.board_state), + } + now = time.monotonic() + if (payload != self._last_state_payload + or now - self._last_state_post >= 0.1): + self._last_state_payload = payload + self._last_state_post = now + self._post("gripper_state", payload) + + def matrix_seq(self, side): + with self._matrix_lock: + return self._matrix_seq.get(side, 0) + + def latest_matrix(self, side): + with self._matrix_lock: + return self._latest_matrix.get(side) + + def _on_slam_pose(self, pose): + """SlamProcessController 工作线程回调:位姿进队列保序。 + + 原协议用 None 表示"无位姿/进程停止"(start() 的首个 stop() + 与进程退出都会回调一次),桥接直接丢弃。 + 轨迹在此累积(与上位机 PoseState 同款滚动窗口),新点追加才 + 重建不可变元组——UI 侧按对象同一性省去无变化重绘。 + """ + if pose is None: + return + self._trajectory_points.append(tuple(pose.position)) + if len(self._trajectory_points) > TRAJECTORY_POINT_CAP: + self._trajectory_points = ( + self._trajectory_points[-TRAJECTORY_POINT_CAP:]) + self._trajectory_cache = tuple(self._trajectory_points) + self._post("pose", tuple(pose.position), tuple(pose.rotation), + self._trajectory_cache, pose.timestamp) + + def _on_stereo_packet( + self, payload, sensor_ts_ns, host_mono_ns, sequence, + width, height, channels, step, encoding, + ): + """raw 流双目包:首包判定拆分模式,只取左目转 BGR 投帧槽。 + + 右目不投递(主程序只显示左目;SLAM 解算在桥接进程内部完成, + 左右目原始视频与 IMU 均不落盘,只存 SLAM 位姿/轨迹)。 + 模式一 side_by_side:单包宽 >= 3×高(左右拼合,如 1280×400), + 取左半。 + 模式二 vertical_stacked:单包高 > 宽(上下拼合,实测 640×800 + = 2×640×400),取上半(上半→左目,真机核对后定)。 + 模式三 paired_packets:单包即单目(如 640×400),相邻两包配对 + (先左后右为暂定约定),右目包直接丢弃。 + + P5 每个 raw 包(含各模式)先过 30fps 空桶看门狗:SLAM 进程被 + 资源竞争拖慢时包以「空洞+突发」到达,wall 桶统计即可检出。 + """ + self._stereo_drop_tick(host_mono_ns) + if self._stereo_mode is None: + if width >= height * 3: + self._stereo_mode = "side_by_side" + elif height > width: + self._stereo_mode = "vertical_stacked" + else: + self._stereo_mode = "paired_packets" + self._log( + "[Gripper-Raw] 双目包模式判定: {} ({}x{}x{})".format( + self._stereo_mode, width, height, channels)) + buffer = np.frombuffer( + payload, dtype=np.uint8, + count=step * height, + ).reshape(height, step) + if channels == 1: + frame = cv2.cvtColor( + buffer[:, :width].reshape(height, width), + cv2.COLOR_GRAY2BGR) + else: + frame = buffer[:, :width * channels].reshape( + height, width, channels).copy() + if self._stereo_mode == "side_by_side": + half = width // 2 + self._post_frame("stereo_left", frame[:, :half].copy(), + host_mono_ns) + return + if self._stereo_mode == "vertical_stacked": + half = height // 2 + self._post_frame("stereo_left", frame[:half].copy(), + host_mono_ns) + return + pending = self._stereo_pending + if pending is None: + self._stereo_pending = (frame, host_mono_ns) + return + left, left_ns = pending + self._stereo_pending = None + self._post_frame("stereo_left", left, left_ns) + + def _stereo_drop_tick(self, mono_ns): + """双目取帧 30fps 空桶看门狗(口径复用主程序 s80m_drop_watch)。 + + wall 时钟 1/30s 桶计数:SLAM 进程取帧掉速时包间隔拉大,跨 k≥2 + 桶计 k-1 个空桶。累计 ~3 秒样本后空桶率超 + STEREO_DROP_ALERT_RATE 记一次日志告警(每段录制重置一次, + 与 s80m 告警同口径;日志面板可见,不弹窗打扰)。 + """ + interval_ns = int(settings.STEREO_RECORD_MIN_INTERVAL_S * 1e9) + # s80m_drop_watch 的 entry 契约带 drop_watch 键(与 s80m 注册表 + # 条目同形状),这里按同形状包一层,纯函数口径原样复用 + _, dropped, elapsed = s80m_drop_watch( + {"drop_watch": self._stereo_drop_watch}, + mono_ns, interval_ns) + w = self._stereo_drop_watch + if w["alerted"] or elapsed < 90: + return + rate = dropped / elapsed + if rate < STEREO_DROP_ALERT_RATE: + return + w["alerted"] = True + self._log( + "[夹爪-SLAM告警] 双目取帧不稳定:近 3 秒空桶率 {:.0f}%" + "({} 空桶 / {} 桶)——30fps 采集受影响,SLAM 轨迹将卡顿;" + "若持续偏高请检查 USB 带宽与 CPU 争用".format( + rate * 100, dropped, elapsed)) + + def stereo_drop_snapshot(self): + """(累计空桶, 累计桶数)——录制结束汇总口径,与主程序 + _s80m_drop_summary 一致。""" + w = self._stereo_drop_watch + return (w["dropped"], w["elapsed"]) + + def reset_stereo_drop_watch(self): + """录制开始重置空桶统计(告警放行下一段录制)。""" + self._stereo_drop_watch = { + "last_mono_ns": None, + "dropped": 0, + "elapsed": 0, + "alerted": False, + } + + def clear_trajectory(self): + """录制开始清空 GUI 轨迹滚动窗口(只显示本段录制的点)。 + + parquet 的 slam_trajectory 列由 writer 在录制期独立累积 + (见 pipeline.write_slam_pose),不受此窗口影响;这里只管 + 显示侧。UI 侧配合 pose_view.reset() 同步清空渲染缓存。 + """ + self._trajectory_points = [] + self._trajectory_cache = () + + def _on_raw_reconnected(self): + """raw 客户端断线重连成功回调。 + + 断连窗口(服务端原始队列溢出主动断开,通常是录制停止时 + 主进程瞬时卡顿所致)的空桶属于显示侧问题,不计入取帧质量: + 清掉残留的 paired 待配对帧(断点后流序重来),并重置空桶 + 看门狗统计。 + """ + self._stereo_pending = None + self.reset_stereo_drop_watch() + + def _teardown(self): + """逆序回收:串口 → raw 流 → SLAM 进程 → RGB 线程 → 触觉子进程 + → 相机租约 → 服务进程 → Fays 租约。""" + with self._lock: + self._stop.set() + serial_controller = self._serial_controller + self._serial_controller = None + self._serial_worker = None + self._serial = None + raw_client = self._raw_client + self._raw_client = None + slam = self._slam + self._slam = None + rgb_thread = self._rgb_thread + self._rgb_thread = None + rgb_camera = self._rgb_camera + self._rgb_camera = None + tactile = self._tactile + self._tactile = None + reservation = self._reservation + self._reservation = None + uvc = self._uvc + self._uvc = None + lease = self._lease + self._lease = None + if serial_controller is not None: + try: + serial_controller.close() + except Exception: + pass + if raw_client is not None: + try: + raw_client.stop() + except Exception: + pass + if slam is not None: + try: + slam.stop(join=False) + except Exception: + pass + if rgb_thread is not None and rgb_thread.is_alive(): + rgb_thread.join(timeout=3.0) + if rgb_camera is not None: + try: + rgb_camera.release() + except Exception: + pass + if tactile is not None: + try: + tactile.stop() + except Exception: + pass + if reservation is not None: + try: + reservation.release_unclaimed() + except Exception: + pass + if uvc is not None: + try: + uvc.stop() + except Exception: + pass + if lease is not None: + try: + lease.release() + except Exception: + pass + + def close(self): + with self._lock: + if self._open_thread is None and not self._opened: + return + self._open_thread = None + self._teardown() + self._opened = False + self._post("closed") + # 哨兵事件让 emitter 线程优雅退出:守护线程若挂在 + # queue.get() 上,解释器退出时仍在写 stderr 会核心转储 + self._events.put(("_stop", ())) + emitter = self._emitter + if emitter is not threading.current_thread(): + emitter.join(timeout=2.0) + + @property + def running(self): + return self._opened + + @property + def trajectory_path(self): + """桥接进程直写的轨迹 txt 路径(open 成功后才非 None)。""" + return self._trajectory_path diff --git a/collector/core/gripper/control/__init__.py b/collector/core/gripper/control/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ab4c26c6008f31ef1060576e5e47c563c76b10f0 --- /dev/null +++ b/collector/core/gripper/control/__init__.py @@ -0,0 +1,19 @@ +"""夹爪软件判定(机械臂遥操控制已随 teleop 录制一并移除)。""" + +from .grip_state import ( + GripEvent, + GripSnapshot, + GripState, + clamp_percent, + firmware_percent, + normalize_fz_threshold, +) + +__all__ = [ + "GripEvent", + "GripSnapshot", + "GripState", + "clamp_percent", + "firmware_percent", + "normalize_fz_threshold", +] diff --git a/collector/core/gripper/control/grip_state.py b/collector/core/gripper/control/grip_state.py new file mode 100644 index 0000000000000000000000000000000000000000..68b159906ba89bc0ca83d465988a4f42ca35f136 --- /dev/null +++ b/collector/core/gripper/control/grip_state.py @@ -0,0 +1,233 @@ +"""夹爪板状态、百分比与双路 Fz 锁存的唯一状态源。""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import Enum +import math +import threading +from types import MappingProxyType +from typing import Mapping, Optional, Sequence, Tuple + + +DEFAULT_FZ_THRESHOLD_MN = 300 +MIN_FZ_THRESHOLD_MN = 10 +MAX_FZ_THRESHOLD_MN = 5000 +RELEASE_PERCENT_THRESHOLD = 20.0 +RELEASE_CONFIRMATION_COUNT = 3 +ACTIVE_BOARD_STATES = frozenset({"1", "2"}) + + +class GripEvent(str, Enum): + NONE = "none" + TRIGGERED = "triggered" + RELEASED = "released" + + +@dataclass(frozen=True) +class GripSnapshot: + """供 UI/录制读取的不可变夹爪快照。""" + + board_state: Mapping[str, str] + actual: str + as5600: Mapping[str, str] + raw_state: str + raw_actual: str + raw_as5600: str + updated: str + fz_threshold_mn: int + grip_latched: bool + release_count: int + percent: Optional[float] + raw_angle: Optional[str] + + +def _freeze_string_mapping( + values: Optional[Mapping[object, object]], +) -> Mapping[str, str]: + return MappingProxyType({ + str(key): str(value) for key, value in (values or {}).items() + }) + + +def normalize_fz_threshold(value: object) -> int: + """按原 UI 契约把阈值限制到 10–5000 mN。""" + + number = float(value) + if not math.isfinite(number): + raise ValueError("Fz threshold must be finite") + return max( + MIN_FZ_THRESHOLD_MN, + min(MAX_FZ_THRESHOLD_MN, int(number)), + ) + + +def clamp_percent(value: object) -> float: + number = float(value) + if not math.isfinite(number): + raise ValueError("grip percent must be finite") + return max(0.0, min(100.0, number)) + + +def firmware_percent( + board_state: Mapping[str, object], +) -> Tuple[Optional[float], bool, Optional[str]]: + """读取固件 ``PCT/GRIP/RAW``,保持原三元组返回契约。""" + + try: + percent = clamp_percent(board_state.get("PCT", 0)) + except (TypeError, ValueError): + return None, False, None + gripped = str(board_state.get("GRIP", "0")) == "1" + raw_value = board_state.get("RAW") + raw_angle = None if raw_value is None else str(raw_value) + return percent, gripped, raw_angle + + +def _force_z(force: Optional[Sequence[object]]) -> float: + if force is None or len(force) < 3: + return 0.0 + try: + value = float(force[2]) + except (TypeError, ValueError, OverflowError): + return 0.0 + return value if math.isfinite(value) else 0.0 + + +class GripState: + """唯一写入 board/Fz 锁存状态的线程安全控制对象。 + + 该对象内部保存可变状态;消费者只能通过 :meth:`snapshot` 取得深拷贝并 + 冻结后的视图,不暴露入口字段转发器。 + """ + + def __init__(self, fz_threshold_mn: int = DEFAULT_FZ_THRESHOLD_MN) -> None: + self._lock = threading.RLock() + self._board_state: dict[str, str] = {} + self._actual = "--" + self._as5600: dict[str, str] = {} + self._raw_state = "--" + self._raw_actual = "--" + self._raw_as5600 = "--" + self._updated = "--" + self._fz_threshold_mn = normalize_fz_threshold(fz_threshold_mn) + self._grip_latched = False + self._release_count = 0 + + def snapshot(self) -> GripSnapshot: + with self._lock: + percent, _gripped, raw_angle = firmware_percent( + self._board_state) + return GripSnapshot( + board_state=_freeze_string_mapping(self._board_state), + actual=self._actual, + as5600=_freeze_string_mapping(self._as5600), + raw_state=self._raw_state, + raw_actual=self._raw_actual, + raw_as5600=self._raw_as5600, + updated=self._updated, + fz_threshold_mn=self._fz_threshold_mn, + grip_latched=self._grip_latched, + release_count=self._release_count, + percent=percent, + raw_angle=raw_angle, + ) + + def replace_board_snapshot( + self, + board_snapshot: Mapping[str, object], + ) -> GripSnapshot: + """原子接收串口解析后的完整 board 快照。""" + + nested = board_snapshot.get("state", {}) + state_values = nested if isinstance(nested, Mapping) else {} + as5600 = board_snapshot.get("as5600", {}) + as5600_values = as5600 if isinstance(as5600, Mapping) else {} + with self._lock: + self._board_state = { + str(key): str(value) for key, value in state_values.items() + } + if self._grip_latched: + self._board_state["GRIP"] = "1" + self._actual = str(board_snapshot.get("actual", "--")) + self._as5600 = { + str(key): str(value) for key, value in as5600_values.items() + } + self._raw_state = str(board_snapshot.get("raw_state", "--")) + self._raw_actual = str(board_snapshot.get("raw_actual", "--")) + self._raw_as5600 = str(board_snapshot.get("raw_as5600", "--")) + self._updated = str(board_snapshot.get("updated", "--")) + return self.snapshot() + + def update_firmware_state( + self, + values: Mapping[str, object], + *, + updated: Optional[object] = None, + ) -> GripSnapshot: + """只替换固件 ``STATE`` 字段,供串口状态循环使用。""" + + with self._lock: + self._board_state = { + str(key): str(value) for key, value in values.items() + } + if self._grip_latched: + self._board_state["GRIP"] = "1" + if updated is not None: + self._updated = str(updated) + return self.snapshot() + + def set_fz_threshold(self, value: object) -> int: + threshold = normalize_fz_threshold(value) + with self._lock: + self._fz_threshold_mn = threshold + return threshold + + def evaluate_forces( + self, + left_force: Optional[Sequence[object]], + right_force: Optional[Sequence[object]], + ) -> GripEvent: + """应用双路 Fz 阈值、锁存和连续三次张开释放滞后。""" + + left_fz = _force_z(left_force) + right_fz = _force_z(right_force) + with self._lock: + state_code = self._board_state.get("ST", "0") + if state_code not in ACTIVE_BOARD_STATES: + return GripEvent.NONE + try: + percent = clamp_percent( + self._board_state.get("PCT", "0")) + except (TypeError, ValueError): + return GripEvent.NONE + + if self._grip_latched: + if percent < RELEASE_PERCENT_THRESHOLD: + self._release_count += 1 + if self._release_count >= RELEASE_CONFIRMATION_COUNT: + self._grip_latched = False + self._release_count = 0 + self._board_state.pop("GRIP", None) + return GripEvent.RELEASED + else: + self._release_count = 0 + return GripEvent.NONE + + has_force = ( + left_fz >= self._fz_threshold_mn + or right_fz >= self._fz_threshold_mn + ) + if not has_force: + return GripEvent.NONE + + self._grip_latched = True + self._release_count = 0 + self._board_state["GRIP"] = "1" + return GripEvent.TRIGGERED + + def reset_latch(self) -> None: + with self._lock: + self._grip_latched = False + self._release_count = 0 + self._board_state.pop("GRIP", None) diff --git a/collector/core/gripper/devices/__init__.py b/collector/core/gripper/devices/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..544367cfe124b118efc61947824b20b470148eb1 --- /dev/null +++ b/collector/core/gripper/devices/__init__.py @@ -0,0 +1,37 @@ +"""KSQ 夹爪硬件适配器。 + +设备模块不持有应用或 Tk 对象。串口、Sightac 句柄和触觉计算子进程分别只有 +这里声明的控制器能够创建和关闭,其他子系统只读取不可变快照或调用公开 API。 +""" + +from .gripper_connection import ( + ConnectionSnapshot, + ConnectionState, + GripperConnectionController, +) +from .gripper_serial import GripperSerial +from .serial_command_worker import ( + SerialCommandCancelled, + SerialCommandWorker, +) +from .tactile_discovery import TactileDiscovery +from .tactile_process_manager import ( + TactileProcessBridge, + TactileProcessManager, + TactileSnapshot, + TactileState, +) + +__all__ = [ + "ConnectionSnapshot", + "ConnectionState", + "GripperConnectionController", + "GripperSerial", + "SerialCommandCancelled", + "SerialCommandWorker", + "TactileDiscovery", + "TactileProcessBridge", + "TactileProcessManager", + "TactileSnapshot", + "TactileState", +] diff --git a/collector/core/gripper/devices/gripper_connection.py b/collector/core/gripper/devices/gripper_connection.py new file mode 100644 index 0000000000000000000000000000000000000000..13df701915111814ba64c79c29fce639d1562f55 --- /dev/null +++ b/collector/core/gripper/devices/gripper_connection.py @@ -0,0 +1,717 @@ +"""夹爪控制板连接、响应解析和三组定时循环。""" + +from __future__ import annotations + +from dataclasses import dataclass +import threading +import time +from types import MappingProxyType +from typing import Callable, Mapping, Optional, Protocol + +from .gripper_serial import GripperSerial +from .serial_command_worker import SerialCommandWorker + + +UI_LOOP_MS = 33 +SLOW_LOOP_MS = 150 +FAST_GRIP_LOOP_MS = 10 +RESET_EVENT_DEBOUNCE_S = 3.0 +# ESP32 declares the host offline after 1.5 s without a signal (HEARTBEAT +# in main.cpp). The host-driven "?" poll runs on its own daemon thread so a +# stalled Tk main thread (e.g. a long synchronous save) cannot starve it and +# disconnect the physical record button. +HEARTBEAT_PERIOD_S = 1.0 / 30.0 + + +class SensorLifecycle(Protocol): + """Connection controller 唯一允许调用的跨设备生命周期接口。""" + + def prepare_connect(self) -> object: + """只读预检并完成 Open 资源交接;失败应抛异常或返回 ``False``。""" + + def connected(self) -> object: + """串口握手后启动 Fays/SLAM,并重新初始化左右 Sightac。""" + + def connect_failed(self) -> object: + """收回部分 Connect 资源,并按需恢复发起前的 Open 状态。""" + + def verify_prepared_control_port(self, device_path: str) -> object: + """确认交接后串口节点仍指向预检时的同一 ESP32。""" + + def disconnect(self) -> object: + """按依赖逆序停止 SLAM、Sightac 和预览资源。""" + + +@dataclass(frozen=True) +class ConnectionSnapshot: + """供 UI、录制和诊断读取的不可变连接快照。""" + + serial_generation: int + connecting: bool + connected: bool + no_esp: bool + loop_token: int + connect_time: float + board_fields: Mapping[str, str] + actual: str + as5600: Mapping[str, str] + raw_state: str + raw_actual: str + raw_as5600: str + updated: str + error: Optional[str] + + +class ConnectionState: + """连接状态的唯一可变源;只由 GripperConnectionController 写入。""" + + def __init__(self): + self.lock = threading.RLock() + self.serial_generation = 0 + self.connecting = False + self.connected = False + self.no_esp = False + self.loop_token = 0 + self.connect_time = 0.0 + self.attempt_generation = 0 + self.error = None + self.board_state = { + "state": {}, + "actual": "--", + "as5600": {}, + "raw_state": "--", + "raw_actual": "--", + "raw_as5600": "--", + "updated": "--", + } + + def snapshot(self) -> ConnectionSnapshot: + with self.lock: + fields = MappingProxyType(dict(self.board_state["state"])) + return ConnectionSnapshot( + serial_generation=int(self.serial_generation), + connecting=bool(self.connecting), + connected=bool(self.connected), + no_esp=bool(self.no_esp), + loop_token=int(self.loop_token), + connect_time=float(self.connect_time), + board_fields=fields, + actual=str(self.board_state["actual"]), + as5600=MappingProxyType( + dict(self.board_state["as5600"])), + raw_state=str(self.board_state["raw_state"]), + raw_actual=str(self.board_state["raw_actual"]), + raw_as5600=str(self.board_state["raw_as5600"]), + updated=str(self.board_state["updated"]), + error=None if self.error is None else str(self.error), + ) + + +class GripperConnectionController: + """协调串口连接,且仅通过注入的 ``lifecycle`` 管理其他设备。 + + 本类不持有 App、Tk widget、相机或 SLAM 句柄。UI 调度、定时器和业务事件都 + 通过回调注入。 + """ + + UI_LOOP_MS = UI_LOOP_MS + SLOW_LOOP_MS = SLOW_LOOP_MS + FAST_GRIP_LOOP_MS = FAST_GRIP_LOOP_MS + + def __init__( + self, + state: ConnectionState, + serial_owner: GripperSerial, + serial_commands: SerialCommandWorker, + lifecycle: SensorLifecycle, + *, + dispatch: Optional[Callable[..., None]] = None, + schedule: Optional[Callable[[int, Callable[[], None]], object]] = None, + on_state: Optional[Callable[[ConnectionSnapshot], None]] = None, + on_board_update: Optional[Callable[[ConnectionSnapshot], None]] = None, + on_ui_tick: Optional[Callable[[], None]] = None, + on_grip_check: Optional[Callable[[], None]] = None, + on_reset_event: Optional[Callable[[], None]] = None, + on_stop_event: Optional[Callable[[], None]] = None, + thread_factory: Callable[..., threading.Thread] = threading.Thread, + clock: Callable[[], float] = time.monotonic, + wall_clock: Callable[[], float] = time.time, + logger: Callable[..., None] = print, + ): + if lifecycle is None: + raise ValueError("an injected sensor lifecycle is required") + self.state = state + self.serial = serial_owner + self.serial_commands = serial_commands + self.lifecycle = lifecycle + self.dispatch = dispatch or ( + lambda callback, *args: callback(*args)) + self.schedule = schedule or ( + lambda _delay_ms, callback: None) + self.on_state = on_state + self.on_board_update = on_board_update + self.on_ui_tick = on_ui_tick + self.on_grip_check = on_grip_check + self.on_reset_event = on_reset_event + self.on_stop_event = on_stop_event + self._thread_factory = thread_factory + self._clock = clock + self._wall_clock = wall_clock + self._logger = logger + self._transition_lock = threading.RLock() + self._connect_thread = None + self._heartbeat_stop = None + self._heartbeat_thread = None + self._grip_stop = None + self._grip_thread = None + + def snapshot(self) -> ConnectionSnapshot: + return self.state.snapshot() + + def start(self) -> bool: + return self.serial_commands.start() + + def clear_serial_queue(self) -> int: + return self.serial_commands.clear() + + def stop_serial_worker(self) -> bool: + return self.serial_commands.stop() + + def invalidate_loops(self) -> None: + with self.state.lock: + self.state.loop_token += 1 + + def refresh_ports(self): + return self.serial.list_ports() + + def _publish_state(self) -> None: + if self.on_state is not None: + snapshot = self.snapshot() + try: + self.dispatch(self.on_state, snapshot) + except Exception: + pass + + def _lifecycle_call(self, method_name: str, **kwargs): + method = getattr(self.lifecycle, method_name, None) + if not callable(method): + raise RuntimeError( + f"sensor lifecycle has no {method_name}() method") + result = method(**kwargs) + if result is False: + raise RuntimeError( + f"sensor lifecycle {method_name} rejected transition") + return result + + def connect(self, port: str, baud: int = 115200) -> bool: + """异步执行预检/交接和串口握手。""" + if not str(port).strip(): + raise ValueError("serial port is required") + with self.state.lock: + if self.state.connecting or self.state.connected: + return False + self.state.connecting = True + self.state.error = None + self.state.attempt_generation += 1 + attempt = self.state.attempt_generation + self._publish_state() + thread = self._thread_factory( + target=self._connect_worker, + args=(str(port), int(baud), attempt), + daemon=True, + name=f"gripper-connect-{attempt}", + ) + self._connect_thread = thread + thread.start() + return True + + def connect_sync(self, port: str, baud: int = 115200) -> bool: + """测试和无 GUI 调用使用的同步连接入口,顺序与异步入口完全相同。""" + if not str(port).strip(): + raise ValueError("serial port is required") + with self.state.lock: + if self.state.connecting or self.state.connected: + return False + self.state.connecting = True + self.state.error = None + self.state.attempt_generation += 1 + attempt = self.state.attempt_generation + self._publish_state() + ok, error = self._perform_connect(str(port), int(baud), attempt) + return self._finish_connect(attempt, ok, error) + + def connect_no_esp(self) -> bool: + """Start Fays/SLAM diagnostic mode without opening the ESP serial.""" + with self.state.lock: + if self.state.connecting or self.state.connected: + return False + self.state.connecting = True + self.state.no_esp = True + self.state.error = None + self.state.attempt_generation += 1 + attempt = self.state.attempt_generation + self._publish_state() + thread = self._thread_factory( + target=self._connect_no_esp_worker, + args=(attempt,), + daemon=True, + name=f"fays-no-esp-connect-{attempt}", + ) + self._connect_thread = thread + thread.start() + return True + + def toggle_no_esp(self) -> bool: + snapshot = self.snapshot() + if snapshot.connecting or snapshot.connected: + return self.disconnect() + return self.connect_no_esp() + + def connect_no_esp_sync(self) -> bool: + """Headless/test adapter for the no-ESP diagnostic path.""" + with self.state.lock: + if self.state.connecting or self.state.connected: + return False + self.state.connecting = True + self.state.no_esp = True + self.state.error = None + self.state.attempt_generation += 1 + attempt = self.state.attempt_generation + self._publish_state() + ok, error = self._perform_connect_no_esp(attempt) + return self._finish_connect_no_esp(attempt, ok, error) + + def _connect_worker(self, port: str, baud: int, attempt: int) -> None: + # ESP handshakes and SDK startup can block for seconds. Keep the full + # transition off Tk, not just its preflight half. + with self._transition_lock: + ok, error = self._perform_connect(port, baud, attempt) + self._finish_connect(attempt, ok, error) + + def _connect_no_esp_worker(self, attempt: int) -> None: + with self._transition_lock: + ok, error = self._perform_connect_no_esp(attempt) + self._finish_connect_no_esp(attempt, ok, error) + + def _perform_connect(self, port: str, baud: int, attempt: int): + self._logger(f"[Connect] Preparing Fays/Sightac handoff ...") + try: + # 必须先完成 Fays 身份预检和 Open 资源释放,失败时不得打开串口。 + self._lifecycle_call("prepare_connect") + with self.state.lock: + if attempt != self.state.attempt_generation: + raise RuntimeError("connection attempt invalidated") + verify = getattr( + self.lifecycle, "verify_prepared_control_port", None + ) + if callable(verify) and verify(port) is False: + raise RuntimeError( + "ESP32 control port identity verification failed" + ) + self._logger(f"[Connect] Trying {port}...") + ok = self.serial.connect(port, baud) + self._logger(f"[Connect] Result: {'OK' if ok else 'FAIL'}") + serial_error = getattr(self.serial, "last_error", None) + return ok, None if ok else ( + serial_error or "serial handshake timeout" + ) + except Exception as exc: + return False, str(exc) + + def _perform_connect_no_esp(self, attempt: int): + self._logger("[Connect no_esp] Preparing Fays handoff ...") + try: + self._lifecycle_call("prepare_connect") + with self.state.lock: + if attempt != self.state.attempt_generation: + raise RuntimeError("connection attempt invalidated") + self._lifecycle_call("connected", fake_imu=True) + return True, None + except Exception as exc: + return False, str(exc) + + def _finish_connect_no_esp( + self, attempt: int, ok: bool, error: Optional[str], + ) -> bool: + with self.state.lock: + current = attempt == self.state.attempt_generation + if not current: + return False + if ok: + now = self._clock() + with self.state.lock: + self.state.connecting = False + self.state.connected = True + self.state.no_esp = True + self.state.loop_token += 1 + self.state.connect_time = now + self.state.error = None + token = self.state.loop_token + self.dispatch(self.update_loops, token) + self._publish_state() + self._logger( + "[Connect no_esp] SLAM started with diagnostic fake IMU") + return True + + rollback_error = None + try: + self._lifecycle_call("connect_failed") + except Exception as exc: + rollback_error = str(exc) + failure = error or "no-ESP diagnostic connection failed" + if rollback_error: + failure = f"{failure}; rollback failed: {rollback_error}" + with self.state.lock: + self.state.connecting = False + self.state.connected = False + self.state.no_esp = False + self.state.loop_token += 1 + self.state.error = failure + self._publish_state() + return False + + def _finish_connect( + self, attempt: int, ok: bool, error: Optional[str], + ) -> bool: + with self.state.lock: + current = attempt == self.state.attempt_generation + if not current: + if ok: + self.serial.disconnect() + return False + + if ok and self.serial.is_connected and self.serial_commands.is_running: + try: + # 新协议握手:先让 ESP32 进入“已连接/等待初始化”,再通知 + # “初始化开始”,随后由 lifecycle 完成 SDK/SLAM/触觉初始化。 + if not self.send_control_signal("C"): + raise RuntimeError( + "ESP32 connect signal (C) rejected") + if not self.send_control_signal("I"): + raise RuntimeError( + "ESP32 init-start signal (I) rejected") + self._lifecycle_call("connected") + except Exception as exc: + # 初始化失败时通知 ESP32 进入异常状态(红闪)。 + try: + self.send_control_signal("E") + except Exception: + pass + error = str(exc) + ok = False + + if ok and self.serial.is_connected and self.serial_commands.is_running: + try: + # 初始化完成 → ESP32 进入“等待开始录制”(绿常亮)。 + if not self.send_control_signal("F"): + raise RuntimeError( + "ESP32 init-complete signal (F) rejected") + except Exception as exc: + try: + self.send_control_signal("E") + except Exception: + pass + error = str(exc) + ok = False + + if ok and self.serial.is_connected and self.serial_commands.is_running: + generation = self.serial_commands.advance_generation() + now = self._clock() + with self.state.lock: + if attempt != self.state.attempt_generation: + # A concurrent Cancel has invalidated this transition; + # its disconnect worker owns cleanup under _transition_lock. + return False + self.state.connecting = False + self.state.connected = True + self.state.no_esp = False + self.state.serial_generation = generation + self.state.loop_token += 1 + self.state.connect_time = now + self.state.error = None + token = self.state.loop_token + self._init_fields() + self.dispatch(self.update_loops, token) + self._publish_state() + return True + + rollback_error = None + try: + self._lifecycle_call("connect_failed") + except Exception as exc: + rollback_error = str(exc) + self._logger( + f"[Connect] Open rollback failed: {rollback_error}") + self.serial.disconnect() + failure = error or "connection failed" + if rollback_error: + failure = ( + f"{failure}; Open rollback failed: {rollback_error}" + ) + with self.state.lock: + self.state.connecting = False + self.state.connected = False + self.state.no_esp = False + self.state.loop_token += 1 + self.state.error = failure + self._publish_state() + return False + + def disconnect(self) -> bool: + """停止注入 lifecycle 后断开串口,并使全部旧循环/命令失效。""" + with self.state.lock: + was_active = self.state.connecting or self.state.connected + self.state.attempt_generation += 1 + self.state.loop_token += 1 + self.state.connecting = False + self.state.connected = False + self.state.no_esp = False + self.state.connect_time = 0.0 + token = self.state.loop_token + generation = self.serial_commands.clear() + self._stop_heartbeat() + self._stop_grip_checks() + with self._transition_lock: + error = None + try: + self._lifecycle_call("disconnect") + except Exception as exc: + error = str(exc) + self.serial.disconnect() + with self.state.lock: + self.state.serial_generation = generation + self.state.loop_token = token + self.state.error = error + self._publish_state() + return was_active and error is None + + def close(self) -> None: + """幂等停止连接、单 worker 和串口 owner。""" + self.disconnect() + self.serial_commands.stop() + self.serial.disconnect() + + def send_async( + self, + command: str, + callback: Optional[Callable[[str], None]] = None, + key: Optional[str] = None, + mode: str = "queue", + ) -> bool: + return self.serial_commands.submit( + command, callback=callback, key=key, mode=mode) + + def send_sync( + self, + command: str, + *, + timeout: Optional[float] = None, + key: Optional[str] = None, + mode: str = "queue", + ) -> str: + return self.serial_commands.execute( + command, timeout=timeout, key=key, mode=mode) + + def send_control_signal( + self, command: str, *, timeout: float = 1.5, + ) -> bool: + """Send one host→ESP32 control signal (C/I/F/E) through the worker. + + Returns ``False`` when the signal is rejected, times out, or the + worker is not running. The ESP32 replies ``OK `` on success. + """ + try: + response = self.serial_commands.execute( + command, timeout=timeout, mode="queue") + except Exception: + return False + return bool(response) and not response.startswith("ERR") + + def request_as5048a( + self, callback: Optional[Callable[[Mapping[str, str]], None]] = None, + ) -> bool: + """异步读取 AS5048A;不绕过唯一串口 worker。""" + def handled(response: str) -> None: + values = self.parse_as5048a(response) + if callback is not None: + callback(values) + + return self.send_async( + "G", handled, key="as5048a", mode="skip") + + def get_as5048a(self, timeout: Optional[float] = None): + """同步读取 AS5048A,同样经过唯一串口 worker。""" + return self.parse_as5048a( + self.send_sync("G", timeout=timeout)) + + @staticmethod + def parse_as5048a(response: str): + if not response or not response.startswith("AS5048A"): + return MappingProxyType({}) + return MappingProxyType(dict( + item.split("=", 1) + for item in response.split() + if "=" in item + )) + + def _init_fields(self) -> None: + self.send_async("?", self._handle_state_response) + + @staticmethod + def parse_pairs(line: str): + values = {} + for part in str(line).split(): + if "=" in part: + key, value = part.split("=", 1) + values[key] = value + return values + + def _handle_state_response(self, response: str) -> None: + response = response or "--" + event = "" + fields = None + with self.state.lock: + board = self.state.board_state + board["raw_state"] = response + board["updated"] = time.strftime("%H:%M:%S") + if response.startswith("STATE "): + fields = self.parse_pairs(response) + board["state"] = fields + event = fields.get("EVT", "") + elif response == "ERR": + board["state"] = {} + connect_time = self.state.connect_time + + if fields is not None: + if event == "R": + if self._clock() - connect_time < RESET_EVENT_DEBOUNCE_S: + self._logger("[Button] EVT=R ignored (debounce)") + elif self.on_reset_event is not None: + self._logger( + "[Button] EVT=R → reset origin + recording") + self.on_reset_event() + elif event == "S" and self.on_stop_event is not None: + self._logger("[Button] EVT=S → stop recording") + self.on_stop_event() + + snapshot = self.snapshot() + if self.on_board_update is not None: + self.on_board_update(snapshot) + + def _poll_info(self) -> None: + self.send_async( + "?", self._handle_state_response, + key="poll_info", mode="skip", + ) + + def _loop_active(self, token: int) -> bool: + with self.state.lock: + return ( + token == self.state.loop_token + and self.state.connected + and (self.state.no_esp or self.serial.is_connected) + ) + + def _ui_loop(self, token: int) -> None: + if not self._loop_active(token): + return + if self.on_ui_tick is not None: + self.on_ui_tick() + self.schedule( + self.UI_LOOP_MS, lambda: self._ui_loop(token)) + + def _fast_grip_loop(self, token: int) -> None: + """Run force checks off the Tk main thread at the original period.""" + stop_event = self._grip_stop + thread = self._grip_thread + if thread is not None and thread.is_alive(): + stop_event.set() + if thread is not threading.current_thread(): + thread.join(timeout=0.2) + self._grip_stop = threading.Event() + worker = self._thread_factory( + target=self._grip_check_loop, + args=(token, self._grip_stop), + name="force-grip-check", + daemon=True, + ) + self._grip_thread = worker + worker.start() + + def _grip_check_loop(self, token: int, stop_event): + while not stop_event.wait(self.FAST_GRIP_LOOP_MS / 1000.0): + if not self._loop_active(token): + break + if self.snapshot().no_esp: + continue + if self.on_grip_check is not None: + self.on_grip_check() + + def _stop_grip_checks(self) -> None: + stop_event = self._grip_stop + thread = self._grip_thread + self._grip_stop = None + self._grip_thread = None + if stop_event is not None: + stop_event.set() + if ( + thread is not None + and thread is not threading.current_thread() + and thread.is_alive() + ): + thread.join(timeout=0.5) + + def _start_heartbeat(self, token: int) -> None: + """Start the ESP32 keep-alive "?" poll on its own daemon thread. + + The poll no longer rides ``root.after`` so a stalled Tk main thread + (e.g. a long synchronous save) cannot let the ESP32 declare the host + offline and stop accepting the physical record button. + """ + stop_event = self._heartbeat_stop + thread = self._heartbeat_thread + if thread is not None and thread.is_alive(): + if stop_event is not None: + stop_event.set() + if thread is not threading.current_thread(): + thread.join(timeout=0.5) + self._heartbeat_stop = threading.Event() + heartbeat = self._thread_factory( + target=self._heartbeat_loop, + args=(token, self._heartbeat_stop), + name="esp-heartbeat", + daemon=True, + ) + self._heartbeat_thread = heartbeat + heartbeat.start() + + def _heartbeat_loop( + self, token: int, stop_event: threading.Event, + ) -> None: + while not stop_event.is_set(): + if self._loop_active(token) and not self.snapshot().no_esp: + self._poll_info() + stop_event.wait(HEARTBEAT_PERIOD_S) + + def _stop_heartbeat(self) -> None: + stop_event = self._heartbeat_stop + thread = self._heartbeat_thread + self._heartbeat_stop = None + self._heartbeat_thread = None + if stop_event is not None: + stop_event.set() + if ( + thread is not None + and thread is not threading.current_thread() + and thread.is_alive() + ): + thread.join(timeout=0.5) + + def update_loops(self, token: Optional[int] = None) -> None: + if token is None: + with self.state.lock: + token = self.state.loop_token + if self._loop_active(token): + self._start_heartbeat(token) + self._ui_loop(token) + self._fast_grip_loop(token) diff --git a/collector/core/gripper/devices/gripper_serial.py b/collector/core/gripper/devices/gripper_serial.py new file mode 100644 index 0000000000000000000000000000000000000000..7ec55d4b28844c06e1b7ada1857cd078fa931c51 --- /dev/null +++ b/collector/core/gripper/devices/gripper_serial.py @@ -0,0 +1,181 @@ +"""ESP32S3 夹爪串口的唯一资源所有者。""" + +from __future__ import annotations + +import threading +import time +from typing import Callable, Optional + +import serial +import serial.tools.list_ports + + +class GripperSerial: + """拥有并封装唯一的 ``serial.Serial`` 实例。 + + ``connect`` 内的 ``?`` 是打开后的握手,不属于应用命令。握手完成以后,所有 + 同步和异步应用命令都应交给 :class:`SerialCommandWorker`,由它串行调用 + :meth:`send`。 + """ + + CONNECT_BAUD = 115200 + CONNECT_TIMEOUT = 0.5 + CONNECT_WRITE_TIMEOUT = 0.5 + CONNECT_BOOT_DELAY = 2.0 + CONNECT_ATTEMPTS = 8 + CONNECT_RETRY_DELAY = 0.3 + COMMAND_TIMEOUT = 1.0 + + def __init__( + self, + serial_factory: Optional[Callable[..., object]] = None, + *, + sleep: Callable[[float], None] = time.sleep, + clock: Callable[[], float] = time.monotonic, + logger: Callable[..., None] = print, + ): + self._serial_factory = serial_factory or serial.Serial + self._sleep = sleep + self._clock = clock + self._logger = logger + self._serial = None + self._last_error = None + # connect/disconnect 与 worker send 共用同一把可重入锁;断开不会在一条 + # 命令写入和读取响应之间关闭文件描述符。 + self._io_lock = threading.RLock() + + @property + def ser(self): + """Return the owner-held handle for read-only connection diagnostics.""" + with self._io_lock: + return self._serial + + @property + def is_connected(self) -> bool: + with self._io_lock: + return bool( + self._serial is not None + and getattr(self._serial, "is_open", False) + ) + + @property + def last_error(self) -> Optional[str]: + """返回最近一次连接失败的准确原因,不用握手超时覆盖打开错误。""" + with self._io_lock: + return self._last_error + + def connect(self, port: str, baud: int = CONNECT_BAUD) -> bool: + """打开串口并用原有的八次 ``?`` 握手确认主控在线。""" + with self._io_lock: + self._disconnect_locked() + self._last_error = None + try: + opened = self._serial_factory( + port, + baud, + timeout=self.CONNECT_TIMEOUT, + write_timeout=self.CONNECT_WRITE_TIMEOUT, + ) + self._serial = opened + self._sleep(self.CONNECT_BOOT_DELAY) + opened.reset_input_buffer() + for attempt in range(self.CONNECT_ATTEMPTS): + opened.write(b"?\r\n") + line = opened.readline().decode( + errors="ignore").strip() + self._logger( + f"[Serial] connect attempt {attempt + 1}/" + f"{self.CONNECT_ATTEMPTS}: [{line[:60]}]" + ) + if line.startswith("STATE"): + return True + self._sleep(self.CONNECT_RETRY_DELAY) + except Exception as exc: + self._last_error = ( + f"serial open/handshake failed: {exc}" + ) + self._disconnect_locked() + return False + self._last_error = ( + "serial handshake timeout after " + f"{self.CONNECT_ATTEMPTS} attempts" + ) + self._disconnect_locked() + return False + + def disconnect(self) -> None: + """幂等关闭串口;即使底层已关闭也清除 owner 引用。""" + with self._io_lock: + self._disconnect_locked() + + def _disconnect_locked(self) -> None: + opened, self._serial = self._serial, None + if opened is None: + return + try: + if getattr(opened, "is_open", False): + # CDC-ACM 端点停止接收时,close(fd) 也可能等待 tty 输出 + # 队列排空。先中断 pyserial 写等待并丢弃未发送字节,保证 + # Connect 失败和退出路径都有界。 + cancel_write = getattr(opened, "cancel_write", None) + if callable(cancel_write): + try: + cancel_write() + except Exception: + pass + reset_output = getattr( + opened, "reset_output_buffer", None) + if callable(reset_output): + try: + reset_output() + except Exception: + pass + opened.close() + except Exception: + # 关闭失败时也不能把已经失效的句柄重新暴露给调用方。 + pass + + def send(self, command: str) -> str: + """发送一条文本命令并返回匹配的完整响应行。""" + with self._io_lock: + opened = self._serial + if opened is None or not getattr(opened, "is_open", False): + return "ERR" + try: + # 固件在 RECORDING 状态会主动输出 DATA 行。先清旧输入,再只 + # 接受当前命令的响应前缀,保持原程序的防串线行为。 + try: + opened.reset_input_buffer() + except Exception: + pass + opened.write((str(command) + "\r\n").encode()) + expected = { + "?": ("STATE",), + "G": ("AS5048A", "AS5048A ERR"), + "C": ("OK CONNECT", "ERR"), + "I": ("OK INIT", "ERR"), + "F": ("OK READY", "ERR"), + "E": ("OK ERROR", "ERR"), + "R": ("OK ASR", "AS5048A ERR"), + "S": ("OK START", "ERR"), + }.get(str(command)[:1], ()) + deadline = self._clock() + self.COMMAND_TIMEOUT + last_line = "" + while self._clock() < deadline: + line = opened.readline().decode( + errors="ignore").strip() + if not line: + continue + last_line = line + if not expected or line.startswith(expected): + return line + return last_line or "ERR" + except Exception: + return "ERR" + + @staticmethod + def list_ports(): + """返回系统当前可用串口设备名。""" + return [ + port.device for port in serial.tools.list_ports.comports() + ] diff --git a/collector/core/gripper/devices/relative_usb_topology.py b/collector/core/gripper/devices/relative_usb_topology.py new file mode 100644 index 0000000000000000000000000000000000000000..c3823d721dcda1063d32a203fed22032ec998ec7 --- /dev/null +++ b/collector/core/gripper/devices/relative_usb_topology.py @@ -0,0 +1,455 @@ +"""ESP32-anchored discovery for one physical gripper set. + +The only accepted topology is: + + ESP32 (VID/PID 303a:1001) + -> H1: one DECXIN (VID/PID 1bcf:2d4f) + -> H0 = parent(H1): two Sightac (VID/PID 0c45:636f) + +Fays is identified independently as one FT602 physical device with +interface 00 and interface 02. It is assigned to the ESP32 unit only when +their USB root-port numbers match. No independent camera unit, enumeration-order +pairing, or fallback topology is accepted. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import glob +import os +import re +from typing import Callable, Iterable, Optional + + +FAYS_VENDOR_ID = "0403" +FAYS_PRODUCT_ID = "602e" +SIGHTAC_VENDOR_ID = "0c45" +SIGHTAC_PRODUCT_ID = "636f" +DECXIN_VENDOR_ID = "1bcf" +DECXIN_PRODUCT_ID = "2d4f" +ESP32_VENDOR_ID = "303a" +ESP32_PRODUCT_ID = "1001" +DECXIN_NAME = "DECXIN CAMERA: DECXIN CAMERA" +OUTER_HUB_MIN_SPEED_MBPS = 5000.0 +INNER_HUB_MAX_SPEED_MBPS = 480.0 + + +def _read_text(path: str) -> str: + with open(path, encoding="utf-8") as stream: + return stream.read().strip() + + +def _natural_key(value: str): + return tuple( + int(part) if part.isdigit() else part + for part in re.split(r"([0-9]+)", str(value)) + if part + ) + + +def _root_port_key(physical_usb_path: str) -> Optional[str]: + """Return the bus-independent root-port number from a USB path.""" + match = re.fullmatch(r"\d+-(\d+)(?:\.\d+)*", str(physical_usb_path)) + return match.group(1) if match is not None else None + + +@dataclass(frozen=True) +class RelativeDeviceNode: + role: str + device_path: str + physical_usb_path: str + physical_sysfs_path: str + parent_hub_sysfs_path: str + vendor_id: str + product_id: str + serial: str + name: str + interface_number: str + stream_index: int + + @property + def video_index(self) -> Optional[int]: + basename = os.path.basename(self.device_path) + if basename.startswith("video") and basename[5:].isdigit(): + return int(basename[5:]) + return None + + +@dataclass(frozen=True) +class RelativeUnitTopology: + fays_stereo: Optional[RelativeDeviceNode] + fays_imu: Optional[RelativeDeviceNode] + sightac_nodes: tuple + decxin: Optional[RelativeDeviceNode] + esp32: Optional[RelativeDeviceNode] + outer_hub_sysfs_path: str + inner_hub_sysfs_path: str + fays_physical_sysfs_path: str + + @property + def ports(self): + if self.fays_stereo is None or self.fays_imu is None: + return {} + return { + "stereo_dev_port": self.fays_stereo.device_path, + "imu_dev_port": self.fays_imu.device_path, + } + + @property + def outer_hub_path(self) -> str: + """Diagnostic only; never used as a matching key.""" + return os.path.basename(self.outer_hub_sysfs_path) + + @property + def inner_hub_path(self) -> str: + """Diagnostic only; never used as a matching key.""" + return os.path.basename(self.inner_hub_sysfs_path) + + +def _parent_hub(path: str) -> str: + return os.path.dirname(path) + + +def _hub_speed_mbps( + hub_sysfs_path: str, + *, + read_text: Callable[[str], str], +) -> Optional[float]: + try: + return float(read_text(os.path.join(hub_sysfs_path, "speed"))) + except (OSError, ValueError): + return None + + +def _hub_device_class( + hub_sysfs_path: str, + *, + read_text: Callable[[str], str], +) -> str: + try: + return read_text(os.path.join(hub_sysfs_path, "bDeviceClass")).lower() + except OSError: + return "" + + +def is_hub_path( + hub_sysfs_path: str, + *, + read_text: Callable[[str], str] = _read_text, + isdir: Callable[[str], bool] = os.path.isdir, +) -> bool: + """Return True when the directory describes a USB hub (class 0x09).""" + try: + return ( + isdir(hub_sysfs_path) + and _hub_device_class(hub_sysfs_path, read_text=read_text) == "09" + ) + except OSError: + return False + + +def _physical_device_from_interface( + interface_sysfs_path: str, + *, + realpath: Callable[[str], str], +) -> tuple: + physical_path = _parent_hub(interface_sysfs_path) + interface_basename = os.path.basename(interface_sysfs_path) + physical_usb_path = interface_basename.split(":", 1)[0] + if ( + ":" not in interface_basename + or not re.fullmatch(r"\d+-\d+(?:\.\d+)*", physical_usb_path) + ): + raise ValueError(f"not a USB interface path: {interface_sysfs_path}") + return physical_path, physical_usb_path + + +def inspect_video_node( + class_path: str, + *, + read_text: Callable[[str], str] = _read_text, + realpath: Callable[[str], str] = os.path.realpath, + device_exists: Callable[[str], bool] = os.path.exists, + isdir: Callable[[str], bool] = os.path.isdir, +): + """Classify one video4linux node using only its sysfs identity.""" + del isdir + basename = os.path.basename(class_path) + if not re.fullmatch(r"video\d+", basename): + return None + try: + stream_index = int(read_text(os.path.join(class_path, "index"))) + if stream_index != 0: + return None + name = read_text(os.path.join(class_path, "name")) + interface_number = read_text( + os.path.join(class_path, "device", "bInterfaceNumber") + ).lower() + modalias = read_text( + os.path.join(class_path, "device", "modalias") + ).lower() + interface_sysfs_path = realpath(os.path.join(class_path, "device")) + physical_sysfs_path, physical_usb_path = _physical_device_from_interface( + interface_sysfs_path, realpath=realpath + ) + vendor_id = read_text( + os.path.join(physical_sysfs_path, "idVendor") + ).lower() + product_id = read_text( + os.path.join(physical_sysfs_path, "idProduct") + ).lower() + try: + serial = read_text(os.path.join(physical_sysfs_path, "serial")) + except OSError: + serial = "" + parent_hub = _parent_hub(physical_sysfs_path) + except (OSError, ValueError): + return None + + if not device_exists(f"/dev/{basename}"): + return None + + lowered_name = name.lower() + role = None + if ( + vendor_id == FAYS_VENDOR_ID + and product_id == FAYS_PRODUCT_ID + and "ftdi" in lowered_name + and "superspeed video bridge" in lowered_name + ): + if interface_number == "00": + role = "fays_stereo" + elif interface_number == "02": + role = "fays_imu" + elif vendor_id == SIGHTAC_VENDOR_ID and product_id == SIGHTAC_PRODUCT_ID: + role = "sightac" + elif ( + vendor_id == DECXIN_VENDOR_ID + and product_id == DECXIN_PRODUCT_ID + and name == DECXIN_NAME + ): + role = "decxin" + if role is None: + return None + return RelativeDeviceNode( + role=role, + device_path=f"/dev/{basename}", + physical_usb_path=physical_usb_path, + physical_sysfs_path=physical_sysfs_path, + parent_hub_sysfs_path=parent_hub, + vendor_id=vendor_id, + product_id=product_id, + serial=serial, + name=name, + interface_number=interface_number, + stream_index=stream_index, + ) + + +def inspect_tty_node( + class_path: str, + *, + read_text: Callable[[str], str] = _read_text, + realpath: Callable[[str], str] = os.path.realpath, + device_exists: Callable[[str], bool] = os.path.exists, + isdir: Callable[[str], bool] = os.path.isdir, +): + """Classify one ttyACM node as an ESP32 using only sysfs identity.""" + del isdir + basename = os.path.basename(class_path) + if not re.fullmatch(r"ttyACM\d+", basename): + return None + try: + interface_sysfs_path = realpath(os.path.join(class_path, "device")) + physical_sysfs_path, physical_usb_path = _physical_device_from_interface( + interface_sysfs_path, realpath=realpath + ) + vendor_id = read_text( + os.path.join(physical_sysfs_path, "idVendor") + ).lower() + product_id = read_text( + os.path.join(physical_sysfs_path, "idProduct") + ).lower() + if vendor_id != ESP32_VENDOR_ID or product_id != ESP32_PRODUCT_ID: + return None + serial = read_text(os.path.join(physical_sysfs_path, "serial")) + parent_hub = _parent_hub(physical_sysfs_path) + except (OSError, ValueError): + return None + + if not device_exists(f"/dev/{basename}"): + return None + return RelativeDeviceNode( + role="esp32", + device_path=f"/dev/{basename}", + physical_usb_path=physical_usb_path, + physical_sysfs_path=physical_sysfs_path, + parent_hub_sysfs_path=parent_hub, + vendor_id=vendor_id, + product_id=product_id, + serial=serial, + name=basename, + interface_number="", + stream_index=0, + ) + + +def discover_relative_units( + *, + video_sysfs_glob: Callable[[], Iterable[str]] = lambda: glob.glob( + "/sys/class/video4linux/video*" + ), + tty_sysfs_glob: Callable[[], Iterable[str]] = lambda: glob.glob( + "/sys/class/tty/ttyACM*" + ), + read_text: Callable[[str], str] = _read_text, + realpath: Callable[[str], str] = os.path.realpath, + device_exists: Callable[[str], bool] = os.path.exists, + isdir: Callable[[str], bool] = os.path.isdir, +): + """Discover complete units using only ESP32 -> DECXIN -> H0 -> Sightac.""" + video_nodes = [] + for class_path in sorted(video_sysfs_glob(), key=_natural_key): + node = inspect_video_node( + class_path, + read_text=read_text, + realpath=realpath, + device_exists=device_exists, + isdir=isdir, + ) + if node is not None: + video_nodes.append(node) + + tty_nodes = [] + for class_path in sorted(tty_sysfs_glob(), key=_natural_key): + node = inspect_tty_node( + class_path, + read_text=read_text, + realpath=realpath, + device_exists=device_exists, + isdir=isdir, + ) + if node is not None: + tty_nodes.append(node) + + fays_by_physical = {} + sightac_by_parent = {} + decxin_by_parent = {} + esp32_by_parent = {} + for node in video_nodes: + if node.role in {"fays_stereo", "fays_imu"}: + fays_by_physical.setdefault( + node.physical_sysfs_path, {} + )[node.role] = node + elif node.role == "sightac": + sightac_by_parent.setdefault( + node.parent_hub_sysfs_path, [] + ).append(node) + elif node.role == "decxin": + decxin_by_parent.setdefault( + node.parent_hub_sysfs_path, [] + ).append(node) + for node in tty_nodes: + esp32_by_parent.setdefault(node.parent_hub_sysfs_path, []).append(node) + + fays_groups = [] + for physical_path, interfaces in sorted( + fays_by_physical.items(), key=lambda item: _natural_key(item[0]) + ): + stereo = interfaces.get("fays_stereo") + imu = interfaces.get("fays_imu") + if stereo is None or imu is None: + continue + fays_parent = stereo.parent_hub_sysfs_path + if fays_parent != imu.parent_hub_sysfs_path: + continue + if not is_hub_path(fays_parent, read_text=read_text, isdir=isdir): + continue + speed = _hub_speed_mbps(fays_parent, read_text=read_text) + if speed is None or speed < OUTER_HUB_MIN_SPEED_MBPS: + continue + fays_groups.append((physical_path, stereo, imu)) + + candidates = [] + for esp_parent, esp32_nodes in sorted( + esp32_by_parent.items(), key=lambda item: _natural_key(item[0]) + ): + if len(esp32_nodes) != 1: + continue + esp32 = esp32_nodes[0] + if not is_hub_path(esp_parent, read_text=read_text, isdir=isdir): + continue + speed = _hub_speed_mbps(esp_parent, read_text=read_text) + if speed is None or speed > INNER_HUB_MAX_SPEED_MBPS: + continue + + decxin_nodes = tuple(decxin_by_parent.get(esp_parent, ())) + if len(decxin_nodes) != 1: + continue + + outer_hub = os.path.dirname(esp_parent) + if not is_hub_path(outer_hub, read_text=read_text, isdir=isdir): + continue + speed = _hub_speed_mbps(outer_hub, read_text=read_text) + if speed is None or speed > INNER_HUB_MAX_SPEED_MBPS: + continue + sightac_nodes = tuple(sorted( + sightac_by_parent.get(outer_hub, ()), + key=lambda node: _natural_key(node.physical_usb_path), + )) + if len(sightac_nodes) != 2: + continue + + esp_root_port = _root_port_key(esp32.physical_usb_path) + if esp_root_port is None: + continue + fays_matches = [ + group for group in fays_groups + if _root_port_key(group[1].physical_usb_path) == esp_root_port + ] + if len(fays_matches) != 1: + continue + candidates.append(( + fays_matches[0], esp32, decxin_nodes[0], sightac_nodes, + outer_hub, esp_parent, + )) + + fays_use_count = {} + for fays_group, *_ in candidates: + fays_use_count[fays_group[0]] = fays_use_count.get( + fays_group[0], 0 + ) + 1 + + units = [] + for ( + fays_group, esp32, decxin, sightac_nodes, outer_hub, inner_hub + ) in candidates: + fays_physical_path, stereo, imu = fays_group + if fays_use_count[fays_physical_path] != 1: + continue + units.append(RelativeUnitTopology( + fays_stereo=stereo, + fays_imu=imu, + sightac_nodes=sightac_nodes, + decxin=decxin, + esp32=esp32, + outer_hub_sysfs_path=outer_hub, + inner_hub_sysfs_path=inner_hub, + fays_physical_sysfs_path=fays_physical_path, + )) + + return tuple(units) + + +def unit_for_esp_serial( + units: Iterable[RelativeUnitTopology], + serial: str, +) -> Optional[RelativeUnitTopology]: + """Return the relative unit whose ESP32 matches ``serial`` exactly.""" + wanted = str(serial or "").strip() + if not wanted: + return None + for unit in units: + if unit.esp32 is not None and unit.esp32.serial == wanted: + return unit + return None diff --git a/collector/core/gripper/devices/serial_command_worker.py b/collector/core/gripper/devices/serial_command_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..699239c72c61530810a483021c5985c754d1fe6a --- /dev/null +++ b/collector/core/gripper/devices/serial_command_worker.py @@ -0,0 +1,294 @@ +"""带 generation 的单一串口命令调度线程。""" + +from __future__ import annotations + +from dataclasses import dataclass +import queue +import threading +from typing import Callable, Optional + + +class SerialCommandCancelled(RuntimeError): + """命令因断开、清队列、停止或 latest 替换而失效。""" + + +@dataclass +class _Completion: + event: threading.Event + response: Optional[str] = None + error: Optional[BaseException] = None + + def finish( + self, + response: Optional[str] = None, + error: Optional[BaseException] = None, + ) -> None: + if self.event.is_set(): + return + self.response = response + self.error = error + self.event.set() + + +@dataclass +class _Command: + command: str + callback: Optional[Callable[[str], None]] + key: Optional[str] + mode: str + generation: int + completion: Optional[_Completion] = None + + +class SerialCommandWorker: + """顺序执行全部同步/异步应用命令。 + + ``queue`` 保留顺序;同 key 的 ``skip`` 忽略重复提交;``latest`` 在当前命令 + 尚未结束时只保留最后一次值。``clear`` 和重连会推进 generation,旧命令不能 + 再发布回调。 + """ + + STOP_TIMEOUT = 1.0 + VALID_MODES = frozenset({"queue", "skip", "latest"}) + + def __init__( + self, + send_command: Callable[[str], str], + dispatch_callback: Optional[ + Callable[[Callable[[str], None], str], None] + ] = None, + *, + thread_factory: Callable[..., threading.Thread] = threading.Thread, + ): + self._send_command = send_command + self._dispatch_callback = ( + dispatch_callback + if dispatch_callback is not None + else lambda callback, response: callback(response) + ) + self._thread_factory = thread_factory + self._queue = queue.Queue() + self._state_lock = threading.Lock() + self._pending_keys = set() + self._latest_by_key = {} + self._generation = 0 + self._running = False + self._thread = None + self._active = None + + @property + def is_running(self) -> bool: + with self._state_lock: + return self._running + + @property + def generation(self) -> int: + with self._state_lock: + return self._generation + + @property + def thread(self): + return self._thread + + def start(self) -> bool: + """启动唯一 worker;重复调用不创建第二条串口线程。""" + with self._state_lock: + if self._running: + return False + if self._thread is not None and self._thread.is_alive(): + raise RuntimeError("previous serial worker is still exiting") + self._running = True + thread = self._thread_factory( + target=self._run, + daemon=True, + name="serial-command-worker", + ) + self._thread = thread + thread.start() + return True + + def _run(self) -> None: + while True: + item = self._queue.get() + if item is None: + break + with self._state_lock: + self._active = item + try: + response = self._send_command(item.command) + except BaseException as exc: # worker 必须继续服务后续命令 + response = "ERR" + send_error = exc + else: + send_error = None + + next_item = None + with self._state_lock: + current = ( + self._running + and item.generation == self._generation + ) + latest = None + if item.key: + if item.generation == self._generation and self._running: + latest = self._latest_by_key.pop( + item.key, None) + next_item = latest + if latest is None: + self._pending_keys.discard(item.key) + else: + self._pending_keys.discard(item.key) + stale = self._latest_by_key.pop(item.key, None) + self._cancel_item( + stale, "serial generation advanced") + has_newer = ( + item.key is not None + and item.mode == "latest" + and latest is not None + ) + self._active = None + if next_item is not None: + self._queue.put(next_item) + + if item.completion is not None: + if send_error is not None: + item.completion.finish(error=send_error) + elif not current or has_newer: + item.completion.finish(error=SerialCommandCancelled( + "serial command became stale")) + else: + item.completion.finish(response=response) + + if current and item.callback and not has_newer: + try: + self._dispatch_callback(item.callback, response) + except Exception: + # UI dispatcher 的生命周期独立于串口 worker;窗口已销毁时 + # 不能让唯一命令线程随之退出。 + pass + + with self._state_lock: + self._active = None + self._running = False + + @staticmethod + def _cancel_item(item, reason: str) -> None: + if item is not None and item.completion is not None: + item.completion.finish( + error=SerialCommandCancelled(reason)) + + def _invalidate_locked(self, reason: str) -> None: + self._generation += 1 + self._pending_keys.clear() + latest = tuple(self._latest_by_key.values()) + self._latest_by_key.clear() + for item in latest: + self._cancel_item(item, reason) + + def clear(self) -> int: + """推进 generation,并丢弃断开前尚未执行的命令。""" + with self._state_lock: + self._invalidate_locked("serial queue cleared") + generation = self._generation + while True: + try: + item = self._queue.get_nowait() + except queue.Empty: + break + if item is None: + # 不得吞掉 stop 已发布的唯一唤醒哨兵。 + self._queue.put(None) + break + self._cancel_item(item, "serial queue cleared") + return generation + + def advance_generation(self) -> int: + """成功重连后建立新的回调 generation。""" + with self._state_lock: + self._invalidate_locked("serial connection generation advanced") + return self._generation + + def submit( + self, + command: str, + callback: Optional[Callable[[str], None]] = None, + key: Optional[str] = None, + mode: str = "queue", + *, + _completion: Optional[_Completion] = None, + ) -> bool: + """提交命令;返回 ``False`` 表示被同 key 的 ``skip`` 合并。""" + if mode not in self.VALID_MODES: + raise ValueError(f"unsupported serial command mode: {mode}") + with self._state_lock: + if not self._running: + raise RuntimeError("serial command worker is not running") + item = _Command( + command=str(command), + callback=callback, + key=key, + mode=mode, + generation=self._generation, + completion=_completion, + ) + if key: + if key in self._pending_keys: + if mode == "latest": + previous = self._latest_by_key.get(key) + self._latest_by_key[key] = item + self._cancel_item( + previous, "serial latest command superseded") + return True + self._cancel_item( + item, "duplicate serial command skipped") + return False + self._pending_keys.add(key) + self._queue.put(item) + return True + + def execute( + self, + command: str, + *, + timeout: Optional[float] = None, + key: Optional[str] = None, + mode: str = "queue", + ) -> str: + """通过同一 worker 同步执行命令。""" + completion = _Completion(threading.Event()) + accepted = self.submit( + command, key=key, mode=mode, _completion=completion) + if not accepted: + raise SerialCommandCancelled( + "duplicate serial command skipped") + if not completion.event.wait(timeout=timeout): + raise TimeoutError(f"serial command timed out: {command}") + if completion.error is not None: + raise completion.error + return completion.response or "ERR" + + # ``request`` 是语义更明确的同步别名。 + request = execute + + def stop(self) -> bool: + """停止 worker,并保持原实现的 1 秒 join 上限。""" + with self._state_lock: + if not self._running and ( + self._thread is None or not self._thread.is_alive()): + return True + self._running = False + self._invalidate_locked("serial worker stopped") + self._cancel_item(self._active, "serial worker stopped") + thread = self._thread + while True: + try: + item = self._queue.get_nowait() + except queue.Empty: + break + if item is not None: + self._cancel_item(item, "serial worker stopped") + self._queue.put(None) + if (thread is not None and thread.is_alive() + and thread is not threading.current_thread()): + thread.join(timeout=self.STOP_TIMEOUT) + return not (thread is not None and thread.is_alive()) diff --git a/collector/core/gripper/devices/tactile_discovery.py b/collector/core/gripper/devices/tactile_discovery.py new file mode 100644 index 0000000000000000000000000000000000000000..be7b4bb160d12ae1fc5f1dbc10c255ec17af4884 --- /dev/null +++ b/collector/core/gripper/devices/tactile_discovery.py @@ -0,0 +1,1707 @@ +"""Sightac left/right 发现、Flash 缓存和 TouchSensor 构造。""" + +from __future__ import annotations + +import ctypes +import glob +import importlib +import json +import math +import os +import re +import sys +import threading +from types import MappingProxyType +from typing import Callable, Optional + +import cv2 + +from core.gripper.fays_runtime import GRIPPER_DIR + + +_ERROR_MARKERS = ( + "error", + "failed", + "exception", + "traceback", + "cannot", + "unable", + "denied", + "timeout", + "timed out", + "device busy", + "resource busy", + "错误", + "失败", +) +_SONIX_MODALIAS_PREFIX = "usb:v0c45p636f" +_SIGHTAC_API_PACKAGES = frozenset({ + "api", + "api_legacy_2_4_5", + "api_new", + "api_v3_2_2_ksq", +}) + + +class TactileDiscovery: + """发现两路 Sonix Sightac,并在开流前缓存完整 Flash 参数。 + + Linux 探测是 fail-closed 的:只有 ``/sys/class/video4linux/videoN`` 的 + ``name``、``index`` 和节点自身 ``device/modalias`` 都能只读确认、 + ``index == 0`` 且 VID/PID 为 ``0c45:636f`` 时,节点才会交给 Sonix + SDK。旧模板身份只读解析 video class symlink 对应的 USB interface 及其 + 唯一物理父设备,不遍历 USB 总线,不修改 sysfs,也不执行 USB reset。 + """ + + def __init__( + self, + *, + sysfs_root: str = "/sys/class/video4linux", + dev_root: str = "/dev", + platform: Optional[str] = None, + sightac_root: Optional[str] = None, + cv2_module=cv2, + path_exists: Callable[[str], bool] = os.path.exists, + logger: Callable[..., None] = print, + full_logs: Optional[bool] = None, + old_sensor_template_file: Optional[str] = None, + api_package: Optional[str] = None, + ): + self.sysfs_root = os.path.abspath(sysfs_root) + self.dev_root = os.path.abspath(dev_root) + self.platform = platform or sys.platform + self.sightac_root = sightac_root + requested_api = ( + api_package + or os.environ.get("KSQ_SIGHTAC_API_PACKAGE") + or "api_new" + ).strip() + if requested_api not in _SIGHTAC_API_PACKAGES: + raise ValueError( + "unsupported Sightac API package: " + f"{requested_api!r}; expected one of " + f"{sorted(_SIGHTAC_API_PACKAGES)}" + ) + self.api_package = requested_api + self._cv2 = cv2_module + self._path_exists = path_exists + self._logger = logger + if full_logs is None: + full_logs = os.environ.get( + "KSQ_FULL_LOG", "").strip().lower() in { + "1", "true", "yes", "on", + } + self.full_logs = bool(full_logs) + self.flash_param_cache = {} + self.flash_full_params_cache = {} + self._camera_names = None + self._sonix_dshow_map = None + self._scan_lock = threading.RLock() + self._reported_rejections = set() + self._reported_touch_sensor_runtime = False + self._old_sensor_template_file = ( + None + if old_sensor_template_file is None + else os.path.abspath(old_sensor_template_file) + ) + self._old_sensor_template = self._load_old_sensor_template( + self._old_sensor_template_file + ) + + @staticmethod + def _validated_template_vector(value, name: str, length: int): + if ( + not isinstance(value, list) + or len(value) != int(length) + ): + raise ValueError( + f"{name} must contain exactly {int(length)} values" + ) + result = [] + for item in value: + if isinstance(item, bool): + raise ValueError(f"{name} must contain finite numbers") + number = float(item) + if not math.isfinite(number): + raise ValueError(f"{name} must contain finite numbers") + result.append(number) + return result + + def _load_old_sensor_template(self, path: Optional[str]): + """加载明确禁用力输出的旧传感器临时模板。""" + if not path: + return None + try: + with open(path, encoding="utf-8") as stream: + encoded = json.load(stream) + if not isinstance(encoded, dict): + raise ValueError("template root must be an object") + if encoded.get("enabled") is not True: + return None + if encoded.get("mode") != "old-sensor-template-no-force": + raise ValueError("unsupported template mode") + if encoded.get("force_output_enabled") is not False: + raise ValueError( + "old-sensor template must keep force output disabled" + ) + usb_identities = encoded.get("usb_identities") + templates = encoded.get("templates") + if ( + not isinstance(usb_identities, dict) + or not isinstance(templates, dict) + ): + raise ValueError( + "usb_identities and templates must be objects" + ) + + validated_identities = {} + validated_templates = {} + for side in ("left", "right"): + identity = usb_identities.get(side) + if not isinstance(identity, dict): + raise ValueError( + f"missing USB identity for {side!r}" + ) + vendor_id = str( + identity.get("vendor_id", "")).strip().lower() + product_id = str( + identity.get("product_id", "")).strip().lower() + serial = str(identity.get("serial", "")).strip() + interface_number = str( + identity.get("interface_number", "")).strip().lower() + stream_index = identity.get("stream_index") + if ( + not re.fullmatch(r"[0-9a-f]{4}", vendor_id) + or not re.fullmatch(r"[0-9a-f]{4}", product_id) + or not serial + or not re.fullmatch(r"[A-Za-z0-9._-]+", serial) + or not re.fullmatch( + r"[0-9a-f]{2}", interface_number) + or isinstance(stream_index, bool) + or not isinstance(stream_index, int) + or stream_index != 0 + ): + raise ValueError( + f"invalid USB identity for {side!r}" + ) + if ( + vendor_id != "0c45" + or product_id != "636f" + or interface_number != "00" + ): + raise ValueError( + f"non-Sightac USB identity for {side!r}" + ) + validated_identities[side] = { + "vendor_id": vendor_id, + "product_id": product_id, + "serial": serial, + "interface_number": interface_number, + "stream_index": stream_index, + } + + source = templates.get(side) + if not isinstance(source, dict): + raise ValueError( + f"missing template for {side!r}" + ) + device_type = str( + source.get("device_type", "")).strip().lower() + if device_type not in {"planar", "curved", "bevel"}: + raise ValueError( + f"invalid device_type for {side!r}" + ) + params = { + "device_type": device_type, + "fx_params": self._validated_template_vector( + source.get("fx_params"), + f"{side}.fx_params", + 5, + ), + "fy_params": self._validated_template_vector( + source.get("fy_params"), + f"{side}.fy_params", + 5, + ), + "fz_params": self._validated_template_vector( + source.get("fz_params"), + f"{side}.fz_params", + 5, + ), + "fw_params": self._validated_template_vector( + source.get("fw_params"), + f"{side}.fw_params", + 9, + ), + "flash_state": "old-sensor-template", + "calibration_source": + "old-sensor-template-unverified", + } + if device_type == "planar": + fw = params["fw_params"] + x1, x2, y1, y2 = ( + int(fw[1]), + int(fw[2]), + int(fw[3]), + int(fw[4]), + ) + if not ( + 0 <= x1 < x2 <= 640 + and 0 <= y1 < y2 <= 480 + ): + raise ValueError( + f"invalid planar ROI for {side!r}" + ) + validated_templates[side] = params + + if ( + validated_identities["left"] + == validated_identities["right"] + or validated_identities["left"]["serial"] + == validated_identities["right"]["serial"] + ): + raise ValueError( + "left and right cannot use the same USB identity" + ) + self._logger( + "[Tactile] old-sensor template armed: " + f"left={validated_identities['left']['serial']} " + f"right={validated_identities['right']['serial']} " + "(force output disabled)" + ) + return { + "usb_identities": validated_identities, + "templates": validated_templates, + } + except ( + OSError, + TypeError, + ValueError, + json.JSONDecodeError, + ) as exc: + self._logger( + f"[Tactile] old-sensor template disabled: {exc}" + ) + return None + + @property + def old_sensor_template_enabled(self) -> bool: + return self._old_sensor_template is not None + + def physical_usb_port(self, video_index: int) -> Optional[str]: + """从 video4linux class symlink 提取仅用于诊断的 USB 端口。""" + if not self.platform.startswith("linux"): + return None + device_path = os.path.realpath(os.path.join( + self._candidate_class_dir(int(video_index)), + "device", + )) + interface_name = os.path.basename(device_path) + port, separator, _interface = interface_name.partition(":") + if not separator or not port: + return None + return port + + def usb_video_identity(self, video_index: int): + """只读返回 Sightac 节点的 VID/PID、serial、interface 和 stream。""" + try: + index = int(video_index) + except (TypeError, ValueError): + return None + if not self.platform.startswith("linux"): + return None + if self.probe_guard_reason(index) is not None: + return None + class_dir = self._candidate_class_dir(index) + try: + with open( + os.path.join(class_dir, "device", "modalias"), + encoding="utf-8", + ) as stream: + modalias = stream.read().strip().lower() + match = re.match( + r"usb:v([0-9a-f]{4})p([0-9a-f]{4})", + modalias, + ) + if match is None: + return None + with open( + os.path.join( + class_dir, "device", "bInterfaceNumber"), + encoding="utf-8", + ) as stream: + interface_number = stream.read().strip().lower() + with open( + os.path.join(class_dir, "index"), + encoding="utf-8", + ) as stream: + stream_index = int(stream.read().strip()) + + interface_path = os.path.realpath( + os.path.join(class_dir, "device")) + physical_path = ( + os.path.dirname(interface_path) + if ":" in os.path.basename(interface_path) + else interface_path + ) + with open( + os.path.join(physical_path, "serial"), + encoding="utf-8", + ) as stream: + serial = stream.read().strip() + except (OSError, ValueError): + return None + if ( + not serial + or not re.fullmatch(r"[A-Za-z0-9._-]+", serial) + or not re.fullmatch( + r"[0-9a-f]{2}", interface_number) + ): + return None + return { + "vendor_id": match.group(1), + "product_id": match.group(2), + "serial": serial, + "interface_number": interface_number, + "stream_index": stream_index, + } + + @staticmethod + def _usb_identity_matches(actual, expected) -> bool: + if not isinstance(actual, dict): + return False + return all( + actual.get(key) == expected.get(key) + for key in ( + "vendor_id", + "product_id", + "serial", + "interface_number", + "stream_index", + ) + ) + + @staticmethod + def _usb_topology_identity_matches(actual, expected) -> bool: + """Match a topology-pinned Sightac without trusting duplicate serials.""" + if not isinstance(actual, dict): + return False + return all( + actual.get(key) == expected.get(key) + for key in ( + "vendor_id", + "product_id", + "interface_number", + "stream_index", + ) + ) + + def resolve_old_sensor_template_camera( + self, side: str, excluded=(), + ) -> Optional[int]: + """按旧相机严格 USB 身份给无 Flash 相机分配 left/right。""" + normalized = str(side).strip().lower() + template = self._old_sensor_template + if template is None or normalized not in {"left", "right"}: + return None + expected = template["usb_identities"][normalized] + excluded_indices = { + int(index) for index in excluded if index is not None + } + matches = [ + index + for index in self.safe_sonix_indices(max_devices=64) + if index not in excluded_indices + and self._usb_identity_matches( + self.usb_video_identity(index), expected) + ] + if len(matches) != 1: + self._logger( + "[Tactile] old-sensor template identity unresolved: " + f"{normalized} expects USB serial " + f"{expected['serial']}, " + f"matches={matches}" + ) + return None + return int(matches[0]) + + def apply_old_sensor_template( + self, + side: str, + video_index: int, + *, + topology_verified: bool = False, + ): + """仅在硬件完整 Flash 缺失时注入旧模板;真实 Flash 永远优先。""" + normalized = str(side).strip().lower() + index = int(video_index) + template = self._old_sensor_template + if template is None or normalized not in {"left", "right"}: + return None + with self._scan_lock: + cached = self.flash_full_params_cache.get(index) + if cached is not None: + return cached + expected = template["usb_identities"][normalized] + actual = self.usb_video_identity(index) + exact_identity = self._usb_identity_matches(actual, expected) + physical_port = self.physical_usb_port(index) + expected_port_suffix = ( + ".2" if normalized == "left" else ".1" + ) + topology_identity = ( + bool(topology_verified) + and isinstance(physical_port, str) + and physical_port.endswith(expected_port_suffix) + and self._usb_topology_identity_matches(actual, expected) + ) + if not exact_identity and not topology_identity: + actual_serial = ( + actual.get("serial") + if isinstance(actual, dict) + else None + ) + self._logger( + "[Tactile] old-sensor template rejected: " + f"{normalized}=video{index} has USB serial " + f"{actual_serial!r}, expected {expected['serial']!r}" + ) + return None + params = { + key: ( + list(value) + if isinstance(value, list) + else value + ) + for key, value in template["templates"][normalized].items() + } + if topology_identity and not exact_identity: + params["flash_state"] = "old-sensor-template-topology" + params["calibration_source"] = ( + "old-sensor-template-topology-unverified" + ) + with self._scan_lock: + existing = self.flash_full_params_cache.get(index) + if existing is not None: + return existing + self.flash_full_params_cache[index] = params + self.flash_param_cache[normalized] = index + fw = params["fw_params"] + actual_serial = ( + actual.get("serial") + if isinstance(actual, dict) + else None + ) + self._logger( + "[Tactile] old-sensor template applied: " + f"{normalized}=video{index} serial={actual_serial} " + f"port={physical_port} " + f"device={params['device_type']} " + f"ROI=({int(fw[1])},{int(fw[3])})" + f"-({int(fw[2])},{int(fw[4])}); " + "Fx/Fy/Fz publication disabled" + ) + return params + + def clear_cache(self) -> None: + with self._scan_lock: + self.flash_param_cache.clear() + self.flash_full_params_cache.clear() + self._camera_names = None + self._sonix_dshow_map = None + self._reported_rejections.clear() + + def cache_external_flash_params(self, video_index: int, params): + """Store one live libusb Flash read for the next sensor instance. + + This is deliberately an in-memory handoff only. The caller must + provide parameters read during the current UVC discovery pass; no + template, persistent cache, or default calibration is accepted here. + """ + index = int(video_index) + if not isinstance(params, dict): + raise ValueError("external Flash parameters must be an object") + device_type = str(params.get("device_type") or "").strip().lower() + if device_type not in {"planar", "curved", "bevel"}: + raise ValueError( + f"external Flash device_type is invalid: {device_type!r}") + expected_lengths = { + "fx_params": 5, + "fy_params": 5, + "fz_params": 21, + "ft_params": 20, + "fw_params": 9, + } + copied = {"device_type": device_type} + for key, length in expected_lengths.items(): + values = params.get(key) + if not isinstance(values, (list, tuple)) or len(values) != length: + raise ValueError( + f"external Flash {key} must contain {length} values") + normalized = [] + for value_index, value in enumerate(values): + if ( + key == "fw_params" + and device_type == "bevel" + and value_index >= 5 + and ( + value is None + or ( + isinstance(value, float) + and math.isnan(value) + ) + ) + ): + # Reserved bevel-table tail; it is not consumed by the + # current ROI/line algorithm. The libuvc JSON path uses + # null, while older in-process handoffs may use NaN. + normalized.append(float("nan")) + continue + try: + number = float(value) + except (TypeError, ValueError) as exc: + raise ValueError( + f"external Flash {key}[{value_index}] is not numeric: " + f"{value!r}" + ) from exc + if not math.isfinite(number): + raise ValueError( + f"external Flash {key}[{value_index}] contains a " + f"non-finite value: {value!r}") + normalized.append(number) + copied[key] = normalized + copied["flash_state"] = str( + params.get("flash_state") or "programmed") + copied["calibration_source"] = "hardware-live-flash" + with self._scan_lock: + self.flash_full_params_cache[index] = copied + self._logger( + f"[FlashCache] live libusb read cached for video{index}: " + f"device={device_type} source=hardware-live-flash") + return copied + + def cache_snapshot(self): + """返回不会暴露内部列表的完整缓存副本。""" + with self._scan_lock: + labels = MappingProxyType(dict(self.flash_param_cache)) + full = {} + for index, params in self.flash_full_params_cache.items(): + full[int(index)] = MappingProxyType({ + "device_type": str(params["device_type"]), + "fx_params": tuple(params["fx_params"]), + "fy_params": tuple(params["fy_params"]), + "fz_params": tuple(params["fz_params"]), + "fw_params": tuple(params["fw_params"]), + "ft_params": tuple(params.get("ft_params", ())), + "flash_state": str( + params.get("flash_state", "unknown")), + "calibration_source": str( + params.get("calibration_source", "hardware")), + }) + return labels, MappingProxyType(full) + + def _candidate_class_dir(self, video_index: int) -> str: + return os.path.join(self.sysfs_root, f"video{int(video_index)}") + + def _candidate_device_path(self, video_index: int) -> str: + return os.path.join(self.dev_root, f"video{int(video_index)}") + + def probe_guard_reason(self, video_index: int): + """返回 ``None`` 表示节点可探测,否则返回 fail-closed 原因。""" + try: + index = int(video_index) + except (TypeError, ValueError): + return "invalid video index" + if index < 0: + return "invalid video index" + if not self.platform.startswith("linux"): + return None + if not self._path_exists(self._candidate_device_path(index)): + return "video node does not exist" + class_dir = self._candidate_class_dir(index) + try: + with open( + os.path.join(class_dir, "index"), + encoding="utf-8", + ) as stream: + capture_index = int(stream.read().strip()) + with open( + os.path.join(class_dir, "name"), + encoding="utf-8", + ) as stream: + device_name = stream.read().strip().lower() + with open( + os.path.join(class_dir, "device", "modalias"), + encoding="utf-8", + ) as stream: + modalias = stream.read().strip().lower() + except (OSError, ValueError): + return "video identity is unreadable" + if capture_index != 0: + return f"non-capture V4L2 index={capture_index}" + if not device_name: + return "empty video node name" + if "ftdi" in device_name or "superspeed video bridge" in device_name: + return "Fays FTDI bridge" + if not modalias.startswith(_SONIX_MODALIAS_PREFIX): + return "non-Sonix VID/PID" + return None + + def is_safe_sonix_probe(self, video_index: int) -> bool: + return self.probe_guard_reason(video_index) is None + + def _linux_video_indices(self): + """按数字顺序返回 sysfs 中实际存在的 ``videoN`` 节点。""" + indices = set() + pattern = os.path.join(self.sysfs_root, "video*") + for class_dir in glob.glob(pattern): + suffix = os.path.basename(class_dir)[5:] + if suffix.isdigit(): + indices.add(int(suffix)) + return tuple(sorted(indices)) + + def _linux_sonix_indices( + self, max_devices: int, *, report_rejections: bool, + ): + """发现实际 Sonix 节点;``max_devices`` 限制候选数而非节点号。""" + limit = max(0, int(max_devices)) + if limit == 0: + return () + candidates = [] + for index in self._linux_video_indices(): + reason = self.probe_guard_reason(index) + if reason is not None: + if report_rejections: + self._log_probe_rejection(index, reason) + continue + candidates.append(index) + if len(candidates) >= limit: + break + return tuple(candidates) + + def safe_sonix_indices(self, max_devices: int = 10): + """返回实际存在且 VID/PID 精确为 ``0c45:636f`` 的采集节点。 + + ``max_devices`` 是最多返回的安全候选数量,不是 ``/dev/videoN`` 的 + N 上限;因此相机号漂移到 video10 以上仍能被发现。 + """ + if not self.platform.startswith("linux"): + return () + return self._linux_sonix_indices( + max_devices, report_rejections=False, + ) + + def _log_probe_rejection(self, video_index: int, reason: str) -> None: + key = (int(video_index), str(reason)) + if key in self._reported_rejections: + return + self._reported_rejections.add(key) + self._logger( + f"[Cameras] Sonix probe skipped: video{video_index} ({reason})") + + def concise_sdk_print(self, *args, **kwargs) -> None: + """第三方 Sightac 日志的唯一父进程过滤器。""" + if self.full_logs: + self._logger(*args, **kwargs) + return + message = " ".join(str(arg) for arg in args).strip() + lowered = message.lower() + if any(marker in lowered for marker in _ERROR_MARKERS): + self._logger(*args, **kwargs) + + def _ensure_sightac_import_path(self) -> None: + candidates = [] + if self.sightac_root: + candidates.append(self.sightac_root) + local = os.path.join(GRIPPER_DIR, "sightac_sdk-main") + candidates.append(str(local)) + explicit = os.environ.get("KSQ_SIGHTAC_ROOT") + if explicit: + candidates.append(explicit) + for candidate in candidates: + normalized = os.path.abspath(os.path.normpath(candidate)) + if os.path.isdir(normalized): + if normalized not in sys.path: + sys.path.insert(0, normalized) + return + raise RuntimeError("local Sightac SDK path is unavailable") + + def install_xu_probe_guard(self, xu_module): + """给 SDK init 入口安装本适配器的 fail-closed guard。""" + xu_module.print = self.concise_sdk_print + original = getattr( + xu_module, "_ksq_original_init_sonix_sdk", None) + if original is None: + original = xu_module.init_sonix_sdk + xu_module._ksq_original_init_sonix_sdk = original + + def guarded_init(*args, **kwargs): + video_index = ( + args[0] if args + else kwargs.get("video_index") + ) + guard = getattr(xu_module, "_ksq_active_probe_guard", None) + if (video_index is not None and callable(guard) + and not guard(int(video_index))): + reporter = getattr( + xu_module, "_ksq_probe_rejection_reporter", None) + reason_getter = getattr( + xu_module, "_ksq_probe_guard_reason", None) + reason = ( + reason_getter(int(video_index)) + if callable(reason_getter) + else "rejected by tactile adapter" + ) + if callable(reporter): + reporter(int(video_index), reason) + return False + return original(*args, **kwargs) + + xu_module.init_sonix_sdk = guarded_init + # wrapper 动态读取当前 adapter,避免重复包裹 SDK 全局函数。 + xu_module._ksq_active_probe_guard = self.is_safe_sonix_probe + xu_module._ksq_probe_guard_reason = self.probe_guard_reason + xu_module._ksq_probe_rejection_reporter = ( + self._log_probe_rejection) + return xu_module + + def _load_xu_module(self): + self._ensure_sightac_import_path() + xu_camera = importlib.import_module( + f"{self.api_package}.xu_camera") + return self.install_xu_probe_guard(xu_camera) + + def _load_touch_sensor_class(self): + self._ensure_sightac_import_path() + api_module = importlib.import_module(self.api_package) + TouchSensor = api_module.TouchSensor + module = sys.modules.get(TouchSensor.__module__) + with self._scan_lock: + if not self._reported_touch_sensor_runtime: + version = str( + getattr(api_module, "VERSION", "unknown") + ).strip() or "unknown" + vendor_base = str( + getattr(api_module, "VENDOR_BASE_VERSION", "unknown") + ).strip() or "unknown" + compatibility_base = str( + getattr( + api_module, + "COMPATIBILITY_BASE_VERSION", + "unknown", + ) + ).strip() or "unknown" + source_file = os.path.abspath( + str(getattr(module, "__file__", "unknown")) + ) if module is not None else "unknown" + self._logger( + "[Tactile] SDK touch_sensor.py " + f"version={version} package={self.api_package} " + f"vendor_base={vendor_base} " + f"compatibility_base={compatibility_base} " + f"file={source_file}" + ) + self._reported_touch_sensor_runtime = True + if module is not None: + module.print = self.concise_sdk_print + # TouchSensor 会间接使用同一个 xu_camera;在构造前确保 guard 已安装。 + self._load_xu_module() + return TouchSensor + + def get_camera_names(self): + """只读枚举名称;Linux 仅访问 video4linux class 目录。""" + with self._scan_lock: + if self._camera_names is not None: + return list(self._camera_names) + if self.platform.startswith("linux"): + names = {} + pattern = os.path.join(self.sysfs_root, "video*") + for class_dir in sorted(glob.glob(pattern)): + suffix = os.path.basename(class_dir)[5:] + if not suffix.isdigit(): + continue + index = int(suffix) + try: + with open( + os.path.join(class_dir, "name"), + encoding="utf-8", + ) as stream: + name = stream.read().strip() + except OSError: + # 名称不可读的节点不能作为名称回退候选。 + name = "?" + names[index] = name + count = max(names) + 1 if names else 0 + self._camera_names = tuple( + names.get(index, "?") for index in range(count)) + return list(self._camera_names) + try: + from pygrabber.dshow_graph import FilterGraph + self._camera_names = tuple( + FilterGraph().get_input_devices()) + except Exception: + self._camera_names = () + return list(self._camera_names) + + def clear_camera_name_cache(self) -> None: + with self._scan_lock: + self._camera_names = None + + def find_camera_by_name( + self, keyword: str, occurrence: int = 0, + ) -> int: + keyword = str(keyword).lower().strip() + found = 0 + for index, name in enumerate(self.get_camera_names()): + if keyword in str(name).lower(): + if found == int(occurrence): + return index + found += 1 + return -1 + + def get_touch_xu_ids( + self, max_devices: int = 5, expected_count: Optional[int] = None, + ): + """调试枚举,只保留 SDK 明确识别出的 Sonix 触觉候选。""" + valid = [] + try: + xu_camera = self._load_xu_module() + except Exception as exc: + self._logger(f"[Heatmap] XU enum unavailable: {exc}") + return valid + if self.platform.startswith("linux"): + indices = self._linux_sonix_indices( + max_devices, report_rejections=True, + ) + else: + indices = range(max(0, int(max_devices))) + for index in indices: + try: + camera = xu_camera.XuCamera(index) + if not camera.is_available(): + continue + info = camera.get_device_info() or {} + serial_number = str( + info.get("serial_number", "")).strip() + vid_pid = str(info.get("vid_pid", "")).strip().lower() + self._logger( + f"[Heatmap] XU candidate {index}: " + f"SN={serial_number or '?'} VIDPID={vid_pid or '?'}" + ) + if serial_number.startswith("SN") or vid_pid == "0c45:636f": + valid.append(index) + if ( + expected_count is not None + and len(valid) >= int(expected_count) + ): + break + except Exception as exc: + self._logger( + f"[Heatmap] XU candidate {index} failed: {exc}") + self._logger(f"[Heatmap] touch XU ids: {valid}") + return valid + + @staticmethod + def _decode_ascii(raw: bytes) -> str: + if all(byte == 0xFF for byte in raw): + return "unknown" + return raw.split(b"\x00", 1)[0].decode( + "ascii", errors="replace") + + def read_flash_side(self, video_index: int) -> Optional[str]: + """Read Flash ``device_params[1]`` (``left``/``right``) for one node. + + The node is opened through the XU control channel only and is + released before returning; no ``VideoCapture`` or image stream is + created here. + """ + try: + index = int(video_index) + except (TypeError, ValueError): + return None + reason = self.probe_guard_reason(index) + if reason is not None: + self._log_probe_rejection(index, reason) + return None + try: + xc = self._load_xu_module() + except Exception as exc: + self._logger(f"[FlashSide] XU unavailable: {exc}") + return None + try: + if getattr(xc, "_sdk_initialized", False): + library = getattr(xc, "_sonix_lib", None) + if library is not None: + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + if not xc.init_sonix_sdk(video_index=index): + return None + library = getattr(xc, "_sonix_lib", None) + if library is None: + return None + buf = (ctypes.c_ubyte * 8)() + if not library.SonixCam_SerialFlashRead( + xc.DEVICE_BASE_ADDR + 1 * 8, buf, 8 + ): + return None + value = self._decode_ascii(bytes(buf)).lower().strip() + return value if value in {"left", "right"} else None + except Exception as exc: + self._logger(f"[FlashSide] video{index} read failed: {exc}") + return None + finally: + library = getattr(xc, "_sonix_lib", None) + if ( + getattr(xc, "_sdk_initialized", False) + and library is not None + ): + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + + def read_sonix_product_serial(self, video_index: int) -> Optional[str]: + """Read the Sonix XU product serial for one fail-closed node.""" + try: + index = int(video_index) + except (TypeError, ValueError): + return None + reason = self.probe_guard_reason(index) + if reason is not None: + self._log_probe_rejection(index, reason) + return None + try: + xc = self._load_xu_module() + if getattr(xc, "_sdk_initialized", False): + library = getattr(xc, "_sonix_lib", None) + if library is not None: + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + if not xc.init_sonix_sdk(video_index=index): + return None + camera = xc.XuCamera(usb_id=index) + info = camera.get_device_info() or {} + serial = str(info.get("serial_number", "")).strip() + return serial or None + except Exception as exc: + self._logger( + f"[SonixSerial] video{index} read failed: {exc}" + ) + return None + finally: + library = getattr(xc, "_sonix_lib", None) + if ( + getattr(xc, "_sdk_initialized", False) + and library is not None + ): + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + + @staticmethod + def _decode_double(raw: bytes) -> float: + if all(byte == 0xFF for byte in raw): + return 0.0 + value = ctypes.c_double() + ctypes.memmove(ctypes.addressof(value), raw, 8) + return float(value.value) + + def _read_full_params(self, xc, read_at): + reads = {"ok": 0, "all_ff": 0, "payload": 0, "failed": 0} + + def read_raw(address, buf): + if not read_at(address, buf): + reads["failed"] += 1 + return False + reads["ok"] += 1 + if all(byte == 0xFF for byte in bytes(buf)): + reads["all_ff"] += 1 + else: + reads["payload"] += 1 + return True + + device_values = [] + for offset in range(5): + buf = (ctypes.c_ubyte * 8)() + if read_raw(xc.DEVICE_BASE_ADDR + offset * 8, buf): + device_values.append(self._decode_ascii(bytes(buf))) + else: + device_values.append("unknown") + + def read_doubles(base_address, count): + values = [] + for offset in range(count): + buf = (ctypes.c_ubyte * 8)() + if read_raw(base_address + offset * 8, buf): + values.append(self._decode_double(bytes(buf))) + else: + values.append(0.0) + return values + + result = { + "device_type": ( + device_values[0] if device_values else "unknown"), + "fx_params": read_doubles(xc.FX_BASE_ADDR, 5), + "fy_params": read_doubles(xc.FY_BASE_ADDR, 5), + # 0902 FZ21 包含模型选择及两种布局;FT20 包含四组区域。 + # 必须完整读取,不可固定把第7/8项当成所有模型的R/B阈值。 + "fz_params": read_doubles(xc.FZ_BASE_ADDR, 21), + "ft_params": read_doubles(0x47000, 20), + "fw_params": read_doubles(xc.FW_BASE_ADDR, 9), + } + if reads["payload"]: + result["flash_state"] = ( + "programmed" if not reads["failed"] else "partial") + else: + result["flash_state"] = "unreadable" + result["calibration_source"] = "hardware" + return result + + def read_and_cache_flash_params(self, xc, video_index: int): + """从已绑定节点读取 device/fx/fy/fz/fw 全量参数。""" + video_index = int(video_index) + with self._scan_lock: + cached = self.flash_full_params_cache.get(video_index) + if cached is not None: + return cached + library = getattr(xc, "_sonix_lib", None) + if library is None: + return None + try: + cached = None + for attempt in range(1, 3): + candidate = self._read_full_params( + xc, + lambda address, buf: library.SonixCam_SerialFlashRead( + address, buf, 8), + ) + if ( + candidate["flash_state"] == "programmed" + and candidate["device_type"] + in {"planar", "curved", "bevel"} + ): + cached = candidate + break + if attempt == 1: + self._logger( + f"[FlashCache] video{video_index}: direct read " + f"returned {candidate['flash_state']} " + f"(device={candidate['device_type']!r}); retrying" + ) + if cached is None: + self._logger( + f"[FlashCache] video{video_index} read failed: " + "no usable hardware parameters after 2 direct reads; " + "not caching or injecting defaults" + ) + return None + with self._scan_lock: + self.flash_full_params_cache[video_index] = cached + self._logger( + f"[FlashCache] video{video_index}: " + f"device={cached['device_type']}, " + f"state={cached['flash_state']}, " + f"source={cached['calibration_source']}, " + f"fx={cached['fx_params'][0]:.4f}, " + f"fy={cached['fy_params'][0]:.4f}, " + f"fz={cached['fz_params'][0]:.4f}" + ) + return cached + except Exception as exc: + self._logger( + f"[FlashCache] video{video_index} read failed: {exc}") + return None + + _read_and_cache_flash_params = read_and_cache_flash_params + + def _cache_windows_flash_params( + self, xc, library, device_pointer, video_index: int, + ): + try: + cached = self._read_full_params( + xc, + lambda address, buf: library.SonixCam_ReadFromSF( + device_pointer, address, buf, 8), + ) + self.flash_full_params_cache[int(video_index)] = cached + return cached + except Exception as exc: + self._logger( + f"[FlashCache] video{video_index} read failed: {exc}") + return None + + def scan_camera_by_flash_param( + self, + target: str, + param_index: int = 1, + max_devices: int = 10, + *, + candidate_indices=None, + ): + """按 Flash ``device_params[param_index]`` 匹配 left/right。""" + normalized = str(target).lower().strip() + with self._scan_lock: + if normalized in self.flash_param_cache: + cached = self.flash_param_cache[normalized] + self._logger( + f"[Cameras] '{normalized}' → idx={cached} (cached)") + return cached + + try: + xc = self._load_xu_module() + except Exception as exc: + self._logger(f"[Cameras] Flash scan unavailable: {exc}") + return None + + result = None + flash_address = ( + xc.DEVICE_BASE_ADDR + int(param_index) * 8) + if self.platform.startswith("win"): + if xc._sonix_lib is None: + xc.init_sonix_sdk() + library = xc._sonix_lib + if library is None: + return None + devices = (xc.ScDevice * int(max_devices))() + count = ctypes.c_uint(0) + if not library.SonixCam_EnumCameras( + ctypes.byref(count), devices, int(max_devices) + ): + return None + for sonix_index in range( + min(count.value, int(max_devices)) + ): + pointer = ctypes.pointer(devices[sonix_index]) + buf = (ctypes.c_ubyte * 8)() + if not library.SonixCam_ReadFromSF( + pointer, flash_address, buf, 8 + ): + continue + self._build_sonix_dshow_map() + video_index = next(( + dshow_index + for dshow_index, mapped in + self._sonix_dshow_map.items() + if mapped == sonix_index + ), sonix_index) + if video_index not in self.flash_full_params_cache: + self._cache_windows_flash_params( + xc, library, pointer, video_index) + value = self._decode_ascii(bytes(buf)).lower().strip() + if value == normalized: + result = video_index + break + else: + try: + if candidate_indices is None: + linux_indices = self._linux_sonix_indices( + max_devices, report_rejections=True, + ) + else: + linux_indices = [] + for value in candidate_indices: + try: + video_index = int(value) + except (TypeError, ValueError): + continue + reason = self.probe_guard_reason(video_index) + if reason is not None: + self._log_probe_rejection( + video_index, reason) + continue + if video_index not in linux_indices: + linux_indices.append(video_index) + linux_indices = tuple( + linux_indices[:max(0, int(max_devices))] + ) + for video_index in linux_indices: + if getattr(xc, "_sdk_initialized", False): + library = getattr(xc, "_sonix_lib", None) + if library is not None: + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + if not xc.init_sonix_sdk( + video_index=video_index + ): + continue + library = getattr(xc, "_sonix_lib", None) + if library is None: + continue + self.read_and_cache_flash_params( + xc, video_index) + buf = (ctypes.c_ubyte * 8)() + if library.SonixCam_SerialFlashRead( + flash_address, buf, 8 + ): + value = self._decode_ascii( + bytes(buf)).lower().strip() + if value == normalized: + result = video_index + break + finally: + library = getattr(xc, "_sonix_lib", None) + if ( + getattr(xc, "_sdk_initialized", False) + and library is not None + ): + try: + library.SonixCam_UnInit() + except Exception: + pass + xc._sdk_initialized = False + + if result is not None: + self.flash_param_cache[normalized] = int(result) + self._logger( + f"[Cameras] Flash scan: '{normalized}' → " + f"video index {result}") + else: + self._logger( + f"[Cameras] Flash scan: '{normalized}' " + "not found in any camera") + return result + + _scan_camera_by_flash_param = scan_camera_by_flash_param + + def prepare_topology_camera( + self, side: str, video_index: int, + ): + """Cache one Hub-pinned camera before any member of its set opens.""" + normalized = str(side).strip().lower() + if normalized not in {"left", "right"}: + raise ValueError(f"unknown tactile side: {side!r}") + index = int(video_index) + with self._scan_lock: + self.flash_param_cache.pop(normalized, None) + self.scan_camera_by_flash_param( + normalized, + max_devices=1, + candidate_indices=(index,), + ) + cached = self.apply_old_sensor_template( + normalized, + index, + topology_verified=True, + ) + if cached is None: + with self._scan_lock: + cached = self.flash_full_params_cache.get(index) + if cached is None: + raise RuntimeError( + "Sightac calibration unavailable for topology-pinned " + f"{normalized}=video{index}" + ) + with self._scan_lock: + self.flash_param_cache[normalized] = index + return cached + + def resolve_camera_id(self, value): + """解析 left/right、数字、名称和 ``名称#N`` 回退格式。""" + text = str(value).strip() + if not text: + return None + lowered = text.lower() + if lowered in {"left", "right"}: + result = self.scan_camera_by_flash_param(lowered) + if result is not None: + self._logger( + f"[Cameras] '{text}' → USB index {result} " + "(matched by Flash param[1])") + return result + self._logger( + f"[Cameras] '{text}' not found via Flash scan") + return None + if text.isdigit(): + index = int(text) + if ( + self.platform.startswith("linux") + and not self.is_safe_sonix_probe(index) + ): + self._log_probe_rejection( + index, self.probe_guard_reason(index)) + return None + return index + occurrence = 0 + keyword = text + if "#" in text: + keyword, suffix = text.rsplit("#", 1) + try: + occurrence = int(suffix) + except ValueError: + occurrence = 0 + index = self.find_camera_by_name(keyword, occurrence) + if index >= 0: + if ( + self.platform.startswith("linux") + and not self.is_safe_sonix_probe(index) + ): + self._log_probe_rejection( + index, self.probe_guard_reason(index)) + return None + return index + try: + index = int(text) + except ValueError: + return None + return ( + index + if not self.platform.startswith("linux") + or self.is_safe_sonix_probe(index) + else None + ) + + _resolve_camera_id = resolve_camera_id + + def _build_sonix_dshow_map(self) -> None: + if self._sonix_dshow_map is not None: + return + self._sonix_dshow_map = {} + if not self.platform.startswith("win"): + return + sonix_paths = {} + try: + xc = self._load_xu_module() + if xc._sonix_lib is None: + xc.init_sonix_sdk() + library = xc._sonix_lib + if library is None: + return + devices = (xc.ScDevice * 10)() + count = ctypes.c_uint(0) + if library.SonixCam_EnumCameras( + ctypes.byref(count), devices, 10 + ): + for index in range(count.value): + sonix_paths[index] = str(devices[index].devPath) + except Exception as exc: + self._logger( + f"[Cameras] Sonix enumeration failed: {exc}") + return + + dshow_paths = {} + try: + from comtypes.client import CreateObject + from comtypes.persist import IPropertyBag + from pygrabber.dshow_core import ICreateDevEnum + from pygrabber.dshow_graph import GUID + from pygrabber.dshow_ids import DeviceCategories, clsids + + enumerator = CreateObject( + clsids.CLSID_SystemDeviceEnum, + interface=ICreateDevEnum, + ) + collection = enumerator.CreateClassEnumerator( + GUID(DeviceCategories.VideoInputDevice), dwFlags=0) + moniker, count = collection.Next(1) + index = 0 + while count > 0: + try: + bag = moniker.BindToStorage( + 0, 0, IPropertyBag._iid_, + ).QueryInterface(IPropertyBag) + dshow_paths[index] = str( + bag.Read("DevicePath", pErrorLog=None) or "") + except Exception: + pass + moniker, count = collection.Next(1) + index += 1 + except Exception as exc: + self._logger( + f"[Cameras] DirectShow enumeration failed: {exc}") + return + for dshow_index, dshow_path in dshow_paths.items(): + for sonix_index, sonix_path in sonix_paths.items(): + if dshow_path == sonix_path: + self._sonix_dshow_map[dshow_index] = sonix_index + break + self._logger( + f"[Cameras] DShow->Sonix map: {self._sonix_dshow_map}") + + @staticmethod + def _decode_fourcc(value) -> str: + try: + encoded = int(value) + except (TypeError, ValueError, OverflowError): + return "" + return "".join( + chr((encoded >> shift) & 0xFF) + for shift in range(0, 32, 8) + ).rstrip("\x00 ") + + def _require_capture_mjpg( + self, cap, video_index: int, + ) -> str: + """Request and independently verify MJPG before the first read.""" + try: + requested = self._cv2.VideoWriter_fourcc(*"MJPG") + cap.set(self._cv2.CAP_PROP_FOURCC, requested) + actual_value = cap.get(self._cv2.CAP_PROP_FOURCC) + actual_code = self._decode_fourcc(actual_value) + except Exception as exc: + try: + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + pass + raise RuntimeError( + f"Sightac video{video_index} requires MJPG before " + f"the first frame read; FOURCC verification failed: {exc}" + ) from exc + if actual_code != "MJPG": + try: + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + pass + raise RuntimeError( + f"Sightac video{video_index} requires MJPG before " + "the first frame read; actual FOURCC is " + f"{actual_code or ''}" + ) + return actual_code + + def _set_sensor_mjpeg(self, sensor, video_index: int) -> str: + return self._require_capture_mjpg( + sensor.cap, video_index) + + @staticmethod + def _release_sensor(sensor) -> None: + if sensor is None: + return + try: + cap = getattr(sensor, "cap", None) + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + pass + + def init_sensor(self, video_index: int, reserved_camera=None): + """构造 TouchSensor;Linux 命中缓存时完全绕过 Sonix SDK。""" + video_index = int(video_index) + reserved_is_ipc = ( + getattr(reserved_camera, "transport", None) == "libuvc-ipc" + ) + if ( + self.platform.startswith("linux") + and not reserved_is_ipc + and not self.is_safe_sonix_probe(video_index) + ): + reason = self.probe_guard_reason(video_index) + self._log_probe_rejection(video_index, reason) + raise RuntimeError( + f"unsafe Sightac video node {video_index}: {reason}") + + with self._scan_lock: + cached = self.flash_full_params_cache.get(video_index) + if reserved_is_ipc and cached is None: + external = getattr(reserved_camera, "flash_params", None) + if external is not None: + cached = self.cache_external_flash_params( + video_index, external) + if self.platform.startswith("linux") and cached is None: + # Linux 上不能在 VideoCapture 已开流后再让 Sonix SDK 绑定同一 + # 节点。扫描阶段已做两次完整 Flash 读取;仍无有效缓存说明设备 + # 类型/标定不可用。此时必须在开流前停止,既不能注入伪造系数, + # 也不能回退到会造成 select timeout 的 SDK + V4L2 双重打开。 + raise RuntimeError( + "Sightac full Flash calibration is unavailable for " + f"video{video_index}; refusing to open an uncalibrated " + "or SDK-conflicting stream" + ) + + BaseTouchSensor = self._load_touch_sensor_class() + if reserved_is_ipc: + xu_index = video_index + else: + self._build_sonix_dshow_map() + xu_index = self._sonix_dshow_map.get( + video_index, video_index) + cv = self._cv2 + platform = self.platform + logger = self._logger + require_mjpg = self._require_capture_mjpg + api_package = self.api_package + + if platform.startswith("linux") and cached is not None: + class CachedTouchSensor(BaseTouchSensor): + """从预读缓存恢复算法参数,不再次调用 XU SDK。""" + + def __init__(self, cached_params, camera_index): + self._cached_params = cached_params + try: + super().__init__( + usb_id=camera_index, + defer_baseline=True, + ) + except Exception: + cap = getattr(self, "cap", None) + if cap is not None: + try: + cap.release() + except Exception: + pass + raise + + def camera_init(self, camera_index, fix_config=False): + self.platform = "linux" + self.xu_camera = None + if reserved_camera is None: + self.cap = cv.VideoCapture( + camera_index, cv.CAP_V4L2) + prefetched_frame = None + actual_format = None + else: + ( + self.cap, + prefetched_frame, + actual_format, + ) = reserved_camera.claim() + if not self.cap or not self.cap.isOpened(): + raise RuntimeError( + "[CachedTouchSensor] cannot open " + f"video_id={camera_index}") + if actual_format is None: + self._ksq_fourcc_actual = require_mjpg( + self.cap, camera_index + ) + else: + width, height, fps, actual_fourcc = actual_format + if ( + int(width) != 640 + or int(height) != 480 + or abs(float(fps) - 30.0) > 0.5 + or actual_fourcc != "MJPG" + ): + self.cap.release() + raise RuntimeError( + "[CachedTouchSensor] reserved format " + f"invalid for video{camera_index}: " + f"{width}x{height} " + f"{actual_fourcc or ''}@{fps:g}" + ) + if ( + prefetched_frame is None + or getattr(prefetched_frame, "size", 0) <= 0 + ): + self.cap.release() + raise RuntimeError( + "[CachedTouchSensor] reserved first frame " + f"is unavailable for video{camera_index}" + ) + self._ksq_fourcc_actual = actual_fourcc + self._ksq_prefetched_frame = prefetched_frame + self._apply_cached_params() + check_config = getattr(self, "check_config", None) + if callable(check_config) and not check_config(): + logger("WARNING:") + logger( + f"[CachedTouchSensor] video={camera_index} " + "init OK (cached, zero SDK calls)") + + def read_flash(self): + return None + + def _apply_cached_params(self): + params = self._cached_params + self.device_type = params["device_type"] + self.apply_flash_params(params) + logger( + f"[CachedTouchSensor] params injected: device={self.device_type} " + f"model={self.bevel_calibrate_model} source={params.get('calibration_source')} " + f"ROI=({self.roi_x1},{self.roi_y1})-({self.roi_x2},{self.roi_y2}) " + f"RB=({self.mask_r_threshold},{self.mask_b_threshold}) " + f"regions={self.rb_filter_regions} hue={self.hue_threshold}" + ) + + sensor = CachedTouchSensor(cached, video_index) + sensor._ksq_api_package = api_package + sensor._ksq_deferred_baseline = True + sensor._ksq_calibration_source = cached.get( + "calibration_source", "hardware") + self._logger( + f"[Heatmap] CachedTouchSensor video={video_index} " + f"FOURCC: {sensor._ksq_fourcc_actual} OK " + "(cached, zero SDK calls, source=" + f"{sensor._ksq_calibration_source})") + return sensor + + if xu_index == video_index: + sensor = BaseTouchSensor( + usb_id=video_index, defer_baseline=True) + sensor._ksq_api_package = api_package + sensor._ksq_deferred_baseline = True + sensor._ksq_fourcc_actual = self._set_sensor_mjpeg( + sensor, video_index) + self._logger( + f"[Heatmap] TouchSensor usb_id={video_index} " + f"FOURCC: {sensor._ksq_fourcc_actual} OK") + return sensor + + class RoutedTouchSensor(BaseTouchSensor): + def __init__(self, routed_xu_index, routed_video_index): + self._routed_video_index = routed_video_index + super().__init__( + usb_id=routed_xu_index, defer_baseline=True) + + def camera_init(self, camera_index, fix_config=False): + touch_sensor_module = importlib.import_module( + f"{api_package}.touch_sensor") + if platform.startswith("win"): + self.platform = "win" + camera = touch_sensor_module.xu_camera.XuCamera( + camera_index) + if camera.is_available(): + self.xu_camera = camera + self.cap = cv.VideoCapture( + self._routed_video_index, cv.CAP_DSHOW) + elif platform.startswith("darwin"): + self.platform = "apple" + self.cap = cv.VideoCapture( + self._routed_video_index, + cv.CAP_AVFOUNDATION, + ) + else: + self.platform = "unknown" + self.cap = cv.VideoCapture( + self._routed_video_index) + if not self.cap or not self.cap.isOpened(): + raise RuntimeError( + "cannot open video_id=" + f"{self._routed_video_index}") + self._ksq_fourcc_actual = require_mjpg( + self.cap, self._routed_video_index + ) + if getattr(self, "xu_camera", None): + self.device_type = ( + self.xu_camera.read_device_params()[0]) + self.read_flash() + check_config = getattr(self, "check_config", None) + if callable(check_config) and not check_config(): + logger("WARNING:") + logger( + f"[Heatmap] routed: " + f"video={self._routed_video_index} " + f"xu={camera_index}") + + sensor = RoutedTouchSensor(xu_index, video_index) + sensor._ksq_api_package = api_package + sensor._ksq_deferred_baseline = True + self._logger( + f"[Heatmap] TouchSensor video={video_index} " + f"xu={xu_index} FOURCC: " + f"{sensor._ksq_fourcc_actual} OK") + return sensor + + _init_tactile_sensor = init_sensor diff --git a/collector/core/gripper/devices/tactile_process_manager.py b/collector/core/gripper/devices/tactile_process_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..ce079b3e87f2029a1dad50cfb717fc40dbde9f61 --- /dev/null +++ b/collector/core/gripper/devices/tactile_process_manager.py @@ -0,0 +1,2631 @@ +"""Sightac 句柄、输入线程和独立计算子进程的唯一生命周期所有者。 + +锁顺序固定为 ``TactileState.lock`` → 单路 ``TactileProcessBridge.condition``; +输入线程只在 ``capture_lock`` 内调用 ``read_raw_frame``,不会持有 state lock。 +停止时先使 generation 失效并唤醒 IPC,再等待输入/协调/初始化线程,最后释放 +VideoCapture,避免 release 与正常 read 并发。 +""" + +from __future__ import annotations + +from dataclasses import dataclass +import multiprocessing +import os +import queue +import sys +import threading +import tempfile +import time +import traceback +from types import MappingProxyType +from typing import Callable, Mapping, Optional + +import numpy as np + +from core.gripper.runtime.interruptible_queue import InterruptibleQueueReader + +from core.gripper.tactile_process_worker import ( + clear_frame_queue, + create_frame_queue, + create_shared_frame_pool, + create_shared_result_pool, + run_tactile_input_process, + run_tactile_process, + shared_frame_view, + shared_result_view, + snapshot_sensor_state, + TACTILE_FORCE_MATRIX_SHAPE, + TACTILE_HEATMAP_SHAPE, + TACTILE_INITIAL_BASELINE_FRAMES, + TACTILE_RESULT_FLAG_OFFSET, + TACTILE_RESULT_FORCE_BYTES, + TACTILE_RESULT_HEATMAP_BYTES, + TACTILE_RESULT_SLOT_BYTES, +) + + +def _env_flag_default_on(key: str) -> bool: + """读取“默认开启”的环境开关:未设置或非 0/false/no/off 视为开启。""" + value = os.environ.get(key, "").strip().lower() + return value not in {"0", "false", "no", "off"} + + +def _env_flag_default_off(key: str) -> bool: + """读取“默认关闭”的环境开关:仅 1/true/yes/on 视为开启。""" + return os.environ.get(key, "").strip().lower() in { + "1", "true", "yes", "on", + } + + +# 输入进程化开关:默认 1(input 采帧线程迁入独立 spawn 子进程, +# run_tactile_input_process),主进程不再持有 VideoCapture/TouchSensor。 +# 需要旧父进程 input 线程路径时显式置 0。 +KSQ_TACTILE_INPUT_PROCESS = _env_flag_default_on( + "KSQ_TACTILE_INPUT_PROCESS") + +# force_matrix 主进程回传开关:默认 0(主进程不再逐帧把完整矩阵从共享 +# 内存拷回,只回 heatmap+fx/fy/fz 标量,减 ~90MB/s 拷贝; +# force_matrix parquet 仍由计算子进程直写 writer)。需要旧行为时显式置 1。 +KSQ_TACTILE_FORCE_MATRIX_MATERIALIZE = _env_flag_default_off( + "KSQ_TACTILE_FORCE_MATRIX_MATERIALIZE") + + +TACTILE_INIT_TIMEOUT = 10.0 +TACTILE_PROCESS_READY_TIMEOUT = 10.0 +TACTILE_CALIBRATION_TIMEOUT = 10.0 +TACTILE_STOP_DEADLINE = 3.0 +TACTILE_INPUT_UNBLOCK_TIMEOUT = 1.0 +TACTILE_PROCESS_JOIN_TIMEOUT = 1.5 +TACTILE_PROCESS_TERMINATE_TIMEOUT = 1.0 +TACTILE_RESULT_QUEUE_SIZE = 4 +INITIAL_BASELINE_FRAMES = TACTILE_INITIAL_BASELINE_FRAMES +OPEN_WARMUP_FRAMES = 5 +CONNECTED_WARMUP_FRAMES = 30 +HARDWARE_CALIBRATION_SOURCES = frozenset({ + "hardware", "hardware-live-flash" +}) + + +class TactileCalibrationJob: + """由 CPU4 输入线程采帧、独立子进程计算的一次标定任务。""" + + def __init__( + self, job_id: int, reason: str, + warmup_frames: int, frame_count: int, + ): + self.job_id = int(job_id) + self.reason = str(reason) + self.warmup_remaining = max(0, int(warmup_frames)) + self.frame_count = max(1, int(frame_count)) + self.frames = [] + self.ready = False + self.taken = False + self.done = threading.Event() + self.success = False + self.error = None + + +class _InputCalibrationWaiter: + """输入进程化模式下一次手动标定的父进程完成记录。 + + 计算子进程上报 calibration_result 后由 coordinator 解析并 set。 + """ + + def __init__(self, reason: str): + self.reason = str(reason) + self.done = threading.Event() + self.success = False + self.error = None + + +class TactileProcessBridge: + """父进程与单路计算子进程之间的有界共享帧 FIFO。 + + 队列满时不让相机读取线程等待;当前正在处理的帧继续完成,新到的帧 + 直接丢弃。图像本体位于共享槽位,FIFO 只传递描述符;这样处理速度 + 低于采集速度时不会把实时预览拖成越来越旧,也不会反复序列化图像。 + """ + + RESULT_QUEUE_SIZE = TACTILE_RESULT_QUEUE_SIZE + + def __init__( + self, + context, + *, + materialize_force_matrix: Optional[bool] = None, + ): + self.materialize_force_matrix = ( + KSQ_TACTILE_FORCE_MATRIX_MATERIALIZE + if materialize_force_matrix is None + else bool(materialize_force_matrix) + ) + self.condition = threading.Condition() + self.capture_lock = threading.Lock() + self.frame_queue = create_frame_queue(context) + ( + self.shared_frame_storage, + self.free_frame_slots, + self.frame_slot_bytes, + ) = create_shared_frame_pool(context) + ( + self.result_shared_storage, + self.free_result_slots, + self.result_slot_bytes, + ) = create_shared_result_pool(context) + self.command_queue = context.Queue() + self.result_queue = context.Queue( + maxsize=self.RESULT_QUEUE_SIZE) + self._result_reader = None + self.status_queue = context.Queue() + # 输入进程化:input 子进程专用命令/状态通道与开始采集门。 + self.input_command_queue = context.Queue() + self.input_status_queue = context.Queue() + self.begin_event = context.Event() + self.stop_event = context.Event() + self.stopping = False + self._next_calibration_id = 0 + self.calibration_job = None + # 输入进程化:手动标定 waiter(未绑定 job 与已绑定 job_id)。 + self._input_waiters = [] + self._input_bound = {} + self.input_calibrating = False + self.next_sequence = 0 + self.published_count = 0 + self.dropped_new_frames = 0 + self.dropped_result_count = 0 + self.taken_count = 0 + self.last_processed_age_ms = None + self._closed = False + + def get_result(self, timeout=0.05): + # Created in the consuming parent thread, never passed to spawn children. + if self._result_reader is None: + self._result_reader = InterruptibleQueueReader(self.result_queue) + return self._result_reader.get( + timeout, cancelled=lambda: self.stopping) + + def submit_capture(self, frame, captured_at=None): + captured_at = ( + time.monotonic() + if captured_at is None + else float(captured_at) + ) + calibration_payload = None + calibration_capture = False + with self.condition: + if self.stopping: + return "stopped" + job = self.calibration_job + if job is not None: + calibration_capture = True + if job.ready or job.taken: + return "calibration-wait" + if job.warmup_remaining > 0: + job.warmup_remaining -= 1 + return "calibration-warmup" + job.frames.append((frame, captured_at)) + if len(job.frames) >= job.frame_count: + job.ready = True + job.taken = True + frames = job.frames + job.frames = [] + calibration_payload = ( + "calibrate", + job.job_id, + job.reason, + frames, + ) + outcome = "calibration-frame" + else: + outcome = "frame" + + if calibration_payload is not None: + try: + self.command_queue.put(calibration_payload) + except (BrokenPipeError, EOFError, OSError) as exc: + self.finish_calibration( + calibration_payload[1], + False, + f"calibration IPC failed: {exc}", + ) + return outcome + if calibration_capture: + return outcome + + with self.condition: + if self.stopping: + return "stopped" + self.next_sequence += 1 + sequence = self.next_sequence + # 不等待、不覆盖旧帧:FIFO 满时丢弃刚到的新帧,避免采集线程被 + # 处理端反压,进而让预览和后续数据越来越滞后。 + slot = None + try: + slot = self.free_frame_slots.get_nowait() + except queue.Empty: + with self.condition: + self.dropped_new_frames += 1 + return "dropped-new" + + try: + array = np.asarray(frame) + if array.dtype != np.uint8 or array.nbytes > self.frame_slot_bytes: + raise ValueError( + "unsupported Sightac frame for shared transport: " + f"dtype={array.dtype} shape={array.shape} " + f"nbytes={array.nbytes} max={self.frame_slot_bytes}" + ) + destination = shared_frame_view( + self.shared_frame_storage, + slot, + (array.nbytes,), + array.nbytes, + self.frame_slot_bytes, + ) + destination[:] = np.ascontiguousarray(array).reshape(-1) + self.frame_queue.put_nowait( + ( + sequence, + int(slot), + tuple(int(value) for value in array.shape), + int(array.nbytes), + captured_at, + ) + ) + except queue.Full: + try: + self.free_frame_slots.put_nowait(slot) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + with self.condition: + self.dropped_new_frames += 1 + return "dropped-new" + except Exception: + try: + self.free_frame_slots.put_nowait(slot) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + raise + with self.condition: + self.published_count += 1 + return outcome + + def request_calibration( + self, + reason: str, + warmup_frames: int = 0, + frame_count: int = INITIAL_BASELINE_FRAMES, + ): + with self.condition: + if self.stopping: + return None + current = self.calibration_job + if current is not None and not current.done.is_set(): + return current + self._next_calibration_id += 1 + job = TactileCalibrationJob( + self._next_calibration_id, + reason, + warmup_frames, + frame_count, + ) + self.calibration_job = job + clear_frame_queue(self.frame_queue, self.free_frame_slots) + return job + + def finish_calibration( + self, job_id: int, success: bool, error=None, + ) -> bool: + with self.condition: + job = self.calibration_job + if job is None or job.job_id != int(job_id): + return False + self.calibration_job = None + job.success = bool(success) + job.error = None if error is None else str(error) + job.done.set() + self.condition.notify_all() + clear_frame_queue(self.frame_queue, self.free_frame_slots) + return True + + def _send_input_command(self, command) -> None: + try: + self.input_command_queue.put(command) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + + def next_job_id(self) -> int: + """分配一个跨父进程/input 子进程一致的标定 job id。""" + with self.condition: + self._next_calibration_id += 1 + return self._next_calibration_id + + def request_input_calibration( + self, + reason: str, + warmup_frames: int = 0, + frame_count: int = INITIAL_BASELINE_FRAMES, + *, + wait: bool = True, + ): + """输入进程化模式:请 input 子进程开始一次标定采集。 + + wait=True 时返回父进程侧 waiter(由 coordinator 在计算子进程 + 上报 calibration_result 后 set);wait=False 用于自动重标定。 + """ + with self.condition: + if self.stopping: + return None + self._next_calibration_id += 1 + job_id = self._next_calibration_id + waiter = None + if wait: + waiter = _InputCalibrationWaiter(str(reason)) + self._input_waiters.append(waiter) + self.input_calibrating = True + self._send_input_command(( + "request_calibration", + int(job_id), + str(reason), + int(warmup_frames), + int(frame_count), + )) + return waiter + + def bind_input_waiter(self, job_id: int, reason: str): + """input 子进程开始某 job 后,把最早的 waiter 绑定到该 job。""" + with self.condition: + if not self._input_waiters: + return None + waiter = self._input_waiters.pop(0) + self._input_bound[int(job_id)] = waiter + return waiter + + def fail_first_input_waiter(self, message) -> bool: + """input 子进程报告已有标定在进行时快速失败首个 waiter。""" + with self.condition: + if not self._input_waiters: + return False + waiter = self._input_waiters.pop(0) + waiter.success = False + waiter.error = str(message) + waiter.done.set() + return True + + def mark_input_calibrating(self) -> None: + with self.condition: + self.input_calibrating = True + + def clear_input_calibrating(self) -> None: + with self.condition: + self.input_calibrating = False + + def resolve_input_calibration( + self, job_id: int, success: bool, error=None, + ) -> None: + """计算子进程完成 job_id 标定:解析 waiter 并通知 input 子进程。""" + with self.condition: + self.input_calibrating = False + waiter = self._input_bound.pop(int(job_id), None) + if waiter is not None: + waiter.success = bool(success) + waiter.error = ( + None if error is None else str(error)) + waiter.done.set() + self._send_input_command(( + "calibration_done", + int(job_id), + bool(success), + None if error is None else str(error), + )) + + def record_input_stats( + self, published: int, dropped_new: int, + ) -> None: + with self.condition: + self.published_count = max( + self.published_count, int(published)) + self.dropped_new_frames = max( + self.dropped_new_frames, int(dropped_new)) + + def request_stop(self) -> None: + with self.condition: + if self.stopping: + return + self.stopping = True + job = self.calibration_job + self.calibration_job = None + if job is not None and not job.done.is_set(): + job.success = False + job.error = "sensor pipeline stopped" + job.done.set() + for waiter in self._input_waiters: + waiter.success = False + waiter.error = "sensor pipeline stopped" + waiter.done.set() + self._input_waiters = [] + for waiter in self._input_bound.values(): + waiter.success = False + waiter.error = "sensor pipeline stopped" + waiter.done.set() + self._input_bound = {} + self.condition.notify_all() + self.stop_event.set() + try: + self.command_queue.put_nowait(("stop",)) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + try: + self.input_command_queue.put_nowait(("stop",)) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + + def record_processed(self, captured_at) -> None: + if captured_at is None: + return + age_ms = max( + 0.0, + (time.monotonic() - float(captured_at)) * 1000.0, + ) + with self.condition: + self.taken_count += 1 + self.last_processed_age_ms = age_ms + + def materialize_result(self, result): + """Copy large result arrays out of shared memory and free the slot.""" + slot = result.pop("result_slot", None) + if slot is None: + return + heat_view = shared_result_view( + self.result_shared_storage, + slot, + 0, + TACTILE_RESULT_HEATMAP_BYTES, + ).reshape(TACTILE_HEATMAP_SHAPE) + result["heatmap"] = np.array(heat_view, dtype=np.uint8, copy=True) + force_view = shared_result_view( + self.result_shared_storage, + slot, + TACTILE_RESULT_HEATMAP_BYTES, + TACTILE_RESULT_FORCE_BYTES, + ).view(np.float32).reshape(TACTILE_FORCE_MATRIX_SHAPE) + flags = shared_result_view( + self.result_shared_storage, + slot, + TACTILE_RESULT_FLAG_OFFSET, + 8, + ) + if flags[0]: + pass + else: + result["heatmap"] = None + if self.materialize_force_matrix and flags[1]: + result["force_matrix"] = np.array( + force_view, dtype=np.float32, copy=True) + else: + # 只回 heatmap+标量:完整矩阵由计算子进程直写 writer parquet, + # 主进程不再保留(省 ~750KB/侧/帧 拷贝)。 + result["force_matrix"] = None + try: + self.free_result_slots.put_nowait(int(slot)) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + + def record_result_drops(self, count: int) -> None: + with self.condition: + self.dropped_result_count = max( + self.dropped_result_count, int(count)) + + def snapshot(self): + with self.condition: + return MappingProxyType({ + "published": self.published_count, + "dropped_new_frames": self.dropped_new_frames, + "dropped_results": self.dropped_result_count, + "taken": self.taken_count, + "age_ms": self.last_processed_age_ms, + "calibrating": ( + self.calibration_job is not None + or self.input_calibrating + ), + "stopping": self.stopping, + }) + + def close(self) -> None: + """只允许在输入线程和计算子进程退出后关闭 IPC 管道。""" + if self._closed: + return + self._closed = True + for channel in ( + self.frame_queue, + self.command_queue, + self.result_queue, + self.status_queue, + self.input_command_queue, + self.input_status_queue, + self.free_frame_slots, + self.free_result_slots, + ): + try: + channel.close() + channel.cancel_join_thread() + except (AttributeError, OSError, ValueError): + pass + + +@dataclass(frozen=True) +class TactileSideSnapshot: + side: str + video_index: Optional[int] + sensor_present: bool + initializing: bool + input_alive: bool + process_alive: bool + process_pid: Optional[int] + calibrating: bool + force: Optional[tuple] + heatmap: Optional[np.ndarray] + error: Optional[str] + + +@dataclass(frozen=True) +class TactileSnapshot: + generation: int + running: bool + mode: Optional[str] + calibrating: bool + left: TactileSideSnapshot + right: TactileSideSnapshot + flash_labels: Mapping[str, int] + flash_full_params: Mapping[int, Mapping[str, object]] + + +class _SideState: + def __init__(self, side: str): + self.side = side + self.video_index = None + self.sensor = None + self.initializing = False + self.init_thread = None + self.coordinator_thread = None + self.input_thread = None + self.input_process = None + self.sensor_state = None + self.process = None + self.pipeline = None + self.force = None + self.heatmap = None + self.error = None + self.ready_event = threading.Event() + + def reset_for_start(self): + self.video_index = None + self.sensor = None + self.initializing = False + self.init_thread = None + self.coordinator_thread = None + self.input_thread = None + self.input_process = None + self.sensor_state = None + self.process = None + self.pipeline = None + self.force = None + self.heatmap = None + self.error = None + self.ready_event = threading.Event() + + +class TactileState: + """Sightac 的唯一可变状态;外部只能读取不可变 snapshot。""" + + def __init__(self): + self.lock = threading.RLock() + self.generation = 0 + self.running = False + self.mode = None + self.calibrating = False + self.initializer_thread = None + self.sides = { + "left": _SideState("left"), + "right": _SideState("right"), + } + self.flash_labels = {} + self.flash_full_params = {} + # 输入进程化标记:由 TactileProcessManager 构造时按开关写入。 + self.input_process_mode = False + + @staticmethod + def _frozen_image(image): + if image is None: + return None + copied = np.array(image, copy=True) + copied.setflags(write=False) + return copied + + @staticmethod + def _process_alive(process) -> bool: + if process is None: + return False + try: + return bool(process.is_alive()) + except (AssertionError, ValueError): + return False + + def _side_snapshot(self, side_state: _SideState): + process = side_state.process + pipeline = side_state.pipeline + calibration = ( + pipeline is not None + and bool(pipeline.snapshot()["calibrating"]) + ) + return TactileSideSnapshot( + side=side_state.side, + video_index=side_state.video_index, + sensor_present=bool( + side_state.sensor is not None + or ( + self.input_process_mode + and side_state.input_process is not None + and self._process_alive(side_state.input_process) + ) + ), + initializing=bool(side_state.initializing), + input_alive=bool( + ( + side_state.input_thread is not None + and side_state.input_thread.is_alive() + ) + or ( + side_state.input_process is not None + and self._process_alive(side_state.input_process) + ) + ), + process_alive=self._process_alive(process), + process_pid=( + getattr(process, "pid", None) + if process is not None + else None + ), + calibrating=calibration, + force=( + None + if side_state.force is None + else tuple(side_state.force) + ), + heatmap=self._frozen_image(side_state.heatmap), + error=( + None + if side_state.error is None + else str(side_state.error) + ), + ) + + def snapshot(self): + with self.lock: + flash_full = {} + for index, params in self.flash_full_params.items(): + flash_full[int(index)] = MappingProxyType({ + key: ( + tuple(value) + if isinstance(value, (list, tuple)) + else value + ) + for key, value in params.items() + }) + return TactileSnapshot( + generation=int(self.generation), + running=bool(self.running), + mode=self.mode, + calibrating=bool(self.calibrating), + left=self._side_snapshot(self.sides["left"]), + right=self._side_snapshot(self.sides["right"]), + flash_labels=MappingProxyType( + dict(self.flash_labels)), + flash_full_params=MappingProxyType(flash_full), + ) + + +class TactileProcessManager: + """唯一创建/关闭 TouchSensor、cap、输入线程及 spawn 子进程。""" + + INIT_TIMEOUT = TACTILE_INIT_TIMEOUT + PROCESS_READY_TIMEOUT = TACTILE_PROCESS_READY_TIMEOUT + CALIBRATION_TIMEOUT = TACTILE_CALIBRATION_TIMEOUT + STOP_DEADLINE = TACTILE_STOP_DEADLINE + INPUT_UNBLOCK_TIMEOUT = TACTILE_INPUT_UNBLOCK_TIMEOUT + PROCESS_JOIN_TIMEOUT = TACTILE_PROCESS_JOIN_TIMEOUT + PROCESS_TERMINATE_TIMEOUT = TACTILE_PROCESS_TERMINATE_TIMEOUT + OPEN_WARMUP_FRAMES = OPEN_WARMUP_FRAMES + CONNECTED_WARMUP_FRAMES = CONNECTED_WARMUP_FRAMES + + def __init__( + self, + state: TactileState, + discovery, + *, + cpu_map: Optional[Mapping[str, int]] = None, + bind_thread: Optional[Callable[[str], object]] = None, + bind_general_thread: Optional[Callable[[str], object]] = None, + bind_coordinator: Optional[Callable[[str], object]] = None, + unbind_thread: Optional[Callable[[str], object]] = None, + publish_result: Optional[ + Callable[[str, object, Optional[tuple], object], None] + ] = None, + record_event: Optional[Callable[[str], None]] = None, + record_stage: Optional[ + Callable[[str, Mapping[str, float]], None] + ] = None, + on_state: Optional[Callable[[TactileSnapshot], None]] = None, + context=None, + process_target=run_tactile_process, + set_process_affinity: Optional[ + Callable[[int, set], None] + ] = None, + get_process_affinity: Optional[ + Callable[[int], set] + ] = None, + on_process_stop: Optional[Callable[[str, int], None]] = None, + thread_factory: Callable[..., threading.Thread] = threading.Thread, + clock: Callable[[], float] = time.monotonic, + sleep: Callable[[float], None] = time.sleep, + logger: Callable[..., None] = print, + record_queue=None, + record_gate=None, + input_process_mode: Optional[bool] = None, + materialize_force_matrix: Optional[bool] = None, + ): + self.state = state + self.discovery = discovery + requested_cpu_map = dict(cpu_map or {"left": 0, "right": 2}) + self.cpu_map = { + "left": int(requested_cpu_map.get("left", -1)), + "right": int(requested_cpu_map.get("right", -1)), + } + if min(self.cpu_map.values()) < 0: + raise ValueError(f"invalid Sightac cpu_map: {self.cpu_map!r}") + self.bind_thread = bind_thread + self.bind_general_thread = bind_general_thread + self.bind_coordinator = bind_coordinator + self.unbind_thread = unbind_thread + self.publish_result = publish_result + self.record_event = record_event + self.record_stage = record_stage + self.on_state = on_state + # 自诊断:按侧统计「力标量有效但力矩阵为空」的连续帧数。 + # GUI 热力图只依赖 fz 矩阵、力曲线只依赖三轴总力标量,都 + # 证明不了 250×250×3 完整矩阵是否产出。 + self._matrix_diag = {} + # 显式使用 spawn,禁止 fork 继承 SDK/VideoCapture 句柄。 + self.context = ( + context + if context is not None + else multiprocessing.get_context("spawn") + ) + self.process_target = process_target + self.set_process_affinity = ( + set_process_affinity + if set_process_affinity is not None + else getattr(os, "sched_setaffinity", None) + ) + self.get_process_affinity = ( + get_process_affinity + if get_process_affinity is not None + else getattr(os, "sched_getaffinity", None) + ) + self.on_process_stop = on_process_stop + self.thread_factory = thread_factory + self.clock = clock + self.sleep = sleep + # 采集进程化(B):tactile 计算子进程在录制期间直接把量化后的力 + # 矩阵写进该队列,主进程不再量化/put,避免 writer 反压拖 GUI。 + self._record_queue = record_queue + self._record_gate = record_gate + self.logger = logger + self._spawn_lock = threading.Lock() + # 输入进程化开关:KSQ_TACTILE_INPUT_PROCESS 默认开启(置 0 关闭)。 + # TouchSensor/claim/读帧/标定采集迁入独立 spawn 输入子进程, + # 父进程不再创建 input 线程。 + self.input_process_mode = ( + KSQ_TACTILE_INPUT_PROCESS + if input_process_mode is None + else bool(input_process_mode) + ) + self.state.input_process_mode = self.input_process_mode + self.materialize_force_matrix = ( + KSQ_TACTILE_FORCE_MATRIX_MATERIALIZE + if materialize_force_matrix is None + else bool(materialize_force_matrix) + ) + # 输入子进程自绑核:默认与对应计算子进程共用同一逻辑核(旧 + # 方案中 Sightac 输入线程也与计算进程同域,输入主要阻塞在 UVC + # 读取上)。可用 KSQ_TACTILE_INPUT_CPUS_LEFT/RIGHT 覆盖。 + def _input_cpus(env_key: str, fallback: int): + value = os.environ.get(env_key, "").strip() + if not value: + return (int(fallback),) + return tuple( + int(cpu) for cpu in value.split(",") if cpu.strip()) + self._input_cpus_explicit = { + "left": bool( + os.environ.get("KSQ_TACTILE_INPUT_CPUS_LEFT", "") + .strip()), + "right": bool( + os.environ.get("KSQ_TACTILE_INPUT_CPUS_RIGHT", "") + .strip()), + } + self.input_process_cpus = { + "left": _input_cpus( + "KSQ_TACTILE_INPUT_CPUS_LEFT", self.cpu_map["left"]), + "right": _input_cpus( + "KSQ_TACTILE_INPUT_CPUS_RIGHT", self.cpu_map["right"]), + } + if self.input_process_mode: + self.logger( + "[Tactile] KSQ_TACTILE_INPUT_PROCESS=1: " + "input capture runs in spawn child processes " + f"(cpus={self.input_process_cpus})" + ) + + def snapshot(self) -> TactileSnapshot: + return self.state.snapshot() + + def set_performance_cpu_map( + self, + *, + left: int, + right: int, + ) -> None: + """Apply the current runtime CPU mapping for both Sightac workers. + + The lifecycle handoff stops the Open-generation workers before the + next Open/Connect generation snapshots this mapping and creates its + child processes. + """ + requested = {"left": int(left), "right": int(right)} + if min(requested.values()) < 0: + raise ValueError(f"invalid Sightac cpu_map: {requested!r}") + with self.state.lock: + self.cpu_map = requested + # 输入进程默认跟随计算子进程绑核;显式 KSQ_TACTILE_INPUT_CPUS_* + # 覆盖时保持不变。 + if not self._input_cpus_explicit["left"]: + self.input_process_cpus["left"] = (int(left),) + if not self._input_cpus_explicit["right"]: + self.input_process_cpus["right"] = (int(right),) + + def set_input_process_cpus( + self, + *, + left: Optional[tuple] = None, + right: Optional[tuple] = None, + ) -> None: + """输入子进程化时按当前 slot policy 覆盖 input 绑核。""" + if left is not None: + normalized = tuple(int(cpu) for cpu in left) + if not normalized or min(normalized) < 0: + raise ValueError( + f"invalid Sightac input cpus: {normalized!r}") + self.input_process_cpus["left"] = normalized + if right is not None: + normalized = tuple(int(cpu) for cpu in right) + if not normalized or min(normalized) < 0: + raise ValueError( + f"invalid Sightac input cpus: {normalized!r}") + self.input_process_cpus["right"] = normalized + + def _notify(self) -> None: + if self.on_state is not None: + try: + self.on_state(self.snapshot()) + except Exception: + pass + + def _active(self, generation: int) -> bool: + with self.state.lock: + return ( + self.state.running + and self.state.generation == int(generation) + ) + + @staticmethod + def _release_sensor(sensor) -> None: + if sensor is None: + return + try: + cap = getattr(sensor, "cap", None) + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + traceback.print_exc() + + def _set_error(self, side: str, message) -> None: + with self.state.lock: + self.state.sides[side].error = str(message) + self.logger(f"[Tactile:{side}] ERROR: {message}") + self._notify() + + def start_open( + self, + left="left", + right="right", + *, + asynchronous: bool = True, + ) -> int: + return self.start( + {"left": left, "right": right}, + mode="open", + warmup_frames=self.OPEN_WARMUP_FRAMES, + asynchronous=asynchronous, + ) + + def start_connected( + self, + left="left", + right="right", + *, + asynchronous: bool = True, + ) -> int: + return self.start( + {"left": left, "right": right}, + mode="connected", + warmup_frames=self.CONNECTED_WARMUP_FRAMES, + asynchronous=asynchronous, + ) + + def start( + self, + inputs: Mapping[str, object], + *, + mode: str, + warmup_frames: int, + asynchronous: bool = True, + on_initialized: Optional[Callable[[int], None]] = None, + ) -> int: + """启动两路独立初始化;构造完成后可通知 Fays 再开流。""" + if mode not in {"open", "connected"}: + raise ValueError(f"unsupported tactile start mode: {mode}") + self.stop() + with self.state.lock: + self.state.generation += 1 + generation = self.state.generation + self.state.running = True + self.state.mode = mode + self.state.calibrating = False + for side_state in self.state.sides.values(): + side_state.reset_for_start() + initializer = self.thread_factory( + target=self._initialize_all, + args=( + generation, + { + "left": inputs.get("left", "left"), + "right": inputs.get("right", "right"), + }, + int(warmup_frames), + on_initialized, + ), + daemon=True, + name=f"tactile-init-{generation}", + ) + self.state.initializer_thread = initializer + initializer.start() + if not asynchronous: + initializer.join() + self.wait_ready(timeout=self.PROCESS_READY_TIMEOUT) + self._notify() + return generation + + def _resolve_inputs( + self, generation: int, inputs: Mapping[str, object], + ): + reserved = { + side: inputs.get(side) + for side in ("left", "right") + } + if all( + getattr(getattr(camera, "node", None), "role", None) == side + for side, camera in reserved.items() + ): + left_node = reserved["left"].node + right_node = reserved["right"].node + if ( + left_node.root_hub != right_node.root_hub + or left_node.direct_parent_hub + != right_node.direct_parent_hub + ): + raise RuntimeError( + "reserved Sightac left/right are not below the " + "same direct Hub" + ) + resolved = { + side: int(camera.node.video_index) + for side, camera in reserved.items() + } + labels, full = self.discovery.cache_snapshot() + with self.state.lock: + if self.state.generation == generation: + self.state.flash_labels = dict(labels) + self.state.flash_full_params = { + int(index): { + key: ( + list(value) + if isinstance(value, tuple) + else value + ) + for key, value in params.items() + } + for index, params in full.items() + } + self.logger( + "[Tactile] Hub-pinned pair: " + f"root={left_node.root_hub} " + f"hub={left_node.direct_parent_hub} " + f"left=video{resolved['left']} " + f"right=video{resolved['right']}" + ) + return resolved + + raise RuntimeError( + "Sightac 必须使用本次动态 libusb/libuvc 相机套件;" + "禁止回退到 V4L2 video 节点、旧缓存或旧物理端口约定" + ) + + # ------------------------------------------------------------------ + # 输入进程化(阶段1):input 采帧迁入 spawn 子进程的路径。 + # ------------------------------------------------------------------ + def _ensure_sightac_syspath(self) -> None: + """把 Sightac SDK 根目录加入父进程 sys.path。 + + 旧路径在父进程 init_sensor 时已由 discovery 加入;输入进程化时 + 父进程不再构造 TouchSensor,需显式恢复,spawn 计算子进程才能 + import api_new 等 SDK 包。 + """ + ensure = getattr( + self.discovery, "_ensure_sightac_import_path", None) + if callable(ensure): + try: + ensure() + except Exception as exc: + self.logger( + f"[Tactile] sightac import path: {exc}") + + def _discovery_payload(self) -> dict: + """把父进程 TactileDiscovery 的可序列化状态交给 input 子进程。""" + discovery = self.discovery + payload = {} + for key in ( + "sysfs_root", "dev_root", "platform", "sightac_root", + "api_package", "old_sensor_template_file", "full_logs", + ): + value = getattr(discovery, key, None) + if value is not None: + payload[key] = value + cache = getattr(discovery, "flash_full_params_cache", None) + if cache is not None: + try: + payload["flash_full_params_cache"] = { + int(index): dict(params) + for index, params in cache.items() + } + except Exception: + pass + labels = getattr(discovery, "flash_param_cache", None) + if labels is not None: + try: + payload["flash_param_cache"] = { + int(index): value for index, value in labels.items() + } + except Exception: + pass + return payload + + def _reserved_input_spec( + self, side: str, inputs: Mapping[str, object], + ): + """把 Connect 的 libuvc IPC 保留相机转成可 spawn 的 spec。""" + reserved_camera = inputs.get(side) + node = getattr(reserved_camera, "node", None) + if getattr(node, "role", None) != side: + return None + if ( + getattr(reserved_camera, "transport", None) + != "libuvc-ipc" + ): + return None + return { + "transport": "libuvc-ipc", + "socket_path": str(node.device_path), + "capture_format": tuple( + getattr( + node, "capture_format", + (640, 480, 30.0, "MJPG"), + ) or (640, 480, 30.0, "MJPG") + ), + "flash_params": getattr( + reserved_camera, "flash_params", None), + } + + def _spawn_input_process( + self, + generation: int, + side: str, + video_index: int, + pipeline: TactileProcessBridge, + inputs: Mapping[str, object], + warmup_frames: int, + initial_job_id: int, + ) -> None: + config = { + "video_index": int(video_index), + "mode": str(self.state.mode or "open"), + "initial_job": { + "job_id": int(initial_job_id), + "reason": "initial", + "warmup_frames": int(warmup_frames), + "frame_count": INITIAL_BASELINE_FRAMES, + }, + "discovery": self._discovery_payload(), + "reserved": self._reserved_input_spec(side, inputs), + } + process = self.context.Process( + target=run_tactile_input_process, + args=( + side, + int(self.input_process_cpus[side][0]), + config, + pipeline.frame_queue, + pipeline.free_frame_slots, + pipeline.shared_frame_storage, + pipeline.frame_slot_bytes, + pipeline.command_queue, + pipeline.input_command_queue, + pipeline.input_status_queue, + pipeline.stop_event, + pipeline.begin_event, + ), + daemon=True, + name=f"tactile-{side}-input-process-{generation}", + ) + with self._spawn_lock: + process.start() + with self.state.lock: + self.state.sides[side].input_process = process + + def _wait_input_ready( + self, + generation: int, + side: str, + pipeline: TactileProcessBridge, + ) -> None: + sensor_name = "sensor2" if side == "left" else "sensor3" + try: + status = pipeline.input_status_queue.get( + timeout=self.INIT_TIMEOUT) + except queue.Empty as exc: + raise RuntimeError( + f"{sensor_name} input process did not become ready" + ) from exc + kind = status[0] + if kind == "fatal": + message = status[1] + detail = status[2] if len(status) > 2 else "" + raise RuntimeError( + f"{sensor_name} input process startup failed: " + f"{message}\n{detail}") + if kind != "ready": + raise RuntimeError( + f"{sensor_name} unexpected input startup message: " + f"{kind}") + _, child_pid, child_cpus, sensor_state = status + with self.state.lock: + side_state = self.state.sides[side] + process = side_state.input_process + side_state.initializing = False + side_state.sensor_state = sensor_state + expected = (int(self.input_process_cpus[side][0]),) + if ( + process is None + or int(child_pid) != process.pid + or tuple(child_cpus) != expected + ): + raise RuntimeError( + f"{sensor_name} input child verification failed: " + f"pid={child_pid} cpus={tuple(child_cpus)} " + f"expected={expected}") + self.logger( + f"[Tactile] input process bound: side={side} " + f"pid={process.pid} logical-cpu={expected[0]}") + + def _initialize_all_input( + self, + generation: int, + inputs: Mapping[str, object], + warmup_frames: int, + on_initialized: Optional[Callable[[int], None]], + ) -> None: + """输入进程化:在 spawn 子进程内构造/claim TouchSensor。 + + 与旧路径顺序一致:两路 TouchSensor 只在子进程内完成构造和 Flash + 操作并上报 sensor_state 后,才通知 Fays open/首帧尝试;随后 + coordinator 线程启动计算子进程并放行输入子进程开始读帧。 + """ + initialized_notified = False + + def notify_initialized(): + nonlocal initialized_notified + if ( + initialized_notified + or on_initialized is None + or not self._active(generation) + ): + return + initialized_notified = True + try: + on_initialized(generation) + except Exception as exc: + self.logger( + "[Tactile] initialized callback failed: " + f"{exc}" + ) + + self._ensure_sightac_syspath() + try: + resolved = self._resolve_inputs(generation, inputs) + for side in ("left", "right"): + if not self._active(generation): + return + index = resolved.get(side) + with self.state.lock: + self.state.sides[side].video_index = index + if index is None: + self._set_error(side, "no Sightac device id") + with self.state.lock: + self.state.sides[side].ready_event.set() + continue + pipeline = TactileProcessBridge( + self.context, + materialize_force_matrix=( + self.materialize_force_matrix), + ) + initial_job_id = pipeline.next_job_id() + with self.state.lock: + side_state = self.state.sides[side] + side_state.pipeline = pipeline + side_state.initializing = True + try: + self._spawn_input_process( + generation, side, int(index), pipeline, + inputs, warmup_frames, initial_job_id, + ) + self._wait_input_ready( + generation, side, pipeline) + except Exception as exc: + pipeline.request_stop() + with self.state.lock: + side_state = self.state.sides[side] + side_state.initializing = False + side_state.ready_event.set() + self._stop_process(side_state.input_process) + self._set_error(side, exc) + traceback.print_exc() + + notify_initialized() + for side in ("left", "right"): + if not self._active(generation): + return + with self.state.lock: + side_state = self.state.sides[side] + ok = ( + side_state.pipeline is not None + and side_state.input_process is not None + and self._process_is_alive( + side_state.input_process) + and side_state.sensor_state is not None + ) + if not ok: + continue + coordinator = self.thread_factory( + target=self._run_side_input_process, + args=(generation, side), + daemon=True, + name=( + f"tactile-{side}-coordinator-{generation}"), + ) + with self.state.lock: + self.state.sides[side].coordinator_thread = ( + coordinator) + coordinator.start() + except Exception as exc: + self.logger(f"[Tactile] initialization error: {exc}") + traceback.print_exc() + notify_initialized() + finally: + self._notify() + + def _run_side_input_process( + self, generation: int, side: str, + ) -> None: + """输入进程化 coordinator:启动计算子进程并消费结果。 + + 输入子进程已由 _initialize_all_input 启动并在 begin_event 上等待; + 本线程(主进程)只负责计算子进程与结果/状态汇总,不再创建 input + 线程,也不持有 TouchSensor/VideoCapture。 + """ + sensor_name = "sensor2" if side == "left" else "sensor3" + pipeline = None + process = None + input_process = None + try: + self._bind_coordinator(side) + if not self._active(generation): + return + with self.state.lock: + side_state = self.state.sides[side] + pipeline = side_state.pipeline + input_process = side_state.input_process + sensor_state = side_state.sensor_state + if ( + pipeline is None + or input_process is None + or sensor_state is None + ): + raise RuntimeError( + f"{sensor_name} input process did not become ready") + if not self._process_is_alive(input_process): + raise RuntimeError( + f"{sensor_name} input process exited unexpectedly: " + f"exitcode={getattr(input_process, 'exitcode', None)}") + cpu = int(self.cpu_map[side]) + self._ensure_sightac_syspath() + process = self.context.Process( + target=self.process_target, + args=( + side, + cpu, + sensor_state, + pipeline.frame_queue, + pipeline.command_queue, + pipeline.result_queue, + pipeline.status_queue, + pipeline.stop_event, + pipeline.shared_frame_storage, + pipeline.free_frame_slots, + pipeline.frame_slot_bytes, + pipeline.result_shared_storage, + pipeline.free_result_slots, + pipeline.result_slot_bytes, + self._record_queue, + self._record_gate, + ), + daemon=True, + name=f"tactile-{side}-process-{generation}", + ) + with self._spawn_lock: + process.start() + self._verify_child_affinity(process, cpu) + with self.state.lock: + side_state = self.state.sides[side] + if ( + self.state.generation != generation + or not self.state.running + ): + raise RuntimeError( + "tactile generation invalidated") + side_state.process = process + try: + ready = pipeline.status_queue.get( + timeout=self.PROCESS_READY_TIMEOUT) + except queue.Empty as exc: + raise RuntimeError( + f"{sensor_name} subprocess did not become ready" + ) from exc + if ready[0] == "fatal": + self._handle_status( + side, sensor_name, pipeline, ready) + if ready[0] != "ready": + raise RuntimeError( + f"{sensor_name} unexpected startup message: " + f"{ready[0]}") + _, child_pid, child_cpus = ready + if ( + int(child_pid) != process.pid + or tuple(child_cpus) != (cpu,) + ): + raise RuntimeError( + f"{sensor_name} child verification failed: " + f"pid={child_pid} cpus={tuple(child_cpus)} " + f"expected={(cpu,)}") + self.logger( + f"[Tactile] process bound: side={side} " + f"pid={process.pid} logical-cpu={cpu}") + # 计算子进程就绪后放行输入子进程开始读帧。 + pipeline.begin_event.set() + with self.state.lock: + self.state.sides[side].ready_event.set() + self._notify() + + while ( + self._active(generation) + and self._process_is_alive(process) + and self._process_is_alive(input_process) + and not pipeline.stopping + ): + while True: + try: + status = pipeline.status_queue.get_nowait() + except queue.Empty: + break + self._handle_status( + side, sensor_name, pipeline, status) + while True: + try: + istatus = ( + pipeline.input_status_queue.get_nowait()) + except queue.Empty: + break + self._handle_input_status( + side, sensor_name, pipeline, istatus) + try: + result = pipeline.get_result(timeout=0.05) + except queue.Empty: + continue + self._publish_result(side, pipeline, result) + + if self._active(generation) and not pipeline.stopping: + if not self._process_is_alive(process): + raise RuntimeError( + f"{sensor_name} subprocess exited unexpectedly: " + f"exitcode={getattr(process, 'exitcode', None)}") + if not self._process_is_alive(input_process): + raise RuntimeError( + f"{sensor_name} input process exited " + f"unexpectedly: exitcode=" + f"{getattr(input_process, 'exitcode', None)}") + except Exception as exc: + self._set_error(side, exc) + traceback.print_exc() + finally: + if pipeline is not None: + pipeline.request_stop() + self._stop_process(process) + self._stop_process(input_process) + process_alive = self._process_is_alive(process) + input_alive = self._process_is_alive(input_process) + if ( + process is not None + and not process_alive + and self.on_process_stop is not None + ): + try: + self.on_process_stop(side, int(process.pid)) + except Exception: + pass + with self.state.lock: + side_state = self.state.sides[side] + side_state.ready_event.set() + if side_state.process is process and not process_alive: + side_state.process = None + if ( + side_state.input_process is input_process + and not input_alive + ): + side_state.input_process = None + if side_state.pipeline is pipeline and ( + not process_alive and not input_alive + ): + side_state.pipeline = None + if ( + side_state.sensor_state is not None + and not input_alive + ): + side_state.sensor_state = None + if ( + side_state.coordinator_thread + is threading.current_thread() + ): + # 引用保留到 stop 的退出确认。 + pass + if pipeline is not None: + stats = pipeline.snapshot() + self.logger( + f"[Tactile] {sensor_name} input-process FIFO: " + f"published={stats['published']} " + f"dropped_new={stats['dropped_new_frames']} " + f"dropped_result={stats['dropped_results']} " + f"taken={stats['taken']} " + f"input-pid={getattr(input_process, 'pid', None)} " + f"process-pid={getattr(process, 'pid', None)} " + f"mode=input-process transport=shared-memory" + ) + if pipeline is not None and ( + not process_alive and not input_alive + ): + pipeline.close() + self._notify() + + def _handle_input_status( + self, + side: str, + sensor_name: str, + pipeline: TactileProcessBridge, + status, + ) -> None: + """处理 input 子进程上报的状态(输入进程化模式)。""" + kind = status[0] + if kind == "calibration_started": + _, job_id, reason = status + pipeline.mark_input_calibrating() + waiter = pipeline.bind_input_waiter(job_id, reason) + if waiter is not None: + self.logger( + f"[Tactile] {sensor_name} calibration started: " + f"job={int(job_id)} reason={reason}") + return + if kind == "calibration_busy": + _, job_id, reason = status + self.logger( + f"[Tactile] {sensor_name} calibration busy: " + f"active job={int(job_id)} reason={reason}") + pipeline.fail_first_input_waiter( + "calibration already in progress") + return + if kind == "frame_activity": + _, event_ns = status + if self.record_event is not None: + try: + self.record_event( + f"sightac_{side}_input", int(event_ns)) + except Exception: + pass + return + if kind == "input_stats": + _, published, dropped_new, _empty_reads = status + pipeline.record_input_stats(published, dropped_new) + return + if kind == "error": + message = status[1] + detail = status[2] if len(status) > 2 else "" + self._set_error(side, message) + if detail: + self.logger(detail.rstrip()) + return + if kind == "fatal": + message = status[1] + detail = status[2] if len(status) > 2 else "" + raise RuntimeError( + f"{sensor_name} input process startup failed: " + f"{message}\n{detail}") + + def _calibrate_input( + self, timeout: float = TACTILE_CALIBRATION_TIMEOUT, + ): + """输入进程化:并行请求左右手动标定并等待计算子进程完成。""" + waiters = {} + with self.state.lock: + if not self.state.running: + raise RuntimeError("tactile manager is not running") + pipelines = { + side: self.state.sides[side].pipeline + for side in ("left", "right") + } + missing = [ + side for side, pipeline in pipelines.items() + if pipeline is None + ] + if missing: + raise RuntimeError( + f"{missing[0]} tactile pipeline is not running") + self.state.calibrating = True + for side in ("left", "right"): + pipeline = pipelines[side] + waiter = pipeline.request_input_calibration( + reason="manual", + warmup_frames=0, + frame_count=INITIAL_BASELINE_FRAMES, + wait=True, + ) + if waiter is None: + self.state.calibrating = False + raise RuntimeError( + f"{side} tactile pipeline is stopping") + waiters[side] = waiter + self._notify() + results = {} + deadline = self.clock() + max(0.0, float(timeout)) + try: + for side, waiter in waiters.items(): + remaining = max(0.0, deadline - self.clock()) + if not waiter.done.wait(timeout=remaining): + raise TimeoutError( + f"{side} calibration timed out") + if not waiter.success: + raise RuntimeError( + f"{side} calibration failed: " + f"{waiter.error or 'unknown error'}") + results[side] = True + self.logger( + f"[Calib] {side} calibration done") + return MappingProxyType(results) + finally: + with self.state.lock: + self.state.calibrating = False + self._notify() + + def _initialize_all( + self, + generation: int, + inputs: Mapping[str, object], + warmup_frames: int, + on_initialized: Optional[Callable[[int], None]], + ) -> None: + if self.input_process_mode: + self._initialize_all_input( + generation, inputs, warmup_frames, on_initialized) + return + sensors = {} + initialized_notified = False + + def notify_initialized(): + nonlocal initialized_notified + if ( + initialized_notified + or on_initialized is None + or not self._active(generation) + ): + return + initialized_notified = True + try: + on_initialized(generation) + except Exception as exc: + self.logger( + "[Tactile] initialized callback failed: " + f"{exc}" + ) + + try: + resolved = self._resolve_inputs(generation, inputs) + for side in ("left", "right"): + if not self._active(generation): + return + index = resolved.get(side) + with self.state.lock: + self.state.sides[side].video_index = index + if index is None: + self._set_error(side, "no Sightac device id") + with self.state.lock: + self.state.sides[side].ready_event.set() + continue + reserved_camera = inputs.get(side) + if ( + getattr( + getattr(reserved_camera, "node", None), + "role", + None, + ) + != side + ): + reserved_camera = None + sensor = self._initialize_sensor( + generation, + side, + int(index), + reserved_camera=reserved_camera, + ) + if sensor is not None: + sensors[side] = sensor + + # 重构前顺序:两路 TouchSensor 只完成构造和 Flash 操作, + # 随后 Fays 完成 open/首帧尝试,最后才启动任一路触觉 read。 + notify_initialized() + for side, sensor in sensors.items(): + if not self._active(generation): + self._release_sensor(sensor) + continue + sensor._ksq_initial_warmup_frames = int( + warmup_frames) + coordinator = self.thread_factory( + target=self._run_side, + args=(generation, side, sensor), + daemon=True, + name=( + f"tactile-{side}-coordinator-{generation}"), + ) + with self.state.lock: + side_state = self.state.sides[side] + side_state.sensor = sensor + side_state.coordinator_thread = coordinator + coordinator.start() + except Exception as exc: + self.logger(f"[Tactile] initialization error: {exc}") + traceback.print_exc() + notify_initialized() + finally: + with self.state.lock: + if ( + self.state.initializer_thread + is threading.current_thread() + ): + # 保留已退出线程对象到 stop/wait 检查后再清理。 + pass + self._notify() + + def _initialize_sensor( + self, + generation: int, + side: str, + video_index: int, + *, + reserved_camera=None, + ): + result = [None] + error = [None] + timed_out = threading.Event() + + def do_init(): + sensor = None + try: + if self.bind_thread is not None: + bound = self.bind_thread("input") + if bound is False: + raise RuntimeError( + "cannot bind Sightac init to CPU4") + if reserved_camera is None: + sensor = self.discovery.init_sensor(video_index) + else: + sensor = self.discovery.init_sensor( + video_index, + reserved_camera=reserved_camera, + ) + if ( + sensor is None + or timed_out.is_set() + or not self._active(generation) + ): + self._release_sensor(sensor) + return + result[0] = sensor + except Exception as exc: + error[0] = exc + + thread = self.thread_factory( + target=do_init, + daemon=True, + name=f"tactile-{side}-init-{generation}", + ) + with self.state.lock: + side_state = self.state.sides[side] + side_state.initializing = True + side_state.init_thread = thread + thread.start() + thread.join(timeout=self.INIT_TIMEOUT) + if thread.is_alive(): + timed_out.set() + with self.state.lock: + self.state.sides[side].initializing = False + self.state.sides[side].ready_event.set() + self._set_error( + side, + f"initialization timed out after " + f"{self.INIT_TIMEOUT:.1f}s (idx={video_index})", + ) + return None + with self.state.lock: + self.state.sides[side].initializing = False + if not self._active(generation): + self._release_sensor(result[0]) + return None + if error[0] is not None: + with self.state.lock: + self.state.sides[side].ready_event.set() + self._set_error(side, error[0]) + return None + if result[0] is None: + with self.state.lock: + self.state.sides[side].ready_event.set() + self._set_error(side, "TouchSensor construction failed") + return None + self.logger( + f"[Tactile] {side} TouchSensor idx={video_index} initialized") + return result[0] + + def _bind_coordinator(self, side: str) -> None: + if self.bind_coordinator is not None: + if self.bind_coordinator(side) is False: + raise RuntimeError( + f"cannot bind {side} tactile coordinator " + "to tactile compute CPU") + return + if self.bind_general_thread is None: + return + if self.bind_general_thread( + f"tactile-{side}-coordinator" + ) is False: + raise RuntimeError( + f"cannot bind {side} tactile coordinator " + "to general CPUs") + + @staticmethod + def _process_is_alive(process) -> bool: + if process is None: + return False + try: + return bool(process.is_alive()) + except (AssertionError, ValueError): + return False + + def _verify_child_affinity(self, process, cpu: int) -> None: + if ( + not sys.platform.startswith("linux") + or self.set_process_affinity is None + or self.get_process_affinity is None + ): + return + self.set_process_affinity(process.pid, {int(cpu)}) + actual = tuple(sorted( + self.get_process_affinity(process.pid))) + if actual != (int(cpu),): + raise RuntimeError( + f"child affinity mismatch: expected={(int(cpu),)} " + f"actual={actual}") + + def _run_side( + self, generation: int, side: str, sensor, + ) -> None: + if self.input_process_mode: + self._run_side_input_process(generation, side) + return + sensor_name = "sensor2" if side == "left" else "sensor3" + empty_reads = 0 + pipeline = None + process = None + input_thread = None + try: + self._bind_coordinator(side) + if not self._active(generation): + return + cpu = int(self.cpu_map[side]) + pipeline = TactileProcessBridge( + self.context, + materialize_force_matrix=( + self.materialize_force_matrix), + ) + sensor_state = snapshot_sensor_state(sensor) + sensor._ksq_pipeline = pipeline + warmup_frames = int( + getattr( + sensor, "_ksq_initial_warmup_frames", 0, + ) or 0 + ) + initial_job = pipeline.request_calibration( + reason="initial", + warmup_frames=warmup_frames, + frame_count=INITIAL_BASELINE_FRAMES, + ) + if initial_job is None: + raise RuntimeError("initial calibration was rejected") + self.logger( + f"[Tactile] {sensor_name} initial calibration queued: " + f"warmup={warmup_frames}, " + f"samples={INITIAL_BASELINE_FRAMES}" + ) + process = self.context.Process( + target=self.process_target, + args=( + side, + cpu, + sensor_state, + pipeline.frame_queue, + pipeline.command_queue, + pipeline.result_queue, + pipeline.status_queue, + pipeline.stop_event, + pipeline.shared_frame_storage, + pipeline.free_frame_slots, + pipeline.frame_slot_bytes, + pipeline.result_shared_storage, + pipeline.free_result_slots, + pipeline.result_slot_bytes, + self._record_queue, + self._record_gate, + ), + daemon=True, + name=f"tactile-{side}-process-{generation}", + ) + with self._spawn_lock: + process.start() + self._verify_child_affinity(process, cpu) + sensor._ksq_process = process + with self.state.lock: + side_state = self.state.sides[side] + if ( + self.state.generation != generation + or not self.state.running + ): + raise RuntimeError("tactile generation invalidated") + side_state.pipeline = pipeline + side_state.process = process + + try: + ready = pipeline.status_queue.get( + timeout=self.PROCESS_READY_TIMEOUT) + except queue.Empty as exc: + raise RuntimeError( + f"{sensor_name} subprocess did not become ready" + ) from exc + if ready[0] == "fatal": + self._handle_status( + side, sensor_name, pipeline, ready) + if ready[0] != "ready": + raise RuntimeError( + f"{sensor_name} unexpected startup message: " + f"{ready[0]}") + _, child_pid, child_cpus = ready + if ( + int(child_pid) != process.pid + or tuple(child_cpus) != (cpu,) + ): + raise RuntimeError( + f"{sensor_name} child verification failed: " + f"pid={child_pid} cpus={tuple(child_cpus)} " + f"expected={(cpu,)}" + ) + self.logger( + f"[Tactile] process bound: side={side} " + f"pid={process.pid} logical-cpu={cpu}") + + input_thread = self.thread_factory( + target=self._input_loop, + args=( + generation, + side, + sensor, + pipeline, + ), + daemon=True, + name=f"tactile-{side}-input-{generation}", + ) + sensor._ksq_capture_thread = input_thread + with self.state.lock: + self.state.sides[side].input_thread = input_thread + self.state.sides[side].ready_event.set() + input_thread.start() + self._notify() + + while ( + self._active(generation) + and self._process_is_alive(process) + and not pipeline.stopping + ): + while True: + try: + status = pipeline.status_queue.get_nowait() + except queue.Empty: + break + self._handle_status( + side, sensor_name, pipeline, status) + try: + result = pipeline.get_result(timeout=0.05) + except queue.Empty: + continue + self._publish_result(side, pipeline, result) + + if ( + self._active(generation) + and not pipeline.stopping + and not self._process_is_alive(process) + ): + raise RuntimeError( + f"{sensor_name} subprocess exited unexpectedly: " + f"exitcode={getattr(process, 'exitcode', None)}") + except Exception as exc: + self._set_error(side, exc) + traceback.print_exc() + finally: + if pipeline is not None: + pipeline.request_stop() + if ( + input_thread is not None + and input_thread.is_alive() + and input_thread is not threading.current_thread() + ): + input_thread.join( + timeout=self.INPUT_UNBLOCK_TIMEOUT) + self._stop_process(process) + process_alive = self._process_is_alive(process) + if ( + process is not None + and not process_alive + and self.on_process_stop is not None + ): + try: + self.on_process_stop(side, int(process.pid)) + except Exception: + pass + with self.state.lock: + side_state = self.state.sides[side] + side_state.ready_event.set() + if side_state.input_thread is input_thread: + side_state.input_thread = ( + input_thread + if input_thread is not None + and input_thread.is_alive() + else None + ) + if side_state.process is process and not process_alive: + side_state.process = None + if side_state.pipeline is pipeline and not process_alive: + side_state.pipeline = None + if ( + side_state.coordinator_thread + is threading.current_thread() + ): + # 引用保留到 stop 的退出确认。 + pass + if getattr(sensor, "_ksq_pipeline", None) is pipeline: + sensor._ksq_pipeline = None + if getattr(sensor, "_ksq_process", None) is process: + sensor._ksq_process = None + if ( + input_thread is not None + and not input_thread.is_alive() + and getattr(sensor, "_ksq_capture_thread", None) + is input_thread + ): + sensor._ksq_capture_thread = None + if pipeline is not None: + stats = pipeline.snapshot() + self.logger( + f"[Tactile] {sensor_name} FIFO: " + f"published={stats['published']} " + f"dropped_new={stats['dropped_new_frames']} " + f"dropped_result={stats['dropped_results']} " + f"taken={stats['taken']} " + f"mode=drop-new transport=shared-memory" + ) + if pipeline is not None and not process_alive: + pipeline.close() + self._notify() + + def _input_loop( + self, + generation: int, + side: str, + sensor, + pipeline: TactileProcessBridge, + ) -> None: + sensor_name = "sensor2" if side == "left" else "sensor3" + empty_reads = 0 + if self.bind_thread is not None: + if self.bind_thread("input") is False: + self._set_error( + side, "cannot bind Sightac input CPU domain") + pipeline.request_stop() + return + try: + while self._active(generation) and not pipeline.stopping: + try: + with pipeline.capture_lock: + if ( + pipeline.stopping + or not self._active(generation) + ): + continue + raw_frame = getattr( + sensor, "_ksq_prefetched_frame", None) + if raw_frame is not None: + sensor._ksq_prefetched_frame = None + else: + raw_frame = sensor.read_raw_frame() + captured_at = self.clock() + if raw_frame is None: + empty_reads += 1 + capture = getattr(sensor, "cap", None) + transport = getattr(capture, "transport", "") + if transport == "libuvc-ipc": + try: + capture.reconnect() + except Exception as exc: + self.logger( + f"[TactileInput:{sensor_name}] " + f"IPC reconnect failed: {exc}") + if empty_reads in (1, 10, 30, 60): + self.logger( + f"[TactileInput:{sensor_name}] no frame " + f"count={empty_reads} transport={transport!r} " + f"reconnects={getattr(capture, 'reconnect_count', 0)} " + f"error={getattr(capture, 'last_transport_error', '')!r}") + if empty_reads >= 60: + self._set_error( + side, + f"{sensor_name} Sightac IPC has no frame for " + f"60 reads (reconnects=" + f"{getattr(capture, 'reconnect_count', 0)}, " + f"transport_error=" + f"{getattr(capture, 'last_transport_error', '') or 'unknown'})", + ) + pipeline.request_stop() + self.sleep(0.01) + continue + empty_reads = 0 + if ( + pipeline.stopping + or not self._active(generation) + ): + continue + if self.record_event is not None: + self.record_event( + f"sightac_{side}_input") + pipeline.submit_capture( + raw_frame, captured_at) + except Exception as exc: + self.logger( + f"[TactileInput:{sensor_name}] ERROR: {exc}") + traceback.print_exc() + self.sleep(0.05) + finally: + if self.unbind_thread is not None: + try: + self.unbind_thread("input") + except Exception: + pass + + def _handle_status( + self, + side: str, + sensor_name: str, + pipeline: TactileProcessBridge, + status, + ) -> None: + kind = status[0] + if kind == "calibration_result": + ( + _kind, + job_id, + success, + error, + reason, + samples, + ) = status + if self.input_process_mode: + # job 状态在 input 子进程:只转发完成并解析手动 waiter。 + pipeline.resolve_input_calibration( + job_id, success, error) + if success: + self.logger( + f"[Tactile] {sensor_name} calibration done in " + f"{side} input process: reason={reason}, " + f"samples={samples}") + else: + self._set_error( + side, + f"calibration failed ({reason}): {error}", + ) + return + completed = pipeline.finish_calibration( + job_id, success, error) + if completed and success: + self.logger( + f"[Tactile] {sensor_name} calibration done in " + f"{side} process: reason={reason}, " + f"samples={samples}") + elif completed: + self._set_error( + side, + f"calibration failed ({reason}): {error}", + ) + return + if kind == "recalibration_request": + reason = status[1] + if self.input_process_mode: + pipeline.request_input_calibration( + reason=reason, + warmup_frames=0, + frame_count=INITIAL_BASELINE_FRAMES, + wait=False, + ) + self.logger( + f"[Tactile] {sensor_name} calibration requested: " + f"{reason}") + return + job = pipeline.request_calibration( + reason=reason, + warmup_frames=0, + frame_count=INITIAL_BASELINE_FRAMES, + ) + if job is not None: + self.logger( + f"[Tactile] {sensor_name} calibration requested: " + f"{job.reason}") + return + if kind == "result_dropped": + pipeline.record_result_drops(status[1]) + return + if kind == "error": + message = status[1] + detail = status[2] if len(status) > 2 else "" + self._set_error(side, message) + if detail: + self.logger(detail.rstrip()) + return + if kind == "fatal": + message = status[1] + detail = status[2] if len(status) > 2 else "" + raise RuntimeError( + f"{sensor_name} subprocess startup failed: " + f"{message}\n{detail}") + + def _publish_result( + self, + side: str, + pipeline: TactileProcessBridge, + result, + ) -> None: + if result.get("kind", "frame") != "frame": + return + pipeline.materialize_result(result) + received_at = self.clock() + publish_started = time.perf_counter() + heatmap = result["heatmap"] + calculated_force = tuple(result["force"]) + calculated_matrix = result.get("force_matrix") + with self.state.lock: + side_state = self.state.sides[side] + params = self.state.flash_full_params.get( + side_state.video_index, {}) + calibration_source = str(params.get( + "calibration_source", "hardware")) + # 只有当前硬件自己的完整 Flash 才是有效力标定。旧相机模板或 + # vendor defaults 只能用于临时图像/热力图,绝不能把计算结果送入 + # 夹持判定、力曲线或 HDF5 力通道。三维力矩阵与合力同源, + # 服从同一硬件 Flash 标定闸门;hardware-live-flash 是 libusb/libuvc + # 迁移后的同一次硬件实读来源。 + force = ( + calculated_force + if calibration_source in HARDWARE_CALIBRATION_SOURCES + else None + ) + force_matrix = ( + calculated_matrix + if calibration_source in HARDWARE_CALIBRATION_SOURCES + else None + ) + side_state.heatmap = heatmap + side_state.force = force + diag = self._matrix_diag.setdefault(side, { + "frames": 0, "matrix_frames": 0, "logged": False}) + diag["frames"] += 1 + if force_matrix is not None: + diag["matrix_frames"] += 1 + if ( + not diag["logged"] + and diag["frames"] >= 60 + and force is not None + and diag["matrix_frames"] == 0 + ): + diag["logged"] = True + if self.logger is not None: + self.logger( + "[Gripper-Tactile] {} 侧连续 {} 帧力标量有效但" + "力矩阵为空:计算子进程未产出 fx/fy/fz 矩阵" + " (250x250x3)".format(side, diag["frames"])) + local_publish_ms = ( + time.perf_counter() - publish_started) * 1000.0 + ipc_ms = max( + 0.0, + ( + received_at + - float(result.get("result_ready_at", received_at)) + ) * 1000.0, + ) + diagnostics = dict(result.get("diagnostics", {})) + diagnostics["publish_ms"] = ( + ipc_ms + local_publish_ms) + pipeline.record_processed(result.get("captured_at")) + if self.record_stage is not None: + self.record_stage(side, diagnostics) + if self.record_event is not None: + self.record_event(f"sightac_{side}_process") + if self.publish_result is not None: + self.publish_result(side, heatmap, force, force_matrix) + self._notify() + + def wait_ready(self, timeout: Optional[float] = None): + """等待左右两路各自 ready 或独立失败。""" + timeout = ( + self.PROCESS_READY_TIMEOUT + if timeout is None + else max(0.0, float(timeout)) + ) + deadline = self.clock() + timeout + with self.state.lock: + events = [ + self.state.sides[side].ready_event + for side in ("left", "right") + ] + for event in events: + remaining = max(0.0, deadline - self.clock()) + if not event.wait(timeout=remaining): + return False + return True + + def calibrate( + self, timeout: float = TACTILE_CALIBRATION_TIMEOUT, + ): + """并行请求左右手动标定;协调线程本身不读帧也不做计算。""" + if self.input_process_mode: + return self._calibrate_input(timeout) + jobs = [] + with self.state.lock: + if not self.state.running: + raise RuntimeError("tactile manager is not running") + pipelines = { + side: self.state.sides[side].pipeline + for side in ("left", "right") + } + missing = [ + side for side, pipeline in pipelines.items() + if pipeline is None + ] + if missing: + raise RuntimeError( + f"{missing[0]} tactile pipeline is not running") + self.state.calibrating = True + for side in ("left", "right"): + pipeline = pipelines[side] + job = pipeline.request_calibration( + reason="manual", + warmup_frames=0, + frame_count=INITIAL_BASELINE_FRAMES, + ) + if job is None: + self.state.calibrating = False + raise RuntimeError( + f"{side} tactile pipeline is stopping") + jobs.append((side, job)) + self._notify() + results = {} + deadline = self.clock() + max(0.0, float(timeout)) + try: + for side, job in jobs: + remaining = max(0.0, deadline - self.clock()) + if not job.done.wait(timeout=remaining): + raise TimeoutError( + f"{side} calibration timed out") + if not job.success: + raise RuntimeError( + f"{side} calibration failed: " + f"{job.error or 'unknown error'}") + results[side] = True + self.logger( + f"[Calib] {side} calibration done") + return MappingProxyType(results) + finally: + with self.state.lock: + self.state.calibrating = False + self._notify() + + def calibrate_async( + self, + callback: Optional[Callable[[object, Optional[Exception]], None]] + = None, + ): + def run(): + try: + result = self.calibrate() + error = None + except Exception as exc: + result, error = None, exc + if callback is not None: + callback(result, error) + + thread = self.thread_factory( + target=run, + daemon=True, + name="tactile-manual-calibration", + ) + thread.start() + return thread + + def _stop_process(self, process) -> None: + if process is None: + return + try: + pid = process.pid + except Exception: + pid = None + if pid is None: + return + if self._process_is_alive(process): + process.join(timeout=self.PROCESS_JOIN_TIMEOUT) + if self._process_is_alive(process): + self.logger( + f"[Tactile] process pid={pid} did not stop; " + "terminating") + process.terminate() + process.join( + timeout=self.PROCESS_TERMINATE_TIMEOUT) + if self._process_is_alive(process): + # 输入子进程可能阻塞在 V4L2 read;terminate 未退出时 + # SIGKILL 兜底,保证 stop() 能确认全部所有者退出。 + self.logger( + f"[Tactile] process pid={pid} still alive; " + "killing") + try: + process.kill() + except Exception: + pass + process.join( + timeout=self.PROCESS_TERMINATE_TIMEOUT) + + @staticmethod + def _dedupe_threads(threads): + result = [] + seen = set() + for thread in threads: + if thread is None or id(thread) in seen: + continue + seen.add(id(thread)) + result.append(thread) + return result + + def stop(self) -> bool: + """停止并确认 init/input/coordinator/process 全部退出后才成功返回。""" + with self.state.lock: + has_resources = ( + self.state.running + or self.state.initializer_thread is not None + or any( + side_state.sensor is not None + or side_state.init_thread is not None + or side_state.input_thread is not None + or side_state.coordinator_thread is not None + or side_state.process is not None + or side_state.input_process is not None + for side_state in self.state.sides.values() + ) + ) + if not has_resources: + return True + self.state.generation += 1 + self.state.running = False + self.state.calibrating = False + initializer = self.state.initializer_thread + side_states = list(self.state.sides.values()) + sensors = { + side_state.side: side_state.sensor + for side_state in side_states + } + pipelines = [ + side_state.pipeline for side_state in side_states + if side_state.pipeline is not None + ] + threads = self._dedupe_threads( + [initializer] + + [ + thread + for side_state in side_states + for thread in ( + side_state.init_thread, + side_state.input_thread, + side_state.coordinator_thread, + ) + ] + ) + for pipeline in pipelines: + pipeline.request_stop() + + deadline = self.clock() + self.STOP_DEADLINE + for thread in threads: + if ( + not thread.is_alive() + or thread is threading.current_thread() + ): + continue + remaining = deadline - self.clock() + if remaining <= 0: + break + thread.join(timeout=remaining) + + # V4L2 read 极端阻塞时,只释放仍有活输入线程的对应 cap 来唤醒它。 + for side_state in side_states: + input_thread = side_state.input_thread + if input_thread is not None and input_thread.is_alive(): + self.logger( + f"[Tactile] forcing blocked input to exit: " + f"{input_thread.name}") + self._release_sensor(sensors[side_state.side]) + for side_state in side_states: + input_thread = side_state.input_thread + if ( + input_thread is not None + and input_thread.is_alive() + and input_thread is not threading.current_thread() + ): + input_thread.join( + timeout=self.INPUT_UNBLOCK_TIMEOUT) + + # 协调线程正常负责 graceful join;若它已卡住,manager 仍拥有最终回收权。 + for side_state in side_states: + self._stop_process(side_state.process) + for side_state in side_states: + self._stop_process(side_state.input_process) + for side_state in side_states: + coordinator = side_state.coordinator_thread + if ( + coordinator is not None + and coordinator.is_alive() + and coordinator is not threading.current_thread() + ): + coordinator.join( + timeout=self.PROCESS_TERMINATE_TIMEOUT) + + alive_threads = [ + thread.name for thread in threads + if thread.is_alive() + ] + alive_processes = [] + for side_state in side_states: + for proc in (side_state.process, side_state.input_process): + if proc is not None and self._process_is_alive(proc): + alive_processes.append( + f"{side_state.side}:{getattr(proc, 'pid', None)}") + if alive_threads or alive_processes: + details = [] + if alive_threads: + details.append(f"threads={alive_threads}") + if alive_processes: + details.append(f"processes={alive_processes}") + error = ( + "tactile stop could not confirm all owners exited: " + + " ".join(details) + ) + # Record the real wait site; a thread name alone cannot distinguish + # IPC reads, callbacks, locks, or child-process joins. + frames = sys._current_frames() + names = {t.ident: t.name for t in threading.enumerate()} + stacks = [error + "\n"] + for ident, frame in frames.items(): + stacks.append( + f"\nThread {names.get(ident, ident)}:\n" + + "".join(traceback.format_stack(frame))) + del frames + try: + with tempfile.NamedTemporaryFile( + mode="w", encoding="utf-8", prefix="ksq-tactile-stop-", + suffix=".log", delete=False) as diagnostic: + diagnostic.write("".join(stacks)) + diagnostic_path = diagnostic.name + error += f"; thread dump: {diagnostic_path}" + self.logger(f"[TactileStopTimeout] {error}") + except OSError: + self.logger("[TactileStopTimeout] " + "".join(stacks)) + for side_state in side_states: + if side_state.error is None: + side_state.error = error + self._notify() + raise RuntimeError(error) + + for sensor in sensors.values(): + self._release_sensor(sensor) + for pipeline in pipelines: + pipeline.close() + with self.state.lock: + self.state.initializer_thread = None + self.state.mode = None + for side_state in self.state.sides.values(): + side_state.sensor = None + side_state.initializing = False + side_state.init_thread = None + side_state.input_thread = None + side_state.coordinator_thread = None + side_state.process = None + side_state.input_process = None + side_state.sensor_state = None + side_state.pipeline = None + side_state.force = None + side_state.heatmap = None + side_state.ready_event.set() + self._notify() + return True + + close = stop diff --git a/collector/core/gripper/devices/usb_camera_ipc.py b/collector/core/gripper/devices/usb_camera_ipc.py new file mode 100644 index 0000000000000000000000000000000000000000..255676c93607adb008d630bb5b1af48f0f6f41cb --- /dev/null +++ b/collector/core/gripper/devices/usb_camera_ipc.py @@ -0,0 +1,255 @@ +"""Minimal Python consumer for the camera-service Unix-socket prototype. + +The public shape intentionally follows ``cv2.VideoCapture``: + + cam = Camera("sightac_left") + cam.open() + ok, frame = cam.read() + +The service sends a fixed-size header followed by one MJPEG payload over a +Unix byte stream. This module reconstructs one complete frame and does not +open a V4L2 node. +""" + +from __future__ import annotations + +import socket +import struct +import time +from pathlib import Path +from typing import Optional + +import cv2 +import numpy as np + + +IPC_MAGIC = 0x4B535146 # "KSQF" +IPC_VERSION = 1 +# The C producer uses the native-aligned struct: uint64_t is aligned to +# 8 bytes, so there are four padding bytes before timestamp_ns. +HEADER = struct.Struct(" bool: + if self._socket is not None: + return True + if self._released: + return False + if not Path(self.socket_path).exists(): + raise FileNotFoundError(self.socket_path) + connection = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + if self.timeout is not None: + connection.settimeout(self.timeout) + try: + connection.connect(self.socket_path) + except BaseException: + connection.close() + raise + if self._released: + connection.close() + return False + self._socket = connection + return True + + def isOpened(self) -> bool: + """Match the small ``cv2.VideoCapture`` status API used by the app.""" + return self._socket is not None + + def reconnect(self) -> bool: + """Close and recreate one client lease after a transport failure.""" + self.close_socket() + for _attempt in range(IPC_RECONNECT_ATTEMPTS): + if self._released: + return False + try: + if not self.open() or self._released: + self.close_socket() + return False + self.reconnect_count += 1 + self.last_transport_error = "" + return True + except (OSError, FileNotFoundError) as exc: + self.last_transport_error = str(exc) + self.close_socket() + time.sleep(0.05) + return False + + def getBackendName(self) -> str: + return "libuvc-ipc" + + def set(self, _property, _value) -> bool: + """The UVC mode is negotiated by camera-service, not V4L2.""" + return False + + def get(self, property_id): + """Return negotiated metadata where the IPC protocol can provide it.""" + if property_id == cv2.CAP_PROP_FRAME_WIDTH: + return float(self.last_metadata.get("width", 0)) + if property_id == cv2.CAP_PROP_FRAME_HEIGHT: + return float(self.last_metadata.get("height", 0)) + if property_id == cv2.CAP_PROP_FPS: + return 30.0 + if property_id == cv2.CAP_PROP_FOURCC: + return float(cv2.VideoWriter_fourcc(*"MJPG")) + return 0.0 + + def _recv_exact(self, size: int): + # Capture the socket once: release() may clear the owner's reference + # while a blocking read is in progress. recv_into avoids accumulating + # and then copying each individual TCP/Unix stream fragment. + connection = self._socket + if connection is None: + raise ConnectionResetError("camera IPC socket is closed") + buffer = bytearray(size) + view = memoryview(buffer) + offset = 0 + while offset < size: + count = connection.recv_into(view[offset:]) + if not count: + raise ConnectionResetError("camera-service closed an incomplete packet") + offset += count + return buffer + + def close_socket(self) -> None: + socket_obj = self._socket + self._socket = None + if socket_obj is not None: + try: + socket_obj.shutdown(socket.SHUT_RDWR) + except OSError: + pass + try: + socket_obj.close() + except OSError: + pass + + def read_packet(self): + if self._socket is None: + if self._released or not self.reconnect(): + return False, None + try: + header = self._recv_exact(HEADER.size) + values = HEADER.unpack(header) + (magic, version, header_bytes, sequence, width, height, + fourcc, size, timestamp_ns) = values + if (magic != IPC_MAGIC or version != IPC_VERSION + or header_bytes != HEADER.size): + raise ValueError("invalid camera-service IPC header") + if fourcc != int.from_bytes(b"MJPG", "little"): + raise ValueError("camera-service did not negotiate MJPG") + if not (0 < size <= MAX_PAYLOAD and 0 < width <= 8192 + and 0 < height <= 8192 and timestamp_ns > 0): + raise ValueError("invalid camera-service frame dimensions/size/timestamp") + payload = self._recv_exact(size) + except (OSError, ValueError, struct.error) as exc: + # A timeout can occur in the middle of either header or payload. + # Continuing on that socket would interpret JPEG bytes as a header. + # Report this failed read; only a later read may create a new lease. + self.last_transport_error = str(exc) + self.close_socket() + self.last_metadata = {} + return False, None + if not payload.startswith(b"\xff\xd8") or payload.rfind(b"\xff\xd9") < 2: + self.last_transport_error = "incomplete MJPEG payload" + self.last_metadata = {} + return False, None + self.last_transport_error = "" + self.last_metadata = { + "sequence": sequence, + "width": width, + "height": height, + "fourcc": "MJPG", + "timestamp_ns": timestamp_ns, + "payload_bytes": size, + } + return True, payload + + def read(self): + """Return ``(ret, BGR frame)`` like ``cv2.VideoCapture.read()``.""" + # USB startup can deliver an occasional incomplete JPEG before the + # source settles. Match V4L2 semantics: report read failure instead + # of killing initialization on the first undecodable packet. A hard + # error remains if several consecutive payloads cannot be decoded. + failures = [] + for _attempt in range(MAX_DECODE_ATTEMPTS): + ok, payload = self.read_packet() + if not ok: + return False, None + encoded = np.frombuffer(payload, dtype=np.uint8) + try: + frame = cv2.imdecode(encoded, cv2.IMREAD_COLOR) + except cv2.error: + frame = None + if (frame is not None and frame.size > 0 + and frame.shape[:2] == (self.last_metadata["height"], + self.last_metadata["width"])): + self.last_decode_failures = len(failures) + self.last_decode_diagnostics = tuple(failures) + return True, frame + metadata = dict(self.last_metadata) + failures.append({ + "sequence": metadata.get("sequence"), + "bytes": len(payload), + "head": bytes(payload[:4]).hex(), + "tail": bytes(payload[-4:]).hex(), + }) + print( + "[IpcCamera] partial/truncated MJPEG payload " + f"socket={self.socket_path} attempt={_attempt + 1} " + f"sequence={metadata.get('sequence')} bytes={len(payload)} " + f"head={failures[-1]['head']} tail={failures[-1]['tail']} " + f"transport_error={self.last_transport_error!r}", + flush=True, + ) + self.last_decode_failures = len(failures) + self.last_decode_diagnostics = tuple(failures) + if failures: + print( + "[IpcCamera] MJPEG decode failed " + f"socket={self.socket_path} " + f"failures={len(failures)} " + f"transport_error={self.last_transport_error!r} " + f"details={failures}", + flush=True, + ) + return False, None + + def close(self) -> None: + self._released = True + self.close_socket() + + release = close + + def __enter__(self): + self.open() + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.close() diff --git a/collector/core/gripper/devices/usb_camera_sets.py b/collector/core/gripper/devices/usb_camera_sets.py new file mode 100644 index 0000000000000000000000000000000000000000..18b0a7233e14e57750fb2843b91444191745adb9 --- /dev/null +++ b/collector/core/gripper/devices/usb_camera_sets.py @@ -0,0 +1,81 @@ +"""Shared camera-node types for the dynamic libusb/libuvc transport. + +The production selector lives in ``uvc_camera_service``. This module keeps +only the common node/topology data structures, format constants, and the +diagnostic ESP32 tty root-path helper. It does not scan or open camera nodes. +""" + +from __future__ import annotations + +from dataclasses import dataclass +import os +import re +from typing import Callable, Optional + +SIGHTAC_WIDTH = 640 +SIGHTAC_HEIGHT = 480 +SIGHTAC_FPS = 30.0 +SIGHTAC_FOURCC = "MJPG" + +DECXIN_WIDTH = 1280 +DECXIN_HEIGHT = 960 +DECXIN_FPS = 30.0 +DECXIN_FOURCC = "MJPG" + +class UsbCameraSetError(RuntimeError): + """A required camera stream cannot be reserved.""" + + +@dataclass(frozen=True) +class UsbCameraNode: + role: str + device_path: str + video_index: int + physical_usb_path: str + physical_sysfs_path: str + direct_parent_hub: str + root_hub: str + vendor_id: str + product_id: str + serial: str + + +@dataclass(frozen=True) +class UsbCameraSetTopology: + """One manifest-selected DECXIN plus left/right Sightac pair.""" + + root_hub: str + tactile_hub: str + decxin: UsbCameraNode + left: UsbCameraNode + right: UsbCameraNode + + def node(self, role: str) -> UsbCameraNode: + if role not in {"decxin", "left", "right"}: + raise KeyError(role) + return getattr(self, role) + + +def _root_hub_from_physical(physical_usb_path: str) -> Optional[str]: + match = re.fullmatch(r"(\d+-\d+)(?:\.\d+)*", physical_usb_path) + return match.group(1) if match is not None else None + + +def usb_root_hub_for_tty( + device_path: str, + *, + realpath: Callable[[str], str] = os.path.realpath, +): + """Return the diagnostic root hub for a ttyACM path.""" + basename = os.path.basename(str(device_path).strip()) + if not re.fullmatch(r"ttyACM\d+", basename): + return None + interface_path = realpath( + os.path.join("/sys/class/tty", basename, "device") + ) + for component in reversed(interface_path.split(os.sep)): + physical = component.split(":", 1)[0] + root_hub = _root_hub_from_physical(physical) + if root_hub is not None: + return root_hub + return None diff --git a/collector/core/gripper/devices/uvc_camera_service.py b/collector/core/gripper/devices/uvc_camera_service.py new file mode 100644 index 0000000000000000000000000000000000000000..0328eff1f895871a65d75e0d53e93559e0ccc6c4 --- /dev/null +++ b/collector/core/gripper/devices/uvc_camera_service.py @@ -0,0 +1,782 @@ +"""Runtime libusb/libuvc transport for Sightac and DECXIN. + +Fays is deliberately absent from this module. The Fays instance manager has +already identified and leased the S80M through the official SDK; this module +uses that live assignment only to associate the separate USB2 camera set. + +The discovery executable is run for every selection. Its Flash calibration +payload is therefore a per-run read from the camera, not a saved fallback. +The service then exposes the negotiated MJPEG frames through Unix sockets. +""" + +from __future__ import annotations + +import json +import math +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import threading +import time +import sys + +import cv2 + +from core.gripper.fays_runtime import PROJECT_ROOT +from core.gripper.runtime.device_access import device_access_guard + +# camera_service/python is a checkout-local transport module, not an ambient +# dependency. Resolve it before importing the IPC client. +IPC_PYTHON_ROOT = os.path.join(PROJECT_ROOT, "camera_service", "python") +if IPC_PYTHON_ROOT not in sys.path: + sys.path.insert(0, IPC_PYTHON_ROOT) +from core.gripper.devices.usb_camera_ipc import Camera as IpcCamera + +from .usb_camera_sets import ( + DECXIN_FOURCC, + DECXIN_FPS, + DECXIN_HEIGHT, + DECXIN_WIDTH, + SIGHTAC_FOURCC, + SIGHTAC_FPS, + SIGHTAC_HEIGHT, + SIGHTAC_WIDTH, + UsbCameraSetError, + UsbCameraSetTopology, +) + + +DISCOVERY_BINARY = Path(os.environ.get( + "KSQ_UVC_DISCOVERY_BINARY", + os.path.join(PROJECT_ROOT, "camera_service", "build", "discover-uvc-config"), +)).resolve() +SERVICE_BINARY = Path(os.environ.get( + "KSQ_UVC_SERVICE_BINARY", + os.path.join(PROJECT_ROOT, "camera_service", "build", "ksq-camera-service"), +)).resolve() +DISCOVERY_TIMEOUT_S = 45.0 +SERVICE_START_TIMEOUT_S = 10.0 +FIRST_FRAME_ATTEMPTS = 20 +FIRST_FRAME_RETRY_S = 0.05 + +# 原生二进制依赖交付目录内的 libuvc(原上位机由 start_upper_computer.sh +# 全局注入 LD_LIBRARY_PATH;主程序改为仅对这两个子进程注入,避免污染 +# 主进程及 Fays 桥接的自建库路径)。 +_LIBUVC_DIR = Path( + PROJECT_ROOT, "camera_service", "build", "third_party", "libuvc") + + +def _native_env(): + env = dict(os.environ) + existing = env.get("LD_LIBRARY_PATH", "") + if _LIBUVC_DIR.is_dir() and str(_LIBUVC_DIR) not in existing: + env["LD_LIBRARY_PATH"] = ( + str(_LIBUVC_DIR) + (f":{existing}" if existing else "")) + return env + + +class UvcCameraServiceError(RuntimeError): + """The live libusb/libuvc camera set cannot be used.""" + + +def _root_port(physical_path): + text = str(physical_path or "").strip() + if "-" not in text: + return "" + return text.split("-", 1)[1].split(".", 1)[0] + + +def _path_contains(bus, outer_path, child_path): + outer = str(outer_path or "").strip() + child = str(child_path or "").strip() + if not outer or not child: + return False + if str(bus) != child.split("-", 1)[0]: + return False + return child == f"{bus}-{outer}" or child.startswith( + f"{bus}-{outer}." + ) + + +def _require_finite_vector(params, key, length): + values = params.get(key) + if not isinstance(values, list) or len(values) != length: + raise UvcCameraServiceError( + f"当前 Flash 参数 {key} 长度无效: expected={length}" + ) + result = [] + for index, value in enumerate(values): + if key == "fw_params" and params.get("device_type") == "bevel" and index >= 5 and ( + value is None or ( + isinstance(value, float) and math.isnan(value) + ) + ): + # Reserved bevel-table tail: firmware may store NaN here and + # the current bevel ROI algorithm consumes only fw[0..4]. Keep + # either JSON null or a Python NaN sentinel through the external + # handoff; the tactile cache converts it to its internal NaN + # representation. + result.append(None) + continue + if isinstance(value, bool): + raise UvcCameraServiceError( + f"当前 Flash 参数 {key} 包含非数值" + ) + try: + number = float(value) + except (TypeError, ValueError) as exc: + raise UvcCameraServiceError( + f"当前 Flash 参数 {key}[{index}] 包含非数值: {value!r}" + ) from exc + if not math.isfinite(number): + raise UvcCameraServiceError( + f"当前 Flash 参数 {key}[{index}] 包含非有限值: {value!r}" + ) + result.append(number) + return result + + +def _flash_params(candidate): + if not candidate.get("flash_ok") or not candidate.get( + "flash_params_ok" + ): + raise UvcCameraServiceError( + "Sightac 本次 Flash 身份或完整标定参数读取失败: " + f"side={candidate.get('side') or ''} " + f"error={candidate.get('error') or ''}" + ) + device_type = str( + candidate.get("device_type") or "" + ).strip().lower() + if device_type not in {"planar", "curved", "bevel"}: + raise UvcCameraServiceError( + f"Flash device_type 无效: {device_type!r}" + ) + encoded = candidate.get("flash_params") + if not isinstance(encoded, dict): + raise UvcCameraServiceError( + "libusb 探测没有返回本次完整 Flash 参数" + ) + encoded_type = str(encoded.get("device_type") or "").strip().lower() + if encoded_type != device_type: + raise UvcCameraServiceError( + "Flash device_type 身份与参数表不一致" + ) + return { + "device_type": device_type, + "fx_params": _require_finite_vector(encoded, "fx_params", 5), + "fy_params": _require_finite_vector(encoded, "fy_params", 5), + "fz_params": _require_finite_vector(encoded, "fz_params", 21), + "fw_params": _require_finite_vector(encoded, "fw_params", 9), + "ft_params": _require_finite_vector(encoded, "ft_params", 20), + "flash_state": str( + encoded.get("flash_state") or "programmed" + ), + "calibration_source": "hardware-live-flash", + } + + +class IpcCameraNode: + """The subset of UsbCameraNode consumed by the existing lifecycle.""" + + def __init__(self, *, role, socket_path, video_index, candidate, + outer_path, bus, flash_params=None): + self.role = str(role) + self.device_path = str(socket_path) + self.video_index = int(video_index) + self.physical_usb_path = f"{int(bus)}-{candidate['port']}" + self.physical_sysfs_path = self.physical_usb_path + self.direct_parent_hub = f"{int(bus)}-{outer_path}" + self.root_hub = f"{int(bus)}-{str(outer_path).split('.', 1)[0]}" + self.vendor_id = f"{int(candidate['vid']):04x}" + self.product_id = f"{int(candidate['pid']):04x}" + self.serial = str( + candidate.get("flash_serial") + or candidate.get("usb_serial") + or "" + ) + self.transport = "libuvc-ipc" + self.flash_params = flash_params + self.capture_format = ( + DECXIN_WIDTH, + DECXIN_HEIGHT, + DECXIN_FPS, + DECXIN_FOURCC, + ) if self.role == "decxin" else ( + SIGHTAC_WIDTH, + SIGHTAC_HEIGHT, + SIGHTAC_FPS, + SIGHTAC_FOURCC, + ) + + +class IpcReservedCamera: + """Lazy IPC client; opening it claims exactly one service socket.""" + + def __init__(self, node): + self.node = node + self.actual_format = tuple(node.capture_format) + self.transport = "libuvc-ipc" + self.flash_params = node.flash_params + self._camera = None + self._first_frame = None + self._claimed = False + self._lock = threading.Lock() + + @property + def claimed(self): + with self._lock: + return self._claimed + + def claim(self): + with self._lock: + if self._claimed: + raise UsbCameraSetError( + f"{self.node.role} IPC reservation was already claimed" + ) + camera = IpcCamera(self.node.device_path, timeout=0.5) + try: + camera.open() + first_frame = None + failed_reads = 0 + last_decode_packets = () + for attempt in range(FIRST_FRAME_ATTEMPTS): + ok, frame = camera.read() + if ok and frame is not None and getattr( + frame, "size", 0 + ) > 0: + first_frame = frame + break + failed_reads += 1 + last_decode_packets = ( + camera.last_decode_diagnostics or () + ) + if attempt + 1 < FIRST_FRAME_ATTEMPTS: + time.sleep(FIRST_FRAME_RETRY_S) + if first_frame is None: + details = "".join( + f" seq={item.get('sequence')} bytes={item.get('bytes')}" + f" head={item.get('head')} tail={item.get('tail')}" + for item in last_decode_packets[-3:] + ) + raise UsbCameraSetError( + f"{self.node.role} libuvc IPC has no first frame: " + f"{self.node.device_path} " + f"failed_reads={failed_reads}{details}" + ) + self._claimed = True + self._camera = camera + self._first_frame = first_frame + return camera, first_frame, self.actual_format + except Exception: + camera.release() + raise + + def release(self): + with self._lock: + camera = self._camera + self._camera = None + self._first_frame = None + if camera is not None: + camera.release() + + +class IpcCameraSetReservation: + def __init__(self, topology, cameras, on_release=None): + self.topology = topology + self._cameras = dict(cameras) + self._on_release = on_release + self._released = False + + def camera(self, role): + return self._cameras[role] + + def release_unclaimed(self): + for camera in self._cameras.values(): + camera.release() + if not self._released: + self._released = True + if self._on_release is not None: + self._on_release() + + +class UvcCameraServiceManager: + """Own dynamic camera-service processes for the active UI slots. + + One service process is used per selected physical camera set. This is + intentional: the current socket protocol accepts one client per output, + and two UI slots must not force a running first set to be reconfigured + underneath its clients. + """ + + def __init__(self, *, logger=print, discovery_binary=DISCOVERY_BINARY, + service_binary=SERVICE_BINARY, + service_cpus: tuple[int, ...] | None = None): + self._logger = logger + self._discovery_binary = Path(discovery_binary).resolve() + self._service_binary = Path(service_binary).resolve() + self._service_cpus = tuple( + int(cpu) for cpu in (service_cpus or ()) + ) + self._lock = threading.RLock() + self._services = {} + + def _run_discovery(self, *, usb_bus=None, port_prefix=None): + if not self._discovery_binary.is_file(): + raise UvcCameraServiceError( + f"libusb/libuvc 发现程序不存在: {self._discovery_binary}" + ) + if not os.access(self._discovery_binary, os.X_OK): + raise UvcCameraServiceError( + f"libusb/libuvc 发现程序不可执行: {self._discovery_binary}" + ) + command = [str(self._discovery_binary), "--json"] + if usb_bus is not None and port_prefix is not None: + command += ["--bus", str(usb_bus), "--port-prefix", str(port_prefix)] + completed = subprocess.run( + command, + capture_output=True, + text=True, + timeout=DISCOVERY_TIMEOUT_S, + check=False, + env=_native_env(), + ) + if completed.returncode != 0: + details = "\n".join( + (completed.stderr or "").splitlines()[-20:] + ) + raise UvcCameraServiceError( + "libusb/libuvc 动态发现失败 " + f"rc={completed.returncode}: {details or ''}" + ) + try: + report = json.loads(completed.stdout) + except json.JSONDecodeError as exc: + raise UvcCameraServiceError( + f"libusb/libuvc 发现 JSON 无效: {exc}" + ) from exc + groups = report.get("groups") if isinstance(report, dict) else None + if not isinstance(groups, list) or not groups: + raise UvcCameraServiceError( + "libusb/libuvc 没有发现完整 Sightac + DECXIN 组" + ) + return groups + + @staticmethod + def _assignment_identity(assignment): + if not isinstance(assignment, dict): + raise UvcCameraServiceError( + "Fays 尚未完成 device_setup 身份分配" + ) + esp = assignment.get("esp32") or {} + fays = assignment.get("fays") or {} + esp_serial = str(esp.get("serial") or "").strip() + fays_serial = str(fays.get("product_serial") or "").strip() + fays_path = str( + fays.get("physical_usb_path") or "" + ).strip() + if not esp_serial or not fays_serial or not fays_path: + raise UvcCameraServiceError( + "Fays 当前分配缺少 ESP32 serial、Fays serial 或物理路径" + ) + return esp_serial, fays_serial, fays_path + + def _associate_group(self, group, assignment, live_esp): + esp_serial, fays_serial, fays_path = self._assignment_identity( + assignment + ) + bus = int(group.get("bus", -1)) + outer_path = str(group.get("outer_path") or "").strip() + matching_esp = [ + item for item in live_esp + if str(item.get("serial") or "").strip() == esp_serial + and _path_contains(bus, outer_path, + item.get("physical_usb_path")) + ] + if len(matching_esp) != 1: + raise UvcCameraServiceError( + "当前 UVC 组无法按 ESP32 serial 唯一关联: " + f"serial={esp_serial} matches={len(matching_esp)} " + f"group={bus}-{outer_path}" + ) + # Fays is USB3/FT602 and may be reported on a different libusb bus; + # the existing topology rule intentionally correlates its root port. + if _root_port(fays_path) != str(outer_path).split(".", 1)[0].split( + "-", 1 + )[-1]: + raise UvcCameraServiceError( + "当前 UVC 组与已分配 Fays 不在同一根端口: " + f"fays={fays_path} group={bus}-{outer_path}" + ) + normalized = { + "bus": bus, + "outer_path": outer_path, + "esp32_serial": esp_serial, + "fays_serial": fays_serial, + "sightac": {}, + "decxin": group.get("decxin"), + } + sightac = group.get("sightac") + if not isinstance(sightac, list) or len(sightac) != 2: + raise UvcCameraServiceError( + "UVC 组 Sightac 数量不是 2" + ) + for candidate in sightac: + side = str(candidate.get("side") or "").strip().lower() + if side not in {"left", "right"} or side in normalized[ + "sightac" + ]: + raise UvcCameraServiceError( + f"UVC 组 left/right Flash 身份不唯一: side={side!r}" + ) + normalized["sightac"][side] = candidate + if set(normalized["sightac"]) != {"left", "right"}: + raise UvcCameraServiceError( + "UVC 组缺少动态 Flash left/right 身份" + ) + if not group.get("valid"): + raise UvcCameraServiceError( + "UVC 组未通过动态模式或 Flash 完整参数校验" + ) + for side in ("left", "right"): + normalized["sightac"][side]["flash_params_local"] = ( + _flash_params(normalized["sightac"][side]) + ) + decxin = normalized["decxin"] + if not isinstance(decxin, dict) or not decxin.get("mode_ok"): + raise UvcCameraServiceError( + "UVC 组 DECXIN 未通过动态模式校验" + ) + return normalized + + def _discovery_scope(self, assignment, live_esp=None): + from core.gripper.fays_runtime import discover_esp32_devices + serial, _, _ = self._assignment_identity(assignment) + devices = tuple(discover_esp32_devices()) if live_esp is None else live_esp + matches = [d for d in devices if str(d.get("serial", "")).strip() == serial] + if len(matches) != 1: + raise UvcCameraServiceError("ESP32 身份无法唯一定位,拒绝启动全设备扫描") + physical = str(matches[0].get("physical_usb_path", "")) + bus, separator, ports = physical.partition("-") + root = ports.split(".")[0] + if not separator or not bus.isdigit() or not root.isdigit(): + raise UvcCameraServiceError("ESP32 USB 路径无效,请重建设备清单") + return int(bus), root + + def _resolve_current_group(self, assignment): + from core.gripper.fays_runtime import discover_esp32_devices + + live_esp = tuple(discover_esp32_devices()) + bus, port = self._discovery_scope(assignment, live_esp) + groups = self._run_discovery(usb_bus=bus, port_prefix=port) + matches = [] + for group in groups: + try: + matches.append(self._associate_group( + group, assignment, live_esp)) + except UvcCameraServiceError: + continue + if len(matches) != 1: + esp_serial, fays_serial, _ = self._assignment_identity(assignment) + raise UvcCameraServiceError( + "当前设备清单身份与动态 UVC 拓扑无法唯一配对: " + f"esp32={esp_serial} fays={fays_serial} " + f"matches={len(matches)} groups={len(groups)}" + ) + return matches[0] + + @staticmethod + def _signature_for(records): + return tuple(sorted( + ( + int(record["bus"]), + record["outer_path"], + tuple(sorted( + (side, str(candidate["port"])) + for side, candidate in record["sightac"].items() + )), + str(record["decxin"]["port"]), + ) + for record in records + )) + + def _write_config(self, records): + runtime_dir = Path(tempfile.mkdtemp(prefix="ksq-camera-service-")) + lines = [ + "# Generated at runtime from the current libusb/libuvc scan.", + "# Fays is not handled by this service.", + "", + ] + sockets = {} + for index, record in enumerate(records, 1): + for role in ("left", "right", "decxin"): + candidate = ( + record["sightac"][role] + if role in {"left", "right"} + else record["decxin"] + ) + name = f"unit_{index}_{role}" + socket_path = runtime_dir / f"{name}.sock" + sockets[(index, role)] = str(socket_path) + lines.extend([ + f"[{name}]", + f"vid=0x{int(candidate['vid']):04x}", + f"pid=0x{int(candidate['pid']):04x}", + f"usb_bus={int(record['bus'])}", + f"usb_port_path={candidate['port']}", + f"streaming_interface={int(candidate['streaming_interface'])}", + f"forced_altsetting={int(candidate['altsetting'])}", + "forced_payload=800" if role in {"left", "right"} + else "forced_payload=1280", + "width=640" if role in {"left", "right"} + else "width=1280", + "height=480" if role in {"left", "right"} + else "height=960", + "fps=30", + "format=MJPEG", + f"socket_path={socket_path}", + "", + ]) + config_path = runtime_dir / "current.ini" + config_path.write_text("\n".join(lines), encoding="utf-8") + return runtime_dir, config_path, sockets + + def _ensure_service(self, records): + signature = self._signature_for(records) + with self._lock: + entry = self._services.get(signature) + if entry is not None and entry["process"].poll() is None: + if entry["leases"]: + raise UvcCameraServiceError( + "当前物理相机组已有活动 libuvc 租约;" + "不能让两个界面共用同一组相机" + ) + return signature, entry["runtime_dir"], entry["sockets"] + if entry is not None: + self._stop_entry_locked(entry) + self._services.pop(signature, None) + if not self._service_binary.is_file(): + raise UvcCameraServiceError( + f"libusb/libuvc 服务程序不存在: {self._service_binary}" + ) + runtime_dir, config_path, sockets = self._write_config(records) + service_log_path = runtime_dir / "camera-service.log" + service_log = service_log_path.open("a", encoding="utf-8") + try: + process = subprocess.Popen( + [ + str(self._service_binary), + "--config", str(config_path), + "--parent-pid", str(os.getpid()), + ], + stdin=subprocess.DEVNULL, + stdout=subprocess.DEVNULL, + stderr=service_log, + start_new_session=True, + env=_native_env(), + ) + finally: + service_log.close() + def startup_details(): + with service_log_path.open("rb") as stream: + stream.seek(max(0, service_log_path.stat().st_size - 8192)) + tail = stream.read().decode("utf-8", errors="replace") + return "\n".join(tail.splitlines()[-12:]) + if self._service_cpus: + try: + os.sched_setaffinity( + process.pid, set(self._service_cpus)) + actual_cpus = tuple(sorted( + os.sched_getaffinity(process.pid))) + if actual_cpus != self._service_cpus: + self._logger( + "[UVC] camera-service affinity mismatch: " + f"pid={process.pid} " + f"expected={self._service_cpus} " + f"actual={actual_cpus}" + ) + except (OSError, PermissionError) as exc: + self._logger( + "[UVC] camera-service affinity bind FAILED: " + f"pid={process.pid} " + f"cpus={self._service_cpus}: {exc}" + ) + deadline = time.monotonic() + SERVICE_START_TIMEOUT_S + required = tuple(sockets.values()) + while time.monotonic() < deadline: + if process.poll() is not None: + raise UvcCameraServiceError( + f"camera-service 提前退出 rc={process.returncode}; " + f"日志={service_log_path}\n{startup_details()}" + ) + if all(os.path.exists(path) for path in required): + self._services[signature] = { + "process": process, + "runtime_dir": runtime_dir, + "sockets": sockets, + "leases": 0, + } + self._logger( + "[UVC] libusb/libuvc camera-service started: " + f"group={signature[0][1]} pid={process.pid} " + f"cpus={self._service_cpus or ''} " + f"log={service_log_path}" + ) + return signature, runtime_dir, sockets + time.sleep(0.05) + process.terminate() + try: + process.wait(timeout=2.0) + except subprocess.TimeoutExpired: + process.kill() + process.wait(timeout=2.0) + raise UvcCameraServiceError( + "camera-service 未在限定时间取得全部相机的有效 MJPG 帧;" + f"日志={service_log_path}\n{startup_details()}" + ) + + def _release_lease(self, signature): + with self._lock: + entry = self._services.get(signature) + if entry is not None: + entry["leases"] = max(0, entry["leases"] - 1) + if ( + entry is not None + and int(entry["leases"]) <= 0 + ): + # 租约归零说明该物理相机组已无人使用。必须立刻停掉并释放 + # libusb,否则重连时 discover 二进制无法读取已被占用的 + # Flash 身份,_resolve_current_group 会得到 matches=0 + # (“设备清单身份与动态 UVC 拓扑无法唯一配对”)。 + self._stop_entry_locked(entry) + self._services.pop(signature, None) + + def select(self, manifest_provider): + """Claim the physical group before any discovery opens its cameras.""" + assignment = manifest_provider() + bus, port = self._discovery_scope(assignment) + guard = device_access_guard(f"/tmp/ksq-uvc-group-{bus}-{port}.lock", timeout=0) + guard.__enter__() + try: + with self._lock: + reservation = self._select_assignment(assignment) + release = reservation._on_release + def release_guarded(): + try: + release() + finally: + guard.__exit__(None, None, None) + reservation._on_release = release_guarded + return reservation + except BaseException: + try: + with self._lock: + for signature, entry in tuple(self._services.items()): + if (not entry["leases"] and any( + item[0] == bus and item[1].split(".")[0] == port + for item in signature)): + self._stop_entry_locked(entry) + self._services.pop(signature, None) + finally: + guard.__exit__(None, None, None) + raise + + def _select_assignment(self, assignment): + selected = self._resolve_current_group(assignment) + # Use one service per physical set so selecting a second device does + # not restart or invalidate the first set's Unix-socket clients. + signature, _, sockets = self._ensure_service((selected,)) + index = 1 + left_candidate = selected["sightac"]["left"] + right_candidate = selected["sightac"]["right"] + decxin_candidate = selected["decxin"] + left_params = left_candidate["flash_params_local"] + right_params = right_candidate["flash_params_local"] + left_node = IpcCameraNode( + role="left", socket_path=sockets[(index, "left")], + video_index=1000000 + index * 10 + 1, + candidate=left_candidate, outer_path=selected["outer_path"], + bus=selected["bus"], flash_params=left_params, + ) + right_node = IpcCameraNode( + role="right", socket_path=sockets[(index, "right")], + video_index=1000000 + index * 10 + 2, + candidate=right_candidate, outer_path=selected["outer_path"], + bus=selected["bus"], flash_params=right_params, + ) + decxin_node = IpcCameraNode( + role="decxin", socket_path=sockets[(index, "decxin")], + video_index=1000000 + index * 10 + 3, + candidate=decxin_candidate, outer_path=selected["outer_path"], + bus=selected["bus"], + ) + topology = UsbCameraSetTopology( + root_hub=f"{selected['bus']}-{selected['outer_path'].split('.', 1)[0]}", + tactile_hub=f"{selected['bus']}-{selected['outer_path']}", + decxin=decxin_node, + left=left_node, + right=right_node, + ) + cameras = { + "left": IpcReservedCamera(left_node), + "right": IpcReservedCamera(right_node), + "decxin": IpcReservedCamera(decxin_node), + } + with self._lock: + self._services[signature]["leases"] += 1 + return IpcCameraSetReservation( + topology, + cameras, + on_release=lambda sig=signature: self._release_lease(sig), + ) + + @staticmethod + def _stop_entry_locked(entry): + process = entry["process"] + runtime_dir = entry["runtime_dir"] + if process is not None and process.poll() is None: + process.terminate() + try: + process.wait(timeout=3.0) + except subprocess.TimeoutExpired: + process.kill() + process.wait(timeout=2.0) + shutil.rmtree(runtime_dir, ignore_errors=True) + + def _stop_locked(self): + for entry in tuple(self._services.values()): + self._stop_entry_locked(entry) + self._services.clear() + + def stop(self): + with self._lock: + self._stop_locked() + + +def build_uvc_camera_set_selector(discovery, manifest_provider, + service_manager, *, logger=print): + """Build the production selector backed by dynamic libusb/libuvc.""" + + class Selector: + def select(self): + reservation = service_manager.select(manifest_provider) + try: + for side in ("left", "right"): + camera = reservation.camera(side) + cache = getattr( + discovery, "cache_external_flash_params") + cache(camera.node.video_index, camera.flash_params) + except Exception: + reservation.release_unclaimed() + raise + logger( + "[CameraSet] libusb/libuvc selected dynamic group: " + f"left={reservation.topology.left.device_path} " + f"right={reservation.topology.right.device_path} " + f"decxin={reservation.topology.decxin.device_path}" + ) + return reservation + + return Selector() diff --git a/collector/core/gripper/fays_runtime.py b/collector/core/gripper/fays_runtime.py new file mode 100644 index 0000000000000000000000000000000000000000..73baf2dbfa6e9d80298793bffa17f65b92cf19bb --- /dev/null +++ b/collector/core/gripper/fays_runtime.py @@ -0,0 +1,1638 @@ +#!/usr/bin/env python3 +"""FaysSense S80M 的单一运行时配置来源。 + +这个模块只使用 Python 标准库,因此上位机、启动器和检查脚本都可以安全导入。 +相机设备节点来自 Fays SDK 配置,禁止在业务代码中另写一套默认值。 +""" + +import fcntl +import glob +import hashlib +import json +import os +import re +import threading +import time +import sys + +if "__compiled__" in globals(): + GRIPPER_DIR = os.path.dirname(os.path.abspath(sys.argv[0])) # 二进制所在目录 +else: + GRIPPER_DIR = os.path.dirname(os.path.abspath(__file__)) +PROJECT_ROOT = os.path.dirname(GRIPPER_DIR) +SUPPORTED_CAMERA = "FaysSense S80M stereo fisheye + IMU" +FAYS_MIN_USB_SPEED_MBPS = 5000.0 +FAYS_STEREO_FPS = 30.0 + +FAYS_SDK_ROOT = os.path.abspath(os.environ.get( + "FAYS_SDK_ROOT", + os.path.join(PROJECT_ROOT, "FaysSense_VI_Kit_Release"), +)) +ORB_ROOT = os.path.abspath(os.environ.get( + "KSQ_ORB_ROOT", + os.path.join(PROJECT_ROOT, "ORB-SLAM"), +)) + +# There is one production ORB bridge. ``device_setup`` records this executable +# together with the per-device SDK/ORB YAML paths in the canonical manifest. +FAYS_MARK_ONLY_BINARY = os.path.join( + PROJECT_ROOT, + "dist", + "fays_opencv48", + "bin", + "fayssense_orb_slam_sn219_opencv48_mark_only", +) +# Do not expose an executable override: the production bridge is fixed. +FAYS_ORB_BINARY = FAYS_MARK_ONLY_BINARY +FAYS_DEVICE_CONFIG = os.path.join( + FAYS_SDK_ROOT, + "config", + "fays_vikit_s80m.yaml", +) +DEVICE_MANIFEST = os.path.join( + GRIPPER_DIR, + "device_manifest.json", +) +_ORB_VOCABULARY_CONFIG = os.environ.get("KSQ_ORB_VOCABULARY", "ORBvoc.txt") +ORB_VOCABULARY = os.path.abspath( + _ORB_VOCABULARY_CONFIG + if os.path.isabs(_ORB_VOCABULARY_CONFIG) + else os.path.join(PROJECT_ROOT, _ORB_VOCABULARY_CONFIG) +) +ORB_LIBRARY = os.path.abspath(os.environ.get( + "KSQ_ORB_LIBRARY", + os.path.join( + PROJECT_ROOT, + "dist", + "orb_mark_only", + "lib", + "libORB_SLAM3.so", + ), +)) +ORB_WORK_DIR = os.path.join(PROJECT_ROOT, "ORB-SLAM", "Examples", "fays") +ORB_TRAJECTORY = os.path.join(PROJECT_ROOT, "ORB-SLAM", "traj.txt") + +# AIKit is a peer localization backend, not an ORB-SLAM calibration mode. The +# official service keeps its runtime tree in a bind-mounted host directory; +# before each launch we replace only the current device's factory calibration +# and ephemeral video nodes in that tree. +AIKIT_BRIDGE_BINARY = os.path.abspath(os.environ.get( + "KSQ_FAYS_AIKIT_BRIDGE", + os.path.join( + PROJECT_ROOT, "dist", "fays_aikit", "bin", + "fays_aikit_slam_bridge", + ), +)) +AIKIT_CLIENT_LIBRARY_DIR = os.path.abspath(os.environ.get( + "KSQ_FAYS_AIKIT_LIBRARY_DIR", + os.path.join(PROJECT_ROOT, "dist", "fays_aikit", "lib"), +)) +AIKIT_CLIENT_CONFIG = os.path.abspath(os.environ.get( + "KSQ_FAYS_AIKIT_CLIENT_CONFIG", + os.path.join( + PROJECT_ROOT, "dist", "fays_aikit", "config", + "active_tracker_client.yaml", + ), +)) +AIKIT_SERVICE_CONTAINER = os.environ.get( + "KSQ_FAYS_AIKIT_CONTAINER", "ksq-fays-aikit-sn198" +).strip() +AIKIT_SERVICE_HOST = os.environ.get( + "KSQ_FAYS_AIKIT_HOST", "127.0.0.1" +).strip() +AIKIT_SERVICE_PORT = int(os.environ.get("KSQ_FAYS_AIKIT_PORT", "5413")) +AIKIT_SERVICE_RUNTIME_ROOT = os.path.abspath(os.environ.get( + "KSQ_FAYS_AIKIT_RUNTIME_ROOT", + os.path.expanduser("~/Downloads/FaysSense_AIKit/runtime_sn198"), +)) +AIKIT_SERVICE_DEVICE_CONFIG = os.path.join( + AIKIT_SERVICE_RUNTIME_ROOT, "driver", "fays_vikit.yaml" +) +AIKIT_SERVICE_CALIBRATION = os.path.join( + AIKIT_SERVICE_RUNTIME_ROOT, "calib", "calib.yaml" +) +AIKIT_FACTORY_CALIBRATION_DIR = os.path.join( + PROJECT_ROOT, "config", "calibration" +) + +FAYS_VENDOR_ID = "0403" +FAYS_PRODUCT_ID = "602e" +ESP32_VENDOR_ID = "303a" +ESP32_PRODUCT_ID = "1001" +_USB_PHYSICAL_PATTERN = re.compile(r"\d+-\d+(?:\.\d+)*") +_INSTANCE_IPC_FILES = ( + "orb_current_frame_tmp.jpg", + "orb_current_frame.jpg", + "orb_meta_tmp.json", + "orb_meta.json", + "orb_pose.json.tmp", + "orb_pose.json", + "orb_control.json.tmp", + "orb_control.json", + "orb_raw_stream.sock", + "camera_calibration.yaml", + "imu.yaml", +) + + +class FaysRuntimeError(RuntimeError): + """Fays 运行时文件或配置不完整。""" + + +def fays_slam_profile(calibration_serial): + """Return the setup-time artifact paths for one discovered Fays serial. + + This helper is used only while ``device_setup`` creates the manifest. It + does not select among historical devices or provide a runtime fallback. + """ + + serial = str(calibration_serial or "").strip() + if not serial: + raise FaysRuntimeError( + "device_setup 无法为缺少 product serial 的 Fays 生成运行资源" + ) + settings = os.path.join( + PROJECT_ROOT, + "dist", + "fays_opencv48", + f"s80m_{serial}_stereo_inertial.yaml", + ) + if not os.path.isfile(FAYS_MARK_ONLY_BINARY): + raise FaysRuntimeError( + f"稳定版 ORB-SLAM 程序不存在: {FAYS_MARK_ONLY_BINARY}" + ) + if not os.path.isfile(settings): + raise FaysRuntimeError( + "device_setup 尚未生成当前 Fays 的 ORB YAML: " + f"serial={serial} path={settings}" + ) + return { + "backend": "orb", + "calibration_serial": serial, + "executable": os.path.abspath(FAYS_MARK_ONLY_BINARY), + "settings": os.path.abspath(settings), + } + + +def _atomic_write(path, payload, *, binary=False): + destination = os.path.abspath(path) + temporary = ( + f"{destination}.tmp.{os.getpid()}.{threading.get_ident()}" + ) + mode = "wb" if binary else "w" + kwargs = {} if binary else {"encoding": "utf-8"} + try: + with open(temporary, mode, **kwargs) as stream: + stream.write(payload) + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, destination) + except OSError as exc: + try: + os.unlink(temporary) + except OSError: + pass + raise FaysRuntimeError( + f"更新 AIKit 运行配置失败: {destination}: {exc}" + ) from exc + + +def _factory_calibration_for_serial(calibration_serial): + serial = str(calibration_serial or "").strip() + candidates = sorted(glob.glob(os.path.join( + AIKIT_FACTORY_CALIBRATION_DIR, + f"FS-VI80-*_{serial}_dump_calib.yaml", + ))) + if len(candidates) != 1: + raise FaysRuntimeError( + "device_setup 未生成当前 Fays 的唯一工厂标定 YAML: " + f"serial={serial or ''} files=" + + (", ".join(candidates) if candidates else "") + ) + return os.path.abspath(candidates[0]) + + +def prepare_aikit_service_runtime(calibration_serial, selected_ports): + """Atomically select the current device for the mounted AIKit service.""" + + serial = str(calibration_serial or "").strip() + if not serial: + raise FaysRuntimeError("当前 Fays 缺少 product serial,不能启动 AIKit") + missing_ports = [ + name for name in ("stereo_dev_port", "imu_dev_port") + if not str(selected_ports.get(name, "")).strip() + ] + if missing_ports: + raise FaysRuntimeError( + "device_setup 设备清单缺少 AIKit 所需节点: " + + ", ".join(missing_ports) + ) + ports = { + name: f"/dev/video{video_index_from_device(selected_ports[name])}" + for name in ("stereo_dev_port", "imu_dev_port") + } + calibration_source = _factory_calibration_for_serial(serial) + try: + with open(AIKIT_SERVICE_DEVICE_CONFIG, encoding="utf-8") as stream: + driver_config = stream.read() + with open(calibration_source, "rb") as stream: + calibration_payload = stream.read() + except OSError as exc: + raise FaysRuntimeError(f"无法读取 AIKit 运行配置: {exc}") from exc + + for key, value in ports.items(): + driver_config, count = re.subn( + rf"^(\s*{re.escape(key)}\s*:)\s*[^\s#]+", + rf"\1 {value}", + driver_config, + count=1, + flags=re.MULTILINE, + ) + if count != 1: + raise FaysRuntimeError( + f"AIKit driver 配置无法定位字段: {key}" + ) + + lock_path = os.path.join( + AIKIT_SERVICE_RUNTIME_ROOT, ".ksq_runtime_config.lock" + ) + try: + with open(lock_path, "a+", encoding="utf-8") as lock_stream: + fcntl.flock(lock_stream.fileno(), fcntl.LOCK_EX) + _atomic_write( + AIKIT_SERVICE_CALIBRATION, calibration_payload, binary=True + ) + _atomic_write(AIKIT_SERVICE_DEVICE_CONFIG, driver_config) + except OSError as exc: + raise FaysRuntimeError(f"无法锁定 AIKit 运行配置: {exc}") from exc + return { + "calibration_serial": serial, + "calibration_source": calibration_source, + "calibration_target": AIKIT_SERVICE_CALIBRATION, + "device_config": AIKIT_SERVICE_DEVICE_CONFIG, + "ports": ports, + } + + +def fays_aikit_profile(calibration_serial, selected_ports): + """Return an AIKit profile for any device configured by device_setup.""" + + required = ( + AIKIT_BRIDGE_BINARY, + AIKIT_CLIENT_CONFIG, + os.path.join( + AIKIT_CLIENT_LIBRARY_DIR, "libfayssense_aikit_client.so" + ), + AIKIT_SERVICE_DEVICE_CONFIG, + ) + missing = [path for path in required if not os.path.isfile(path)] + if missing: + raise FaysRuntimeError( + "AIKit 运行文件不存在: " + ", ".join(missing) + ) + if not os.access(AIKIT_BRIDGE_BINARY, os.X_OK): + raise FaysRuntimeError( + f"AIKit 文件不可执行: {AIKIT_BRIDGE_BINARY}" + ) + if not AIKIT_SERVICE_CONTAINER: + raise FaysRuntimeError("KSQ_FAYS_AIKIT_CONTAINER 不能为空") + + prepare_aikit_service_runtime(calibration_serial, selected_ports) + return { + "backend": "aikit", + "calibration_serial": str(calibration_serial).strip(), + "executable": AIKIT_BRIDGE_BINARY, + "settings": AIKIT_CLIENT_CONFIG, + "arguments": (AIKIT_CLIENT_CONFIG,), + "service_container": AIKIT_SERVICE_CONTAINER, + "service_host": AIKIT_SERVICE_HOST, + "service_port": AIKIT_SERVICE_PORT, + } + + +def video_index_from_device(device_path): + """把严格的 ``/dev/videoN`` 路径转换为 OpenCV 索引 N。""" + match = re.fullmatch(r"/dev/video(\d+)", str(device_path).strip()) + if not match: + raise FaysRuntimeError(f"不是有效的 V4L2 视频节点: {device_path!r}") + return int(match.group(1)) + + +def inspect_video_node(device_path): + """只读检查 V4L2 节点、USB interface 编号和 FT602 身份。""" + index = video_index_from_device(device_path) + class_dir = f"/sys/class/video4linux/video{index}" + info = { + "device": device_path, + "exists": os.path.exists(device_path), + "name": "?", + "stream_index": None, + "interface_number": None, + "modalias": "", + "vendor_id": "", + "product_id": "", + "is_fays_ft602": False, + "physical_usb_path": None, + "usb_device_sysfs_path": None, + } + + fields = { + "name": os.path.join(class_dir, "name"), + "stream_index": os.path.join(class_dir, "index"), + "interface_number": os.path.join(class_dir, "device", "bInterfaceNumber"), + "modalias": os.path.join(class_dir, "device", "modalias"), + } + for key, path in fields.items(): + try: + with open(path, encoding="utf-8") as stream: + value = stream.read().strip() + info[key] = int(value) if key == "stream_index" else value + except (OSError, ValueError): + pass + + name = str(info["name"]).lower() + modalias = str(info["modalias"]).lower() + info["is_fays_ft602"] = ( + "ftdi" in name + and "superspeed video bridge" in name + and "v0403p602e" in modalias + ) + try: + interface_path = os.path.realpath(os.path.join(class_dir, "device")) + physical_path = os.path.dirname(interface_path) + with open( + os.path.join(physical_path, "idVendor"), encoding="utf-8" + ) as stream: + info["vendor_id"] = stream.read().strip().lower() + with open( + os.path.join(physical_path, "idProduct"), encoding="utf-8" + ) as stream: + info["product_id"] = stream.read().strip().lower() + info["physical_usb_path"] = os.path.basename( + interface_path + ).split(":", 1)[0] + info["usb_device_sysfs_path"] = physical_path + except OSError: + pass + info["is_fays_ft602"] = ( + info["vendor_id"] == FAYS_VENDOR_ID + and info["product_id"] == FAYS_PRODUCT_ID + and str(info["interface_number"]) in {"00", "02"} + ) + return info + + +def inspect_tty_device(device_path): + """Resolve one selected ESP32 tty to stable read-only USB identity.""" + basename = os.path.basename(str(device_path).strip()) + if not re.fullmatch(r"ttyACM\d+", basename): + raise FaysRuntimeError(f"不是有效的 ESP32 串口节点: {device_path!r}") + interface_path = os.path.realpath( + os.path.join("/sys/class/tty", basename, "device") + ) + interface_name = os.path.basename(interface_path) + if ( + not interface_path.startswith("/sys/devices/") + or ":" not in interface_name + ): + raise FaysRuntimeError( + f"无法解析 ESP32 串口 USB 身份: {device_path}" + ) + physical_usb_path = interface_name.split(":", 1)[0] + if not _USB_PHYSICAL_PATTERN.fullmatch(physical_usb_path): + raise FaysRuntimeError( + f"ESP32 串口物理路径无效: {physical_usb_path!r}" + ) + physical_path = os.path.dirname(interface_path) + + def read_attribute(name): + try: + with open( + os.path.join(physical_path, name), encoding="utf-8" + ) as stream: + return stream.read().strip() + except OSError as exc: + raise FaysRuntimeError( + f"无法读取 ESP32 {name}: {device_path}: {exc}" + ) from exc + + root_match = re.match(r"(\d+-\d+)", physical_usb_path) + return { + "device": f"/dev/{basename}", + "physical_usb_path": physical_usb_path, + "root_hub": root_match.group(1), + "vendor_id": read_attribute("idVendor").lower(), + "product_id": read_attribute("idProduct").lower(), + "serial": read_attribute("serial"), + } + + +def discover_esp32_devices(): + """只读枚举当前在线的 ESP32 控制板节点。 + + ``/dev/ttyACM*`` 是本次枚举得到的路径,VID/PID 和 USB serial 才是 + 设备身份。这里沿用 ``inspect_tty_device`` 的 sysfs 读取路径,不打开串口, + 不访问 USB interface 目录,也不修改硬件状态。 + """ + devices = [] + for class_path in sorted( + glob.glob("/sys/class/tty/ttyACM*"), + key=lambda path: tuple( + int(part) if part.isdigit() else part + for part in re.split(r"([0-9]+)", str(path)) + if part + ), + ): + basename = os.path.basename(class_path) + device_path = f"/dev/{basename}" + try: + info = inspect_tty_device(device_path) + except FaysRuntimeError: + continue + if ( + info["vendor_id"] == ESP32_VENDOR_ID + and info["product_id"] == ESP32_PRODUCT_ID + and info.get("serial") + ): + devices.append(info) + return tuple(devices) + + +def read_fays_usb_speed_mbps( + usb_device_sysfs_path, + physical_usb_path, +): + """从 USB 设备目录只读获取 Fays 当前协商链路速度。""" + physical = str(physical_usb_path or "").strip() + if not re.fullmatch(r"\d+-\d+(?:\.\d+)*", physical): + raise FaysRuntimeError( + f"Fays 物理 USB 路径无效: {physical_usb_path!r}" + ) + device_path = os.path.realpath( + str(usb_device_sysfs_path or "").strip() + ) + if ( + not device_path.startswith("/sys/devices/") + or os.path.basename(device_path) != physical + or ":" in os.path.basename(device_path) + ): + raise FaysRuntimeError( + "Fays USB 设备 sysfs 路径无效: " + f"{usb_device_sysfs_path!r}" + ) + # ``inspect_video_node`` 已将 video class symlink 解析到无冒号的 + # 物理 device 父目录。这里只读该目录的 speed,不访问 ``*:*`` + # interface 属性,也不写 sysfs、不复位或重绑驱动。 + speed_path = os.path.join(device_path, "speed") + try: + with open(speed_path, encoding="utf-8") as stream: + speed = float(stream.read().strip()) + except (OSError, ValueError) as exc: + raise FaysRuntimeError( + f"无法读取 Fays USB 链路速度: {speed_path}: {exc}" + ) from exc + if speed <= 0: + raise FaysRuntimeError( + f"Fays USB 链路速度无效: {speed:g}M ({physical})" + ) + return speed + + +def validate_fays_superspeed(devices): + """拒绝 FT602 降级到 USB 2.0,返回当前链路速度(Mb/s)。""" + physical_paths = [ + devices.get(role, {}).get("physical_usb_path") + for role in ("stereo", "imu") + ] + device_paths = [ + devices.get(role, {}).get("usb_device_sysfs_path") + for role in ("stereo", "imu") + ] + if ( + any(not path for path in physical_paths) + or len(set(physical_paths)) != 1 + or any(not path for path in device_paths) + or len(set(map(os.path.realpath, device_paths))) != 1 + ): + raise FaysRuntimeError( + "无法确认 Fays stereo/IMU 的唯一物理 USB 设备" + ) + physical = physical_paths[0] + speed = read_fays_usb_speed_mbps(device_paths[0], physical) + if speed < FAYS_MIN_USB_SPEED_MBPS: + raise FaysRuntimeError( + "Fays USB 链路不是 SuperSpeed: " + f"physical={physical} speed={speed:g}M," + f"要求至少 {FAYS_MIN_USB_SPEED_MBPS:g}M;" + "请将 Fays 直连 USB 3.x 端口" + ) + return speed + + +def fays_usb_control_node(devices): + """Resolve the FT602 USB device node used by the D3XX control path.""" + physical_paths = [ + devices.get(role, {}).get("physical_usb_path") + for role in ("stereo", "imu") + ] + device_paths = [ + devices.get(role, {}).get("usb_device_sysfs_path") + for role in ("stereo", "imu") + ] + if ( + any(not path for path in physical_paths) + or len(set(physical_paths)) != 1 + or any(not path for path in device_paths) + or len(set(map(os.path.realpath, device_paths))) != 1 + ): + raise FaysRuntimeError( + "无法确认 Fays stereo/IMU 的唯一物理 USB 设备" + ) + + physical = str(physical_paths[0]) + device_path = os.path.realpath(str(device_paths[0])) + if ( + not _USB_PHYSICAL_PATTERN.fullmatch(physical) + or not device_path.startswith("/sys/devices/") + or os.path.basename(device_path) != physical + or ":" in os.path.basename(device_path) + ): + raise FaysRuntimeError( + f"Fays USB 设备 sysfs 路径无效: {device_paths[0]!r}" + ) + + values = {} + for attribute in ("busnum", "devnum"): + path = os.path.join(device_path, attribute) + try: + with open(path, encoding="utf-8") as stream: + values[attribute] = int(stream.read().strip()) + except (OSError, ValueError) as exc: + raise FaysRuntimeError( + f"无法读取 Fays USB {attribute}: {path}: {exc}" + ) from exc + if not 0 < values[attribute] <= 999: + raise FaysRuntimeError( + f"Fays USB {attribute} 无效: {values[attribute]!r}" + ) + return ( + f"/dev/bus/usb/{values['busnum']:03d}/" + f"{values['devnum']:03d}" + ) + + +def validate_fays_control_access(devices): + """Require read/write access to the FT602 D3XX register-control node.""" + node = fays_usb_control_node(devices) + if os.path.exists(node) and os.access(node, os.R_OK | os.W_OK): + return node + + details = "missing" + try: + metadata = os.stat(node) + details = ( + f"mode={metadata.st_mode & 0o777:04o} " + f"uid={metadata.st_uid} gid={metadata.st_gid}" + ) + except OSError: + pass + installer = os.path.join( + PROJECT_ROOT, "env_init", "install_fays_permissions.sh" + ) + raise FaysRuntimeError( + "Fays FT602 D3XX 控制节点不可读写: " + f"{node} ({details});双目/IMU 可能仍能取流,但曝光、增益和旋转" + "写入会报 FT_Create failed。请先执行 " + f"sudo {installer},然后重新 Connect" + ) + + +def validate_fays_sdk_access(devices): + """Validate both the SuperSpeed stream and writable D3XX control path.""" + speed = validate_fays_superspeed(devices) + validate_fays_control_access(devices) + return speed + + +def discover_fays_device_groups(): + """只读发现全部完整 S80M,并按物理 USB 路径分组。""" + groups = {} + for class_path in sorted(glob.glob("/sys/class/video4linux/video*")): + basename = os.path.basename(class_path) + if not re.fullmatch(r"video\d+", basename): + continue + info = inspect_video_node(f"/dev/{basename}") + if not info["is_fays_ft602"] or info["stream_index"] != 0: + continue + physical = info.get("physical_usb_path") + interface = info.get("interface_number") + if physical and interface in {"00", "02"}: + groups.setdefault(physical, {}).setdefault(interface, []).append(info) + + complete = [] + for physical, interfaces in groups.items(): + if len(interfaces.get("00", [])) == 1 and len(interfaces.get("02", [])) == 1: + stereo, imu = interfaces["00"][0], interfaces["02"][0] + complete.append({ + "physical_usb_path": physical, + "ports": { + "stereo_dev_port": stereo["device"], + "imu_dev_port": imu["device"], + }, + "stereo": stereo, + "imu": imu, + "config_updated": False, + }) + return tuple(sorted( + complete, + key=lambda item: tuple( + int(part) if part.isdigit() else part + for part in re.split( + r"([0-9]+)", item["physical_usb_path"] + ) + if part + ), + )) + + +def read_fays_config_ports(config_path): + """Read configured access nodes; never infer a product identity from them.""" + with open(config_path, encoding="utf-8") as stream: + text = stream.read() + ports = {} + for key in ("stereo_dev_port", "imu_dev_port"): + match = re.search(r"^\s*" + key + r"\s*:\s*['\"]?(/dev/video[0-9]+)(?=['\"\s#]|$)", + text, re.MULTILINE) + if match is None: + raise FaysRuntimeError(f"Fays SDK 配置缺少有效 {key}: {config_path}") + ports[key] = match.group(1) + return ports + + +def materialize_fays_device_config( + ports, + destination, + template_path, +): + """从只读模板原子生成一个实例专用 SDK 配置。""" + try: + with open(template_path, encoding="utf-8") as stream: + content = stream.read() + except OSError as exc: + raise FaysRuntimeError( + f"无法读取 Fays 配置模板: {template_path}: {exc}" + ) from exc + replacements = { + "stereo_dev_port": ( + f"/dev/video{video_index_from_device(ports['stereo_dev_port'])}" + ), + "imu_dev_port": ( + f"/dev/video{video_index_from_device(ports['imu_dev_port'])}" + ), + } + for key, value in replacements.items(): + content, count = re.subn( + rf"^(\s*{re.escape(key)}\s*:)\s*[^\s#]+", + rf"\1 {value}", + content, + count=1, + flags=re.MULTILINE, + ) + if count != 1: + raise FaysRuntimeError(f"Fays 配置模板无法定位字段: {key}") + destination = os.path.abspath(destination) + os.makedirs(os.path.dirname(destination), exist_ok=True) + temporary = f"{destination}.tmp.{os.getpid()}" + try: + with open(temporary, "w", encoding="utf-8") as stream: + stream.write(content) + stream.flush() + os.fsync(stream.fileno()) + os.chmod(temporary, 0o600) + os.replace(temporary, destination) + except OSError as exc: + try: + os.unlink(temporary) + except OSError: + pass + raise FaysRuntimeError( + f"生成 Fays 实例配置失败: {destination}: {exc}" + ) from exc + return destination + + +def discover_fays_manifest_device_groups(): + """Discover Fays groups only after device_setup manifest resolution.""" + from fays_serial_probe import discover_fays_manifest_groups + + return discover_fays_manifest_groups() + + +class FaysInstanceManager: + """Own one manifest-selected Fays lease and all per-GUI runtime paths.""" + + def __init__( + self, + runtime_dir, + *, + run_id=None, + lock_dir="/tmp/ksq-gripper-fays-locks", + ipc_root="/dev/shm", + discover_devices=None, + discover_selected_devices=None, + inspect_tty=inspect_tty_device, + validate_link=validate_fays_sdk_access, + logger=print, + pid=None, + ): + self.runtime_dir = os.path.abspath(runtime_dir) + self.run_id = str( + run_id or os.path.basename(self.runtime_dir) + ) + self.pid = int(os.getpid() if pid is None else pid) + rendered = re.sub( + r"[^A-Za-z0-9_.-]+", "-", self.run_id + ).strip("-") or "run" + self.instance_id = f"{rendered}-{self.pid}" + self.manifest_path = os.path.abspath(DEVICE_MANIFEST) + self.lock_dir = os.path.abspath(lock_dir) + self.ipc_dir = os.path.join( + os.path.abspath(ipc_root), + f"ksq-gripper-{self.instance_id}", + ) + self.device_config_path = os.path.join( + self.runtime_dir, "fays_vikit_runtime.yaml" + ) + self.trajectory_path = os.path.join( + self.runtime_dir, "orb_trajectory.txt" + ) + self.assignment_path = os.path.join( + self.runtime_dir, "hardware_assignment.json" + ) + self.event_log_path = os.path.join( + self.runtime_dir, "fays_instance.log" + ) + self.native_log_path = os.path.join( + self.runtime_dir, "fays_native.log" + ) + self._discover_selected_devices = discover_selected_devices + self._discover_devices = ( + discover_devices or discover_fays_manifest_device_groups + ) + self._inspect_tty = inspect_tty + self._validate_link = validate_link + self._logger = logger + self._lock = threading.RLock() + self._lock_stream = None + self._selected = None + self._assignment = None + self._tty = None + os.makedirs(self.runtime_dir, exist_ok=True) + os.makedirs(self.lock_dir, mode=0o700, exist_ok=True) + os.makedirs(self.ipc_dir, mode=0o700, exist_ok=True) + self._clear_ipc_files() + self._event("instance_created") + + def ipc_path(self, leaf): + if str(leaf) not in _INSTANCE_IPC_FILES: + raise ValueError(f"unknown Fays IPC leaf: {leaf!r}") + return os.path.join(self.ipc_dir, str(leaf)) + + @property + def pose_paths(self): + return ( + self.ipc_path("orb_pose.json.tmp"), + self.ipc_path("orb_pose.json"), + ) + + @property + def frame_reader_paths(self): + return { + "meta_path": self.ipc_path("orb_meta.json"), + "current_frame_path": self.ipc_path( + "orb_current_frame.jpg" + ), + } + + @property + def control_paths(self): + return ( + self.ipc_path("orb_control.json.tmp"), + self.ipc_path("orb_control.json"), + ) + + @property + def raw_stream_socket_path(self): + return self.ipc_path("orb_raw_stream.sock") + + @property + def calibration_yaml_paths(self): + return ( + self.ipc_path("camera_calibration.yaml"), + self.ipc_path("imu.yaml"), + ) + + def runtime_environment(self, base=None): + environment = dict(base or {}) + environment.update({ + "KSQ_FAYS_IPC_DIR": self.ipc_dir, + "KSQ_FAYS_INSTANCE_ID": self.instance_id, + }) + assignment = self.snapshot() + if assignment: + calibration_serial = assignment.get("fays", {}).get( + "calibration_serial" + ) + if calibration_serial: + environment["KSQ_FAYS_CALIBRATION_SERIAL"] = str( + calibration_serial + ) + return environment + + def record_camera_set(self, topology): + """Append the selected USB2 camera topology to this instance log.""" + if topology is None: + return False + roles = {} + try: + for role in ("decxin", "left", "right"): + node = topology.node(role) + roles[role] = { + "device_path": node.device_path, + "physical_usb_path": node.physical_usb_path, + "vendor_id": node.vendor_id, + "product_id": node.product_id, + "serial": node.serial, + } + camera_set = { + "root_hub": topology.root_hub, + "tactile_hub": topology.tactile_hub, + "roles": roles, + } + except (AttributeError, KeyError) as exc: + raise FaysRuntimeError( + f"无法记录 USB2 相机套件拓扑: {exc}" + ) from exc + with self._lock: + if ( + self._assignment is None + or self._assignment.get("status") != "acquired" + or self._selected is None + or self._lock_stream is None + or self._lock_stream.closed + ): + return False + expected_root = ( + self._tty.get("root_hub") if self._tty else None + ) + # The schema-v2 selector already resolved the camera set from the + # ESP32 serial and the relative H0/H1 topology. ``root_hub`` is + # diagnostic only for this path, because a nested USB3 hub can + # legitimately put the cameras one level below the ESP root hub + # (e.g. ESP root 1-5 vs camera H0 1-5.2). + actual_root = str(camera_set["root_hub"] or "") + same_usb_branch = bool( + actual_root + and expected_root + and ( + actual_root == expected_root + or actual_root.startswith(f"{expected_root}.") + ) + ) + if expected_root and not same_usb_branch: + raise FaysRuntimeError( + "USB2 相机套件不属于当前 ESP32: " + f"expected={expected_root} " + f"actual={actual_root}" + ) + self._assignment["usb2_camera_set"] = camera_set + self._write_assignment() + self._event("camera_set_selected", camera_set=camera_set) + return True + + def set_preferred_tty(self, device_path): + with self._lock: + rendered = str(device_path or "").strip() + candidate = self._inspect_tty(rendered) if rendered else None + if self.is_acquired(): + previous = self._tty + self._tty = candidate + try: + group, _unit, _manifest = self._resolve_assignment() + except Exception: + self._tty = previous + raise + if ( + group["physical_usb_path"] + != self._selected["physical_usb_path"] + ): + self._tty = previous + raise FaysRuntimeError( + "当前 Fays 正在使用,不能切换到另一套 ESP32;" + "请先 Disconnect" + ) + else: + self._tty = candidate + self._event( + "control_port_selected", + tty=self._tty, + ) + return dict(self._tty) if self._tty else None + + def verify_preferred_tty(self, device_path): + """Recheck that a tty node still names the preflight ESP32.""" + with self._lock: + if self._tty is None: + raise FaysRuntimeError("尚未选择 ESP32 控制串口") + current = self._inspect_tty(device_path) + fields = ( + "vendor_id", + "product_id", + "serial", + "physical_usb_path", + "root_hub", + ) + differences = [ + name for name in fields + if current.get(name) != self._tty.get(name) + ] + if differences: + self._event( + "control_port_identity_changed", + expected=self._tty, + actual=current, + differences=differences, + ) + raise FaysRuntimeError( + "串口在 Connect 交接期间指向了另一设备: " + + ", ".join(differences) + ) + return dict(current) + + def is_acquired(self): + with self._lock: + return bool( + self._selected is not None + and self._lock_stream is not None + and not self._lock_stream.closed + and self._assignment is not None + and self._assignment.get("status") == "acquired" + ) + + def selected_ports(self): + with self._lock: + if self._selected is None: + raise FaysRuntimeError("当前界面尚未分配 Fays 设备") + return dict(self._selected["ports"]) + + def slam_profile(self, backend="orb"): + """Return the selected localization backend's runtime profile.""" + + with self._lock: + if self._selected is None: + raise FaysRuntimeError("当前界面尚未分配 Fays 设备") + selected = dict(self._selected) + calibration_serial = selected.get("calibration_serial") + normalized_backend = str(backend or "orb").strip().lower() + if normalized_backend == "orb": + serial = str(calibration_serial or "").strip() + if not serial: + raise FaysRuntimeError( + "设备清单缺少当前 Fays 标定序列号,拒绝启动 ORB-SLAM;" + "请先运行 device_setup" + ) + sdk_yaml = os.path.abspath( + os.fspath(selected.get("sdk_yaml") or "") + ) if selected.get("sdk_yaml") else "" + manifest_orb_yaml = os.path.abspath( + os.fspath(selected.get("orb_yaml") or "") + ) if selected.get("orb_yaml") else "" + missing_manifest = [ + label for label, path in ( + ("SDK YAML", sdk_yaml), + ("ORB YAML", manifest_orb_yaml), + ) + if not path or not os.path.isfile(path) + ] + if missing_manifest: + raise FaysRuntimeError( + "设备清单缺少当前 Fays 的运行文件,拒绝启动 ORB-SLAM: " + f"serial={serial} 缺少=" + + ", ".join(missing_manifest) + + ";请先运行 device_setup" + ) + for label, path in ( + ("SDK YAML", sdk_yaml), + ("ORB YAML", manifest_orb_yaml), + ): + if serial not in os.path.basename(path): + raise FaysRuntimeError( + "设备清单运行文件与当前 Fays 序列号不匹配," + "拒绝启动 ORB-SLAM: " + f"serial={serial} {label}={path}" + ) + executable = os.path.abspath( + os.fspath(selected.get("orb_binary") or "") + ) if selected.get("orb_binary") else "" + if not executable: + raise FaysRuntimeError( + "device_setup 设备清单缺少当前 Fays 的 ORB 程序," + "请先运行 device_setup" + ) + profile = { + "backend": "orb", + "calibration_serial": serial, + "executable": executable, + "settings": manifest_orb_yaml, + } + elif normalized_backend == "aikit": + profile = fays_aikit_profile( + calibration_serial, + selected.get("ports") or {}, + ) + else: + raise FaysRuntimeError( + f"未知定位后端: {backend!r}" + ) + missing = [ + path for path in ( + profile["executable"], profile["settings"] + ) + if not os.path.isfile(path) + ] + if missing: + raise FaysRuntimeError( + "Fays 标定运行时文件不存在: " + ", ".join(missing) + ) + if not os.access(profile["executable"], os.X_OK): + raise FaysRuntimeError( + f"Fays 定位文件不可执行: {profile['executable']}" + ) + return profile + + def snapshot(self): + with self._lock: + return ( + json.loads(json.dumps(self._assignment)) + if self._assignment is not None else None + ) + + def verify_active_link(self): + """Revalidate the selected Fays immediately before SDK startup.""" + with self._lock: + if not self.is_acquired(): + raise FaysRuntimeError("当前实例尚未持有 Fays 租约") + try: + group, _unit, _manifest = self._resolve_assignment() + speed = self._validate_link(group) + selected = self._selected + if selected["ports"] != group["ports"]: + selected = self.acquire() + else: + selected = dict(selected) + selected["usb_speed_mbps"] = speed + self._event( + "runtime_link_verified", + physical_usb_path=group["physical_usb_path"], + ports=group["ports"], + usb_speed_mbps=speed, + ) + return selected + except Exception as exc: + try: + self._event( + "runtime_link_failed", + error=str(exc), + selected=self._selected, + ) + except Exception: + pass + if isinstance(exc, FaysRuntimeError): + raise + raise FaysRuntimeError( + f"Fays 运行时链路校验失败: {exc}" + ) from exc + + def inspect(self): + """Resolve the manifest assignment without locking or opening Fays.""" + with self._lock: + group, unit, manifest = self._resolve_assignment() + result = dict(group) + result.update({ + "unit_id": unit["unit_id"], + "calibration_serial": unit.get("fays", {}).get( + "calibration_serial" + ) or result.get("product_serial"), + "mapping_source": result.get( + "mapping_source", + "device_setup_manifest_sdk_serial", + ), + "manifest_sha256": manifest["sha256"], + }) + return result + + def acquire(self): + with self._lock: + group, unit, manifest = self._resolve_assignment() + physical = group["physical_usb_path"] + lease_key = str( + group.get("product_serial") + or group.get("calibration_serial") + or physical + ) + sdk_template = str(group.get("sdk_yaml") or "").strip() + if not sdk_template: + raise FaysRuntimeError( + "device_setup 设备清单缺少当前 Fays 的 SDK YAML," + "请先运行 device_setup" + ) + if self.is_acquired(): + if self._selected["physical_usb_path"] != physical: + raise FaysRuntimeError( + "当前实例仍持有另一台 Fays;请先停止资源并释放租约" + ) + if self._selected["ports"] != group["ports"]: + materialize_fays_device_config( + group["ports"], + self.device_config_path, + sdk_template, + ) + refreshed = dict(group) + refreshed.update({ + key: self._selected[key] + for key in ( + "unit_id", + "calibration_serial", + "mapping_source", + "runtime_config", + "ipc_dir", + "trajectory", + "lock_path", + "usb_speed_mbps", + ) + }) + assignment = self._build_assignment( + refreshed, unit, manifest, "acquired" + ) + assignment["created_at"] = self._assignment[ + "created_at" + ] + if "usb2_camera_set" in self._assignment: + assignment["usb2_camera_set"] = self._assignment[ + "usb2_camera_set" + ] + self._write_assignment(assignment) + self._selected = refreshed + self._assignment = assignment + self._event( + "video_nodes_refreshed", + ports=group["ports"], + physical_usb_path=physical, + ) + return dict(self._selected) + self.release() + speed = self._validate_link(group) + lock_path = os.path.join( + self.lock_dir, + f"{re.sub(r'[^A-Za-z0-9_.-]+', '-', lease_key)}.lock", + ) + stream = open(lock_path, "a+", encoding="utf-8") + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError as exc: + stream.seek(0) + owner = stream.read().strip() or "unknown owner" + stream.close() + self._event( + "lease_busy", + unit_id=unit["unit_id"], + physical_usb_path=physical, + owner=owner, + ) + raise FaysRuntimeError( + f"Fays {physical} 已被另一界面占用: {owner}" + ) from exc + assignment = None + try: + owner = { + "pid": self.pid, + "run_id": self.run_id, + "instance_id": self.instance_id, + "unit_id": unit["unit_id"], + "physical_usb_path": physical, + } + stream.seek(0) + stream.truncate() + json.dump(owner, stream, ensure_ascii=False, sort_keys=True) + stream.flush() + os.fsync(stream.fileno()) + materialize_fays_device_config( + group["ports"], + self.device_config_path, + sdk_template, + ) + self._clear_ipc_files() + selected = dict(group) + selected.update({ + "unit_id": unit["unit_id"], + "calibration_serial": unit.get("fays", {}).get( + "calibration_serial" + ) or selected.get("product_serial"), + "product_serial": selected.get("product_serial"), + "sdk_yaml": selected.get("sdk_yaml"), + "orb_yaml": selected.get("orb_yaml"), + "orb_binary": selected.get("orb_binary"), + "decxin": unit.get("decxin"), + "sightac_left": unit.get("sightac_left"), + "sightac_right": unit.get("sightac_right"), + "mapping_source": selected.get( + "mapping_source", + "device_setup_manifest_sdk_serial", + ), + "runtime_config": self.device_config_path, + "ipc_dir": self.ipc_dir, + "trajectory": self.trajectory_path, + "lock_path": lock_path, + "usb_speed_mbps": speed, + }) + assignment = self._build_assignment( + selected, unit, manifest, "acquired" + ) + self._write_assignment(assignment) + self._event("lease_acquired", assignment=assignment) + try: + self._logger( + "[Fays-Instance] selected: " + f"unit={unit['unit_id']} " + f"esp={(self._tty or unit.get('esp32', {})).get('serial', '-')} " + f"fays={physical} " + f"stereo={group['ports']['stereo_dev_port']} " + f"imu={group['ports']['imu_dev_port']} " + f"ipc={self.ipc_dir}" + ) + except Exception: + pass + self._lock_stream = stream + self._selected = selected + self._assignment = assignment + return dict(selected) + except Exception as exc: + self._lock_stream = None + self._selected = None + self._assignment = None + try: + if assignment is not None: + assignment["status"] = "acquire_failed" + assignment["error"] = str(exc) + self._write_assignment(assignment) + self._event( + "lease_acquire_failed", + unit_id=unit["unit_id"], + physical_usb_path=physical, + error=str(exc), + ) + except Exception: + pass + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) + finally: + stream.close() + raise + + def release(self): + with self._lock: + stream = self._lock_stream + selected = self._selected + self._lock_stream = None + self._selected = None + if stream is not None: + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) + finally: + stream.close() + self._clear_ipc_files() + if self._assignment is not None: + self._assignment["status"] = "released" + self._assignment["released_at"] = time.time() + self._write_assignment() + if selected is not None: + self._event( + "lease_released", + unit_id=selected.get("unit_id"), + physical_usb_path=selected.get( + "physical_usb_path" + ), + ) + return True + + def _resolve_assignment(self): + """Resolve one selected ESP32 strictly through device_setup.""" + if self._tty is None: + raise FaysRuntimeError( + "尚未选择 ESP32 控制串口;设备身份只能由 device_setup " + "设备清单中的 ESP32 serial 确定" + ) + manifest = self._load_manifest() + matches = [ + unit for unit in manifest["units"] + if unit["esp32"]["vendor_id"] == self._tty["vendor_id"] + and unit["esp32"]["product_id"] == self._tty["product_id"] + and unit["esp32"]["serial"] == self._tty["serial"] + ] + if len(matches) != 1: + raise FaysRuntimeError( + "当前 ESP32 不在 device_setup 设备清单中,拒绝猜测 Fays 归属: " + f"serial={self._tty.get('serial', '')} " + f"matches={len(matches)} manifest={self.manifest_path}" + ) + unit = matches[0] + groups = tuple(self._discover_selected_devices(unit) + if self._discover_selected_devices is not None + else self._discover_devices()) + if not groups: + raise FaysRuntimeError("未发现所选 FaysSense S80M FT602") + product_serial = unit["fays"]["product_serial"] + group_matches = [ + group for group in groups + if str(group.get("manifest_unit") or "").strip() + == unit["unit_id"] + and str(group.get("product_serial") or "").strip() + == product_serial + ] + if len(group_matches) != 1: + available = ", ".join( + str(group.get("product_serial") or "") + for group in groups + ) + raise FaysRuntimeError( + "device_setup 设备清单与当前 Fays SDK 序列号无法唯一匹配: " + f"unit={unit['unit_id']} expected={product_serial} " + f"available={available}" + ) + selected = dict(group_matches[0]) + selected.update({ + "unit_id": unit["unit_id"], + "product_serial": product_serial, + "calibration_serial": product_serial, + "sdk_yaml": unit["fays"]["sdk_yaml"], + "orb_yaml": unit["fays"]["orb_yaml"], + "orb_binary": unit["fays"]["orb_binary"], + "mapping_source": "device_setup_manifest_sdk_serial", + }) + return selected, unit, manifest + + def _load_manifest(self): + from device_manifest_writer import load_device_manifest + + try: + manifest = load_device_manifest() + with open(self.manifest_path, "rb") as stream: + raw = stream.read() + except (OSError, RuntimeError) as exc: + raise FaysRuntimeError( + f"无法读取 device_setup 设备清单: {self.manifest_path}: {exc}" + ) from exc + manifest["sha256"] = hashlib.sha256(raw).hexdigest() + return manifest + + def _build_assignment(self, selected, unit, manifest, status): + return { + "schema_version": 1, + "status": status, + "created_at": time.time(), + "pid": self.pid, + "run_id": self.run_id, + "instance_id": self.instance_id, + "unit_id": unit["unit_id"], + "pairing_status": unit.get( + "pairing_status", "unspecified" + ), + "mapping_source": selected["mapping_source"], + "manifest": { + "path": self.manifest_path, + "sha256": manifest["sha256"], + }, + "esp32": dict(self._tty or unit.get("esp32", {})), + "decxin": selected.get("decxin"), + "sightac_left": selected.get("sightac_left"), + "sightac_right": selected.get("sightac_right"), + "fays": { + "calibration_serial": selected.get( + "calibration_serial" + ), + "product_serial": selected.get("product_serial"), + "sdk_yaml": selected.get("sdk_yaml"), + "orb_yaml": selected.get("orb_yaml"), + "orb_binary": selected.get("orb_binary"), + "physical_usb_path": selected["physical_usb_path"], + "stereo_dev_port": selected["ports"][ + "stereo_dev_port" + ], + "imu_dev_port": selected["ports"]["imu_dev_port"], + "stereo_interface": selected["stereo"].get( + "interface_number" + ), + "imu_interface": selected["imu"].get("interface_number"), + "usb_speed_mbps": selected["usb_speed_mbps"], + }, + "runtime": { + "device_config": self.device_config_path, + "ipc_dir": self.ipc_dir, + "trajectory": self.trajectory_path, + "work_dir": self.runtime_dir, + "lock_path": selected["lock_path"], + }, + } + + def _write_assignment(self, assignment=None): + assignment = self._assignment if assignment is None else assignment + if assignment is None: + return + temporary = f"{self.assignment_path}.tmp.{self.pid}" + with open(temporary, "w", encoding="utf-8") as stream: + json.dump( + assignment, + stream, + ensure_ascii=False, + indent=2, + sort_keys=True, + ) + stream.write("\n") + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, self.assignment_path) + + def _event(self, event, **payload): + record = { + "time": time.time(), + "event": str(event), + "pid": self.pid, + "run_id": self.run_id, + "instance_id": self.instance_id, + **payload, + } + with open(self.event_log_path, "a", encoding="utf-8") as stream: + stream.write(json.dumps( + record, ensure_ascii=False, sort_keys=True + )) + stream.write("\n") + + def _clear_ipc_files(self): + for leaf in _INSTANCE_IPC_FILES: + try: + os.unlink(os.path.join(self.ipc_dir, leaf)) + except FileNotFoundError: + pass + + +def build_fays_runtime_env(): + """构造生产 Fays/OpenCV 4.8/ORB-SLAM3 子进程环境。""" + env = os.environ.copy() + arch = os.uname().machine if hasattr(os, "uname") else "x86_64" + priority_dirs = [ + "/usr/local/lib", + os.path.join(FAYS_SDK_ROOT, f"lib/fays_atrak/{arch}/Release"), + os.path.join(FAYS_SDK_ROOT, f"thirdparty/ft602-linux-{arch}"), + os.path.dirname(ORB_LIBRARY), + os.path.join(ORB_ROOT, "lib"), + os.path.join(ORB_ROOT, "Thirdparty", "DBoW2", "lib"), + os.path.join(ORB_ROOT, "Thirdparty", "g2o", "lib"), + ] + + # 生产桥接程序只允许 OpenCV 4.8。继承环境中的 SDK 4.2 和旧 dist/lib + # 会让同一进程混装两个 OpenCV ABI,因此必须过滤。 + legacy_dist = os.path.abspath(os.path.join(PROJECT_ROOT, "dist", "lib")) + inherited_dirs = [] + for path in env.get("LD_LIBRARY_PATH", "").split(os.pathsep): + if not path: + continue + absolute = os.path.abspath(path) + if "opencv-4.2.0" in absolute or absolute == legacy_dist: + continue + inherited_dirs.append(absolute) + + ordered = [] + for path in priority_dirs + inherited_dirs: + if path not in ordered: + ordered.append(path) + env["LD_LIBRARY_PATH"] = os.pathsep.join(ordered) + + # 当前 ORB 核心直接链接系统 Boost 1.74。清除继承环境中人为预加载的 + # Boost serialization,避免另一 ABI 在系统 1.74 之前发生符号抢占;其余 + # 与 ORB 无关的预加载项保持不变。 + inherited_preloads = [ + path for path in re.split( + r"[\s:]+", env.get("LD_PRELOAD", "").strip() + ) + if path and "libboost_serialization.so" not in os.path.basename(path) + ] + if inherited_preloads: + env["LD_PRELOAD"] = " ".join(inherited_preloads) + else: + env.pop("LD_PRELOAD", None) + env["FAYS_SDK_ROOT"] = FAYS_SDK_ROOT + env["KSQ_ORB_ROOT"] = ORB_ROOT + return env + + +def build_fays_probe_env(): + """构造官方标定探针子进程环境(OpenCV 4.2 + fays_vikit + ft602)。 + + 探针二进制依赖 opencv-4.2(libopencv_imgproc/core.so.4.2),与桥接 + 进程的 OpenCV 4.8 环境必须隔离;探针环境不过滤 opencv-4.2,也不含 + orb48_env/ORB-SLAM 目录。 + """ + env = os.environ.copy() + arch = os.uname().machine if hasattr(os, "uname") else "x86_64" + priority_dirs = [ + "/usr/local/lib", + os.path.join(FAYS_SDK_ROOT, f"lib/fays_atrak/{arch}/Release"), + os.path.join(FAYS_SDK_ROOT, f"thirdparty/ft602-linux-{arch}"), + os.path.join(FAYS_SDK_ROOT, + f"thirdparty/opencv-4.2.0-linux-{arch}/lib"), + # opencv-4.2 的传递依赖(libtbb.so.2 等)只存在于 orb48_env; + # 排在 opencv-4.2 之后,4.2 同名 soname 优先命中 + os.path.join(FAYS_SDK_ROOT, "thirdparty", "orb48_env", "lib"), + ] + inherited_dirs = [ + os.path.abspath(path) + for path in env.get("LD_LIBRARY_PATH", "").split(os.pathsep) + if path + ] + ordered = [] + for path in priority_dirs + inherited_dirs: + if path not in ordered: + ordered.append(path) + env["LD_LIBRARY_PATH"] = os.pathsep.join(ordered) + env["FAYS_SDK_ROOT"] = FAYS_SDK_ROOT + return env + + +def validate_fays_runtime(): + """校验启动所需静态文件;不要求相机当前已插入。""" + from device_manifest_writer import load_device_manifest + + required_files = { + "Fays ORB 可执行文件": FAYS_ORB_BINARY, + "设备清单": DEVICE_MANIFEST, + "ORB 词典": ORB_VOCABULARY, + "ORB-SLAM3 核心库": ORB_LIBRARY, + } + try: + manifest = load_device_manifest() + except RuntimeError as exc: + raise FaysRuntimeError(str(exc)) from exc + for unit in manifest["units"]: + fays = unit["fays"] + prefix = f"{unit['unit_id']} ({fays['product_serial']})" + required_files[f"{prefix} SDK YAML"] = fays["sdk_yaml"] + required_files[f"{prefix} ORB YAML"] = fays["orb_yaml"] + required_files[f"{prefix} ORB 程序"] = fays["orb_binary"] + errors = [ + f"{label}不存在: {path}" + for label, path in required_files.items() + if not os.path.isfile(path) + ] + if os.path.isfile(FAYS_ORB_BINARY) and not os.access(FAYS_ORB_BINARY, os.X_OK): + errors.append(f"Fays ORB 文件不可执行: {FAYS_ORB_BINARY}") + if errors: + raise FaysRuntimeError("Fays 运行时检查失败:\n- " + "\n- ".join(errors)) + return required_files + + +def main(): + """执行不打开相机、不复位 USB 的 Fays 运行时与设备预检。""" + try: + required = validate_fays_runtime() + groups = discover_fays_manifest_device_groups() + verified = [] + for group in groups: + speed = validate_fays_sdk_access(group) + verified.append((group, speed, fays_usb_control_node(group))) + except FaysRuntimeError as exc: + print(f"[FAYS-PREFLIGHT] FAILED\n{exc}") + return 1 + + print(f"[FAYS-PREFLIGHT] OK: {SUPPORTED_CAMERA}") + for label, path in required.items(): + print(f" {label}: {path}") + for group, usb_speed, control_node in verified: + print( + f" unit={group['unit_id']} serial={group['product_serial']} " + f"physical={group['physical_usb_path']}" + ) + for role in ("stereo", "imu"): + info = group[role] + print( + f" {role}: {info['device']} " + f"interface={info['interface_number']} " + f"index={info['stream_index']}" + ) + print(f" Fays USB link: {usb_speed:g}M SuperSpeed") + print(f" Fays D3XX control: {control_node} read/write OK") + print(" Hardware access: sysfs read-only; no VideoCapture; no USB reset") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/collector/core/gripper/fays_serial_probe.py b/collector/core/gripper/fays_serial_probe.py new file mode 100644 index 0000000000000000000000000000000000000000..533b1bcbf93e9fef55beb1a9f05ca9f3f4802193 --- /dev/null +++ b/collector/core/gripper/fays_serial_probe.py @@ -0,0 +1,246 @@ +"""Read a Fays S80M product serial through the official VI Kit SDK. + +The FT602 USB bridge has duplicate USB descriptor data, so the only reliable +product identifier is ``ViKitDeviceInfo.serial_number``. This module wraps +the existing calibration-probe executable and returns that serial without +opening a video stream or touching USB state. +""" + +from __future__ import annotations + +import os +import re +import subprocess +import tempfile +from core.gripper.runtime.device_access import device_access_guard, FAYS_SDK_INITIALIZATION_LOCK, fays_device_guard +from typing import Mapping, Optional + +from core.gripper.fays_runtime import ( + FAYS_DEVICE_CONFIG, + GRIPPER_DIR, + PROJECT_ROOT, + discover_fays_device_groups, + read_fays_config_ports, +) + + +DEFAULT_PROBE_BINARY = os.path.abspath(os.environ.get( + "KSQ_FAYS_CALIBRATION_PROBE", + os.path.join( + PROJECT_ROOT, "dist", "fays_aikit", "bin", + "fays_vikit_calibration_probe", + ), +)) +DEFAULT_TEMPLATE = FAYS_DEVICE_CONFIG +_SERIAL_LINE = re.compile(r"^device\.serial=(.+)$", re.MULTILINE) + +# Temporary probes share the SDK initialization guard with the native launcher. +# A separate per-device lease prevents probes of an already streaming device. + + +def render_probe_config( + ports: Mapping[str, str], + destination: str, + *, + template_path: Optional[str] = None, +): + """Render one candidate SDK YAML from the canonical template.""" + template = os.path.abspath(template_path or DEFAULT_TEMPLATE) + try: + with open(template, encoding="utf-8") as stream: + content = stream.read() + except OSError as exc: + raise RuntimeError(f"无法读取 Fays 配置模板: {template}: {exc}") from exc + for key in ("stereo_dev_port", "imu_dev_port"): + value = str(ports.get(key, "")).strip() + if not value: + raise RuntimeError(f"缺少 Fays 端口字段: {key}") + content, count = re.subn( + rf"^(\s*{re.escape(key)}\s*:)\s*[^\s#]+", + rf"\1 {value}", + content, + count=1, + flags=re.MULTILINE, + ) + if count != 1: + raise RuntimeError(f"Fays 配置模板无法定位字段: {key}") + temporary = f"{destination}.tmp.{os.getpid()}" + try: + with open(temporary, "w", encoding="utf-8") as stream: + stream.write(content) + stream.flush() + os.fsync(stream.fileno()) + os.replace(temporary, destination) + except OSError as exc: + try: + os.unlink(temporary) + except OSError: + pass + raise RuntimeError(f"写入探测配置失败: {destination}: {exc}") from exc + return destination + + +def probe_product_serial( + ports: Mapping[str, str], + *, + template_path: Optional[str] = None, + probe_binary: Optional[str] = None, + timeout: float = 60.0, + environment: Optional[Mapping[str, str]] = None, +) -> str: + """Run the official calibration probe and return ``device.serial``. + + timeout 同时是 SDK 全局初始化锁的等待上限与子进程运行上限:双夹爪 + 并发打开时,第二台的探针要等第一台 SLAM 初始化(最长 45s)释放锁, + 20s 会在等待期间误报超时,故放宽到 60s。 + """ + executable = os.path.abspath(probe_binary or DEFAULT_PROBE_BINARY) + if not os.path.isfile(executable): + raise RuntimeError(f"Fays 标定探测程序不存在: {executable}") + if not os.access(executable, os.X_OK): + raise RuntimeError(f"Fays 标定探测程序不可执行: {executable}") + with tempfile.TemporaryDirectory(prefix="ksq-fays-probe-") as temp_dir: + config_path = render_probe_config( + ports, + os.path.join(temp_dir, "fays_vikit_probe.yaml"), + template_path=template_path, + ) + try: + # The thread lock covers two slots in this process; flock also + # protects against a second application instance probing through + # the same vendor SDK at the same time. This is synchronization + # only: identity still comes exclusively from the live SDK result + # and the device_setup manifest below. + with device_access_guard(FAYS_SDK_INITIALIZATION_LOCK, timeout=timeout), \ + fays_device_guard(ports["stereo_dev_port"]): + completed = subprocess.run( + [executable, config_path], capture_output=True, text=True, + timeout=timeout, + env=dict(os.environ if environment is None else environment), + check=False, + ) + except subprocess.TimeoutExpired as exc: + raise RuntimeError( + f"Fays 标定探测超时: {ports} ({exc.timeout}s)" + ) from exc + output = ( + (completed.stdout or "") + "\n" + (completed.stderr or "") + ) + if completed.returncode != 0: + tail = "\n".join( + line for line in output.splitlines()[-20:] + ) + raise RuntimeError( + "Fays 标定探测失败: " + f"returncode={completed.returncode} ports={ports}\n{tail}" + ) + match = _SERIAL_LINE.search(output) + if match is None: + raise RuntimeError( + f"Fays 标定探测未返回 device.serial: ports={ports}" + ) + serial = match.group(1).strip() + if not serial: + raise RuntimeError( + f"Fays 标定探测返回空序列号: ports={ports}" + ) + return serial + + +def discover_fays_manifest_groups( + *, + target_unit=None, + probe_binary: Optional[str] = None, + timeout: float = 60.0, + environment: Optional[Mapping[str, str]] = None, + logger=None, +): + """Resolve native Fays groups strictly through the device_setup manifest. + + Setup may probe every visible group. Connect supplies target_unit, limits + access to its configured nodes, then verifies the live SDK product serial. + Other rigs are never probed as a fallback for a missing selected device. + Probe failure, an unknown serial, or missing manifest runtime artifacts is + fatal. YAML ports, old pair files, cached assignments and unique-group + fallbacks are deliberately not accepted as identity sources. + """ + from device_manifest_writer import load_device_manifest + + groups = tuple(discover_fays_device_groups()) + manifest = load_device_manifest() + units = tuple(manifest["units"]) + units_by_serial = { + str(unit["fays"]["product_serial"]).strip(): unit + for unit in units + } + if target_unit is not None: + # Physical position only limits access; identity still MUST come from + # this live SDK probe and match the manifest serial below. + expected = str(target_unit["fays"]["product_serial"]) + ports = read_fays_config_ports(target_unit["fays"]["sdk_yaml"]) + groups = tuple(g for g in groups if g["ports"] == ports) + if len(groups) != 1: + raise RuntimeError("所选 Fays 节点已变化,请重建设备清单;禁止探测其他夹爪") + if expected not in units_by_serial: + raise RuntimeError("所选 Fays 不在当前设备清单中") + resolved = [] + probed_serials = set() + for group in groups: + try: + serial = probe_product_serial( + group["ports"], + template_path=None, + probe_binary=probe_binary, + timeout=timeout, + environment=environment, + ) + except Exception as exc: + raise RuntimeError( + "Fays SDK 产品序列号探测失败,拒绝使用设备清单外的回退: " + f"physical={group['physical_usb_path']} error={exc}" + ) from exc + if target_unit is not None and serial != expected: + raise RuntimeError(f"所选 Fays SDK 序列号不匹配: expected={expected} actual={serial}") + if serial in probed_serials: + raise RuntimeError( + "Fays SDK 返回重复产品序列号,拒绝猜测归属: " + f"serial={serial}" + ) + probed_serials.add(serial) + unit = units_by_serial.get(serial) + if unit is None: + raise RuntimeError( + "当前 Fays 不在 device_setup 设备清单中,拒绝启动: " + f"serial={serial} physical={group['physical_usb_path']}" + ) + fays = unit["fays"] + required = ("sdk_yaml", "orb_yaml", "orb_binary") + missing = [ + key for key in required + if not fays.get(key) or not os.path.isfile(fays[key]) + ] + if missing: + raise RuntimeError( + "device_setup 设备清单缺少 Fays 运行资源: " + f"unit={unit['unit_id']} missing={','.join(missing)}" + ) + annotated = dict(group) + annotated.update({ + "unit_id": unit["unit_id"], + "product_serial": serial, + "calibration_serial": serial, + "sdk_yaml": fays["sdk_yaml"], + "orb_yaml": fays["orb_yaml"], + "orb_binary": fays["orb_binary"], + "mapping_source": "device_setup_manifest_sdk_serial", + "manifest_esp32": dict(unit["esp32"]), + "manifest_unit": unit["unit_id"], + }) + resolved.append(annotated) + + if len(resolved) != len(groups): + raise RuntimeError( + "Fays 设备清单与当前硬件数量不一致,拒绝继续: " + f"manifest={len(units)} visible={len(groups)} matched={len(resolved)}" + ) + return tuple(resolved) diff --git a/collector/core/gripper/fays_single.py b/collector/core/gripper/fays_single.py new file mode 100644 index 0000000000000000000000000000000000000000..9894359ec5dba522f24c2d3443ea7c25fdcebdae --- /dev/null +++ b/collector/core/gripper/fays_single.py @@ -0,0 +1,334 @@ +"""单夹爪场景的 Fays S80M 租约(无 device_setup 清单版本)。 + +主程序一次只服务一套夹爪 rig,设备身份全部来自运行时探测: + 1. ESP32 串口(VID/PID + USB serial)唯一匹配; + 2. discover_fays_device_groups() 发现且仅发现一台完整 S80M; + 3. USB 链路速度 >= FAYS_MIN_USB_SPEED_MBPS,否则拒绝(提示换 USB3 口); + 4. probe_product_serial() 通过官方 SDK 探针读取真实产品序列号; + 5. 按序列号定位 fays_config/fays_vikit_{serial}.yaml 与 + dist/fays_opencv48/s80m_{serial}_stereo_inertial.yaml; + 6. flock 租约 /tmp/ksq-gripper-fays-locks/{serial}.lock 防多开; + 7. materialize 当前端口的运行时 SDK yaml,并在 /dev/shm 建 IPC 目录。 + +返回的 selected 字典携带 SlamProcessController 与相机服务组合所需字段 +(ports/runtime_config/ipc_dir/trajectory/settings/executable/...)。 +""" + +from __future__ import annotations + +import fcntl +import json +import os +import re +import shutil +import tempfile +import threading +import time + +from core.gripper import paths +from core.gripper.fays_runtime import ( + FAYS_MIN_USB_SPEED_MBPS, + build_fays_probe_env, + build_fays_runtime_env, + discover_esp32_devices, + discover_fays_device_groups, + materialize_fays_device_config, + validate_fays_sdk_access, +) +from core.gripper.fays_serial_probe import probe_product_serial + +_INSTANCE_IPC_FILES = ( + "orb_pose.json.tmp", "orb_pose.json", "orb_meta.json", + "orb_current_frame.jpg", "orb_control.json.tmp", "orb_control.json", + "orb_raw_stream.sock", "camera_calibration.yaml", "imu.yaml", +) + + +class GripperFaysError(RuntimeError): + """夹爪 Fays 租约失败(设备缺失、速度不足、标定缺失、被占用)。""" + + +class SingleFaysLease: + """一次打开夹爪的 Fays 租约;release() 幂等。""" + + def __init__(self, *, logger=print): + self._logger = logger + self._lock = threading.RLock() + self._stream = None + self._selected = None + self._runtime_dir = None + self._ipc_dir = None + self._lock_path = None + + @property + def ipc_dir(self): + return self._ipc_dir + + @property + def runtime_config_path(self): + if self._selected is None: + raise GripperFaysError("Fays 租约尚未持有") + return self._selected["runtime_config"] + + def is_acquired(self): + with self._lock: + return bool( + self._selected is not None + and self._stream is not None + and not self._stream.closed + ) + + def _match_esp(self, esp_serial): + """按 USB serial 唯一匹配 ESP32 控制板,返回其 tty 设备路径。""" + devices = discover_esp32_devices() + matches = [ + info for info in devices + if str(info.get("serial") or "").strip() == str(esp_serial).strip() + ] + if len(matches) != 1: + available = ", ".join( + str(info.get("serial") or "") for info in devices + ) + raise GripperFaysError( + "ESP32 控制板未唯一匹配: 期望 serial={} 当前=[{}]".format( + esp_serial, available) + ) + return matches[0] + + def _discover_unique_fays_group(self, esp): + """按 ESP 的根端口关联 rig 内的 S80M,要求唯一命中。 + + Fays 是 USB3/FT602:插在 USB3 口时走 5000M 伴生总线,与 ESP/ + 触觉相机的 480M 总线 bus 号不同(如 ESP=7-2、Fays=8-2 是同一 + 物理口的双总线伴生),因此原程序的拓扑规则只按根端口关联 + (见 uvc_camera_service._associate_group 的同名注释)。 + 同一台机器可能还插着主程序自己的独立 S80M(不同根端口), + 必须按夹爪 rig 的拓扑范围区分,不能全机枚举;多台命中即报错 + 不猜归属。rig 内仍只允许 1 台完整 S80M。 + 多控制器机器(双夹爪)还必须带控制器身份比较:两套 rig 可能 + 都插在各自控制器的同号根端口上(实测都是根端口 2,控制器 + 0000:0a:00.0 与 0000:74:00.4),只比端口号会互相误配。 + """ + esp_controller, esp_root = self._bus_root( + str(esp.get("physical_usb_path") or "")) + if not esp_controller or not esp_root: + raise GripperFaysError( + "ESP32 物理 USB 路径无效: {!r}".format( + esp.get("physical_usb_path"))) + groups = tuple(discover_fays_device_groups()) + same_rig = [ + group for group in groups + if self._bus_root(group["physical_usb_path"]) + == (esp_controller, esp_root) + ] + if len(same_rig) != 1: + found = ", ".join( + str(g["physical_usb_path"]) for g in same_rig) + raise GripperFaysError( + "夹爪 rig(控制器 {} 根端口 {})内发现 {} 台 Fays S80M," + "只允许 1 台: [{}]".format( + esp_controller, esp_root, len(same_rig), found)) + return same_rig[0] + + @staticmethod + def _bus_root(physical): + """"1-3.4.1" → (controller, "3")。 + + controller 取 /sys/bus/usb/devices/usb{bus} 的 realpath 父路径 + (usbN 节点之上的 PCI devpath,如 .../0000:0a:00.0)——多控制器 + 机器上不同控制器的同号根端口必须区分;USB2/USB3 伴生双总线 + (同一物理口 ESP=7-2、Fays=8-2)仍只按控制器+根端口关联, + 不比较总线号,伴生容忍不变。 + """ + bus, separator, ports = str(physical or "").partition("-") + root = ports.split(".")[0] if separator else "" + if not separator: + return "", "" + try: + real = os.path.realpath( + os.path.join("/sys", "bus", "usb", "devices", f"usb{bus}")) + except OSError: + return f"bus-{bus}", root # sysfs 不可读时退回总线区分 + return os.path.dirname(real), root + + def _probe_serial(self, group): + """官方 SDK 探针读取产品序列号;USB 速度不足时给出换口提示。""" + try: + speed = validate_fays_sdk_access(group) + except Exception as exc: + raise GripperFaysError( + f"Fays USB 链路校验失败(疑似插在 USB2 口," + f"SuperSpeed 需 >= {FAYS_MIN_USB_SPEED_MBPS:g}M): {exc}" + ) from exc + if speed < FAYS_MIN_USB_SPEED_MBPS: + raise GripperFaysError( + "Fays USB 链路速度 {:.0f}M,低于 {:.0f}M SuperSpeed 要求;" + "请把夹爪 USB3 接头插到电脑的 USB3 口后重试".format( + speed, FAYS_MIN_USB_SPEED_MBPS) + ) + try: + serial = probe_product_serial( + group["ports"], + environment=build_fays_probe_env(), + ) + except Exception as exc: + raise GripperFaysError( + f"Fays SDK 产品序列号探测失败: {exc}" + ) from exc + return serial, speed + + def acquire(self, esp_serial): + """锁定并返回 selected 字典;重复调用返回当前租约快照。""" + with self._lock: + if self.is_acquired(): + return dict(self._selected) + self.release() + esp = self._match_esp(esp_serial) + group = self._discover_unique_fays_group(esp) + serial, speed = self._probe_serial(group) + sdk_yaml, orb_yaml = paths.per_device_fays_yamls(serial) + + os.makedirs(paths.FAYS_LOCK_DIR, mode=0o700, exist_ok=True) + lease_key = re.sub(r"[^A-Za-z0-9_.-]+", "-", serial) + lock_path = os.path.join( + paths.FAYS_LOCK_DIR, f"{lease_key}.lock", + ) + stream = open(lock_path, "a+", encoding="utf-8") + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError as exc: + stream.seek(0) + owner = stream.read().strip() or "unknown owner" + stream.close() + raise GripperFaysError( + f"Fays {serial} 已被另一进程占用: {owner}" + ) from exc + + runtime_dir = tempfile.mkdtemp(prefix="ksq-gripper-fays-") + # 双夹爪同进程各持一份租约:IPC 目录必须含租约身份(序列号), + # 否则第二台撞 orb_raw_stream.sock/orb_pose.json 导致 SLAM + # 初始化失败,且一方 release() 会连带删掉另一方的 IPC 文件。 + instance_id = f"{lease_key}-{os.getpid()}" + ipc_dir = os.path.join("/dev/shm", f"ksq-gripper-{instance_id}") + os.makedirs(ipc_dir, mode=0o700, exist_ok=True) + try: + owner = { + "pid": os.getpid(), + "run_id": "collector-main", + "instance_id": instance_id, + "esp_serial": str(esp["serial"]), + "fays_serial": serial, + "physical_usb_path": group["physical_usb_path"], + } + stream.seek(0) + stream.truncate() + json.dump(owner, stream, ensure_ascii=False, sort_keys=True) + stream.flush() + os.fsync(stream.fileno()) + runtime_config = materialize_fays_device_config( + group["ports"], + os.path.join(runtime_dir, "fays_vikit_runtime.yaml"), + sdk_yaml, + ) + selected = dict(group) + selected.update({ + "unit_id": f"gripper_{serial[-4:]}", + "esp_serial": str(esp["serial"]), + "product_serial": serial, + "calibration_serial": serial, + "mapping_source": "runtime_probe_sdk_serial", + "sdk_yaml": sdk_yaml, + "orb_yaml": orb_yaml, + "orb_binary": paths.FAYS_MARK_ONLY_BINARY, + "runtime_config": runtime_config, + "ipc_dir": ipc_dir, + "trajectory": os.path.join( + runtime_dir, "orb_trajectory.txt", + ), + "work_dir": runtime_dir, + "lock_path": lock_path, + "usb_speed_mbps": speed, + "esp_tty": str(esp["device"]), + }) + self._stream = stream + self._selected = selected + self._runtime_dir = runtime_dir + self._ipc_dir = ipc_dir + self._lock_path = lock_path + self._logger( + "[Gripper-Fays] 租约已锁定: serial={} " + "stereo={} imu={} speed={:g}M ipc={}".format( + serial, + group["ports"]["stereo_dev_port"], + group["ports"]["imu_dev_port"], + speed, ipc_dir, + ) + ) + return dict(selected) + except Exception: + try: + shutil.rmtree(runtime_dir, ignore_errors=True) + except Exception: + pass + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) + finally: + stream.close() + raise + + def resolve_assignment(self, esp_serial): + """相机服务所需的身份 assignment(不探测、不锁租约、不校验速度)。 + + UvcCameraServiceManager 只把 fays identity 用作同根端口关联与 + 错误文案,从不打开 Fays 相机;此处用实时拓扑推导的物理路径即可, + S80M 的官方 SDK 串行探测留给 acquire()(P3 全链,含 USB3 校验)。 + """ + esp = self._match_esp(esp_serial) + group = self._discover_unique_fays_group(esp) + return { + "esp32": {"serial": str(esp["serial"])}, + "fays": { + "product_serial": "runtime-unprobed", + "physical_usb_path": group["physical_usb_path"], + }, + } + + def snapshot(self): + with self._lock: + return ( + json.loads(json.dumps(self._selected)) + if self._selected is not None else None + ) + + def release(self): + with self._lock: + stream, selected = self._stream, self._selected + self._stream = None + self._selected = None + if stream is not None: + try: + fcntl.flock(stream.fileno(), fcntl.LOCK_UN) + finally: + stream.close() + if self._ipc_dir: + for leaf in _INSTANCE_IPC_FILES: + try: + os.unlink(os.path.join(self._ipc_dir, leaf)) + except FileNotFoundError: + pass + try: + os.rmdir(self._ipc_dir) + except OSError: + pass + self._ipc_dir = None + if self._runtime_dir: + shutil.rmtree(self._runtime_dir, ignore_errors=True) + self._runtime_dir = None + if selected is not None: + self._logger( + "[Gripper-Fays] 租约已释放: serial={}".format( + selected.get("product_serial") + ) + ) + self._lock_path = None + return True diff --git a/collector/core/gripper/paths.py b/collector/core/gripper/paths.py new file mode 100644 index 0000000000000000000000000000000000000000..048ad1ef7ad8eb1cf240ae82348b70a5977318bd --- /dev/null +++ b/collector/core/gripper/paths.py @@ -0,0 +1,164 @@ +"""core/gripper 包的原生资源路径与运行时常量补丁。 + +夹爪 Python 代码与原生资源全部随本包交付(有意从 online/gripper_version1 +分叉):原生二进制、官方 SDK、标定文件与 orb48_env 都镜像在 +core/gripper/native/ 下(布局与 online/ 一致,保持 $ORIGIN 相对 RUNPATH +可解析);触觉 Sightac SDK 单独放在 core/gripper/sightac_sdk/(pyarmor +加密后随包入库)。主程序不再依赖 online/ 树。本模块是唯一路径解析点。 + +主程序导入 core.gripper 时由 __init__ 执行 patch_fays_runtime_constants(), +把 fays_runtime 的 PROJECT_ROOT/GRIPPER_DIR 等常量改指到 native/ 下,并向 +build_fays_runtime_env 注入 orb48_env(与 1234 启动脚本的顺序一致)。 +""" + +from __future__ import annotations + +import os + +# 采集器仓库根(core/gripper/paths.py 的上三级)。 +COLLECTOR_ROOT = os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__)))) +PACKAGE_ROOT = os.path.dirname(os.path.abspath(__file__)) + +NATIVE_ROOT = os.path.abspath(os.environ.get( + "KSQ_GRIPPER_NATIVE_ROOT", + os.path.join(PACKAGE_ROOT, "native"), +)) +GRIPPER_DIR = os.path.join(NATIVE_ROOT, "gripper_version1") +FAYS_SDK_ROOT = os.path.join(NATIVE_ROOT, "FaysSense_VI_Kit_Release") +ORB_ROOT = os.path.join(NATIVE_ROOT, "ORB-SLAM") +DIST_ROOT = os.path.join(NATIVE_ROOT, "dist") +ORB48_ENV_DIR = os.path.join(FAYS_SDK_ROOT, "thirdparty", "orb48_env") + +FAYS_MARK_ONLY_BINARY = os.path.join( + DIST_ROOT, "fays_opencv48", "bin", + "fayssense_orb_slam_sn219_opencv48_mark_only", +) +FAYS_CALIBRATION_PROBE = os.path.join( + DIST_ROOT, "fays_aikit", "bin", "fays_vikit_calibration_probe", +) +ORB_LIBRARY = os.path.join( + DIST_ROOT, "orb_mark_only", "lib", "libORB_SLAM3.so", +) +ORB_VOCABULARY = os.path.join(NATIVE_ROOT, "ORBvoc.txt") +CAMERA_SERVICE_DIR = os.path.join(NATIVE_ROOT, "camera_service") +CAMERA_SERVICE_BINARY = os.path.join( + CAMERA_SERVICE_DIR, "build", "ksq-camera-service", +) +DISCOVER_UVC_CONFIG_BINARY = os.path.join( + CAMERA_SERVICE_DIR, "build", "discover-uvc-config", +) +SIGHTAC_SDK_ROOT = os.path.abspath(os.environ.get( + "KSQ_SIGHTAC_ROOT", + os.path.join(PACKAGE_ROOT, "sightac_sdk"), +)) +FAYS_CONFIG_DIR = os.path.join(GRIPPER_DIR, "fays_config") +ORB_DEVICE_CONFIG_DIR = os.path.join(DIST_ROOT, "fays_opencv48") +FAYS_LOCK_DIR = "/tmp/ksq-gripper-fays-locks" + + +def required_resources(): + """资源校验表:路径 -> 是否需要可执行位。全部就绪夹爪才对外可见。""" + return { + "Fays ORB 桥接": (FAYS_MARK_ONLY_BINARY, True), + "Fays 标定探测": (FAYS_CALIBRATION_PROBE, True), + "ORB-SLAM3 核心库": (ORB_LIBRARY, False), + "ORB 词典": (ORB_VOCABULARY, False), + "libuvc 相机服务": (CAMERA_SERVICE_BINARY, True), + "Sightac SDK": (os.path.join(SIGHTAC_SDK_ROOT, "api_new"), False), + "Fays SDK lib": (os.path.join(FAYS_SDK_ROOT, "lib"), False), + } + + +def gripper_resources_available(): + """全部原生资源就绪才允许夹爪设备出现在主程序设备列表中。""" + for path, executable in required_resources().values(): + if not os.path.exists(path): + return False + if executable and not os.access(path, os.X_OK): + return False + return True + + +def per_device_fays_yamls(serial): + """按 SDK 探测序列号定位这台 Fays 的 SDK 模板与 ORB 标定 yaml。""" + serial = str(serial or "").strip() + if not serial: + raise RuntimeError("Fays 序列号为空,无法定位设备标定") + sdk_yaml = os.path.join(FAYS_CONFIG_DIR, f"fays_vikit_{serial}.yaml") + orb_yaml = os.path.join( + ORB_DEVICE_CONFIG_DIR, f"s80m_{serial}_stereo_inertial.yaml", + ) + missing = [ + label for label, path in ( + ("SDK YAML", sdk_yaml), ("ORB YAML", orb_yaml), + ) + if not os.path.isfile(path) + ] + if missing: + raise RuntimeError( + "当前 Fays 缺少运行标定文件: serial={} 缺少={};" + "请先在夹爪上位机中运行 device_setup".format( + serial, ",".join(missing)) + ) + return sdk_yaml, orb_yaml + + +def patch_fays_runtime_constants(): + """把 fays_runtime 模块常量改指到 native/ 树,并注入 orb48_env。 + + 必须在任何 `from core.gripper.fays_runtime import <常量>` 之前调用—— + core/gripper/__init__.py 在包导入时最先执行,顺序天然保证。 + """ + from core.gripper import fays_runtime as runtime + + runtime.GRIPPER_DIR = GRIPPER_DIR + runtime.PROJECT_ROOT = NATIVE_ROOT + runtime.FAYS_SDK_ROOT = FAYS_SDK_ROOT + runtime.ORB_ROOT = ORB_ROOT + runtime.FAYS_MARK_ONLY_BINARY = FAYS_MARK_ONLY_BINARY + runtime.FAYS_ORB_BINARY = FAYS_MARK_ONLY_BINARY + runtime.ORB_VOCABULARY = ORB_VOCABULARY + runtime.ORB_LIBRARY = ORB_LIBRARY + # 派生常量在 fays_runtime 导入时已按旧根计算,必须逐一改写。 + runtime.FAYS_DEVICE_CONFIG = os.path.join( + FAYS_SDK_ROOT, "config", "fays_vikit_s80m.yaml") + runtime.DEVICE_MANIFEST = os.path.join( + GRIPPER_DIR, "device_manifest.json") + runtime.ORB_WORK_DIR = os.path.join( + NATIVE_ROOT, "ORB-SLAM", "Examples", "fays") + runtime.ORB_TRAJECTORY = os.path.join( + NATIVE_ROOT, "ORB-SLAM", "traj.txt") + runtime.AIKIT_BRIDGE_BINARY = os.path.join( + DIST_ROOT, "fays_aikit", "bin", "fays_aikit_slam_bridge") + runtime.AIKIT_CLIENT_LIBRARY_DIR = os.path.join( + DIST_ROOT, "fays_aikit", "lib") + runtime.AIKIT_CLIENT_CONFIG = os.path.join( + DIST_ROOT, "fays_aikit", "config", "active_tracker_client.yaml") + runtime.AIKIT_FACTORY_CALIBRATION_DIR = os.path.join( + NATIVE_ROOT, "config", "calibration") + + _original_build_env = runtime.build_fays_runtime_env + + def build_fays_runtime_env(): + environment = _original_build_env() + orb48_lib = os.path.join(ORB48_ENV_DIR, "lib") + if not os.path.isdir(orb48_lib): + return environment + # 原版优先目录缺少 orb48_env(opencv4.8/pangolin 等桥接依赖)。 + # 按 1234 启动脚本的固定顺序插在 ft602 之后、ORB 库之前。 + parts = [ + part for part in + environment.get("LD_LIBRARY_PATH", "").split(os.pathsep) + if part + ] + insert_at = len(parts) + for index, part in enumerate(parts): + if os.path.basename(part).startswith("ft602-linux"): + insert_at = index + 1 + break + parts.insert(insert_at, orb48_lib) + environment["LD_LIBRARY_PATH"] = os.pathsep.join(parts) + return environment + + runtime.build_fays_runtime_env = build_fays_runtime_env diff --git a/collector/core/gripper/recording/__init__.py b/collector/core/gripper/recording/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..bcd06d96563defdb362ae57226fde87844642172 --- /dev/null +++ b/collector/core/gripper/recording/__init__.py @@ -0,0 +1,7 @@ +"""core.gripper 录制子集:只保留 raw 双目/IMU 流客户端。 + +原版 barrel 引用的 controller/dataset_index/episode_writer/lerobot_v3/ +quality/session 未复制;主程序录制走 core/egodata_writer.py。 +""" + +from __future__ import annotations diff --git a/collector/core/gripper/recording/fays_raw_client.py b/collector/core/gripper/recording/fays_raw_client.py new file mode 100644 index 0000000000000000000000000000000000000000..ac6c7b1cf79a357bbf42cae4318b96f3c09a7ddf --- /dev/null +++ b/collector/core/gripper/recording/fays_raw_client.py @@ -0,0 +1,314 @@ +"""Client for the Fays ORB bridge's raw stereo/IMU recording socket. + +主程序适配版:原始上位机把包直接交给 LerobotV3 writer;这里改为 +``on_stereo`` 回调(bridge 拆左右目、只取左目转 BGR 投递 UI)。 +IMU 原始数据不累积、不外送:SLAM 解算在桥接进程内部完成, +主程序只落盘 SLAM 位姿/轨迹(imu_packets 仅作包级诊断计数)。 +""" + +from __future__ import annotations + +import socket +import struct +import threading +import time +from typing import Callable, Optional + + +RAW_HEADER = struct.Struct("<6I3Q4i2hi2I") +RAW_STREAM_MAGIC = 0x53544F55 +RAW_STREAM_VERSION = 1 +RAW_PACKET_STEREO = 1 +RAW_PACKET_IMU = 2 +HEADER_SIZE = 80 +IMU_PAYLOAD_SIZE = 48 +# 断线重连节奏:1s 一次尝试,累计 60s 仍连不上才算致命错误 +RECONNECT_ATTEMPT_INTERVAL_S = 1.0 +RECONNECT_TOTAL_TIMEOUT_S = 60.0 + + +class FaysRawStreamError(RuntimeError): + """The native raw stream is incomplete or malformed.""" + + +class FaysRawStreamClient: + """Convert one native raw stream into bridge stereo/IMU callbacks.""" + + def __init__( + self, + socket_path: str, + on_stereo: Callable[..., None], + *, + logger: Callable[[str], object] = print, + on_error: Optional[Callable[[str], None]] = None, + on_reconnected: Optional[Callable[[], None]] = None, + raw_cpu: Optional[int] = None, + ) -> None: + self.socket_path = str(socket_path) + self._on_stereo = on_stereo + self._logger = logger + self._on_error = on_error + # 断线重连成功回调(bridge 用来清 paired 待配对帧 + 重置 + # 空桶看门狗:断连窗口的空桶是显示侧问题,不计入取帧质量) + self._on_reconnected = on_reconnected + # 接收线程专用核(P5 补丁):None = 不绑(继承掩码即可) + self._raw_cpu = raw_cpu + self._stop = threading.Event() + self._thread: Optional[threading.Thread] = None + self._sock: Optional[socket.socket] = None + self._lock = threading.Lock() + self._last_stereo_sequence: Optional[int] = None + self._last_stereo_timestamp_ns = 0 + self._reconnect_count = 0 + self.imu_packets = 0 + self.stereo_packets = 0 + self.connected = threading.Event() + self.first_packet = threading.Event() + self.error: Optional[str] = None + + @property + def alive(self) -> bool: + thread = self._thread + return bool(thread and thread.is_alive()) + + def start(self) -> None: + with self._lock: + if self._thread is not None: + raise RuntimeError("Fays raw stream is already running") + self._stop.clear() + self.error = None + thread = threading.Thread( + target=self._run, + name="fays-raw-stream", + daemon=False, + ) + self._thread = thread + thread.start() + + def stop(self, timeout: float = 3.0) -> None: + self._stop.set() + with self._lock: + sock = self._sock + if sock is not None: + try: + sock.shutdown(socket.SHUT_RDWR) + except OSError: + pass + thread = self._thread + if thread is not None and thread.is_alive(): + thread.join(timeout=max(0.1, float(timeout))) + with self._lock: + self._thread = None + if self._sock is not None: + try: + self._sock.close() + except OSError: + pass + self._sock = None + + def _fail(self, message: str) -> None: + self.error = message + self._logger(f"[Gripper-Raw] Fays raw stream failed: {message}") + if self._on_error is not None: + self._on_error(message) + self._stop.set() + + def _connect(self, deadline_s: float = 30.0) -> socket.socket: + # 原生桥接在 ORB 系统装载完成后才创建 socket(通常在 + # [FAYS-CALIB] 输出之后数秒),比本客户端的启动时刻晚; + # 带重试等待其出现(bind/listen 竞争也一并覆盖)。 + # deadline_s:首次连接 30s(SLAM 进程还在装载),断线重连 + # 收短到 5s(服务端 accept 循环常驻,正常秒级即可连上) + deadline = time.monotonic() + float(deadline_s) + last_error: Optional[OSError] = None + while not self._stop.is_set(): + try: + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + sock.settimeout(5.0) + # 加大接收缓冲,吸收 native 抓帧线程被瞬时抢占时的突发: + # 每包 ~1.4MB(1280x480x2+IMU),2MB 申请值内核翻倍后 + # 可容纳 ≥2 包突发,避免窗口抖动导致丢包降帧 + try: + sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, + 2 * 1024 * 1024) + except OSError: + pass + sock.connect(self.socket_path) + sock.settimeout(0.2) + return sock + except OSError as exc: + last_error = exc + if time.monotonic() >= deadline: + raise FaysRawStreamError( + f"raw socket {self.socket_path} not ready " + f"after 30s: {exc}" + ) from exc + time.sleep(0.5) + raise FaysRawStreamError( + "Fays raw stream client stopped before connect") + + def _recv_exact(self, sock: socket.socket, size: int) -> bytes: + chunks = bytearray() + while len(chunks) < size and not self._stop.is_set(): + try: + chunk = sock.recv(size - len(chunks)) + except socket.timeout: + continue + except OSError as exc: + if self._stop.is_set(): + return bytes(chunks) + raise FaysRawStreamError(f"socket read failed: {exc}") from exc + if not chunk: + if self._stop.is_set(): + return bytes(chunks) + raise FaysRawStreamError("Fays raw stream closed unexpectedly") + chunks.extend(chunk) + return bytes(chunks) + + def _close_sock(self, sock) -> None: + with self._lock: + if self._sock is sock: + self._sock = None + try: + sock.close() + except OSError: + pass + + def _stream_loop(self, sock: socket.socket) -> None: + while not self._stop.is_set(): + header_bytes = self._recv_exact(sock, HEADER_SIZE) + if not header_bytes: + break + header = RAW_HEADER.unpack(header_bytes) + ( + magic, version, kind, header_size, payload_size, + _reserved0, sensor_timestamp_ns, host_monotonic_ns, + host_realtime_ns, sequence, width, height, channels, + encoding, _reserved1, step, _reserved2, _reserved3, + ) = header + if magic != RAW_STREAM_MAGIC or version != RAW_STREAM_VERSION: + raise FaysRawStreamError("unknown raw stream protocol") + if header_size != HEADER_SIZE: + raise FaysRawStreamError( + f"unexpected raw header size {header_size}") + payload = self._recv_exact(sock, payload_size) + if len(payload) != payload_size: + break + if kind == RAW_PACKET_IMU: + if payload_size != IMU_PAYLOAD_SIZE: + raise FaysRawStreamError( + f"invalid IMU payload size {payload_size}") + # 只做包级诊断计数:IMU 原始数据不外送(SLAM 解算 + # 在桥接进程内部完成,主程序只落盘 SLAM 位姿/轨迹) + self.imu_packets += 1 + self.first_packet.set() + continue + if kind != RAW_PACKET_STEREO: + raise FaysRawStreamError(f"unknown raw packet kind {kind}") + if channels not in (1, 3) or width <= 0 or height <= 0: + raise FaysRawStreamError( + f"invalid stereo frame {width}x{height}x{channels}") + normalized_step = int(step) if int(step) > 0 else ( + int(width) * int(channels)) + if payload_size < normalized_step * height: + raise FaysRawStreamError( + f"short stereo payload: {payload_size} bytes") + # 时间戳单调校验仅对 side_by_side(单包含双目)成立: + # paired_packets 模式左右目交替到达,两目传感器时钟有 + # ~20ms 固定偏移,全局比较会把正常交错误判为回退 + side_by_side = int(width) >= int(height) * 3 + if (side_by_side and self._last_stereo_timestamp_ns and ( + sensor_timestamp_ns <= self._last_stereo_timestamp_ns)): + raise FaysRawStreamError( + "Fays stereo timestamp regression: " + f"previous={self._last_stereo_timestamp_ns} " + f"current={sensor_timestamp_ns}") + self._last_stereo_sequence = int(sequence) + self._last_stereo_timestamp_ns = int(sensor_timestamp_ns) + self.stereo_packets += 1 + self.first_packet.set() + self._on_stereo( + payload, + int(sensor_timestamp_ns), + int(host_monotonic_ns), + int(sequence), + int(width), + int(height), + int(channels), + normalized_step, + int(encoding), + ) + if not self._stop.is_set(): + raise FaysRawStreamError("Fays raw stream closed by bridge") + + def _run(self) -> None: + # 线程级自绑专用核(P5 补丁):接收线程负载轻但节律敏感, + # 独占一个 SMT 核可保证 native 30fps 取帧不被主进程重线程 + # 抢占;失败不致命(继承掩码已避开 SLAM 分区) + if self._raw_cpu is not None: + from core.gripper.affinity import pin_raw_thread + if pin_raw_thread(self._raw_cpu): + self._logger(f"[Gripper-Raw] 接收线程已绑定专用核 CPU{self._raw_cpu}") + else: + self._logger("[Gripper-Raw] 接收线程绑核失败(沿用继承掩码)") + # 断线自动重连:服务端(SLAM 进程)在客户端短暂卡顿导致其 + # 原始队列溢出时会主动断开连接(stereo loss detected → + # close);显示链路重连即可恢复,不视为致命。只有首连失败 + # 或重连持续失败超时才算错误。 + first_connection = True + reconnect_deadline = 0.0 + while not self._stop.is_set(): + try: + sock = self._connect( + deadline_s=30.0 if first_connection else 5.0) + except FaysRawStreamError as exc: + if self._stop.is_set(): + return + if first_connection: + # 首连失败=致命(SLAM 进程未起/ipc 目录缺失) + self._fail(str(exc)) + return + if time.monotonic() >= reconnect_deadline: + self._fail( + "Fays raw stream reconnect failed for " + f"{RECONNECT_TOTAL_TIMEOUT_S:.0f}s: {exc}") + return + time.sleep(RECONNECT_ATTEMPT_INTERVAL_S) + continue + first_connection = False + reconnect_deadline = 0.0 + with self._lock: + self._sock = sock + self.connected.set() + if self._reconnect_count: + self._logger( + "[Gripper-Raw] 原始流已重连(第 {} 次),显示链路恢复" + .format(self._reconnect_count)) + if self._on_reconnected is not None: + try: + self._on_reconnected() + except Exception: + pass + else: + self._logger( + "[Gripper-Raw] Fays raw stereo/IMU stream connected") + try: + self._stream_loop(sock) + except FaysRawStreamError as exc: + self._close_sock(sock) + if self._stop.is_set(): + return + self._reconnect_count += 1 + self._logger( + "[Gripper-Raw] 原始流连接中断:{};{}s 后自动重连" + .format(exc, RECONNECT_ATTEMPT_INTERVAL_S)) + reconnect_deadline = ( + time.monotonic() + RECONNECT_TOTAL_TIMEOUT_S) + time.sleep(RECONNECT_ATTEMPT_INTERVAL_S) + continue + except Exception as exc: + self._close_sock(sock) + self._fail(str(exc)) + return + self._close_sock(sock) + return diff --git a/collector/core/gripper/runtime/__init__.py b/collector/core/gripper/runtime/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f122a3fb6dfecc2eaceba6924fbe13353860afd7 --- /dev/null +++ b/collector/core/gripper/runtime/__init__.py @@ -0,0 +1,7 @@ +"""core.gripper 运行时的最小子集:CPU 绑核、线程亲和与设备访问互斥。 + +主程序只依赖 cpu_policy/thread_affinity/device_access/interruptible_queue; +原版 barrel 引用的 app_config/log_policy/performance_reporter/shutdown 未复制。 +""" + +from __future__ import annotations diff --git a/collector/core/gripper/runtime/cpu_policy.py b/collector/core/gripper/runtime/cpu_policy.py new file mode 100644 index 0000000000000000000000000000000000000000..52b5853bedbd04b9a291ce834eca8890a8c72d67 --- /dev/null +++ b/collector/core/gripper/runtime/cpu_policy.py @@ -0,0 +1,777 @@ +"""KSQ Gripper 的固定 CPU 角色和 Linux 混合核拓扑识别。 + +本模块只读取 affinity 与 sysfs。它不创建线程、不修改调度策略,也不接触 +任何设备。实际 affinity 写入由 :mod:`runtime.thread_affinity` 独占。 +""" + +from __future__ import annotations + +from dataclasses import dataclass +import os +from types import MappingProxyType +from typing import Callable, Iterable, Mapping, Optional, Sequence, Tuple + + +CPU_ROLE_ORDER = ( + "input", + "fays_input", + "left_process", + "right_process", + "idle_smt", + "fays_prepare", + "fays_left_orb", + "fays_right_orb", + "fays_track", + "fays_background", + "general", +) + +DEDICATED_THREAD_ROLES = frozenset({ + "input", + "fays_input", + "left_process", + "right_process", + "fays_prepare", + "fays_left_orb", + "fays_right_orb", + "fays_track", +}) + +RESERVED_ROLES = DEDICATED_THREAD_ROLES | frozenset({ + "idle_smt", + "fays_background", +}) + +FAYS_PROCESS_ROLES = ( + "fays_input", + "fays_prepare", + "fays_left_orb", + "fays_right_orb", + "fays_track", + "fays_background", +) + +EXPECTED_ROLE_CPUS = MappingProxyType({ + "input": (4,), + "fays_input": (4,), + "left_process": (0,), + "right_process": (2,), + "idle_smt": (1, 3), + "fays_prepare": (5,), + "fays_left_orb": (6,), + "fays_right_orb": (7,), + "fays_track": (8,), + "fays_background": (9,), + "general": (10, 11), +}) + + +def parse_cpu_list(value: object) -> frozenset[int]: + """解析 Linux sysfs 的 ``0-3,8`` CPU 列表格式。 + + 与 sysfs 格式一致,空字段会被忽略;负数、倒序范围和非数字字段会抛出 + :class:`ValueError`,防止错误拓扑被静默接受。 + """ + + cpus: set[int] = set() + for encoded_part in str(value).strip().split(","): + part = encoded_part.strip() + if not part: + continue + if "-" in part: + start_text, separator, end_text = part.partition("-") + if not separator or not start_text or not end_text: + raise ValueError(f"invalid CPU range: {part!r}") + start = int(start_text, 10) + end = int(end_text, 10) + if start < 0 or end < start: + raise ValueError(f"invalid CPU range: {part!r}") + cpus.update(range(start, end + 1)) + else: + cpu = int(part, 10) + if cpu < 0: + raise ValueError(f"invalid CPU id: {part!r}") + cpus.add(cpu) + return frozenset(cpus) + + +@dataclass(frozen=True) +class CoreTopology: + """一个物理核在当前进程 affinity 范围内可见的拓扑。""" + + cpus: Tuple[int, ...] + sibling_count: int = 1 + max_freq: int = 0 + core_type: Optional[int] = None + package_id: int = 0 + core_id: int = 0 + + def __post_init__(self) -> None: + normalized = tuple(sorted({int(cpu) for cpu in self.cpus})) + if not normalized or normalized[0] < 0: + raise ValueError("a physical core must contain non-negative CPUs") + object.__setattr__(self, "cpus", normalized) + object.__setattr__( + self, "sibling_count", max(1, int(self.sibling_count))) + object.__setattr__(self, "max_freq", max(0, int(self.max_freq))) + + +@dataclass(frozen=True) +class CpuPolicySnapshot: + """不可变的 CPU0-11 角色分区。""" + + source: str + input: Tuple[int, ...] = (4,) + fays_input: Tuple[int, ...] = (4,) + left_process: Tuple[int, ...] = (0,) + right_process: Tuple[int, ...] = (2,) + idle_smt: Tuple[int, ...] = (1, 3) + fays_prepare: Tuple[int, ...] = (5,) + fays_left_orb: Tuple[int, ...] = (6,) + fays_right_orb: Tuple[int, ...] = (7,) + fays_track: Tuple[int, ...] = (8,) + fays_background: Tuple[int, ...] = (9,) + general: Tuple[int, ...] = (10, 11) + _dual_slam: bool = False + _balanced_dual_slam: bool = False + _relaxed: bool = False + + def __post_init__(self) -> None: + for role in CPU_ROLE_ORDER: + cpus = tuple(int(cpu) for cpu in getattr(self, role)) + if not cpus or len(cpus) != len(set(cpus)) or min(cpus) < 0: + raise ValueError(f"invalid CPU role {role!r}: {cpus!r}") + object.__setattr__(self, role, cpus) + if self._relaxed: + self.validate_relaxed() + elif self._balanced_dual_slam: + self.validate_balanced_dual_slam() + elif self._dual_slam: + self.validate_dual_slam() + else: + self.validate_strict() + + @classmethod + def dual_slam( + cls, + track_cpu: int = 6, + input_cpu: int = 5, + ) -> "CpuPolicySnapshot": + """双设备实例:第一套 input=4/track=8,第二套 input/fays_input=5、 + track/output=6;其余角色与单设备严格分区一致(general=10/11)。""" + return cls( + source="dual_slam", + input=(int(input_cpu),), + fays_input=(int(input_cpu),), + fays_track=(int(track_cpu),), + general=(10, 11), + _dual_slam=True, + ) + + @classmethod + def exclusive_dual_slam( + cls, + *, + secondary: bool, + ) -> "CpuPolicySnapshot": + """把两套 Fays/ORB 子进程放进互不重叠的物理核域。 + + 当前主机 SMT 关系为 ``(0,6) (1,7) (2,8) (3,9) (4,10) + (5,11)``。第一套 Fays/ORB 使用物理核 0/1,第二套使用物理核 + 2/3;两套 ORB 的重负载阶段不再落到对方的 SMT 兄弟上。 + + 2026-08-27 双设备共用 GUI 修正:GUI 和 camera-service 固定保留在 + CPU10/11,不再跟随最后连接设备切换。四路 Sightac 计算分散到 + CPU4/5/1/3。CPU0/2 是两套 Fays Track/Output 主线程,不能与 Sightac + 重计算同核;CPU1/3 只承担较短的 Fays prepare/background 突发, + 竞争代价远小于直接阻塞 Track。Sightac 输入线程主要阻塞在 UVC + 读取,允许与对应计算子进程共用同一逻辑核。 + """ + if secondary: + return cls( + source="exclusive_dual_slam_secondary", + input=(1, 3), + fays_input=(2,), + left_process=(1,), + right_process=(3,), + idle_smt=(4, 5), + fays_prepare=(3,), + fays_left_orb=(7,), + fays_right_orb=(7,), + fays_track=(2,), + fays_background=(3,), + general=(10, 11), + _relaxed=True, + ) + return cls( + source="exclusive_dual_slam_primary", + input=(4, 5), + fays_input=(0,), + left_process=(4,), + right_process=(5,), + idle_smt=(2, 3, 8, 9), + fays_prepare=(1,), + fays_left_orb=(6,), + fays_right_orb=(6,), + fays_track=(0,), + fays_background=(1,), + general=(10, 11), + _relaxed=True, + ) + + @classmethod + def balanced_dual_slam( + cls, + *, + secondary: bool, + ) -> "CpuPolicySnapshot": + """双设备正式性能方案。 + + 当前主机的 SMT 关系为 (0,6)、(1,7)、(2,8)、(3,9)、 + (4,10)、(5,11)。清单顺序中的主设备使用 + Sightac input=4/5、Fays callback=4、prepare=5、ORB=6/7、 + track=8;次设备把对应阶段放到 Sightac input=10/11、Fays + callback=10、prepare=11、ORB=0/1、track=2。 + 四个 Sightac 计算进程分散到三个物理核的四个逻辑 CPU:主设备 + left/right=1/5,次设备 left/right=9/11。设备1 Left 不再与 + UI/general 线程共用 CPU3;CPU1 是设备2右目 ORB CPU7 的 SMT 兄弟, + 这是当前双设备满载下避免 CPU3 抢占的明确取舍。CPU5/11 与负载 + 相对较低的 Fays 预处理阶段共享,避免占用 Track 固定逻辑 CPU。 + 普通/UI线程继续放在 CPU3。 + + C++ mark_only 二进制的显式 MP cleanup 初始使用 background=CPU9。 + LocalMapping 和 LoopClosing 保留各自 ORB 子进程的完整 CPU 域,不再 + 被外部审计器持续压到单个 CPU9。 + """ + if secondary: + return cls( + source="balanced_dual_slam_secondary", + # Sightac 的两个读取线程允许在 10/11 之间调度;Fays + # SDK 回调仍固定在 10,避免所有输入工作都锁在一个逻辑核。 + input=(10, 11), + fays_input=(10,), + idle_smt=(6, 7, 8), + fays_prepare=(11,), + fays_left_orb=(0,), + fays_right_orb=(1,), + fays_track=(2,), + fays_background=(9,), + left_process=(9,), + right_process=(11,), + general=(3,), + _balanced_dual_slam=True, + ) + return cls( + source="balanced_dual_slam_primary", + # Sightac 的两个读取线程允许在 4/5 之间调度;Fays SDK + # 回调仍固定在 4。两者因此使用不同的角色和 affinity 域。 + input=(4, 5), + fays_input=(4,), + idle_smt=(1,), + left_process=(1,), + right_process=(5,), + general=(3,), + _balanced_dual_slam=True, + ) + + def validate_balanced_dual_slam(self) -> None: + secondary = self.source == "balanced_dual_slam_secondary" + expected = dict(EXPECTED_ROLE_CPUS) + expected.update({ + "input": (10, 11) if secondary else (4, 5), + "fays_input": (10,) if secondary else (4,), + "idle_smt": (1,) if not secondary else (6, 7, 8), + "left_process": (1,) if not secondary else (9,), + "right_process": (5,) if not secondary else (11,), + "general": (3,), + }) + if secondary: + expected.update({ + "fays_prepare": (11,), + "fays_left_orb": (0,), + "fays_right_orb": (1,), + "fays_track": (2,), + "fays_background": (9,), + "left_process": (9,), + "right_process": (11,), + }) + actual = { + role: getattr(self, role) for role in CPU_ROLE_ORDER + } + if actual != expected: + raise ValueError( + "invalid balanced dual-SLAM CPU partition: " + f"expected={expected!r} actual={actual!r}" + ) + # left/right_process are child-process domains, not parent Python + # threads. The primary left worker is kept off the UI/general CPU3. + # CPU1 is the SMT sibling of the secondary right ORB CPU7; this is the + # least-invasive available slot in the fully occupied dual-device + # layout. CPU5/11 carry the comparatively light Fays preprocess stages + # as well as one tactile worker each; no two tactile workers are pinned + # to the same logical CPU. + overlap = ( + set(self.reserved) + - set(self.left_process) + - set(self.right_process) + ) & set(self.general) + if overlap: + raise ValueError( + "invalid balanced dual-SLAM reserved/general overlap: " + f"expected=[] actual={sorted(overlap)}" + ) + + def validate_dual_slam(self) -> None: + expected = dict(EXPECTED_ROLE_CPUS) + expected.update({ + "input": self.input, + "fays_input": self.fays_input, + "fays_track": self.fays_track, + }) + actual = { + role: getattr(self, role) for role in CPU_ROLE_ORDER + } + if actual != expected: + raise ValueError( + "invalid dual-SLAM CPU partition: " + f"expected={expected!r} actual={actual!r}" + ) + if self.fays_track not in {(6,), (8,), (10,)}: + raise ValueError( + "dual-SLAM track must be CPU6, CPU8 or CPU10: " + f"{self.fays_track!r}" + ) + if self.input not in {(4,), (5,), (6,)}: + raise ValueError( + "dual-SLAM input must be CPU4, CPU5 or CPU6: " + f"{self.input!r}" + ) + if self.input != self.fays_input: + raise ValueError( + "dual-SLAM input/fays_input must share the same CPU: " + f"input={self.input!r} fays_input={self.fays_input!r}" + ) + reserved = set(self.reserved) + general = set(self.general) + if general != {10, 11}: + raise ValueError( + f"invalid dual-SLAM boundary: " + f"reserved={sorted(reserved)} general={sorted(general)}" + ) + if reserved & general: + raise ValueError("dual-SLAM reserved/general overlap") + if any(cpu < 0 or cpu > 10 for cpu in reserved): + raise ValueError( + "dual-SLAM reserved CPU outside 0-10: " + f"{sorted(reserved)}" + ) + + @property + def roles(self) -> Mapping[str, Tuple[int, ...]]: + """返回不可变 role → CPU 元组视图。""" + + return MappingProxyType({ + role: getattr(self, role) for role in CPU_ROLE_ORDER + }) + + @property + def fays_process(self) -> Tuple[int, ...]: + """ORB 子进程需要作为 cpuset 超集继承的全部 Fays 阶段 CPU。 + + 进程启动时 taskset 必须包含所有内部阶段 CPU;否则 TrackStereo + 里的 ORB worker 无法用 sched_setaffinity 绑定到自己的角色核。 + """ + return tuple(sorted({ + cpu + for role in FAYS_PROCESS_ROLES + for cpu in getattr(self, role) + })) + + @property + def reserved(self) -> Tuple[int, ...]: + return tuple(sorted({ + cpu + for role in RESERVED_ROLES + for cpu in getattr(self, role) + })) + + def cpus_for(self, role: str) -> Tuple[int, ...]: + try: + return self.roles[str(role)] + except KeyError as exc: + raise KeyError(f"unknown CPU role: {role!r}") from exc + + def validate_relaxed(self) -> None: + """放松模式:只检查预留域和普通域不重叠。""" + reserved = set(self.reserved) + general = set(self.general) + if reserved & general: + raise ValueError( + "relaxed CPU policy: reserved/general overlap: " + f"reserved={sorted(reserved)} general={sorted(general)}" + ) + all_cpus = reserved | general + if len(all_cpus) < 4: + raise ValueError( + "relaxed CPU policy requires at least 4 logical CPUs: " + f"found={sorted(all_cpus)}" + ) + + def validate_strict(self) -> None: + actual = {role: getattr(self, role) for role in CPU_ROLE_ORDER} + if actual != dict(EXPECTED_ROLE_CPUS): + raise ValueError( + "invalid fixed CPU partition: " + f"expected={dict(EXPECTED_ROLE_CPUS)!r} actual={actual!r}" + ) + reserved = set(self.reserved) + general = set(self.general) + if reserved != set(range(10)) or general != {10, 11}: + raise ValueError( + f"invalid strict boundary: reserved={sorted(reserved)} " + f"general={sorted(general)}" + ) + if reserved & general: + raise ValueError("reserved and general CPU domains overlap") + + def describe(self) -> str: + return ", ".join( + f"{role}={getattr(self, role)}" for role in CPU_ROLE_ORDER) + + +def _read_int_file(path: str, default: Optional[int] = None) -> Optional[int]: + try: + with open(path, encoding="utf-8") as stream: + return int(stream.read().strip()) + except (OSError, ValueError): + return default + + +def discover_cpu_cores( + sysfs_cpu_root: os.PathLike[str] | str = "/sys/devices/system/cpu", + affinity_getter: Optional[Callable[[int], Iterable[int]]] = None, +) -> Tuple[CoreTopology, ...]: + """返回当前进程 affinity 允许范围内的物理核拓扑。 + + ``sysfs_cpu_root`` 和 ``affinity_getter`` 可注入,便于无硬件测试;默认 + 路径只执行只读访问。 + """ + + getter = affinity_getter + if getter is None: + getter = getattr(os, "sched_getaffinity", None) + if getter is None: + return () + try: + allowed = {int(cpu) for cpu in getter(0)} + except (OSError, TypeError, ValueError): + return () + + root = os.fspath(sysfs_cpu_root) + records: dict[tuple[int, int], dict[str, object]] = {} + for cpu in sorted(allowed): + cpu_root = os.path.join(root, f"cpu{cpu}") + topology = os.path.join(cpu_root, "topology") + package_id = _read_int_file( + os.path.join(topology, "physical_package_id"), 0) + core_id = _read_int_file( + os.path.join(topology, "core_id"), cpu) + key = (int(package_id or 0), int(core_id if core_id is not None else cpu)) + record = records.setdefault(key, { + "cpus": set(), + "sibling_count": 1, + "max_freq": 0, + "core_type": None, + }) + cast_cpus = record["cpus"] + assert isinstance(cast_cpus, set) + cast_cpus.add(cpu) + + try: + with open( + os.path.join(topology, "thread_siblings_list"), + encoding="utf-8", + ) as stream: + sibling_count = len(parse_cpu_list(stream.read())) + record["sibling_count"] = max( + int(record["sibling_count"]), sibling_count) + except (OSError, ValueError): + pass + + max_freq = _read_int_file( + os.path.join(cpu_root, "cpufreq", "cpuinfo_max_freq"), 0) + record["max_freq"] = max( + int(record["max_freq"]), int(max_freq or 0)) + core_type = _read_int_file( + os.path.join(topology, "core_type")) + if core_type is not None: + record["core_type"] = core_type + + cores = ( + CoreTopology( + cpus=tuple(record["cpus"]), + sibling_count=int(record["sibling_count"]), + max_freq=int(record["max_freq"]), + core_type=( + None if record["core_type"] is None + else int(record["core_type"]) + ), + package_id=key[0], + core_id=key[1], + ) + for key, record in records.items() + ) + return tuple(sorted(cores, key=lambda item: min(item.cpus))) + + +def select_cpu_policy( + cores: Sequence[CoreTopology | Mapping[str, object]], +) -> Optional[CpuPolicySnapshot]: + """在已验证的混合核拓扑上选择项目唯一的固定 CPU 方案。 + + 核类型识别顺序和重构前实现一致:``core_type``、SMT 拓扑、最高频率。 + 编号或物理拓扑不匹配时返回 ``None``,绝不把固定方案套到未知机器。 + """ + + normalized: list[CoreTopology] = [] + for core in cores: + if isinstance(core, CoreTopology): + normalized.append(core) + continue + cpus_value = core.get("cpus", ()) + cpus = tuple(int(cpu) for cpu in cpus_value) # type: ignore[arg-type] + if not cpus: + continue + normalized.append(CoreTopology( + cpus=cpus, + sibling_count=int(core.get("sibling_count", 1)), + max_freq=int(core.get("max_freq", 0)), + core_type=( + None if core.get("core_type") is None + else int(core["core_type"]) + ), + )) + + if len(normalized) < 3: + return None + + p_cores: list[CoreTopology] = [] + e_cores: list[CoreTopology] = [] + source = "" + + typed = { + core.core_type for core in normalized if core.core_type is not None + } + if len(typed) >= 2: + by_type: dict[int, list[CoreTopology]] = {} + for core in normalized: + if core.core_type is not None: + by_type.setdefault(core.core_type, []).append(core) + + def type_rank( + item: tuple[int, list[CoreTopology]], + ) -> tuple[int, int, int]: + core_type, members = item + return ( + max(member.sibling_count for member in members), + max(member.max_freq for member in members), + core_type, + ) + + ordered_types = sorted(by_type.items(), key=type_rank) + e_cores = ordered_types[0][1] + p_cores = ordered_types[-1][1] + source = "sysfs core_type" + + if len(p_cores) < 2 or not e_cores: + sibling_counts = sorted({ + core.sibling_count for core in normalized + }) + if len(sibling_counts) >= 2: + e_count = sibling_counts[0] + p_count = sibling_counts[-1] + e_cores = [ + core for core in normalized + if core.sibling_count == e_count + ] + p_cores = [ + core for core in normalized + if core.sibling_count == p_count + ] + source = "SMT topology" + + if len(p_cores) < 2 or not e_cores: + frequencies = sorted({ + core.max_freq for core in normalized if core.max_freq > 0 + }) + if ( + len(frequencies) >= 2 + and frequencies[-1] >= frequencies[0] * 1.05 + ): + e_freq = frequencies[0] + p_freq = frequencies[-1] + e_cores = [ + core for core in normalized if core.max_freq == e_freq + ] + p_cores = [ + core for core in normalized if core.max_freq == p_freq + ] + source = "maximum frequency" + + if len(p_cores) < 2 or not e_cores: + all_cpus = { + cpu for core in normalized for cpu in core.cpus + } + if _can_use_homogeneous_fallback(normalized, all_cpus): + return _build_homogeneous_policy(normalized) + return None + + all_cpus = { + cpu for core in normalized for cpu in core.cpus + } + if not set(range(12)).issubset(all_cpus): + return None + + p_cpu_groups = [set(core.cpus) for core in p_cores] + e_cpu_set = {cpu for core in e_cores for cpu in core.cpus} + if ( + not any({0, 1}.issubset(group) for group in p_cpu_groups) + or not any({2, 3}.issubset(group) for group in p_cpu_groups) + or not set(range(4, 12)).issubset(e_cpu_set) + ): + return None + + return CpuPolicySnapshot(source=source) + + +def _can_use_homogeneous_fallback( + cores: list[CoreTopology], + all_cpus: set[int], +) -> bool: + """检查是否为同构 12 逻辑 CPU 系统(如 AMD Ryzen 无大小核)。""" + return ( + len(cores) >= 3 + and all(core.sibling_count == 2 for core in cores) + and set(range(12)).issubset(all_cpus) + ) + + +def _build_homogeneous_policy( + cores: list[CoreTopology], +) -> CpuPolicySnapshot: + """在同构 CPU 上构建放松策略。 + + 以 AMD SMT 编号方案 (0,6), (1,7), (2,8), (3,9), (4,10), (5,11) + 为基准排列角色,保证每个重角色独占一个物理核。 + """ + + sibling_map: dict[int, int] = {} + for core in cores: + cpus = sorted(core.cpus) + if len(cpus) == 2: + sibling_map[cpus[0]] = cpus[1] + sibling_map[cpus[1]] = cpus[0] + + def _sibling(cpu: int) -> int: + return sibling_map.get(cpu, cpu) + + matched = True + try: + if sibling_map.get(0) == 6 and sibling_map.get(2) == 8: + # Standard AMD SMT (0,6) (1,7) (2,8) (3,9) (4,10) (5,11) + return CpuPolicySnapshot( + source="homogeneous_amd", + input=(4,), + fays_input=(4,), + left_process=(0,), + right_process=(2,), + idle_smt=(6, 8), + fays_prepare=(5,), + fays_left_orb=(1,), + fays_right_orb=(3,), + fays_track=(7,), + fays_background=(9,), + general=(10, 11), + _relaxed=True, + ) + except Exception: + matched = False + + # Generic fallback: assign roles to distinct physical cores + used_physical: set[int] = set() + role_cpus: dict[str, tuple[int, ...]] = {} + role_order = [ + ("left_process", 1), + ("right_process", 1), + ("fays_left_orb", 1), + ("fays_right_orb", 1), + ("fays_track", 1), + ("fays_background", 1), + ("fays_prepare", 1), + ("input", 1), + ("fays_input", 1), + ("general", 2), + ] + cpu_pool: list[int] = [] + for core in sorted(cores, key=lambda c: min(c.cpus)): + for cpu in sorted(core.cpus): + cpu_pool.append(cpu) + idx = 0 + idle_cpus: list[int] = [] + for role_name, count in role_order: + assigned: list[int] = [] + while len(assigned) < count and idx < len(cpu_pool): + cpu = cpu_pool[idx] + idx += 1 + physical = sibling_map.get(cpu, cpu) + if physical in used_physical: + idle_cpus.append(cpu) + continue + used_physical.add(physical) + assigned.append(cpu) + # mark sibling as idle + sibling = sibling_map.get(cpu) + if sibling is not None and sibling not in assigned: + idle_cpus.append(sibling) + used_physical.add(physical) + if not assigned: + assigned = [cpu_pool[idx % len(cpu_pool)]] + idx += 1 + role_cpus[role_name] = tuple(assigned) + idle_smt = tuple(sorted(set(idle_cpus))[:4]) + if not idle_smt: + idle_smt = (cpu_pool[-1],) if cpu_pool else (0,) + + return CpuPolicySnapshot( + source="homogeneous_generic", + input=role_cpus.get("input", (0,)), + fays_input=role_cpus.get("fays_input", (0,)), + left_process=role_cpus.get("left_process", (0,)), + right_process=role_cpus.get("right_process", (2,)), + idle_smt=idle_smt, + fays_prepare=role_cpus.get("fays_prepare", (5,)), + fays_left_orb=role_cpus.get("fays_left_orb", (1,)), + fays_right_orb=role_cpus.get("fays_right_orb", (3,)), + fays_track=role_cpus.get("fays_track", (7,)), + fays_background=role_cpus.get("fays_background", (9,)), + general=role_cpus.get("general", (10, 11)), + _relaxed=True, + ) + + +def detect_cpu_policy( + sysfs_cpu_root: os.PathLike[str] | str = "/sys/devices/system/cpu", + affinity_getter: Optional[Callable[[int], Iterable[int]]] = None, +) -> CpuPolicySnapshot: + """发现并严格验证项目所需的 CPU0-11 分区。""" + + policy = select_cpu_policy(discover_cpu_cores( + sysfs_cpu_root=sysfs_cpu_root, + affinity_getter=affinity_getter, + )) + if policy is None: + raise RuntimeError( + "strict CPU isolation unavailable: expected CPU0-9 reserved " + "by role and CPU10-11 available for general work" + ) + return policy diff --git a/collector/core/gripper/runtime/device_access.py b/collector/core/gripper/runtime/device_access.py new file mode 100644 index 0000000000000000000000000000000000000000..84a08d3ecc9f56de329c9f7c7d98a6e09cd19da5 --- /dev/null +++ b/collector/core/gripper/runtime/device_access.py @@ -0,0 +1,66 @@ +"""Cross-process device-operation guards; no SDK calls or affinity changes.""" +from contextlib import contextmanager +import fcntl +import os +import stat +import time + + +@contextmanager +def device_access_guard(path, *, timeout=30.0, cancelled=None): + # Read-only flock also works for a lock created by a sudo-launched process. + # Do not truncate, unlink or follow symlinks: every caller must lock the + # same inode for the whole operation/lease lifetime. + flags = os.O_RDONLY | os.O_CLOEXEC | os.O_NOFOLLOW + try: + fd = os.open(path, flags) + except FileNotFoundError: + try: + fd = os.open(path, flags | os.O_CREAT | os.O_EXCL, 0o644) + except FileExistsError: + fd = os.open(path, flags) + acquired = False + owner_pid = os.getpid() + try: + if not stat.S_ISREG(os.fstat(fd).st_mode): + raise RuntimeError(f"设备锁不是普通文件: {path}") + deadline = time.monotonic() + timeout + while True: + if cancelled is not None and cancelled(): + raise RuntimeError("设备操作已取消") + try: + fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + acquired = True + break + except BlockingIOError: + if time.monotonic() >= deadline: + raise RuntimeError(f"设备正在使用或初始化,请稍后重试: {path}") + time.sleep(0.05) + yield + finally: + try: + # O_CLOEXEC does not prevent inheritance by fork-only workers. + # close(fd) alone leaves flock held by their duplicate descriptors. + # Only the acquiring process may release the shared lock explicitly. + if acquired and os.getpid() == owner_pid: + fcntl.flock(fd, fcntl.LOCK_UN) + finally: + os.close(fd) + + +FAYS_SDK_INITIALIZATION_LOCK = "/tmp/ksq-fays-sdk-serial-probe.lock" + + +def fays_device_guard(stereo_port, *, timeout=0.0): + import re + if not re.fullmatch(r"/dev/video[0-9]+", str(stereo_port)): + raise RuntimeError("Fays stereo 节点无效,拒绝访问 SDK") + return device_access_guard( + f"/tmp/ksq-fays-sdk-device-{os.path.basename(stereo_port)}.lock", + timeout=timeout, + ) + + +def fays_config_device_guard(config_path): + from core.gripper.fays_runtime import read_fays_config_ports + return fays_device_guard(read_fays_config_ports(config_path)["stereo_dev_port"]) diff --git a/collector/core/gripper/runtime/interruptible_queue.py b/collector/core/gripper/runtime/interruptible_queue.py new file mode 100644 index 0000000000000000000000000000000000000000..489fb9d4106cbcec900662a77055f7f1fd709160 --- /dev/null +++ b/collector/core/gripper/runtime/interruptible_queue.py @@ -0,0 +1,75 @@ +"""Bounded pipe-message reads for a single parent consumer on Linux/CPython. + +multiprocessing.Queue.get(timeout) times out before recv_bytes, not during it. +An exiting producer can leave a partial frame. This adapter preserves partial +frames across timeouts and never enters Connection's blocking recv_bytes. + +Own this queue's read end exclusively: do not mix with Queue.get or another +reader. Queue capacity is returned exactly once after receiving a whole frame. +The CPython-private queue access is deliberately isolated in this module. +""" +import os +import queue +import select +import struct +import time +from multiprocessing.reduction import ForkingPickler + + +class InterruptibleQueueReader: + MAX_MESSAGE_BYTES = 16 * 1024 * 1024 + + def __init__(self, channel): + self.channel = channel + self.fd = channel._reader.fileno() + os.set_blocking(self.fd, False) + self.buffer = bytearray() + self.header_size = 4 + self.payload_size = None + + def get(self, timeout=0.05, *, cancelled=lambda: False): + deadline = time.monotonic() + max(0.0, timeout) + if not self.channel._rlock.acquire(True, max(0.0, timeout)): + raise queue.Empty + try: + while True: + if cancelled(): + raise queue.Empty + if self.payload_size is None and len(self.buffer) >= self.header_size: + if self.header_size == 4: + size, = struct.unpack('!i', self.buffer[:4]) + if size == -1: + self.header_size = 12 + continue + else: + size, = struct.unpack('!Q', self.buffer[4:12]) + if size < 0 or size > self.MAX_MESSAGE_BYTES: + raise ValueError(f'Invalid IPC message length: {size}') + self.payload_size = size + target = self.header_size + (self.payload_size or 0) + if self.payload_size is not None and len(self.buffer) == target: + payload = self.buffer[self.header_size:] + self.buffer = bytearray() + self.header_size = 4 + self.payload_size = None + self.channel._sem.release() + return ForkingPickler.loads(payload) + remaining = max(0.0, deadline - time.monotonic()) + ready, _, _ = select.select([self.fd], [], [], min(.02, remaining)) + if ready: + try: + chunk = os.read(self.fd, min(65536, target - len(self.buffer))) + except BlockingIOError: + chunk = None + if chunk == b'': + raise EOFError('IPC producer closed during message read') + if chunk: + self.buffer.extend(chunk) + # Decode complete messages even if this read used the + # final instant of the deadline; otherwise retain bytes. + if len(self.buffer) == target: + continue + if time.monotonic() >= deadline: + raise queue.Empty + finally: + self.channel._rlock.release() diff --git a/collector/core/gripper/runtime/thread_affinity.py b/collector/core/gripper/runtime/thread_affinity.py new file mode 100644 index 0000000000000000000000000000000000000000..ed38322dbbdcb7f8e652004b8dd4da798dafb583 --- /dev/null +++ b/collector/core/gripper/runtime/thread_affinity.py @@ -0,0 +1,677 @@ +"""Linux 原生线程 affinity 的唯一写入服务。 + +锁顺序固定为 ``_state_lock`` → 无其他内部锁。外部回调(日志与 fatal +dispatcher)始终在释放锁后调用,避免关机路径与审计线程交叉死锁。 +""" + +from __future__ import annotations + +from dataclasses import dataclass +import os +from pathlib import Path +import threading +from typing import Callable, Iterable, Optional, Tuple + +from .cpu_policy import ( + DEDICATED_THREAD_ROLES, + CpuPolicySnapshot, +) + + +AUDIT_INTERVAL_SECONDS = 1.0 +AUDITOR_JOIN_TIMEOUT_SECONDS = 1.5 + +_FAYS_STAGE_ROLES = { + "fays-input": "fays_input", + "fays-prep": "fays_prepare", + "fays-orb-left": "fays_left_orb", + "fays-orb-right": "fays_right_orb", + "fays-track": "fays_track", + "fays-output": "fays_track", +} + +# These long-lived ORB workers must be able to use the complete ORB child +# domain. Treating them as a fixed background stage pins both to CPU9 and +# recreates the LocalMapping/TrackStereo contention seen in dual-device runs. +_FAYS_CHILD_DOMAIN_THREADS = { + "fays-local-map", + "fays-loop-close", +} + + +@dataclass(frozen=True) +class ThreadBindingSnapshot: + tid: int + role: str + label: str + cpus: Tuple[int, ...] + + +@dataclass(frozen=True) +class ChildDomainSnapshot: + name: str + pid: int + cpus: Tuple[int, ...] + allow_fays_stage_threads: bool + stage_cpus: Tuple[Tuple[str, Tuple[int, ...]], ...] = () + + +@dataclass(frozen=True) +class ThreadAffinitySnapshot: + installed: bool + auditor_running: bool + faulted: bool + bindings: Tuple[ThreadBindingSnapshot, ...] + children: Tuple[ChildDomainSnapshot, ...] + + +class ThreadAffinityService: + """应用固定 CPU 角色、登记专用线程并持续审计边界。""" + + def __init__( + self, + policy: CpuPolicySnapshot, + *, + set_affinity: Optional[Callable[[int, Iterable[int]], None]] = None, + get_affinity: Optional[Callable[[int], Iterable[int]]] = None, + list_task_ids: Optional[Callable[[int], Iterable[int]]] = None, + read_task_name: Optional[Callable[[int, int], str]] = None, + native_id: Callable[[], int] = threading.get_native_id, + process_id: Callable[[], int] = os.getpid, + logger: Callable[[str], None] = print, + fatal_callback: Optional[Callable[[str], None]] = None, + ) -> None: + if policy._relaxed: + policy.validate_relaxed() + else: + policy.validate_strict() + self._policy = policy + self._set_affinity = ( + set_affinity + if set_affinity is not None + else getattr(os, "sched_setaffinity", None) + ) + self._get_affinity = ( + get_affinity + if get_affinity is not None + else getattr(os, "sched_getaffinity", None) + ) + self._list_task_ids = list_task_ids or self._default_list_task_ids + self._read_task_name = ( + read_task_name or self._default_read_task_name) + self._native_id = native_id + self._process_id = process_id + self._logger = logger + self._fatal_callback = fatal_callback + + self._state_lock = threading.RLock() + self._bindings: dict[int, ThreadBindingSnapshot] = {} + self._children: dict[str, ChildDomainSnapshot] = {} + self._reported: set[tuple[int, str]] = set() + self._installed = False + self._faulted = False + self._stop = threading.Event() + self._auditor_thread: Optional[threading.Thread] = None + + @property + def policy(self) -> CpuPolicySnapshot: + return self._policy + + @staticmethod + def _default_list_task_ids(pid: int) -> Tuple[int, ...]: + try: + names = os.listdir(f"/proc/{int(pid)}/task") + except FileNotFoundError: + return () + return tuple(sorted( + int(name) for name in names if str(name).isdigit())) + + @staticmethod + def _default_read_task_name(pid: int, tid: int) -> str: + try: + with open( + f"/proc/{int(pid)}/task/{int(tid)}/comm", + encoding="utf-8", + ) as stream: + return stream.read().strip() + except (FileNotFoundError, ProcessLookupError): + return "" + + def _require_api(self) -> None: + if self._set_affinity is None or self._get_affinity is None: + raise RuntimeError("Linux thread affinity API is unavailable") + + def snapshot(self) -> ThreadAffinitySnapshot: + with self._state_lock: + thread = self._auditor_thread + return ThreadAffinitySnapshot( + installed=self._installed, + auditor_running=bool( + thread is not None and thread.is_alive()), + faulted=self._faulted, + bindings=tuple(sorted( + self._bindings.values(), key=lambda item: item.tid)), + children=tuple(sorted( + self._children.values(), key=lambda item: item.name)), + ) + + def _apply_exact(self, tid: int, cpus: Iterable[int]) -> Tuple[int, ...]: + self._require_api() + target = {int(cpu) for cpu in cpus} + if not target: + raise RuntimeError(f"empty CPU affinity for tid={int(tid)}") + assert self._set_affinity is not None + assert self._get_affinity is not None + self._set_affinity(int(tid), target) + actual = tuple(sorted(int(cpu) for cpu in self._get_affinity(int(tid)))) + expected = tuple(sorted(target)) + if actual != expected: + raise RuntimeError( + f"tid={int(tid)} affinity verification failed: " + f"expected={list(expected)} actual={list(actual)}" + ) + return actual + + def install_strict_boundary(self) -> None: + """在任何应用 worker 创建前把已有原生线程收进普通线程域。""" + + self._require_api() + general = self._policy.general + pid = self._process_id() + try: + tids = tuple(int(tid) for tid in self._list_task_ids(pid)) + except (OSError, TypeError, ValueError) as exc: + raise RuntimeError( + f"cannot enumerate startup threads: {exc}") from exc + if not tids: + raise RuntimeError("cannot enumerate startup threads: empty task set") + + for tid in tids: + try: + self._apply_exact(tid, general) + except ProcessLookupError: + continue + except (OSError, ValueError) as exc: + raise RuntimeError( + f"cannot isolate startup thread tid={tid}: {exc}" + ) from exc + + with self._state_lock: + self._installed = True + self._logger( + "[CPU-ISOLATION] default boundary verified: " + f"reserved-only={self._policy.reserved} " + f"general-only={self._policy.general}" + ) + + def set_xhci_irq_affinity_to_general(self) -> bool: + """Pin xHCI interrupt handling to the shared general CPU domain.""" + general_text = ",".join(str(cpu) for cpu in self._policy.general) + changed = 0 + try: + interrupt_lines = Path("/proc/interrupts").read_text( + encoding="utf-8").splitlines() + for line in interrupt_lines: + irq_text, separator, _description = line.partition(":") + if not separator or "xhci_hcd" not in line: + continue + try: + irq = int(irq_text.strip()) + except ValueError: + continue + try: + Path(f"/proc/irq/{irq}/smp_affinity_list").write_text( + f"{general_text}\n", encoding="ascii") + changed += 1 + except (OSError, PermissionError) as exc: + self._logger( + "[CPU-ISOLATION] xHCI IRQ affinity FAILED: " + f"irq={irq} cpus={general_text}: {exc}" + ) + except OSError as exc: + self._logger( + "[CPU-ISOLATION] xHCI IRQ scan failed: " + f"{exc}" + ) + return False + self._logger( + "[CPU-ISOLATION] xHCI IRQ affinity set: " + f"irqs={changed} cpus={general_text}" + ) + return changed > 0 + + def bind_general_thread(self, label: str) -> bool: + """把当前普通线程严格绑定到当前策略的普通线程域。""" + + tid = int(self._native_id()) + try: + self._apply_exact(tid, self._policy.general) + return True + except (OSError, RuntimeError, ValueError) as exc: + self._logger( + "[CPU-ISOLATION] general bind FAILED: " + f"thread={label} cpus={self._policy.general}: {exc}" + ) + return False + + def bind_general_thread_for( + self, policy: CpuPolicySnapshot, label: str, + ) -> bool: + """Bind a thread using a device slot's immutable policy snapshot.""" + tid = int(self._native_id()) + try: + self._apply_exact(tid, policy.general) + return True + except (OSError, RuntimeError, ValueError) as exc: + self._logger( + "[CPU-ISOLATION] slot general bind FAILED: " + f"thread={label} cpus={policy.general}: {exc}" + ) + return False + + def bind_gui_main_thread(self, cpu: int, label: str = "gui-main") -> bool: + """绑定并登记 Tk 主线程到指定核;auditor 不再纠回 general。 + + 后续未登记的工作线程若继承该核,会被 auditor 按 general 域纠回, + 因此 GUI 主线程可以独占该核而不被轻量线程挤占。 + """ + self._require_api() + tid = int(self._native_id()) + cpus = (int(cpu),) + binding = ThreadBindingSnapshot( + tid=tid, role="gui_main", label=label, cpus=cpus) + with self._state_lock: + self._bindings[tid] = binding + try: + actual = self._apply_exact(tid, cpus) + except (OSError, RuntimeError, ValueError) as exc: + with self._state_lock: + self._bindings.pop(tid, None) + self._logger( + "[CPU-ISOLATION] GUI main bind FAILED: " + f"cpu={cpu}: {exc}" + ) + return False + self._logger( + f"[CPU-ISOLATION] GUI main thread cpu={cpu} verified " + f"actual={actual}") + return True + + def bind_dedicated_thread(self, role: str, label: str = "") -> bool: + """绑定并登记当前专用线程;失败时撤销登记。""" + + role = str(role) + if role not in DEDICATED_THREAD_ROLES: + return False + cpus = self._policy.cpus_for(role) + tid = int(self._native_id()) + binding = ThreadBindingSnapshot( + tid=tid, + role=role, + label=str(label or threading.current_thread().name), + cpus=cpus, + ) + with self._state_lock: + self._bindings[tid] = binding + try: + actual = self._apply_exact(tid, cpus) + except (OSError, RuntimeError, ValueError) as exc: + with self._state_lock: + self._bindings.pop(tid, None) + self._logger( + "[CPU-ISOLATION] dedicated bind FAILED: " + f"role={role} cpus={cpus}: {exc}" + ) + return False + + report_key = (tid, role) + with self._state_lock: + should_report = report_key not in self._reported + self._reported.add(report_key) + if should_report: + scope = "Fays" if role == "fays_input" else "Tactile" + self._logger( + f"[{scope}] CPU bound: thread={binding.label} " + f"role={role} cpus={actual}" + ) + return True + + def bind_dedicated_thread_for( + self, + policy: CpuPolicySnapshot, + role: str, + label: str = "", + ) -> bool: + """Bind/register a dedicated thread without changing global policy.""" + role = str(role) + if role not in DEDICATED_THREAD_ROLES: + return False + cpus = policy.cpus_for(role) + tid = int(self._native_id()) + binding = ThreadBindingSnapshot( + tid=tid, + role=role, + label=str(label or threading.current_thread().name), + cpus=cpus, + ) + with self._state_lock: + self._bindings[tid] = binding + try: + actual = self._apply_exact(tid, cpus) + except (OSError, RuntimeError, ValueError) as exc: + with self._state_lock: + self._bindings.pop(tid, None) + self._logger( + "[CPU-ISOLATION] slot dedicated bind FAILED: " + f"role={role} cpus={cpus}: {exc}" + ) + return False + report_key = (tid, role) + with self._state_lock: + should_report = report_key not in self._reported + self._reported.add(report_key) + if should_report: + self._logger( + f"[CPU-ISOLATION] slot thread bound: " + f"thread={binding.label} role={role} cpus={actual}" + ) + return True + + def unbind_current_thread(self) -> None: + tid = int(self._native_id()) + with self._state_lock: + self._bindings.pop(tid, None) + + def register_child( + self, + name: str, + pid: int, + role: str, + *, + allow_fays_stage_threads: bool = False, + cpus: Optional[Iterable[int]] = None, + stage_policy: Optional[CpuPolicySnapshot] = None, + ) -> None: + """登记一个子进程的 CPU 域供审计器维护。 + + Fays 子进程的 ``role`` 仍然记录为 ``fays_background``,但其实际 + 启动域是全部 Fays stage CPU 的并集。已命名的 native + 输入、预处理、特征提取和跟踪线程由 ``_FAYS_STAGE_ROLES`` 收窄到 + 对应 CPU。LocalMapping/LoopClosing 及其他未识别线程保留在子进程 + 启动域,避免长期后台计算被压到单个逻辑 CPU。 + """ + + child_pid = int(pid) + if child_pid <= 0: + raise ValueError(f"invalid child pid: {pid!r}") + child_cpus = tuple(sorted({ + int(cpu) for cpu in ( + self._policy.cpus_for(role) if cpus is None else cpus + ) + })) + if not child_cpus: + raise ValueError(f"empty child CPU domain for {name!r}") + if role not in { + "left_process", "right_process", "fays_background" + }: + raise ValueError(f"unsupported child CPU role: {role!r}") + if allow_fays_stage_threads and role != "fays_background": + raise ValueError( + "Fays stage thread routing requires fays_background role") + registration = ChildDomainSnapshot( + name=str(name), + pid=child_pid, + cpus=child_cpus, + allow_fays_stage_threads=bool(allow_fays_stage_threads), + stage_cpus=( + tuple( + (role, tuple(stage_policy.cpus_for(role))) + for role in sorted(set(_FAYS_STAGE_ROLES.values())) + ) + if stage_policy is not None else () + ), + ) + with self._state_lock: + self._children[registration.name] = registration + + def bind_child_process( + self, + name: str, + pid: int, + role: str, + *, + allow_fays_stage_threads: bool = False, + ) -> Tuple[int, ...]: + """Apply and register one child CPU domain through the sole owner.""" + + child_pid = int(pid) + cpus = self._policy.cpus_for(role) + actual = self._apply_exact(child_pid, cpus) + self.register_child( + name, + child_pid, + role, + allow_fays_stage_threads=allow_fays_stage_threads, + ) + return actual + + def bind_fays_orb_process( + self, name: str, pid: int, + policy: Optional[CpuPolicySnapshot] = None, + ) -> Tuple[int, ...]: + """Apply the full Fays-stage cpuset to the ORB process. + + The child is registered with the ``fays_background`` role for lifecycle + bookkeeping, while its audited domain is the union of every Fays + stage role. Otherwise a worker created by TrackStereo cannot bind to + its ORB CPU. Native LocalMapping/LoopClosing threads are restored to + this complete child domain by the affinity auditor. + """ + child_pid = int(pid) + selected_policy = policy or self._policy + cpus = selected_policy.fays_process + actual = self._apply_exact(child_pid, cpus) + self.register_child( + str(name), + child_pid, + "fays_background", + allow_fays_stage_threads=True, + cpus=cpus, + stage_policy=selected_policy, + ) + return actual + + def bind_child_process_for( + self, + policy: CpuPolicySnapshot, + name: str, + pid: int, + role: str, + ) -> Tuple[int, ...]: + """Apply/register a non-Fays child with one slot's CPU policy.""" + cpus = policy.cpus_for(role) + actual = self._apply_exact(int(pid), cpus) + self.register_child(name, int(pid), role, cpus=cpus) + return actual + + def enable_dual_slam(self, track_cpu: int = 6, input_cpu: int = 5) -> None: + """双设备模式:第二套 input/fays_input=5、track/output=6; + 其余角色与单设备严格分区一致(general=10/11)。""" + with self._state_lock: + self._policy = CpuPolicySnapshot.dual_slam( + track_cpu=track_cpu, + input_cpu=input_cpu, + ) + + def enable_balanced_dual_slam(self, *, secondary: bool) -> None: + """切换到现场验证后的双设备正式性能分区。""" + with self._state_lock: + self._policy = CpuPolicySnapshot.balanced_dual_slam( + secondary=secondary, + ) + + def enable_exclusive_dual_slam(self, *, secondary: bool) -> None: + """切换到两套 ORB 子进程互不共享物理核的实验分区。""" + with self._state_lock: + self._policy = CpuPolicySnapshot.exclusive_dual_slam( + secondary=secondary, + ) + + def child_affinity(self, pid: int) -> Tuple[int, ...]: + """Return a child affinity for controller-side post-bind checks.""" + + self._require_api() + assert self._get_affinity is not None + return tuple(sorted( + int(cpu) for cpu in self._get_affinity(int(pid)) + )) + + def unregister_child(self, name: str) -> None: + with self._state_lock: + self._children.pop(str(name), None) + + def audit_task_group( + self, + pid: int, + *, + allowed_cpus: Optional[Iterable[int]] = None, + allow_fays_stage_threads: bool = False, + stage_cpus: Optional[ + Iterable[Tuple[str, Iterable[int]]] + ] = None, + ) -> int: + """纠正父进程或指定子进程中越过职责边界的线程。""" + + self._require_api() + process_pid = int(pid) + own_process = process_pid == int(self._process_id()) + with self._state_lock: + bindings = dict(self._bindings) if own_process else {} + + general = set(self._policy.general) + child_domain = {int(cpu) for cpu in (allowed_cpus or ())} + child_stage_cpus = { + str(role): {int(cpu) for cpu in cpus} + for role, cpus in (stage_cpus or ()) + } + if not own_process and not child_domain: + raise RuntimeError( + f"missing CPU domain for child process pid={process_pid}") + + tids = { + int(tid) for tid in self._list_task_ids(process_pid) + } + corrected = 0 + assert self._get_affinity is not None + for tid in tids: + expected_binding = bindings.get(tid) + try: + actual = { + int(cpu) for cpu in self._get_affinity(tid) + } + except ProcessLookupError: + continue + + if expected_binding is not None: + expected = set(expected_binding.cpus) + target = expected if actual != expected else None + elif own_process: + target = None if actual and actual <= general else general + elif allow_fays_stage_threads: + task_name = self._read_task_name(process_pid, tid) + stage_role = _FAYS_STAGE_ROLES.get(task_name) + if task_name in _FAYS_CHILD_DOMAIN_THREADS: + expected = child_domain + elif stage_role is not None: + expected = child_stage_cpus.get( + stage_role, + set(self._policy.cpus_for(stage_role)), + ) + else: + expected = child_domain + target = None if actual == expected else expected + else: + target = None if actual == child_domain else child_domain + + if target is None: + continue + try: + self._apply_exact(tid, target) + except ProcessLookupError: + continue + corrected += 1 + + if own_process: + with self._state_lock: + for stale_tid in set(self._bindings) - tids: + self._bindings.pop(stale_tid, None) + return corrected + + def audit_once(self) -> int: + corrected = self.audit_task_group(self._process_id()) + with self._state_lock: + children = tuple(self._children.values()) + for child in children: + corrected += self.audit_task_group( + child.pid, + allowed_cpus=child.cpus, + allow_fays_stage_threads=child.allow_fays_stage_threads, + stage_cpus=child.stage_cpus, + ) + return corrected + + def _fail(self, reason: str) -> None: + with self._state_lock: + if self._faulted: + return + self._faulted = True + message = str(reason) + self._logger(f"[CPU-ISOLATION] FATAL: {message}") + if self._fatal_callback is not None: + self._fatal_callback(message) + + def _audit_worker(self) -> None: + if not self.bind_general_thread("cpu-boundary-audit"): + self._fail("cannot bind boundary auditor to general CPUs") + return + while not self._stop.is_set(): + try: + corrected = self.audit_once() + if corrected: + self._logger( + "[CPU-ISOLATION] corrected " + f"{corrected} thread affinity violation(s)" + ) + except (OSError, RuntimeError, ValueError) as exc: + self._fail(str(exc)) + return + self._stop.wait(AUDIT_INTERVAL_SECONDS) + + def start_auditor(self) -> None: + with self._state_lock: + thread = self._auditor_thread + if thread is not None and thread.is_alive(): + return + self._stop.clear() + thread = threading.Thread( + target=self._audit_worker, + daemon=True, + name="cpu-boundary-audit", + ) + self._auditor_thread = thread + thread.start() + + def stop_auditor( + self, + timeout: float = AUDITOR_JOIN_TIMEOUT_SECONDS, + ) -> None: + self._stop.set() + with self._state_lock: + thread = self._auditor_thread + self._auditor_thread = None + if ( + thread is not None + and thread.is_alive() + and thread is not threading.current_thread() + ): + thread.join(timeout=float(timeout)) diff --git a/collector/core/gripper/sightac_sdk/API_VERSIONS.md b/collector/core/gripper/sightac_sdk/API_VERSIONS.md new file mode 100644 index 0000000000000000000000000000000000000000..38bc00a1056755a53e16594998fb6570de3b77bb --- /dev/null +++ b/collector/core/gripper/sightac_sdk/API_VERSIONS.md @@ -0,0 +1,27 @@ +# Sightac API 版本 + +生产默认继续使用经过现场验证的 `api`(2.4.5)。版本选择必须显式,不能通过 +替换目录或修改 `sys.path` 顺序暗中切换。 + +| 包目录 | 用途 | 默认加载 | +| --- | --- | --- | +| `api/` | 当前生产稳定版 2.4.5 | 是 | +| `api_legacy_2_4_5/` | 2.4.5 完整恢复快照 | 否 | +| `api_v3_2_2_ksq/` | 新兼容版 3.2.3-ksq.1 | 否 | +| `api_new/` | 厂商 3.2.2 原始参考包;目录结构不完整 | 否 | + +新兼容版以稳定 2.4.5 上位机契约为基础,保留 `defer_baseline`、 +`read_raw_frame`、`preprocess_raw_frame`、`process_raw_frame`、 +`update_frame` 和 `update_calculation`,并合入斜面款负 Hue 不参与 Fz +标定的修复。新旧目录携带的 `libSonixCamera.so` 内容相同。 + +仅在完成 `FAYS_ONLY.md` 的现场顺序验收时,临时选择新版本: + +```bash +KSQ_SIGHTAC_API_PACKAGE=api_v3_2_2_ksq \ + /home/admin1/gripper_env/bin/python \ + /home/admin1/KSQ_Gripper/gripper_version1/upper_computer_fays_opencv48.py +``` + +不设置 `KSQ_SIGHTAC_API_PACKAGE` 时始终回到生产稳定版。紧急恢复快照可显式 +设置为 `api_legacy_2_4_5`;不得删除或覆盖恢复快照。 diff --git a/collector/core/gripper/sightac_sdk/api_new/__init__.py b/collector/core/gripper/sightac_sdk/api_new/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..48728e518a1f53aacb5f51828569a327e1a78f43 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/__init__.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:47.704240 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\xb0\x02\x00\x00\x12\t\x04\x00\x06\xf9!\x9cF\xf9{jW\x03\x87\x8f7\x81\xa0s\x00\x00\x00\x00\x00\x00\x00\x00\x86Y\xa2\xf1\x1f$\xca)\xa0f/\xd0\xcf\xb3\xc9\xe7@4\xec\x89\xc139\xf6cK9\xd3BG\xe3\x80\x8f\x15\x15\xd8\xb2\x9d\xf0?!8T\xc8\xaf\xa8\x91,dV<\xd1\xda\xb3\xbf5\xb8\xd2\x84\xf5\xe5i\xba\n\xbf\x1d\xaf?.Y\xe9\xff\xbcy\xd5\x04)!\xff\x14,\x02\xa8\xe9\xac\xbe\xc9\x03\xad\xdcv\x93\xf0\xa6k\xf8bOw\xc5\xaa\xcf\xeb\xb0\xafO\xec\x94\x9c\xc0\xa1\x11&E\x9a6\xef\xdd\xfag\x84a\xfej\xe8-\xf9qy\xc3G8\xee(\xf9\xf8\xb5o\xdf&\x04\x9dp\x84Ox}V\x84\xfc\xfd\xffZ$\x1f\xd0}\xb2\\Q\x90\xedY\xdd\xb2\xd9\x1c`d\xb1\xa9\x80\xe3\xfa\x81\x987sx\xa8X\xf2\x14o\xc9\xd4~\xe2\xda\xf9\x06[\xe36\xd7\x96\xd4\xfbM\xcbv\x16\x9a\xc7\xb5q\xc7\xf3\xd4\x9cyy(\xe9m\x03.\x94Y(|/\xab\xed+\xa6h\x01Q>\\\xef\x0b\x92\x034l5Cuz\x1c\xa4N>~\xf8&\x19\x05\xa1W\xa0\xa0\xf5\xe2F<\x82+\xef<\x84\x9f\x8c\xd1Z\x935D\x89\x8bH\t\xd4\x99R\x85\xa1\xc8!\x13=4f\xdf\xbb6\x12\xab\xb3\x14nZ\x1aF\x8al\xbc\xab\'7\xa8\xae\x85q\x07\xee&\xc8\xda-\xe1\xe5+\xa6\xaa~jN\x13\xc1\x88\xed\xff\'Y\x0e\x05\xf9l7jb#\xe3\xc9\r\\\xb9)\x9c\xcb|\xb6\xc2/\xe3{\xc2u\x05\xb6/4KY\xfe\xe9Yt\xdd\xd4\xeeNV\xfe%\x0c\xfdJj:\xa2\x84\xb3\xae\xfbu\xc9\x05g\xdc-\x92%\xbf.\x80\x1c+\xe9\xb3t33F\xba\xee\xe8\xe0\x19\xd1y\x8b\x13\x8f\xf6\xaa\xa6\xf8\r\x06HO\xc0\x11d\x07\x14\x9f\x1e&\xe7x\x07\xb4\xbe\xed\x9bC\x12x\x88\xd5\x0f\x85\xff\x85\x9e\xfc\xae;\xc2\x80\xd5\xf6\t\xc9\x15F\xee\xba\xf3\xc4\xf8\x9c>\x87\x08\x08>\xecF\x06\xbf\x99\x9f\xc3?8\xc9f/D\xf5\x05\'\xbe\xc8\xb2%e\xd2!X\x87\xe7\t\x0e\xd6x\xc4\xcdH\xac\xec\xdd1\xab\xda`}S\x90\xa64\xb1\x8fN3\xf2\xb8\x8a\xd7\x92\x15^%!Z\xc54\xac\xf8\x1b\x9d-\xec\xda\xd7<\xfd\xa2\xe8\x17?9\xe5\x1e\xdb\x1a;\xa7U#\'\xe6\x0f-\xc8\x95\x96\x00\x92\xaaIR\x1b\x80\xd8t"c\x99\xb7?\xe4\t\x17*\xe1\xf1m;z6rA\x00~r\x9d\x9d\xa7H\x06u"e\xbf(9@\x86C\xf0\xdc\xc0\x9c\xaczD,P\x8e\xe6\xf9p\x00\xd6IgOW\xde\x82\x9d\xb6R8\xfe\x7f4\xd0\xc6\xb5\xe5\xce\x97\xaa!*r\x8c\xaf>^\xeceW\xd5\xef\x07\xe0\xcd\xbe\xbe\xe1\xa2\x99De\xb6Lhj\x86\x8fW\x8d\xff&\xf0\x10\xa5,\xac\xccQ\xdc\x99\x12\xc3\xa8\x8f\x1c\x80}\xd0\x99\xbb\xdf\xb8SREL') diff --git a/collector/core/gripper/sightac_sdk/api_new/libSonixCamera.so b/collector/core/gripper/sightac_sdk/api_new/libSonixCamera.so new file mode 100644 index 0000000000000000000000000000000000000000..5d1b2329e52880f9986538639e6618df08dc0f7d --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/libSonixCamera.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f016ba98f81a7acdb1c33dcbfa5de9b756bee671df8c3d6c9a7506170d95063c +size 167528 diff --git a/collector/core/gripper/sightac_sdk/api_new/parameters.yaml b/collector/core/gripper/sightac_sdk/api_new/parameters.yaml new file mode 100644 index 0000000000000000000000000000000000000000..dfe2467345aa38dedb7d8b51310d828eac10be9d --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/parameters.yaml @@ -0,0 +1,80 @@ +# Farneback光流参数 +params: + pyr_scale: 0.5 # 图像金字塔缩放比例 + levels: 4 # 金字塔级别数 + winsize: 61 # 搜索窗口大小 + iterations: 7 # 迭代次数 + poly_n: 7 # 多项式邻域大小 + poly_sigma: 1.1 # 多项式标准差 + flags: 4 # cv2.OPTFLOW_USE_INITIAL_FLOW # 标志 + +# 单元格大小 +cell_size: 1 + +# 步长 +optical_flow_step: 35 + +# 压力缩放系数 +pressure_scale: 4 + +# 压力图显示模式(0=灰度,1=彩色,2=3D指尖视图,3=3D点云视图) +pressure_form_switch: 3.0 + + +scale_factor: 0.5 + +# 默认端口号 +usb_id: 2 + +# ROI区域 (640x480分辨率) +roi_x1: 0 +roi_x2: 640 +roi_y1: 0 +roi_y2: 480 +display_angle: -1 + +# 触摸状态阈值 +contact_threshold: 10.0 +release_threshold: 8.0 +slide_threshold: 1.0 +slide_force_std_threshold: 0.2 + +# 摄像头参数 windows系统平面款器件 +#camera_params: +# hue: 0.0 # 色调 +# saturation: 50 # 饱和度 +# gamma: 251 # 伽玛值: +# auto_exposure: 0.0 # 自动曝光 +# exposure: -5.0 # 曝光值 +# contrast: 50 # 对比度 +# brightness: 0 # 亮度 +# sharpness: 100 # 锐度 +# auto_wb: 0.0 # 自动白平衡 +# white_balance_blue: 4600 # 白平衡色温 + +# 摄像头参数 windows系统fpc平面款器件 +camera_params: + auto_exposure: 0.0 + auto_wb: 0.0 + brightness: 10 + contrast: 10 + exposure: -5 + gamma: 100 + hue: 0.0 + saturation: 64 + sharpness: 0 + white_balance_blue: 4600 + gain: 18 + +## 默认摄像头参数 (根据 v4l2-ctl -d /dev/video2 -l 输出配置) +#camera_params: +# hue: 0.0 # 色调: min=-180 max=180 default=0 +# saturation: 64 # 饱和度: min=0 max=100 default=64 +# gamma: 300 # 伽玛值: min=100 max=500 default=300 +# auto_exposure: 0.0 # 自动曝光: min=0 max=3 default=3 (Aperture Priority Mode) +# exposure: 0.0 # 曝光值: min=50 max=10000 default=166 +# contrast: 50 # 对比度: min=0 max=100 default=50 +# brightness: 5 # 亮度: min=-64 max=64 default=5 +# sharpness: 50 # 锐度: min=0 max=100 default=50 +# auto_wb: 1.0 # 自动白平衡: default=1 +# white_balance_blue: 4600 # 白平衡色温: min=2800 max=6500 default=4600 diff --git a/collector/core/gripper/sightac_sdk/api_new/platform_utils.py b/collector/core/gripper/sightac_sdk/api_new/platform_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f906d62a1f45cb4fe627bb0cead13ebddd472602 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/platform_utils.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:47.771312 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\x1a\r\x00\x00\x12\t\x04\x00\xe7\xcf\xa2\x98Nr\x8f\x86H\x03IC\x8c\xdc\x0b\xd2\x00\x00\x00\x00\x00\x00\x00\x00h\xc9\x9af\x88\xa8\x12*S\xcf7O\xc6\x14\xaf\xf238D44K\x93s=T\xbdp\xdb\xeb)K\xa6^\x02\xc4\xe5\xeb\xbc\xe9?u.\x1d\xe5\xdf\xa5\xe2\xbc@\xa5\x8c\xf9j1u0K\x9a\xdd\x9c0\xe7\xf7l&\xbe\xd0+6\x1a\xe1\x05\x99\x98\x8aT:\xdd\xae>R\xcf3D\xdf\x8d\xc0\xcc\x95\x8at\xce\xea\xf5\xc0\xfa\xdbh\xc82\x9d\x0f\x95\xdbh\x02@c\xbc\x07\xb3\xf3\xf6\xf9q\x97K\x1f\xfb\x10\x9d\x92\xef%|Y\xaa;3\xba:\x94\x90}>M\xaaeH\xc0OG\x8c}\xd8\xc1\xac\x17\x8eA\x08\t\xf8\xf5\\: R>G\xc4\xb9\xd4q\x86\x0e\xdf\x8aU\xb4\xdc\xb7c \xe6\xbcd0\xe3w\xfd)\xd4\xbf\x89j\x11z\xd5\xa3\xc4F?S\x90\x04cM1\\q\xb9\x96>@\xf4u\x11\x15\x16\x98\x03\xfcZ/_f0&S\x1c;\x15\xfb\xb40<\xfa\xc9l\xce\xbb\xaa\xb0C\xe9\x86\xae\xa9\xb1\xd6\xfdc<8\xf0}\xba\x06\xfb\x0f\xe5(\x11\xdd\xfa\xa3\xed\xae\\\xd4\xc2\x1e\xa3\xe1\xcf\xf0\xc8\x10\x9a\x88\x99\x93\x115T\xaf\x9f\xda\xdb\xa6\xff5\xddma\x04\x13\r\xaaB\x19\x88\x0f\x7f)\xfb\x1e\x0c\x8b7j\xea\x9a\xa4H\xbb>\xcd\xef\xabK\xef? ^o2KW\xce\xae;\xec8\xb5}\x86\xd4?\x85\xb1\x83Z\xf8\xa7\x04\x81\x9f\xe6\xb8"@>.\xc6\xe0\t\x1eHL?\x07\xfb\xb0\xb52k\x87X\xd1\xc9\xc6\xbc\xef\xcbT\x1aU\xa0\xabqW\x12\x88\xab\xff\x1e\xd8x\xa0\x9bZ\x84.!g#\xc46\xa6\xc6U\xee\xeb#\xe6\x9fz\x86w\x90\x96K\xf7\xdel\xc6\xb4_R\xe3\t\x9f\xfa\xd1lx\x12t&\x11\x11\xe8\xbdK\xa5o\xf2\xedN\x95\t\x8a\x8aN\xc0\xe2\xcd\xdd\xfdx\x02\x0f\x17\xe4\xf4\xdf"8\xa2Dqf\xfb.\xc1\x0f\xe2\xfc\x82\x92\x9b\xd3\x8e1YA\xf2\xb9\x94*\xaaR4h\x1c\xd2\x02\x19\x99\xe2;\xf2o\xb4\x0b\x81\xca;\xc5\xbb\xce\x9c\x18\x85\xa7*G\xba\x85RQ\xde\x16\x06qq\x1c\x85\x80\xa0\x02&fn\x82\xa0T4y\xfb\xfa\x01\xcfy|y\x88\x81\xfc\x14K\x12w\xc0\x86\x82vX_\x8bR\xc2\xe9^T8\xaf\xe9\x84\xaf\xd1^\xbe\x80;o\x04,O\x92c\x9b8=\x0e\xea\xde\x12\x8f8\x0bC\x03\x1dk\x84\xd8/X\xf8}9\xe3\xcb\xab<\x99\xaf\x99#\xfd\xc5\x83"]cd\x01"\xdf\xd0&\x06\xf7\xaf\xb8\x84\xca!\x8aw,\xecs\xbaF\xb6F|\xa5\xfdW\x88\x10\xc6\xea\xa0\xfa\xcdv\xc1\x97n\xda8\xf9O+5\xa0\xf5\xaa!\xbdp\x19\x8c\x9b_\xf7\x18\xc9\xe5\x0f\x8du\xc32?\xd0F\x86\xd7\xc0\x9e+/\xc29\xf8PN\xcfw\xcbE\x7f7\xf3\x89*\xf2\x12n\xce\xf7T\xd7\xbaV\xcfG\x8b\x08\xf3>!\xe2\x03\xa0\xad\x9b\x93;\xe6[{\xe3\x13X\x11[\xf7\xa5\x89\xe3q%\xc7\xd1\x12\xbaEmy\x9b\xb4\x9d\t\x7f\xce)v\x99\xcb)\xa0\x82\x8b/\x8d\xa1\xfam\x1a?\xc7<\xcez\xbe\x05Yr\xe9\xae(\x0f\xe5\'\x85\xcf\re\x80;\x1f\xb1\x18\x17\x18\x969\xe7\xee\x84AL\xbb>\x06\xf5\xcf\x99\xa1t\xde\x08\x93\x18;\xbfs\x1b\xc0\x81{V\xf5N\xf8\xdfZ\xd4Zr\x90\x941[O\x15!\x88\x06\x90&@\xd6\xeb\x86!\xfc\x80\x05A\xc3S\xff\xe8\x9b\x9e\x13TX\xf9\xf5\xe5\xfd\xfc\xc9\xfe\x00$\x8fao\x9cd`\xf9j\x95T*\x8e\x9d\xb8DR`=XL}\x89cwn\xe6\xcb&\x10\xf7<\xf3\x97\xcf\x86\xbd\xc6\xb9?\x06,\x14\x90\x8cx\xc0k\xc3\xa80\xa0\xfc\nRp\x1f\x8c<\x8a\x83\x0f/\xd5\x89b#/u\xcc):\x11\x81m\xf0L\x1f\xe8\x1c\x9b9\xf5\xf4\xc4n\x1e\xb8\x83k\xbf\x1a\xc3\x16$\xc7b\\\x9cQzY0\xee\xb0k\xbf\x86"\x1f\x02G\xf5\xcb\x8b@\xc8::\xc3\xff\x1eS\x19=\x12\xdc\xf9\xc54\xe9KK\x94\xdc\xbb\x92\x1c\x0f\x03WC\x14\xa0\x86\xfd\x0e\x9fk\x1b\xba&\x13\x13\xb5F\xce\xf0\x1fQk1\x86.\x9e\x0e_\xef\xce\xa2\xcf\x82\x08\x12\xfa\xd5>\xb1\x8ee\x17\xb0\xd1\x8fV\xca\xdf\x82\x05oG\x9dvT\x15\x8a\xa2\xed\xc1/Y\xcb\xe8\xee\xa2\x1f\x103\xc7\x05\xc3d\x92\x8do\x00\x94\x99\x16\xea\xb2]\x9bQ\x8e\xa2\xcd\xfd\x8b-\xa5{\xbc\x7f\tZa|\x15\x07Q\x18\xc3\xeb*\x15mN\x15!)\x07\x01\x99L\xda\xd8\xfcn\xb9+*)\x88\x1f\xd6A\x19\x9ba\xfd/\xaa\x9fc\xb3\xf8\xc3\xb6\x96\x87\x15,\xa7\x89\xfe%y\xce%\xdd\xa7\xd3\x12\xd3\x1c\xa7r\x06\x95\x8c\x91\xcc\xdb2b#RA\x9d\xe0&\xd2\x14\x91R\xd2+\xcf\x1bS\xb1\x80)0\xc0\xb3L\x9ag-\xa1@\xb5\xd9:\x99\xd5:.m\x05n\xb3[%\xf6\x0f_;\x95\x9fL\xb8z\xd8\xcf\xd6\xc2\x8f\xfb\x02\xe6\x9f\xbdD\xb3!\x87\x8c\xa4\xe0\xc8d\x0cF\x94\xec\xa4]\xbaL\xea\x94\xba`\x9e*\x08\x93G\x80\xb3L8\xf1V\xfc\x0bN\xda@\xd3q\x17\xb1\xd0jm/\xdd\xda\xc6\x88R\x03{\xca\x11XS\xad\x19g\x96\x1dK\xde\xb8B\xbe\xce\xbb\x0f\x9b\x80\x9f\xf4\x04+\x19:\\\x05\x99\xf3\xee\xa6\xf4\xc6\x1b#\xed!\x02\xd3j\x8dN\r\xc6\x00n\xd3\xaf\xfb\xe0\xbc\x02g\xac\x80\x08L\xc9vB\xe5\x89\xb7Y^0j\xf5qL\xb7\xe6\xde\xf7\x8e\xcdG\xd84Gr\x88\xe4c\x93\x14N\xe2\xf7^\xd4;=!\x96\xc6\xb5\xba\x06\x96\xf9\x88\xdb\xab\x18\x0f\x19u\xa8\xb3\xad\xf46*\xf5\x99\x19\x9e\x86;\x91\xe8\xc3\xbb|p\xc7L\xfd\xf1\xbe\xf28\xbb\xe3#\x02F\x0ej!\x01\xef\x11\xe9\x87$\x91\xd0W\x18C,4\x03\x11@\x0f\x14\xe2r\xcd\xca\xd7\xf4\xc5\x9c\x94\xfe\x06\\f\x86\xbfo\x8b\x80\x8c~E\xf6\x1e\xbd\xf5\xa7\xb4?.\'hfL\x86\x81\xc9\x19C|\x80\x0eL\xa7Vim\xc4l\xaf\xe37(\xb4p\x9e\x0e\x1a2&1|\xe8\xc3\xbc\xc6\xe0\x07v\xd3j\xbftM\xd9\xf4\x91\x7f\xe6\xe1plr\xccUMj\xb7\xe2\x17\x06p\x18\xd1$6!\x03\x80\x9dc\xec>\xc2\xc6\xe0\x8a\xd2Ds\x19O96\xa2uV\x1fq\x9f\x91\xe4P\x85o6D\x07\x86\xd3w\x00a\xc8\xd5\xd2\x06\x90U\x9e\xa8\xa0\x8a\x8bq\xeb3/\xb7\xe8f\xf4\xf3\xde\x17\xae\xd1[h\x15\x06G\x97\x17~\xe9\x85\x90h\xdc0&\xb9\x11,\xda\xa8\xb3~.\x19\xb1\x0c\x16\xd2\x83\xff\x85\xdf[y>\xc9\xef\x07\xd8\x89\x9at\x17\x1b\xd0o\xb5I\xedJ\x9a>\xe4\xebY\xb99\xb6\x16\x11H\xf2W\xe8\x1b\x8c\x86\xdf\xe7\rT\x17\xb3\xa1\x9bMg\x98\xb1M\x8f,\n\xef8\xc5\xb5>!t^J\x1dw\xe4o\xe1)\xd8\xe4u\xe3X\xe6\xabi\x9e\xb9#\x0f\xb3,J\xb1\xba\x9dfm\xcb\xd5\x9e]\xc4\xbdV6\x89\xd2\x8b\n\x99,\x01Nl\xd3\xe3qB\x8d`{\x0e\x9d\x12\xc1\x18\xc6+\xf5\xf1\x13\x92\x19\xec\x14m\xa9$G[\xb9?\x89\xac\xf8\xfcssT\x0b_\xaa\xae\xbeS9\x05\xfe\xbf\xb1\x87\x05X\xca@\n\x04\'}\xe7 \x87\x9b"\xc1\xcc\xcb,\x8f\xa0=v\x08\xda\xfdX4\xd2.\xe2Z_z\xf0\xfd\xbf\xd5m\xb6\n0L\xe6q\xa4\xf3\x17PvF\x04|\x03\x8a\xb2i\x05Bxb\x8b\xa9\xb0\xc5]\xe6\x1bn\xd2H\xb5\xdd!E#\xa8J\xc8C\xf1\xea&T+r\xac\xf7\xc1;\xd8\x04u5O\xcf.\xb4\xf7\x8eq\x13\x9b\xc9F\x91/\xf9\xe9\xd7\xa9\xbds\xc5$h\xdd\xa4\xcc\xd1\x9a\x0fg\xfdR sK\x9bB\xec\xa3$[\xed\x9b:\xe3\xfa\x87\x8ec\x04,\xcfm9y\x02\xf0]tTMA\xa7\x03n5L\x16X\x86D\x95\x9e\x86\x83x;\xc5J\xd1\xafO\x98\xfa \x8f\x8f\xfc\x13\x93_\x1e\xa4\xe2\x1e\x03R\xc3i\xa1\xb4\xaf\x9a\xd8\x91\xe2\xaam\x0f\xa3\xb6\x0f\x85\xe1\x7f\xca\xa2\xa2\xa0\xf9\xb1\xb4\xea\x1aJ\xdf\xa6\x1eu\x04\xd5\xef\n\xa8\xaa\xec\xb5\x91\x140X\xc9\x8b\xbe\x9fa\r\x1b\xb1\xfc\x07A\x980\x07\xdc/\xca\tE{\xcf\xef\xb7{\x90\x9e\xb7\x97\x8f\xfb8\x065K\t\xe0V\x15\x16\xf2\xa8Z\x19\xd3\xc6:\xa6\x8a\x87\xc7*\xfe+5M\xe5y)\xd9\xf8\xe3\xcb\xe3\xeay\xe9V\x84\xa0\xe4?A\xf7\xf4/\xe8\xa5\x95z\x05\'\x16\x057\xaa=\xe1\x1f{$\xec3g\x10D\xfa\xe5\xe6\x05\xca\x99\xb0\\\x9ac\xbew\xb5+GD\x18s\\Q\xban\xc7\xf8?\x8c\xf9|\xb2\xbc\x85\xe9\x96\xf3\x86\xe7K\x0b\xfeO~b\xa4\xf1\xf7\\b\x02\x0f{\xd2\x89\xd5\xc4\n\xec\x87ZNr!\x95v\xda\x16\xdcI\xca(k\x7fH\xe9\x89\x9f8\x16\x9f\xbb\xe8`\xb2\x1e\xe9\x1cMA#\x8b\x1c\xf9\x16\xe7kook]v\x95\xd8\x83\xc6k\ngB2\xca=\xa7\x9e@\x168\x86\xf9T\x08\xe2p \x92\x10"&L\xe8{:\xb9v\xc3On\x84\x19\xe6\xf3\xa5\xaa\xae\xdfK\x9d\x91\x0c=\x11B-V\x9e\xbb\xb1\xb3x9\xe1 \xf8&\xfc1\xc5\xf7\x08%\xbe\xe4P\xbc\xeb\x9f\xd8\x07\x7f\xb6\xe6\xdb\x85\x8c\x82\x96\xea\x0f\x06\xf1U\xb6\x9a,\x95+L\x07\x14mJZ)r\x81M\xceD,S\xb8bb\xf56\xbe\t\x96\x96g\xf1\x8d\xde\x11:u\xe7\xea\x9c\x06\x00LeG\xf4\xe8-rn\xb7\xb1\xc9\xb4.\\\xa3\xce\xef\xf4{\x0f%s\x03\xbdv\xd5{)\xa0\xa25\xb2\x82\xfcO\xf48\x89\xb5"][$P\x8a\xc6D\x8e\xdf\xd4(K\xf13\x00\xbf\xe4\xf5\xb56\xf3\xa0\xa4\x8f5\x08\x9b\xba\xc3\xf0\xfb\xd9z\xf6\x02 \xca\xa3\r6\xd3xslU/z\xc7Y\xc8\x1cQ\xe3\x0e\x93B\xd4u-J\x96P\xcf\xda\xeb\x9d\xc2\x1a7\x8cY\xde\xbc0M\x06u\xab\xf5\xb8u0\xe7&\xe1\x97\x00}\xd3&7\x98\x8c\x9d\xf2\x8e\xc5u\xf4\x05\xa6\x18\xeb0!\x08{\xc5\xc9x\xe0&\xf5l\'\xf2\x1e5\r\x81\x87\xc7\xb1Ku\xc8\x8bf(u>\xaf\xb4\xe4\x00\xbb\xcc\x8b/\xcd\xc1\xb6JY6\x08uO\xcb\xb9 l\nd\x92\r7a\xd1\xa7\xc5a\x1f\xe8\x8f\xb7\xcc3G\xec\x016\xeb\xda\x7f\xa9k\xbe\xa7\x8f1\xe4\x88U\x9f\xe9o{\xa3\x92m;\xfdz\x02*\xdalr\xd0\x9fX\xba\xdaG\xfe6\xd3\xb6c\x96\x89\x1e|\x02(V\xdbJ\x86\xe7Vo\xf0\x02\'s\x12\xf8\x87\xe7J\x86b^Y\x06\x8f\xf0/\xbf\x10\xb4\xb6\xad070[\x9a\xb4h\xf7|\xf1Y\xada%yM\x0b\xf7j\x18\x07\x90ws\xe5G\xcdx\xb1\x82\xb6\xe1\xa1\xb2Im\x08\x9be\x13\x1d_\xa2\xe3\xa2\x85e\xcf\x8f\xda\xc8Du\xe5\xcf\x0c\x9b\x14\xeeY\xc3\x07\x0b\xb6\xadj\x82\xa7x?\xca\x8f\xf3\xc9m\x98\xed~\x1ePj\xddI\x18\xd0\xd5\x8b\xb0@|\x1fV\x9f\xea\x99\xf5\xfb\xd2*[\x84\xbb\x7f\x18\x90\x8c^\xf1\xces\xa0\x16\x95\xad\xe2\xc0T\xa2C\xaa]\xcf\x0e4\x1f\xf6^\xbe%h\xc9\x8cm\xe0\xf7\x97\xe5\xf1#u\x126s[P\xe8\x84L\t\x88jH\xc5*P\xdda\x8c\xfa\xe7\xd3\xc7H\xe7R\x0e9\xf3E\x04<\xb9K\x84h\x0c\x95\x84_/\xe34}U\x98\xf2\x16\xb0\xd9M,\x86\xb4h~\x1f\\p\x92\xa4\xb7L\xb1\x0b\x7f`_\x11\tMG\xa4\xdeV-\xca\xd0my@\xa4.\xaa\xfc\xc2\x9d:\xbb\xe6\x87\x07z\xbeF\xe6\xbaQ\x83\x0f!W\xc5\x15\xc5BgrD\x0b\x14:#1f\x84\x16\x10H\xd5`\x04\xc65uC\xad\x9aS\x91\x1a\x908*=\xa4\xe3\x9a|\xe3\xcd3\xa3\x8eo\x9d\x99:\x97\xdaP!U\x0c\x03mm\xc6j)\xcf\xec\x0e\x13\xa2\xf0~\xd3bFFt9\x8cc\xcb\x84dHo\x86\xe2IOZ\x8c\x0c\x0eO^\x04@\x90\xb7z%\xda\xeaj\xca{\xad\xc5\xd4`\xbf|\xcc\xd7\x17GSC|\x93t\xb6\xeb6K\xcb\xca\xce\xfdR\xf0\xa3\x1b\xb3\x9bs\xe0\xe5"\xee[\x7f\x02\xe6\rd\x16Z\xe3\xc2\x95_\x03\xcc\x84\xca\xbfQ\x9d,\n\xdc\x1e\x87K\x92N\xc7w\xad\xe4g"\xfb\x84\xe2c\x15:\xa4)\xfb\x1c\x05[c\x1e/\xd0/\xd6\xdf\x96\xd5\xec#\xc1Y;\x84(\xe5]\x83O\x1er\xd0\x8f\x18m\xa0\xecm\xea\x8e\xcd\x81\xa4\xda.\xb9\x17Gx\xe6\x14\xf2\xe6\xa0U\xd2\xcf\xaf\xc1\xfa\xefW]n\x9cG\x93\xbcPE0phe\xc6\xebuC;`k\xd9\xbey\x89j7\r\xa1\xf6K\xe8\xc1\xddXiYbU\xd4B\xf2u\x87\xe5\xe6\xb3\x8b\xf2|\x95\xa2EO\xcc\xdc\x18\xe4Vm\xf4\xb7\xed\x1e\x85\xc3r+\x98\xea\x8c\xb9_\x0es\x94-\xcc/\xb7\x87\xb9\xb5\xc0!1t\x04(RE@\x8b\x8a\xcd;\xfd$\xbe>\x1a\x1e\xf6:z[\xb0VN\x1bd=\x9d\xd0X%\xcf\xb2`\x11Fd\xf8J\xc3\xbb\n\xc8z=\x8b\x81\x06\x99\t\xc6\x11\xb0\x18i\x10\xf0\xaf\xbdW\x14+6\xb3 $G\xe4Vz\xa0/\xf6\xd7\x9cm\x86\xd9\x865&%V\x8bv\xdeht!]l\xde=\xc6i|\x92\x81\xae\x8aa\xd5\xf9@\x96E\x1eh\xc1\x9c\xdd~\x853\xb1\xf5-\xa0a\x15@\x0e=\x9c\xb5\x17\x0eF\x8e\xa7\xe2~\x8d,\xd0)r\x83\xa3Z\xd3Pv(\xb6\xb3\xe0 +\x89\x070hw\xff\xb3\x17\xe6\t}6\xc6\x81\xf5\xa8|B\x9f5\xb7R`\xed\x97\xfb\x102\xb1r\xa3\xb2\xbbO\x10V\x12\xbe\x90\x81eu\x1d\x1a,\x1b\xa0-A\xc3)p\xcd\xdf\xe1\xdeA\xcb\x8b\x17\x8c\xd3\x84N\x00\xf6\xb3o\x95\xc8`\xdevU\xc3\xf8r\xd1\xc9\x07\xa2\xd1wp\x7f\xaf\xb7\x1f\xcc\xb9\x1e\x07\xd9L)&\x85J\xf0s\xaa\xe8f\xfb\xa4.z\xba\xacT3%\xe5q\x102\xd9w\xde-\x8a\x8f\xc9\xad\xca\xa8\x99\xc3\xac\x15\xd7\x0e50\x9aca\x91\xd4\x9e\x7fh\x10]f?\xb6m`{\xb1Q\xafA\xe1\xa3o14\xdf\xf5\xe0\xd0\x9ff.V\x9f\xe2\xe0\xabB\x9dZ~\x8f\x16\xe3\x8d%\x96\xe6\xd4\xfa\x87\x00\x8b\tr\xab?\xd7\xbf\xda\xaa|\xe5I\\0\x0f\xcb,\x07)\xb7\xc8\xb6p8\x14\xdcG{>\xd3_\x1fI\xcci)\x8f1[\xa6EQ\x87\xa0\x93\xedxG\xdeG\xb9\xc8\xd4\x19&H\xb9\xe1v\x80\xf4\xc5Ig\xaa\x06\xf7Xd\xb6\x83\xfc\xf6\x1e\xc2\x01l\x8dk\x18\xf6\xde\xc1S\xca+\xd6\x8fM\xb2\xc3\x8bp\xb3\xd4j6\xdd~rt\xb8Z\xe8M\xb7\xd3N\x8c\xb3\xf5\x80pP\xfb\xf2[s\xc1Q\x83I\xb0\x1b\xc9\x9d\x18\xee~H1\x9aV\x7f\x83Vj\xd4\xa3\xd8\xd6\xa6\x9d\x1f\x94u\xdb\xbbm&^\xdc\xdf\x9e\x13K\x19*\x8e\x8dm\xa1\x04\x84\xb8_\xb5z\xc1xg\xf9\x00^.\x19\xdd\xb3\xa3\x83\xdd\x136\xf8\xa2\xfa\xc8\xbc\xf2\x04\xd4blk\xac\x12\x06(\xd9\xc3(3l8\x19\x8d\x85\xecv\xb1\xf7\xc0(@\xfa[\x11 \xea)\xc9[\x8b\xd0jjf|\xc2\x92@\xfb\xf2[,\xfb|\xa7RU\x81\xbb\x00\xdc\xb3\xa3\xa2!\t\xb6^\xc3\x01\xc6\xa4\'\xb3\x0f\x0b\x98\x95\xef\xd1\x9c\x98-8\xd5\xf7\x05\x16?\xb7\x96tA\xe8f\xe1\xb8M\xd6\xbfC\r\x94%\xc2%\xd9\xba\x972\xe6b\xd9zy\xa9\xe5\xaek\xac]\x16\x08\x91\xceH\xf5Hf\xf35e\xd5\x96\xd5\xaa\xdb\xb1\x04\xd3\x8c}\x1e-.\x14\x8cF\xe0\x9c\x97Rs/\xec\xd2\x1c\x10\xa8-\x87\xbb51\xb5!\xd58\x92b\t\\\x1a\xef\xa0\xde\xeb\x0c\x99bz\xe2\x99\xb4\x986Cv\xd5\xbe\x83\xaa\x9e2\x8c\x95\x02\x05}\x9f\xb0\xd7\xc4\xc8\xee\xe4n]\x0e\x80:\x90\x98Z/7\r\x8bk\xa9\xb4\xad\xf1\x0bp\xf4\xaf\xf14 \xe3\xb4\xc2\xaa\xeco\xcf\x98\xbe\x05\xde2\x10RN\x8bH\xf1\x86X\x08\xe9\xc8\n\xac\x9e:_\xf4\xbe\x97ne\xf0>O\x98\xa6\x1d\xf9\xad%\xb4\x04P\xedM\x1cT\xe9,\x1aU\xa9C.\xc4u\x175\xa0\xb8:\xf4eh\x03V\xa0\x02i\x9d`\xc7$\x89\xa5\xf7]~\x8b\xd2^B\xa8\xa5\xc1\xe47\x13\xa1*x\xce<$\xe0\x15x\xbd8}-G\xaaS\xcb)_[\x0b\x08r\xe7j\xdb\xb3=C\xdc\x84.\xa6\x02\xbao\x7fQ*\xe4\x92s\xd1\xe8\xdc7\xa0|\xa6kx\x14\x1b\xbc\xd4\x98st}\x0b\x01*\xe2\xe5N\x9e\x9d \xbb<\xcbwx7\xc4\xd7\xcd\xfb:\xef\x7fZ\xbd\x8f\xbd\xffuWR\xc0\xbf\xc8l\x0b\xaf\x08\xb9y\x86\t9\xf0\xd2c\xd0\x90-/\xf1\x1b\xce\x08,\xd2\xa8\xe23Aj\xb0|Iq\x18q\x85\x96\x05\xe7\xae\xda\x95A\xe0\xad?\xa1\xda\xd4\x8dq\x1b\xfb\x8aN\xf4f\x8aD\xc6\xe4\x1cV9b[W\xe4\x11\x17\xe2@%\xe0\xa78\xa6[\x97\xa7\x82\xae\x19\xe1\x08\xabO\x84\x06\x904/\xf8\x1a\xab\x84\xa7\x95\xc5\xff`\xacG\xcd\xfeC\xc9\xe1\xc9\x99z\x9dq\xbd6\x93k\x05\x87\xc9\xea(!\xdd\x86\x80\xf4\x90\xd6\x8a\xed\xab\x9f\xaa\xe6;\xd5\x88\xc7W\xc6(\x96\xdfW\x1f\x80\x04\x82\x915I\xb2\xf1\x14@S\x92E\xb0\xe1\x84%\x998\xaf\xa8\x01\x05\xaa\xa4\xbb\xeb4i\xff\xa3B;\xf9\x8a\x01\xe4*:\xbe\x97\xb7\xef6\x0e(oM\x0b\r\x89_\xc7\xe1\x8f\xd2\xaa\xb7\x93< \xce@\x9d\xd3\xf2\xc3\xbd$\x0f\xc8\xb0\xba\xaf\xdf\xb0\x00_\xe3\xc5i2Q\xf9\xb4\xdeJ\x1d\xdf\xf6\xb3\xe3\xdfw\x0c=5\x81\x85\xf9\xfet\xd6\xb5\x83\x8fB\xea\xde\x89?e\xab \x1b\xa1\xc3\x9a\x80\xbc\xc3S\x19$\x00\xb8\x9a\xdc\xe0\x8d\x89\xfc/I& \xe9\xfb58\x9e\xacW\xcc7\xccz\x0e\xcd\xee\xa8\xe2M\xab,\x02\x18\xcc\x16\x9a/\x9f\x81\xab\xe7\x7f0\xa4aP\x10jX$\xd8\x0f\xd7~,Y)\xaf0$\x852:\xf9{\xda|\x0e\xc1\x94h\x1b\xda\x1f\xdc\x08\xd04\xb9\x9c\xd3\x88LDiq\x98,\x8c\x94Sm\xc2\xd6b\x8d~W\xd80\xf3\xb2\xe5\xf8hX\xb5\x92L\xe9{\xf9$\xf2\x9a\x95`\xc0\x86\t\xe0a\xa1y+\x9c\x9cp\n\xe0\xc4\xfc%\xa9\xdb\x83m\x9cR\xa3\x04\xb6\xb0\xf7\xdcX\x88;Sp\xc1\x047[\xa0\xc0\x03\r\x1c\x88p\xc3\xbds\x01/\x8f\xcb\xb4\xc97@\x85\xd1*c\xd6+yt\xca@\x86\xa2\xc6Mx\x02\xeb\xd6\xb5\xa3\x88\xe91k\x8a\xa0]\xc3\xb5\x8e\xdd\x18\x0b\xbe\xfb0\xdfB\xabk]B\x98\xf77H:\xcd78\xb0\x81\xfb\x0e}\xf4\x17\xac\xfb\xf8\x85i,Wi\x13\x9d\xc7u\xa9\xd7\xe9\xc8\x03\x80 \\Z\xb6\x1c\x03\xe0\xe2\xea\xa6\xc7\xdb:6sK\xf7\x1d\xad\xc1\xd8gh(\xc6\xd4\\\x95`\xfc\xd1\xd1nb\xa6\x97\xca\x01\x13D\xb5`\x99\xce\x12:\xadv\xdcmR+If\x96\xcc\xb6\xb7\xf2?\xc2\xd7\xeb\xb0R\x0c\xa1\xe19!\xdb;\x94V\xd6\x1cG\'\xe7\x18\xbb\x0c\xbd,}\x0bio1\x0bR\xc0"\x02\x85\xbeT\xa9\xd6_\xd0Z[T\xf6iEA\xb4\x06\x12\xf7\xd3\x10\xf8\xb7_C;\x1c\xb6\xb6\xc0\x00)jH"#G\x15\xeb\xca\x07\x1ck\xfb\xa8\x1f\x87\xb0\n\x11\x18c\xd3\xe4\xcf\xc8\xf0\xa1\x12R\xc9\xf5.\x80\x17\xc8q\xd8Y\xe7\xfb\xe5\xea\x86!\x17\x92<\xc1\xa6\x81\t\xdcE#\xc3\xd1e\xd1\xee\xb4$\xe1\xb8\x93[b\xbe\x01`K\xf1\x1aTk\xf5\x96\xbf\xc2\xdasP\xb2\xa3v\xc6"y}g\xbc\x9b\xe1\xdaf+{_\\\x87\xf5hi\x81\xc2~;\x11\xad\'`\x9bJL\xec\xcc\xdbE\xb1\xe0%\x0b\xca\x94jG\xad\x06i\x8b\xfed(\xc2\x19 fm\xaa\xc39<\x93\x0e\x0f\x9a\xf8\xb09\xa3qT0\rb\xb1Sq(\x83,\xe0=\xe8u&\x81\xf6-8b\x96I\xa5\xc0C\xa7h\xebf\xcd\x99\xb6\xd0\x8d\xd4\xa8\xcb\xde\xab\xe7\xdarz\xc0g\xfc\x9d\x86\x0c\xa0d\'\x81(\xc4\xf4\xba\xf2H\xa6\xa9\xca\x8e\x00\xf2\x84\xb9@x\xd5:\x80-\xe0P\xf2\x82\xc1sv!\xb2e\xb9U\xb5\x8d@~\x88K\x92\x16k\x95\x83\x9d\xabd\xd0mN\x10q\xe68;\xdf\x86\x12\x1a\xd2Vn\xbcGBw!\x82\xf0\x92\xc4\x9cqY)P\x1c\x95\rXR\xcc\xeb\xf93[\x80\xfd\xe8\x92\x0c&\x112\x91\xc9\xd4z\xa0\\&\xa8\xf8CNp\xfdXT\xe7\x10\xd9xW\xc7\xd1\xa6+\xac\xc9\xd8Q[\xae`\x84w\xfcX\xd2\xb0\x1fi3\xc3!\xb1\xcc\xab\xc6\xc5\x02e\x1f\xf5\xa6~\xdd\xe8\xc1R\xa8\xc5\xf6\x81\x88b%\xfew\xaa^jR\t\xb0\x90\x8d\xf0\x13\xba\xd4\xdc\x8b\xcd\x97\xf1|\xe6\x83\x0c\xbcY\x9eb\tX]\x87\xc1\x1d05\xe6\x9d*\xd6\xbe2\xcf`\n\xc1\xba\x19e\x88(\xad^\x1fjg\x0eX\x00L\xa9 \xe7j"K%\xf7\xa9\xc1\x0e@m\xec\x8b\x1e\x9b)?\x9e\xe0\x05\x97t.\x83|\xc8!N\xf4\x07\xb0\x07L\x1cQp\xf2\xe6b\x7f\xaa\x0fq\xfe\x13\x19\x8d\xaa/z\xbd\xf2n\x16\xaa\xb9\x10?\xa3Am^\x9cra\xc6\xcbX\x8a\xa2\xb5\xe31\xf2\xab\xabn\x05\xc9z\xf7J\x90B\xda\x1d\xc9\xfe\x9e\x13\xb2B{\x17\xfb\x85\t\x88?\x95\xeb$\x0behk\x82\x82\x9e/\x937\xce\x86m\xd3\x91\xa2kc(D8\xdaQ\x947%\xd4x\xf90\xae{s\x03e\xcc00\xdf\xec\xd0\xce\x80\xde\xa3M\xf6\xa8\x80\xddK\x1ex\xb0\xbb\x14\x9ay\xc1\x8bIf\xb2\xea\xa8\xde\xacR\xa4\x1a\xd8\x13\xacl\x03\x82\xc2+l\xc9TJJ\xb0F\nr\xad\x14\xf2W\xac\x83\xea\xe8)\xcd31T\x1fq\xd8\xa6\x1a\x8b\x06z\x1b\xac\x9f\xf7*\x12\xdd\xc7\xb0\x9f\x0b\xdf\x8a\xeb\xfcn\x81\xf5+\x05\x052G\xfbX\xf8\\+-\xf9\xdc\xb4\xa7Y\xaemv\x84\xebLPm\xd6\x1a\xa9\xaeX*\xfe\tY[\r7N\xe8\xef\xceI\xbb\xbce\xba*\x10k\xf3B\xc9v\x0e3\xc7O\xf3g\xf2\x17\x88\xe1\x08\x8a_\x1c\xe6\xc3\xcdHI\x84\xf5\xb9\xc9\xceg\xf4\xf8\xad\x90\xf17\xae\x11\xf4(\x12\x0c\xc7S\x8c\xa6\x8e\xb3\x08n\n\x00\xbd\x13\x04\xcfS\x03*Sx\x97\x97\x06\x8d\xf0\x18\xd8\xc1{D\x84\x83\xa49\x17\x86\x89\xdb\xe7\x0f\x9c\'U0\xa2\xfd&f .\x9e\xac\x05\x07\xddh\x19.\x15\xc4\x01a\x18\xacn\x08\xef\x11T\x88S\x10\x17H8\xe2%\xe9p\xbfb\'S/t#\x0f\xa8\x919n\xc2\x90K\x81\xe5\xec\x03j\xcc\x9a\xab\xebNLwb\xfa5V\xf8\x1c2#\x0c\xcb\xea\xdb\xa0\x86`V\xe9rL\xaa\xd5\x8bl&\xf0I\xe9\xdb\xd8\x0eXA&!\xcd[\xc0\xd2:\xb6"\xc4\x8d0\xee\xff\x1eB\x9f:\xdb\xb9\t\xef!OrU\x1c\xbe\x8c~`T\x8c,\xf1h\xcd\x06\xf4\xca\xffU=\x1e\xc1\xac\x1c\x0ea\x14\x8a\x01\xb0y\xd6\x89\xef+\xf1LJANCL\xda\xb6\xfd-`\xa4\x10\xc7<\x08!\x96T?8\xd5\x8e^\x84\xc3t\x7f2\x15\xcc\xab\xad\xc8\xfd\xb9\r\x8f\x15\xcc0\xe9e\xda\xef\xae\x87\xaa\x0f}\xad\\\xe6@\xbd\xe8P\x1f\x9d\xe0\xae\xa9\xb0\x17n=N\x82G\xb7b+\x80\x96\xbd\xb8L\xa0@\x96\x13\xf6\xf2\xc9A[\n]\xff*.\x96\xebU\xd5\xdd]\x1f\xc9\x9a\x7f\xf4?Ip>\x8a\xd7Xr\xb4\xf3\xad\xa8nz\xb5R\x1f\xf9s\x8a\xce^\xc6Yq\xb7\xcd\xc4\nb1"\xe1\x93X\x93\x81\x8eh\xd9\xa8;\\E\xf0G\xf2\xce\xcaXN\x8e\xff\xcd\xc6\xfc\x14\xfbjXA.\x06\x8e:\x85l\xf4&\xb4\x8f\x8f\xf9\x97\xf2pR\xdb\xd2\xecr(\xe4\xe4\x83\xc0\xee\xa5\xf8\xce"S&|B\x96\xd8\xfcz\rQ\xe5\xafG\x96\xb7\xf7\x9co\x06\r\x08\x8f;\xe0u"\x112\x18\x04&,F\x0el\'\x12\x0bn#\xd0\xd1Om\xces\xf2\x95(\x07\x95\x13bi(\xf8\xf8\xe7\xea>\xfe[_\x0f\x87 \'\xefu\xce\xe0\'\x16i\xa4\xdb\xe1\xac\x10;\xcd\xf4\xce0\x90\xd3\xedJO\xec\x8a\xbc\xe6\xcbP\x7fw\x12\xe3\xcc\xff\x06|\x97\xe9*\xd3uZ@\xe0\xfa\x14\x9e[&32\x0c\x9d\'\xbaiW8\x9f\xf7\\\xb7I\x08\xd0\xdd\x15\xab\x9f\x0c\x91%\x91\xed\xc3\xe3\xc2\x08\x19\xcc\x14\x96G\x9c\x0f@Y3*\xa4\xe1y\xb4B\x7f\xc0\xd9\xb5`Yw\x82\xf2\x93P\xfe\x8c\xc9\xbe\xab\x8a\x1a\xc4-\xf5\x90\xbe\xd7=\xed\r\x00\xd8"\x18\x8ch&rD\xd2v`z\xf5\xfb\xa3%l]=\xbf\x0b\x81\xacQ}\xc0\x95*\x1b\xd2\x96,:b|!\x850\x82\xb8[\x98P3NZ\xadn\xbc\xa8\xf0\xea\xb8k\xc5\x06\x8f\xc6\xc2\x92\x80\x88\xaa\xf8\xf8r\xb3\xc7h\xfa6\xb2\xda6\x10\x1dY\x7fO\r\xec\n{9\x19\xf63\x06\xb2\x90N\xff%6\x9eGB\xebz\xd4\x0cq\xec\x85\x93D\x13\xba\x02F]u1p\x17\x9esu\xefW\xea\x98[\x02\xdeL1\xf0}\x8b\x15\xd8\xb4\xff\xae\x87}\x8ek\x05N\xe5B\xe9m^\x16\xc3\xd1\xa9\xaeZ\xc67w\n\xcf-\x14\xacT\x05\x99yM\xb8\xd5a\xads\xfd.\x11\x9e\xbb9\xe3\xf9OC1\xcaS\xbc\x9e\x01\x16\xe4\x0e\xb3\xe9\x9d\xc9\xcb\xc3\xcbnt\xaf\xb8<\x93\xcb\x1f\xf9\x14#\xeaU\x97"C\x01\x8f\xab\x81V\xf8$\xe3p\xccw\xa8_\xf7J\xf2\x12\x0e\xd4\x87\xb9\xa9\xe0\xb1"\xf1&y\xa9N\x9c\xa2\x90\\U!\x96\x95\xb3`\x92\xe5\xa3\xbf\xdc\xf8\x9e\xd4\xe1\xe1}\x87G\xbc\x81\x84&\xe4\x14cNi{z\x9c\xd6\x83c\x17\xb4\x14P\x06Q3\xad\x0e\x1c\xbbk\xa4\xbed\xf8\xa6e\xa2\x01\x10\xf8\xb6\x8d\xc0(\xbb\x10\x16Y\x99\xcc!\x0b\n\xa9\xe5\x83\xba\xce\xd1\xb5\x8e\xac\x93l\x17\x9d\x9a\x18,wId^\xceCi&\x12u\xac\x17\xfa\xed\xda*\x9e\xc1l<\x8b\x90D\x82\xac\xfc\xd4\x84WZ+&\'3\x81o\xb9\xd4\xb7\xf2\x95\xd3\x9a\xf1\x15\xac\x84\x02\xd4\xa3wx\xa2\xd3\xb5\x17\xa0\x9f\x1fn\x10\xfd3\xde\x05q\x87\xae7\x92\xd0\xae\xf3:\xe6\xcf\x8eg\x01C~H\x89\xb1BB\xcfX\t%\xd8\x9e]\x94;\x1c\xab@\xd2.Zn\xf0\x17M(w\xc9\xd4.\xfa\xc0\xdaMv)\xba\xf2\xff\x07%+\xf6\xc9w\xb1\xd0`=T\x15\x93\x0f\x9e*\x12?\xdc\xce\x8a\x9d\xa6\xf5\x07~\x17V>\xeeA\xd1{&\xa4\xc1\x04,\x0e\xef\xe1\x8b\xb4\xdf\x9et\xc4\xad\x07<\xe1%\xfc\x83\x15\xf0G\x9f\xce\xa4\x8f\x8f\xb2\xafx\x1b\xbd\xf2\xd0\xdb\x1cF\x95[\xf7\x86\x95\xc7\x10rx\xa4#S\xcc\x85\xcc\x08\x00C\xd0\xbb5:\xf3\x00\x92T\x14?\x14d\x06\xf9\xa5s\xc6\xca\xcb\xe2\xa3WK\xe0\xdd\xa5H\x99\xd7\xad}\xa4\xd8\x8f\xcbGf_\xeei\x15\x06oHE\xbd\xdd\xd2\xd1(\x9c\xe0\xe0TG\x18\xab\x10\xf4\x9am\xa4\xa3[\xa0EdD\xc4\xe1K\xff\x9a\xde\x18\xdar\x11s\x05\xb0v\x1b\x86u\xb2]\xedj]\x86I6\xbd\xd5\x1eF8\xedf\xc4\xb8F\x03Jc\xa4Qt\xfe!\x90\xb5`P=5ZT\xc2\xd2\xacrN\x1d/\xa3u\xb5:\x94w\xd8\xf6\xa1\x89B\xe6\xcd\xee\xdf\xcf\t$@M\xdbi2\xf2l\xec\x19\x8f\xb4\x1f\xc6\xe0k\xbf\x86\x99\x16a\x1fYKE\x91\xc7\x1bJol\x0e\x9b&\x14\xfb\xbef&\xaa\x19\x9cM\x9c\xc6\x8d\xa6\xbe\x133\x8a\xb8\'\xe7\xc7M\x02~\xe8\xddi\xfaH\x19\xd6V\x85N\x80V\xbe\x8ePp$\x14\xe8\xb1\xb5A\x0f\x90\xcfWZ\xd216e\x14ee\x96\x1e\x99y0\xa9\xe5\xc0\xae\xaf\xf0\xcdW\x0c\xfcb\x0c\xa04\xdarN\x02\x7f\x00\xa4y\x04\xae9R\xa7\xcd\x1e\x19tC\xe9\xd1\x0cnm\xeaQa\xc3Fe\x88\x80\x95\xf1)iOp\x9co\xca\xacV\x8ev\xbb\x15\x8b\xe4s$\xbeS\xb7\xfc\xac|\x13\xeb\xab\xe4\xac\x8d\x9dx\x1aZt\xd0(t- \x89;\x17e\x91g\xa2\xaf\xbf\xc1\xd2\xe2\xf6;7A\xd2\xd8\x96\xdf\x14:\xcc\x95KR@\xde\x02\xaa|K!y \x84j\t*z9\x98\xc4\x9c\xc4\x15\xd0^\x04\r\xeb!e\xe4Gk\xe1Q\n\xd5\xe1d\xccc\x16w\xae\xd6\xe6\xd8E\xd9\x084\xf1h\xbblI\xd09W\xe5\xfa\x89\x1aa_\xde\xb5%\xb3T\x04\x9b\x9c\xbc^\x9b\xfb\x0e;\x90\xa9\x99YF\x92&\x1a\x851*\xeetF\x16TD\x81&i\x15EV\xb0\x16\xbb\xfa;\xff\xb81i\xdf\xd2\xbf\xad=||\x7fv\xe7\x82\xe9\x1f\x08\x9dO\xe5\xf3\xa6\xa1\x04\xb4/\xba\x0cl\xd9\xad0\xab9\xd0\xcdO\xb9\xc0\xb1(\xc4\x1c\x85k<\xe9<\xffrlE]\xbfd\x8cK\x10\xafG0\x83\x10D\x16\xd4n\xed\x15q\x1e\x87N\xc7\x0c#\xf6\xba\xcf\xc2g\xfe~\x82\x8ax\xeb\xcb\x19\x7f\xa1\xaeP*G\x97\xe7\x83\xd4]\x87r\xf4\xdb6=\xfd\xdb\xe2\x89A\xd6\x95\x90y\xe3\xba\xfbd\xdc\xe0\xb5\xd7\x18"{t\x90\xe1u\x08W\xaa;l\xdfr%)\x1elG\xe4K\x0e\xae\xcc\xcaX\x11\xf4\x02\x83\xc7\xb6\xc0\x07\xdbsf[\xd2\xb4\x8a\x88|#\xfac\x14\xc3\xbct\xb2-{_.\xaa41\xa6\xe91]w=t\xe6\x07\xe2\x9d\x10\x95\x87\xc1MW\x14\xb7\x9a\xee`)\xeb/\x19\x18\x03\xaa\xb1\xa5\x0bn2\xbbMj\n\xafm\xf2fg\xc6\x8b7\x94\xd02\xfa\xd2d\x14\xf9f#\xf6a\\\x19r5~R\x8c_\x8b\x85.\xe5\xaa\x8a\xb0\xa1\xf3`T\x97\xe3\x8b\x08\x94iw\x14\x191\xb6g\xba\xc0\xf0\x8e\x93\xa0O<\xd9T\x9f\x01\xfb\xf5]\xdd\x8b\xd59-\xc6\xe7\xc2\xd7\x17K\x10\xc2(\xc7\x02\t\xff`g\xd0it,P\xa6/N\x90\x16\xf3*\xa6m\x958F\xf5\xcfq\xca\xcb\xa1%\x8e4M\xe7yO\xba\x8d\xb9\x94\x16\xb8\xa4:u,\xadH\rU4\x86\x8e\x8b\xdc\x90\xb5\n\xc1{\xcb\xc7r\x9d\xd4f\xc7\x87(Q2\xa4LI\xe0jD\xe7ihq\x82>v\x8f\x19x\xaa\x01\x18d\xca:\xa2\x1b]\tI?\x90s\xa5\x1by\xda\x8c\x9c\xbcu<\x8dB\xcc\x81\x9e\x1e\xd7pi\x86L\xe3\xb0\xe8\xf2\xc7\x9b)\x1a\x9e\xfe\xedZ-\xafglsEZ\xe1\\\\\x00\xc5\x12\xb4\x11\x08\x16^\xb1\x87\xf4\x9c\x94\xcb\xcdq\r\x86m\xedW\xdci\xfc0[\x82\xe0dmW$\xad\xdc\r\xd2~\x10[5\xbd\xbb\xcc\x03\x0fx\x06\xfc\x94\xa1\x8f\xb0T#[\x03\xc0\xe0T\xc7\x16\x02\x8aUF\xce.\r\xab#\xe1O\xca\x0f\x96\x99\xf4q\xdb\xfc\xcf\\\xec;\xa2|$\x1aVm\xb8 \x84\x11\xec\xb7V"7\x15\xfb\xfb\x8a.\x03\x0c\xa1\xfd{\xe6\xec\xbdU\xcd\x97\x10J\xd6G\xeb\x05B\xc1x\xfc\xc8Z\xe5\xc9\xa1\xd1\x14\x99\x87\x05\xe9T\x01R\x86\x9e\xb6q\x9d\x06o\xdf\xc9\x96-1m\xea\x0en\xe9\xad\xa8A1\xff%\x16n\xb0GF-\xcc\xea\xc8.Y\x9b\xe0\xc1\x02\x8c\x19\xf4w\xc3\x88\x05\'\xa5u\xd9o\xf1HOBx\xc9\xfb\x89D\xa0d\x0e\xc5\xe7%s;\x88\x9a\xb2\x92\xcd\x0c\x0bo\x15\x8et\x1a\xdag\xca\xfe\xb6\xb7P\xbcCC\x88\xfe3\xa2\x17\xec\x01\xfc7d\xa9zm\x01\xb4\xfc\xfd\x15\x17<\xff\xad\x9etDLi\xd1$\xf0\xb9&\x1e\xb9\x12\x99\xfcn\x84\x9cH\xb4\x9c\x10\xa6\xb16}d\\\xf1H`b`\xa8Xe\x8c\xcf{\x1e&\xff\x11\xe5,\xf0\xd5\xa4R\x9dT\xed\xcb\xa4E\x06e\xda\x9b\x890Mg\xfc\xb4\x7f\xef\xae"=\x1c#\x84\xacF\xef\xa9IKC\xc3\x97\t\xa3\xb8\xc0\xc8\x088K\x15\x02VWG\xa9\xca\x11\xdf\xd6>qc\xbf\x02\xd6\x81\xf8\xc1\xd1\x93\xe1\xcc?\x88C6\xde\xc4\x9eC\x86\x99CP\xe6\xa78\x94\xd9i\x19\x1f\tT\xa5\x84\x83\xc0\xc2\x87\x94Q\x10\x1d\xfc\xccsrG\x90\x05\x15ck\xd7i\xda\x9b\xc7H\xee\xdd\xaa\xd5\x1ep<9\xaf\x87\x84^N<\xa4\x80\xfc&<\xbf,\xff\x8d\xdbS\x99\x949P\xf1\xb6\xcb\xc7\xe2^\xcf\x8a\xd8\xea\x8b\x85\xc8\xa7j\x01!\xcf\x8b\x84\xf8\xa0\xb5\xb2\xa3\x97\x14\xa1\x1a\xa8\xb7\xbd\x13\xca\xc6\xa3d\x13\xe0\xb0\xec\x07\xe7`yFI\x9bONjQ`\x9d\x10\x06\xeaG\xf8#\xcf\xbb\x04\x15So\x8an\xa8\r\x8c\xbddO\xcd{sa\xf2\x85@)\x98\x1eM9W!\xbe\xc7\n&\x94\xd0H\x8c\xe0D\x08\x97:\xcf\x8aq\xa3n\x8a\x8a\xea\xa4\xd8\xaa)\xbd\xb2\xf5\xd3S\xcf\t9\xc0j\x18[\xf9\xd3#\x102H\x8f\x17&e\xff2\xc7xj\xeaT\xaaNc\x15\xfc7#\x16\n\xc9\x0f\xef\xfcc\xbd&h\xf0v\xd7i]\xe8\xbb\x8c\xcb\xa8\x97\xa6<\n\xfe\xf2@\xc9\xcf\x0c\xec\xa1\xb4\xd4\x10\x01\xb6\x19\xa1\xd5\x91G\x93\xb5\x1a\x9c\x8b\xa7fq\x00\xaf\xdb\x918N(\x17\xe2\x1c\x05=\x818\x82\xa9f\x13\xb4 y\xcff\xef\x03\xe0\x8b# \x14\xc7\x13\x80\x88\xfaG\xa4=\\50>\x97\x1e+a\xb4m\xd7Zd\xbc\x81\xea\x9dF\x04X\xe2\xc1\xb4\x96{\x17\xfc\xbe\xbe\x983\x12\x96\x8e\xaa!\xf1o\xfda\xd8\xa7\x0cs\x8c=\xe8\xa0\xe6\xc0\x85\xdaA\xe0&7\x06\xff\xb1\xf0\t\xaa=Xt\xc8\xa9P{\x9d\xea\xe5T\xb2[t\x13`@\xa4\xd3\xdd\x03\xad\x8dRJuy^m\x91\xe7:\xbb\xf9\xc9\xbd\xf6\xa3\xc2Y\xe5\xab@=\xcf\x83Q#\xaf\xe1\x91\x14G9\xdb\xba\xfc\xdc\x00\xa6ebx#\x01\n\xff\x1c\x0bUl\xb3\x93\xedh\xee\xd0(\x9cUF$uxQL\xbb\x1c\x08\x88\x97\xf4\x8c^\xd5\xcb\xc6\xc7\x83\x84\xd0\xf9\x83r\xf8\xa3\x02R\xee\x1e\xd2\xb2\x07\xcb\x8a\xe0\xed(\x86M0K\xa7\x84\n6\xf6w\x99\xf8\x7f\xfd?C4\xc91\xf5\xaa\xc9xF\xef\xcc\xfb\xcca\x82\x82Nt\x13\xf3*\xf2\x18\xc8/\x8b\xc3-\x0f\n\xd8\xf6\xb7\xfa\xc4 \xceFx\xb2\xd7\xd2\xadF\xbf\xb3fH\x1bG\xe3}\\\x91\x97\xa4a\x9c9v,8A]v\x04\x0e\xb2\xaa\xd7U\xdf\xd1)-\xd2\xdb\xc3*q\xccd \xb6\xc3\n\xc4\r\xb9\n\x8b[\xea(\xfd\xda\xf1\x16\xe2\xfc\x9b-x\xae\x1aG\xc6r\x8az\x06|\xc1\x87\x12\xdc\xb5\xf7\x14\xa8\xd4\xd7\xed\xeb\xaa\xb5\xb3,/\xb8\xc8\xe3\x99j\tH\xcf\xd0i\x161\x9b\x0e\xe4;&"1\xc6\xaf\xf3}{.R=K\x9e\xc8\xbf!\x1b7\x0e\xc1\x81\xf4\xafU\x97k2\x18\x9d\x1f\xbc,\xe5\xc3!~\xae\xa0\x84m?\xb2?M\x1dwb\x8dB\xec(3\x06\x16\xddc\xf06x\x9e\xfaU\x19\x84\x14]\xa2 \x94\x02\xb1\'#\xa0~"L\xbcL[\xb5)%\xe9\xb69kc\xdb\x17&|\x86:Y\x8b\xe3\xfd\xa5\xeal\xfe,!/\xd7\xea-\xb9\xf5\x9a\xd1sd\x93\x06\xd3\xef\xe8ui\x14\x8e\x81\x86\xcc\x06@\x9c\x0c\x93\x8b\xff\x97\x08;_\xa1C\xa3\xfd\xe8H\xf5m=\xe3\xd9&``\x95\xe4\x10z\xc6}\xb0\xa4\xbe\xb0[V\x81\x0c\x0e\xf47\xaa\xac\xb5\xe5\x12\xf3\xe8\x81J\xba\x18\xa9\xfbT\xdf?\xf4\xf8\xcb.h\xaeRy\x8f\xc9\xa0\x98\x1e\xf9\x02\xf6Q}RI\xd3vp\xb9\x9c\xf9d:\xe7\xcb\xce\x08\x94\xb5:\xda\x94!;\xd7\x05.\x0eh\xa3\xd1|@&\xb0\x19\xd8\xb3\nJ\xf2\xd4\xd8\x00m\xb5\x0c\x1f\n\x18;\xcc\x06\x1eq\x9c\xab~\x97H;M\xf6l\xd0o\x96\\\xde\r\xac\xb6\x8c\xaf\xca\xec\x06~\xde~\'\xc4,\x12\x9d@\x18\xe5\x0b\xde\x01\x00\xdd\xda)\xce!kV\xe4,\xc9L\xf3\xb9L\xa8\x93\xff)\xabq\xcc\x0b \xb4B\xba(\x8c\xbe\xad\xf1\xfd|\xe2\x0c\xb3\xde\xa6\xf2\x08\xde\xaa\xc5\xa5$\xe4\xf2\xb3K[$p\x8f\xaf"RN\x18\xf5\x82?"\xd4wB\x17\x19\x8f\x1e\x13\xfcb\xa3\x9e.\x19\x06hB+O\x9a\xb7jg\x9bWy>h\xf8\xb11\xe4z\xadT\xa2cT\x13\xd2\xf3\xe7\x8f\xa9\xc5\xe3\xbaO\x15\xb3Y\x94w\xe4\tP\xb2Qz[$[\x7f\xb5h\xad\x07Q\xed"o\xac\x0f\xdf\xa4\x83\xe3YZj\x1c#_\xcf\xca@\xca\x08\x84\xe6-\xffm\x03\xc4\xe6\xde,\xf6E\x15\x87\x01$\xe8\x86\x15sBL\xd2\xc3A\xe5\x15\xcc\x13\xe07%\r\xf4)\xc3\xaf\xefq\xa5\xb8\xf2\xa4J(\xb5v$\x16\x7f\xa6\x1a\xb1\x0b\xe4\xe0\xac{\x9ay\xb0m\x00\xdc\x92\x96\x9d\xdd\xf0I\x05\x14\x91\x8cT\x1e\xf5\xcbhEN\xcdrk\xf5\x05\xb9\xfc,\xd3\x1f{\x1eJ1\xf9\xe3\xa6\xf6\xb2\xd4_\x94\x1d\x1c\x88O\xc4\x13-\t\xb9\xbde\x19&&l4\x0c@\xae*09+\x8fH\xfd\n\x1f\x04`\x0c\xf9\n\x05\xc4\xbe^\xba\xbf\xd8lc\xaes\x8c\x03A\xa8XK\xc2\xd4n\xf3\xa3\xae\xfev\x86z{r\x1f\xceb\x8b/\x9bb\xad\xd9\x06\xe2\x9e.\x96\xe9\x81\xder\xb0Jg-YD\x1d\x12\x11\xcf\x91>!L\x1b\x97\x11#\x9eoD\x08\x10\x12\x7ff\rUw$,\xf9\x8e:m\xe9q\xbb\xf9\x9cb\xa1\x87O6\r\\6\xda\x8c\xe4\n\x8az\x94\x89z\\\xce\xfe\xd0Z\x86e\xf0\xcc^\xc4\x89\xeai&\x171\xde\x9b\xb6\x18+\x92HP^\x8f6\x14\xe1\x0b\xc8C\xa7\x06\xc5\xc8\xaa\x17F\xd3\xc8[\\\xdc\x02\xac\x8b\xbf\x8dU\x91\n\xce\xb5`.9\x0f\xaa\xaf\xe1\x91\xbe\xaa\x80\xb9\x99\x1b\x02\xa2\x9b\xb1S\xd0M\\@\x90\x81"\xf3\xa07p\xa8\xb4\x90+\xef]\x83.m\xa1":+b\xcf<\x8b\xce\xfeOieq\xf4I\xd9\xa3`\x85\xec\x1f\tL\xaa\xd6\xa3\xfc\xd3\xee\xb1\x80\xd39\x06\xd9J\x9b\x13\x0b\xa2i\x9c\x9f\x97\x8f\xfe<\x00W\xd1\xe5\xf4\xb4\x08h\xe3\xe9\xb3\xa3w\xbc\xc7\x18\xd0\xf7P\x11\x9c\x17\xb7\x96\xff\xf1A\xcd\x9d\xd6\xa2*6\x9b\x13C\x8cD\xfe*\xab\xb8\x12\xe3#\x0b\xc8h\n\xf5\xa4&\x19\xa9e\xdd\xb3G\xa9\xad\xb3^H\x00S\xfd\xf7\xa9\x05\xa2\x80\xc2\xb6\xe9*\x01P\xd8\xa3CD\x00\x87\x90\x05\x8d\xa6\x9ap\xdd\xe7\xfa\xc1\x1ee\xcat\x82\x15Q\xdbHCa\xba\x1d\xa7G\x05>fq\x01\xe8\xafE\x1d\x02r,\xe4\x9e\xc5\xa8\x87\xc7\x97a\xbf\x1aqJ\xd5z~ \r\xba\x80\x81\x122/\x03\x08W\xe7]\xf5]qs\x04\x14\x980\x89r\x81\'\x0e\x97\xd5.%}\x80O\xa9A\xc9\x89\xa7\xe6\x1e\x87N7 \x141,\xbe`g\x1c\xa5}\xc8\xb6T\xb0Pwv\xb5\xbe6\x1a\x8d\x9f\xc8\xcd\xd03\xfd\r\x01\xbdO\x89\x14\x8a\xde\x17l\xc8H\xef\xc2\xa7\xc9\xf8\xb54\xa4\xf8&qs\x9d9\x92M\xa4N\xc6\xde>K\x12S\x9d\xb7l\xf5%%\xf94\x999o\x15nn\x94x\xa3\xbf\x98)\x83\x81\xaa\xbe\xf3\x1c)J\xa4\xa5i\x14\x9f\xe3\x92H?\xa6H\xcd]Z\x9c\xb4\x08\xc2\x16\x1e%q\xc1:y\x9duz\x9c\xb1\x06k\xd2Q}\xd3n\x1di3\x11\xebH\x8ey\xb5^\xfeg\xef\xac\x1a\xc8\x08Qbn\xca\xad\x05\xe206}\x872\xe8uZ\x03\x9d\xc9\xed\xa3-\xf6\xe2=\xba\x1d\xf8\xaf@\xfe\x9fwA\xfd4;T\x1e~\xaf\xb2!|\xaa\x13\xc5\xcbo\x08\xaan\xa0\xa9\x86\x06\xc7\x91\t9+\x15\xee\xff>\x02I\xc8FG\xa8\x9e\x8b\xcbv\x9a\xa6\x91\x0e\xfb\xde\xde\xd8\x1e4H#\xa6\x83\x0f\xaa\x12\xd9W\xd8\xb3\n(\x8e\x8d\xa3T T\x98\xa0\xacz\xdev[\xc6\xfe\xd5\x85\xa5\xedGk\x1d\x81\xb3C\xcau7\x88M|\xe6\\\x15Oo7\xc4\xa5\x8a\tX\xf7N\x1b\xf8dr\xe0\x00\t=WU5\xe1\x15+Y#.\x05\xc1\xde\xb10!\xc5\xf6\xdcH\xf09\'\x0e\xf9~\xcf\x8aY\xe8\xf7\xd1\xdc]\x11\xf9\x15)@_xx\xc5\xdc\x19\xf5\xba(-[\xb7\x00\x16\xbb\x07qz\x9a)_3:\xe4\xe2\xf9\xa9\x851\x14$\xf3\x0b\x99\xb8\xeeT\xdb\xf4\x7fY\xb2\xce\x1c\xf6u\xc8\xfcj\x1a~]\xbfd\xdf\x94\x01$\xe4`\x9c\x92X1\xb7\x83\xa7\xad\x0f\x8c|;\x12\xc8\xbck0C\x84\xb0"_`\xc0\x12H\xaa\xfaH?\x0f\xac\x82\xe9\xdaHt\xa3\x93A\xbfd\xcesd\x03\x9fa?\xe4\xeb\xac\xb2k\xa11S\xf0\xba)tu|\x90\xda\n\r+\x91\x16\x8f>\xf8\xd7cJ\xf9\xcc`\x9f\xa0\xc8\xd2\x7fa\x9f\xe4\xb0\x16\xe1`\xc6Q)D\xbar\x11{\x10\xb6\xa8\xfc\x1cc\xfcAB\xf9\xb6\xc8}\x87\xac&\xe17\xa4_\xa2\xc5\x01\x19\xd8QV\xbd\x88\x04\xae\xe4\x85\xb0\xa2\x90%c2\xf0\x16\x19M\x82;\n/]ek\x1e\x07#x\xf3\xfa6Q\xbbQ\xcb\x14\xca\x8f5fD\xd8\xcb\xaeo\xa5~\x85\xda\xdc\x83\x1cUB`\xf5\x86F4\xa3&Y\xc2M\xfb\x001\xa5]9\x17>i\xf5\xf9\xa5\x07\x92e\x8ba/\xe1\xbd\xa9\xe1\xcaK\x083\xb7\x90\xfd`\xfb\xe7_5hT\x9bn\x83\xa1\xf3\x06\x04\xe0\x0b\x90\xa9w\x87~S%\x8fY\x04\x98\xb7\xccl\xce(\x8at\x93r\x85\xa3\x00\x1b\xb66B\xa3\xa7lF\'\xe7\xb2\xff\xff_9s\x15\x10c\x0e,!\\2.Q\x94)(\xb3\x9e\xd0\xbbs\xe8\xd2\xc14T\xba\t\xe4-\xcc\xaeg\xb2\xceE}\xa69\x01\xd5\xd6<\xee\x18-\xf3)\xe7\xb4\xa9[\xcd@\x9c\x9b\x07=\xd3\xe1\xa4\xcc\xbft \xce\xd9F\x03Z\xd9\xc8=\xcb\xcec\xc7\xfb\xe7\'Rg%\x98\xd8:\xffM\x1a_o\x14\xcdl Z{\xf7\xb3)6|!O\xb0X\x1f\xeb\nC_\x81;\xca\xc4\xb5\xd4\x18\x0b\x1d=/F\x96\xa1W\x7f\xbd\xb8\xf4\xa5^\xccFK\x15\xd4\x10\x7fN\xa4\xba\xc1\xf4y\'\tZ?\x11\xe5\xd9@\xbd\x8c\x069r\xa0)\xb2\x85\xf9\xb9>}\xf2\xb2\xb3\x1b\n\xa9\xc7L\xe7\xf2\'\x03\x1a\xc8!\x8b6\x91d:y`\x04Q\x8d\xcef\x1am9+\xe9E\x9cY^\xe0\x05\xe4\x85\x92\x9bM\xa1\xa9\xb1\xaf[\x07\x7f\x94\x17\x10\x90k\xd5,\xa5\x95\x02\xa6\\\xb3\x1d\x12\x17\xf3\xe6y\x1a;\x1eh~&U\xcc\x8c\xbf.,O8@\xee+L\xd5?\x92D\x03\xbcz\x9e\x13\xdd;H\x0b\xe3u\x1co\xe0\x80\x1f\xfb\x02\xc4\x15\xa2\xd9\x87\xf6Y\xf5\xf7\x8d?\x82l\x9bB\xd3\xf8c\x18O\x04\xd8\x1b\x99q\xfe\xc4\xc5\xe7I\xb4\x98\xa6\x19\x1cB\xfa\x01#7\x15\x1b\xb1\x0f&\n\xb4\x9dP\xb8\x86j\xc3l\xde\xd9\x9d.\x91\xfd\x1d]\xeb@eJ\xdbh5\xef\xc3P}\xd7\xa1a\x87\x07\xf7\xed\xc6^\xae\x10\xd9\x15WJw,h\xdbIn3\x0e\x89#\xaa\x13\xaf\x88(Mf\xad_\x1aM\x8f\xa3a\x82n\xc1\xe6\xe9\xbc\x80\xc2\xd0R\xf4M\xf2\xfb\x18\x19/\x9b\x00\x87\x96})~{\x1acz\xfdT\x91\xea\xfb\xa6E7P\xf8@\xa99\xd6\xb6\xc2\x8e\x9e\x17\xd6\x1f\x1e\x12\xd1\x07\xb0\xe3\xb9^\xd8\xcby\xd7\x19\xe5\x99\x81\xe4\xf9\xd8\xad\x8b\xe3\xaf\x03\x1f\xd8J\xb5\xb6Z\xaa8\xe9\xc2BG\x163\x8b\xa4@H\x80\xf4\xf9\xe1t\xf6\x8a\xa1\xc5\x08:\xc3_\xc1h\x18\x96\xb7V\x0b\xc0\xbe\x99\xda\x8d\x1c\xcbK\x8cU\r\x9e\x84!\xd7\xb7\x95UR\x82\x0e\x1ca6=\x16g:X\xb9\xe8C\x04\x94]\xe6L\xb1o"\xb3\xd5\x0c\xcc\xa3m\x91\x91\x87.\xa0\x97c,\xd4\x93\xf8\xee\xd2\xdf\x02z=\xe9\xabn\x91?\xde\x95d#\x857\x89\xa7\xce\x82cM\r\t&;\xd9\xc5$;\xe1?\xb6\xdc\xd7\x0et\xa7\x95\x04&s\xa79\x8ez\xd2!\xe7^"Wr\xfe\xd5\x9d\xa6\x0e8\xab>`\xaa\xc6\x93\xa1\x8fnF\x12\x10R\x9b2\xbe\xceyP\x80\xd5\xb0\x9f/\xb6\xf8<\x95\xec\x19\x8b\xf0]\xed@X\xab-\x96|\xf6`E\xdd\x06\xf7P\x8c\x9d\x1d2\xfa\x06\\\xd7\xe6\xf1\'\x13\x8eG\xb6\xf9\xd7n\xc0\xb2\x02Hc\xd1\xac\xd6\x0c_6n\xa7\x9f\x97\xd4\xdb\x8dR\xe5\xa9\xfd\xcb^\x14`h\xc6\xde\x83\x8b\xe5Ii\xefs\x0f+\xb9\xb33~\xd3\xef\x89\x9c5\xe1T\xae8\x01A7\nc\t\xc8\x8b%Xv\xc9X\x14V@\xe7\xeb0\x03\x82\xb9\xc5\xe7\xb3P\xac\xf4\xfa\t\x7f\xfe\xd7U\xd2w\x17\x88\xb7\x9b\x14!\x83\x102\xda\xcb\xf1n\nE\xe5\x12\x89\xba9\xc0D\x1f\xff\xdf<\xacu\x8e\x00\xc4\xa2\x1f}r\xdd\x89\x8e\\\xc5 oB\xedh\x87\xbf\xe5\xca\x06>\xb2n\xa9J\xc3\xf2@\xfe\xcbh-\xed\x94D\x9e\xe8\xca<\xf8\xba\xcd\x94\x07\x8e\x15\xbe\xdd|\xd0\xec\xe4\xa2\xfe\x92\xfc\xcbu\t]j\xd23\xc23\xbe\xc9x\xa0\xd3\xa3a?(\xf1\xbe\xca\x11c\xbc\xdf\xfe\x10\n\xd2\xf2\x18\x86\xeb\x9eU{\x97\x82>k\x0bwt\xbf\xec\xf7/\xff~\xc7k\xe7\xab\x1e\xcf\xd4\xeb+N`\xe7\x9c\xe2\x88o\xe7f\xef\x1f\x99\xa374!\xd6\xe2\xf0\x0c\xfd\xaa\xbe\xe99\x93Rw\xea\xdc\xcc\x8a\xd4\xf5#oXE\xb4\xf4\xdd\x8a\x0c\xb0\'\xb2\x1e\xdd4\xa8\xba:!A\xa2\x9d\x14Jb\xe1\xael\x86\xa3`\xd5O\xddM`\x04\xc8\x98\xfb0\xb9\xbb\xcc\xc9Nd\xfc\x81~W\x7f\xfc\xc7\xa4,e\x9a\x1e^N\xc7{\xbb\xf9\xe6~\xff\xf7\xcc\xe4\xd0\xbd\xca\xcb\r\xad\x0b\xe1\xd8\x03\xb2}[I{\xe1i\xeed\x07s\xe7\xe4\xe50\x1c\t\x80\xa5<&\x97\xaa\xdc\x08:\xc65]\xdd\xc0\xf9d\xee>G\x19\xcc\xb1?-\x86\xcc\xe6K\x1cD\xd6\x84T\xaa\xc2\xf4\xde\x9b\xbao\xd1\x961-\xee\x8c\x02\xe5\xf1\x9at\x8aB.H-\xd5\xc2\xb5<`\x95\xb6\x95:\xa8d\xbeQ\x8a\xb7\x7f^\xec\xbe3\x14\x07M6\x0f3f\xd6U\xb9H\x16)Jr3%\x99\xc4\xae\xebq\x06\x94MZ\xdf\xf8\xb6\xb0H\x85%:\xe8\xba7\xe3k\x0cl\xb3\xba!8\xc3\xde\x87r*\xf2M\xc4\xee:z=X\xe2z\xe7\x03\x9b\xf0\x0e\xba\xb3\xedg\xc0&\x9f\xe9\xb2EK\xeb\xfc\r+d?\x1fo\xe6\x97\xc7\x92\x9f r\x1bKm=\xc7\\4V|\xea\xc6<\x02QN\'\x8d1\xda\xdc\x8c\xa1R\xbb\xa3W>s^\x8d+\x99\xf2\xddqj\xeb\xb4\x87+|\x11\x1a\x04\x8b\xabdx\xd5\xe1m;\x15\xd2E\x16:%+\xbd\x830\xc4\xbe\x13\x07\xab\xce\x15\xa8\xdap\xe5\xd1\xc2\x97\xb5a\xa6\xfe\t-\x9a\x15\xfe\x0b\x08]\x06\x88\xc2\xfa\'\xd2\xff\xe0\xb4\xf9\xb4Clh\xd1S\xc5\xbbp\xb5\xf09\x86\xea\x9f\x83\xacYE\xbez\x11^\x12\xc3\x98\xe2\xbc\x96\x94\x8f4M!\xeb\xa8}\x8a\xaf8\xff\x96/\xe7m1\xe7C\xfew\xbdr\x08_\xa2oc\x1f\xfc\xef\xff\x107\x84\xab\x8b \xfb\xf4Q\x1e\x12o\x94Z=\xbb\nRWbr\x9a\x18p\x99\xcd\x88c@\x03\x86\xe7\xa7\xe1\xdf\xb7\x97\xab\x84\xf3^\x84\x8d`(\xb2~_\x1c\xcb\xd4\xcd*+&y\xb6\xb3\xb8\xc2\xcd#\xba\xc8\\#\x0ez*\xb74v"\xf6\xa1;Ie\xff\xd1\xa8\x81\xda\xbe\xa9\x08\xc3\xf1%\xde\xba\x90\xd1\xb0\n\xa8T\xc5\x96\x1c\xf0\x9at\xcf\xda\x92\x88?N\x96\xf8ww\x84\x1b\xd7\xd7\xa6ri\xd0/"\xe6S\xe4\xe3#H3\x07\xef\x12b\xef/\x98\xa1\xfe\xd4\xbb\x85\xb5\xe3\xbe\xc5\xb6C\xacw!\x80\xbb6\xc6\x08C\xf7^\x97\xd0\x99\xb4\xfa\x88\x86 \xa1\xbc\xec\xfc\xc6\x1cQ*\x86[\xab\xce\x16IF\x96K\x80zdrR\x95q\xd8\xad6\xe9:ZTA\x84\xed\x06Q!/*;\xa4<0\x18\xf5\x04>\x80\x19)\xb3\x9c\x99\xdeo\xe0\xef*$\n9\x8b6\x02\x1c\x9a\xfau\xdd\xe1)\x89\x9e5\x8dZ\xd27\xc6\xee"=\x01Di\x16\x0eEY/\x8aS\x86\x9c\x9b\x0ew\xc7\x90\xda&\x04C6e\xa0i\x9f\xb8&\xf5Fa\x87a\xd3\x99\xe2,\x97\x98)\xcbN\xff\xfe\xa6\xea\xf5\x03A$\x8c\xa2\xd6GC\x01\x8c\x91T/\x81\xe3\xbb\xde8>\xfa\xde]\xf1Ryj\xdfDc1 \x18\x06\xc3a\xdd\x03\x86\xa8\xb7\x91+C#H4n\x9c,\x95j\x1cd\x16\x8a\x97\xe3\xbfg\xbb\x88\xf5m:uL\x9csvrF\x13\xe61%c\x03\xe6\xcf\xcc\x8a"\xf0\xd4\xe5\xc4\x06\xb6T\xb9\xfb\x16P0D\x1cH\xc6\x8bW]\xb0:\xfe\x8f\xa3\x15\x9c\x9fW\xea\x89\xfa\t>$o\x8c\xc9\x81Q\xd3\x0f\xd6N\x97\x9d\xf1\xa2\xb7J\x9am\x19uN\xb4\xf3\xa4\xf4>\xc9\xbc)\x97O\xa4\x18\x12\xf1\xb1\x1a\x13XC}\xaeN\xa4x\x02:U\xed\xbd\x86#\x1d~\xad>\xd9\x1e{e\xf6\x85k\xec\x04G{\x14\x90\xd6M\xc5\x1b\x9b\xc9,\x05\xd9\x05\xc5\xc7aKa5\x10\xd5\x7fq\xc3\xba\xba\xe9\xfc\xfc;w9\x97lsl\xc9\x1cR\xdaU\x97\x17\xcd%]D\xf1\x1e\xa1\xdas\xda\x8a\x8fQ5\x01;{\x88\xd5D\xacEd@\x94-#\xea\x9f-\xa3\xd9\xf6\x97`%\xd5[\xb1\xe8\xa3&\x90;O\x82\x13\xd5\r\t?~\xa3\xfa\xc6\xb0=u\xb0\x1e\xe2\xe3$S\x98\xa7\x99\x8b\xad-\xe7\xf7\xe1?\xa3\xb1\xb6\xa33\x92\xa2\xe2VB\x90Ox\xf8\r\xf6\xa9%k\x879\xed\x05p\xc1\xf5\xf0\xdf\x14@I\x9c\xcd\xfb\x98\x02\x15\xcbh\xb8\xeeK=\xd6\xaf\xc8\xe5\xd71\xdd\xa66L\xe7A\xa6S\x7f\xa40C\xd7~\xd3\x95aJ\'\x13\x94n\xb0{\xf9\x02\xeb\x1f\xef\xb7 \xe0\x8e\x1c\x91\xe7\xd7Q\xbb\xbc\x12v|\xfb\xd1e\xf56R\x06\xd6"\x8b\xb1\xeb]\xa2\xd0\xee\x9b-\xcc\x19\x9a\x7f`\x9c\xcb\x0f\xaa\x84}\xbd\xe9\x8a0\xb3\x19X\xbf\xb1\xdd\x83P\x9ePvA\x85\xdf\xc7\x84Q\x95-\xa9\x12\x86\xbc\xc6\xc7\x17:F\x8a\x83\xd7\xbcZ`CMS\x91\x01\xe4\xa7}\xc7\x02\xe9\x9c\xf8\xbc\x99\x01\xa4e\xacG\xaaVz\xa5+\xf8zoY\xf4+}\xb5\xd9f]{\x1d\xa50\x82\xc8N\xf1\x02\x12ln\x11\x01R\xc3=\x7f\xd7\xb7\xa4Z\x02*\xa1\xab\xde;\xd65(\xb4\xcf+\x06\xfe\rD+\x99\xbe\xd9\xc3\xce$d\x18/\x94\xc7\xfaF\xa3"\x0c@\x9f7\xa3ap\xb7\xb5 @\x92\xb0\xbe\x81\xf5\xff\x00y\xd4\r\xe1\xd5\x0f5\xb2p#\xb4\xb6\xee\x19,\x95-\xc2\xfd\x07\x1bG\x07\xe6r@\xd17\x08\xf6\xc0\x14\xb5\xac\xbf\xc56\xb0tp\xbe\x99m\x82\x8e"Jzer\x0b@\xcc\x8b\xdc\xd5\xa3\x80\x9fb?\x86\xc3\x12\xc6A\xeb\x12@y\xb3/\xeb\x0f\xe0\xdc\xba\xc0d\nj\xce\xc7\xcb\x7f\x95\xe9\xc1\xac\xee\x14\x9do8H\x7f\xe9\xe0\xd9\xd0\xd1\x02863p\x16\x01\xac\xa0n\x1d\xfd\x00:<\xc4d\x1f|\xff6\xfb\xe5\xde\x05+\xe8@\x9fO\x97\xcc\xa4\xde\xf4r\xf2\x9c\xe6\x8b\xd8\xf9\xf3M\xee\x04*\x02\x0c\x80\x8cQt(\x90a\x11y\xc7\x92$\xe2\x1dC\x95\x7f:\xe6\xbf3\xf3\xb3{\x9d[\xf2\xe1\xd1\x9e\x99\x03\xc9\x86b\xa9\x94L\xc7\xbf]b\x03_?\x1dPO\xbf\xa6\x0bE\xe2\x84\xd8\xcc\xdd\xa2\xf4\xe0X`)\x01\xf6\xdf\x88\xd7\x0e\xd2\x85S\xb2\xe4L7\x97Z\xfe-\x086\xef\x94N\xca(\x90\x85\xc2\x03\xa8\xbc\xdaf\xdf\xce\xc6\xca}7V\x98\xec\'\x07\x0f\xdd\x8c\xd9\xb4\x8b\x8f\x8d>,\x19\xa1c7\x84\x93!\xe0\xa1\'\xd9\xbc\x9d%\xc9\x80u\xdb\xb9\xdb\xd6H\'0u\x1bT\xb2\xf0\xa4\xb1\x15\x94\xf7\x92(\x165\xe0`QD\x1e\xe4A9\xa7\xd9\xf0\x90YR\x9d\x876X\xf6\xb0\x03\xa8\xdcTs!\xdf\x07x\x90;\xf8#\xb4\x1cP\xe0\xdf\x9e\xa9\xcc\xf3\xdf\xa5.1\xbcyE:u+X=\xb4Z.0\xdfPj\xf9c\x84\xc8\xad\x19\xa1r\x00\x1d ]\x07\xfb\xb7\xf7\xc6C\x88qW\xc9V\x949\xee\xb8<\xbb\xc8t\xdfL\x07\x82\xd0.\x12\xa8\xcf\xe9\xcf\xc7\xb2-(Ii\x16\x13\xa1\xcd\xd2)J\x89\xb4xie*\x8e\xe5\x8d\xb6\xffY\xd6\xe9W\x1a\x17\xe9b\xe2,\x1aJ\x8d\x9e"\x0f\x08\xc3\xe4\xb7\xbb\xdc}0\x94\xd7\x90\xa6\xc9AuVF)\x85I\x89(i\xb8\xf8\x95\x89\x9a|\xbd\x8b\x1b\xd3\xa1\x06\x180\x87N!\xd6r\x00\x1c\xf5\x14\xc4Q\'\x08b\x1c@\x17j\x89\xce\xfc\xf1\x80\x7f\x14/E\x97\xad`\xff\xc2q4\xb6mZ\xf1\x19\xb3\xa5\xd7\x14\x02\x11\xe3)\xc1\xbf\xb9#\x16\xcdC\xad\x11F\xfb\xe1"5]\xecZ\xf7j\xf3\xaf|\xb5\xcf\x1f\xad\x05@{,\xdb\x80\xc1i%QE}\x1cJ\xe7\xf5\xee\xcbnr\xcfw\xb8@\x9f\x06\xa9\x16\xd1M%Y\xf83q\xce\x06\x9e\xb7)\x98\x8d\x7f\x81pT\xa1\x01\xc5r5\xfb\xce\x0b\xe8\xcdXu%\xd2\x05\xbd\x06\x1cP\xd7\x80264Y\xe8\xaa)(\x11\'\xaa\xca\x9f\xb3\x08\xb4\xbeX)\xc1uX\xca\t\x82H\x9b\x9brx\x8f\xe1\xd0\x8c\xff\xb14\x9e\xde\x9c\x8a\xa6+\xf9\r3E\xa3\xf9\xc0\'\xb1\xfb\xac{\x9a&\xe7J\xf3\x98\x88w\xe3/\xf9\xafUg5Y\x06\xa6\x07\xcau\x80$g\xae\x056\x088^Ao\x0c\x06\t\x95\xe2E\x9eE\x15^\x8a:\x0c\x8f\x16\xac\xc17)\x87\x1b;\x9f\x82?H\xb3\xff\xdd\xf0E\xdcl\xd7\xe8\x989\xc0\xa8\xa0\xac\xfa\xd9SiC\x1a\xd7@?\xbb\xe0\xb8[\xf6\xf7\xa8\xb7\x12N\xa3!fpB\xd8\\\xff\xcf\x15\x05\xc6w\xfa\xc8\xb9cVYA\x08\xc1\xca\xca\xe0Yn\xaa\xccA\x11\xce\x1c]\x16\x8b?j~Ym\x8c]\xfe\xfeoL\x10\x11\xb11g\x96ok\x87A\xd2\xa0\xae\xd9\xa1\x88\x8a\xde\xa9\x06\x85\xe91\xd1zm\x02+\xf0\x16$\x80\xb0\xd9\xac\x06\x8c\xb8\x06\x98\xd1.\xacBl\xf6\x8b\x90]\xaa\xffj\xb2\xde.\x11\xa3\xde\xc7k\xcf0\x86\x86v\xfd\xc5\x1cHE\xca\xe9\\.\x14:\x80\xe6\xfaw[\xb6\\LV\xda\x86=\x18\xab\xd9\xbc\x96\x9e\x9f\xddSN\xe1vC\xf2\xb9L\xbb.\xfey\xce^\xfa\xb7\x98\xa31_t\xda\x17\xccA\xbdC\x10J\x02\xb8~\x96\x8c\xcc\x88\x01S|2\xb26\xfau\x81\xd1\xf3N\x84\xe7\xda\xdd\x95c\x0fr\x1fUz\x0f\xaf\x06\x1c3\x9c\x9dM\x87\x10\x92\xf4\'yW\xc2@\xf1h\xbb]\x88\xa4B\x18\xa3\x03l\x16\x9e\xb8\xc1=\xbej\x0eX\x1f\xf6j\x03\x9d:\x12e\xc9\x94\x930\xb5\xfa\xcc\x0en\xef\xd30\xa1\x8a\xe7\x15\xe8\xd9\xa1R\xf6\xc3\x84\'\x0f\xb6<\x9b\xf6\xd1\xa5(\xeb2k-\xd8\xd9\x7fN\x94\t\xad\xa2U\xdb\x8e\xa4S\xf7\xc0\xae\t\xa9\x1eu\xe8\xaa>\x01\x83\xa9\xdcwj\x86S\xf9g\xfd\xcf{\xf5:\x1d\xe1F#^P\x03\xe3\xde\x10\xcc\x80y\x8f\xfb\x87\x0e\xc5\x06=w\xf3\xda5\x15\x08\x0e\t\xc6AK\xd80D(\n\x8f\x1d\x07H\r\xbfSV\xedqi\xd7_d\xd1\xd8\\\r\xb9\xc3O\x95\xd2I\x00\xc8\xade~\xd1\xb2\xc6\xa7\xcf\xa1\x1b\x0b\xb1\x85\xbbJ\x98HQ4lw\xf8\xd0\x8c\x9b\x848H+\x8cB^\xecf\xe6\x16\xca\xd8F\xf9\xc79\xd4\xc1\xfa6h\xd1Q\x90\x9cJG|\xd6|\x15\xab|\xff\xda\xb9oB\x7f8\xd9\xf5q,\xb7\xc0\x94\xf4=`t\xa2\x953\x0f\x0e\x94\xd4\x8a$\x06\xac\x93\xcbI\x91\xa0\xddF\x91\x95t\x18\x959\xd3\xd6>6\x12\xf4>l!*i\x8ak^\x05\xd6\x9fN\xb0\xd2[\x81\x03e\xd0\xbc\x8b\x10~#kh\xdeH2w\xd2"\x02\xb5\xfe$qX\xd8\xfa\xe5\xd4T$\xaa\xbcC\xed$!\xe8\'D\xd4[M\xdf\x98\xb8>\xb3\x86;\xb5\x0f\xfc\xdeX\xc3\xcc\x086C"e\x80]\x88\\\xe0\x8e\x96\x91j^\xa6\x8eX\xe0\x8bO\xf0"\x19\'.\xc0\x1eT\xe2L\xd9\ng\xba\x02\xd6\xc1\xff7\xc3\xc6\xb0\x02+\xc8\xca\\XV\x7f\xf7~\xe5t\x05e\xc9>\x08\x1f?\xa5\xfa_tk|\x07A\x93G\xf0_\xb5\x91\xeb\xbf\x05\x8a\xc4p\x12\x00\xc5X\x18\xdf\x1c\x13\xd9\xb28\x1dA\x1f\x8a\xb6\x96I\xf4y\x0b\x7fC\x02\x18\xb2\xacL\x1d\xaf\x80I\xc0_w\xdd,\xb7`\xa3\x90~\xc3\x84\x8b\xaf\xdd\xf7\xe2\xfdW\xcf\x94\xdaz\tG\xba\xff\xf3yv\xfb\xf6\x85\xdc\xab\xc0o\x12\x93\x0e\x11\xdaG\xd6j\x97\x93\xa2\xa2\xe3\xb3=U\xd1\xa9\xab}2\x17\xae\xd8\xf5\xb4B\x9e\x08\x1d\xaeDr\xcd\xea\x89\xea\x90\xd57R\xd3\xde\x98\x1b\x0f@\x9f\xafMY,\x97fD\x0e\xb7\x98z\xc4]\xc0x\xbc5h\x07\xa4N\x7fi\xcf(\xb5\xf1un\x16\xbe\xcd\xf6\x15P\xc8\xa5pJ{\xbe\xd0V*j[\xa3\xac\x16\xc7\x8a\x98t7\xca_+\xc6\x1eJ\x84b+K\xb4F4.\x7f\x9bD\x1euN8b\x06\x01\xc3\x9d\x8d\xb9\xdd\xf2\xfd\x8f\xa9\xeb\xdc\x84Hs\x02\x86\xb0\xac\xb5&u\x1a\xb24\xca\xd3\x0fy\x16\x1a\xa5qL\x8b#%%G\xf7\xf9m\xf4#w\x0c\xad=R\xed\xabn\xca\x9f\xac\x88\x1bZ&Y<\x1b\x8d}K/}\x0b,\xc0X\x13\x81M8\xc4r\xd5\\\x1b>\x070\xdd>Q\xe4f#\xe3\xa6\xb9\x19$\x8b5C\xd6z\xf1\x93\xf3:k\x12\x95:\xbd\xbc[\xcf\xb7\xa9\xbcz\xb8B@+\x86d4\xe9\xfb\xbd>I\xaat\xe4\x1d\x10 \xd1r\xd2?\x8fA\xf6\xe60\xa5z\x12\x91\xc4\xf2\x15\xb6G\xd3HE\t}Y\x19\x16\x0ev^\xad\xf2C\xecB\x82\xdb\xc8\xb0\xffl\xae\x1f\x7f\x19B\xd1\xa4p(\xab\xdd\x8a\xbd\x04\xba\x85Uv\xbef\xf6\x99)\xd1\x91u8\xd7\xf1D\xa7\xd5\x1fy\xca\xb1\xb1\xc8\x93\xd1h\xb1n\xc7\xd2\xf3\x03\xb4\xf3\xcf\xda`T\xd2WOk8\xa0\xb1\xb5Y\x98\xdd\xc0\xef\xa5\x0c\xc5\xd1B"\xf06G3\x16\x84\x13g\x05\xd2\xca\xce\x86\x0e:\x92\xc1sbO\'\x9a\xf4EC\xcd\xbc\x08\xca4B\x02\xfb(\x83s\x19\x05\xa4\xdc\xf8A\xd9\x89>\xf0!}\xeb\xcb\xa9\xca>$\xb9Y\'D\xc6\xa6\xe4\xbd\xfab\xbc\xe6ks\xa65\xcd\xc4~\xf7\xcf\xfb\x81:\x85\xa5(\x06\xe5\xf2\x10\xa3\x0bM\xa6\x91\x99\x1a\'\x9c\x98=\x92\xc0\xd4!\x9f\x8e\xa0\x05i2I\xe1\xa0X\x1e\xa2{\xbd:\xcd-\xe9\xfc\xfa\xf8r"K!\x90\xfa\x88\xe4\xd2iM\xa7Pe:\xc1\xc4\xe1\xbc?\xb9\xbc\x80v\xee3\xdb\xd2\x9f\x83\xec\\__W"\x90\x958o\x10\xb9YEVm\xb8-d\x89\x89\x9c\xfe\x98\xbb\xcc \xeb\x8a\x19\x02\x8a?\xbf\x877\xf6\x15\xf6\x1fE\xfc+\xd8\xbf6@\xa4$\x9c?\x0bbb+\x17\xf3\x8f,|\x84\x8e1\no\xe9"\x1fi\xff\xd4&{\xb5\xdd\xdcg\x93k\xb0\xdf\x1a\x07\x8d\x93}+8\xa5r\x19\xaf\x96\x8bq\xae`W\xc7\xeaf+\xbdP\x16\xb2\xd5\x03\x82_\xd6,\xdeO\xe2w\xfa\xa8\x10^H\x7f:m\xb9\xcc\x06\xacMT\x99\x8e(7\xd0\x89\x95\x0b8\x06\x83\xd8+^\xa2nl\x82\x86o\x01\xe8W\xabFq%+N\x12R\xd8\x15\t\xa3\xfc\x97w\xbe\xdd\x06\x86\xa7\xbf`w^qH\xdbD|\xa2\x12\xe6\x1d\x04\x8a\x9f\x97\xe4|\x8aV\x98\x80)\xd1W\xc9\x98\x07Ph\xd3\xc74\xd4\xa2\t\xe1\x8c\x02\x98\xcd\xf7\x1b\xaa_\xd2sh\xf7\xea\xf7\xe1fJ\xa7\x9c3\xea\x0c\x80\xf5k\x8a\x05\xd3T\x86\xd5\xce\xb8\x089u\xbb\xa0\x91#WVBr\x920\xc8?\xcb\x9d\xda\xb8\x7f\x9dZ\x98\xba\xb8\x8e\xfb\x88\xc1Wa\xfd\'\xdc\xad\x1a:\xabQ/\x0f\x10@\xb8\xf1\xeaepb95+R{\xd3\xd8)|\xc9}\x93\x1a\x16\x9b\xe9\x13\x95\x92Z.\xac\x9d\xa9\xe2kp\xa2X\x89$\x0b\n\xbbM\x8bk9\xc7\x15R\xbc\xc3\xc8\xcdr\xf5\xc9\x17\x14\x98\xd9\x1b|\x1b\xb8\xd3BX[\x16B\xb0hg\xe8Q$RC\x97\xd2\xf5\x8b\x80\xc7\x10i\xae\xd9f;\xe6\xfc\xd3\xf2\xfe\x80\x92\x9a\xd4r\xc4\t\x18\xfe\xcdF\xda?\xab\xd5\x9d\x8bu\x93[#\xe3d\xd7\xb4\xf4\xa6]Gf\xd4\xe0\x0f{7?K\xa1p\x08\x8bT\x1e\x07\x12\x92AY\x1b4\x92\x9f\x94\xbb\x9f\x92\xde\xb3\xd9\xa1\xde\xb7\x1a16~\xd2\xbf\x10\x8bYf\xe4{\x1b\xe26Fo\xeeZ\x81qm\xb5<0\xea\xf6\x96\xf9]\xf9\xcbL^z\xb3Y"\xc1(l\x8d\xea#\x0b\xaaB_}y\xb2Ka&\x8ea\xbcB5\xa0\x99\xbb\xe4\xc8A\xbc8\xacz\x86!\x07(\x0bvOW}\x92qe\x9b\x85j\xdb\xc6n\xa1\xbd-\x94\x84/|J\xd4=\xa0\x8c\xc2\xf1\x17\xd0\xb8\xefME\x99\x12\xc5\xbd\xf3S\xe4\x14\xd8\xb5\xc1\xa8\x1a\x9a\xa6\xe9\x00\xfe&\xbd\xa41\xcb\xaa\xa5\xa5\x06\xc4\x9aV\xa4\xc5\x19\xdf\xd2\xca,*\xc3\xf5\xac)a\x9bZ\x80\xe27\xb3\xb7A\xc4*\xaa\xfdSA\x94\x85G\x1d\x89\x06d\xe0\xbe\xfc\xa3\xe2\xbc\x8f\xcb\x80\x8b\x9c\x19M\xa3\x8ft\xc2u\x9c\rT7[@5\x80\x9a\t\xbc\x07\xb0\rw\x0b\x1d\xa1V\xfb\xa2\x07\xaeh*\xf8i\x10\xb0\x08\x88\xbb\x1e\xcd\xdaG\x9e\xbdP\x8f|\xb6\xa7\x89\x90Y\xecd\xdf\xe2Q\x88~[:\xec\x87\x0bD&\xac\x04\x13u\xf6\xf5\xde\x96\xc6\xb6nq\x04\xa9\x06[K\x16\xfe#\x9a\x1b)\x84:\x00\xeb\x87@\xbf\xe8\x92FP\x96\xdaR\xf3\xe5\x0b\xec\xa9\x90\xd7>yj\xbcM%\xd8\xe5V\xb0!R\xd9\xd4\xccy`\xe4w\x1ah\xa9C\xda\x92\xa5\x9f\xfc\xaa\x90\x96-\x90\x9b\x910\x9e\x9e\xee\xcb)\x82\x9c\x02\xb2"O\xc5BN\x04\xc5+\xb5\x0f\x06Z\xc8\x85:\x06\x9aZ\xd0\xcc\xfaz$\xf6\x8d)\xc29\xc0\xb9\xf9\xc6\x9fU\xbe)\xd6\xf2\xec6X~A?\xc6a\x16\xe1# C*]\x88\xd5\xd7\xb5\xd4X(\x131\xdd\x19\xdbT\xd0\xf9\xb4\xb5\xe2\xa1\x8fbW=\x8d[\x0cI\x03l\x89\xa3\xc5\xa4\xa3\x0c\xe5\'\x17\x90\xda\xa27\xa1\xe6\x92q\x89w\xcd\xec\t\xef\xee\xe1\x07N\x17\xfe\nus\xa9i\x15\xd7G\x99x\xffh)j\x0c\xa8[\xe0\x0b\x89\x84`\xbb\x17\x03\xe1\xb8\x0e\x90\x900\xb9B|\x8fl\xea\x1d~\xe1\x85U\xeb|[\xb0\x18\xa0\xbdxD\x9b3\xb8&\xf0\x16\xf5\x04\x11\xf5D(\xcc\x0b\x8fx\xe9\xb2\xfd\n\xb8\x83\x8bB\x84\x97\x93\x85VO\xbb\xeb\xa3\x17d\xd2\xa3<6\x03\xbc9\xdc\x86\x9e\xb0\x14\xf5\x8dQ3\xaf\\\x1do\xd2z\xe6.\xa2$4\xcbD\xd4\xa5\x1f\x8e\xc3\xea\xe8\xde\x01\xb4\x82\x18\x94]\xadk\x1e\xbb\xa5\x00\xd8\xa0\xb4\x01\x19\xa9\x96\x14#\x97d\x19\x90\n\xa9&\xb2\xe8s\xf6[c\xbaj9\x9dC\xa0>\x84&N\xb1\xff\x92\tX\x7fq\'\xd59\xfc|\xd5\x1b\xc0:\xfc\xbc\xbd\x1c\x86\x1a\xd9\x9d>\xc8\xb4\xa3\x83\xd1\xa5\xf6!{\x93R3\x06M\xcdN\xfa%+\xd6\xd8\xb6zT\xa3\xf0\xe0\xa3\xa3\xb4b\xc4d\xd7\xc6\x93\x03\xd6he\xdb\x87%\xa3\x13f\x05S\xee\x12i\xa1\xf7\xb8\x90C\x1c\xd9a\xbct5d\xc8\x84(\xc9\xcags\x9c\xde\xff\xe0\x1f\x05\x19x>z\xfd\x19\xb6Z:\x87\xd4\xa52~A\xed\xc3]\xeam=\xfc?\xa0O;-\xa2\xa4o\xd7\x9f\x08*\x0fS\x9f\x85\xa3\xd8O\xbb\xb6\xbf\x16B\x066\x89\x86\x94\xdd\xe4\xfe\xfe^s\x99\xb4?\xa8\xe8\x86\xd9\x995p*\x94\xce5\x84\x1dI\xc6@\xee\xad\x94\xd6\xbd\xf25\xed\xaa\xa1I)k\x16\xf3\x99\x0c{\x86\xb6\xe4\x9d|EGp\xc1\xf23\x8c\xad\x18\xa5H?\xf9\x8f\x97\xc7\x1a\xd6\x14\x05>\x14\xa6gRF\xbf\xdar=\xe7+\xba\xf7\x0f\t\xbf\xb4z[^D\\\xfb\xdb\xdd\x0f\x1f\xc5\xe8\x08\x89\x08\x98\xe2\x92\xb4\x993F\xaax\x88\x1d\xbd\x9a\x92a\xe2%\xf2\xd8\xdf\x1a\xd6\xcc(m2WR\x04\x88\xff/\xef#\x006\xcc}\x7f\t\\dX\x10\xc88-\x94"8\xd8f+\xe2\x13c\x11\'\xfay\x91\x9aq\xf8\x06\xb5\x11\xc6"\t\xbd\x82\x8f\x07\xdcJ\t\x14\x7f\x80\xcf\xb8\xd2\xe1\xd5q\xa4{\r\xa2L\x14\x18\xb16m\x11\xb1\x04\xbd\n\x1c\x07A\x7fU-\xcd\x9f\xca3\xdcb[\x85\xcd\xe0\xe2\xa8\x04\x8b\xca\xa2\xf9\xad]\x8f\xad^\xd6\xce\xd8j\xd4U$\xa4\x90<\xe1\x80-0\xd6&A\x04X\xf1\xd6\x9d\x001\x85\xbbnS%gv$F[h\xd6\x97\xd7\xbcd2)7K:\xa09D\xcc\xc3g\xa9w\x9d@\x8b;{\x15$\\/\xf0g[\xbe\xd9\xbcg\xce\xe7SV\n$\xb7\x08\xb9\tgP\xe6\x17\xfaq=<\x87\xd3\xe7Q\xa7\x7fbV\xf3\x8bJ\x12\xd36e\x0c9t\xa3E\xa0\xfd\xce\xc7\xc3FO^\x892\xb9?\x03\x9a\xa9P]\xae\xb9V\x8bZ\xab\x01\x1b/]\xa0\xb2\xc38\xf6\x12\xedu\xd8R1J\xb7\xbb\x01\xae\x9e\x9b%z\x96\x0f\x91\xf4\xdfGT\x0b\x80l\xe8\xf5\x1f\xa4\x18\xf3\x1dT\x01\xe5\x9e\xe4\x966\xde\x16\x7f\xb6\xfe\xd4qm\xa6\xddt\x1c\xce\x01\xca\x17*\xeeB\xd1\xf9OK\xa7[\x96\xc7\xc2\x12=\xb6\xcfM\x04\xb5\xb4"\x83\xa94\xca\xca\xf7\xaa\xdb\x96\x0e\x84\r$\xbaP\xbc+\x85n\xba8\n\xa0MCA\x08Q\xc6\x9e%\xdfm\x14g\x86\x10\xfa3\xb0\xef\xe8\x0c\xa6\x98\xa7\xa7\xf8\xcd[Uh\x14\xed\xfe\xd8[5\xeb\x9c\x7f\xa7;W\x94m\xa5\x8d\xd6Yl\x04\xdfu\xf7 PU*"\x98\x14x\xd8\xc6\xb3)\x00\x99\xc0\x16 \xe2\xa3\x0fH\x02\xf2\xee]o\x13\x8c\xc4\xbbT\xb6\\\x1c-Q\xfc\xb8\x8e\x91O\t\xef\'\x06{\xe1`>\xb9D`\x88}\xc0\xa40\x14)\xf0\xc3\xd40\xe2\x94I4\xfcs)D\x06<\xd5\xdan\n\x80\x829\xa6\xdeCE\x81\x81]\xd1\x80\x0f\xb5\xbck\x8b\xef\xf9\xb5id\xac\x96X\xe2\xc5l\x8d\xfd\x1e\xb0B\x01\x7fA\xec\xbc\xa3\x11\xab\xde\x94\x00\x1c\xad\x9d]n]\x10\xe7\xb9\xaf)\x9f\xc8\xd6\xb5\xaeuO\xd5\x8d\x8f\x9f\xfc!c,\x80\xa0\x88\xdd\x9a5\x9e\xea\x01\x0b\xe6^\x01h\x88\x04\x83\xcb{\xbbyc\x94=\xf2\x92\xb7\xb0G\x0fV1QW\x01"]\xfa\xcb\xf6\xa0\xf5Jq\xea\x81R\xe2\x9a\xbf\xbe)\xea\xfa\xd3oD\x99\xf5\xa3\xc3h\xc8\xe9i\xaf:\x8f\xe9N\xd0\xce\x89|\xd8wk\x18Z)\x01I=S8\r\x88s\xc0\x17c\xf2\x88r\xdf\x0bJLK\xd1}<\xd3W\xed2\x87E[{\xfd\xc5\xef\x12h\xd8a\xc57\x9e^\x16d\r\xafR\x04\xa2\xd5G\x01I\xf7q,\xb7\x12\xd8\x9f\x13lW\xb2_5<&\x06\n\x1a1\xe7)\xc3\xa5\xc5v\xcb\x8f\\\xa3\xe3\xaam\x075\xa8\x8c\x07oip\xd2,\xb5\xef*\x02\x1b\x95Y\xa8\xe6\xd91S\xb66\xe9:\x12\xcf\x1d\xed\xdf\xc38\xd0]\xff0\xed\xb2 \xac\x97dF\xf4#\xabg\x1aZ\'\xeae\x88X\xe9\xf6+]\x13\xe2b\x8be\xbf\x99\x96\x9dSk\x11\x07X\xb5#\x96\x9fzX\x9a\x88\xc7j\x7f\xd9\x7f\xbe\xfd<\xcc\xb5[x`!\x8e\xeb@\xf8\x93[3.\x8e\xda\xdc\x8da\xee\xa6z\x9c\xc2\xb3t\x95d\xec\xfc\xd4\xaa\xe29>5\x16\xf4\x069\xd7\xa6\xf9\x05\x10\xa9\x89\xd3\x08\xe9\x86\x13*B\x13\x8d\x89\x1f\x9bZ{\xc0ZJT\x11\xd5\xaf^w\xbe\x0eCH6h1mSj\xc6\x87\xf7\xa4\x9ev\xe1&\xf2u2ee.\xfca\'\xfb;\xc9\xcd\'\xfb\xa6)\xbb\xe1 \x8eP\xa8\xaa\xf7\xfa\xd1X\x14D\nt\xb3K\xf3\xd1\xdb\xf8\xb7lh\xe6\xdcv\xccg\xda\xcdM\x8bJ\n\xcbG\x88\x1e\x06\xed\x9f\x9a\xc0\xe1\x9a\xb1eY\xa8\x18&-(\xe7an#\xf1c\xe4\x83\xc03\xbf0\xb6\xccD\x10=\xad\xb3Y\xa0~!\xa8AKs\xee]$\ta1\x93\xea\xa0\xa7]\x97H)\xae\xc5}F\xfc\x13\xceR\x0e>\xc5D\xa7\xc2\xb7"\x1d\x9d~N\x85.\x99\xae\x08]\x97P\x8f\x1c\xe5&48\x9d\xa3\xc2:\x93\x17\x8f\xc96\xea\x18\x9bMDhf\xd9\xec\xe7\xf7\xa2\xf8\x06\x9eD\x8d\xa1(\x1bj\xbd\xb9G\xfeH\xae\x81\xd5\xb9)\x1f\xa6\xb7\xb4\xae\xbc\x81\x90&\x9fr\xbf\xb6G\xd7\xf0\x8c\x9d\x18\x0c\x15\xc5\xbe\xef\xc5\xf5\x1cHBf\xadyR\xc5\x9d\xe9P]\xb7{\xc4*\xe1\x98\xd2\xd8\x88\xd8\x9d\x7f\xe9\xd1\xa0\xffD\xe5\xab\xf5\x86Q\xd8\xa5\xf8,\x01P\xf4\xc9C\xcd\xec\'\xb2\xf9pt\xed\xa0\xa4\xb3\x95\x08>\x0c\xc1\x00\xba\x96\x7faq\xa3\xa6`Y\xc7\x9fB\x0c9\xa7\xb7\x1a\x7f\xff\xd1eQ\xb3;\x02F\x9c\x93 >G\xb2}O\xda\x96\x88T\xca\xf2\x98\xbbt\x92\x12\x00\xadHq7\xe5\x82.\xec}\xf2\r\x91\xee\x07\xe91\xfb\xa8/M\x8f\xa7\x8f\x021\x8d\xcb\x9c\xa7\xa0\xbc\x14\xef\x1eG\x9c\xf9\xf7\x85\x93%\x9f\t\xb1\x9f\xe9a5\xc7S3`\xe4o\xde|\xa4oGR{3\xc3\xad\xdf\xff^\x97e H\x960\xdam\x90?\xf2\xb2@\xaa\x95\xb0\x14e\xb7\x95x$\xdej\xad\xf8\x91\x0b\xad^\xad1\xe5W\xe1hF5\xa2wv\n\xb5\x1e\x00\xb1\x93\x95S\xc5/m\xd8H\x84\xf0x\xc7\xa0\xa7W\xba\x1e\xe3W/\x8e\xec\xe6\xa3K\xa3H\xfdp\xbfl\x80s\x18\xbb\'\xe3\xd1\xf3\xf8]\x1c\xfcT\xa2rj\xde\x19e\x10\xb5-\x1cH1U\xcf|\xf7(Q\xf1\xbc\xab%\xe7B}\x9d\xb8\xf1\xd8^\xee\t\xaa6p\xc7\x82L1R\xdb\x8e)\x83g\xc8\xa3\t\xd9\xa4\xf3hr\xb3\xfa\xcaP\xdd\x1dg2\x1c\xd4Y\x96~\xe4]\xd3u;\xc8\xf8\xfe\x8bBE\xed>\xab6\xceh\xac\x13G\x98\x11\x92\xf1\xfd\xd74\x9b\x1b\x04\x83\xa1\xc3S?\x80@|T\x08\xbeU\x14\xeb~j\xb2\x10\x96Q\xfd\x1c\x15\xd7\x1dU\xee\x08SH)\x03\x8f\xc2D\xbc\x1bq\x94\xb0\x83\xe7\x10\xea\xdb?:\xda\x00!\x90t\xe2\xa8\x82\x87\x96\xa8\xeb\xf9`\xb7\xcd\xc6\xcf\x84\xf7x\xc8\xea\x88\xe2`f\xa2U\xf0\x13\x1ar.V\xdc\xe8\x98\x04\xf6\x82\xb1\x8ck\xdak-\x9a{\x87\x19\xa1\x8aB\xa1\x03=\x90\xa9\xdc\x05\xb9rmz\xe8OUH\xdeI\xac]\xb21\xa5U\x80\xebtc\x90\x89\xd0fcR\xf2?\xd1\x12\xdb\x0c\x86X4\xa1m\xddU-\x9b\xddfR\xd3\xe1\xb8\x10\xbb\xacaP7f}\xc0x[l\x8c\xa0L\x18\xe0\x85\x18r*\xe7~\x9b\xed\x08bH;$\x10\x0f\xd4\x8d@\xd0\xc0i\x9a!\x84\xcb\x8c\xcdc\x19O\xe8z\xc5\xeb8\x19v\xd3<\'\n\x04\xf2Q\xf9\\\xd4\xbe\xeb\xb8\x1d\x08\xf68\xec\xbe\xa8L\xd3\x84\x06&?_\x0f\x13\xefjUt\xdf~\x83w\xf2\xadt]n\x91\x99\x125\x9a\xda\x90\x8f\xa7\xe0\x87\xedG\xe8\xa1\x1eM}\x1f\x0c%i\xa6\xf4\xb2N`\x97\x07\xf2\x1c\x1fn\x82\x92(\x07\xd4\xcf~\xec\xa8\x11\xe3\x0f\xafL\xb2\xa8\xd3\x92\x02\xe2\x18\x97C\x9b\tO\xffa\x1b\xbf\\&U\x18|r\xd0\xc1K\xc7\xad\x86\xb2\x8dJ\x02hY\x06\x9e\xdb9\xfcj\x88\xc5+\xc3\xef\xb0\xd8\xdd?\x9c\xd6x\x91\xb5ge\x7f\xd9*\r\xbbl\xad!-\xfc\xaf\xd3\xf2\xd6\xa1\x07\x92_v:(\xa0\xdb\r_\x1e\x08\xa1U\xbe\x83\x0b\xc6\x87a\xc84\xdadbLR\xd3\x01\xe8\xfd\xe2\x82\x94\xb63kX\x01qX\x99ru\x18\x15\xabwPT\xadE\xe5\x95\xcb\x94\xe9\xea]\x93,\xc0q\xe0\xf6\xb9\x03\xfb7\t\xa9\xbc=\xe1\x99lc\xb8f\xb1\x97\xb2"S\xc3\xd4@\xae\xe1*S\xb8@v\xbf\xcd\xf7_.\xe1njq\x8c\x81\xe8\xc8WFtX\xce-\xc8\xd5\xbf\x9e\xc7\x9f\xa7n\x19+\xa4\x8c<\x05\xef\x01\xcb\x7fK\x1e\xe6\x85\x81\x98\xed\xb0s|\x04\x14\xdc\xd8\xd3\xc6C=\x9d\xd1\xc9\x92\xa9\x17\xc9\xf1pz(\x168w\x7f\x08w\xbf\xdb\xfb\x91\xff\x93e#d\xa9D\xed\xd6\x80\x14\xfcI\x0e$N\x8bg\xc0P"\x02\x1a\xe17\x91\xeeb1\xf8NPy\nS\xbe#\xae?\xf9\xf5^\x85\x08\xd3\xa3\xf2\xd7\x11.;^8ku\xc8\xfd\x0c?\xbcT\xf7=\xbc\xb6\xf3\x9c}x\x0e\x06\xd7\\?~\x11\x11\xa4],\x02o\x84\x91\xb9$\xb4\xfc\xb9\x19\xf5d\xcc\x9fs\xbe\x85\x16\x96\x0fO\x1be\xeb*y\x15\xc5\xbcPr2\x7f\xba};\xf0c\xb8b\xfd\x1e"\x91\xe8\x87\xc8Bc0/P\xe4\x1e\xd0\x9b\x1ad\x9a\x1c\x81\xb5V_N\xa5\xb4l\xb3]SKa\x95$\xab\xd1\xc7x\xcd\xe7\r`\x171\xa7\xe3\xe7\xf5\xb1\x1d;\xf1c\x0b\xd7\xa6j\xa2\xbe?X\xa2\xa3\xfd\xd9\x9bf\x9d\x1b\xdf\xde\x985\x0f~\xf0a\xde\x13\xb1\x94\xc9{\x08\x18nth\x97Ym\xf0\xb7.\xca\x9c\x01$\xd9\xb3*\xf1{M\xa3U\xe0\xe0\xcc6T\x96\xd9}2Pj\xa0%\x93\x9ev\xd8\xc5v\xff\x04=fix\xff\xcfO\x01s\x93\x96\xc7\xce\xf5\x9f\x1a\x81+qa\xc2\xfb\xd9\x8cA\x9a\xc2\xccj]\xfc#r\xf4\xf5r\x14\x16{\xe1\xa2\x19\xaf\x19a\xb0\x0cC\rG\x94\xf1e;\xc6h\x97P\xb1\x1b\xf8\xee\x8f\xa4AY\xe9\x19~\xcd\xf1\xde\xb4\x98\xbc\xbf\x83\x18\x80\x8e!\xe8\x8cI\x9f\x8d|9h:Z\xa4\tO\xb4\xe6O\x82\xc1\x99\x9e\xf2\x04\xca\xe5\xd2\x13\xa4jD\xc3v\xfaV+\xd6\xa8\xcdI\xf2U3:.>\x9bZ\x0c/\x0f.\x99\xfd\xe2\xf1#n\x0e\x9d\xf6\x91P\xf4\xb1%\x958>N\x96Qa\xf9\t\x91\xa5\xe6\x8by\x89\x00\xf4\xf7r\xab\x05\x93h\x8ey\xb7C\xbb;\x94\xae`\xb0\xd1\xa4\x93\x17\xb0|\x17I+\xd6\x19\\\xe7\xb8\xbb,\xd1\x88\xdd\xa8P\xbay\xf7AT)\nz>Q0\x91\x9a\x13\x05\x9e\xc0\xc6\xe7#M:\'\xeb*\x07q\xebi\x16\xff\x142\x87a\xc8\xd5\x8e\xech\x01:w\xfe&\xd9\xcb\xe6\xff\x94{8c\x1e\xa2\x87\x0coF\xdar\x82\x19\'\xe9\xf3\xd3\x9e\xc5W\xf1\x00\x9b)\xednt\xf1\xbb\x94\x88\xcd0FT\xb0P\xf5\x05-\xcd)\xb6\xffH\x1ee\x03m_}\xe3=\xab\x1b\xcc\xe6\xba\xbb?\xb4\x1e\x85(\xea@0c8D%\x04\xd4\x0ej`\xa4\'7_\xbb\x91![\xa9\x12i\xaf\xa4\xc8 cl\xd55f\xb9\xc6\xf5\x06\xa8\xad\xff\x8f~s\xd8}\xfcv\xbc\xbf\xa7\xbb\xec\x06\x96M\xe4l{kp&\xca\x0fzc\x9c\x07\xae\x1bv\\h\x02\xa8\x1b\xa7P\xe1# %\xc6\xb7D\xfeA\xe7\x8fv\xde\x08\xd4g;\xb5$\x98\xac\xc1\xa0zFQ\xcb\xff1n\x8a\xc9\xcf\x0c\x8e\x94\xf1*\xa1\x7f;\xda\xeb\xd0 G9Rt\xa9\x98m@\xd1\xde\xe6\x80\t\x89/\xe0=\xf1\x8eiJ0E\xd3o0\xa0!0\x067\r\x8e;\t"\x8eC\x06\xe6"C\\\xdbH\x9c\xec@\xceBj\x92\xad\xd2\xbbg]\x1cp\xcf\xb9r\x19 S[\x88_\x04\t\xb1\xedh\x10\xa5\r-\x07/\xe7 \xf8\xca\xe3\xd2t\xe9\xf2\x1c\xc3\xb6px\x8dq\xb1\tK\xbeQ\xdc\xfb\xb0n\xb1\xcd\x19Df\x0e\x9d\x04S\xdc_\x038l\xc9\x1cg\x89\xd2\x03\xb0\xd5\x7f\xc2\xc6-c\x13"\xd3\x00H\xc2h{\xf6\xde\xfa\xf4\xed7\x9bn\x0b\xf7RBW\xad\x01\xac\xa9\x96\x19\xd2\xfd\x8a\xfeF\x0c_\xca\x89\xb8X\xfd~~F\xfb\xa4\xa49\xed\xfd\xe3\xce\xaeB\xcd\xb1\xf5\xc2\xa7l\x04\xbd,\xea(%\x0c\x16\xec=\xa4\xa2KN2\xd2\x15U-\x96\x17\x04z^\xc0\x15\xb4\xd8\x92{\xa9?_.\xd8:\x0f\x9bM\x0c\x8f4Y\x9c\xde\xc2\x86\xf8d\x05\xdc\xa4|\x1b$-1\x1c\x81\xda\n\x8e\xe4\xe7\x13\x1d\xf9U/D\xf3\xa7.4&\xee\xb6\xa4\xc5\xdd\x14\x1d\xb9\x92\x14\x8cA\x05\\\x1e\xf8f\x14d\x81\x96aE\xa5\x1e\x83=B\x8b\xa9MC\xdb\xab\xc0T\xac[\x93\xe5\xb3\xa7-\xc4\xa8\x8dKa\xa0y\x87\x009u\x96\xac9\xba\x92\xe2]\xbf\xe1\xcdH\x15\x86A\xe5\xe4\x1f\xa0\xf2\xe1z$\xa0\xd0p\x19\xa02\x1f\xf0\xb3\xf1\xc3\x8c\xa2\x9f^\x9bx\xc2=\x05\x18\xefp\x0e\x05\x02\xe6i\xf9[}\tKsGxX\xf9UC\x86\x8b\x84#\xf5@\x17\xb8i\xa5\xc2\xb4\xcb>ai:B\xce\xf5\xc1\x93C\x0f%\x99Z8\x90r\x85\xb0\xa9]\n\x94\x88\xdbF\xf2\xb4\xf0\x13\t\x07\xd1\xf5O\xfb\xe2\xec`\xd3\xda\x85\xee\x05\x861\x0b\xa5\xa0\xa8\x9d\xe8\xaeaH\xef\x1aE\xd5\xa6X\x82\xd9\xe7\xca\xe0\xefF\x97)\xed\x8fs\x0c\xf6\xca7\x8e\x9b\xa9\x89hJ\xcf\x88\xba\xc5D\xdd8\xec\x7f\x9cV\xd0\xe2\xb04v\x9f\xe8\x9a|\xa7\x85]\xb3\x0e\x95\xfd\xb5\x1d\x17P_\x13d7\xf4X4C4\x00C\x92\x15\xc7\xff\xab/5}\x15\xf9|e\x8b\xae\xd5|\xb9Z\x1c\x9c{\xd3Wy@\xbcB\x80L\x08WF\x1f\xb3\xb31\xe0\r\xfe\xbd\xa2\x01J\xf0c\xf1^\xdb\xa3\xaf\x1c9\x8b\xcd\xdf\x9cB-\xce!\xb7(\x8e\xc9\x8fmP\x16\xa8@\xce\xb8r\xe7>\xe4\xeb\xe5\xe3\xee\x1e#E\x00\xfa\xe8\xea\xc8\x12\xa3c\xd4\x8dLci\xc0\xcf\xaa\xd4@\x86\xb2 p\xd8\xf6BS\x13\xb8\x165\xcf\xb3v\xbe *\xf8`\':xZn\x95\x1eL\xa6\xa0\x05\x00\x9f\xc9\xb9\xc3\x90\xd3\x88\x19\xf6\x81\xa7\xc6%$\t\xe2\xa3T\x11)\x90\x1bp\x112\x10\x0e\xc4\x05{:*gvF\xa4+7\x9e9G\x0eN\xf5\xb8\x0b\x92\xd0\x98ji\xcd\x99\xa3l*v\xb5Q?\xc7\xf1\xde\x9d\xf1\xd4\xfd\x1b\x18\x06\xb1\xe0;\xd3\x1cUM\x05)Jn_\xd9\xfa\xc5\xc7\xdd\x9c\xe22a\x04pS:\xd4 \xaf\xf9\xaa\r\xf6"[\xca\x1d\x881\xb2xw\xdc\xc7\xac\x95\xd7\xf1\x8b,5\r\xd1A\x93\x14\xf9\x1a\xc5_V\xa9f%\xce\xd03\x88q\xcb\xa4=\xdb\x12Uuh\xf4\x0c-\xce\x05\x9d\x9d[v\xc6|0\x9d\xa4\x05Zm\xd0\xfd\xb7\x1b\xc8\xb9m\x89\xe6S2w\x05\xe0\x9bM\x89\x1c\xa5\xa6\xb6[5\x88\xc6\xfb0M\x95\xee\xf5t%\xb2\xf8\xb6*\x05\xf0$\x96\x80\xe4\xd5\xc9\xb8=YYq\xcap\xfa\x02/\x86L?\x9d\xf5\x84\x99\xa8\xc2\x08m]p\x98\xde\xe1P3\x9a\xc7#\x02\x83\xe4\x93\x9aq\x1a\xaf\xa6\xab*\x05\xcfhjH\rrmO\xefK\x86\x0b\xad}\xe0\xa3U\\\x13\x10j\xeac\xe1\x97\x187\x0b\x0eA.nS\x0b\xe9QT\x11\xcf\xce!U\xac\xfe;=\xd21\xd3\xfb \x95\x05CN\x92\x8dJ\x1fk\x16\x02L7^\xcb\x8b[\xca\xf4oM\x8d\xa8\x97|\xfa\xca\xe6\xc0\xc3,\xbc\xf4tjYhN\x18\xb7\n\xabV\x91\xab\xef^\x9c\xcc\x94\xe1M\xc8e\x8a\x90\x84\xf1\xd1\xe2\xb3Lo\xa02}\xae>\x19\xfd[\x1e C\xdb\x93\x1c\xe8Z\xff\xc0\xc3\x15{]\xbd/\xc3\xa8!\xb0\xcbd\x1c|\xc93\xf6$\xd64\x82\x0f\xc80B\x0bo3\xbb\x13\x12~\x86\xf1\xa3\xe6\x91\xb8\xbe\x80\x8c\xb0+\xab\x95\x8d\xe1\xf0\x87\x96TY\x0f\xec\nD\xe6x\xe2\xf0\x01pwq\x88\x8f\xa6\x92\x0bJ\xa7\xf6F28\x91\xb0\xbb\xe8R\xb4\x02\xa4\xf7"\x10\x8a~E\xf5\xc2\xa4J\x9d\xe2\x9chR\x9fLh\xea\x84\x9d\x93\xd7\xf2\xf8\xa1\xaa\xe6\n\x06X\xf3\xbcb\xabF\x0b6w\xb6\xb4\xce\xf4\x1e\x16\x16\xbb[\xcd\x9a\xac\xa0xB4/`\x8d\x08]\xbc\x99V^<\xcb\xa4v\xafB\x89\\\xf2\xa7\xf5\x19 \xcb\x17\xf4\x9a\x80\xf2{\xa0u/\xe3F\xc5\x07\xf2ln\xca\xd0\xcc\x00\xce\x1az\x1d\xf2\x00\xd3\x03u!\x93\xea\x8d.c\x92U\xcb\xb4\xd0o\x1ewJ\x7ff6\xb5\xaf\xd8\xc3\x04ccy\xb7M5F\x81\x0eZ\x91K\x06\x9b\x1a\xeb\x93\xb6\xb2\xa2kwA\xb8N%r\xe5\x18L\xf0\x0b]\xde\xbfW\xa0\x1e)\xe9\x85\xa8\xef7\xf5\xc6\x08\xa29\x84\xfd`\xc2\x02\x1a\x90bvBh\xbd\xd1\xfb\xee\x7f\xa7\xcd\x9c\x9b\xe6\xcb[\x18\x10\xf4j\xe4\x1e\xaa\x8b\x16\xdf\x13B0\xd1\x1dn\x0b\xbb\xf4*$^\xaa-\xee\xb6\xf5\x14z\x10\xe6O\xa6\xbd\x03MQ\x8aL\x83\x14\xdb\xffa\xfb|\xa6\xb0\x1d\x94\x87\x8a\xef\xbd\xf3v\x0b\xd3\x06\xde\x9eKgV43\xee\xa1\xec\xa4|\xecu\x9cU/D\x1c\x1bN\xa0\xbf\xe1C\x9d\n\xf4\x01Za\xbb\xf4\x16\x14e%\xf4:\x0f\x8e\xfc\x06\x9f5*=\xa1\xb2T\xaaE\xad\x06\xe9\xae-\xf8\n\xe3\x90^ho\xdf\xdcok\xbf\x02\xa7\xec\xe6\xbb\x91\xfa)m\x05\xad\xdeL\x8bsh?\xa2\xc0\x03\x88/N|"\x81\x84\x11\xc3W\x01\xd8x\xd0|*S\x0f0\xbcr\xf2\xda?0\xf7\x82M\xf3\xe2\xdf#q\xab\xe0\xdbM\xc3\x8f\x01\xd64\xd3\x9eF\x9fI\x18\xdc\xbd\x8f\xed\xe0\xe3\xaa\xea\xcc\xb3/T\xd8\xa4x\xc0\xb3kx\xd0w\tP\xf5k\xa2\xf7\xf6\xdcQA\xeeQq7\xbe^\x1b\xb44\x18\x81\xa7Y\x83v8@|\xdeT\x0e\x16\xc2\xe8\x10\x0f\x95\xa6\x14\x80\x9c\xba\x14XQ\x91J\xeb\x1f\xa4i\x94:3\xaf\xa5,]\xc0\x80\xfa\xaa~\xdeEZ[\xd10y\xcb\xbf\xb2/^\xf6\xf0\xd9\xb5\x9b\x16\\=\x9f\xfc\x9dS\x9fR\xfb5\x84K\x8a\xe90\xfd\xc8\x87\xda\xed)\x00k\xd2\x95\xca\x9aw=>\xe7\xc2\xae,\xe1Y\x89\x8fs@\x96B\x10\xc6w\xad~\x12\xd9\xd8\x18\xe66>\x9b\x95\x94\xe2\x9e}\xa4\xb1\x00\xbb\'\x81\xa09\x02\xa03\xder\xe1\x9a\xe5\xcb\xb7*\xc1\xad\xceC\xa3\xe8\x82L\xa5%\x8eG\xa6\xd1\xaeH\xd2\xe3a h\x90F\x0e\xf5\xfa\xe8\xc5\xec\xff\x126\x95\x81\xaf\xb5\x9a\xc8\x92\x9cdb\x07\x04\x10[x\xa7"Ucg\xb8\x1b\xe5a\x98\x02\x884T\xc3\xdc\xa9\x9b\x14\x03\xedB?K\xc0\nL\\e\xf5m\xd5\x0c\xf7m\x9c\x11H\xc5\xca\x93\xf2\xdb\xbd\xf4A\xfc\xe9\xe3\x1b\'M\xa3wR\xad\x85\x1bK\xd5\xe6\xbc~d\xcd\x93&\x00\xe1\x95t\xca\x8es\xc7\xe2\xce\xf0\x86H[$\xd6j!\x85\x93e\x94k\xdc\xa2;\xc1\xbehG\xe8\x8dj\xbc\x02(\x11Z\xabsn\xf8\xc3=\x9a!\xa8\x89\x94\x7f\x8aj\xa5{\xfb\xf9\x1fl8\xcdAV*3\x99{\x8f\xa9G\xfe\xc1M\xff\x19XV\xd5=P\x08\xe2!\xf2:\xf2\xbc\xaen;\xbc6\xbbe\x07\x9a\x88\x15>\xd1R\xbe\xe4\x14&]0\x9e\xa9T\x15$\x11\x91b\xaf\x84>\xb2\xfe\xeeK\x08\xb9\xc77\x17)\xa6+{q\x19\xae=\x87\xc8\xba\xfd=Om\xbe\x90\xf2E\x95%\x89\xeeV\xae\xf3\x15\xcf\xcb\x89R?\xd0\xa5\xc6\xfcK\xb3?C\xb1\x10g[\x1co\xe3\xe5\x89\x0e/\xac\x18\x8925=\xab\xab\xef\xa0\x033\x92\xc8g\xc1U\xc2#c\xc4\xc9,\n\x97\xf7\xc0\xcb_\xde\x92\x85~8.\x85\xe2\xa2\xec\xeb\xefe\x0c\xa0$\xe2\xee\xd3K\x12\x19\xad\xfb\xca1\xdcn\xe6lX\x18*V\x7f\x1d\xff\x99\xa3\xac\xe3\x1e\x9e\xde\x86\x0b%5\xea\xe8b\xad4\xdaO^\x19\x8cF\xad\xad]K\x1cA\n\x9b\x95\xa1\xd8mI\x87\x94\x90<\xed\xab\x82.\x8e\xdaVO\xb0\xd4\xb5*b\x06r:\x03\xd8d\xe6\x96\x86\xba`\xc7\x15\x13o\xba\xcd\xc6\x9c\xd8HnJ\x8f\x92\x11\x9d\xe3\x1e\xde\xd7`\xec\xa3I\x00\xc7H@\xf5K\xc2\x89\xa3\xcd!~b\xd9\xc7%7\xb2\xb2\xb1S<\xfc\x1c(\x03OC\x05\x99\xe0\xcfw\xe9\x98\x91\x8b>\xa4\xd0\xf7k9\xa8}\x9c\x93 \x80\xdc\x14Z\x06\xca?]\x13\xe7!\xe6\xf4^!\nXy\x8f\xf369\xee\x80S.\x1f\x01\x97:^+yq\xba\xe6\x8a\xdc\x89\xcb\xde\x82\xf4\x97T9\xeaA\xd2\x80\xf9r\x96fA\xa7z\xc2\x15\x86p\x8d\xb74=x\xbd\x08\xcb\xff&%4\xf3\x7f\xb9\x8a\x91`^\x84w\nX\x0b\xb5yQ\xa2\xc8\xb4\xf8\xcdG\xdc\xce\x92@\xdeB[\x88\x08i\xa5nr\x80\xf92\xee\xfe2\xdc\xbe\x10\xcb\x8a\xb5\xa1\xf6}b5\xaa\xd0\x8f\xdd\xac\xe5U\xe1\xd6\xd9\x8d\'\xd0\xfc{\xcb\xab\xec\xe2\xd3\xaaA\xb1\xc4\xe9\xc4Dn\x87u7\x19IU:\x87\x1dy\x94&\xeb\xe8o\xd2\xd6\xc2\x07\xc6\x86p\x0b\xad\xbe\xee\x1e\xa1\x10\x1c\xc0e\x1b\'KIiI\xdd\x15\xbd\xb8"\x91\x9aXJH-\xe8\xf2\xcf\xe5\xd0\xd57\xf2Y\xe2\x853\x99}\x96\xa5Io(\xb7\xf5\x1c\xc0\xda\xf6\xf7R5\x1d\xd8.E\x7f\xf3\x996T]\x93\x8a\xbc\xf1\xbf\xe10\x1c\x89\xa5r\xecc8\xf6P\x90&\xc8\xd7\xcd\x8e\xf6\xa3W\x85\xbf\xa1\x94\xff\x9b"\r\xe9\x84\xf5\xfa\x9b\xf0\x9bje\xbc\x90\xd4\xdb\xff\xc7\xac\x08\xad\xef\xede\xa1jt\x8b\x97\x99\xb8\xd3s\x93\xa1y\x9b\xa8r\x12>\xda]`\x02@#b\x1c\x85k<\x8a\x87\xf7\xea\xef\x87\xcf\x1b\xe5&\xb4\xbc\xd1\xc9w\xf6\xb3wZ(\xf0\xea\xb5\x1c&\xf4\x0e\x02\xd7\xac\xc1\'\xf4\xd8\xf2\xb6o\xde\x10x\x8c\x84\x968\xa0\xe4\xd8_"\xd0.\xf8,\xa5mzwa\x83\xebX\xd4pS RH\x07j\x7f&\xd9=\x82\x04\xa9R#\x8d\xef\x1b\xdd\x9cG\xf6\xc4t?fA6>\x1f\xa6n\xf3\xf7\x87U\xfbD\xf1\xfe\xb5(=\xad\xd7\xb2A\x99s\xcb}\x90\xc5\x93\xc8\xb9\xc5|\x02SV+U\xec\xd1\xe0\x8c\xb9\x13n\x10\xb0\t\xddw7,\x1c5\xfdn\xf9\x8b"\x05\xf5\xaa\x05\xacAen\x12\xd9\x00]\x1f\x0b\x04(M<\xd7\xadvy9\xad#v\x9c\xef\x0er\x01:N\x02\xe4")f\x97\xc1fF2\xe9\x90\xa3\xe0C\x90\x15\x83\xd4\x08\xa4\xecC9kz\xbe\x97\x07,\x8d\xa3?\n\xcep\xdc\xe0\xd4P\xdf\xecRTo\xa1$\xb1f\xc6f\xa4fk\xcb\xc0j\xd3\x19$\xb1\xb3\x008V\xb8\xdf\x9fP\xe3!\x04=\x1b\xc9\xba\x8b\xc0\x92\x97\x04\xff\x03\x02X(\xc3\x1a\xf9(\xaa\xe6\t\\\xf1\xb6\xc0\xa1U\xc1\xcb\x00\xf5\x89\xb7}S\x95Y1ym\x14q&nn\x88C\xf6?\x1a7\x11A\x9c\xc3Jl\xe1t\xaf\xbaf\x16O\xae\x7f\xb9\x0e\xd6e@=\x9aW\xc8\x9a\x98\x9c\xc9\xadNM\x9e\xf3\xf9(\x8e\xc8\x82|8\x0eL\xd6\x9c\x89)\\\xea\xddW\xcdy\xf9\xd4\x02\x07\x0e}$\x01\xc5\x84\xd0\x13\xb5{\x0c0^\x8d\xf3\x08(\xd1\xa8\xc1\xc5\xaa\xa3\xfb\xf6\xb3Y\x03."\x166\x93\xae\x0c\xc1\xa3\xa0B\x8f\xc9,F\x832*\x82\x04\x90EM\xf5\xb9\xc96\r\x0eK0\xde9b\x14\xc7D\x87\x82#\x85\x16\xb4\xf1\x9eE\xa2\r\xb5\xd63\xd8l\xae\x18\xb7\x95\xb0\xfaG9\xe2\xb2\x9c\x048\xd5>\xda\xe9\xfd\xf6\xbc\xdfZ\xbe\x05Y\xf4\x8alG+;\x93w\xdcj\x03t\x81?\xccw\xf5\xe3\'\xd2\x05\xd0nq\xad\x86\x8e=5\x86\xef\xe0\xc5\x17L\x17Y&\x889\xcb\xbaQp\x93\xf0\x0b\xc0\x9c"S \xe4\x00\x90\x9e\xeb\x98\xf1~\xdc\xeb\xb2H#\xc6DKh#\x839\xe6\x01"\xd6*Z,\x85g\xecc\xc8\xfe\xf6\xfa"[\x1e\x06E\xe69\x00\x85=\xc3\x96\x18"~]d+`Y\xa2\xe7w~\x8dC\xcb\xce\xb9u\x0e\xae\xbc\x0c\x07d\x92}\x04 \xefV1\x7fd\xb8e\xd6\xc1$>:\xd0\xebk\xea\x91\xa2c\x8e\x93\x96\x9c\x06\xfeX\xc1\xf3Y\th\xdbLe\xad\xce\x0e\xa5p\x8f\xaa\x1a\x0e\x01\xca\xd4/\x06\x0c\x12\xdd\xe9\x00\x9f\xdaO\xd5\xe3\xf5\x08\x19m\xaa\xc9\x9c\xa7L\xcb\x94*\xfd\x90C\xb1\\\xf5\xde\x9b\xed\xa1>\xed\x0c\xfaCy\xc4\x14|)%^\x18(\xf5H\xdb\x034\xa3\x89\x92\xc4\x9bS\xa51\xbap\x08\x1d\xf1y\x18\xc2\x8f2\x17\xe1*\xa8\xa395+\xfc[}\x15u\x17_\x98WJ\x954\xd5.\xe8i\xb4\xae\xa3\xeb\xa9@\x0f\xc2>d~o\x85\r\x91\xaf\x87\xe0[\xae{\x89\x1f\x03/\xbe\xb9\xa4\xbf\xe4\xbf3HT\x9d\xca\xe3|\x94\xe5#\x00]@Q\x8e_\x14\x04\x93y\xb5\n},\xe9\xbe\x05\x7f@\xcc\xc8\x10\t\xa8\x92\xcd\xd3I\xe4\xdb\xe1\xfc\xb7\xd4lD\x7f\xa7\x071\r\x16\xb01\xa5\xf0\xd6\xcb\xbdof\xc2+\xb9g\xeeX\x0c\x80\xb1Z\xc2j\xca}\x14X\x88\x129\x8b\x8d\xf5\x08x^E\xfaDhD\x0bh\x12\xc6\x0eM\xe0\xfa\x81\xab\x02\x11\xc7\x13f6Q\x8f:Z^\xe2\xff\x1dcl\x01\xbf5\x13;\xf1\x9aa\x8b\xa5HR\\\x8c\xe3Z\xb2\xec\xd8\xac\xf9\xeb\x04&\xc8\xc3\x9dk$.\x17\x81\x9a\x9c\x80E%d)\xba\x81\xdbl\xff\xfa\xae\xe7\x8e?\xe1\xbf\x84\xc1\r\xfd3\xf4\x83\x92\xe6\x02K\xd1\x06[\x05\xa6W\x07,K\nA\xcb!/\x9e\xf9,\xb1\xaa\xa7,7\x9f3\x11\x15@\xd3!,\xc2@M\xe1;\xb0\x05\x19p\xf2\xa2\x02Tf\xc1\x00[w\xda\xd1\x05*\xa9\xa5+\x17\x00\xd6\x96\xdaN\t\x8b\xcb\xce\x16Q\xd0\xce5\xb3\xe6BwZ!\x03\xcf\x14\xa1/\x0e`\xc4\t\x83s\xb9\xf4\x94\x11\x17$\x19\xe4\xe3M\xb9\xbe\x18\xea06(\x93Un\xdb\x0f\xef\x07w\xbb\x8f\xee\xfe\xba8)-,\x9ea\xa3?\x97u\x1f\xc2\xfe\xd2\x04\xbd\x82@\xd2&c\xa6O\xebt1\x1f\xd1e\xa4\x8b\xff\xcf\x8b\x06\xaf\xdc\xc0eP\xa2\xe1\x8f\xca\x04\xcf|\xde\x00\xf0\xeco\x05\xfa\xdc5\x15\xa7\xf6\x07x\xc1i\x0b\x03\x05\xfc\xac\xf7\xe9\x1c\xbe\xc277\xc2\xdb\xe5\xbc9\xcd\xa1%;~\xb9\xedb\xbb]\xd8*\xd6\xfc\xd3znT\x06<\xffq\xee\xfc\xc4\xc5\xd1vN\xf9\xbe\x1b\xff\x10\xac\xa1o\xc7\x07Cs\xd8\x00\x93T|\xa1\xc3\xbe\xdb\xfe\x91Gn\r\x1f\x91\x9a\xc6\x00\xf8\x10#\x18&-1\xb4\xb0`\xbb\xcb\xf5\x15P,\xae\x1e\xa9\xddmlj\xf2\x91\xb6\tO\x14\xe3\xe8\xb9\x7f\xe20\x0chjB+Z/\x1f\x8b5\x9b\xd8\xae\xb4\xafV\xc1]3\x07\x10\xe43\xbf\x0f\xa6\xa7\x1c\xd5j\xabyD`\xdb\x8c\xe3\xa1g(\xa9g\x7fFQ\xa3\x17\x18\xd4\x84\xe9\xab\xdaO\xe2\xc7g\'\x0b\x9d8|~\xcaN\xc4\xb7s2\x9f\xe1\x0b\x83\xc2\x10\xf1\x90\xcc\xc9\xa6\xd7\x04\xd6H\xab0\xa6u\x18\xe2\xbaOC\xf8\xc3\x08\x98g\xca^-2\xe1\n\xef\xfcr\x0f\xbf\x16\xc3\xc7\x1dtF\xfd\x9f\xe7\xfd\xb7m\x83\xa8}\xcf+\x93\xd7?\x12z\x88\xe2g\xc5^w\xd6\x85$\x1f\x15\x05\x83#\xb9\x07:\xc3\x98\xf5CU1\xbdK!\x86\x04o\x7f\x0c\xed\xd0M\xd4\x94\x9f\xa4:%\xfep\xfe\xd7p\x05g\xae\x90\xff\x020\x05,\x9a\x98\xb0\x1c\xe0z&\x97]_Dit;[I\x9d\xaa[\xba\xe1\xf5;U\x01\xd5\x93OZ\x15}\xf0\x8d\x0f\xc6\xde0S\xf2\x93h_\x0c\x17\xf9^\n\x05\x01\x9b\xfd\x1c\xd2\x98\xc4i\xf3\x1dk\xcdf\xdd\xfdR\x80\xa0\xa7\xbc\xcf\x0ew\x0f\xf1\xd5Y\x07o\xab\x91=%\xc2\xfd\x86z\x10a\x8a\xac\xfeF[.\xdfY\xdd\xe0EoLZ\x03\x11lH\xd7\xb7\xe1\xae\xdf\xb5u\xab{\x96\x8dv\x1a\xf2\x9b\x8fpD\xd1\x95b0Z\x13\xbb=\x1e%\xdeN#\x8d\xc6\xc9\xc4\xcdpV\x91\xee_\xef\xfa\xdc\xf4DG\xa8\xd02\xb9\xf2\x85\x0bN\x12BO%L\xe2\xb3_5Sv0\xc3k\x94\xbf\x97\xd0\x87N\xf6\x81\xb1\xf7\xe1\xc2C\xf4\xf2\xe5\xf0N\x1b\xff\xe6Oz\xfe\xf3z\x124\x0c\xab\xe3\xcd\xcfw\x80\x9dR\xb9\x82\xdd_\xac/Q(\xb6\xa51\x10\x13<6\xd4\'\xfb\xa8\\\xb3\x16*D\x1c\xfc\xe6\x98\xe4G\x86\xdf\xc3W3\xf0\x8fC\x1d\xf1B\xd6xX\xbd\xbb\xaf[>r^\rx\xa4\\H\x1eG\xeaE\xc8>\xa2\x1d\xce\xd6\xb7\x00\x16\xe1\x06*\xe3{\x1b\xee\x0bB\xaa\xde\x9cl\xeb\x8fZ\xb1\x1b\x9f\xdcO\xbao\xc8N\x0b\xa0\t-J \x80H5\x8a\xcf\xf5\x16\xebu\xd4\xf8.r\x87!?\x85JsD\xc6d\x86\xbd,\xcf\x1dj?\xe9\xb7q\x98T\xde`l|x;5\x06u\xd1/0\x16\xca\xc4\x163]\x1e\xa9q\xc5\x9c\xcf{%R\xb6-\xac\xd4\xd7\x1c\xc69z5\xd4#It\xb8\x16\x15\xacC\xfb#\x98\x93=\xe26t:L\x8f\xe3\x95\x9cfk\x801Yx\x8f\x81\xa2\xee)%\xc8;\xa0\x9e4[\xe8\xf0\xe5t\x03\xe7\xee\xb0\xd1\xa1h\xad\xcc\x03^\xdaD\x06,l\x8eU\xdc\xab\x1c\xf5<\xd7A\x02\x0e\xfb\xb5\xa6\xff\xd1\x98b\xfa\x1a\x7f$\x06G\x04\x1d\xec\x14\x99<\xde\x1f\x99\xae\x078t\xf3\xec:\xe2\xff\x06NbB\x01\x9e+\xf3-\xc2\x03\xec\xdb\xf6\xec\xfd\xdb\x86-\'\x83\xd8)E\xef7v\xd0\xe5\x8e\x14l\xf21z\x89Mg\x87k\xf72\xa1\xadT\xbf\xfb\xd2\x88\xac\x01\x97\xb7\xf2Aa\xe1?|\xcd\xf4\x1fP5\x19\xbcW\xd4\xbe\xbc\xb5O\x19\xcd\xae-0\xbb\xaav>\x00\xc0\xa3\xa9\xc8F\x82\x1b\xdc\x06a8\xe4SH\xb5\x86\xa3?\xf1\xa8*]\xd3\xff\xde\xb6/vg\xee, \xf8\xb7\x9d\x0e\x02@\xfcQ\xd7\xdc\xc4\x90\xa9\xb4D*\'\x9d5t\xf1$x}\\\xbe\x99S\xf8\x00\xccCJ\xb5-\xe1xr\xda}\xf7\xaf\xd0\xbdo\x86\xf0\xa7V\xf7\xfc\xa6\x1b\xc9\x11\xa1so\xa85w\xe4\x14\xeekF\x80\xfd\xa2Fd\xaeg\x9a\xd2\xd1\x13\xe7yY\x96\x99\xab\xcbb\xd2-\xb7\xc5\x13G\x05B\xa0J\x07\xfb\x95\x1b\xef\xf9Og*\x01ZR\xb3\xc8\xbc\xd9\xb2g\xcbfIN\xaf\xa0\xbf\x12\xa3\xa4N\xd2/\xe7\x96\x05\x92\x91\x90x\xbeL\xaa\xcc\x0e\xd3uN\xe6T\x91\xc9_\xbf\x98\xf7]\x84\xec\xd2\xc5T\xe8\x8d\xcaK\x82\x9a\xf6\xf1\xb4`\x94Y\x8b\x85@\xc9\xc3\xcd\x1f\xb1[W\x94\xec3\xb9u\xd2Hq_xz\x14f\xaf?\x94\x19\xfb\xd5\xc9-\xe0}h%\xf7\xcb\xdfT(\xd0a\xdf\x00\xd9\xf5\xd2v\x92\xc6\xaf\xac\xc1\x0fy\x13<*\x12\xa3\x15-\r \x93\x86F\xdd\x1bE#jy\x98X\xc4\r0\xeeW+\x9e\xcd&w\x19\xb5\x98\n%\x0cX\xe5\xee\xdb\x00\x8f0\x01a\x0eBr\xd9\xea\x07\xe4\xa2\x1b$\xbb")\xaf\xee\'\xea)\xe3Y\xa1\x19J\xc2\x1b\xdd\x87\xce%\xfb\xe8S~\x8bGjF\xa5\xa8M\xd5\xb4\x86O:\xdb\xf0\xcb8c\x89O`\xbb\xb1\xfe\xa7\xc8\x9e\x03\xc4\xad\x90?\xb1p\xac\xea(\xae\x0b\xaf}\x84\x92O\xae\x07%%Y<\xa6g\xbf\x86\x98\x02\x8d%c{\xcf\x7fKY"SYj\xca4\x9e\xaa\x8a\xdd\x04\xfa\x8f\xcb\x12g\xbf\x9f\x87\xf1\x03kP\x86\xde5r\x92\xb5Fu\x9f\xdcER\xb7\x96\xd2<\tV\x97?s\xd4\xea\x0cy\x11\x1axEsP$R\xa9\xdd\xc4-\x91\x82\x94\xa5v\xeal3s(>L\x0c\x05\x1f\xcd?\xec\xf1\xbd=^S\x85P\xeb\x1f\x11b\x14J\xc8\xe5\x8e%\xaa_XT\xa8w\xce\xfc\xde\xd0\xc8l\x1f?5\xac\x0b\x10\x99\xfb\xe8\x8eZ%\xb6\xc1\x89\x1f!\xa9\xba\x1fHr\xceC\xedE\xb8\xd5\xef\x15\x99&\xe1g\x84I.\xc1Liz\xa3P\xcck\x10\x17\xb0\xf0\xb7\xeb{\xc0\xa1\x8e\x11j@Y\xce\xe8&8\x1a\x08\x88>\xf9\xf1w\xa9\xba~\x0cXf\xda\xbf\tx\xc4$\xe2,C+\xee\xb9\xd1\xded\x04)0Pa\xe7*\xa0#\x12\xd2\xb7u\x1b J\x84\x8bCS\xba\xb3\x0e\xd5\x7f\xaeb\x0c\x8fE\xc7\n\xab\x9f\x8b\xad\xb5-\xd6\xe1_\xe4\'`\xca\xbf\xa6; \xaa>\xech#>\x1eR\x80.-\xf9J\x1b\x84\xec\xb4\xd3\x99\x12\xd1HZ\xdc\xb9\x0e\xcfJ\xc7\x95\x9b\x96@\x98\x89\x95\xb7GZw)\xed\x84\x1aI"50+\x94L#\x80\x80\x08E1\xc9\xa2\xc1g\x18\x91\xa1Cj8\x1bc\x81\xa6\x90\xb6\xd0\x16`\x1a\x96\x9a<\x02\xea\xd3*eDI}\x0eI\xfa\xaf)/\xb4\xb0\x90\x1c\x19\xb5\x92!\x80\xe2\x10\xba\xb2\x03\xafK\xbf[/4\xdb\xc9[C-Z\xc4\xe7\xdej\xab\xee}\x83S\x06f\x08\xe0i\xff\xf9\x96\xc3\xe9ch\x1c\xf4a\xf8\xc4\xd7\x12\xaf\x9a\x81\xd7^\xe4N8\xa2\xc64\xf3V\xdf\x96\x0bG]\xb5\xd4X\xc4\x19\\\xad[\xc6\xe0\xb7\x1cMK1\\Ml\xfa\xd4\x9a;B\x01G_\x06eV*;R\xad\xa2$(:.f+\xbc;pC\xd6({\xd1(\xf6\xc3\x87\x0b\x16((>\xa5N\xdf>\x94\xf2%\x90\x16~\x0c\t\xde:\xf3\x90Z\xb6\xc7\xdc\x8c8\x89\xed\xd2\xe3\x91\xb1s\xb8\xec\x8fhD\xc7?(Uj\xd6,\xcdiZ\x03\xa8\xa0\xb6\t\xe3\xaa\xa2.uZ\xf8u\xb1\x1c\xe9~\xa44\xd9\xc9\xea\x17uS\xef\x87\x04\xdd\x14,\x82\xe3J\xab\xb8\xac\x87s\x85K\xd4\xba\xd8\xb4*8O)r2I\xaa\xcd)\x85g\x8f\xe5f\xc1e\xd2/\xd3\x93\xe6BY\xb2\x02\xc6A\x80\xcb)\x97\x13W\xf9\xb4.:{m\n\'\x14 \x9f\x02\xe6\xd5L\xab\xb2\x99\xc3\xa5\x1e\x83\x1b\xceT\xef1\xa4\xef\xa3|\x06>f\xb9\xf5\xe9\x8a\xd4-\x0b\xac\xed?\xe4\xf9\x1f\x8c;\xef\x99\x8d&\xe9\xcemX42\xc4\x04\xcd*H\xfa\x19Xg\x9d\xf5\x14 xP\x13\xb5gNG\xa4\x84\xc7\x00Oi\xf3\xbb\xa4\x82>~\x8bG+[\xb75b\xdbuJ\xe6{K\x17\x1ex \xb3L3.\xea\x1eZ\x8e\xa3\x13\xfa\xe5\x03\xd1\xdcA=\xb1Cm\xe69\x0f\xf9h\xa0#\xc70\xc0\x88_\xd8\xfc\xfa\xcejc`\xfaHv\x16^K~H\xf4\xa2\xa4,\xfb+\x86\x9eF\xfbn\xab>\xc3\x96\n]\'\xa8\x83gf\x0c\xa0:AC\xfc&\x0e\xd6$\xf4\xe8+\xa1>\xc85\xfcp\xd0\x0e(\xf1\x00\x1b\x91\xf2\x82\xac\x9d^\x92\xc3\x03\x07\xb6a\x0c\xb9\x8b\xd3\xef\x88e\xba\xb6\xc4\x1f\x0e\x1f\x9e\x8b\xa67\xf4e\xf5\x16&\xb3\xa3?d\xaa\xf6\xd9\x13J\xbc?\x88\x04\\{\x1b\xb5~]2X\x1fw^E\xee?\x96\x80\xc8f\x10\xe8\xf5\xe2\xb17c\xf9\xea\xa5\xc5\xde\xb2\xe1\xe1\xf7/\x9b-\xf2\xaakC\xe3FB\x91\x08!"0#H\xbfX\xeb\x9d \xf4,\xa3d)0\xc6\xff\xc5\x8f\xaa]\xe5\x00\x8a\x87e\xbaq\xa1\xd1\x9d~p\xcd\xe2{0\\qq\xe9_i&I\x00ET\x9d3{\x00}\x89\xde\xb8\xc4l\xec\xd5\x88\x8a\xa1\xfa\xfd\xef9d}\x08\x00\\6t\x8bq\x82#a\x9e.\x04\x8fC;\x15\x99\xe0\x19\xfc\xd6\xdd\xb6\x9f@\xbf\xe4r$xos\x97\xf9\xe0Fq\x13\xe3e\xebc\xc6\xa4J\x03 \\\r\x1f\x0cs"D\x8dx\xa0\x96\xc0>FS\x14L\xbf\x16\xc7\xd6\xc0\xaa\xc8\x95d\x13\xdc\xe9aN\x02+\xe4\x1bI\x11\xd0)\x15M$\xf8F\x92\xeaO\x11\x8dc\xb3\xfd\x8a\xbdY4c$\xfb\x10\xddZ4\xa9\xcc\xb6\x10ndW\xc3\xaeMP\x08\x85e>\\\xd4s\x82\x0eT\xd4\xd9\xdd\xbb\xe0f\x83\x89\xb9\xec\xab\r\r\x07w\xc9\x0f\x0f\xe8\x9aP\x1c\xe7[\xc6\x13\r@\xf7\x7f^\x8e\xe3\xe3\x8eN\xb0\xa8\x9b\xa8\xa9\xd5\x98ct\xf5\xfb 4\xc8j\xb8\x94\x03\xaa$\x94\xdfg\xc7\x07BoT\xcf\xd8\x8bXoQ\xf9^\xf0\t\xd5\xea\xdd7\x98)m\x7f\xa7\xf7\xca\xec\xcf{\x1d\x08]\xb1\x8d\xda\xb4\xeb\xf7\xc7\xc0\xc5\xfem\xa4\x0ch*\xf9\xbb\xb6\xfc`m\'\xa7\tF\x9c\xf3\x8e\xb4\x04\xe9H{\x90?O\xd01\xe4051\xad0\xb9\xb9\x15\xc8\xcc\xfa\xe2V}\x00\x80\x93\xbc\x86L\xff\x92\xeb\\Q\x9d\xc6\x07|\xe4DZ6\x9aCn\xfa_\xef\x06 *\xd8.\x1e\x9a\xdb\x8a\x95\xb6\x84\x94j\xc9\x12\xee\x9b\xd5\xea\xb7c#\xac\x8a\x9e?M\xaa\xa8c\x8d\xc22$\xae/t\x03W~e\xc9qb\xf4\xceL\x8a\xf2Gg4\xde\x8c\x8b_!\xd8\x15\x1b\x9d57\xed\xf7\xa4\x94\xf8\xea\x017\x96\xd6\x08\x14\xdeK\xa8\xce\xb5\x98\xdbv`2s\x00\xe7\x86\xd5\x1b\x8d\xc8M\xb0\x00\xe3\xef;\xe8\x17S+F\xfe\xf85\xc5\xe9\xea\xf7\xe4\xf8\x9bH\x8f9\xfa\xda\xef\x1cL3\x04\xb1\xbf\xbd&V6tB\xbd\xab/\xf8fx\xe3Z\xb9\xb1y\x1c\xb5P\xc5\xc6x\xef\xcd\xe4qn\x1dGSb\x9b\x90\x17\xfaK\\\xaf\x15\x9e?\xdas\x8e\x1a\xf8K\xd5\xe9\n\x88\x1c\xf6\xf8uS\xaa\xef\xba\xb2\xffY\xce\x8d\xe5\x97\x90o\xd3\x8d\xb6\x85\x07\x94F\xe1\xbbb]w\xfe(ja\x08~@\x8b\xa6\x9e\xcd\xe4~s\x8ce\x90^YHW\x83]+\x1dh\xcd-,\xfb\x98HS\xbb\xff*\x88=\xads\\o\x86\xf6\x936e{\xa9l|\xb6\x96\x9dc\x94F\xb6\x84\xa1\xc2\xc8[\xcf\xff[ \t\xc7L\xc8\xadzZ\x00t\xdb=\xfd\xd9\xea\xe2\xe2-W\x01fV\x01\xfdk1o\x1c-u\xf8\x19\xc7\x1as\xadm]\xa4\xd3\x17\x0bd\xa9\xb4\x15D\xa1\xb1\x8e\xe5\xaalz\x1d\xcc!\x1d/,\x88 \xdc\xaa\xbf\x109\x94k\t\x82O\x8b\xbb<\xf4\xdf\xfa\xc5\x8d\xbaU*\xf2\x8c\x85p\xb4`\xd479\xf8\xebx\xedwZ\x95v)\x7f\xa3N\x803\xf1jw>C\x027\xf8\x80\x8fP\xb5\x8a\x82\x8c\x16Q\x1e\xf3G*|\xc2\xb6V\xc4\xef\xb6\xb1\x06\xf5\x03\xae\xfa\xb90\xb7\xf22\xb5\xf9AM\xcc\xd4\xa8t\xb8\x10#P\x95t\x04\x7f\xf5L)\xf6\xdfIJ\x1d\xd9\xdd\xb8J\'\xa7\xda\xdd\xfd\x13\x13\xa2\x0b\xfbMh\xce\x99\x97w|\xd0\xb6S\x8e\\\xa6X]\x17L(U\xa0*\r\xe7\xf2\x8f\xa9\xee`\xe9\xd2\xe7\xba\xee\x17\x84\x83\x97\x9d30O\xed/H\xae.\xa0=\x9b\xc9\xba\xc6\xbd7\xa8\x86\xd0a\\n\xff\xfa\xf9\xd0Jsm\xfem\x90\x84\xf7\xb9`\xab\x06\xebn\x95sHsX|\xd5tq\xa4\xa1\xa5\xe8\xedP}\xe7}o\xdb\xa0\x90r\xcd\x96 ]P\xd8\xed\x95,\x16\x7f02S\xf7\x95QRUO+U\x19^\x0bC4\xbc\\F\xa0V\xf6\xa4\xbe$\xf5\x14k\xe9\xc6\xd1z\x04\xb9\xf4DL=/0\xe8\xbbv\xcb\xd5\x1d\xee\xf4\x88#\xef\neF\x17\xbb\xa3\xd3 \xa9_\x16\x03\xc53\xf5L\x0e/\x1c\x1a\xe3,w\xba\xd4z`\xeb\x15W\x08\xd3\xe7+\xf2\x80qB\x7f_x\xa1<\x1d\xa6\xa8/\xaa\xc0\xed\xf9\xb9M.\x1b&<\xbbU\xca\xe1\xb2y\x92"=\x90\x10\xaf+\x18\xcf\xf4\xa0\xf3\xff\xcc\xa8F\x94\x90Ly\x9d\xa3\xbc\x1cp\x9b\xd3\x16p\x9e\x84\xbd\x9d\x94\xe7\xe3\x04\x1b\xee\xedW\xe5\xd6\xf5(H\xea\xfb\xa9\xd1\x83C\xf3\x94#\xf4\xbag\x11\x96\x1c\xd6\xd1v\xba\xc9\xe7\xa0\xe1\x97\xf1xh-\xc8\xaf\x18\xa2\xf3H\xacA9BV\xc3b\xd3\x00\xb8\x07\x1f\xf7\xed%|\xb2xN!v\xe9\x9d\x1b\xcc;\x85\x88\x94\xb1\xdf;\xa1k\x186\x13!#G\xbfC:Q;c\xc2\xbfC:\xe4\x82\x17\xf62\x1a\xeb\xbb!\x01\xd3\xda{Z\xb6\xb7\x03`\x88p\xc2\xbb\t\xa1f\xe3\x12p\x1f\xcdB\xbd\xf8\xf9tml\xac\x9d\x87tN\xaa\xf4\xda\xbf,\x19\xbd*dh\x88z\x05\xf5\xbb\xe3)\x13\ne\x11\x0e+V)\x1f\x9d\x0f\xaa,\xa2\xdd\x95lC\x1f\x9a\xa6\xf7\x9e\x96\xf6.gS\xf3\x80(\xda\xcb\xcf?v]\xc3VB-\xcdX\xdb\xf4%\x16\x04\xfa\x02\x8b\xe7\x10\xae\xde#\x13\xcf\xf8\xc1Ah\xfc\xa2\xee-\x0f\xb4\xfak\x12\x9aZ\xdb\x05\x8c\x12]\xcbC\xbe\xf69\xac\xf2\xdc\xf0\xf1K\xdd\xdd\x1d5>\xdb\x00\xf6\xe9?\xd5\xaeR\xceF\xfe\x19\xa06x\x0ft,\xd6\xb6\te\xfd\xff\xb7l\t\xacq\xd5\xe8\xab\xf3:\x0b\x15\xc8P,6\xf85\xafa\xa4\xbe^B\x84\xd6\xdd\x12\xf6\xc2\xc3gn;\x7f8R\x8f\x07\xfca\x0bR\xb6`$y\x82\xfc\xdf\xe0;\xa9\x93&\xf0\xa6\xdc\n\xe9agI \x08\xa9\xec\xb7z\x8c\x9a\xed\xf0>\xb5\x81\x05\xceN\xd4\x82e>\xbd\n\xc3\xae\xd3\x13\xfc\xac\x93\xe07\xae\xa0\xea(K\x9eEH\xb6\x81\x99\x83<\xe3\xe7\xf7\xbes\xce\xe0\xcb\x86\xe6^\xda\xe9\xe5\xc0\xc9I\xbf|u5\xda\x9e\xb3z\xac\xba\x80A\x93`v\x8e\x87.\x0b\xd9Z\x98\x15 ,\xed\xc2\xa5\x9a\xdf\xc9\x93\xcd\xab\xdf`\x10\x1d\x80\xd1\x9c\xde\x95\xa2\xe5\x0b2\xc5\xec2g\x88\xdf\xd9\x9c]\xb36\xe24\xeb \xdd\x1c\xe2\xcb\x87\xddQqd\xb3\x16\x84(qyA\xe4\x8e\xbf\xf0\n\x03\xff\xc5\xa0\xd3\xac\xd5U\x93\x13\x92oP\x94\xd6E\xa8\x82\xc7}\x1c\xbc\xf9\xdc*\xde\x8d^\xac\x93\xbb\xf7\x04\xa3\xc8\x93i\xae\x0f\x0fT\xe6\xc5\xa3\xc7ET\x1fp\xfd\xca\xd2\'o\x80\x82\x99\xb5\xdd\'2\x02_\xad\x16|\xf8\xcb)Ik\x994\x0c/\xc47e\xec\x1d\xb8v{=\x08\xd8[\x19\xbc5\xa7\xb6b\x9c\xe1\xfe\xe2\x8c|\x8f \xbb\xee4b\xcb3\n\x85\x87\x85\x87\x15\x85\x1f\x90\xe0\xcd?\x06\x9b~+\x148\x1a\x079\x1b\x88\xfe\x06\xec\x8f\x17\xb8L\xbe\xa6\xd9.\xdc\xd4\xb6\xb9\xa4a\x8c\x966\xb7\x95D\r\xcb\xcbx\xffL\x88@1g\x87\xe6Er\xc7\xcd\xc9\x0f\xc8\x12t\xcbmv\x11\xa0U\xe7\xfd2\xac\xefD\xab\x04GzX$\x91\xf7\x86D\xb0(\x97\xe6\xc0@\x89n\x1e\x9e\x01j\xdaO\x11\x06\x05/\xc1\xf7R\x14\x19\xcf\xdf\xe4\x98+/\xee\xd8\x96\xa8\xcd\xc2\xee\x8a\x08\\\xba\xd5\x9e\xfa~\xf7\xd98\x10\xa2\xdc\x98\xb7\xee\xaaW\x9f\xf5\xbe\x11[\xae\xa4\x17x%E\xd4\xe3%\x125%\xafGI\xdd\x7f$\xa4\xe7\xc3\xecqi\xea\xef\xd6\xa3\t\xfa\xa0\x87N\x17TP\xbd\x14\xb5\xac\xd9\xb3\xf5\xfc\xa8i(\x0fJ/2)\xe0k\x13YD\xf9\xea\xc8?K\x06\x18\xde|+\xc1\xf00\x85\xb1G\xfc\xd9\xa3\xeb)\x92\xc6\xccs\r\x8c\xf9\xa4\xac\xdc\xe3!ce\xbc\x83\xf0\x87mb\xf9\x84\x84\xc6\xe8\xd6\xc2V\x010\xcbo\xcf\x08R0\x9ezv\xb3\\\n_\xba\x7fJ\xcd\x12.\x08nk\x07\x9a\xf9\x8c\xf9\x8b1-\xda \xbd\xc8\xc7s4\x90\xd0yl/\x91\xea\x99e\xb6\x15\x91\x9e\xb3\xf2\xec\xc2@=\x94\xbf\xbcVes\xeb9\xd1\x8b\xe2\xa2\x83\x8d\x1b\xf8v\x14\xbf\xa7\xab&\x0c\x1f\x90\xbb\xcb\xb6\t\x83\xb1\xeb\x10\xa4v\xb0\x85\xfa\xe86r\\\xda\xae\xb9\\?)\xec\xefx\x7f\x80\xd6*\xcc\x02\x88\xe6J\x08\xa3m>\xa6\xb8\x9b%\xeb\x9c\x9b\xbci+\t\xc3^S\x029\try\x0c\x9a{\xef\xab\x10\xd1\xac\x83\xc4\x19O=\x08|\x94\x8a\x17Y\xc8E\xce\xed\tc\xcc*wW: l\x9bI*\x0f\x8b\xf6R\xde\xc2u\xee\x9do]\xc3\x8c\x9f\xa6\x86j\x12\x9d\xd7\x86\x1c\r^~\xc2\x19\xe28#4\'\x9dCe\xe4kX\x9d\'\xd4\x8b\xe8T\xf0\xd9\xcd\xc4i\xbbWs\x06{\x8e\x9e\x02\xb7 ^\xcf\x12\xa5\x9b"\x91\x89et/\xbb\x07\xed\xdd\x0f\x91\x9b\xf6Q\x7f8\x06i v\xb3\xa3\xc5KM@0\xbd\x12\x87\xad\xfa\xccZ\xb1f\xb0p\xc1C\xdd\x00\xfa\xb3\x10\xc3\xe9O\xc8\x0fF\x80}\n.\xe2\x7f*\xc6\xb5\xa4\x89\x04{hJW\xe1\xd2\xc0\xba\xf5F&\x8eTp\xc7\xd4\xe0\xba+\xfd\x91S={\xdeP\xfb\x073\x00?#\xb4\x11\\{\xeaeT_\x92_J\xf1\x95\xe8\x8f\x91\x91/\x1c\x1f\xf3\xae\xd3\xbd9=r\xb7q"\xe6\x8c\x94s\x94\xa4\xbck\xa7\xd39-\t\xe9x\xae\xd0n~\x81\xd8\xcd6mt\x98>5;\xbeG\xdc\xd7\xf4F\xaa\xf1\xc8u\xd3+|\xbd\xe6G\xb2^\x99\x1eZ\xae\xc1\xea-\x9d\x1ftH2\x1a\xdfj\xec\r8E\x1b:\x97SVQ\xa7\xeb\xa1L\xfe\xed\x9b\x9fCi\t\r\x91\xbe\xcai\xe76\xa5(k*(w\xb49\x1e\xd1\xdd5/Ws\x94wr\x82L\x1b\xe3/\xda\xc3\xe6\xe3o\xb8\x9f\xd4\xdd\xde\xab"\x15\xc9\xed\xa9k,\xb3\xfa\x95\x7f\xfcg\xc1\x07I\xf4\x9d!\x9c\xff\x1b\xf3\xb8\xb9_B\xd0t(\xc80_\x95\xee\x1fF\x894\x18\xfbk\xb5\xf8\x18\xa5\x86\r\xe8\xd5\x88\x87\x1c(\x923\xfb\xb8\xfa8\xe2\xf7\x9b\x14\x1a;\xee\xc8\xfd\xc4 \xb4\xedtn`\xe3\xc6g\x1dM@rT\xc3\xb6\xecD\xfd:\xc2\xcc\xc6_b\xed\x9b=h;\xd6\t\x03)\x94\xda/\'@*\x1a\x89%cz\xbc\xa3\x0c\xbb\xca3\xcb\xbfT@\xc3\x1b\xa1\n5\x10\x0b\xae\xf1\x0e\x88\x8c\x7fxH$\xc4\x80x@\x1b\xe8A\xf7\xcc\x8c\x99\xbe\xdc\x9f\xbd\xfa\x84\xe3\xf2\xba0+\x07\xc6\xb4\xbbh\xceV\xb6\xc5\xa4\xd1\xa6}\x82\x9a\x13\xcdg\xd3\xad{\n\xad\x8e\xfaT\x8c\xb0\xc3\x1ex\x93\x8c\x01dt;\x00\x11\\v\xc4\xcd\x02\xef\xef\xba\xcaz\x8a\x7f\x82t?.\xbe\x96\x94{\x07(t!K\xe8\xda\xb6\xb5^a\xc2?\x1a\xcdY\xd8\xed\xcd\xb7"5\xa2\x83\x18\xcdV&T=R\xf6\x19\x8a\xfc\xb3\xcb\xff.\x12C\xdb;\xc1]f\xcdM\xeb\x1c\x05P8r`g\xa7\x0c\x9b\xe5==\xa5\xd4\xaa\x1bb!\x92\xec\xc6\xbf\xf2"\x85\x13\xc4TU\x08(\xf0oyO\x11\x84\x1cqH\xe2\x1b\x08>\xa2\xd2\xe5\xe2\xd2\xce\x8d*\x8c\xb2\x19M\x83h\xe8\xae\x06\xa7\xe54\x9bs\xe1\xe3*^\xd8\xd2\x12\x07T\xc39#}\x91\x90I-\xad\xf0\x1b\xc8c\x038\xa7\xe4\xe9\x18\x0fi\x13\xc5\xc0P\xebsh\xb0/\xa0c$\xcbLa"]U\x1a\xdc\xb7[\xef\x96=\t\xe6Z\x1028\xce\x07\xdb:\xf3\xb2\xc5`*r\x82\x95\x0c\xf8T5\xf4r\xb0*\xd3\xef\xab@:a\x9d\xde\xe1j3\x15\x8eS\x17\xa6.a\xb8K\x80R<`\x92P\x87\xc8d\x93 b\xc0F\x81\xe9k\x9a;\x19\x0b\xdeS\x1e\x89\x8e\xb5WB\x8d3\x8dx~\xaa\xb6S\x84|\x8ey\xd4\x8e\xfe\xd1\xdaF\x84\xc4\xc8\x96*\x7f\xd0$\xc2\xfa\x1e\xd2\xe0\xef\xff|e\x13m\x16Y\'\t\x06\x9e\xfddo\xdd\xb4\x80ju\xdd\x8c\xc4\n\xc2\xbaW\x16\xc9\x18"\xb5U\n\xa1\xb3n\xceq\xdc\x18kW\xd8Z\xcd\xd6J\xf2#\xe7\x1c@\xd8?_Y\xc0,\x89r\xa6H|w1\x00\xb22\xb5\xa4\x88\xc7\xad\xa5\x1e\xe2\x1en\x89?G34Fo\x0b\xd9\xc7m\x1d\x02\xa4\xaf+2\xcd\xeb\xfa\xc2\x84\xc8\xc8\xb4og\xe3O.\xa5\xa0}G\xfc\xa8\x85\xf9L\xaa\x93\xe4PE3\xf3,\xb5F\x92\x9dU\xcc\x86\x93;\x1f\xc5\x82K\x98\x1f\x85\xb7D\x1d\x06\x1fY\xd5B)*\x92\x85\x9a\xf3\xd11\x8e\x8f\xdf\x95?}\xd2\\\x8b\x9e[\xdd#\x9b\x05+\\dJ&\xd0\xbbN\x8eo\n5\x9b\xa8`\x9e}\x01C\xf6\x9e\xd8\x97G\xa7\xc8\x8d\x0f\x18\xc7\xca}Z\xf87\x13\tOowq\xc0w\r\xd3L\x1a\xbcB\xa9h\x9f\xad`\x17\xa4q\xc0\xdb\xc9\\\x10dMo\x18\xe4\xaa\xd7\x95~5.\xf4]\xccxn\xde\xd3\x07\xe8`\x8e\xe2Ki\xc0Yn\xb3\x0f\xa8\xe4\x98!<\x81-TY<\xd0\xe5\x8a8\xac^4\xdf\xa3\xe5\xd0VmB\xe28<\x81\xe0\x86\x86W\xbe\xc6\x02\x92Cc\x12X\xf6\xb9\x80\x1e-d\xfb.D\xe8\x13\xdc1\xbcS\xd4\xac\xf4\x01~\xa8C\x9ao!\xdaD"\xbeYn]\xd5a\x82_\xc1\x1d\xd2A\xcb\x10\xbe \xed\xa2\nV\x18\xfd\xbe\xf0\xcb\xfaa.w\xf2\xc8\xfc\x83\x06jf\x93?&t#*\x10FE(\xc6\x11\\\xf9\xd0\xb5k\x89+\x81\xde\x83\x99\x88\xe48\x8f\x89f\xd6\xa6]\xb1\x9fV\x08\x97\x85\xb0s\xc1\xb4\x17\x1a\xb1NOL.X\xdd\xdd\xf7\xbc\xa1\xc5\xf0\xf0\x16b\xbe\xfc\x0b{\xa2\x9ei\xb2\xc5\xf8\xfe\x95V\x7f\x91\n\xa7\xfb\xdf\xc5\xb9\x9aZC\xf6\xeb\x80\xb1\xb2#\x88\xdb~@\xcd\x171P\xa1\x9f\x80[\xc9|\xecX\xee\xf2\xf5\x91.=\x15\x11\xdb\x12\x9f\xcd\xf1\xf6\x07E\xd5Pb\x08\xbf\x9c\xcbM\xba\xe3\xdf\x90[\x81\xa30\x0eM_\x0c\xcbl\x08\x04\xe2W\x1b\rN|e\xfc\xeb\xe3\xbf[\xbb\x9a\xf9\x9f\xe7\x9b\x10S\xdc\x90\xfcNQ\xde}\'g\x02?\xb3\x00\r\x8a\xd1\xa6z\xc2\xdc\t\xb7\x9c$\xbdc\\7\xae\x93`\x9b\xf2-\x04Tl\xe2\xbb\xcbHA\x876z\x8c\xf3\x92.\x1bK\xe8\x0f!\xa6v\'j\xe4\xbdb\x8e\x1e\xb2\x9ca,\xc2\xb5\xad\xa6&W\x95\x07\x17\x95w1B+\xa85I\x15\x91\x8c\xa3\xad\x938\xc9(S\xe8\x92\x16\x8a\xd4\xee\xe8=3-63O\xc9Ox\x88\xac\xda\xe1a\xcb\xc2\n\x92\x10\xeaE\x83\xd7\xdb\x12\x908^80\x08\xb5YN\xb9\x10\x03\xf7@\xf7\x1a\xd2X\x9a5\x9b\xba\xc9\xe8\x1av8\x9b\xb1\xa7\xb9c\xa6u\'\xeb\x7fi\x1d\x18\x07\xedf\xa26h\x1b_\x9e\x97\xa8\x976[:\rY\xf6\xb0$\r\xd6\x92j\xc8\xe3\x0fF(\x9e~\x99H\xf8\xc9\xd1;\x81\x1c\xfc\xa1\x036\x08n\xac.s\x04\xa1\x16\x13a\xca\x9c{\xe0\x96aD-\x0cs\x90X\x19Hc-\xd0\xb7\xc2\xb4\xb0\x95\x17\xe9A|+\x03\xdf8+\x18\x8d\xc9>\x9f\xa4\x81@\xd4a\xa9\x13A\x02K\x01`\xcdP\xf4\xfee\x86\xae\xa4\x00#\xb3:\xbeT\xa0\x1b\xd1\xdd\xcf\xd6f#m\xf2J;\x1d\x10\xd6\x05J\x03,\']\x92\xb9\xe0]p\xed\x07{\xc0\x8c\x0c\xca\x88$\xcbC\xc1X\x8a\xd0c\x10\x16\xb6P\xba}\xc3g\xd3\xd1\xab}\x84*\x0c\x06C\x87\xd4\xddn\x15*\xcf5SJ}V.\x8b\xb5M\x01\xbb\x1c\xf2\xe1\xef\x12\xaa\xc6~\xb1\xfe\x93q@\x87!(\xf1S\xb9\x82gCA\xbb\xe2?\xec\xd7\xb0\xee\x93\xabL\xfd\x99\x01\xb6>\xca\xd0\xb7v\xde\xe3z\xcd#\x8dR\x12h\r\xfe\xa03\x1cH1\n\xf2r\xe6UK_\xa1\xc3*\xa2GWI2BZ\x1aR\xc8\xdd\xab\x88\xef\xd8\x01D\x94/2e=\xc9\x84\xaaQ\xfe\xf6\xf2\x1a\xcf\r\xb2%\xb2\xe1Dw\xe0y\x9d\xba\xc2p\x9c\xca\x8e\xdbKq\x97\'\rV\x99\x9fHG{\x96;Qk\xd9\x1e\xba\x13\xc4`\x1f\xa4j\xb3\x12\x8a"\xb7\xe4\x13\x17<\x99\xa1\x9c\xf6P\xe6uO\x06G6\x92X$If\x82V\xdd\xd4\xe5\x00\xd2\x7f\x1e0\xab\xf5\xf1d\xfe\xc5\x16)\xd53\x97\x99\xe5\x80r\x16\xb0\x8b\x86\x08\xb7P\xe0\x1f\xf2\x13,\x12\x96\x07!&7s\xcap\x7f\x9e\x99I*\xb3\xaf)?\x15oU\x92`\xf1\xddD\x90\x18\x87e#\x16Ti\xf0\x8dZcp1\xca^~La\x89A\xe5Pj\x82\x86dl\xd2e\x98\x04\x01\x84m\xece\xcc-\x9a\x1b\xee4\xc7\x9b\\\xa2z1fV\xd5\x07\xea\x16\xbci\xf7\xd2=\x19\xef\x16\xf4\xed\xef\xfb\x89\xa2\x90\xb4\x89\x1d\xce\x98\xa1\x1e\x8b\x99\xe3\xd0\xe2\x9f\x01\xd5\xa4\xf2\x9a\xe7D*\xd7\xe7\xf2\xbe\x94A\x03\xab\xa0JkTd9H\xa5\x90\xc9\x9e\xde\xe3\xbe\xc8jq.\xfcl\xebq$\x16\x1a%\xf6\xe3T\xf2\xff\xe8D\x05\xef\x8f\xa9\x1a\x93\x84\x8e$\xe1A\xbc#Y\x9e~\xdb)\x16D2\xe1A\xdaxp\x8c\x8d\xa0\x9b\xfd\x82\xb5\xb1\x19qQ\x98\x1e\xe0|H\xa8B\xf7\xd8"\xcc[\x96\xf9IMmKf\xe5\x17\xc9\xfd\xb7c.O\xba\xae\xaaaJ2j\xf0cl>Z\x91<\xb6c\xcc\xf9\xeegR\x8e\x93\xbc\xd4\xb1$\xa8E\x7f\x19\xdf\x1a\xa5\xa5\xbfX\xdf\xd3\xdaU\x82T\x1e\xcd]\xc1|\xe0\xeb\xbbX\xfc\xf3\xe5W\x08b2d\xd1\xeb\x05\x88\xbc,\xa8\x87\x1fY\n\xa8\x1e\x82o\x7f\xf2\x1f\x85?\x9bVy\x86!\x00\x82\x16LA \xe6\x9e\xae\x95\xbeq2J\xa4\xe27\xe1\xd7\\\x91\x9d\xd8\x08\x80-\xd5Jk\x13\xa2\x84\x83\x88\xffw\x9eQ\xf1\xdf\x9f\x8d|\x0e\xdb\xd0Q\x94\x8eh\xd3\xbe\x0e\xb5\xac\xfd\xdb\xa1\xfb\xf3\x9d\xfb\xf5\xd6\xc6#.\xbd\x1bQ\x9a\xc7\xf0\xea\xb9\xe4`I\n\xf6\xe2\x8d\x8f&|y<\xc4\xb0\x97[\xdcN\xe0\x8d\xf4\xb4\xa7\x19\x0bG\x81iA\xfa\xbb\x9b\x96n\x1e\xd4\xd9\x88^U\x1d\x97"\xd0::\xf7":\x06=\x81&!\xbf\xf1\xeb\xbd\xdc\xecE\xc3mq\x04`2\x8f\xde/0N\xf4\xfa/\xeel\xa5]\x8d<\xf1\xd6xr\xa6\x1b\x1a.\xa2\xd9\xf1F\x87\x07\x11n\xff\xb9\xbb\x97\x08\x055W)}\x8d\xc6tav\xdf\xa9\x1aSM\x90\xdb\x92\xa3"\xc8i\xa9\x96!\xb9y\xf1k\xc8\x97\xc1=\xe8c~(\x8dr\xc8\xe0\xae\xb1C\xd9x\x86v\xb5\x01("A\x99\xcdm\x16\xb4\x96\xc3K\xcb(\xdej\x15!6\xa9_\x0b\x9f\xdf\x9e\xc7\xcd\xd1\xa0\xdf\xdd\xcc\x89N\xda\xa6\xd84Drd\xd4?\xc9\xacL\x0c\x85\xe0mDi\xcb2\x9c\xf9\xfa,\x93\xe0\\\xac\x18J\xe5>K\xac\x89\xa3y\xa15\t\x8e\xfc5\x9d\xd8O0\xe3\xec\x83\x02\x9eWtw\xbb\x0f1\x97\xe2\x9c\xa0\xbd\xbbP.z<\xc32\xf8\xff\n\xb2\xb9eL\xeeWX\xfa\xf4\xc6l\x17\x13\xc2N\xfeG\xba\xff\xf7\x1b\xf5U\xf3\xeaW\xa0\xe3\xbe\xe5l\xf4<*i\xdeu\xe1_\xac\xb2h\x88\xbfW\xea\xc7\x03\xdd\xc7g\x0fyw;.\x0b:duH\xc21\x90\x8d+\x89&\x16_\xa1\xfd)Z\xf4\xedc\x18MHF\xe8\xc2\xc1\xb8\xb6N\x87\xc4\xbf\x1c\xe0\xbc\x80\xe4P\xd2\xfe\x8ek\xc0c+\xe6Zn\xc4\xf0?\xd7\x08\x95\xe9\xa3-<\'{\xfeI\x8eG\x88\x95\xd3{i\x84\x16\xa6`\x90x\xa3|\x01\xa1~\x9e\x8a1\x88\xbc\x97p\xdf]\x96\x9b@\x13\x80\xedX?\xecJh\xf7\x88\x97:I7\xaaf\x7f\x9fP~\xd2\xd2v\xaa\xe8\xd0\xed\x06\x1d\xb4\xcc\xd3\xeeU\xa1\x0c\xc5\x85\x88\xef\xb4\xfb79a\xe6\xba#@~\xcfB\xeaE\x96\xb3\xa2\xc5\x14\xd4=*$\xd4\x9f\x8a\xe4\xaa\xd69\xf9\xa9\x87VP\x1f\xb2N\xf3\x12O\xca\x94\x1a2+\xf7\x9b\xb8\xf7j\xb8B\x80\xc6l\x9fYZ\xea\xde\x08\xa0\xf5k\x8a%m.\x96XC\xc2\x92\x14\x98`\x07\xe8\xde\xb5\xa7\x94\xd1\x08\\\x0eB\x7fQ\x95\xaf\x00\x01\xd3I\xe7\x8b\ti~\xe0W\xdc\xbam\xdb\x83\xd7\xf3\xed\xebQ\xff\xfan\xce<\x84\x0c\x07\x94\x83\'\x8c\xc7\x11\x13\xed\x96\x9d\x1e\xd7:\xd4\xc4Q\xc4\x89\xdb\x93i\x1b`\xbc*"\xd0\xc80v\xe8]\x12"\xe1\xb1\x94(\x1f\x02\xa3a\xdf|\xff\xaa`\x08\x8537\xd1\xfd\xa3H\xc1\x00\xf8\x7f\xef\x00`\xb6QY\xbb\xee)/?\xf5\x15\x9e\x07L\x87t\xa0hq\xa0\xd5\xe4\'Z\x92mj\xd33\xac\xba\xce\x95a[\x9c\xe8\xa4\x1fE)\x9ea\xa1\xd5\xeb\x84\x97\x0b\x1d\xe6\x0e7\x8a\xd8K\x8c\x90u\xaa\xa9\xa0\x124~^*\x1eA\xe9^\xa7\x1a\xba\xb1\xd6l\xaf\x7fW\xf2\x87\x83\x18V\xf7x\x0e5#U\xf6gmp*L\xbd\x0cqa_\xac\x1d300E\xe6r\xbf\x1f~\x13%q\n\xd9e\xb8[F\x86\xdb\x94_\x9a\x90\xdfz\xd0\x93\x0ec/\x8fYBy \xeaXa\xfb-+\xe9\x10\xcf\x0e\xdejq\xf7V\x07\x04\xd1\xf6\xb3N\xd8\x05\x11M\x81\x10\xfc\x94\xe7 \x93\xf9->4z\x04}F\xca\xd1Q\xf6\x92\x15\xe0}\xa0v\x0f\xdd\xe4\xc9\xde\x1c\x12nZ\xd3\r\\\x9a[)\x9e\x9e[\xa4\xfb\'\xf4\xe2y>\xa3%\x00\x80\xe2\x15_\xdcr\xd1\xe5T\'K\x10\xb8\x87\t\xaf~5\xc7\x18Q\xc3\xfb{\x94\xc3h\xa1\x12\xc0\xc1\xf8\\s\x7f6\xbf}\xf9\xa5\xb9\x03\xedk\x82\xe5K]\xbb\x11\n\x9bO\xec\x01\x10\x08\x0f\xca \xef\xabN5\xd8\xfaRR\xd4\xad\xf8C\xac\xd8\xb2um<\x8a\xa7\t\xb8\x93\xef9\xb1\xe0a<_\x85\x00Do?P\x16\x14\xed\x1d\x95\x18\x85(#\x82!\t\xa4\xf3\x87#X8\xc8-\xb1\xba{\xe1\xeeis\x90W}{\xce7\t.n\x8c\xfe5MG;\x960\xbd\xd8`M3\x82\xfc2\x90B\x93M[3+"\x0c\xe2%\x04\xb6\xba\x9a\xa5b5\x8a\x15\x87u\xfc\x08,\x04\\\xe5\xe2U1XH\xeb\xc5\xb8\x1f\xdc;!\xd3\x05\x11\x9a\xe5\xd0u\xdd\x00\xe4\xb8\xf7Y\xcf\x0e\xb9\xc3\x18\xb1\xd3\xab\x958\xeb\xa4QYW\x03\xec~F\x013an\xf2\xad\xd8x\x13\xad\xd5\xca\xac\xe5\xfc\xa2\xe9#\xd8\xb4\xfa\xde\x99\x1f\xf5\x17\xc7]O\x9du[\xd7\x9a$,\xab`g\xd2g\x89\xe8-\xca\xf0m\xc1\x1bhK;\x9b\x85\x96A\xc8\x11\xc0\x13\x1aU5\xbc\x0b\xb3\xd6,\'\xffj\xc7\xf6\x1a\xd4W\xdf\xaeNCo]/\x99\xbbi\x05\x98\xe9!\xc8p\x05\xb9X\x80\xc5x\xf7\xc5tDe\xe0\xc1\x99\xbdL\x8d\xe6\x13\xcc\x99\xa8\xf1\xb3\xb1\x00f\xe3\x8d9\xc0\xae\x88\xe7\xd9\t\x12:#)yK\xe1\xf8,\xb5\x9f\xe3Q\x82\x9d\x9e\xe5\x89\xb7\x0b\xba\xe0=S1\x1dh\x86[n3\xe7\x90\xf8\x10\x12\xe4\xf8g\x1e\xe0\xff\xda1\xd0=\x91\xd5\x07X\xfa\xbagR\\\xf7\xe7\x0e\x0c\x11h`>\r\xce\xd8\x11\xfdF\x9c\x9dN\xe5\x1a\x8e\x80cdB\xf5)U\xed{\xe9r\xb4\xed\xcc\x81{f\x13\x0e\x8e\x11\x16wU&\x9b\xf1^3k\xf1|\xcc\xa3m\xc8\x10\xd1\xe8HI\xca\x9eN\xb4\x9fs\xb1}\xe7\xd5)\x9f3>\xeaj\xff\xb6\xd5:V\xab\xee?\x811\xcbu\\\x8e:\x041\xd2\x02\xb8\x89{!q\n\x02\xc9\xf6q\xed\x8b\xeb\xf7\x97\xeb\x16Je\xeeh:Sf\xb0F\xa0\x96\xfc\x94\xdb\x8b\xf2H\xffR\x95l\x17q<\n\xb0N-\xc1Wk|\xccs\x0e\xdam(X\x80"\x11\xf5K\xca\x821rf\x00\x8e\xa1\x860\xc6\x91{6\xc6f\xb5\x0fth\xdb\x1c\xf4\xa4\xcb\xe0\x14)L\x95\xbe\x01`\x9e;W\x9e/"\xe9u&\xda(\xcd\x8f\xc3Fm\xa0\xd46\x8f=\xce\x01\x02S\xd0on\xf2\xc4l\x87\x08\xbe\xc0\xe4\x10\n-v\x80\xdcn"\xb0\x18p\xfa\x0b""\x1fO:R;E\xfa\xc0\x9et\xbe\xf3\xfa\xa3\x95\xabE\x84\xc3NgE\xa9\xe0\xa8~\x9ai\xd5\x99 \x03\xcd\xd6\xaa\xd3\xf83>\x0e\xaaV\xdae\rMsuL\x04\xd816&D\x8a\x8d\xd2&^\xdf\xcd\xe2\xb3%\xe0\x8aG\xfbV\x9b`\x86\xea8\x10\xe4\xe0\x96&\x88\x03;\xee\xe8e\\\x80\x96\xcf\x16<\xb2Hz\x95|\xc2I:\x8dV\r\xbc\xa4\xcb\xc5\xdd\x16\xf0Z\x9b\x96q\x80H\xe5\xfb\x80W\x98}\x801\xcd"\x04\x90\x18yk\xef\x992{?\x1di}\'[\x1e\x88vJ\x1b6\xd09;^\xb1\xb1Rc\x1f\xc8l\x17\xe0\xc3\xa3\xacG\xcd,\x19\x9f\xc0\x15\xcf\xeb\xad\x95\x86\x00\x81\x05P\x07\xa3\x06\\K\xf6\x9cl\x19G\xb1\x82(f\xb2\x02&P \xa1\xef\xd6\xa8\x85\x98\xab[\nX\x9a\xae\x90\n\xc69\xdf\x17|\x9f\x9c\x8b+9/\xe32T6\xf1\xd3\xd89\xe7\x14\xe4\xb9\xdd\xe4\x148\x15\x95\xa0\xbe\xa7\x91\x8b\x1e\xd9\x987\xea\xf0aA\xdaQ\xdb\xf7\xee\xe9\x19\xa2\x16\x8ca\x10z\xc1\xfc$\xc1\xba;x\xbci\xffX[)\xab\x10\xff\xf9d\xc3\xfd85]\x9b\xe0K4\xc1r?\x98U$\xecR\xc1\x92\rV\x97\x13\t\t\xb66\x08U\x1b~\xa8\x02\xd0\x96\xb4x#{t\xad\xde\x94Q\xf4\xc1\x9f\xb6\xf2E\x14\x11\x8ff\x87\xf5+\xe4*\xa7\xc9K\xb6\xe4\x91\xaa4\x80>T\x91\x89\xdb=\x82\xb8\xe3\xfed\x9c\x03\xc9\xb0\xc0\xa1$\xb7Z\xf7\xb0\x81_\x03\xd3\xad~~\xce\xe5h=\xbf\xc4\x18\xc1\xe3\x03U\x96{n\x94\xd9\x83\xd8\x1a)\x11\xaf\xc2u\xe3\xf9\x0e\xdb\xffE\xa7H\xe7f\xfbg\xc6\xebV\xe8\xd8\xe5\xad2\xc2!\x04m\x0b\xe0\xdedS\x88\x17\xbf\x1c\x92\x8b\xcc\x83s\xe6\xa0\xd3l\x13\xd3\x98\xbb\xb2\xe7\xe7\x05\xe1\x12d\x85\x98B\xab\xdcp8\'~\xdb\x12:\xd2\xe2Xe3\x96\x7f\xc4r:h\x81\xadg\xce\xb7\xda\xf1\xa6\x97^)X\x91l\x1au\xd9\x15\xe5\xa8f7\x915H\x1c\xaeVn\xac\xef\x82\x83\xed-8\xe0E5\x19\x84\xd8\xbe\xa9=c\x8e\xe1\xed\xa9\xea\x1b\xeb\x9e\x0ej\t5\x97\xeel\x8cDJ\xd8\x11\xecb\x1eBE#\x02\x15\xe0#\xd9\xd1\x1f\xb5\x88/\xbe\xfd)\xe6\x01\x1f`@k~\xbd (\xceC\x15Ava\xe3\xd7\x9d\xf5\xa5\xca1L\x0cUu\x91\xf69\x1c\xe5\x9c\xd8\xf9\xc1\x10\x10v\xc5\xef4I\x1e\xc1\xcbA\x06\xadU\x8e&\xe1\xdc\x89+\xc0R\xafyS\r|Vc\xf8\xfd\xcd]\x1a\xc5\xa6\xb1y\xb5\x86\x00/\xcf\xbb\xb2\xd2^\xefT\xa6=\xdc;\xa2\xcbk\n\xbe,\xc1\xdb\\E]\xd2.U\xfa0y\x87\x8ft\x12\x973\x8c\x88;*\xeb4\xablIX\xf2:\x190O\xe4\x17\xda\xd7\xc2\x92\x02\x91\xa1\xe8\xda\xe5\x1a\x9d>f\xbf\xe3g\xa7r\xf8!u\xa4\xf1\r\x16\xc61\x10$B\xba;\xeat5\xea)\x1d\xc9(kV\x18\xa7\xeaa\x85j\x18\xda\xa7\xad\xc6\xd3\xfdM\x15Q\x89M\x86\x1aF\xf7\x069\x1b\x9b\xbc\x0e\xed\xca\xdd/\xc0\xa6$\xcd_\xfa\xc0\x92\xcc\x10\xca\x99\xc0"\x7f\xb54\x82pDH-+TRtP\\\xe3\x0b\xa4?\xb4uA/\xe1<\xae\x17\xb1SQ\xbcQ\xa6\x16\xc0FdX\xf0Q+\x01\x07S=\xe3YV\xc9\x0c\xeb\xce\x99\x8c\xc6}\xb8\xb3S\'&\xb5\xc1\x04i\xe8\xb0Lv\xca\xccC\xb4\xb6\x19\x88\xaf\x94?\xdb@\xf2_-\x15\r\xcb*\xaaQg\xef\tpq\x95C\x97\xd8n\xa4\x89W\xb9_\x13hI\xbc\xf6 \x01q\'"\xc5\xdfcf\xf97\xcd(\xd5a\x0e\xb1\x9d\x00\xd2\xd7p9\xf6\xdfD\xe2)\x0f:8\xc7s+\xa4eeZM\x8f?\x13\xb5\xe3\xd3F\xf6\xe9\xb8E\xe3a"D&\x91\x1e\x05\xe0\x1f\x0f\x9a\xe8\x07\xcc\xca\xc4\xf0\xaa \xca\x8f\x8e\xed\x14\x8e\xc6\x07\x8d\xb4\t\xd5$\xdf\xc0\x0el\xe5\x87:\x92\x9e\xab\x1ds\xd4\xed\xae%\xdd\x06\x16\xd51M4\x83\xdd<\xff\xb0\xd2\x06k\xa1P\x8b*\x9c\xd7\x05JRC\xbe\xa8f\xadS\x1b#(\x0c\xd0\x17\x87\xd5X\xf5\xbd\x88\x06\xbbv\x99\xa8^\xa9\xac"1\x97\x0f\x00\x19\x0f\r\x02U\x11i\rfO\xd2\xae\xdc\x14_\x1e\xe6\xa6\x83\x9av\xc46\xf5\x05w\x89\x9d\xa1\xbd/AF\x18~Vg\\\xf4\xc2)q#\x89^|\x94\xda\x08_\xbb\xda\xe6\xaa\xcb\xf4\xb7\xfc\x80\x0c\x8b1\xd8\xdd\xf1\r\xf4\xc5og\x91#&\x8d\x99\x1b\xf4\x16\x85\x8fl\xae\x80#7\x99\x0ej\xc2n\x8a\x18\x9bcI\xa6;\x96\x87m^\xbe\xbeob\xb1\x95\xb2\x95\xde\xac\x10\x91\x0c\x8c\xa3l \xbc\xaa\xb9\xc3\x7f\xba\xe4\xa8\x904\xf9\x16\x18\xbd\xcacX\xbe\x9f\xc3\xf5Q\xb9%\xb7\xfe)\'\xd2\xac\r\x80Q\x7f\xd2\xec\x16\xeb.\x9bd\x07\x0c\x96\xfc\xcf\xb8\'k\x8e\xae\x1cs}H\x11+\x1f4@{5\xf9\xa2\x005\x9b\x01M\xdc\xf8$\x01\xcc\x97}\xd5\xd7\xe7t\xe7P\x83\xa9E\xe5\xe6F\xc6\xe7\x0b\xfd\xd8\xe8\x19\x82\xc6\x84\xf4\x8d\x84\xa5sY\x1c\xfeo\xaa\x9d\xf8A)\xe9\x85\xa4\xe6\x06\xa4\xf0\xbaWt\xcb\xf5\xfa\x03\x16@\xe0d\xb7\x17\xb09T>\r(\x83So&\xe6\xfb\x9b"\x1d\xbcG,M]JRXbQ{\x88cl\xf0\xd1\xf5mG8\xbeU\x93\xce\xd3\xa8\xda\xd7\x0bJ\xdc|f\x1a\x89o\x9d4\x0c\xa2\x8aW\xfa\xe4&\xbf:\x9c\xf5\xf7\xc0\x96\x8c\xcd\x1d7\xc72\xe1\x048\xf1$\x94\xd6\xfa\xbe\x05\x8e\x19\x17\xfa\xcb)\x86`\\E\x94 \x13[\x82\x92-\xab\x84\xa4\xbc.J\x1c\xd0M\x01\x8c\t\x10\x11\x9a\x8c&\xb1\xf6\x9d)~w\xe5\x919\xb6F:\x18\x00\x98G\xddu\x83\xdf,\xad[\xd7\'\x18:)S\xc7D\x7f2\x8cz\xa2tT@\xa7<\xef\xd2\xc3\x9eH\xc8-\x8f,\xbd\xee\xe8\x19\xb3\xb5\x0646\xc3ij`\x81F\x85J\xfbz\x0f\xb3\x02H\n\x17\xfb\x14\x1d\r[jW\xd8\xe4EU\xe4\xc3\xa3\xd8\xab\xf0\x98\x93\xa7\xf9n\xa5\x08\xc9\xb3\x07`\x80U%\x12\xb4\x1b\x85\xc3\xc34r\xf6\x9a\xb9W\xce\xe0\x14\x0b\xfc.\x8c\x03\x8eR\xca{\xc2\xeb\x97\\f\xd5\x1f\x92\xb8&H!\xc3\xcah\xec\x19\x15\xc47\xec\x01\xd8\x90\x87qJ\xa6>\x8d\x9f1Jh\xcb.\xad\x1a\x91\xc7\xa4z1\xef\xdccZN\xc3\x1d\xf2D\x15PX\x96\xc0<\xd8\xb9|6Z8\xcf\xaf\x11;a\xd4\xad)\x14dm\xbe\xcc\x06(\xa7\xee\x05p\xe2\xf5yk0\xb1O\xec\xed%\x19S\x01\xf0\xd7G\x97Td\xa1\xbb\xfa\x1b\xbf\xf2$\x10G!X\xb5\x13\xe0\xaf>\x7f\xf7\xcc\xf1\xfc\x9bV\xb9\xf8\xc1\xb7\x11!\x0f\x89\xf9g"}\xe9N\xa3\xfa\x10\x14\x01k\x98\\\xb2=M\xea\x00\xb1\xdf\xca~\x16\x0f\xa9Qn\x8f\x1980u\x88\xb8Dmao\x1fu`Q\x07\xdf@]~\x8a\xca{T\x85FZ\x958\x15q%\x8a\x8a`\x98\xb0\xf9W\x880\x92%\xcc\x80q\xbbJD-"p\xe0\x0fdOp\x01,\x8d=\xe0\x89\x86@\x10\x96\x19\xd9\xc3j\xde\xbb\x92\xe2\xa8\xd3M\xc1x^\xd49\xf4\xcbnj86\x15]\xc6z\xfa}G\xfc*5\x13Xm\xc3\xfb]}\xa2\x8a\x90\xb0\xc4\x96\xe2\x00\xf0\x00\xfbru\x07\xea\xfd\xb1\x8aU\xf2\xe4\xa3v\xd8\x8a\x15U\xfcV`\x91\xc6\x86\x8a\xa6E\x88\xafJ\xd7 \xa4\xae\xa7Pa\xcf\x1a\x82\xa9E9\xa8;\xe8\xdc\x8c\xd5\xe2\x0b\xbe\xe2*}\x91\x82\x9a\xb8\xd0\x8ah)\xd9V|\xb5\x87T\x15\xe2t]N\x8b`,\xcaPj\xb9{n\xed\xbf\xc6\xa2\xfa\xa9?\xb3\xb7\xa7\x1fq\x8c\xae\xd5\xa8\xf9\x14\xeb\xfa\xc8\x1cj_\xe0u(\x8fL4\xa5\xa4\x7f\xfb+^\x88\xc7\xf7\x86\x1e\x0f\x89\xe2s\x05[\x17\xed\xa3\xc8\x02\xa1\xcbP@\xd7f\x8b\xdf\xaa\xd3\x00\x18N\x00&\xba\xd2\xcf@\xeb\xed\xa0s\xc8\xc2\xa5t#s\xeb\xe2wJ\xd9^\xaa\x915\xad\x17\xfcY\xe3jP\xfe\xfa\x03\xfaB\xb2\xbb\xad\x85\xab\x16\xc7\xbb\xdb1O?\xf0\xe6M\x89K\xbe(v/\xf5\xea1p\x06\x06\x16\xe3:\x1aR\x13\xa3\x7f\xdaCBG\x9b\x05\xe0\xad\xe3\xc0\xd6\xd72I\xbfB,\xab[_\x0e\xa2\xd9\xa5\xc4\x9b\xf8H\xb4]\xdc\xb7ln7\x93\x1b\xcc)\xdb\x87A\x1c[\xe1\xf3\xa31P\x00\xe5\x04&\xeb\xc9(*<\rl\xc1ayp\xfb\x92W\xe4\xcc\xb4\xb8d\x9dz4|+2b8\xdcV\xb6_y\'\xc4\'\t\xc2:\x9f\xcb\xcd\x0b\x0b\xd9\xc3\x14\x17\xd7\xd0\x9e\xf4\xe3\x02b1+\x11f5*\x15\xc7\xd7Qm\xdb\x8dE\x97\xb3\x8b\x03Z{\x01\xca\xef\xc6\xcf\x99M\xdb\xa6\x9b\xc9\x91Y\x98\x00\xdf\xf4\x9d{\x8a\xafY\x93\xc8\x999\xf0+\n\x93\xb3\xa5\xf6a\xae\xe9&\xa2%\xce\xb4\xc3\x94h\x96h\xb7j%n\xf5\xa8\xe5\x10tlLS\x99)\x1c1\n \xa3"P\xb3&J\xb5\xc4\xb4\xd6Vbw\x07\xb9\xc5\x82\xd5&\x81\xb7\xf5\x13\x9e\x0c\r\x82\xe2\xc1Y.Q\xcc\xd4\x9f\xbc\x15\x81\x9b\x18\xaf_F\'\x93\x82\x01\xf9\xe7?W\x8c\xbe\xc9k>C+C(A\xb7\xdb\xcfR\xdd\xf1\xf89O\x1c\xf6b\x1f\xb3\xe0\x07`\xad\x87w*\x1d\x9d\xb1a;\'\xd5\xd2\xb3\x9c\xb9\x90\x85\xf9P\x90p\xd7\xa4\x9b\x8c\x89\xd6\x05B\xe1\x86\xe7\xbd\x99\x08\xef\x07\x1b\x94\x1eN`\xa8;p\xecU\t\xe0\xbeCMy-\xd1\x12\x0f\x85\xe1@\x02\xab\x16E\x99\xbc\xec\xf4CM4\xc0\x91K\xd3\x7f\x93\xa0\xdd\x1f\x012\xa5\\{\xa3\xdf\x13\xa36T\xd8\x91\x86\xc7m\x04\xe9\x1c\xb7\xa3\x83x\xe7\xe5u\x15I\x19\xc7\xb1(\x08vh\xf3\xc3\x16\xdcb\x17L\xe6\x87~&\x01\xbb\x16\xed\xe5o\x8c\x96\x1au\xdd\xc0\x99\x18Y\xe3\xf3\xb4#\x08A\x9b\\\xc8E\x0b\xd6\xaao\x02i\xd3\x02\x14\x88\x80`\xdc\x85<\x87A[\xa6}\xbf\x1aC\x11xU\x9fn\tl\xe9\xa4\xed\xdd\x81E\xa1\xe6="\xc3+\x8a\x0e\xf7/\xab\x9e\xb6\x1b\xbb\xb5\xac\xf1G\xe9sA\x86\xf2\xc7o\x8c\xd6\xa5C\xc6\xf6L\x19!G:Q1>\xa9!4\x99zj`9=6\xb53m\xa9\xd7C\xe0\xda\x16\xc5\x02K\x0f\x8a\x95\x06\x0c\x025*\x9cJ\xc7~\xfa\xf5\xb36Z\xbd\xf3e&$\xb5\x9a\xeeh\xde2\xff\xb2\x88-@\x88d$\x17=?\xda\xf1\xc20<\x15G\x9e\x1e\xc2\x10\xc9N\x00\xd1\xb1/\xef\xb5k2Ys\xd2\xec\x7f\xd7\xcb\xbb\x9e\x1eG\xd3\x06\x1e\xae\x80T\xdd\x80\xa7|t\xd4\xaa\xc2WG\xed1\x0b\xea\x96\x90\xb8\x0c\xda\xec~\xaf\xd2\xce\xd8\x0c\xaf\x8bN\xe9\x99\x89^[\xf0\xdfb&\xf5\x8f\xdd\xc6\x10k\xc8=\x06\xc3\r\xce\x9a\xecs\xbc\x0cD\xac\x0fW\xb0u=\xdb\xa1v\xb9D\x11P\xdc\xa1x\x94\xbd=\xff\xee+\xcc\x08\x11"MLJ:\x8fW\x14h\xa13y#Q\xa4C\xad\xddb%\x1b\xde\x08\xf2\xa1\xa0\xa5\x9f\xf9\x1e\n\xca\xfd\x06\xe8\xa3\xc7=rE\xddzu\xffGy\xaf\xa127\x85\x1d$\xda\xf8\x06i\xb4\xe6\r\xdds=\xba\x95\x804\xd8\xceW\xfd\x1ddw\xdb\xb7\xd0\xdfD\x05j\x1a\xb7\x8e,^\xf4\xa1(\xf5Y\xf1\x03q\xa7\x1e{\xe9\xea.\xba\x1fk\xf0]0\xf8\xbd8\xf7\xed\xa9\xadc\xe0\xa8\x0f\xb0\t\x8d\x04\xc2\xe0\xf1\xc3\x92\xad\n\xf0\xd4?\xfbO}\xe2\xa2\xd35\xa1\x17\xcf\x82\x84w\xbd\\\xe4/\xaf\xf8\xa7\x94\x81y\x1dqW:\xec^\xfd\xcf\xaf\xa4\x14\x86\x00\x87}\x95\xfcIJJ\x9a)\xfa\xeb\xd5Q\x97\x80\x80\xa3G\xee[R\x04\xf42T\x19T\xbe\xce\x9f\xf0\xcd0\x88\x80[\xa2|\xc0\x0cTs\xaa7\xd0\xce\xe5\xa6\xd2\xb5\x12\xd6"\x8fd\xdf\xce^a6\x96\xe6\x04\xc4\xb7&\xcbcoPE\xac\xd0\x0b\xa9\x94]||!\xde\xc8\xbd\xfaM\xd9\x1d\xfc\x19j?\xe9\xc1\xae\xa5\x89\xa3?\xa6\x8e5\x05\x019y\x8f\x83T\xdf\x00z\xf4\xf1\x88w~\x8b\n;\xe0>{\xd9\x9e:Y\'3@\xf7\xdd\x02\x13Y\xe9\xc3#8\x062\x04mC\x16\xa4sn\xb1U\x8f\xf1J\xde\x8cf\xa8i~8\x98\xdb\xd2\x82\xea\xbe\t\x06h\xcd\xde\xe0$z\xc2\xf7\xb8?\xafHD\xd6`>\x94\x97\x89\xe9s\xcf\xe9\xab\xac \xca\xda\x8f\xfb[J\xe3 \xc0\x06(\x81\xaf\xdc\x80\xadZxv}m\xbf\xc3\x0e\xd4\xbe\t\xaeXcrYN\xcb\x93\xbc5\x00\x8e\xd6 |G\xfa\xae\xdf\xbd\xb1\xb6\xd0\x1f\xb7\x13i\xd8\xaa\xc2\x8f\x7f\xfe\xba\x0f\r\xa94\x8a\xa2c\x1bA\x0f\x88r\x1az\xdf\xae\xaax>{\xdcjk\xb8\xe5\x8a\xc7\xe9@\xb8\x94\x149\xc4?N-\xb3\xa6\x01\x97\x06\xf7\xf4\x9d\x11\xae\xfa/\x14\x1bY6\xb7\xaf\xdeq\x8e\xd4wp\xd1\xb6\xeem\xefb\x96j\x12\xb7\xce\xe9\x99}\xbc\x90\xa3\xad\xa8S\xf0\xf2\xbd\xac\xab\xcdT:k^F\x15\x9fP\xd3\xa5\xf1\xbd4\x8f\'!\x9c\x9e\xe6!\xd97\xb6 \xb8\xcd\x01\xc0\xec\x05\xf2#\xea\xdb_\xbd\x03BH\xc5)\xab\x80\tf\x93\x1aZJ\x0f\xdeu\xb0\x9c,\xfb\xde_\x1d6\x8a\xe9\xb29DiK\xa5#\x91C\x9f\x82\xe4\x97\xa4\xd0A\xa3\x88\x0bD9M\x84\xd3`\xe6\x1d\xdf`\xed\xc9\x9e\xef}B\xa96\x95\xecr\x03m\x05NVD,h>i]\xf9\xfaL\x86c\xd1\xbc\x8c\xb9\xe0qR\x93\xed\xf7\r\xe2;\x1eq\x02\xc7#=\xe4I~\xa5\x12J.\xf3w]\xc4\x08)\xc7\x03\x1el,\x9d9\xea\xc92%r\xa1\\\x9d\xad\x16P\xd6\xbe\x8f\xc7\xaf\x13b\x80\x8f\xcc\xb5\x83\xc6\xecBD\x1a>\x02@c_g\n\xc6\xa5\xf7\x1b\xbd\x06\xad\xae?\x1c|\x11\x9e\xb3\xa9\x86\xb2\xac\x8b\xf0[\xda\xaf\xab\xe2\x10,\x18\x9b\xd1T\xe3\x0f\x87\x0bc\xaa2Q\x11\t\xee\xfe)\x02\xd3\xc7\x9d\x9d]9\xfc\\~\x912jH4\xb6\x1a3\x14&\xb5d\xa6\xb0\x1f\x88\xaa-\xc4\x0c\x84\x96\xf3\xcf\xa3\x06s\x9f\xad)\x81\xa2\xb7+96\'^\xdeU\xb9\xe29\x05\xb2\x99#0\xa7\xe4\xe7"!\xee\xd7\xcf\x9b\x9a\xc7\xa7\x1b\x8e\xef\xbc:\xdb\x1d\x92\xf3@\xf3r\x96\xb5\x82r\xaf\x9a\xcfw\xd8\xcd\xec\xacN+\x0f3\xf3\xe9~\x1a\xd6\xa4\xa3\xd1%O\xec\xa5\x89~\x15\xed\xe0\xb1\xfc\xcd\n\x06\x1a\xb6f\xa2\xa3\x93\xc4\x19\xd99A\xed\xc5O\xab|;-\x1c\xac\xad\xc2\xb0\x1f>\x13\xddU\xc8\xd7\xb7\xd5a\x08\xb3\x02f\xb9\xe1\x9a\x99s\xb8\xf5\x1a/sb7\x823\xd3\x9c\xc0\xa3C\xa0-cZ\xf2\xa8dP\x15Tk\t\xa5sa\xc6~\xd9\x93&ZP\xcd\xd1\xe6]\xc7\x12\xc7\x9f?\xc0\x95\x00A\xee#Z\x11\xe1\xfe\xfbn$\x89\x16\xb3\xf4\xad\xa0\x83\xe7n3)jvE\xd7\xd5\xe4^\x9bn\x94\xdf\x02\x16\xc9\x9d\xda7\xb1\x1f\x83I\x99g\x0c\xd3\x11\x1cN\x8de&[\xc7\xc2\x9a3\x11`\x9eT(|\x91\xe1!za\xc2m\xf3\xd0\xc3\x8f\xc7\xa7\x96\x9eq\xc2\xb8b\x1f\x07ZbmPj\xc5Ww\xdf}[B\xe31\xd1\x99\x87\xd5,\xf9\xc3\x03exp\'\x91H\xe9{/s/~\xd0\xb9!\x82\x1da\x11b\x9cp(Z\x19\xde\xd1\xc7\xc9\rm\x8c;\xd5,EDC\xf4J\xc9\xe9\xbd\xb0]\x12\xf9I^\x17Uc\xe6\xad\xef\xf7\xbd\x7f|\xa4\x7f\x80\x02xX\x1c\xfd\xa8b\x91\xdb\xa2\xcc\xd2n\x97k&|\xc8\xcf~\x03]\xcb\xe5!\xaa\x0bB\xa4\x93\xc7\xf6\xdet\xf0~\xa9\xc8 \x81\x97\x90.5-\x11\xc4\x0c\xad\xe3\xe9\x14\x88\xc9;\xd9\xf5S\x86`\x94\xed\xcai\x8e\xfe\x03]\xefV\xf2K\xd7\xcc\x16W\xe0\x9a`\x0f M\xa6}f\xa8\xdc\x10\x13\xbe\xe3t\x03\xa2\x8d\xb7K\x06\x08\x18\x1by\x07\xe2\x14\x01\xd2\xb0(\x08\xbbfw?\x8bW\xa6=\x9b\x10*\x03\x89\xbaY\x0fQ\x97\xef\xcd\xbbpZ\xe4\x85\x04\xc3x\x1e\xae\xde\x93\xb1\xc1\xeb\xd9\x06 \t\xb1E\n$\xe1\xb9\\\x94\x7f\x0f}\xd0\xfb\xc9\xbd~mP6\x8dV\x87\x12\x17\xbd\xee0\x16V>Kcu_\xc7\x05\xe4>\x90\x1cZ\xb8\x850\xa7\x01\xa2\xee\xd8\xda\x0c\x8c\xab-\xbdH\x18\xb1\xed\x93\xfdW\xe1\xbb\xa2w9\xb0\xc4\x9cH1\x84\xc7E\x14oH{\x05\xe7\x88|L<\xef\x03\xef\xb7\xda\xd7(M\x8f\xf7\xc4iR\x04i\xa3c\x11u~\x15\xf5a\x189c\xd6(3\x1fX\x12\xe8\x11\xcc\x8f\x88\xfbXD/\x8fCq \xf6\xca\x817\xcd>\xcb\x96\\Mv\xbb\xb8G\x8f\xdc9\x0c\xe2\x1b\xd6\xfd\x1cz\xd9<\x10\xe5L|\x04f\xbb\xbfV\x9eF\xf2\xc5\xd3\xb3F\x80\x1f\x8a\xa7\x06\x84%:b\x15\x81|0\x86\xc2k\xb7\x12>h\x91\x84&\xc7\xeaW\x8a\xf5\t\xa6\xec\xc4\xe3Z\xcdeF\xe81\xb3b\x17\x80\xe7\xd1!\x88\x8d\xeb\xbe#6rOUYP6\x92`\xd8N\x10\xd2\xf24q\xac\xb2\xea\xaf\xb0-K\xb68\x81\x85\x9a;\xaf\x95\xec\xef\x86\xab\xc5\xb1\xb1p\xcd\x811\xa0v\x97\xaa\xf2\xe6\xdd\xca\xeb\xa2\xdcq\x8f\xa7P\x7fh\xa6\x06\xa3N\xa44"L\xd5W\xc7\xcb"\x8d+8\x170F\xac3\xe8\x13\xd3@\xfdH\x07q\x13\x08\xd2\xf7z\xae\x88z\xbd\x1c\xd2\xfb\xef\\y\x8a\xa3\xfd\xe5\xf0\xcea\nj\xbb\x8d\xf3L"\x0e\xc0\x86\xc1\x80\xa2\xcdB\xe1\x0e3e$\x9a\xc8L\xc4=\xec\xa7T\x16fD\xf4\xba\xa1\xddX\xf3W\xcc\\\x1a|\x85\xed\xef\x9a\x0cX\x02]\xdc\x0f%\x99\xd5b\xe7\x11\xec\xc5t\xc4\x99\x85\'B\x98|\xbe\xb14\x9d\xf9s\x91\x8c\xd2\xf5\xae\xee\xb3C\xd6\x06\x7f:\xb5J\xf8\xb7p\xb4\xcd\x81u\xb8\xf6\xcf\xc4^\'\xfa\xa9\x8aW3eS<\xdf\x1d\x8b\xf9\x13\xd0\xd4\xde\x98f\x95\x1a\xbd\x97\x15e\xbb\xf2\xeatx\xdfH\\\x0c\x16;\xa7\xd1\xae\xcd\xc0\\\x1cc>\x16]\x8d)4\x8b\x9e\x8cR\x10\x8c\x8f\xe7\xcb\xd2\xba\xe0\xc4\r\x95\x87f\xf9g%\xd0\xad\xd7\x00%Y\xc9g\x86\xfd\xf7\x89\xc1\xae\x8ab\xd9?\xdd\xcbtU\xcb\n\x1b\x06WV\xc5a\xd2:f\xf7\xec\xbc`\x13\xbd\xa4G\xbc\xc2\xc2\x1er\xad\x98&\xd4\xcd\xb0D0:\x90\x0f\xa7\xb7,}\xfe\xea9o7\x16\x81\x93\x99~\x078}\xdc\xfc\x97\xbc\xd2"C\x95FlM\xe9\x97\xd2\xc0k\xc0\xad\xb6\xac\xab\xa3\xcbD\x0b\x98\xf4&\x92\x1e\xa9\xacS\xafx\x0b\x03>\x7f\x03"\x92\xfe\x07\xa3\xa8\n\xa2A\xd7\'\xad\x80\x88\xd7\xa6\\\xe4\x080\xe3\xfbJ\x94\xad\xbax\x13\xcb\x0e/\x8d\xfa\xd1\x8f!\xc5\x0e8\x9b\x07a(\xfaX\t\t\x03\xe1\x0c\x0f\xe0\x07\xcc>_rT\xa3f\xd00\x1f\x11\xd1\xb8\x18(d\xa1t\xe5U\x14\x84[|\xfe\xd9$\xaa\x89\x908-\xf9\x8a>\xbe\xac\x13-Hs_>\x81S\xb9\x93\x15\xd9\xb80\xd7>\xed\xc4\xb8\x93\xec\x1c\x89;E:\xdb\x86\x80\x91v\x83H\xd0{$\xd7G<:\x06\xcd\x02\xbb\x9a@.\xdd\x19\x9a\xcd\xbfk\xc3\x85\xe3\x01\xab;Y\x84nH\x96\xaa[Z\x84\xf9\xfd,\x08\xdeLhZ\x10%\xcf>\x034\xcec^\x9b\xa2\xe7\xc3\x07$\xad\x0f\xf2\xe2-8\xd9\x1c\xabJ*Dr \xc2]%\xf8\xe2\r\xe80\xa3\xb7\xd4{\xa2\xe1N\x96AT\xc5\xc11HLh\x95\xcf2L\x0f\x19\xba\xd2\x1b\xc9\xfc\x17\x85\xa0\xc9 \x0f+g\x9f:6\xef\xb2\x8b}&\x88\x97r\xbd&\xd1/#1\xae\x88O\xbaV\xb0\xecN\xc9\xaf\xbb\xf2\xcc\xad\xcbF3 zU\xb8\xabS\xb0\x87\xdad\xeb}\xeag)M\xc46\xb8\xdc\x00tFDmQ\x9f\x8f\xd5\xb2\x9d\x8c)\xef\xe41b+\xafB0\xba+Y\xe6{\xa1u\xb8\xdc\xb5.\xe3n\xd3\xf2\xdf\xb3Jb\x15h{8$1go\xc3\xc6\xf6\x8e\x9e\xf6\xd0G\xb7\xf6\xd1\xb3\xf5\x006"\xe3\xac\xaen\x11h\xef\xc4\xd52\xd65\xc8\xa2\x8d\xf2\x9c\x9b]\xb4\xd3]\xd5\xbc\x07\xc4\x01\xc6d\x1a\xc1\x84_\x88\xde\\\xc6\xc42\x96\xf1\x8b\xd5Y\xe8\xe6\x04\xf1c\xc7{3\xa3\xcd\x96\xb6\xeb3l\xe8P\rS\x83\x87\xedh\xc8\xd0\xf8\xb2eW(z\xed\xb1Z\xea,\x10\x17\x90\x91a\xa9\xc7]\xab\xac=\x95J\x1c\xe2\x08\xb5\xe2\xe7\\\xd8\x9e\x83\xc7\xcf\x9b\x00\\\x0b\xbb\x19\x0f\xf9y\xab(\xa5V\xa7\xb0\xa1s\xb2\xbc\x97\xddy\xc1\x12\xeab\x8e=\xca\x97\xa6\xcf\x9c^\xf1\xc5\x11T\xc4e\x94?t\xed{\x16\x8a\xe1\xd83\xe0\x1fDz\xeb\xbc\x19\xf5\xf0\xe59\xf0s\x04\xa6\x14V\xb8\xae\xa5\x1e\x8f\x8f\xc2\xa9j\x12\x87\xee\x1e`\x1e\x8e\xbd\xca\x04Sh1\x04\x99I%\xf8YRr\xa5;\x82g\xf6\xed\x1b,y\x1f\xdb\xde!\xdf\xac\xb7\r\xe0\x02]\xbf\x82h\x7fD\x8eX\x12\xf4WT\x1bv\x1e\xd5\t\x02\\\x05o\xcca\x86\xee\xe9\xc5\xa6d\xa6\x10r\x11\xfb\x98\xb5\x08+6\xe8r\xa2\x9b\xb0\xd4;\xac\xd0\x8a9Q\x8f\x87\xd3\xf6F\xc2\xbfg\x9f 0\x15\x87\xf7=/\xe3\x9e\x92\xce0\x18\x8b\x01\xb4\xe9\xfd\xcd#D\xb6\x92/\x16\xafmu\x8d\x0e6\x87\x84\xd0i\xbd\t\x91\x12\x1d\x04=\xafL^u\xacFo\xac|EF\xe0\x89`\x12\xf2\x8c\xc1\x9eq}/\xf0\xc5?M\xdbX\x00\xc6**\xa6`\x1f\x15h\xe0\\\xf5\xe5\xbf\xc8\xbaL\xc32+\x1d\x93\xc7\xe7\xc1\x0cD\x8f!\r\xa3DH\xfc/\xc4\x1e\x9f\x00\xbf\xb2\x89qm\xc62:\x1b\xee\x88\xa3\xaff \xda\x00\x97\xb5\xe3\xfcS\xfe\x18\'"\x82\xd5\xea\xeeZ\xaf\xbf\xc6\xf3k\x1c(\x19zD\t\x0c\xe5C\x18 \x8bM\xd5\xff\xc9\xdd\xdb\xfe\x10\xc5l\xe2\x8d\xd3HPX\xa1(\x9b\x89(\xf7\x08y\xcb\xacUG-\t\xf7\n\xbdLw\xeb~5e\xd8+\xf1@\x11\x83_x\'\xbb\x8b\xdc\x93\xd6mA\xb1Q\x10\xe5=\x1b R\x1coU\x18gP\xb5\x1dI\xdaqy \xc6\xc6+\x1d\xbe\\\xea\\!\xe0\xa2\xb4\xba\x81\xf9\xcb\x93\rX%U\xe4C\xe7b\xa0\x11*\xe9\xfd3\xd4\x94\xe1\xac:\x9e\xe8\x9f\xc7Wy!3IlU\xdd\x07\xb3\xc5\x18\xf4\xb3d]\xe3jkSf3"\'>\xe7\te\xb9\x19\xd5\x80\x02\'\xfb\x07\x88\xb7(\x8d\xa8\xb3\x13+\xb3\xd3#\x9b\xc5\x13B\xcd\n\x151d\xc6\xed\x07@\x80\x0b\tV\xb6Kg5\xf8P\x13h2\x12\xd0a\xc4\xee|3\x1d\x9b4\x8b+\xe8\xf4L\x11\xbf\x89\x1d\xc0\xb7HHR\x03\xe9\x14\xe4\xd5,E?\x8e\x1e?\x05\xf8A{H3\x13\x80/\x9a\xf9\xd2A\xdba\x9a\xd7(\xd1a\xe4\x14\xd0\xf0\xbe\'y\x1f\xd01=\xd1\x01G\x8fP;\xacd\xf1u\xa4\xf4\x10\xe6-!\x9e\xf6}\x99/@u\x8d+W3t\x1b\r\xdd;\xb2\xd1\x9e\xcd\xbb\x1b\xed\x9b Is1Ar\xda6\x1a\'\xbf\x95\x86\xcb\x99\'\x1f{\x18\x1aYp\x06\x11\xce\xc7\xb2\x8e\x96q\x8f\x19\xe5&\xa7\x0b\xf7\xf7\xaf-\x18\xf5\x91\xaf\x88,z\xb1;"\xef\xd9\xdc1\x9c\xdc\xdb\xd9D\x8b\x1bt\x12\x10Y\xc1\xfa\x89\xc9{p}W\xf0\x8e-]\x02\xc1\xe5\x11-\x00\xb7\xe7\x84\xb6\x01G\x05\x0fv\x18\x8d\xaa\xdfamI\x16\xb6bgvZ~\xc0S\x81\x15lb\xbdN!\x0b\xcb_\x15\x1d\xce3,A\x9e\xbc\x8c\xf4>\x95Ez\x8b\x02K\x8aoe\x19CW\x97\xea:t.\x042u\x0f\xb8\x9a\xa4\x8d\xec\xd1-\xf0Y\x92\xb2Ql6\x12%\x95\x9ao|X\xab\xf3H\x1c\xb5w\xcb\xf0+\x9cr\xeb\xeb\xc9?\x0f\xd0X\x9eYz\xfb\xe8+\x95L!1\x93&\x8b\xb0\xd3C\xbfy_\x96\xd6\x15\xed\x8fg\x88G\xde\xe3\x88\xcb\x880"\x14Y\xa6\xe9k=\xb1A\x06\x91\xed\xdb\x8a+m\xfcUI\x1e\xfd\xb5h\xb3\xf5\xa0\xe5\x89\x9c\x07\x17SW\x84-u\xbeF\x1f))E5\xbb\t9\xc5\xcd\x1aTJAy\xb8\xf3\x01B$\x17\xe8\xd4d\xafX\x10\x9f\x06\xdf9\xd3\xed\x98j^-\xa8Q&\x13|\xe32\xe0\xea~\xea\x1b\x9f\xd68-\xd0\xf5\xb3\xffn\xdc\x08\xd9\x04\xbe(l\xa3\x06\x8e\xd3\xc2\x07\x9d\xb8\x9a\x11\x16U\xaa\xfc\xfa\xf7\x13\xdcwb\xf5Rr\x88\x9d\x1f\x0b\xd8\xffh\x8f\xd8\xb0\xd3\xac,\xb1\xc9p{!\x0b\x91E\xdc\xe6q\xbcj\xdb\xe1f)\x95ELW\x1a%\x9d\x18U\xe8\xa7\x96N\xaf?\x08\xc3\xfe\x02k\x9aP\x11\x95\x81\xb8\x96*{\xdad\xea\xee)\xa7bUa\xc5c\x02\xa6\x8db\x94e\xc1RqW\x8a~\x85\x19I\xf4<\x1b/,\xca\xd0\x7f\x04\x00\x0e\xf0b\x8d\x14n\xcay\xc4\xbd\x83\xe5\xf8\x11\xe0\xd7C\xe8\xb4\xd6\xb4y\xcaV\x99\xf4\xfe\xce\x8e,L\x86\xeb\xd3x\xf3\x08\xc1\xf4G\xba\xe4\x84\xa9yn\xcd\xc8\xd2p\x9a~\x03\x16g\x90\x92\xf7\x01&\x13nl\x11E\xf7\xce\x80A\xe3\xd5\x9fd\xc3|\xda\xec\xb2\x12\x96\xbc,\xf4\xaf\x9d\xa9\xb12X\xf3\xa0\xc0\xa5\xcd\xe5869H\x9ft\xcf!\x86HZ\x08^\x19|\xb3\x00\xa1\xa6\xa5\xbd|5\xe1\x92QXb\x1f\x163\xee\xcd\xd9\x86\x95\x10j\xbf\x1aFA\x92\x8b\xd0\x99\xb7\x87p\x91G\x925\xbc\xb09AA\xf4\xac\xa2\x1d2\x83_e*\xb6\xd0\xdc\xc7B\x0e\xa34\xd6\xe7\x9ch\x85\xd2+\xba\\\xc8\xae<\xb8\x99\xc8\xe5*\x00\xd0$\xcd\xba-\xd4\xe2\x0e\xaf\t\xfd\x1d)\xcc\x01&\x8d\xb7\xd6\xa8\x00\xb9u\x1f\xa7s\x0e\xf3\x81\xad\xcci\xc4\xae\x83\xee3\xe7D\xbeS\xd4\xe7\xe9\xa7\xb5\x07\x8f\x9bC\xa6>\xe0J\xe8l"\xbe\xff\x97D\x8c\xaa\xa1\x86e\xe2\x1e\xbdp\xfct<\x04\x041\x19\xe3\xcb\xb9\x11d\x03\xb3\x1f\xc3\xa0 W\xa0R\xe82"\x85\xe4\x7f[f~\xd1^\xe2\xf9\x87\xd6>la\xb2\xe1QU\x14\xdc4\xf8w\xbc\xf3\xd9\xaf:;\'r\xd7\xf6\xe8\xfc\xa2J\x89uv\xe4*^\xdf\x9a1\xc7o\xbe\x17\x8c\xd8\xdc0\x0cw\x0br\xfd0\\\n\x8d(S\xd9(\xf4-\xbd+$W\x99\xafC\x19\x16\x0f\xe1\x1c\xb6_\xe4u(tg\xdc\x0b\xca\xd2>\xa0\x7f\xccW\x15<-k\x93\xaf\x82\xdd"\xbc\r\x98\xb0\x9f\xeeQ\xdcZ\x0f\xf7\x93H\xd4\x93\x95\x80\xf4\x9b~?l\xd6Ql\xb7\xe7d~\x98C\xe4\x8a\xd8F\x7f\xc4P\xaa\xb6\xca@\xf83\xa8\x80\xf1\xd8\xe6\xd3\x01\xd6.\xc7\xd7\x18 \x0cjU\xb6C\t\x9ec4C\xea\x02^\x9e\xd2Xo&\xcfbB\x8b\x13\xa3\xc0\x06\xe5,\x89\x07X\xb7G+\x94\xcb\x8c;\xafyk\xdf`\x17@i\xc9g\xa7f\xdf\n\x9bg\x17\x9ar\xbcp\xfd\xcf\xe4:\xe6\x12K\x8amA|3.:6 4\xac*\x86\xfc\xd0\xccn\xf0\x00y\x91\xef\x14/g\xab\xf5x\x14\x8a\x03\xa6\xbb\xa2\xdb\xaau\xd5\xb3\x08|?G7\xce\xd8~\x8fO"fMV\x8d\xd1,e\x9fHtW\xfc\x8eT\x03g\xb6\x84\xccP[\xb9\xa9\xd2\xc3%\x7fR\xf92\xdbK;As\xb1\x86\xb3\xc2\x08a \xec\xe6"\xe8\xcd\xef\xc9\x02\xf9\xca;\x03.\'\x88\x82*\xedo\xb2\x06\xcb\x8c(\xbc\xaf\x9b\xb2\xa4\x13\xc3\xechZc[\xf9\x07n[\x9d\xd6\x06\xca\x00J\x96\xe6a\x10\x8a\x10\xdd\xc7\x94\xff\xd5#\x18\nv\x92\x8f\t\xba\x108\xa5\xd7\x87E\xe8t\xe7\xc4)\x1e\xf5$\xe8\x9e,>\x10\x00:\x17\xad\x86\xaf\xc4\x19\xb1\xf0@\x8f\xfdz\xda\xe6\xc06\xe7\xec\xa1;[vB\xa9\xb1\x7f2\xd4\xcax2\x80=\x02:5,U\x9e\x91\xf1\xab\xf9\xcb\xa3A\xa1\xb4\xea\x96\xc3X\x8b\xfa\x87\\\x8c}\x8b\xcaD\xc4\xff\x7fh\x14Q\xac\x80s\x81\xd11\xfc\x8eql\x87\xa0\xedOP\x02\x81\x83\x01\xcd|\x8bt\rZ:.:\xb8\xaf\x9e\xd2]O\x14h\xc6\xedR}\xe55\x06E\xbfj\xa1)\xc5Jd\x9d\xecM\xcamT\xb2B\x86\xbd\x9d\xcc^\xd2\xa66\xfd/\xbd\xe0\xd044\x91K\x1aE5\xdfN=\x10\x19\xa4\xd8\xa3\x0b\x93\x89\x058\xa2s\xe8b\x87\x7f\x1aqk(\x1d\xa6\xed\x17aD\x01\xce\xb4\'\x12;\x9a\xc4\xf23\xa5\x88\x91|!P\x83T5!\x0e\\\xbcz\xf8u-X\xb8e\x9e~\xfeg\xc2\xa2\x0e\xe8\xdc\x8e\xfd\x0e\xb6\xbfK\xa7\x9cH\xf1\r|y!\'\x8cZ\x0e\'l\x89\xda\x15\xca#\xae.\r\xaa2\x94}\x19Xel\xce\xb6\xbd\xac[\x83p\x0e\xe9\xf5Xp\xceg\x85\xcc\xdak\x9e\xef\xf0X\xb3a\x9dyb\x1aL(<\x01\x16@]\xb9P\x8e\xcb\xaeX\xddA\x8c\xa2"\x15\x87\x94\xf8\xb7\xd5\xc1\xd3C\xbd\xef?H|\xb7X\x1a\x0b\x14\xefg\xa9\x01\xaf\xb0\xc2\xc9\xb5\x8e[\xcc7Lc\xd6\x9c\xdb\xe4\xb4q\xd3p\xec\x12n\xd6\x90\xd6\xdc"\x08\x83\xc6\xee\x13\xbc\xf9\x91h\xe8C<\xdd\'\xa1\xf7\r\x0b,,\xba\xa3\xed\r\x81B\x94\xee`\xa5[?-\xae\xdb\xc7($y\xf9W\x11\xba\xeb\x14_\xe8\n\x1b&|i\xbdQ\x19\x89>\xa3D\xd7\xb8td..Y\xb0\x07\xbc)L\r\x96iUl\x8f\x1a14[\x90/m\xb7\xa5\xb8*\n\x8a\xc9\xc9\xc9g\x8e\x93{\x1b\xdeE\x08!@d_\x02\xdf\x87\x99,\xa1\xcbD\xcaxb\x98\xa1\x8f\x11\xbf\x8dL\xf6\x80\xcf\xe3l:D\xf7\xc4\xc0\x17\x16\xdd,\x1eQ\x8bs\x1e\x00d\x03\xb2\x9f@\xda\xa7\xf0y$G_\xe9\x05!\x04.\xc6\xb1)\xd1(\xc7\xbb\x86\xf7m\xd4J\xaa(q\xae\xe1\x89\xa6\xe5\x0eS\x99\xc8\\J\xe5\xeb\x17\x17\xb7o\xd9\xb5C\xfc~\xb7\xf9\xb8\xea\xadg\x04=\xab=\xa9\xfb\x14\x8a\xfbid\x01\x05\xd3\x84\xfc\x83\xd8\xb5\xa0N\x9f\x11\xd1\x04\x8c_\xb9B\xdd\xeb5\xb2\x8dHF\xe0k\xa3\x1e\xf2\xb0\xdc5C\x9b\xaa\x14\xd1\x0f\xfa\x01\x9c\xc9y-];\xd7!`\xef\x8e\xe4\x95\xb9b\x01>\xae\x15\xfe\x84\xf8\xec\xa1\xdf0l\xd7\xa6d\xabe\xbbdw9\xa7\x93#\xfac\x91\xaa.\xda\x94\x01Q\x95,\x01\x85\xa0\x16\n\t\x11\xc7\xae>\t\x84\x84n"7;\xdb\xab\xe3F![\x023\xbe\xf2Q.B\x87\xd2\xe2\x05\xc6\xd8\xefL\xa4\xeeY\xf0\xcf\xc6O}\x7f\x93\x04\xa6\xe5Q\xf4;[\x9c\xbb\xb0\x9f\xbc\x9b\xa8k\xff\'M`\x8cX\xcf\xf9,\xea\x90\xb1\xa4\xca\x94\x8bz)\xfeM\xc1m\xc6\xc9\xf5\x07\x8ey76\xe2N\x02Z\xa4`\xf1\xce#u\x88\xc2\nv\xa0\xf3o<\xe1\x0e[\x8f\x80\x7f%#\xe4\x1e!\x92Fb\x8b\x180\xda\x00<\x89\xdf\xcb\xcf=\xc9w\xcd:;\xc8\xb9X\xe2\xff\xb9(\xa2\x1eK`\x9b[`g\xb7\xd5+\xb3\xcf1S\xc7\x8b\xd4\xcb\x94!\x93lE\xcc$\x97\x19\xb7Y\x88\xb5\x0c\x89\x1cI \x98\x01I\xa1\xaa\x1c\xb1r\x10x\xa6\xea+\xc5\xaa\xc7\xc3\x16\xc9\xea\x0f\x8f\xbd^-\x10\x02\xe6\x80\x80\x01\xf5\xd5\xde\xec\xda\xc3\x1a\x1bM\xa6V\x8f3\xb9_\xd3b(\x97\x8f)\x9e\x98"\xa1 \xfb#\xde+ \r\xbc\xba\xfc>\x10\x1a\xa59%\xe7V\xfd:C\xd5df\x94\x1c\xb0\xf3\x93\x0b\x9f*\xf5s\xa1~=\xb5hk\xbe*\xed\xa2\xf3c\x0f\x83\x0b$\xd1+\x163f\x8f\xd2\xd8\xef\xb0\\\xbd\x7f|\xbc\xb6\xa9< /\xae\xf43\x8f\x07\xd2\x89e5\xa2\xa5\x1d\xe2\x9c\x91\x0cHL\xf2\x84\xb4\x1124\x83\x8c|\xac\xc5\x846\xbd\xf3\xd8\xd4t\xf4C\x19\x17\xf1\xe5U\xae\xfc\xe7\x97\xaf9\xfd\xc1\xb4\xf1d\xa5\xe3\x13`\x9ft\x9d`\xc3\xb1\xadl\x07P\x90H\xa5\xe8\xd1\xaa"\x80E\xce\x94\x8e|.\x12\xb8}-\x8b`\xc4\xbf6\x92c\xf7\xdc\x82.\x7f]\x0b\xab\xd9]\x94\xc7W\n\x8b\x14\xee\xb5\x9e\xa1\xa8\xfa\x8c+\x9fu2\x89\xee\x04EQ\xf3\xce\xd6\xa1\xc8.0o\r\xa1\xfc\x13\xc2H\xa4w#\xa5J\xef\xf0\xb6vQ\xe8\xa4\xe5\'9\x10\xe1U\x0eY\xa6\x83\xcc`\x02\xb9\xed\x11\xf1\x17\xff\xd9\xbd\x87\x16M\x8d\x0e\xe8\xa4U\x83@\x85TQ\x9eU\xa7\xb4\x9e\xd4o*=\xaaI{\xde\xeaV\xa7\xe5\xf3\x1f\x11\x9a1\xbe\x81\xd7\x92U\n\xcc\r\x1dB5\x90\xfd#G=_7\x03DC\x0f\x11\xb9\\s_a\xa3\xc6\xad$\x16v\xca\xab\xc1\xe4y;3g\xbfDw\x89\xb0c\x18}\xfd\x1e\x01\xb9sL\xaa\x00\x8f\\E\x9d\xf9\x98\xf0\xef\x1e\x10\xd6.\x98\x90\xf4\x9aSsS\xe5?=-\x0b$\xa6\x19Hj\xd1\x9d\x07\xc3\xfe\x96\xfb\xe3\x89\x8f\xd4\xe9\x8e\x9f\x8b \xd9$b\x07 \xe5\xf2\xc3<\xe8\xf4\x14Z;G\xe3\xdc\xaeK\x05\xf1b\xafs\x892^\xeb\xb3\xda\x87IhE\xd4bmg\x84\x95\xc5\xc6\x19]h\xf0\xe3hTzu\x06\'\x0c\xc5\x11h\xc9\xc7\xb5!\x19\xf1\xdb\x0cx\xa6Rg \xb5av\xf2\x02\x95\x9a\x92\rY\x0c5^[@\xd0X\xf8^\x87\xc0\x04@\x99\xd1\xb9/\xc9\x1c\x1d\xa1\xce\x85>\xfd\x02\x88\xfd\xf1!S\xee\xa0S\xfa\x1aS\xd6\xfd\x90\xbe\xd9Ux\x95\xc3\xbc\xaeE\xb6\xed\xb4\xd8v\x7f\x06\xe30^d\xd9\xe0H\xf2\xed\x1du\x06L\x1a\xa9b\xf7\xebS\xe5\x0e\xe1\x93\xb70\xa4\xbb\x98\x8c\xe2\x9c\x12\x90to\xf1\x05<\x8aN\x99\x1f\x98\xa9\x97\xd37\x99.\xff \xeb\xe1f\x88\x8d\x9d3\xc2\x9b\x9a\xe6.\xf2\xaa\x93\x9e\xea\xca~Ic\xed\x02\xb7I\xa4\x89\xd3\x87\xdf\xc2N\x88\xa4\x9c_\xa1\x959\x19\xecA\xeea\xc9\x160\xa6\xbfO^\xceK\x9d\xf4p\x94\xea\x86\xff;\xb0\x94\xe7\xc8\x96\xde\x8d:\xcf\'\xd5\xbfW\xf4Y\x12\xdf\xa8pz\xd6\xb5\x1508\xa5\xc3\xb8a\x12a\xeb\x1d\x81\x04%\x7fe\xb5\xba@\x98\x9b\x0e9&\xc8d"r-\xeaz\xc8D\xac&|\xe0\xea\x1aBjT\xdb\x14\x82u!G\xcd\xb0er\x8d\xe4\xda\xd4\x99\xb0Z\xd6\xb7MT\xbe\xcf\xca\xdd\x13<\xe4\x17_\x1b@>)\xd4u\xc2\xa2qlqdI{~\x83\xc53\x84.\xdf\x95\xa4S\xd4P\xd1\xd9\x97\xfdu\xddF\xcb-\x9cE\x9fp^\x1f\xca.\x06\xe3\xa3\x8a\xf6\x9e\xa0\xad\xa3\x12r\x0e\xcd9\xdc\x04\x8bB\x8a\x14\xa8r\x15\x7f\xdf\xf7\x08\xf8\xf7\x05&k\x83a\x88GE\xech\xdb>B\xd3\xc3Kk1\x1a\xa1\x01\x88\xe49\x01k\xb4\xf7\x15\xad.\x16\xb2\xe8\xc3\xe1<\xea\xc1\xf3\xc9\xa0=\xa9\x98\xb6\xa2+V\x13\xa5\xa7\x17\xe7\xfb\xecA\xb2\xf3\xf0\xd9\xdb\x88\x9e`\xec\x18\xb9I\xbe\xa6\xf7\x1a\xc63\x7f\xb9\xa3\xdd\xd2\'}s\x0e\xff\xeb\xd2\x8d\x8d=\xf1\xb2\x14\xca\xc3\xc1\xa1\x15\x12\x05\x9e~w\xae\x0f7\xf1W\xb2\xba\x8a%\x9f\xbc\x8b\x03e%\xe7\xf3\xe9\xce\x05\xc6\xf9\x01\xcd\xc5\x98\xd7\xa0Er\xe2\x87s\x0e\xd2\xeb\xeb\x81\xf3\xc4\xab%i\xc0\xbf~\x8aP\x90\xd5%\x90\xdc\'\xa2\xe7\xd9\x07\x7f+\x97<\xbf52x{\xedO\xb5\x84e<\x891\xdc~\xbd\xa5)\xfe\x03\x93\xc9\xcf\xd7\x0eg\x01\xad\xfe\xc9-\xf0]$\xbd\xf2.\xc6d%\xd9\x85\x04\x9c\x14{r\x83o\x80\xdah:\xe2\x85\xc5\xa2-\xe8f\x92\xfbN{<\x89\xd7\xc8L\xdc\xc6\x11/k&t\x855l\xdd\xf8oY\xe5o|/\x1cGV\xc21\xc3w\x01F-z\xd5\xd6\xcd\xd9\xde\x1d\xa7k\x99\xe8i\xab\xff@&\xa8\x0f~\xc7\xee\xf8\xc2\x88\xf7\x925\xf0\xb5\xaa\xb0\x1b\xaa=\xe5t\xd9\x0e\xb7c\x9c\x15\xc6\xa3\x8a\xf9#\x89G\xbc\xed%\x1b\xd6\x96\xf6\xcd<\x94\xe1V\xa4\xaa:\xdf\xdc\xb5\xf3\xa5T\xba\xbc0\x88&\x8bf\x1b"\xf4\x04\x8b\xdb\x08\xc1\x1c\x16\xfa\xd2?\xf2\xe2\x93`S\xcdr4=\xbcM\x11\x99\x99\xdb\xe9\x83m\x99\xad\xb1\x7f]j\x934\xebWS\x83\x00\x9f}G\xdd\xf0\x19\xbfMq\x07\x7fCt\x12\xaf\x9a\xb1oyBR\x1f\xdb\xcf\xd3\xc8\x87\x7f{\x1b\xb4\xa4U\xb8\x03\xd9\x9b.\xfa\xe5\xb5d\xa7.\xcaw`Wg\xa4\xee\x04Z\xb7&?@\x10\x8eLtq\x07\xa3\x12\xafb\xc9\xc3\xcc\x0b\xbb\xf8\xcf\xdaI\xa3t\xcd@\x0e\x19>\xd2F\x8dQ\x04\xd6\xbb41\xef\x90\x9b\x99\x1b\x0bS\xf4[N1#\x9bp{T\xc5\x06}\x985\xf5wbn\xd4\x98\x03.\x81d\xbe\xe8\x1d\xccX\x19nrK\xde\xedJ\xbb\x9c\xb0\xc1a;6#\x86\x07\x02\xb7\xc7\xffm\x99t\xea\xa1WV\xc90V\x03\x13\xfa}\xb8\xae\x00\xc2>0\x9b\x82\x90\x9a\x90\x95\xaf\xa4\xa7&\xce\x9a\x04\x81\xa1\x93\xf9U\xeep\x05\xb0\xd5\xe6\x94\x81\x08\xa1\x12\x9byZCNk\x18g\xbd\xaebm\xf2\x8c\x91\xe7\x86B\xcd\x06v\xe8Q6\x048\xfc5?|"\x16x\xe0%;\xfe\x01\x84NE\\\r\xb1\xad\xe0!;y\x93\x7f\xa6>i9\x92.\xff\xe0A\x05\xfb;_\x9b\x009\xe3#;\r\x03\x877\x1a\x02e\xf2x\xef}Q\x02(\xbd{\x17\xb8\xa9x\x9b\xf9\xed\xb0R\x1d/\x05\xca\xb1\xcb\x10\xcc\xb4\xa3r\xea\x0c\xc9\x95)\xb1\xd1\x9f=^\xbb\x99N\xef\x04\x19\x11\xf4"\x10\x91\x95L\x8fj\xac8\xc5\xfeQL\xa9*vL\xef\x1e+z\xa2\xcd$\x7f\xb4CO\xa71\\\xc7\x81@\xb2\x82\x13\x8ed\xca-\x9a\x9a?c\xa7\xeb:v\x00!\xe1\x83dy\x87\xb6/\xc6\xce\xa5\xe5\x13\xdb\xa8\xde\xc4T\xeb]\x16\x82*|\xb8\xe5\x934\n\x1c@\x1e\x9fY}N!\x19_\xff\x0f\x8e\x1a\xd9\xbeD*\x0f\xae\xfd|\n\x91\xa2\xda\xd6\xc5\x04Z\xecq\n\x11\xcc\xbe\x93\r\x1bX\xb3M\xf4[\x9fjt\xb6\x1f\x8a` \xb110\xc2K\x8c@0\xf9g|\x7f\xea\xb0\x1a\x0e\xb57\xd9W\\\xef\xdf\n\xba\xc6\xf21\'`Gu\x9f\x04\x0b\x0fM\xcd;\x9fX\xec7\xc1d\xe0>\xda@\x0c\nT;:a\xd8\x8e\xae\x83\x0f0\x99j|\n\xda\xa0 \xbd:\n\x11\xc7J\xcd9\xd18JE\xdf\xd7\x0b\x02F\x0fV\x07]ql@\x04\x0f\xbd\x94\xe1\x15\xab\x89\xd4\xf8`o+\xa3\x9e\xe1\xa1M\x18S3\xdc\x88\xc2\xf5M\t\xa5\xb3\xca;\xe0YY\x16\xf2\xdc~\xa4\x1f\xb5\xd6\x9e\t\xe8NhQ\xfb\xd1\xbeo\xd1\x07\\rl9\x82`\x97\xad?\\a\xf2z\xc3\x9aY!Bo\x00\xfaeHe\xc7\xf7\x9a?2\x1bu\xaa\x86&\xa4\xc7\x0c\xf0\x9c\xf5E\x8bZ\x8e\xffHr\xddMoi\xb2\xbc\xfa\xb0\xc2\xb6\x7f}\xae?\x15/\x9aY\xe9J\xff\x9f\xdc\xe4\x85\xf8v}M\xa8G\xaa\xf6}\x8c\x85\x8a\x83\xa7<\xcez\x08Y\x8c\x88x>V\xae\xa7\x0f\x01\x18eo\x1e\x08<*\xb8\xe0(\x93\xbeK^\xde\xcb\x00\xde\x94\xb90W\xfaQ\xe2]p\x98\xa4\x7f\xa0d\xa5\xc1\x8eh8I\x06\x7f\x9b\xc2\xc5\x0f\xf2\xe5\x15\x0c\xb9\xb5\xfe~\x1b\x08\xbc?\x95\xb6\x9f \xbe\x8d-\x7f\x00%\xdb&^\xf7\x1b\xe3\x18\xd1Y\x9b\xd9)D"ry,M\x1d\xe7\rD$6\x13\x83\x10\x9c[9v\xa6G\xf7R\x9e\xb4\xf0\xc6\xa2;\xfc\x1d\x91\xa7\xcbz\'on\\@(\x82\x01\xe2\x87\xfc\x82\xdd\xf0\x01.\x0f\xa5\xd1\x11\xe9\x9d`\x9fd\x8e9\xc0#\xc2\xab\x91`\x8e.\xec_t\xdb\x8e\x99\xe9\xd8\x8eS\xb1\xb0\xe6o0\xaf\x9e\xe8\x19\xa14\x04v\x129\x17gw\x89\xac\xfc\xa5m\xbf\xd8[45F;\'\xafe:P\xab9\xc8\xf7\xd7\x1d\\\xc5\xa9\x985\xb5yN\xb4\x8a\x8f\x99\x89\xe3\xd4\xc7\xe4j9\xf9\x8d\xea\x13\xd5@\xc6:} V\xf3\x99\xf52fueWf\xe6\\\x92\xa3\xe8+9\xa6&,Y\xe3z\xc6\xed\x8bj\xb2\x9c\xaaO\tP\xb6Q\xd3EXL\xa4/\xa0\xdc\xcf\x85z|-\x89\x01\xc3\xf3\xe1\x1dI_^\xbdB\xa7\x05\xa1M5\x16a\x17t\xd9\xd2V\xda5\x18f#EL\xa4\xcb\xb4\xa0\xc6\xa6+\xd6W\xf9uY\t\xbf\xe5\xfcR`\x8f\xb4\xe1"\xec\xf7\n\xc7\x08\xbd\xf79iq\n\xe9\xbeSWzC;/\x94>\xf79\x1d#\xd0\x8d\x8cLK?\x92G\xa4i\xba\xa7\xfb\xb1\xb3\xfe\xecx\x0b\xb4\xd3DR\xb7\xd6\xb1\x04g7\x0fV\xc9\xf9I\xccz\xfa;\xb2\x19\xa2\xe5;|\xdbJ4v\xb6\x95\xcb&\xe0\xea\x06\xcbn2\xf1m\x17\x81\xec\xff\x12\xb9]\x8d\xdb\xeeR u\xceA\xe8\xc4b@\xc7\x19\x7f2\xf9\xe74\x9e\r\x81B 1\x9e\xe7\x1c\x97\xc3\xab5\xd0\x90\\eW\xfe\xf5\xc1G\xa0\x18!\xa6>\xed\x8bx(:\xfe\x0f\x95\xf8\xf2\xd3^\x03\xa7;\xe7\x8aY\xeb\xa7\xe8\x8f\x89\xc8pOov\x14\xa8F\x0e i\xf1-\xe9\x98?\xf4\xfa\x9a\x103;\xe3\xe1\x13kc\xc2\xbb\xccT\xfd.\xa5\xe5\xdd`\xe5s\x06e\xb6\\^?x\xa5\xb0\xe2\xb8\x18\xf6\xc7fm\xf6\x8d\xf8\x17\x19Y\xb4\x15\xba\xd5\x86\x12\xed\xfb$a\xf3\x12O\xdc\xcd(\x08\xba\xa3\x9a\x9b\xe5\xfc\xe6\xd3;1\x9b\xdel\xb6\xbb\xc06\xd3\x9a$\x0f\x1a\x84\xaa\x02@\xc3\x04\x8eN\xb8\xdd\xf6\x85\xb2\x8c\xe0\xf9\x1bk\x0c\xd7\x19\xf2\xe1E\xa4kZ@\x17Q\xd9h\xaf\xb6\xcdW\x11$\xca\xe7\xe1\r{\xe5\xa0\xf0\xb0\x06j\x1ed]\x10(\x04#\xb5\xa0Eg\xd3\xdb\x9b\xf1\xad\x11\x17mS\xa0\x9eD\xa9txd\x7f8x\x85\x86\xc1-k\xab\xb5J\xa9\x06\x1f\xdf\x9aD\xa8RI\xbb\x0c\xf5-\x04M\x1a}\xfc)@\xc4U|C\x03K\xb4\xa3\x14s\xd8\xd8\x80w\xa2\xc0X\xc5G\x9c\x15\xf1\xaa\xc4\xa8N\xf9\xf5X\xfa\x93\x0f\xf2?j\x07\x87gk\xdf\xfc\x9b\xbc\x8cm6F\xbeB`\x9d-<:"\x7f\x1a\x9c0\xcc\xfd5\xf6\xb7$\x8e\xa1\xdc\xd8)\xb6#\xa9\xeb\xed6$\x87\x8f^:P\xf5\xaf\xfdH\xda\xf1Y\xf1\x13\xbfv\xbb\x94\'k\xbfw\x02\xafJu;%\xf3>\xc8\xf6\x99\x8f\xfd\x03\xf4\x0b\xbb\xde\xbeS\x02W\x94\x92\xaej\x89\x8c\x18\xad)P\x1fJ\xaaw\xb6\xa9,\xfb\x9cy\x11\x94\x85\xa1,\xc6`\xf0O\x8d\x88=j\xd0\x08\xa75M1\x84\x0b}\xf4K\x90\xec\xb9\x14\x85% 3\xb9\x00\xa1\xb2"Z@\xfc\xa4p:}&\x02\x0b\xf3O6\xff\xb3\xaaS\xf5\xc9T\'\xdf\x8d \xc2z|\xf6k\xda7j;i\xfe,\xf6\x96\xff\x15\xca\x1dD\x017{DQ|B\xcb%\xfc\x8a)\xa4\xb4z\x91\xc2\x99\xc5\x84\xdf\xb7?V\xb0\xba$[|\x83\x030\xd6o\x94z\xbd\x850\xadM\x06i\x81\x02\x97\xa9\xe5a\n\xb8\xad\x8a\xb8\x93\xf9QE[\x82l\xca|\'6\x0f\x92\xf23\x1b\xe6.P\xb1\xc7d#I\xd0\x12\xf8\x1eQj\x00\xc8n\x9e!\xfb\x0f\xa4\xa1\xbf\xaa5\xd0\xea\x00C}\xec\xb33\x01J\x97\xf7\xf8\xc8\x11\x88z\x82\xe7\xe3\xd9"\xd0:\xed\xbd\xf1h\xa2OV\x02[\xaa\x82\xd4\xff\xb3\x87\x8e\xeb\xa9(\xb8\x9fM\x81\\\xc2;"\xbe\xb6\x06\xb0:W!\xf7G\xf8|c\xf6\x88$vr\x1c\x9f\xcfU"<\xe4\x0f\xec\x0c\x8bI\xa3P\xd7\x8f\x9f\x14#h3#\xcf\xd0Z:\x1cW\xdc\xb2\xbb\x04w@\xe2\xd1]\xa2A\x9a:\x0f\xc6\xa1\x11\x03\xd4\xb4}-h\x92\xac\xd9\xc7\xeaa\x15f\x92S\xa7T\xd6"3_\x8e\x06c\x89\xe6@D\nV\xa8\\\xd3d=\x17\x1e\xa5X\x10a\xbe\x08\xd2,\xf2Y\x9f\x8cnl\x84\r\xe9\xa1MJ\x8db\xb2C\x96a\xd0^{\xba\'_f\xea\x8a^\t\x0c\x9es\xa5v\xb3\nG$\x08k\x18\x0f\x93\xe5\t\xec\xd1+/\x0b"FR\xfa3\x99\xb7\xbe\x1d\x9f[\x9b\xda\xe0E\t\xd0\x98\x1e\xb7\x903\xe3N\x1e-\xda\xe5Aw\x9f8\xb5\xd9\xe5\xc7Y\xde/\xc4LM\xa6\xc7\xe1:\x95\xa3\x96#(\x85\x80qh\x12a\x15\x08j\xf8\x01\xc9R\xe6\x8a%|ZL\x88\xe6\xfa+\xee\x13x\x9a\x1eM\x82\xa7Y\x9f!\xa9\x83\x06O\x94\x83(I\x81j\x8c7\xc4\x9eA\x1b\x87\x86\xe0T\x0f\xe4\xae!M\xcf\x97\xfd\xb8\xdc\x0f\x9bm\xc2\xa2\xb8s\xf75#\xfc\x07\xcf\x8a\xaf\xfa\x85Z)\xdd\xea]\xb7\xeb\x93\x94\xa6^\xe7\xfd%\x8cZfJm-A\xef\x0f\xaf\x81\t\x15\xb1\x0c:U\xeb\x1e(\xd1\xc5\x8f\xb3\xec\x88\xbbb\xe0\x0f\xe6px\xf1\xb00\xabI7\x10\xa2SH\xa1eG\x00|Io\xfd3\xf9C\xdf\xb9%\x9f\x0f\xc0G\xf3\xd0\x80\xa4o\xb3\x85X.\xfa\x0b;\xbe\xbc\xed7G\x1f\xdf\xef\xc0BV\xf9\xc1\x1e\xd0\xe3\rq\xda\x9d\xf4P\x19\xc6{\xd8\xb4\xfc\xaf9,\xf5\x15V\x88=\xd8\x10\xbd\x10\xe6\xc4\xbb\x86\xbc\x88\xc7\x04Z"\xe1s2S\xdb\x08:OK\xa5$\xddC\xfb\xc6\xac\\\x85\xd2\xe1\xf1\xde\xa6\xd1\x07^\x94\x1a\x7f\xf9}\xcbmLD\xdf\xf4ju\x7f\xa6w2\xab\x84\xa7\x9e\x8f\x92\x9c\xad\xc0CD\x19\xe5\xe6\xd8\xd3I&\xfc\xde!8\xbe\x87\xb5<\t\x83\xa5\xbc\xbc\x12a\xcf$NF\xe3\'\x157&\xdf\xa54\xb7^gM3\xfb\x95\x95\x90\xa2B"\x9f\x01h\xba@\x97\xb0\xf0,\x97`\x88\xaa(\xed\xc3.4q\xee\xb1\x08\x93\x08\x16_\x18*\xa3\xf5\xe4P\x8b\xc9}\x065\x8c\'\xd3o5\xa4\xefi\x95!\t\x02\xd3\xe7/\x95\x1e\xa6\x9f\xab\xf7i0\x99\xfa\xabw=\x86\xd8\xae\xee\x9f\xb1\xd8\xb5s\xa9\xcf\x10;\x1c7\x14\xad\x04\x1d\x83\xcaK3pGx\x98\x05\xd7\xbc\xbaR\xdcE\x05\xdc]"\x1e\xbc\x82|\x802\x07\xc3m\x9f\xb5y\xaaD\xb1"]a!<\x96\xbc\xa5\xce\x13\xee&m\xdb\xde\x85;\x92\xa8#\x9a\x98\x88 L6\x82\x9b}[\xae\x85\xc8\xcc\xe8G]9^_5\xda\n\x86#\x88\xf8\xd4\x0eb]\x9c\xf9\x9cY\x07\x03j\xdcD\xad\xd9\xf0\xb2\xd9\x7f\x1a\xd0\xf3\xbb0\xb6\x01\x17\xd8\xeb}\xcbf\xdbq\x98\x07U\xed\xe3\xe0X\xf4\x91\xc2\xf7\xe4\xde.jO*a\xf2\x7f}\xa8\x88\xdd|\xcc\x1dF\xe4\x83\x82\xda\x11\xda\x0e\x9c\x17aq\x14\xa3J\xca\xbc\xa6\x90P\xb2\xa6j\x14\x89\xde\xe4\xb3ep\xf4\xea8X\xefZ\xa8\xfc$\xd7\x07\xd7\xd9xZ\xa3\xf2R\xccB_\xcb\x83\xd9\x03\xb4/\x83}I\xd0\xc2\x8f\xa2MV\xfdr\x90\xad\xa0\x12\x85?\x10\x88\xf8`\xbd\x96{;\xa7\xb9|^\xc4\x13\x1e\x92A\xaa_Z\'z]\x7f_\xa8\xf0\xf7\x84\xe7\x1d\xf38\xd8dn\xe3\xfaS\x16\xe1\xb4+\xb2\xcd\x8e\xcd&-Z8v2\x8fk\'\x10\'\xf4;\xb1\xaaj%_\xac\x887\xbe:\xe3\xebF\xbc\xccb\xe0\xa9\xc7\xbb,\xd6\xaa\x8f\xd4\x14\xf9\x9e\xb4|\x01\x9a\xdd|\x13\xd0AzoU\xda\xac\xf6\x81\x95\x1b(i@\xff\xf6b\xbc>Zx/\x11\xac\x89\x87^or\xe9\\\xdb#\'>[ \x91\x18\x8a\xd4w#BO#\xdc"\xa0\xd9\x96\x03\'S\xbd\x89P\x9d\xbb\xc0y\xdf\x83b\xba\xc8\xfe\x06\xe5\x9eI$\x8c",\xbb\xda\x8a\x1c\x02A\x8a\x98\x90$\x95O\xd8\xbd\x8d\x81\xf6\xb4\x8bN\xd3\x0b\xc2\xa4\x0c\xdc\xc5\x99\xf4\x18\x9f\xc4<\x82\xfe+\x15\xfaz\xb4?u\xef,Z_\xc4_bv\xd7\x11q\xfd\xf3\x18&te\xef\x04q{\x18\xce\x06\xd2g4E]\xa6\xcb\x0f\xab\x95\xde\xa5l\xa7\xf2\xb9\x89\xd7\xc0\xe2\xa5\x9d\xdd\x9e\xaf\x1d\x00\xa9\x07#\xf4\x1e\x03\xd0\x1c\x03 \x8aKS\xf8\x94\x1b\xb2h\xd8\xe0\x04\xbd\xf1\xb0\xbc\x82\xd20\xfds?\x06\x19\x00\xaf\xa6\xb4\xaf)1\x00\x03\x1b\x98:\xb2\xecu\x7f(\x0e\xa7Y\xe7[\xdc\xcf\xff\xc9\x8e-\xc0\x04\xc1X\xed$\xbb\x0f\x86\\\xe3\xb2_\xc2\xe7\xc9_V\xbbv\t\xef\xec\xf6q\xa5\x81JW\x8c\xe3\x93\x9c\x9e\x05\x95}O6n\x18\x90\xb9\'\x04\x12\x089\x81PK\xe4\xc2\xf8\x0bt\x1f\x85\xb4\xa7{;\xd1M\x105\xb1\xabO\xdd\nx\xef\x82\x98\x97d\xd5\xf4\xd1\x9d\x89)\x87\'\xc8\x19d\xdb\xd5^\x89\xc6j\xa9#\x92I\xab\x92\xa5E2\x03e$\x9f\x86\xd4}\x14\x11\x8b\x91\x03}\xf8\xd0\x7f\xb4m\x81\'PX% \xc6\xa5\\\xf5:\xed\x046\x9c\xe9\r#>\xe5\xa0v\xb1\x8c(\xc8^"o\x04\x8eB\xa7s\xe28b\xa6^\xe1\x89\xfbk<\x02\'\xfd1\xe1\xe3\x02\xa6\xe8\xd2M\xe3v<\xb1\xa0\xfe\x9a\xbd\xad\xc3{\xff\xbf\xac%\x1c\xed\x1a\x17\x88N\xfb_]1\xd7:\x88SP\xe5\x9a\xa2^w\x10[8\xf6IF\xc9\xfbD\xb8\xde\xd9\x83\x8aOqEY\xf0z\x15\x19\xf9#\x8b2\x8fC\xe0\xf3\x8dN^\x96\x85\x94\xe3ly\xe6\x13\nz o\xe9\x16\xd5\x85\t\xcb\x02A\xfbl8\xe0\t$^P8\x027\xa7\x17\r\x98\x94O\xa2\xd0\xad\xaf\xc6\xbc\xa4\xcda\x80\xc5\xc1\xe3\x16&\xc75j\xf8\x9b\x8a-\x07\xf4\xec\xc83\xfb\xadS\xdd\x84\xbd\xcc\xcd\x08\x9a\x7f\x13\x1d\xe6\xccO5\xcax\x1a8|\xfb\xac\xec\x906h\xef\x97u\xf5\xf8\xa2\x18\x86-\xcf:\xe1.37\xae\t\x8a\x83\x936)J\x0c!6\x16\xef9+\xe8k_Mc\x88\xc6\xffg9G\xaer\x80Vzh!Y\x00\xa1W\xf2\xd18u2\x9b\xac\xb1\x00(\xca\xdaM\xbd\xcb\xaa\x05\x8b\xfbHs2&\xa0\xae\x01]\xd8\xf6_\x88\xc9\n\x1e\xdf\x88J\x0fl\xf1\x82\x925\xbf\x0c\xc6\xde\x06\xf9tJ]\x87a\x8f\xb4m\xca\xa0\x7fo6>P\x17\xe9\xdb\x08\xd9\xd9\xf4\xe1\x18k\x86(w\xb7K\x85\xa2\x1d\x8dP|+\xda\xf2\xb8U\xa7\xe4\xb0\xf4\xd9\xb0\x10m-\xd0\x8dx~\xad\x9eq"}\xf2\xa8\xbe\xd9\xee@D\xaf\xfe\x9e\xf4Z\xe2\x8f\xb3@\x0f\r\xe7\xc4VB\xb0\\\xb7\xe0O\xaa\x95f\xea\xa4\xa4\x9a\xa7|\x9c1\x0c>\xbc\xba\xb1\xd5(\xf9\x08\xfeQ\x9b0\x8c\x12\xe3\x18\xbc*\xf0\xfe\xa7Tz\xbd\x01\xb6\xc3\xb71\xec\x91\xcb\x04\xf0}\x8dl\n\xe7\x1e\'\x1bu\xfc\xd9\x0ftfLh\x89\xc9w\x1f\xe0V\x91\xacQ!\xa9\xb1\xbb\x11\x93\xc9\xdf0\xc5\x0es\xf1\xac}\x9f\x04\xb9\xee\x8f\x0cc\xdd\xae P\xc7\xb3;}\xc0 \xc6K\xe7\x9fZ\xe3\x85\xa4GYf\xd51{\x10\xc0\xecEH\xc9\n\x10\xd9\xd4c\xf1\xba%\xc1\x0bH\xfbK\xe4\xe4\xe5\xd18{.\xa6\xf87\xf9R\xf9\xb3\xb8\xeb\xef\x0f\x97\xf8\xb1T\xa4\xdc\xe7<]\xecM.\xe6\xae\xb3\xfe$\x1d\xb0\x98F\xcb1\xff*\x83\xc8\x13|.W\x9d\x05\xceKe\xa0\x13Z1\x1d\xe5\x07\x07@\xc4\x85\xab\xb9\x95*\x99\x06\xc0\x02j\xd6G\x1f-p\xf9\xa0\xa7R\x99"g\xa9\xad\xafQ\xef\xb0\x12\xefZ\'\xd6\xa7\xce\x94\xa8]@\x0f\xf7\xb6\x8ep+\xa0e\xf4\x19\xf3n\x89_v\xbf4\xc0\xfb\xe9OI\x86\x8b\x8f\x9d\xd7\xb4\x94\xfe"\x00?\x14\xeb\x18\xe8/\x81\xe9\x11\xc7\xa1\xd9D\x9c\x01\x1c \xeeGF65\x94\xe62W\x1c\x98\x05\xfd\x96\x01N\xadJ^\xbdl,L\x10\xfc\xdd\xde\x1aO\xcf\x88N\xe5sq<\xaa\xcb\xf0\xec2v\xeb\xf5\x9e\xc6\xab#\x89\x176\xd3\xdd\xae&U\xb8\xa0\xff\x04)\x9eD\xa7`\x89\xf4\xbe\xb3\xf9\xbd+[\x06\xc6\x1a\x10{\xe2\xff\x13\xc5\xf6\xcbS+))\x8c\x9a\xe8\x1d!\x89C}Hv\xacu\x83|S\x8f?}\x95\xd2\x0f\xaeVGFY\x99^R\xaf\xf4\xd6\x03@\xda\xec\n$WX\xf8\xeb\x1dk\xec\xdf\xfa\xddR98\xbe\x91/\x86\xffJ\xfdU\xcc\xc9\xb9\xff#>Y\r\x18\x0c\x12\x8c\x05\x13\x83\x85\x13\x03\xa4\xcck\xd3\xf0\x91\xa5=M\x85\xd8\xb7\x1e\x1a^l\xc6\xd90\x07\x9c\n!\xc4\xd4l\x1f\x87`\xbc\xff\xf8Y\xb8\xcd\xf2\x04\xfe\x04N]\x9cd\xc3k\xaeW\xb9cF$\xf9\xcd\x14\xf9\xf7J\x82\xadKF\xee\x14\xb2F\xfd\x0b\xf7\x92\xbc\x83\x96P^\xd5\x9bC\xa2\xd5\x9d\xc5\xbe\xd6I\x1a\x01fq\x0c\xed\xb8~\xc0`\xf8\x94)%\x89\x16\xd8\xfa\x95\x04\x9b\xdd\xf3q^ \xe8\xbc$R\x9dz\xd1\x14\x10+0\xf1HJ\xef\x1d\xb5\x87h\xd4eF\x0b6_@\xcd\\\x1a\xd8\xc7(\x92(\xa8b?\r\xf8\x86*\x13\x9fv\x11\xbf{\x02U\x93y\x0eV\r\xf8\xa5\x9b7\xb9\x9b\xad\x91\xce+\x0e\x00\xe0JY\x01\x98\xc8\xd7T\xd6\x9dF\xccZ\x85\x89v\xf7\xbb\x8a\xe3"\x10@?\xda\xa6\xe3\xb0\x11\xde~\x9e0\xb8Xsh\x06i.y\x07\xe8\xb5\xde2\x89\xdb\xddMF\xce\xc8P\x1f\x01d=\xee\x89\xabd`\x8c\xf9\x13\x87\xc4JkC\xf7\xf1GH\xc6\x86{\xd5\x11\xbf\x9bR\xb5\xd7,N\xb8Y\xf8t\xe2\x88\xa4\xd4\x98\x1aKaV,\x00\xed;\xe6\xa9&}+\x88\xaf\x05\xef\xdb\xfc\xe7\x8a\x9b\x0c\x07\x95\x13\xb2\xcf\xc761\xed,\xe4\x9b\xc8c=?\xbb\x1a\xe4\xfd\xb1\xe7\xb17\x1a\x89-b\xb2\xdf\x9b\xb9\xe7M\xdeT\xc3\xeag\x9f3g\xfd)\xa2\xd47\xca\xe9)\xd9\x15\xae\x98\xfeq\xce\\\x8dt3_\x00\xb3\xdb3V@*\xaeG\x90\xf4\x95\'JjX+\xcex\x11\x02?\x97zT\xf2ic\xb1\xded\xb9I\x17\xa0\x1b%\xe5\x02\x90yh\xd1\xd3\xaa\x04=\x0c\xb0\x9bJ\xecr/\x84\xb7\x0b\xa3l(\x90\xf0|_\xcfz\xdaL\xb6\x10\xe3g\xceq\'\xcf\xd5\xe1\xea\xab\x14\x1bd\x17\xc9\xa5\xfd\xc3\xa5/\x80\xaf\x1fwx9\xcf\xe2\xefd/\xfa]\xe6\\\xb5\xc3\xf4.s\x837\x1e+\x05\x81\xa1I\xca\xc5\x8d\xcfc~Y\xb3\xa7\xcf\xafSP{M\xb3fx\x9c5T\x8b\xef\xb2u\xc2d{\x86\xa2\xb9\x0e)\xc3\xecd\x16Lj\xe5\xebsm\xcf\x92p\xfb\xf1\x99\x9d\xd9\xa1\x8c\x7f\x878\xd2t\xbf\x1b\xc5\xeb\x80@xg\x11\\\xc0\xfc\x0cr\xe8&\xb4?\xd1P\x15\x15\xae\xe52\x11\x7f\xdc|\x1e\xaen\x19*Pwl\xde)\xd2\xb5\n\xe4\x88j\x0c\xd4b\x1e\x0cw\x9d\x15\xac\x1f\x7frs\xe0\xe1\xdbY\x05\xb7\x98T\x11#k\xcf\xe9\xcfu\xc6\x95\xb3\x8d\xad\xb3\xb5\x94|c\x88n\xf3\xa3\x94\x17\x85\xc5\xb7s\x02lMl\xf7\x02\x80\x8e\xd9\xaaP\xc5\xd0\x05.\xd0\xff.S\x86(M\xe7\x8e\xba\x91;\x9f\x1f\xc4\xbe\x82\xc1y\xd6]\xa4I\xb4x\xed\x00]U$\xc47Yv\xc3\xads\x92\xccI$P\xc0\x10\x00\x9e\x93n\x0e\x95\xe2\xefb\x925\xeb\xfbt\xb9\xbb\x9a?\xe2\xf7\x97\xdbw\x80\xe9\x9a\xed\xa1\x92\xc3\x0b\x93\xd0X\xca^ \xffX25\xfc\xfc\xc6\xff\xf0\x03\x89\xf1\x0b|\x1c\xd4;\xf82\x89\xc9\xd3-Q`\x07\xb6\xcb\x9c\'\x1eA\x91\xa8E\x99N9&c\xda)\x08\x1b\x8a\xb9\x19\x9eF\x9bU\xd9\xc9\xffgr\xd0\xab\x1eD\xa3\xfa"\xf9q}[HK\xf4\x82\xa0qn5=:61\x90$\xe6\x10\x13\xb1\x16\xa1\xee\xde\xe8\xd8\xcd9\x01\xd5 S\xa4J\x16\x8b\xcbr]\xc5\x17\x15R\xfa\x9d\xd6\x8a-\t\x90=nP\xdf\x9eSO.\x7f\xc2\x10;AU\xa8\x1f\xd0\xe4\t\x0b\xaa\x10K\xe0\x87\xde\x07\xac\x80\xc9j\xf4R\x04q\xb30\xac\xe6)\xa3\xdc\x99\n /\xb5\xcc\xb4h\xcdF\x9fa\xf5\x02\xbdD\xab\xd2`\xf1\x92\xb3\xeb\xf3\xf1\x92-\xc3{d*\x90\t\x06h\xa3,\x96\x9a\xe2\x18\xddv&|\x1a\x14\xd2\x98\xe73\x8dJ]]m\xfa\xda\x97\xb6\xe3\xf4\xd669Y\xc1\x02/\x84\x86\xa9 \xab\x85\x16\xb4\xd2;2\x10\x10+\xb6t\xc5al\xa9\xc8\x163q\xef\x154U\x93\xeb\x98C\x07\xd0\x94\xca\x94\x84\x88\x82\xa5\xd8\xf6\x97\x1cZ7Y\xbc\x98U\xfb\xd5^\x1e\xe5\xf4\x86\xd1\x80\xdd\xb3#g\x8a\x0e1\xd7n2\xd2\x8b-5&\xf8`\xcf\xac9\xc9\xd2\xa7\xd5E\xdf\x04V\xd8\x0e=c\xf4\x87\xce0\x80I\xa0\xbb\x15\x88*\x7f\xee\xfa\x16d\x11 ym\xd7>\xfe\x8e\xd3\xe1\xec\rH\xae\xac\xa7\x16mT\x1f\x13eI\xa0\x9d\x99Wx\x08#\x82\xef\x85\xd5\xe5\xbb\x0f\x9b\x90\xf0\xad\xc0\xbc\xbd]q\n\x80\xfc\xd1\xeb?\x93\x92\x97\xa6\xf5\x83\x05s\xd6\x0eG\xf3\xc5*\xf6\xb1\xb4\xe3\x9c7\xf9R\xe6\xaefv\x0e\xe4\xe7E-(\x93\xd5b\x96\xc6\x8bP?+YqKy\xb7\x1f\xe5~\xb7"\r\xf5\xf4\x9eR>*~J\xf5sm&\xee)G\x95\xe0d\x93\xba\xe1=\x9fzg\r\x1a.ut\x7f\xf6\x19\x1f\xa4\xfb\xadS\xa6G\x94\xc6\xe5\x8f\x02\x1e\xbd}V\xf1\x19\xdcb\x82\xf4`\xf757\xbc<\x8d\xde\x95P\x9a\xf4\xe5\xb6\xdd\xeb\x02\\\xaff\xcc:P\x05\xe4\xc7\x0em\x13\xed[\x81;\xe5\x94\x15\xec\x8b*>7\x1eqj\xfdq\xd0\xf88\xf3qB\xd5\x06\x8c5\xff\x16\x89\x9b`\x9d\xbd\xe3\xcf\xe8\xb9r\xa8&a\x01YO\x1e\xf2D\xef\xdc\xb7\xa6\x06\xb6eC\xce\xf4\xe8\x9c;h\xbd\r\x0c[!\xdcM\xd4\x7f\xdd=\xad\xdc\xb0\xc8\xd9\xda\x01Qp\xe1\xaaW\xdd\x8aB\xa0=\xc2A\x17\xa0\xde\x9b!\x98[\xad\xe2C\xdd\xa6J2M\x8e\x1e\xae\xf9\xd9\x7f\x1d\xa6x\xdd\xea+b\x13\xc4?\xa2C\x12\x9bu\xa0\xb1\xef9<\xc7F\x05\xf9%\n2\x03~\xaaR\x9b\xa8O5<\xfa\xa0\xa0\x95\xd7V\xa0\x122\xeb}_=7\x80Y\xa1\xa5\xb7\x9a\x9eu\x05o\x18\xd9\x8f\x1d\xf1\xfa\x06\xaa\x05\x94\xb0\x87u\x05\xf1\xdc\xa3\xc3 \xce\xc5\x1bsh\x97(\x9d4\xfc\xbe\xb1+~(n\xe0/\xac\x13+\xb26\x1b^\xfe\x0fc&^.\x06\xd5{\xb1\xa8x\x10K.\x8b\xd9\xb6\xd4a\xd6\xb9\xd84\x06\xeb\xa0\x19\x1ex\xbc\xee,\xadF3D\x8e\xbb\xe8\xd2\xee\xf9\xed^') diff --git a/collector/core/gripper/sightac_sdk/api_new/sensor_gripper.py b/collector/core/gripper/sightac_sdk/api_new/sensor_gripper.py new file mode 100644 index 0000000000000000000000000000000000000000..928b642173c07bd134da1e7b0db0979398254da1 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/sensor_gripper.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:48.062364 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\xf5s\x00\x00\x12\t\x04\x00\xc9D!\x85O\xc7\x1a\xe56\xbb\x80&\xd42}Q\x00\x00\x00\x00\x00\x00\x00\x00\x8ccVH\x02{r\xff9\xa2N\x8e\x02\xaf\x83v\x8a\xc0\x8b\x7f5\x12\xff\x06\x93A\xfd\xbd\x86\xe4\xbd\xd3y\xf2\xc2x\xdc\x99\xcf\xe4\x9aU\x8d\xd3\xf7\xbb\xea\xe7}\xa0\x99\x1a\xacE\x17\xa2q\x06\x8c\xa8\x9a\xcd\xd6r\xce\x82\x13\xff\xda\xbf\xdd\xb0\x90f\xbf/`31\x8f\x0e\xce]\xa3\x0e\xc4\x99\xa8\x9d\xe5\xbeq\xb8k\xac#\xa7\xcc\x7f\xda\x9aMM\x86&\x0b\xa7q[i\x15b\x1a\xdc+\x0e\xba[\xfe\x1dM\x17\xc3]\xfe\xf0%75\xf0b]\x91\xc29\xc90\x9b\xb4\x9d8\x81\xbb\x94\x15\xc1\xce\xe5\x808j\x91zs\xb6Xj\x84\xcfa\x07\xc2e\x85\x91z\xe8\'\x1a\xae\xab\xcbw$=\xf1y\xef\xd2\xa79\xea4Z"x!\xd4k\xf1\xd8-\xb2&s\x8b\xeau\x84\xbb\x03p!N\x13\xb4C}_\xf4p\x8b\xaa\xe6\xb5^\xaf.4\\\xebW\x93q\xcd\xf8\x1f\xff\xfc?]\xb2\xa8\xa8\xbb\xdd\x0f\xe5A\x16B.@f\x0c\xcb[w)\x9c\xcc\xa5*\\\x00_*\\\xf0\x92\xcd\xe2\xcb\xc4\xf9\x99\x14\xb1\xb7\xf4\xb14Q\x96\xe3*\xf3F\x1e\x0bITB\xf4\x8c\x80#\xfa\xc8\x83\x80\xe3Q\x11\xe2\xcb\xa6\xe5p \x03SK\xde8\x1a\x8eb\x1b\x8aQTm\xdaD\x90L\xdf\x07zq\x1e\xcf\'nV\xe3j\xc8\x15\xa1\xa2\x16Z \x1a\x8b\x95<1\xd1\x15\xbc\xb3u\xda/i\x8b\xc5y\xae\x9dL\xc4"\xbe\xd4U\x85\x9e\x93\x84\xa6v-X\xf9\x82\x82\xd8\x01qD{$\xef\xba\x857Hn\xb5\x9e\xd3\xeb\xa3M&_l\xc9O\xde\x01:\x90K\x1e\x8c\xaf\xa8\x04\x01\x8ek\x84\x1e5\xd7B\x0e\'\x92\x86\xe8\x14^\x1ee\xf2\x16h\xc3\xdc\xf2X\x9d\xc4\x17S\xbcyat\xd7(\x83\xa4$\xc8\x08\xa5\xbb\xe3\x92\xd6\xc7\xae\xf9 \xbd\x93\xbf\x0cv\xfcN\xd2\xa2F"\x12\x044K\xce:*\x13F\x7fR\xd1\xef\x87&\x04\xc2\xdd\x0cC\xc7-@\xda\x87\x87\x11p\xe8\xb4L\xbdfc\xc4\xe3\t\xdf\x85\x99\x8b\x1a\xddE+\x83\xd9\xcf%\xbe\x81\xe1\xdb)\xa8\x0f\x01\x1bk\xf1\xfbDH\x9d\xd4\xb7\x95.\xe2\xd1\\\xeeo\xbc\x82a\x14\xae\xa1\x8cd\x8d\xad[W\x9ft\x16\xc3U[\xfb\x1cv~!\xbd\x1a\xc5\x97\x83f\xc9U\xf4\xfe\x7f\xc1 \x7f\xdb\xca\xbd\x03\xda\x83\x00\x8b=\xd4Ng\x076\x0c\x15E\x92\xa0Gi>\xecbL\x10\xfe\x8b}\xa0\xab\x0b\x95\xabK\x88\x851\x05\xbd\xe2\x14\xe4\xfe\xd13WI\xb5\x8d\x84\xe2\xbe\xa6\x8bG\xf8G2\xc1)D\xd6\x86\xa6\xf8\xc3K8B\xaar\xf6o\xdd\xb30\xafNAP\xc9\xe3h\xff\xb2\xba]\x82\x06-\x0bB\xcf\xc1\x16\x00\xd0\xb2\x14\xe5\xfb\xfc\'\xb2\xa0\xd0\xbdFT\xc5[\xe10\x92\x00\xab?,l\x9b\x8f\xd8\xc9N]\xfc\xb5+:k\xe2\x06\x14\x0b\xee[\xeawe\tB\x86\xdc\xf1$\x8f\x08\x8e\x95\xd8\x90\xb7\x94\xb8\x9f\xc9\x92\xff\xaa\xae\x17\xc7&\xce]\x9d\xef\x94T\xc5\xf80\x89\xffG\x81\xe5`I\x96Oh\xed\x15\xcd\xce<\x80t\xe1\xbd\x98l\xf9\xe5@\xa0\x9d\x1c\xe72\xde\x9a\xbf\xf6\x07\xaa\t\xa1s\xc8\xf2<\x05Y\x89\xbf\xb7\xddf\x8d^\xca\t\xd4rM\xe0\x02r\x9cm}\xc1\x92\xceiRO\x97\xe0\x1b\x08@\xee\xf8\x7fi\xa7\xf1\xb0\x01m\xa8-\x87\n\xeb\xc9\xfd]}\xe1\xde\'\x0cC\xdcC\xd4<7J\x06\'!I\xc9\xde\xb9\xb6\xa7<{\xa9\xe2\x86\x03*\xa1\x97\xfcp\x83\x18\x03\x7f[V=\xf9\xb0\x8d\xe7\xf8\x0c`O\xe3\xe8\xc0\xf3\x8fX\xb0C\x17G\x9f\xd4\xfb`6\xb7\xf0\xa4\xfa\x04Y4\x1aa|U-`/\x18\x89\x8fA\xbb\xe5#\xc4tvIr|\x06+{\xc5\xb4\xd6N|q"\x9d\xad\xdc\x1f\xbc\xf8\xcd\x0c/s\xa9F*\xb2\xa3\x06\xa7D\xf0\xd3\x1b->\xf0\x1d^\x89\xc4\xa3\xf2V!\x11{\xceF\xa3J\xec`)\x80\x01X\xa7\xc9\xac_\xc7t_\x1f\xb1\x0b\x9c\xe3\xf3\xe3\xbc\x89\xcd\xdc\x06\x8c\xc1\x9e\x9b\xae\xd8Y]\xa8\xc4A\xf2\xeb\xc3n\x85K\x8a\xd7|\x81\xaf*\x0b\r\x89U\xa7\x1eE\n\x1d\xd4`\xd0r\xc1\xab\x01q\xb2\xb1*X\xb3\xc7\xd3[\xcbc-y\xc4D$#\x90\xa4H\xb5\x84\x82;-b\x1e\n\xaa<\tZ\xc9R!\xcf\xf3\x11\xaf>\xf0\xfb\x08\xfb`_L4mlm\x8f\xec\xb1\xa2R1{Q\xf5\xce)\x91\xbf/|V\x0b\xcf$\xf3V\xcf\xa7Z\x9c\x90\x06\xbb\xc9p\xf6\x8d\x1ey\x85\xdf\xf9\x96\r\xc81G\n\x8b\x05,\xf4\xbb\x90\xf0y\xd4\nb\x01L\xea\x1d \x83\x95\x9f\x81$\x98\xed\x94x\xe9d\xdb\x10@\xe3\xdd\x87\xeb\x83E\xa1A\xe4MV\xe5@Do\xc3Y\xc7\x06m\x15@\xccd\xfd*\x87-\x83r\xd3\xaa\xf1\x1e\xf8\xa9\xd0\x98\xd18\x90\te\x02\xab\xfa\xa3\xf7q/8\xf8\xdb\x91\x8d-S\x009\xd9\xd8\x07\x15\x11\x9b\xe0\x85\xa3nR\x8a\xad\xa43\xb9@\xb20\xa41\xde\xe2\xdax\t\x94\x92\x13"O\x93\xdb\x19\xb40`w\xa2\xe0\xf0\r\x14\xd6\x87\'U\xe1\xf5in\xc0vX#*&\x1c\xf6\xd0\xc2\xde\xc1vd\x80\x9c^=P\xf0\xd6(\x1fp\xb8\x8cp\x8e\xaf\xd3\xd3e\x82\xe3\xdb\xb9\xf1u_\x91\xfd\xccu\x17"\xdb\xe1G^\xaa\x96\xaf\xb7\xe8\xa60P\xc8\xc8Z@0\xa3\xe6\xbb!p\x93\xece\xb7\xe2\x17uw\xd2\x7fi\x1dP\x05h\xaeQ\xa1\xc3\x04\xbb\x01\xa2~!d\xc1\x82s\xf5\xeb\tw$_\xd1\xa0M8\xf7\x02\x8d;>\xc3\\5\xf2\xee\xb8\xfdN\xa3\r\xc5\xa7\xa4\xc3\x0e\xf6\n\x84\xdf\x94\xe0\x03\t\xbf\x82g\xbeI\x84NR\xbb\x97\xb8\xc7\xc5\xfev\x824F\xed\xb4\x9eD#@vm\xde\xb0%\xb5\xf3\'\x12\xdb?&\x18\xeb\xb5\x1e\xd8\x17m\x82U1d8\xab\xbe|\xde\xda\xa8n\x88\x10\xfa+\x89\xb1\x92\xc6\xbbr\xbee\xa4\xd2\x89_\x91\xda\x8ai\xf0$EO).\x08\xa1M\x91p\n\xc9\x19K\x88\x10\xce`\xc8\xe6\xf7h\x07\x94[v\xcf\xe5\xfd\x86\xc2|\xcc\x1d\x88\xcb`\xab\xe5\xc2\x18\xf6\xbd\xfdZ\x98\xf9\x0b\x0f\xc2\xaf\xb8t\x15\xa2\xa0\x985\x84\xd3%\x15jd\x9fM\xaa\xc7\xd7[\xaa\xb1\x1f\x87\xf3R\xdf\xf9v\xd9\x95\x01\xf1\xa1\r\xe4\xec\xb6+\xfb\xcf=Xf\xa78D\xa7\xc8\x93\xa6\xd4\xab\x8dt\x90\xf7r\x14\xba\xb6\x804\x08p\x05\xfcE\x8d\x06\x02\x16\x14h91x,\x06gKz\t\xa5\x04u\xbf\x8d\xbd/\xc9\xb6rt\xdd\xcfEc!3A,\xd1\x0b\x9d{\xc0\x05@\xb3k\x90j\x9e\xdf\x19\x07OyA\x8e(Q\xb7\xf2\x1b\xc1\xaa\\l\xdc\x17\xbc\xcc\xd1\xc77\x91\x129^\xa26\xc5\xf4k}\x8cJ\xf6<\x0c\xdc~h\xbf\xe2\xbc\x01Ui\xf7\xd7\xd6\xb0B9\x8dA\xdd\x1c\x9f\x04p\xfa\\2:>pD\x99#J\xcfV\xd6\xdd\xb4f\xa0Oe\x8dxR\xfc\x05S\nw6B\xa97k\x8f\x8c\x1e\xb8L<\xf2\xaf\xdf\xd7\r\x0c]0\x1e\n\xa3j^Ku\x86DP+\x16\xd2\xb73\xd3\xa9\xc6BlZ\\\xa2\x8cd\x83\xf8\x9c1\xc0\xbbn8v5&\xae\xba\xfb\xf6\n\xf6\xbf\xbd\xbe"\xff|\xa8\x1d\xbc\x8b\xc5U\x05\x9c\xb7\xdf4\x07\x05\x13.\xe6=V\xd6b\xf9#\t\xeaN3R\x81\xdf\xab\xa9c\x9b\xc0\\\xf50\xd7\xfd\x02\xfc\x0b\xb8\xefR\x88\x1eY\xd7_\x8dGs\xc6QE\xafX\xf8\xed\xc3\xbaN\xd4\xe6\xf7\x0b\x11\x12\x96\xb18,\xf4\xd3\xf1\xd8v\xe3\x04+\xae\x1a\xef\xab\xedU"l7\xc50S\x83\x8a\xf6a|\xd2.\x7fx\n-\x1d:\xb0Z\xd7{\x0c\xb5\x9fk\xd7\xdc\xf3$\xd3^7\xca\xc4}\x0e\xd9F\x07c\xdd\xb6G\xe9HG\xdb\x05\x97#3qy\x9a\x99L<\xf6\x89\xe1"\xcc\xd0k\xcf\x87Hog\x1e@\xf3\xe1=\xaa`M\x99o\'\xb3$\xba\x86[&>\xe22\xbc\xe1\x17\xd2.\x86\x03t\xef\x86\xcf\xd0\x1eA\tC\x9b\xdd{\xe4\xf2\x17\xff\xfebc}\xcbq\xa1\xe8\x1bG*\xfb\xec\x9c\x1c\x89|\xe4H\xca\x89\xe2\x99\xed\xe4\xff\x07\xec\x9a%\xad\xdaL\xb6\x81=rT\ny\x89\xed!Cs\xde\xe6\x90\xa205\xf6\x87\xf7f\xd0ch\x93\xc36t\xa1.\r\xd2\xf6\xa8~\xacW\x82\xf0\xe2\xfa\xdcuLh\x83\xbc\xa0{\xf9lM&gVh\xed\\\xd98\xafU\xcf\x86\xa21\xd7\x93\x8e\xa0J\x91\xff\x0c\xccJ\xe3f\xb8FI\xf6\x1e\xfc\xbe\xb5_\xd3\xce5\xd8f>xY\xa6\xdd\xb9"\x7f\xb3\x9e\x88.4\x00\n\x8e\xf6\xe2vz\xffC\x04\xd33\xd83\xc3\x8d9?\xabb\xb2\x9e\xad\xccrFB\xfe^\x9bh\x95\xa7N\x89\xb9\x92$\xb1AuLfJS\xa8\x04\x81\x98\xda\x02$\'\x99\xc6\xfc\x14\xdfL\xebNOR\x03#\xa7[\xff\xe2s\xb8G\xf1\xecV\xd0\x91xJ\x95\r\xa6\x15A\'\x1eym\xa0\xa1\x83\xea/\x80yuP\xa2\x07\xe0\x12\x05\x07lX\x01\xa2h\x9a\x83\xa1N\xd0a\x03 k\'j\xceMs\xe7\x01\xa6\x08\x7f\r\x99\xda-\xe9F\x9e\x18\xbc\x05QJ\xfd\x9e?r\x16\xdeya\xec\xfe\xa8-_y\xb4\xfd\x85\xc5B\xecUUI\x89\x03\xaf\x8b\x12\x9a\xb4|\x14\xcc\xed\xb5\xe3\x0b\x1f\x8f3\xfd\xcc\xeb\x98\xad\xa2\xf0\xd7\x15?\x8c\xe4\xdc}\xeb\xe9\xe9a\xfd\x05S\t\xad-q\x04\xe0\xd2*\xd9\xf6\xfeZ\xc8)r\xf3\xa2T\x07\x91UT\x16\xaa\xe2\xac\xf7!\x9cE\xf1\xd5M\xc3\x03J\xc3\xe4\xe4I\xe4nL\x87\xc3}\x10\x06\xf1\xear\xb5D\x81I\x9b|\xc1\xb3\xd7\xd2FB\x8d\xc5\xefZ\x10\x956%\xfb?\xac8#\x85s\xab\x15q\xb9\xfc\xf6\xa4\xce\x05\xd1\x1a\x10j\x92\xd8A0\x94\xd4\xfe$\xde\xac\xb8\x06\x10l\xc673\xfeh\x90\x19J\xdb"\xd8tf\x0e\xc2Q\xd2\x107U\xbe\x18\xd2\x03\x87\xaf\x1bU9\xde\x18\xbe\xd3\x05\x97\x94\x01\xe5\xe0K5\xa1\x00\x15WR8\xa3\xfe\x07\xecB{\xba\xa5eR\xed\x04\xf7\x8a\x16\xc0>\xfb"\xb0.P-\x80\'9\xbb&\xa5\xdb\x9b\xcb\x94"\xad\n\xd0\x94x\xa6\x84\xe5f\xa2\'\x14\x80\xbcS_&i\xa5\x84\xd1\x0eB\xe2\x0eth\x8d\xe0\x12\xc6\x0cO\x97\x93!\xc9\xb5X\xdbcP\x06\xedM\xc4\xb8\xc5\xa6\xe6=\x00\xd1\xa8\x1dJ\xfb\x01\xf4\x96hvan\x16\x1f\x9b\x9c[\x85.\xd7\xfc\xee>~u\x18\xed\xf6@\xad\xa7\x1c\xfe\xee\xdf\xb6c\x91\xf9\x9e\x18\x9b<`\xd4\xa0\xf4D\x01\xa4\x8c\xaf$\xb5\xefO\x80\xc5^lG\xf2\x16\x15\xfc\xf6\xfd\xe3U=<\x8d\xde\xbb\x8c*\x85\xdb\xc2v\xbd\xfb\xc6(\x0b\x99&^7)P\x9c\xee\'\xbf\xb2x\xa7qX\xc9\x05r\xd3\xf1\x1a\xe1\x8c\xfe\xa6\x96\x02\x1b\xedV\x97\x97\x8c\xabifFZ\xad\x85VU\x05\xe8\xaaN\xc4\xf1\xfc\x98\xff8:\xbc3uv\xfbeF\x0c\xc0+Z\xc9UU[\xfa|5\xfe\xcf\xc1\x13f\xe2\x8f\xf9:/\x90p\xda\xd8\xd7\xc9\x86J\xb3\xcba\x17zB/\xda\x16s\xc7\xe5\xc1\x08"\x03;\x01.\x8c\n\xc5aL\xb4\xc1>V\xc9\xf3t\x1c\x91_\x16\xe0\xa7\x1a\x0e \xc8\x04D]B\x96\xd00\xa5\x85\xa0\xba\xa3l\x9f\xfco]J\xf1\xf8\x1bs\x8a2U\xea\x881\xa3uG\x94\xf4=\x87v\xe3e\x17\x0b\xa4T\x1b\xc4\xa4\x10>\x96\'\xebN\xa0\x11\xec\x84\x98W\xb2\xd7\x16\'\x1f\\s\x07?Kc\xde\xd9\xa9\x81\xac~\x0e\xba\xdc\xd6\xfc\xdf\x9c\xbc\x00\xbdC\x11\x1b2\x8aI\xbf\xc6\x8d\x15(\x0fw\xb6y5>y\xda\xee\xc2\xb3l\xe0Au,\xf3\xcf*\xfc\xa7\xff\nN\xf4\xed\xd0\xd1\xe66\n\xfb\xac\xc2\x82\xa5\xb8,\x04\xa4\xd5\n\x92\xe6\xf8\x1e\x98n\xe7Qw\xe0\x91\x12\xde3\xc2\xdc\x03|\xa6\x0e\xc7\xa6\xa2\xf2{/\x0f\x8b%q#V,6\x1b\xe5 ?\xb2\x95\x02Z&\xc16U~\xc7Jn-\x1c\x8e\xd0\xb1U\x85\xfa\xc0\x95\xe8|\x9ac\xb7?P\xdf\xdeR\x17E\x9amL:\xab3\xf0\xda\xb7\x81\xe4\x02MA\xbc\xb0\x9a\xdb\x89\xc3\x1d\x0b6x\xc4S+\x9e\xa6\x8d\x88\r\x0b4\x01\xca$\x1c\xa6\xef\xddw\xbf\xcfB\xb0\xb9\xb3a7M\xc7\xa2P?7\xcd4\x19\',\xf1\xf3\x8b\x10\xbb\x14L\xf7\xc5\xf3\xf48.#\xd1\xda\xd0\xf2\xc9\x18m\xc4z\xe5G\xb0\x9e\x80e&C\xaa\xee\x1b\xbc\x15\xa5n|~\xe1\x1d\x08k|\xe1\x97d\xff\xf1MvPW:\xe4\xcbf[\xb6\xfa\x87\x8f\x13\xf1}r|\xaa\xc7\xcc9\x1bvx\xdb\xfdo\x8eD\xb0\xd9\xd2\x82o\xa1\x15\x81|\xff\xe3\x07\xe2\x88\x05\xb86cA\xb86\x90\x1bq\xfb\xe6<\\\x0b\xbc\x8a\xb8\x15\xce\x9bEc\x96\x83S\xe8\x8a)\xd4(\xd1\xca\x9a1\xa6%y\xd0\x1f\xb7*-G\xf5\xb4\xe1P\x91Akr\x89\x1fK\xeaS\x86(\xccp}p,\xdcW\x08R\x156-\xd7\r\xc1\xf1@\xb0\xf1k\x14\x1e\xe7\xc7[\x82\x1c\xb2l\xffI\xe2\xcb\xd5Lo\x89\x1b\xf9Z\xa2\x1d\x99\x02\x14\xc3\x91.\x1c\xb9\x83M\xb8\xd3\xc6r6,\x95q\xde\xf5\xe2:@\xe2ZKU\x90\x85HY\x12\x0f\xf8\xa4\xf0\xe1"\x84\xb2\x97\xe1\xea\xa8;;\xf2\x18.\xa7^\xb9\xd4-k[}\xfe\xa1\xef\xaf\\0\xc5X\x96\x81\x15\x97,\xcau\xc9\x02x\xc4\x019\xa0\x91\xa0\x7f\xb0uFyPAI\xbf\x7f\xd8\\e\xbb\xd8TR\xe0\x9a\xadD\x0e\x12p\x9e2\xbf\xcc\xa5L\xfdH\r0\x8d\xb7\xdcf\xd9I\xa4\xb2\x9c\xb1\xfe\x91\xfb\x15\xfb*\xec\xc9T\xc7i\xb8\xdb\xa9.\xd4\x0b8 o\xb1\xe8{\xf1\xf1\xbd\xb2{\x8c,\x88e\xf7g\xf9Gz\x8d\x06B\xa4\xed\xb1\xfe\xd8O.r_\xba\xb6^b\x9a5\xf3u\xedp\x057\xc9J\'Z$a|\xd9&\xb6\xb5\xb6z\xb7\xec_.\x8f7@st\xb9\xc2N\xfd\x89\x07\x92U]i\x91\xbb\xb5W\x94\x7f\x1a\x19\xd3\xfd\xcf1\xd2\xb6\xfbs<\xb6\xcc\xa3\x0b\x92\xc1Z8\xf7Ze\x13\xe0=\x7fV\xad\x03P\xe6\xc0\x89\xcd\x12\x8d\xe3\t\x15\xbd?\x11oR\xb1Pj"l\xf3\x10\x1e\xfd3\x95\xf5\xe4\x85z\xd7\xf0~\xae\xbd\x80\xf1\xaa\xf4u\xe6\xc3\xa02\xfcY0\xf3H\xfd\x15\xf0\x87;\x05uH5\x9ee\xff\xe3t?k\x7f\x0c\xcc\xda\x9f\x8e}\xb6\x82P\x05\xc5U\x10!]Y:\xb0\x8eY\xd3\xf5C\xd0\\\x06E\x90\xdf\xa1\x9a1\xc0,\xec\xe4\xc6\x83\xb2\xd3T\xd8J\xf7\x86\xa5\xbe\xff<;\xe1\x92\xf8\x167\x0b\x10\xb2\xe1\xe9\xc6W3\x81/\xc8_\xb3\x997\xf0\xd6\xfe2\xd0AW\xc7xn\x8dtb\xb0X\xa6\x101\xd8\x1c\xc1g\x17\x81\x97\xa9\xeb2\xa4\xb6\xe4\\$\'\'\xe6\x1d\xf6G\x02\x032\xb6\xd9\xe4\xc6%\xdf\x12B\xf1\x04@s\xab7\xd7\xadJ\x14\xed\xfdN\xca\x7f\xb1$\x07m\xd9Y\xc7\x8e\xe8}*%4\x0f\xb6\xdb\xc0\x1e\x9by\xb0\x83\xec\x9e&\x86;\x84!\x9f"\xeb\xa6\xcc\xb5\xa8\xfd\xef\xe8\xa2\x06\x91\xca\n\x0fy\xa3\xf6D>x\x14\xd2t\xb1aG\xf2t\x1c\xda\x93\xb7\x02\xa7qs\x8b\x87\xcb\xdf[\xf4\x0f\xf9\xc3\x18\xd1v\x80\x92\xd2\xc8\x13m\xe76\x92r\x06,\t\xe91\x84S\xca\x95p]I\xae\xb0\xe8k\x8bXu\xfd\x80\xb4\xe7\x17\xdb\xc64[\xd1rg\xe0\x9a\xb8\xa1rn\xc1\xb7H\x11\x19~\xbc\xdb j\x90J\xa7e{\xfd\xbc\xfbrJ\x1c\xd0w\\\x84\x94\x95\x03\xf77\xdfj\xdc\xee\x0bF+$\xf2\xc4%\x1d\xd4\xd5\xe3P!\xd8~\xfaD\x86r\xd5\x15h"\xe1@L`\x9a\xfch\x8b*\x9aQ\x08y3\xa8\xea\xd3\x93\xe1D\x9a\x1f\xba\x9b\x03\x98\xde3s|\x80\x0e\xdfog\xf0\x899qQO\xfd\x1fs}\x92W\xe7^/D\xa7\x9b@\x8c"\xae{\xe0]\x06\x0b\x9cA\xa4!\xd3U\x86\xcbo1~\xd1e\xd6\x1b";\xfe\xdd\x93\xfdd\xf0\x11\x8b\xd5(\x07\xea\xa1\xe3\xd3^L|s\xa7\x1c\xbbW&\xf7;\x15\x96\xf6_4"\xb9ul1ko\x1b\x81\xa3\x94\x12\xfdc\xc3\x8d\xb9\x97\xc3>o\\_\x02?\x1cL^\xe4\x99\xaf\x1d\x118\x9aME\xe4h\x15\xa4\xa1\xbbq\xb9\xfbpm\x98^H\x8f\xb5\x9b[\x85\xb0a\x8c\x95\x03Xm\xe2\xe06\xadzq\xf9\xda\xe9\xb5WP\xef\x01\'\xb1\x9aRF%\xb9\xf9\x8c\xb1#\xa3V\xd5\x8f\x16\xae\x9a\x9c\xf9\xa3(&\xa7\x06 3\xa5\x876j4\xfd\x08\xe6\xfa\xc5\x9am\x05\xa05r_C\xcb\xf0U6\xdc\xa99]\xc2\xe6g~U\x8bA\xe2\xa4\x8eS\x99\xaa\x8ck\xaf\x95\xadwS\x8f\xabd\xb1\xdb\x852\x0fDO\xed\xbc\xb4\xd3&\xb2_?K\x17\x00\xf6\xc7\xb9^\xb9\xb5\x1e\xa0{\t\x01\xf38\x92\x08\xa5\xa6\xa1\xf5\x12\xe3k\x85?g\x91g"\x07\xd8\x86`\x8e\xec\xa3\xc5\xfb\xe4\x9a\xdf?\xb1\xcf\xea\t\xd8\xec\xd9\x8c0\x1f9[\xd3\x89ta\x90cJ\xd5\x80\xbd\xcf\x1e\xcf\xc8\xa9Yvw 3\xbe\xcec+\x10%\x02\xd2\xc5\xcc\xce\xf44jZ`\xf4\x15\x03\xc7\xfb\xf0D\xdf\xac\x9a(\xf7!]#\x1b\xac\x11\xa6\x12oGu`\x82\xed\xeb\xa8|\xab\xa8/%k\xf7\xc2\xbc\xb3/\t\xe2\xd0\x81]J\xd1\x94\xf8)\xc7\x7fR\x16*\xac\xc9\xcc\x87##\xb1\xa0\xe2\xd8\x82w\x97\xde\xff\x17W$\x9f\xc6Y\xac\x01\xaa\x1c\xeeX\xea\xad\xc3\n\xa4\xd6\x9c\x85\xb1&\n\xecf7\xad\xc2|\xd6\x1f\xf0\xfd_\xe1$V\xc5`\x98\x90\xc3\xff\xae\xbd\xc8\x1c+\x99\xf6\xe2^\xbc\x92=\xa3\t\x8bx<2\x868\xc5Y\x97\xff\x8e\n\x0bU\xd8\x86\xfeT\x8e!L\x0c\xf3e\'\x8a\xd1W\xaf\xe8O\x9e\xf1_\xadN\x13\xb5\xa2\xfb\xb3\x98\xd9vo\xe6\x7f\x87\x9b_\x95\xd2\t\xe3g`>\x1c\xf7\x01\x8f\xcd\x98_\x9d\xcf\x0f\xaa\x0f\x08\x00\xf4\x8e\'\xbd\x87\xea\x0c\xc7\xec\x96\xe4>\xc1`\xb0u%\x82\xe6I\xa5\xaa\xfc:L\tpK\xc8\x01\x83\xbeY:\xdc\x93x\x84\xd3\x7f\xe9~\xa9No\xc5\xdd\xb4\x91W\x8dx\xbf\xb3+\x1f;\xaf\xfd\xd9\xc3\xe8\xc58\xba-\xb4\xed\xe09\xa5\xd0\x1c\xea1-\xa0\x97+\xdel\xf9H\x8c\xe8x\x91770\x0e\xdc\x1c7\xe8\x06\xbf\x0c.w\x15\xd6+\xb5\x9dR\xa3-\x07\xffQ\xf9\xa2\xfal\x8b\x98o\x86\xeaD\xbf\xc9\xb7\xd3\xcelA"\x88A\xd6\x92\x97<\xeb\xf0\x98\x03\x95>\xb0\xd6\x7fA\xf3\xeaV\x95L\x16y<\x84\xa7\r\x158\xcec\xfb\xea?\xf1\xac\xf2@=\xf9A\xcc\xaa\x16\x92Y\x0c\x88p\x81\x1d\xf3O=\xa1q\x8fRg\xd9\x97g\xd0\xe3\x93\x9d\xbc\xe1\x16\xa7\x7fz\x19L\x07\xed\xea\xfbys(\x1c\x9a|)\xbdX\xbc\x98\x95;\x91jT\x12i[j\xb7\xf1Yo\x1f\x10\xa0y\xa7x\xd5\xe9\x91^\x88m@\x07fx\xa0\xd4\x91[\xd7\x7f\xae\xf5\xe3\x85\xeb\xca\xcbi7U>9R\xa6\xb0/\x05\xd4|a\x119qn\xe1.\xfd \xc1\x00\x97\xe1\xfc\xb9\x15\x13\x87S\xfe\x8b\x80r\x0b]\xa5\x87\xbe^D\xa89\xc7b\x98\xe8\xf7\xfb\xa8\xc4\xf9\xb2\xdc\xd1U\x808\xd1\xa3+\xa0\x1f\x97U\x9b\x89\xd0\x12\xe3\n6q>%C\xe2\xe7\xdeI\xd9\x8b\xfa\x97\xa6\x97\x13\t\xe9\x869\x1a\x07\xea\x8dY\xf0\xc5{\xef}+\xdaRl\x80\x1f\xea"#\xbe@\xc8\xa9\xe8A\xaaz\xbc\xf3\xe8\x1e\xb0\x02[\xaf\x18\x8b\x14iN\xf27\x01\xa4`\x87\x98G\x0f\x906\xb2F.9J\xd9\xad\xa1\xca\rs\xca\xc6j\xabWz\xaaHN?\x7f\x97\xec+l\xa4WI\xa8\x94\x15G\x9f\xca\xdc\x1d\xcc\x89\x81\xaf{E\x9e\xe6\x1c+\x04\xaaP\xdfpe*\x81\x97\x04\xb9Z\xe4\xb5\xe2#\x8f\xd2\xd27\x1b\x07\xeb\xae\xc4\xc3\x0cB\xb1o7\x7f\x03\xa02!Y\xc9\xb8j\\Z"h\xa5\'\x1f\x00\xd5q\xceD\xf5\x89\xc76\t\x96\xa4\x1e\xc9)\xcb\x8c\xd9\xbb\x96C\xcb\xd9\xf1\x92\xd7\'Z\xa2\x9e\xd2\xa4\x03\xf4\x0f\xcfy\x9f\xf7\x00\xb2\xcd\xb6k\xe5\x9b\x05\xde]X\x8c\x94\xb9Ogc\xc4\xec\xf7\xd0\xfe\x1e\xa2\xa0\xc1\xc5\xae7\x00.u?\xc1>\xf3\xac0M\xe5\xae\xfe\xfdp"%\'\xba\x04J\xef\xe0\x17I\xb5\xfaM\x86\xbb=\xed0p\xab\x97w\x1e\xf2\xb5\xed\x1a\x13lY\xfc\xec\xc8\x06\x023\x90f|\xac-\xeb\x87\xbdk\xf4\xc2]\xd4b\xe6\x9a\x11h7\xd3\xbc\x81C\xe6\t\x00\xd7\xb2\x80\x8d\xba\xd1\xaa\xafh\r\x8e\xce)F\xc7!#&\t\x96\xa2}A?\xf7b\xd3u\xad\xe4\x17b6Z\x1d\xfe2\xa7L\xfa\x83\x1c\'\x06b\x10l\x1d\x03\xe0\xe1\x92\x04\xb4\xfb\xce\x01\x95\xba\xffZ3D\x8c\x1a\xc0\xff\xd9o\x17e1\x1a_\xe8~x\x06\x84RN\xa2l\r\xb8\xbc\x98_\xc7\x868\xcb\xf6\x80\xe9\xa0h\xb7WA\xa1#\xe2\xac-8p\xc8\xb8`\xc8p\xec_p4M\x1c\x00\xa3\xd59\xe4n\xdcT\x98P\xaf\xa9\xe04y\xe5\xaf@\x9b\xae\xa5\xb7\x85\x8c|0\x93\xfd\x85\xff0\xd0\xaf\x08\xe1\xa0\x94\xf8U\xa9u,\x0b\xea\xb4x_@p\x1fUn%\xe7u\xe0\xa0\xfd\xd4h92\x07\x1f\x81\xdb\x022\xc0\xb0\xb4H\x8a_\x8fo\xf2\xf1Y\xa78}\xba\x8eK+\xd5\x8c\xba>%\xa4\x04Gb\x87\xa4y\xf7<\x08$\xaa\x15\xa3T\xdfkG\xba\x86\x9a=\x08\x97[mk{\xd5b\x05\xd7(t7\xde\x07\x83\xbe\xc9\xc3\xd9yp\xd8\xa1\xeeUU\x1f\xf2\x03\xa4k\x9a\x89\xe5\xc2\x84\xbaK\t\xc4F\\F\xb4%\xdd\x0b\x8f\xb8\xc3r=\xb4\x17\x9c\x87\xa8\xe38\x1ad\xc9i\xbc\xe5,\x07\xfdq\x85:\xa1\x84H\xecu\xb7\x84\xbb\x02\x99\xf5\x16\xb0\x87f\x8a\x9d\x1e\xfa\xafM\x9cTa\xaf\xfb\xc3\x80\x95\x92\x05\xcd\xc8\xb0\x93\x93>Txn\x009z2\x9a\xc3O\x7f\xf1\xd9 /\x06\xb1\xe8\x86\xcaC\xb4\x14J\xa69\xbecXeR!\x9d\xcf\x93Zh4\xc7\xc0stG\x90\xa8#\xf4\x1d34i\x08T\'r\xfau\x18\xe4\x082\x85\x10[1\xce\xbbK\xea\x8f\x05H\x87\xb1\xe9\xa6g\xce\x14\xaeT\xd9^\xbe!k\x88\xf1d(Y\xbc0\x89*\x93\x05\x1c8\xde\x1e\xf6;u\xc4Yg\xbd\x8d\x1c\x06\xe6\xd3\x85\t\x1dL\x1c&?\xb0j\xbczL\xf9\xed\xdbNI\xb5ANtU\x9b\xc3T\x80\xe2\xfc(\x93\x89\xdd\x01\xa9\xfc(=\x81\x0eL\xf1\xa2\xe3\x0cb\xd3\xdb\xd3\xb4\xe3\\\x94\xab\xe23\xf0g\xc0IX\x80\ns\x1e\xec\xda\x99\xcf\xcebb\xb5\xcch\x8b\x94\xd9.\xf6\xd1u\x06R)8?o\x90*L>\xe2\xe14\x8c\xd26}t1\xe7\xac\xc1:Sl\x00\x1f\xebiz\xc6\x98Z\xc1z0\xa4\x07p\xca\xde\x01\xf4\xbf\x14\xa6\x85i\xb3\xdc\x0co\t\xe6|\x8fb\xf3s`\x15\xe6\x82\x7f\xaa\x962\x8ct\xc5\r\xdd\x85\xebJ\xaa|\xefb\xdb\xf7\x1c\x8fUE\x86\x89n\x13\xc8\xc8Bw\xe2\xa8{\xf4\x11\xb79O\xe4\xb1\xd7u\xd8\xe4\xd7\xe7\xe2\xc8\xc7}\x1e\xbd\xbb\xab<\x05\xbes\xbep1\xacN\x17\xf1#\xa6L\xfch\x91\xa0s\x98\xf6\xaf/\xb1\x17k8\xa7\xdb\xe2\x92\xa1\x86\x9e\x0e\xdd\x81\'|\xb4\x03\xc8.\x81\xd5\xaf\x1c\x14y\xd6}\xad\xe9\xb5\x0f3IzY<]D\xd6)\xc3\xbc\xef(\xbd\x89\xdb\xee\xa9\x1c\xb3\xfa\xfd\x19M\xe0\xac\xe8zV\xc5\x08B}Ko\x859v\x15\x840\xdf\xd10\xca\xc4\xfe\xca\xa0\x15\xd6\x17]\x8d\xa5\x96&\xba08\x95\xb2`\x19\x81\xbd\x1emk\x03\xcfi\xe8\xd9\x83E\xb7\xdf\xba\x98\xea>`\x98@n\xa7k\t;\x8d\xf7\x1a\x9c\xbd\xb6/t`I\x9es^x\x0c\xcf\nV\xd3\x82\x86\\\x89\x01\xce\xa9/\nZ\xa5\x92m\xcf\x8e\x11\x05\xfa\x93\xe1\xb7\xf1)\x8b\xd7]\xab4\xb9,D\xf0H*\xabH8\x0cG\xc8\x14\xcd\x11\xc6IS\x93N\xa0\x06\xe4\x17\xf8\x92\x04f\xa8\xb6\x86\xd8\x83\xc7x\x89R\xf0|\x9c\x0c\t@\xe9\x80\\?\xe90\x05\xdc\x12r\xd4`\x93t~\xf6|e-\x8c\x9eo\xa3\tL\xe6\x95g1\x98\xda\xfd\xdc\x89B\xa2\xaf\xdeM\xa5\x9al\x17\xaa\x95\x12\xb2\x99\x04\xbbQ\xc2"\xc7\x97\x87B\xf5\x1c\xf1\x9f\xb5\xb5\xa7\xcf\x9d\x0f?\x83\x92\xdc\x8d\x1a_\xa1\x1c$\xb4\xb9\xd4\xc5\xcd\x15\xbc\x8b^o\xd98d\x16\t/-g\x15\x00\xcf;\xc7\xa7\x08\xe9\xf8\xa4\x1dW\xbe\xb6\x87@\xba\xc1m\'\xf8\xaf\xd2\xdb\x8am\xf8M\xdb\xa7l\x9f\xa2\xb7\xa3\xe3\xe5\xf2?\x1d~\x9d\x94\xa4\xee\xbe7^\x9a\x03\x81\xe7\x91v\x0b\x05`?\x12\xe3\x02\xeb\xb1q\'\xe6L\xa0\x83J\xc9\x1ax\xf0[\x05GfMO\x91\xcb\xa0\xbf\xb6\x9b\xae\xdem\xcc+\xfd\xba\xaf\xb4\xf0(\x1a\xeb|\x02H.\x87\xaa_7\xbah\x1cn%GM\xe5\xef39-\xf7W\x00\xacG(\xf1\xe7\xa5wa\x19\xfd\x1c\xe5\xc1\xde\xb8\xdae\x0c\x80\xee`\xed\xbdi\x05\x8ff\x92\x97W\x86&qK\xde\xc9\xaf\xaa\xc3\x06\x1d\x92w*\xb7\xee&kO\xdf\x15mzL\x88#8>\xb3!\xf7\x95\xf3z\xa3P\x7f\xfb\x9bz\xe9h4\xf4\x89d$Q\xa4)\x98\x99Y<\x91\xd6_\x95\x0ez\xe30\x9dD\x03\x88\x9b\xfdExQy\xee\xe4\xd2\xa5\xe1(\xab\xfe\xeeM\xb7\xe0\xc0\xf1\xdb2\'\x95H\x83\x86\xb3\x1c\xedmI\xd8"\xbf2\x84HN\xf1l2\t\x9a?\xefc\xf0(\xc9\n\x82\xe2\xdf\x9a\xf8\x8b\xd9\x8b}5\x1aJ->\x8cn\x89j\xc8\x07N\x95\xb6\x8d\x0b\xf2\xd4\xff8\x11\xe7c\xb1\x01#?\x9c\xf7Z\x0bx\xad\xf7\x03\xe1J\xab$=\xf2\x11]\x7f#\x947#[\xc9\xeb\x12\x0c\x94b\xeaH\xc0\x0c\x84\xac\xfc(\xfe\x02\x97\n(\x00u\xa0\xf3\xad\xb6Z\xa2\xb5\xb5d?\x934[S\xa4\'\x974\xd9\xba\x03U\x15-\xd05\xf86\xa2\xcf\x11]\xc7\x13wi\xe4\xb0=m\xael\x02\x05\x9aZ\xd1\x86\xfb\xf5^bb\xc1\xb8=]\xd1P\x13h\x92d\xa2%\x8f\xf2\x86\xa8\xe5\x87\x1f\x14"\x92~\xb8[QAX\x88\xf9I\xef\xe2\xdd$[\xd3\xef]a\xdc3\xe8\x99i\xed\xdb\xa3.\tU\x08\x19\xe1\x073[\xbePJT\xfa\xf9\x94\xf3\x8f\x16A\x8142\xe4\x89\xbc\x05\x0e\xecE\x17\x08\x8a\xbb*\x11\xc1\xe2\nd^m/*\x02\x95\xae\x08\x88:\x12%$bH\xf5TU\xe5\xe6\x1a6\\&6(\xf3\xaa\x1f\x13\x84\x9d7$\xa0\xc7NK\xf2>+\xd2\x93\xaf\n\x0b\xe6\xa1\x8c\x93\xd65\xfc \xc2S\xf7L\x1ev\xb9\xde\xdb\x02\x01\xcf\x87\x93\xf9\xe7\x12n\xe18q\x14\x06\xeeP\xd3\x9b\xd0\xc9\r\xca#:\xdeg\xaeFQ\xa4\xa4\x1e\xa5\x08\x8a\xa3\x8b\x99[\xcc\xbd\xce T3}x\xbf\x11/\xd5p\xf2t7\xefD\x17\xea66\xfd(\xb4\xb7\x0e<\xb7\xc9\xd5\xbe\x053\r\xd1\xbf\xbfl\xe3\xc2\x9e]\xbf\xec\t\xb8N\x83J\xff\xf0\xf6\x8dWs\x1c\x15\xa0\xd8!I\x9c<#\xf5\xc0\x85g2\xf6\xde\x06\xb5\xb2\xe4\xae\xc91\n\xad\xb3V\x9bR\x83Q5f\xad\x88)\xbcw\xe2\n\xa5n\xe3\xdatM\xb4\xaaOI\xb7\xc8\x03G\x9d\x96\x9b\x9a\xf1\xac\xb7\x96|\x98\xb9/m.`2EZ\x8f\xbd\xa1|!\x9b\xb2\xc6RLH\x1ca\x07\x1a\xe6\xfb\xaf\xae\x97\xdf\xc0RF\xaff\xe6\xeat\xf5)\xd7\xdc\xbfD\xe5\xee^\x00\xc8\xeb"\xc4*+\x84\xa1}\xfb\xb6i\x92\xfb\x9fkM*{\xc9\x80\xe5\xde\x8c\x91\xb0,-y\x14mi\xccp\xe9\xf7+\xd42`\xc4Q6Qjo:!\x005QH\n\xcd\x8d{\nk\xd1\xe2\x99Q\x120\x89\xb3\x0eL]\xd4\x82\x16O!\xaf~\xec :\x10\x9a\xc0\xf0\xa9\x92\xbf&+\xeb"\r\xd4\xa4\xa7\xdd(\xcd\xe2H0y\x06\xec\x9a\x14\xb3\x94\xd0\xc9\x08\r\xf6J\xd2^\xc9N[\x04+\x9e\x9c\xfb\xb3p\x15p\xc9\x18\xa7r,\xaef\x8b\xf1\x86\xfe\x1cn\x8c\xa18bp\n0\xc4m\x9d\x95\x8d\xcb\x8c\x81_\x0b\x0b,\tB\t\x10\x05\tr\xa6@\xbc\xc1\\\xbc\xedI<[\x89z9\xf0||U\x1e\xf9h\xfe\xc7\x8e\xf7\xfe\xb8+\xe9^y\x99IE~\x87\xc2\xda>K^\xa8P\xafo\xf2\x01\xa3\xb2Q\x15\xeb\xb6e\xf6PX:\xae\xaavL\xea\x97nKF\xd9,\x8d\xff\xb6\x91\xee\xd7\xd5\xe6!\xf3\xc2\xdd\x10)\x05\xdc\xac\xd2\x8637\xd8\xf9\xba|\xccy\x0bU\x06\xa9\x9f\xd0`\xf3\t\xc2[\x92]\x97\xbf\x98\xc0\xeb\xc3(\xef\x10\xd0\xad|\xa7\xf1p^8\xcc\x87\xd7@9\xe4\xae\x02<\xe54\xbd\xc9`m8\x17\xf8{#f\xc6\x9d=\xc5\x80\x0e.\x18\xb1\xdc\xea\xf7N\xaf\xb5\xba\xbb\xaa\xd78\xea\x84[\x7f\x9a\xa9\xb7\x0c\xee\x80\x8e\xfaq\x13Ux\xa6%\x88\x1f\xe3*\x9c\xb3\t\xa3\x11\x9f\x10\xa9\xb87\xa5\xe8\xa1\xf6\xc2\xa2+\x8e2A\x83\xcb\xbd\x9d*y\xddb^n\x19\x19\xf5w\x8a\xac\xc9\xe8m\x90s@%\xae\n\xc5W\xc9\xfaxFw\xad\xcf\x8d\xde\x96\xd1d\xd8\xed\x07\xfb\x00m\x01\xa5\x0e9\'+\x81\xa2i\x96G*\xac\x9c\xda\x91\xc9\xd3HA\xa0E\n\x03B\x16rh\x1f\x98\xe6\x14x(\x96^\xa0T\xbf`,Zl\x8a\xf7#\xf1\x9e\xfdq\xdd3\x0c\xd7zQ\xdcJ(\xa9-\x81\x8b\xfd\x8dC\xfa\xd0\xc3yO\x9a]\xaf\xa3\xaa\x8egiBvd\t\x9a\xcfx\xd5\xc1\xb8\x83Y\x98n\xe5\xbc\xc5\'m*\xa8\x00Y\x0f\xd7Iu\x15-\x81\x80\xc0Q\xa1\xe0\x0c\xb3\t\xfa\xfc\xad\xf6;\xcd4\x9f\x9d\xe1\x0b\xba\x9a\xec\xe1,\xd3<\xe3\xc4\xfb9\xcd^\x12\xb0O\x94\xb01|\xe95\xe7\xec\x9f\xd2\x9a\xbf+\r\\\x8e8.\xe5BP%\xbe\x1b\x7f\xc6\xad53E\xb1\x14\xbe\xb9\x0b\xd0\x9c\x18\x12\xbef\xc4m\x96%*aF}y\xa6\xa6\xea\xd4\xa5V"{.\x10\x12\x8c\x81\x00\x9bx|\xee\xd5\x9e[?\x1aa\x81\xa1\xa3%\xd2\x88\xa4x\x98\x02(\x94|\xa4\x83.\'\xe5\xaa\x14\x15\xe3Q{r\x07\xfd\x82Ce\x9bkM>\xed\x940a\'Nk\xbc\xd6\x99\xa2e\x1f\x9ez\xe1\xdc|s1\xd2Y2\x99\xe3)Lq4\x90\xadR\xde*/?\xf7\xa4Y\xe4\x00S\xabr\x0bThM5\xde\xca\x17\xe8G1\xd0\x07\x11\xa4y\xb1;yFH+{\xffK\xf5zY\x05\t`eL\xe9.\x85\xdd\xda\xa46\xacZ\xde!v\xd3\xef\x8eu\xbd\xf6X\x1d\xfd\xa4Y\x01J\x92\xcb\xee\x15Lc+A+_\xe5\x99L\x9eM\t\xaa>\x0b\xf9\xfb\xa1C&\xf1\x05\x0e\xa0\x1b\xb6\xfc>\xf0\xce\x1e\xcea[\xe4X\x92\xb9\x8eT\x7f\xdd\xb9\xd32\xb7\xc3\xfb\xdd\x16\x8b\x19\xde-O\x84\x17\xbf\xc8\\\x8a\xc3\xfaLSW\xf6jx+\xad#tc\xffZ\xb5\x86\xfbcq\x89\xa9y/^\xf5{@L\xe1m>f\x10\xa7\xb9u\x8c\x9f2d\x19\xbd\x12%\xaat1\x16\xcf\xb0\\\xe6]<<]\xa2\xcf\xcd\xd1\x8cl\x07\r\x06\x08\xaf\xd9\x96\xc1\x85\xc9h5\xb5\xfd\xbc3"\x9a\x05\xf1\x10\x80\xfa#\x1e\\\xbcC\xd7\x9d\xba]\x00r\xa9\xfb8\x88\xa4Ljc9x\xfd\xd8jM\xda\'\xc4\xe3\xdbZ\xe9\xa8\xea\x91WF\xb4\xcf\xa09\x84\\\x919E\xfa\xd4x\xfb]\xc6\x7fF\xa5\xa5O\'\xd7\x10\xab 4[\x08\nZ\xcc\xbe:&3\\\xb4NCqZ\xf3\x9d9\xd7\xbaY5\x1eaT0\xd4q\xe9\x1b$9\x98\xd2\x04o\xabW\x17+\xcf\t\x91\xde\xfc\x1d\xa2nB\xed7\xbc\xc1\x06\'\xc9%~9o(\xbe\x05\xc1+\xe7qA0\x1c\xea\x8f\x90\x0f\xa1R\xf7\x92\xbd\xb0\x18E\xd398G\xc2\xbf\x04\xd3f\x9b\xed\xf2\xbb\x1f+\xe9\xca\x03L\xf9Ij\x8a\xb9\x8c\xc9\xa8\x08B[j\xc6\xff\x0b\xf0Y\x86\x12\xfa[U;D\xb6]\x11n\xd3\xf7\xa58\xaf\xcd\x98\x9fO\xe0z\xa4/\xd2\xe7\x85\xd7\x1b\xe0\xe2\xca\xc2#\x8c.h\x9b\xbd`\xfa\x85\xc8\xfdd\xa6MC\xab\xb9\xa5\xad\x8c\xa8U\xd4\'C/\xf0\x9f\xb1{^V\xcd9gc\xd9;\xdd\x8a\\\xc0\xbf_M\xa5\x15S\x9c\x8b\x87\'\x85=U\x01\x9c\x15OA\xff\xe9V\xbe\':\x96\x91)&\x90/\xdet\xcc\xdau]IyK=D\x91\x86A\x85\xca\x91\x96\x94+\x19z\xdd\xc9\xbe$\x94\x10\xadd\xce\xd9\x98k%\x01+\xc9\x00b\xf7\xc0\x95\xb3\x86\x8a\x04g\xfa~\x7f\x17\xbery\x8f\xf3\xeb\xe6\x0cb\xa7q&\xdf\xc3@\x8c81\x8fV\x15E/\x11@\x1c\x04\xfb\xb8\x83@\xdf\x02\xbb_\x98\xd8\x81\x9e\xe2\xa8\xff;^yg\xb0]\t\x12\xdc\x16\xd2\x19\xa6]P\x199\xe8=NTo\xeep\x08J\x08\x92\x8d\xa9\xed\xec\xd8*\xc2\x85\xde\xdbo\x8a\xc0G\xc3\xd65\x91\xed\xf1M\xcf]\xc5\x04\xfb\xe6@\xdb+\xb9\xa3i\xf0\x9f4\xda\x08\xcd\x19\xe6\xd4\xd6I\\7?\x82$R\x14\x81\xd6\xbf^\x0cdV\x18\x87\x1d\xf8\xe0\xbf\xd8}\x12\xbd\xe1\xf3@\xb1^\xa9\n\xd2hs\xf2\xb5q\xba\xce\xc0\x07\xa2P8\xd1\x8a\xfb\x86\x01g\x03p\xcf\xacQ\xd6\xe1\xb9\x8cf\xd3\x9c\xcf\x00\xf5\xdc4Hn\xeb\xef\xa4\xe4n\xd1\'\xaf\x08\xc2\xadl\x99\xd9\x0eH\x96\x9b\tM\xd7mL\xd3\x99\x02&8\xd7|\xca0\xa1a_+\x8f)\x80p\xea \xd5L\xcc\xbdz\xc8\xe1\xe3~\xa7l\x85\xd0\xef\xca\x9e\xf4q\xe3\xe4\x87\x99\'\xabf\x1e\xfe\x91P\xa6\xe9}\xda/\x94\xfd\x9d"\xe3\xd1\xed\xb8\xa5P\xb3`\xe8\xf1\xb5Y\xc2\xe0\xec\x1d\x1c\xf5(\x82 \xca\xce)[\x7f\t\xff\x10\x8a\xa8q{\xca\xb9\x1esA\xfdr\xc2N\x00\xda1+\r#\xad0hV\x0b\xc0\xc4\x9f\xff\xf6Pw\xe2\xe4\x95f1\xaa\xd1\xa9"\xd6\x05\xd2\xc7\x8a\x18cy\xd0\xcb\xdd\xfa\xe7\xfa7g \x93\x99\xe8Q\xf3\xb9\x81\x06\xac6\x00e\xf2\xd0\xc7\xbb\x1a\'L\xe6\x9c\xb2\xf2\xa9r\xf1~e\xab\xa2 \xe8\x9b\xed8%\xc8\\?v\x0e\xb1x(\xd9J2\x1ar\xdd\xd9\xdc=z\xc4\x82\xfe\xd7\xa6\x8b\xb7+\x92B\xc1\\7Mc\xeek\xde\x9dnv,\x88\xc5\xf3a\xd4j\x9f\xc04pB\xd8R\xec\xe5{\tI\xfe\x11\xde\xbf`X\xaf\x92\xaf\xaa\x0f\x11BpI?\xcf\xdf\xdd\xcc\x1f\x8e\x07\xa2\x8f\xcel\'\xcb\xe9\xdc\xb2\xe0\xbe\xbf\xc4\xa7~\xf8Z\\\x9c\xa9\x04Y\xcb\r\xe5\x8e\xfb\xd8\x15\xfb\x80\x8bz\x9cj\x8d\xad :\xa1\x83\xee\x8bA\xcc\xb7\xc4\xc7\xc1>F!\x8f38\xde\xb3\x85i\x88\xa9D\xc1\t}\xe37\xdb\xa4Y\x86\xb6\x86\xd8,(I\x97\n\x03U\x06\x17x\xe5\x8dS\x9b\xa9\xef\xa7\xe2\xd58\x8d\xa8\xf9\xc7f\xa4\'\xc2\x9b\x0f\x06\x11\x17\x0f\xdd\xee\x80$J~\x93\x00\xb0\xdd\xc4\xb8\x85X\xef\xd8\x9aZ/\xdd\x1c\xe2\x903\xeb*\xb7K\x06\x17\xe71\xaeH\xa5\x82\xd2D\xf2)\xcf\xd5\x19\x00\xef\xa6\xef\xe16;\xbd\x88\x1c\xf9\x19=\xa8GW\xe6\xf3q\x12\xb5\tW>7\xfa\x80\x12\xf0hI@@m\x84\x93\x81Y\x8dE\xc4\xaa\xa0|>4\xe2>SY\xbca\x81\xb4|\x87\xc4 \x82\xa2\xeb\x1e\xc8\xee\xa3@RS\xc3B\xd4W\x17o{\x9f\xce\xc0-\xd0Pfm\x8d 1\xa1\x08\xdc\xa9(F\x9a\xab\x95s\x96A\x8e\xe12\xf6=A\x96\xd5\xac\xb3\xe5\x18\x0f\xb8Ej\xd1\xb3\x19\xff=\x86N\xce\x9e\x95?\xc2\xbc\x0c\xc1u,\xd8!n\n|\xf1\xaa\x95\xec\x01\xd2\x11\xf3\xc7+\xb6\x1e\x0c7bc\x1de\xe5\x8c4\xff\x96P\xd0\xfd\xe1\x9aZt\xb46L\xab\x86\x94z\x85\xaa\xcaa\x87A\'\xa9BRp\xa2bf\xd2\xa6\xb4\x8dGB\xad\x04\x9a.X8\xb3\xe2\x96\xc3\xab\xb9\x0eS\t[W 0\x8e\xbd\xfa\xac\x8b2#\xdfM\xd4\x03#:\xd18\xd0\xc4\xfa\x99B\x88\x84Y\x1b\xe4\xc0\x0c\x8bND\xe5\xbd\xdax\x17b\xd2\xdfr"_\xac\xce]\x96zK\xe4\xbc;\x18\xda\'\x85\xf9~\xda\x9b\x8a\x8f\x82#\x8ec\xe4\xe2\xd8\x9c\xafJ\xf9t5\xf7\xed\x8c+\xa4\x1a!i\x0c\xb1p\x1bcD\xe7\xee\xf5\xdey?\x8c\xd4\xc0\xb0\xed[\xc56ih\xe3i]Z\x97f\x14/>\x1c\xb3\x85\xc6@nI\x0e\xb8zy\x0e\x84M$\xeb\xce-s"f\x07\xa2\xa6}\xb9\x9a\x1bbV8\x0c\x8f\xa9\xac\xb3\x11o\xee\r\xf1\x97w+\x97\x97\xc15\x88\xf7_\x10d\xd4\xe9y)Q\xd5:\xe9\x18\x9bu\x86\xb0\x04\x8a)\x8e\xa2B\x0c\x10\x9b\xe5\xe2\xbd-sKQDf@\x92J\xf3\xb95s\xab\xd3\r$\x98j\xf4@\xe2\x8a\xa7{2*V&Q\x8b}U\xa9n\xf6C\xc4\x88\x9be\xa0n\x07V\xd5a\x13\x8aj\xeb:s\xabK\xb2\'\x0f4\xac/\xd2\xc2 \x01`\xf8\rHw\xaf5\x80\x15qs\xf0rBkQ\x96\xec\xf4P\x84e\x07\xf9\xae\xd1T\x7f\xdf\xeb2O\x7f\xc2L\x9f\xda\x9f\x9e\x82\x123K\x8d\x7fA#\xeeq\xf8\xd9w\xb1\x1c\xa5\x8d\xcb\xb3<\xba\x8d\xd6\x02\x84\x90{\xcd>N\x06]\xb7\x11\x83f\t\xda\xfa/\x0f\xbfux5^\xcam]>\x01W\xd3\xe7\x83I\xbf\xf0xoV\x1f\x92\x18\xca\xd4\xd2-\xf3CJ\xb4\xf9X\x03\xc2\xf9\x86\x00\xe0\xba\xa1c\xe8\xc3\xfa\xabz\xc4h\x18\xfc{vH/\xdb$@\x10\xb0\xa5\xf7f>Pa"\xebB^E\xe0\xfb\xb5\xc5\x18\x16\x0f\xd2\x19.\x07\xb2=\xee\x8b.v\x8a\xf7X2\xecy\x8d\xb2\xd7\xcd\xd7\xec\xbeJ\xb4\x05H\xa1\x9eV_\x1f,\xd7\x07\xaa\xb8\xaf\x18\x06\t\xd5\xdc\x1e\xc0\\C\xd6?\xd4\x0e\xa1<\xf1\xef\xf6\xe8\xf0\x0c\x8a4\xb7F\x00@\xcf\xae\xa0\x9b\xe2.w\xe9\x9b~\xe8\x8aT!"pi\xbdr\x9d\xc3<\xabam\x17F\xfd\x8aCc\xcc\xf3\xa0.\xa8\x8e;\xda\xd2]X\x8bx/@\x1f#\xd4\xa2\x86:(\xf1B\xda\x86\x1a\xaea\xae\xc7\xecE\xeas\xe7\xf55"\x1f\xf5\xcb\xae\xb9>\x9b\x94#9\xbe>\x94\xd2\x8a\x8a\x0c\xfdz\xe1b\xa8\xfd\x1b\x91*G{4z\x1b\x9a\x1b\xb9E\xc5\x8dS\x82[\xd9\xa4\x87\xb1mG\xdf#\xa6\xf5\xefX[<\xa0\xcb%\xe2\x1f\xb4\xf1\xc5;\x9d\x15\xea\xb3\x8b\xc5\xbc\x82V\x17\xe9b\x1f\x85\x86\'\x1b+\x83\x83\xa6\x84I=\x89\x19\xa9]\xf2\xb2\r$\x14+H\xd5\x98\x8an\xe2\x00\xce\xf8\xab\xc2|\xcc\xf1\x88\x9d5\xc4\x92(\xbdW\xf0O4\x0f\xce\xf6;\x8c\xcbsU\x13o8\x9a\xf3:\x12\xe3?\xb1r\x0e\x85\x7f\x02y!\xd0\x08\xbee\xe6Xa\x8e\xb2W\xd7\x0f\x13\x1cA\x90\xa7=k\xb8\xae\xad\x13\xd7\xe60a\xe5]4\xc5uMf\xe2\x16/\xbe\xb1\x0f\rr^.^\xfd2O8\xf0\x19\xb1#/\xc8\x13l$A5D\xf9\x9aQgUS8\xe3}\xdc\xfb\xb3c\xc7\xb1\xc3\x8dA1.;\xa9b\xfd&\xe9\xd4\xad\xd4R\xa2\x80\xafi\xed\xe7(\x15\xfa\x1a\xba@\xb8\xf9\xeao\xfb\xf9\xbd=\xd8.\xcf\x89\x88\x87*\xd6\x1dfz]\x08V\x07\x95vok\x15\xea\xbd\xa5\xed\x8b%\xbb\xfb\xb9\x1f\x08\x8b\x0f\xf6M_\x07V\xc4\x9d\xcdt\xbf\xab\xac\xfd\x10\x91WP\x8d\x15@\xa0\xf8\xc0\xa0}\xbe7\xabg\x95\x1586i$\xee\xcc\x9cu\xf5\xaeo\xf4\xcf\x83UZS\x8cq\xb2\x19\xcf\xc8S\xaf\xb6\xa7xb\x02\xbe"\xac\xf8\xdc\'\x99e\x90\xe6A*\x1em\xdd\xc0w\xd3w\x0b\x84_\t&^\xf3^/w6\xf0\xc17!3\xaf\xba\x0c\x0b?F{\xfd\xdf\xdf)\xff\xa8\xe4P\xe6g\x7f\xcfl0\xe0!\xbc1L*F\xe9,\xdd\x9e\xf3W\xfb^h\xcd\n.\x14u\xc9\xcb\xd9\x10\xf2\xc4y\xb1\xea\x9e\xd6\x9a\x03\x89\x1d\xa0{\x1a~42\xd0y\x0bQT\xa9\xe7\xe4w9\x9d\xb3\xa9\xbd\xdb#3h\xaf\xef\xdd\xa1\xc8\x87k\xb2\xe0v\xb3\x07\xec\xb3\xe4\xa4\x83\x90\xf9z\xcf\x03\xe1\x06\xd60\x94\x86\xa8\xfaH\xcc1YT\x9a\xa8\x02\x8a\x03h&\xff\'\xc3D\xb8j\xd9\x81\n\'\x90\xe6%n\xa9\x0e\xc0\xd9\x93C\xd9\r_T\xfa\xf4\xc9_\xa2/\xce\x99\xad>\x9d\x0cb\xb85.\xf6\xf7Y\xa9\x01\xb5\xefU\x80\xda\xb2\x1d\x07\x01\xe6v\xc66\x0fH\x0c\xf7\xf7\x97\xb0x\x0e\xd1w\xd5\xd2\xe9\x8e\x95Q\x19z\xe0C\x7f\xa9\x98\xcf\xeb\x1a\x91\x94\x87h\xd2\x08g3\xb6t\xf9vj\xa6`\x8f\xbb\x03\xe7\x16\x87,T+\xae\xa0\x199jy\x06F~\x80\x05OK\xc6\xce\x1e*\xeb\x94%n$[\x8a,\xcb\x07\xe7\xbd\xa8\xf2\x80\x92\x812\xc7A\xdbf\xd4Dm\xe4Y\xe9"\x12\xc1\x95M\xd6\xabo\xc0\xdd\xa2l\x91\xa1\xb7;\xc3w\x95l\xae\'>\xb3\xd50\xd5\xe3\xb0~\x1a\xe2[\x01\xfb\x9c\x90\xca\x07\xa4\xa1p\xbc_q\xb2\x7f\xabyxm\x8f\xa1\x15~g\xa6\xc5\xb7\xaa\xe6V\xb1n\x81s\xdd\xfaU\xfbr_t9\xe8a\xe4\xd9\x10;\xc2Gj\xcc\xcd\x0b\xe3\xbe\x0e\xd2\xdbX\xeb-,v\x05wal\xc6lI\x1a\x1fP\'X\xac\xfe\x9a\xed\x9ah\xa1\x00D\r\x80/\xa2\x9e\xb4\x1c=["`\x9c\x81B\x8bN\x0b\x157\xe6\x9f5\x9aJ\x0c\xa9\xbd\x9a$\xf7\x1d\xb4x\xbb)\x8f9r\x01\xe45a\x0b\x01\x90\xdcI\x02n\x82\xe3-\xe7\xb7\x97Hh\x8a(\xa1\x92\x11\xf8d\x9f\x80\x96\x1e\x0c\xa5gRKG\xeeEk?\x11\xc4\xd6HG\xa2\xba\xf3\xa0\xbdA\xd2\x18cZ=\xcd\x01\xa3\n\x12\xc6\'"\xbb\xb6+\xb8\x9d\xaf>\x8d\xe8)\xcf2zM]\xc1\xd6\xee=\ti\x84+*D:\x0e\x1d\xc5Fg\xd3^0\xbf\x1b+N\xe9\x97d\x99\x0f\xad\x0e\xab\x0b\xfc\x1e\xb5\xb0\xea\x93\x04\\\xf4\xc6\x15\xfd\x16\x87\xfd\xe3\x05H\xb6%\x9b"\x05\xcbK\xb7Q\xff\xad\xb0\x11\x07;\xd4\xa3?NZ\xa7\xc7[\x9a\x93a\x1bd\xb2Z\xd4=\xce\xd1\x8e\xe9\x82+_\x06\xb8:\xe1:\xc3\xf5\xe7dmj(-\xe3\xf6\x15=)\xd9\xe4\xfd?\xf3\x0e&\xb8\xbe\xb6$\n]\x1f\xdf\x83\x96\xbf\xe4\xdf\x8e$d6\xd3R\xcbJ\x98\x85/\xbdX\xe1\x85&n6_\n\xc8\x00\xca|70\xd1\x94\x02XK\x89\xebg=QS\xde\xef\x8e4)\x04\x0c$PM\xe1l(\\I\x84\x91\xe7K\xb8\xca\xe5\xa4\xcb\xd6\x07\x87w\xd8m!\x9cG\x94ym\xed\xb8i%\xeecD(1\x95\xe6B\xa2K\xa8Tv\xa9?os\x03\xe5_\x92r\x82\xc4\x1f,\x19\xd1\xbd\x9eVI\xa2\xa9\xf8\x1f\xfb\xcd\xa4\x89%\xa7\xe9\xe8\x95\x8f\xd3g\xebCD\xe6;\x0f\x9a\xdd\x03\xb8jd#\xbcwKm\xae\xbf\xbb3h\xa9\xcfw=cYa\xde\xc8EN\xe3\xb9 W0\ny\xf6\xf4}\xc0,\xfeq\xc9\x9f\xb9e\xaa\x01\x87=*\x9bu\x03\xa1\x8e \xdc\xa8p{Y-,N\'\x1d\xd8\x11\xe9W\xfa\xc4\xcd\xe9UD\xda\xb8\x00\xf1t\xbc\x9bOm\xf7\xce\x1a\xbc \xc9\xd7\x81H\x8aE\xaa\x972\xcd:\x19\xb8G\xb7\x10am(\xfd=\xdf?uHN&k\xa3\x81\xed\x15\x16>\xbb\x88>\x89\x9dQ\x1a\xa5i\x19\xe4\x05\xfd\x074=\xccd\x0b\xf2_\xf7[\xd1\x9a\xd7\x16\xeb\x1c6:\xc1Gfc\xd7\xe8\x82r\x9b?2\xb8VU>k\xc7\x04\xa5d\xad[\x95\x1a\xeb\x00m\xbf\x15=@\x85D\x8b\xe0\xb7\xe8\xc8 \x0f\x0c\xb1\xed\xd7\xf4o\x14\x8b\x8a\x8fl\xc8e\x82\xe4\xa0p\xee\x07O \xf9Sd#\x03Vu\x0b\x8a+\xda\x95.\x1f\\\x97\x90\xc5J\x97\xe7\xea\xe6,T>_-4\xce\xf3 z\xd71\x1e#\xebsx~\xf4{v\xe5:\x8bo\xcd\xa8\x02\xd9\x1c\x94\x01\x9fo8\xa4\x03bMbx)\xbeB?\xb6\xf3U\x13\x9c\x8f\xdf\xf8\xd7AX69\xc7-wB\x88\xe6\xe58v\xd2M\xcc\x96dC\xa5\xdd>\xfdd\xaa#\xc1\xe7L\xb6\xe2,\xe2q\xeb\xb3\xc8\x96nF\xc8\xa8\xc5\x06\xb2\x1d\xb9\xf5y\x1f\xe2Y\x1b\x02\xa3n\x9e<\x91\x957\x17\x9e\x0b\x10\x1cOG&\xcbRa\xc7\xe8\xd6\xa1G\xcc\x10\xa2\xd6\xa5\xd1\xb5\xe6\xfa\x14\x05\x17\xe3\x19\xd0\xb9\xcag6\xb4\x19\n\x82 \xeaqE\xe1j\x822\xfb\x1f\xa7}[[d\xf7.\xc7\x1d#\tY\xb7\x13\x08\xf41\xa9f\x05\xa5\xcaB\x03\xb7wLha\x1c\x98\x87\xdc0F\xb3v\xe5C`\xe8\xb8\x08\xea\x83\x85_\xe6\x97\xc8b,\xb4c\xcd\xe9W\xd24iZ\xe5\xfdh\xe3w5Le\xd9\xb6f")8\x08\xba\x91\x96\x14\xc7\xb5\x08\x1f[D/ \xd7\xf0En\xcc\xc0m\x91y0"\x1f+\xcc%\xddZ}\xdeA\x97\xd3^&\x97u|T\xa7R\x8f\xacn\xac\x93\xab\xd8\xaco\x1e\xe9|\x93P\xd0\xc6\xdd:\x96\x8d(\x0b$\xa6\x8a\x92\x9cd-;\x0fd~\x12\x86\xe3\xf0\x17\xb7\x87\xa9\xaa)\xf3\xaf\x1a\xbf\xbb\x16\x15\xceCt\x04>c\xb9\xa7k$BL\x122\xe2I\x82@\xf9\xeb\x11l&\xdd\x04\xc3?\x8eP\xfc\x0f5\xfd\x8e)\xd1D\xef\r?K\xa5\xf3\x00.{f\x00\xb3\x15{\x87\xa1\xbb\xbc\xfb\x13\xc1,{\xb7\x0b\xf8\x88\xfe\xe8\xff\x1cg\x96VUD\x07\xe1"p\x9bi12\xb95\xac\xdd\xb7\xf6\x11\xc2\xda?n\xf9\xf42P\x0ew\xa5\xb0g\xab\xe8\x08\x01\xbe\xe6a6\xb9\xe2=\xd9\xf9\xc8\x9e\x0f\x0f\xb6B\xfe\xbetFS\xcc\r\xc9Ut\xf54\xc3,\xa4YT\xba\xb8o\\7\xe9\xee\xb9\xab=}@\x95\xc6Q\xf1\xc2\xb8\x96\x17\xba\xd6\xbb\xf8\xc0\xcbb\xec\x082\x1b\x07\xde \xcb\xb9\xc0\xa8\x1b\xe5*n\xa3y0\x890q\xa8\xd1\x9b\x15\xa4\x07\xfd\xdc\x9ein\xa6\t\xab\x9d\xa2f\xf0Q\xa1\xce\xa7\xebk\xf2\xc2\n\xd4\xe0\x9b7\x93\x94j\xf7\xe2\xf2\xf34,\xb20\x86{\x8d\xbb%\x99\x1f\x85Q\xd2]\xfb\x97|F~\xde\xab\xff\xc2x\xe0T\x9f\x8c\xd8J!B8\x8f\xaf\xee$\xb9\x08\xdeop\x1aC\x8eLg\x9e\xfco\xd0Ey\xf3\xcd\x19Q$\xa2\x82\xf0\xe2\xfa\xd9x\x7fX\xeb\x1ac\xaf:\xe8\xcd\x9eA\\\xc0\x97r`\x1b9M\x9d\x83\xe2]\x00YM\xd0\x10\xa3B(u\xe8[bW\xa7%\x08\xa5\x88\xb3\xa5Y\x9f}\x19\xdd\x94X\xce0\xd4\xaea\x0c\'\xdf\\\x05\xb6$T\x93\xf4\xc0\'\x03R\x99\x0b\x83\xe5\xb5\xe8\xcd\x1a\x07S1S \x0f\xcaI\xd1\xac\xa3@\xf6H\xd0\xcd\xf0\xd3#_avh\xc5\x13\xe0;\xb0\xf5\x08\x8b\x87\xf73\xdcY\t\xca\x1f\x02\xf9k\x166x\xffB\xd2\x8c\xdf\x9a\xc2I\x92\xf4c/cBA\xa4`\xbfG\xaa\x94i\nK\xbcA\xc8\x9c5[\xa5\xebF\xb9t\x8a\xb3\xe87\xd8\xc4\x81&\xdb\xd0T\xe8\xe5\x86\x15g\xcfN#\x9b\x9f\x1f\x92\x12\x84\x89\xd4\xf1[Y\xce\xf5\xae\xed\x00\xed\xd0\x0e\xdb\xa57\xaf\xb7\xa1\xefs4\xdc\x08\xe8\x84~a\xd5$\xb4\xd5\x8bM;\xc7r*\xd7\x8ck\xf5ZL\r-\xc8)\x12T\xa5\xf8E\x17\xfb\xd3a\xe2/\x17\xe1E\x8d\x0b;<\xa7\x0b\xc3u\xf6\xcb\xfd\xc9|\xe4\xe5\xb0\x13zH\x83\x04\xdb5\x1a"]\xfc>\x1cB7\xbb\xe0\xf0\x84\x13\xe9\xf1\xda\x8d\\\xd4\n\xd2B7\x15.\x17\xb0\xe61\xa19\xb4\xbf\x8c\x86v\xcc\x84\xe8\xee\xaf9\xbc\xc7 8\xba\x81\xab\x7f\x87\xef\x01y3\xb2K\x97\x95\t\n\xcd\x8efa\xdfTt\xc0G\xbd)\xe3\xe9}\xec\xbf]\xb6LD\xb2\x19\xb2\xeeJ\xfc\xa8[\x04\xe66\x08\'\xfdH\xf0A[\x13\x92\xad\xb2\x91\xe0\xfb\xdb\xef\xdf\xa6\x19\xfc\x12\xc6K\x07\xd7\xc8\xb1\xd0\xb6fzYx\'y\xbc\xed1\xd2\xd5m\x00\xf3?6[1j)(\x8c\xa8;\xe4\xaf\x01\xe7\x91\xd4g\x9c\x06\x81\x1e4\xb4\xc1\x87(C\xb4\xb1\xf3\xb3K#Y\xb3\x06Q\x1b2\xd2\x9f4z\xb7\x81\xc2\xa7\x93\xd9P\xcc*I\x89P\x1f\x95\xc7\x0fJb\xcf\xdaK\x1f.\x9cs\xd9\xc6\x0f\xeeH\xa4\x81?\x14\xab\xaa\x0e5\xc9\xa4jd\x06\x02mUE$O|\x17\xfeT\x8f\x0f\x99\xca\x1f\x85\x9b\xc9\x00\\\xd8\xbb\xf0\xbbm&\xce\xf9Oa}R\x1a\xf1\xc3\x9b\xc8\x1e\xea\xd3\xab\xb6O\xb3\x10\xabb\xbe&:\xf7\x81QwF\xf8\xd9\x165\xd3\xbc\x99\xe2hy7\xfb\x9b#\x18\x92\xd5\xa1\xb0Y\x13j\xe4*\xec\xd5\x11\x9dD\x97\xea\xd6h\x91\x1e\xdb|K\xce\xb3\xc0\xb3\xfek[\x9bs\x11\xb5\x0b\xccT\x11\xb4\xeb\x93\xa8Ju\xc0$\x0e\xd7[\x9b\xc0\x98x\xd0\x9a\xe5\xb2\x9c\x86k\x0f\xe4\xad\x98\xe3\x98\x9fm\xfd=@\x15P4}\x1e\x19Q\xe9\xe0\xc7\xaf\xdb\xdc\xac\x95pCa\xb5\xcd\n_\xcat\x1dQ p\xdc\xf8<\xfb\xbc\x97z+f\x80\x80a;\xae\xbb\xdf2\x8fa\x1b\xbaZ\x1e\xc5]\xcf\xd2\t\xe6L\xace\x08b\x8f\xc5wjA\xd5\x93\xecj\xb9\x19F;\x03+4\x8b\xca\xa8\xf7d\xf3\x8fX\x88XTaIW\xb9\xee\xf8\xdd\xc7\x0f\xf5\xbc\xec\x7f\xa8\xc7:>\xfa\x87\xeb\x029\x1f8\xc1\x02\xc1<\xd8r-f\xb3E\xb9\xbfIK-\xc2\xca\xc6\xb2*\xa4\x9e\x92a\xd1\xbb,\x12\xf7\x89q25s\xef\x06!\x96\x1e\x7f\\*\xee\x9a\xe4\xe1:\x11bK\xa6\xdd\xb8-\x12\xf4bK\xa7\x95S\x0e\xf1\xbfU\x92\x15|\x81ID\xf3\xb2\xd7d\xd4\xfa\xbb\xbe\xcd\x06#|\x863w,\xae5\x10\x0e\x8b\xa9i\x0fe\xcb.\x9c\xc6\xb4\xad\xa6\xb7\xbd\xcb\xc2\x02\xb1\x0f\'\x9d\xf7\xc6\x02\xd1\xa8E.j\x18\x81\xe0\xed2\xf4\x1fm6\xae\xc0\xff\x00\xad\xfa\xdf\xb3\x82\xa0\xd0>\x8f\xb1\x8a\xd4\x90\x14\x0c\xb7\xf7\xbe\t\xb8\xc2L\x99\x9d\x1c\x9fw\x05\xd4)\xbbV\xd6\x16\x07\x0c\xcc\xc2\xab9`\x8c\x9b(\x19\xe0\x9f\x18\x17\xce\xfe\xce\xdc\xe5\x9bpr\xaa\xba\xa5w8]4\xcc\xa6_\xee X\x84\x98q\xec\x1bN\x92\xecgX\xef\x98w\x97\xb1?\xb4\xe4\xaaN\x18kZ\xcf\x9b\x83)\xddc \xdb\xc2@2\x0b\x1b\xf2\xcdV\x06\r\x95e\xa9\xecu\x0c\'\xe46\x99\xf6\xe6m\xeb\xb1\xd2\xc9\xe6\xbam\\\xd5\t\xcf\x12\xa2\xd1\x9bI*\x95\xb6\xfe\xde\xf1\x83\x96\xa5D\xb1\xd0\x9fEv\xbd\xc2&\x14<\xc7L+\x8fUY\x80\xe3\x17M\xa7CN\xcfH\x11\xd0\x07x9d\x92B\x8b:\xea\x0f\xec^\xce\xb8{\xfaK\xa2W\xb6}\xa6[\xb9h4\x9d\x92\x90\xf8v8YxY\xcf\xa6\xf4\xdb\x06\r\x83i?y,\x0b\x96\x82$sn[<\x02e.\x1c\n\xb0\xc2\xaa\x17\x9bk\xca\xe6\x1b\xf2\xf5C7\x85J\xe9\xc2]m9A\xa5%\xfe\xe7\xd7E\xe1\xf5\xee\x82>fn\x8a$\x94Si+\x9b\x90k\x06E\xb0Tj\xce\xe3\x05\xc9\x06\x8d\xa9\xe4\x05\x87\xd28]\x1a\xa3\xc9H\xe6\x1di]Bz\xa2\xe4%x\x95E\x8c\x8fT\xe8\x02\x08\xaa\xca\x9e\x973\xe9\xf8\xa8Jc\'\xdcg\x86\x1d\xb7\xefB\xd6\x88L\x86\xf1\xdfT\x05j\\\x90A\x07u\x9bx\x13\xdc;\xd8\x08\x87+\xba\n\x98\xb5n?n\x00\xe7\xcb\xc7>D\r\xc9\xc8$\x9a\xa0\xdd\x90\x99\xda.%`Y\x00\x9b\xceF\xfa\xdb\x08\xa7\x87r# y\xa1\x12x\xfe\xee\x10\'6\xcd\xec\x9bu\xddw\xfa\x91\xfe[\x96\xde\x95\xfb+|Q\x1d\x9ffzU\xfak\x0c\x9d\x87\x9a>\xcc\xf4\xbfA\xb4pb\x0eK\xb7\xeb\xdc\'\x97q\x13\x83\xcb\xe7\x17Y\x00\xd4\xa4AAp\x86\x9d\x901v\xb0\xd7}\xc2\x1d\x18\xb9\x8e\xc6u\xb6\xb5\'\xdar\xf4\x8d\tz)\xb7n\xa6\x9a3\x10\xdd\x89s\xb6\\E\xa4<\xed\xc5(6\xdc\x9a\xdd\x80V\xdb\xe0\xb9\xb1(\x87;d\xc4\xbd\xa7@,\n\xb5\xe4+\x0f\xc2\xc2\xeb\xd5\xe9\xc5\xce\xbc\xe2U\x0c:J\xb61sT?\xfc\x13\xc1g\xa7H;\xaa\xd8\xd2Yp\x93\xe7j\xaa\xb7Ma\xc0\x8eHC\x88\x99%\xcd\xf0\xc8\xfa2\x02\xad\xdcx\xc84\xd5\xee4\xfc\x82\ty\xa1\xd6\x16\xfe\xe5[\x1e\x8c"\xc7\x08\xdf\x18\xdf\xd4@\xba\xf9^v\x17\x14\x8f\xc0\xb5\xde1\xae\xb2i3\xb9\x9ck\x08\xc1\xc9\xae\xa9\xb7\x06\xb0\xd0\xfc\t\x8f\xec\xae\xc0!,$\x1e\x05\xc1CE$\xbf9\xab\x10H\xa5\xc3#j\x86&\x9euf\\\\\xd3\xc2\x90T\xc4\xc9\xb9 V\x03T\x876%\xfdT>\x9cqy\xa5\x8b}\x0e=\x83\x1cY)*\xe7!Fv\x87\xa8\xc7,\xe5\x93\xc8:\x96\xef\xd5\xe6\xe2\xf8\x0c\\rh\xcf\x9c\'\xb6\x810\xa7\xd0u\x0b\x0c\xb2j2\x1a\x16\x1e\x0b!\xfa\xa9\t\x0eeh\x88\x97\xdd\xc8\xcb\x19\xb9\x89\xc5\xd7_\x94\xad\x8f\x9e\xe9f\x03\xc74\x87J4\xac\x94\x1d\x9cr\xf7\x1a\x9c\xa3V0\x93_\xffR\\\x18c\xac\xb9 \xecB\xfa!27h\x0f\x9f\xc2G5v\xd9\xca\xa2\xaf\xc6R\xc5\xc1\xf5\x85\xf88\x9cD;"\x0c\xe1\x15*\x8fH\xa7\xb0\x9e<\x9e\xda\xf5V\x80\xd7U\x04\r)\xcf\xb2\x84E?"\xab]\x06>o\x87\x15\xa0D\xae\x1d\xe8\xa0\x15\xf5\xcc\xd3\x8b\x93\xcb,W\x83^c\xa3\x82q6\x8d,\xb6K\x1d\x92\x18]ng\xa4\\\x14y\xdb\xb8\xd3\x858\xc4\xc0\xf4\r\xbb\xb5*\x1c\x18p\xd6\x15\x86\r!\xf7\xb3\x107\x90]\xc9\xd1;[_\xd7\x81\xe55\x802\x8856}\x04\xaf\x86]\xed\x88\xe6\xfck\x8eS\x91H\x91\x10C\xddp\x84\x11F\xe0A.\xc0L\xae6\x93\xe1|fM_\xe4\x97\x00\xb2\x92\x7fNv\x87\xc5\xb8\xe3\xfcs&2Lecp\xcd_yW\x8ddE\xd9\x0f\xfb\xdb=\xab\xaa\t\x8d\xdd\x10R\x9b\xfe\x1b\x89\x88Yx\xe2z8\x9f\xd5X\x06/\xa6\x95qU\x8b\x9eC\xb0\x81\xf4\xe8/\xd7\x02\x9d\x89=\x9d.\xbc\x8b\xaa\xc40A\xdd\xe0Je\xce\xf4\x9b|\tp\xf6h\xa8\xe3\x9e\x08O^\x1d\xbb\x8c\xb40O\x1e\xab\xa0&\x84?\xb6^oz\x838\x87\x816\xbb\xf9{\x1e\xae\x13\xbc\x86[D]\xa1\xbe2\xe3\x19\xeflkn\x8c&q\xe5\x95\xa7\xf8\x82\xfb\x91\xc9k\x86%\x8a8V\x03\x99\x0e\x96\xd9Ki\x1f\x92?\x9d1\xc5\x1e\x1e\xf9\x9bA\x94\x86\r\xa1\xa1v\xc7\x12\x16\x84\x13.\x98\xc5\xa0\n\x9f\xedA\xc1\n\xbdls\xf9\xb7\xa1\x07\xda*u\xc5Hj\xa5\x8a_\x17TV7>q\xbe\xce\xc1:\\\xf9\xa5O\xd6\xec\x13m\x10l\xad\xcfA|;\x95\nI\x97J!\x19\xb7\x93&][\xb2dQi-}\xacL\x9a\xca\xe9\xde%\xc5m\x8eZ\xff\xe2j\xe8\x83n\n\xa6^\xec\xb6\xa7\xb8\x9f\x80\xaa\x89\xa9~\xb3\xd2~\x93QH8\xcb^\x0c\xd5\xfaj\xb2\xdeby\x80\xfb;\x19#t\x0c\xb4\xb5\x8b\xff\xdb\xbdL6?\xb0\xf4\xb5&\x1ac\x95\xfc+\x94I\xd2\xde\xa9\x84\x9b\xd3\n]\x8c\xc8\xac\xc4\n\x8d\xcd[\x02\xbc`\x17|\xab\xf5\xa29\n\xd9\x99\x19\x93\xe2l\x83\xa7\xfb\xa4\xa0\x03\x16\x0b&V\x7f\xb9\xb9\xf8w\xe3\xd2 "z?\xd4\x0f|7\xddb\xa6\x03-\x96\xc3\x19].\x9fm\x9f\xa7M\xbc\xfbuo\x8b\x86\x1e\x93\xd84\x93\x15\x05u\xaa\xd1Q\xb8\xfa\x9d\xfa\xa2\x86\xcc\x88\x04N\xb8a\x1f\xd1\x88E\xd7\xb1\x00\xc0\x99\xa9\xd0\x07\xddaY@:\xd84\\\xb7\xa8\xbb\x0c\xe9r\xf1HRY-]\x1c\x9f\xd0\xdf\xa2\x81\x80\xa8\x92\x83\x08\xb2\xea\xf8rT\x05\xbe\xf6\x99\xa1\xfd(\xa6\xb9\xc9{\x82\x80|o\x8f\x05aU\xc9/^\xa0\x9dmU\xae\xe8g`\x1e\xcd\x0b\xd1E\x91)\xc7\xf9\x0b2gvD\x9d\xb1\x13\xf5m\x0e}o,<\xf3z\x8d\xb4\x8c^u\x1cs\xb6-*\xc7\x80H\x17\xa9d\xbe>\x13Z\t\x11\xb2c\x93\xe8\x1bk\x838iE\x90\xefdN>\xfd\xdd\x94\xdb\x10\xbc\xe3\x93.j\xbb\xc11\r\x06b\x9a\xb8\xb8f\xc4\xce\xdd\xfd\xf2\x8fko \xe0\xa62\x16\x92[\xf1\xc7\x18\x1d\xb8\x11\xf2;\x17X\xf0\xd2\x8d\xd4m\x93c\x10a\x0cK\xe4\xaa\xa3n\xbd\xc5\xab\xb0\xcc\x9f\xcf.s\x8e\x9a\xce\x15\xed\x9f\xceSa\x92`<\xda\xce%6x\xb7\xf5\x02\xc2I\xbbNo\xe1\xb2\x94\x1c\xd7b\r\x8a{\x9b\xef\x1a\x9a\x81*\x91\x06u2\xf1\x16\xf3L\x9a\xecV\xa0\xdd\x9a_\xe8:\xa7\xf0@\r\xe8\x91\xe933\x08\xc58F/\x04O\xe5\xddl\x18\xf8\xbd\x7f\xb2\x08_\x0e\x94\xfci!A7Y\xcb9\x8f\x06\xb5\xbd\xa2\\\xa1\xbc\xbb\xd9\xea\x15\x988\xcb\xfa0L\xf3+|\xb3d\xd6\xa2\xb5\x91\xbd\xda\x1cHX\xf3\xce\xb4\xba/\xa0\xa2|C<\x10\xa8\x93\xbb\x17\xa5\xd2\x02\xeb%\x1b\xd4\\\xba\x91\nfa\x13)3\xa5I`F\x99\xf7\x19)\xdf\x1c\x81\x89m\xabF\x05\xe7\xaa\xf9\x12W\xbclb\x0c\xac\xab\x11\xfe\xa1\\\x06\t\xbf\x81\xa0\x19\x8d\x0bl0\xf2o\xdb=\xd0\ra\x16w\x8dV.\x1dPt8\xcf\xd5&\x1d\x9f\x04\xc4W\x01g\x0c\x13h?T\x8b\xb8v\xd7\xd6\xb73\xb6\x05\xec\x83sK\xe2\x05r\x85(\xd3v,\xd3\xc5\xd67m\xccD\xcc\xbc\xad\x96*>\xc7\xd5\xc7/M\xae\xaf\xa4\xf4b\xaa\xf5]U\xcb(\xea\x9c\xa1\x0b\xc1\x82m0\xedG\xeaH\xb1\x1f}3\xcb\xa7\xbd\xc6g-\x03gH>8\x90\xdb\x8e\xa3|\x7f\n\xf4\xc5\xb92\xb9\x12/\x19\x03\x01\xc9#\x96\xd2o#\x8a/\x94\xbcw\xae\x0c\xddKD\x87\xd8\xa6H\xb9YDi\x06\xdc\xbe\xfe\x03\xfb\xc8\xfabO\x9f\x869\x10!\xe1\x9cV\x99\t\x1fp\xa3\x1b\xa7N\xe6\x07r\x15\xc9\x94.\xbf\x88 l3\xf9\xe1\xa9"ThF4Q\x115\x19\x0cP\x82jmag\xe6\x10mZ\xcf=\xa5&\x9a\xb7h\xad\x7fN\x17[@\nL\xaf\x83*[&\xd67\xb2\x7f\x14sw\x05\xf6\xf4\x8f\xec6\xa7WW\x07\x85\xe1,\xd1\xf9\xb9\x80\xede\xf9\xef`\x9f\xe2\xa9\x1a\xd2\x90\x05s\xd3\xc2u)\xc2\xd1e\xef+L\r_\x95\xf3>l\xbfX"U\xf2\x8e\x91\xe4i\xc9 C\x8e\x83X/\xca\xc0\xd6C\xec\xf2`\xd8y\xd6\x93/t|\x8fd\'\xfb\xcdi\xa6\xe9\x88\xbe\xce\xd9{\x05\x06\x92\xe6?al\xcf$SV_\x881\xdbo\x8f\x97\x17\x02\xa8\xe7\xc2\xbf\xb9\x83e\n\xea\xb5\xa0\xbfg-5]\xd2{\xa9\xd7r\xe6P\xe7\xe42\x86\x13\xbe\xac\xcc#\xbd\xc3\x92x+\xe2\xf8\xb2\xdf\xb5YCl\xd0b\xea\xab\xdfwY\xa8\xd2\xad\x91\xb1;\xe5\x15\t\xc5\x04\x91N\x8a\n\xe9h\xa7GFw\x91\xbci\xba`Z\x88E\x91\x83\xe0Z\xd5\x8f\x0e\xc6-\x81\xd6\x82eq@\xa9]\xa0\xbcy\x87\x89\x07\xc7\x92\x81;\x998\x82g%\x07\xc4\xa7\xc61\x82\x8bLgd\x0b28vf\xee\xb0r\xce\x1d\xc3\xa9QBt\x17i+\xf6r\xe0xB\xa7\xd1\x19\x07\xaa\x00\x87\xd8\xd3D\xe2\xcfv\xc1\xed\x07`\xf2\xf1\xdb\xbd\t\xa3\x9c\xf8N\x10}\x96\xcc\xc2\xcd\x1a\xc1\xfak\xd6\x17\x1c\xb0\xa2\x96\x08#\xb8\xaf\x1c\x17\xd2\xba\x10?\xf2\xaa\xe6&\x1cf:\x14k\xecf\xf0\x94\xf6\x93\x02\xdd\xda,c\x9f4\xce\xef\xfe4\xbb*\xce\x0b\x1b\x95\xef\x05\x15\xab\xb0\x9d\x8bKJz\x074\xd0I\xc6\xfbKE]\xcdB\x85\x96\xba\xc4\x08\x1bf\xace\xe6ot\x19\n\xc5\x1e\xce-\x06\xfa\xe7\xbd\x9b\xaa}\x8c\x1a4J1Od\x8a\xae\xeb\xe15\x97LhRC\xea\x97\xef\xc3\xc0O\x9eRs\x90nG \x18\xb6w\x1b"\xd5\xf8\x84\x12b\x94\x89\xacMNs\x89\xa7\xae+\x88\xb3Z#\xaa\xf7\xdd\xcbo8\xe4d\xdd\xae\xbf\xb6\xfdOf\x1c\x06\x9d]\xc1{?\xbd\xec\xba9\xdb\x19\xf1\x07_y\x85\xfd\x82\x1d\xe0y\xeaW\xebt\xad\x9c\xa8\xa5.\xc8\x81\xc2j\xc0\x8a\xf4\xff\x87\xc7T\xf5/\xf7pH\x90<\x1dqZ\xcc\x8aUA\x1cf\xd1\x851L\xf1C\xc3\xbb\xeb\x03\xd8z\xf0\xf4l\xc8\x9d\x96w\xc9\x8d\xb6\xdb\x91\xf7\xf0\xa7\xa877\xfd4\xffi\x14a\xf0\xb2\xb4)0\xce\xab\x1f4\x9bj\x94G\x8b\x02s\xd3\x1a\x8d\xeb\xf6\xab\xdcQ\x9a\xd3uS\xd7s/\xe4n\x1d\xe6\x14\xc7\x13C\x1c+ \x99_\xebI\xda-l\x12f\xea\xd3y\x04;\xd0R\x03\x9f\xce\x16 \xd7%f\xd9\xb9\xb3\x83!\x19\xca30\x9e|w|c\x9a\xc6\x0e\xd1\xce\x99\x84S\xcd=\xbc/\x08"\xaf\x934\xdeg\xffg\x01\xc0@Z]\x1cW\x8d\xa6\xdfv\x02S\x82|/\x1f\x07\xb6\xe3\x1f\xaa\xd5\xdd\xcf\xec\'\xb6k\xf7f\xa2\xa0\xbc\x11]\x01\xcbJW\xcb\x0f\x8a\xad\n\x953*\xd8m\x10\xf1\xe9\xd3?\xa6\xe3\x8bg\x88\xe4\xdd\xf7\x18\x0b\xfaa\xa7E5\\\x9fZ\xc4\x81#\xa6\x881_4\xf6\xf2\x85\xe5\x10\xa3[}\x99s\x01\xdc\x13\x8b\x067\x9d\xd5\xe4\xf94\xf2N5M\xd2=\xa8\x9ch\xdc\xfa\x0e\xcf\x84\xaau\x9b2\xd0\xbf\xe5|\x94\xa4\x82CB\xa9z\xc7\xc0HW\xd3\th:\xdb\x94\xbc3\xc8,\xb53\xbf\xf7s\x8b\xf2\x98?j"\'\xe9H\xd5\x0eTb\x82\x11\xcd\x8dc^\x98t\x0c\xdd\xa6\x00\x88/C\xcd\xc7)\xdc\xcb\xe1\x97\x8c5c\x8f\xddT&/\\\x120\xde@\xadk\xc4\x9b\x94B\x10\xa7\t\xfb*Wz\x86 \x91\x1f\xadm\x01D\xd2\xaf\x0cr4\xda\xe2\x7fn\xd2\xbf<\xc0\xb1 >\xb0E\xe0"\xa3&+7\x9fE34\xd1$\xa2\xbfM\xadI\xd6\x88\xc8\xca\xad\x87r%e\xc6\xaf\x14\xe2.\x1a\xe6\x02A\x85\xbd\xec\xfbn\t\x01\x9eQx\'\x8e\xf2\x07\xdfk\\\x81\xa5\xfd\x80\x05e/Y=.yF\xfc~\x00\x9f\xde\xb3\xe7\xcd\x94\xe2/\xfc\xa8\xc69;i\xd0S\x85<\xfd\xa0\xf2\xf8\x8a\x0c\x9f\xcc\xa4\x8f\xd3+\xff\xa8\x1d\x9f\xf8\x03\xca\xc4\xc0\xe6\xd0\t\xc1\xca\xbdA\xb41Gx\xc4\xbeX\x9c\xc2i^4$\xa7O\xee/\xa8~f\x88t\x08\x04\xe0%\x9a4o/>\x82\xb2\x12\xe5\xde\x0e-O\xac\xbf\xb1\xf76&\xfas\xd1\x95`\xa5:o\xf45\x84U\xe13\x03p\xc1@Y\xee\xf7^\xe0\x1e\xc7&\xbd\x01\x8c\xfd\x85\x86\xe1sbF#\xad\xf7\xc8\xffF\x9dX#\xb4\xa3\x80\xf6\xc8)*\x7f\xc2\x16B0o\x1d\x17\x0c\x91L\x0b\xb5\xd0\xb9\xd9\xee\xd50\x14\xa4\xbd\xc8M8A+\xcdKcc\xb0\x1d\xce\xc9\xa0\x83p^ d\x954\xaf-\x90\xeb\xa0W@\x17!\xf3\xfc\xfc\xd8i\xb4\xdc9\xe0\xcb<\xa2\xf2\x9b\xad\x8e\xfa\xf7\x15\xd0\xb1R_\xe6\x1e\x96-\x86\xd9\xe9\x15\xc2\xe3t\x15\x85q\x19Y|\xad\xbf\xf3\xff\x0c\xb8Z\xef\x10\xab\x92*\x95?\x9dQ\xa5\xe4X\xddk\x08\x90\x9d\xa8Y\xb0q\xc3\x99Q\xaf\x1cJ\xc1\xe8\x92\x98\rB~P\x98,\xcc\xce|\xc3bk\xb2\xd3\x7fh\xa6\xa8\xbfn\x1eo\xb8\xe0\xbb\x0e\xff#^V\x8c\xdb\xc8Dh\xfb\xfc.\xcb\xad\x81\xfaMn\x8d\xf9T\x92\xe7\x9e\x12\xf6mmi\xa0\xddG\xdb\xa5\x8e\xf3\x88\x8dT\x1e\xeb\xa1\xc5\xc1{_[A\xbbpX\xb8\x84\xdeB\xf8L\xee\xe8@\xc5|9\xcf\xbf%Tc\x7fr\xdc\x1cO\xc9\xc5\x12\xc9\x90\x02G\xa5\xf3\xab\x9e\'\xce\x9e\xab\'\x9eiuS\xf3\xed3\xb9\xa2\x94\xfb\x0c\xd7\xbbs\xec=\xfb\xbf\xd8B\x8d\xed~!1\x9aA\xe6\xac\xe2\x1b\xf1\xcb1\xef\xd2\t2\xad\x05,l5\xd7\xf1\xf5.\x9b\xcd\xf7\x10\xad\xe4\x1bXP\xa8,6\xe8"c-\xd6yj\xaa\xbd\xae\xab1\xc6\xad\x02\xcc\xfe\xea\xbb|\x03\xea\xc1]\x83\x04&\x93rr\xca\xe7\xc3\x11w&M&\xb0Q\xdf\x1a\xb5L\x05\xc2\x05D\x9dg\xd4Kh\x03\xc2wF\xf7\x80\x00\xa9\x89V\x0c\xd8s\x8b\xc0\xf9y\xf3\x98\xd8\x15\xday`\xa0X\xd8%\x19\xfa"r\x85i\\\xe6\xec\x0f\xc5\x90\xff\xd0\xac`#\xe9\x0c&\x85`M\x98Z\x92\xf0\x88\xaf \xfd\x013\xca\xe5\xd5\xfdC\xc4 \xf1EU\x9ac\xee\xc1\xcf\xef9\xbac\xe5\xb6^\xae\xb1E\xe3\x9en\xe22\x07\xcd\x10\x83\x0b\xb1\xd3\xf2\xcd\x92;\xe5\xbe\xd1\x19\xc1\xff\x84N3\xdf\xba2\xe2\xfb@\x04\xfbM\x1a\x06\xcc\xff=h\xafBw^>m\xe9I2\xa0+eNg\xc0\xc8u\x05\xc3\xfe\xb1\x90n\x1d\x03\xdarWP\xd3\xc7J9\xc5G\xe7]\xdf\x99&\xa12\xd7>O\xc8\x9f\xff\x93;q\x91\xf0\x1da\xaf\x16\xc35\x84\xaa\xefIcF\x97\xd1u[\xa7v\xcf\xe0\x0f%\x88\x1c\xed#\x84\xe2 V\xcbbm\xff\xd6:/\x95\xdd\xdc\xe5&$e\xcb|y\xb1\xcc\xa04\x1d*\xfcT\xfe\x1e\xa4P\xaa\xad\xa01e\xef\xef5\xd3\xd3\xa6\xd7\xb4R/\x80\xea,\xe5\x7f\x19%Z\xc63\x889\xf4\xa2=\xd5\x11\xees\x19^\xe3\xcc\xc5\x18g\xde\xf5\xe2lp\xb5\x83\x08,\xfe\t1\x05\xe3\xb2Q%=\xc0\xb0F\xf7\xf1\x1d\xc3\xb9%D%\x06\xf0\xb7\xc9\x1c(u\x18\x05.!\xdb\xcaj^*[\xa4s.#o]\x82&^\xe7\r6\xcb<\xdd\x1cFN!n\x92k.t^@]\xe7"\xd3\xfc\xa7/\x80x~Q\x16h\x80\xa2\x8b3\xde\xfc\x88\xfa\xca\xbe>\xf3\xdf3\xd6\xa9a\x8a\xcd\'h\xaf.\xd7&R\x94\xf4u"8\x85\xb7b~l\x9e5\x1eHe\x9d\x7fp?*^R1\x08-\xca\x84k\xad\x84\xa4\x92@~\x9dZ\xf6\x10\xaa\xb3\x8f\x80\xb6\xae\xf4\xefv\x17\xfe^\t\x81zIqd\x80\r\xa4\xb5\xebX\x7f\x99\xff\xe7\x16\xd6\x97%8 \xb3\x94k{v\x92\xe1\xd3\xf8\xc9\x8d\xddSfz\xcew\xd2#\xa7\xd8\x17)"\xd0@?nB\xb5\xb6\x03\xba\x80\xf1\xf5c\xb2\x96\xf9\x84\xad[\x91f\x9fO\xa1g\x86\xfdp!\xf8\xe3\x0f\xdebZR-\xc1\x82\xd8\x0b\xc4b\x1c\xcf\xf8r\x1a\xe9\xe8l\\\x10\x89]\xf9\\ibw\xe8\xa8\xbb\xcc}\xa3\xb8\x88\'%\xa7\x8eWP\xde\xe5}\xc4>E\xc7\xc6\xd2=\x08\xb6TQ\xe9N\xbe=\xc7\xa4j\x1a\xdd\xbc\x92Yw\x92\x85\xf9\x17\xa3\xa5\xf9\x14\xcd_\xb8\xf2\xfd{F=\x8a\x07\xe6\x11\xd7\xf8YS*\x8f\x82\x99M\xb5\x1fU\xa2}\xea\xbb\xee{#\xf9\xa6\xad\x9e\x10_Q;.\x9f=\x17<8\xebl\x10\x8f\x1d\x10J;s~\x89\xc4;\xa1Q\xb7\xeeV\x14\x8b\xb4\xa9\xd5\x9eP\xff\x9c\xe3\xa2[:\\\xb5\xa5QdN\x08b+5\x99 \xa6#\xe4e\x07\x85\xa6Y\xed\x03\x97BO2\xfd\x92\xbe\xa9\xd0[\xc5\xee\xa1\x99l\x1d\xdd\x0f\xdf\x18\x818Z\xbeN\x86\xd9\xe0\x03\x1bI\x9e%}\x15w<\xfa\x8b\x06\xd6\xeaU\xb1\xef\xd61.\xcf-\x8e]T\x01\xa9\xf8\x8dP\xaf\x17\xc7)\xc8\xe8\x93\xe1\xc9.:\x05AU%\x9aYj\xa1O\xd4\x8c\xb1\xe7q\xf723\x07%\x1b\x9e:,XG\x10q\xa3\x84\xe0\x8d2xp$w\xb0\x9b`\xc4c\xc3\t\xd9\x81[H\xbc\xb6\xbe\xaf\xba\x1f\xf4\x99\x9d\x86\xb7\x02\xb8\xf5\xf2\x0ewo\x03\x8d&\xec\xd4\xab\xc0iK\xcf\xe9/\xe5z]\xd4\xfe\xf3\x0eY|\xe8P\xdc\xc8\x90\xdf\x1fP\xd0\\\xe5\x1e\xd8B \x89\xa0W\xba9\xec\x17\xfa~\xd9\x18\xb9\x02\xb0\x84V\xd1j\xaa\xec\xfc\x02\xf8O\xf3\rW\xef/\xe9\xc9a\xbf#\xbf\xcd\xaes\xa0\xe2\x0e7\xe5\x08\rC\xb9t\xf6\xa8\xcaT\xa7\xb1\xa5q\x02\xf4\x91\xdc\xee\xb58\xbf\xb4\xac\x96:\x9e\x98d\x98\xe6c?\x08\xebS2z\xc0\xb3Cr}Q\xda*aJ\xdd\x8e\x14\x8e`\xc6\xe9\xd0[\x8e\xdd\xa9\xd2\x92;\xac\xe9\xc7\xb0\xab\x1al\xf6\xa2\xda\xc4.\x1fd\xc1O\x94\x822h\xa0\x8d{\r`[\xec\xff+\xd8Y\xf4H\x01\xbe\xd8J\xd7\xe8\xf3\xe5\xb5xL\xf7\x1c[\x18a\xf3w\xf6\xf9\xa8W\xebBf\xe0\xe6\x95\xd0\xe3\xea\x8ffH\x16\xaax\x9d^\n\xdf\xe9\x05\x822\xfby\xb2\x1b\xfd\xee9\xa8\x17\xb8(\xa5\x05,\x93\x0f\xf1\x0f\xde\xbb\x08\xf0l\xe5R|\x02\xf0kh!X\x1f\x18\xd65\xadl\x06x\xd7\xdbJ\x04]\xa3\x8d>\x87q=\xea\xe8:D\xe1\x0c\xc5\xc4C\xdf\x19\xe9\xf0g\x98f\xb07\x02\xf9\xf5Q7M\x84f\x1e\xc6\xdc\xd4\xc0%g\x1a\xf6\x06\x8b\xbd86\x8d\xe7\xd2\x12I\xfcU\'\x17\xb6\xc37R{\xef\xf6HB\xa7\xdf\xc0=\x17\xf0\xbd\x12\xfb\x1e2\x11.%+Q5f\x94\xb5;\xe6\x94\xaaV>S#\x0fq\x15\xa9X\xe9\xe7\xe1\xe4\xa7\x94\xed\x19\x9bSOs?\xa9\xa5\xaf-JyW_\xb7`-\xc3O\x99\xd9\xfdxm\x1f\x95\xe8 \x92`\xf8\x8es\xe9\xd2\xea\xa1\x91\xe2\xd0!\xa2\x9a\x84\xf0]>\xb6\x81F\xf5\xe3-(\x18\xd2\xc4t\xf8\x16\xae\x99\xc8\x8d\xd0sz\xeb\'\x9d\xef\xd1\xb3*W\xa7iI\xce\\\x058\xaf\x80S\xa9\x93t\x9b\xc5\xe8\xe7t\x85\x0c?\xe1d\xff\xd0(\xab\xf2\xb9\xff%I\x9c\xb5\x93K\xbaI\xb4\xb7*\xf6\xd9\xe8\r.\xa2biK\x8c\xe9\x98\xd3Y\xce\xc2\xad\xb1"l\xcfS\x94\x10\xf6z1\xfacO\x9eM\xc5\x91S\xd9\xd1ZZ\x03V\x17\x99\x8c r3\xberc2y\x9c\xee\x00R\xe8L\x82,4Y\xa8\x9e\x18\x17\xdf\x15\xfe\xf2\xdd[\xfd\x0ff\x82-\x94\x8bI\x8a\xa6\t+\x8f\x16\x9d\xac\xb4\x87\xc0I\xa7\xf7kxz\x08\xfb\xbes\x9e\xf0\x8dA\x08\x1c\xc7\x8fro4!\x0f_\x15J&\x0f\x0f\'x\xa4\x1c\t\x80\xc0\xed\x0f/g\xeb\x0e\x1ba\xa2\xff\xdb\x96\xdb\x8d\x14K6F*#\x07\x9dB9agR\x11s}\xbe\xfc\xa5^8P\xc84\xac.f\xfc\xd2\nV\xf5A\x8a\xdd\xca\x04\xaaG}5\x81\x00\xa5od[h9=\x10\xe1,\xe22\x9d\x0cW\xe3\x84\xa6\xf1\x13&\x99\x1aD^\x8c"\xd0\xd1\x1e\xae\x91\xfdp\xc5\x0eM\xe1\x16\xf8\xect#\x06\xbcdGH\xc4*\x1cJ[8\xc1\xd1,"\xd3w\x82\x82\xcc\xab\xb9\x1d\xa6\x86\xb49\x19r\x94c\x8eU{U9\\\xaf\x92\xdf\x86\x8f\xf7\x95\xf8\x1d\x1cRv\x05\xf3\xc5%H\xfd\xd9J0AM\xb1\xb6\xe6\x1e\x87jG\x05\n\x82\x10T\x12p]B\xa5\x1f\xd5\xfd\x06\xa1\x82\xa8k\xbbr\xba\xfb\x93\'R\x078\xb5;\xcdm\xfa\xf0\x1f/\x1e\xbe\\\x9aM{\t\x85k\\\xac\x07\x13\x1d?\xb2\xb7\x9b+V\xeb\xe8\xfc\xa9\n|"}\x0c\x18Vd3b\x7f>\xd6\xa4\x90\xa6+\xc3E3"r\xeb.^\x88\xec\x11\xd1f\xb1\x15\xab\x87\x8dv^\x91\x1a\x86\x9c\x97\x87\x1b"\xaaV\x0b\xaf\xc9!|?oa\x8c\x87\x02}R\xac\xccD\xb1\x10t\x8cT\x1b\xb2\x17V\xf2\xeb\x8bn\xc4U\xc1\xd7\x05=\n\xb6\xfa\x1d\xf8C\xc8\x1eg\xa9\xd1+\x9ed\xde\x9d\xc3\x9c\x11A\x93\xd3\xe3*\xec\xb6\xce\xa2\x90|\'\x842\x05\xc3\x05\xd0De\x92\x85\'\xddo\xd7d{\x91\x9ee\x0c\xc5\x08\xfc\x9d\x05\xab><\x1bw\x948\xbc\xea\xacb\xd6\x86\xefm\x84\xca\x88D\xdc\xae\x0cRZn\xe7\xcd\xd5\x10\xf5wL\x18\xf5\x8ac\x82t\xe3\xe7C\xad.\x95R+\x89\x9a\xcd\xba\x1f\xfa\x83\x11\xd9\x01\xca5t\x9b\xc5\x17\xde\\\x8e0\xe2\xacb\':\x1f)\x85\xfd\x01t\xae\x04%\xb4\xf2\xc6\xa1u\xe1\x93\xca\xb3\x15\xce\xfc\x02\xbc\xfaF\x94[\x9b\xcf\xb6\'\xc3n\'%\xfa8\x1d7\xe3\x0cN\x83&\x8c\xb5;\xfe\xf7\x93\xae\t;F4s\xd4Cc4<\xa58#7(\xe7\xc1w\x89\xc4(\x12\xb0\x98\x89\xbe\xdcL)=\xc9\xd0%8\xab\xb8\x1d\xccN\x1e\x8d\x94\xe7{B&\n\xb4\xb30\xeb7/\x11\nKZ!\xee\xbc\x0b\x93\xa5\n\x81\xe6\xeb\xa4ey\x98t\xaah\xfd\x9e\x15@\xf7\xcf\xd4h\xd8=\xbb\xb7\x15\x82\xae\xb0L\x07\x1b\x05\x00\x82.\x03\x19\xa1\xf9v\xf0lu\xc6\x9f\x15\x03u\xa0n\xc5\x9dw\xd2*\x07O<5~\x10\x97\xf5\xe1\xea7\x82\xfbz\x9dm\xc4\xeaf`9\xce\xf5\xe7\x8b\x8f/\x11V\x187\xad\x02\xc5\x02\xe1\xb5i\xbcU2o3\xfdrk\xac\xeee\xa4!\\\xb1K\xed\xaf\x95*\xcc\xf4\xb9)`\xc7\xadE\xa5\x18F\xc0\xdf\xb1\xb71\xce\xb6nb7\xd5\xe4\x8e7eAfCh\xc6\x8cR\x00\'\xd3RB*xq\x98_\r\xe4mc\xba\xb0Zvf\x1c\x14l\x0f\t\xef\x8a\x98\x92s\'\x97\xc8`\xff\xe8\x85\xafw}~\x05\x12\xc0\xde\x8b\xf5d\x1a.\x17\x1b^om\xd7ya\x02\xc0<\xa6\xc3,[4\x0f\x80D+\xbd\x1e\xbcIb\xb5\x81\xc4\xf2\xcc\xbd\xba\xf1\x1f\xeb\x86r\xe6\xd6\xce\x1e\x1e1\x937~gP\xc5I\xff\xd2%vc\x06S7\xc0~\xcd\r\xdc\xd4<\x02\xab\xf7N\x0c-\x88\xd8\x8bY\n\x94\xe0\xac8c\xabgH\xcd\x9f\xe5\x05\x8d*4\xe6E\x90OS=\xc2\x00\xe7\x0c\xe6\xa8\xa3\xe0\xf3\xf6/H\\0\xb7\xac\xa6\xfa\x16[m-\x12\x1fP\xae\xa8Ax\x97\x82\x90\xe7\xf1\x19Q\xae\xe6^\x02\x9a H\x8f\xf4\xe8\xec?y_\xbcZ\xff\xdcZ\xe51\xb6\xe9\x17\xb9\xc8Y\x11\xd0&\x8d\xbaC\x1d\xe3\xbc!\xbd\xd7\x91\xbb\xc0\x81\x8c\x0c\x15bKn\x95\xef2\xc6\x15z\x8fY1\xac]\xfb\xa2\xb9e#\x08\xb0V@\xf7\x93\x1c=\xe1\xecUe\x1b8\x85x&\xb3\xbfy \x96\xb2\x0fX\x99{\xb9\x86\xf4\x16\x01\xafh+\xca\xd2X\xa4\x19\x87\xc7\x15\xb9\x1b\x0f\x12\xb3lX\xa3\x9f>F\n\xfc-\x1d\xfb\t\xf2Xk\x8e)\xc6\xb63\xdc\xe3L8\x89:*\x8a\xda;X\r@|A1S\xa2\x83\x04\xb5Z\xb4\xa4\xd8\x19-\xef\xf9p\x1a+C\x7f\xd6\x7f\x83\x87\x91\xba\xc7K\xf4!\x1az*L\xc2\xce\xfaV\xb4\x03K\x92\t\xb2KjH\xf7S\xf9< \xe8!\xe6\x8cX\x88\xdd\xca\x1d\xe9\x93c\xccX\x7fP\x98\xb1\xa0C\x15\x00\x8a\x950+\xecQ\xde\x12~c\xb64\xaf\xd7\x8b\xf7,6\x1f\x11mT\xfah\xe3*s\xf8\xafL\x03\xed\xda\x88\x8f\xac\n\n\x82\xb68\xb5c0$\x02\x05G\xc1\xc7t?\xb0\xbb\xf3\xf6\x05F4\x1fO%\xb8\xb0\xd3\x16\x03\x14\x9c{b\x1e\xaa\'DS\x05\xeb\xb1\x8f\x1ep\xb1\x18\x1e\xae\xf2\xc8\x00\x8e=\xab\xd7}\x93\xfa:\xdf\x7f(\xaf\xd8\xaey\xf6\xc0\x8a\xe0@b+!\xb0\xc0\x17\xec\x04N\xcb\x8c\x7f\xd6\xd7\xc2E\x95,\xed\xb7\x99\x83\x12\x9alP\xd4B\xf4\x07\xbc\xe6\'!E\xda6\xe7\x93\xe5\x1c\x00_\xd9uS\xc2\xf2r\xa1hW\xa3\xa1\x94\x9d\xf61\xc7\xdf\xb0\x82#\x1e\x15B]4\xc0\xb9C\xab\x1a\xadi\xf33\xbcR0\xec\xa9&\xccf\x939+y\xbf\xb0R\xcd\x16\xacD\xb8h\xa4\xf1 p\xf6\x08\xf07\x15\xf2\xe9\xca\xb8=\x1c\'\xef\x12\x8d\xf0\xb0\xa0\xa0\xaa\x0e\xec\xd2Uc\xc5$Z\xa1/\xf3.B_\x8c\xbf\xe7\xf1\x93\xc2Yi\xde\x9e\xf3\xaea\x95\xa6\x8a\xab!\xf1\x18\xda\xe7\x81\x92\xf04\xbf~\xf26\x88\x9fBZ(n\x18\xc6\xeaIu\x12\xc6/\xea2y\n\xdd\xaf\xec$\xce\x84\x91mp\xed\x1fwk\xd9`\tQ\xc6\xb3\xdc\xb2]\x0e\xd0x\x06\xba\xed\x11\xec L\xd7\x9b\xb6\xe5\xdf\xd3\xa3\xc7\xd0\xe8\x80\x06)\x97U\xf0\xd1H\x82\xaa\xc1:P\x85x\xce\xf1\xa4\xdb\xa3V\x9b\x08\x08W(\xfa\x1b\xca\xdf\x82\xa4\xae6q\x89\xc07\x0c\x05(.\xa9\xf3\xfe\x8e\x8e84\x1a\x10\xa3\x9b\x05U\xdb\xf70\xe7V}3\x9b\xa1GNc\xcb\xe8D\x92,xOJ\x19\x9a\x1fdF\xe8\xed]\xc3\xf8\xb1/w\xf7FX\x8e\x1c].\xfc\x9d\xef\xb03\xcb\xe6yNl\x1e\x01\xe8\x89Z\xe2\xb1\xbd\x9f\xf9;\xbc\xce@Y\xfa\xa9\xda\xdc;\x0e\xfa\x1a\xb9\x1f\x04\x97ky\xce\xcd\x96\x9a\xc7\xd1j\x86\xe5\xc6"\x80\xa5Q\x94\x82\x9c\x0c\x03$QP4\x01\xafEx\xf9\x00\xf5\xbd\xec\xf9\xf1b%\xbd\xc0<\xf9\'\x8a\xdbi\xf2\x81\xa5\x0f\xd0g\x85\\\x94\xc9\x03A\xc1\x12\xe6\x9bp\x1bV\xb1u"\xa6km?\x15\x98\xe6\x89\xb7\x04~9\xcf\x11\xb0\x833>\x88\xb0\xe9\x1bl\x8f\xd4\xb9\xe7c\xda\x93\xa0\x83\xe2\xd0\x10\r\x8cm\xc4\x7fk\x12u0#\xac\x88h\x0c\xb8N\x8a\x19\x07\xbd\xd6t\x88\xf2W\t\xa1\x02\xf4\xe3 \xfc\xe3\x00@\x95p\x9b\x92=b\xd2C\xcb\xd2#~\xdbd\n[\xea\x87q\x8cq\xc9\xc9\xf6B`\xa3\x91\xf4\xf6\x93\x0f\xbc\xe3\x16\x01K\x19C\xc2\xaa:\x84cd\x99\xe0\x1a\xd3\xe9N\n\xac\x00I\xbc1\xf8\x86G\xa4D\xfa\xf9n/\xf3\x0e\x00\x00\xdc\x1e\xa1\x1a\x9b%+\xc5\xe4\xc1\xaa\xca\x01\xec\xce\xde\x19\xe8\xf0\x15\x00\xd7;\xbc\xbd%\x9b\xe8\x84\x9f\xf7\xc3\x05\x94>B\xfb\xf6\xe8\x80\xb7h\x02q\xee\xfe\xb6 m\xfd\x8eP\x03g!\xee\xc3\x82/\x19\x9aF(A\xe1\xaf\xddC\x92\xb4\x9cg\xa17H\x0c~\xed\x97t,\x11\x95W?^\xf6p\xa0w\xdd<\x12\xcbx\x07\x1dClC\x04\xa9t\xadL\x03}\xfc\x0fZ \xde\xfc\x05\xee/\xe2(V`K"y\xd8r\x9d\xe6\x89*\xc7\x11\xb1\xd4\xa5\xcb\xfa\xcc\xc5(\xbfxn\xa9\xd9\xca\xed\xb7}\x993\x86\x9f\xd6\x00\xf70\xb3\x7fr)\xd3\x95\xf1\xe8}d\xd3\xcf\xa0\x1b;\\\xd27\xe8\xee\xf56or\x10\xcd?ZD\xf8A\xc8\xda\x13\xd0\')\x92T\xab\xf5\xe1\x15\x13\xdf\xa2,\x07\xb8\xe1\x1f?\xc0\xe7n\xb1Z\xf4E}ST\xcb\xe5\x85\x8a\x10\xce/\xbc\x95F\x80\x13K\xb5.l\xf4N\xb8\xc5_\xcf\xf69R\x8dG{V\x13O\x82\xa8\x0f$\xf7\xdf5\x11\xa7\xf26\\DBV\'\xea\x05\xcb\x01\xdf\xeb\x08Tr\xee\xd02\xadBIk~[\xd1@\x08\xcc\x9a\x8f=\n3\xa5\xcb\xa9Q\x10\xb7x?\x0e\xb6\xfd\xa6\xaa^\xe5_(@E\x173\xe3>\xbc\xaeO\xbd\xcby,\x86\xbdg\xd3\xed\x12p\xf1\x9e\x02\x99\xd3\xd9\xcb\x1e\x8b\xc8f\xbf\x92\xf7\x82\x84\xa2\x89)X\x10\xf80\xd2\x02\xae_\xf3\xffB\xb6\x82\x81\xfb\xf0\x94\x14\xbf\x1c\x0b@\xe6\x0f\x96\xe0\xc2\xa6]\\F\xbc\xa7\x9cQ"\xf0\x16\xb7\xc4\x97O\x91o\x11\xea\xa6\x90\x9e\xe5x\xa9y\xb5\x17\xa1b\x98\x03\t\x10f\xe1\xb8\xeb?v\xcc\x91\x920\xd5//i\xea R\x0b\xd9\x06\xbf\xea\xb5\x14V\xdbXc\xa5Ace\xa67N&\xb2\xab5#\xa23\x92\xd4\xb0\x12\xb6\xb5)\xe0\x90\xbb\x9f\xbf4)\xae\xa7\xe2j\x97\x0bm\x9azc\x8cq\xa1\xdc\xed\x86\xe5\xa9~\x8f[=\x8e\t\no\x1b\x1e\xb2yZ\x85\xff)z\xb9\x02\xb5\x8f\x93\x82\x95\xf6\xb4\x92L\xe7\x17L\x9e^\x83\xc2dT\xa1\x90A\x0f] \x8a\xaf=\x1c\xb74\xf6\n\xea\xe8\xb5ocm\r\x01\xb69T\x94\x80D\xfa\xd5C`\x8c\x8e\xecD<\xcdk\x06\xf6{\xb2\xd6$}}\x16\x17\x8aB\x97{c52\x81\x94f\x10sa\xe7\xdb\x1b2\x03\x8f\x8f\x11T\x01\xe51`\x0e\xbb\x19=\xc4b@Pn\xa5\x1d\x11\x88j\x9f\xcb\x1d\x16\xe1\xd5\x1c/0\x18\x82G\xeav\x8d9!\xa4f\x15\x187\x81\x8c\x98_\xcd\xa7\xe9\xf2+\xfdm}\x18\tO\xfc0gn\x02n\xca\x92\x00\xe6`\x03\x14eeq-6\xaa2\x15=z\xf5RC(\xa4\xcc\xb3\xb7\x0cS\xcc\xc0\xc5\xda\x8f\r\xb29\xf8Iz\x16\x82:\x9bU\x9e\x01\xed\xc7\xfe\x8e\xb8\xb9\x84/\x91\x91\x06\xa7G?\xe7~l\xc0V\x9c}\xf4\xc2x;\xc0d\xdcf%\xde\r\x1eB3]\x7fl\x9d]gU\xe3\xf78\xa6sK`u\x889\x87b\xaa"\x04f\x0b\xa0\xc4.\x02>\xc8,KA\x1a\x1c\xf6\x0c\x8b\x81%m\xfaq\x0b2\xd1\xa0\xcf{\x914\xed\x8d\x8e\xe8\xa63\x9b\x9at\\\x84u\xd5\x0eO\xbeX\xdc\x90\xc4\xc21\x16\xe2V\xd0\x0c\x91\x8f(\xf4\xad\xa5\x9c|"\x9da\x91bd\x19\x13\xadt\x915T\x97z\xedE\xdc#p\xb7\xec\xf6m`[\xc3\xcf\x7f\xae]8\xf5\xf7\xe4\x8a\x8f\x19C~\xdd\xafI\xeb\x8c#\x85\x93\xb2\x9a.@\xb2FFa\x83\xcds\x1f\x97Ds~\xe5\xbdz\xd8\xde\x04-\xca\x0c\x7f\xcd\xe9\xe7\xbd\xc8\x987\xcf\xf5<*\xe4,dK d\x0c|\x8de\x12\xe4T\x1f\xef\x1c\xf5\xdeO\x96\xa1\x86\x98\xf9\xdb\xed\xbe}<\xaa\xd0\x0c\xba\xc3V\xb9\x89u(\xd1\xe1\x0fC\x12\x8f\xd6\x80K\xc8\xbb&\x86\xff?\xb4\xac\xd0Q\x0bO$qn\xd9\xfa5k5;\x8a\x92\xff0\xc1\xf8\xeeP\xdcUc\x1b\xab^\xe7\x02\xbd)\x93]\x19O\x02`\xdfQH\x86\x07\x878\xe78\x1c:\xb1D\xd6\xd9\x81-\x82\x1e.E\x83\xea\xe6\x92]A(QM\xda\x9c\t\x16VgK{\xf7\xd8\x87f\x02\x91\xbe\xf5\xc68z\x98SJ\x14\x95\x1a\xaf\xbbi\xdb\x85%\xc1\xb4\xb4\x89\xe8\xe4\xa9\xf7\xb3:w\xc0\xc5\xe5\x95um\x8d\x9b\x07^\xb5\x9e~w\x95N\x90g\xfe\xc4\xa6\x82\xd3\x11\xbb\rz\' @YW\xfa\x83\x1eS\x19\xb4\xe2I\xf56\xa8 ^\x8e\x18?\x08z\x19n%p\xc4\xc2\x04\xf1Z\xc33DP\xae\x83\xacy^K*\xa4C\x9a\x80\xce\xce+<\xb7\xeb\x13FM\x07\xb3\xe1\x1e\xac>\x17\xf4\x11\x89\t|GT=\xc5\xea\\\x1f>lFV}\xdb\x93Ag"0\\\xc2;\x84\xb9L3\xcc\x9e\xf2i~\xb6\xd8fV$":S\xb9)\xaaP\xdb\xf1\x98\xb3\x0b\xe8^[\x7fJ\xbf.\xd3LK\xffx\x1a\x9aSt\xb9,\xc4\xdc\x98\x8f\x84\xfaE\x18FUmc4~\xe0G\x1f\xad\x03\x80#a-\xef\x95\xcb?\xa9\x18d\xae\xbakB\xef\xbe\xc5+\x9a\x920\xb3\x173\x01\x1a\x9bw\xf4n*\xb6\xf05\x1a(+\xb0:tL\nG\x95\x88\xf8\xfcT\x82\x14b\xc7\xd8\xb9\xa6\xda.\xbcFe4^q\x9d\x08\xb1@m\xc8I\xa4\xbd\x8dE\xa4Q\x1al5l\x11\xff\x1e\xb7\x04`\x0e\xb6\xcbe`\xfd\xcef5\x8e\x1a#\xdd\x14\xd2\xd0\x90\xbe\x93K\xb5\x8c4iQ$$4\xd1\xe2\x10](\xd9\x18\x17#\x1cR\xea\rz\\\x9a\xbd\xc3I%\x1aJ%$\x0f\xef9\xfc\xd7\x95;\xef7\x017\x92\xa3\xe1yD\xf2!\xd2})hH\xf9\'\xbf\xa5\x91a7\x19\x8b\xadT{\x00/\x155+\xb7\x00\xe1\xa5Z\xe4:/s\x13\x14\n[X\xb8\xa0\xc5]\xc5@\x8a\xb9\xaf\xf3\x82?\x9a4\xeb\x1d\x8f\xfe\xf1\xd7\x14\x93\x90\xa9\xb7\xf8\x80\xcd\xb4\x16\xd0\xa2\xec\xe5"\xe4\xb2\x0c\xfd\x0e\x0e\xb4\xdf\x8c\x84)\xc3N\x99\xa3\x97\xf0\xe6\xc76mLN\x85NM<\x1e]l\xd0`\xa1D\xdd\xb6\xcev\xb5\xce\x87\xa60\xe4\xa2nXG\xd2\xe7\x83\xfe\xb7]nC\xbb\xce\xed/z\x8d|\xa0\x99\xb0\xa4\x8b\x9b\xd4\xb3\xbf(\xd7\x960\x03\xc6\x8b\xa0\xe0\x1c\xfe\x9d\xf0\xc5\xaa\xb0\x04\x8fm\xd9s\xf3g\xc7\xfa\x0f\xaf*\x80\xef\xd3d#\r\x8f\x13\x85@\xe0\xc9\xb7\x0e\x1c\x94\xe0#\xca\x89Q\xb6\na\xb6X\x9bRc\xfeI0\x86u\x9do\x8ao?\xd0\x19\xc1\xcdm\x11\xef:\xb0\xe4\xd7\x84:\xd2H]W\x95\xdb\n8\x9d\xdd\x04I\xed\xbe\xfcX\xb8\x07\xfdx\xefP\xd3\xf6=\x18\xf8\xae\'\xcdn\xe3\xf60\xde\xae\x1a\xc4\xac\xb0>]f\xfd\xe8z\x9a\xe3T\xef\x9e\xac\xb01\x93]fb \x9c\xb5\xd3\x0fY\xf0\xa8\xa8|e\xb8\xe3\x01bu\x0b\xeb\x99\xbak\xe03\xa2c\x19\xbd\xa9.\x13ME\x1a\xa6\x05\xfa\x8f\xe2\xc4W\xca\x95"%\xe8\xe0X\xac\x1e\xb4\xe2\x08\xe0\xe6c.\xb41\xaa\x12\x01\xaa\xb6\xc5\xd7>\xcb\xbd\x9e\xe8\xf4\xb2\xbc8m7P\x0c\xa8\xd3k\xcfl\xcfG\xf44\xdf!\x8a\xa9\x1f\xe8\xe8\xa9\xb9\xa3\xc1D!\xfc\x18\xa8\x962\x9f2\xcb\x96\xe82C\xa5\xdf"+\x0bT\xa1\xe2 r\x97\x80\xa0\xe4\x84\xed\x1c\x8d\xcfI\xe8\xe6q\xb6\xe1\xad\x1f\xda\x13H\xa7\x95\xb5H\x98 Ze\xf2\xbe\xc8(i\x19`(\x83\x13\xcb\x19\xf2\xde\x88#\x0f\x8bu}\xdcS\x0e\x12mN\xdd\xf8\x13M\xe4\x8e\x01\x9d4h\xb5\xbd\xa3\x02\xc4GhN{\xcc\x13\xbd\xdaW\x84\xba\x0fI\xf1Z\x96v\xda\xb9\x89q\xa3\x1e\xf4b-:\xb7\xe3\xa9#\rp\xe1`\xc1b9\xdbj\x80\xc6\t\xe9jg\x82\x05:\xb1\x96%\xb2\xbf\xce\xe9\xf8\x8a\xf1\xfd\x8f\xd2\xa79\xfd\x98G\xdd\xb0\xec?2!\x0b\x8b\x90\x92\xe9:C\xb0\xbe\xaa\xe6\x8f\xe9]b\x86:\x87)\xb5S\x98Z\x92x\xe8%\x05G\xde\xb6&\xc4\x87\xc0F\xfe\x83?\xc4\xc3\xc9\xba\x90y\x90bQz\rvB\xa9\xc4\x02\xdb\x88q\xe7I\x100X\xe9 \x88\xa21\xe5\xd8\xee^Yw\x8c\x98\xac\x00c\xe3\x973,\xbb\x08Y(\xc2\xab6G\xabh\x1b-\xe9\x155\xbb\xeb\x96\xd0Zq\x82+\xd1\xa2\xe7$\xe1MQ\xac\xc3\xa8\x1d\x0c\x82Lw\xd2Y:\xda~\x92\xb4\x99\xbaw8S^<\r\xd2=\xe6Ko>\x05p\x9b-\x08\xa6\xe6\xee\xcbdz\xc6L\xfc\xec"\xf8[\xe4OV\xd6\xe9\x8b\x98b\xaa\x81\xf84\x94\xebm\x8bt\xbf\x0e\xc2\xf0&g\x1b|\x89\xbbv&\x11\xc2\x85\x17\xfcV\x16\xc8"\x81\xedl\xf8\xdf0\xc5\x03\xd8\xd05\xdf\x94_\xb2\x80\xd6}\xddn\xb9\x16\xbf\xf3j\xd5\xee\x93\xa3\x16\xb6\xff\xc0\xeb]\x08[g\xb8N\x15\x8b\x85\x01\xdc\x97\x11*.\xfd\x80\xaf\x86\xb8\xcc\x97\xfc\xe4\x93iqb\xae\x9aRA\xc5v\xcb\xe1}x\xf4\xbd\xe3xJU\xf6\xb8\xb8m\xb6\xafT\x9e\x10-\x83\x83\x17\xa2[Q\xdf\x07\x8e\x9e\xb2\x17\xda\xa4\x89\x0f\x97\xa7\x80\xfe\x1cS 6\x01%\xbb\x8e\xca \x82F\xf5 \xbd\xabG\x85w\x7f\xa6\x9e\xab(\xb72\xd0\x80\xcev\xba\x96d\x08\x99|lU\x08;PL\x18ec\xcb\x81\xcb\xa8\xe6\xda\x88Or[Ms\xed\xcb\x8d\x99\xbaSpq\xdau\x86\x16\x7f\xf9\x80\x18+g\x98\xa6l\xe3^D>tw\x80\xf6\x0c#\xfe\xd24\x93\xaet\xc6\xd6C,<"\xdc\x97W{\xdf\xab\x11\x95e\x11N\xeb\xf8\xb4.\xf5\x97\x02?\x8d\xde\x0bv\xady\xadDg\xf7\xf9\x00\xe0\x14\x9b*\xab\xaaj{\x83\x03\x0f\x84~\xb9Q\xc3\x9c`\xf4@C\xdd\xc9\xfb\xd5~$\x0f\x7f\xcbR\xb5\xc1\x1c\xc8o\x929\x82y\\\xc9O9\xf9\xc4\xa2E\x0f\x05\xc7\x14\\\x80\x1c1\xa4\x1dI|]^Rl\x01\x0c\xa0\x84\xa5b\xe6m\xb8o"\xdfM\xf0w\x80K\xc2{b\xb1\xc0\xb2.\x9e\xd9\xd4\xf6\'\x16!`\xc2\xb3\x97\x96#\xeb\xbe\xf5.\x04H\xd6j+p\xf1\x01\xe8\xc4\x00\xed\x18\x96\xbc\x88\x9c\xb8-\xc7&\xd5\xfc\xbds\x8d\xcd5\xcf\xfdt\x88\x9e\xc3\x1e\x9c\x16\xc3\xe0\x0cBLJ\xc2\x8fi%\x05^&\xe8fR\xd2\x1c\x90\xb4\x916\t\x07\x8cA\x15|\x88$#\x18\x88\xe7\x98\xba\xf7\xa8\xc6\xd0\xab\xa9\xae"\x98m\xc1v\x87BG\xf9\xbb\\\xa0\x83\xa8S\x81K\xd8\x01\x9c\t)\xc8u.\xa7\x85w\xbc\x1aJ\xda\xea\xd9kD\x01\x93l\x0cS\xae\xd91c\xc567\xd7sc\xfe9\xb9\x81\xc6!\xc4\xfeR\x06\x9c\xaa\xa4\xf8>\xcf\xa0{\x04\xfc\xbc8G\xb0$s\xbb\xc4\xdc\x80\xb6\xa2\x95\xa3c\x10@\x1c\xdc\x1fD\xe2\x1d\xcf\xd8\x85\x81\x10G\x85,\xbb\x16Q\x0b|\xf6p\xfb\xe4\xe8\x1b\xc9^5rhB\xdc\x11\xd1Q\xf4\xd0\xd9\x0f\x90\xe3\x9b\x9b\x1f\x00k\xa9h\xefV\xf2\xf4\x98\xdf\x83o$\xa4\xc2\xb0\xc2\xe6(\xbe/2b-\xca\x87\xdf\xb0\x92\x04\xca\t\x82\xe2+o\x92^#\x96\xf3\xaf\xbaW:\x1fF\x1bn\xfdQ\xe0q`x`\xe45\x06\x14x\xcdD\x96(\x82\xd3R\xdb\xa4\xc1\xad\x15\x16\x03\xbe\xfa\xfc+\xb3\x10x$\xf1\x18\xec\xcf\xde\xd2\xda.iD\xfa8O\x9c\xf5m\xca\xce\x08\xabw\xa7\xf6\x91\x1f\xb0h\xdf%%2\xba[\x91\xb0#\x1f\xb1n\x1e\xa6\xd8\xb0\x85\xef\xd3\xf2h\xb1\xe0\xa1\x947\xde\xe6\xf4\xb2\xf5\x11\xfde>\xcc\xe0\x9f\xc6y\xae\xc4\xab\xab\xe1\xf7C\xecE\x17\xa1\xb0]\x18\xa1\x1d(m\x19\x83\xe0\xde\xf8\xc6Idk\x9801\xb6*\xd5\xfd\x94\x90\xca\xb0\x184\xbdK\xf0\xf4\xf00\'\xae\x7f%\xe0\xc6\x91\xe4<\x88\x1a-\xd0\x0c\\\x07\x82\xba\xedp\xce\x85B=\xf0\x1fz\x18\xf3R\xc5\x13\xdb8\xbd\x806\x88\xab\xee>\xe4\xbb\x95\xf4\xe4,^\xb3\x19\xdf\xb2E\xf8G\x90\x97\xaaO\xa0n\xde\xaa-Y\x86B\xba\x0et\x1f\xbf6B\x85\xa0\xee\x93\x03$:rF\x96\x1a>\xb79\xc0-z\xf6\x18\xb7 \x90\x98I\xe7k\x11Pw\xa2\x045\xde@\x9e\xfe\xac\x12MKf\xefp\xc5\x17\x19k\xa1\xf9\x04\xb6?\x8e\xef5\xdf\x02\x91\xe5\xa9@\x80\xd1\xe7\xb8\xb2)\xabG\xb5\x8f3\xfb\'s\xcbQq\xc8\x86\xaa\xfc\x19g8Xf\x14\xf8D\xd4\xcc\xdcc\xa3A\x08\xe1|W\xe82\x9d<\xb4\x8f7\x87\xed\xf9&K\x05\xb7\x8a\xdf\xc8\xc9j\x11=\x1e\x7f\xcf\t\x18\xc3\xae\x87\xa7E-@\x11\x0b\xdd\r\xb2L\xba\x18\x80\xd2\\j\x1e\xeb\xbd\x055\x05\xb6\xb8\xcap\xdd\xc9:\xbe\xb7\xd9\xd81\xb6r\x8e\xa3&\xab\xcdl\xeb\xefe\x15.]\x92\x1f&\xca\x15\x01\x98\xd6\x9d\xf0h\x06\xa4\x94,\xfd\xbc\xb2\x7f\xf5/H\x8aV\xdfb\xda\x0e\x88bx\xad\x9d\x00T\x0c\xee\xf2\x1b\xd3\x0e1\xf9h\xc8\x97\xe1\xe7\x82\xc4\xbc\n:4\x88\x050\xb7\xfb\xd5I\xcb\xdf\x8d(\xd8\xc6\xce\xb1u\xb3Eb\xe0+\x91\xaci}\x05\xe2\x92\xbd\x88\x9c\x03\xa5#T\xd5\xfd\x1f\xe6\x98\xf1$l\xb1\r\xe9y\x8a\x0e9\xe8\xe6g\t\xc3\xb6|\xbf\x8d\xac\x0c\xc3\xd7H\xd7Ft\xd8\xfd\x06\x15\x80l\xe1{\xb2Q\xa8\xd5\x02\x03\xa4R2z\x07\xec\x9f\xc9D\x13\x84\x14B\x01\x0e\xe2R_+(8$C\x0cd\xc8r\xce\xaa\xd8.\xce\x0bu<5\xd0"\xa3\xa8V\t\xb0\x85R\xbak\xd9[\xb3\xaff\x0c\xb3\x91o\x7f\xf9\xc6\x1e\x0e\xda\xe2?w\x88\xc7\xe9p\xef\x9c\xd2\x99B\xae\xa1\xe1\xd0\xf0nI>\x02\xe1\xa58$C\\l\xae\xf5w\x9d\xbc\xcd\xb1\xbd\xb3cM\x82\x17\xd8\xf8{VC\x07\x14\xfa\xf8k\xe5^\x05\xad\xac\xde\xb87\x84\'8\x837\xdf#\x9f\xed\xf0\xc2\x02WUsN\x1eE}l\xcb\xa2LE\xd0r\xa6\x9d\x90\xbd\x9d\x06\x10x\x8d\xb75S^\xa2\xa6>\xc0\xfc\xe0\x8d\xabS.\'QZ\xd3\xbc-\xc9\x981\x98h\xef\x9f\xbc\x89p\xd5\xc0\xe3\x15\xa8"\'\xd7i_\x95\x91\x8c\xb3\x98\xfc\xfb\xa68\xdb\xc7}<\xd3x\x8b\xa4z2\xdfa\x12d+\x80i\xcd\\\xd0C\xf7i\x80Gse\xc7\xce\xa3\x10"~o\xb3\xe6L/3E\xdc\x11\xff\x8b\xe8\x02\x92\x8d\x00~W$\xc2\xe3\xbal\x1b\x0c\xa7\xc9\xa7\xd32tj\x08\x9dX\xb0k\x9aP9\xde\x077\xa5\xa3\x0b\xb6\xd6\xf9\xc3\xf1\x1f\xd3\xfa\x8b\xc1\xe9fYf=\x0b\xcct\xf6\xa47\xaa\t\xf3\x97\xe9!\xc9\x05$\x1e\x96\'b[\xfd\xcdwAee\xeeq\x9d_\x10\xf3\xef\x89E\xac\xb4\n\xf6\xc7\x9b\xf6w\xbd\x9d;\xc9\x0b\x8b\xb0\x9d\x86\xe6j\x85\x0b\xe02R\xcc\x94(QNpO\xdd;$\xaex\xd3z\x8f\x9c\x1f\xc3\xd2\x8d\x02\r\xda\xb1Ei\x1d \x17\x97t\xb2\xf6t\x10\xbf&\x8e\xba\x94\x19\xd4\x84s\xe3\xcfA\x91\x95Y\x7f\xf3\x98\xf8\x93Y\xd0\xa1F\x9d@g\xeb\x02\xb6*a\xbe-;\x8c\x16)1\xa5\xd1Q!\xb6\t\x89q\xae\x0f\x7f\xe3(F\xd8\xf1\xd4\xa1\x03[\xdbu\xd7\xc8\xbb\xd7\x08}\\\xd7\x7fW\xb4\xf9\x18aNg\xbe\\\xa4\x1b]B$m\x02X=\xc1\xe1>~u}\xea\xd5\x07\xa8r\x0b,&\xe8H\xb9z\x7f\t\x9da\xffX\xab\r\xd58\xa2#B\xb6#O*%\x8bG\xd2#}z\xca\x03C\x19\xce\x07C\x11r\xe9u\xde"W\xdf\xe8\xe1\xb7~\xde\xf4\xf5l\xc3\xe09\xbd}\xa1\xae\xef\xde\xb6\xa2\xc7\xc9\x151\xea\x17.\x99\x03\xf2-\xb6\x82\x04+2\xc3BL\x18\xda)\n\xe9\x94\x03+n\xd4\xff\x1ahO5\x88\x89\xec,<\x04\xc5\x1a\xa0\xadI\x91\xe5\xcc\xb9\x02\x929\xa0\xc0a\xf0_\xa1\xfen;\xf5\xd8\x8e\x9c1\x1eE\xa7\xd6\xb5\xd5S\xa2\x0f4\xf8\x03\xe3fkP\x02_\xb6\x98?\x98\xf4%\xd7\xab\x04\xda\x82\x8c\xc9R\x1b\x15\xc9m\x02{A\xec7G\xcc"8Ki\xa9\xbbnV\xb9\xa9i\x0e\x7f\xcf\xc1J32\x1d\xa1\xa3^\x07\xddkX\x8aM\xad/\xc8?8\xbe\xfd|\x13\x1e\xb72!\xd9\x0eB\x1c46\xff\x14\xeb\x8f\x10\xb1\xe1!\x0f\xfa\xb9\xc5V\xf2\'\r\xf7^\xd1\xc3\n\xf5\xee\xef\xa2\xd2z\xafw\xe7\xa6\xdb\xb9\xb2s\x14\xa4\x83q\xce\x13\xdd\x83\xdf\xfa\xc6yk\xb9\x95\x08$]\x14\xcfmUQ\xdb\xcd\xec\x86"T\x11\xa7\xfb\xc6\xf2H\xf5n\x84\x182L\xf4K\xf0\xed\x8cuB27*\xd6xk\x16\xfe\xc8\x86\x88#\xf9\xd8\x88rI\xd3\xca\xe6b-C\xe0E\xae\xc2\x8b0\xd8k\xe0\x98\xc7\xb3\x02%\xb5"\xef\x83\xedh*\xfdH\x00{jo\x0b\xb2L\xdd\xe9FS\x1d\x99\xd2}\x08\xae\xb7\xaf\xbb&#\x8a.\xb3\x84\xf1Y\xa2m\xed\xa5P+\xb7\xc7\xc5#\xb9\x1f p\xd2a\xed+y\xe3\x16\xff\xa0\x1e\xb8\xf2yroU\x10\x11lK\xea\x18f\x07\xce\xdb\xba#\x00C\xcb\xc2\x81>\xd1\xd4\xd8\xfd7&\x10\xf7\x7f+zH*^\xfd\x08m\xae\n\xb7\xb2\xd7\x11\x92\xfb\xce\x0b\xdb\xb8\xd0\xf4\xb3B\x1a\xd5\xd65#!Ow\xfd\x90\x0b-s\xda)\x95Qd\x9f\x80\xea\xbbf\x03\x9a\x84\x00Q\t\xb2\xe7\xb4\xcc\x9c\x89\xbey#\xc3\x8f\x16\x13}HL^.%\x80p\xb1ZQ|\xfaE!\x8d`\xa7\xe5\x8ey\xc1\xdfl\xb2f"P\xfc\x9f\xc036\xdc\xac\x05\xdealU\x90\xeb\xbbO\xbaI^\xb87R-\xc9\xee\t7\xf8\x16\x95J\xa9\xce<\x16\xd9\xfb-K\x11\xddY>\x0e}\x18?\xfd\xd5\x84\xa7\'\xf5=\xa7\xe8\xd5A:\xcbp\xec\xebR\x94\x8b\xe9\xc6\x17\xbaL\x9f5\x04\xef\xcdkbEzQW\xbd\x9d\xae\x15n\xbe=U\x92\x99\x8bkq\xcf{+\xde\x1aVz\xf0\x00;C\x8d\xbd\n7\xe2\\%J\xd8\xedXRV\xc91tHU\xbe\xbfV\xf9\xc6\x90D\xda\xadG\xdc\x13\xb0\xd6\xc7\x18\xd4\xeb\x12~\xe1 p\x8d\x17\xce\xc6\x02\xd7v\xcb\xe1\x07\xf7D\xfcb\xaf\x10\xb7t\xd9\x87\xac\xf8\x0b6\x86\xb9\x9ct\x9f\x1e\x12\xc42\x1a\xf9\xc9\x85\x89@6\x94\xce\xd5\xa2\x86c\xb6\xa5\x96\xae`!\xc8\x9e\x05\x87E\x0f\t\\*\xdd\xfdR\x0c\xa3\xff\xae\x9b\xa1y\xa7\x04}\xd2K\xbc\x9fiw\xe1\xff\x92xyc\xa8\xfc\xb8\x96\xf8Q~\xc0\xc8\x8d\x01\xbe\x12k\xaa\x1a\x89\xf4\x15I\x10\xffR\xbb\xb3/\xc9c\xe5/Q\x8aT\x8a\xc1!\xfd\x8a\x97\xd6\xec\x81@\xec+C\x8a\xc4\xbe}Y\xb5\x9d\xfb\x82n\x99\x9c!\xca\xe4\xa0&\x88>J\x872YBu\xce\x1a\x8a&\x01\xeb\xe9\xdf\x1c\xe5\xc9\x17\x1e\x86\xa3\x7f\x9c\x81gf\x85\x8c!\x9e{$\x15\xeer\xe0\x9d }\xe0D\x9f\xf4H>C\xfb%\x96\x87F\x00\xfa\xc6XqL(\x85\xbb\xc1{\x90\xe7!\xa4\xe6C\xbc\xe7\x9fz~\xd0\xff\x0f\xa2\x9e`\xc9\x0e\x93_\xc4A\x8d\n\x02\xe8)\xe1\xa0\x95\xcb\xa3\xdaI\xca\xfd\xf2\xf3\xbc\xf3\x04\xd6\xa0\x0c\x9c\xaf\xe9\xf4?\xbb\xa8\x9b0\x10\x81\x00\x08\xd41\xc3\x94\x06\xae\x89\xeb\xeb\xb7\xd6\x8e\xddKri\xe0bXiRs\x84DJ\x1d\xe9\x7f\xbd\xea\xa6\x9d|\xec#+\x0e\xf91c\xcf\x1bl\x90\xdb}\xfd\xb4z]\xf1\xcd\x89\xb6\xd9\xa9\x87f\xce\xac0\xe2\x9a\xd8\x1b\x97\xb1\xdfX\x9f\xf1\x9a\xafn\x0f\x1d6Y\xbcT\xbc\xd9\xda\xc6\x80IH\xf8\xf0P\xc83\xccm\xebU\x91\x1e\xb6\xdc~C\xf6\xfd\x8e\xcd4?Dk\xc5\xcdc\x80\xfd\xfb;\xf4\x0f\xd24\xdf\x91\xcc%\t\x94\xb3\x0f\xc8\x95\xf2Uj\x82\x079\xc2\x9au\x81"\x8c/\x03\xad\xcf\xe6\x9b\xbeu#K\xc7#\x92u\xa5\x13o\xb9\x0bh\xd6\x81b\x9f\x94\x921?\xfc\xf4z\x95\x00<>\x13={\xb1\xa8|L\xbe\xcav\x17w(D\xb4=J\x16\x9c\x97\x9fWD\xf2(c\xab\xa3\x10\x06\x9c%\xa5\xc6\xf1L\xef\xf2\x93\xb6>\x93\x1f\x0f\xde\xf0$;\x08C%\t\xecJ\xfe\xd7\xb1`\xc2\xf9\x8c;E\xfdQ\x98Q\xb26\xf3~\xf7E9Gr\x92\x11[\x1bE\xb9g\xc8Z\xff\'g\x8c\xbe]_\x9e\xf7q#\x92b\x91S\x13\xd2\xfb\x8e\x19\xb10K@\x1a\x126\x8c\xe4X\xa6\x0c\xaf\x90\x04L\xc3H\x0eV\xa3}\\\xd9\xa1\x99{FE>\x896\x88\x1ca\xf5\x16A+f\x06\xbc\xed\x8b\x87\x0c\xa9\x8eV>*\xfeEa\x1b\xd2\x1b\xf6\xea\x0c\x8b\xfd\xf6*\xf0\xc7\x15y\x9b\xb4\xb6\xc0rL}\x89\xa5\xe0WW\x12\x80r.y8\x86\xddi\xdf%>*,\x88\xe1\x13\x1f_s\x9bRR#a\x9fB&\x16 \xd1\xb1\xc0D\xdc\x7f\x8a\x8a\xf5L\ti\x91\xa8\xc9.\x991\x07I\xdb\xb5|\xa0\xc0\xa0\\\x12\xd9\xed\xb9\xa31P\x1d\x84\x840H\xd6\xfd0S\x8f\xe2\xcd\x05\xb2\xaa\x12Jl(\x0b\xcd6\xc331\xc9%\x0c\xa8\x06\xb5\x93!#|\x13+\xfe\x9b\x15\x17\xb6%d\x84\x87\x11\xd0\xb8!\xae\xab\x1a\xe2\xe6\xf6T\xbe\x18\xe1\\e\xffF\xf0\xf7\xea?\xac,B\xa4\x10o\xdf\xa1*\xb6\'\x12>\xeaF\xf9=\xde\t\xf3\xc1%\x1b\xc75\x82|\xa26\x9d\xc3\xc87\xaa\x95\xc7s\xd4.\x0f\x0fU\t?\x89X\x91\x90\xb4uX\xb9\xa9\xaf\x12\x8e\xd7\x86\xbd:\x08\xff\xb2q\x82\xfe\xe94f~\xb1-\x87 \xce2\xbe\xe2\x91\x13\xbd\xbb\x02\xc9\xde\x13\xeft\x99\xfc \xb7#\x1a\xdbSX\xea\xc4\x8c\xaf\x06i P\xf4\xfcw\x11\x80\x07\xc3\x8f\x06\xe64=J\xa0q\x02\x8f\xedo%\x98O%h\x1cj\xfah\xd4\xdaBc\n(\x1e\x85\xca\xeb\xfc;\xd1NI\x19\xfeS\xe1\xd5\xc4RM\x9fl\r\x18\xba\xffy"\xf0\x85\xa4U\xb8\x1a6\xed\xcf\xe8\xa9kR\x99a\xd7\x82\x7f\x0c\xa1\xd29hL\xa3\x96\xf7P\x8a\xb2%9M\x13\xdb\x86\xb3\xd0x\xe0\x93c\xa9\xe8t\xec\x83\xe0\xe7\x7f\xf0{\xccli\xdb\x19\xaa\x7fM\xe5\xf1\x1e1\xb4\xab\x9c\xfbR\xe3\xb4\x17v\xde\x97\x13\xef\x98\x90\xe5N\x8e\x0cgWu\xf6\x17TZYU\x87\x12\xc5\x061\xa7\xc0\x07\xd7\xd1N\x8c\x07\xfa8d\x93\x002\x9a\x8d/\x04\xfa\xed\xeb\x17\xef\x10\xe9e\xb7\xc5\xc1\xafNX\xec\xd2\xcd\x07e\xd9\xeb\xf6.\xb2\xeb!$\x175\xd0\xf5\xa9&z\xa6\xb0\xec-?\xf0c*%y\xa9\xb2O\x92\x88R\xfa*\x89*\xf8tT\x95kb\xaf\xc8\xc4S\x11\x81\xb9\x968\x9a\xce\xcf\xa2\xaa\xf9\x1c\x01\x05\xf6\xef\x165\x15"\x90J*\x95\x1aK\x12\xa9\xb6\x1f\x83\xba\xb5\xc5}\xda,\xa4\xa6\xb7\xdb\x10\'\x10\x81V\x9d1\xe6\x00>\x17\xdeU\x05\xad\x93\x1d\x90\xe5\x1e~\xfa;\xd2\xe4\x06B\x85\x04\x96\xfd\x0et1\xf9\x8asbk\xb9\xbfy\x17\x1a\xd0I7\x7f\x1fK\x84\xff\xed\xeb\xfd%9RG/\xab@/\x8a\xa0\x87]T\xaet}&C|\xa1t\xd8\xfbK\\*Ws\xde\xdag\xb5j\x9a\xcc0.O\xd29p\x1d.\xea\\\x97p\xb5\xe3^\x05\x08RnYb-\x9b\xd71\xd9\xfb\xe5\xe7\xbe\x02/\x90?|\x95\xf9@\xc5\x12\x9epfK\x1e\x9c\x0f\xce\xc0_\xd8j.No\x98b<\xaeE$A\xa9\xac\xc2\xee\xad0Nl\x84\x0e\xf7T\x8e\x10\xa1R\xb9\x89\x8e4r\xa5[\xbar\x92\xf8p[63\xbd\x8b\x08\x0eb\x97lY\x89\xfcYJ\xc4\xa9(C\xde\xa9\x909@\xd5\x03\x1c\xb3\xb9\xd4d~\xd8\x7fX\xc9`\xa0\xfbVq\xa0\x14\xffLB[\xcc0\xd4,\xc9\\\x87T\xcc9\xdc\x05\n\xc8kA\xad\x05\xb3\x8dA\x0b&W3\x82\x10 q\xdc\xaeI\x91\x01\x1c5P\x118J\x8b\x95K\xd0\xff\x89\xf4\xe9v/\x13\xf4t~~\xbe\\\xff\xb8\xf8d\xb8\xc7\xdf\xad\x8dc5u\xd3\xd2\xcf6\xd0.\xd6by\xcb\x85\xc4\x1a>\xc6\xa7\x98\xc1\x15\xb6\xecH[\x01\xda\x0c\x9a\xb1\x17u\x899V\xba\x1f\xc6\x03\xaczo\x18f\x9b\x8b%\xc6\x14\xed\x1a\xf4\x0f\\k\xa3\xe8W|.!,\xf9\xe5Y\xf32\x0b\x9ayq\xe9\xff\x19?-p\x8c\xe09,$\x8a\xc9\xdd\x8a\x12\x1dH\xe9N\xa5\x06Cl\xa0j,\x81\x89\xb8\x9eFYi\xf9\x03\xcd\xe3\x8b\x89N\x16E\xf1\x84\xd25`\xd5\xbf\xad\xf4\xee\xfb\x9bu\xdcu\xf8\x9cL\x85,J\xa0\x90#\n#\x97\x90h\xea_r*\xc4L$x!4\x87f\x14\x81\xf7b\r\x81\x969\xf9n#\rO\x16\xbf}\r\xab\xc5\xbd\xdd\xd4\xa7\x1c\xf4\x8a[\xb2\xcf\xa1r\x1eR\xe2\xa5\x0e\x9b9\xd3l"\x8a\xf1\xf2\xca\xfb\xd7\x81\xdd\xa0\x9b\r\xd6f\xee\xb01d\x07W\xadxn\x9fBL\x06\xf6gK\x7f7\xd9\x9c\xb5aWp{Z\x8d\xec\xc9mv\xa8\xc8\xc4\xeb\xc2\xd7SE\xfd\x19\xbd\x19T\x8eJ\xc8\xf9*W7-\xb6\x8f\xd4\xc2#\xaav\\)\x80\xa7\x95~lP\x98\x98.\xdd\xd0-K\xc6I\xba;\x89L\xcd;\x92\xeb&\x061\xa0\xfb\xae\xf6\x00\xc8\x05\xa8\x1a\xe6G\xe5\x07\xf1\xb2\x0e\xd5\x8f\x9e\xbc\x85\x9d\x8cH\xe3\x90\x9ck\xee\x96\xd2\xae\xce4\x89\xc2\x0e\xff\xf0[\x15\xba| \xca\xf9\xa6}4[rd\xfd\xe2z\x9e\x8c\x88Jk\xf4\x08\xfe\x83\xf8\x937\xbf\xdcXH\x98>\xcb\x019~@^\x06\xae\xe4\xe3c\xc14\xe0\xea\x06Ko\xed\x8b\xbc\xf5\xefE\x85\x14\x07\xae\x8ey\xba \x88\xb4\x9c\x1feE\xaa\x7f\xd0\x02\xc0\xee\x13f\xdd}\xceJ\xf8\x89\x18\xda\x901sc\xb8\x0b\x84\xee\x15Z|\x8bg\\\xe8\xd1`\xd0k\x89\x1e\x075\x16\x87\x11\x02,\xca,\xccA\xd9\xfb~\xea4\xdd\xad\xc7\x94_\xe4N\xd4\x1b)\xb9\xe0|\xfd\xdf\xd5\x9c*q\xd1\x99\x1b\x01\x13\xf7\xe3\x88\xb0\x89\xb6%i\x8a8Q\x97FV\xa1\xa0UI\xe0\xbcM\xddii\xa8FTm\x88\xb1\x13=\xad\x80y\xb2\xf2\xf68jSzq[)\x0c\xbb\xfa\xdeO\xcd\xde[\x02\xa3\x0e\xcbb\x1f\xf9*rh\x9d\x1c(\xc6\x04\xf7\x94\x19\x08Rt\x08\xee\xe4E\xdb\xbc\xd5\xbe\x7f\xa7\x95o\x94\xe3\x08\x0f;\x10\x15\xe1"M\xde\xbe:<\xe2u%]\x18[v\x1a\xb7#\xfdwv/\xbd\x02"\xfdjO\x92\xcc\x84]\xff\x88\x08\xf9\x95\xde\x95\xb7\x13\x99\xbb\xfd\xcf\xb8\xbd)\xa6\xff\xda\xf4\xd6\xc6\\\xc3X\xe5\x93iI,$eu\x13\xb2E\x1bs\xa5\xc0Q\xc2\x96Z\xb3\xdcZi50\x80\xed!\x1aO\x8f\xb0\xec\x037V|F\x1e\xfb\xc0Ig\x929\x1dC\xed\x94U\x96gr\x13\x82\xdf\xf2\x1a\xa2\xeb\x02\x98e\xaaC\x87\xfbl:B\x02\xc2\xe2\xd3w\x9d\xb3\x9b\xcfD\xb5gaS\xbf\xce\xf0_\x0b\xc2\xfbY\xff\xaf\xc9\x8aJ\x1c\xc8 \x98K3\x18\xb3\x94\xd4j%\x99\xcb\xf5\xb9\xae\x03\xdf\x9a{\xfe\xc7e\xe3\x0bq~\xee\\BrK7\xd0]\xae\xec\x12\xca\xfcylR\xd7\x0b\x0c\n\x07\t\xf2\x0b\xe5;+0QG\xf6\x13\xb9$w\xf4N\xbd\x01\x8ehM\xdfJc\xbd\xe6 *\xa7\x9eB\xecK\x18\xa2\x9eY\xe9 \xc5\xdd^\xf9O\xf6\xf16k\xae\xfa4\xb9\xd4k\x10-\x14\xc0,\x19 \xf0\x0ed\x0evr\xd4X\xcf\xba\xb0\x1b|$c|V3\xefg/\x18Z\x10)\x01\x8e+\x063\x05\xb0\xfb\xb6\xf1VvP\xb7]\xdf\x8f\xdf\xc7\x04\xe4f\x93\x06\x13\xb2M\xc1\xd0?YQ!Zp\xf9\xf3D\xb1\xe9\xc4\xfah.l&[1\x9b\xc9/\xf4\x9e|\xe3\x06\xfa\xf8h\x15\xea<\xf5\xc6\xdef\x912(\xe2\x9e9\xdb" \xaf$\xdf\xccP\x17%0\x99\x83\xd70f>\x9f\n(,\x00\x99w\xee\xbd\x9aN\xe3\xff\xd75\xd98\xfb\xc6G\xa9$%\x98EV<\xbc}\xab\xb9\r\x81p\x1c\x0f!\x8c1\xbc\xc1$~\xc8ll\x89\xbf\xa4\xa0\x03\x82\xff\x1f\x91k:\x80K?\x120\x03\xfd\x8d\x1d\xfb%-\x86M~\x1fzJ\xdc#G\xbbU\x10\x84\x834o\xdd\xe5jt\x11\xd0\xf6\t\x12\xef\x8e\xc9\xa6\x8b\x95\x14z\xbcv\xe0\xff\xe8^\xea\x0b\x8d\xc5\x9c\x9e\x0bR\xb9\x8b\x0b\xfc`\xfb\x943^x^o\xd6\xe3\x1f\x7f') diff --git a/collector/core/gripper/sightac_sdk/api_new/touch_sensor.py b/collector/core/gripper/sightac_sdk/api_new/touch_sensor.py new file mode 100644 index 0000000000000000000000000000000000000000..4559b12114f05dbea3dd8e7cc83483691fe248d4 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/touch_sensor.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:48.262443 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\x96\x96\x00\x00\x12\t\x04\x00Qj\x07\xf7Q\xe2 \x84\t\xf4\x8fh\xf9\x89\xba?\x00\x00\x00\x00\x00\x00\x00\x00\xb2\xd7\x1eW\xcd\'eb\xcdQ\xbb\xd0\xd2\xe2j\x82$\xfd\x1az\xf5R\x84\xaeJZ\x18\x00.\xb8L\x9d\x8adg: \xf8M?\xc0\x13\xc5A\xee5N\xd3\xd2\xce3\xa2WG\xe4\xa3\xa0\x04\xdd\x89\x02\x08\xf3>o\x9a\x94\xf8pDs\xc9[\xaby\x1f\xb94t\xe8cr\xf5&\xa9S_\x8ds\xfa\x1eb\r\x1d\xe3\xac\x97\xe7\xdcs\xde\xf6\xe8}\xe8\xbd;{\x9cW\x1e2\xcb\xfe\x1af\xdf\xe2/\x04k\'.\xf7\xeb\x1dg\xe0\x7f\xb9R&n\xb0\xf4H\xa4\xd5j]\xe8\xfda\xe3\x8d\xaf\xe4\xbc{0\xd5\xad\xadf\xc0S\x15-\'\x8a\x0bL>\xc8\x15\xb2\x15<\xb7\x96\xaar\x80w9\xa4%xf\xaf\xc0 \xba\x0c\xe43^,\x10\x86\x05]]\xed\x01\xd3q~\n\x90\x11\xb8\xfer\xa5Y{D\xd0\x8c\xd8#~\x8dG\xd9\xb4:\xc8\x8a\xf01\x9a\x81\x1e\xb7\xbf\xfa2\x9e\xd8\x85\x88\x97(\xc8j=xd\xf1\tb\xff\x83\xe4 u\xa6\xb2f\xc5|\x13\xcbV\xda\xc9{\x83#\x1f.\x97\xf7\x05\xf3H5^\xdfm\x8f\xf5\xc5\x9ev\x93\x05\r\xc2\x92\xf9*W\x85\x1a\xab\xde\x91b1\xa7\xbd3\xc4\xffu\x0bD\xfc\xdch\x19\x0c\x0eL<#\xfd\xb8\x08\x90\x15"AraR\x81m\xd4k\xda"\xa2\xbd }(\x9dr\xbd\x1e]W\x08;\xd5k\xae\xc3k\xe3\x0e\xfe\xc3\x03\xd8wF\x9d\xe8\xf1\x01\xeb\xbbeM\x05\x047(\xfb\xc7\x9e\xe2\xf9&t\x99\xcd\xbb"P\x9aP\xcd\x8d\x19\xa4\xfa)@\x03\xe1\x80\xa0A[\x02\xb5-VGw\xd6\xde\xa1<\x7f}\x0e\xa7\xb5E9\xbe\x0c~<\x00D\xe4\xdf\xb5\xf5=\xf0\x9d>\xec\x06\xd6\xd8\xfdR\xe7qp\x16\xff\xcb\xc61oI9\x80\x80\x97\x11\xe6\xc9k\xd1%\r \x0e\xb9\xfce^\x91d\xe2Y\x07\xf3\x17IX\xf2\xc4\x10\xb2\xf7\xd1I\x97m\x99_AAr\xf1\xb0\xc3S\x9ci\xfc7!\xc6\x8a"\x97\xafP\xf1K\x90\xed\xc3\x04\xbbCn\xda?u\xe2\x81\x05\xc0\xa7P1\x12\xb3\xa1l\x8b\xb2\xf7<\xf6;\x06\xac%o\n\x91\xb5\xec\xe8\xa5\xf9871\xa9zm\xb6\xc8\xc8r\xd3\xd9\x1f\'\x80\xef\x1a\xa0\xca\x0f\xd2\xb3\xd4\xc5\xfd\xbdZ\xc12\x81m{\x98\x8d\xbc\xed\n\xb6:\x15(\x91\xcb\xed\xd9\x9a\xac\xfaV+pO\x9b\xe8 \xa7\x8cR\xe2\xfe\x1a\x9d\xd8\xa5\x08\xa6\xe3\'\xa13\xdd\x8f%%!\x8d\xddc\xdc\xf0\x82wPP\x91\x19\xa4\xea\xef\xd1\x0c\xbd\xe1\xa1t\x181\x8f-\x8f\xf2\x1f\x16%l\xc1\xb6N\x1f#<\x9f\xd6<\x06\xf3\xab\xbb)\x82d_\x91\x01\x06\xadg! \x17\x11\x93k\x15\xe3\xf4\x9b\xfe\x97ly*\x19w\xfd\x1c\x073-\xe0>\xea\x01\x16\xc4\xec\x80\xd7\xee\xefM\xff\xe3\x8dhy\x03\xd7F=`\x8a\x00\xbc\x0c\x94\x15HU~\xa5\xeb\x971\x8a\x8f\xd9\x93\x10\xb0\x0e]x}\xb3&G\x80#\xfb\x95A\xe2\x07^\x8eX\x0f\xf7M(X\x8d\xc2\xdd\xd4a\xd4\xc8)=v\x00A+\x92\x8b\x053\xbez\xd1\xaf\xce\xc2{\xba5\xda}^:5\xca\x01\xecFD\x7f_\x14r\xd2\x91\xef\xd8\x18"\xda\xa1\x98Z\x86-\xad\xf70\xc8\xb1\x92k\x82\x9b`F\x97i\x16\xb5\xd0\xdb1\x80\x81\xff\x811\x94\x1a\x981.\xbdg\x99\\\xf4P$E\xd5)\xdaLq\xd4i\xd9}\xadET\x95\x1aIq\xf4DBak\xab\xa1^\xf6z[\xb8\x95GF\x83\x14\xcf\x9f\x1c\x9d\t\xe10%/\x8c\xeb(\x1aD\x96\x91:\xc8<\x12\x98G \x0b7\xcf\x86\xa0o\x95\xac]fxGb\xf3\xb2\xbcl\x82Gy\xb4\x03\x08\xa1\x03]\xeaS,\x9a\x8c^Nr\xb9\xd0\xd5a\xed\x15\x0f\x0cL\x84\xa3S\xf7E\xf7\x1d\x9f\xd6\x8b\xe9\xc7\xb1ch8\x97W\xf5\x9eE@\xa8\xf5r\x81\xb8\x17\xea\xa5\x1f\xc4\x9b\xc3]\x1f\xc8q6*m\xf7\xf06X}\x0f+\x1a\xa8\xe9\x97\xcc57J\x07Tn\x8b\xad,\x9do5\xb4\xcc\xa4\x08\xd1C\xe5\x0c\xa6\xbe\x1fW\xe2kZF8\x0f\xa0\xc5\xb1k~\x9fC\x85=\xb7x\x95\xd17C\xd7\x94^\x91\xe0\x8a\x7f_\xbb^\x02\x01\x82\xde\xde\x93%\xdaM\xb7\x12\xe2\xcdi[\x08\x9d\x90\xd0r\x04;\x8a,<\xe954\xae^D\xde\x7fB\xc3\xafY\xccCd$\xc0\xd9\xa8\xaa\xe8\xac\xbb\xde\x9d\xd2\xd1+\xbf\xe1\xedR\x13\x8f\xa1M\xa2j\x184\x8c\x80\x9c\x91<@\xa5\xe0~\xf1j\xe9\xec.8\xe7\xb6\xceW\xba\x03\xc1/\x00\x86,\x1d\xe4\x14\x19\xecO\xd8P_Q\xcf\xee$\x03g7\x15\xf7\xc7\x00\xba\xb7}\x9f!\xd4T\xa2X\xda\x9a\xc5R\x81\x98z\xf4\x0b\xaf\xd2WY5\xc0_!\xddw\xef=\xe5C\xa5@e\xb0\xe18\xe4F2\xc6G;dw\xea>\x90\xe5y\xf7\xd7\xe8\rK\xf8f\x13\xa4W\xb8)\xdb\x16\x93Vj\xb6\x9e.\xb1\xe64a\xad2\xd68\xc9\xe2\x97\xf8">\xb9\x80\x9b\x93\xbe\xea\x91\xf4]\xff\xd0!\xce\xf7>\tW\xf29\x06\x07$\xd2\xc0\xd8\xac\xbeF\xfe\xf3I\x14\xd5\xe3m\xb4n\x1a&\xbb3j\x8a\xaf\xc2\xb9M\xf0\xfc\x90\xd4\xec\xaf*\x8d}\xf8\xc5\xba\xd2\xf5\xa2\x8c\x91\x7f\x90S\x84\xe7z\xb1\x92{\xa6\x7f\x0b\x17c\xef\xe10\x1b\xe8\xc4\xe4\xe2?L\x88\xf9\xb5!\tA{\xbe^\xc7\xbf\x9c\x98\x17\x19{\xd5\xeb\x1br\xaf\x81\xa6^\xeb\x9c\xf9\x88+E\xb3\xbc\xd3\xf2=\x7f\xdc\x08l\xfb\x956\xa4\xb4W&>\xc6\xba\nz?\x16\xd5\xe5\xa6d{\x1b(?\x151\x14\xc7\x80\t\x1c.mv\xaa\x00\xed$4\x85rp\xfd\x19a\xb7\xdd\x0c\xb0\xf8\xdd{r\x7f\x8bU^\xe7w\xd5\xf1\xa3\xd2\xf8\xb5\xea1\x1eL\xa7hd\x840r\xb8(\x83f\xce\x97\xdc\xb9\xaa\xc12m\x9d\xc8\x81v\xe3\xad\xba^\x9b\xd2\xfc\x81\x86\x89\xc4\xe0\xe8\x04\x08\xe0\x98D{\x86A\n[\xc5\x94\xec\x07\x00\x88?\xda\xcc\x19\xc7&\xc7W\x15\x9cUD\xb3\x8fV\x02t+\x7f\xed~7\x8b)~\xb9A`\x8a\xd1\x80\x07qr\x8a\x8df\xd1Q\xea\x8f\xdb\xcd\xb5@f\xa7\x8dd\x19\xe7\xa3\x8d\x9a\xf4\xde\x03=\xca\xdf0\xd2\xa8m \xf98L\x12\x01%\xe7\xe8\x99WG\xd8\x0b\n\x1b\x1cd\xa37\xfa\xb0K4\xa0\x95\xae\xaa\x0b\xd6\x81F(I\x1a\x91\xe2\x1a\x02\x82\xa86\xad\x94\x06I-\xb4\x8f\xb4\xfe"V\xf2\x1f9{\xd5 \nY\x0bT\xdepmV\xda#\x06\x95o0\xe97z\xdb+\x9d\x02\xab#\x82\x0e\xadg\xc5\x1aQ\xc1\xaa\xfbX\x1d\x86\x01\x9d\x85\xf0Tl\xab[\x7f\xc8\x1d\x18\xf5p*\xdfs$!\x86\'\xc1d\x05\x97\x87\xff\xff\x1a\xabj\xc2\xf6\xa4\xb8\xc5\x8b\x02A\xb1?\xe2\x131\xf4\xf9\xf2\xd4]\xdf\x9f3<\xb4\xa5S\xbb\xf2\xe2\xc7\x89\x05d\x1a-\xa5\x03\xc0\x19\xeb\x90!\xa6v\xa6\xc0\rS\x01\x8af\x95\xc3\x92\x8e\xa24\xec\xfd\xde\xa0\x0c\xb0\xef\x1c\xbbD\xe1\xc8[\x18hOD\xc0\xa0\xf8`\xfa\x1a\xd5\x83\xf85\xd48\xbb\x07\xd4\x8e\x89W\xfbv\xc5\xf7\x1a\xbdQX\x86\x05\x99\xa8\xab.u\xb6\xdc\xf5r\xb1\x0c\x83;\xa3\xab%\xd4a\xf0$a|\'\xee{\x1d\xcb&S\x1e\x80(\'5_@\xf1\x7f\x97\x0c\x15>\xae\xc1\x19z\xb91\ri"\x17y\x03\xde\x86D\xe7\xf7\xb5\x8b\xd2\x8b:\x0b\xb6U5\x7f\\gN\x16\xefF\x96\x12Iq\xee\x89\x1c\x95\x9dY\x10a\xcd\xa9G\xa1\xadJ\xe3\xbc}v\x89`\xdb\xaa\nXb\xc6\xf3\x8c\xfbr\x08\x80\xa1Q\xfa\x81\xd5e\xa6$IJ\xde\xc6\x0c\x89u\xc4\x16psB\xd0\xdf\x19\xd8\xc5\\\xc6\x91V~\xc5\xdda\xc4\x1f\xbd\xf9\x89\xd6"n}y\x9bI\xae\x92\xa3e\x0el\xecS\xdf\xe7\xdd\x1dm\xf7 \x1bgW\xae\x9c\x08g\x9d\xa7\xf7\xe7\xa2\x86g|\xf0g\x11`uZ\xc7\xda\x18\x17H\xd5\\\x84d\xaf?\xad?`\xb5\xec\x1d\xde\x1bU\x12\xe8M\xff!\xcf\x01\xc9\xd1\x9f\xabN\xad\xcb5@\xd1Er\x86=\xb4\x9d\xff\xdfr,\xa3_\xfb\x99\xb6\xab*\xe4Z\xcci&\x89C\x85\x82\xffku\xddcf\x84\x9e\xb2\xd1C=\x8c\x15sUoI\xf9!\xa9Y\x04\xf0\x8d\xdb\x13(\xd1^\xf1:U\xf5#\x85E\x95d}dH\xdd%\xe8\xf0\x7f7\xf8\xcc\x07C\x155\x98 v\x8e$u0q\xf2s"\x12_\xb6\x97h\x08\xd3\xbfn\x84\xb4\xf0\x1c\xa3{`Gv\xe3\xc6V\xa1\xa8\xf6]\x07?\xa35\xe2\x176\x85\x96\xfb\x18\xaa9@\x9b{\x87\x93/\xf0\\\xef\x04\x17\n_\x08 \x10F\xf29>\xaeb9\x00\x06\xef\x9f^C(\xc0\x185\x1bcZ%\xcf`=6\xf3\xb8\n-\xd5\x9f\xe5\x16\x17\xb4M\xc4I\x0f\x18i\x0f\x9e\xb6\x9e\xd4R0\xacpT9\x86\xc1II[\xda\x0c4\x99K\x18\x1a]\xced{\xc4\x83\xcata`\x8d\xac\x1c\x02\x95\xa12\xe26)\xd0\xadj\xf6\x18O\xd9\x1f\x9f\xa2Hm\xdfW\xc2\xf7\x9c\xadv\xe10\x82\xbd_\xf9\xbd\xc7\xaa&\xc9s\xfaA\xdd >\xbb\x04A2^=XX\xda\x98\xcb?<\xc0V\xb9\xaeO\xa6\x1c\xcez\x8f\xa3\xd1tq\x96\x14*\xa6qs\x96\xbe\x9b\xf3\xd2\x069r_\xc8OVW\xd2:\x19\x95+\xe2S\x10s\xd2B\x05#\xbc\xf8\xe3\xf2\x84\x9b\xd2kq5}\x9d\xe4+\xe8q+G\xfaH\xdf\xe4S\x04\xc0\xf8\x92\x00\xf6\xb9\xf8\x8b\x8f\x00\xdeCh\xf5\xafY\x0ejQ\x89\xae\x8f\x7f\x05s\x07\x81:9iI\xac\x1e\x07\xb5\xe6\xc3\x9e`\xe7\x06\xb4\xc6Z)\x9b\x81\xba\x92\xb2\x18\x11\x16%\xa8\xa2\x8a\xda\xc7\x9a\x0c\xce\t\xfcj]\xdf\x81\xd5\n3^\xa0UW\xdd\xd8\xe2"\x8c\xc8\xfd\xed\x8c4\xec\t\xbeL\xdd\xf8ZI\xc7`^\x19fZb\xf5 \xf2\x7f\xb9t\xde\x7f\x0c\x03%\x13\xff\x86\x93\xde\x97\x1fS\xd71\xfe7\x12z\xe1\xd3@\x87\xeb\xb4\x0f\xd6\x1bA\x90r\xd6\x85\xc9\xc8\xf0\x05\xe9j\x1dc\xd1\x18s\xd5\x0b\x10\x90\x00\x99\xc2\x9f\xd9w}\xfc\xb5f\x11\xcb\x05*\xc9M\xa3s\xdc\'#\x03\x07\xf6EL\x8f(r\xc3\x8ay=\xb4o\xbf\xe5u\xb6\x8c\xdd\xd9@\x04\xae$jvk\xd8\x01@\x128\x83\x918f\xb0\xc8\xba]\xb4&l\x8eb\xf5\xa2p\x98\xb4\x12S\xcbq\x1e\xa6ci\xa7\xa7\xaf\xba\xd9\x15\x16!\xe2\xca\xc9\xa6\x1a:)W\'c\xd8\xc1\xc3\xec\xa8\x90\x1d\xee\xc1\x7f\xa3\x908\xb5\x14Rp\x90\xea\xbd@\xfdzK\x86\xc5\xbc\xd4B\x8d\x98{\xfd\xa1\xf3\x80\xae\xec\xb8\xb5\\`Zk\t\x96\rR\xb2@g\xfd\x97\xbeg\xc2I\xe6\xcd\xe1\xbd\x1c\xa4\xfd<\xfe\xc4\xf1\xb2\xc8\x99\xf2A\x7f#\x95\xfa\x7f\xf4\xcb\xfa\xe2\xf8\x0b\xf1W\x91\x1b\xfeB\x8e)\xe6m\t\x1b_xD1\x8a\x10\xef"\xe9\xe1\xa8\x1c\xf54/5\xb0\xd1\xfeR\xfaq|>\x84.\xeba\xea\x82&60Ou\x9f\xb3_\xd2\xe9L\xe3\x80\xe7\xb31\xec\xeb\x87H9\x9a\xb9\x94;E\xfb\x83\xdc\x1d,\xb8\x04\x93]\xf8`I9\x916 \x1c\xf8"\xf0)\xee\x0e\xfe\xa86$\x9d\xc0\xf2\x1a\xfd\xb4\xb15{=^\x94\x80m\xde\\w\xf7,\x1c\x8a%\xfd\x83\xe1\xf6\xc8W\xd6\x1afv%]\xa0Y\x0c\xe8/\xa8!\xa1\xaf\xa2\x82J\xae\xa7q\xa5\xc9b\xdc\x99\x96\xaf\x91c\xbe\xbb\xec\x85\x05)\xde\xb3\xd2 \x19mb\x88r\x0eW\xe4\xe4c(t\x932\x8b\xb4\x0c\x117\x06<`k\x93\xa1\xf1j\xb4Q,\xea$\x84;[\xd6\xc0\x05\xba\x1c\x8b\x9a=\xc2\xddA\x10\xae\xcb\xa8\xe2I\xb2S\x05\xb9\xe05-\x1b\x17l\xb7M\x89\x15\xcf\x1d\x8f\xa2\xa0\x8b\'\xc5\x10.Ih\xab\x88\xff\xb9hU4\xc9\x97\xad\xb8\xfe\xb2\x1c\n\x05\x8bI+\xab\xd0\xe4\xaf\x0b\x99\x9c?\x87av\xfd7l\xaa\x0e\xc2t\x1e\xdfW\xce\x93\xc5\x0fV*\xce\xc6 p\xd1\xf9d\xee\xa1\x0e\x84\x04\xdc\'\x11i9\xfbT\x83\xc9\xccV\xfd\x9e\x86\xabD\xb1r\x96\xc3$%\xa6\xec\x86\xed\xe4\xc1qwc\xdcdf\x89\xdad\xb4\xffR\x9eF\xb8\xb38Y\n>@6\xef\x8f\xd6\xe4\x9e\xc6\xfdD7\x18\xf3at\x93I\xe0\xaf!8y\x00\x05n\x9f\xb8fo\xb85\xd9\x08e\xadT\x88$\xbd\x1fx\x0c\xca\x8b\x9f\xf5\xfa6X\xaf\xd5f(\xbc6\x82]\x965\xadU\\]\xf0\xc0b\xfc\xb2\xe9kgO\xe1y\x8b\xb5\x83*\xe6\xe8\xecu\x0f\xc3lO8\xdd\xdf>\xa6\x84\x1e\n\x86i6\xdeaA3\xf6\xb4\xc3r]\xe8T\xe6>\xc1@n\xd0\xe5G\x8fV\xe0\xab\t%%\x8fla\x8fL\x0b\xfaf\xffN\xb28\xc2\xc1H\xb4m\x99\x1c\xcc\xbc\xa5IRJ;\x12@\xab\t\x8f\x06ar\xb1\xd3\xf2q\xd9\xb2\xe43L\xb4S]/\xd3u\x04\xe3\x83Q\xa6\xf9\xa1Gl1\xd3\xde\xa8@\xa99\xbb\xc2\xe8/\x1aX#O\xfd\x8b\x0b\xd6]\xb3\xc3sB\xb6B\t\xa1\x87K\xc4`\x1c\x1b\x1b\xbd\x8b^\xd8\xf6\xcb\x11\x03\x92\x98\xbb0#a\x82\xef\xcblw<\xc21,\x11mN{\xbdB\xfc;*\xdfk\x90\xfb\xcd\xf9\x06\x03\xbe\x00Zf\xa7\xab\xf3\xd5\xf9\x93>\x8d\xcd\xdf<\xbe:c\xb7\xe0`\x81\xef\xb7\x9b`\xc2\xf5\x1ae\xb1\xd4\x1e\xf5\tXDV\x047\r\xdfw"\x112\xcco\x16/\x0e\xec\xdc\x05\x07\xea\xaa\x81st\x00.\x15\xf8\x98\xcb\x8f\xf2+ \xdf\xa3\x10\x85\x831\xa9\x88\x10\x85X2y]`\x14\xa9A\xb3v\t\x14\xd3\xdd\x91\xf7\xf3\xef=J\x8fr,\x08=c\xc6\\\x0c1PUu<\x08n\x9c\xf6{\x92~|4\x84\x95\xd75.\\Rb\xd4u\x93\xb6\xdf,fy\x9a\xf4D\x89\xb7\x04\x9eK\xecci\xfb\x95\xe8-\x11\x95,\x19T\xf7\x82L\xc8K\xcc\xb3b\x0b\x88\xc9z\x8b\xfb\x00\x90\xb5I\x19\xe2\x1f\xafUy\xb4\xbf"\xe0v\x1e\x15l&\xbd@\xd3wY%e\x95\xb6\xe0\xc8D\xf0\x05+\x84R4\x1d\x96\xd2\x1d\xe1O\xfb2\x1a\x83\xf9IpU\xed\x00<\xba\xc3A\xb1\xa1c*G\xe7[\xd1\xaeZ\x16\xa6c\xcb\x95\xbcX\x8f\xb9\xfb\xef\xc8\xa0\xd6\x0c\xeaC\xc5#\xf88\xd8\xcb.\xa6\x84z\xca\xf7q\xb3\x89Y\x0fA6\x13\xd4\xd1K\xda\xa8\xbbu\xaf\t\xc6vKZdM\xe8D\xcbx\xa7\x02I\x0b\xc6b=\n\x94\xe4J\xf2;\xeeY\x99\xae\xfe\xc4\xabBfX\xdd\xe9\xa0\xa0\x13R\xec=Z\xf0\x12\x840\xa07Nq\x7f\xbd\xf5\xf0\x89\x1c\x13\x94\xba&\xaa\xa5\x15\xfb \x05F\x1d\x8dv,CM\xc5l\xb5\xf9k+]\x19m\xf0\xd5}\xcd\x11\xcf\xb1\xd8\\\xf8\x94\xb5z)R\x8b\xbf8\xf3\x9f2\xa6\xa9\xc44^\xe3\xc3?\xd8\xa8\x08P\x7f\x87\x02\xb5\x8c7\x9f\xa5\xff\xbfi\x9c\xe5B\xe2\xb4S:\x96\xd9\x93TI\x08d\xb8z\x93\x06d\x8e\xb9\x8fYk5\xa9\xdb\xa9\x87{f\x0c{\x12\xd9\xa9\x0b\xcc\x89\xf7\xcfoa\x90\xac\x08\xe6\x83E4\xd1(\n\xda\x12\x06+\xa8\x1d;Z\xb0\x82\xe8\x8b1e.\x17w\xcb}\xaf\x19\xd4<\xf7B\xf8\xee\x89&\xf3h\x10Cr\xe8\xbb9\x8f\xb1"b\xb9"\xce\xb0\xe3\x86\xb2O\xcb6\x82\x97\x8f\x12\xb9\xf0\xbb\x86\xc7\t\xdb\xc6\xcd\x92\xf7B?|`j\x00\x8b1\x9d\xb7Y\xf8\x1a{\xd9\xc8\xc9\xfb\xd2RfU\x94<\x87g4\xab\xd7S\x81N%_\xae\x7f\x8e\x1aS\xa6\xea\xe1\x92\xa8]\xbd\x055\xa1\x83\xc9\x1d7V\x9d\xf6\xdb\xab\xd8\xd3\xfd\x9b\xb6\xfe\xa5\x90\x08\xa1\x80\x95\xfb\x88l\xaa\xcbb\x89\xe7gI\xee\xf5F\xc2\x98JT|(\xda\x8a\xe0\xb2s\xf4\xbf\x87\xecZr\xc3=,b\x9c\xfc\xc8\x10j\xe8\x1d30\xca\xac{\xa6\x85\xe3ZU\\}\x18\xec\xb6=\xb3qZYK\x9b\x8d\xb1M\xf5H\xdf\xb3\xbf\x9a\x0f+\xf9\xfa\xb1\xe2}\xe9S)]\xaf\x8e\xf6\x154`\x85\x90v\xff\x85j]\xce\xc2\xe7\xee:\x9e\xb2*\x10\x1f\xa93iQ&\xd6\x98Q\xfb#\xd3\xdc#\xad_b\xd8\x11v\xcb?\xef$\x96\xc5\x87qdx\x88\x92\xfa\xda\xcc\xde\x83\x0eL\x86\xe3X.<\xa2\x02\x81\x0f@\xf4an@\x0f\x00\x939?"\x884\xaa\xdb\x84\xf1.s\xe1\xf0Vy\x08\xaf\x92\xd2\x89?\xde\tR\xc1\xe6W\x1a\x0e%\xcb\x01\x9c&2\xd0\xd6K9\xdd3\xa9D\xb6\xa74\x891Q\xbd\x0b\xf1\xb5\xe1\xc9O\xff2\x1eN\x1f=h\x80H"/\x0e\xa5\x9b\xf3K\xde\xa9\xcb\x07\x93\x9c\xe1\x19F\x8b);\xdf\xff$\xa7\xfc\xe4\xea\x01D@\xc3\x13\x98kn\x90\xab\xd6\x06\x0bT\xad?y\xd1\xe3E;\x18 \x97=\x96\xf3\xf0\x00\xc6\xe7\x1a\xa3\x9d\xf1}m\x13\xde\xf1\xc6\x86\x86d\x86f\x1em#\x951\x80\xf6"A,\x1e\x80\x87\xd0\x9e\xae\xb0@&\xf0\xaf\xf2\x96\xbfN\xc0\xdaO&\x01\xa0\xc8\xa6\xc8\xff\x06\x15\x06\x01\xd9f\xf6\xf4\xae\xde\xba\xf4\xd1\x14\x13S\x88\xf1%\xc1\xff\x81\x1b\x9dz6\xa0\xe1\x99\xf4\xc1\xd7\xcdy\x98\x8a<\x85U\x01i\x1d\xb9^5\x81%K1\xe0Z\x7f\xeca\x84J\xe1Fg{\x9dn\xff>\xc0\xaf\xdf\x10\xb2LT\xdczA\xbc\xddP#\xf8}?--\xa5\x8fR\xc0\xb68[\xc1\x18\x7f\x1f\x14\x1fiSI1\xf0\xf3\x10\x0f\xac\xd39\n\x9f\x0ba\x04\xed\xe2\xe31\xc4v\xfe\xce|\xaa\xc9\xd4\x85:]\x05\xa0GM]\xa3\xec+Ic\x91x]\xa8\xc6\x8cV\xb0\xe0\xc5\xcap-\xc2\x95`\xa2\x90v&9\xcb\xa5\x04=\xe8\x1b\x97\xbef&\x80A LVZ\x16\xa3\x80,<\xa1\x8c\x1c{t\xb0\'\xd7u-Y=\t,\xb8\xb1i`\xef\xeb\reY+\x9eEj\xa6|.QG*?x;\xde\xe8\xef{\xc9Jz\x06\xab\x08~\x1e\x1d\x81\xb1\x926\r\xdcNS:\x80^\x7f\x9az\x16\xfdL\x1b\xbeNhQF\x17\x8e-\x03\xdcGQ\xea\x1f\xc0\x0b\x14\xe5\xee\xf9B\xdf83<\xaf+\xd9\x97\xff\xe8\xe9\'u\xc9<\xb1)\x01\x9e>\xaa\xb3\xad\xbf\x98,\x8e\x9bu\x9a\xe4;\x94\x11\xb97}\xbc\x1cx\xf9=\xbd(k\xecKJ\x15\x03J\x7f"\xd8:q\xf3z\x7f\xd3\xbb\xc2\xcb\xa17\xde\xdb\xc9\xdb,\x12\xea\xea3\xc3N\xaed\xde\x06&\xf6\x93\xc9\xb2\xc6\xc6\x87}\x1e0\x7f\'\x81\xfc\xaef\n\xf5\x98={\x0f\x03\xabT\x14\xeb\xa6aF\x92\x05\xde\xef.+\xa28\xf2\xfdVf\x9e\xbfJ\x9f>\x88]\x14(2\x07\xa8\xed\xbab\x11\x91\xae\x19\xf8\xb8\\\xbe\xc00\x08qf\xd6\x81I\x969cV\xdeJ\xd8\xe6)-oJ\xd3o\x94j9\xe4\x89\x0e$\xed\xe2\x82N`\xd4\x84\x9a\x02IYb?\xe7`\x84\x18\xe5\xf8\xed~\x88\x13\xee\x1c\xf4\x0cp\xb1:\xd0\xd8w|\xda}z\xea\x99b\x0bz]\xf2]\xcd\x8c\xad,\xd8-\xebkR\xe1\xb2D<\xd0\xf6\x93I\x00\x81of\x88\xfd+\x1c\xfa\x9d|R@\x0c0\xef\xf5`\xb3\xe3\t\x15t\xa3M\x93-\xef\xa6\x96*\x8bbX\x8f~v\xc6C%%o\xff\xabn\x00\x07!\x00V\xd2\xc5\xf50\xd5\xcf\'\x1d\xceNeD\xd4\xc8\xf0\xc1\xcd[\xcc\xa3\x91\xad\xc2 \xe72\xc2\x13\x1e?\xc9M"\xcb.\xb9"c\xafOCy\xacD\x06\x08\x1c\x01\xd6cg\xb5#\x0f\x89X\xad_\x0e\x16\xca\xd2\xfeZ\xb4?\x82*\x93\x90\xfc#\x03\xe8\x9bm.\x8e\xb6\xfd\xec\xa2\xfa\x19\x83"U\x1b\x81\x1fx\xd2\xcd\x0e\'\x9b\xe4\xadb\xc0H[\x90f_\x04\x82\xdc\x98\xa5\xd7\xeb8\xf4\xc6\xc2\x11\x7f\xec\x91\xd8\xc1j\x91.\x13\x07\xc7\xc3\xf2\xc2\xf8\x9b\xd0\x122\xd0a\xa4\x96\xb6q\xdb\x94\xec\x92A\xb2\xe1\xb8\xe5\x9b\xf1\xa5Ej\xba\xdf\x1b\x12\xe0\xab~u\xbeF\xb8\xa0\x93\xd0\xac\xe0\xd1\xdai\x87W6\x07\xf9\x87>\x1f~\x92\x0f=\xf1\x89\xcfn"\x19\xc2\xeaab\x1ea.o_&\xe9\\_\r\xa13\x9dE\x84(\n\xc8\xces^\x82\xb0\xcb\xb6c\xc1\x16\x8e\x1c\x1a\x00\x1b\xbd\xa2\x80x\xef\xcfm\x13\xe4U\xcb&\xfe>\xc8\x97\xacF\xf6N\xd8t\xfd\xb7R9\xe0a+\xab\xfd\x0c\xc97RS/\xbc{t\xdbY\xe2lG\xb2\xb8\xad|\x83\xb5\xd7\x90x\xf8u\xa7\x93\x84\xb0Obf\x86\xb3S\xca\xec4;\xb6A\xb4\x97\x1a\xef@\x1a\x01\xa3\x8cv\xe1\xfb\x87\x1cT\xab=\x87\xf8\x1f\xe7\x12\xca\x82\xed\xa2C\xa6\xe7\xe5Va\xe3\x9e\xa7\xe3\x81\xa4\xcf\xa5\xdfa\xf3\x81v/\xc9\xda\xc2\x9a\xec\xa5\'\xd3\xc7\t\xfdl\xec\xce]\xb9@I`\xd1\xa4i\x05\x9d\x0b?vq2\xff\xe3\xf6\xf9\xeb}\xe6~s\xe9-\xee\xf5\xbc\xcb\xa8\xd6\x11S\xfb\xee\'\xdcu.I\xb0GD\xa6\xf4k\xf2\x8a\x8c\x91\xae\x00n\xdd[\x8c\x02\xa0\xce\x9f\xc3\x18]\xef9\xe9\xdc\xee\'\xa08\xe8\xe8\x18\xd5\xb5\xd2p\x8c\x1f\xed=\x06\xe7A\x80\x9f\x12\x14\n\xc3f\x1b\xb4\xc8\x96\x03\xfdm\x98,\xca\xb5\x87\x0fqS;9F_\x03\xb3\x89?g&,d\xe3\xe9\xf6\xea6\xd2\x1f\xf7\xb7\x98\x7f\x9a\x9f\xcaVg\x88\xf4\xc7\x04\x80\x83\xe4a\xdc\x93\xb5\xc4K\x1a~\xbeqfx#!;m\xf7\x9f]Z\xa5\xd1\xf8\xec7\xd7;R1\x1e\x1dX\x16:i\xcd\x9c\xfb\xe2\xb3\x0f\xd0[\x07]<\x8dO\x055\xe0\x8fx\xaa~\xb8H\xf8\xad\xf4\x92x;\xb3\xf21H\xb62Lv\xfb\x02$E\xc8\xe6e\n+\xd3\x1a\xe7\x99\x8f\x05\x07\xf0\x1e\x1e/\x81\x1c\xed!\xc0\xf9\x13\xedo\xd9\x82|\x9f\xe3L\xa3ptO\xae\xa7\xb9>Sv\xbb\x03\x8bxG.o\xc3\x0eP\xc1\xd0-\x83\x9am\xf2\xf6\xca\xd3N\xdb\xa8\xfe\xe7\x9eH\x15x@\xae\xff\xc3\x95O\xa0\x83\xa2\x93Q2\xde\xf6\n(<+\xc1\x1bQU\xc7\x87\x92\xf4e\xa8\xc4\xa0\xd7\x91O6\xd0\xd7q\x0fPlu\xb6;\xa9\xd9\xc2\xe4)[3\xff\x1dC\xdd\xb36\xe2U\x83j\xa5\xa0Pw\xda\x90 \xb5FI\xc0j\xca[\x9a\x83\x92l\x9a\xd1\xfc\xfa\x85\xee\x8fi\x0e\x0c\xeb?\xca\x89\xaf\x90/\xba\x9e5\xbd\xb4;5n\x91\xe4\x84b\xd5\xc8\xfb\x02\xdf!\x86`\xdd\xd9\xc3: \x1c\xf4\xcbP\xb0\x1c\x16\xc6\xd5\x0b\x89\xf8v\xbd\x18"\xac\xcb\xf3\x94\x7fH\xd3\xcdj$\xd70\x06(\x08\xcd\xcb\x8c\xca\x88k)\xec$\xb0\xbfM4\xbdb.\x7fe"\x9f\xae\x8b\xf4\x17\xf3\xa0\xfbWV\x92\xbf\xa2\xb1w\xddi\xd5G\xde&\xa7\x8e\xb9a8P\x86\xf7_\x97J,1\xec\xe4~\x80?\x0b0\xa9]\x9b\xecN\x9e\xab^\xf2H\nP\xd2\x97\x937MA2\x8dZ\x14\xfc\xf0\x82[\xff8\xec\x96i@X\x83\x02:{H\x1d\x92\x9a\xa8\x86\xc1\x1b\xad#\xe2\xe5\xd4d\x81GPJ\xda$Z<8\xfa\x17\xaf\x08\'\x1ci\xfa\x9a\xed;V\xee\xc2_\x80\x9c\x98R\xfa\xd9(\xf5\x98[\x084y\xa34*\x17\x00t!\x95&xb\xe1\xd3\xc7\x93\xf4\x06\x13\xc3\x03&.5\x1e+\xf1#\x8e\x96\xca\xbb\xab\'?\x15\xa5\x9b\'y\xa2\x03\xc8\xf4\x9a\xeaK\x84\xbe\x9b\xcfu\x8e \xd8F\xa8\x96;\xb4\xe9\xec\x86Tx\x1bNc\xb1\x93^\xc7R\xf4\x911y0\xb0\'g\x0f\x8aMk\x81\\ieH{\x8f2\xd3|3 \xf1\xa3w\xd4<$E]i\r/\\\xff\xee\x80\x95\xae.\xe0[\'\x03\xdd\xc0\xddM\x1f\xad-)&\x03{\x14/\xdb]\xa8|\xa7\x94\xe3\xdc\xd6\xd5&2\x83=\xf4B\xcbk\xc9z\xf1\x98\xa1CE\x8c\xba\xd0\x06\xcf\xb8\xb0U\x86?\x9b\xe4q%nB!e\xc5\xa4\x99\xd7\xa1#\xd2\xdc{S,T\x9aJ6\xb1\xf0Q\x91l\x91.\x12\xe8\x7f2\xcf\x12-gJ\x11\x0f\xc8\xa0\x93z\xfc?D\xfdA)\x84\x99\xc0\xb9\x07\xf4\xa33\xb782Ci\x1e!7\xda\xd0\xa5\xc3c*\x7f\x8fF\xc2|\xc0\xcb%\xf7\xeb\xda^\xc9c>n\xdc\xf9\xe3\xd2\x94d\xb8\xee\xf8Ol>0(\x85\x15\x92\xc3)\xe9\x1d<\xcf\xe8[~\x1b\xba\xcfq\x10\xda\xe2\xc5\x84\xb0\x9c\xc3U\x81\xff\x98G\xde\xc6\xc5\xe5\x1c;^\xfeU\x82\x17Z(bP\x9b}\xf9\xee};tcV6\xe5d\x90\xb11r\xf5\x08\x9c\xb1Q\x11[Ae\x0ex/\'^;\'\xe7\x14\xa9\x9f\x9f\x9d\x19\x11W\x0eP*\xba\xe5\x02\xaa*A(r\xa2\xe6\xd5\xd7\xb0Z\xbdj\xeb)m\xefnF\x05T\x06\xd3\x1a\xfd\x18\xfaic}\xaf\xe6!l4\x04t\xa3\x90\xc1\x15\x95m\xe8IW=C\xce\xa9\xd7\x1e\xa5\x92=mNW\x06\x1c\xe88\x16\t\xa9\xaf\x1d\xe6d]\x10\x98u\x13h\xad\'e\x9c\x90\xbd\x83\x18\xa6\xaa\xe2\xe9\x85\x92\x85\xbf\xefhQH\x0f\x93\xc5KC\xbe\x12\x06c\x1a\xfc\xab\xaa\x0f\xb7\x9d\xdc\xeb\x02\xd9\x08G\xa3\xdb\x91\xd5\xc6$\xac[\xfd\'\xc5\x996\x7f\xedH\xea\xa6\xf9\xd0\x17B\xd9\xc7\x0b\xc8\x7fF7\xf4L5\xceW\xbc\x8f\xa3\x8aP@\xb0\xa1\xd6\xa2\xbd\t\x13\x80)\xd8\xaa1\xcc\xa8\x92\xdc=\xca\xb4$b\x04|\xa3\x07\x85\xe4\xcc\xc8>2@\x9e\xa9\x1f\x0f=l\xf8R\xadD=j\xe0\x95\xee\x87EVS\xd9U\x94\xfe\xc5"\xb4E<~\x13\x98Qk\x15=\xbf\xdd\xee\xd4.\xe33dbst\x16\x1a\xb50\xa3\xc9\x04\xa5`\xa1\x18\xcb\xdfb!\x89\x8f\xb2\xd1\x0c\r\xc6p\x98\xaf.\x1e{ZM\xe18\x7ft\xdb\xa2\xc4\xa18\x8eS\xcf\xfc G\xe6\xb0d\xf9w\x0f\xa0\x1c\x0e\x0c\xf1\xd5C\x18D\x0e;g\n3\x89p\xc7H\xb6%T\xf9\xe5\xb69\'\xa9\xcd\xb3\xab\xe4\xc4\xc0\x8e5\xaczN\x89p\xfc#\x951\x93v\x1af\x99i\x835&\xe4\xb6\rO\xfd\x0e\x96%\xe4\xe7\x1e\x14\xf5\xaa\x19\x90\xa4BN\xfa(`\xf41)\xb5:\xe0\x88i^\xf8Kv\xa1\xe1\x1a\xa2\x153\xa8E(\x14cjF0\x8fI\xc6aM`f\xf3\xac1\x01{uD>\xa3t\x03\x8e\xdf\xf5\xdd\x92f\xads,\x12\xf2\x9a\x82\x98U\x04!\'\x83\xaez2\xf8\\,)\x0e\x8f\xb3Q_\xbfw\xfd(\xcd%\xb9HBr\xfex\x18\xfb\xd9\xde\xb0\xa5\r\x1duDG\x01\xc7}\x8e 1\x8cxY\xec\x1br-\xc0p\xab \xa2v\t\x021\x7fB\x8e\x9fYA\xf7p\x1b\xffW\x00\x13\x9b\xa3d\xa4\xbc\r\xb8S\xb0Z\x05[}T\xde\t}\x9b\xb89\xd4\xd6m\xdd\x03F\xd1M\xc2\x7f\xd2\xfe\xcb\r\xbc\x81:\xbf\xc4\x17D&\x90\xf9}\xc9\xfbU\xfa\\\xed\xd4\x88\x96Et\xb5\xae\xbcT\xe9\x08F\x86\xc5\xea\x95\x96\xaeh\x9b\x9d\xffw\xde\xcbR\xff\xa8\xa3\xee\x1a\x98\xac!\xcdT\xb7yW\xc7W\xcb\xe2\xf5\x89>\xfb)S8H\xb0K\x95\xc6\x18\x9a\xde\x9b\x1c+\x98\x84^\x1a\x8aj\xaecy\xe4\xcb~df@g^Auf23\x85Q\xfdO2\x94\x7fy\x97\xb2\x7f\xfb>\x05\xaa\x19oEg&\xbb\xff\xf1\xcb\n\x17\xc8\xa6\x99[A\xbb\thf\xcfZ+6\xcciP\xc2\xe9\xb5\xec#V\x8e\xd7Z\x1d\x90\x1ddg\xa4cm\xac\x95:\xf0\x99d\xbdH7\xdc\x10\xa5\x05\xe09T\xe43FB\xef\xc6\xae3\x86e\xd6q\xcefC\xddu\xba\xd9\x84\x9b\xe7\x90\x0c\x82\xd4\x82s\xbf\xd1N\xb8\x95#\x00\x9c\xc5\xbc\x9e\xe9\xe80\xd3\xb2\xaa\x05!\xeav\xddu\xae\xbdx\xa3\xa9h;\x14\xcaT3-\xf6\xb5\xf3.p\xb5\x04\x85\xf9\xa9\x01\xd9\xec\xca!\xf8\xb0\x13\x9aK\x02+\x0f\xe0<\x1c\\\x99\xff\xe2\x07,\xd6m\x13\xc0b\x19j\xd7\xb3\x16\x9b\xb2\x88\xaf\xb1\xfa\xd8t\xf2\xea\xa9\x1e\xd3h\x8f\xe2O\xf0\xef-\xb2\xe5\x9d\xac\xd9 ;QUi\x83?\x12\xa8\xd0n\xed\x1d\xa2\xaf\xae\x88\xaa\x0ee\x99\xd6\xfbg\xaa\xadI\xb30lb\x83\x92\xf7U\x03\xdd:\x17\xe0J\xa6\xc3\'j\xad\xca\xd6\x9e\x04I\x1e\xac\xbf\x1d\x93w\xc9\xef\xc5\xd4\xf5$\xe4?\x82\xd3\xfd\xd5\xe0\x98E\xff\xa2$\xeb\xbe)\xb1\xa5\xd2\xdd[\xb2(\xe1\xc5\xbb\x14\xcf\xbe\x04\xfa\x96\xf1f\xa4\x8f8\x89j\xe1;\x91\xb6V\t\x91]\xe0\x00\xe7X{6bz\xc1\xba\x98!"1@/(#Rz\x87\x7f\x02#[\x8a\xb0\xe9Q]\xce\xdb\xaa\x94\x92\x88\x14n\x96\x9e\x95\xc3\xbb\xba\xae+\xa9!Hy,{\x1c\xb5\x11\xb8[)\xe7\xd4\x99`o(\xea\x17\x92\x11~\r\xcd\x18l\xe8S\xe6\x9b5 e\xb1\x9d\xa0U\x83\x03\xe6\x00\xc3\x8d\xf6\x85\xac\x10\xbch*\x89}\xca\nL\x9ca\x8d\xa3\x1a\x8c\xb7?\xf0\xbayF\x97\xdb\x12\xa8-\x1e\xb0\xbfy\x9d08\xe4\xe5\x14\xd2g\xb3\'y\xb5\xc4\t\x96\x1enN\xef\x01gX\xb5\xea#\xb7\xc6q\x03\xfcZ\xbf\xc3\x8dy\x8a\xc8\xac\xf4SVZ\xab\xa51n\x05\x12O\t\x11\xd8\x11\xe0:[T<\xec\x15Q\xe7\xf3\x0e\x17k\xb64\xc4\x1a\x08z\xe7\xc0\x90\x95\xe8PC\xf0\xea\xd3\xcfS\xcb;+\xcb\xf3\xdc\x07\xb3\xa9$4\xe2\x81|\x8c\xb1\xb3\x86\xe4\xb3\xbd\xffc\x15cq\xd1/\x8a\xf9H\x00\x16(\xd0\xcf\x89\x03\x18\\\x00V\xab7\xf5\xea=4\xef\x81\x15R\xfdp\xf0\x1a/H\xf6\xab\xd4fT\x08\xe9l\xb0\x1d\x94f\xa9e:X\xfe\xcf3\xd2\x12\xd0\x1ag\xfes\x86Xv\xed\xa4t%\xb9\xb2\'_S\x96\x1cQ\x0f`\xf8=\xe6\x12\x9e T\xf8\x0f\x1fGs\x01\xeb~c\xb1\xa3.\xa4\xef\xb0{\x8b\xce\x02N\x13\x08j2\xa4W\x98\xb1\xc9\xd2\xb7\xa5\xe2K#WAN\xf3\xe0\x00\xb2u\x18\x88\x00\x8d\x82\x0c\xf1\xae\xc2\x0c\xbe?\x01D\xc65\xde\x1b$\x07m9\x01"f|\x18\xd2\xb3\x1a\xb6\xc2\xa3\xceQq\xd3\xa6\x81\x7fuo\x88\xb8<\xef\xbf\xfb\x8c\xfcs\x01\x14\xf5\xc53{\x941\xb5\xb7;\xb5k\xa7j#\x02C\x9f\x8f\xedi%-\xee\xe6\x88\xcb\xe1I\x1fi\x83c\x98\x1e\xafQo4D\xed\x0f\x16\xa9\x18\x0c\x06\x97w\x8f\xd3\xd9h\x98\xb0\x01\xa52LB\xf4\xab\x87\xde\xd8\x8e\xccjtd\x16\xc7\xe1\x18\x10\xd8\xd0\xf9S\xdf\xda@C\x7f\xc1\xbbQl\xb6\xe9_\xa3\x13\\\xf0\xa7S^\x91J\xb3\xdd2^\x07GF[)\xc2\x8c\xe5\xbf\xb1\xb6\x83Ju\xfbx\'\x06\xb8\xfd\xb8\x95T\xef\xbcS\xad\x14\xa1\xd5\x1c\xa8\xec\xb0\xec\xb5\xfd\x99]\xad\xd7Sm\xda@\xde,G\xa9\xf0K[\xa6@\x15\x14\xebct\x03qc\x91\x102 \r\xa5/\xf0\xce\xd2M\x9cf\xa6&%\xd6so\x9a\xd4\xb3\xfe?\x0fj/\xd2\x98\xba\xcb\xca\x9baz\xcd\r\x0c{\xfc\xd93\xc3\xcdF{[\xa9\xd6\\\x971\x8e\xf3\x0f\xa8\xd3\xf1\xf2\xc7\x8bI\xf2\x1c\x8b~Tg[+\x80r\xb7\x82\xef\x99.\xce\xf9\xfe\xca\xd8N\xe2\xa8\x9e\xe1\xc8\x0cBcC3\xfb\xfa\x98q(\x89\xe3\nt\xc3\x8b\x85Fy=\xc3\xfc\xe8\xbbF6\xb8\xfe\xc8\x06\xe9&\xaf\x00\xee\xde\x07\x8bc\xdb\xca\xa2V\xac\xab\xfb\xd3\x93\xeb\xfd\xe3\x07\xb4\x81Q\xec^\x85\xcfk\x88\x83\x14\xe0M\x83\x016>\xfb\x19\xcf\x14\x9c\xb8X\xd24\x8f3\x9a|\xb0F\xdd\xcb\xba\x9f\xd4\x80C\xe1\xb6I\xa2\x05\x1d\xb6\xeek\x8fG\xd5\x96\x98|\x86*\xd2y\xbdIQ\xf1/\xf9$\x84\xeaH\xeeu\xed\xca\xda\xf0\xde\xf7\xdb\x7fw\xf1\xca(\xf5;\x89Gv\x9b\xc2\x9f-(F\xb6!\x1f\\a\x96\xa7\x19\xe4\x16\x19\xfc\xb1I4\x80.\xc1\xfc\xd5\x0bH\x86\xe7Q\x1c!\xa3@W\x088\t\x8e\xcd\xd6c"\r\xd3\xc8E\xf2 \xf2\xa3\xca\x99]\xbb\x85\xf0\x98\xda(\xe2\x84\xe9\xec\x89/`\xa6\xc0[\x06\xc2\xafc\t/B\xe8\x903\x8b\x8a\xbc`[\xa2\'\xa7\x8f0\x18\xe3\x89\\\x80\x11\x1b=\xb6\xae\xfd\xe02 \n\x83\xb2\xeaNu\x06\xe9\xcf\xe7}\xde\xf1U\x95\xa4\xd7x\xe6Q\x7f\xfa\xf9x\xff\xd8\xc8\xda\xc8\x02\nt\xf7\x05ot_\',\xa9\x9e\x85h\xc3`ewp\x93\xc3Kd\xa9\xcf\xc4\xc0\xab\xc8\xbcd\x96T=\xe2\x07\xa5\xd4\xe3\x99\xe7\xf1k2\xc4\xbc\xeb8\xd4f\xb2\xad\x0fG\xc0X\xa9\x88K@\x86\xb8\x80,\xbf\xa9\x82\xfaA\xeeP\x89\t\xf1/\x7f\xfb\xde`\xf5\xa5W\xdf\x80\x1aE\x98\xc1\x03\xd2j\xa4\xb3\xa2{\x8e\x1eM\xffho\xf3\xc4<\x87\x01\x8e\xc6@=*\t\xb3\x11T\xaf\x10\xc3\x0cc\xb0:\xd2X\x85\xc4\xa1\xd52\xb3t\xbd\x1c\xc6\x9e\xdd\xbeBN\xaa\x92\x89\xdd\xad\x05\xfb09\x01\xf9\xdc\xac#\xf8`\x81s\xd1\xeb!\x88g{#\x90\x9a\xe2\x9e\xbb>p\x85o\xdb\xe9e/\xbc\xe2\x8e\xc6\xc0\x18NTIW\xc7\xaady1\xb7%*\xd6y\x9b\x98f\x01\xbd\xf3\xaf\x87e\x17\xc5|\x90\xecq\x03+1\xad[\xfd\xf0\xd7;\x13\x8d\xc2\x8c\x18?\xcd\xf3\xa8a\xfe\x8f\x19\xad\x98#`\x9b?\x9d!\n\x9a\xe5d\xd9\xe83\x15ls\xdc\x83F\x97\xe5\xffk\xfe\x11\x02w\xa7\x8f\xa8\xd2N=\x96\xd1\xd3;\xd9\xbd\x00\x1a\xc0{A\xfb\xc1\xe7&\x06\x8a\x9f]\t\x17\xb7\x81\xdf\xcd\x84w\xdd\']\xd2\xfe\x9fm\xbe.l\xd0\xe8\x85\x96(0\xe5\xe9~\x7f\x93\xf7\x16\xa7\nX\xe3\xac\xd9<\x1d\x1e\x9c\xfd\x1a\xd4\xd8L8\x9ah\x8f\xbfw\x19X.\xa6\x00~_\x8e\xab"\xd6\x93nlD\x11\xfb\x01v_a\xae\xc4\xadf2\xf0\x99\xd2\xd02\xbb]\xb6\xd2\x05_\xed\xfd\xccT\x9d\x96\xb2\r\xc1j\x16\xbf(\xfa\x92)\x0b\xdb\xc7\xad\xb9\xa3ze\x08K5\x1f;\xb8o\xab5\xf2\xd7\x90\xe0&\x90\x19a\x88\xf1\x0cd\x141\xfd\t\xab\xf1\x1e\xf3RJ7e\xe2\xfb\x03\xe6\xc9\xb7GB\xeb \xd0\x99\xc4\xb7\xb5\xe6X\xb5\x19\xb0`\xc6\x9b\x19\x99\xe6\xd0$\xb5;\x19NX/f,|i\xf1\xb0\xe7\x04\xce\xbb*\xd2\x83\x1b^+\x9d\xa6i\xb2?vag\xe66cA\xce\xe6]\xaa\xd7(7T\xd0\x9ay\xc9\xb9\xac)\xc2&\xa3\np\x92\xc6\x0f\x03\x8d\x17\rm\x9e\xd8\xd0\x9dE\xb0\x18\x99\xb1\x86\x04\xb3\xe3^\x80\xd1>hw\xdc\xfa\xc5\xcc}\x9c9\xcb\xa6\xfc\xf3a\x88\xc0\xa5\xf8\xd5aJ\x91\x15\x11@\xfeh\xd0m\x0b\x01\x0eei\x8boh\x84\x1d\x03\xe0\xd1O\x00\x8eb\x8a\xac\x8b\xaf\xed\x13$\x83\xef\xd31e1\x95\xb1U\x02 \xb3\xadL\xcc\xc0\x05\x14\xe9\xba\x18\xb9S\x1b\xfc!G\x04\xe6~l\xfe$4\xe3\x9eT\xee{\x9c\x14\xac\xda\x9a\xfb\x1f\x0e\xef.2\x85a\xc54\x1e[\x80\n\x8c\x1a\xb5\xb0&n\x0f\r\xf0:$\xae\x15u\t\x94\xe7\x02F\x06\xcd\xcc\x8e\xbaN\xaa\xbd\xf0\xb3\xa7Jd\x03\xbb\x13\xe0c6\x93\x10\xbe\xd4\xc8\xce\x1a\xe5\x82\xe2\xd4a\x1d\xdb \x00\xcfE\xeba\xba\xeb4\xb6\xa5\xd4Ge\xeeLn\xfateY\xae"\xae\x9aI|V\xe1!c\xd0\x87\x17/g\x0c\x9f\xad\xf8\xde\x1d_\x8ar\xc41}!\xe5%\xd3\xc2?\rMN\x97\x88}\xdc\xf76\xb9L\x80\t\xcaZc$\xd9A\x16\xd7yf\xed\x87\x83\x90\xde;\x06*\xf8\x1c\xd4"K\xc8\xdfs\xd8\xc0i\xb2\xe7\xc0Rd \xcb\x8b>\xd1\x81\xb4\t\x0b\xae\x80\x02\xdb\xc0\x9db%i\xaf^S/I2}\xc4\x1a}\x03\x14\xdc\x9a\xc0\xba\xb8\xe13\xa4sVC\xf3\x0e\xa5\x02\xa2\xc8\x91Y\xa3\x85D_G\x96C\xcd\xf8\x90\x9c\xc5\x87\xf9L\xe2\'\xf0\x06\xd9~\x84\x9av6!\xf3\x17\x17\xb7Z\x19"\t\'\xb8\x83+m\x0f*\xd2J\x9f\xba\x8a\x82\x14h#\x87\x13\x8e^m8S*\xc4(\x19\xbf_\\\xec^\x03\xdc\xaa\x9eq>\xcc\t|\xa6\x02\xb8\x9a\x10\xa0\xd3\xdc@T[\x88\xa7\x9fF\xb2\x8eI)\xa4-\x1b\xca_\xb81\xe0\x97\xb8\xb5\xdcRm\x18\x0b\xf3\xc5IQ\x9b\xe8)<^ps\xd8\xc0z\xbd\x1dRrL\x82\x94\xd0\xf3\x01\xce\xcc\xcd\xcc\x17pYj\x06\xe6.\x8d\x96\xb9\xa8\x04\xacG\xbb\xb5\xf2(d\x08Z\x8ef-\xb9\x0bj\xd1`\xd6\x9a\x84X2\x8c\xed~\xa9W\xaf\xc1\x88\xcc\x11\xf3\x87\x7f\x04\xc0\xc9yJ\xd4\xd6\x97\xe4\x7fH\xd9\xa1\x82\xfa\x15\x14c\xb5\x9c\xf8\xaf:v20\x0eo\x8fn~\x95\x06\xd1\xea#\xbc\x86\xe4d#Z\x7f\x0e\x05l\xd2O\x05\xba\xcd\xa5>\x1e-\x85\xf6\x95\x8dH\xcb9P \xbb\x8f\xf4\x88\xe9\x0fz\xac\x130\xba\x11\xb5\xdf\xdb\x8a\xe03\x90\x04\x84\xd3\xf9\xee\x16R\x1b\x00Yv\xb5\x7f7\xfb\xcb\xc85k[!\xd1\x8b\x15~\xd8+\xe2\xdaI\xb6\x80\xa1\xa0k(\xbcQj\xcc\xcc\x8e}\xbf\xfe6\xae\'<&g\x96a\x16\x90a\xfb`0j\xad1\xec\xbcV\xc4J0l\xf2rqM1\xa7\x0e\x0c\x88\xa5p\x94\\O!h-\xb9\x81g\x9c\xb8\x15\xb0+\'\x99\xfc\xae\xbe]S9\xc3o\x06_g\xeae\xf5\x12$\xd2\x87\x98t\x84YR\xe3\x0b\x8c\x1eE\x11Y\xc8V\x9d\xe4\x17-\x1cO\xc1\xb88\x07\xf2\x8e\xe8\xeeB\xc7\xa9\x19\x97\xa4x\'<\xf2+8\x01\x11\xc8t\n\xeb\xec2H\xe8N\x03@\xcd\xa3\x90Pq\x1eo\x97\xba\x18\xf3w\xc1\x8d\x1bg\xe1i|\xd7\xd6N\x7f\xe2C]\x9e|\xc7\xb3\x905md\x82n]\x95\'V\xd4\x07\xbb/)\x84:+\xa0\t3x\xc0Z\x1bt\x9f\x8b^\xe9A\xc0\x0c\x14P{\xe8\x82#\xb8\\\xf8!\xe0\xff\xd7\xde\x91(%n\xa1v*7\xb7\xa7\x9aWO\xcd%\x1d|\x0c\x86\xbc\x81\x1b\xc7\xa1\x912\x1aqQ\x0ca{\xb2\x8d\x865D\xf0\xeaP\xbd\x0b\xb3_"\xbb<\xb7>\x1a\x90e\x80\xc5\x0c\x06y\xb2\xe2\x9e\x8c\x1dc\n\xec\xe1E+\x1e\x890\x84\x82n\xfd\x84\x92\x01`$\xe0\xa4\x91\x07<\x14\xaa\x9b\xc18\xbbqjO\xcd]w\\\x7f%\xdfj\xd6\xcb\x02\xac.,&1\xb4D\xeff\xe4\xee1-\xae\x08z\x14\xf9\xfaI\xfc.\xe1\xcd\xb8\r\xc2\xb5I|E}\x995\x12\xc7\x8f\xad\xda\xb2\xa3*2\x1d2\xc1\x82\xc1;\xee\xda\x04=\x8f\xba\xb0v\xfe7k\x10\xbc\xf18\xe7\x04\xf3\xd7L\xa6\xfb\x0fYg\n\x93\xf6L\x0ePIms\x8b\x19\x8d\x9b\x14\xbcn$5\xd5\xe9\xf5n\x0eSU\xa9\x84a\xd7\xe1\x1a3o\x05\xcd\x15E)\xbf\x00\x01[\x10\xc8k\x8e\xeb\x0c-\xa2e\x85\x96\xddZ/\xd4\x9aJ\x90\x02\xc15\x92\n\xd4N~\xa3\x8a\xd4\xb1\xbd^\xd50v;\xdf&\xb6[+\x87TSSg\n\xaeL4\xb1\xb6\x1c\x14\x9e\xc41_y\xaa`\xd8Uj\x07\xf3\xfe\x97z\xec\xba]b\xc85-\xbc\xc3\x94E\xb3g6\xde\xf4\x08Gw\xc7\x18\xca\x04B\xbd\xa6\x12\xc6\x88\x1c\xb8\xa8\xaf\xd4\x06!z\xce\xe7\x84\xfc=\xe2\x8a\xec\xc3\xb7\x89\rU\x07\xcf\xec\x8f\xb0pN\xb9J\x87w\xe3%\xfdf\xd9v\xfa,7\xc7rp\xef\x04\xc6K^\xe5\xe6\xa8\xfb\x8e>nN\n\x8e\xa2\x80Sz\x11\xc6\x96Z\xf3\xea<\x0c\x88\xf9B@\n-\x95;\xe3L\xce~42\x12!\x90\xab\xa9\x9fB\xb4\x9e!X\xf6\x9cfD\x06IG\xd5\xb5\xf5}\x93\x00\xe72\xa6O\xdf/i\x9d\xfa\x86\xbc\xd3\x0c\x9d-\xde\xde\x9c\xf8\xb7Y\x1c\x13\xe9T\x95\xe6\x92\xaeM\xf7{\xcc@\x9b\xc8v\xc1\xb3S\x9f\x01\x11\xe5\x9a\xadPz\x02]\xb8|z\x1c\t/N&\xf1\xc90yaK\xac\xffB\xda\xdf0\x94\x04,\x13U\xa7\x08\t\xa4d_\xb2\xbc\x06\xef+\xb3\xa2\xad\xdf\x91\'c\x85\xad\'\x0b@|\xb5u.\r0D\xa3\xb0\r\x89\xd9-f\xda\xa7S\xe1\xbb2\xc3&5s?\' \xa9fU#!;\x19e\xd6\x101\xdb\xae\xfe\x80\x1b\x93F\x0f\x18\xc1B\x1b\xf6\xb6k\x94\xd1\xb6Q\xff9\xda#r!\n\xb0b\xe3\xee\xcd&+\xa1\x9a\x13<\x19\xf4\x1aI\x1ez4\xf1\r\x9c\x0f\xf0z\x1e\x81\xa9\x17\x9c6\xac\xdfN\xf1Y3\x1d\xb8\x89\xab\xbe\x08\xcf4\x14V}\x17\x10H\x93\xd9yE\xf2\x9b\xbd\x0c\xd7`*LA\x88\xc3\xd16@\xeb\\^C\x06/\x08t\x0e\'Z\x0e\xc9\xa7\xdb\xee3E\xc89\xa0y\xe9\x92\t{[\xf3[\xf2|\xb7F\x9fi1\xd5N\x02\xb5\x1c\xc1V\xe5\x7f\xa0\x0b9#1\x9aj\x8d\xd1R\xc2X"\xdef%\xe88x\x01\x8d\xfc\xd6l\x0c\xa0\xe4\x19\x0b\xdd\x89\xf9\x83\x92\xaa\xd63\x07\xc6\xdb\xfe\xcb\x89=\xdeE\x12\xb0\xdd\xe5u\x0b4\xedr\x822\x7f+\xae\xf4d\xffP\xa8&\xe4c\n}2\xcf\x90\x87\xee2aX\n\xfaA\x16RJ]T\x19\x88\x03b\xcc\xcb\xf3\xfc\xcaRx0\x18\xa3\x0e\xc5N\x08\x89~,;\x94\xab\xa3\x1c`\xb3\xc1\x89\xe28\x832\x8e\xb0\xc2\xce\xee\xab\x9a\x8d,}\x14\x1523\xfb>\xcaR`\xa4\x97u\'aJ.\x19\\Y\xe6\xed*\xaf\xb2\xf1yp\xd4(LM\x8c\xe4\xe9\x95\x16\x05\x80\xd3)\xa2_\xd9\x96\x8c"dl\xd5\xd0\xa3%!\xee\xd8c\xf7\xbcvD\xd5\xd5\xe5U\x12"\x82\xd4~\xe3\x968\x9c^`\n\x8as\x03\xa6=\xd5du\xbfp\x80\xf1\xec"\x08>wP\xd7jy^B\xdc\xc6\x15\xd2M\xf1\xd1\xf6%\n\x13/P\xceZ9\xd1\xb2\xc3\xbap;\x00\xcb\xfcCTvd>2N$\xc3\x16-?\xd3\xa8B\xae>Q\xfdO\xce\nC\xbdZo\xc8\x11\xd6\xc6?\x9f\xab\x05\xb3\x92*\xd0\xfd\xba\xba\x97\x99\xe8\x9b\x8f\xf8\xebD\xbb\x15\xef\x05\xd2\xa8\xf1Jrzzpb\xcb\xe3t_c[m\xe1\x1d\xf4\rj\x9f&\xbd\xdc\xd43\x01\xb0\xee=\x7f\xaa\x08aE;\xb2\xb2u\x18\x11<\xf5\x149\x00\xe9\xe6CIXVlUy\x9bQ\xeeA\xb5\xb9\xdb\x87\xd2\xc2\xdb\x95\xf5x\xdd\x90\x95\xfbq\x0fAZ\xa8\'\xf0\x9f\xca/\x1d\xa7[\xcb\x81z\xcd\xd6 O\x02\xa7\xb4\xc3\xe3y\xd0\xea\x17E\xb6\xfde\xa4\xfc \xc9O8\x10tY\x8d\xe7\xc2\xb2\xfa\x07l\x0e\xd5\xce\xe1{\xe9\x1e\x84<\xd3k\x98l\xa3?5\x90\xdf)B\xeet_\xaa\x85|\x02\xf3;\xf3\t\x13\xe3W\x9bg\xa6\t\xa1\xa7\xfa\xb0z\xe5\x98\xf5\x89\xac\xcc \x8f\x9f\xa2\xe4\xe8N\xbf\xb6\xff0>\xe0\x81/\xd5\xee\x97\x10\xc5&\n\xda\xa7\x0e\x88\':dk\x07\xcb\xcb\x05\x85\x12\xfc\xbd [\xe6]R\xbf1\xb8l\xa6\x8b\xacf\x17UR0\xc8|Q\x0e\xfe\xf7\xb6\x0c[\x075Er\x83\xfb\x07\x81\xc3\x08/\xad\xc3Ze\n\x184\x84\xb6#_\xa3\x9b\xca\x92ZgWF-\xa3#\n\xd2H$\xbek\x07kk\xd77\xa3\x08\x8ez\xfd\x0c\xaa\xcb\xe9\xb6j\xa0O\x1c\xb8\'M\x12\xcc#\xca\xcc\xd9:\x9ct7RU\xb9\xcb\xec\x12\xdfMcwW*\xc0C]\xab\x83\xf9e\xfc\xee\xb3\xa1W\x81_1MQed\xb0\xa44\xea\x9c\xdd\xd0\xa0\x1c\xe1\xda\xa5\xdb\x07\x06\xc2\x02\x9d)\xd9\x17\x10o\\\x142\x0bh\x93\x98b8\xab~N\xaa\x97\x191\xb1\n \xad\xbdq\xcf\r\xb7\x1c\x1bJHc\xbf\xb7.Z\xe6&\xce\xd6\x99\xc9D\xd0@[\xab\xe2\x9d\xba\xa8"6\xb9\x94%$=.\xe8\xae\xa0\xb7\x06NV&\xe3\xaf\xf5\x8c\xe3\xc0[ \x05W\xec\x88$\xe36\']\xf5oi\xe0X\x19\x1fp\xfe\xd1\x87\x05\'\x02\x98y\xce>P\x01\x1b\xa1"\xe6\x0e\xc74\xe3K`x\xf7o\xdd\xcc\x83\xc0[e\x88\xf2Y\x0f\xa4!\x1d\x14\x19\xb6{\x99Vp)\x97\xf2\xd2ds\xc3-`k\xb6\x92\xc2\xb5[F\xc9\xe4\x08\xa0\xdf\x1b\xfd\x14\xee\xd7Y\xc9\x93\x8d\x16p\x0e\x89\xa4\x96E\xcd\x94\xaa\x82\xf5b\x00y\x0e\xfa\xcc"4w\xb9#&\xa4\x86\x9f\xf2\xa3\x13|GH\'\x04\xcc\xc2z\x0b\xd0\x99\x00\xa65\xa9\x1f\x1b\xb9\x99\xe0\xb2\x0bE\xda\x14\xbc\xf6~\x12\xb7k\xb4\x92F\xda^\x85\x97\xf7Y7\xa2EJV\x023\x97-\x81\xb0\xc79\x86\x10\xbe[\xd4\xed\xc9\xf7{Q_^G\xb9[\xef!\xb42\x0e\xe5\xf6\xa0\xd4+\x8a\xe5x\xf8\x80\xaeLH3,\xc1v\xf5\xc6\xa1\xa8M\x80\xc6\xe3G\xab\xa3w\xfa_\x93T~m\x07\xb9\x02\x9b\xe8\x04\xde\xf0\xfb\xe9+\x849\x97\x9c\xe8\xdf\xc3\xb8c\xb2\xdb\xa9\xcb\xa3r\xc2\xa41(B\xab\xe4\'=\'Q-9a\x82\xdf\xb6\xb3\xb2\xbch\x91\xfd\x98\x041\xdbGa\x9e\xce\xfc/\xfd\xa311\xfbX[^`\xb5:\xac\x86Y|\xd7\x85P\xb9\x01\x05\x01mP\x98\x96\t\xa9\x90\xc0v\x10\t\x05\x87xQ\xd1R\xb3\x93\xcd\x14\x8c\xca!\x14)\xd4\xa5mJ\x1c\xfc\xf2\x1f\xd8\xcf\x07\x0b]\x90\x04JDTXB/\xf8\xcd\x17C\xc2<\xa2\x01\xe5\xb0\xd6m\x83\xf8\x84\xe8\xbe\xc1\x11+\x0f<\x8d\xbb\x9de\xeb\x84\xa3\xf4m\x0e\xed\xd8\x8b>c\x9a\x05\xde\xe7\xe4c\xd3aL\xd9\x15\xdf\xdd]i\xe7[$\x8a\xb6\xd0\xcb\x8fVc*\xd4\x91T\x18\r\x0b4\xdag5\xd3\x9beL\x1f\xcf\xfb\xd6\xea7\x8d\xe8\xff\x19\xed\x12J\x91\n\x87\x13S\xe5\xae\x8b\xff\xee p\x8c\x0e=\x7f=\xfdUH\xdb\x06\xbah\xa0\xbaD;\rDK\t\xbf\x987=N\x85\xac:@\xd6r\x9e\xef\xe1\xc9%\xdf\xfd~\xafJI\xb2U\xb5\np\x0f\xb0|\x84h\xabQ\xebu]#}k\xc9\x12\x07\xf2I\xfb\x15\x80].n\xcf7\xba\xca\xb3\xbc\x9a\x17\t\xdcY\t\xc7\x07\xa8\xd8\xf5\xe1\xea\xe2\xb8\xa1\x11\xa9\xab\xee\xd5\xe1\x99&\xfc\xea\xc1\xad\x11s\xbdq\xec\xe0\xaa\xcaE\xb7J\xd0\xc2\xbf \x97\xc5\xea\xd00\xbf\xc2\x02*\xbb\x94y.\x04\x1f<#\xa18\xd9\x87\x92\x94\x9d\xee\x86\xef\xae\xf7\xe0\x1c=F\xf3\xf2@#W\xfa\xd52\xe6\xff]R-m9m\x1c\xd4;\xdfE+1\xa4!\x06\xadw\xd97\x93\xdf\x87\x86\x99\xa5=\xb9\xf9\x03\x86\xc6\xf1\t\xa4\x11\xad\xbaE%I\xe6*K\r\xfbw\xfe\x15\xfb\x94L\xe9\xcbC/\x84\x13\x913\xfdr!\xc3\xae\x1d=\xe5|$\x874\xb3\xe2\xc8\xb8\x96\x07\xbb\x90\x04\x90\xde\x1a\xb94p\xac\x162p\x12@\x18\x07\x8c\xcd(G`q\xafD\xc3A\xe6zC_\x8e]1\xae{\x0f*\xe2k\x90\x810\x9f\x83\xe8P2\x91\xf4\x01\xf5\xf0\xbb9\xb4\xee\x853\xacS\x1aj\x9c\x1d\xedt\xe1*\xbe\xcb1d\x85\x8d\xe5\x99\xe9\xc3\xe7E\x80\xc2\xbcc\xb3\x82FyT\xc6\xd7\xef\x94Xn\xa2\\\x98\xdft\xf4\x7f\nr\x1c\xdfOQ\x8aXgn\x9dt2@\x04[\'#\xac\xe06o\xe0e\xfe\xaf\xcc\x9e\x97\x7fJB\xce~\xbc\xdc(P\xcd\x1d\xe63\xfahl-\xbf\xf2\x04\xe6\xb8\xa30`rpT\xdf\x064xzN\x089\xa7GJRMw\xb6\xae\xfe\xf9\xa2\xab\xc5\xb3\x0e\xd3\xd5\xe7\xc3\x14\xe0\xf3M\xb0\xd8\xa4D\x91z\x14\xe7\x8f\xbd\x9d\xb9:\x10\x9e9\x13T\xef\xed\xdd\x9e\xfd\x00\xff\xee\xd42\xaa\x96&\x85\x9b\x0b\xad\x97b\x19\xb2\xd7\x02|\x8f\xd9wb\xb7k\x1c\xf1\xa9\xd8\x92\xd8\x86\x1b\xf3\xef\xce\xc30\x8c\xe4FHF\x98\xe4\x15\xc1\x9ds\xda\x07SX\xa3\x12\x8b\xb2\xe9\xb1g\xd0\xd2\x953\xe8\xa9\x1aWy\x81\xbf\xb0\xbd\xcb\xca&\xb6\xf3\x1c\xf4\xa0\xb7s\xbbosB\xbd\x90q%8\xbd-iw\xfbK-\xb7\x00\xa6\x00\xb3\xe8x\x08k\x04\x80\xe7\xda~E\x92\x17\xf2l\xbck\x1dE7\x91&U\tZ!\rh!4]\x99y\xf9\x11\x88<\xfcl\xf1%\xce\x04\x8e#/\x1e\xf28\x07\x1f\xd1C`F\x99wer>F/gT\n\xa6\x8f\xf0\x9b\x14\x01\xbf\x7f\xb2sI\xee\xae\xe3\\\x8b\xe519d\x08\x18\xef\x0f+\xed5xr\x83:p\xca\x01\xd2\xd5E\x84&\\Pw\xa4\xd6\n\x95lu\x16\xa1\x86\x98\x8a\'\xb3f\x1a\x11\xd5\x93t\x01\x928\x91_\xf9tm\x9a\xdcj\xec\xa7Mp\xb8W@:,\xad\xee\x1f\x1d\xb0\xfb\xd3\xfa{$\xb5\xb1\x99\xf0.=C\xc2<\x7f\xb1ts\x91U\\\x0f\xb7D\x83\xbbm\n\tfc\xdbx,%\xad&\x82\xaf\x83\x91\xcd",\xa9\xb3\x18\xa9\xe8\xed]\xe7\x0el\xee\xf4}\xd1\xb9\xd3\x9d\n**\xdd\x03\x8e\xdf\xdd\'\xde\x1b\xe9\x89\xfchp\xb1\xfa\xf7\xb4\xa6F7\x86\xa5c\xe4j\x99\x0f\x17\x02t$\xa6\xf7\xbfG\x9e-\xf63@\xcd#A\x1eUy,\xf9y"X4\xbd\xbb\x8f\xa4\xb1\xfb\x0b\xe1\xcb\xe6\xcc&\xb1\xb1\x07m\xe26\x8e\xc8t\x97><,D8\x96\xc3\xd2\xdb\x1d\xe2~|\xfe\x9d\xd9\x7f\x08\x84\xca\xed\x88<"\x00\xce\xd5\r\xe1\xc9J\xd7\x15\xcd\t\x1b\x06\xc2\xad\x1e\xef3i7\x92\x86]S\x06E\x089\x13:\xd8+\x12\x06\xf3\xdeca\x98\x9ep\xc4\x8e3\xb8N\x00\x84\r\xcc\x0b\x92\xe0\xb4\xbb\x84\xd0\xe3\x0c\xcb9G\xaf~\xc1RsX\xbb\xd0vq\x14\x96|_\xec\r\xc2\xe2\x96e\xe9\x1f\xdb\x8d>\xdf\x99\x08D\xf6\xa2\x0ed\xb8\xe1\x06G\x1e\xb1IA\x93\x8a\x1e\xfew\xf4E\xd6\xee\x13\xfc\xbb\xa57\xc4\xf7\x1f\x93\x826\xd5\xa0~hw\x88\xa9\xf16b\xaa\xc3\xf0\xcbq:UXLB2D\n6\x19\x8f0\x0c\x0c\xad\xe8R\xf6\x0f\x80\x8a\xe0\xa2\xd3h\xffE\xf4\xf7\xf4ff\xbc\x83\xf9o\xf6\xa0\xc1\xc9\xb4\x8e\x96\x9czh\xc3\x1e\xd8=\xb90p\xc0\x18|\x05\xef\xd0\x9d\x11\xd4\x12$\xfc\x92\xdc\xf9p4\xf0\xa1p!h\xa9*\x89\xe5%\xb1\xdc\xcc\xd0\xdb\x89\xbe9n\x15\x0b~\\\x9f\xe4\xc0\x98\x07\xba)\x95\x1c\xa9\xe4\x1a\x0f\x0c\x9bR\xe8\xf5{`F\x87+[\xa9\xfc&$\x15f\xa1\xa0\x01\xf8\xed\x19~\xeb\x01\x03\xce\xc4\x80\xe3\x92\xe0V3\xa5\x8e?%\t$\x96\x7f\x9bi\xfay\xb1\xed\x0bW\x82\x9b:\xdfj\xfd\xe3F\x06\xf5x\xf4\xaa\xbb\x03\xd8\t1\xd0\xee\xcd\x7fD\xe2~]Y\xde\\\xf8\x14\x13\'\x1f\xd3\x02H\xbc\x11\x18\x19\xf1\xf0\xd3t\xa7\xec\xacW\xbf\x94\x0e\xe5\xfd\x80\xda\xcd\x7f.zn\xc5;\xa8P\x1f\x07\x1c4\x85a4\x07<\'-p{\x81*\x92\xbc!\x05\x97\x9a\x91\xc8\x08`P\xd9\x18\xf4\xda[f\rK\xdbm\x07\xfa?\xe2\x97\x91\xa8i\x8bZ\x05\x00\xb5\xedy\xeb\x91\xd4\x8b\x85\x03\x81M\x1aW\xdb+\xea\xf9\xa6\xa1\x81\x82\xda\xac\xcd\xfa\x9ei\xf1\xa31\xc2\x11*\xd1\x82\xc1\xb3\xdb\xd1d\xf1\xcb\x00\x80\x82\xe3\xdd\x1d\x074\x05\x7f\xe5\xe9.\xd1\xd2>!;\xd3\xf5\xfa\xc7\xd4\x1c=*\x02\x11\xe8\xa3+/c4\x82\x18\xe6\xd2\xe1/\xd3E\x1d\x08:\xeb\x85BWn\rAY\xa2!\xd3\xaa\x08\x1d|i\xba\x11\xff\x95\xc0-\x0f\x9f\xe6El\xb2\x08K\x03\x9b\x95\x07\x86\x05\x0fv[\x8cKi\xa7\'\x90\xf2A\x9c\xdd{\xc3\xbe\x18mb\xa1\x94G\x0e8\xe0\x9b\xa1\xf67\xb4z%L\xf1\x04\x9a\xa9\xa8\xa6lnD\x82\x1f!\xf6\x99\xa4(\xfeV\xab\xd7\xd7\\O?\x89\x87\xbaX\t\xadL\x1bY\xb5\x96\xaetb\xdf\xd6\x1cd\xd0\xd7\xcd\xe9!\'\xb7\xdc#\xda\xd1l\xdc~:M\xea\xf4!\xa2\xeeVN\x8eF\xf0. \x84\xbf&\xc3\xfa\x82\nGT8\xa4+DQW\xd7\xbd\xb0z\x1f#wN\xfd\xa6\xcf\x8c\xb9\xca\x07\x9c\x12C\xb8\x1f\xc0O~\xfe\xa7\xeb\xb4\xcf\xb5u\x12\xe6\xd1\xac\x7f\xd2&\xf1\x8e\xef\xda\xb6W\xbe\x17$\xe31\xd5\x00\xe6A\x93\x94j\xc2\x98\x88\x87\xe6\x93\xd7M 3\x0f\x95\xe5\xd0\xcbj\xf6h\xc8\xf0\xea\xcb\xc6Ne\x8ePr[\x9d.\x11>c0\xe0\xeeJ2\xaf\xf2\'\xd8\x9f\xf1\xd2\x99iC\xe3\xe4K\xbbH\xeeh\xfb\x99\x9fv\xec\xc6\xc0\xbe\x97\x8d\xea\xd7\xf8d5\xd1\xa2\xaf[\x07\xf2\xe9\xef\xd8\x05\' o\xe5*%\xbaZ\xab\xf3\x17\xf23C\x06\xdd\xbf0{vd\tyv\x8c`[\x1e\xcd\x8e\xfaZ^\xf5\xf3?\xb0 \xa4\xee\x03\x83_\x18c2z\xe0\x96\x03\xbb\'\xfd\xdb\x0e\xa73\xf4 M\x13\x9b*\\-\xee\xcb\x10\xc9\xeda\x95\r>I\xf4Ee\xdf\xee*\x00{$\xe8B\x80j\xeb\xdfn\xc7Z\xd3\n,P\x12\xad\r\x98\xb6;\x0f\xc7\xb8\x02 \xa9\x18=X\xa4#\x85_:\xcf)\x08G\x00\xd2\x91\xda\x90\xdf\x03\rF,>\xb5Uy\xe8\xc81\x05G\xf9\x05U\x18\xdd\xbb\xebG]\x9f\xae\x1d\x17\xa0\r\xf8\x8d\xfa\x9fv$\x01\xba{\xddh\xcb\xf1.\x9e%\x9f\x0e\xc6\xea\xe3\xdb\xdc\xf9\xc5\xd5\xd3\xdd\xdc\x91\'\xe2\xf0\xee\x85\xa7^5S\x8dv\n.rd\x84c\xbe\xc0\n\xd0\x90\xf6\xf5zt\xa8\x03\xcf\x86\xb6S)\xb5>\xbb\xe4>\x10\xeaX\xebidd\x0b\x19\\.\xbbz\xacs\xab\xe2\xedF\x12\xf2\x82\xce\xdc^\x9e\xcb\x99\x05\xb2\x99W\nX\x8a[_\xb2\xa6`\xdd\x87\xc4)\x91-\x87&\xd0s\x89\x9e;\xbd\n\xd5\xcf\x0e\xa8:\xbb5\\\xe9\x9a\r\x98\xb7[\xc3}5K\xe7E6\x1c\xba\xd0V\x81\x1c\x17y\xbf\xcc\xc7\xdf\x14\xec\x1f\x1f\x82\xe6\xf7\xfc\x80\x98R\xc9\x08\x05\xda:\x96\xaa\xbe\x0bi\xb3\xf0\xfa\x97\x07\x18\xf3\xcc\x8ee\xb5e\xc6\x9b>\xdbX\xf3behO.\xdb\x81\x8c:\x15\x9d\xca#E\xc4\xb5H42\xd0WW\xcaP\x91\x89\xd8\xe2\xa0\x8cY!\r\x95\x1b\xa7\xb3\xd4\x18a\xd3Y\xc2P=lTW \xe0\xf1X\xcfd\xfd\xb9\x17#\xd7\x07[c\xff\x93dV&*\xd0\x97[\\$\xee\xd6\x8d&r\xeav\x80e\xad\xee\xe1\xde&\xfa,\xd0\x91\xaf\x1a\xf5Q\xdf\xb7\x14J\xb9\x82`\x8b\xd1\x925\x0fxEf \xec\x825\x90R\xbb\xd2\xae]\x88\xc05\xc5u,\x0f\x9cj\x0bA\xe9\x0eH-&+\x8f\x9f$-\xd4\xcd\'wQp\xe6B\xac\x1c\xa2\xd7:\xd6\xe3\xc8\xean|x\xe0\xb4\x1c\xd1d\x08m\x11\\\xdd\x19Z\xb2\x87\x85\xb4\xf3%\xac\x1d\xd2N\x0f\xee/\xc6\x18\xb6\xb5\xdc\x01\xab|\xe9\xc06l\x18\x8e\x11\xe9U\xe3y\x9b\x1d\xff\xe0\x95m-\xc5\x06\xfb\x999qd\xa4O\xfdt\x17\xa5;o\x8c\xccW\x0f\xcco\x1aL\xd5\xc6\x0e\xdbw\x06\xa5\xe1\xda\xfe\x88OA\x9c\tl\xcb+\xd8h\xedA!\'\x80\x15,\xef\xf7\x82\xf3\x95&\x01\x9c*\xaa\x02\xf6\x01-Ys\xfa!Z\xa7\xd6M\xd7\xecT\x1a\x90j\xd8\x01\xc2#\xadI\xcd\x1c\xb5#\xd4\xf5\x01%\xe6P\x84\xa0\xef\xa8\x01>i\xfc\x84\xa0HA\xbeJ:\xca\xe9w\xb3}]i\x15\x04rGD\x89|\xe2\xff\xe4w\xed\xcc\xc6\xa7\xbcca<|\x07\xa1TqM\x90\xba_4\x1f\x84q\x1f\xa7W\x96\xd94\xdf%\x1d\x81\xea\xa5\x19x3"\x1e\xf7;!\xfb\xc5=\xfb\x01\xda\xe3\xbf[C\x04\xab\x9a$l\x9d\x82\x8f\x98?Zr&\x9c~\x13\xf1\r&\xd3y\xc32v\xb7\xffM]_\xbf\x1a\xcdm\x9c\x99\x0e7\xa8\xd2\xe6\x0e\x81\x91\xb0w\xdcr\x9f\xd8Vb\x02\xa5\x16\xbf\xbf/\xc5\xd5\xc9\xbcG=\xe4\xb1P\xd9r\x1b\x04\x16\xd5\xc0\xcb\xf0\xc9W\x00\xd4\xba\x97\xb2\x0e\xd4x\xe5y.\x07_V\xdev\x94\xca\xbcD\x0egw\x93\x95\x04MpX\xb0>\xc6\x97`\xb1\x18gC\xe0\xcd\x18]\xb5\xef1\xb8\xa2\xe7da\x1f\x9b<\x08\xca5h\x89\xcc\xbed:GS=\r\x9a\xe5\xca\xb3}\xe5^_\x12\xc5K\xab<\xe3-\xdd\xe5\xf5w\xeb X%\xa2n\xe2\xa6B\xcd\x86$u5\x96\xb1:\x02}>\x8a\x9f\x15\xc1Q?\xb2S\xb0U\xafJ T\xcc\xe1!0\xf4M\xc1\xd0,\xacH\\\x17\xc4\xe4R\xb2\xcf\x93\xfe|.\t\xa3\xc7\x18E9\x13\xcbh*k\xaf\x1ac#\x80\x0f\x10\xd1\xeb\xae\x8e\xfa\x8c\xd5\x8a\xb2#\xd6G\xed\x01\xc3\xc9\x1a\xdeja\\\xe1\xf8d\xabr\xdc\x80\xa8|\x97Jg\xcc\xd6\xca\xad\x13\xd4\x0b=\xbe_\xa6 \xf7\\\xc7\xd5\xce\xdaqp\xd7>\x9e\xe7["D\xfd{\x8cJX\xaa]\x87\xa3$\xa3\xbcG\xe6\xca\x9b\xaaY@C\xb8M\x92\xb3\x14C\xd48z\xbb\xd6\xc2\xd7\xbfE\xcfj\x90i\xea\x13\x12\xc8,\xc3\xc9\xbd\xf5|Kp\xc0\xbdx\xf4\xfa\xe0\xf99\x8fq\xc8F\xad]d\xdc\x03#\xc5:oN\x96\x9e\xed\x92\xbc\xe0c\xcfne\x0b!\x9b3\xeaj,b\x93\xbcj\xc1k \xbd\xaa\xae\x0f\x9c\xecAd\xb6\tV\xb9\x07!B\xc8\x95\x1c\x18\x9d\xd4d\xa1\'\xba\x8a\xb9 \x9c\xb6\xf6\xeb>\xf6?\x1b/\xe6\x0cfPk\x9c\xb1\xd5\x0eh\xce\xb0\xa6\x86t/\xfa\x89\xe4\xf1\xc7\xda\xf3$\xe6;r\t)\xbd\x91\x9d\xc0\xac\x83,\xb9\x88-\xe9\x08\xdfk\x84L\xce\xb2\xb5\xb1\xdc\x01\x15\xe74X\xa6A\x84\x96\xb8\x9c: \xf3\\\x99\xdc\xf8\x83\n\x87\xe3\\\xa5\x10\x13;\x1e\x10\x14\xbe\xf1\x8f\xe8\xf1\x12\xadbkB\r_\xc4\xf8\x9ep\xfbTs\xc9\x8d\x0b\x1d"\x1fB\xc6N\xc2\xe9\x9c\x8c\xd4N\t\xd9\xcfQ\x1e\x97m\xe1\xbf\x12\xfb\x13P\xe6\xfb\x18Li\xa5\xfc\xa3\x9d\xf2\xad8o\xf7\x89\xc3|\xd7i\xe2W\x82P\xe4F\x96+{\xd0V\x9c\xce@\x93\xab\x1b\xd6\x17\xa4\xdaG\xd7,\x8f8|(~LYd1\x00\x9dd\xae\x1f\x85!x\xf7\x15\x9d\xf7;\x7f\xd0\xc3q\xb4:d\x05O@\x02Y\xdb3\xef\x0c\x8dC\x0eO\xfe\x99[UK\xb3yT\x9e\xd3\xa6\xba\xb66\xe5F\xeb$\x1a\xda\x9a\x18\xd1\xe3bl\x866n\xab`\xa8\xa6\x905E\xbdpM\x1a\xdd\n,\xcdw\xbf\xe8\xfa\xd2y\x84v\xcb\xf9\x05\xe5\x87sl\x12n\x9bu\x1f]A-l\xf6)\x01\x8d;c6\xc8^G\x03\x95\xed\xe1YH\x9b\x85k\xe5\x91\x9bLE\xb9RV\xdf\xafB\xcb\x9d\x08\xdd\x11\x7f\xba8\xb7m\xab\x15*\x92\xd9\xca\x94\xf6\xcf\x1eD}\x9fr\xc8l\xa3\xe5\x95\xed\xe7\xc1\x03B\x1c\xae\'\xe0$\x1d\x15]p\xcf\xd3\x9dt\xc1\x81\xef\xfe\x03\xf9&T\x86I[l+\x08Z{\xf4\xf5F\xa0\xb6\x81\x8a\xe3^fjx\xa9o\xaf\x9f2\xec\x8e5N&\x18W\xcfs\xfc\x7f\xeee>\xa4K\r\xce\x8c^1\xe4\x99\xda\xe6OO\x82\xb3)\x7fj^\xe5,\x01\xfeA\xba\xc48\x94\x9c\xbd\x1e\xcc\xa6we@\xf3\xb6\x0c\xbfv\x14\xbd\xed\x80\xe9tS}k\xc2\x9d\x88y\x0f\xd2\xe5\x92X+k\x03\xfb{\xb1Z(\xf8U@\xa6\x8e\xe3\xb5\xb4\xdc\xa7\x80\xbdt\x06\x99\xcc\x15[\x13\xb8v\x04\xe1\xd9l^\xd95U\x9dNjh\x8e\x85\x80\xbb\x15\xae\xad\xaa\xd0\x1a\x19?R\xb0\xa3W\nB\xb8\xb7\xc7\xe7g\x02\xa0\x12\xc5\x89-\xfdv\xb5\xe9\x82\x18^"\x1b\x04Q\xceI\x01G\xd0y\xc9*oPb\x93\xd27\x91[\x1e\x00?/\x9d\xf9l\xe6ff\xcb\xfe\xd3\x15\xda\x06[Y\xf3r\x124\x18\x80\x8f\xf6\xec\xec\xb5\xda\xac\x86\xdebQ\n\xcbh\xb1\xcdo\xfe\x15\xb8\xe3\x87\xf9]\xf8\xde$\\\xbd\xea\xa2(\xbf\x9b\\\xad\x80\xda\xd0\xb5X6\x0e\xdf\xe2t\x8a=\xe6\x8dR\x9e\x1a.\xf9\r\xd54\x95\xdd\xe9\x80\xb1\xf2\t^\x84\xd7\x84\xc9Z\xb8\x9a\x1b\xd6\x00\x87\x0b\xfa\x91\x8eX\xa3-b\tv\x8c(\x93\xfe\xd7\x04\xbbu\xf3&\xad-0\xc4F\x86$\x87t\xa1\x1c:$\x90\xef\x05\xdbE\xff\t\xae\x0c\xd6\xa8\xfd\xaf\x13\xa9\xf4D\xe6\xf6K\xd4\xd6\xf5\x88B\x87\x97\xe1i\x9a\x90\x06s\x04\x06-\xa9\x90~O\xb18!\\\xf1\x98\x05\xe4H7\xeeq\xae|4v`\xf9X\xd0\x8b\x0b\ntd\xd2\xa9\xbd\x96\x0b\xdeQ\xa5Ex\xbc\xfb\xa3\xd7\x81\t\xe0T\x81E0\x1c\xfe_\x87\xac p\xec\xbd\x06J\xb4\x8da\rx\xf3\x886\xc6\xff\xbc\xcb5F\xd2v[\x87S\xb9[\xc6Y\xb5K\x99\xc4\xc8%\xea\xc60\\\xe9\xf0\xa8\xd7\xd8]\xd1 \xd9?|U\x9b\xcfz\xb6\xce\xcaRL-G[\xb4\xd3\xbc\x19\xd8Q\xeb\xef]mqNf^*>\x00\xc14\t;\xd8?\x19\xc7\x12\x04\t\xdd!\xd5wi\x170M\xde(\x08~/\xac\x99,\tO5\xe6\x00Dkd\xc23n@\x15\xbf\xab\x85\xd0\xe28\x8f\x8d?&\\\xe7\xe0\x91\xd7\x15N\x8csbP\xec\x92\x1b&\x94<=\xa9\x95\x8eC\xd6grX\xa9\xd9\xe5\xca2\x99\xaa\x8e\xe2\xc8\x86+j\xa5Rt2_\x12\xc9\x94\xc5Y\x14\xa5,%\xda-bV\xa5\xeb\xd9\x89\x03Y\xb7\x9d>\xfc\x9b\xe5\xa7?\xceWq\xb0\x02\xf4\xc4\x07\xa7\xa9\x80\xa3\x95\xf7\xaa\x10\xc4\xdd\x02F\x8b,\xe5\xdc\xefQ\xd7\x03\xb2*\xe1f(\xf0\xeb,8+<\xd3T\x1a\x9c\xe4&\x05\xc5\x9f\x8a\xc7\x0e\xa4\x80ci\xdc\xfc\x87\xa6\x00\xd0\xfa\x92@(-\xd52\x05\xe4\xdb{\xe4\xca\'$\x15@j\xe11\xd5\x88q\xa9\x14\xb8\xb3\x07\xe9\x04\xdc\xe2@?\xf6B\x8b\xd1J"I<\xedm\x80~wC\xf6\x07\xbc\xa6\x16\xb7+\x9e\xad\xe8\xad\xda3\x9e\xeabh\x9f\xf2\xa9\xe1M\xb3\xd1\x06\x9e=c\xfa\xde\x1do\xff\x1d6$\\\x1b\xac\x95\x91\x8b\x81\x8d:z\x01OR\xdf\xcfS0\xca\xd4\xfbL\xe8\x04\x849\xf6\x01\xa1\xd0Zb\xbd\xf6\x9a?\xf8!\xd0=\x81\xe2Q`!Guo\x1c\xfd\xae\xd0\xfc\xc5\x16\xd0\xa3\x19Z\xe5]W:\xa7N\xfc\xfc g\xd4\x9bM\xde2\x03\x1a@\x9ea\xb4\x19\x87M\xc2m\xda\xd0\xec\x8d*\x1b\xba\x0f\xaf\reg\xf1\n\xe3c\x9a\x0f\x85#\xca\xd7\xcc\xa2\xc3]\x0f\xc7z\x91\xee\xafv=\xe6\x8e\xe0%\x93+\x9b\xf3\x9b\x1aQJ\x1f;\'\x19\x81D\x97\ti\x96\xbb\xec*\xfc\xba\x88Y\xf4z\x04\xf9\x81\xd1"\x16\xb5\x14*_\xbb~\xff\x92\xeep\xe8\x91\xa7\x12\xdez\xf7\xdbE\xc7\xa8\xa7I\x1e=\x84\xad\xfeI\xf9\xef\xf1\xb7\xd9\x12\xea\xfa\xf2\x91\xfa\xc5\xbbX%M\x90p\xfd\xed\x08!w\xc0\xd7\xacM\xbb\x0c\x8b\xdc\x1a\xd3\xba\xd5\x9f\xc0\xd9\xb7x\xee\xa8\xc4\xb1\xc1\xc1\xef\xfc\x1a%A\x87\xcdZu\x16\xeb\x8d\x14 -\xfey\xbe\xd5\xa5\xdd\xd1"\xd0\xf0kq\x13\xf1x\x01i\x18cC\xc8\'\x13L\x99\xe5\x890\xb5\xb4\xd3[\xa3<\xed\x06\x84.\x85\xe0\x17)\x1d\xfa\x9dE\xc1\x92\xcd\xce\xa7\x82\xec\x90x\x15S\xb2\xe3\x11\xb8\x89\xaa\xe0\xad\xfc\xb1\x9f\xc0(\xb3)\xd8;\x86"\x15V\x04\x1b\x8cH\xb6\xbc\xdc\xec\xb7\xd5\xc0m}\x135\x1a\xb1>\xdf\xb5Ve\xf3\xc9]\xf8\x93\xdf\x88\xa7-\xc9\xca%\xf7\xb7Uk`O\xb4\xac\xa8\x848"\x90\x13\xf1-j\xbd\xd2\x82\x0b>\x8d\x1f\xfb\x1e\x02\xd2\xc7J\xd4\xde\xe2\x1bsM\xe4ALb2\xbb\xf2r\xe9\xf8\x8fA\xe3\xfb\xd2{C\xccxv\xad\x90\x1e*Jh\xd4\xcf\xb6?\xd7\xfc\xf0\xea2\xd0\xcb:\xf2$\xe6\xe7\xcc9v\xab\xfa\xb9\x05\r\xed\xec,\xeb\x1ebU\xbc\xb5}E\x84\'\x08\xfb2@eF\xba\x0ee\xf2wU\x97\xa6\xae\xa1\xf6\x80w7h\xaa\xff\\\xb8\x8e\xa2\xce\xbd\x8e\xb8T\x1cnB"\xa1+\x8f\x90\x0b\xa5+\xf5\xb3\x8b\xc3\xabl\xd2=G*\x07\xbb\xd7A\xb5i\x14Y\x81;1\x16\x9b\xcc=\x8bA\xbf0\x10D}\xba\xd1\x0b\xc50\xb6\xd6\xef\xe2(_L\xd3\xe2d]B\xc1\xb3\x1d\x89\x81k\xceO\x8b#&\xb6\x11\xff\xf0\xc9E\xcb\x00\xb6\xc7*\x95I\x94\xbe\x92\x08\xdf\x87\xe8\x81$l\x8d\x00~\xe2l\x1e)f\x15\x03\\\x9e\xd5\xdf\x98E\xa5\xc2I\xc2#\xa4>\x94\xfc\xbe\xa8\xe7\xbf\x0fa\x1b&\tNY\xacR\x98\x02i\xb0\xd0\xef7\xca&\xa63gY\xd42\xda\x07jE\xc67\x7f\xca\xe79\xc3J\xb3ML\xc5~J\xe7\x93)9\xd3Ly\xb8\x82\xbf\xfb\xec\x80\xf08\xa6\xe0s\x19\xa7*#\xa2\x89\xb6X\xaf\xfe\xf7\xc9@\x00\xf6\x19\xd0\xdc+\xe1\xcdK@I\'\xfdw\xc3\x86\xca\x8d\x868\xa7a\x12\xa1^\xba\x0f`0\xde\xce\xb46S\xab\xa4\xd8:\xff\x83\xc5\xbeZ\xc6\xc0\xaa2-\xe2&\xbbc\x82P\x88\x0ec\xcc\xad\xd7\x7fM\xe2C\x0c\x92gR\xb7\xb4\x17\x0f\xe3IbJ\xcb\xc7l\x0f\xe4\x96T\xb4\x1dTCl\xd3"\xc2\x81q5\xd3\xf5k_wy\\\xe9ac\xc2\x07\xec\xf4\xa4\xccr\x13\xc8\x8a\xc4\xd4g\xba\xb1\x193`mS\x9b*\xddd\xb1\x8eD0\x97w\xb3\xce\rb>#!\xaa\x8fO\xc1\xc8_\x8f\x81s\x1a\xb8 mQ\xaf0\xb3\xcef\xe6y\xae\x95\xd2\xce\x05\xe10\xd3\xf5\n\x02\x00K\t\xd3L\xeb5\xd0\xd1}\xc6\xb1\xa1\x02T\xae*\xce\x13\xb0\x99\xde\xd7\xc9\xf1\xdc\x960\x00O%\x84\xe9\x96o\xa0\x9ef\xd2\xf3\xf5w\xa27\x90gW\x1fe\x02\xd8\xc4\x81\xd0\xea\x9d\xc9\xa6\xad\xf7\xa0\x1d\xcfUDE\x92y\x17\xcaa8\xb1\x81\xf6\xa2h\xd5\x93\xc8p\x9b\xbf\xfa\x05\xed\x83\x88\xa9\x80/i\xdaY5\x83\x10}\r\xadw6b\xb6\xbc\x01Q\xa40\x17\x9d\xa7Y\xb1\xe27\x7f\x1d\xf0g\xf5n\xd6_\x18\x0bS}\xae|9\xc6U\xe8k`\xbbm\x9b\x87\x15\x04V\x83\xfcG\x87\xc1\xd5f\'3#tE\xf7\x8ah\x8et\xadB6u3\xf1_\xd1\x88d\xe0u+&\x05\xa4\xfbTL\xaf\x97\xeb\xf8\xc0,z\xc1d!c\x84\xb7\xb8O\xbb\xf1\x9aVg\xfa\xb3t}\xb6\x011\x9d\r\x13\x99\x98=0\xcf\xb4\xf4M\xf4y{\xa1=\x1f\xec7h\x19\xee\x9c\xc2\xa8\xe9\xa3u\xac\x13\x92\xd8\x06\x02\x0b#*\xc2xz\xf2\x02\x92\xe1f\xf5\xf6\xf4\xdb\xdaw\xf6\xb7\x11\x13\xbb0\xec\x8b\x93\xe4\xec\xe5\xe0)\x16\xeb\xfb\xc7\xb7\x9dq\xbf\x88\x87\xed\xcb\xdeu\x02\x98{3\x98\xf8\'\x95\x0e\x8fC\x13hU.\xa1\xfe\x8a\x9aC\x8fu\x1e|\x04|\xa6Q\x90\xff\xf4Z\xb8\xfa\x0b\x87\x1av\x9aE\x8e\xe0\xbb\xd0\xb2\xces\xa0wv\x0ei\xa5O\x80\x13H>!eG%\x01\xbc\xd1\xfdv>\x88"\x1dg\x8c\xa2\x96\x81\xd41V\x04\xe5\xa4\xd08\xf5\x1a\xd0\xad\x95\xe1O\xcc\xe9]q\x7f\xb5\xa7PP\xea\x1d\xe8#\xc1\x1e\x9a\x9d\xac\x1c\xa6`J\xd4+o\xed\xed\x14\x0b\x90p\x96\xcc\x0ebM\x1e\xd0\xadq\xde\xd6\xeb^\xa1\xed\x01\xd5\xf5\xff\xca\xf1\xa5u\x8f\x90\xae5?v\xeb\xa4\xc2.h>\x94\xdb\rn\xb2oz\xaasc\x97\x9d\x16\xb1\x91\x99r\xbc&_^M\xf5\x03y\xcc\xaa\x17\x9e\xe57\x97\xcc6\x12kR\xe3\xb0h\xbdZ7\xdf\xe1\xed5\x91\xb9\x92\nx\xc34Y\x87\xb71\x08#\xb2\x1c\x90s)\x92\xae\\\xe9I_\xdaJ\x1b\x13\x8b\xe3F\xae\xdb\xfcw#\x15D\x9f\x18\xfc\x05O\x86\x97IR\xc7\x03\x9ff\xf3\x8dk\x1a\x19\xa7,FtC\xf9\x16\xd0\x9ar\x18r\xe6\xc3\xe1\x9c\xc3\x98\xfa5\xcc\x1a\tN\xc9\xf1\x83S\x8b\x02\xc18\x97\xe1<"w\xa6{\x9bz\xf2\xf2\xa5|\xae\xce\x05\xe4\xb2\xed\xeb\x99\x8b\xe1\xb6\xf5\x18\xa9;\x90\xc1\xdf\xcc\x18p\x05\xf7\xe3,\xc3\x80\x94\xe8\xc4u\xdf\xbe\xf3>\x8cx`\xb6\xd2\x83\xbar\xc3\x14\x921\xa2\x13\x84\xcb\x99\xf7\xe6"\xbc\x84\xf9\x12d2\x88Ou79X{\xb2JN}k\xeam\r\xe3\xa8\xb19\x0e\xf2\xbad\xa5*\xa6\xaa\xb4\x81\x102\\\xbb\xdd\xdaj\xdc\x15\xf8\xf7\x1b[\xf3\xd3\xb9\x7f\xecu$\xa7\xb0\x90\xdaV\xe4\xc5{V\x8c\xb0J\x01\x11~\xba\xf1\x15\x9b\xc2!\x8f\xfe&\x18\xa3|\x97\xd7R9L(\xcd\xe0!nQ{\x01\x1dG^Ho\xcf\x9c\xb4\x8d\x7f\xc2\x8f\xcc\xe3\x8205\x17\x10\xcf_+q!u\xf8\x086\x07\xe8\x83,\x18J\x86*\x8d\xe0G\x03\xb8\xd2\x8a\xd7\x8c\xef\x1613\xf7\xe0p\xfe\xc5\xaf\xe2E\x01af\xad\xe2fT\xd3\xbf\xc0^\xb8\xe2\xd1\n\xdb{t\xe4$!\xb1\xb9\xf32\xd1\x97\xa0\xa4\xbf?\xce\xd9\xeduH\xefy\xae\xdfs\x06`#G\xf7\xb3\xd1\xeb\xb8c\x8c*\x0f\x0b\xe89\xdf\xcb\xae\n\xcd0\xaeq\x04V\xe2\tWW\xf3\x98V/8@M\xd3\xb9\x16a\xd3\xe2h\xcd\xc8\x92\xa9G\xefD\xbc\x06?\xd8\x8d\xbenyi\xcb.\x0e\x04;a\xe4\xd1\xf4\xa8\xc9\x91i\xa9\n\x9dh\x82\xd9\x8e\x97)\xd4]\x82\xf9J\xe8\x19\xf1\xbf\x95pP\xde\xa0\x19\x0e\xd2\xeb\x97v\x82g\xf0ve\xd4\xf1\xa3n\xf2\xa2\x91\xad\x9fU\xd8\xefE4-$\xed\x9a8o\xe9r&,:\x04\xbfa\'\xc2\xa7\xd0\xc1\x997\x98\xe0\xe19\x0es\xba\x10\x0b\x83\x1d\x84\x15;\xbbd"dk|\xb3\xf7FA\x86e\xc9\x8f\x87x\xda\x91^\xf5\xc0\x8c\xf1\x8fs\xa1\xb1p\xe8B\\\xe2\x82\xdac\x97\x00\x96\nNF\xbc\xe6\x86\x92\xea\x82Z\xeej@\xad\x81\x02t\x02\x97\xfaR6\xd3\x82\xb3\x0f\xdaH\xf4)\xe7\x9a{vK#\xb8`k\x0b\x1c+\xce\xa2\x0e\xe5\x13p$\xf9\x84q\xcc\x91\xe92r>\x84\x80N\x94\'\x12\xc1\xf9\xe7K\xbd\xbc\xef\x00c=Z<\xbb]"\x14\x9f\x92\xd1\xf6\x96\xc8?MB\x164\x9d%\xae\xbfl\x9f\x00\x950\xb0g\x1c\x83;\xb7\xe6+\xf2\xf0Z\xba\xd5\x94\x1fY\xf5\xcb\xa2\xb4\x82`9\xc6p\x8b\x04\xc3&k\x15\xd3\xd2\x9e\xd4\xf6\xb7\x02\xbe\xa5,`Y*Y\xea\xbe\xfe\x1c\xa2\xff*.\xd0mi\xc3\x00\x01\xd1\x96a\xd8\xd6\xe0f \x9c\xdd\xe7ep`\xe5\xc8\xa58\x80:\x11G\x9bo\xbc\xf4\xb8\xfa\xad\xdc\xc5\xc7\xe5\x14\xb2\xb6\xa4\x87\x96\xddr\xd7?\x12q\r\x92\xd6\x98\xd7\x84S\x0fX\x91\xe20\xbaM\xa0M\x8c\x00\\%\xf5\x92\x81W\x8e:\xf4\xd5\xd2\x18\xbb\x95f;\xb6L\xe6\xefh\xe2i\x9d\x88l\xc1\x8a\x87\xa8\xf9X\xbfgZ\x91\xcf\xc0^c\x1c\x8a5\x86\xe6\xc9%\x06g/\xc4\x02\xb8V\xaec\x8f1\x85\xce\xdf<\xc3D>\x03\xb0nx\xad\x84\xa3\xbe\xdd\xe8\xff4\xf9\xe6:t\xad\xa2\xda\xff\xedh$\xe1\x05\xdaP\xd5\xd4P\x13y\x94\xaa\x16\x9b\xbfo\xe0\x0b\xa7\x03\xb7\xc3W\x12X+\x864.4\x9d0\x10\xc6\r\x1e\x15E\xf6U\xa4\x00\x11\xbe\xbc\x19ipSN\x98\xa4JQ\x11\xcd\xdd\xf8\xbf\x9b\x061\x10\x0eV\xc2\x1e\x95K\xdb\xe2\xb6\xcd\xc2\xbc \xc12\xf5\xc6\xb82%\x0eu\x019(\xf1\x18\xa1\xfe\xc9\\\xd5\x16\xb8\x8e2\xa6u\xc1.\xc6\xacJ\x8dZ\x96Z\xbb\xab\x00yj\xc8\xf6F\x03\x93 \x0b\xabv\x88~5\x80\xe8\xa1\xbd\xb1\xdd \xcb\x9b\xb5\xc6\xd9\xce~4\x88E~\t\x0b\xc6~\xc5\x14\xcb\xc4Y\x9a\xcdSI\xd2\xe8\x12\xect\x13\xf1\x9d\x7f\x80\xc8r\xe3\xf27}U\x94\xd6\xb64\xc3\xc4\xd4\x97\x02s\x81id\t\xb4S\xcd<\x81w\x00\xa7\x0c\x92\x10\xe4\xf7\x8b#77\xf2\x8ai\x06\xa1\x9fw*\xfd\'\xb0\xf9\xd7X\xa9\x84\xfe\x91\x06\xda^N\xdaz\x94E\xe6p\xb2\xc0\xe5b0J5\xfcR\x852h\xfc3e\x93;\x81;\x83|\xde\x1fG\xad_R\xefX\xf2\xf1\xb4\xee\x00}_\xaa\xae2\xad\xcflH\xd1\xcf\xf5\xcf\x08Y\x1dS=[\x14\x0e~\x9f:\xf1/\x94$\x18|\xd8eF\t\xc4\xe6x\xd2\xb6\x89:K]\x97\xb5\x02`\xd1\x8d\xe9.-\x95\xa1 \xa7{\xea\x87\x7fS\n_\xfeW\x86\xc8-7_\x0e\x90\xb3\xb4\x1a+Y\xc6I[\xb09\xb4\xb3\xf8\xa5\x03P\x81J\x1e\xa2\x0f\x01\xf8 \x19\x99\xc4z\x93W8\x95Y\xac\x9d\x85\xad!\xd7\xb5\xa9B\t\x14\xc4bG\x1b-\xf0\xa1\t\xe4\x01\xcf\x0e\x83y\xd0t\x04\x8c\xf8\x9cD\xab\x9cE\x11o\x90W\x1e \xa8\x1ec\x03\xfd\xc8\xd8\x16\x8d\xc0\xa1\x17 \xbe\xf3%\xee|Y\x8f@\xf0X\x98,\xe9u\x1alWz\xc3\xe8\xe3SO\xceS\x1fHP\xe0\xbb\xbb\x14rw4v\xf6fK\xcc\x9d\xa0p\xb6\xf8\x82\xbd\xea\x95\x07SA\x00,\no\x9d\xac\x190\x81\x19\x07\xbf\t\xf3\xf5`\xb8}\'\xa4;\x18\x85\xfey\x05\x17b!`\x03\xc3F\x89\xf6\xeaW\x0c\xab\x8a7l4\x8d\xd1g\xe8\xa5\xcf\xc5\xa38\x1e0=\x9cg(.\x8e)\'\xf8\x02\x99\xe3\xff\x86\xb7\xde\x94\x89!}/\x18\xb2\xa8$\x90u\xda\x1c\xeb\n\xb0\x04*{*\xb3\x80X\xa5\xef\x8f\x87kAC\xfe\x82\xce4\n\xd3\xe7Kz\xf9\xce\xbd& Q\x7f`o\x04>j\xce\x15H\xcb\x19(T<\xd2\xb2C\xad\x88\xcb4\xc8\xde\x80\xfcZ\xdf\xb4\xdb\x0b\xa5\x1f\xa8F\xe6\xeb\x06\x038\xe37\xa8k"\xc3\xe0\x18j-\x80\xa4\xa6@\xcc\xa9#\x98\xec\x82\x96_\x0e#5\x82\xd2\x06\xac\xaa\xfaM\xa7\x86H\r\xfb\x9a\xc0\xf6Y\xfa\xb1S.\x11\xfbam\x8b\xdfk\x88\xea\xa8e\xd4\xb5\x8b\xdfn\x92\x19\x83\xdc\x008\x13\xbb\x99\xcd\xa6\xfe\xc9J\x08\x03\xf4D*\xf6\xb9~>9\xd9\x18a\x80?^\x92\xfb_\xffw\x9d\x11zq\x91:\x07\x02S\xc6\xd8\xd7\x85\x05[\x17k\x01bl4\xff\xb4\xe7\xa5`.\xa4|\x87B\xbe\xa9\x15\xfe\xc5\xf5\n\xb3\xf7\xdf\x99\xc4\xf4\xf8\xad\x81\x19$\xcbL\x9f\xc9\xe1\x01Y\xe0\x1f\xe0hOs\xcdB26\x9a\xe9S&3\x89\x1b\xf7\x94\x96\x89\xd7\xd3\xc6\xe8\xe0\xfdb\xc98h&\x1d3\x07R\xc5\x12\xd4\x12n\x9bt\x9e\xa33\xad\xb33T\xcc\x8cq\x1e\xa9\x81\xca\t\xa6\xf2\xfcR\xb3h\xf5;\xc6\x95\xe7\xa5\x91\xc61\xa1\x9f\x8f\xba\xeb\xbe6\x18\xeeD\x9a\x1a-\xa64\xf8\x18-1[\x03c\x1b/EJo0,\xd2\xc3\xabZw\x8aK\xd7\x11\x1bI7\n\xa1\xfa\x921\x81\x07\xb5\x84\xa6\xbe\xa6\xf9+\xef\xd4\n\x1bU\xa0iX\x17\xe8\x1e\x15m\xcaMPc\x80\x82\xe5\x0f\xbc%\xaa\x07-z\x07\x9b]BW\xb4\xc9T}`\x94\x84{\x04;\x94\xc6\xa5P4i\r\xe0\xc7\x13\x93\xb79\xa4\xff\x1aU\xd6\x98K\x04\x87\x0f\xcd\x14g\xc3\x84\x89\x1b I\x00\xa6\xd1\x96T\x00\xe0[42\xe6Bu\xa9P\xb3n\xe0\xc9\x1d\xc4f\xccj\x07\xcd\x1d\xe5\xd6\x102\t\xd9 \x80\xe1\xb75\xb6\x84\x8c\x87\xe9\xd8O\x86w\x1e\xd5\xae\x93\xcc\x8d\xc2\x8f\x15\x99-\x89`fFK]&\x9bm\xbf\x15(z\x83\xc3\xc36\xdb\xea\xdb\xdbu\xfcIw\xd1\xd7O\xf6\xee\x94%\xcd\xefo\x91\x9d\x17\xc3\xbf\xef\xc9y\x18\xf7\xcf)\xde*^\x18\xc0O\xfda5\xf9!3.*\xdf\x1c\x08\xe7\x97tRF$1\x084M\xf7\xad?\\Q\xef)o\xcf8f.r\xe4\x0f\x9c\x98\xca\xeb\xde\xf8=DJ\xe4I\\\xf0\x1a\xaa\xbf\x9a\xc8\x0b\x7f\xc3N,\x8a5\xe3\n\x95\xd7D]IB\x15\xf5\xa3\xb0\xdaow\xb1v\x9c\x01\x9bP\xf9\xc2P\x88\xccG\x89>u\x1a<-k\x9b\x1d\xf5\xba\xef,\xaa2&\x17\x7f\x9a,\xabaV\xe7\xf3\x93\xab\x07O\xc6\x9f\xd1\xc9\x8e+qn>\x91\xc6\x03\xe0\xdb\xa5,9\x17\x04\xac\x04\xd3\x88\xae\x9a\xf8qt}\x81Kx\x10\x0e\xf4\x9f\xcasy\x1cG4\xd7\xc3\x88\xf3\xa6\x1cPm>\x90/\x0b\xff<.6\x12\xd40\xa0\x14\t\xe1\xf0\xdf\xd6\xcc\x95\xf87j)\xe7\x1e\xd7\x80\x9e\xfd\x96qgJ\x1e)\xed\xd5\x8b\xd90\x16T\rv7\xfau\xd3t\x16Cnx\xa8\x8c\x0f\x1d\xd6\xb4\xb9|\xc8\x920)y\xacYn\xbf+\x1f\xa0|\xcf&Yk\xd7I\xad\xf6P\xf3\xe1\x8b\xa2\xff\\\xe9I\x0c\x00\x18\x1c\xfaE\x8e\xbc\x9b%\x03\xd5p\xa0\xa6l\x0e\xd3\xec\xb0\xe8\xce@*ME\x8e\xfb\xcc\r\xcd\x10n\x0f\xfa\xa8\xc5\xd7\x86~vUC8\x03\xc4\xd8\xd9r \xf0:\xd7\xc4\xc6\x086\x9a\n\xa2\x93\xdf\x88\xce\xd2\x06\x94\xc8\x9a\xc4\x9a\x05\x0b\xc1\x19\x90\xd7}u\xa5\xe5\xf6\xb4\xc3\xf6N\x9eK\xa1\xeay\xcf?\xd6j:\xeds(6\x83\x94\x87\xd1\xeb!\xbb\xecH\xae\x17\xb0|wz.\xea\xaean\xe7g\xdb\xc9\xd3\xf1\xd9\x9f\xc3a/\xf6\xbe\xd2O]\xb7:\xbe\xe5\xe7\xa5\x92\xdc\x02\x14\x99\x84 \xe0\xca1\x93\x06\x83/\xf5(+\x15\x8f\xba\x9by\x0c?\xe2\x84\'U\x94\xb1#\xfe4\x00<41+9h\x13q1$o\xef\xfaB\xd0r\x1c\x81\x0fB\xac\x84\xd9z\xcc\xb5\xf5N\xd3\xec\x1e<\x06\xdf#&g$Z&\xd5\xa8\xd3\xe8\xe99l;\xa1\x92\xcc\xder>G\xef\x86\\v\x9f\x87\xcb\'\xb30R&\xf9*Y\xe5[\x00\x92\x08\x82\xc1\xe4Z\xcev\x95$]\xaf\xaf\xa63_(\xd1m\xdfS\x97)_\x92$\xaf\x92\xf7\xdd\xfdP#\xd0\xed\xd9\x17P\xd86~\xa6T\x8d\xe0\xa4\xa5\xcc\x8c\xaf\x0bX\x04\xf9\xa8a_\xaa\xa9\xa8\'jV\x8d\xd5\x93*K\x16\xe4_\x87\x08\x8a\xcbu8\x1a\xbc\x8fv\xf0\xa28\xdc\xf9U%\xcfB\'F\x12\xf4\xa5V\x02\xbd\x12xR2\xd5\xc2z\x8c\x02\xad\xc6|%\x11)k\xed\x1d\xa3\x86\xca/\xc8\x02;K\x8f\x87\xd2\x0b\x9fM\x16i\xc8\\Y\xf3v\xa0\xcd\xf00\xef\xca\x82\x17M\xb6\xc6\xb0#\xdbv\xc8x\xbb\xcf\xc4p\xd4\x19\xddA\xb19\x87\xe7D\x7f\xbd\xa1L\xab\xf7\xf7+\xef_e\xc8\xb4fx%\x8e\x9fj\x87\x04Yj\x05\x1d\xe0\xe2f\xd8\x9e\xe1M&\x0f\x8d!\xa23\xf0\x7f\xb9\xb2\xe1\xa7\xffnK\x87\xe3S\xc0\x98%B\xb8\x84\x91*\x83\x12\x1e,\x06_\xa8\xb6\x8dy\x9c\x0c}]bj\x16cR\xc2\xeb,\xef\x87K\x01B\xf23\xe6,\x08\x96o\x1c\xf4%;`o\xcf\xa7J\xfc\xc2\xb6rWXO~m\x04\xe5\t{\xd0\xe7\x17\xdf"\x80\x8bW\x81\xfc\xd6\xdf\x9b\x0b4\xd42.\x03\x84\xab\x1e\x07\xd9"n\x17\xba\xa1x\x9dY\t\xa4#=\xf1\xe9\xb5\x08#\n\xf1\xc42g\xbd\x15\xea\x88\xb6GgY%\x8fF\x1b\xfcA\x82l\xe6\xf0\x11\xa8\x1d\xf6\x83\x918\xd3\x80\x1b\xf2\x8a\x8ep\x83\xefe\xfb\x16\xda\xee\xcfWd\xa4\x8d\xd9\xb5@&\tn^\x8b\xecM\xe0\xf0\x8aHB\xb2\x96va1k\xa5\x90\xa6\xc0d\xae\'4\xcc2]N\xa2C\xaf\x07\x12\x01\xc1\xd7\xaa\xb9T#A\x98\xf4\xa0\x1a\xc9\x11\x11P\x93\x05\xa8`\xec\xb3K\xf4Z}O\xed.\xeb}$\xb3\xcc\x0bo\x8cZ\xcb\x1d\xdb"\x07\x9f,\x00\xdb\x96\x99\x11#\xc2\xcd\x14\xb3\x9a\xad\x91\xaa\xaa\x16oP\x86\xd9\xde\x01m\xfc\xe0\xa9\x9d\xfd\xd4Nzz\x16OH\xd5/U c\x99\x01\xbc#0\x8e\xffqu[hXE\x08(\xb4\xa9\xca\xda\xc3\xca\xc2\x19\x8e~\xb5a\xa1~d==|E\xe0\xcc\xb6\x9b\xc4\xcf\xb6\x07\xf9~8\xcc\x80\xb7<^v\x86?\xe4\x12\xec\x80\xe1\xd8\x881q\xa9\xc5\xdc\xc8v\xd0\n\xa7\xd3\x8f\xe3\x90\x90\xb4PS`\x1c\xca_\xc6\x00qc\xba\x90\xed\xc2M\xac\xacV\xf9U\xa1\xbb\x02\x19\x8e\xe3I\xcf\xcf\xe0!2\xc0V\x96\xdd\xe8\x84\x9a\xfbSZR\xe8\xf9$\xe1\xfa/Ei:sW?\xf3Y|\xe2\x8aZ~\x7f\x9c\xfa\xc2\xed\xadF\n\x8d\'\x1e)9\r\xf8<\xc9\x8eb\xba\xf7\xa0a\xed\xae\x02j\x15\xd6\xb7(x\x83\x10\x9c\xde;\x17\xda\xfflvW\xf6X\xbaC\xd2`\nN\xff\xbd@\x96\x93\x85\xab\x1bP\x8ex\xcb_\'\xc8\xfau5\'\xe0\xddf\xa5\xea$\xeehfm\x1f\xbb\xec\xd3\xb2\xa9\x98F\xa9\x9c5\x0fR\x9aZ>Wz#\xb9qs\x0f\xe0\x17e\x17\x12\x145\xdb\x01~\xd4A=\x10\x8a\xcd\x19(:\x88\x9f\x17\x02\xe8j\xed3\xb0\xafS\xc6\x8e\x10Bv\x9a\xc9\xd0\xeb \xeeK\xa7*I%\x97;\x8e\xb7\x88&R\x9de\xcb\xa5\x90\x00%\xac\xd4 p\x7f\x8d\xab-\xfb\xa3\xd4\x81)\xb4\xbdV\xd3\xf2HB1\xea}\xc9V\xd2\xd4K\x16\x8dv\xd3\xd7\xfe|,\xca8\xf3\xd5\x99\xab\x95\xdf\xca:\xcd\xce\x1cA\x1e\x1b\x1fm\xdf\xbb\x91\xd1\x8e_1u\xde\'\xd1\x8c\xfc\xc9\xbe\xf0\xf5\xeax\r!\xe4\xcd"-\xe7\xff=\xa6N\xd5\x00{Q\xee3\xcf\xecv\xc3z\x17\x17C\xf3d\x92\xc5\xfc \x8e+\x90\t\xe8R\x12d\xe9}\x94\x92\xcd\x06\xe9h\x1eSQ\x0b\x17\xee^\xeb\xd0\x94!\xf1=\xab\x12\xeag\xf6\x85VA\x18\xdf\xe7\x0b\x89\x1b\x05\xcf\x90Q\x15\xc2\x8f\xfav\xe5\\\x1a\x8cR\x07\x81K\xf5k\x9b\x92\x05l\\Xe=N5\x95\x01\xd4\x91\x94>\xb6\x0e\xf0\x0e\x83T\xa6!3"\x13\x00\x93\xfdC\x9b\xd8Y\xd0\xd3uZ&\x80 \x8d\x1fz\x9e\xbcd\xce\xcaA;\xbb\x15\x0b\xa0b\xe1X\xfaL\x9d\x8c\xf8|S~C,\\W\x81\xc3n\xf6\x01\xf4\x00\x1c>\xa2)*\xfa\xdb\xac|=\xc7\xd2\x99~c%\xbc6",\xdd\x83\xa5\xfe\x8bA\x1a\xef\xaav\x08eNh\xa5(Z\x1f\x01\xa5\x91\x8bW\x83\xea"\xea\x10T\xf1\xd5\x97i\xa2\x04y\xab\xca\xbb\xf0\xca4\x93U\x0b)[\x98\xeb\xe2\x14\x0c\x8e\x10\t\xc8\x0f>5\t\xbd\x9dh\xa41\xc1\xc8\x98\xae\x05\xf8\xaff\xc9\x90\x0b\x8e\xb2\x0c\x98C\x97\xe9AD\xf3\x0e\x03\n\x19\xe7IZ\xa5g\xaf\xf3@\x9f\x95lj\xb8J / \xb2_\xe17\x9b\xb0\x05f\xb2\xa8\x0e6GC\xcer\r\xeaD:\xe5\xe2\x95\xb7\xef.H\x917_\xdf\xea]\xdf\x07W\xdd\xaa\x88\x8b\xbe\xb3@\x00!\xbb\xcf\x16\x1fJm(\x00\xd0\xc4\xf6\xcfm\x89\x8c\x83\xdan\xd9\xcf[\x7f\xfa\t\xc2\xd88\x02J~\xa9o\xfa\xff\x99 &\x9e\xe7_\x0f\xea\xe3\x1bs\xc9\xfe>4\xd9\x146|\xc3L\x9a\'\xc3P\xd2J\xd6\xa7\xd0\xfb]|\xf3\xc5\xf9\xc6fd\xa7\xec\x91}\x0f\x0e\t\xa9\x00\xb1?KY\xbe\x96Lv\xfb.T\x0e>k\x08|q(XI\xcc\xfd\xf5X45\xd7\x13-\xdf\x97\xc4\xaf\xcf\xbd7\xf3~a=\xf9\x99v\x83\xd8\x9e\x1d\x1a\x12\xf8\xdc\x11S\xd7\xfa\x98\x9a\x8c%ee\xad1\x8e:1\xcc\xd8\xa2\x83\xe8\xd2\x19\xfd]\t\x98w\x1e\x1d)\xbf\xc8Kx\xedAO\xcfB\xe6\xf2\xc0\x84-n\xc1i\xa1\x9a\xa3\x95~Ir_Ex\xa7#\x9a\x03\xed\x1d\xaf\x19\xc6\xc4\xd7\x1fyi9\x89\x13\t\xc0\xdb\x0fi\x97_*,N\xbf\xdf&nq2\xe4_|\xc2\x8d\xb6\x08\x8f`_P\xde8\xdd|\xc2{m\xc3\xa3\xa0\x07\xd5\xab@\xf13P\x84\x19\xfc\x8a@\xc4\xaa\x7f\x80\x86\x01"\xe1\x8aS\xa5V\xd8\xa8W7d\xfc!5\xea\x12\x11v:\xf6W\xd9\xf1\x1e\xf7*[\xfda\x05\xed\xea-}b\xbc\x7f>[\xe0Q(\xa5h\xb9Qpi\xecUt\x7f\xb5\x06.;\xf4\xd8\x97\xb3\x16\xd0_\x1e\xd4\x9e\x82\xa4\xea\x04\x08V\xb0\xe4C\xd1a\xf9\xe9\xdc\xac8fJ\xc4\xa6~\xfb>W\x08Ym]\xe2\xe9L\x03\x1f\xeb,Q-~\xe7\xad,]J\xa1_1\xc9{\xd4l\x91\x89D\x00\x18u1\xb4\xba\x90\x1dn\x0b%\xd4\x93J\xac\x15\x17;\xebOHx\xd4[H*\xce63\x1b\xfe<:%\xa6\xb0\xdb\xfdl\x0ev}e\xeck\xee\xdac\x1az\xd9\x96\x10\x08\xae\x86\xf7wB\x86\xee5I\x8e:FOHA\x00\x08m\xec\r\x0fb\xa94\xdb\xa9|\x8d\xb7.f\xda\xad\x15lF\xa8-\xfa\x84\xc89cEEp#\nw\xf1\xdc\xf5*\xdd\x08ZOx\xf1_n;.\x0b\xd8\xa2\x0f\x87\xa1\x00H\xd0\x05BX\x9c\x9d\xde\xce\x8e6\xacY\xa4\xe1\xb5\xe52\x1c\x0f\x9d\xf8"h\x10v\xc3/\xcb~S?\xe4Dg\xbd\x078\x90\xe3\xe8\xbd_\xddiAxh\xe9\x96\xc1\xa8\xf8\xea\x88S3Wo,\xcd\x876\xf8\xd3\x084\x0ey\x9f<\xf4\x93\n\xdb\xad}\x01#\x18\x98\xb4-X\xc0\xbd\x94:\x95\xab\x0c\xdfO\xc5\x99\xa5\xebf\xd4\x04\xc8N_%\xe3TdId\x00\xe4\xcaF\xb3&%\x9b\xdb\x10\t\x1c\x9f\xdb[J\x98\xf4\x94\xae\xbe\x97X\x01a\x16.<\x1bJY\xf4~\xa5J\xfd\xf4\xa7\x10\x9b9\xf4\xc8T[\xa2\xa2\xd2U\x7f\xe4\x03\xd7D_\xb7\xee\x03\xb5\xd8tv\x11\xc2\n\xc3\xb4+\xe3\xb7\x1c{\x14x\x04\x02\xaf\x95U\x8c\xe5\xad\xf1P\xean}\xbc\x94l\xf8\x06\xe0\x15+\xdb\x9a\x89\xf8\x1c\xb0Sz\x81\x96\x83\xef\xf4\xb1>\xb1\xf4\xce\xd06\xc5\x89{\xac\xf5\xf3\xdb\x1aE\x9a\xfd\x02\xa2\x16\xff\x0c\xdbFc\xa4.\xcb\xe7N2th\xa6\x9e\x1d\x8blGB\xa9\x81hy\xfc\x1c~\xfaY\xb3w\xb45\x92h\x16\xb2U\xb1\xb6sa\xfe\xee\x07\x1b$\x89\x88\xa46\x11\\\x97x]~\x99\xc1\xc8\xa2PF\xe1H\xec\x12$\x8e@\xff\x886\xaah\xa8q\x8f\xba\xcc4+V\x9a\xceU\x81\xb9)\xdc\xeb\xd2\x88N"H\x05I\x13+\xd15\x05$;[\xbe\xb4v\x8c\x00cu-^$\xa4\xc0\xac@\xc9JW\xac\r`\xd0#$\xd8@\xda}u\xe1\xa6\xb1\x88QKP\xb6\x90\xa7\x1d\x9c:\x03\r1+_rdi\xad 2d\xf6\xdb!\x9f\x01b\x91\x8cq\x16_\xa0\xd7\x00\xcf\xee\n\xb6\x04~\xfe\xea\xe7\xb2\x92\xec\xe2\xeblL\x05\xa9u\xf5P\xe3^\x1ay\xf5Y\xa0\x1dQr\x95kW\xfe\xbb\x16m\xa2\x9c~\xd3\x18\xafD\x04\x18b\x8a\x9b\x1et\xa1\xcb\xb5\x82\x96\xc6\n\xe6\x0e\x90\n\xba\x99)\x0e~\xcf\x16\xed\r\xe3\x1c\x9d\x00\x9au\x83\xee\xd3\x88$\x1c\x82)_\x81\xa1\r\xae\xae\xb3\x94\x05\xbd\xc86@5t\x07(}ZtZ\xfc\x8d\x1eUE2\x8cD\xb5i\xce\x901.\x93\x0e\xd1X\xfb\x1a\xe13!\xa5\xbek\xbe>~^\xe7\xc7\xfah\xb4@l\xda\x0cBI$\xe5\x83\xc4\xb9\xf0\x19=\xf9\x05\xfc\xa9\xaa\xe6\xfa\xd3\xa3\xee\xca\x18\xbf\x8e\x90\x8e,\xfd\xb7\t\x91\xc7\x9f\xd5\xb7\xcf\x8ab\xb2\xee\xd6\xa4\xa0#\t\xf6V\x14\x8eTL\xdfQ\x99hF1\x97\xfb\xf5\xe9\xeeg\x80\xce\x04XES\xdf\xd7\xa6NR\xc1\xa5\xd9\xf6)\xbfV0\xd5\xdd3\xbe\x8e\x19\xe1\xf4\xfa&\x80\xc2\x9a\x8d\x83\xc6u1\xcc\xaf\x07\xd6\xd6\xb5\x87T2\x84+C\x1c\x91\xe0\xfc\xe6\xa3\x12\r\xcc\xe5\x85\x02@(\x84\x85\x88\x10\xb8,\xf7\x19\x88K]\x0c\x1a4\xa1&%U\x82e\xf8"\xc5\xfc\xa2C\xcc?S\x9e\xa2/V\xed\xc0\x1b\xa1\xdc\x91\xc0\xb7\xfaH\xbdj`\x81\xb5\xfc\xf5\xd2\xc8\x15\xed\xd8K\x8f\x0b\x87\xb3D\xa1\xff\xcf\x95\x94\xdci\xeebo\x91"x|ln%A\x88N\xc8YS6M]\xeaG8j\x88\xa3\xd9lQ0GB:k\'\xe3I\x19\x83\x0fr\'?\xfe\r\xec\xfb73\xd3\x8dd\xbb~P\xb2\xa6%\xd0\xcc\x04\xae\xb2q8\x01\xe5\xb0X\xfeH\xd8\x8fXq\xcb\xa8\xe1\x8b\x0fa#\xbe\xc8h%\xf1\xd5zv%\xb0&\xe9|\xa7+\x18\\j\x1f\x06b\xda\x0b\x1e6s\x8d\x91\xd7\xdf\x802\x12V\n1\xf4\xbb4\x1a\xe1\'\x8ep9o\x83\xf6>\xaam\xc7\xb6l\xa32\xe9\xd2\xf0\xee\xae\x80\x00\xd3\xea\x87\xdd\t\x05\x08\xa1ab\xd5v\xae\x81D\x0c(\xe4\x0f9j\xd4#\xc2@\xfa\xa2\xe8\x03@r:\x8b\xd37\x0c\x1b\xc5\xfe\x0e0\xf3#\xb7Q\xcc\xe5\xf8\xb5\x8fll.~\xe3q6_\xeb\x19\x18\xa0\xc6\xef\xec\x8cW|\xf2\x8b\xe4\x91;\xf7\xec8\x9e\'b\tZ\xfe\x88}\xa1\\\xd2\xdamE\xa8\x9b\xde*\xf4u\xf5;\xa2}\t\x970\xf9&g\x08\x16\xd21\xeb\xbfOo\xc0\xb5&\xdf\xcd\xae7\x11\xe6J\x14\x91\x15\x150\n\xbe>\xfe\xfd\xbdMl`a\xb1\xfeT\xfb\xfd\x1b\xdc\xbf\xfb\x1fN\xda\x99\xe6\xc5\xb6\xc9]\x93\xd53\x93\xa7h&!N=fL\xf9T\x7f\x94\xe1*\r\xc5T\x06\x04\x04J\xa3b\xd0C\xa4d`y\x0c\xcc\xc8c\xf5\xd6\x99_\xfc\'\xdb}L\x9b5\xcb\x10\xb6s\xbc-\xf9\xd0s-\x9d\xe8\x0bj\x1b\x17\xd1\xf8\x80\xd1\xe7\xeaJ\x11{\xd87\x91\x94(* \xab\x00J\xb2\x90,\x13\xf4\x1a\xf4f\xdcW\xe1\xa2\x91\xfa?\x19\xa4Vhu\x99\xd6*\xa5!\xab@\nr\x88\xc4:\x90\x15x<5R8\x08sSx\xe8\x04\xa6)\xcf\x1f;zR\x0c\xd9\xda"\xb5SPQ\xeb\xf5\x1b\xc0.!\xac\xb6\xc6d\xa75\xb4\xff|E\xa0\x9c\x0f\xba\x9c\xa4B\x1f\xb1\xad=%\x8e"\x8b\x00,P>\x8a\\\xa8JaBF\x19\xa3}\xa1\x82\xdb\xb2\xd0\x1e\xe9\xb3\xb9,A%/i\x10*\x1bCA\xe9\xd0L\xe4\x1d{K\xc6J\x91Y\x0c\x88]\xdc\xe0\x7f\x7f\xd5\x18:\xdfw\x7fo\tY\x06\xaf\xa8\xcf\x87*\xf0\xf0\xbd\x9feQA\xdd}mK\xbdA_\xb3,DY\x02y\x01\xa0+k27\xc5\xae\xb2\xb75\x04M%\x0c\xaf\nn\x93\xbf\xae\x01\x03\xf1\x1f\xc3\xbb\xc2\xf3\x1c\xc8U\x9eJ\xd4\xf3\xe3Zu\xc6\xfbzrv\xf9\xdf\xbb\x86?\xb7\xd2\xafh\x9bJT\xc9\xfa\x02\xdc\xa8\xc8\xa1+\xe4\xd4d\x0b]M\xcc\xae,?\xd6.b\xdfM,U\x96d\x8c\x80\xad\xa7\x9b\xe4\xd8C\xe9\xa3H\xddAF~.\xe2h\x94g4\xec\x8d\x96\xdb\x97\\\xc5\xd7!\xd3\xc8\x80\x97\x06\xc8\x03\x83\xaf\xe3\xa8\tIh\xed \xd7\x8a\xed\xeb\x10\xcb\xd3aJQ\xe4\xa3\xcc\x8dz\x98*\x1dD"Us6\xe4\x07\\]\xbf\x06M\x9cZFQ7\xfa\xeeH\xb9\xfac\x0c9\x8a\xf3\x0f\xb7pz\x838\xa5\x84\xac1\xba\x1b\x9fl\x03\xe6r\x99\x12\x02\x13I\x12\xad\x9a\xee\x0e\xdc{\xa58\xb7\xc4\xe6\x8dxv\xd3^I\x0f\x93\x1a!\xddN\xaf\x0b>\x00\xd3b\x0c\xc2t\x9a\x88\x0eS\x8d\xcb\x8c\xfcfn0oON\x92\xd4\xdc\xc17\xe8<}@\x1cV\x8bB\xa7\xc9\x82\x04_k\x99\xb4\xf4\xf0ms~\xe2\xbc\x86: \xc6S\x97\x16\xba\xfaZc\xc0G\x1a:<\\-\xa9a\x05\xa0\xde\x18/\x8fOF\xfa\xe2\xe2\x02\xd8\xda\x96\x88\xc6\xd5\xee\xe1\xb4\xca\x11\x8e0J\xc3\xef(\t\x83\x1c\xacC\xe6%\xfd\x10O\\\n\x15\xc9\xcc\xee\x1b\xc4\x9cu[\xdfn\x0com\x93s\x91\xa7\x85\x12\x9f\xe4\xdb]T-\x07;W\x1b\xafvi\x1c\xcb\xa5\x93?\xae\xd4Y\xb8\xbd\x8d\x0e}\x84>K\x8b\x97\x11\x96\xc2W~\xb1\xb5\xce\xee\xbe\xb5\xed\xc6}\xb7.\x0bb\x07)\x06\xdb\x9f\xdf\xf1\xb2_w\xa4_z\xc447\xfad\x03\x1a\x1a\xf5\xf2\xb1-*\xf0\xb8\xbb\x03\xa2\xb5\x953\x14\x92\xaa\xdaa\xcc\xd4+\xc0\xb1\x9f"\xfe*?,\x17\nU\xb9\x17\xe4\xcb&\xa4\xbf._\x11\xbaa\xd4\x17\xd9>@\xd8\xbea\x18L)O"\xb7\xc5\xbd\xa6\x1e\xa8\xbc\x8a\x9f\xe0A\xc0\x11\xb5\x94\x1e?\xe1\x90V\xf4\xa7i\xc5\xe4~B\xa1\x9f\xcb\xde\xf4\xc7\xc1\xc5N\xb9z\xc5\xf0!E\x97\xa5\xe3`x\x13\xc5\xd6\xbc3\xe2j@\xbb\x87\x9cG\xd5\xf7&\xd9\x0e\xc3O\x85/\xb9\x0b)\xafl\tV \xd4\xe2\xb3\xa0\xdb%\x9b%\x90q\'\xbbf\xe5p\x81\xe8hH\x822K\r\xd5Tki\xca\xa7\xdb7N\x96_\xff\xe1\xd8?\x82\xb5#\xdbP\xc0\xac\xc5j\x9dO\x02A\x9do\xd8\xb7\xe7mm\x0c\x8eW0~\x05\xf9\xe2\xfb|\xe54\xe2]#\x0b1\x02\x0e;tC\x8d\x98u\x0f\x1cQ\xc4qnOU\x90\x95\x82\xf1 \x9d\xb4)\xceH\xb3\xc1d\xffL\xa6\x91\xde\\\xe7\x9f\xd6\xba\xe5\x01\x9f~\xde\x1d[9\xecj]\xc4$\xa6\\\xbf-C*\x0f\xecY9A\xe6\xf8\xfaS\xb9\x0c\xcdY\xae\xe3\xe7?\xa0\x80\xb3C\xa1\x8d\x18\x1b}\x8f\xd8\x08\xcd\xc9\xa9\xcf9k?\xad\x94\x84\xab\xa1R\x06\xd7c\x81\x9d\xce\xe4\xae\xdf*}F\xe7q\xf6\xef\x8e\xac\xa0#\x1e\xa0\x11\xfaEz\x13b6\x80\xa8a\xcf\xb8V\xde\xf3\xd0\x0e\x9c\x12\xb3\x80\xf9L\xa1\xaeT\xea\xac\x8e\xee\xab#\x11/\xb3\xe1v\x9f\xe0\x12\x05\xe80=]\x9d\x1c\x0e(\xe8\xb6O\xff\x06\xa0\x07\xa5g\xc4-\x95\x80\x10\x90J\xd3\xf0\xb3pe8\xfal\xb6\ne\xc5\x06\r\xfe\xf8g\xf1\xbd\xce\x14\x86uy\xd0M[\x8d\xda\xf3!\x0f\x97z\xba\xa7\xf0\xab\t\x01\xbc\r|\xba\xe12\x9d\xd0\x016\x9a\x15!\x9b\xc1&\x9f\x01`\xd5\xd9P\xae\xb6\xe1KP\xda`\xef\xcb\x9d6\x0b\xe2\x85\xb0\xdc\xeb\xc2\xd7X\xdf\x1b\x1b\xa1\xa8\xe6\xd3\xceG\xfd\xf1\x8b\xd4\xe8\x8f\xf3\x95\xdf\xfa\x15\xbc>\x88\xcc\x9f\x13\xa3Q<\xbb/\xa9\xf2\xe9\xc5\xf1\x81\x93\xbb\x85\\\n\xa0\xaf\x08\xee:\x83I\xb1]\x9c\xf7T\xd1\x05w\xf1c}+\xe8\x93\xf4S\x90O\x9d\xba\xcd\xd8\x1e\x17W\xb3=\x98\x1e\x00=j\xbf!1l2\x9e\x8eX\xc3\x19\x8e\xe7a@F\x8c\xc1\xa4\xa4Aop\xa0n\xfe)l\xf77\xa2\x16\xe5\xe1\xc7\xe5\x94M\x87\xd4D\x9f\xb6A\xeb\x03>#\xc5\xb20\nd\x14L\xe3\xbd\x19\x98\xa8/h\xd1\xc1\xf9g69\x7f_y\x982<\xac\xe2\xfb>\xae>\xfc\xd2\xf5\xab\xa5\x10WN\xca\x19J\xcdj:r\x92\x9bm\xf6l\xcc\xfd&yk/N\xec\x16\xb1\xd1!\x9c\xd5MS\x0c\xce\xb3\x93\xa5O\xf8\xeb\xc3\xf7W\x95!:xz M\x1f\x92}P\xba[\xea^\x80\xa4\xc39\r\xbaa\x91\'\xf3\x17\xacM\xfe:\xc3\xbd\x92\xdb\xf2\xb9p%\xbeV\x91K\xf3\x87\x98ddH\xd1\xe7\x1f\xa9Sv\x15\x99s\x8f\xa0*\x80\xd3\xe7\x9b\xda\xcb\xb4a\xf1d\xd6\x1c\x04\xab.\xff~e\x9d\xbc\x9e\xd0_`\xbf\xe8e\xf2!VA\x9e\xdeY \xc0\xd8\x8b\xc0\xfb\x1c\x80\x97\x1fo\xea7i\x05\x1c\x8d\x83\x8f\x11\xc7u6\xccEH\x86I_qx\xbd!N\xc0?4\xc8\xc8\xd6\xfa\xcc7^\x0fP\x84\xc7A\x1f\x89\xbd\xcc\xb3\x0b\xf3\xe0\x87\xef\xcb\xe1\x138\xe2\xa7\x1f\xcak\xbd_L\xb1VpZ\x83!X\x15\x1b%\xdc\xb0\xf6\x08\xe8?\xe4U\x90\xa55\xab\xff\x10F]3\xc5{!\x10@v6\xd6\xf6\t\xac\xc3\x9en\x9c\x9c\x8egc\xb37\xa6\xaa\x0e\x1a\xbf\xee`H\xe2\xa5?\x1c\xf9\xf8\xfa\xd6\xc0\xa4\xa0~\xa5J\xc66:~{J\xb9\xd4\t\xcd\xc1\xb5\xd9g\xc0\x8e\xa7\xf7\r*\xa7-\x8b\xae\x10\x9a\x05~\xec\xac%`\xc2\xdc\xa6\x0e\x0f;\xf0\xfc3IP\xb3X\x91\xe1\xfe\xdf\xd3q/\xa4\xc0+\x80\xaa\xcb\x07\xae\x1cw\xcf\xeepS\xa8\x9e\x946\xaeWN\xfd\xc3\xd6K\x84\x8f\x94\xb2\x02\xd2\x95`\xf2G[\x94\x0b\xc9<\xa8\xfc\x1c\xc4\xe4\x8f\x1b\x02\xf0\x1f\x13@IV\x93\xae\x1b\xe4\xa7\x97t7\xee\x9a\x9b\xa1$\x82\x91\x11oD\x19\xf3\xb4\x14\x90\xff\xc4\x95\xbb\x1fW\xa0\xb9\x04\x0b\x8e\xc1\xa3)FE\xf8/T\x83\x1e\xaa\xba\x1fe\x95\xcc[\x87\xb3\x05\x17\x90~\xcf\x12(DJ\xc89\xa8P\xc7\x0f\xfd\x87\xd4\x1e\x86eA}/\x01\xa8\xf1\xc5LB\xf7\x138\x9a\xb3\xa8N0\xf2};At\x10\xa8`\x18\xb6\xe1``\xa7\xd4\xd2\xeaR\xe6\x89\x1a\xe7;\x97\xc0\x90\x9f\x8f\xb8\xb5\x96\x1a{\xe8\x8d\xc3\x84\xa7\x83\xee\x99\x0e\xb1\x90W\x94\x7f@d\x01;\x01\xe2\x91\x04}\xe6\xd0w\x84@cTv\xcb\xfb\xbdQ\xd51\xdd\xa6|\xf5_|\x93\x90\x8dr2\xc8w\xff\x15\xfc\x83\\\xc8\xb1\xa7\xdc\xfe\xb7\xab\x82\xb9\xbe~\xd8\xcd.q\xa5e\xcf@\xbf\xf5+\x9aP\xf2\xab\x19\x88\n\x1b\xde\\u\xc7mv\xadK\xcc1\x86j\x85\x0b\xdb\xb1/\x8cH7\x96\x1c\xca\xee\x0fW\xda2\x1c\xb2\xe20\xd7\xf3\xe2\xbb\x10\\$\xaa\xb5\xdfs\xb0U\x03\x94:\xaa\x99y\xecK0<\x82d\x14\xfc\'\xf3\x1e\xc6\x17j#\xc3\xb0\xd2\x7f \x8c\xc8\x00\x19]R\xe0S\xa5\xa5L\x14\xfdr\xec\xe5\x8e\xbb\xd8]\xbcm?\xe0\xfd\x81]\x83\x18\xf9uG\x00\x10\xc3\xa5&( \xb2\x1b\xfe\xa5\r\xb5\xe4\xd4@um\x0b\x97\x81\xc7Y\x19\xb1^[\xecb\x03\xff\x93\xc1\xdf\x18\x9fE\'\xcd\x18\xf2ba\xd5zg\x81c\x8c\xd5\x875.\x99\xfc\x9d\xc2\xff\xb2\x1bV\xbbm\x0b\xa1g\xc6\xea\xd4A\x88U\x8ac\xc3\xb6\xf1N\xcdT\xbd\xb4\x1d\xed\xf9\xe9\xf4K\xb4@\xd0\xc7\xb13P\xe8\xc8\xd8\xb6\xb4\xcb\xe5j\xf9f\xd4\xc8\xbe\xa4\xb0\x0b\\\x8d\xe2\xf0~\xb3.o>u4X\x19\xc4SB\xc5{_\xe79`\xd4\xc1\x7f\xe7<\xcep\xff\x954n\xd3\x9fZ[\x04\x84\x05\xf4\xea\xc6\xb4\x83c\xea\x13\xbc^\x7f\xaaB\xdd\xab\xf8<\x96\x9e\n\xa90\x8blo\xa3T\x86h\xfd\x8d\x11\x91O\x8e%}o\xa5:\x85;\xf4z\xe6\xd6c\x9f\xa3v\xfe0\x8dd\x98&>\xc02\xbc\x9el%\xdb\xb3v\xc3\xdcT\x80_\xed\x11Q\xcb\\g\xb7\xf4\xe0\xc8\xfb2\xcb?+\x87\x07\xde\xc6@\xec\xe9y\xfa|n/\x05\xd7-\x8bn\xf7\xfc\xef\xfcU\x01\xba\xe5T\xac\x8d<\xab\xe0\xcc\xd5\xb0\x14\x9a~\xd6\x8c/N\xad\xfcL\xbe\x9c1\xbfi\x94\xfe\x97=\x14\x10QrQ\xbe\x87\x90-\x93\x96\xd4<\xca3kY\x14\xff\xf2\xee\xc5\xaf<\'+\xc47`.\x1b\xc3T\xa5\x07\'`\x89\xdd\xb1\xd0\xe6\xc7\xf5\xb89\r \x1f\xc8\xaa\xf6\xf6)\xb6Q\x84\x10\xc3\\\x8b[\xbf?\t\xf4W\xd6x\xcb\x056U\xe7\x1fE\xc3\xbf\xc4E\xc6\xe2\xfa\xcd\xc3\x02\xe6:\xa0(\xe9\x02\xdb(\n\xa8\xf8\xe0)\xa9l\x1fh\x89\xeb\xe1\x90\xea\x8d\xa4\x0b\xc9\tC\xb3V\xa4\xd4\x83\xa2\xea\x9ctw\xdc\x88\x81\xc2\xb8\x8ao(\x95\xc3\x8c5V5\x92\x07\xe2aq\x9a\xb7\xaa\x84\xbf\xc1\xaen1\xceVJ\x98\xf3< \xa4\xf8\x9b\xb95\x81\x88Ru\'\x0b\xbb\x1f\xfc\x1fQ\x14\xad\xd0\xed<\xf3\xe0\xbft\x9e\x11\xee\xf8\xca\xf6\xad\xca\xf5y\xfdIl\xb7\xa1\xde\x0b\n\xd9(@\xf0\x0c\xcc\xcd$\xbd\x18\x1e\xfb\xda\x1cfk\xd4\xff\xec=B\'5\x18AkBD\xcf\xef\xad\x13\xa3\x94\xebJ$x$\xce d\xb5R\xa5y\xf8\xfd\xd2\xa2\xe2\xf5@`g\xbc4C\xdf\x8b\x1d\xc0\xc1\xb9\xf8L\x08\xf7\x9f\x14\x8e\xc7rI~\x85=\x88\x82en\xa2\xc5\x84\xf6\xbfx\xeb\xcc\xb2M\x17?\xca\xd7.\xb6\xd1*bk\x94\xc4R\xc1\xc1\xa2\x05f\xa6\xca\x11\xfb\xa4\x8fi3\x98\xbc\x9b\x90c\x9b!\x93b~\x03\x81tN&7\xa4W\r\xf9\xcc\xe8\xff\x91M:\x85D\x94\xeb\x92o\x9dH\x14\xa3jk\x11\x00\x14\xbdw(\xcc\xdf\xa8\xa1\xe1\x9a$Q$\xf2\xf8TAJ4\r\x17&\x00?\xca\xb6\xf7O\x0b\xaf9e\x0f4\x12yF\x96\x1eK\xaa\xb2v\xc6\xb9\xd3\xd8\xa3\xa8P\xc6\xc7Cw\x9a\xe5(\x95\x9d\x8b[\x04\xb5\xf8x\xda\xc2\xf3\xa4\x8c\xad\xfd\xfdvG\xc4!\xc1\xa7\x02G\x80\x17\xa2\xc1\xa6\xa6}\x7f,\x81\xa0\xee\xf4\x1a\x97\xeat[@\xa0\xb2\xfaa\x98\xa8\x17tR&{b_\xd3\xcc\x8dk\xb2\xb7E\xda\x84n\xc2\xb0\x7fr\xf4>i\x14a\x8f\xd7\x12\xea\xe3\x86\x17\xa0<\xd2\x12\xc3r\xed\xf2\xa872w\xc8::\xaa\tb\xf4u\x17\xf4\xa3\xe7q\xaaLgp\xb3\x14#j\'\xccy\xd2\xe1[\xae74E,S\xdc\xa2L\xd8\xbd\xa8\xf9\x1c>\xd3n\x82\x90/\xb9\xb9x\x1f\x89\x04\xe8D<\x98\xec5\x88\xaf\xad)!\xd8\xf6\x90\x18Q\x03\xf1a\xba\x06\xbf\xab]\xe0\xb9\x97\x96\xb5\x94,\xb6\x92\xd2*d\xf3_\x0e4\x91\x9d\xe4\x1fY+\xb0X\xa1\xd9B\xc9\x82\xd2T o\n\xb6\xe7\xc4\xff\xafQz\xd7\r)\xdd\xb7 \xd4\xe9\xd3\xa5C.\\s\xe6\xaa\xe4\xe7\x99\x95\x0bq\x8d-\x7f\x1e\x95\x15T\xd0\xb91\xec+@]\xeb\x08\xaa\xa0\x1a+\x02\x135\xb7\xa0D\xa2\xcb\xae?\xf8q\xba\xa8\xea\x87MH\xb3\x14\xe3\x17D\rV\xe0\xab*UW\xbd\xf0\xc5\x8b\x12a\x92\xcd\x83\xc9q\x99\x93ha\xb6M%`\xdd\x92\x18=\xaf\xbb\xc2\xaa\xd9\xf8\x88pM9V\xfawU\x9e\xb9\xb5\xbeM\xfe`x\xfe\xfdf\xd6\xefS\x16\xc6R\xe3\xa6\x83\xd9;_\xdf\xd5\xdf+\x11\xd3T\xe0\xca\rw\xf1\xe20\xebh\xe5\xf4\xb2|\xd2\x91\xd9\x9a\xaaz\x109I\xcc(\x93\x8b\xe3Q\x8f\xa7Y\xdc\r\x91+\xf0l\xd6a\x9d\xbce\xd9\x0cDZ\xd1\x14.\xdf\x13\xa5\xcc\xa0z\x13\x9c8\x10\xe0L\xec];\x9eKvd}C\x8f1\xe9t\xd8\xb8\xd1\xb6\x10"\xbd~Iy\xd4\xf4)|\xef\x00\xd7\xa3\x05L\x96\xc5\x8c\xd9\x8a\xa4G+\xde<\xa5\x96\x13m\xa5+\xf5\x11\x17x,\xc6\x1e\xeb<\x8a;\xc2\xbb-\xc8\xa6\x02\x8cU\x033g\xcf\xcdL\x10\xfc\x0c\xdfNM\x1e\x9ao\xef)\xc4\xd0\xa9L\xc7\xa7\xd6\xb8\xfc\x95\xda\x1eX\xd1\xd3\xe6\xd17\xf6\n\x99*p\xb1\xce\xd7\x90\xf5y\x12\x02\x0b6\xf4w9\x85\x82\xa1\xc9\x8fwF\x03)\xfd\xa8%\x8b\xceF\x91\xadM\xceD\x15V\xe9\xe2\xa6\xb0\xb4\xbb\x13D\xbb\x11\xe8\x19\x1d\x1co\xa3jt\x91\x95\xac\xd0R:\xe4]\xde\xa4\xb4%\xcf\xb7\xca\xf3`.\x7f`\x1b\xb8?\x9e?aU\xd7\xca\x9f\x81C\x96]t\x04\x16E\xe80l\x8a\x93\xa4KK=\x00\xa5\xc0}\x03}\xc0\xfa\xd8\xcd\xb3\xa2\xc9X\xc2PB\xdfMa\xd6\x8d4\x00\xf7\xe4W\xe1\xfa\xcd*\x064\xe2[+\x9d\x85\xc2\xed\xe4\x07\x9d\\\xe0Ze\xdbQ\x919(\x88\xcd\xc2B>\x03\x86h\xf3a\t7\xe2\x90\xca\xe9\xca\xb6_\x7f\xf8\x0ep~\xaa\xfe\x83R\x14\x96\xa1`ed\x8b\xa4z\xfc!s\xaa\xc5k\xa9\x86\xba?\xf1\xa3\xc1ua?\xca\xcd\x15\xf4_\x14\xdd\x98\xb2Q\x9a\rJ\xa1\xdcy\x7fY\xb4\xd46\xf0#\xe8^{\xba\x8c\x88\xfc\x90\xea [\x1c\x97\x06\xbe\xf0\x88\x1ec\xc4\xd9V\x03\xbf\x9a!&\xd1IK\xddd\x17\x1c\xae^\xbd14=\xe1\ty\x17\x93\xde,w\xd9f\xc5a\xff\xaad\x86\xf8\xed%P\xaf\t\x03\xefbL\x87\xee\xbf\xed\x88\xb2ku\xa6?,\x06\x06\xc0\x11\xed\xcf\x94\xa4\xaa\xc4}\xaaf\x81\x17P\x9c\x93_v\xdb\xdb\xf8\x16\xbf\xcf\x84\xc8\x1f\x8e\xbeq\xcb[\x12y\xe4 \x95\x95R\xe2)\xea\\5\xe8\x88\x01\xc0I-\xdf\xab \x02O\x8d\xf6\x95\xa6\xaeF@\xfb\xca}\xf5#!8\xbd\x1dP\xf6\xe5\xb57L\xb7\xf4\x9dS\xb5\xe1\xb7\rm\xb3G\x06q\xb9s\x96\xf8\x96\xc1\xc1;\xad\xa0xZg\x8b_\xba\x0e\x81g\x11\xf5\xbaD*\xd5z\x18\xf4\xcaMX2\x922\xb7\xc8\x0f\xaaD(]7$v\x9d\x18?\xa9%\x98|z\x07Q\xe2b\x04?\x0c4\xd4\xabF\xc7\t\x1f\xd0\xbdZ\x90\x15\x9e=]\xa1\xe5\xaa\xb0\x98x\xf9?\xd2\xab\xd0\xbe\tz\xfa\xb4\t\x10\xdeX\x15\x92\xc8g\xd4\xe7l\x10\xeb^<\xa1\tjCW\xb8\xa9xq\x9f\n>\xb2\xde\x1d\x98\x8c:Mc\xff,\x9d\xfb^\x80M\x14Q\x1e{8g\x7f\xac\x91g\x1f\xa8@\x0e\xaea\x95\x05\x1a\x8cB\x07\xbf\xc8(\xf2\x9e;\x13B\x95\xd6yN\x94t\x9e\x82\xc3\xfa/\xdf\xd7_\xf6\xf5a\x17"\x10\x7fV_(I\x16\r\xb2\xe3\xd1\x7f\xfa\xe7/\xb6\xf9\r\x05(\xc2\xd9@\xd8\xd7\x8a\x94`If\x9fo\x84\xe3\xcb\xc1\xbbS%O\xe4\x96\xe0\xb3\x1e\xac\'\x8e\xf7\x0f\xf9\'\xd9\x14\xaawx\x12\x81\xdf$\x94\'~\xb3\xe9J\x19\x01\xae\xd8\x16E\xce\xe1\xceE&n\x05\x1b\xc6\n\xef\xc1\xe1\xb4`\x0f_A\x1a\xec\x19\xc7\x8e\xe8M\xa2\x1a\xa2\'\xeb\xff`\x14\x8d\xda\xd7-n\x90`/\xd2\x10\xfe\xce\x0fU"\xd5*m\x19\xa2\x1f\x87\xfe9?<\x0c\xcc\xb8\xccf{},\x80Zl\x9f\x106\x90\xb0\xf3{\x19\x05\xa5\xcd1\xceQ1\xc2S\xfe\xc9k\x9b2}s\xa4u\x9d\xc7\x9ceR\xa0\x1c\xa1\x0b\x84e,4W\xb7\xb2C\x129_e(\xcfg\xf7n\x93\xea8e\xfe\x9d\x0c\x99\xa4\xd3>k\x8e\xcfx2T\xee\xc1\xa7C\xa2\x85\xbcT\xaar\x14(\x9b\xc7\x9b|>\xea\x84\xd3 \xe1;\x1fl\xaa|\x1c\xa1Z\xc4_\x8a\xa9:\xdd\xc1\xba\xc2\xa0\xd7\x11\xdd\xc1\xd8\xfa\xdc%\xf76\xb5\x8bw7\x13\xcf1\xa4"+U\xc7\xc9M0\x1d\xfe\x9e\xca\x8a\xc16\x14e\x80a\\\xf6\xd7o\x9d\xcc\xef\xa6\x1f\xee"!\x1c\x80\x17\xfb\xb0\x8f\xe2\xcf\x87}\xab[uQ?\xeenW#G#w"q\xec\x00\xd0\x9a\xa2bR\xde\xacV\x9d\xd7?\x95K\xc8\xd8\xcf\xdc\x16hFE\x01\xd3\xad\xfa\x0b\x92\xdd\xc1\x19\xf2\xc2u\xeab\xff]\xc6\xac\xf63\x8b\xb5\xafv\x0e\xbd\xb4L\x9bxr7\xc3\x99m\xecl\x02Q\'\x061\xda\x8b\x9d\x07\xc1;\xbe\xce\xabzM\\\xbf\xf80\xfc\xff\xfb\xee\x1d*\xfe\xba"\x13r\x04\xbe3\x95x\xd3\x8c\xc5]\xf6N\x8f\x0b\xed\xeb\xf2\xect\xd2\xc9E#f\x13\xb6`\x87\x8d\x08\xf2/\xa3V\x89",\xc8\\mX\xdc\xb98\xff1i;h?)\xa2\xd7\x8f\xd9\x0eR}\xd5\x03Y\x91\x13L\xcc=\xf7Hd\xd4\xf3\xbb\xfc\xaf1\xc4\xc1\xb7\x14\xa2\x9f\x951p\x0e,\xc3\xf4bU\xc2\x04?)\xde\xda\x16p\x83q\x9a\xa0\x1c\xde\xf8f\xae%\xde\xb5|L\xed\xe0z%pD\xc4\xd4\x96A\x83\xab\xd9\x9d\x1c\x01\xfb\x1d\x9bB\xcb\xe6\xf9+\x95\xf4\x8b~\r\xdbZ\xff3\x95X\xcdL\x80\x96\'~\xb2\xc0\xc7\xf4\xd0\\)\xb7\xf9\x08,|\x9du\xa1\xaa\xaf*-Y\xef\xda\xf0\xea#\xb5\xfa9}\x0b\x1dCn\xbeMq\xc1\xd1\xe2$v\x10\xbfRw\xad\xbfn\x1f\x80\x91\xe9\xdaK&e\xbc\xe6cb\xf0V\xbf\xf7V\xc8(\xd7\xe65\x7f\xaa\x9bU\x1d\xdamCTxT\xc1?8rX\xec\x8e\x0eC\x17j\xd1o\xa1\x04%\xacw\x81\x9fU\x8c>\x86\xe3q\xa2;\xa4[\xe3m\xd4\xf4\x92-\xd6+\x17\x1f-\xc9\x86/\xb9<4\xd7\xd5\x9d\x8bs\xe4g\xbd]\xb1\xc7\xef\xb0\xdb\x9c\x9d\xa7\x02\x03}t\xf5\x95\xc3\xd3\x03\x86\xf77\x91\xe0\xd4\x15-t\x9a)\\Y\t/\xb7\x90\xd8!-\xbc\xe9\xa5\xe6\xb5\xb9\xb1h\xc3\xe2\xbc\x94B\x88\x1c\xae\xa0\xecL\x84\xe6\xc4\xb59E\x92"\xccs\x18C\xc0\xe4\x00\xb5A\x9b\x1ey \x88\x7f\xbd\xf1\x03i\xff\xcfu$vq\xb7m\xf6\xf3\xf4\xa1\x04\xb6\x11\x89\xeb\xba\x9fd\xff\xa52\x1f\x10"\xf8k7c\x92\xceJ\x0f\x894;\xfdo\x07\x08\xba\xa3\xd2\xf6yK\xf4!\xcb^\x90\x11\x95\xe6\xd1`\xbcOx\r\xcadT#\xf2tS\x81Q\xb8\xb1Hd\xe9\xad\x01\xc45\xdeUC\xef\x18\x14[\xf43\x91\xe6\x81n\xfa\x88\xa8\xe0?\x12\xe3\x1f\x1a\xcc\xa7\x0e\xaa\x80\xa4\x13\xd2m\x90\xb1\xad@\xc7=EBZ\xc7u\xaa\xbb\x01\xf4\xc8\xb5\x05W\xf7v\xd5\x1f/\xfb\x94\x9b\rx!\xa4y\x17Y\xab\xb3M\xa3F\xcb\x0faO_\xb7\r\x97\x85\xbb\xfe.\xed\xd4\n\xa951\r\xfc\x12\x11\xb2\x9c(Q\x17s\xda\x18\xcd\xb1X\xfc g\xbd\xc6C\xbbh\'\xc5"\xdaB\xa6\xaf\xfa\x83,\xc44\x96VzU\x14$$\xa0\x1d\xa8\xcfp\xffO,\xe7\xc9\xa6\xe8\xd0\x84{\x85\xaa\xcc1\x80\xaa\xef\xc2\x11\xd9\xd4\xbd\xbd\xb2\x16\xfct\xcf\xdeu\xf6\x8a-\x03\xab\xa2w\x86!NC\xa7\x0f\xe0\x0b\xcc\xb2\x85M\xd0\xcd\x94~\x00\x98\x89r\x85\x94lFw\xca.\x00M.\x90c\xabx\xe6h_\xb2\x8f9\x08\xe1\xd0Ps\xf8\xae\x8aG\xa5#\x12\xebR\nQ\n_\xfd\xfe|\xff\xec\x07\xca6db\x8a\xc3\\\x84,\xe9L\xc3\x1d#\xfaI\xca\xb7\xf3\x18cp\xee\x9dn,\x8an4xv\xbf\xaf\x19)\x9a\xb8\x9c\xd2OXo{\x16\xaeQ\xa9+\t\xcbh\xf1\x8e\xf9A\xe3`K\xc3\xc1\xaf\x97N(\x83\xad\xd4\x01\xf0*w\xd7\x82S\x8e\xf6w\x81d\xaa\x97\xfc\xb59]\x08=\x8d\x0cd\x19\xd2\xffW\xdd\xb3\xa7\xbe\x96\xe8\x14\xf4":G\xca\xef\xb9\x90\xbcT~\xa5\x9c\xea\xbaG@\x8a\x14\x0bH\xa0\xe8\x03\xfd\xa5\x88\x16@~Q\xba\x06sD~\xb4\x02\x06N\xb1\x06\x0fD\xad\xe6F\x94P&\xd1\xf6dh]M\xc0\xeed\x10\xd4A\x14\x83\xd4<\xc2\xfbg\x1d-B\xe4\x1c\x86E\xe2G(\xd3,5Q\xb8eP&(\xdb\x99\xa2\x86\xcc5\xac\xdb\xc8N\x1d\xc3`_\x0e@\x89\xfe\xd6]\xc5/\x81\xa4\xa0\x81\xdf\x13c\x9f\xd7\x9a$\xbc\xa2\x7f\x19\xa5\x17\x89\x0b\xf5P=\xe2I\x8eL\xdc)\x86#\xd0\xcb\x02*\xe9\xca\x0cbKIK\x823\xd7,M\x07\xad\x8e\x90\x12\x9e\x9c \x95NhC\x86G\xf7`\xa7\xe5l\xc4M\xe2{\x87\x9b\xbc\xf0\xbe\'\xbes*\xa7y\x18V\xbd1\xff\xf72(\x1ek\xeb\x91\x1d)\x1c\xb2\xd4\x07\xdfR\x81\xf3\xff\x93\x9c\x8b\x00w$]\x0b\xb6e4\xc0\x1d\x13\x02\xd9\xfe\xa3~\xd3\xd2\x04\xab\x1e\xcaW\x142\xd3+\xed\x18\x83AYz\xe6\xca\xaea|\xf9\xe9\x90^z\xbcE\x9c_\xc3>\xff\xe9l.\x87l/<\xe6\xcb\x1d~\x05\x18\xc0?\x8e\xbf\x19=HhxH\x977\xd4\x8c\x96\xc7\x9bU\xebG\xb7\xad\xc7\xbc\xd5\xe6^&\xc0\n\xfec\xdb8\xebg\x08~\xc8\x7f\xdf\xf8s\'\x84\x02\xb2N\xa9}-\x94K6\x8b\x8c!\xce\x8f\x08\xe3\x891\x84\x92`\x95\xda\xa2W \x1f\x14\xfd\xba\xed8r\nb\x16\xdf\x8a\xda0\x0e\xdbI\x05\x1a4\xc8\xbf\x9a$\xdf \xfc\xa7\xf9bha\xed`\x8e&\xf9\xc1$\x8e\xed\xb8\xa9u\x00]\xb0\x04\xb1\r`\xe5T\x12\xb2\xc8mU\xd5\xdc:\xf0\x91\x9b>\x00\xf6\x908\xdf\xdc!e;\x88\ra&0C\xc8\xb0K\x03\xe2\x15\x9f|\xdfg\x13?\x87\xfc\xb6\xb8\'\xeeUn<\xbe\xd2\xe1\x06s\x01\x967\xabH\x16\xcb\x82:\xa3\x87T\x05\xcc\xae\xf5\xc4/\x07~0q\x11O\xb8\x10\xe2E\x12\xbe\xac\x11hL\xd9N\xf7\\\xbc\xb5\xdf\x15\x8c\x86\xde\x0c=\xd7\xbe~\x8e\xc44\xeb!`\xe6,\xb3n\xd9\x00\x81\x83Kb\xdaO6|\xf1F\x16H\xf9\x85\xc8\x17%q\xa4\xef\xc5j\xaf\xcb\x12\xec\'\x95f\x0f\x86*\xe5\xf6;\x9e\xb0.\xb3\xd0\x92+\x16F\xbd,zXVS\x0f&\x81\xa61\x0b\xb3/iEG\x17^\x98y/q\xb1\x81\xd2\xcd\xca\x10\xa1\xe9\x82\xe7\xd2\xa9\xa7T\xcd\xc2c\xcf=\x91Q6\x88T\xfb\x95\x85g\xa0\x99:Y\x98E\xd5\xb7\x07\xba\nX\x99\xc2\x7f\x16\xecf\x08\xe5\x98\xa5\x80\x07\x84l>\xe3Gh\x958\x1e5\xebhma\xdb\xa2\x1c\xed\xa2\x13\xa2C\xf6]\x04LR\x9e\xc1\xd6\x172~\x8d\xbb\x06_\x88\xdb\xdb\xa8\xc0\x87d\x0e\xa6\xfc\x9e\xda~d\xdfn\xd3\xc4\x1cV\xed\x03\xe9\xf3\x0f\x19E\x84#I\x1cLz\x8e\x8d\x1d1W\x8a\xc20\xd5\xee!\xf2\xdb\x1e\x88\xd7E\x97\x04fV\xeem\xbc\xf2\xe4\xef\xbdR\xfe\x1a\x9b\x0f\xad\xf4\xe6\x96_\xf6\x10/\xe5a\x1c\x9e\xda\xd3\xf3\xb3@\xc1W\x0e\xca\x9b\x95\xf3\xde\xa6\xc4\x12\x88\x1b4uTk~\x91\x89f\xbf\xd1\x86\xd9\x95\xb6d\xa8PO\x01\xa3\xe9z\xb6@\xfca$\xbe\xd8\x7f\xb9\xf3\xd5\x99\xf7\rE\xdd\xff@IG`u\xd3\xe5\xbaY\xe1-\xe8L\xd4\xf5*\x8bj\x81\r\x12\xe9\xbf\xf4\xccH(\xc4o\xd9\xb6\'l\xb5\xa4\xea\xdd\xce:\x96^Y/\'\xf4\xadSx0m\x8d{\xac#A\x9a\xfc\x91x\x94\xbf\xa9\x0f\x17\xf3y\xec\xf6\xa6{c{\xee\xc2\x06\xa0\x05\x05\x1e|%\xc1\\aE!n\xf2^\raM\xa5\xf0p\x9c)\x99\xfa\xe2\x19M\xbd\xddJ\x8a)\xb75\xf5C\xfa\xa63\x18 \xba\xcc\x8c\r>l\x84_\x9cE\xf8:z\xbcD\xa8>FW\xb1\x9b\x9b?erv\xc7\x04\x05\xc9J\xe6\x1a*\x9c\xf6;\xd2\xb5\xae\xa4\xbe\x89l;-\x18\x18\x929\xb6:sQ\r\xb0}\xccc\xc1\xc2~\x90H\xc7Z\xaf\xf2O\xe6\xdeLez\xc8\xab\x83\x05-\xff\xc6\x85`\x9e2m\'\xb2@\x82\xea\xb4v&;o\x8e\xd3.\x91\xces{v\xb3h\x12\n\x82\x16k\x86\xbf^\xafj\xdan\xf5m,\xf8\xef\xaf#\x84\x8d\x91W\xab\xe4\x1b>\xb1\xfc(O\xc7\xdac\x98t\x15\xe3\xc6\xa7G\xf5g\x9e\x082\xa4\x1e\xdc`\xc9\xcd\x9c\xc3FXj\xd4\x066\x0c\x93\xc1\xe8\xb1_~\x8c#a\x9aJ\x93T\x19\xd0a\xa1\xb0\x94\xdb\x9d\xd2\xc2\xcc\xbb8\xc4\xffb4\x8bT;|\xa5&\x94nL\x92\xa3\t\xa7B\x1f-\x8f\xe7\xc4\xbd\xb7B\xde\x97\x8c\xbc\x8f\xfd\\\xf7f\xff7T\xfd;\xaf\x8e=\xf4\xd6)\x8c\x7f\x80\x01\x8bC\xb9[u\xe3\x9f\x0bo|\n(\xa9?\xe37\xeb\x87j\x04n\x0eJ\xefRDe\xdbi;W^AF\xaf\x01\x8b\x1a\t\x83i\xc1g\x90:>\x1d\x18\xce4\x14\xe2)@\xe2\xf1P\x1c\x1dS\xcd\x90\xcb\xb2D\xe9\xcf\x0e\xb8\xe2<0\xc5\x86\x8b \xeb=I\x83\xd1\xeb\x9a\xb4\xc7 \x06KR\xe6\x1d.\xbb4E\x83\xec\ni\x17\x1f\xd2*m\xb6\xf7GX\xc5\xc3J\xf0\x91\x1e\x8c\xa2u\xc8\xaa\xa9Cz\xff\xf5&\xd1\xd3\xba\xe7\xd4=\xf9\x88\xf6=\x9c\x8b]3\xac\xdc2\xa1\xf6\n08\xecA\x84\xead\x8c\x0b\x06\xc2\xf7zV\x16!\xbd\x1e\xd0\xd2S+>\xffA\x81\xc5\xf7\xee\x11g\x99@Yr;\x1a\xd1\xacM\xd0S\xb4,\x9fi\x04]\xee#\xfd*\x00]\x14\xfb`\xb5\xddO\xc1{\x02"\x936\xef\xd4\xf1e\x95\xc6\xe6:\xd5\xe1z\xc5\xb6\x16\x83\xd4\x81U\xa0\xfc\xa2\xef\xc93\x01\x0c<\xfd\xef\xce\xd2\xac\\\x1c\xff\x00\xa3g\xf9ti:\xc5_\xc8\x8b#58\xb0@V\x83\xe5\xfbb\xa0\xbb\x88\xb5\xfe\xab\xb5\x15\x12\x02\x9ft\xc2\xe4\xef\xcfs\x99\xd8\xe1\x1a\xaa\xa3\xd2I\x99`bK\x8b}i\xaf\x07\x85\xfd\x88\xf2d(\x95\xbf\\D\x11z\x8a`r\x92\xc7\x81\x82bn\xde\xf0\x1b\x84\x7f\xe2\xde\xb9\x00\xa1c\xc1\x94j\x1b?\xafZ\xbf\xff\xc4\xadW\xe3\x7f\x10O\x91q\xd0\xa3.3u\xe9\xa6\xee\x91\xef\xb6FS=\xb6hRK\x0e\x0e\x9c\x88O\xb5Q\x94\xaf0\xea\xe9\x7f\xca\r\x15\xf5\xe9\x82[L\x08;#\xe9\x86V\xfd\xb2\xc5\r\r\x90Rn\\\x1a~\xbc\xcaU\x912\x12f\xac2Q4\xa4\xca\xe1\x81\x9f\x9b\xc1\x9d\x9f\x00s|L\x15\xf4\x9d\x07}\x91\xb2\x9c\xe6_\xac\x02\x16\xa6\xfcvQ\x82Zb\xa9b\r\xc5r\xf4A\x13\\m\x852<\x9b\xfb\xb9\xc5\xe5ZX%6E\xd80"nh\xde\xc7\xc3S\x8e\xeb\xa88\x9e\xf8\x89\xd8\xb7FL&\x9a\xefV\xf7\x88\x88W\xca\xba\x0cg\xf7g\xa0\x8b\xc1\xbd\xed\xb0\xde\xc8\x88\xf0*\xca\xfd\xdatF\x83a&Mo_\x10\xdd\xf6\xb9\xbe\xef\x0f\xccG]\x87G,\x9b\xad\x834\x03 t;\xd4\x14y\xb6MK?\x14\xc1Q\xbc\x0b5\xfe\xad\xb8|\xeeB\x93\r+\x9b=H\x91F\x18\xd2\x03\xe3\xa3\x0b^\t\x15FjR\xa5\x9f\x8eq\xc8\x08g\xe4q\xde\xfa\xe2(y\xf3\xacJ\xa7\xcc\xe2\xdd\x0b\xb42p\xb3_\xd9\xbe\xd9\rGGfU\xbd6\xabS\x83)A0y\x10u\xfc\xa9\xde\x11\xe1\xe6\xc0\x898e;F\xc0g\x14dg\x04\x95\x1c\x88[*R\xbdn\xda\xeb\x90\x13\xb6\xc6\xb2\xb0\x07i\xf5?Pl)\x0f#Pdn\xcb\xcc\xf3)\xff\x91c\x05C\xa8\x14V\xac_[\xb1\xe7\xea\x18\x8a\xa7\\\xfc\x1a\x94\x83\x03S\x97\xa5\xb2\x80\xee\x8f\x19h\xc87\x9f\xb1"hj\x8b\xb6\x8c\xf4\xb1\xa5/\xb1\xca&\xd0Y>\xaa\xba?(\x7f\'\xce\xb9\xf7,\xd0\xd0&e\x14\xb1\x8d\xf9\xce\x1dz@\xbf-@-\xfb[%\x0f\x9e\xefg\xda\xb5O\xf7\xf7\x8a\xec\x9er\xe6gX\xb2\x91 \xb6\x86\xef\x8c\xf5C\x1f\x1f\xc7\x94S\xd8#\xe8\x0c\xb4\xb9\x83\xc7F\xfe0\x9c*x\xb6\xcfQ\xe9\x82\xb8\xf5R\x02\xfc\xd8#\x85\x9e\x16?.\x94\x03\x85\x06\xe18\xf2\xd8\x83\xe7\xb8gQ\xe5?[\xff\x87\xb6\xe4\xd8t\x06t\xd41\x92s\x84jo=\xeaiA\x8b\x99\xe1\xed\x87\x8a_C\xfc\xcb\xe1\x10\xf3\xeb\x1a\xa9\xd5\xe1\x04\xdcn\xe7\xbe\xa8\x16}\\n\xda\x0c\xaa\x8d\x15.GtW\xfb\xa1\x1dv\xdd\x81}\xec\xc5\x19\x8d\xf5\xf8\xf3\xaa/\x17\xa9\x91\xb0z\x00\xfc\x86\xd3\xd8D4=\x1a\xc8\x91\xd9\x81{\xf8\x1e\xcf?\xb1\x11\xeb\xb5\xa4\xa2\xd5\xe9\xba\xed\xf7@\xb3\xde\xaf\xe4\xc4\x87\nPn-\xe5LV\xa8b\xf0\xd9\x0b\xaf\x15\x1a0\xa7\xdc#:\xb9e\x8d\xa4k4\x14C,\x94\xe6!\t\xa9s\xbcr\n\x89\x88\xdf/>\x06\xf89\xd5\x7f\xd1\xa3\x05\x19$\x8e\xc5j\x13\x89\x1f\xd8\n\xb9\x15=\xc2\x18\xd2\x9e\xa4\xec\xb4Q\x1d\xe9q\xb8\xc0q\x97u\xb5\x06@\x0b\xf3\r\x88]\xd6\xee\xaa\xf9\xebj\x1c\x9f\x1b\xe3\x14\xa5\xc3,p4+x\xe1\'\xb6C\x9a!R6\xe9\x96\xf6K\xa8\xf3%!\x90\x17k\x96C\xe4S~6i(v.?\xa3\xa8y\xa2O\xd3WNi\xff\x90\x1bNd\xd0\x00\xa1\xb1\xd1\xbf1IyVj\xde\xac1\xc88@\x92\x81\xe6{\x14|\xe8\x17}Z\xb0\r\x1f\xbb{\t\xb75y\x14\xe2\x04@y`\xe3\xc2\x7f\xa5\xba\xc3\xbe\xa4\x97\x87\xa5Sv\xb0\xc6j\xd0\xc9%\xa9\xc9y\xe7{Q\xac\xf2\x89\xd2v\xb6\xe5T^\xb8\xd7mE\x1boq\xf0s\xd5@\x8b\x10\xac\x92\x97\xe1H\xaa\xebE\xe0\xb5fC\xd4\x82!\xbf/\xf7\xd2/\x11\xd6/\x02\x9d~\xa5%\xb5\xfd\x9eG\xc0X\t\xde\xee\xf9\x0bhd\x0f\xf5\x86\xa7\x8a\x8cbC\xb1!7\xfd\\\x82Ll\x9f\x93Yj\x12\xb5\xb9\x81:}P\xd2\xa9@\x94\xf0u\xb5\xc2\xb5A\x05\xden%2)\xab\xe7\x18uh\r\x19\x04\xfb\xb1\x02\x86N_\xf4\x84\xd8\xd7\xbd\x88\xe8\xe9\x9c@K\x15\xce\xd8\xd2\x00\xf4\xf5c\t\xb7D7\xfa\xa1#\x89\xb7\xef\xa0uD\x16<\xb6N\xc6y\x1c\x9c,=\xd5\xc7\x1a\xf7\xac\xcb\x1f\xc1\xd2S\xe2!={\x8a\xe1\xd2\x1c\xacig\x19\xf2\xfe\x84\xdb"\xf1\x89\x079\xca \x0f\xce\x801t\xc0\x15\x11+\xc6\xa9_\xd3g/2s\x80\xa3\xc4>@\xb5\xac\xf7\xd4\x0b\xc4\x8cZt\x85\xff\x0f\xe4\xcc\xaa\xcb\xcf|\x84\x9d\xe4\xda\xbc\xaa\xde\x13\xee\x7f\xac\xf1k\xcf\xa7\x92mv\xc2\xe0\xb7D\xcd\xea\xf0\x13\x0c\xb8\x19\xca\x11"\xaa{\x8a\xa1\xa4/!\xcc\xa1\xef\x96`\xfe\xffM\xb1\x99\xcb\xd1\xca\x18\xf5\x97\xb7\x1d\xfcq\xb0J}<\x02"\x7fBM\x1d\xa4\xce\xf1\xa1=\xbb\xae\x1a\xc3\xf4\xc3j\x13\x10\x88\x07h\xec\xac\x17Dk\t\x9a);0\x0e\xf5\xc1B\x08\x00\xff\xe4\xd7\xcf}\xddp\x17\x85\x03l\xea2\x89M;\xcc\xd0\xfbn\x1f^\xbc\x89\x0ea\n8\x83\xee\xe0aA\xf9E\xd1L\xe0\xb7\xdc3@xZ\xe9\xb2\xad\x01\xc1\xdak\xdd\x88\xd1\xdd\x8e\xad\xa2\x85\xfe\xc7\x9dk\xf5\xfd\xd1\xde\x90\xc5[\xc7\xe1\x86}]\xd1\xe9\tVY\x94\xda\x07\x07l\x19_\xc2\xdeP\']\xfa\x91f\xadN`\x8e:\x11\x88\x11`\xd0\x1c\x95\x0e1\xe5ehQ\xdd\x14\xb9x\xfd\xc9\x1d=2E\xdb\x077\xda\xe1XH~ZTS\x9e\x86\x94\x82%\xc8\xa4\x92\x16\xfd\xe4\xd3V]v\xdc\x85\x1c~\xe9\x9b\xc9\x91\x18L\xbc\xdd\x9dX\x1d\x8e\x98D\xb5\xc6Qy\x12V3\xdae-\xafv\xb1\x1b\xc69\xec\x1b>\xe0\x19vn\xcbD\x8b\xc6 w\x1e\x19O;f@\xf6\xfe=\x97\xacD\xff/\xf1\x9c\xb80\x89\x80~N6\xf6g\xd2\x038\xb6\xa4\xa9\xf1\x7f\xbe\'\x98\x04/\x11\x92\xf0`\xde\xf6\xfaE\xe3\x03\xe8\xfd\xac\xc3\xea?\xbc\xfe\x9f5\xfeS\x1a2\xe0\x15\xce\xa5\xf3!J1T\xdf\xac\\\xc6\x9e\xac\xbf,\xead\xea\xef\xd4\x93\x87\xc7f\x07\xdf,J\xaeF\x0f\xd82\xfc\x82\xa6\x16\'T{\x89\xa7t#tD\x14\xc1\x12\xf7\n\x9c\x88\xd0\xac\x0b\x17\x1a\xca\x0b\xae\x0f}\x15jX\x80\xeb"\xe1\x13c~\x8c\xc9e\xb6\xb16n\xd0=L\xf5\xdbZ\xcd\xb6\x06Mm\nN\xf0\xc7\xbc\xfc6\x9d\x15\xc66\x12\xc6\xd2uxx/\x92\x8e\x1d\x9e\x1c\x1e\xda\xe7\xd1\xa4\x00w\xc2\xc7\x1d\xc9\xa0\xc8Hwh\xafL\xe5\x0c\x98\xaa\x83/\xf8\xbb\xf0\xc7\x99\xe5U\x88f\xeeb\xf7\xdf\x06\x016\xf0\x90\x8c\x8f_\x97\x06#Fb\x1fb\x19\x8e\x08|\xa2\x8f8\xc2\x9b\xdd\x94\x9bH\xe7\x9b\x83\xf2\xdf\xae\x96\\\x1f\xdb@\xfa\xfb}\x0f\xae\xb1y~\xb1(\x18\x15\xbf\xa4\xdb\xc5\x13_\xb3\xfe\xe9\xc2\xe3\xc83\xaa\xb3m\x8bP1Y$\xbe\xf3c\x9e\xd5g?\x81\x14\xbf\xab\xa3\xad_\xe6{\xebO\xce\xd3\xd7\x87\x16`"AZ\xdf\x8f\xfdF\xb8\xd1\x0c\xfa)\xfe\x11L@\xc7\xcf~\x8a\xc1{y\x8eK\xd8\x86\x89\x94c\xca\x92t\x86\xb3B\xb6\xa9\xbcP\xcb\x9b=\xcf\xac\x98\xc9^?{%\xc1J\x7f\xacfSh\x9e9)=\x84\xb4Cf\x11.r\xc8\xe0x\xc65\xbd\xef\xda\x93{K\xfd\xa57`\xf0\x12\xcen?\xc0\xc3!\\C\x03\xbb\xe4\xcf\xef@I0\x06b\x9az\xbf\x17e\xb8\xb5/\x10\xcb\xaa\xf0\xec]EA\xd2\xf9|\x19z\xb2\x02\x03\xed\xb6d\xc1\xad\x9f\x8e\x9b%\x8e\x11u\x99\xc7U\xce\x97\xed4\x19\x08E\x1f\x87\xa6\xbd\x08\\r\x05\x11\xc2*pJ[\xee\xa3)\xb2;\xe0\xe48\xe2\xfb\x07\x9c\x17\xb1:\xca\xee\x0f\xfc\x01s\x86I\x14\xf4\x88\xfb:sf\x9e%\xcc\xbe\x96Ir>\x05\xe0\xf1V\')\xd7\x18\x95\xa1:\x13\x91B\xbd\x1b.\xe1Lb\xd2\xc1\xb8`\x9c=U\x15t\x15qH\x8b"7\xd6-iI\xa2\xf5\x9c\x08=\xb5y\x85\xcb*\x15h\xc5g+\xc9X#9\xd13\xae8\xa3h\x03\xdf\x0f\xb7O\xf8\x07\xfaEs\x90|i\x17\xec"\x94\x96\x8a\x0c\x93#v\n\rI\xd5\xc3\xaa]i:\xc8K@\x01\x97l}\xb5\xb3[\x91\x81\x9b\xfb\x8d\xd4|_\xfc5=\x06\x04\x1b\n\xea\xd6\x18\xbbe\xb6\xda\xa7l\xdcp\x81\xd2\xae\x8b\xdf\x94\x0b\xda\xe5\xd0\xbc\x16\xa3\xfd-=\r\x98\x82\xa1\xe6\x18\xe6\xab\xc3#\xeb}xc.V\x9c\xaby\xb3\x04BN.fo\xb8\xc5\xbb\xe6\x14\x00\xd1D+\xc7\x87\xfc\xce\x00\x88\xb5q\xc1`2_\x9a\xa5y\x89u\xb2\xd0\xbe\xa6\x89Jp\x03\xf6\x95q\x1d5)\xb2\xc1W(\xd8:\xf6\x00\xc8}\x92\x1aSmv\x9f\xd31;T\x1aYn\x87\xfb\x87\xd3\xf3\xa8\xa0@q\xfc\x87\xcc\xb3\xb9\xec\xb7\x0c\xb5\xc4\xb7\xed\xde\xb3\x0c-\xbeY\x0c\xa6\xb0Q\x05\xfe\x06\x16\x91\xc9I6/\xdb\xe5\x11\xacoD\x9f\t\xe7\xd7\x1c\xdf\xb7mPQjnfG\xff\x95\xce\xb7\x1b?AVP)[\n\t\xc3\xe3\xdbD\xf3\x02I\xb7R\x1b\x1c\xa0/\x04\x91>\x04\xb3Plj\xd6n\xc7\xc4\x87 S\xb4(\xf9a\x9b\xf9FX+\x11\xe9\x92\xdfx\xcb[u\x14_\xf2;\xe2)\xa1c#\x7f\x9b]\x808_\x02\x1c\xa42}$.\xd1\xc1N\x10\xcdw;!w\xee\x07\x08E\x8e\xe1~0\x81\xb3\xa8(\x10lp\xf35N\xcbN\x9c\xe8\xcd\x99\xbd\x9f\xa8\xa5\x12\xdc\x1bow/\xae\x04\x97,\x1c\x91$\xd9\x9e\x91\xc0\xd22&k\xed\x96\xf0\xf0OS\xc7\xc4\xbe\x848\xbac\xa16\xbf0\x98\xcf\x95K\x14k\x9ds\x19\xeb\xcc.\xfa\x94\xc5\x8ah\x14\xbc\'\xbf\x9e\xc4\x18a\xac\x96\x05\xfd\x12\x96:\xb1R\xf6\x01%.\xdd\xfad\xe1\x86\xeb\xe8\xa7\xcc\xd5F]!tu\x15\xa3%\x13U\x1dx@\xe1VdD\xcdMp\xa9\x8a<\xed\x89\xcd\xec\x84\xc7w\xf9\x9e\xb5\xdd\xf0E\xdb\x8a-\x1e\x88o\x08]\xc6\x99c\x13\r/vc\x89v\xb5\xf5\xbb\x88\x0b\x8bn\xc6Q\xa0&5\x8d\x97\x9dp\x98&\xb4\x86\xae\x07\x93l{{\xe0\x7fY\xa0\x92\x90x~\x97\xae1\xe7]\xa9\x152\x05\x1d\xb4\xdf\r\x85\x8d\t\xabZ\x1d\x16m\xac^K\xcf\x17\xb6\xf0\xd7\xede\xff\xae\x17\x97\x1d\x1c;at\xba\x00I^\x14\x01I\xf7\x1b\x1e\x8a\xe4s\x1cf\x115M\xdf\x97\xad\xe2X\x7fK\xfd\xe3i;\x80u\x05\x1cX\x86\xa5\xd3\xf7\x9d\xec7y\x918\x1f\xc7%\'\x89\x97\x14\xa1\xa6\r\x04\t\x1eE\x96\x82\x81\x15/\x04\xeeV\x83\xa9\xa81\xd9L\x08\x1a|X\xf2\x13\xf7c\xb6\xc5\xa1\xf2\xa9\xcd\xb2}\x8b<\x03\x96\xb4\x91\xea\x9e\x84\xf0\x02\x9d\r\xf3Fs\xa2K\x86\xf7\xff\x80\x9a12/li\x10V]\xce=\x88\xc9\xe4\xa8\xe7\x98\xf1\x1eV"\x92\xad#\x86\x1b\x99|\xb2\xea\xd0-\x94\xa1\xd6\xc1\'\x1b\xf5\xaa\x9f\x7fu\xe6\xc9\xfe\xf2_\r}\xd2\x15N\x8ci\x99\xa6A\x8e\xea\xdd\xd1\x08\xd3\x0cZ\x80\xc1\xaaI\xe3\xde\xaa\x0e\xbfz9\x0cJ\xaeYg\x88\xd8\x077J\xae\xd7\xac\x9d\xdc\t\xf4u%\xc0\xd5[\xb4`[\xd8\x89d\xaf\xb2\n\xa3Wf\xb7m\xae\xd4x`\xcd\xf6k\xf3\xcd6\xf4\xc0\xb5\xf2(,V\x02W\xa7\xff\xa9\xcc\xf2\xe1\xc8>\xf1\x02x\x9e\x9d\'Q\x0e\xa0:\x1ay\x11\xb5\x15\nqG\xfdG\x12nF\x88\x8cJB\x03{\r>\xfb\x8d\x92\x95\xa2\x95S\r\xba\x7fb\xda\x879\x1c\xbd;zL\x0b\x17\x17\x7f\xf1\xdd\xc3\xca4{Q/\t*xC\x9f\xfe\x95X\xac\xe1\xbe\x89q\xa7\xfa\x9e\x06\xb0\xef\x01\xae\xfbA\xa6A\xf4i\xd8\x99P\x1a[\x08\x18\x91\xa7\xad\xd7[\xc1\xdbJ\xd8\x80\xe3\xc3Z)k\x04\xb6\xba\x1c:\x00\xb5\x0cTP\xd6\x96\x84\xe14\x0f\xff\x11\xbc\xbf\x00N)\x87\xaa/\ns\xe0\xc1:\r\x8fv\xc5rpU\x86\xed\xc2t"\x08>T\xc1\x90\xefHy\xf7\x7f\xb6k\xcbs\xd7\xfa(t\x01b\xd2\x9c\xf5\xcfM$\xb4\x11\xcf\xbe\x12DV\xfed\x8b\xea;\x8c\x97t\xcc!\xb4\xea\xcfE\xb6c>\xef\xf0\xab8\xb1\xb5\xab\x990/\xe3\xa6\x0eJ3\xff\x1c\xb0\xd2\xb1X\x8e\xbd\xe9s&\xc3Jt\x9cUz\x10E_l7\x9b\x1eI\xa9\'k\\*\x81\xef!,[\xc2\xe8\xfe\xac]\xd9\xd47\x9f\xab\x89\xb7\xb7E\xe9\x1e\xdfc\xc0\x960F\xcboPqu|\x13\x82+\xb9\x0e\x9aWrl\xd4R\x91\xfe\x01\x1a\x98/\x8e]\xa3a\x8c\x12nD\xa1\x00[\xa8?@\x9d\xd59\x9e\x96k\xade\xb7\xe0\\\xa0A\xcd-\x0eft\xc8\xd4\xf1;\xfe\xac\xaa2K\xa5W0>9F\xb1\xecd\xb5=K\xca<\xa8\x07\xf7\xa7Bs\x96\x11\x14xp\xb9+P\xad\xc0f\xafo\xa2-\x99\x8e)L]/\r\x08\x1e\x00U\xe5\xc7\xd1P\xcd\xee*\xd10\xfd\x15\x83\xa8d\xc1\x96~\x88\x84\xea\x93T\x868U\x97\xf5\x07M\xb8\x03\xba\xa7qw*\xa0I6\x11\x1f,x\x8f\xf4\x8c\xe6\xd6\x89p\x06\x84\x0fZw7\xa7\xbd0<336G\x18K\x92,~e"\x8ciz\xca\xc9B\xf2\x11Z\xf7\xea\x9e\xb0\xa1_\xd2l\x86;xw\xf6G\xcc\x96< \xc7}\xc8\x80Gst\x97a@!\xda\xa6L\xf1\xf8\xa3\xce\x1f*.\xef\xd8\xb7\xd5e\xc4/#;*\x07\xf0\x80\x05QVs\x13\xf8p\xbd\xe2\x81\xd1t\x9ba\xd6\x97^\xde\x86\rN\x01P\xe9C|\x0e\x91y\xe7\xb2\x02pF\x83\x9f~7\x1c\xfd\x90.\x12^k\xa0sO\x97\xf5s\xf4\x95\xd1i\x11\xa2\x0fBl\x02\x19\xdd\xe7\x0c\x9f\xa7\x0f\xd4k\xee\xbf\x95\x17\xa2\xd4\xc4W\xf1\\\x1d\xa7\xc8\xf0\xbb\xbc\xe1\x98s\x1fAA*3#\xfe\x1a\xb5\xd7\xc3KR\xe1\xec\xd6\x02\x18\x98\x80Mr\x8f\xf7\x02\x0b\xb8i1\xf9\x7f\xb2\xa3\xdbe\xac\xfd\x98\x92^\xdc\x87~\x1b]\x0f)\x9b.J\xabvl\x82\x8e\x05>\x066\x1cD\x05\xbf\xdee\xb4\x8f\xc0\xd7\xd1\xce\x15{\x1b\x85a\xaa\xd3\x19[\nn/PM4hLyu\xbfUAO3\x02*\xaa)G\x00\x05\xdc\x90\xa4\xe5/\xdbp\xf4U\xd4\xde\x10\xfcXW!7\xb7\xdd\xe5c[\x8e\xe0Z\xed\xd3\xe5\xb9\x84\x1f\xab\xcf\xc6|j\x80%J\xdfoN\xa3\xf0\xcdi\x9a#\xc9\xe3\xdeh(\xb8)\xc5\x92f2\xc2-\x7f\x9a\xd9\x16\xa6\xc2Qr\xbe\xa1\x14!\xd8\xddp{e\x05\xed9\xc7\xaa\xa8\x02\xbe\x8f;H\x10 ~RPc\x8d\xaf\xa9\xbc\xa3\xf8\x98\xd9\xc8\xfc.\xf5\xcepL\xa9\xe8q\xd8\x00\x92\x95\x84\xe6g\x1a\x8a+\xdaz\xa7\x85\x94\x9c\x8f\xc3\x17-\x12\xf6\x1a\xc2\xf9\x84*6\xcf\xfc+A\x99\x93\x9e\x90\x84\xfc\xa3\xdd\xa6\x15\xb2l\x16\x0c\xf5\x14#`\xc5\xae"}\xf3\xfcEg/\x9e&L\xcbB\n\x91\x84\xf7\x0c\xd7\x1d\xbf\xd2\xc8\xba$\x91\x95lf\xe4"\xa3\xe9\x8e\x04\xf6N\xc8\xb3\xeeac\xc0B\'\x80]l\x8d\x91F\n4N1\xf4\x05\xeb\xbc\xb8\xda.J{\xb87\xb2\r\x9dg(E\x0f4\xa1\xf2r\x95\xc5!\xb73\xa7\x98\xab\xff\xee\x1aRb\x17\xcd\x10\x9d\x1aN\xae<\xd3-"T\xb4k\xe7\x8f\xd0\xabyL8\xe5\xc3\xe1+\xd7\xfeq\xe0\x82\xa83+\r\xba\xe0\x01\x80NP\xdd\xe3\xdd\x01\xaa;\xb5\x98\xf91\xf3\xdb\x87\xd2W\x1b\x8bN\x83\x05\xa5[p\tO&\\0\xfcu\xeb\x1co\xc3\x81\xb3\x9e\x004\x7f\xaa\x18\xe3\x19\xb5\x01-\xd5c<\x8a+\x10\xee\x91\xf2^\xe1}(_\xdd\x8bq\x05<0(\xc9\xc3\xd6~\xb8V\xfe\xfd\x8f\x06\xec\xedo\x92\x0c\xf2\x81\xb6\xf4/S\xcb:\xe5&\x84\xf2\xf86\xf8\xbe@\xf0\x05\x11?\xdb\xc9]\xef\xd9DG\xff\x84/2\xfa\xfc\xd0!|A\xccow\xa3\x94Tg\x12~\xba\x00\xf0\xc0\xe6\xa8\x99\x15\xa7D\xbck7UI)\xad\x13\xdd\xe6\xbc\xa6\x03w\x18v\xfd\xc6\x89\xae\xcc\x13\x7f\xdfD\xcd;\xfa\xe1pq\xd3\xfd\xd6\xde!\x1fVG\x93\xa8 \x08\xd6\xfcRF\xa9\xbd\xf1\x8b\xa73\x9f\xe5\xe2\x8c6\x0e\xb8\xda\xc8l\xba\xd6Y\x022\xcd0\xef`\xc5\x8f\x07\xb5\xa6\x87\x80.\x01pm\xc4\x96)-\x85\xa2\xda\x10\xd3\xc3\x9d\xaa\xb6\xe4\xbe\xc8(\x95J\xf0\xa1\x82\'XV\x16;\x03\xd6\x1e)\xed\xb3\x86P$\xdch\xe5\xd5I\xca\x99\x99\x9c,\xcf8\xea\x93\xd2\x82\xe7\xd9^\xe4J\xc2\xa4O\xc0\xabJ\x0c\x04p,q\xa0-\xd0\xba\x03\xfcb\x1a\x84\xd9\xad\xed\x8a\xb1\x90/\xf2`!!\t\x009\x02\xa7~h\x95\xf9\x197\xa1+\x81\xa8+k\xc6l\t\xc9\xae^\xaa\xd0SIX\x1a\xe4}eZ\x1c6\xdf\xb5\x93\xb0\x1e|\x8a\x04VSj\xd4\\0n\x86X|\xf2\xbeA"\xf5\xbd\xc1=(%\x1c9j)x\xe6\xd0\xa4\x8a\xc4\xed\x1d\x92\x13\x8dtQ^\xba\x1eL\xf7}\'T\xf3\xc13}FF#P\x89\n\'\xdf\xea\xd1\':\x87>t.\x05\xa14\xd1\xcc\xda\x05z\x199d\xfa\x18\x10\xb2q\xb3\x92\xf5\x0elIv/\x82B\xb3\x88A\x0c\xf6\xfc\xb0\x18y\xfa\x05\x00\xfc\x88\xa9|\xaf.\xe3\x90I\xb1\xc8\x99mfI\x1a0\xb1\xe5\x13\x03\x99\xee\xa5\xec\x19\x0c\xdb\x1a\x1dUj\x1c[\xb4\xdd\x1e\x84X6!\x10\xda\x0e\x1a(\xc2\x04C\xc9\x0f\x88ZI\xda\x18\x9d\xfbuV\xe3\x11>EKg\x93\xdaT\x9b\x85\xc6\xedQZ\xb8\x95\x9b\xee%\xde=@\xbfS)\xd6Y\xd1d\'\xecl\xa6\xf2=\x95[\xb3\x142}\xf9\xc5\xf4`\xc3\x96\x03\x85\xd5|{^\x8e\xcd\x95A\nS\xbb\x9d\xad:=\x02\xce<\xf6\xfc\xe8&z\x89=<\xd8\xffJH\xca~\x96\x0b\xc7\xae1\xe1\xbf\x866\xde\xbe\x1crW\xfeK3\xd6)\xda)\xc2t\xbb\xa6\x82B\xbcQ+\x19#\x02\x0e\x81\xb5\xab\x96\x07\x8c\x01PEX`\xa6\x10\xca5\xf5|$N\xa2|\x0f\xea\x8bY\x97\x98\xb8\xd9\x8b\xb3o\x0e\x9a\xf8bi<\xf8\'-\xc2\xe4\xd2T\xc8\xfc\xe2KDQ\xbeDNT\xab\x9e9\xd0\x85/\xbbJ\x9b~\x8bD\xcbwC\xccm\x1b\xd744s\x7f\xd7\n<\x1a\x9a\xfe,\x8c\xa2\xc7\xf7\xfb\xecD\x9b\rD\x92&\xe5{\xf6\xd3\x99Dcl\xed\xb1\x81\xf5H\r\xfd\xaa\t\x7f\x15\xbd\xe90\xb1\x8e||\x80D|\xe5\x16<\xa1\x00\x92\x9d#\x16;\xae\xb6\x9c\x8cW!z/\x99\x18\xedqDd\xc5\xd7qW2\x88KC\xb0\xcd\x8a\x05|\x03\x9dN\xa2\xb8\xad\xf7j\x8bt\xb1<&\x7f\xc8\xd7F<\xae>\x06\xe1j\xa8G\xe2a3e\x03\x05\x82/q\xd0gic\xc8\x91\xd2\xaa\xac\x1a\xec\xfc_7\xef\xbbE7\x11\x0f\xf0\x8e\xeb!+\x94\xb7G\xef\xf1\xa5\xe8\x1e\xc3\x19b\xdd4\x0c\xb9\x01\xbe\xd8X<\xdbj\xf8\xa3Ia$\xf8\xe7\x0e\x8c\xd3\x1f*\x94\xc0\x9av\xcd\x81p/\xaat\x1a\xfc\x87\x7f\x07t#]\x8d\xa1H\xd4\xa4@\xfd \x84\xfb\x03\x9f:\x1e\x0f\xc2\x85\x12Hu\x90\x01\x86\x9b\xb9\x1b. \x1a\xde\x10\x9e\xd2\xbf\x04\x1fH\xe9\x87y%0 \x82\xa6\xd5\xde\xfe~\xf0\x18\xe1\x1a_*\xe4\xc2w\xd0+\xb9*D\xf1\x8e\x18\xeb4\\\xa7\xb2\xb1\xd9\xb5\x02\xfa)\xe6\xfdQj\xa74\x01s\xdbJu\x1c\xad\x19\x89\xc0;\xda\xa3\x8d\xa5\xdb\xcfP\xa7\xf1\x0b\x93a\xd8\xf5\xbf\'\xbb\xcf\x8d\x02? k%\x87\xaf:\x1c\xea\x88\x9d\xf6Q\x85;:\xe0\xc4\xe6\xa8\xa4Md[\r}\x11N\xc1\xbb\xd4(\xb9^\x9f\xf4\xef\xf4\x8e\x80\x8e5\xd6\xab\xcf\xd5h\xc5\x9e\x91\'{V\xebXY+\x8c\xd8b\xca\xc9\xd3\x1f\xda\xce5\xd5(\xd7_@\xe7\t\x95\xabG\x9fT\xd0\xf4\xcb*\x10\nz\xe0\xab*\xb7Bi\x81\x9f\xb7\xa2\xdb>\xedOn\xcf\xe2\x96B\xa1-\xf4\xc8\x07\x87\x951]\x7f\xfd\x06Pp\xb9L\xaaP\xe4^@\x15\xfe\\o\xf7x\xeegu?1\xf7]\xd7X1\x18\x1f\x897\xaak.E2A\xf3c\xd5h\xe8\xce)Z\xbdC\x9c!\x10d\x1f\x95f\xb0\x14\xe7sx\xf3x\xb2p\'\xf9\xb4I4\x10\xa6\xa2B\x1e\xc8\xa8\x00\xb4@\xae\x1c\xde9g\xd8\xb3\xfb\xf7k\x9asQ\xc7\xd6\xbd|}\xc46O\xf8\xe3\xc9F|\xec\x96m\x98\xe4\xd4\xa4\xfc\xf3ND\xe2_\x8fl\xd5-Z\xcaqo+Z\xed\xf3iP\xc0Q^\t+k\xc2:\xc2\xfa\x1c\xbd\xca ^K\x0b\xc7\xcd@`\x05\x9e\xde\x86H\xc1\xe4S\x83I\x16\x028m,\xd9\x83\x18NfL@\xa7\x0e\x95\xfd\xb6\xb3y\xda\xa2\xac"\xea\x98\n|T%)\xa5\x0c\x01\xaa>\xc2\x12f\xffZ\x9a\xe6\xff\x8c\xc1|z\xad\x8b\xa1\x83Ex\xe4\x1a\xcf~\xbc\xb5M\xd9\xd0M\xef\xa5\xf0\xb7\xb00\x8e\x92\xe2\xc3\xdb\x7f;\xda6_\xca\x8c\x11\xc3\xc2z\xb9a\xafX\xb2\t\x82\xae\xec\xb8\x8c>\xddR_\xf65f\xbdq\xb7P#%\xd9\x9b\xf0\xa2\xad \xbfn&}\x11\\AK\x94L\xf3\xab\xa3d\tQ\x96\xde\x0c]\xb9\x93\xfav+\xa1\xffCdw\xf67\xc1\\z\xaat\tS5K\xda\x16\xe8\xdd\xde51\x90\xe5m\x1f^\x96\x1bj\x0chA\xed\xefC\x9a \xc6\xf9\r1\x14\x8d-\x08\xb1V5\xf7\xf2\x8b/en\x7f\x894U\xa7\xd2h\x96\xc6\xe6+\xe1\xdf\xa8\xd0\x15\x06\xad&l\n\xc0\xd5\x17\x1e@I\xdf8\xba\xfd\x88u\xa9\xd5\xf7s\x9b\x13\xec\xb5\xc7\xa9\xc9\xb3\xc0\x02\xb5\xe3\x07\xe8\x1d~9,F\x17\x93\x95>\xeb\x8a\xed\xe0\xc6\x12\x12\xae\xef\x01\xac\xd1\xfe\x8a\xb8\x1e\x07\xacKZ\n/Q\x99\x1fe\xdf\x11z\x19\xf5\x80q\x902=\xdf\xbaGC\x04\x95$Hu\n\xff\xd7\xa5}?\x10\xae\xb6\x11\x87.2\x9cW\xe2\xe10\x8f\xb6\x1c\x90\xf4\xfe\xc9T\xca\xe0\xb5\xc77\xfe\t\x1b\xff,\xd5\x8c\xd0\xd5\x95`m#\x03\x08X\xe1\x1a;\x15\x83\xd1\xaa\x01\x03\xfb\xcfz%myB\xf8\xefmbM\x7fM\x0b\xb2\xf2\xb5\xf1\x14\x92W\x00_\x85\x15\xc9\xb1!#\xce}Z\x1c4\xcf{N\xa8\xec^,[\xcc<\xe7\x1c\x02\x01\x16\xe9\xab\xebj\xf3\xeaCY\x0b\x0b^\xbby<\xde\x03c\x04\x88\xe3\x11\x8f\x8b,h\xfa|\x9e\xc0\x0elk\xac\x8e9\x14:up.zA\xef\xaeN\xc5q\x1a[\xfa\xeb;\xf3\x98r\x8f\xec\x98N\x1c\x9b\x19\xcb\xd4\xc38\xa1\x94E\xbbD=\x1d\xf9\r\xd8\xd2\xb1\xf1\x13\xa2\xbaU\xc9\xdc\xcb\x08s\xec\xd6\x0f\xf7\xc2\xa7\n"$\xa1\xef<_\xb2\xeeT\x0c\xecF\xde[R4\x94@\xe2\xbc\xd8\r\xf2Z\xaaJ\xfb\xe2\xd3\xbf\xa4v\x00m\x12J8A$/\xa4\xc7\x12u\xc7\xcf\xb3\xc0\xa2~%\xad\xc8>\xd1\xd4\xf4\x95\xd4\xe5E\xc0\xd8\xf2e\x850\xd0\xa8\xb3\xccZs)\xca^\xfc^~\xd4\xe7X^\xdf\x99 #n\xf1%E\x17=\xca\x02\xb8-F\x9aT\xdb\x19\xae\xcf\x1d\x80\x94\xa1R\x96\xb3E\xde1\xcd;\x14_\x7f\x87\x7f\x84\xe3\\\xa2\xc22\xc3=}np\x0bg\xeet2\x10=\x95\rp\x1d,\x06n\xc7\xdd\x8f\xbf`U~\xdd\x16#\xcb\xc2\x8c\xb0\xc3\x19\x98?\xb9U\x94;\xe4P\xd2F\x1b\x9e\x02: \x08\xc8\x00J_\xc0%k=\xa5\xbaX.\xb4!T\xc1\xc3\x93\xa6n\xe9\xe0#*\xb5S\xe5\x00\xdc`*\xae6\xe6q\xf1\xc6\xf9\xd1\xc9cQ\xfd\xb3xdxiw\xa2\xe9\xafBUvN\xee\xad\xe1\x9cj\xe7\x16!\xe9\\:\x1f\xa1\xceA\x9eS\xbbJ\xa2\xe5\x90\xb3Ul@\xe0\x83\xc3\x12\xa2\xa7Ho,\xef\x0b\xc0l\tA\xe5\x16\x0c\xb2\x94\x1a\xd7\xd0ZV\xf1\xe7\x90Q\xd7\xbb\xc6\x0e\x02\x1c\x89\xf2n\xcdZ9\x83@\x1b&\'\xb5\x17GY\xf4\x18\\\xa8#\xe3*4\x10\x12_r7x\xdf\x8cl\x97\xe9\x84\xbb6\xdcu\xd6\x97\xfdV\xf5\xa3\xc8\xcbX\x87\xb0\x0e\xb6n=\xf8,49\xf3W\xad\xa70\xdc\x00\\\xe7\xe40p\xd0\x8a*\xf2\x10\x9d\xdb\x06Nq\xea\xb8\xca32IE\xd3\xc5\xac\x1a\xb8\x10\xac\x01\xc3\xef\xf2\x13ZJ\xb9\xf3\x7fH\x15\xa2\xa3\x9d\x0284Tda\xfc\x0e\xa5\x92\x13\xfc\xdc\xc5Y\xd0\xeaTc2\xdf_\xd7\xc1\xc2!\xf3\xf0?\xd8\xff\x91<\xf75,\xb5\x85\'\xb2\xc0\xc3\x0e\xf2z\x16\xe6Z\xe1\x9d\x8es\x0b\xdf\x8d\x9e\x1c\xc3\x8a\xf9\xc3g\xf7\xf65\x1f\xbd_\nZ\xbc\x16=\xfe\x1e\xc8aY(\xb3\xea3\'?\xb4') diff --git a/collector/core/gripper/sightac_sdk/api_new/touch_sensor_base.py b/collector/core/gripper/sightac_sdk/api_new/touch_sensor_base.py new file mode 100644 index 0000000000000000000000000000000000000000..772b63ed5be0eaddd599a55e1f3bcce767d47ea3 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/touch_sensor_base.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:48.165461 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\x89\xbb\x00\x00\x12\t\x04\x00\xd0}\xde\x84\xb8P\x1cN\xbdU\xad\xe0,\xc5\xb8[\x00\x00\x00\x00\x00\x00\x00\x00\xa3Dw\x08\x11\x98+\xc5\xba\xc9\x1b]\xc5|\xe8\xfd\x19\xc8\xf7\x18s\xa3m\x18\xa3bs\xba\x18\x06^\'\xcea\x91U\xd37SX0\xb7\xc6H\xf6\xce\xe9\xcb\x1fnX!g2\x94\x08\xe04\xf3\x8dP\xb0\x88\x87W\xc6\xb3)\xe9\xfe\x85\xb2J85\x16\xd9\x8a1\\:\x88\xcb\x0e\xd0\xcb\x04H\x87\xdf\xbe\xcb\xb2\x08,\x1e\xd7\x87\t\xf3\xff\xcf\x05\xa2\x04\xe59\x87\x0cV\x00\xdbO\r\xcf\xe8\xd1\xd1\x1f\xc5\xa0\xe6\x83\xd9B\xdaI\x8a%\x03e\xf6\xac<[\xa2\xb1\xc7`\x0b\x87\xc5\xd8<)\xcb\x10\xa1\x02\x9fK\xd1\xd2wo~\xd1R\x92\xd0\xef\x9eR$\x89Q\xe9\x065\x97\xd2\x94q~\xa4\x82\x0bip:\xd52\xa0V2m\xf3\xe7\x1a\xd904xS\x0f\x08\x0cO\x80\x87B\xf7\xb4H2\xd3\xf2\x16\x15\xabTL~\xa9\xb9?.A<@Q\xd4W\xe6\x95\x807`\x9c\x18\xdf\x0c\x0f\xc7\x8b\xec\x81\x0c\xdc\x06^\x83(K|\x9cu\x1d6\x80G\xd802h\tVh\xbc\xd4\nx\x92\xa5%9\x17\x7f\x9d \x16\xaa\x1e\xb4\xd94\x83\x95s=t\xe7m\xbe\xe1\xf8T\xe1\xce\xe0\xdb\x0f\xff\x02\xdd\xfe\x81/B\r~\xfa\xd4\xdf\xfc\xd3[(\t~\xbc\x9ay\xf2[\x066\xd6\x8cQg\x8d\t\xd6nmnu>\xd3\xa2\xd03D,\xeaE\x84\xb5b\xe9g\x86\xf2\xa0\xce\x98\xe3\xad\xd7\x14GR\x0c\x95\x94P\xa9\x17\x80K\xe3]H\xd2\xda\xd4\xe0\x1c\xc6v\\YIh\x89\xce\xdd\xc2\x1b\x85y\x1c\xfb\x87 \xf2\xce\xc2\xec\xa2\xe72\xce\xc9w\x16,\xf5\x97\xb3^\xfa\xe5\t"\xb0\x9dS/\xc4\xf6\xfb>\xb0\x9d\xa1Z&\xdc\x02\xa6\xb3T)\xaa\xf9\x07Jy\xfc\x8e\x84\xe0\xae\x81\xa2qxb\x04\x0fT|\x97\x8c5f\xd5\x9c\xafc\x8a\x1b\xd0\\a\xa4?\xad\xfb\xa4o9\xd5k:\xfan\xa8\x99X)\xe6H\x8dT:6\xdbXq\xffYP\nI\xc8.`1\xbf\xec\x19\xba\xb5\xd2\xbe\xe0\xd4\x9a\xbf\x00\x95\xbf\xd8\x18\x86\xd0a\xae$\xa1\x1cW -\xc0\x1d\xe1\xcb\xe9S\x00\xadN\xa9\x9f\x99_\xcc#\x07\xfe\x17\xb2=\xfe\xe0\x9cY8\x9bl\x95\xb3\x18\xec\xc1\xfc\xf5\xeat\x95\n\xdf\xab\x99\xed\x04O\xf2\xa3\xbf\xc2PR\x1a\xb5x\xe5v\x88\xc1b8\x87C\x89\x08;\xf9\xc4A\xccY#yr\x12\x99PM3\xdf\xaco\xcd\x88F_\xb3\x12\xb7\xff? \x06\xef\xcf\xa4!\x1b1\xeb\xa6\xa8-D\xdcm\xc7\x0c%D\x9b\xd5>n\xd8z}\x08{\xb1r\xf6\xae[?!\xca\xd8\n\x83\xf9\x1b\n7=\xd1\xcb\xe1\xd7\xc5\xca=\xbf#`\xe7\xd2S\x0f\xed\x89\xb5c\x11\xed\xe5\xc5\xeb\xd4z6\rL\xa4\x82\xb8\xe3\x0c3\x8a\x9cEV7\xa6r\xc5&9\xfdD@\xe5\xf4\x87W\xaa\xd8\xce\x83}+);mb2\xe2\x13\xca\xe98\xcd\xb6\xf7\xee\xee\xdf\x01\xc8\xd3{%\xe1+@\xe2K\r-`\\\x99h\x94\xecF\xdd\xe9zT1\x03\xeaZ\xdd9q\x0c(\xd6MW\x02\x8f\xcc\x00co\x19\x15\xd9\xd5\x85"\x17B_r_M\xfb\xedQ\xaf\x19z\x97\xf2\x9cZg\xf0\xcf/\xa5\x8a_\x81\xa8j\xb9HS\x7f\xb5\x7f\x8b5+\xee\xc9{\xf3\x1f\x1e\xce\xd7\xd6\xe3\x88me\\:fv\xa0b\xfcF\x9fcf{hF\x10\xfbm\xdcqt\xe3>PI\x98\x9f\x9b\xb1|\x12\x98[\x98\xcc\xb5\xdf\xcb@\x810\x1d*\xa6\xd1\xfa^\xd9\n\x9c\x0e\x01\xe5\x03\xce/4=\x0f\x95\xeb\xdb\xa8\x06\x92\xa7\xeed\x83`\xda\xa9\x9e\x1cY\\\xb3\xb3N\x14\xb5\x15Z8\'8R\x92t\x9c.,/\x92\x96\x7f\x91\xb8,\xfd\x0e\xeb\xebb*x\x1bzr(\xbc\xbe\x9b@\xd8Z\xf7\\\xc0\xff\xc6\xd7\x03G\xea\x1c\xef-\xe1o\x99\xa0+v\xbd\xf1\xae,<\xd0~\x8b\x10\xa7j\xd1\xef\xa3\xd2\xb7},\xeb_3;\xfa\x1a8;U\x95J\xb5\xe3[+\xee\xdc@\xc1\x17`w$\xd1\xde\x16\xd7u12\x077U\x1e\xe3^/mU8\x0c\xab\xccMRj\xdb\xd4\x80[\x9f\xe5\xc9O\x15\x82\xbd)\xd8\x97\xb3W\x0cz\xe8\x0f]\xf9\x8d\xb0Se\xea\xbe|\x87\x15\xc6+\x07\xd5O\xcf\xd4fK8\xcaM`\x18\xbff\xcf\xd9\xa4U\xfd\x83b\x9f\x0f\x06\xaeN\x0b\xba\x9f\xa8\x9f\x08\xc2\xda\x00\xd3\x03\xad\x1f\x8cj\xbeb\xf5\xcc\xc6\xb2@\xb0\x0c\xd0M\xc29\x02\xc2\xd9\xcc\x04\xd3\x12\'0\xc4t"\x04\xebg\xf4\x8b\xc9t\xc1\x82\xdf\x0c\x9e>\x15\x7fk\xec\x06a\xc6R\xce\x97j/\x8e\x04\x01L\x1b\x9c?\xb7s8\xcf\xf8dh`\x0b\xa5&\xaf\xa1=\xa5\xe6\x9f\x8a\xa9\x80\xee\x06b@N\x07e\xb6 \xac \xcbA\xceX\x9d2J\x84\x99t[\xfe\x96s\xe9VOU\xf0\xa5\x89S \xd3\x10\xa5\xd4\xe6U\x92:\xee\xf5\x14x\x8a,\xc7O2U]\xd8/]\xbb7\xcf\x0b\xe8\xf5l\xd16\xab2\x10\xbc\x8d\x8a\xf1Y\xa4\xf5\x02\xb7\xba\xb4<\x15\xe6\x88\x82-l\x9ei\x80\xa5\x03\xf0\xc1\x02\xc8{co\xa8\x9f\x9c\x13\xd3\x0cp\xe15\xb7\x97\x84\xec\xc4\x91b(\x16\x97\xadBT\x017a`\x9e\xae$\xde\xdf!T\xa3N4J\xf3a\xab\xd1\xf3^:D\x07:\xa2\xed\x1f\xed\x83{\xd9\xd6\xd7+\xed/EZ*\x86no\xee\xe8\x8dr\xf8\xf4L\x92\x9c}au\x9e\xde\xa6\x0fN9\xebo\x84\xd0`\xd7\xd4V\xc2\x15i\xc8)*Cx\xd316-\xe0Ka\xf1\xff\xa5\xb7W\xdb\\ \x07\x83x\xd7\x9a\xa5\x86\xa5\xc3\xf55sR\x11\xca\xd1\xd7\n\xd8\x95\xbf\xb3\xe1\xd1\x82v[\xc0\x80Mp\xb3;\x11Kiy\x9bd\xa1M]\xd5.\xdag\xd2\xe1\xb8\x0b\x99\xf8\x93i\x18K\xb2,!g\xcdq\x1aw\xc3\xc5\xe4\xf4\x98\xce\xd2C\x8e\xdbC\xc1\xb6C\xea\xc6\x1a\xcb=\x163e\x85j\xcd\xdehn\t\x93\xdb\xcej\xf2o\xf9l\x8c\x8b\xb7\x83$,i\xa8]\'\xd69\xeajT\x18\xf2EI\xae\xdf\xc1\x92w\x7f\xca\xa1\x14{\x05\xcb\xc3\n\x1d5\x16;\x8f\xe5i:k\xa8\xa5f&7\x9d@\no* s,\xfb\x1e\x12\x7fdK\x1a*\x8f\xcd\x04\xa8\x11\r(9\x02;"T\xa20\x81\xf9\xafX\x95\x91\xa4$\t\xef\xa9\xc4\xa2\x13\r\x94#\xac\xf3P\xdd1\xa1\x95\x00\xa3\xc9\xf3Z=\xf6\x98\xbes\x0f\x7f8\xc7\x13z]X{\xa9\x11F\xd2t\x8e\x04_\x12\xc7\xb4\xd4K\xf0\xa0\xc8\x86\x91B\xff\xa1v\x14\xe5\xea\xf5\x9f\'\x03\x9f\xd6\xa5\x7f47\xb3\x97\x11\xcdi\x9d`\xbeNa)\x81\xef\xe0\xfc0\x08\x17\x00,h\r\x1f\xa5\x90\x9b\xacL\x07\xfd\xd4v\xc0\xfa\xf4\x0b\x02G"\xaf\xf28\x8cu\xb2\x88\xbd\xb3a\xf5\xb0\x83\xd4\xfae\xb2\xc3\xec\x12\xaa/f\xcc\xbc\xe6\xf3F\x85\xb6\xf2\xb5%\\\xc9K]\x1f\xbcu\xcf\xb5\x04o\xd9\x160\xa2\r\xb9n\n\xc4\x16\xa9\xbb\xb4\xae\xb9\xdd{\xf9\xe0\xd9\xd3\xd3D\xe96y1\x82\x8d\xb0\xe3y\x8b\x9fz\x9e\xaf\xc4\xe9&D\xde\xec\x88v\x06\x05=g\xdd\x1b\xce~\xdaDGK\x0b%\xa8z\xa9\xb6b\x941m\x9a1\xde\xc2\x9a\xed\x86\xe1%\xefCh\xe2\xacl\x9do\xa6R\xd2\xcd\xe0\xad\xac\x15\xfe\xeb\xe1\xad\xffg\xde\xcf\x13\x930\xfe\xa5\xf4\xa6\x8aE\x8b\xd2J*\x908!\xc6\xf6\x7f\xb9F\x11@c:\xa7\xd7F8\xa1z$\xd6\x1fec\xff\x8b*cJ\x8f\xd0aQ\x07Y\xfe\x85\xb7\x85\xff_i\x86\xe4B\xacz\x9e\x10\'\x18\xc6\x86|>\xe5\xbd\xf6\xad\x9e\x08q\x85\xd7\xdc\xc0\xf8d[\xd5\xcb\xd5\x0c19\xc9\xa9>\xea\xe3\xe7\x8dg$\x1c\xb8E~7\xcd\xcb\x05m\xf5\x7f6M\xcd\xf9\x14\x98\xee\x0f\x832\xdb\x01\tI\xc6\x0bEG-\x82i\x8c/\x1f3\xda\xc8m\x11\xa3\x1f\x18\xc9\xd4\xc4\xab\xdaS\xeb\xfd\x8aw\x9e\x01AlXK69\xa8\xeeG\xe9\xcc\xeep\xafW\xb7*:\xd63E\x04\xfe^wG\x19i\xb9\xa3O\x15\x8bS1\x7f\x94(\x04\x98B5E\xde\xe3\xc52K\x02\x13o\xfe\xb8\x9f\x153\x92q\xfah\xaf\xde\x08\x81\xc3\xf3\xce\xe1D\'e\xb0\x91!<\xf8ow\x04\xb9\xe1$\xdb\xd5\xfe\xca\x9eqjLW\xa9\xdc\xa9\xb4\x93p.\x7f\xea~l\xdb\x84\xd1}\xd8|e\xa5\xfd\x98\xfe\xae\x85\xef("\xc2#K*\x0c\xd1\xf08\x8a\x1cL\xc9(67\xae\xfc\x12\x02\xde0\x8bp\xa4\xb2`\xed\xc5s\x0f\x9b\xfe\x007\x14\xb40\xab\xdbt\x1eg"\xa9\rJt#m>\xa9\x9a\x0b5\xf7]\x99`\x18\x93\x9a\xf8\xa2w\xb2\x12\xf2~=\x02\xe4\x9d\xbf?VD:&4\x8b\xf4\xe2\xbbT{\x1eG\xbbt\xa0\x08\xf3\xd5o\x05\xe5nN\xfb\x9b\x1d\x13]Fr\x0c\\\xef\xb0\x17\xff\x1d\x8b\'\xc5\xe1\xf9\x11\xca\xa5\x93\xf8\x93\x99@I_z\xd0\x1d\x00\xe1\x84)\x90\xf3\x03\'`!j\t\xfb\xfed8\xd4\xb9\x0bB\x17(\x7f\xaa\xc6\xecK\xb0\xa5\xd2]\xf8R\xf8\xd6`\xcf\xc7\x13h\xafg{\x84K\xd9\x8b\xddY\xa45\x9d\xbdW\x98\x8b\xf2\x10i\xeezn\xa1\xf5\xbd$\t\xc6D\xb5\xc7\xfc\xdb\xcfZ$\xf9\xa2\xc8B}\x1a\x97\x1be\xf5{"u\x1d\'\xad\xb8\xd6\x97a\xca\xe96;\xc2K\x8b\xfa)y9\x9e%\xfd\xc8\xdb\x14a\x8f\x08\x0c\x86C-\'\xb5\xad\x96\xbc\x9b\x0b\xefh\r\x176\x14\xf8)\x02d\x1a\x15,\x82\xa9+\xfc\'B\x97\x13F\xbe\xf3+\x8f\xe8\xab\x1e\xa2\xc5L\xa4\xea\x04|\x86\xadm\xe2F\xc8s\x94\x95\xed\xc7\x04\x9a6\xf9\xdd\xdfaZ,\xc2t4)\x06\xa2\x8c7\xf0\xb0\x07S~\x96\x04l)\xc1!\xb25\x97\x1e\xec\xee\x8fSgd\xe3\'E\x87\x86\x9e\'\xbe7\x13\xf3\xcb\xe03\x15\xd4\x80\x1c`\x04\xc9\xcbOq>\x86\x1d\xd6j\x81\xfd\xa1t\x8c\xfc\x91l\xbe\xf0\xfb\xce\xbf\x956N\xe7\x13\xe8C\xcd\xee\x90\xa3\x9a\xb8\xd7\xed\x81\xda\xaf\xdb\x91\x82\xd1D(}\x98\xe1\x0f\xb9u\xe4}X\xc1\xc3\xe0\xa3\xd6&f\xb8\rf\xc4\xc5\xc4\xf6\xf1\x8f\xeb\xc3\x1eR\xc7dGi\xa7\xd0\x0b\xf5C\xa7~\x7f\x16\xdb\x010\x12\x0b\xec\x13\x8a*\x17h\xc8W\x1f\xfeq\x9a\xa8\xfa\xf3a}h~\xeb\x7f^\xecW\xc4\xc0]!\xa2="\xdc\xdcxV\xf7hX.\x1c+=\xd6\x1c\x87\xac\xa5\x9ch{\x12X\xe8\x02-L:\x9dL5\xa0\xe0\xe1\xb7I\xc4\xe6/\xa4,\x91\xb8\x90\xba_<\xbf\xac_\x1d\x84\x04\xa8\xc30q\xf3\xb1\x9fT\xb5\xb6G\xcb-k\x90e\x06k\xe5u\xc8F-\xf4\xa2\xbf.\xca\xe7b+\xf4>\xdf@\'\xfcJw]\xdaceF\x89[\x84\x95\xd7e>\xf1L\xffjPF\xdd\x11Z\xe57s\xcf\x0fa\x17-\xd0\x14\xfb\xcc\xe7\xe2\xc3V\xdc=r\xd6\xff%\x9d\xc7m(O%I\x83\x95W\xe8\x99n\x91\x98\xe8`\rxo\x15\x88?\x0ewJ\x93;\xc5]\xd0+\xa1\xf3\xf0r\xfc\xca\xff8\xbd\x85/xC~\x9d\xef\x18y&\x05\xc7s\xc3\xe2\xbc*j7]\x8f\x9e\xf3#Q\xde\xd7<\xa1\xf1\xfe\xf4\xdby\xbddCl\xf0\xe4\xd5\x17\xe21\x8afH\x8d9\xb7\x7fn\x00d\xfc\n\x87\x00X\xf7\xb3\x86\xb9 O\xd0\xf2W\x8b\xad&\xb6\xf5\xc3g\x05a\x88\xf4\xc3\xba\xaeeH"B\xd4\r\x90\x1cS\xe2\xc3}\xd5\x1c\xf0\xaa/\x15\x91K\x01\xd25\xcd\x7fqN^(\x08\x12\xccw\xef*{\xacW\xba\x1by|\xd8(\xd4\x9b[\tA\xe4\xc8\xc7~8\x1c\x05kFP\xa7\xe7\xe67\x0e3\x15\xc3\xf4\xe50\x9d\xb6*\xc3\xab\xba}\x84\x86\xf5Q8\xd6\x9c\x085\xc1s\xbd\x850I{\xf6{\xcbm@XS\x83;\x99\xf6\xe1,\xfa\xe8\x90\x02\x17Eu\xdf\x90\xab\xc1\x99\xc3T\x08`\xec4N\xbd\x0b\x1c|.\x8by\xa8\x9c\xdc\xbfs\xfe\x0bj*5\xecc\x81\x16\xe2\xe2\xb1\x9b\xceU\xa3\x1b.W\tT\x84\x88\xc9\xad\xb8\xeeM\xe5Qn\xcd\x186\x0e\x8brE\x9d\xd8\x83\x93\xbb\xc5\xd0\xe6zt\xb8\x13\x0b1ez\x16\xc4\xcd\xf1\xfc(al\x85\xed]\xfc\x05\xb4z\x0f\xdeW\'\xe6\xe9M\xbb\xb3J\xe9"IwDz\x9e\x16\xb6$\xa7\xa1\x94o\xf9\xdb\xbe\xfe\xce\xac,\x0ch\xbf\xd0t\x96"\x12\x9a\xd3/\x97D\x01g\x8c\x97\x1d"\x8d(\xf72\x8a\x12/y\x1a\x8d\x96@\x8b\xaeL\xff\xb5\x9a\x81_\x1f\xbc\xc9\xa4\xb1/\x98\xb1\x0c\xef`K\x19!&\'&\x8c\x94\x19\xcb\x85\x87P\xb7\x03`\x90\x95M\xa4sR\xe9\x97\xe8k1+\x97\xef6>|mW\t\x18\x07QL\xa9\x03\xfa\xac\xfb\xfe\xdc\xe2\'\xf1\xd7\xeaQ6\xf7\xf1\xb7\x99\'\xe0 \xf4\x8d\xfc\xf1L\x7f\xf9\xe40\xd5\x07\xe6/\xf3_\xe0\xfaS\x19@^m)\xf5\xe0%\x87\xde\x13\xd7\xa8x/\xb3\xd1+\x91$\x01u\xeb\xb1\xd5b5vk:\xa7\x85\xd6~-\xaaB\xab#w\x0cN\xe80\xf0-5\xb5\x8f\xd2\xfb\xad\x90\x0e\xc4\xdbn\x11J#\xdf\nh\\\x8a3\x07AB\xbd\x97\x94h\xbc\xc1\xa1~\xa8\xd4\xae*>\xf5\xacVt]K\xe5\xf8\xc5S\xe5z\x99\x04r$\xd1\xd3D\x93\x13Y\xbb\xbb1B[<\x19\xa6Z\x16|B(\xf0\xe2\xc2\xfb\xd6\'\xd6AeK\t\xdd\xae\x9eF\x88\x87$\x19a\x8d\t,p\x11\xad\xed\x06\x8bG\xbd\x05\xe7-\xb6\x92w\x1d\xcbXB\xc0>\x8dgh\x0c\x8a\x1c\xad=\xaa\x9b\xa4~\x97\xcd\xef\xa1\x03e6\xa4\x83Td,\x19\xa9\xcd\x1f\x1b\xf8\xfab>I;e\xc2\xf7d\x89p\x8c\xef\x83\x0c\xe0\xbfO$0\xd8\xf5\xd04\xa7\xea\xce\x10+\xef\x08\xaf\xfa\xe2I\xa6cf\x17(T\x18\xb9\xdfD\x8f\x08T\x92\x01\x1dlp\xd1a\x93\x93\x07\xd9\xb2\xdc\xb0\x0ff\xd0H\x8b\x88\xf7H@=L\x83~\xac16\r\x84\xa0\xa8*=-D\x1d\xae\xf71\xce\x15\x0e\xed\xe0\xbd6i\xa4V\xbe\x1d\x87iB-\xe6\\t\x7f\xce.\xe8d\x97{\x0e\x83\xb1{\xc3\xf4\x10G0)t\x89_\xbf\x984J\x8a\xf4\xe8P\r\xa7\x99(\xbbv)I\x9a\x88`\xcf\xa8a\xc9S\x16\xae\xc6\x05}\t^\xd7S\xf6hu\x1f3\xb6\x98\xac\xaf\xc4\xb0\xc1\xabK\xc7\x08\xb5\xf3\rT\xaf\x95\x0fn\xa0r/\x84~\xb3\xb1P\xf2R\t\x02i\x17+\xdd\x8e"\xb7\x9eQ\x1fR\x9c\xf0:\x80\x9d\x04V\xb7\x92~&\xae\xc9e\xd6d\xfc\xf2\xa8stS\x96\xcfF$=\x86\xd8\x0b\xa5\x88\xf7\xf8G\xdcm[e\xeax\xa9%\xd54~I\x83\x86\xf65\xd0i\x04\x8e\xca\xad\n\x12\xe5\x08"\x17\xf5mP1\xc0\xc6\x84\xfb\xc5Y\x9ak\x03,\x17F\xf3\xed\\\x1f\xbeHA\xb2\xaf4\x97L\x9b\xc1#1\'\x01Z\xe2r\x02\xb1\x99\x14\xd0\xf0H\xf4^\xaf\x82\xe0t\xfd\x1c\x02\xe3\xe9\x10\x05\xf3\t\xee,\x10\xbb\xdaJ\xc2\xd9\xde\xe5\x86\xe6\x93\x14\x16\x19\xec\xa7@a\xbf\xd6(\xe7\xec\xa6\xab\x8b#x\x18/\x1aZ+\x83\x00\xfb\x82\xde\xf4\r]\xfc\x97\xac\xb3D\xd6\xbe\xf9)\x89,>v\xd2uoZ\x92\xc3\xfbg\xe1jK\rd\x0f\xfe\x91\x17\xc2\xfd\x03\xd5\x1b\x05\xe8\xae\x1d\x8eT\xa8rX .3\x97j\xfc\xe1\x1a\xdb\x83\x0bU \x96\x82\n\xf3\xf2\xaf!\xbd\x8d,\xa9!\\-|v\xec\x84\xf0\xffi\x14\xf7\xa8,E\xd3\xdd\xa9-\xcff\x8b_\x9a\x98C\xe4\xc4\xe8\xf7\x19B\xde\x08\x84w\x14\x06,yF\xcdv6\x138\xeeb\x7f\x8c=`\xe1\x07=\x97\xa6\xdfp#\x89\x0b\xf2\xc3J\xbf\x1d\xb5\x10"\xa1\xe1\xfd\x89\x1a\xe7.2\x13D\x9e\x82\xd1\xf8\xa2\xe6\xd8i\xb7\x03-PH\xbf\x9a\x18#K\xedZ$\xc4K\xf0\xd7\x89\x19\xd9\xb8\x87\xa3d\x1e\x02\x9b.\x1bX\n\x00\xf5\x9cK\xe0\x1cb-8\x0e\x935\x11\x87\xce}\n\xaeR\xbb\xaa@\x80\t8\xde2o\x1d=\x08}\xc7\x1a\xfb\x7f\xe7\xaa\xf3\x8a\x12\x8c{Hf\x9d8\xe5/\xb7\x18\xed\xa0\xe6(\xc6\xeeY\x81\x9d\x94\x1e\xaf\xea\xb1\x0b\xf6\x7f\xc9&\xcc\x86>\x00V\xd1\xd2\x19\xfc\xb6\xd56\x9a&\x12r\xfe\xf9\xd9\xc1E\xa9\xca\xbb\x1e\x13\xbe0psk\xb0`\xe1\x12\x9b4V+\xd5\xa8\xbd\x87\xcdub\x10Sy\x81L\x10\xc1\x98\xb6\xb3>K\xe1/,\xbf\x99]+\x8d\xfd\x0f:G]\xdb\xb8\x94O\x8d\x88\xb9\x0e{4\xa7\xbbIs\xbe\xa0A\t\xd1\xaf\x87\xe4\xfew\xba\xd6\xbb%?<[\xd4&i!\x92N-\xaa\xbbG5\xceM\x1b\xe3\xd8\n)^M72uV\x83\x00\x17\xc5\xe8A\x1e<\xfd\xa7\xc0\x16GD\x00\x88\x17\xf5\xb0\xa7\x13\xbe\xac\xa7\x03I\xcb\x9a\xcb\xf8\xcc\x83\xf1o\xc1\xddF\xe3Hi\x85:C\tv\xc6j~f\x06\xf0.\x92\xf4\xc3\xae\x86\xe6\x9fQH-\xa4\xfa\xeez\xe1\xd3\xb4\x99#z\xe0@\x14Xd\'\x0e\xba\x85O\x87\xef%\xc8!\xf0\x1d\xa5\xd2I\xea\x1e4\x93\xfd\xb1\\A\xe6\x02\x91)\xaf#Y\xd2Yv\xf5\x9c\x85hD\xb2\xe7\x9f\xf7FjX\x18"\x81N\xd9\xf0\\\xc6\xbb\xddig\xe0\xc2\xa3\xbd\x0e\x84\xfc\x96eNf\xab\x82\xe0\xb5U\xbe6\x16>\xd9/f\xc3\xbc\x1c15H\x9d#1c\xa1\xe7\xc5\xa6)\xc5B\x9e\xb1\xed\xd1\xa7\xf4\x8c\xfa\xc1\x0fi\xbd\xd3o\x02\xddY\xda`+\xf60\t\xc6A\x0b}\x8cD\xfe\xd6\xf5^\xfd\xb2\xb3\xe5K\x98g\tFA>t\xcf9\t\x06\xb3G\xb7\x9fz\x94\\\xd5\x9c\x1b\x88k>\xa3\x18\x7f\xbfHFF\x86\xdf\xd2G\xa8Y\xc0\xa0i\x8d]\xe4\x96s5~0\x96h\xca\x9cv\xd3\xdb\x13FM^?wl \x93\x00\xbf\xf0\x05\x8f\xf5\x1a\x8c\xcb\x00^\x93<\xf0\xf4\x8d\x85s4\x0e\xcdi\'\x10\x91\x80c\x9bT\xd7\xe7\x84\xb3e\xc5{YUp\xc6\xac\xcb\x84^\xdd\xd1\x91G\xd8N\xf6\xe8\x92\x945\x19\x820&0\xf0L\xd2\xba\x88\xd8\xe3\x03 \x92\xb5 c\xdcU\xea\x80\x85\x86\x8c\xb0\x9eW~`(+C_\x9e\x12\x8b\x89\xe46\xe3\xd8,\x1f\xa1\x16S\xc4)oq\x1bgT\x1bl<\\\x92\xf4V\xdd\x8fj\x96D\xdcD\x96\x14+\xd3\x9dW\xfc\x9d\x9d\x81\xbf\x15\xd3\x97S\xc1\xb3\xb1\x01\x0b\xfauV\x04\xac\xa4\xab@g\xe8\xbc\nUX\t\xba/fF\x13\x9b\x19\x15{\xd7\x82\x1b\x1b\x19\xa4\xfe\x1e\\9J\xcd\xbe\x9f\'\x980\x03\xfa\xfd\x94\x8fk\x1fH \xe7\x0b\xda\xa9\xd7\xd4Q\xea\xcb\xe0\x15c\xcbW\xc2\xbd\xf8\xad8\x0e&\xea\xa7\x08YN&\x984"\xcf\xc1\xa7\xdc\xa0\x1b\x828<\x1fB>|\x91\xb4F\xb4\x17\x1c\xe8\xa37\x92\xe7Y\x99\x94:\x90\x01\x96\xd8\xf0c?\xaf\x1f\xc0AX\x01\x99\xdaE\xb7u\x9f,\xb1\x87\x13>Z#\x1b\x14\xb6XR\xcfo\xb3\xad\xe8\xf8\xad!Z\xd8\x02\xc6$i\xba\xf1\xb8\x9b\xa5\xb6\x10i\x03\x92\x94\xa8\xac\xdd\x7f\xb1\xb3*\xf1\xbf\xdd\xd1\xf1\xfe\xad\xe5\xc8@\x0c\xfd\xb9\xa6j\xfbq\x81\xce\x1a\xc30v\x9a\xfazLZ\x07eSRi5\xec\x12\x97r\x19\xe9\xf3\x95\x0b \x1bjyq\xaaB=\xc9+g\x9clDw\xbaS\x91\x1c4\x1d\xe5_\x08\x17\x80J\xacMxRa\xa8\x81\xb2\x8cm\xf1`\x03\xf3\x92M\xa9\xf1\x1130\x96\x85H\x1d\x17T\xa2d\x05r\xe0\x01\xcb\x9fq\xf4\x7f\xdd\x10\xc3\xb3\x1e\x12\x12\xcf1\xddvn\xe2E\xca\x16\xa2\x83z\xb3\xdd8B\x069\xb3\xdf\x8c\x193.\x8eX\xb4\xe9Hg\xa1\xbeN\xba\xe0~\x9b\xc7\xf9\x91\x01\xe1\xbb\xb0\x97\xa6\xb9\x9eu\xd0\xcb\xf3V\xebW\xb2W.\xf0\xa1]\x13\x87\xe0\x93\xd2\x05\xa2\xe26\xa9\xdb\xfd^8\xb2,"\xdf\xd5\x1a\x9e\xcf\xd5\xc9\xd3\xf5\x97\x15N`\x16-\x9d+\x02\xe6Eu\xa5I[\xe5qc\xdcw&Q\x0ba\x1c\xcdF\xea\xe7G\x11]\x0e\xa56\xab\xf1X;\x906\x9c\xa0_$X\xeb\x0faU\x1bw\x92\xb2\x89@V"(\x07\xa6\x01\xd67"E\x8f\'\xf8\xaa\xea\xdd\xb9\x99\xa0\x9c\xfa8{z\x90\xce\x1a\x086I\x162\xd8HcHD"$\xfd,q\x19pm\xa3\xdaY\x92T\x04\xb7\xbb\x83\xed}Mf\xaf\xba\x05\x1f\xca\xb7\x1a\x126\xe6\x87\xe9S\x81\x1c\xcd\xf3\xe5\xb6\xdb\xfda4\xaf\x97\xfb1I\x00\xf1\xcfWk\x8f\x96!\xf4i\xbf\xa71Y\x17\x89-9\xddsK\xb9\xcd3\x91\xfa\xd7\xf9\n>\x13G\x06W\xb4\xa8\xf9\xeew7WbLs\xba\xe3\xb0\xdf\\\xdb\xf9?C\x18\xc9\xf5\xe8\x07\xb6g;\x86@\xe8NL\xb9\xbb\x851\xfd\x86_\xffW\x16&\x1b=\x0b\tw\x13\xfb\x99\xab\xc5%\xceZ\x8a\xc7\xb1\xcb\x98\xfc\x9e\x1a\xe8\x06\xca\xe6\xfa\x14\xe6\xf0\x85\x93F\t\x18\xaaP\x85\xddw\xecA\xfb\xf1f\x15\x93\x06X#mpj\xfdnj\xc1g\xa0\xec\x8f\xd0.\xeb\xe6\x8b\x97\x16*\x0c\xe8\x9a2\xdc\xb1Z\xe7E\xbd\x1b\xde2\x88d\xd4\t+\xe9\xf4/\xd7l\x1d\x1fz\x96?\x8f\x01\x9c\xfc;~\xf7,\xf0\x01\x9a\xb8N\xf1\xd5\xd4\x06LI\x1dUb\x9b\xce\xcd\x93\xba?\xc0\xaf\xf3\xbb\x1f\xd2\xc5\x0cb\xb9+\x84\xb5@\xd0\xfc\xcb\xe5\xacE\x97\r$GJf\x12?\xf4/\x08\x19K\x11\xc5EC??\x8d\xbd\xf2\x0e\xad\xc0\x8f\x057\xf7}\xba\x82\xdf?\xc6\x8b\xeb\xc4\xdc\x12\xe9\xcc\x7f#5\xa1\xcdp$\x893\x17\x10RE\xcax?\xa9A\xf0\xe5\x9f\xca\x01o\xb8|\xd7\x1a\x81D:PM?\x02&\x18\xedu\xf7h\xe2\x98\xde\xe0\xc2\xc4\x83\xb6W\x84\xc6\x9c\x8e@\xe4gbF\x90\xd9\xe9\x1e\xc1]|\xee\xec.\xda\xc6\'\x7f\xf0-.\xdfj\x00*\x03\xf9\xae\x15z\x9e\x83\xa3;s\xaak\x01G\x86\x1a\xa4\xe9\xda`Y2fx\xd3\xe4dF\x97\xe0\x1b=\x19J\xdd\xfd\xba\xf9}D\xdabt\xe5\xc7\xbd\nc \xbav\r\x19eK@\x02\xaf\xbc\x1f\x8bm\xcei\n\x1b1\xd1F\xe8\x92\x8d4\xa3I\xe2\xff\x9c\x03\xe7\xfa=\xf85\\<\xc3\x16\x1bN\xfd4\xaf\xe8\xca\x9c$\xd5Fo\x96\t\xb9&\x1c\xd3\xfb\x9b\xa0YV\x08gd\xa9\x7f2\xfc6>\x9f\x1c\xeeE\x08\x0f\x95\xcf\xa0\x05HD\xd6\xb7\'\x18q\xb5\x13\x1c\xa5j\x96B\xb7\xf73\xe7\xc9}\x03\x1a\xb4.\xec\xd5\xbc\x92k\x9e\xfdWE\xcd5\xc6\xeb\x7f\xbb*\x80\xc2\x18\xaf\xda\xd6\xc7\x1b.\xfeR5r\xde:\xe9c\x14=\xd2\xc9\xf8\xb5\xad\xe9\xcd\xdf\x9fI\x15\xecL\xder\x0b\x8c\x829YZ\x83\xde~\x03\xc2\xf4\xa8\xab\x8f\x10\xfe\r\xf4L\x0b\x86bP`\t\xfe\x13$\xd0r\xd8l\x06\xac\xe7t@n1\x1b\x1c\x9a\x86aD\x83\xec:M\xa6a\xb2\x8e\xc9\x7f\xe7\x93\x0e0\xcby\xe8\x08\xcd\xde\x9c\xa3sV\x83\xa0`\xa8y\x90\x1a\x91X\\\xbb\xa4\x0e\xe3F\x905p\xd5\x9e\x94\x8d\xb56\xdb\xa4\xdeX\x93\x95|N^P\xe1N\xbdQ\xc9\xfdhl\xb2\x98\xdeg\x0f\x87\xe3&N\x81\x0f\xba\x17d{\xc4\xdbY\xee\xc0\x07g\xe7Z\x07s\x04\xa4/\x9b\x0e\xc0\xad\xda\xb6\xe0\x01\x11\x9e\xb4\xa0\xc3\xd2\x97\xe4\x989\xf0\'\xd7\xea\x91v~\xbe\xc6\x01GR\xd5\xc2Bf\xf1\x9d\x03\xd6\xfc\xb6\xbb\xf33\x189~\x0f\x97Fa\x91p\xb7\x7f*\xb50\x91\xb1\xe62\xfb\x89Xl\x8c\xcc_\xa6\xdd\xd6\x81\x03;g\xe8\xae\xbc\x86\xc9\xc6\xaf\x15\x03l\xc8\xad\xdd\xf4)\xa88\x12\xb6\t\xe3\x82\x97\x06\x02\xb4\x90\xd9P\x82!\xff\x0e\x99q\xd3\x1cIBb"\x8b\x95!\xba\n\x95\x92\x1eFu_\xef\xb3\xc4\xdc\x0f\xb1\xc6\x07\xe5s%.?v\xa7\xad\xea\x15b9\xbf]\xf7\xa0\x89G\xc9\x1a\x95\xb4\x9e\xe0\xd2\x08\x0c\xfeg\xf5\xa7_\x93\xdd\x7f|\xe7\xb1\x1a.\x15a\x99\x05\x15\xf8\xceqj-\x85\xaa\xf0\xe3\xd3;N\x16I\x11R\xac\xd6\xeckW\xb4\n{\xcf\x1a\xd6#\x82V\xb5\xc1\x18\xbc\xe7\x89`\x7f\x1f\x97\x81u\xa5\xa71:\xe3\xberP~\xe5\x85\xf6I+\x83\xd8IN\t\xe5\x1fP\xa3\xdb\xd9w}\x10\xab\xa3\xca\x89*\x132\x7fl\xce8F\x12\xf8a\xdb\x17\xba\xbf\xa9\xe1\xd9\xd3>\xda\xf3t\xa1\x03l^\x94~J\xfc\xc1\'2\xd0\x11\t\x87uC\xfa\xef\x15\x7f\x8cw\xb5\xc8v\xadcd~\x8c\xc1 o\x86\\\x08\xf5\xc3M\xd5\xe1X,\x8c\xa6\x87W\xd2\xdet\x8a\xbaTcI\xbf\xa3\xaf\xe2A\xa9\xfaxQ\xda\xa6,\x10\xf2\xa5u\xc7i,\xf1\xed1\xdc\xe96\xd5V\xee\xda\x97\x01y\x94\xc2\x9d6\x1eQ|\xf6\xeb\xd94\xae\x81d0*\x02\x08\xf5g\x1eY\xa6s\xba\xden\x82\x9d:9\x1e \x11\x9a\x1e<\xc5\x7fs5\x80\x19\x90\x15Y\x00o\xbe\xf0\xbb\xc0\t\xfa.\x13\xc3x$0B\x90\x98\xb1\x19Qz2\x15lT\x86vQ\xba\xb7\x12k\xdd\x82J\\\xd2*\x9b\r\xa7\x0f\xbfn\xe6![\x96\xdb\xa4\x84\x0e\xcc\xc3\xde\x17\x93\x948/\x88#\x98z\xd9\x7f8\xf3oC\x0e\xd2\x8ed\xccc7\xde`^\xb51#\x07\xad1\nz\xc8G\xd6\xf9e\x91\xb5\x14\x1a\x1a\x16\x02\xcc\x97.\x97\xef\x19U;7\xee\x92\'\xb0\x05\x1b\n,\x8b\x886U\x9e4\xab\xc6^\x80\xec<\xbf\x08`\xa1\x14\xe1\xda\xd7\'\xd7[\xd3\x97\x1a\x8b\xbc\x06\x86\x84(\xcf\xf4\xcf\x07=\xbby\xca\x8b\xbfs\x99{|\xec\xc7\x14QR\x10\n\xdc^\xfb\xd1\xfd\x98\xf6\xbc\xad\xaf\xa3\x99\xb0Q\xe4\x15"2,\t\xc9/\xc2\x04\x0b@\xc7\x07\xbe\xf1P\xdb\xe0\x86\xbbQ\x1b\xd8\xf7\xe6\xd8U\xa3\x8a\xef;\x97\x8d}\xdf\x15\xd0D@[\xf2\xf0\x9esm\xa26@\xde\xae\xa5}\x0c"D\x8cB\x1c\xf7\x89g\xdd\x05\xd3N\xb9g\x16\x1du\x0f\xd0\x04\xc1h\xf5\xf725\xb2m2F\x97f\x87\xd7\xfa\x93\x1c\xdb-\xb1W\xd1\xc1\x90\xd1\x98\\\x1eA\x1e\xab\xda!\x96}\x80\xce\x17\xcau\xb8\xe6\xbb\\\xbb@\x0c\xd9,V\xdez\xdeh}\x85\x17\xbc:\x9fl4L\xa0K}\xff\xa9)jG;\xc0\tc\x9a\x92]\xdc\xf0\xb6\xe2\xabX\xear\x1a\x9b\xa9\x86~v\x08\x98S\xa8?\x83\x94\xe8\xf3tDt\\\xa3;\xa0\xfc\'e\x1eK\xd6\xf1Q\xd4\xb4\xf0\xf2v\xc0\x05q\x88 )=\xdb\xb7b\x89\xf5v\x16\xfb\x96\xb5\xc4\x18\x94Ku/\r\x1d\xb4\xda\x18>o\x93\xa0\xad\xbc\xf8\xb6\xd9GO\xbe\x96\xc5\x053\xa1\xe0\x7f\x1e;ir\xfa\x811\x8d\x02\xe9\xa8\x1e(k\xbc\xb5\x00Ta\x06\xaf\x1eHf\x9bbD\x9cz\x05\xd6\x0e(\x89!\xe23\x84\xe0\x93S\x0e\x8c\xd9J\xdc6\x96\xa7\xc4\x90\xfeO\xdf\xf2\x87eX\x86\x12[yJ\x8b6\xf0\xc9\xf5\x864\x834\x1f\xbf\x13\x9f4Q|4 L\xd5\xd1o|\xc2q\xad\xe1\xa7\xf4/\xb9\x18\x14\'6r7}\xee>))\xe6\xe9\xca&\x8f\xc3Q^\xad\xc1\x83\xa7\xd1\x96\x8845\x9b\x1b\xb1\x16=\x02N\xaf&\xce\x97\x83\xd5\x04e \xb9\xd4\x10\x15\x03BQ\x1bB\xfb\x05\xca\x14\x07b\xf4M\x19\x0f\x9c\xff:c\x82\xc2\xff\xbf\xe3\xdc\xe3\x8a|:?\x1fYp\xbb\x1e\x19\xc8\x00\xa7\x8a\xaa\x1cA*\xff\xf2Q<\x0b\x0c\x17R\xc6\x0e\xb07>\xfd\xac\x86\xe2T\xdf\x841\xaf\xaa\x87\xe3\xdaz4\xf9:\x18\x14\x9a\x98-\xe1\xa3#q:%\xc8\xf8\xc4m\xe1\xf4\xcb\x9e\x97\x8c\xa46\xb9\xe4\xb0\xcf\xb3\xa9s\xda\xd7\xda\xbc\xef\xa4\xcd\x10_\xd6\x19\x86_\x17\x17\xc2{\xba]_5\xa7\xe3\x1c\xb5\xa47\x1c\xff\xa0Hp\xc9\x97\x1bG1\xdfXi\x10\x881\xaaL\xb9\xbe8\x10ax\xe4\xd9\x05\x1e)N\x89\x10\x95\x95\xc8\xd0\x98\x01\xcf`rz\x87\x95qql\xb3\x13XQ\xbe\xb0\x9c\xd5l(~\xb0q\x0bCXL\xdc\xf1\xf2r\x96(\xfe\xc8\xc7\xb0F\xa8\xd9\x88|A\x00kE\xa2\xc4\x01\x141\xf7\xba\xfa\x947\xcfk\xe3N\x90\x11+/\xa8\xdc\xba\x8c\xf7\xff\x8a\xc0\xbd|{\xe5\xbe)I\xb5\x83\xf9J\x9c\xcf\x8a\x02\xe6\x9d\xbe\xd3\xd8\x97\xd8\xc5\xd6\x05\xf1\xc8\x16\xed\xeaV\xffq3N\xa6@\x95o\xd1A\xcb\xc4N\xa9t\xf0r\xc2\xf0\xd0\xdd\x851\xecK\x1b\xeeY\x8b:l\xb3S\x07/q\xd9M$\xef\xbd>\xb0\xaf\xb6BQ\x8b\x8e]b\x82l\xaf\x9d\xd9\xa4\xc1\xf8:\xd9\xa7\xa2sF\xae\xc6Q\x03I\x97\xc0\xe4\xc7\x82\xe6L\x11\xdb:\xdag\xbf\xb2\x83\x9a\x0flN\xe7d\x95W\xfc\xa3\xc3T\xf6\x8a\x18\xc3\xce\x14-\xccxk\x9b\xac\xe5\x07\x16\xf8\x8bP\xa2\xc1\xde\xd7v\x0c\x810\xdaW]R\x03z\xf1\x94\xbc|\xb4g\xbe,l\x89:K\xd7\xcf\xe3L\xb9\x94\xcf\xa5\x07Hl\xa0L\x02\xda\x96\xd1\xca\xc5\x0e\x82YJ\xca\xb4\x071!q\xb2Fl(b\xab%\xe1h\xdf\xace\xae\xab\x8d\x03\x10\x8et\xbe\x94e\xc4n\r|[\xa8\xc9+\xf3\xa3\xcd\xe6 \nH\xc2\x0f\xc1\xab\xe6\x99\x16\xca\'u-\x13\xe9\xb0y\xec\\\x0c\x18\xfci-\xcee\x18\xfa_\xdf\xb8\x9a\x8f\x1f\xd5\x8e\xea\x99\xf0\xdeGG\xa5n\xebt\xe9\xf5\r\xa4\xe5\x8d|J\xd3s\xbd~\xb4Ek\x06\xa6\xaf\xf19\x9f\xc5\x19\xb05\xb9\x95\xfd\xe7\xd6m\xdaub\x17r\xb0\xeav\xf1k\xa4\xe7\xa1[R\xa56\xb8\xfetU\xaf\x93{3>\x97\xea\x0b\x99\xb9$"\x97\xe0\xd7\x8e\x16][(\xcf\xc3g\x14\x02\xf9L\xea\xbe\xeagj\xc7Gh\xbb\x06\xc1\x9b_\xe3\xc4\xf1t\x04@\xb7_hG+\xe9\x19\x1f\xa4\xb0i\xb8\x8f\xa5\xff\x91\xfa`kf\xab\xbfv\xb0\x0fCS8\x86V\xb9\xb5\x0c\xb1\x06\xe3\x1f/?\x92\xb2\xba\x0c\x11\xd3(q\x9c\\-;\xdd|\r\x850\xabA\xab5\xce\x0c.\x05\xe1\x12I\x89\xee\xebuJ\x02\xab\xcf{\xe9\x08\x05E\x07\xa9j\x936\xa6wA\x19x\x8d&\x07\xfc\xcf} 5\xf4G\x8c\xa1g}\xeb{{I\xf4<\n\xa7n\xca\x8b\xb1\x15K\xc1\x8d\x8d\'\x8dB\x07\x90\x96\xdc\x8d\x7fxO\x1e\xcf\xcb\x89\x7f\xbf\xc4\x9bv\x06\x0f,Z\x99\xa9\x8b\x9c\x00\xfe\xcf]W\xa2\x1dB\n>\x0f\x18\x88\x9c\xb6\xb3\x07\x12\x9b\x19d\xc7\xe47\xb9\x0b\n\x14\x91.0\xcb\xd9\xc0\x99B\x19\x02\x0f %\xed\xdd\x95\xb1\xa5\xc2\xad\x87%\x9c\x14\xccx\x0fxK\xde\x01\xe0\x98\x87\xa9\xfc\x0bS\xa7\xcb\xf2\xd4\xce\x87I\xb6\xec*\x90\x13\x91\xdbK\xaf\xbd\x91=}\xb4\xf3\xef\xf2\x8d\x14{\xb7\x04\xbb\xd7e+\xfcyUv\\\xd5Hi\x1c<\x02WH\xa9\\^\xef\xa6\x9a\xc1\xc35\xa1q\xf4\x91\xfeO\xe7/\xb7\xc8\xb8\xfbPx|O\x07\x07\xab{\xaa\xa3k*\xa2s\xb9\x0c\x1d\xf7\xf77@C\x9a\xd51\xb9\xa8\xe75y\xbft\xc6}\xbd\xff\xc9o\xef\xb6C\xda\t\x17OR\xef\x9eFf\x0e\n\xe5IS\xa0\x1b\x177&\x88}\x1a3\x8e\xef\xa9_\x958\x1c\x88\x83\x8e\x7f\xdf>\xd2\xd8\x97\xe4H-\x9f[\xa2xsw\xee\xe5;F\x83B\x08M\xd1\x9e&ws%\xf1i\xbe\xcd\xbe~w\xaa\xfa\xe5\x9cx\xaa\xdc(\x16\x99\xed"\x1d\xd8^\x94\xfc\xc8\xd6j\x95<\xa3Z\n\xb7@\x13\x0e\xe4V\x9bO\xfb\xc7\r\xed\xac\xda1\xc6\xe7\x04\x1e5\xcd\xb7\x9f\xfb\xc3\xa1/\xd0=r\xa1\x89\x83@\xfa_p\x8a\x83\xe2\r(\xc4\xb9\xdb\x9b\xd0:\xdc\x9c\x82\xfc\x9d\x16\x05\x95Aj\xb4\xab\xc1>\x8d\x94{\x82\xdd\xe5\xe1^g7\x978\'\x87X\xf4(P\xe3\x00\xd59\xa6\xca\xc2+\x0b\xf9G\xb5\x83\xd2\xf3\x00\xa2\x1fs\x83\x0fC\x86 \x89[\xb4[\x1c\x80\x83\xaf\x96\xaf\x99\xf1\xc0\xd9\xb7\x99\x0c\x07A\xd2\xc3ES\x13$\xc4\x0f\x80\x19G\xa2`\x9c\xd4\xf5}\x1e\xdd\x08\xea\xf7\xb3G]c~\x98c\xdc\xef\x15?\x12\xc38\xf9\xc5\xf8\xd4R\xa2C\xa3N\xffaM\xbc\xb5=\xc5\xb2\xcb8i\x8b|\x8dw\x9aAG\xeb\x08\x06\xe3\xf36\xb3\x123q\xd88,]7\xf6,\x14\x8e\x95\xb1NZ\xcf2E\xa7|\x02,u\xd73^\xc7[\'\x1c\x7fU7R\xbe\xb7t\xd4\xac\xe3H}1q\xee\xbd\x11\xc9\x8eM\x10\xfd\xa3\x8d\x9b#\x14\xbbK\xf8\xf9\xb1\xf9v\x8e\xaa\x92\xdb\xffR\xe8\x80L\x98\x98\x14l\xdcs\xbab\xfc\xa3\xcd\xd9h\xf6\x84\xae\x11\x8f;\x8d\xf9\x1c\xb5n\x15\xcbX+\xb2(\x8fVqe\xc9\xa1\x1cy0\x13bI5\xfd\x13\x8e}hm~bns\xd8Ux\xf7\x9e\xe9\xf3A\x9d\x08\xc9%\xe8\x19q.\xd2M\x06\xa2\xe9Y\x88c\x0e\xfca6\xfck\xc7\xa4\xf5\x9a\xe7[Z\x95\x0f\xb7E\xf5\x0f\x8a\x81\xd5\x16\x80\xea\n\x85p\xafaQD\x03S1\x7f\x05\xf9\x99}\xa4\x86\xcae,\xb0Lk,\x0f\x9e\x17\x1bvD\x90\xf7\xb9\xe8P\xaf\xeb\x92\x02\xe04\xd0\x90\x9d\xd77\xfe\xe0w\xb7i\xdd\xc9A\xfc\x85\x80ao\x91.y\xe3\\\xeb\xb3\xca\x0cL4&\x1b\x94\xe8\'y\xcdA\xbd.8N\xb3\xcf\xeeR\x84 \xdef\xe3\x9c+\x99\x7f\xcb\x16N\xb4\x1e\x136\x9c\r\x89\xb5*\x86\xf52\xe8\xbe!<:j\xaf\xfb\x9d \x02\xb8\x1b\x81\xa0.z\x16Z\\\x8a\xac\x91\xad\xf3\x9b\xf2L\xdd\tz\x11D\xc4\x9d\xdf\x15\xec\xfc\x0f\xb4\x10\x13\xec\xcbyH>\xcb\xab\x88\xd4\xa9\xb8\xa9\x9c\xb5\xa1E\xac\xc8\x15=\x8e\xe6\xbb\xa7z\xa6a`v\x92Hy\xbfcf\x02\xa9\xa2\x9aG\xe9?Q\xd7\xedp\xe9\xedG\x0b\x04y\x89\xc1\xc3\x87)\x84\xf2\xd1\xef\xd9\x92\xe4\xb2]\xe0\xf1\x1aD\xca8\x07\xe8\x7f\xdf\xefv\x83[>&\xee]\x02\x16\xcb\xe4\xed\xea\x88l\xb7]j\x9b\xda\xdat\x8e\x06\x91.\xd8-O\x17B\x1f\x12C\x18\xaa\x95\xff\x9c\x1a^\xbf\xcc\xa3\x18+\xd9~\x1e\xcb\xb2\xfd\xaeke\xc7 \xa5\xee\x87\xf9\x04h\xca5p\x96\xa23"Pn\xa7\n\x8aD8}\xa7}\xb6\x97dN\xb2\x07\xb8\x90\x10\xb2\xe3\n\xe0\xf5e\xe5\xfc\x8cbL\x87N/\xec\x95\xa8l\xc0\x0b\xd7\xd2\x1a.9\xe8VJ\xa2<\xd6t\x02=Z\x975^\xfe\xbe\xce\xcf\xcb\x1e\xc3\x1c\x8e\xfa-\xdf\xf1\xf8\xa77h\xf0L\xf1\xaez\x9d\x80i\x90-\xe4\x1cCiM~\xa6\'\xa7\xad\x1dM\xe8c\x01`\xca\xd8\xd5S\x83\xd6\x0e\x0f>\x8b;^\xe7Z8aJ\x83\x86\x07\x17\xaf\nt\xb9\xf6\x89\xa8\x8c7\xfdy\x7f\xf0\xc4\xe4\x81\xa0\x87Q\x9al\x0e\x1a9dI\x18\xc8I^\xad@6\x90\xc4\x18\xae\xae\x14\xc8\xdc\xc9W3>\x04\xe1\xa8A{\x10\xf1\xeb\x05CS\x97\x9e\xa6J\xd0\xaaN{\xd6\x88\xf9\xb6\xd3\x92R\x9e\xf2ZN\xe7#Z\x81-~\xacs\xec0\x07\x1e\xe9\xc5T\xe8\xf3\x92\xd01\\\x05\x9e\xa8Q\x127\xd5\xf7\xac^;\xe9>\xc59\x11z\xd3\xb2h\xe3\x863sb\xb3\xac\x98\xc7\xc8E\xa2\xca\xa2\xfcYvV;o\x99Hh\xeb\xe2\x94\x16\xeb\x06\x98\x05T\xaaN@\xea[\xf1\x17\xfc\x864v{\xf6,a?\x7f\xa4\xe9P\xce\x03+\xf7l"qV:\x9b\xdbG\x9a\xed\x82\xe6\\\x06\x0e\x85\xdc)\xdf-X\xc1St\x86\x93\xd4\x17\xdb\xcd\xbd\xac\rfHE\x9b\xa2\x05iF\x94\xbc\xab\x04\x7f\xf6\x980\xea\xd64\xdb7\x85\x8fo\xa8Y\x81"l\xc8\xc2$\x1a\x97q$\'\xaf\xf2\x92[\xdf!\x0f\x1e\x14\x1edf\xec\x08\x98|\x90\xf1|\xaf\x16d\xf4\xfe\xf4C\xdd\xc0\xef3LQ\xae\x9a%e\xd1,B\xd2\xe9.\x81t\x11\x85\xdd\xee\t9\xe4K\x03\x87\xe9L\xa7\xc9\\.i\xfd\x02P\x14\xdb*\xb5\x13C$\x1d6\xbbZ\xbfK\x04o\xdf\xe0s\x07[x\xc8\xa3\xb5\xd9\x1f\xd4\x01Sh\xdf\xa4\x07\n\xd9\x12_\x8e\xa6\xdb\xcb\xd7af\x86,\xae\xb3t\x91\r\xda\xdc\xe0\n\x91\xc3\xc0\xc6\t\xd5*\x9b\xa5\x8f\xb8\rG\xa9H\x8e;\xb9\xaf#p\xf1\xaa\xaf\xa6\x86\xf7\xcf\x92\x04\xee\xc4\xec\xeaL\xf0\xa8T\xa4r\xe8\x87L/\x0e\x9a\x91\x14$P\x8f\x0c*\x98\x81\xcfrD\x14>,a\x03c\xb8G)\xb8J\x95Hc\xdf\xc6\xcc>\x0cM\x18TZ\x81@\xee\xf6\xf3\xa2"=\xfd,\x16\xe7Jb+\xecy[\nD\x87p->Cu\x95o\x10\x88\x1f5\xc4\x8d\xe2\xda\xbe\x95\xd5B\x91\x04\xcb+\x10\x00\x14\xc4\xe3\'/\xe6\xb0\xd5\x96;q+_\x1f\x0b\x05\xba\x81\x02\x12\x99\x86)<\xca\xef?\xaf\x8f\n\xee\x9fZ\x11\x92=\x9d\xd0\x8b\xd7\xce\xaf\xfc\xef$\xc4\xb9\xc75C\x91\xb9g\x03V\x05\x12\xa08R\xd0I\x9a\xd2\xe12>H\xc0!\xa4{\x801D\xd6\xa0\x01\xd1x%\x07\x93\xa9s\x9ak\x0cB\x00Q}\x7f\xd3\xef\xa4;\x11\xd97\xec\xd1\xc5\xc5\x9d\x13\xbd-\x9e\xbbe\x00@\xd8\xa5\xd1\x8e\xbd3!\xd6\xa2?\x94\x1c\x89\xd8Z\xf5\x80\x9e|\x96\xe1\xdfc\x06?dz\x8b\xb0\xfbL\xfd\xa2Ta\x9e\xa4\xfdy\x80\x08\xfd\xeb\x9a!C\xd1\xc9\xe6\xc1\x0c\x13\x13\xb2}\x19\xebi\x85}\xdf\r\x90\xa9\x9aa\xf5\x84i\x10\xef/\x13k\x1a\xde z\x12\xba/\x07>y\xb5\xda\xa7\xb7c\x84\x1dc\xf4\xe8\xbe\xfb\xdc\x99T>\xa7\xbc\xcd(\x8bj\x15\xe2\x97\x83\x03\xb51\xc7\xe9g\xd8\x0c@\x00\x1bNV\xeb\xd6C_\x9e\x85\xfa\xab\x02\x87s\xbb\xa1{\xff\x10o|\x91\x8b\x9a:p\xc1!\xd1\x863\xf4\xf1\xe0$\xdaN\x07\xfbJ\x11WL\x07w\x19\xde\xad\x98I}+M\\U\x9c\xffA\xe8\xff\x89\x8d\xd0U\xe9\xdf\xa0vp\x90\xa7\x9c\x91\xd6\x1bN\xa2\n,\x0f\x15\x01~\xa4^G\x1eH@\xf0&2\xc2\xf8\xda{\x1c-\xcf:\xb8\xfc\x0bvB\x19\xd5"\xdamb\xb2\t\xb6\xc9\xa3\x98\xa2\x00\x85\x8b\xdc\x08\x80\xa3F!\xe8\xa1z\xdd\xa4`\xec^R\x08e\x1a}\xf0\x02\xe7z\xb7=\xdb\x0f+\xbc\xb2`\xd2\xa0\xa7\x83\xb8e\xb9\xf1\xe4\xf8,fc\xe87\x06d\xfaE\xc1>\xaf\xe7\x16\x80\xa1\xda\xf7\xfb.e\x7fS\xb0\xc2\xc4\\S\x97=\x06Oo\xa2\x8a\xc9\x85V|]\xd6\xac\xedr\x14o6\x85\xbcDV\xd2c\x95c\x18\xb7\xf1E\xf0P6_s\xd9\xfd\x01\x89\x81\x8d\xbbA\xabU\xfb\xa4\xccA4Sh\xadI\x88$W\x96\xfdY!\xde\x9b\xf9\xb4\xfb\xfe\xc8\xb0\xbc$\x05\xa5\x00\x1e\xa6\xba\xa4$\xd8n\x93"\xe0\xaeh\x9e\xcf0\x105\x061\xe6\xea\x99u\xe7\xbat\xff\xc9ZHo\x10\\.o\x05|\x04p\xfa\xc8\xce\xdba>\xd9c\x91\xcagS\xceH\xad\x16\x02\x82\xb8t9O;\xe9\xdaH\x96\x80\x1f#\xbb\xbc8\r\x99\x9f.\x12\xc7B)~\x17\xf7\x90S\x04\x173\xff/j\xcd\x1f\x0bID\x81\xb1%Z"\x1b\x1bIr\x9d\xad\x9cu6\x98\xa00\x1d\xfc\x8c\xb7\xce?\x00\xd7\xf4\xf8\x1c\xe0\xf3\xe9\xf6\x8d\x1b\x87\x9d\xc9\xa3\x82\x85\xef\x00\x10\xe0\x8d\xfc2\xe0\xd5\x13x\xdb1p\xf6\x8c%g~\'f\xd8o}\x91\xd7~eT4\xec\xc6l&\x87/\xf7a\xbd\xbc$u\x87\xcf\x98\x14\xd0\xf4X.\xe4Y\xdd\xfd\xea\xf5d\x02\x85\xcc\x82Tf\xda\x8f\x88\xae\xceU\xa1`\x1d\x9f!\x91GxA,\xf4\xc2\x84\x92\x98\xdfs\xab\xba\x97\x98\x80\xa8G\xde\xd4HY(\xc2\xa9b{|:\x0e93\xfb)\xe3[~\xfd|dPb\xc4\xba\x92\xb9\tr\x0f\x05MJ|B\x0bZi\x89\xbc\xf4\xc6\xaf\xe2\x0c\xc5\xc5\x02\x86\xb3\x8cw2\x93\xc5b\xd5\xc6\x8d\xe2\xf3{\xb4|\x8c\x98\x81\xc9#\xae\xfb\x81\x19\x89}+\xfb\x1a\xab\x874J2\xa1K\x16\xe3\xa9}\xeas\xb4>\x82\xc7\xf1\x97\xfa"\xea\xf9\x10\xa5\xa9\xf4eVkXh\xceq/b\xf5\xd1\xddH\xd0\xefl\xdf\xe1\xa2t\x1fS\xfe7\xa4\'u\xeb\x01\xf6\x93\xe9<\xf9^Z\x9cw\xd3\xed-\xe5\tPy+\x19:\xa1N\x00\x953v@}Yc\x91\x1e(\x18[\xf4\x7f\xf9<\xaa\xe1\xd8\xce\x93\xec\xf2\'\x9e\xf9\x13\x04\xbeO\x0f~JRsH\x8f\x8cu{\x8f\x9eHq\xf2P\x1frD\xc4\x1a-\xf9\x05!\x16\xd8\xe6r\xb0\x87\xe3mi\xa2\x91\xeb\xe6\x91\x83A\x07l\x9d\x1b\xfba\xd5\xf5\xa8~\xe0\x05?\xc5]\x04b\x89\xc7\x00\\\xac\x0eyx6\xde$\x07\xce\xfc\x1a\x9f\x9a\x13S\xb5M\x87\xfc\x0fA\x12\xa7[08\xa1\x0b5\x0b\x9f\xff\xcf\xdb7\xc3M\x0c\xf04\xf2\xcb\x8e%@dj\x97\xf7\xd8\xa5\x98\x82P\xa2\tU\xbdp8>\xf5|\xfe_\x88K\xe1Fs\xd6Y\xbe\xcd\xef{\xe5\xddjo\xd6L\xb8L`Aq\x88\x06\xda\xfd\xdf\x80\xd2l\xeb\xeep\xe2\x94\r\x9b\x85\x9f\xe4A_\xbf\x90]\xbb\xed\xd8\x8cl\xd7\xab\xfd\xf4\x06BI\x93\xfaF\xef1\xc4 \x8c5\xf4\x93Diu\xb7:Lr\xb9\x92\xc3\xd8\xcbO\x11\x85\xef\xee\'\xedZ\x87oa\x1f\x8f\r\xda\xc3IjCv\xe5\xeb\xf7\xd99\xf2f\x02\xbf:\xc9zv\xac\xe9s\x83\xf5\x9f&\xeam\xf7B*n\x1f[1\xc1\xf3\xb0\x88y_\x87\xe6\x85\x92\xfe\x06^n0\xac-\t\xbc\xaf\x8b&\xf7~\xbf\x9e\xd3\x1bB\x92\xa2\xa9\xad\x99\xf1\xa9rGG*D`\t\xaf\xe7\xb7S\x83:\x90bp\xfc\xc3U\xbc\xec\xcbN\xe9\x1f_\xb9\x87ba\x97\x18(}\xd4}|\xe3T\x91\xcd+\xf3"6\r\x13\xb9@IP\x1bsysh\xf5}\xebD\xde\x98\xac\xf3\x81Z\xf8\xb4\xde\x12\xef\xcc\xecQ\xf9%\xa7jT\xa5\xf3\xeeja\xd0\xbcAZx\xd7j\x9c=\x13\xa8c\xdb\xaf\xb9qp\x17z\xba\xaa\xf7XM.\xad\xb9\xf9`,\xf7B\x19\xa5\x9aMQ\xa3\x11\xd5\xb7E.X\xa7\x83\x80v\xd2\xcf\xd6B\xe4OVD\xff\x94\xca\xfa\x8b\xf2*\xdct3\x8f\xbf\xd8\x11\x93\x11\x0e\xf7|\x94j\xb2\xf9%7E\x13\xab\x8a\x83\xe5T\x08\x95\xa4\xdc\x10\xacFn\xc0P\x1f\x93\xb8\'\x98\xc2\xdf\x01\x9f\x8dI\xa8\x86IJ~\xc8\x92I\xc0.\x86\xeb\no!\xa1\xf3:\xf8\x8cRv\xfdm\xc3\xe0"u_\xa69u_X\xe1.\x1d\xfeG\xb9\x8b}M\xfb\xcc\x1aw\xa6\xea\xd9-s\x9f\xf4\xadk\xae\x87\xfc\xa6N\x84 Z\xca\xdc\x11\xa6_\xd3\x9dR\xbbs\xdc\xe5\x8eI9\x1a\xcd\x14)\\\xe3#\xad\xec\xc5\xa7\x0c-}N\xbb!\xec\xc9^\x15R\xd1\x92\xd9;\xc3\xd1X\xaahZ\'n4{Sy\x1b\x7f\xd0S+\xf4\xe9\xd1\x06#y\xb0\xbb1C\x89D\xc9\xfc<\x81dW\x16\x10\xe9\xd3\xa3\xe7E\x18\xe6fE}\xd1s\x1ab\xa2\x8f\xf7\x13\x8d\xe8\xd7)\xdeoT\x9b7@p\x0bq\xd8}\xe8J\x14\x91\x1f\x01L\xabn9\x97\x03\xd3\x18\x94\x98\x9c\xa7E\xcasw[\xf1\xcaQ\xba:\xc0\xf7\x8a\x8e\xe1\xd2\xf3\x98\x05\x80\x0c\xa8\x8fd\t\x8fs\xb7\x1bf(p`9Ud\x1bM\xfbU\x9fmh*\xd9:\x89s\x99Y\x97\xf4\xc6z\xd0\xf0\x87\x7f\x98\xb58\x87\xc2D4\xa9\\\x8fT\xd43Q\x96\x13KMTvu\x1b\xb9e\x9e\xaf\xc14\xd9)\xc7r\xb3#\xe5\xcb\x15\x92\x03$=\xbeyu\xb4=\xf4\xb5\xaaP\xba\xc8\x17\xe9}\xb8\x1e\x9e\x17\xed\xe1\x034a1\xbb%Ita\r\xae\x8ct\x92\xe6r\x1c\x89S\xd0i!\xf8\xa7\xa6\x86\x9b{\xe2\x9a|&\xb2\x0f\xcd\x1b+\xf3\t\x936\x81\xa1\xab\xc5\xf0Z\xfcE\x99Q\xe6\xd3\xe6?\x00\xc0a/%\x02l`\xb5\xda!L\xc1\xff\xee\x983\x1e\xe4&\x11g6e<\xf5\x07\x16\xe9\xb9\xf2jl\xec\x82\xe0\\\x93\x9a\x9f\xc5\x1a\xd6\xe9\xb0\x8e\xfe\xa7mMYe|\xdbM\xff\x89\xeeh\x08\xb6\xf7\xdd\x9f\xf7E\xb7-w\xb15\ru\xdd\x1fd\xcf\xe1\xda\xd0\xbd~\x1a\x16Z0\x9d\x03\xbc|:4\x08\xf7\x0e2\x96J\x0cm/\xf0\xfe9\xa9\x0f\xfb\xc0\xb9\xd7%{\x87\x85\x12\xf8\xb9\xb1\xa3\xa8\xefh\xc3=\x05K\x08\xec\x01\ra\xbcG"&kR\x85A\xe5\r\xee\x8b~BS![:\x87eJj\x9b\x03\n\x9e\xc6\xc0.\xee\xd55\xb0\x11I\xb5\'\x8dU$0\x1e\xa5\xc9\xbem\xe1\x1b\x10+\xd56\xfcqd\xe0\x1b\x0f\xfc\xb4\xf07\xd5P\x87Rw\x0f4\xb3\x9b}!g\xaa\x9bAw\xc7\xa2^*\x8f\xe9\xb8\x07\xfd\xb5\xdf\x1c6\xd5\x1d\xad;`\x80Kh\xb5\r=a\xa0\xac\x10\xd7\xe2l\x86/O!\xa2\xb0\xa4\xbf\x8a2\xe0\xef7\xe1DT\xd9\xd4\xbb\xd6P\x83\xa4\xbez,\x85\xe6\xed1\xbf"\xc0\xeb\x9fz/\xbe\x96k\x0c\xe8_%\x10i\x07]\xca\xf2i\xf1#C\xf5g\xfc\xa7\xdeb9\xd8<\x7fH\x18\xe2\xf5o/qo\x1ft\x88\xcd\xb3\xb9\x13bW\xd5_\xdf\x19JN\x10\x97\xdb;SrT\xbd\x12)\xe4\xcf\xea\x05\xd9\xe4\x8cGM\xa5\xc5(x\x8b.wEH\x08\x7fR*\x86\xe7,MU\xcf\xe3faGl\xee\xabA\x80\x8c\xae4\xc0\x98\x92\xe3z!Bq\xeb\x8e\xcd\x9e\xe8y\x11w\xa4\xa6#\xe3\xed\x8cpV\x03\x95\xd8\xdcv\xbd\xf2\xd6Y\x93\x80\x90\xcc\x1d\x00\xfa\xeaKH\xbd\xd6\x81{nTc\x11|R&{W\x15\x8bI8\xa1\xbe\xdb\x94z\x0b\xa6\xf0\xc0&\xcc\x9e\x80$W\x92)\xed\x01\x97\xd0\xe9\x83t\xaa\x00\xe7>-\xb3\xe3\x11P\xdfv\xdd\xe1KP\x0e\x01<\xed.I\xb2?k\xdc\tRp(\xc2\x80t\xa0\xa8\x99\xf1\xf3i\t\x10\xae\x85pa\xcc\xccKB\xa6\x94\x9c\xc4\xd7;\xa8\xcdG\xfdO<\x92\xe8{F\x98(\xa5\xc4\x10\x1cK=\x82\x9cSHp\x9e\xc3\n\xaf\x1f\xee\xbb\x80\xa5\xf7Sf\xa5\x9d7C\xa3\xa6 \n\xa2\x90.\xaby\xc3\x17\xd6*\xb2#T\x15\xf9B\xbbv\xed/\x99BT\x8c\xba\xaa\x86\xadp\x9c\xf1\xec\xcdO.\x9dlFt\xf6#\x8aX\x86\xa31!\x1f\xa4\x00\x028\\\xdcC\x17\x83#\xedyg\x08\x10\xbc\xad\x08\x05\xbb\x89C&\xcd\xa7\xba.HA\x93\x1c\xd2\xe9;Q\x8c\xa16\x93\xdd\xc9Y\x1e\xd1\xd4%\x00e\xf3v\xd7?.\x111er\xa4\xf1\xb8w\x9080 z@\xb4\xd6\x8d\x89\xcf\xb9\xae\xf6\xf8\x18\xc7\xfa\xbd>\x9dq/O@q\xb3\t.\x83\x19\xd2\xfe\xebV\x03\xa0 z~MF=\x8e\xeb\x15\x06\x8e\x7f(\xf1\xdc\xda\xf5\xe7e\xbd\x90\x9dh\xeaR\x0bz\xae9H\xc3\xa6\x8c-,\xab\x1c\xa4p\x84\xdbEJ\xf4\x88w\xb4\xcfM\x05{\x11\xafG\xf4^t\xefl\x07\xb8\x7fO\xa6uo"\x98\x1c9\xa5\xa5x{b\xa7\xdb\x9f\xa0\xb5\xfc\x1a\xa0{\xf2\xd6\xff\x19\xb2\x8e\x07]\xf0A\x0f\xa7\x05S4\xb6$.\x8cbeapZ\xe9R1\x93;8\xeb\xb8\xf7\xa3\x056c\xc7k\x8caf3\xb8\xdc.MD\xf7\n\xc6\xd4\xe1h\n\x1a>`\x17>\xa0\xb4\xc5\xcd \x91\xec\x13eH\x0c\xafE(\xcbY\x96\xde\xa4\xb1X\x1dP\x1d\xb2\x10F<\x8dD\x9b\xc4\x94\xd8\x05\xcab\x8a\xb4\x9c(\x99(\x1b"\xbb\x0b\t\x9dC\x98P\xe9/\xec\xcb\xc0;gaXL\xe1\x90\xa4\xfc\xfcd\xd5\xd9K \x8a\xe7\x9d\x1eO\xff\xdd\xaa>\xd1P\xb5g\xfb\x12\x10\x85O\xb7\x07N\x9a\xb4\x08\xf5\x07\x10#4\xb4\x0fo=OB}\xb2T\x95\xe8J\xb06\nlF\xb5\xbe\xf0\xbc\xb1\x85\x10t\x16\xfd\x87\x1bMc\x133\xe0\x81X\x84<\x04\xba\xe8\xbf\xd8dx\xd9&\xfffu\x191\x9eXL\xd0C\x12\xbe\xa35\xd7DM\xfa\x87"\x1c\x85Q[\xba\xda8\xa5.\xc1m\xe3\x8c^ \xed\xdc\xe2\xb1\xee\x7f\xbf(\xeb\xe2,\xcf\xa3\xd4X\xe7o|\xcc>\xaf\t(\xb9\x10u\x8f\x1a\x991\xc4\x97\xe6bB*\x14Kti\xef\xd8\x96-\x19\xb3%\x0cl8\x0cq\xbb#\x1f\xcci\x1d\x03i.p\x0e\xfe\xfd\xf5\xf79\x1ft\xec\xb5\x13\xe5\x12I\xcd\xe8`?\xe2\t6\x94\xebfE\xee>\xfb\xec\xe5n\xcd\xcae\xcb\xb5\x95\xd5\x17\x86\xc1\xf9\xe5\xd3ta\x0eT\x86\xd1\x7f\xd4u\xb0\x02_1\r\x83\x9c`\xadU\xd0Q\xec\x9c\x1e\xea\xcf\x10_\xaa(G\x04\x9b\xd0f\xf7\t\xbc\xc4\xcb\x1d\xff\x08R&\xcc\xef\x15\xc1\xb2\xd6\x99\x00\xbay>2\xcc\xb2\x12\x164\xd0,T\xdc\x0bu&\xf3\x10\xe0\xc2-\x94\xb7\x81"1\xa8\x1c\xd9\xbcF\x94\x15\x9a\x0f\xbd\xe4\xa9P;\xc0\xa9\xfb\xed\xb9}\x7f!\x92\x1a\xb8H\xe2)\xdb\x8d\x14.~\xdf\x7f\xc1\xa9~\x14\xca\xde\x014\x81\xda\xfa\xa54\xc8\xcf\xf0\x9a9C\x07o+U\xad,lq/\r/\xea\xfb"\x83t\x16\xcb[\x9e\xe6\xa8\xb3\xf6h\ra\x12\x8fn\xc4\xaf\x0f5i\x16\x10\x8c"\x1a\\\x99Wp\xd2 \xa2\xa9Z\xee\x04d\xba[\xb9\x13\x03\xe5r\xa9\x08\xb7\x1c\xfa\x91zi\x97\xfa\x7f\xd0\xa0.\x1eT\xbe\x0b\xa9o\xa6\x01rG\rs.\x81\xd9\x93}\xe3\xc6(<\'R\x11\xa9/\x11Zy\x91\xc1\xf3J\xbf}\x14\xb3\xbd\xca\xa0\x82YsjpH\x1b.\xc07**\x056B\x1b\xf9\x96\x91\xc4U\xa5\xbdA\xb7/\x05sM\'\xb5y\x95N\xd5\xbc=\x18\x8b\xcb]\x8a\x81L\xdf\xaa\xabl\xc9\xc9!\x17\x80\x7f- \x94\xdfL\xb2M\xf9\xea8\x0b\xd78\xf7\xcbY\x85P\x1c\x9a4\xbf\xb2\x94<\xed\x91uC\xaa\xaa;\x1d\xb2(\xb3\x1e\xecG\xe4\x01Hu\xf3\xc8\xc1\xf72b+M\xbc\xa4\xf0eB\xbb\xfeb\xf4\x94Z\x8c\x10\x07\x06.b\x0e\xe1\x8c\xc7s\xe2\xe4P)Km\xe1\x03\x02v\x1b($\x84\x04J\x88\xe4\xbd\xa6\xeb\x15d\xbd\xebb\xce%9\x0f\xb1y\x1c\r\x8c\x8d3\x07\xe8\xca\x0c\x1c\x914(\x1b;\xab\xd07]D\x1d+\t\xf6bD\xbb\xe9\x032;\x07f\x08\x85\x92\xb1\xf4B\x05\xc8\x81\xd7\x01\x13\x02.\rQx\xa9\xc57\xcb\xff\xce\xf9\x9d\x19f\x06#\xea\xe7Z\x0f;/`\xa1\x80\x81\x84\x85\xde\xf7\x1d`\xf1\xfcu\xa84\xe7p~\x88\x1b=L\x9a\xb0\xd4\xd2\x97\xdb\x1f\xc8-\xf76\xac\'\xcd\x9d\xf5eT\xd9}\xb8\xe0\x98T7f\xf7\x9a\x1e\x80jI\xd1\x05&\x00\xebw]\x92\xa2\xc8Y\xc62\xca\xbbsq\x1e/\x00\xcb\xf0\x98\xfc7\xbc\xfd0`\xe1`IS@\x0f\r<@x\xac\xc5\x0b\xb2*\xb5\xcf\x9d\xdf\xa1\xdek\x8bW(\xdf$\xc2\x94\xb0b\xda\xdf\xcb\xd0RsD=8\xcb4\xe1\xae\xc4\xad@=\x9b\xd1\xf4\xbb\x04\x056\xf1\x15\xbb\x17-TZ\xa6\x12\xb7\xeb\x92#\xd7\xa7\xdf\xd7\xf1\xa8{\'\xb8ga\xc7=\t\xa7\xe9\xb0\xb7\xef\xe7+\xd4\x80\xfe\x90\xbe:\xfb\xc4@Xm\xdbv\xe9\x16f\xf1\xad)G\xe8`\x0b\n!\x91-U\x94Hr~\x17iI\xb6\x01\xbfA\xe1\xb7\xeeK\xab6tb\xbc\xff\x9b\xf5/\x86O\xec\x03elQ\xff\x03\'7bp\xda\xce\x19\xf3\xb7M\xce\x1f5\x8d\x1d\xc2\x14\xfe\x98qT\x13l\x1c\xaf\xabO\xfa\xb4Ljb\xc3\xafm\xd7\xc1\x896 \xb8\x13\xa52\x83\xd3h\xb3\xdd58>p\xf5\xcb\xf4\x84\x06\xae\xd8q\xacH&\xd2$\x82\x1f\xe6\x0c\x93\x1f\xa2N \'d\xe9J\x182\x1b\xbb\t\xb9\xc3k\xfa\x19\xc5\x80a\xa7\x1a\x1f$\x84\xc0L\xdc\xcf\xee\xa3\xde\x83\x0fk\xfd\xf0*\xb9xZ\x80\xb9Ea"4D\xd8\x1aQO\x10\xc7\xb8\x1e\xa5\x1f5\xf8\xaa0\xed\x13\x1a\x8e\x15\xdf\n\xe11*\xc57\xf3\tq\xc0$LdU\xee*\x82\xfb7\\\x88u\x07A\xea1\xeb\x12\x9cUX\x84U\x06OJ\x1de\xc1\x9b\x9c\x00\t&\x1f\x9e\x13L6?+L\x00(SE\xb4"k8b\x19`5A{%x\x06\xc6w\xeb\xaf\xc2\xc1~a\xbcA\x1f\x03vW\xe3\x8d\xcb\x9f\xa6\xc9j\xc9e.\xd0\xcc\xfb\x0cl\tH\x1b\x8b9Z\xfcoS\xd6%5iUU\x84\xc3\xbd\x8e\x8c(#\t%\xcf\xc1\x85\xd0I\xbf\xb2\x88_\xb6d\x8fh\xd0\x08\xc3\x1c\xb1\xa4\xb8\xdaq\xf5(%9W\xbf\xf9\x1bey\x9d\xe2\xecb\x03t\xa5p\xbcaL0\xcfc\x86\xafR\xb4$\x16u\xfd\x8d=m\xd2\xea\x8dS\xc6\xd69\xb9\x0f\xeb\xbb\xe5-\x97&\x05\xdd\x03\xca\xeaQq\xde\xeb%\x90|:\x97\x19\xe6\x8b\xb9\xa0\xf4`\x81O\x81\xb6@_\x0e\xd0k\x87\xa4\x98\x04B5\tX\xf0\x13&\x9c\xc2\xe4_ x\x961>\xafm\xa5$\x1b\xf9\xde\x87}\r\x82\x14\n\xb5\x95\x01\x1a\xb0\x82oS\xd3\x96S+\x84!\x88l\x1a\x92\xa1\xa48e\x0eE\x80\xe7\xc5\xaf\xa7\tK#|\xa2\x15d\xaa\x14\xd6G\xc6\xdb\xfd\x872\x84\xa0S\xcd\x0ch\xb4\xf7\x03p\x8d\xccK\xa9\xd8\x0c\tq\xd8;\xb9\xa5\xba\xa1\xc6\x8a\xf0X\x88\x8d\xe6_\xd5K>/J\xb6\x89\x82\xd7\xcf\xa8\xec\xe6\xfd\x15\xfet\xf2A8\x11W#\xc0\x16\x05=\xd5\xba\x82\xb9\xdf\xf1\x07\x8a\x10\x00"\x8eu\x81\x87\xf9\x1d\xe5\x18y\x958\x853O\x1d}F\xe9\x0e\xbe\xe6\x9ag\x19\xfc\xe6\x9e\x8e\x95\xbf\xcb\xcb\n\xde\xec\xa1O\x0f\x046\x1a+|ZT\x88\xbfT\'P>@#&\x11\xd4\xdc@\x81\t\x8a\xddh(\x15\xb4\nJKB\x13B^\x9e\xe0\xb3\x85cK\xfd\xb8\x9fz\x06h%\x88p\x1d\x01oVB\\!\xa7\xff\x977\xa6\x19[\x917\x06(\x1b\x04NkF\x12\x97\x16\xfd\xcas\xdf\x82)qni\xe57\x88^\x16(\x14\x8ey\x0b\n\x7f\x98\xc1\xbfd\xa3\x82\x01\x19\xbbL8.L\x0e&bp\x9eM2+b\xb5r\x8b\xc1}`\xd9D;{\x16\xe4\x0edQ*\x81(\xd3IN\x00\xd7\xc8\xaf$\x07\xe5Q\x9a\xe8\x96*\x1d\x8b\xa5\xbf\xf7_<\x0b7\xb8\x1a\x13\xc4m\xe1=\x80\xd3h0\xbdF\x7f\xca<,\tY\x99\xd0\xb4C\x12\xc6\xd0\xd8\x88E\x06\xe5Ot\xeb\xb2\xff%\xb8\xa8\x13\x1c\x9fI\xce\xb3\xc5\x0b0J\xd2fd~\xac\xd9\x92\n\x8d>\xfa\x9c$\xcc\x07\xa4\xbb\x0b\xd6\x1a\x0e\xden2\x03\xd3\xa9pK:\xd6\xaf\x18\x93\x8e\xdb\x95}0\xe5\xb2\xee\x80\xdby\x17\xbb\x1a\xb6GnhE\xc6\xa4\xf9\xec\x7f\x17\xf7N(x\xbc\x1c\x1c\xc1\xa4\xf2\xb4\xc8=\xd3\x9fc\x058\x1cDNo!\xbb-\xa8p\xdb\xef\xbbm\x8c\x0b\x15\xbb\x90\xa5\xf4\x8c\xf2 7\xf5\x18-)OT\xa3\x9d\xc8\xad\xd2\x01\x97`k\x84w\x8a\x07&~2L\x0f\x0b\x11\xf4\x87\xd9\xfeK+th\xe3\x1e`-<\xf2\xd1Sd\x18\xb2\x1b\xe3E\xfc\xfa\xfcr*bv-}D4\xa1\xe6d\x13\x8aP3\x16\x8c~#ugB\x1f\x87\xff\xe174^\xb9\x131z\xfd\x14P\xdecO\xb41S\xdf\x85@\x96\xc1\xaf\xf59\xe2\x82Y\xe7\xa0!\xca\x91\xab\xb8o\x84R#`\xb2aj\xad_w T\x7f\xf6\x99\xb6c\xb7\x8f$\xaf{\xf6\xc7\x1a\xfc\xefS\xce\x9b2\x99\xf9~\xecl\xbe\xcd\x80Sc\x974\x15{JS\xc3e\xc8\xfd\xb9s)\xafGx:\xec\xbf\xa7\xc3\x04\xd6\x8d\x00;\x89\t\xd2\xf5{\xd3\x92\xdf01\xbf\x00\xe7Mp\x8b\xfdd\xc3#\xc3D\xf9\no\xcbS\xfc\xa2\xb6\x8b\xef\x1b0R\xe7\xdb\xec\x85\x1c/f|JG\xd8)\xa5\xb5\x7fK\xa9n\r\x85\x91\xa2\xe2\xa7\xe2X&X\x1b\xf9\x93\t:\x12%h\x9f?\xbb\xaa\xf2@\x17+R\x058\x9e\x1c|\xe6\x16\xf56\xb6\\\xb1\xf8:(\x0c\xabp\xa7\x08L\x95X\xd8\xd6\x12[\xd1\xec\xf6\xc6O\xb4\xf7\x86\x9e\xee\xd0@\xbd\xbf\x82\xe2\x99\xe7\xc15\x02\xfb\xa4\x10\x8b\xbd\xf8\xcf\xad^\n:9\xf4\xa2\x12\xa9\xe8\x9f\x92N\xad\xf1<\xdb\x9dt)YK\x9e\xc0F\x7fW\x9d\x7f\x05\xe8Lq\x8f}\x9e#\x1e\x10l\xc9l\x9dhl\x0f\xa6M\xf6\xfa\xac)\xf8&\x0f>\xe2\xbco0\xfch\xc3\x87\x8c\xe7\x897\xf2\xac%\xc4\x15\x81\x16\x84\x1f\x936p\x03pi\xe4h\xdc\x82\xae\xb7h\xe8}d\xa4t\xacA\x1c\xc2\x88\x8b?\xb4"\x97T\x8c9\xe5\x96)\x89?>\xb3+\xb3\x98y\x17\xca\x03\xe5\xb8\xa3z\xa6V\x83\xc0\x0b\xb1\x07\x1a\xdb\x15h\xc5!V\xed\x93\xe2\xab\x80E\x00\xac\x86=\x81O\xdd[C\x84\xc5\x0b\xd9R\xc5D\xb7\xae\xa6\x06yc\xee[Z\x04\xd1\xb8\xee\x11&\x19\x8ao#\xe2\xdd\'\xe4zO\xcc6;Gd-3O\xa2^\xaa\x07\xcc\xc9uM\x96#>Nf\x82c\xa7\'\x06\x1a\xf1\x9f`\xad\xf4\xcf\xab\xdf]\x07\xb8~$w\x1bn\xd0V\x18\xb3\x1f\x14\x05\xce\xad\xbd\xf6\x0e\xe5\xabU\xd1\xefF\xab/\xfc\xffQ\x8e\x9c\xfb\xa7N\xca\xc7\xf9\xf2\xe22\xf0\xae\xee\x96f\xb4\x19\x8b\xd7a\x04\x06\xde\xd4\xe08\xc7\n.\xad8\x07\xb5\xa6kX\x03/\x1b\xbb\x04\x916\xa4\xde\xcc\x97\xc3\xfdh\xc9\x11\xb7\xae\x979Ue\x8e\x88\xde\x99"\xf9\xe3\x8e\xa3\xdf\xff\xbc\x98\xa2\xbfd\xf9F)ef*:\xe3\xc9h\x9a\xe2W\x13\xbc\x14\x98H\xb2.\x8f[\x1d~\xfc*{\xd7.\x1f\xaa\xf4\x9c\xdbT\xf1\n\xbf\x8ex\x98\x9d\x1b<,\xe2\xed\xaae\x11\xbf\x98\xf3\xafIq\x9b\xed\xdf\ro\xc7\xa7s\xaf\xd3\xfe\xbc\xce\x0b\xf3\xa4\x17\xebU#\x05k\xce\xc6.lI\x8f\xa9\x94(\x85\x174\xf6\xdd\xa9hp;\xa3\xc4\'\xcc\xf7M\xabf\xd6\xb5\xe4\xaf\xcbh\x92\xa5\xb2765\xecm\x7f\xeb\xee\x8f\xa9>\xe1)k\xc2\x12\xc9\xb8\x8f\xec\xed\xafT\xf2\x19\x87\xe1\x92\xd5\x84$\xe90\xd1\xd6\x87\x1d[\x1e\xb2.\xd2\x84$\xb1V\x8f\xe2\xdf\x977\xa4`p\x92\x17\xce\xd8\xc1m\xb6\x80\x84\xc0\xf8\x86{\x948U\xe3l\xd8;\n\x81#\xcd\x84Ur\xa8\xbd\'\\H\xce\xe1\x7f\xcf\x10l\x92*\x8aO}\xa53\xd3\xee\x87f2\x80k\xc1\xdc\xc9\xec!\x1f\xba\xd0%\xe3\x81s\x97\xbd\xe0\xe5\xb1\xec\x86\xa7\x94\x08\x9a2Pr\xab\x83\xcd\x8b\xf2*\xbc\x19ng\xban\t\xd83\x97Wg\x8a\x19T\xeaCfg\xfa"B<\xd8\x07y\xb5n\xad\x11[\xee\xe5\x98\xad\xcfM\xfe]W~\x7f\x90\xd7y4~\xbf@W\xfa\x82d\xb6sb\xb0\xe5\xa8\xe4$\x19E\xa4\x1f\xc5\x92\x9d|\xa2B\xef\xa60y~\xec\xe0\xc4G\x02\xd1\xae\xc3\xf6\xec\xa4\x97\xef\x98\xe9\xa4d\xac\xf5\x06\xc0\x85 *\xd8y_L?\xc3\xc5\x0b\x85\x08\xdd\x8e\xc1\x8a\x10hr\xc3\xe3\xeaT4\xdb\xae\xab\xd8\xe8\xc3A\xbf`\xee\x94\x1f\xb0\xe1\xc9\xe6p0c\x9d\xb2\x16R\xce\xb8\xde\xd2\xb9\xb0\x85\xb9\xdb\xa2[\x07\xfbuy\x8a\xc67\xd0Dc\x1a\xd7\xac\x0f%\x92k\xff\x07X\xf3\x92\xc9\xce\xe5ix\xa3G\x99\x1f\x1e\xe7)hZ\xa4\xee\xf2\xc8W\xec\x08\xae\x01\xd8}\xff"\x95\xb8\xd4\x14l\x0f\xdfv@8n\x0c\xc0aM\x0eE)\xd4Z\x0e\xac\xd9\n\x84w\x7f\x16M\xfd\xd00\x1d\xca\xfe\xf7\x87\xc3\x01n~\xcf\x83\xe55\x03IA\xa8\xaayM.\xd1\xb4\xc6\t\x02\xdb\xd6\xae\xf4Nx\x82\xffP:\xb2pYr\x02\x8f\xa1\x16,a/\xa8\xf5\x07\x8b\x98\xbe\x89\xf7#\xdfi\xbc~s\xa3\xbd\xd41\xa6\x01D\xde\xdd\x00\xb1-d\x94\x80\xa0\x1d\xe8\xd1\x83\xe6\xdb\xe0WRNV+)rg0I1\xf3\'\xde\xcc\x01\x07a\x0f\xb3\xe2Oz\xd8\x85jo\xeaj\xdag\x94\xc8\x9a\x103\x05\xd2\xc10l\xfb\xd0\xbb\xcd\xb6\xe7T\xacQB\xff\'\xa9\r9\xb2\xe6\xac\xf9\x90S\xd7\xfarA\xd6Z\xe0$\xaa\x01\xc1\x91\x9e\xbe\x8a\xc9\xfd\xfc\x1ax\xe4\xc5<)\xb6\x90l\x99\xa6\x06\xd7:l\xa4\xe5\xc1;\xf7\x11\xf7\x1d_\x8b\xfc\xbf[\xbd\x19\xa1(\xe8\x92d6\x0e:\xdf\xca\xb4\xc0O(!9\xba\xdbA\x95M\xf6%\xf6\x8cn\xaaj\xc1.\x9d\xb75I,\xa8\xb3\x11zY\xd2e\xcc\xd5\xde\x0f\x14\x81]\xedt\x89s\xf7V\xba\x9d)j3\x89RK\xea&\xd0\x01\x19\xb9\xff\xc7\xc9\x10\xde\xb7\xca\xc2Ln\xc1\xeav\xe5\x9d\x15%\xb2`\x17\xb5&\xd1\xd9y\x86\xa6-b\x04&k\x88\x05h\'\xff,\xf5{\xb1\x1c\xff\x98s\xf6\xe9\xff\xecCo1\x8dP\xe8Rj\x1f\xa1@b\xb1\x13Ht\x016\'\xf6\xb9\x95\xd6\x9d\x8b\xf7\n\xc2\xd0_\xe4\xc2\x89\xff\xc0\x0c]\x8c\x8b\xd7\x83I\x83-z\xb9\x1d\x8e\xc2^7\x96\xb1\xf3(i\xdf\xa3\xc1p\xa4\xd3c\xf0\xba\xd4E\x14J)~]\x97N\xd7\x8d\'H\xb4\x8b*U\xc9\xe1\x10\xfc\xe5j!\xdc\xfa\x12\xee\x14\x18\x81\x98\x15\x8cQ\xb5u\xa7\x06X@\xe7y&\x15\xc7G\xdck\x15\xc3?\x0ey\xc4\xc7z\xb9j\x93p\xe7\xeb?\xd5\xaa\xe4\xffB\xe4<\xf2\x04B\xf9\xa5\xb9\xc44F\x00t\xd1ga\xb4\x81e\x8e\x17\x1c\x01\xa8L0\xbf1z\x06\xc5\xe1\xb4\xee\xf9\x0e\xef\x83\xb2\xd9}\xbb\x90\xaf\x82\xe7\xc8\x07\x9cj\xd1(h\x1d\xc4JVfq\xc2xM\xe5\x85\xd7{\x9a]\x86\x15\xc0\x07\xea9\xe6/W\xc2\x88\xec\x87^\x13\n\x00X`w\xbe\'\xc1\x9ay\x1b\xcd\x9d\xa7\x02\xb5\xe4t]\xa1\xfe\xfb\xb8r\x07\x91\x10\xfc\x9d\xf1\x9eNL\xba>3?\x8d\x9aNV\x87\x14\x86R\x86\x19C\xf3\x8d\x03,\x12\xc0\x8a\x0e&._g\x03x\xed>2 \xc9Q\xf6r\xd8\xc3\x06\xd9\xf3\x94w\xd8&\x0c\x93\x97\x98\xd0\xde\xe9\xcb \x91\x03\x97\x07V:.\xf2q\xe4\xc0v\x8d`\x87h\x96~\x8b\xba\xa5\xa5\t\x1fI \x83\x11\x1a\xf8\xf9F\xae\x11\xcd?\xac\x1d\x05|\x80\x1f\xb8i\xa0\x01jm\xf9\xbbie\x01\x02\x84ey\x07nh\x86\xf6%\xb7!\xa2\x01\'\xff\xfeB,4\x11\x14UIya\xf5\xf0\x9b\xe8_\xe5\xa6%\xb2Qz\xfd\x01;\x89Rx\x82\xbfL\x0b\x10n\xb1\x83\xe7)J`\xea\xa7\xea\xc9\xa4=n\x9aL\xd0e\xac\x8de\'+R\xbb\xe1\xbf\xe9"=GP\x98~\x0f\xae#\xae\xb16z\x8dF\xaeOz~\x02!\xb5\x7f\xacG\x12\x8d\x83\x96C\xc4\\>\x1a\x00\xa82$\x00\xe7\xc6&\xf3\xf2\x87\xea\xcdLG\xb6f\xe97\xcb\xa4e\xc4\x1c\xcb\xe3\x17\x9c^^\xea\xf0UEr\xa5\xb9\xd0\xf3\x1d\xe0\xc0\xe7#\t\xb6y\xcd\x0c\xee6AK\xd0:\x9dm3V\x9f%\xe4\xab.x@09\xe4\xe7a\xd0\xbeq\x8e\xc8\x87\x83\x1b\x0e\'\x11\xd5\xc6j\xcb\x0ba\xf6"\xde\xee\x028\x12\xbc\xc3\xf4\xaf\xc1\xc7kO\x16\x01\xbd\x86\xd5(z\x83\x1c&v\xf8\x003\xbb"\xb4A\x06\xae\xe3\x95+y\xfe\xd4\xc9h\x1c\x00?1\x06\xe2\x1d\xf1\xa6]\xbb0\xcc\xfd\x038\x87\x8b\xb0WH\xc5\xcdSA\xe2\xac\x16\xf5[\xa2o\xe1\'\r\xca\xf5\xa4\xac$X\xe23j6\x16\x82O\xdc.)E9\xe0\x0b\x14\xb8\xff\xd12r\xe9\'d\xc7)\x1c\xc6\x86vN\x08\x16x:\xdb\x00\xf96\xbd|~\x07\xe4Xz\x06E\xd7.H\xa7\xf4\x16r\xde\x89&\xf0\xe8\x01\xdf3\'\xf9\xe1\x9a\xc9\xcfY[\xd0\x1e\x86\xca,\x7f\xc4g\x13\x98\x8dv(\x8d\x05\x8c\xcesZ\x04\xc4\x12\xa5G#zbl\x14\xee\x97\xc9\xa4:L\xbb\xec\xac\x80\xe0?:\xaa\xa8f\xf7\xf7\xfa\xe7\xaf4H\x01g\xfcS\r\xc1{A\xc5\xa4\x9c\xbf#\x93&\x1d|\xb2\xb8\x00\x19\xfd\xad\xa2\xf7\xb86\x19\x13\xb1_~\x7f\x9a\xc5c@\xbcB#\xa4\xc7\xd3\xcf\xaep\xc2\xc6\xbb\x84\xb5;\xf1$\x9ai7\xcd|uT\x19\xe4(k\x001\xa5\x8f\xe3\x15\x1c\xb9\x00Mx?s\xb1C\xc3\x91\xf9\x1f\xa0V\xfb\xc2R\xe4r>\xc9`Q\x1b\x98\x98gAQ\xa8$\xdc\xc4,\xd7\x88\xca:+\xd1\xb4M\xa7b\x8bg\x9d|\xe6{\xa6\x0e\x17\xaf\xb1\xaa\x945\x91\xe5\xae\xde\x91\xb8\xbc\rb\xb5B\xa05\x0fh+\xa4\xb3}\x99KT\xb6\n\xd4\xa5\x86@\x99\xce\x8f\x969\xa6\xea\xa0\xc5\xb1\x7f\xacLR^hq\x87pP\x86\x8baU\x9b\xdf\xf5Y\xd3=X\x91]\xecd\x1b\xd78\xd9{,\x0c\xa3\x9b\x84r\x0e\xebH\x84e8\xf6\xb0\xa5\xff\xfdf]\xa5N\xad\x08\xebjf\x19\xb2D\x14\xb4\x93\x1d\xc7\xb0B\x80\xa1n#\xc6M\xdf\xc9\xab\xdf\xc9BJrh\xca\xc60\xb3\x04(f~g\xa8\x9c\x16\x0c\nr\xb4\xeasY\xf6\x8fv\xfeDO!\xff\x8f(qB\n4\xd7\x08@\xdft\x9b\xd2\x1aS}\xe3\xd0\xa9\x8e`;\x93d^.\x08\xd8+\xcefg\x8f\x9e\xd2v\x97)\xf5\xf9\xb5\xc8\xdeU\x800\x1f\x13n\xaeAb\xa8\xf8\xce\xd4\xbek\n\xe2\x1f\xc4&\xd1\x0f\xe6;;\x80S\xf8\x8a\x048\x8e\xcd\xc1\xaaw\x85\x97XX\xf82`F\x1c\xa2\x01\xcd\xff\x1e\x14\xd7\xb4\x0f}WrLh\xed\x92=\x1a\xb4\x17\xb4:\xa8!V\xa05\xe2\x19\xc2\xb7\x16#\xe6\xad\xef\x88@\xee-\xe4f\xdb\x86T\xe4\xb3\xb2\x02\x8477\x84\x04kyz\x19WY>`$\x80\xae\x1f\xd8\xa2\xd4\xac\xd7\xad\xe7\x84\x06$\x9f\xd2\xccs=\xc6\xad\xca\xd0w$\xb3\x92f\x08u\xa2/N[/\x83#\x93\x03\x06R~t\x1d\x02[\xd3Flu\xd5\x83\x1f24d\xbe\x13~\x16>\x92\x86\x03\x7f;f\r \x84\x88m \xf3\xb8\xcc|\n\xb4\xf4\x0b\xf3jT\x9a#\xaa\xae\xfc\xfb\xeby\x93\x16\x03V}+\x99\xeb\xacq\xc9\\\xe4D\xf4\xb2\xcf\xb4\\\x13\xcb%\x1f\xf5\xde\xe9z\x07~J\x83\xb7\xa3\r\xed\xbfU7\xd1\xd6B\x15|\xc1\xca\x19E\xd8\xd8g\xde\xa2\x95\xecH\xfc]\xc9\x87\x07rpo\xf6\x9e\x0b\xb8\x98\xd2{+\x1a\xa5\xdb\xae|\xb3\xa8\xa4\x95qmv4\x8b\xc1\xd4\x8c)\x0f4\xf8\xb8\xa4U\xd0\xe3\xec\xb2\xa99\xeb\x94\xd5\x14>v\x047E\xea\x12d\xf4\x94\xc5\x90\x00n\xd9W\xbeu\tB\xa2\xf0\x8aC\xd8\xeaq\x9d&\xd2\xeb\xaec+1)\xaa\xa7\x1b\x90\x96\xa8\xe8\xde\xb0M\x08\xb2\xe7\x7fe\xa6\xf6u\x85-\x1a\xa7{\x06\xa4\xee?\xa2Oa\x9a-h\xbca\x96\xf2\xd2\x00?\xd5\xabz\xc9\xf5\xfb\xce3(\xbdk\x83\x15L\xee\xc1\xf4h\x01\x14k\xc6\xd8 \xfa2f\'^|\t\n6*\x17\x9e\x07\xc6g\x04\xa4\xef\xd5|B"R\x83v\x97\xc5\x0c\x9b\xb1\xc8k\xe7W\x11v\x9b\xce\x03\xfb\xacX\x0c\xc2\x17\xf4!H\xaa\x05M\x92e\xabj\x03\xb7\xf9\xa0\xe9r\xe6\x84a\x88tE\xe7\xeaT\xed\xc2\xfd\x18\x90\xf1\xd9\xfd\x1d\xcd\x8cp\xa5\xa3\xa7\r\x87\xc46\x0e\xbd\x96H\xa4h\x1eap\xd1\x1ao\xbf\xc9_#\x96\xc6U\xc7\xab\x852#\xc0Y\x1c?\xd3S\xd3\xd2P\xf2$;\x93\x97@^M/\x0b\x0c\x10\xc8\xaf1\xdb_/\xe3\xe2\xf8\xe1<\x1c]A6#/\x89\xf5w\xeb\x8a4\xe71%\xe5\xab|\t\xd8\xc7\xfb\xb3z\x18\x9d\x90\x89z\xba\xd3\x12\x9f\xd5\xbc\xeb\x96h\x03\xaf\xa5\x84\xef\xd0\xb0k\xb7\xf2\xc2\xdd\x96:WVR\xe6=T\x80U\xc8\xc2GC\x8ao\xc4\xb2\xa2\x0b\x92\x9d\x93;\xec43\xf3y\'\xb9\\$\x12\xcc\x8d\x1c\x1b\xdf_\xc9\xe9\x08S|\xd4[\xb6\x90\xcdglL\xf7\x80\xfe\x06H_ t\xd7\xc9$\xb2*\xb5&\x9d\xd8\xcf\xf9d+\xa5ZS\x17\xcd\x0c\xc3\xb2\xbb\x89\xd8\xe0\x99\x15\xf3$\x93K\xe3\xe7\xc3)\xdc\x90\xc1U\xf7g\xffv\x08\x87v\xa1v\xe9\xe7\x9e\x0e\x8b<\x08$8\xda\xf8\xb2\xc9\x81\\\xb9-\x04\x1c\xbe\xd7P\xf0t\xea\x14;B\x1bJ$Xg>\xd3\xe2<\xad_\xbaG\xe3N\x06\x91\xc9Z\xcc\x90]\xce\xe9\xcf\xaf\xa1\xbe\x7f\xf4v#\xc1\x9e\xc5\x98\xe4p\xb4~\x00i\x14H\xb3\x05\xbd\x0b\xe0\x10\xc5`\xbdI\xf4$F\xf6\x8f\xe5\xdb\x10\x03:\xd5\xc2\x83+\x11\xc3\x9b.\x88\x04q\xc3_x\xcf\x92U\xbb\x88\xc4\x93#\xd7V\x1b\xf5+B\xa8\xfa\xf4\x8c\xee\xfe\x0bOj\x82%P@\xe9\x8a\xb0\xf0=\x84e\xc6{`Q\xa3\xa4\xff;\xd9\x11B/\xed\xe4\x82\xa4mz\xf0\xac\xad\x19\xad\xd9,\x97\xf7bb\x86\xe6\xc4\xf5Z\xc3\x0f\xa1:\x8c\x92\x17\x19t\x02\xdb$O\xa5\xf5z\x86\x170?Fo\xe2\xc7\xca<\xd3M\xf4n/\xb8\xbd\x10\xad\x13\xcf\xc4\x8d\x1aR\x06\xabuP\xef\xd8\xf8\x18(.Q\xf7\xd31\x00\x02\xef\xd5lL*]\x99\xe7q\xfbo\xed\xc7\xb4)\xf4\xbd\xc0\xc95\x18\xa9\x18\xf4\x11z\x9a\xa6\xb3q&\xd4\xd7\x162\xbb\x92\x05|9\x14\xb8\xed\xe23\xab\xa8\xe8\x94\xca\n\xd1|\xd6\xf0\xd8\x1b\x17\x1e\xba\':6\xd6-\x85\xf6\xfb\xa0\x90er\x1e\x9a5\xf24|\xb3e\xca$\xa1\xac\xb8\xcf\xbd\xf9\x9e\xd6\xa1\xd2>[*\xea\xde\x8bsu\x1b\xf9\x92\xb8\xd3R<\x18\xce\xbcN\x8e\xf5\xb7\xb2-\xdb\xdb\xbe\x8f\x8a\r\x9er\x12\xe89_\x07\xa0\x980!\xa7\x92v\x9fG9\xef\xe2\xf5\xccuRa\t\xd5\x04\xbdC\xb1\xe9vV\xf3\x13\x1c\xc7\x02F\x1f\xec\xf5\x8f\xbc\xc3\x18\xbc2\xab\x1eg\x1evD\xad\x04P\\\xb1\x92\xe7\xd9\x13T-,\n^\xda\x9f\x9cy\xde\xfc\xda\xd2\xe0\xde\xc5K\xb9\rF\x12\xb3\x7f:\xaa\xe5E\x97\x1f\x84 \x90\x95O)s\xfb\xeci;\x84o\xb6Z\n\xab\x13tf\xc9\xc0\xdae\xdd\x96\x1b\xd7ZoS\xa8V\xda\xa1\xd4Z\x92b5\x93\xc5xa\x8a\x17\xc0&\xb0\xe4\xe3\xc7-!/\x08\xf3\xaf\x93\xf9\xddB\xefv~\x15b\xffr\xe1\xf8dn0\x14Y\x7f\x83S\x93\xed\xa8\x05\xdal\xab\x93\xe2\xb22\xa1\xcb\x8b\xc9\xf1\x1a3\xd4\x08Bh&\xdd\xbf\x02\xd5@\xc8\xa7p\x02[(S\x8f\x0bB\x8c\xb5@\xb3\x1dl\xe9\xaf4\x98\xc8\x9c\x8br\x9f\xa0Y\xfe\'\x1c\xf5\xff\x1a\xbb\xf4\xe8\x13\x00@\xf2\xcecU\x1c\xceU;\xf5\x14\x97\x13DF\x05F\x12\xb7?\xdb3\x82\xd5\xe8\xdbd$dD\x1e\xeeg\xdb2\x15\x97\x06=\xd9P/}\xbbEqm\xaa\x88\n\xc1Z\xc0(F:\x1e(\xc7\x93\x1d\xf7\xfftc\xf4O\xd8\xe4dN6\xcb5\xea\xcdF \x98(\xc2\xd1\xfc\xe7\x0bh\xe5\x93\x82c\xdc{\x03\x16\x06O;\t\xdf\xdbQD\xb7I\xe3x\xc2\x92jR\x92\xbd\xbd\x03\xf0\xc9\xa7\x1f0n\xceK\x98\xb3n\xba\nw^\xdfY\x9a\xc5\x16\x04\x10\x7f\xea\xc1\x85C\xa8Pg\xd1"\xce\xf7L\xbd\x16\xea\xd9\x8e~\x14d\xe8\x0c\xadNlI\xeayE\xcbg\x8b(\x15!\xa8p\xa9\xf6wY\xc6\xb0\xfd\xe8\xff6&\x0f\x1e\xf6e\x1c\xb1\x82\x00\x10\xc1\xd9?\xf9"j^\xa4\x88\xe7\xe4MU\x9f\xbf\x98\x92\x07e{\x88\xcd\xe8n?\xd0&\x87\x83Fr\x1c\xc6U\x02\xff\x9b0E\xda\x1eiu\x0f\xe7\xb9\xf96\xe4\xab\xc4xt*\xb3*\xf5\xc8\x1c|\xc6\xa65\xc3o.\xc7\xc9\xdfCc\xd1\xb4\x1a\xad\x85\xc7\x80\xedC\xb5\x8c\xc8\xafjBMe2\xf2\xdd|\xee\xf4\x961\xf5\xc6\x9b>\xed\xb8\\+\xc7\xe3\xfe\ru\xc37\xd0\xb7\xa01\xbaR\xfan\xc6\x08K\x90au\x83\xe5oG^\xc9\xcdj\x99\x86\x88XF\x82\x17\x93\x98\xe3\xd5!\xd3\xf5\xb1\x9fR\x1b\xf2\xb1\xda(|\x96\xd8\xeaV\xc0(\x925\xf4\xa3\xae\xe8\\\xcb\xab\xec\xd6G\xa08\xb6\xbf\xf0\x18\x83^\xa8\xf7\xd9wM\xc9\x96PF\x9c\x07\x93\xd1^\xdd\xbb\x8f\x1dj\xff\xd6\x832\x05\xfd\xe7\xfd+\x0c\xa5\xe6\xbd\x97\xe4q\x87\x97\xdd\xc2\xcbg\xa5>\x00\x9e\xd68T\xbf\xdb\xda\xc1$\x1ay\x17wO9\xf8S#^3v\xe6\x1f\xfe\x80\xcd\xa7S\xcc\xb3\xc3\x17\xaa.#mg}\x9e\x84\x07h\x00\xa9\xa8\x80Z\r\x8c\xa0/x\xbd\xe1\xa6\x8b\xbc\x14\xaa\xc9\xd4\xc6\xf5\xddTX\x10\xe1\xbb\xb9\x978D,\x06h\x82\x18\xed\x1e\xc6\xbb\x11\x11[\x92o8[l\xe0d\x12\x80]\xef\xe56\x86\xcbS\xa6\x92\x14\xdb\xb8\x04\xa5\x08\xf7\xad\x19%>d\x8d\xd4T\x83H\xf4\x07HM\xd3\xb1\xc7\x1a\xbcx}\xe9\xf4G\xda\xfd\xba\x1dB\xf5\xd7\xb6\xaf\xcdc\xdd\xab\xe5e)\x9a\xc8\x1cO\xcd\x90\xb1-\xcf/\x15-\xe8W\xd5\x11\xa6\x7fU\x1b?W\xec\x01\xb2\x89\x0c\xfa\xe2<\xa2\xccz\x07\x00(\xe4\xc1V\x80s\x172\xbaoE\xe8\xe9N\xcc\x82\xc7=\xe6\x16\xbe?\xf5t\xc1\xf4\xaa\xc0\xce8\xa5z\xaf\x94\x0f\x13\xca\x8d\x14z\x0cM\x1c\xa38y\x8d\x0b\xfbo1v\xd7CA\xf1\xf7\xc3\xdbn\xc6*\xb3\xdaA\xa7R\xd6\xbf\x96\xb3\x07-\xe16\xa3\x15QbK\x98?\xbb\x14\xd0L\xb7e\xf8~\x1e{?R\xa4J\x8b\x94K\xf2\x7f\xed\xc0\x01\xa3\x8b\xca\x16\xbb\xcd8|" \xd08\xc0Z\xfd\xd4\xf2n\xb5q\xf8\xda"\xaa\xee\xe4\x1e\x9a8\x02(\xcf\xcda\xa1\xe2\x16H\x0bb\x04\xf8\xf4\x94\x88\xccq\x98\xa9i\xc2C\xa3\x9a\x0b\xaeJ\x98\xc1\xb5\x10\xb1\xdf\x89)\xa0\xe1P\x888\xb9]\x80|\xea\xf41!X~H\x8bN\x84\x8dZj\x8d\x9e\xaf\x7f\xe1M\xf9\xfe\xbf\xa5\xd2\xee\xc1O58L\xbdVsQ;\x80u\xefX\xa8r\xeb\xa7\xd2\xcc2\xd0X\xff\xb1\xbb\x0fzMg?\xa0\xce\xccL}\xb3\xad\x03M_\x9f\x06\\v\x89\xb8\xed\x00A\xa2Z\x8a\x06\x82x\x0eZ\xf1$\xd6<\x14\xf4s\x9c\xab\xd4\xe6\x08\xfb\xca\xa1\x80+\xe3\x81p\xfc\x9d\x1f\xc1=&\xd3\x9f\xd5\xec\x87\xb4\xcb\xdd\x92\x98\xd3V\xcf\x0e\xc65\x0bv\xc8\x1f\x86\x00X\xe1\x01\x83\xf4\x9b\x9b>\xc6\x8d\xc0\xaf\xdd\xbe\xc3\xaf\x04x\xb1\x14\x92\xc8\xab!hIiA\x89\xb4\xb5\xa3\xe5Wt\x8a\x18\xdcX\xf0\x9e\xb9\xfcd+\xa6\x89\x8c\xf6\xc4L\x8cC\xe7\x84GO&\xab\x95\xff\xe0\xd8D\xc0|\x86\xfbz\x9e\x84\xc7\xcdY\x83go\x0e(lC\xa1\xa16\xcb\xdd\xb6\xa9\xdf\xb3\xd7\xbaL\x90=\x85\xa6B\xe3N\x9a\x96\xf8\xf0\x8c\xa4\x86\x80[av\xc3\xf9\xda\xd43l$$\xf5\xf8\x1c$\xd9J\xab\x98;\x89\x95\x0bC\xe1\x1f\x95\xb0WU~\x13\x1e%\x0bs\x00rl\xdb\x00\xbb\x11\x9a\xa9\xe4;+\xb3\x12\xadi\\\x1a\xd6\x13\xef\xcc\xb5\xa9\xbb\xc8\x0c\x8fH\xd3\xbaP\x1e]\x85\xfd\xbc\xfeU\xc5\x84p&\xb1H\xc9\x0e\xd6\x1a\xdf\xfc^\x85\xc5\xe0\xd5\xa1Zj\xbdsyg\xfb|U\xee\x04@\xae\xa4\xf9\xd4\x9b\x1f\\\x94|\x95n\x1bN\x04\xd3\xd0\xd0\xf2m2J\x8a\x946\x0b\xde\x95\xa0"\x05<"O\xd9\xa2\x87\x9d\xbc\x80\xb75\xe0\xaaSH\xf8s\x94\x8fS\x1dK\xb5\xa5\xa1s\x90\xe7\x00\xc1\xfb\xfb\xd4\xb0\xa9R&W\xa3\xf2\xb8\x19i\x90Mq\xbdaR\xf0\xac\xf7Z\xc5\x82e\xd5V66\x89\x125G\xf3\xfc\x15.\x9av\x9c\xf9H\x06\x9b\xa1\x92\xb4\xca\x9e\xef\xd5\n:\xf6\xbf\x88F\xf5=+)\xac9\xac\xd8\xa6\xc4-?l\xe8\xadzn\xb0\xb9\xcf\xed\xfd8,\xb4\xc5\xd2\x17\xf3\xa5\x05\xdbP\x8f\xa2\x15a\x1cbq\xb1W\x9d)]\n\xb3,nK\xc2l.\x9d\xf5s@hT\xe8\x80\xdbxQ\xdb\xe4\x11\xf7\xdc\n\x17\xcb\xeaG\x1fr\xc3\x97_(\x8d\xa9\xe3\x8bNU\xb6r\x8b\xde\x8e\xc0\xadY\x19\xb3\x97\x14&6\xc2\x01\xb4\x0c\xcc\xcc\x91-\xe4\x81\x0f\xc6\xfb\xeb\x12I\xffF\xdc\xcb\x17\xee\xf9\x19;\xc1\xec\n\x8e\x07\xf6-\xbc)\x17E\xa7\xa9f\xb5\xab\x15x8$\xb9>\x1f\xfb1\xdeJ\xda\xc4\x85(\xd4\xbc|\xcd\x96~R\xd0\x98#\xa1\xcb\x97ZG<\xc0\xa0\x0b4$\xe8\xc2\xcd\x10\x0f5\x986\xb3\x0chi\x18\x19\x90}qg\x80\xde\x91\xe6\x9f\xcd\xbd\xf9\xaa\x18D\xe7$\x00\x8b\xcc\xd6\xaauM\xd5\xb2\xcb%f\x06E\x87\x8e7b\x997\xbe.\x95\x15`\xa2 <\xc9j\xa1\x9eu\x98\xb3\x1b\x18\xae\x91:\x18\xaf\xa4\x1bjW\x16\x1a\x89F\xef\xd3\xc2\xaa!EH\x02\xa7\xec\xfd\xeb\xc4Q\x08BG\xc6\xbc\x8f\xab\xd0@-\xcek\x0fb2@0\x8f\x115\xc07*\xbb6\xb8>\x95*\x1b\xb2\xe2MZT\xe3D\x18\x9dr\xc7U?\x99\xb6q\xde\x80@\x02\xdd\xf71#\x02}\xde:\xdeMZ\x1d\x01~\xd9\xd3\xc4usk]c\xba\xbca\xc1\\\xbf9\x83\xe1\x97\x9da\x01\x83#U\x05\x11 \xed\xf1\x18\x8d\x93\xb4\xc5\xa7\xb7\x8a\x19\x11Y\xbd\x06\xdfl\x89\x1a\x87B\xae\xbfeH\xedvT\x05\t(k\x89/j\r\xe2SU\xd3\x14\x0fP\x06=\xa6D\xeb\x98\x17\xed\xec\x8b1!b\x1b\xc3F\xe8\x03q/\xef\xdd\xd1\x93\x0e\xff\xbe\x88N\xaa\x14\xc7\xcf6\xee\x8b\x9a\x89\xb7hy\x0b\xc5\xce\x04\x16gZ\xae\x07\xdf\xa5y\xabDx\xaa\x91\xce\x92\xe5@0\xcd\xf54w~\x9f\xb7\xdc\xca\xd2\xf0\x95Q7\xcak\xb7y\xa9-3Q\xf2\xe4\xec\x82//\\\xbf\xfb7h\xf7\xe5\x12P\xceC\xaf=\xbbI\x0cj\x94\x8a\x08\x13\xbd\x91\xd9\x8f\xf6\xa7\xad\xb3\x15\n\xa4\x83\xbb\xe6\x8c\xb5\xc5Rq\xbd\xbb\x07Z(\xf4PZ\x83\x1agvvX)\x83]\xe8N\x018)\xf7G\t\xa1\xb1\xcb\x93s\x9a\xb18\xc7\xf6\xfc\r\x9b\xc2\xa4\xbel\x85O\xf5Z\x80\x19:M\x11\xa5w&\xe4\x84\x81%!\xdf\\\xdb\xfaJ\xc5\xe8\xb8c\xf6bm\xea\xd3\xfb\x93_SG\x99\xac\x8fx`0[\x1aY\x82\x16\xf0\x84\x89\x86Y\ng\x8f\xff\xf5y\xf4\xd8\x85\x1cU{\xd8\xdb\x07\xf5\xe7Z\x96\xc6\xbd ?\xa9\x8aT\xb32\x03i\xce\x11KS\x81\xa6\x0b 2\x83\xcd$\xd4Q\xb9\xf0\xc6$\xf4\x0f\xa7\xc0\x15\xec\xf4\xadpy\x7ft\xbbl\xd7\x91\xdc}\x91\x84\x04\xeb\xdc&\xd9\x1b\x83\xe3\x18\xf8\xf8Y\xbb(~\xaf\x157\x84>\x8a\xaf\xcc\x90\x15\xf1#\xee\xb3\xa4\xe3\n\xb7\xd6s\xfb`\x01\xe6\x03\xbd\xcd\xc2\x18\x1d\xad\xaa\x83~^)\xd0\xba\x99!\xa9:\xbf\xac\x03>\xe1\xe9\x8d\xea\xffM\x03\xe9b\xe4\xe0}Y\x0e\xd9\x19\x8a7\xf4\x99\x9b\n3;\x8b+\xfb\xe2\xd0\xd4\xef\x0b\xa7*\xec\xb7,V\xc1\x9fn18qL2\xa0\xd6\xc8\xe6m\xd6\x16xWp\x8e\xa7\x1b\xe4\xc2\xbb\xe2k\x0b\xfb\x00\x90\x0c\x0e\xa1h2\xed\xb7\x90\xaa\xeft\xb8\xad\x18\xeeX!h\xc7-x\x04\x98\x87\x82&c6\x10\x05\xe9,\xc6\\\x10\xb5l\xcfq\x18\xe8o-Q\xb8\x15-\xc3\x89\x87*\xc1\xa6y\xb3\xf6\x01V\xc7\x83\x8d\xcddT\x92\xa6\x07\x13P\xf9\xc9\x0f\xd48\r\x8d \xd1\xe8~\xafG\x95\xf6\xfe\xa8\xe4\xb5\x03j\x95\x19.\xea\xaf\xef\xfc\xfc\xe9\x95\x90\x9e\xd8jU\xe0\x1b b*}]l\xee\x81\x953\x19~\xfd\x87\xf1\xa0\xd07;\xe2K\r8G^\x15^\xa2\x18\x03w\x89\xf7\x881\xd7G\xcf{\xda\xa1\xb8\xc0\xfa\xf0G\xec\x0b\xe0\xec/\xfc\x1d\xf6,\xc6\xa1\x99\x14\x94\xf4\x07\xe0U\x08\xe8\x07\xa7\xe3\x82;\xb0\x0f\xebX\x1b\xa01\x8a\xbcF\xc2\x83\x14\xe5\xbf\xd2\xe2\xc5s\xf6qo\xd3\xb7C\xa9\xa4,>\xd7\x84\x8b}\n\xbe\xceN\x13\x19T\xff\x8b\x16i3\xd1\xd2\xdel\xc0\xd7>\x11\xad\xd6\x01D\x07\x18\x93=\x90j\x0fT}\xe5\xb9\xe1\xc9\xe7A\xf5M+z\x99\xaf\xa0\xa9\xbb\xa5k\n\xa8>7F\xbeI\x871\xdaR\xfe\xaf\x849\xc54\xdd\xfa\xb0f\x06}\x1dz\x81o\xd1\xbeT\xbe\xf3\x0f\xf7\x14\xa4\xb7{:4p\x81r\xdb\xec\x95\'\x17\xe3\x1cn\xe7\xf6\xfc\xa62!nsk\xb1$Y.k\xfa\x90\x11Q\xf3\x05\x05+\xfa\x7f\x80$|d5\x10\xb6\x7f\xd8\xe27%(\xdc\x8cm\xf1cA\x9e\x18\xfe\xc9\xbd\xfb5\x9e\x9b\xb4zQ\xbdr\x80Sq+\xd9\x0b\xbf\xa7\x90\x169\xb7\x16\xbfF\x18\x89\xf8+\x8f-\x04~R\xc1/\xaa\x03A^&\xd7P\x96\x95\xc3\x8f\xdb\x91(\x9d\xa1\x86@t\xb7\xabs\xe9\x84\xea.\xcb\x88\xd1-ZOP?\xdc\xca\xfb\xad\x8b\xeaVn+\xda,\xdf\xcb\x9dEf\xb92x"\xbd!\xff\xf6O\xb3\xce[\x96^0\x8dQ:D\xb2g\x98\x81s\xa8t\xfe\xfcC\x00\x05\x08\xf2\xa6z\xee\xed\xbb\xb1\xd2\x0elv\xe2?XN\x14:_\x03R\xaa7\x98\xc58J\x91`;\x0bT\x17\xb2\x89\xb2xh\x16xd\xe1\xc9r\xba\x80Q5\x12\xaf\xa6\xafC7\x82ziV>\x90D^\x12\x1aV\xf6\x8a\x9cU\xa6{\xf2\xe9V\xc3>R\x7f\xb7\xd8\xee\x19\xef\x04\xbb\xffP\xf1=\n\x1a\x07\xf8\xe7\x9f7\x08g\x13Y\x7f\x06\xeb\xfbW\x88M\xe3\xd6;\xe2\xf9\xae\x9b@I\xb4\x14z8\xdc\xbep\x05\xcc\xc8O\x96\xac\x952-\xae&\xe0\xb4\xe7?\xefh\xde\xe5\x91j\x88U\xd4qrX"k:\xff\x849\x12\xc1\x0e46\xe6-\x17d\xb1\xad\xd6\xc6~Q\x03y\x10\xa0\xd9{\xab&\xcb\xf2q@\x81\x1d\xf4:\xae\xe9\x9b\x17\x9c\xeb&\xdaJ\x87[\xac\x88Y=\xd7\x1b\xb4\tE\xdb\x94\xf7\x04c\xcc\xde%\xea6h\x84\xcb!\x18\xa1\xa9\xeb\x94,P\t\x08Q\x95FB\xd2zE-rx\xeb\xf6:\xff\x06\xc0\x9adO\xba\x83\xc9\xfe\xdbk\xf8\xe1\xee\xa0+^" >\xa1\xc9^\xb0\x134\xdb\xbe\xd9\xba\xc7\xe8\x96J\x1e\xd8J!\xb4\xeeWx\xb5\x98\xb8\\R\xd2\x80\x832\x93\x8c3\ng\xe4\x11\xedIl\xf5\x92*\xe2\x11\xc8\x8f\xef\x14\xa5\x8c\xa5\x8f\xf3-OV\xcb\xd5\xfe>\xc4$|E+\xba\xc8\x00M\x07\xa8?\xbcu-\\*\xa5\xd6\xa3Z\xf2=\xf4\xc8\x00\xd8`N\r+\x12Z\xcd\xc6O\x0e\x89\x9f\xbf]\xb1%\xd3\xcb\x1c\'\x15D\xdb\xdb\x17\x87^b\xd5\x1e\xcd\xd2\xe3\xbes\x99C\xad{\x15\x0c^\xdbh\x86\x0b8+\x7foh\x89RwrO\x87\x1f]Cn2a\xdbh\x03\x8f*\x8a\xc3,\xd5\xb2K[\xf6.8Q\xdc\t\x11m\xf3\xa9\xdbX+\x1aSHS\xf5U\xce\xbe\xc0\x8d\x8d\x17\x95[\\9.\x9d\xd8\x95\xf3\x95\n\xfc\x99\n\xb1\xb6F\x91x\x8e\x9b(/i\xd2\x8b`\xfa\xf3\xaf\xddT1\x05_\x89\x95\xd7\xf1\x85zG\xd4\xcb8\xcak\xd2\x8e\x9a"`6\x1a\x97\xfd\x0f\xc9\xf3\xa4\xbbK\xe8g\xc8\x04\xd2\xdc\x8eTS\xf1\xbbY\xca\x05%Y\xfb\x8e\xbc\xecP3*\xea\x80\xd7\xc1\x10g\xe1\xd2\xbc=(\x8a*Z9\x8f\x90X,|\x12\xc2v\xf2p\x8e\x9b\x9a\'1\x18\x03C\xb3\xeaZ\xd4\xfb\x8c\xdb\x1e\x8b\xbf\xc2\xcf\xf4\xe8A\x86o\x7f\xc0\x8b6qV\xbe>k\xe6\xfe\xc7x\xb0\x05!\x81hsSz\xdf\x8f\x1a\xf58\x02~\xa8\xee_J\xcc\x1e=\xbfJ@\xa9\r\x9b\xf0\x883\x8b\xc2\xc8\xa0"u\xa0r>\x85*\x95\x83#\x00\xba\xa8+\xe1\x9e\xf5\xe9\x1f\t-\x9a\xaa\xe2\x92\xa3\x95\x00\xe6Q\x93\xd7\xc5n\xf9\x81\xb7\x1f\x0b9\x91"\x9e\xffF9(\xc4\x00\x9f\x96/F\xc7\x86\xc6\x92\xf0\xd8\x84\xa2hy\'8\xad\xf3\xf7QL\x1c\xd1I\xee-\xe2\xa5Z\xa8&\'\xf4H\x19t\xca\xf9\x8f\xf9\xb99\\9\xf0 \x18\xe8q\xa4j\xc8\xf3\x0bs\x19\x0b:\xacZ\x05\xefh\x99\xe93\x15wJ\xaeDa:\xa6\x9a\xd3$\xeb\xe3\x0cUrq\x8d\xd1<\xf2ly\x0240k\xc8`d&\xbfb\xa2j5\x1a\x14l!\x17\xda]9\xe4~\xc4d\x7fL\xe5\xd4S\xd6\xe4L\xca\x07v0wX\xb8WO\x1c\x1f\xe3\xe3\xa1\x96\xff\xdek\xbf?\xb7\x87\xcc\xf3\xa8\x11o\x0b\x11)\xc09i\x8c\x04\x87\xcf#\x13\x99 \xa7\xf0\xfep\xe5\x03\xd2\x03\xbb\xed\x96KI2\xb8\x04\xd5\xd91\x8c\x0ff\'G6U\x87\xd6so\x83\xf5\x93(\xea\x7f<\x83\xa4jd\xb9J\xe4\x10\xc4\xb6Kl\xc6[\x8f\xb6\x03\xd8\x18gC\x92\xc9\xce\rYZ\xe1\xf5;\x1d\xbb\x96\x15\xa6\xaa\xe0\xc1\xcb\xfb\x0c\x9a\xd0\xec\xfb\x86\x96\x00\x91\x82\x82:\x01\x87+\x96{\xd8\xed\xb8\xee\xe4\x1c|\x19\xc4p\xe7t\xe1\x8a\x19<`\xf44y\'`S\x19\x8c\x95\xea\xbd\xbc\xccZ{\x92\x93\x0cq@\xd9\x96ud\x19\xcb8\x97\x88S\xe9\x05\xb5\x995b\nq\x80\xef\xd4[\x83\xcc\xe7QT{.\x08>\xfd\xb4\xcb\xee\x10z\x16\xef\'\xa7q\x12\x86\x8e\x03\xe2U\xfc\xf1\xfa\xa8\xc3\xc0\x9b0\xf2\xbcd\xcd{+\xd3\xc6\xc3#\xaf\x88\xb9p\x19\xd2\xa7\xd9Y\xe4\xcd\x83\xc3X\xdee\x7f\xb5F\xf6\x8b\x87\xcc\x90\xf0\xa0\'N\xaf\x18\xd9\x91\x9d\x9ac\xeb\xb2\xc7=\xc3d\xdapEIt\xfd\xa1\xa4\x1cUH\xb8\xd6\xb7\xda\x89_f\xdaI\xdbl\xa5\x90\xf9\x16X\xab\xe3m\xfb\xfe\xa5\x96\x9eQ\x90\xdbZG(\xc7V\xb3\x9e\xe6\xf0\xcb\xa1\r\xe3n\xc7\x00\x8b\xea\xedZ\xffz\xd3\\\xad\xd7x\x9a\x9b\xc8r,%\x9e\x19U\x10f\xed\x98~\xb0\x8b\x14\x97\x9a\x15W\xb9\x80\xaac\xb3\xa4\x0b\xd3\xbd\xc6\xef\xf3\xe9\xc2\x05\xfe\xadk\xc7\xaaK\xf6\x1f\x8f\x96?\xed\xa3\x14\xc8\xfc`~\x0e=7\x83\xea\xe9\x17\x88\xd10\xa0\xdcC\xd0ON|&\x1f\r\xaa\x93\x9a\rw7\x1bR\xe9#\x02!\x15\xc0#{\x8f\x87\xe4=\xc7{\xcf6\xdf[\xf0!\xfb\xffv\xc3/\x13\xc9j;R}\xb4\x92\x1d\x9da\xa9\xbc\xc6\xfe\x97\xe6\x9d|\xd4\xaa\x9d\xc2\xc5<\xd3<\'\x06`\x83\x81\x1b\xb0\xc2<\x8d\xac\x8aP\x88\xc8*\x97\x8f\xa0\xedJ\xd2W#\xef\x9aD\r\x1cFn\xa8\x8b\x88\x9a\x83f\x85v#N\x11\xd5oPc\xa4\'\x8a\xec1\xbc\xff\xf0;\xae\xc6#[@\xf1j\x97/\x80\xef!^\x109\xcf\x0e\x88\xb3\x0e\x90\x0f\xfe\x98k\xd82\x91,\\\xb2{\x12\x99G\xa9xg\xf6%\x058\x19\xfe\x05\xfdh\x93\xd7Q,\x98\x8f\xb3*Z\xddR\xa2\x00\x14^{\x1f\x0f\n\xd0\\\xf5\xc7,\x82\x06\xbc\xfe\x17\xbe\xff\xacF\xf1\xef\x02\x86\xf7Eo\xfa\xee\xb3\xe1\x87n\xca\xf3]\xe1\xbbI\xa6\x16#\xa9G;w\xd2\x1e\xeb\x14\x80\xc5TD<}\xb3\xc4n\xffU\x93\x14\xe5\xba\x0fp\xf6\x16\xb3rL\x06\x8d\xfb\xaf\xc9X/\xd6\xe7}\xd9~\x84\xd0\xe76\xa9\xa6\xfd&v\xe2/\xfb\xa8\x9c\xd6\xa4\x11\xd1\x97\xaa\x9e_z\x04\xfd\x9dK9\xb59#\x1cdy\xfc\x97s9\x07\xb9@f\xd7\x7fZ\xdei^|\xc1\xd6\x11*ay\xff\nH\x0cS\xc2\x81\xea\x98\xd9\xd1\x9cV\x04\xa2]\xd0\xfc\x9d\xb4\xdf\x9c\x00Vc\x04Y\x88\x81`DZe\xa9C\x91\x19\xceD0v\xfcd\xd2\xc2qO\x15\xf0\x8aZ\xa7\xf5\xedl\x0f=\xe1\xac\xc4\t;\xa7\x1d\xad\xee!&\x83\xb0\x98p\xff\x13\xee*\x8b\x7f\xde\xb2Sk\x8eA\xbb\x06\xe0\x04Ij\xec\xc4\xc8\xc8;\x1d\x18\xc8\xd0x\xf8\xdaT\x18\xfe \xc5\xb1\x8a\x16\x90j\xb4\xc1\x9b\xfb\x0e\x88\xa7[\xc6P\xcf\x1e\xedyi\xdb\x813lbIA^\x85d\xb1\x1f\x90\x99,\xfbgg\x1e\xe2\xa5\x9b`0\x9c\xff\x94\x7fY\xae\x14\x99\x8a\xaeO\xf4\x87\xb5\xbf\xec\xfa\x1e\x85\x90?a\xe1\xc4\xbf|\xab\xe4\xb3\xd0bS\xef\xe5\xac\xf8\xac\x15"\xab\xb9\x0f\x8f`:\x0fq\x8cj\x91q:\x93\x85\x10p\xdb\x07\xb5\xbb\xd3H\xfe\x13\x95\x8fA\xe1\x92\x12<9\xda\xd3\t89\xb0\x88\t\x13\xaa\x8d\xce\xc3\x8f8\r|\x12\xb2\xb6\xd4\xbb\xd452\xe1\x13\xde\x9b5\x98>@\x11\xc6\xc8\xbc\x9b\xc0\xb3\x0eLxQ\xf1D\xa8\x18\xae\xe5\xac\xde\xb3:!.tk\xf4w\xdf\xf1+8\x9a\xb9@\xe3\xa7\xabq~\x16\xdd\xd5\xbf%%\x86\xfc\x1e=J\x81\x0b\xb76\xea\xdf\xb4d\xf1\xce\xbf\xd9\xd1n$h2q\xf2\x9b\xe3\x89\xe3\xd9\xa7F\xd1\x9d!\x17\x03\xf5F\xf8ch\xb4N\xb4\ts\xe7{0\xe4\xe6\x16\xde\xcbj\x9a;R\x08\x03\xceY\xff\x87w\x91\x9e\x8d\x9b\xb1P\xbd\x93\xdf\x00\x1e\xc1\xb3\x00\xc9\xd3\x91 J.\'\xd5\xe2\xcbX-0\xcdMe\xdc\xb3\xde\xe7\x11_\x8d\xa9\x00O\x0f\xae\xe5\xaf\xfd\x81\x88D\xe8>G\x18\xa3\x9c\xf1\xee\xcb)\xdf\xf5cv\xf7\xdf4\x95\xcb\\k\xd3t\xfb=\x90\xb2\t\xcf\xf7\xe7T\x9d\x82\xd0ov\x87\xb7<\xdc\xce\x0bL\x9cD\xb3z\xab*/\x8a\xc2\xd2/`\x7fEP\x1d\xebb\xc5\x9fN%\x0b\x1d\x85\t\xc4\x12?$O\xcd\xef\xe0\x91\x18S\xa8\xf2\xf1\xf0c\x14`X\xbb}\xa8,T\xacZ\x06\xe0\x03\x19|\x19;\xa0\x11\xbf\x97\xed\x8f9\xa0Y\xc68\x1b\x19jv\x15$4L?\xd7\\\xed#\xe4\xe9\xfbD:\xdb\x16\x1cWE\xea\xf2{\x0c\x91)F\xa12i\x90\x92Rl6\x14A\xe7\xee\x05\xf5f\xe3X\x13E\x1a\x12\x14\xc3\x1b\xb7V\xacT\x8d\x19\x7f\xe7V\xb7S\\a\xa8\xcft\x14O\xdd\x05\x96\xa3x\xa6\xdb"h\xdb\xbbWL\xabW\x06\xc0\xf7\x91\x88\x82`M\xbc\xd6\x14Hvo\xc2^\xe7=o\xbb\',%1\xff\xce\xc1b\xd6\x18D\xfaV\xd7]A\xe0\xf3\xed,i\xf8\xd0\xb3\xcc\xa23J\xbb\x95\xdf\xb4@\'\x12b\xb7\x9b\xf8\x81\x10\xdc\xbaWw\xc6\x90o\xb5D!M\xcd4f\x01\xc0\x08\xb4\xee\xef=H\xd1\xe7jbm\x9f\xb6\xa3\xf0\xdbO\xb9wh\x86\xc7\xb4sW$C\x96\xe67&/\x82\xc8/\xf0,R=FH\x1f\xd5\xbfT\xea^\xad\xb0\x8c\xc2N`/\xa6\x02;\x94\x00Vm3\xd4\xfb\xe2\xb1X_\xce7z,I\xe0\xa4\xb8\xbb\x86\x1c\xef\xc7\xb8\xd4\t\x81\xc1\x89\xdb\xb77\xbe\xa6\x85\'\xba\xc0\xee\xe9/h\xca\x12\xca/\xd1s\xd7\xc6d\x8a\x88\x95H\x9c\x9aB\x98\x8f\xd3-\xc3\x98@Yk\x80\x15\xb5\xc7U!\xc7W\x0c\xde\xd3\x9b\xdf\xcb\xa4`u\xc3\x83\xfeL~\x0cI\xdb\x92TF\xd1t\xd3\x03`\xf6\x94|\xf6\x1e\x19\x93]2\x9ei\x9a\xe5;9\xa8\xe3$\x12\x1c%\xfdX\xe4\xc6?\x8fgD\xe3\x0e>>\x9eY<\xfdg\xb6\xff\x99_>\x02\x80\xda\xfdUw\xa9s\xe4\xb2\x05\xd4`w-jX`\x08\xab\xeb\x81m\xbf\x1dV$\xd2\x83\xd4\xb7\x1b\xb9%\xd3\xa1\xf0A\xc1e\xa4d\x85j p\x10>]PIK\xda-"e\xad\xb3,\xb6\x9a\xb9\x9eW\xb0L\xf2\x83\x05\xa4\x02]\xf1\x085\xccN\xc7\x1c\xae\x1e\xc0\x17\x15\\y\x16\x1e\xe5\xdc3\xa2N\xc2\xf1\t@\xbeN+~\x87=\tfc\xe0\xb4\x03\x8b\xb9c\xa2>\x12\x1e|F\xe1\xfc$\x12\xd3\x8e\xadr\x97\xa5\xcf\xfd\xe9\xb1;\xec\xc7:\x8e&\x8d\x85\x8f=\xce\x1d\xe7\xc2v\x0e\xa0\xae@\xe6\t\xf3\x90\x9bP\xc4\x05\xda?\xb2\xf3yF$\xea\x8a\xac4P\x8f\xa31]>\x0c\x1b\x1ef\x89v:\xbe`\xae\xa0\x8b\xb8\xa1dD\x83\x9e_FN\x1fm1\xf9\xac\x90\xe9\x8f\x0f\x03ul\xadq\xa3\xd6|fh5K\xca\xd3Uv"t\x0c\xca\xda\x19\xc8\x99t\xb6Q\xca\\\xbe6\xd7\xd2\xa0\nv\x93v3\xb8X1\x11`\xf4\xdeB %?\xda\x19TtA\x00(\xebz#s\x97\x83\x02A\xcbm\nI\x17\\\x0b\xcf\xf1\xd9\xd5\xc6\x03\xd3\xcdq#\xc6\x95~\x02V\xa8er\x1d\xac\xdc\x88@\x02\xdc\x07\xcd22x\x81\xe9cE0\xe1\xaf\'\xe7U\x84\xe6Y!7%h7\x86*\xdf\x94\x8d\xc5\x9c\x0c\xb2\x18$C\xc8\xc9\xbbA\x8bF\xf4\xf2Y\xb5\x92\x02\xf2\xb0.\xafe\x8e^\x08\x7f4\xaa:\x15\xa6\x8b\xe1\x1e\xee?F\xa9UP\x8f|^\xc0\x8e6X\xd5\x865+\xbd\xf8\x87\x87\xc1\xab:q]\xffD\xb7\x12\xbdJ\xd7\xc3\xe9\xafTg\xe4\xa6\xd8\xa6]?\x95^\xac\xed\xe3i\xb2\xe7\x8c\x1f*\xc4\x90\x7fC\xfch/\x8b\xff\xa7@\x03\xc3\xbe)A\x19\xcex?\xf1\x90\x1a\xc8\xaf\xf9G\x91|\x8a\xc1>\x8f"*\x0fZ9^\x89\x7f*\xfa\x95\xa8\xbd\x9e\xcb\xc2\xde*_\xd0n\xaa\xc8d\x0e\x97f\xd0\x93\xda(\xc8\xb1B\xfe\x85I@\xc3\xac\t?\x87m\xcd\x90\xbb7|\xba\x85t\xc4\xe0\xc9\x08\xf2~\x8br9/\x82\x11\x80\x1d\x10D\x9eH\x8ai\xbc\xc9\xc8Xp\xa1\xf6\xf2OX\xe0fXv4\xcf\xe9Pb\xd9\xdb\x9d\x81\xb61\xdb\xc1\x80\x0c\xe8V\x1ej{\\\x91\xe0\xe2\x9a\xc8$\xec\x7f\xe0\xa8\xfb\x00\xb1>fP\x9b\x9d\x1a\x95\xac\xe7\x0f|\xa9\x8e\xfe\x07\xff6P\xa2T\x1a\x11\xab\xcf\xddD\xbfkz\xa5\xe8\xf1\xe8v-\xf6\x9c\xd4\xd3\x84\xb1\x99\x9c\xde\xb1\xdbsC4\x0bY\x0c\xac\xe1\xd1\x10L\'"\xc4\xe9/Q\xb8\x05\xb7\x15}\x82\xc8[\xbc\x9a\xfb:\xe6\xd8\xd9\x8fi#\xfe\xb5\xaan"\xec%\x90R\xaf\xe3\n\x11G\x91\xa2h\xcd|\x04\x8b\xde\xeeE\x91Yw\x1a\xd2q\x83\xe0\xa5\xc5\xcf\xfd=\x8b\x08\xfb\xe1WY\x1f\xb3\xf3@\x14\xdfak\x13t&\x82\x94\x1e\xc1\x03\xacM\x0e\x08\x93\x1e\x96~\xc4\xc6;24\x0b\xf9\x1dl\x07\xc6u\xf0\x01!D\x11\x83B|-\xed\x19c\xafS\x04\x9e1\x1e\xe46vY\xf4o\xe0\x1ak\x9c\xe4R~}]3\xc1\xdd\xa3\xd3\xe4\xaa\xcfb\xaah\xb8A\x81\xc1\xd0$ \xa5\x0f"F\xe3\x1fz\x17}\xbb.q\xaa\xb9\xb8aK\xd7N|6\xace\x171\xa6\xe4BY\'&\xa7\x9c\xbc\xca\xea\xe7 I^\xa8\xe3\x05\xb4\xed\xd0&\x15\xa3j\x16t\x85\xe6\x98\xea,Ql\xcf\xbdK@\x1a\xa7K\xd8\xe1\xf2Q\xd4@_\x9e?!\xb48\xf2\x97\xdb\xf4u\xb2\x9d)\t\x9a%\x00\x0e\xeb\xd7\x12vs\xa0\x11\xe5\xad\xc9\x92"\xd9Hh\x1b|U\r\xde\xff\x18cJk\xd8\xb2\x8fg\xac\xfa\xfd8P\xec\xd9(\x14\x02z\xf0:\x92\x0b\x92\xb8k\x89\x86g\xc1\xe6\xc7\xdfa\x91\x95\x19a.`R5\r@F\xd7\x04G\x0e~\x06\xeblA\xc9\x80T0~I\xc3\x9d~\xd6Xk\xc6\xaa=V\xca_\x1f\xfe\x11\x87\xab\xd8\xad\x92\x89\xb66\xf4\x9d\xc7W\xce)\x87\xb8j9\x14\xcbOi,W\xc1\xc4J\xa3+\xdf.\xadZ\xf1#z\xde\xaeJ\xea_?\x1e\x94H\x1b\x02\xf5c\xa5\xb1>\x07\xb6\x8a\x81\xade\x1e#\xb5\x8d\xd6\xa7\x19\xcf^VG\x94\xb4\xc4-\x01&\xd4O\xb8\x8434\xfa>s\x91\x11\x84\x14\xe1\x15}\xb2>UV\x9b\xd4Yu\xdc\xc0\xe3g\x83\x9fj\xc7\xba\xd7wK\x13\xf0_\xa3\x0f\xcf\xe9q\x0e\x9b\x91\xd4\x18\xb0\x8aY5\xb5Q/\xcf\xa9E\xab\xb1\x9b\x13\xec\x84S\x84-4\x1as\xe7\xd4\x15\xd9\xd2Y\xad\xf1\xbe+\x8f6nM\xb6\xd3I\xee\x92\xe5\xb4\xa9fJ\xd7\xa3\xbd\x81\x7f\xc0\xac\xf7\xef\xd8\xa2\xc5\xa4-N?\xe7\xd6\xdd\xb1\x8f\xa3\xf1I\xe9\xa0\xd4fZP`9\x181\xa6\x07L\xea\xa7\xdb\xc942\x92G\xfe\xa9\x12O\xcd%YH\')-\xcf\x9c,\x14\xc7i\xdel\xfdd\xb2\x8c[\xac\xd0\xbb\x16\x97m]G\x91s\xa0\xde\xe1a\xe2i\x82>\xe9l\xf9\x95I\x07\xf4_\xbd\xb7\xe5{\xfd\xaf\xa2\xca\xa6X-\xd9\xd9\x11\x99\x93\xe8\x03\xdcE]\x7f\xadG\x17[8 \x00a\xebD\x93 6!`hR"\xb1\x97#9\xb8\xf9\x1d\xeck\xa0\x04\xf2\x8e\xb0z\x9f\xa0\xf7\x1c\xe1j6q\xcc\xed\xf6\x80e\xcd\xcf\xed\x06A\x9a\xd6\xa8\xc2\x8a:\x88>\x03\x90\x9el\x87\xcf\xfc\x1b\xe4+H\xb7\xc6\x97\xc1\xaa\xde-;\xb3!%\xe1R\xf5\xc8)d8\xafF\x10\x06\x9c\x94\xef-\xe9\x1aG\xcdCL(v;\xd1\xf0R\x85\xe3\x16\xcc\xecO+\xbf\xe6^\x8a\xfc7\xbe\xaa\xa5\xb6\xe8\xb1~n\x16\xe5i\x0f%#{\x84\xc5\xe4S+\x07q\xc6^\xc2\\-\x11\xa8\xb3\xf7/"\xe8\xe99\x8eq\x0eR\xfc\x0b\x9a;\xa4n\x0b\xa1\xd3W\xf2\xe9\xd6\xf8R\xe1\x01=\xf4g\xb2\xf9:\xd5\xba\xff\x14C\xd8\x91\xad\'}\xcf\x97\xb6EPT\x04\xd0T\xec\'<\xe5E\x1dve\xbf\x9b\x9d\xee\x1d\xeaD+1\xb1\xbf,\xb2\xc0\xe7\x19~a\\\xd5\xe4\xa9\xf5\x92Q\xc6F%\x90\xc1\xc4\x1d\x18\x80\xf0#\xd0\xf3\xa6\x94P\x0c\x8e\xbf\x0bV\xb4\xe90?i.\x8f\x04\xd1F,\x84\xe8\x94\x92\x14\xf9\xa7\xf4\xa4\x06q\xeccp\x9cO\x90;T\x1a\x0e\x8d3\xd7\x90$\x0b\x16\xbaq3\xd4\xca\xdb\xee\x0ec[\x1dB80\xfd\xae\xad[\xfe\xc1}\x8b\x1a\xab\x10\x8bf\x8b\x85\xd5\xc8^\xb9\xb8\xea\x8b\xaahC\t\xf7\x1d\xcc\xc6\x80\x8a\xaaa7bG\x86\xa8\xc3\x05\xa2\xdc\xeap\x17\xdf\x071\xc2\x06J#\xbd\xc1#\xf99\xc6\xf6\xafw\xd3\xc1@S\xa8\xccl\xea\x8d\xff\x84#B\x05\xecS\'\xb7c\xac\x14\x8c\x13\xff\x93\xcc0\x88\x98\xb8\xf7\x9b\xa3\x0b\x8f]\xad\xd8\xd6\x04\xb1,\xf7\xdck\xaa\xfdj\x16\x89B;\x84y\x9a\xac\xfe\\\xf1\xe2\x823\x96\x9e\xf5\xd6\x9f\xf6fr\xec?\x83KN\x96\x89]\x7fK\x96 \xc0n5\xfd\xc6\xbf\xa8\xa3y\x88T\xd5\xeb\xc8\x14\x8c!2\x15\xc5\x0c/\xa7P3\xd2\xee\xa0\xc7\xaaa\xb0\xf9\x1e\xca}Ln\x03\xae";P\xc1\x10\xe5\xb6\xf1\x0f\xfd;\xcb\x03\x82X\xe8C\x96eB\x99\xe7\xc1&H\x9e\x86:\xcb\xf7\xe1\x9c_\x9c\x9fV\xf22,\xecZ0\xd9$\x10\x9d\x99\x0e9\xe0\x03c\xab\x7f@1;\x9d&\xb9j\xc7\x00&\xaf\xe3\x90\xeav\x18\xe3\xc3q\xeb\x10K\xf7(\xd3\xed\xcd\x8aJ\x18\xc8<\xb4\xd5E\xeb\xc9\xb5\xdb\x8f\x95Ue\xb2\x86<\xfd\xfd\x03d\xf7N]\x02r\xd5\xb1\xdd\xa0\xa4\xfe!ta7\x1f\xc6\x06\xeb2+\x87^\\\x80\x82P\'\x89\xfd\xbeI\xb7\\|\xb9\\p\xaf] j\x9dj>\xce8O\xf8\xa3\x9c\xda\x92\xdc\xd73\x96\xdek.\xa8\xd6\x03\xe4\x11D\x087\xb1\x80;\x98t^\xe08\x98\xd4\xa6\xf9\x98\xe4\xe6\xa9\x99\xad\xbd \xba\xd9\x7f\x9b\xce\xea2\xe1\x103l\xfa\xd4\xbf\xacl\x04\xd5\x85\xba\x9c\x87]l\xc5:t\x05\xf9\xec\xd6%\xaf\x94i\x9a\xf5\x9fv\xf4\xdb\x9e\x1d-s\xf8\xaa\xe7\xce>\xe7\t\x85\x19\x89M9\xfb<\x17aV&p\x11\xa9!.\xf1\xb4\xa4e\xdd\xe3H\xec\x1b\x1dmWDT0_\xc1z\xdaq\xe1(\x0f\x08Q\x05\\\x85\x92\x06\x12m\xa30\x02\xdc\xb0\x91|\x96\x0b\xca\n\x03\x0e\x1f\xc2Ta\x9f\x05\x8er\x1b\xef/2F1[@\xfa\xbd\xff\xdd9b\x9f\x0b\x0b\xb0\xd9=0A\xc8\xc2\r\x18\xcfM\x98\xfb\xae\x92\xaewh\x141\xe8-\xb9\\Y\xe4 \xc2\x00\tP\x13M\xb4\xd5\x85\xea\xce\x8c\x94\xe3vR\xb8\xc3\xc3\xd0Px\xdb\x96\xf2\xa7r\xe4\x03S\xbc\xc3\xd6\xf9\x11\x1c\xdf\x8a\xf05\xe9*\xbb\xff\x973\x002\xba4\xf1\x10\x98\x80\xeb+s\n9\xce;\xa0MB\xcefK\xce\xc9 X\xe5\x96>aI\x10!\xb9"\xac\xda6K;\x06\xe5\\--\xe0\xa3\x10\t\xabK\xb3\xcf\xac\xd7\xe7\x8d\xfb\x8f\xf3\x1fZE\\\x9259\xdaY\x94!\xf0P=\xc8f}\xed\x19>\xc3Y9\x97 %\\\xca\xa2^\xa7-\x8a\x14\x82\x10"\t\xf4\xbeYW\xb9Np\xf6\xd5\x1bzhb\xca\xd0\x86\x19\xb8D\xa9\x0c\xa3\xdb|\xbcc\xb0\xe9\x8f\xa2h\x86G\xb5\xdecI\x0b\xfeD\xad\x14&\xdd\xb3N^\xf2\x1c~\x9f\xa6\xb7K\tqW\xcf\xa4Ayi\xdc\xd1\x0b&fUR^\xac>\xafx\x11n\x0e\x99w!\xac\x95B\xad\xe1>K\n\x0b\xe5\xca\xb8\xc8\xdc\x95\xf0\xbf+\xe2\x04$1\xe0\x8f\xa3\x9d\x89\xed\x0c\xdb\xa0\xf8s\xe4\xab\x8f\xd4\xb99Q[\xbf\xb3\xf3t!\xa3\x99\xd3\xb8\x9crj\x0b\x06\xaeu\xb0\xcdr\x0ee\xeb\x14\\\xc0\xf2\x97\xc2\x11\x7f^_\xc2\x88u1\x86UVsZ?\x96\xcf\xda\xe9\xfcNCJ\xf2\xe6\xba\xad\x9ciR\x82\x94{\xbf\x11\xbd"I\xd9\xb4\xcb!\xde}\x11fzT\xbb\xdccYH\xf2;\x7fb\xa4\t8\xbat\xa3@\x07\xfe\xb0\x95\x7fe\xc84W\x85m\xfd\xf5\xfc\x06\xae\x82"\xc2\xcc\x07\xc5\xef\xa5#\x86\x99Pi\xe7\xaa\xb7Yl\xbf+K\xd6\x19\xb8\x13\xd8\xff\\\x07W\'\x83L\x95Z\x10\tP\xe3X\x1d\xea>.\xc7\xa4\xe7g\xbf\xdd\xfe8\xf2Q\xf26x\x13\xb8\xdb<(=Z\xf2\xe0\x9664\x1d:Y\xf4<\x10AAB\xabk\xb6\x0ft\x03\x83D3\x8e{S\x10\xc0iD\xad#c\xae+\xd9^@z\xdf\x9f\xf8e\x7f\x0c9\xd5\xcf,\x00\xd8\xc5\xb6\xcfv\x93\xdd\x15 Q\xe5/\x7f\x08\xc4\xeb\x1eZ\xc9\xef\x0f\x95\xe9\x0cp\x01DU\xac\x11gj\xa4d\xc66\xe3\xde\x95\xbcT\xa0\xec\xfeBK\x9f/\x8c\x92\x82\xe7\xbc\x94o\xa7;Q\x11\x01-\xff6\xd3[>\x8eS\x1c\xd4},\xc7Z\xf2&I\xc2\xea\x82w&\'1\\*s\xb0E\x9dJ#fC\xb9\x1f\xa7_\x89\x9a\x10\xc2\x9a?o\xa9\xcb\x97\x1e\x19\x7f\\bA\xe2Ii\x86\xbd\x0e\xdf\x95\x0b\xcc\xde\x9bF4\x1dZ\xd2\xc4F\xdc\xd6{\x07yR\x18p\xf5R;\xd5\xe1\xa8\x0b\xf0\x04\xfb\xcc\xbac\xa5\x9d\x90\xe51\xe3I\x1e0\x07&rIL\x9b%x\xd5\xf8\x03\xa06\xc4 \xcf\xe5 \x1f\xa5$u\xce$\x039\xe6=\xef\xc6\xb1\xeaPHR4bI\xcd%\x9d\xfc\xa5\x96\xaf\x93\xa4\xd3\x9e$\xac\xbe\xeeEU^s\x91]\xf3|\xf1\xc3\xe7\x81\xbb\x15\x80y\xab_\x99u\x84\xab\xc4\xbb|\xd8\xaf\xd7\x88\xb8\x89\x98\xcb\x8b\xc9\xe6\x90J\xf9\x9e\xda/&\xa6kv\x8b\xda\xde\xdb\x1a\x9a\x17\xb8\xe1\x90\xe1L\x81\x0e.\x1f\x8f4\x92\xd2\xe8\xce>\xb3;\x08]98p{\x15\x89\xf2z\xa7\xb5k\x02+\x0e\xa8\xf3W\xdf^\xe3\x9bk\x1a^eH\x15{\x1f\xa6\xa9H3\x1d\\\xf2\x12\x9d\xebf\xfe\xdf\x14\xd0\x95\xf1\xfa\xc8\x7f\x80\xb0\xf4\x8c\xd6rx\xa1_~\x85\xc6"\xc5<] \r\xde\x82\x13/\xa5\x1d\x8a\xfd,\xcdCTy+\x95B\xf8_\x17\x0bD\xe4\r\xc9\x16\x8f\x1e]\xf7\xb7\xea\xd4{L\xef\xb6\x8b]&\xf4\xef\x8d\xfa\xe2J\xd1\x11\xeb\x9f\xf3\xefF\x0f//\x93G\x02\xed\x9b]\x9fX\xb6+\xf2\xc3;\xa0\xb5\xc7\xa1V!Zb\xe7w\x06\x97W4K\x16\xa9X\x9b\x8f\xff\xed<\xefo\xc3v+|d\xf6\x17\xd3\xe4\x15\x02o\xf6\xad\xe0\x0cX\xbf\\\x8b]b5+>\xbd\xf5\x95\x18\x11\x8eG\x04{\xcf\xaaN\x00\x0bqO\xaf\xbd\x00\xb2\xea\x1e\xa0\xcb\xc3\xc92\xce\xeb\x12\x99G\xe6\xfa\x86\xfaq\r\xa9`\xaa"\xc4\x90\xb2\x08\xa2U\xee\xc3W\xcf\x1d\xd3\r\xa6\xd4|K\x1b\xe7\xed7\x12@\xc3^\xc9\xfdF\x86\xfb\x9b\xb59\x13\x05\x9e~\\\xae\xaf\xa7\x128\x13KGE\xc6\x89\xc9\xfa\x8c0\xea\x8c\xe1 \xceu\xc7gN\x80\xd3\xce1b\xee\x81\xff\xcb\x93\x19\x9c&\xd5Pq/,nd.=P\x84\xd1\x0c\xe8)\x90\xfa\xb4]\x81\x04\x8d\xbff\x94e\xad\xa5\xcb\xac5\xbc\xed)\'\xd7>\xd4J\xf2\xeb"\x84\xba\xf5?vZ\xe3\xc0K\xa9\x8cE\xfa\xa2\x12\xff\xa1js\xdf\x0b\xaf\x07\xf3\xb7\x83S\\w\xdf\xbao\xc6\xb9\x1e\xd2\xa7\x96bw\xad\xc9\x16\x1a\xb7\xa3\x04\xee\xcb\xeeo6\xae\x05\n\xc8\xd25\xe7\xbfZn,\x86{\x83\\\x936\x9d\x93=C(\x92SF\x8b\x06\xc7\xa1:\xee\xe7\xecV\x9d\xa3\xa1\xe9\xe3\xd4T\xc9\xcd\xa1I\xd4\xe3\xa7G,ZX\x18\x90\x9d\xc4\xec\x8f-t\x98S\xc8\x96+\xed\x88\x17q$o\x7f6e\x1e\x0cJ\xd5E\x05~\x11/\\\xa9j\xfe\xbe\xc1\x8fz\xe7\xd1\x9d\x82\xd2\xa7\x86\xdbL\x1c\xe2\x82\xc1\x1b3c\x0c(i09\xa4\x8c\xec\xa9\x91}\x8f\x913\xc4\xe75\xef*\xafv\xf1\x82\xe52j?\x19T\x06\x0c\xd6\x07i\xdbF[\x9fV\xf5v7O\x08B\xa4\xf7\xd5\x96i\xde\x0b\x98\xec\x14\x8f\x10|p0\xe2\xc2\xaa<\xa2\xa6\xe9;\xff\xafm\x88p\x159\x18\xa9p\xb6\x05y\x08jO\xa1\xd8\xbf\xd3\xb9\x81\xfc\x82Z\n\xf2&\x16\x981d\xb9\xcev\xfbA\x8a\xecn\xe0\'\x96Z\xdf#\xae\xcf\xad\x06S\x03\xd9\x06\xed\xba\x16\xa4\xa4A\x1a\xde\xe2\x8fr\xd7\xc9\x1a\x86\')u\xe3\r\x80\x0f\x02"7`\xfdV\x0f]\x9c\x83\x95]\x00\xd3\xa5#\x15\x1bI\xae[\xc5\xd0(eXr\xa0J\xf5"_\x8as\xfd\x84e\xc5\x1a\x8e\xef\xaa\xe0\xdc]\x10OT\x9c\x01\x87L\xc4\x97dTh\x82\x9aG\xa5\x82)\x12\xe8\xc3(:\xa6rVQ&\x8b8<\x11$\x8fyd\x8882]\x87\xe3\xf2\xb2mM\xbb\x08\xc9B\xc8\x84\xe3jN@\xd4\xa9\xfb\x0b\\\x8a6vO\xd76\xd0O?\xfd\n\xbd\x89\x91\xbc\x06Zg\r\xde\x9dl\xcf\xee|\xed\xbb\xc0\xcb\x80\x89\xf0\x07E8\xc6A~c\x80H\xd9?\xeb\xeey\xc7\x13\xdc\xfdF\xcf\xd91a\xb5\\e}\xb11Z\x94p\xdb\x01\xdbW:\xf4\xdb\x97*\x0f\xd1N\x93\xbe\xc5O\x15X\xc5\xa6\x86\x91\xd3\xc2\xd7\xd5-!\xc2\t\xe4@\x05Tx\xfd5\x14\xf0qx^\xb3\xfb\x06\x16\xf9\xbb\xefk\xa8\xdc\xfa\xe5)\x1e\xbe\xd4#vg\x88Y\x01\xf1\xbd\xe1\xec(\xb7\x05+\x8ckN\xbf\xbe\xbae6\x02\xd5\x8a]2\xb5\xde"\x07\xda\xc5\x85\x1a\xa9N5\xe1\x8c\x01~\xacC\x01M\x15\x1c\xf0@\xb7(\x95\xa0z\x9e Wb\xa4\x07A\xf3\xd6~Y\xe3\x80T(\xca\x9f0P\xdd$\x85&GP\xaca\xb3r\x82D\xb4\x1a \x16\xba\xdf\xf8A\x0b{\x19\xe9\xf1"\xbe\xfco2m\xebpqhpk\x8e4T.\x9a\xefM\x9d\xf8\xb1\xac]G2q2\xb4XL\x13\'\xber\xbd\xb6Dzs\xdc\xd1c\xb0l\x04\x9c\xba\xc4\xce\xee= E\x98\xc6\x8f\xb1\xc8;&\x8dDC3(o\x1ex\x03m\xfd\xc2P\xad+\xdf\x7fh\x86\xa9Vt~+\xf5U#^\x98\x1b$u^\xee_"\xcdtI\xe8\x81\xd2e\xda\'\xc8\xb7#\xd2f\xffV\xe8>{\xf4\n^\r\xa7\x04\x95\x82H-\xed\x81\x9a\x81`\x8c\xf9\xc2\xd6\xca*u\xca/\x94\xe1\xa1S\xe4\xac\x11j\xa3\xa9\xd40\x8cI=$\xd0\xbd\xfc\xdf\xce\xa3\xbfK\x11#fg\x88\xea\xed\x91\xe0\xfb\x89\xcb|q\x98 D\xc27\x12P<\x15\xe79\xad\xff\xd4e\x01nW\xe8\x81R\x00T\xea\x1d\xd6\xc3\x80\xeb\xdb\x87\x0f\x81z_(\xae\x99\x05\x93&OM\x81\x03[mX:\xdeYW\x87\xf8H\xfb&\xd9}\x84$\xa0W\xd8\x9fb\x8d\x93b\x98\x19\xad\xa9\xee\xacT\xb6\xab\xd5\xc90\x1c\xb8\xb3\x07\x08\x7f\x8ea\xa6fO\xe6\x84Tn\xc6\x1c\x04\x12\x1c\xcd\xb5 \xa9\x04\xdb\x83\xc1\x85WZ;\x13\xae\xc7\x82uV\x87\x05\'<\x8d\xa5\xfd\xe3o\x13\x18 \xbd\xbc\xcb\xa3\x89U|\x0f;\xc4\xa8\x8b\xd4\x93j\xe2W0)\xbfxo&\xed\x89\xafQ\xfa"\x10e\x99\xcf\xc4\x07\xfb\xef\x89-\x9f\xf2o\x07\xf2\x14\x02J\x94\xa6\xe2\x90]\xe4Mpi]\to\xed|S\x18F\xc9\xfdHj\xd7?\xe4&\xdf}\xd9\xca#\xb7\x1d\r\xe3\xa6\x83\xb1\xa2\xae\x8cER j\x0ch\x7f8\xa99\xa3\x87\xea\x19\xf3\xb1\xcf$\x18-b\x8f\xaa\xec\xb9\x86\x90\xbe\x12\x04l\x1b3)\x9f\xca\x9d\x92\xff\x96\xb5\xb6\xdf}T\xb7)\x08\x15;\x93Z\xe0\xbc\x9e\x8b:\xf4\x95\xf8\xab\xb0\xa0\x8bhnj\x0e\xc9\xf2\x85\xe4\xc0_\x15\xfa\xe1,!b\xe9y:\xfa\x8a\x076\x8de\x8b`\x97\x13\xad\xce\xcb,+\xfb?\x1e\xe9eD\xa0\x04}\x9d\x1bR\xd2\xe0\n \x88A\xd5W\xc0\xf1\xfb\xb6\'\xc0>4\x9c\xb5 \xe4\x8c\x16\xea#\x85\x12\xbc\xbe\x0b\xa1\xb1}}:*.\'\x1f8\x10n\x16\xf6=,\x0e\xed\xdf\xcbG\x88n\xa5\x80\x08"\t\xef\x99\xf1:\xf7\x18\xe6g\xf4\x18!=\x12\x00m\'G\xb8\xda\xc2\xb3P\xd9w\x80\xa8\xa8\x86}\x00\x0bs\xda\xc9\xa2\xee\xe3\xd6`\xd1\x82\xa3(\xf4\xc6a\x91|\x91\xbe\x07\xca\xd3\xd8*\x1b\xeb\xccT\xa8\r\xb6C\x99~\x91\xc0S7\xc80\xf9~\x0b\xf5C"\x1elg\xb5L\x04n\x9b\xb0O\t\xb2/\xd9K\xcc\x90\x8a\x17\x18\xcf\xe5\xab\xc8\xca\x96\xacl\x8f)q\xe7\x83W\xc97\xb7@8\x06\xf8\x89\xfb\xb5W\xc3b9\x8bo\xf0\x0c\xd4\xff\x9bV\xce&s\x13H\x9dvaMm\xfd\x8fu]\x9b+\x9d\'\x9dn\x8e\xe2\xd9\x82\x8e=\xe7\x8f2\x08?M\xa5ob\x83\xd6]\xe4.\xf0\xf1\x8bh\xa8/\x19\x02\x83\xd6\xba>C47\x0b\x1e\xd4\xdaY\xae#\xd1\xca\xebU<3\x02\xb1y\xf8]\xaa\x1f\xce7\xf4\xa0\xc8qO\xf9s\x14VH\xe3\xeb^_\xf0\xab\x1f\x90Z\xab\xc3\xb2\x17\xfc\x94:\xf9\xef7\x1d\x1d\xa4\xcf\xc5\x88]\x1e%\xaf\xa1\x08\xc8H\x10\x0b\xf9\x90\xf5\x07\xb5\xd1\xa4\xc8*\xd5\xd5\xdaS\xb5,n\x9e]"\xa0\xcf\xb0V\xf754ccsM)Omi\xe6\x8f\x0f\xf4Cp\xdc\xfa\xab+\xc3]\'\xa6\xcb\x9bhL\xfe\xb3l\xfaZ\xfeP+\xa8\\u\xaet\xa8\xb0%0\x81\x1cw\xf3\xae\x93\xc8\xb8\x9a\xd1\'\x11p>\x7f\xc4\x8b#Qr\xce\x7f\xe1\xe1\x151\'^(|\xe5\xe0ZxW\xce\xdbA\x9a~\r\xb3\xbe\tr\xfa\x1f\xb1y\xe7\x1a\xe2jL\xa7\xd8\xb00k\x19:~U\x83\x93.\x15\xc0=X\x01\x98\x93\xdc\x1b\x9b-\x91[tu\x84\xf4\xe2\r\xa73\x84\x9e{\xb7U\r\x9a\x06\xf3\x88#\x89\x1a.B\x04\xe4\xd0G\x08\xf7\xe5\x82\x19\xea\xfa\xf24\x14\xc4\xf1\x0c\x19\xbe\x81+\x84H8\xf1\x98\xed\xa7\x1e\x99\xf49\\GC\xb5\xb2\x14\xeb\xd4L\xfe\xd9\xdeX\xcaP\xaaP\x89\xdc\xc7\xb3\xee\xbdZ\xe0\xf9j\x80\xf9\xc9\xc9Z\xc8\xc9j\x91\xb1\xed\xb0.\xde\xf6\xc5\xa6\x9dW\xfdo\x00\xeca\xa8u\xd5\x14k\xf8B[\xec\xb1f:\\\xfcB\xb6k,\xae\x89}\xd1\n\xad*\x95\xf1\xb3F\x04/:3;\x0e8\x97n5r\xd0\x0e5}\x88!\xe3\xccYm\xe8aS\x06\xa7\x15\xff\xd0\xaf\xd9ZZ)Z\xf9y\xfe\xdfC0\xb6\xf2\xbb\xf9\x02\xc8\xe3\x18\n\xaa\xab\xb5bQ\xb6\x1c4C^\xc7\r_jG\xf3\xb8\r#SC\xceS(\xcf\xd1?\xdd7\x13\xa2\xdc\x00\x1a\x04\xd2\r\tKO$\x15<\xa7\x12\xcf\x19\x9d/b\x83r7\xf4\xb7\x90\xc1TtX\x87\xf9\x85*c\xe8O\x17\x01g#2B&\x1d\x7f$\xfa\rTs\x9e\x83m\x88#\x98\xf0\xef\xa2\xfal\xadee\x148\x8e\xbbs!\x89\x90\xbap7\'\xfbV?\x97\xe0\xf7\xc5L\x7f\xe9\xae\xc2\xf6\x8b\xd4\x06z\xfdi\x19\xab\xadN\x9a\x98cm\xaa\xf3S\x96\xdcR\xcc.\x8f\xcdL\xbe\xb8(C#`\xf7F$\x01\xe5\xbd\xdb\x8eoT\xe9\x13\xc4J\xa7\x82\xbf\xa8\x1ev}\xb8\xe9\xbc\xbe\x0fS4\xa7/\t\x08Kv?(*\xcf\x8f\x15\x11\xde\xfem\x9a\xb4\x99\x1d\xad\xdc\xf8K{GqE\xd2\x1d\x98Fr\xcf\xae"\x00\xa5\xaf(\xfdi\x8cE\x98]h\xc2\x9e\xaa\n\x17\xfc\x0b\x03(\x83;\xda\xde\xcc\xc9\xed\xce\x83n\xb4\xe5\xd2\x99\xc6D\xef\xc2s2l\x1b \xf5\xa2\xde\xa5"o\xd5d\xeb\x9fl:@\xc9\xe2\x83\x00\x13\x98\xf1\x16^\x81Du\x17\xc4\x89\x0c\x1e\x1b2{\xed\xe0/\xec[\xd7\xd4\xe9\xf00\xd9\xad\x9aA\xd1\xf5V\xeaLq\x9cB\x0b\x80\x12\xe3Z\xd1\x1cW\xd6\r\'6\xe0<\xdb\xc5\x1d\xd3\x8c8\xc4Kq\xd3]h\xa5s\x04P\x94\xd1}\x94\xf0C/\x06\xda[Yh\xc7\xe8\x19bUpG\x82\x81J1g\xdc2\xae\xf9h\x93+\xee\xcf\x18J\xb0,|I\xb1s\xc0\xc7\xe9yMs\xfa\xf4?\xbfe#\x89;\njf\x83\x97\x17\x17}z\xf8\xf8mn\x84\x9et\x88\xae\x81\t9/{\xc9\x18 ?\x8d\xe5E7\xdd\xe9\xe8r\xcc\x0cy\xae8\xddE\x0f\xe5x\\K\xeb|\xfa3\xe0\xb6H-b\xb6\x17\x8c\xb0\x97\xda\xb2\x81xx\xf5\x86o\xf7\xe71\x7f\xfa\x90\xd4\xfe\xfeq\x1d\xa1\x1a~\x1c\xf6\xea\xad\xaa0\xd3\xc4wK\xcfeU8!\xa0\nw\xe1Z5\x18\x03\xee\xb8;\xd7\x9e8\x1a\xb9\x14x0\x19\xbd|\xacl\xc8\\=\x1f\xe1u#\xd8=\xaf\xaf0\x0f\x15\xbe\xf0\rw)\x17\x90\xa5\xbb\\\xbbs\x97f\x98\x87\x19\xb1K}k\xd2\xe1\x02A\x08\x86j\x8a\xe8\x03\xb0\x88\x98g\x0bd\xbbK\xa1\x0c\xb9\x12\xed;\xd8N\x11:\x1c\xb5\xfa]T\xa8.|E\xa1\x10\xa3\x1e\xba2\x94\xa0 \x1a\x99$\xc7w\x14\x9d\x08k\xecz2\xd93 \xd6\x91\xd6E\xb4T*\xc8:\xfb\x8e\xcd]\xfb\xf5\xbb\xcfX\xeac\xcbL\x80\xa2\x82Y7#\xae\xf4\xb3\xf4\xf1$\xce\\\xb2N\xdf\xed\xb6x\xce\xea\xde\xeaR\x1b\x04z\x1c\xa2M.a\xaa\x0bax\x80\x01!\x83\x17\xd0\xe6|b\xacy\xfa\xacq4#t\x91\xdaBJ\xd0v\xf5\xcc4\xe9~\xa3?\xd2\xab\x95s\xe9\t\xc5n\xd1\xcd\x01C\xb2\x87W\xe1\xab\x82<)\x88\x81\x16\xb6\xdb\xae\xabz\xbc\xb7;\x16\xef5@\xc5\x84K\x06\x8c\xf7U\xea^V\x7fk\x9e\'\xef\x7fp~W\xb5!\x14?\xac\x06H\'\x83\xd9\xc1\xabU\xa34\xc8Z\xf5\xe7\xd2\x04\'4\xba\xe5\xa3\x9a/\xda*\x94}\xf5#\xc0\xf9\xda\x12\xd9\xe5\x00)\x02\x91\xd2\xe2\xe6\xc8\xfd\xd6x\xfa\x93\xeb\x07\xc0\xf3\xf3eZ\xc48\xa9\xfez\xba\x14\xd3\xac\xf5?^6=\x06+\xafh|G\xec\x02\xe2\x02h\x84\x8dp]\xf0\x9b\x1a9Hd\xfd\t\xe1\xa3!RAo\xff<\xb2\xfb\xe4\x9f@\x90\x10\'8\x8ei\x90W\xef\xc1\xe5\xd0\x04\xbe\x88\x02m\xdf\x8b\x8eon\xb34Ijg\xc91\x8dg\xff\x0e\x8c\xe0B\x1a\xf2\n\x86^IA\x9a\x95K\xc0\xa9\xca\xde0v\xecH\xce\xf7\xc5-\xab\x93_rw\xe6oo\x14E\xdd\xb1\xb4[\xa4\xd3\xb7OK8\xeck\x90\xe0#\'\x0c`\xae`\xe9j\xc5\x08:\xd6\'\x1eQZW\xc7\xc1\xfb\xae!7\xb2\xeb\xd9\x04\xc8+\xa7s\x08O\xa0\x8dSB\x9c=\xce\x9f\xeb\xaf\x8eS\xe2\xef\x17\xcej\xd5bz\xe2T\x8f9\xab\xf8\x1f\x08\x8e\xa3\xdf\x1ah%yC\xcbT\x86\xb9\xc18\x16\x1f\x19\x13!\xb7\xd6~u(\xe6\t\x90\'\x19\x15\xcdmcHvD\xcf\xe1\x03\xdc\x97\xa6MO9\xc3\x97\x83\x9e\xefg"\x95\xc2\xc6B\xcf\xc1\xb4\xd7Uub\xf9\x91b\x8c\x04\xd8\x01\x9d\x9ey]f\xf4"]N\xbb\xe2\x91E>\xa2\xbf\xc36\xc9\xf7\xa8\xd3\x9c\x9c\'io\xf65\xf7\xe3M\xca\xb8s*\xd1\xc4\xf4~|\xbd\x0c\xf4~2\xcc\x8c\xbb\xe2\x08\x1e\xf9\xea\x16~\xf3-~\x90W\xd0*\xc6\xfb_\xb6\x8b[\xf5\xd9\x00\xfb\xf7*%U\xf8\xd0\x17\xe4\xfd\xee\xabq\xd5\x86\xbdc\x9c\xd8|q\xde\xeb1!W)\x9axi\x1b\xea\xfd.\x85W.\xbc\xdd\x120r\x9f\xf5U\t\xeb\xe7#\xda\x01\xf4\x824|\x03\xd5\x1a:\x04w\xf0)\xb85\xca\nO\xcd\x98\xefhu\xfez\xc0\x11\xd7\xd4"\xf3\x02=d\xe1\xf8\xfdi9\xff$\xfcB\x01\x83J\xc3\xa7F\xd7\x93\xaf\x08(|\x8a(\xea\xa0\xf7)\x00gsW\xc2\x90\xfe[z\xb4\x95&\xc7\t\x9e\xbb\xfc\xf1\xfe?\xa7\xd2@nr\xc5\x9d\x9c\xba\x83\xf9\x10_\x9e\'\x15\xd3\xe5(\xee\x0f\xc6\x1c2\x90OEC*\x12\xc8\xb3m\x8a\xe9\xe9~\x1cY\xd8\x0b\xef\x9ab\x04<\x11\xac\x00X"\x11uD\xcb\n\x1f\xcf\xba\x08]\xd2(.$\xb0\x9a\x9ef\x123G\x8e\xce\x0b\'\xc2LU\x04\x8a\xbb\x99\xfb\xfa 8\xff\xeb\x03H\x8d\x977#N|R\xbax\xfb\xef\x85\x03\xebZ/0\\\x9b\xc2\x88\x05wUq\x86\xbeps=\x0ep\x8d\x98\xb4\x9c\xb5\xd0\xf3LV\xd8\x03=iN\x95\x14t_9\x8e%\xb0\x0e\x80;\x06e\xe6W\x9eXC&\x0e\xb6\xa7\x9a\n\xc4R\xebe\x1a7\xff>\xdeon\xe0\x0ew\xfa8\xe6;\xdc\x8b\xdc\xfe\x91\x16\x07\xc0\xd0\xa6\xd3U\xbae\x8e\r\xd6\xe8O\xc0@\xc9\x9b\xc4\xd9\x99\xa89\xd8W\n\x95\xf1\xfb[0\x82I\x91\xba\xe6/\xfa\xf48d\x15\xfd\xbc\xc1\xd0#|c\x9d\xa86\xb1\xf3qZm}\xe2\x98.\xce+\xbf\x1c\xbb\xa6\xc9.M\xc0L\x82\x11\x18\x14\xabq\x90\xdc\xc1\xdf\x9d)\x08HGT\xbb\x19\x93\x93\x9c~\x00\xa7%c\x15\xe4\xc8\x85\xb4\xa0\xb0\xcf \xe9!m\xd8)\x7f\xf5\x91\xccu\\\xeb\xfd\x90\xcb\xa93\xc4\x0c\xf4\x145\x86\x0b\x1d\xba\xe4\x1c\xf3\xfa\xf7\xc1\xd1\xac4/\xaf\xa5\xa8\x95 6^\x1b\x95{d\x98\xe9\x17\x04#\xae!\x10\xa2\xd8\xee\x15\x1bL\xcd\x00\xdf\xcfS\xbc\x8c\xe3\xcfF\x8c\xd1\xf4{6\xe1\x12dz\xc8q\x1f\\l\xc2\xd9~\xa5\xa8\x95\x9a\xf8\x0cZ\x1e\xf6\xf9\xaa\xc7\x97\xdaI\xd8\xae.\x83PZ"\xae\xf5\xe9\'j.`\x99\xf9f\x07\xa0KW\xa7\xac\xadqp\x04 \xa3\xc2\xf0\x1f\x00\x00\xf5\x82\xca28\xf6\xa6\xf4\xa6\x99\xc8\xf3\xc9/A\xd7\xa0\xf0\x14>>\\\xb8\x05\xbc*\xff\xac\xa3\x84\xdf\xd4\xf9\xa6\x1e\xc9\xe6\xc1<\xd6\xe7W\x12\xaf#i\xc8\xc5@T\x94\xe4\xa3\xde\xaa\xf4\x95\xa6,+L\x07v\xf0\xb0\x88\xf2\x9a\xf6\x7fyh\xfdc\x94(|k\'\xf0\xad\xa2L\xfc\xd6!6\x19Q-\x1d\x94\xc8\xeb%\x9f\xd0\xc06\x84\tu\x10\xb9T\x9cF\xb6qU\x1c\xb3B\xfe\xd8\x8f\x02\xdae\xda\xa5\xf1\xbf%x=\n\'\xbak\x06\\\xb3\xb9q*\x07p\xff\xdc=C5\xef\xdf\xf6\x9e\xda\x1e\xd8\xec\xf6\xb6\x18\x1d\xf9\x1c\xa3j\xea\x95jX\xb6\x12SJ#\xec\x83\xad\xff\xbdG9:w\x99]\x11\xbbN:\x82\xb5\x9cq\xbd7\xef\x8e\xf8Q\xc5\x9a\xfe5\x84\x10l\x85J\xfdy!\xb9\x05\x02\x12\xe0\x8e;2^=\x11\xf15e#\r\xe2\xdfV\x1d\xff\x87\x18\xe6\x03K=\x88q\xfa\xff\xfbg\xb8\x9e\xbcq\xaf\xd8\x00\xf5\xd4\xc0\xd4\xcc\xf7\x86\xb2\x8b\xd1\x92y\xf2\xbd\xeb\xf69\x1c\x93\xd9sc\x1e\xb6\xbe\xb1\x94Yau\x03@\xab\xc2\x84\xfc\x05\xd7\xc2\x7f\xc8\x8b\xf4\xac\x82\xc9\xd5\xc6>\x07y\x11\x8b\xadU\xbf\x11e\xbe\xaaET\x18\xb7(0\xfb\xc2$\xed]\x9czP0\x01\xb2\xfc\xf2\xc3^\x87\x9d\x14r\x18\xba0\x07\xd2w,\xe4\x9eZ\xc1\x98g\xf9\x9fT\x1f>$\x8a\xb9\x84\xa6\xa6\xb8\x85\x1b\xdcl\x1f\x0e\x96\xba\x89_t\x9e\x84\xd9\x0e\xf9\xb6>\xca\x91MA\xa0\x00\xd6=\xe5\x97US4%D`]D\xf2\x12\xed^A\x8b\x959M\x16+\xdb\xca\xf4\x00rE,\x9a\xc8\xfa\xf8`A\xbb\x12\xb8\xd9\xe0\xf13\r\xdbt\xfft\xa2\xccZ5\xc4\x92\x81CM\xa1f._= \xf5L\x06\x1a\xe1\xffx\x1a\rO\xfe~\xean\xb6\xa6a\xab\xf0\xbdN`\xcc?i\x94P\x1e\xc5q\x86\xc4\x8b\xdaW\xf2n\xc5\xd7G\x01m\x08z#\xd6=\xd6a\xf0\xb6\xe4\xbdjc\xf2(\xbd}\x8b\xb8\x1ded{\xfe\xd9"};G\x84\n\x99\xdbgy\x81]\xdaT\xee\x00K^\x97\x84[\xda^\xa7\\\\\x0e\xe8I\xf6\x03\xf7z\xd2\xd2h"\xde\xdaD\x9a;Q\xcf\xeeO\xab@\xaf\x87_\xfa\\H!P\x19\xfe\x14h\xc4\x96v74\x93\xcfP\xdc\xce\xbf\xe4S\x10\xf2\xc8\x0bH3q\xe1\xd1\x83*\xf0\x1f\xab\xaa]MFjp\xff\xa7Zfd\x8f\x8bQ\x85\x0c?\x9a\x0c\rI\xe6\xf9y\xfe\x85\x85\xc3\x87\x02\x85D\xe8\x8c\xddL\x97\xbd\xddw\x82\xa2\xaf\xed\x10\xff`\xfc\xb7F\x10\xc51}\xf0\xe5oE\x06\xf6"\x11\x87s(N\x1b+\xf4\x92\xf1\xe2\xce\x95.t7\xf5\x03t\x18\xf2\x19\x80\x9c\xb4!\x95\xce\x111[\xe7d9\xfc\xbb\xa4LBy\xd8\xcd:O\xd1\xf2\xe4O\t c\xe2\xcb\x8a\xdf\x0c?#\x10\x1e\x80\xe7\xc1\x87\x94\xff\x94\x84\x19\x80\x0e\xb8\xfc1I\xe6\xeeF\xcf|\xf6_^\xe2\x16\xcd2\xfc\x95\x99\xb4j\xe7)\x81\xfcRtG~\xea\x13\x1f\xd8\xeb\xe0\x1fbw\xafH\xe5\xc4\xa5\x16i\xfb\xb2\x97\xed\xf9\xc6\xacC\xf7\xc3\x0bm\xd5_\xfbR@\xfa\xed\x84\xfa\xb7Up\xc6\xf7\x89\xbd\x1f7\xd8\x07\xeb:d@\x0e;;\xf2\x12\x84\xbc\xff\xac\xf9\x18\x85\xcf7\xdeN\xab\xfd\x062\xf2\x83\xbf\xb7\x91\xe6\x94d\x90Rx\x9c*Lxeo\x1b\x84\xde\xcc\xdedNy\x0e|\xa2I\xffc\xc9t\xa9\x19\xbb\xfcuFb\xa8\x88\xb1gb\xef\x9a7:\x08i$\x9b\xf7\xcf$\x14\xc9\xd0\xe5\x94c\xe1\xb6\xa6\\)\x9e\x14\xaf\tj\x03z"Wo\x8cn\x02\xba\xa2\x04\xa2\x14\xa55\xff\xbf|\xb8\xfb\x01\xa7Gd\x84&&V\x1d\xe9r\x0f~\xedAO\x9bY[y?\xd5\xc9P\xbb\x95\xce`\xf19X\x81h\x96\xe4\x94\xf5\xaff\xd8&p\x0e\xc7\xaa\xc9\x1f\x82\xccS\xae"}\xb4;9A\xe5\x08i\xb6\xb4K\xef\xc3\x82\x11\xf8\x10\xed&4~`?>\x85%\xc5\xfc\xd5\x8b\xb1\x80\xff\x08\xe6\xfd@\xbe\xa0\x05\xce\x7f\xaa\xac\xbb\xbc\r\'-\xbd\xafG{\xef\x11\xa3&1Dk\xd8\x9dXX\xdb#\xaa\xc8\x8b]*\x99\xfd\x14*>m|\xf2\xdb\xf2\xcc)qhW\x96\x8eTu3;m4)>\x01k=+\xb8\xcc\xab\xc5\x82\xe6=\x15D\x8e4\xda\xcdJ\xbf$\xfb\x7f\x07\x92/(\x08B\xb2\xa3\x11\xca\x1a\r\xfc\xd78\x8bf\xe0\x9c\xe3\x18V\xe0\xf1\xf4z\x1e\x89Z8\xe5\xbd\x92\x07Q\xd7Vn\xaf\x7f\xf0gt\xa6\x9f\x1f,l|i\x9c\xc56X0S\xe8\xaf\x00\x0f\xfb.<\xdd\xbe<\xe1\xa5mF\xaf>>h\xcdv\xc7\xd0\xc7Z\x1e\xd1Sx\x116\xe1\xe0B\x08\xa3ZpO\xbc\xc6v\xf8\xfeS\xce\xed^\xffa\x00\xeb\xa0\xfbf\x88\x1fA\x7f\xb8\x90\xf3\xc3\x90h\xcf\xb3\xd6\x16\xd5\x1a\r\xe82\xbazy\t\xee\xea\xc4\xb4W\xa4\x8a:\xbeX&\xb8\xc7W\xac\xd4\xaf\x1aG;\xb1hR*:\xc7S\xbcsW\xa3\x8c\xf2\xafi\xcd\x8a\x97B^\xd2]\xa2\xc5\xcb\xc1\xf3\xa8\xed\x10\xe9\xe4\xa7\x80_|&\xcd\xc9A\x17D\xf1@\xcf\x93\x86\xf0\x1e\x10\xe8\xc4\xd3?\xf9\xc8N\xe8\xea\xfd\x01\x07\x85\xb7\xa0\x02\xe3}\x0cT\x17C\xce\xbe\x969\xe4\xb0g9i\x81.\x94l\'\x1f\x07\xc7x\x7f\xe7}1|\xff\xb1\xda\xe2\x92\xcbN\xe9\x83\xe7Kxa\x01)Q;<\xe3\xe0\xa9x\xc6\xed8\xbc\xa2\xccZ\x97\xa1)N^c^\xde?\x82.N\xe4N\xf8F{\xefG\xf3|\xeb?\xb8\x03\xaa\xe2\xcf\x94XM3r\xffs\xe1&2|ZE\xa3 Os\x8223U6\xf7\xdd\x06\x99\xd0\xd6\x04\xf0\x9e\x987\xcf\x07l\xf6\xb2\x19\x81tLa\x9e\x14y\xe3\xdd\xf7\x07\xccN\xfc\x7f\x1d\x8c\x8c\xa1\xfc\x06^Cu\x80\xa1\xf4r\x87&\x07\xfd\x83z\xf1f\x0c\x8c\x00\xd1Y\x9bY\x165\xc0\x014\xa6\x0f4\xfa\xe3\xf5\xfdP\xcfm\xa6d\x0c\x11]B\xb0t\x8eg\xec\xce\xdba\x8d \x1dL\xfd\x88\x17\x8b34\xf0\xb0\xee{\xa3\xf2\x82\x99\xba,\xcc\xd3\xda\x1b$\x8a5\x9b\xc8\xd4cV\x96\t\x9f\xe4\xac`\x8flo-\x9a\xd4AQ \x9bX\x19>r\x17v+\x8c\n\xd8o\xaeX:T\xf6\xa1\xc3\x93\xe2\xf5)\xbe47\xb3\xef]\x94$\x17\x7f[/\xb3\xdarM4\x91\x1c\xd2g\xc6\xd6\xdb\x7f\xf3>\xa71S\x87\xbb\xbe\x1fp\x00\x9e\xad\xc3\xb8\xfb\xb5\xee\xc37\xfe\xd7%\x14\xf8y\x04\xdc\xdd\xcb\x1d\xdf\x91Im\x07\xf6j\xe6oe`c\xcb\xd4\x07\x03\x96R\xcb;\xe6\x93\xa0\xa0\xbf\xcc\x1e\xbe\xfb*\xfe\xd8\xd25\x8a{\xfb\x94\xf8\xab\x0e\xe7l\xbb\xf8g\xd2\xbb\x81]y"\xaat\x1f\x83Q\x82l\x11\xf1e\xaa2\x91\xbbjh\x03\xcfi\x85\xf7\x82$\xca(\x1e`\xd0\xe4\xe8\xad\x15j\xedJ\xa8\x8e\x02E,\x96^\x9f\x82\xe5Q\xef^\x08\xec\x8eZY\x1erz\xbf\xca\xa91\x8e\x1d\r,([\x1b\xfa\xf3\xfa1)l\x87\xfc"\xfa\x8d\x0b,\x86\xd4\xeb\x83\x7f*(\xb4FfD\xc8\x9e\xa2\xfb\x00\x0cj\x0f\x7f\xcd\x0c\x9anU\x90\xf0g\xe33\xbb\xaf\xd7\xbb\xee\x1f\xa7C\xcd\xe4\x1b\x14-\xef;\x86\xc8\xba\x14\xc1\x88\xb6y\xd2\x80\xf1\x98-j\x9ci\xe7\xed\xe1G\xa9Y\x04\x83\x0evx\xa9<\x9a\xca|\xb0\xee\xeb\x12\x98\xcb\xd3\xf84[Q\x14\x8d\x1e4\xca\x96\x8d[`\xf1o\xefV\xd6\xbc\xf4\xdeC\x18\xa5\x94"E9\xe3\xb3\xdb@X\xa9\xcc\x03\xebUB\x94\x8b\xb3\xc2\xc0V\xf2\x14\x95Uf"\xec\x8e\\\x99\x95&S\xf0\x1fKg\x8e\'.\xf5\xcd\x8c\x172.\xf6\x15nu\x13p\x1f\x94`\xc0\x82%\x04u\xf6}\xfcy\x85\x95\x98\xa8r0gf\xb4\xabis!\xefa*\xd4\x8c\x9ax>X\x0f\xb1@(k\xc4\x00G$\xdf\xb2\x8d\xe7\x85V\xfcy\xbc]\xc8X\xc4M\xb9\xa4\xc8\xed\x00l\x87\xa6Y\x12\xc8\x8e\x11Y\xe8\xfb\x9e\x1c\xf9j\xfe\xbf\x11O\xbbg\xbbq[\xbe\xad_!\xce\x8fU\x1cV\xf9\xcf\xa0D\x93\xa5\x88kd\x0c\xc2\xf5@R\x9cb\xfb1\xc9b\xd2Y\xe9\xb8\xb4\xb0"\xa8n6M\xf6\xe9\xb9\x92\xb2J\xaf\x17\x15U\xf8\xb5\xe1\xd7\xcb\xf6.\xb2\x02\xc7\x1e\x06\xaa\x00\x19,\x19\xb0\xca8\xb8\xd14\x9bW+\xe3h\x17\xb0a\xae\xe9 l\x9c\xbe\xb3X+\xb6\x99\x11\xd0\xc4Gi\x8a\x97r\x92?\xdd\x87\x80]\xd0\xd9is\xf9\x01\xa1x\xe3\xc05\xab\xb3&\x17f\xca0\xf4\xbb?\xaap\xe7\xe7\xf4P\x90\x85K"\xef\xd8\x0b\'\xa0\x9c"\xd7\x99\xef\xff]\xe7\x80\xa0\xc9\xaf\xf8\x1f\xaci<\x89\xc1\x05=\xb6+\xd4G\x07\xe8\\\x0c\x80\x95$\x8f\xee\xfa\xe5M=\xb8\x1a8B\xe3+I\x03_\x80\x9dY1\x1d\xe2\xd1\x95\xc7\xdf\xa0\xd9\xb5\xb9e\x1d\x18\x197l5|\xf8\xc1\x1e\x0e\xac\x8f\t\x05d\xf7\x81\xab\xdahP\xf6\xf6\xca2\x0e\x1a\x06\xbfG?o\xf9^von\x93ePuN\x8a\xe5\xfe\x17\xf3\x07Pk\t\xe6\xb7\xc5\xba\x80\xfaI\x96\x157\x00\t\x81\x8f^\xa2\x1c\x88\xdb3\x16\xe5\x8b\xbb#\xc2\xde\x86\xcd\xe3\xc4\xbf\x8a\xb5;\xb0\x8d\xb1\xe1\xdf\')\xd7\xb5\x8dW4aL_\x9d\xbe\x84\x07;\x05\xb4\xeb\x8f\x83\x98\xfd\xb5\'\xac:h$\xa1\xc9\x1e\xe2\xb6\xf21\x02\xa8\x02\x02\xe3\xaf\xc9\xdcn\xf2\x98\x8b,\x813\x91\xab\xe0\xa7\xb2\x949bY\xac\xa9\xa5rZ\xc3\xd0\xdb\xbd\xfb\xec\x93d\xcc\xd1Jy\xbc\x84\xd4+\xd4s\xec\xed\x82\xf1\xf0\x02\xcfJ6b9\xdd\x02,\xb0\xa0\x99\xcd"\x11h\xe9\xb1\xb0\xf71\xf09\x02\x94qa\xd2\xb6\x86\x1f\xaf\x80\x03\xd3V\xc2y2[\x14\xea\xa08>\xaa0\x03\t\x96\xffd\xd2q}\n\x85\xbe\xda@\x89\x9a\x1f\xc5Qi\x8a\xe7\x0c\xd5\xcf\xc5\xaf\x92\x96\x98\x08\x97\xc2\xf9PYd\x1a\xf8KE\x1aHU\xfbK\x89\xd52\xee\x97\x0c\xb6P\xe22\x0f\x7ft(&XX\x18N|H\xc9\xaf\x0f/x+\xb8\xc2\'\xdd\xda\x8d)\x92=\xdclBX"ZD\x814\xfeGv\xc8\xd9\xeb\xe3dE\xdb%\x8f\xb1\xf9\x86b\xdbL\x91\xfe\x05LSL\x8b\r\xd9\xfb\x9f)\x1b\xf1*N,Vb\xc3<\xe3+\xb6I\xa2\xe8\xfc\xa5y\x08rV:\x04\x9cOj\xc4\xb5\xf0vd\x88\xe8\xc3U\xcbJ\xf2\x04j6i\xf1\xea\xe3\xaf\xe0d\x8d\xffJC\xa56\x86<)\xa4\xbf|J\x114\x07F\xf3\x93\xa7 Yj/d\x15\xaf\xbb\x1a\xd3\x02\x91p\xd6\x14\xb5@\x8d\x11\x91\xde\x1fw\xd1\xd3\xd9\x19ZV\xcd\xff\x96\xab\xe33\xa2M\xc4\x8a\xb8\x92\xb8\x173\xa8\t\xd7\xe4\x8a*\xc4%\xb5\t\xa4\x9a\xb8W\x92\xc0i\xb4\xf7\x12\xac\xa5\xbd\xa0\x00\xd6d`\xe1-\x91\xcf\x0b!\x07\xc98\xa1\xf540\xf2\x1298\x1a\x92\xb3\xafu\xd0\xf4b\xff\xbd1(\x0c\x89G\x17\xf7\x00bO\xea{\xe5\x01\x87u{\x87\xefN)\x1e7\xf4\xd2\x8a/\xdfj\xb1hs\x18a\x83\x1a\xa3G\xc3G\x0cQY\xac\xec\x15\xdd@\xfa\r\x1c\xe1#\xba\nF\xce"\x8b|\x84b\x9c\xf0J\xa5T\xf1{\xad\xbf:\xb7\xc6\x99o\xf3U+\x94\xbe\t]q\xc4\x80\xc0\x080v\xfe\x15\xb7\x07\xbc\x92\xa4\x15\x13\x97\x18\xf3F-!\x9b\xfa\xb5\xb6\xd8\x92\xe3\xb5\x85\xb6\x8c.4\xa8\xc8\\?X+GM\xaf\xed\xb2_\xc5\x94BD+\xf6\xcf\xd4\x9f\x1fW\xd6e\xd1\x9e\xd2\x9d2\x84.3\x13\xd8.X\xa8\x02\x82v\xe1\xf0\xeb\x8a$5\x8e%\x82X\xe5\xd7\xdd\xae\xa9~\x9e4R\xa7\x9f\xc2\xe4\x07\x89\xc3\xff\xa4V\xb0\xbc\xd9\x06\xb8\xcc\xb6\xba8P\xab\xc0\x01 \xce9a\xf1y\xcbW\xae\xe6]\x11\n=\x9dg6\'Rk\x11\xa7Z\xaa\x0b\xef\xc0\xf9p\xfa\xc1u\x183N!\x88L\xb8\xf2/N\x1a\xd1\xa8\xbd\x9c\xfa\xe0\x97\x9a*\xda\xa4+\xb6y\x97\xab%?u\xd7[\x08\xecQh\xa8x\xf2K\x94\xc1@\xc3\x08\xa0\x8d\x8e\xfb\xef\x00\x12Z\x0f\x8c`iP\x92C\x12\xa4\xa7m\xc2\\^]H\xda}bZ\xc4pW\x82^a\xe6\xd0~\xbd\x83\x06\xe1\xbd%\x89#\xf8\x19\x11\xe7\x1a6-\xdeo\xea\xa05\xff\xbf\xc6u$]O\x95N@\xf9\x12\xb4\xa0\xb4z\xc5\xa3\xd4\xda?o\x801z\xa6\x9e\xa5:a\xa3\x81\xcf\xb9\xd8Wc\x1f\x9bW\xdeN\xf8!\xd8<\x83r\xc9CdG\xeb\xda\xbc\xf0\x8f\xb0\xfd\x90\xec\xd4\x15\xb1\xa8oV\xcbj]\x84YK\x80\x8a\xe2\x91\x15\x88\x13\x97\x1cT3O\xa4\xd0\x92\xe5\xd1\xc1\xa5\x1de\xb4\xc1\xde\xabe\x999\xdb\x14n\x87\x95H\x93\x01\x91\xb1\x80\xc4\xb5{J\xd6\x83\xe9\x19\xa6\xbd\x05$\x82\x19\x13!\x1a&\xe9\xcc\xa0f+}\x13\x9d\xfd\x06LvH\x11\x05\xe0\xf3/3+si\xe9Jm\x1aW\x1c\x14\xc1\xa2\xfcQ\xd3:a{\xc4\xe7\xf8\x7f\xc61\x1c\xb4\x02\x085\x11\xac\x8c\t\x95\xb8\x80_\xee\x00\x99\xfd\xefY\x9b\xdd(\xe2\xa8V\x1f\x0c\x7f\x01\x9a\xe2v\x06`\xb2\xe6`\xe3J`d\xb5\xbb\xfbs\xb11\xd1mQ]\xc4\x96\xb20\xf0\x9bA\x18\xcb\xb8DKr\xeb\xf2hn$V<:\xff\xd3\xd8\xff\xdd\xbfY\xca\xc1\xd7J9Rfa\xaf\xbf\x92\x03\x93e\x07\xd1\x80>\x83o\xd6\xe6!\x10dlA\xed\x88\x11\xdc\xa43\xa7\xcc\xe7\x11\xe3)\xba\xd0\x13AE@\xff\xf1\xc0\xff+\x9a~\t\xc7\x0e\'x\x86\x1d\xa3q\xfa\x91\xfc\xcce\x00\xd8\xb0O\xb7\xb6\x07\x9a\xddp}\xd1\x06\xc9\xd5\xec0\x16i\xf8yM\xf4)m\x85\x03\x00\x88\xc73o4\xdb#6\xe34$\xebc\xbd\xceB8\xe3\'\x00a\xe2\x11\xc0F\x7f\xac\xe36\x90Q)\t\x8a8\x90\n\x0f\xcd\xbchP\x1e\xed>k\xbf\xa98&`\xb8\x8e\x92\xc3\x1f\xe7\xf5\xf0\xc1\xc3\x93#W\x91"\xf2yr\xb4!\x19+[\x00+\x0c\xcc\xefn\xacw\xdb\xcd\xe3V\xfe\x8ec\x7f\xa9\xafNR\x0f\x9e*\\\xbc\xf5~e\xb8p\xc4\x91\xf4\x8b{\x11\xccl\xbf \xb5\x1e\x84\x07D\x92~oh>\xd4\xa0\xf4*F\xf7\\\x08\x10Iu|B|\x07\xcf^\x1fU\xd0\x8a\xb6x\x1c\xfc\x99\x17\x8e$\'\xb4G\xdf\x06F\xa4G\x99\xdf\x0b\x7f\x19\xe3\xef\x95\x9du\x83\x99\n\x13\xad\xc0x\xc3\xfa\xbff\xfd\xde\x05\x08\x80\x1a\x7f\xa2,\xcd"\xde\xfci\x89}\xfc\xfc\x03\rB\xaf\xed\x9c\xb1\x92\x17\x13\xe5\n\xd5c\x7f\xc0\xd8\x8e\xec\x98\xc1\x98\xc5\xc8\xd5\x04\xd0\x05\xd5C,JE\xcdJ\xae\xa0\xb1\xa44\xf0\xa8\x83\xbb1\xc0\x8f\t&fo\x9d\x08Z8\x81\x7f\x95v\x00\xc0\x90\xd3\xa7\xe6\xdaZ\xcb\xb1\x96\x9d\xef\xa4Q\xed\xf7\x1a\x85j]xY-\xea\xac%7-\xee`\x9f\xc3c\xea\xee9+\x82\xcfORGa=\xba4Y9\x88\xe3\xea\rTDU\xdfPLf\x8f\x19\'C*\xb0"\tf\xddo\x93/H\xf8\xab\xaf\x82\xdcK{\xcf\xd1\x05\x88\xa0\x18|\xf1\xc5\x10\x1b/Na\x96p\xa5\t\xa4\xfb\x83\x04\x9b\xae\x06\xe95\x9d\x18\xdf\x81\x01\xd6\xc8\xe3\xc5\x9a\x1fB\x0e\xbf\x17\xc8D\x1cW2%\xc1\xdf>\xb9\x9dh\x1b(\n\x00Zw\xfc\xf6~\x14n\x16a({\x9e\xed\xbc\xf8\xecXR\xb0\x19\xfa\\^v5\xe6\xad\xf2e\xef\x8a\xd6\x7fQ\xfd\xb9\x07Y\x1f7\x8e,\xdd_\xe9\x8b\x08\xd92/\xe6\xcbR\xfc\x03\xf3[\xf7\xaa\xc7\xb0\xbe\xe4r\x0fdm\r<&\xbdd\xdb7\x1a\x10N\x03u\x95\xa4\xdd\xa2\x7f\xab\xb6%f%\xc1\xf2\xfc\xeb\xe0)\xacA\xc6|\xd9\xc7\xa4\xf6-O\xe5o\x92\x1c\t\xf7\xde[\xbf\xd3\xbd\xf3\x98\xa4\x18-,V\xe0<\xef\tLp\x93xG\x11\xf4YI\x81%/\xf7\x8e\x93R\x16\xcf\x06vm(Q\x13\xe2\x05\r\x84\xe5\xdf\xce\xc2\x05)\xf8\x87j\xe5)\xb1\xcf\xc6\x86l\x8a\xd1\x82\xd7h\xaa.\xcd\xef\x90\x81\xb5\x1fc\x98\n\x1f6C\xc9@2Z\x8e\x97l\xdb\xb5\x19h\x12\xa0\xfc\xaclp9\x1bc!\xc4c7XW\xf6z\x83 eCU\x08\xeb\\}\xbe\x0f\x94\x12c\xbe\x8ag\xc3\x14\x82z\x8de\xf3\xa9\x01\x8f\xae\xe4\xd8\xd8\xaf\xdd\xc0\xc4\xa6#L\xd3\xec[\xe9\'\x05_\x03\x99\x8b\x91Gaz3\xbelO\x97\xc8`\x98g\x9b\xe6\xfc*\xec\xfc.\x97\x88\xa4pJ\x97\xee\x8a\x16o\xf7}\x95\x8f\x94\x8d\xb4\x03\x01\x94L\xa4,UN*\x19\x92\x87ie~\xb6A\xa3\x8eFKp"\xc8\x1c\x04\xf3\xd2\xa9\xf8\xd4\xb6T\xf0\xc5\x89\x93\xf4\xe7\xa2\x032)\x07AL\x18\xd2\x0bHt[\xb2B\x9d;\x92\x7f7\x9f\x9cBM\x0e\xac\xd4\xb7\xc9\xadA\x1d:Y{\xf6FN\x8a\x8d\x1f\xb8\xd6\xe2Y\x8c#\xff\x10\xce\xd2\xe7\xd3\x0b\x9c\xab\xd3\x87\xe9=\xbb\x96\x89\xce\xd7\xd7\xc6UW\x90\xd7%\x7f\xbd%\xa4\x88\xfd\x86\x05V,\xbd~\x87%~X\xec\x0b\xe5\xfe\xbd\x8b\xae}\xff; \xe8\x9b\xc4\x01\x93\xf1u\xcf\xab\r-\xeb\x9c\xedvN\x83\x1d\xfd\xbeHa \xfe\x15\xae\xe5\xbb\x9a}A\x01\x84\xda\xf2\x8dF\xf0)\xb0\xbcE\x1b\xcd\x08\x1e\xf0N\xc9\xd3\x1a\xcd\xaa\xbbA\xbd\x1f\xc62T\xdc\x87\'\x89\xfa"\xa1q\xb2\xc6\x1d\xa4/{I\xf7\xddF\xf0\x042\xb6Lz\x15d\x8ch\xa3\x99!\x8f]\x8c\x90<\xdc\x8f\xc5\x13\xe2\x85\xffs5\x1a\x04\xc8\xa7AX\x10C\xdb\xe4"/\xa54\x95\x81\xaeB\x12R\xf0\xfe!\x96\xb9\x05\xa0\xc9\x97\x92\x95}\xea\xb7\x86\x93\xe2\x00\xfa\x0c\xc5\x9a\x18\xc4\x98\xe9\xb0P\n)\x00xtH \xec\xcf\x80\xe3\xdbu\xd0\x05\xa7\xda*\n\xcdL\x8b.@\xc5\x95X\xc7}H\xd3+\xf8\x16\xbfM\xfe\xd4\xc7+\xfd\x1fF\xc9\x8d\x0f\xabK\xf5\xf0\xe2\xc9^Ba>\x9c\x15\x95\xdc\x0e\xd8\x18\x9bB\xb6\xd4A(\xba\xe7\xdb\xf7\xbf\xc3\xc2#-6\xd0\x1c\xe8(o\xf3\xb4\x14\xc4nO\x15\xa9\xba\xc0\r<\x88\x8a\xf5\xa9,\xbd^P\xbe\x15\xf1h\xddA\x10\x87\xeeR\x1c\xdc\xcd\xe27\x1d\x9aOs\x99fh\xbdw\x9b\x0c\xc0\xa8\x0c\x0fK\xd7-\xc8\x8b#\xcav\x02\xef&a\xc7\x94\xc3\xcey\x80\xdb[\xed\xf2\xa4wR0\xf0\x18l:\x06\x0fo\xfc`\x8enU\xbc{\x1c\xdd\xc6LG\x17\xa3\x08\xef\xf9\xc1zb\xf5\xc06\xc4\t\x17\xa1N\xa3\x0c\xfe\xef\xaene\xf9\x0eD\xaa\xad\x89\xf2\xc6A\x90\xf4\xf0]\xc7\xa4\xd9\x87\x1ft\t\xb8\xbe\xa8\xc3\x05\xad\x81\x85\xb1\xa6\x96\x1e7\xf1\xb7j1/:\xe6-1\xc5\xe4\x11\x19e\xb7{\xf7o\xa2%\xdd\xef\xe3\x9f\xde\xa3\xd4\xc3\xb3\x80\x1f\x88\x0bswg;\x1c\xbc\r<\x0f\x8aQ6\xf95\xd0\\\xf3\x97\x91;\xea\xc4\x83\x04r\xc1\x8b\x12Z\x04\xc3}\xd8\xe8\xfe\x96\xade\x01\xce\x00\xb6\x85\x7f\xc9\x11\xc3\x00\x18\x85+\x9f\x9b\xc4\xfd\xb1\xa2ch\xaf%\xca\'\xf7\x7f\xc3y\x7f\xa7.\xbew~/A\x9dm&\x83\xea\x96\xc6p\xfa\x92<0\x9eK\x0c/\xba\x19]d\x1e\xa6\xa8\xe3\xa0>\xd2r-y)\x9f\x08\x0f9\xfd{\xad\xa4\xdd\xe7\xa3U\n\x8f\xaf\x04\xebK(X5\xabM\xd37Dm\xc1\xf4\xc4\xf8u\x126\xba5=\xf1-\xa4D\x85\x89.V3\xd2\xde\x80C\x83^AD\xda<\x0cZ\xf5a\x06\xd6/\x05AE!16\xd97~\xe3\xfd\xf9\xb1\xa5\xf8\xfd\x19\x1fG\xa2\xc9\xa8>Z^\x85r\\\xbc\xc82\x91\xf5\xd2-R\xb4\xc6\xd2\xc6\xdfr$\x03-U&\xc1\x92\xe8&=Rs\xc9)\xf88\x80\xeb\xe3>\x99\xc5`!<\xa4\xc1\x17\x9f\x9b\x0e\x16?Dz\xb8\xd2\xf8\xca\xae\xe4R;\xf0\x01\x15\xea\x91\x18\xc2x\x05\\y\xfa\xd8\xc77\x10\xab\xf2\x1d\xa4/~1+\xe0\xb0df\x11\xccbv\xf5\x80\xedT\xcb\x1e\x86b`4\xac;](\xec6\x95\xc8{P\x83\x8a\x10gQ(\x154nH\x9d7\x88G\x9d3\r\x1c\xd3\xae\x92\xfaAt\xa3\xb4v\x97f\x06\xc9\xf1\xb6m\x9d1V_n6\x91dct\x1d\xa8v?o{\x94\xf7\xaf\xc2\x9e\x9cf\xba\x85H\x05\r_Yx*v\xeaH\x99\xdc\x13\xf7Vl\x84Y^b\xbco\xab\x08\xb4yt\xcfj\xb12~y\xe6\x1a5\xbb9\xad\xf5r\x97\x80?\x9aY\xad\x99\xd6zQP\xb6\xe6\xd8\xd3\x9e\xbf@wB\x0be1\x01l\x0f\x8eP"\x0f\xa2\x9dl\xe1\xfaL\x0c\x13\x84j\x86\xcd\xcf$\xc3}XDd\xe9\x8d?\xe6\xdc{\x95<\xa9\xcb\xc2\x99\x1a[-3^\x8c\xab;\xcc\xca\nm\xd5\t\xaf\x18h\xfc\x0e\xa0p Y\x06\x94\x9cXA\xcfc\x17\x02\xbc\xf8\xf3&\xd16M\xc4\xcc\xc4\n\xc7L+\xf7\x95\x12+\xf6\xa7\xb0\xddTb\xdb\xb7z\xa9\xa7{hjo\xdc\xc3n\xfbt\xe9\xca\x0f\xe5\xb83\x84\xd85\xd8\xa7M\xda5\x95H}\xe4gH!\xd2\xc5\x96\xeb\x8d\x0e\xd3fR\x86\xf0\xa8\x1f\xbb\xcb\xb3\x9c\xd0\xf6\xc5\x83\xc6\xb3\x12\x01az\xfe\xb8\xfe\xc2\xb9j\xb4\x14e\x9e\x9b\xf0\x9a\xbf\xe3\xdc\xb8\xa9<7\x8c\'\xf5\\\x90\xfat\x02f\xa4\xdeYVf\x99\xfd~\xd0o\xba\xc7\xc3\xd6"W\xc1\xd9\x13\xabHZw)q\xda\x0e\xebs.\xca\x1c-\x89\x93t>\xc7h\x0f=\xe6b\x91p\xb7\xb1a*G\x8d*R\x83\x0fH\x90\x95\x18Q\x15gu\x88\xba\xb85\x8e\xf3\xc1%ZKj\x1a1\x027.\xc0\xe7\x026Gc\x98jv\xa6\xcaJ\xf0\xd9bzp\x87\xd2Q\xea\xa5\xe25_F\xc7\xbb\xf3]\xc7)p\x1fw\x9a\xfdp\xcfZ\xdaV\x81A\t\xc6P\xb3#\xba%u\xe7\xb8\xd5\x91D~\xdf\x96\x19\xa7\xe80\xc4\x93\xc4a\x9c\xb2&\xf7\x1d\x18\x826\x8dF\xe3ZgCt\x80\xd8\xf5\xa0y\x8ap\xfc\xbd_V\xda\x11\\\x07\xcb\xfeE8\xb0U\xcd\xa1l\xf7\xa4E\xcb-K\xfe\x01\xc2\x9c(Fw\x8d\x1e\xf0\x1d\x93r\x95\x94\x8d;\x9b\xd3_\xeeE\xc6\x8e\xe4F\x0cO2\xaa\xdc^\xdf\xcf\xf7Z\xa5\xf6!\xa0\x0ed\xe4\xdc\xa4\x82R\x0c#>\xae\xdd\x08_\x9d]\xeb\xe0<\xb2\xc4\xe7b\xd4-\x88@\xd9\xc8\x85\xef\xae\xfb\x19z\xd9\x94\xd99\xe6\x05S-\xc2*(I\xa7\xa1*\x02\x0f /\x02b\x0fZtT\x95\xd2\x14\xd8T\x10l \xaa\xee}\x8d9\xa9\xef\x9c\xdde%\x1c\xaa\xb9\xb6\xb9.\x91\x1a\xfc\xe9\xee\xa4?\xb7\xb1\xe9\xb5\x10\xe0\x1a\xdf]\xa4\xf3\xe7\xd3\xa4\x95\x0b\xc4\xa4\x1b\x05Cp`\xc9\x8c):N\xdf\xa8\x01g\xd1\xc6\x1bs\xe9\xf6\x943\x06\xf1\xb5\xaa\xd2\xf8\xf6\xab\xa0\x17\xa0cf\x95\x9d\xb1vakA{\xc0\x03\xeb\xb3\x0eEs\xbb\x1e\xb5\xb9\xb1\xea}\xdd\xd8a\x81\x0fM\x96\xed\xa77>e2sW\n\xae\x8f\xbe\x90\xe0\x9cI}\xb3G\xe5\xee\xbb2\x908u\xb5\x1e\xd0F1W\x8fb\xcc+J:W\xbfh~\xe3\xca.{\xd2\xed\xf7\x05\x13\x93&\xcb\x15\x02\xdcz<,\xa8KpC(ebY\x9e\xbb\x0e\xc8\x8a\xff\x15I\xdd\xd4\t\xce=}+:C\r\xd0\x80O.)v\x12\xf3&3~\xf2^f\xed\x0f3n~<\xa5\x12|I!?@\x13!p\xf8\x0e\xd7\xc2\x18\xc53\\5\xd8\x19V\x0c\x8f\xe0MJ\xc2\xf2>\xd8\xb0J_\xec\x87j\x12\xef\\yh"\x80}\xd3\xc4[\xb3#\x92\n\x8b\x9b\x85\x04e\xaeB@\xf2\xe0\xb7\xf1\x8d\xe7\x80\xa9\xaa\xfc\xd7\xf8\xc0B$!\xe2\x06]\x08\xafn\xef\xc2w\x97x6\x16X\x19k\xb8\x9c\xab\x1e\x0eaE\x95\x01\xdaC\xd0\xa1\x85\xd0\rX\xd6 \x877#\xd8%\'\xacL\x84\xcbc\nr\xb9\xbc\xea\xde\xa4\x93\xea\x14g\xae\xa3\xa6:\xa8\x15;\x0fX\xdc\xc2\xe1\x14\xac\xf1Hw,\x82\xcd\xfd,\xa9\xfbS\x06e~*\xfc;\xc9\x91\xa9\x04\x92\xa7R\x06Qt_\xa2F\xa3\xd0\xb9\x86\x8f+\xb0\xe2\xac1\xfd\xd0\x93az\xd8Yn\xf7\xe76\xf27\xc8\xee\xebA\r\xf6z\x8c\xa9\x06z\x1d\xcc\x91\xa0A\x03\xf5\x12\xf6:\x12*B\x0f\xe5?\x7f\x13\x9b\xban\xc0\xeb\xa7\x08\x01I\xa9m(\xebo\xe4\x97\xf7y\xb1\xe8\xdf\xa88\xc5u\xc5\xe1<\x10\xdd\xc9\x8d\xa0j\xdf\xa3A\x90\xd6\x8f\xd5\xff\x80;\xf4\x02\'\x864\xa1Z\xd5\xaaX\xe1\x95Y\xbbU\xa8x\xe5\xd6\t\xf6\xe9\xae\xca\xe0\xc2\xf2\x02.\xd4\xcbz\xad\x98U\x8e\xed\xf7O\x8f\xa22$\x13[\xd7\x01\x00\xb4\x86\xbf\xec<\xec\x95\xa1V.@\xddB\xc8uYG\x1dy\x8a\\2\x9c\xc4\x96\xec\xec.v\xe5\xe4\xe0[\xa5\x9f@H%\xbf\xb5\xb4\x82M\x9c\x93\nU\x045\x0f\x04\x92\xf2\xf3P\x9c\n\xc6\x92?\x10J\x9f\x00\xd2l\xbeG\xe3YS\x10H\xa3\x00\x96\xcctC|\xe5\xf7ca\x9fF\xdf\x0c\xee"\x16\xb7\xe0sO\xb2\x97o\xd8\x028O{\x9b\x8c\xb9\xde\xa2o\xda\xf0\x84\xf1\xd8\x04?\x15\r/\x9d\xccW\xb3\xa5\xc9\x7f\x81~\xf0\xd9\xa6\xf68\xd7\xba\x9aR_qLm\xaa\x84\x13T\x9d\xad\x94\xa7\xc0\xc7\x01P)X\xa0\xf7\xd3\x04\xbdL\xaa\x1bk\xe4o\x0b\xcd\xb8\xd3\x0bZ\x16\x12k\xe9\xba\xfc\xca\x1e\x10^\x0e\xa32\rYO\xf7\xcb\xda\\>\x8e\xf6$\xb3\xe8\xda\x0e\xf4bn*\rvPC=\xfb\xdd~^+\x7f\xfe\xe0\x00\xa2\xebL)\x0c|\xdf\xd5\x91\xc0\x96\xcf\x18\xa9\x13\xe9>\xf8\xaf\xe0\xe2TZ\t\x85\x95\xab\x10C\x7f\x8c\x1dY\x95\xde\xea\xda&x\x83\xf1C\x82\xc5\xcd\xaa1\x00p\x88\x158\x80\\\xf0\x85\xb1\x04\xe2\x95\xa0`j\x14\xc5\x83\xd4\xf5x\xb2\x12"\x0eHp\x82\xef\xcf\xe1L\xc4,\x99\xa0\xb6=g\x99\x8fOW\xa5\x88\xf7\xf6\xe2\xe8\xd3\xcaZV\x00S\xa1\x1f \xd3oC\xe7\xe5\x0b\xa7\xa8\xfe\xd1\x1a\xc1h\xbb\xed4\xa1W\x96^\xdbn\x98X\x1a\x03\x1c\x80\xa7\xcd\x13\xf3\xdb\x8bc\x0e\xa2\xf8Q\x83\x7f|\x1az\x9e\xc4*\x96\xea\xe8#gtd\xc5\x82\xa1O\'\xba\x9a@"u\x82mB\xfc\x19\x08f\xfb\x1e\xb7C\x04\x1b\xe0\xaaY\xe2\xb3\xd5\x83{\xc4\xe2\x0c\xeb\xc9\xb1c\xc3q\x0e\xbe\xd5\x14\x1c\xc9\xfe\xd4B\xeaA\xe6\x18\xba:\x80\xa7u>\xc3-\x9f\xd5]\x0c\xe6\x19\xba\xf8\xd9\x00P5\xc8$\xe1+S\x1b0\x87\xdep\xca\xfe\xcf:\x9f\xf02Gf\xfa\xd3\xcd\xb2\xad\xaa(\xb2>\x92\xd9I\xa2~r\xaa\xc3\x85\xe41\xa8\xde\xef6\xae\xce\xb9\xd0E\x92\x8f\xd4\x04\xa2\xb3?1\xb9\xbf\xde"\x82#\x8f\x95\xc0\xf2-\xe7}=7\xba)\xe9p\xba\xf3x\x83\r\x86\x99\x0cb\xcd\xa7\x18\xcd\xbf\x8d\x89\x02\xc7\x10\x02b1\x03\x05\x95V]\xc3\xcc\xf6\xc4\x9eFJ\xac\t\x13\xa1p\x132$y.[D\x0cH\x1452\xb4\xba\xb1\x98\xf8\x01%\xc6\xee\xf8\xcal^\xec\x04\xd4\xb3\x9a\xb5\xd4\x95\xe8_\xe1\xe7\x9a\xf0e\xfc\x1e0\'\x1cO\xadN\xb1!\x15\xffE>\xfe\x12\xe2\xd3\xae\x06\x90t\xc1\xa7\x1e\x93\xe4\x08\x1f\xf5\x89\x8b\xc8\xde \x8e\x13\x97\xbf\x056\xa4\xf3\xe4n\xea\xa6O>d1\xc4\xcd\xebb\xd8\xdf\x8bB\'h>\xf1\x94\x07q\xa9n\x07EM\x19\x8f\xcf\xcc\xecI\x1b\x02f\xda\xe3^\xf5t\x81C\x88~g\x80\xc8:\x154\xe8\xbb\xad}\xf3\xfbN\x101\x9c\xc5\x1bO\x8e7\xa4}\xa7\xd0\x00\xc7\xfa\r\x8a\xe9Q\xca\x17\xa6\x87\xeb(Yii\xe9\x17\x15\xd4b!l\xb0Oj\x1f\x92H\xc9\x0f\xdb\xd3\x80\x94mYC\x13Yx\xefN\xdc\x99\x04\xf0\x02\xf7\x9d\xc7\xd9\xb4\x82\xee\x99\x07\xbaq\x01\xfeAH\x81\x85\xd5m\x05\x8c\xd1\xd4\xd2\xf3\x1b&\xda\xfaXD\x17f\xe2S1,\x8b\xb3L\xee\x1e@D\xe6O\x05\'\xd9sz\x8e\xd0\xe3\xa9\'o\xcff\xc9\x0e\x0fkk+%\x8a\xf7r~D,\x1d\x91\xdb\xcbD\xf9\x05(\xe0,\x97%\xffO\xb9\x9a\xf4\xec\x95\xc7\xb5\x93Eqk\x89/H\x9fN\x0eN\xf5\x8a~NRr\xffC:\xff\x04\xfa\xd0l\xd1\xca^\xaag\x9f\xf2\xc5\xb6\xba,\xe1 \x16\'0\x1b\x13\x90\x15\x08R3z\xb104\xd0\xad\x83\x81DZ\x05\x8d\xa6G\x81\xdeB\xd76y\x1fM{\xd3\xff\x91Bmnu<\xc8\xe6\x12\xf9.$\xe0o\x16^\xcaA:T\xd98A\x9a\x91\xd4Vdqb\xcfA\xac\xe1\x7f\x19\xab\x92Y\x8cI\xb4\xceW)$\x02\xbd\xf8\xd3\xbe&\x1ar1\xda\x93\x94\\\x81\xeaf\xc1\xf9_\x9dS\xc5\xe3\xc3\x141]\xea\x18\xa8\xb5\xc2\x9a\xc2h`A\xb4v\xb7\x8f4f\x05\x7f\xd8(Y\xb3\'R\xce\xc1\x8b\x807\x0b\x82\xf4\xc1\xe2V/\xfd\xf0hb\x94\x1ak\x12\xf5\xc1C\x9cO\xa0\xeb8*d\x18\x0fhn\xdb\xfems<\xb8\x06)S6\xf6\xb6\xa6\xca \xaf\xc8!\'M\x95\xd2:\xe3D\xbc\xf6M+\xfa\x90\xe8"\xf2\xc8\x948\x84\x81\x8c\xeb\x07\x8ey\xbd\xf0L\xbe\xbc\xfa\xf2@ \'\xa7\x87_\xe54\xe2\xd4j\x8dv\x14\xd0qW\x9c\x83\xac\xdb\x91\t\x90-\xfd@\xdb?\x13_&\xab<\xde\xcfL\xbdP\xc55ex\xb0z\xfc\x1eG|\x86\x9c\xbf0\xf2O\xbemA\x10\xfe\xaf\x9a<\x08b\xc2\xff\xdf*.V\x02\xccx\xbc\xc5\xf3\xb4\x8b\x18-\xe1\xf7\xee\xff\xe7\xc4\xf71\x00"\xab\xda\x99!\xe4\xd5\x96\x19\x18\xe0L\xd1Hy\xafN\x93LSa\xa7\xe3\xf5z\xb8\xf8J\x96\x1e}\xd5IY\xb9Mu\xf0(\xdc\x06}A\xe0\xb8\xdf\xe4\x8f\x86R`\xfd\x95\x00\x0cV\x0b*j\x0b3\xe1N\xe1\xbazn&i\xd6\x15e\xcb\xd9\xb57\xc8v\xfe\xa9\x95\x95\xfe\x15\x83\xfc.\xd2\xfaVhuf\xfa\xc7\xe0\xab2A\x8b\xf9B\xba\xfa\x1cn\xedW\xe1\xf8\xefb\xe4\x95\x1c,\xdbK\xa6\x03\x88\xcd\x93A7\x0e\xa0\xeek\xa4\x9fK\xc6\xd6\x81\x02\xfe\xb4/c\r^4\xab\xa98#z7\xd50E<\x11\xb4=\x0cA\x96\xe3\xa0\xddL\xbe\x9e+\xc64\xf2u\xd4fXN\xb7\xbci\x8a\x8f\x06c\xbb\xa3\x94u\xdeTx\xd2\x17\xa2\x06\xe6\xf6\xa7\xbb\xab\xad\xa3s7\xc81o~\x9d\xca\r\x93K\xc1\xca\x8b$[W\xd2\x15uCx\xf6\xe9o\xf1\x94R$#J\x86\xb5\xe6\x95\xca\xd8\xa8\xd2H\xe9H\x96\xfd\x7f\x9aah\xa1\x16\t\xd7f_l\x11=\x8b\x11|\x801OV\xfd\xf5z\x94\xf2\x13^\x8eu{\x1c*N\rK\x93\x80\xda\x8d\xeb\xbf6\x00\xb2\x0f9\xd4zr\xe8\xf4\x08\xe9\x9e\x7f\xc8W\x8b\x8eG\xb7\xedGeas\x17o\xe9\'\r\xf0\x03!\xf3\xf8?\x9e\x1d\xc9\xf5\x02\xe8\xaaw\x1b1\xe1\xc2\x9e\xa7#\n\xfb\xb4P\x9f\xacNq\xfc\x13dd\xd9/\xd8\xab\xdf\x1e\n\xb9\x0e+S\xed)\x1a+\x97\xd3@\x18\xb4\xc6\r\x9f".\xceN\xf7E\x19~\'\xd4\xab\'\x05\xca\x80\x1d]\x8f\x0e?s\x99\xa7\x16\xac\xb8\xa0\xaa/v"\r\x7f\xc3(,\x93\xcaq\x83\xeb\nx\xd9mJ\xc6h\xc0l\xbf\'\xa7\xb3\xfe#\x92\xe22\x08\xe3\xe8\x9bnc\xdb\x00\x859\'\xa5\xb4p\x96c&\x8b\xd0b6V\xc5\x04\x85\x98\x98\xc0\xe9h\xbc\xaa\xa3\xf7\x1az\x08\xf5\x14\x96{[\xe3k\x9b\x0f\xc2\xcd\xbc\xce3\xf3\xb7\x8akx\x136\xbb\xf2I\x07E\xab\x08H\x18i\x129\xf6c\xe3!\xca.\x1b\x17@\x12\xa3i\xeb\xa5\x91\x15\xe3\x84-\xcci\x96\xecc\xe4\xbc&1\xa6\xa9S\xf8d\xd3\xaa\xc6\xce\x8b\xfd\x93,\xf8\x88\x8a\'u\xd5\xae\x99\xd5\x15%\xa4\xfa\x84\'\xc7\x84\xc3c~IZSBFv\xcc\x95\x95 /\xad\xa1\xd7\xd3LV/A\xe5\xf2\x072g|\xb9B\xa5P\xf9Q\x0fl\x9cY\x02&C\xb9\xff&A\xe6\xabEL\x86\x11\xa8\xfc\xf6\x98\xd5\x9f3\x84\x9b9\xe5\xef2\xc1=\xc9\x1fME\xb4\x94\x88p\'D\xda\xb4\xc6\xed\xcc\xd6\xb9\xa7\x04\x1a\xa5\x18\xd1\xf3\xffj0]\x16y\xe5*\x01W\x8ayi\x1c\x04\x8d\x19H\x9c\x99\xc4\x88?\\\xa4\x84\xbe\xdd[\xa3\xc1\xc6\x98\x19L\x9f\x1f\xb2\xc2\x92\x05\x16\xf6&S\rD,\xbe\xbc%\xa0q\x83\xfc\xf5{g=\xc1/D\x03\xfe\x16\x03\x99\xa91\xf3\xd6n:\x816q\'-P\xfb\xadQ\x08\x08\xe6\xf9\xa1\x9b\xa2\xea5;633\x1dFX\xb4\xca\xefG\xb1\xef\x17\xf9|\x01\x98\xcb\xdf\x95\xf7\xf5\x14\x9dpO\x92,\xc7\x9c\xed\xb3"\xa8\xd9\x9c\xed\x02\xc0J\xdbg\xcdj3\x02\x01_\x19%\x84\x82O\x16pQ\xdf\x99\xfb\xd4\xb4\x98\xf3\xb2\xb6\xe59M\x8a\xb4U\x8b\x97>\xbc\xc8\xeaqFs\xe4\x07\xdc\xbe\x8c\xbdhKm\n\xc2\x98\x03QP\xae\x17:\x8cP\xdcy"\t\x8f\xfc\rD\x0e\xfa\x85Ak\x8a\x8b\xc4\xb0\xc1\x01xB\x83\x04Q\xc4\x05\x1d\xb9H\xfd\x06\xc7\x15\x9f4\x9f2\x99w(\x92\xcc\x12\xa0\x0c\xe9\x8fw\x9a@\xf9G\xc1\xbeF \\\x991\xf7k\xad\xeb\xe4w\xdb\xeb\x9a\x9f$v\xa6\xb4na\x83k\x08\xe0Y\xcd2<\xde\xd0\xac\xb8\'\x1b\x84\xc1\x10\xfa\xb6\xab?\xb2\xa6\xf4\xb3\xa7lN\x9cl\x9f\xf4\xce\xe2\'\x94C\xa9\x10\x1c*9\x01\x97.\xb37\xbd\x07\x8b\xe6\x13\xdb\xa4\xba\xe4MfwyN\xab\x0e\x86\xc3d\xa5\x1e\xff\x18\x99\xe8\x91#\xe3\x13\xb6\xd2T|\xc6@\x11\xc0\xfc\x9as\xaa\x03\xfc\xca3\x86\xfb\xd3NK\xc9\xc1\x8a\x9bY\xcd\xec\xf9u\xec%]m\x9d\xf1W;\x89,\xf3}\x84\xb3\x83\x9d\x85\x86\xd06\x04\xb4&\xc8\xf7pY\x02\xa3\xdd\xab\xf4\xea\xc9\xd5N\x0c\xae\x12\xf9x\x0e\x8b\x17cSx\xd6\x1ea\xfe\x96\x01\xe2\xef\xabz\xff\xc5\n\xbe\xef\xad\x1e\x96/g\t`\x99]\xa4\xf7\x1f\xd8\xec\x91\x17\xaa\xc3\xf5\xf83\xff\xcbs6\x9e\xb7\x14\x08Y\xa4i\xd8Su\x1c\xe8\x13\xa7\x84\xf5\x18a\xd0\xc3\x0b\xe6{D|\xf5\xa3Ms\xaf\xb4Kn\xaf`\xf1\x14@\xe4cq\xb8\x12\x9a\xcd\x0b\xefsZ5o\x01q\x0f\xca\xa1\xbc(w\x12\xc2\xd8\x1a\xe0\xe6\x07\xf8\x12\x0b\xafZ\x05\xc4(\xa0I0;y\x97\x82\x84\xbd\x01\x9c\x84\x8e\xbaiW\xd6$\x9e\xd3\xbd\x90\xd5\xa4\x9f\xb6m\x9a\xf3~\x80\xa4T\xb66\xd1\xff2\'\xb1\xfbR\x97\xb9\x9bL\xa1\xca\x84-P_\x96&\'\xd14\x87p\xab\xa24e#8y\xd6\xac[\xec}D\xb9\x9c\xf5\x02\x7f\xf0R\x88a1\xb4\xf6\xc1:n\x83%?\xeb\xdb\x85j\r\xc3&m~U\xe9]\xb4A\r\xfe"\x1da:E2\xe3\xf7\xfd\xdd>>\x8f\xa3.\x9e\xd4jJ\x1d\x7f\xb5\xa3\xc7\x9aY$z\xa3\xb6\xca _\x8e \x8d=]\xba\xfcxZa+2\xe3a\xea\x8d6\xdco3WAH}s\xd2\x7f\x9d[\x13x1\xf4H\x00~\xb7\x98\xc9\xca\xf2\xb9\x85*\xf2\x91\xfc\xd9\x8e\xeb\xd2\xe6\xd4\xa4!\x9d\x03fL}\xf0\xc0q\x9ap\xbfb*(\xfc\xf9\x98tc\xb2\x05\x99\xf4\xeath\x04\x19FNL\x86\x83\x82\xd3Cz[\xc0B:iL\xde/\x9f[B&\xfe\xe5?C\x9e\x92\xaa\xa9\xa1\x00\x07\x97I\xa6K\x9bu\x9d\xc8\x9a\xed\xc1\x13\'M\xfa\x8b/\xa1\xd8\x9b\xa4t4fZ2n`\xb8\x89\xf2A,\x86\xfe\xec\xc4\x10\xd2t\x83\xedb\xddr\xd6dH\xd3\xf8_\x1f\xc0\x81\x18`\xaa\xee\xb6F\x1e\xaa\xcf\xb9\xd3x\xf2\xe1\x03\x98$r\xba\x9fb\x00\xe4\xf5\xc9N\xdf\xb5i\x19\xe5g6 9\xa4\xf6K\xf4\xb7\x9eX\xbeo8\xe3q\xecb\xfdJ\x91BCN\xad\xe2\xa8\xc7\x02_"\x14\xbe\xe9\xd8\x11T\x9fv\xab/\x01C-\x80\xb6\xb3\xbb\xf9\xb4\xab\x080V\x01\x06\\\'M/LmI\xff\xab\x10\x86z\xef\xc16C\xd7p\x07Os\xfe\x82oa\xb8Ff\x06\x8f\xcd\\\xa0\xbfb\xdc\xa0\x95\x7f\xdd!\xea{=q\x83\xbd\'g\xb9M\x81\xc6kh\x83\xd9E\x9e\x92\xdexO\xe4\xe8\xa3\xf4\x16\xf6\x86\x85\xb9\xa9,\xa4\xb0\x91xcq\xe0?\xceD\xfd\xcd+N\x8c\x9fy\xbc\x8d\xcb\xdcc\xd3\t\xae\xf3\xee\x8eKU\x01S%\x82\xbe\x06\x97\x1b\x9ah\x86\x13K\xa8\xeb\x02\xbe $\xe6J\xf7J0\xbc^\xc2Wnnw+\x7fyqXAId\xab_R\xde~.\x01=\x08b\xb2\x94\xe5p\xffn\xea\xb9\xa6\xd3\x99e\x80\xa9\xc7\x14=\xdb\xf6g\x92LA~$^\x81\xf3\x8f\xa3\x99\xd3\xb5|\x06\xfe\xa8b\x12\x9b\xc8K+C\x0e\n\xa9\x06tfZfs\xcc\xeb\x7f.\x10\'\\Cc\xef\x06\x85\\\xe9\xb7t\xf5\xef\xd7|\x86!\xc8\xf7\x83?\x95K\x02e#\x0cX\x15\xf6N\x11{\x02K\xefu\x01\xa9\x9fc\x98\xf0\x84\xd7\xed\x82\xfe\x8f\xd0\xcf\xb1\x84\x9e\xca\x0f\xd36\x11\xf8S\xe5\xd7\xc1)\x8c\xd9F\x90\xc2r[\x9cJ\x81\xa8\x8a\xb5\xb03\xe3\x92\x90A\x9c\xecG\xfbex#\x07\xe2\xec}\xb7\xf9\xe5\x03\x08\xb2\x8c\xb7\xf1\x1f\x18b\x938\x1fi\xf4p\x822\x0f\x80B\xf1\xbb~\xa7\xbb\x84\xba\xe8\x97\x18.\x9e\xed\xf8\xd6\xbc\x8d\xf2#+D(\x1a;\x1d\xc4"\x1a\xa9,\xd7_\xaf\'\xde\xd9\xe1?8\x82\x97<\x0ek\x82V\xb7\t/\x01\x8e\xa0\x97\x0f\x1f!\x1c\xf9\x06\x06\x87\x98\xdb{j\xb9\x0e\x04]\x87{\x83\x13\xba-+7m/\x87 \xfbf\x1e\xdc\xc9\xab\x059+\x8fu\x1e\x1dE\x0f\xfa\x02d\xc5Z\x86s)e\xa1 v\xd9\xf4P\xabV\xec\xdb\xb6\xac)\x11\x17\xe0\xed\xa0\xd7\xe1\xab\xe0EJ \xd7\xca\x92\xdf\xca|6\xd0\x05\xb1Fb\xcdj\x1e\x80\xef|\x85\x02\x12\xcd$|\xd1\xb33\xb8\x01p\xd1\x8bw6\xb9\xdb\xd6\xb4\x84\xec\x06n\xf0F#\xe0\x1f\xc7\xcd\x12f@\xed\x9a\'\xd6W\xe58\xfb\x0fQ\xaa\r\xd0\x85\xfb\x0c2\xfe\xea\x01-\x03\xa2\xff\xcej\x8e\xe1\tRd\xd8\xde\xdb\xfe\xc3\xfb\x8e\xe4\x8a\xd99)\x17rs\x9fs|\xab\xda\xcc\xdaFg\xa8J\xc0\x92\xe6K\xf8\xf0,\xe1\xbc\x8b\x08\x13\x94\x12\xc2\xc3jS\x07X(\x0b\xe3\xf9A\xda\x14S\xd1k\\\x82f\xe2C\xc8\xd6\xb2g\x91L\x94\xd6V\x0bP\x15\x95\x12\xa7\x07\x1e\xd8\x9c\xc1\r"\x07\x12]mbq\xd6\x0e\x17f\xc1\xcc4P\x0b\xdfN%\xab`\x0c\xcc\xd9\xf4r\xba^\x90\xae@\xe7m#\xd4\x85\xab+\x8e\n\xa3\xc5^;\x17\xcbx\x1e\xeb\xdc\xed\xb5\xbd\xee\x18/\xaa\x14fs\x81>a}\xe8\x8c\xa0\xbcV\xda\x12\xf9\x16E\xb2\xdf3\xadV\xbe\xe5\x90\x88g\xd4\xc7\x91$\xcf\xc8M\xee<\xae\xa2\xd3\x83\x14I\x83\'Q~\xc9\x99\xaa)%?k\x1e\x02D\xa8\x8aj\xfb`o\xc9\xe8\x08\xffU\xcb;\x18d\xbd\x079\x85\xe5\xd4\xdd\xafWJ:DB\x8eZ\xc8\x18\xaeu\x84\x85\xf4\xc3|\xd01h\xb4\x07Y\xda%g\x11\x11\x81\xc2\xbb\x0c\x0f\x14\xa4\xe4\x94\xa0\xe7\xfd\x12\xd1\xbb\xa6\xc3\xd6\x9c\xa1\xb7\xe5C\x1d\x9d1V\xc9\xddQ;\x90t\x94\x93N5\xe1\x8b\xd4c\xf2f\xb4O\x94\x8dS\x1a\x81\x98\' \xea\xde\x80M\x05\xc7\x8a\x1fg\xdf\xd1j\xf4\x82EbG\x8a"\x99\xea\xb1\x81\xde\xff\xc6G\x14\x84?\x8d=\xc0FWJG:O?@<\x1aG\xa7\x85\x07M\x0f\x9e\xa0z\x83G\xd6\xd9E\x87\xba\xee\xb9F\x07X\x7f\xc48Qi\x97\xe9\\+\x15L\x9e:\xf41\x85\x0ezI\xa4AQ5\x8a\xb9\x83\x94\xd2\xa9\x11\xc4\xe9\x92"_\xf4\x7f\xa1\xe3\xac\xcb\xd2\xe2v\x95\x11\xc6_\xb1l\xff\x91w\xb4\xf6e\xca\xb8\x81\xf3\x8a\xe3\xe9\xb2\x80\x12%1Y\x89v\xeb\x07\x11\xb1\xf3\x05!\t5m2\xb5\x19\xff\xaf\xd76\tdQ\xe6Q\xaa\xf2r\xebC\xff\xa6V%\\\xc4\xe5\xdd\xacb\x00\xd1\xd4\x1f\xdak\x06\xdc\x95,z\xf6\xbc\xfb\xc0\xc7|\x1bZ\x87\xd9\xf1\x11\x8e\xf5\x04?\xbc\xb9s\xf5$\xb7I\')\xca\x94\x14\xbe\x1d\xd4H\xa3(\xc4\x84\xe2x\xf9\xf7,\x14Uk\xd8\xc5\xdf\xbe\xbe\x8d\xf3\x0b4w#uz6H|\xa7\xf8\xf7\x8e+\x0f\x914\x08\xb7\x87c\xf6\x10v{\xfbc\x89U/R\x13o\xa7 \xee\x1b]S\x1b%_\x055\xab\xa6\x08\x85\x9f\xf0\x86gN\x1e\xa6{\x9c\xf8.\xde=\x90\xd5\x1d \x1bBH\xdf\x86j\xa70\xce\xd0\xfd~\xd9\xd5\xb2L8X\x10\x94\x89\xeen\xee\x00\xa2\x96f\xe6e\x9d`\x12\xc9\xfa-H\xab\x1b\xa6\xe7\x02\xf69\x91\xd7^/\xc9\x18\xc4\x14bJ@\xa5I~\xa8\xdc\x84D\xdc\x96\xa6\x91\x81\xfc[\xf2O\xd54\xf4!\x1dS\x8b+h\xcd9(\xfc\x10\x03\xce\rVQ\x9f\xc9\x87\xdb\xff?Ol-;\xd3\xef\x89\xa2+\x00Z\x96\xbd\xb9\xad\x15\xecX\xa5J> \xc59\xc6\xf1|\xd8\xf7\xbd\xaf\x82\x98\xcc\xb1L\x8b]\x98P\xdf["\n7\x0c0z\xfcD\x949\xf1\xe6\xd2\xd8LT\xcd\x85\xd3kW\xc2\x9a\xccE{\xf2\x85\xf6c\xae\xba\x08V{\x9a$\xe5\xfbT\x07\xfd\xc7\xd1\x93\x13\xce\xf4\xde$#\xe9\x89+9\xd7\xdaP\'\xb6\xda`\x88\xc7\x19\xae\xb5\xce\x87c\xe6 e\xf9h\xde\xba-\xcdE\xc1c\xb9\x0f\x1e]8\xb0xt\x90\xfdg\xfc-\x1e\x19\x1a\x9et6\x19"\xa3TL\x9dF*\x8e\x16\xf9K\xa4\xed\x8f\xcc\'\xf3\x16\xf5T\xaf\x89\x95\xd4F\xbe\xa4\xf3nF\xdf+\xae\x1a}\\2w\xa7\xe66\x01;o\x88\xe7\xf4\xda\x9e\x1c\xe62\x1e\xd6\x15\xa3?\x89\x1a\xa9~\xb9\xdcoz\xe4\xfc\xfbH\xa6\xa9\xfb\x80@&\x08\x82H\xde\xb1 c\x94\xba\xaa\xdcXO5\xbd\xe8Q\x1fC\xa6\x0b \xbf\xb5\x03\x8a\xdd\x17\x93\t6,9\xe1\x81I\xc4\x91;\x0c\x03qpA\x9e\x7fe\xf7\xeb\x04QK\xbfy\x8d\xf7\xd3\xa1\xf7\xb7!;\xbb\xf7\xc2\x96\x06\xe2=H\xe3\xd4\x00wK+\x0bFp\xceG\xefB\x82\xd6\xdftP\x907v\x06\x02f\xf4\xd7\x9a\xc0o\xac]\x9d\xc0\x83\xa8\x11\x00N\x91\xf45D\\\xe5\xf6Np\x88\x04\xde\xa3\x8cV\x1e\xfa\xe4[\xa2\x96@\x88\xdb\xbd<\x9d\xec\xa1\xadl\x96\x02#\xe1\x83\xb1\x17\x82\xe4\xcc\xcb\xafE5\x98Ew\xc6\x0b\'i\xd3\xfb\x9a\r\x05tKx\x8e\x07\xcd\xb7\xfc\xd1v\xd0\x9b!\xd9}ffy\x12.\xb7\xb0>\x8e@\x85\xfd\xf7\x98\xb9\xf3\xe8k]I\xdd\xee, \x9eY\x0f\xddO\n\xaa^\xb8;g\xab%\x8d\xd8 V\xb9>\xba\xcd\xbf\xb8!\xb1\x1eY\xa1A-o*\x94\x10\x88\x94\xbc*=K\xd7\xb1,\x0e\xcfAI\xf0\xca\xb2&\xc4QeoRl-#\xa0{E$9\xd0\xb1\x99\x7f\x01\x92b\x8cU\x08\x91\x9a\x17\xedA\xda@i\xb4\xdbp>\xb5j\xa3\xf0\xc2\x1b\xae4\x134I\xf6\xd6\x88D\xc5x+q \xca\xd0\xbf\\E?\x96\xa9\xcfY\xe3D\xaf\x9b\xe8\xbc\x88&\xc1\x03\xe5\xa0Z_\x02-\xbc\x15$#\x9bI\xa8\xbc\x9d\xb5\xe2\x8e\x8fV\xb1\xc5s\xfc\xa0\xbf!|\x95\r\xe48\x9d\xae\r\xb9\x04\x1d\xcb\x14\x06\t\xf0\xbb%3P\xb1R\x97\xe5\n\x0c\xa8\xeb\x9b$\xe0\xd9\xb0\xf0\x1c\xc8\xa1A4\xf8 X3\xc2\xda\xbd_\xfe\x04`\xb5la\xb2U\xbf\xa0H\xf6P\x97\xc4\x9e\xf3\xa2\x1e>_\xa7\xfb*"\xd6\x9f\xacU\x89\xb5\xd9&\xe9q?d+\xa7\x18r\xb1\x16\x8a<\x15\xc6\x01\xc0)\xc2\xc2\x12l\xe2a\\/\xe9\xb5\x17\xc6I\x97a9\xefN+\xea\xe28s\x846\x1a\xde?\x91B\x9c\xde8,(C\xd1X"\xcc\x9aK\xae\x13.j\xb8\xd0\xb9\nD\xd9\xef\xf7;\xb5\x94|\xc3\x8c\xa8\xfc\xd3\xb7\xea\x9aP\xe4\x94\xbd\x9a\x0e\x82\xa9xq\xf6\xfd\x1b\xafP\xdc\x15M=B(\xe1.:\x00\xa7\x85\x82\xf2;\x13\xb1\\L\x8d+#\x8c\xb5,&\xaf\x9c`=\x12\x1b\\\x16\xe7\xe8i\x94h\xad\xbdxH\xbd,\xfdu\xa3\\\x11\xfeZ\xf7\xecC\xe5\x10\x90\x90r8zE\x959(Vk5\x1c\xc9,Y\x11\xf7\x17\xa2\x06\x03\r\xf7?\xf9\xfb\x98FK\x0e\xf5\x97dH\xb6\x10\x0e\x10\x95\xad\x1a\x92pt-U\x0c\x02Oj\xae\x8e\xb1\x842\x98DN\xc1,\xfe1\\\x8c\x8c\xf4T\xfb\xcbl\xde}\t\xd4\x0bj8\x1eo\x9c\n\xe1\xb6y\xbf>\x14\x8b\xcc&P\x0cL\x90\xae\xffb\xd7\xe9\xcc,\xb4_\x07m\xaf\x95\x10:uL\xf1\x80T\xca\xe0\xbb\xb9\x13\xb3\xb2"\x06\x01L\xcd\x12l\xed<\xef\xb0\x1f\xd4MR\xe4-\xf1\xc4Y\xae*\xca\x08\x17\x83 \x9b]\xdd\xbc\xaa\x91\xda~\x8c\xe9W\xe78N9\xf1\\\'\x8c\x81(\x11\x1fjz5\xc3r\x85\xe7\x015J1\xda\xc6L\xdc\xf5M.pw\xbb,2o\xa8\xd1-\xb2\xa4\x0ebB\x13a.\xe9\x08[\x9fj!(\x92\x87\x19n\xb1\x8f\xb7)@\x8b>\x91\x07\x1e\x80\x81\xa1r\n\xec\xb5F\xce\xff0\xf2T3V \\\x17\x8a%\x8b\xf4\t\xfd\x13\xb5R$\xeb\x97ZV\xe6d\xc4\xe5F\x8b\'\x7f\xa6\xa2x\x84sW\xa2\xcd\x96v\xa6\xf1\xd2\xeb\xe6\xa0P\x9e \x1eX+E\xec+:\x1a\xafX\xf0\x8bC\xf9\xc7]\x9c\xed\xa0\xab\x19\xfaZ+c\x18\xb7\xd1\'\xdf\x891T\xa1\x92\xb0\x84\xbe\x1a\x08\xe4\xd5C\x11\x14\xb9?\xae\x8e$\xd8s\xc2\x13\xde\x8fln\xd9\x8a\xba#x\xa8v\xc1\xa4\xc6\xd74[\x97f\xed\xed\x80\xd3\x99\x958\xc0B\x03F\x17\xfb\x9fSr\x91\xde\xc7\x9b\xbb\x9187\xc0\xb3\xc01<)\xf8I\xc6\x99\xca\xa9\x06ne\x87\xb5+%\x0b\xc2Vc\xc45\xcbw') diff --git a/collector/core/gripper/sightac_sdk/api_new/xu_camera.py b/collector/core/gripper/sightac_sdk/api_new/xu_camera.py new file mode 100644 index 0000000000000000000000000000000000000000..169dce217b1eada936af7ed9a6da0b1596a5d5b8 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/api_new/xu_camera.py @@ -0,0 +1,3 @@ +# Pyarmor 8.5.12 (trial), 000000, non-profits, 2026-09-09T18:33:48.367808 +from pyarmor_runtime_000000 import __pyarmor__ +__pyarmor__(__name__, __file__, b'PY000000\x00\x03\x0c\x00\xcb\r\r\n\x80\x00\x01\x00\x08\x00\x00\x00\x04\x00\x00\x00@\x00\x00\x00\xa0\xdd\x00\x00\x12\t\x04\x00\x93\x07\xe8QBz\xa0v\x10Z\xf6+\x9cB\x86\xf5\x00\x00\x00\x00\x00\x00\x00\x0060n\xaf&\xa2q7\\\xb6\x0b\xa0\x81\x8f\xb9\xdd]\xba\xcf\xa6\x01\x03\x97t\x9c\x8dE\xb9\xe2\x07\x84\xa0\xaeO\x10\xa2\xb4*\xae\x93\xf6\xb9\xf4\xd0\xf7\x9dM\xde\xd3\x10%\xcd\xf3\xcc\x85V\x15\xf0\x8b\xe0,\xb4{\xf2b\x9c\xa8<\x81D\x1b\xc6\xb6h\xa3\x1a\xb43|\xc7\x8b\xfd\xad\xcb\xef5\\\x93\x92E\xa4\xb1\xb4\x95\xa3\xb4e+\xde\xcaY\xa0M/\xe8\x12\xfb\x02\xd1\xac\xab\xf1&\xf1\xd0\xcddb\xb2\xd3\x18\xe7\xb6\xbf\xb0\xe71\x17+K_\x02\x9e\x8a\xfa\xe8\x06\xd1\x85/\xa7ZV/\x94\x98\x99\xb2&?c\xab\xc3SW\xa2\x84\xb2\x98\x1d\xe6\xe0\xe4L\xef\xff&T$\n_\x9f\xf5X^\xe7:\xa9%\xdb\xec*bT\x1c\xc5\xbbx6\xfcP\xfa\x1e\xe9\x8814\x87\xa9\xde\x11\xdd\xcd7B\x16t\x90\x03-Fs\x00\xe6\xfc7.\x94\'\xe0s\xcd\xf1[\x0e\xe0\xfb\xf2\xc7\xc9\xd3(\xa4R$f\x90E\xb6\xae(\xc5}\xdbB\xe3$\x96wmC\x04/_\xe5N\xfc\xc7\x88\x7f\xa2\xa5X\x13\xc3\x92\xcf\n\xd9\x87\xeb\x15x\x1d\xc5\xf7="\x96/|\xe51[\x9f\xb82dc\xb6f\x96>,~\xed\x07\x11H4\x0c\xee\xe0\xefz\xc6\x9d\xaa\x057&=\xb1\xcap\x16e\xc7A?1h\xb3A@`\xa7\x17\xf5\xe0\x08\x00\xb01@x\x10\xb7\x9cR\xa4Y\x83\x1f\xc7ea\xe2\x8dy\xb7<]\x93\xbcReBE?6\x87\x1fz\xef\x06\x95\x1dGw\x10\x1f\x96,\x11\x98x\xb7\xd9\xcf\xa7U\x1e\x9d\x03\xdb\xa3\xff\xdc\xa1\x84\xe4\xf0\xa4\xb0{ \x13\xd9i\xfd\x94\xa5f\xfcbblgq\xf8(}\xca\xc0F\xb3+\xef\xf5&\x16*\xbae$\xd0\xfe\xde\xfa\x9ex\x1b;\x16\xcd|h\x99\x99yDI\xaf\xaf\xf5\x7f/\x1a%3Q{\x02\x1c\x7f\xc51\xfd\xa9\xf7\xe3\xb8\xed\r\x1f\x85\x83BD\xa3zF\xfe\xcf\x86\xabV\xb7<\xb1Cp\x95\x8f\xf6\xf5t\x02\xeb\xbf\x00\x00\xafi\x1e\xfc\xec\xfb\x97F\x9aY\xe2E\x7f\xc2}\xee!\xbc\xa1I\xafix\xc7\x7fI{J\x11\xe2]\xcdk\xd2\xc8\tLH:HE"@\\\xff\xaf\xce\x9f\'\x10)\xd0O$\xe6\r\xd2H\xf5\xf7\xe0\xac\x1d\x10{\x8b\xc6\xe6?\xd3\xe4\xc4\xcd\xa7\x05\t\xbf\xc7[\xc6n\x91K\xfc\x1a\x06\xa3!`B\'W\xad\xeb\\\x8c71\xbe\xde\xf2c\x8c\xaa$N\xd5\xeby%:\xe3\xaf\xd0n\xca\xaf_])n\xda}\xad\xa3\xbat\x14z\x1b\xa7\xc7w\xec\xf8\xffh\x15[\n\xb5\xee\xb3n\x14\x88\xb8`V\xdd\x0e\xf1\x9b\xec\x01\xf1h\xf0w\xbb\x8e\xab\r\xe7\xe3Lq\n\x8f\xc4"\xd4i\xed\xe5\xfe\nr~\x91\xa3X{r\xa5,\xcf\xbfZ\x19\x92\xfb;\xfc\xd2\x11\x8c\x04={J\x19\x7f\x81\x85\xb5\xd1F\xe7\xce\x84\xc8]\xa2\xae\xaa\x16\xa34\x07=d\x80n\xe4\xe2\xfc\xa6\x82\xa2\xfc\xab\xdd\x7f[\xacX\x82\x17\x8a\x0c\xe4Z4\xf5\x04\'\x91\xc0\xf5\xd0\xed\xa9\x94\xa30\xca\x1a=\xd4l\xc7\xb1N\x07o\x10\x13\x0e\xb0\x8f\xb0\x00\xf7\xbd\xa2l\xbc?.VC3\x8c-\xee\x9eh\x18\xd73\xb43&\xd8\xb6\xcf@\xa3\x19/!\r#\xa8\xcco\x93f\x8d\xa1\xb6\x02\xb3+C\xbd:\xa7\x13\x9a\xbb\xc6\xd24\x83\xbe\x9c\xbb+\t{\x0e\xeeP\x83\xc7#\xcc\x15\xb3z\x14\xd6\xd4\x19\x9d\xe3\x84o\xf29\x88A\xa8\x83\x84$_\xeb\x13\x1fd\xb9C\xff\x07/\x1f\xfd\xfaew\xc8\xf4\x9f\xea*\xfdJo\xe6\x9f\t\xbbY\x0f9z\xed\xfe\xff\xa8\x02\x98\xe4\xcb\xbdw\x9bMo\xf1\xa3\xdf\xe3\xbb\xbc\x9d\x80\xa0pu\xe1zVx\xc9\t\xbb\xf4\x9fG\xe4\x98\xb7\xd1H\xa1/\x01\x9aIr\x17\x98\x82\x0e \x1f\xa9\xef\x8d\xd1\x1c+\xc7\xe1\xf6\x17q\xdb\xeeb\xf3^\xde\xdcH\x87\xe4!\xe8%\xa5+\xf2(_\x8a\xa1\xf4\xfb\xd6\x1a8\xb3v\x8d\xcdk\x8fp\xe6!\x8cux\x97w\x9fN\x94\x83\xedW\xc1R\x11\xc2%Ve\xbd\x8b}P\xa8\x916\xfc\xc7GaO\x98n\xa9\xaa\x95\xfdTq\xbf?\xbb56}^\xd7\xd4\x02\x97\x9c\x84\xf7\xf7G\r?\xee\xe0\xd9\x9d\x7f\xc0\x1dxd:\xc4*\x1cFr\xbd\xce\xbe\xf7\x1a\x13l\x87\xcb\x9aX\xf9PY\x12[\x05N\xcb\xc2_d\xa6\xd4B\x1b\xa2=\x9dO]\xe0\x91\xceIV\x02,%\xf5\x85\x96r\x11\xa7*\x12\x9f^\xe0\x84\x16\xde\xd5\x9d\x97\xe9b\xa8y\x19\x9d\xd2\xd5(\x19\ni>\xf3(\x16B\xb3}i\x00#%~\xc8\x15\xc1\'Z\x12p]\xea\xbeZj[\x9d\xd3\xa9Ab\x1e\x9a\x9eE\xc1\n\x1f\x81\xa7j\x0b\xb9\xdc#\xbe"3\x9a\xfb\xc8Lg\xbd\xba\x02\xb2\xab\x8b\xf6\x8a\x89\xe7\xe18\x91g\x11\x94\x84\xcf \x115\x04@S\xe0~\xf7\x97\xc0\x17\xf6%mk\xfc\x00$?)5\xbc\xae\x10\x12g\r\x87Dn\x064V\x82\x10\xf2\t\xdeKZ%\xb8\x14\x01\xbe\x8fP\x0c\xad\xbd\x8d\xb3\x10x\x1a\x9a\x1b\x1a\xb6r\x80\x07\x1eP"5L\x87\xfb\x9a\x98n\x93\xda\xc2wy\n\x13f\x18\x15\xcc@+\xed\x1aO\xd7\xaf~E\x08v\xd6}2U\x07\xa0\xca\x99Y<\xc1\x06\x86\xbc\xb2\xc1\xaa\x01\x91\xf0\x9e\xb5\xb1J\x96\xfc$8\xa1\x87\xee\xe4\xed?\x8d\xb1\xeavA\xa9\x95UJw\xd7\xf4\n\x9c\xfe\x19\xf4\x8fH2Q\xf4C\x90\xf6r;\x1eQ\xe4\xbd^v\x9d/\x16\xa6\xbf5\x9d4\xe2\x80\xdef\x81\x04\x10g\xc4\xca\x0bmte\xde\xff}\x0c\x91\xe8\xbbN\xc1\xe5\xe2\x86\x0b%\xc5\x9b\xe2\x04\x84g\x0f\x81\x05_\x81\xec\x97\x10\x16\x82\xe9\xf9D;\xca\xf2\xdad)\x154\xc6\xad\x07p\xc6T\xe3wYk^\xcch\x115\x17\xd7\xcb \x8e \x08\xeb?\x13\x91zA\xa8\xaf-\xe2\x91\xc1\x9d\xa3\x19)\xb0\xc0xv\'\xbd\x90\x92*\x8d\x1b\xa0\x06\xa8\x12A\xd1X/\x88y\xf1\x17~\xa2*7\x80c\x05toM\xb8;rH"U\xa5UC\x92F\x11F BTo\tC\xffS\xe1\x82\xc3\x95\xaaq\x97dE7E\\\xc9R\x96jM\xab\xd4:\xccI\xb6+\xcd.N\xd7\xa5X\x82<\xb0W\xbd\x8ew\xf6\x93T\xc74W\x8cR?\xbe}]\x07\x84\xc9\xd9\x7fI\x06\xe6\x9a5\xc1\x10]\x16\x93\x97k\xa9N+\x17QC\x98\xb2\xbd\x7ff/\xc9cP\x83\xba\x96\x8d\x1en@\x92\x07_P3\xaa\xd7\x83\xfe\x8d\x95\x15*\xfa\x90"k\xb9+l\xcb\xa4\xeeq\x8e\x9d\x7f\xcd\xb4(\x0e:_\xd7 l\xa5\x85\x8a*\xb6\xe7\xe2+N7B\x1b\xf3\xacvD\xab\x9dR\xceV\x1d@f\xbb\x81h\x9dEZ4I=\xe5\x08\xb4MAZU\x15\xe4"\xfa\x9b\x980e\xb2\x8a\xc4&r@\xcd\x1a\x809\xdbA\xc8\xf3H|\xf3z\xbf\x19\xb1\x05\xa1.\x1ak\xb8\x1c\xe7\xc3\xbb\x0bM\xe1\xdb}\x13\x80\xc2\xb0D\x00mel\xa1\x83Zk\xad\xdbf\xf2\xa6\xd9\xed8\xfd\t\xb7\xfc\xf7\xa9\xc2O$\x05\xf5\x07\xf3\x0cI\x896F\xc1\x94a\x9a\x08\xb7:\r\x97\xf9\x957\xdf\x00[\xb7\x15.\xceB\x80\'\x0b\xd3\xab\x90\xad\xbe\xfa\x1f\xa1m*OI\xcf),N\xd7\xd3:ct[\x1e`\x83v\xa3\x12!\x91\xb0\xbaT~#R\xaf\xb6\x14\x1e\x85T&\xafy\xa9\xa8\x1d\xf4\xc2\xffk\x00u\xc9c%\x9e\xc0k\xf2\xcf\x9arXT\x1f\x82\xf0\\\xcb@y\x89+\xc95\xa5\x08\xc6\xe1J\xfc\xdc\xd6\xf4\rW\x8b\x94\x1f3\x00\xc8\xc0]\xf0\xcf\xea\xdcFY\xec\xab\xe1>\xb1G\x9f\xee\xfb\xddo\xc9\x8eE\xb8\x97\xdf\xcc\xa5\x8f\xe3Yl\xb2wt\x87\xe2\xf5v\x8e\x8e\xeb\xbc\x94K\xa9\xbeV\xd901\x91:\x96\xf8-\x0f\'\xa1\x0c\xd8\xd3\xd0[3\x7fV\xdb\x00\xa0a\xe1{\xfao\xccpL\x80\xadw\xb8\xea\x04\x07\xec\xa11\xd8\xd84/s\x92OB\x88\x15\xcf\x88T\xd3\x19\x1dX\xb7\xba4\xcc\x0cD\x04M\x1d\xffg\xdd\x1e\x04\xcbG\x9d\x8bzE\xab\xe4\xe6E\x0b\xaf \r\xd6Feo\x8a\x05\xd4b\xbb6\xbb0\xdf\x1d\xbe\x0c\x06\x12\x8b\xba\xc38{_\x80\x95\xe8\xdbS\xe9\x8c9 \x02\x9df\xd2Ob\xa9\x9a\xf9\x1b\xa1\xbf\x89\xf6\xcc!\xae\xb0+\xb4\xee\x9b6\xbc\xe4\xe1O\x1b\x8d\xf7\x93`\x00\xd19\x00\xc8S\xc4\xf8\xdc[\x81\x87)\xb5\x1b\x84&\xb2\x86#\xf0\xe9\x9a\xf3\x18\xdf\rl$?A\x90-\xb5\xa9M\xd8\xe3\xdbtb7\x1b\x9c\xae\x08:\xd4\xce\x14\xc2f.K\xb4\xc0\xbf}H4\xaee\xc9\xcc\xc0\xc4\x19=\x9d\x82\x1d\xf8\x8f\xed\xee\xa2\x93\xcd\x03\xc8\xd9:\'\xdd\x08PB\x03\xf2\xda\x87\x9b\xe3:\x15av6\xac\xa9\xbc\x19\xbb\x08\xdd\xb3\x0c\x85\r|}(.\xcb\xef\xf2\xca\xc7^S\x84?\xd9\x1c<\x9d5\x98x\xb9\x0b\x93\xff\x8d\x01\x057\xf2\xaed\x0e\x1f\x8f\x140\xef\xbe\xd9Z\xc2V!\x1c\xa2\xca\x1dWL\xa8\xfc\xed\xcb\xe0*\xee\x0e4\xe1\xc5O#\xe0\xf6;\x9dah\x17\xe5\x1e``\x8f\xad"\xfc)r\xe84\x18\xb4\x02\xddO\xc4u\xb8\xaa5W\x878p\x98\xf9N\xbcW\xda\xe9r\x94(c\x88y3wg\'\xa4qQ>{\x9asm\xb3`\xf0\xc6\xcd[\xff\xa3xw\x8c\xadQ\x00wZ\xb1)85r\xeb\r!$\x9a\x9e\x0e\xab\xa8z\xbc\x17q\xde\xdc\x93}\x06\xfbf\xf9\x93)\x99\x19x\xd1[\x05\xfa\x87\x07\'\xfd/\xd9\xd7\x1cZ\xd9\x1c\xcc\x87\xdb\xe1\xf9\x180e\xad\x88-\xf1\x92\x85:\x85M\xf2\xccj6\xc9\xf33\x87\x10\xfc\xfc^\x1b\xc9& \xe4\xb9\xf6"-\x16D\x15,\xc0\x97\xfb\x19\xa8\xda\xecM\xf8.\xe0\xd2\x17\x1b\xb12\xa2\x0f\xce\x93q\xfd,ae\x19?\xdbF\x93\x05\xacj7\xb5\xde\x1e\x80D\x92\xca\xe9\x1e\xb1\x00\x92\xe6\xc5xe|\x1f\xac\x87\x06eTK\x85\x01\xaf\x1a\xe4V\xdbq/\xd0\xb4Rc\x04\xddNU\xd2\xc6x\xa3\x12C\xd5\xc8\xf9\xee\xdf\xe8\xf5,\xca\xa2\xa1\xae\x1e\x16\x1a\x87\'6N\xe8\x8a\xaa\x0cB\x18\x94JV\x1c\xbeDN\xef-\xfdC\x10U\x06?\xec\x8e\xa2\x84Fc\xc2\xd34\xe1\xea-\x8e)\xb1l\x98y\x92\x8cX\x87\xc2\xad\xc4k\xa2\xa5\xb7Z"\xb6\xba\x8d\xee\xb1\xe2\x9b\xa7\x00\xfcs\xfa\x05\x85r\x88\xd0\xde\xb3\x0e"\xbf\x97a\xf8\xb7?5\x87\xd2\xbejL{`=\xa6\xbf\xc3t\xe89\xca\x95\x9dA\x0bX\xd6\xbb\x0e\xfa\xe1\x03>\xbb>\x87\xe8\xa9-\xc1x\xb0\x83\xfa[yV\xf5\xbe\x97\xc6W\x98\xf8\xf5\xe9c\x9e\xaas\x8b\x12:\x94+\x19\x93m\xec\xc5\xfag^g\xb9\x9do\x17\xde\x9d\xd5J\xc2`c\x8b;O\x19\x84J\xa6\xb53\x1e\x1ct~~\xb3\'m\t(;sB\xc43\x80v\r\xc1\x16g5 }\x15\x1e\x95\xa1\xca\x11\xf7g\x01\x9f-2v\x93VQ\xb9b\x02\xc3\n\xeb\xe2~`\x1e\x97\xdc\xd5\x08\xab\xcfPM\xa7r\xac\xfbp\xc4\xb6?\x9f\xa2H`\x15\xe3\xf5\xde\x9d\x87\xddm\x0e\x8c"\x99c\xa7N\xcd\xa4\xdcb\x93\xed\xe5\x92"T\x1f\x89|c\xa4\x14S\'0\xd4_lV\xa9\xba|FmxY\xa3\x94\xed\x05\xd5v\x98\xdciR\xc8\x03\x99\xa9P\xd0\xa7\x03\xe7~\xf9\xd9\x8e\xbd*>\x91G\xc8\x13l\xbd\x0c\x99?\x08m\xfaOo\x8e\xa3\xec\xb6\xecy\x13\x931\xbcX\xe7y\xff1 RWv$\xecy\x00\xeeA\xc6S\xc2A\xf0\xc6\x80\xd1Y\xd8*\xaf\x91\x0c\x06\x19\xc0:\xa3o<\x99\x1bR|}#\x92i\xc5$\xdb(\xd6\xa3)\x82\x9a\xafo\xb3\x90\xc8\xc4\x01\xb0\xc9\x91\x87).s"\xbe\x98%qCG\xb9\x82\xac\xf2K\xc9\xdc\x7f+\xbdtr\xca\xbe>9\xb4\xad\xfc\xb4O\xa0\xc7u;\xa09\x9e\t\xcc\n\x11\'\xb36\x9c\xe1\x8c\xf3\xdf\x0bSP\x8ab\x01\x97\xcdc\xcf%\x08\xbc/v+\xcf\t,y\xfd<\xd0\xff\xf0\x96\xbb\xf8\x00\x81\xc7O\x0b\xcf\xef3\x16\xe2Twh\xac\r\x8c\xe4\xc1S\x15\xac\x9dH%\xfcT\x03\x91l\x87G\x1cgcg\xb8t($(\xbfzK\xa4\xbfU\x8e\xd7\xe3\xe1\xbf\x1d\x1d\xc87\xe4\xf1\x9d\x9ed\xcc\x05\x91\x13\xdc\x88f\xe3=\x02\x15e#\xc7DZYq!\x8f\x8e\xd6\xb7w\x10\xb2l\x95\xd7\xf6{tR\n\xd0J\xaa_\x8c\n}\xea\xda\xca\x8d\xbf\xa7\xd4\x8e\x9aD\xeaiY\x05o\x99\x1b\xb1\x9a\x89\x14\xf9:\xe3\xe9\x0f\xca\x0e^m\xec\xd9j\xfb\xa9\x99E\\&\x12qe\x9e\xcc)\x00\x06\xca\xfc\xc9\xe6v6\xcaP\x900\x93\x07:b\xde|L\x94\xbe\xe0I\x83\xa2TY\xe5e\x119]\x10\x8e\xd2\xa2i[;E\x8d\x0b\xad[+\xc6@Q@\x19\xadSA\x1a\x9c\x9dd`\xea/\xa0\xef\x8dD\xdc\xe3p\xeet\xf8g\xa1\xea9\x17\xf1d4\x06\x9a\xe9\xf7\x04\xfa\xc4\xc7\xab\xc8A\x11\x15\xe24;\x08E\xd7\xbb\xdc\x18\xa6\xe6\xae\x99\x04\xc1\xb1\x05]\xcah\xe7l\xaa\x84\x03\xcf\xb8\x89\x8bv2z\x93\xae\xe2\xfdCm\x86\xd9\x0e\xab\xd9\xdb\xa7\t5o\x81\xd0>\x9c/\x01\xae\xf1\xb8\x1d\xb8\xb6\xd6\xbc\x17\xf9\t\xd2{\xe7,><\xac\x08\xa7\x95\x80\x96\xbfkZ\x95K\xea\x96\x08\x7f!!\xbc\x92\xed\x8fc*e\xde\xa9aWT\xa3.\x04\x1b\xd8\xfa\x9e\xb5\x06\xfd(\xfdo3\x9ez\x9be\x18\xa9D\xe2\x16\t\x9edfy\x95\xe8.\x0e\xc8:\xd1J\xbf)\xf5i\xf5,\x9a\xf2\xb7!\xadh\xb7C\x96\x88\xd2\x87:\xfbX\x9f\xeb\xbe\x92\xcc\x979r\xa1F\xacL:\x1bs)\xbc\xd40\x9f"\x1e\x0e\x98_^\xe0\x1d\xe6\xc5\xee\xb9\xef\xb0\xf0r\x84\t\t2\xa1?]\xbaQ\xa3\xfc\x16\xde\xd2\xa7z\xdc\xf7\x1e\xbbF\x12\x92\x82xj{\xcfG\xcb\x93\x0fs\xaa\x9d,\xde7\xb1\x9b\x9d*\x08t\x08\xac\xbf\x90c\xa7\xebc\xd7b\xcb\x14\x8e\xdb\xd2\xae\xa2\xc22\xcfP\x91\xd6\xd6;~\x95\xe2q\xfe\xe4>\x91\xdb@\xeb\xdb\\\xcf\xefu\xa6[\xe0\x02e\xe2\xa2\x0ek\xfa#\xfe\xc9\xe1\x1fP]\xfd\xa2\x80\rGh\x9f\xfcS\x8dn\xf6\xb5\xa2\x94\xc7\xb1\xa6\xdbA\xb1E\xe7\xbb-->+\x01[\xc0c\xd3\x8b<\xd7S\xd0\x1b\\\xaf\xffL)5\xfe\xdc\xc9\xe0\xba\x8d\xf3]\xe7\n\xed\x1f\xa1lg\xd2\xd1)\xf8\xca\xea\xf0s@\xb1\x0eq\xdb\x85ll\xa9\'\x8b\xb3\xdf8\x15}\x07\x17<\x14\xd6\xf1\x1a\x03\xd8"!G\x05\xa4\xed\xdc\xe4\xce\x16\xc1\xbb\x94\xe5+\xd9-q\xb9\x0b`F4\x05|\t\xd1\xd4\xacY\x7f\x86}\x05\x97\xbb\xee.\xae\xba\xde\xc3\x8eC\x0e3tZx\xb2\x14\xdc\x12V\xa6\xbd\xd3\x90\x13\xd9\xb3Sy\xe4\x90=2\x84\xb2\x04z\x11/\xb9\xef\x0ew\xfd\xc1\x9b\xa2Ve\xb0X\xd2\xf9+\xb6d2|2^\xad\x1a\x17\xfa\xf3\xec\xb7\x9e\xb3\x07a\xb74\x1c;\x8f\x17;\x97\x96\x1f\xe1\x97\xc1\xf5K\x074\xe5\x86\x98G\x06\xe1~t\x12\xe7\xf9?\t\x0e\xb9\xc1\xb9;\xc8\xdcE3Q\rx&\xacv\xae\xe0\x91L\xb6_b\x08\x8cbHf\xac\xe6h\xc2 }\xf2B\xf0\x1c\x95\x03\xca@\nR\xd0\xdff.Q2\xbf\x91)\xfe[\x8b_bo\xab\xd7\x9f\x96\xf1\xfd\xac\x05&\xcf\r/\xdf\x14@\xe2\xc9ju\xb5\x9e\xe16\x97=3\x85\'U\x93Z,\xd4\x06\x0c\x12\xc6\xb4\xfe\x19\x8a\xf5{\x16\x16\x9c\x1d\x0e\xaf\xd8 \xbc\xb2\xa9e\x8e1\xc0T9\xfd\x94\xaf\x1bq\xa3\xff\x8d}\xb0\xc7\xd4Z\xd2hq"h\xc34g\x93\xb8\xd2{5`\xc4\x82-\x8e\x17\xb1;\xe2.\xbe\xba\x1c\xc4\x90@\x8e\x06\xed\x92\x9a1\xb32\xf6g\x16\xd0MLY%\xad\xff\xe2\r}\x9d\xdf\xd9\xcb/3\xfb\x08&\xa8\xbd\x04\xf0\xc5\xeb\xfcM!\xcb\xf8.\'?\x8c\xdc\x95U\\\xe8h\x13}m\xc9\xb7\xe6Qd\xd4r\x96\x08\xef\xfc\xb7\xe6\xcd\xea\xbdN\x1e\xbb\xd1oh\\\xcc2V\x86\x0c\x89\x078\xaf\x1a\xbd\xee\x16\x88\xeb\x10[\x9bp\x93qu1\ru\xccQ\xecg\xbb\xae\x9c\xb8\x05F\x8f\x05\x87\xfa\xfc:ho6\x9f\x7f\xc5\'\x10\xc8\xb7\x8a\xc5\xc1\x82\xdd\xb0\xac\x12\xb0DH\x8b\xc0g\x926l_\x9cL\x8b\xd3\xc7\xb7\'V\xd6\x04T\x92=\xd2\x03D\xb4\x0b\xc8\x97\x9b_\xc17\x01@\xea*\xea*\x89\xc0\xd65f\xa7#:\x86\x1f\xc5\x9f\xfc\xfb\xa1\x13\xaaH\xa4\xe8\xdd\x18\xc9\xbe`\xa1\x19+\xb0\xc2P\x8b\x90\x9f\x00\x03\x17\xb3\xc1hQhT\x8e\'ad\xa0\x9a\xcae\xc9\xb6\x8dZ\xd9\xb9D$\x06\xed\xa5kT\x1b:,\x8c\xedx\xcd\x84O\xa9\x07\xdaC\xe7\x8a\xdcJ\x9b\xe5B\x06\xd26k\x96J\xfe,m\xfdBh\xd0k\xd9U\xaeymw1]\x83\xeen\xd0\x03~J\xdd\xdb\xa4\x92:\xda\xcc\xaf\x99T\xb2&1\x11\xd6\xc2\xbe\x1d\x83xy\'ec\xcd_\xe6v8\x88\x11\xb0<\x19\xf6f63\x9d\x1c\xbb\xd2\xda\xb2Xvg\xb0\x8d\x80_H\x9f\x17\xaad\xde\xe0\x95\xd6H6\r\'\xc97\xaccm("\t{\xcb\x94\xd6\xf2v\x1e\xfbZI\x9d\x96\x92\xed\x17\x8as\x0fk\xa4%\x1d\xab\xff\xd3\xc4\xcdO\xd2(eN\x8f\xf3\x1eX\xde&\x1b\x88m\x86\xc5\x95\xfa\xb5\xae\x83@\xf7/\x90\x0f\xeaY\xf85vJ\xc3\xf94\x95R\x08C\xc1\xba\xbb\x02G\xc6\x15\xb4\ri\x1a\x0f\xf6\xb7\xcasV[JJ\xc3\x95\xbe]\xf4k\xf3\t\xffZ\xf5x/fH\x16\xd7;W\xd4m\x92%\xcc\xd8\xf9JH\xe8\x0e\x80F\\\x1e\xf2\xa6\x14w\xb3\xf7\x9bQ\x96\xe8\xc5\x93c(7m\xc9a\x16\xe1\xdd)+\xaaB\xf7\xa8\xe2;\xe6\xfb\x8a\x02|\x82\x07c{\xc1N\x11V\x83\xa0\xbb\x84N\xfa\xcbS\x8c\xe3\x84\x97\xad\x92\xeb\x9d\xbe\xe7$\xb1\x7f\x10"c)Z\\S\xdb\xa8\xf3\xe9\xa6a5\x03\x98\x07\x05\x14A\xc3\xed\n-;\xea\xac\xb1\x1eq\x98\xabA\xc4\xb8t\xc5\xca*cs\xe3\x98)\x98pH\xfc\xa1<\xe6\x1dft\xa0}#jy\xfew\xbc4\x02\xd3\xae\x98\x01O\xd0\x96\xa9\xfbP\x1e>\xf7\xec+\xfd\x01\xdd\xd4D\n)>\xf2\xf1<\xa9&\xd6\x1d \xdduK\xe7\x99\xech\xb1J5\xbd\xc1<\x85\xcf\xc6\xa6o\xc3\xb5u\x07\xd3\xad\x9b\xb1\xe5\xaa\xd2Gh\xb9\xb7vw\x97\xe6\xf9\xae\xc8v\xea_v/`\xd4\xcaz\x0f\xae0\xcew>\xb1\xe5\xb25\xfa\xea\xd8\xb6\x87^k\xc3\x83\xdc\xf4\xab7zb>K\x05E\xda\r\xc3\xed^S\xf3\x02\x12\x8c\x8bZ\x912\xa9\xd4\xa1\xf5\xcd\'\xfa\xad\xa2@\x9b\xbe.\x8a\tW\x8ew\xe1\xfc\xe6\x84(\xac\xb2\xdd\x1b|\x94\xa2Q!\x17\x8d\xe2/\x7f\xed%\x81\x95T\xd6IU\x1a\xabd\x83\xff\xd7\x81<\x16s\x8a\x10bK\xc7\x8c\x05\x90d,`ws#\x9e\xca\xee\xb2\xcf\x8d\xd7\xa1\xbd^\x02\xc6\xfb\xa2\xb6\xe6\x1em|L*\xf2\x8a\xbe\x0eT\xe5\xe9\xb8\xc5\x01\n\xacEYZ\xa1O~\x8b\xeb\xa8\xc0\xf56EZ\xa6\x89-\xd2\xe9\xdc\xa2%\xecH)\xb8\x0bBS\x9d\xfcu\x83\xb9\x13\r\xd9Q\xf4\xdfn9I\xe4 \xba\x1d\xc2\x90\x82\x90H\xe9\x9f\xd9\xff\xb0\x979A\xda\xd8\x84\x8b\xff^\x92>\xc1\xcdN\xebb\xb1\xeci\x18R\xb7\x8c\r\xbfW\xd1\x1d\x15\xe8W\xea\x87A\xe9\xfb\xb7i\xd3f\xa6\xd3r\x8b\x03\xf2\x9fGwZ\x05ySL\x178\x0bqpN\x8ei):\xff^\xcb$\x9a\xaf*\xaa\xf7\xf5C\x9f8\xcb\xde\x8a\xc1+\xd9\xd5t\x1b8\xe8H\xe0\x8b\xf4\xf2\xa6\xd9\xfe\x01s\xd0\xba\xaa\xb4\r\x12U>\xdcg\xa0S0\x13\xe4\xb1\x11i\xe9\xc5E\xf9\xedU\x85\x84\x13U\xbe\xd1W\xd0\xa1!\xe7l\x87\x1d\xa6\x03dW\x98\xe4\xa4+D\x16\x9eQi\xb4/\xe5X\xb5CY3\x87\x8f\x8e\xac\xda\xd01F\x00`N\x02,\x1fY\x10\x12k\xc3\x89]\x15\xb0\xa7\xf3\xfe\x1d\xeb\x07Z\xd7\xc4\xc2\xdaT\xa0\x95Jy\xca\x02U\xd3\x84\x1e\x83\xf5\x06\x03\xff\xb4\x03\xef\x9c\xb4s\xb5\xb1\xc7,\xfe\xd8\x9e\xbdp\xc9\x1f5lp\xbf\xd7\xf7\xbb\x9a\xeaQ\xdbKU~\xaf\xdb\x80\xdc\xc4\xde\x81\x803\xa5\n\x94\x198\xb7\xb7\x95\xd9%]\xc9w"B\x1d\xa5\x90\x98\x86\xc13\x00\t\xe6\xec\xe4\xcb\xf3\x0ctk"\x90\xaf3\xde\xbfa5\xff:9\x078\xef\x0f\xafW\x08SQ\x7fjW\xbd#\xf3e\xa1%p#\xca\r\xfd\xdf\xabE\xf2\xcb\xa2\x87\xbb\xdf\xea-5|\xd6/\x85%\x1e\xecI\xa1W+`[\xd4\n\xfb\x88\\Z\x05\x81aVfme-!\xb5\xf1\xb1\xcfy\xbb\x81\x10:\\\x004d\xf0\x86|\xc8\x11:4\xe1]\\e4\x0e\x8d\xbeo\xdfx6\xdd\x91\x03\xf8\xad\xd6jo\xf0\xf5\x84=\x17!\x81\xba\\G\xa2\x90\xcc]\xd2\x17\xaf\xa5\xbd\xdd9U\x895\x19x\xe9A\xe5\xd4$\x16Xy\xeeO}z\xd2\x9b~\x85pkEMv\xe2:Gts&\xa3\x9c\xb4=P\x8dy\x15\x18h\xf8K!\xfdb\\\xcb\xdb\xaf`\xc9\'\xfe\x0cM{\x82\xcb\x00\x08j3_q"l?\xed\xdf\xf0\xc3\xf1\xbf\xbb\x1b\xe9g1\xa5|\x01\x16=\xdc\x83!*\xf0\x8fD\x97\xcf\xaa\xc4\\ o\x12S\xcc\xb6\x1d\xa5\xac\x9a\xbb\xa4\x91B\xbc9\x10\xed\xa2\xd4G\xd2\xd6\x92\x8a\xf6z\x7fw{\x10\xea\x80\xa6\x8b\x171G\x19c\x8d\xb6\xfe\x95W\xed\xb2\x0e\xcf\n$9\xaa\xb6n\xf9&0[}\xc6\xba\xf2\xea\xd1\xcb\xa0;\x14\xb7\x0f\xaa\xd0\x1e\xac2\x08KK\xaaT+\xe7\x94&L?<\x84\xca0\xb7\xae5\x99iN8\xb8\xc8\xd9T\x18\x14\x16\x06M\xa6\x16\xf4\xbcv\xdbc\xccl\x87\xb8\xb2vo\x87\xaa\xdf#W\xa8B8\xfbz%K\x1aX9X\xcc\x05\xd4Tn\xd2a\x91K\x01\xe5FJ\xccK\xd2A\x18{\xc25(x\xa4,h\xbb\xfa\x10\xbfNY7\xecs\x13\xf0$\x8f\xa7j\xd1\xc4\xea\x0f\xc9\x17\xc49\xe7\xad\x80\x03\x8c\x0b\x96i`\xe6\x1b\xa5\x86\xb4~E\x8b\xc1!&\xcd]Q\xd1\xdb\x05r\xa6\xd1\xb6\xffU\x149cth\x93\x80\xa8L\x97\xf6;\xeb\xc7\x04uX\xe2[\x1dk\x81u~\x83\xaa\x14A\xf0|E\xe3\xcf\\\xf0\xb8\x0c\xd1I\x19a\xeb\xc0\xc9\xcf\xc0\x88\x0fj\xe8@`e\x94\xfbd\xdbaE\xe9\xef\x10\x98\xbe\x97\x80v3\x1e\x15\x00i\xe0A\x80\x03_\x17\xecr\xa7\xacw\x1b\xdf\xa0\x9e\xa2\xf1\xcd\x0e\xe0\xb2\x9a^{\xf1{X\xf7>(E\xdd$m3\xb129\xc1\x12+1UB\xfd\xb6{\x17\xd7\x9d"\x8a\x80Z\xd6\xc8E\x9c\xe2\xea\x08W}\x85\xed\x8b\xdc\xba\x7f\xfc~\r60\xe7\x98w:J\xa3\x9d\xd3%a\x1c\xf7\x1b\x863\xf7?\xf6\x18\xddw\xc5\x80\xf0\x9a\xa9\x81\xec\xcb\x02r\x00\x99\xfcH^hl\x94\xb4!"#a\xbc\xf4\x10q\x18\xc8\xa0\xa2\x8a\xac\x9b\xd8\x1c\t\xac\x06@\xa1\x0ew\xc0\xbe\xb0k\\\x9c\xa0\xfe\x17\xf5Zw\xe5\x9c\xf2\x9c\xce\xde\x96\xc3P\x8b?\x1d\xae\x13H\x9d\x1f\xa8\nT\x8b4\x8e\xceR\xf7\xba\x91\xca\xfb\xedX\x90\xa7o<\x0e*\xc0\xa7X#\xce\xce\xeb\x86\x96/\x96j\xc3\xc4\x19\xc9\xc1\xda`\x81g\x95\x07pB\xff\x99p\x93\x8b\x02Y\x9c\xa8\xe8s\xba\xf7\x98\xc3\x86\x0c\xffW\xb2\xd5\xd6\x98vC\x8b|\x01L\x8eZ\xe1\xf1=\xd8=\xb3\xd9\xc7\xb6Fm\xe1yI\xddU\x9b\xf1\x01\x0e0c]\xd3M\xf0\xd7\x97\xba\xc0\xef\xedg\xf0##U\xcf\xc3\x07t\x15\xbd\xcbk\xaek\xed\xca\xf5\xfa\x9c\t\xeb\xef\xbb\xeaU\xa2\xbe&\x8dU\xc6\x9b\x99\xbe\xd5e\xaf`\xf5:\xc7y+^\x823r\xf0\xe2a\x81\xdf\x82\\H\xb5:\x15Q"o\xfd\x96\xb2\\\xe99\xb4\xa3\xd4\xa7\xe1`h\x90\x05\xf1\xf1R\xb1|\xb8FyaDq\xb2 cv\x85\xbdt\x01\xa9\x10\xe6\x98\x92\xc56JB\xf8\xefbS\xf5q<\xaa%\xd6\xcc|l\x0e\x9f@5Ex\xc9vO6\x85\xd8\x0eE\x08\xd4\xd2\x18\xb0\xda$\xf1\x89\x896\x91\x06b\xfd\xcb;\x1d\x18)\x17\xd7\\\xcf{C\x85\x8e\xb4q\xc8\x15\xb9\xbd\xec\x9ee(\xa5\xfb&\x0c\xa1C\x88\x7f\x14<\xf19\twb\xc9\x81\x11\x05eH\x04,\xc7\x92(\x80\x1d\x18\\i\xb2-A\xc7\xa0,\xca\xe7\x80C\x89!\x90\xe0\xb4\t\x0cHd"\xbc\xce\xbd\x1e\xaa\x80\x83A\xb1\xaf\xd4^\x82\x8fp\xa5\xe0\xa8\xf2\xc7#\x84\xb4\xe1.\xe6\xd0\x08\xdc\x97y\xff\xae=r\x0e.\x91sleA\x02\xffT\xc9\x9f\xcc9\xfe\xc6>[\xcf\x87\xd5\xfek:9&\xb3a\x9a\xa9)\xfa\x98\xc6TZ\xbe\xce\x94\xd172E\x84L\\H\xef\xd7\xd8r||\xae\xdc\x01\xc5B\xc4l\x1a\x00\xb6\xd0\x10\xd1\x11:\x0c\xb1-\xb1?|\xcd+h\xf7J\x06\xae=Zm\xf5\xd7\xfc>5JiKD\xab\x9f2C\xf1\xbd\xf5\xb3\xa5\x11\xaet\x93R8$\x96\xae\xa4\xee5\xeb\xcf\x93_>Y\xbf\xda\xdd\xe4\xf4*I\x91\xed\x8e\x91ZqjB\xdc\x89\x15\t\xd6\x0bvL\xa4\xaf8\xe3=1\xb4B\xb2fO$\xe5\x0c\x18!9\xbc\x96\xb2=\xdaa\xbc\xe4\x9bzK5\x8a\xca\xd2\x95v\x90\\i&\xcf\x08\xc8sA\x0e\x0c\xd6\x00\x8e\xc1\\\xd3\xcd\xb9\xc7[P{\xafn\xe9\x11\xae\x02qWK\xd7)\xe1jm\xe0\x9e\xecq@\xbak\xa0\x95\xd0\xbe\xfa\xb4j\x0e|b\xe2\xd07\x1e\xb2\x8a\x80\x85\xb8\xfb\xa0\x87\xd80\xe6\x7fSO]\xf1\x0ftM\x8fe\x17l\xa4j\xfed\xf1\x01\x867/p\x12\xe8\x96:\xb2A\xb9\x1b\xed\x87\xea;\xfb!\x82D\x96\x83\xa1\xf0G\xa9\x9e\xa8/fe\xf8\xc2\xa8P\x91P\xa9\xf0\xbf\xf4\xdfO(\xedq\x99\xb8BS\x1b\xa2\xa8t\x10\x1c\x07\x87\xa5r\xb5\t\x86p\xcf\xa7/^c0\x9fq\x80\xf4\tV\xf5\x80I\x88\x8a\xbc]\x85\x12A\x10"0\xfd\xb0\x8e4>\xb7x\xc8\xe6\xd3-\xfb\xbc\x11\xc0\xda\x12Z\\\xc8\xcc\xebn\xaf\xa7?\xb4\xecN\xfaM7\xde\xdf\xde\xce\xac\x1e\xdc\x12\xcc\xb2\xe69\x88\r\x9f\xe6\xf2\xffn\x98\x9e_zxZ\x08W0\x8a\xa0\x1d)T8Q\x8f\xdd\xd8\xbf=\x0b\xaa\xaa\x13\x93\x18\xe6m\xf8\xe0\xc2\xc5\x15\x89\x88\n\xf2g\x08q\xad\xb3(\x02\xd61>I\xe3\xf0\xe2\xc2\x81\xbd\x98\x9a\xb4\xfe\x82\xd3\x97\x88\xf1T\x80\x17\xd6!\xa1\x91\xcf\x7f db\x85S\xf5!A@\xc2\xaa\x1dh\xe4=f\x03\xd4\xa9\xc8I\'\x0b\xa6\x7f\xddi\xdb\xdc\xe9\xf19SO\x9a\xf1\xb0d\xfd\x95\xa1\xaa\x0c\'\xeb\xde\xa8DX\xa7\xc7-\x92\xcb\xd9w\xc8\xa0l;q\r\xe3\x18.[a\xf4\xcb\xdcO\xc2\x1e\x85C{)J\nDg\xaa\x86=4\xe2za\x98\x1d\x0b&7CD*\x9b\xe1\xc7w\x80^\x91\xe6\x7fn\xddm\x84\xc2\x15\x1bY\xbc\x9c1\xb2b\x97\xc40l\t\x12\x1e\';;\x1a\xd3\x1c\x99\xb7\x0b\xa9\xb0\xc1\xe6\x88b\xc4\xdcu%\x1a5\x14\x01\x04\xa21 Ia=ns:2\xd4\xd9W\xf6\xb1\xbfZ\x0fd\xbeE\t)]J\xd5\x8bXz\xf0\x04\xb8\xe3{\xa8k\xeeo\x11$O\xa1\'y\x8f%k\xd6\xee\xad5\x0c\xe6\xef+\xf7\xe2\x92\x1d\xe7\xc0\xe5\xef}\'e\xd0\xe2\xd5\x02\x80\\\xee# C\x17\xc4\xef=\x1a\xc6G\xa3\xa7|\x1e\xb9\xaa@S=\x17\x0f\xe6\xe5S}\x9bW\xe8\xee\xd4\xe0\xe1\x07\xa7\xf7w\xbc\x919\xb7E\xf2u\xabZ`\x06Z+6\x19\xeai\xde\xb0n\xdf9\x9c6\xd1\xbc\xb8\xbf]\xf7=\xe5\x994t\xd4\xeeh$\xafe\x85#\xd8\xcf\x81\xb6\x08G\xcb\x85l%(\xfd\xde=*\xa4v\x19}\xe4hQ\x16\x9d\xccj\xb6Mm\x9b\x95_\x0bO\x84\xfbI\xe0J\x1ey\x8d\'\x8e\xfe\xddG\xa3z=\x97"\xb6\xb7IQ[c\x1cj\xd5b$\xb4\xe1a\xb6\x8e\xf8\xe2\x84\xd4\xc1,A\xb7\xbd\xd4\xdcP\xc6x\xac\xc3\xaf\x07\xdc\xd7\xa5\x99qq\xc3\xb9\x12p\x1a\xc1\xb3\xc5}\x16v\\\xc0\x1eH=\'\x9d\x81\x14\xe53N\x1c\x1b\x8b\x0c\x9b\xdf\x16i\x14\x15\x15\x99\xc3$\xc3\xfd\xe8\xa2\x17X\xb9p\xd9\x17;X\xd2p;\x7f)\x91jd=\x16\xbb\xd2\x0fl/\xb4b\x8c\xcb<\xd9\xfd9\xc5\xcf?\x94\xe6\xb1\x9e\xd68\xb4^2\x03t\xa4\xf63yZr\x1d_deps\xa4O\x80\xfb\x11!\x06\xca\x0e\x8f\xaf\xb5k\xf0\xcd"\x0f\xbbj\x9c\xdb\x8b\x0c3\xa8\xc1\xd6M\xf5\xce\x83J\xb3\x92\x83\x11\xa1`B\xddb\xbb\xdc\xfc\xa4\x0f\xa4#]@k\xc0\x15\xa9\xa1N\x02\xbb\xa7\xeb\'rM\x0fa\xc6\xf1ea\x06\xc7\x8f\x96\x1a\xd3\xb3\x8b\x05\xb4\x98\x9a\x08U+F\xc1aMa\xaa\xc5\x1d\x83\x00\x02\xfb\xb8\xbe\xa6\x9c;\xe2\x8ah\x90X;\x90\xb8H\xc7\xe3\xa7\x80\xc2\xf1\x8a\x1d\r\xb5ro\x9f\x02\xc2s[\xdf\xc0\xb0\x14\x96\xdc\xcf\xbd\x03-s\x10@\x0c\xb5\x83\xac#w\x06\n\xb5\xba\xc6o\xbd\xa4P\x08X\x9e,\xff\x0b\x83\xa9\xf7\x18W\xa2w1\x8d\xcbEa\x97\xcd\xf1HA\xa6\x03\xd2\xb2\'\xebt\x7f>\xc3*ln\xbd`\xbab\xab\x12\xf7\xf9ZX\x06"\x85\xf7{\xe7E=l\xc2P\xfd\x0b\x10\xdb\xffVL\x8frh\xa4\xce)x\x156\r\x90\xd0#=\x7f\x8d7a\n\x8e\xc44\xd8TMx\x83\xd7gg\xaei\xe0\xe4|g\x96\xb7\tX\xc7\xed$"L\xd4\x98gdO}\xf1\x91\xdaFX\xe7\x9f,H\xcdE\xbbg\x93\xd6\xae\xd7\t\xb2\xd2\xb7\x9b\xef\x80\x92}\xf7\x18P\xb2\x91\xcbyb,\xda\xba\x89\x87\xbaO!.\xb0\xe0G\xd1\xc23\xba\x94\xbfq\x8fwoI\xca\xd8<\x1dBz\xd3=\x8f\xc8|\x80\xc4\xdc`\xe2\x88\x1a\x8f-S\xfc]@-\xde\x92:\x9b\xfa\xa5\xeb\x0cfq\x1dYk\xd7\xd2\xc8\xd3\x8e2\xcehP\xf1\xa1\x7fQ\x9e\xfe\xc2\x84r\xa0p\xc3ns\x10\xfe\xed\xdeBk_u\x1fI\x1aV>\x0c\x8a\xff96\xb2\xdeT\xf3\x12/\xd5\x03\xd7\x15\xff\xa4\xaf\xdd\x95\x14x\xd5\xb0\xffb\xc04`J\xddu\xdd\x15\xae\x01R8\xcd\xec\x7f!\xb2\x03\xfe\xb6a{\xed\x14\x88\x06Q\xe3\xff\x7fz\xda\xf3\xbf\x87*\x1a\x8d_l|m<\xf4\xfd\x0b\x86\xed\x8f\x812\x97\xeaX\t6\\]\x9a\xf3j\xdb\x1e\xea\x94\xf7\xd1\t\xc8M\xc1\xe4*\xba\xf8\xa4Go\x8b\xcbQ\xac\x05F\x8b\x9b\x13\xf8e\xa4x8J\xba\x9dJ\xb7\xcfGh\xe8\xc7k\xd4\r\xf6\xb8\xc8\x82\xad\xc8v\xfc/\xd0!\x04\x1a\\\x91\xd38\x96\x97k \x7f\xa5\xb1\xf3M_F\xae\x1d\r\xf8q\xa2\xe1\x01\x95;\xb1\x03\xe6G\xa6\xd7\xf9\xae\xceT8T\xb4x\xafJ\xa7\xa5\x7fy@USc\x81\xa93\x97\xb4\x1d\xfd\xf4f\xd4b9\xd4yh\xc3\xe8\xe9\xb9\xc9\xa9\xe5\xd4\x8cTX\xdeS?\x93^\x90\xc5\x86X\xdf(Z^\r\x9c\x1a.p\x86\x8eN\xf1\xb7l\xcd((Xu\xf1<\xdd\xc7_\xe7\xfd\xe7\xff\x9c\xa2\xd3\x0b:\xed\xd0\x18\x905\x92\xacXf\xa7c\xb6\xcfl_\xb8u\xa9\xbf\xcc\xea\x03J\x9f\x06\x11\xf6\x89M\xb6\x8d\x17qQ\xde\xa3\xbb\x13\x1b\x96w\xa8\x84N>\xd6V\xf5y\xd8\x170O\xf6Z\xf4\xe60\xab\x15]\xe8\x84\xe82a\x96\x9a\x91\xc0\x99\xc9\xebY-\x0e_\x7fCA\x9cu\x9b\xb1\x92Z6\xf90\xa2\x7f\x92\xfb??\xa2\xf8\x1fX\x08@\x95\xa0e\xcd!\xa4\xc4Ab\xc8J=o\x04\x90\xc9-(\x18\xe2\xda\x07\xc4\x8d\xffAg\xc5\x01j\x83\xf9vw\x13\xb9\xe3k\x99|\xeaA\ru\x94w\x12\xcf\xffX\x8e&,\x9f\x0f\xb0\x07 \x92i\xc9\xa3\x14\x81|\x15]\x84\rOZQ:\xc5\xa2\xfa\xce \x16\x884\xe2\xec\xe8\xe3\xf5\x13\xb5\x8f\x86\xb6\xed:\x98\x9e\xc7u\x1e\x9d{s7|G\x7f-\x90\xa0\x06\xc4V=Ez)k\xc5\n\xfac\x95\xb2r\x8e\x8bj\x0fl8j\x9d\xe3\xe3\xd4\xb2:\xab\x99\n}=\xc6\xfa\xbe\xc3\x8a\xb3\xf4\xe9\x05\x82\xd7>S\xc0\xf72*C\xf3\x910\xbc2\xc8\xbac-\xac\xe8\x0b\x18\x15S\x13n\xbb+\x93\xc0\x98\xef\x8e\xcbDH\xb0O\x12\xda\xebt\xde3sg\xce+\x8b\x1d\x8a\xcb9\x99\x02\xc1\xb9c4\xd4\xf7s\x88\xba\xc8\x1b\xf8\xdeT\xe9\xf1\xf7\xe9L\xe0D\xaa\xe7\x88\xe8a\x94\xe5\x83I>\xa8\xe3\x0eFe/\x9c|\xd2s\xaf\xad\x0b\xc3\x89\x13\x1bu\xcd\xf6H-\xf9*\xc1\xf1\x92\xd8\xe5o\xf0\xd3F\x8f\xdbV&\xdcc\x03\xa5\x02\xa79\xf8\x1e\xbb\xe8\x0c\xfb\x91\xfa\xe6\x0b\x1c\x8aZ\xa7\x8d\x19\x8fD{-\n\x9dY\xd4\x88\xfa\xb6\x08:\xa6\xa7\xea^\x07@_\x8f\xe7\x13V@\x96\xf7\x8f\xfc\xfd\x15\xe3jQ\xc4\xaffG\xca\x0b\x96A\\\x8e\xe2\x9cG\xa1@\x8dJa\xf8.\x8d\x1d\xa4\xe0\'\x7fg=\x94amj\xe2\x17\x14\xdf+\xa6\x99\xd7~u\xab\xae\r\x10H\x11,\x04J}k7\xa8C\xc1\xce\xd5\x0fL2\x94\xf5\xd8\xfe\x89\xf0I4\x8a5\xc6\x96\xee\xcc\xca\xa4G\xd5 \xda\xd3\xc3E/ZGcCU\x7f%w\x18R\xc46/\xdbS\xb15\xef\x0c"\xec{l\x1c\xda?5\xc23\xf2\xe7h9\x0c\x13\xb4@oc\xa4NZ\x1b\xdfE\x89e\xec\'@#\xb9\xb5\x083.\xee\xf88hVM\n\x10\xc9(D\x86\x99\x00\xb3\xb6\x8d^P\xef\xba\x13\x95\xe4.\xd0F\xab\x15\xbc\xef\xc8\xa7]\x91\xe35\xb8\xb2\x16^\xf2\xac\xcdI\rQ k\xf1\xfd\xc1\xef\x9b\xb4T-h\xf9,R\x08\xf9\xf1\xe2T\x00\xb7v\xda+F\xb6\t,\xe7\x11B\x98\x83#VT\x95\x1f\xde\x98\xc7^\x18\xcf\xbf\xbc\xf9J`\xc61\x8c\xf8)ZE\x05X\x1axJ,\x9a\xce\x8c\x99\x17n\xcb\xeaSO\xfd8\xdc\x05\x1a\xa5\x00\xbb\r\x7f\xae\x02\xcd\xd4I\x0b\x1b\x89\xadNM\x17\xfd\xa6\xda\xf9:\nFAu\xb7\xa7`3\x9b;\xf6l\\\xbe\x02\xbf\xe0\xdc\x87\xbeQ\xa8\xe6\x9d\xa1\xb10h\xbb\x7f\xe9\x9d\xf2\x95\x83\x84\xdb\xd84\xd2\xf0\x88\x04\x98\xed`\xab\xa0\'\xe4x7\xe45\xdf\xe59\x0c&k\xa7t5HK\x04\xd1K\xbbj\n\x8dt\xe0Aw\x92Vx\x8a1\xbf\xde\x03\xae\xcc\xe6\xd3\xa5\x16\x7f\x87\xc5\x00\x8e\x869\x86\x1aR\xed\x1d)I\xe3\xbdi\t\x99n\xe5n\x06"1\x04\xda@\x1bG\x8a\x83\x83\x04Lj30c\xea\xad\x11\xd8(\xa1f\xc6\x9a\x8c\x96\xb4\x91z1e\xffMhu:\x8b\x908\xa6\xb1\xc8\xe3\x87\xe2W\xa0\xd0\x02z:\xb1_YA\x10\xd6\xf1\xb5Z\xb42e\xd2\xa5:_\xbbn\x7f\x1eX\xfb<\xd1C\xa8\x9f\xc7W\xfc\x91M\x9c\x08\x1d\xea\xb8\xbd\xcc\x90\x0e\x97}\x06\xcd\xff\xbb\xd0\xb6v\x91{\x15[\xe5\x9dp\xff"\xdd\xcc\xfe\xcd\x88\xd6\xbb\xf9s\xaf\xbb\'\xc0y\xa1\x96`\xac\x08<\xce\xefi\xe9i\xf5^\x0btrp\xa0\xfeR\xfd\x84\x8f\xa2\xe3\'\xee\xb7r\xab\xf0\xc8\xee\x9b\xd8.\x8cN\x1c\xd1X4\x03\xf6\x98R`\xf4\xa5\xefZ\xb9P*\xda\x85(\xa3\xd4\xbd\xeb\x146\x0e<2\x82b?\rv\xb2\xf6\xc2D\x84a\xa9Z\t\x08\x01+@\xf5\xf5\xa1!\x0b\x9dT\xd4\xb1@\x88\xd5\xd2\xee\x96a\xb1(/e\xffs\x94j}\xb3\x8a\xd4\xf66\xc9\xc0\xb7~Q\x9dr2Qm@B[K\xb4\xc4\xaf\xd7XC\xb5lS[\xfc\xc2\xc2s\xbc&\x9d\x03\xe1\x95\xfb\x1c(_\x13{1\x7f\x0f[F5\xe2I^L.\xf1\xe4^\x98\xfc\x81],b\\"\xc1\xca\n\xcckH\x95a\xf7Y\xcf\x02\x06\x02\x19Z\xc9\x8e\xeb\xdb2\xa8L\xbcN\xf8\xb4\xd4\x18x\xeb&\x81\x15\xa5B<\xcf\x1b`TO\xd1O\x93\x17\xe5,:\xcc]\xa4u\xa6\x0fX\'\x9e\x1e\xb0j\x96\xd8#\xa5\xfcU\x93\x04\x1b`\xebx\xd3c9\xde\xc0&)\\]\x80K\x11\xabUj\xaf\xbb\xb6Y\xb3\x19f\x02{R\x07\xbb4\xd7\x06JtM\xae\xea\x15\x80\x06\xb6\x87\x8f-\xa0\xb2g\xa7\x00b\x1b}\x84b\x86\x1fK\x86X\xder\x08K\xcaC\xc3\x08\xaf\xae\xf7Z\xee\xe8^a\xd1x#P1\x96\xc3\x02Q\x89\r\x91\xb5\xf9\'U@\xd9g\xb9C8\xf5\xb2\x97ehM\xfe\xac\x81\x89\xf9\xcc\xcd\x8b\x85\x9a5\xf7\xd3\xc1\xdc\x0c\xa5p\x9f\t{\xea\xa0\xcf\xfd\xd4\xef9\xaaB\xdbl\xed\x94+\xcb^\xb2f\x87\x90Y\xa5g\xdam?\x92%#\xd0_a\xd5\x07\xb1\x19^\xb0\x0b$\x91_\xb8\x0b\x08\xfc\xfed\x89\xfeU@B\x82\x08C>\xaa\x1d\xa9\x8cc\xe3\xf6D\xd4Fv\x85\xe3\xf1\xf49Jgg\x9ckt\x1c\xa6\xa0%\xe8\x8c\xa8zj\xf7\xeb\x84\xa3\xf1\x10\xc8S$I\x03\x05\x88\x8cg\x1e\x8f\x8b\xc5\x11\x08\x8a/\xaf\x01bQ\x9c+\xddNe\x14\x89\xc4\xf9^q\xf3K#\x9f}\xe4s\xbaX\xd8\xbf#\xd8\xe8\xe2\x90\x07\x18\xe2\xeaM\xbe\xd5\xf9ee\xda7\xb2\xfe\xc9/v\xaa\xe2\xcb\xfai\x85 2\xe6\xffv\xab\x90\x074H\xc5\xf7\x08\xc4"\x8e\xcdB\x85\xc2\xef\x8f\'W\x01H\x0b-#R\xf4\xc2o\xec\xd4b\x01\xa7]ru\xa9=\x84\x12\xc68\x05\t\x93\xfb!\xfc1\x06-\x7f\xb3\x08\x03\x9e%D-\xc8\xdf8]\xf0v\xd1S\xdd\xa1z\xe9M\xd6\xe8\x9ba\xfd\xb3\xfd?/\x96!\xb5\xb4F\xa9s\x1c\x86\nX~\xe7;\xe3f|\x83\xdb%\x0b\xa9\x11\xdaB\xe2/z\xe9\x80\x83S\x96u\xfb\x13\x04\xfd\x16`F\xd5\x86\xb3\xa9`\x19U\xa3\xbf^\xb6\x17Uo\xf5\xe7x\xff\xc2{j\x13h\xbe$\xc6\x10\x0f\xa0Y\xc7i\xe7B\xff\x00\xf7\xc2\xe9\x1b\x0e\x88A8\x0b\xbacX\xb2u\x88KS\xb1\xf4\x1bH\x1f?\'x("\x1d\t\x9f:\xf8\xe4\xf6\xe7&9\xd4\xfe\xb8\xe74L]\xfe\t<\xe7\xab\x986\x9e*9s\xe5\xcf\x0e\x15?QD\x01`\x05a\x8c\xd5\xa2\xe6\'X\xe2\x00\xef\xfc\xe1\x9f\xe0\x98\x92,;$\xcc\xdfl\x8a\xc3\xa0\x1eHs\xab\x15D^\xee7\xf2\x1b\x94\x1a\xea\xc4l\x17=\xcf\x04\xd3\x88\x93b\xae\xe4\xec\x16\x16\xab\\\x7f(\xf3\xd74\xefF\n|g\xb6\xca\xab\xb0?3\xa2\xfc\xd1\x9aN+\x17}\x14U\xef\x90\xfc\x94M\xac\xd2\xba6]\x8d\x80s\x7f(.x\xcf)[\xbcU\xe8\xbf=~+\x14\x89\xa3%w\xf5Hr\xb1\x95\x0b\xe4j\xe3\xa5\xeb\xe1v\xdfz\xd3G\x8c\x11\x19\xe7w\tn\xce\x8c&m,W\x92\xb8z\xf38\xf0J\xbe\xfa\xe4\xa4\x01R\xe1\xb9\xa7\x01zs\xb2\xf9\xdf\xc3\xc4\\b<\x80\xae\xdd\x88XC_\x89M\xb5LSkl\xc1?\xf1\xc5Jw\x99\x06\xc0f\x04E)V\xf2q\x96\xc1\x9a\x7f\xf0=\x1d\x89\xa0}\x9a%\x7f\x9a\x9d\xdeQ\xa3,\xb1=6\x80\x92A\x99\x19\x9f\xe5\x9c\xca\x0ev\xa1\\\xb9%\xd1\xa5\xa2M\xe7r3Ql:We7\xefjN!\x08"\xec\x9eR_.\x98\x8f\xf3\xdfI\xc0\xab\x86\x90HR{\xea\xa4\xa0Y\x1f+LA\xf1\tmE\xae\x10d\xe0_\x810\x85w\x89\x08<\xbd{\xba\xaeX]r\xf2\xe0\x1e\x15\xc8\x95Ek\x05\x8bT\xab\xe6O:\x8b\x91\xde\xff=\xd7_P`\x8eL\x8a\x11\xdc\x02\xdaBIog\x01\xddI\xd5\x10t\xee,!\x07\x11\xc2\xd5`\x8a\xb7=lb\x9a\xda^\xdd\x82\xc9\xa1egu<\x91\x8b\xf5\xf1\xf6\xd3\xf5\x02\xf9Z\xc6:-$\x9b\xb2\x10\x02\xe5\x02\xd7\xde\x11.@\xc3\xb7[f\x9f\x8dQ{\x10z\xe9\x8d\xd6\x9c\x91\xc8\x01\xa4-\xd3E\x9fd\xef\xa2G\x0e\xa6\xd4B\x88\x8aT\x08\x16\x7fK\x02\x13E\xa0\x94\x9cl\xd5\xdc\xa3=B\xf3\xf6\xf0i\x15\xf2I\xd0F\x9b\xc2q\x13\xae\xe1R\x0cO\x9f\xd1\\E\n\xa5\xc0\x19O%\xe0\xff\xbb\xa6\xc7:T\xc7\xa8\xbd\xb9\\%n\x801\x14\x95\x19P\'~;AO\xd8\x8a\xfe\xfd\xa8_\xaeE\x08\x7f(d\x97"H;q0\xcc\x8c\xb3\x83R\xe6 \xec\x0e\xb2m\xfd\xb1"\xaa\xb5a\xb6\xd2\xe5Vn\xf0oj\x95\x8bv\xdd\xfbc\xbcy\xea&\xe2\xbf\xf2YO\xd0dm\x04w\xe8\xd4\xb8\x89\x1d\x97%\xd2k\xbf\x11;z\xe7~,\xc6f\x8c6I\xd4\xda\xff\xd4:\xfb\xd1>\x0f\xae\xd0z\xc7\xb1\xf1\xae\x91\xcb\x8a:\xf2H\x9a\x18\x16n\xb9s\xc5Ds\x96\xd9C\x07R\xb2M7C<\x8d\x9f\xb8\xcf^\xd8\x0c@\x05z\xc0-\xde\xf4\x93UN\xc9\xa6\x95^@A\xe7o\x13\xee\xcb\x15\xcc\xc8\xe4%*\xa1\xcf\x9c\x1c\x80\xb8\x03\xf2f\xe4\xe8\x9c\xcd$\xb2+\xbe\xdd\x86\xa82\\yQ\xa4\x13D2\x95\xc4\xe5\xb8.\x8c\xfc\x08\xd7l~\x96\xe7\xc7\x94\x00\x94\x13\xe1\r\x01\xf1\xb9]u\\?\xcc\xbar\x07^ \x903\xdb\xcf~Dd\x92N&\x81\xb2\xf0\xd0tf\xe0\x18\xaf\x1eJ-g\xc5\x06\xac[m,l\xa0\x19\x10\x0c\xf0\x94\xd0\x85uo\x89I\xab\x82\x8cvX/\xb8\xeaI\xdd\xfe":\xa1\x812+>\xca\xd3/\x19R\x89\xdbIF\xf7\x1c\xe8\x06\x1d\x13\xe6Pde\x1e\xc3\x8e$;\x809\xda\xa8h\xad\xd2\xe4\x13\xdcI.\xb0b\xad\xa0U|\x8dTzP\xa7\xf3UA\xd2\r\xbc4%\xb4\x9d\x06\xd3\x83N\xed\xe0\x03\xab\xb0S\xbe\xaa\x04\x9d\x82\x9cy\xcc.\x9e\xc6\\\x01C\xaf\x150\xf0\x83.|:D)R\xf7>\x97\xbd\x04j\xa5\x82v8\xad\xd5)?\xc9\xdb\x9f\xac\x8a\xe3M\x1b\x81z\xd7\xe3\x88\x04A0\xdb\xb7\xa5u\xc5\x92\x91\x07\x91\xfd\xde\x87;E\x0f\xa5\xb2Q\x9a]EPy\x7f\xe4+\xf5\x8d,\x1c\x9f}\x01Nq\xb3c\xf7\x8f\x82\xc7!\xc8\x81\xa6\x19\xaa<\xfd\xa5\xb2)\xdf\xe5\x83\x81A\xe0s\x97\x13\xc0b7\xfa\xff)\x98P\xaa\xd0\xf8\xfe&\xc0Y\x8eH\xca\x9a\xb9\xaf\xac\xc4\x91\x0b;x\xf1\x0fx\xde\xac\x8dT1\x80\xfb\xa4/\xa3\x93\x08\xc8P\xf0\xca\x9e\xc2w\xe7O\xe2\xd4\xa2b\xd2j\xe4\x8c#\xb2\x1a{\xb3\xb7\xef\xa5~\x106\x14\xda\x91x\xca\xdb!\x1e\xf2\nd\xc6\xb2\xd4\xe8\x7f}\x01\xb8)\x0f-\xbe\xa1\x10;\xce\xe0\x06\xbc~\x1c\xd4U\xb7\x13\xff\xb6\x90\xd8\x05F\xe0\xf8\n\t\xbd\xaf\xe6\x85\xc2\xa1\xd3\xc9eSh`\xa5\x824L\xff\xdb\x9d\xaf0\\\rG\xf9,R_Zr\xdc\xf2c\x8a\xb0\x84\x1c\x80\x8cZm\xd8\x0b*P\xa7\x0f\xcf-\xe4\x87\xd1*\n\xfa\x90\x8e<=\x11\xa1\xc0^\xd8\xef\x12\xd7\xf8\xba\xe2\x8e\xeba\xf8z`\xfc\xe6>^\xd0<\x85\xc8\x8d\x0e\x8a\xcb\xd8Yo\x9fX?\x8ae\x06\x8c\x82gD"\xc1\x88\x06\xfd\xbbZK\x0e\x19J\xf1\x87\n\x17\t\x9f\xeaa;\x0c\xa6\xf62#n0\xff\t\'\x90C\xdc\x7fn\xa7\x1f#\x80\xb1\x9e+\xef3\x14\x93\x99\x92\x05N\x8f\x13\x1f\xb9\xeeJ\xc0\xff\xc5\x87\xc2\x11\xff\xc7\xb3T\x97\xa5w\xd9\xb7|m\xe6\xdb\xf9\xa7\xa0\xa9`j9\x12\xdf\xa12\xea_?\xff\t\xbeSp\xa4FZ\xf1\x9e\xed\x08*F\xb5q\xe9B\xecr\xf2\xfdT\x91.\xfb+\xe7\x87\xc3\xe4\xfc\x9fw\xd2*\x80Y\xc5\xa9,~\xed06j\xa1\x18\x98\x94\x92\xe9\xa2\x92_9\xaa\xb3\xe3z\xbf\xc5\x8d\x8c\xc4Ek\n8\xf0\xd0\xba\xed|(\xe8a\x03\xdez\xdd\xcf\xbduC\x9b\xcf\xe9\x98\x1b\xd9\xd6Z6\x01\x89\x14\xee\xfaDZe\xadX\xady6a\xf8_\x1a\x19\xd4p\x02\xf6<\xb1\x90R0}\xb8\xbf\x13\x12)\xeb\xc9\'\xd0\x9f/\x1b\xa4O7\xb4\x88\x83\xb8\xbd\xf1\xbaU\xc7!s\xaf-\xa7\xf0\x9c+\x95\xc3*\x83\xdf\xf9U\xe4\xe1q\x00|P\xcf\x85|\x0b\xe7^\x12`v\xbe\xa8\xb5}*\x11\x96\xe9\xdd\xbe\x9e\x93\x92a*4\xc5\xb56;\xfb%\x9e\xe2\xdcS%B\xa5\xc7\xf4\xb5v\xc9t\xfa|\x18\xe1p\xc8\x15\xf9b\xfb\xdd\xfeS\xb8\xbb<\x8f\x1d\xe6\xd80\xd5\xc0\x88c\x0b\xb4}\xe1\r\x0c:`\x0b\x1ea\xef\x83z(\xb7f\xab\xde\xd3\xc3\x0f1\x113\'\x13\x9b\n\xb2f\xedMk\xf6I\x17LQ\xc2w`\x0f\n6\xc9\xc7Sj$\x7f\x8e\xfc\x14 D\rFs\xde4XE/\xcd\x97W\xc2\xbe\xfeS\x8d\x00x\x1f+TK\xbf]\xeb\xd0\t\xf4\xbb\xf4\xc5\x9e\x1c\xfe\xe5\xc9\xdf\xde\x04\xa0\x1c\x14\x0b\xa5\xb6\xcc!\x17\xae\xae@\xf3\xf4R9\xeey\x06\xbd\xb7>\xc7.G\x89\xfd\x84\xd1\xa0\xb7\xe6O\x80\xe4`\x01i\x10\x07\xa0\xe9\x13,\x92\x8b\xf9V\xd5\x14\xd9\xcc\x10x\xd3FC\x1dsXhm5_\x92c\x93\xe0\x81\x96\x96{O\x0c\xfe\xea\xf6\xe3\x18\xaa\x07Dj\x9ac\xa0\x03\xa1\xc7\x0e\xb4\xca\x9d\xfe\xc8\xee\x1c\xb2\xab7x\xe7pu\xe2Q\x12\xca\x14\xd3\xbc\xbce4P\xaa5\xbc\xe7\xad\xf8\xfa\xee\xcf\xad\xa5s\xc1[y5b\x87\x05\xd7.\xe6\xe2\xf6jk\xe0\x01\x8e(jW\xac\xf9\xa6\x8fX\'\x90\x1d\xb7\xe1\xdf8\xc9\x99y\x92\x81\x88\xb8\x8f%L\xd1\n\r)\xb2]\xceq\xe3\x03\xfd"\xc9_\xdf\xa1\x82\xb7\x83\xb8\xa0\xd8\x88\xd9\x17<\x16Y9\xd8A\xf0\x9b\x7f\xa4\xbc{\xf7\x1c\x9d$P\x82\x87\xc0\x86\xc8\x02\x96\x8c9\xb55wYI^\xbf\x02\xdc&xMR\xb6D\xb6\x1d}\xd7\xf1\xaaIuk\x19hR\xb9O\x866\xff\xa1\xb43\xbe\xf3\x05;\x86X\xc0\x10\xc0\x03\xd3R|\xb2\x18J\x1e\xe6\x1b|k3\x0e>\xa0vR\xda\x84\xff\xcb\xd4p\x8e\n\xe8\xd3\xed\xfd\xef\x1d\xeeK\x0b7?X6b\x94K\x0b\x01U\x8bf\xabg\t\xfe\xb6\xb6!\xaa\x93lG{\xf3\xe1w\xc9\xc0\xc7\xacSV;h\x9b\xac\x05\xf4\xcb\x12\xfe;ie\x90\xd3hN+\xe2\x0b\xc4\xa9\xac\xf2wK\xad\\\xdd\xc3\x80o\xb5U\xc8\x84\xafo+\x00;\xcb\xc4\xf8W\xba\x9f\xb0\x99\xec,D\xed\xb2\xf5\xf7D\x95|\'@\xce\xb6\xd2\xea\x9dx6E4\xac\x1c*\x00\xdd\xa4\x980\x99X\x82N\\(/\xd8\xee)B\x14\xed*\xec\xe0\xcfs\xf7\'Kx\xc2\xd6\x19\xbcV\xb4\xd9\xc3F[\xb5_$\x0e_\x95n;\xac~\x82=\'#4M\xd5\x92\x88\x98r\xb4\xeb\x05\xd8\x95r\xfc<\xd5\x8aj\'!\xc1=\xb2\xf3\x85\x92_M\xee;S^\x9a\x83\t\xed8A\x12\x07\x98\x9c\xfb\xb2p\x00}\xb9\xa8\xb8\xd0\xa6\xb8r\xbca\xacX\xf2\xd3\x9c2e]\x12\xa3\x1f\x05\xc85\x1937\xc6hg\xed\xe8\xb7\xe5{\xc3\xaf\xe6\x13(.\xc3\xb8\xca\x11JP\xca{L\x17\x9e\x10\xc6F?\xf1O\xa2.\xa7\xe8#\x98\xbcx\x1c\xf7V\xc8A\x89\xe7W\xf0\x0br\xfa}\xae\xc8~\xdc\x9b\x7f\xbd\xf92{Z\xe5\x0c\xff\xb6K\xca\xf8L\x17(\xa9\xd8$;+\xfd\xbc+\xd6s8\r\xd6\xfe\x17\xb8o>\xfe\xd2\xbe\xa7\xb0\xb3`E\xa37\xf8A\x17\xea\x16G\x07\xe6\x88M\\\x8bf\r\xd3H\x84\x90x\x07wGh\xd9\x8b\xbc\xf0\xf1\x86\xb4W\xf7\xedD\x07\x0f#T6\xad\r?\xb2\xe5e\x80\xdf\xf7n\x1f\xfd\x11\x80/N\x91\x1f_\x1fL\xcc\xb0\x9d\xf3,\xd5ZHb\x980\xb7\xab\xa3\xcf_\x94\x06\xf4J\xf0\xe6\x88h\xfb\xae{\xf2\xf1\xbd\xa7_\x96\xacC\xe9l&\xb9\x90\xf99[\x10A\x14\xb3\xa2`x\x949\xa4\x08\xfc\'0@\xbcq*\xd9\x01\xebK\xa0\x1b\xf9\x08\xb1c\x02\xdf\x99\x0fEf\xe0\xd8\xad\xe1\xb0\x8d\x1b\xc2.\xb0\xebff\xf2\x8b\xcc\xb5o\xd5&\xb3&\x82\xa6"^\xa0\xf9\xe8XM\x06\x858\x03_`V(\xabInl\xf5v\xb3\xc6\xf7\xf2\x90\x96\x0c\xd9\x17\xd1\xc0Gms9\x14\x0c\x9bx \xd9|\xc2\xed\xf1\x16\x81W\xb2\xee\xc9\xa5%\x01\xab\xaaY\xe7\x08\xfc\xdf\x11r\xfc\xa0\xb9\xb5I\xe2\xe5)U\x8b\x83WL\xe7G@\xea\xbd\xb7\x11\xfd\xb2\x96Pa6\'\xf8bV1\xce]\\\x19\x9c\xc6\x13Q\xc8\xaa\'EI\x0e\xbdpj\x8d`\x05\xb5:\x0c\x84@\x15\xe6\xc5S\xe8\xfa\xb1W\x10i\xec/\xf6k\x91\xd0\xc7\x9cK\x03\x0b~ZE+1\xc9f\'_\xf4\x00\xa2\xd2\xc5z^\x87\x01\xeddZ\x9c\xe8\x9a\'\xe9^\x1fW7\xd4\x01P\xd9\xefe\x15\xc7,\xa2\x16\x85\x89\x07%\xc9\xc3r\xc2h\xc0{\x14+\x9dk\xd0\xab\x144\xb7\xbfg\xb8u}\xa3\x0f\xe3l\xeb5\xeb\xf8\x1d\x9d\xac})\x86A\xb0\xd2iy6\xeau\xe3!\x0e#\xa17\xb3\xfaG\xc4\x189\xd6\x87\xe7\xb3\x94\xabFC\xd2\xf3\x1cJ\xa3\x7f\xbd<\x16D\x84\xda:\xa7\x8dp\xcb6\x99\xadY\xec\xad\xd0\xf4\xd4\x08@e\xfd\xa0O\x11=!"\xbf\xccX\x98\x84\x16\xdd?\x19\x1e\xba;\x04\xb2\x08\xfcV\x13\xb3\xe5\xef\xe5\x96#G1\xcc{`MSK\x9b?\x1b\x98\x96\xa2\xb07\x91\xd9\xce)\xc7\xd0\x90\xf3\xb0\x8a(Vw\xa3\xc7mg\xe8\xa3>R\x84|\xea|1\x1dh\x88\x88\xd8\xdcb\xd6\x8f\x9d\xa5\xe3P@ao\xc4\xe9\xa4`\xd9\x14p/\xba\xc1\xc7\xc4\x83\xde\\9\xf9\x07\xe3O\n\x04O\xc8\x1e\xca\x94b\x98\xe1\x0eM\xf6\xe7\x96\xe1%\xb4\x13R\x07Xh\xbe\x02\xed\xc1\xd1\x9bFD\xda\x99\xc0\x14eK\xaez\xac\xb2PJ\xefbJ\x88\xb7\xcc\x1es\x94\xef@*b\xa5\xde_\xf0\xc6\xb8m\nC\xc6\x93\xb52\xc7\xa8\x1cZ\xb8\xa2%\xear\xcd\x84\x82\x1f{\x16\x14\x8f\x1d\xcd\xddf\x8d*\xa3\xf7&:j\xceS,%\xdd\xa2o\xa7\x1c\x17{\x93:\xf7\xf44\xda\x95U+H:\xb5"\x87#s5\xc0s\xf4\n\x14\x85V(#^\x00\xb5N\x1c\xba\x19P\xae8\xf4\xd0-&x\xe4\xea\xc8\xe5\xdc\xa3\x1e\x12\xbc\x06\x02z\x0b\xb82\xf8hG\xe6\x15\xe1\x0f\x16\x0eM\x02\x01\xc3\x15d\x87\x13\x80\xf0(\xe3 \xca\xb2\xc7\xfa\\\xeb\x900Y\xa1\xec\x8aH\x03\xbfM\xa4\x19q\x05\xb8\x8b\xb7\x1d\xa2\xf0\xaf7\xb7\x0f\xf5\x98\x87\xb9\r\x99\xd1\']\x8ex\xfd\xc1C\xff\xa3?\xef\x04E\x08\xad=\xd1\x90\xf0>\x19G\x18i\xcff\x0b\xb9p\xdb_`\xc2\xc0\xa8\x16\xea\xdc\xe6\x05M\xaaw\xc07\rV\x80\x94]\xd8\xbd\x0b6S\x9cu\t\xa1\xb0\xdbC\xf6\xe5\t3\xb5\xea\xcf\xab\xe1\x96T{x0\x044\xe9\x00}T\xc1\x1bqj\xbd\xa1\x94F\xe7s\x19b+\x15\xa2K\xa3\x8a\xeb\\\x9d5\xecr1\x0c\x04\xb9\xb3\xcem\xd9\xdd\xc1\xff\xe1\r7\'\t\xbfT\x1d\x83\x12\r\xbf\xfd\xc0x3\x146\xdd\x86\xcb\xdc$\x9f\x8d\x8c?\x00\xe1`\xa9\xa8\x8a9m\xe7 \xac\xe3\xc6\x03\xc9\x19\xe1\';K\xe7\xe3c\xe6\xa1=\x85\x17\xee\x0b\xaes\x84\xc7eZ\xcc\x01G\x01\x8bu\xc3{\x8bN\xdd\xfe\x9d\x96B\x97\x11\xe3\xd7\xb6+\x1c\xe8\x18\x80\xc1\xd0\xeb\xed\xc0\xc9E_\x93\x7fC\x06_l\xee\x91f\x07\xaf1Z\x8f\xe0\xbfA\\\xda\xddX\xc6\xae\xdc\xaa\xfc(\xfb\xc8{\xd6\xbcQ/\xbc>\xdbJx\xb3lkG\xdd\x08\x99\x0c\xc2\xb3\x9f\x8c?qq\xc8\xb96\x88\x93g\xf5X\xbcm\xef\xf8\x9a\xed\xe5\xce&\xa8Um\xbf\x048\xcayTN\xa10\x19Y\xaf\xc9\xbc\xbbG\x16\x0b\xbc3\x88\xea\x90u!=#\xe2\x92\x17\xbb\x03\x95\xf8\xd4\xabr(\xa7e3\x81\x07\xd72\xe9B\x8ao/\\\xc8\xb3\xf0;\xb7\x10\xb0z\xa0f\xa4!T g&\xa0<\xc7\x06\x8a7\x1fi\xe9\x80r\xc5\xc7\x88\x13\xbf-\x94\xa1\xf4a\xb2\xac\x03\n*\x1fd\x98\x8d\xda\xde)PS\x05\xc2\xd6u\x0b\x89\xe3L\x95\x00\xc0t\x03\x1a\x1f\rY\x97\x03\x1c\xe9sIP\xb3$Z`\xec\xc5g{\r\xb1\xcf\x027S\x08\x96T!\xe5\x89\x11B\xfa\xaaO\x02]VyI\xa2\xce\xf7\n/\xe5`\xf5`o\x02b\xe0F\xf2\xfaNI\xe9\xcb\x92h\xf48\xbd\x1a.\xad\x10\x97\xcbr%}\xd5\xf1\xdb\xb1\xdfXy\xea\xb5Z\x8bh\xe9\xeb\x12d+v\xaf\xba\x89\x07\xc5\x07\xe0\xfb\xa0\xd1\xc7\xae4L\xba\x1d\xe1\xac\xbb|F\xa9Gj\xcbk\xc9J\xb0\x1aD\xdf\x0b\xdd\x8a\x9b\xdf\x9ekZ$S\xca\x0f"\x9e\x9f\xdf\x13\xee\x99\xea%R\xce\xd4~\x97\x10\xb8\nn\x88,\x87\x82\xbd\xf5\xc1\xb1\xd3.Qu\x84\x07\xd8y\r\x9dd]\xef\xa5(.\xc0\xec\xd6\xd7a\xb2\x13\xdc\x11\xdfZ!\xc3,4N6\xd5\x97\xb6:U\xae\x04\x99j\xdf\x08\x94\xe3\x7f;\xa14\x07\xd4\xcd\t\xb8r\xe3nyE:-\x94P\xdb!\x1eU\x94\xa1H\xbf\xb2\xbe2KEJ\x88\x0c\x18\xf72\x15mBA\xcc\x0e\xcc\xab\x06\xa6\x06\xc5\\:\x95\xac\xc3\x9f\xd1r\xef\xfc\xb6u\x9c\xd2&\xf1|T\xef\xdd6\xb7\xd3\xce\xee\xdf\x95J\xe1\xcf\xff\xca|\xa2\xc0\xca\x15d?!&O\x84\x82\xf3\x88e\x05\xce\x86\x93G\x84\xbb\xc7\x07\x036\xeb\xc5\x85\x02\xd8\xfa\xa55y\xcf[\xdd\xc6\x03\xf1\xb7+\n\xe9b%\xaa\xe8R\xbd8\x8a\xb5zV\xe0=\xcar\xa9\x9d\xf4eH\x80\x14\xc1\xa4pG\x9f\xf2\xb7\xe4\x06\x86\x0f\xfd\xfc\tq\xf1\xe6=\xf2\x10\xf5\xd2\x070\xac{\xbf\x82\x04\x03\x9f8\x8b\xaey\xad\xc1\x99=i\xfd(\x7f\x93$Y5\xa6u\xcf\x8eo\x9fm\x85\xd4g\x02\x11\x02\xe2\x8d\xe7G/\xb04N!\xf0\xdfF\xdb\xaa\xa7\x9fWh\xef\xedV\xdc)\xb4\re5\xf3\xd1=d\xeaD\x9a\xafE\x13\xde\xce\x00\xfb\x90\x96|\xd3\xe9\x997\xed\xfa\xc6 \xa4\xd1\xd5oo\x144\xe3\x9d\xbbb\xfa\xb3\x95\xa3\x04\xa5\xf7\n>\x8a\xdf\xac\x04i\x1e}\x1f\xb6:\xd3L^\x9c\x93cE\x1d\x05\xb6n\xd2\x1e<\xa0"\x1c\xa3u\xdfh\x1af\xd3\x82\xeb(@\xee\xb5\xe1\x9b9h\xb5\xd8\x98\x99\xf4h`\xd2\n\xd3\xeeX\xb6\xdf\xeb\xdbR\x10\xf3\xf2\xb2"\xcf\xb1r-\xd3J*\x12\x81\xa2\xf2\xeb\xe0\x82\xd8\xa0\xf4\xb4\xb7\xe9r0\x7f\xba\t\\2\x89E\xfe\x0b\xb2%C\x87q\x8c\x11\xa5\xfe\xd3\xd3\xc4\xe0D#\xf1\x85(\x90o\x83\x10uT\x85"8\x84\xb0\xad\x83w%c\xd3^\xf4]z)>\x89x\xbc\x05\xdd=7\x0fZ\xff~\xffS\x03\xefZ\xe6X7\x14\xa4R\n\r\x95\xbf\x19\xfb6\x80\x04up\xb1vk\x06L\xb7@"\x92\xc7`+,\x04\x84(\x05\xd8\x05i\x9f%\xbe\x88`\xbfG\xd7Ml\n\xbe\xc1h\x1b\x95\xb16\x91\xe4ZH\x95\xb1N\xf9\xdfi\x0e8\x18\xed\x1c\x94[=\xb7\x19\xfc\x83_o\xe4\x1f\xec\xc2\x0f\'\xdeE \xf1\xfaa\xff)J\xda\xc5\x92\x19j\x1c\xd5*\x05\xa3\xc0\xca\xb3.U\xe2\xa2\xffZ2E\x81\x02\xebsZL\xe0\x98\xa4\xa2;)N\xf7LM\x13\xbc\t\xb4\xf5\xa3\xab\x9dqu\xae\\\xb4w\xe1P\x8bT\x83\xa86\xa0\xd7\x91\x0f\xdd\x91\x16\xfc\xb7\xd20\xa6\xa39F5^\x8b\x8b\x93w[j\x02\x8a6m\xe7\xd3\x87\xdf\x88\xb5N\xdc\xef\x10\xe3\x99\xc9=\x0e\xdf\x15\xe7o2V\x1f4\x19\xf5\xb40qu\xfe\x1f\xad\x17\xe01aI\xbc4\xfa\x1f\x02\xbfO\xc7e\xc9\xb2\xaf\x8a\x10C\x85\xfb\xc0\xd6\xbdt\xdfX{9\xd5\x86p\xe1\x83\xcdb7\x13\xa8\xf5\xeb\tE\x9a\x85\xda\x18\xba\xa9\x86\xc5\xc08B\n\xd6\x05\x93\xb9\x0ba\xeaG\xa34\x88a\xf1\xf8\x1d\xeb4\x08\x9fw\xc1\x00\x13\xabD\xfa\xbasl \xc8\t\xe4\xbd#\xf3Vb\x86\xd06I\xbb\x95\x10\xad\xa7\nm\xd6\xe7\xb3\x83\xe3\xad\xf9+{\xb7ocv\x84&\x1dF\xfd\xc930p\xe2\xaf5&\\\xed{tv\x87\x08,\xb1\xe7\x12\xbck\xfe\xfe\xa1+\x9f~\xbc\xd4\xe9\xc4[\xc0\x804\x97S\x8f\xabY\xad0,\xb2\xb0\xa0k\xd2\xcb@\xb4O\x88\xcfJ\xe2\x14\xba\xde\n\xe10\':uw\xc2\xc8\x16U\x18\xf8\xbe\xf0\xc9\xb7\xc8*\xef\x16C\x16k\'\xd4(\x96\x13\xaf\xabd\x03\x12m\xb7F\xc0\x86\x84%(L\xd36q\xfe\x96\x81>\xd1,\xd9\x05\xc2\xd6\x97il\xde\x04\x0b\x02\xfc\xcb(e\x95F\xee\xcbQ\xaa\xc5M\xd4\\73\x0b\xfd\xd87\x13\xd8E\x0bB\x0bK\xc9d\xe3^\x06\xbd\x88\xca:\x91\x01#\xf7<./#\x7f\xee\xee\x94w\xf9\xc3G\xebF\x9e\xa9r\xbdZm\x80\x19\xac\xe9\xd1\nYUPYX\x8b\xa3LZ@/3,\xc9Y\x93\xbaRhZ\x17\x12a\\:\xce\x04Xd8\x14\xbe7\x8a\x1a\xda\x93\x84\xdf\x8f\x8ca\x14\x8b`^\xb0\xc7\xa3\xe0\x10\xd8O:\x9f\xaaZ\xd9i\xfd\xa4%\xbd\x9f8E\x071\xe5\xa5\xbf\xcb\x00\xba\xb9zu\x9f5m\xbd\xe8y\x85\xc1\xfe\xab\xce\xe6\xfbzqk\xd7\xc3tN\x93\r_\xeaV\x91\xceMP\xf1\xa8\x91\xc4M5[<\xc1\xb4\xb6\x8d\xc2&\xe8\x91o\x07\xcd\x7f\x13\x00\x93\x02L\xae\xe3\x15\xee\x0c\xacm\xd7\xc1\x99\xa2Q\x05\xa6BF\xb9_\x9b\x8d\xd3\x15\xb1\xc0O\xa6Od\x8a2\xf6a(\xa9\xa6Zum\x0b\xd6\xb9\xd0\x10yVh\xeb\x03\xc9\x90\x15\x85\x04\xabw|2f\xc6@\x1cS\xa1\xd4?D\x97d\xfaA\xfd\xc4\x1f\x1d\xbdi9}\xc8\xcc\xa1\x8b\xebN\x07\xfb\x92\xcc\xd0\xd8hzE\xc4T\x97\xc3\x04y\xb1\x00A\xee3\x10S)\xed\xb3\xfe\xe9\xca\xcbi\x82m\xe7,\xb8\x17\\X\x16=\t\xe0\x00\\\x1bpY\xba^\xad\xa6\xf9\xfe\xb05\xdb\xea\xf0PQ7yi5h,E(\xde\x1e\xca\xf2\xe9\xdeQ\x89T\x92\xe1\xee\xf9N\xae\x8e\x95$\xce\xd4\xb6\xe2\xc3\x9b\xe0\x16o\xe5H@h:\x03\xa9\xdea\x83\xa5N\xe5*\xab\xc0\x80\xe2f\xc6 )D\xa7\xf8\xb5\xc7\x05\xda\x9a\xeb\nN\xbd\xd8)\xff\x12\x01z\xd8\x07\xd3{\xb0l\xd8Z\xac\xa9\xd2\xc6Q\x9bo\xb0\x12q\x84\xcfvF\xe0\xb6&\xb7},"[\xdb\xd0l\xb2\xff&\x93\xef\xc8\x804\xc0G\x8a54%\x97\xd8\xc1\xe4\xa02\xf0\xd2\xed\x144\x1e[\xa4a\xf1T6\'g!P(sh\x9e\x9eI\xd2\xd4\x1e\xdd\x8c\x1f6xd>P\x9d\x8bXO\x11\x0e\x14\xab;b\xcbP\xd6\xd1\xf1\xb1 \xc8\xbc:\xec\xbdPx\x7fP\xe7\x12t;\xad9h\x88\x96l=\x86(\x98Fq\xed\xa3%\xadc\t\x9e\xe6\xae\x02\xeee\xb4\xd6FD\xcd\x95VY]\x00\x9a\xf2\xa7.\x1a\xbdj\xafy \x7f%<\x9f\x81\x16\x82\x05by\xdb]\xce\xd2\x8b@\xa4\xef\xf6\xe9\x86\x97f\x0e(\x9b\x846\x1f\xb63q\x9d\xd2Fj\x03\xa9\xb47\xd8\x89\x92||\xde\xf5\x1e\xb4\xcbX\x93\xe7\xb2\x94!\xf0\xf7\xd2L\xc7\x00\xcf\xb3\xe9\xfc-Z\xc1NI\xad\xdc\xac{\xdcq\r\xf0\xe4\x95:\x7f\x1b\xf1\xd7w;\x1fl\xde\x90D\xb2\xd3\xdd+(\xc7\xe8pp\x059\x0eJ\x04\xa6z\xc2\xfe\xf2\xd4u[%\xadU\x10\xfbO*f^\x12\xa8\x17M\x1c\x8f\xc3\x9a\xb2\xa4r\x9a\x8dA\x9d3vV\xb8\xcbcjt\xdd\xdb\x07\xc8Jv\xa8\xec\x96\xee(&XP\x1b\xc5q\xdb4A\x9cS<\xf1\xfa@\\\xe9\x9c\xb59\xbfm\tMr\x15\xaa\xe8\x17\xa3\x91)\xe3\x80nk\xebV~_\xdaIs~\x84\xe2zt(\x9b\xf1i\xc8\x9f?{0k\x7f\x89\xf8c\xcbZP\x03\xf7\xb6\x18\x10\xech\xcc\xe46\xaf`\x83\\\xc7\x1a.c\xa3Y\xfbx\x17\x0e\xe6\x80m\xfe\xddls:\xc3\xcdk\xb4\x18YM\xf1\x89\x83u.\xfd=1f\x9b\xc6}op\x15\xe6\'\xca\x98F\xcd\\\xd1\xa4\x11\xbaK(^\xc0@R\x14\xd3\x98/>\x1au@\xe7\xb7\xc1\x14\x13f\xc8h]\r&\x1b\xc5\xd6kFt\x80\xff,\x99\x0ez\xde\x8f\x95\xf2\xe1\xb1\x910`\x0f\xf5\xb3.e#\xe3\xbe\xe7f\xb8\xc2\xa3\xa8\xee\x83\xff\x83\xa9k\xf0\xc8\xe4\x8b\x02u\x86\xf9<\x84\x89\x11\xf1\x06z4m\x8f^+\xb5\x8a8i\xda+I\x8a\xc7g\xba\xab\x8eLpw\xbcD\xbc}W\x0f]\xeel\x99\x1a*\xff;\xb2\xee\xb2\xca\x8b\x86\x81\xb6\xebN\x88\xb82\xed\x06y \xe9<\x8c\x1e\xc6\xf1\x04\x87\xc5(R0\xce\xbb\xe8\x89\xe7R\t\xea\x12q0\xf9LXn\x1c\xbc\xb2\xc5S\x85\xf2\xe2\xf0\xf2#J\x91\xf9\xbbf\x16\xd1-\x1dm\xef\xe2\x85\xdbH\xe3\xe0\xdd\xf8\xf7\x1e\xd6\xae\x8cn\x05\xed\xcd\xdb@\xa2RM\\lZ\xd1\xccI\xf1_\xa1(O\xe2\x91D\x7f9\xba\xec\xbb\xf5=A\xb3\xb19J\xf6\xb0a\x14jZ\xddnu=\x9a8:&\xda\xd8$\xf8{\xd7[\xd0\xe5J=\x1fd\x82\xc5\xc7\xe6@\xe7\xa8.xj\xd8\x80\x1c-\xa8\x1e\x84\x98\x98\x16\xaa\xddz\x05\r\x95.\x89E\xabT\xddG`\xee\xa9\xdb\xea\xe0\x92\xf7i\n\xd8)\x88^\x87_\t\x7fb\xd2\xf3\x9c\x80\x83\xf8\xaaJ\xff\xb4\x86\xb0\x1b\xd1\xbc>\x13\xd1\x9f\x82\xbb\xf8\xfe\x85\x9f9\xe0\x8cY\x92\xc9\xa1\xd1,\x1e\x82J\xf8i2a\xc2\xf2\xdb\x13=\xd2A\x87\xb3\xf3\xf7\xa1\xba\x88\xe3\xf6\xe0\xb8\x82JJX(lu\xc6\x99\x92\xfd\x81%6ul\xe57j1\xec_m\xcb\x86\xbb\xe3\xc88\xc3z\xbf\xb9\xd3:\xc0\x89\xd3q\x89\x88J$J\x07#Z\xfb"\xf6\xc5\x80.\xba3+\xc9\xd5\x03S4\x9c4\xf4\x8bn\xd2\x0e\x99\x1719l\xab\xbd\x14\xe4\xb9\x13$\xf1\x9db\xd7/\xca\'\r\xe6%\xee>\xf4\xd3\xfeNK\x89/\x16\xd7\xaf\x8b\xd2\xf8F\x91\xce\xa6\x95R\xe6\xd7\xca~\xbe\x93\x8d`\x18\xf1\xb1\xca\x9fh\x88\xdc\xf9\xbd\xfe\xb1o\xa2\xfe\xdf\x1b\x03\xb7\xe2+\x18\x0f\xc3:\x01(R\x02\xc0MD\xb3\xbao\xcfB\xa7\xe5eO$R1\xeeGYSU9\x1f\xb5\xfc\xb7\xcc4\xad\xf4vMc\x0c/\xed\xf1f\x92\x90b\\\xfb;\xc58\xf1\xbd9\x96\x18\xbc\xdcol\xd3\t\xd3 \xa5,\xdbU\xfaN\x880\xdb\x84lM\x9c(\xaa\x9e\x82\x98\xdc\x92\x7fB\xcf%\x7f\xec\xdf?\xe3\xb3j~fdeK\x98\xd1K\x0f-\xa2o\x96g\xf9?[(\xab\xdcq\x9e\xf2;t{\xc0\t\xe5 &u\xb5z\x1b~f\xcc\xe7U\x0b1\xa1^\xe1\x0f\x19\x94\xdf\xf5\x99*;b+-\xf2\xdb\x16\xfa\x8a\x01\xacKB^\x00\xe0;PK\xcc\x80\x89\xb4\x8c\xa78z.\x9a\x12i\xd6\x12\x91\xfc\xbbQ\xfa)\x1f\xb6\xdaq\x13\\2\x13\xf7\xb2\x8dC\xd3\xbd\xcd\xba\x9c\x88\xae\xa4\xa2\xb7\x10\x1c*\x12\x1f\x8a\x84U\x16X\xee,y\x8f\xcb\x87\xcf\x8c\xa6f\xf2\xda\x99sE\x90\x8c\x96\xb8\x89m8,\x06p\xc5\xa6s\xed\xb3\xdd\x0c\xe0\x17\x14\xaa\x16\xfc+\x1e3\x9aI#\x06\xe9\x02Q\x84S\xc3\xa8A\xa9]\xec6&\x87\x15IW\xd1YQ\xdb(\xb0/W\xc3\x8bS\x13\xc8\xd5\xa6\xffVV\xe5"\x8d\xe9\xe8x\xbb\xa1\n\xb45\xf2\xf4k-\x81\n\x83\x8cn\xb4\x17=\xda)\x8d\x1aPTm\xd4\x05b\xd57\x848Y_\xcd\x04>\x9d\xe4\xceo\xc1~}@R\x95\x08k\x99Y[\xd3\x85m\x00\xbcbaj\xe0:\xbe\x81\x1f_\x0f\xee\xa4,\x89c\xfb\xaa*`\x9a\x12\xbe\xbf\xb8r\xd0\xebZ\xe7\xc1\xbcD\xf59\xfb6\xbb\x90#S#J\xba\xfb\x03<\x1f\xc6\xbaQ|\xa1lBK\tA\x11Piv\xd8H#\r\xe6\xc6\xbf>W\xa6\x1f\x90ma\xb2\xf3\xea;\x1d\x9b\x8eX\xf8\xc6\xc9\xe4\x12\xc5\xb5\xbe\xf7I\xd4S\xdb~o\xd7W\xef6\xbf\xf0 D]\x16\xc5\xf9\xbd&]W\x1f\xa1,\x10\xbf\x17\xfe\x9dM\xe9\xa9\xc1\xd5q\xd4k9\xa1u\xa9e\xbb~)q\x13St\x15R\xb3\xde]s\xf7\x90\xd3\x7f\xb9\x07\xe2\x91w\x97l\xdb)o\x08\x91\x05J\xc5\xab\xac>\x97q\x99h\xa9\x9c\x86k\xef\x802\xaa!\xa0\x8f\x86\xf3hr\xf4\xcf\x97\x895,\'k\x9d\xfb\x98R\xe7\xcf\xe2}4\xf2\x8d\x05C\x8aM\xc8\xbf\xb0\x19\x13o\xf0\xc9\x1f\xfc\xeeF\xe4\x06l\xf3\xa8\\A\xdbY\xb4\xa4\x178\x86\xc8\xbb\x00@\xde\x1e\xaf\x06d\x87\xec"0\xaa\xe1\x04\x11\x11HX,}\xb775=\xb5n\x18\x93\x02\x95`\xe7\xb2\xdc\xec\x0cs\x1c[\xc1\xc9#\xd2 pI\x8d\xbdR\xc42/T\xb9\x8d\x8dT\xd1\xa6\xf8\xe0\xe7+\xd7\x15|\xd1;\xceEt\xcf>k\xe6\xac\xfe\x9c\x9d\xcb\x96?\xaaw`\x98~\x0cIF\x9b\x97\xd3\xb4H\x1d1e\xdeV\x95\xc0\xce\xaa{\xb7\x15u<#\x16\x00\xbe\x95\xfd\x1c\xe2\x14A\xee=\x1a\xfd\x14\xcf`}\xb7\x06\x85&\xeb\xf0\x88\x11w\xe9\x99]Q\xc4\x93b\x05\x89B\x19\xa8(!\x94\xe6,\xc4b\x94\xf5:\x81\x0f!y\x1a\xfaHr(\xc7\x17\x811\tfW\x9c\x7fa\x7f:\x97h\xe5\xdd\xb5Q\xcc\x92\xa8 \x86.l\xda=s\xf8\x0f\xf8R\x94\xc8\xf0\xdb\xd0\xc3\x1e\x07\xdc\x86\x9e\x7f\x82\xa2J\x00\xe1\x1f\n\xf1\x9b\xf8b\xd1\xc7\x96\xf0\x9c\xd4\x0bL\xeb\x16?z\x9e\x14!\xce\xfc6\x03\x12H\xd5\xcfp\xe4;\x0b\x96\x840\xadEy\xcb\xeb\x1b\x1aY5l\xa3\xbd\x99J\xab\x95\xb9\x8d\x07f\xb1#l7u\xb5\xcb\x1aO\x8b\x8f\xf4\xe2x\xb5QpH b \xd7=\x1d\x13P?\xb6\x8f\x0c\x84W\xef(\xfeh\xe7Y\xf8;]\x990,\xee\xf5\x988\xf0\xf3\xb4\xda!v\xe1\xec\xfd\xbe\xd5n\x0b\x8b\xac\xea\xe4X\xa0\xc5\xa9\x12\x000L\xf9\xdfFF\xab\x88\xf9\x0c3E\xecU\x81-\xaa5\xaa\xd39\xfe\x94\x9b\xc27\xa4>"\x9a\xc6\x92\x9a\xdc\xba\xa6Gj\x00\x14\xbf\xff&\x88\xd00rIh\xde\xfb\xf8\r\xa3\x88m\xf8\xb3O\x8eC\xc6\xe4\x857\xbf\x97\x06`_F\x14\xa3\x02x\xee\xdbG\x0cpQ\x7f,\xeb\x99\xa1\x0b\xcb\xf9\xc6\x16\xf1G\xfa\xb3\x9b\xc2\xed\xaf\x0bo\x8e\xf9)\xd2\xc9>\x93\rgjy)pya\xfa\xa2\xff3\x05\x82\xb0\xae\x13E\xa4\xfd|\xae\x93\x02\x82\xd0\x07\xaf\x8e\xe8\xcbP"\x85\xc1\xe7\xe6\x1c-\x8d\xe6\xb5(\xa7+\xce\xbc\x83N9\xae\x03w\xf6\xa1o\xf4\x02\xc92m\x9c\xf1\xde\x10\x80.\x06\xb1m\xf8\x82@\xfe\x18BE\xca\xa7\xd2\x95\xb0^\x16\xc1\xfb\xa8\x180\x9eEj\x83B\x98\xdf\x85\n\xa0\x95D$\x84Z\x98\xe6\xf2\x10\xa3\xeb^\xfa]\x17\'\xd9?\x1c\xbc\xac&\xf7\xa16\xd0n_\xc1PL\x82:|\x7f0\xa8;K^\xc2\x81\x14\x9bR\xe2Q2L\r\xd7\x10\x8c\xc6A@\xef\xaa!\xc8\x17\xff[\xa1\xca\xfc\x99\xf6\xcc\xde\x97_\xfc\xd4\x01\xbb\x7f\xc7\xd78\nB2")\x90/\x8cZm\x91V\xb3\xfc\xe7\x04\xe5\xed/#i\x05\xed\x06\xbf80\xfeu\x90@\xcf\x14n\xeb\xae\x8e\xfa\xaf\x1a\x8e\xdf\xa9\xe1\x05\xc0Y\xa4\xfb \x8ep\x1c\xe1/\xed\xf6\xbf\xa9\xb7\x18vv\x8e\x12\x04\xe9\xa2\xd6\xe7\x86\x0e\x07\xca\xf6\x91\x1ag\x11\x16\x8e\x1b~\xf4\xf2\xfb\x17/D\xd2\x85\x06\xe8\n\xf4c\x0f\x15\xa1\t\x0b-\x967\xb8f\xf2\'+U\x11\xb9\xd0X\xe2\x07\x9d\xb4\xad\x8ayh\xb2Q\xdb\xcey\xad\xaedS\n\xb0Z\x96\xe9\x05\xed\x84\xa6xn>_\xf6s}\xc3\xa2~\xcb\x9b@\xf5{1\xa1T\xae\xf0\x80\xd9t\x9b\xc4Y\xa5\xfdT\xcc\x98c\xe8\x86\x80.m\xa8\x01 \xf61\x14_\xe3\x00J\xc0*\rW\xc1\x92\xd7\xc3\xf8\xf8\x16\xe8\t\x06<\x14\x9dd\xab\x88\xf8it\n\x81M6k\x89=T\x95lZ\x95\xfd\n>u5\xa9\x87\xd8\x01\x8c\xdf\x10K\x12\xd8}\xccc\x06\xd0\x98\xf4\xf4St\xe6G\x03\x91\xf5\xe3\xffp)q\x1f\x8b\xbe\xe6\x1fT\x9d\xcd\x83k\x0f\xdb;\x1913\xbf\xaaa\x93\x19\xd8II\'a\x9e\xc8~Gt\xa1\x0f\x0cS\xdex\xd4\xd5o0\xf4\xb6\xa3P#\xb28\xaf\xca\xde(\x91\xa1\xcf\xb3G\xfd\n\rO])\xd2\x05\x93A_\xf3\x9bVo\x81\xc2e\xa3$\x15\x11c\xafY\xf1&jQ>\xaf\xee\nOr^\x1e3|\xf9\x900\xe2\x9fy3\x91\x8f\x89\xbf%\xad\xb7\xa6e\xf4`\xac\x07\xab.5m\xbe\xeb\x08\xd8\xe5\xfd\x1e\x1d\xa7\x9b=\xf8\xbd\xd4,\xcc\x95*\xc2\xf0u91\x80\xf3\xf0\xe8\x9ed\xbb\xcb^\xf8,\'?\xbe\xd0\xb6\xec_\xcb\xf52\xfay\x9fbC\x859\xe4\x8da\xca\x9d\xf7\xb0\xe8;\xa2\x12\xb4\xbf\x1c\xb7\x9e\x99s5N\x91\xfb\x02W\x02\xd5\xbe;&\xccq\x1b\xe6\x1f\\\xad\xc3\xd3\x13l\x08\x91k\x16W\x11\xab\x96)\xa4\x8f\xbea\xb3\x80$\xef\x8a\x99*4\xea>g\xd6C\xc8a\xb2g\x97\x8c\xe4\xd9\x0b\x18\x97f,z)j`7yb\x8bG\xb19r\x87oY\trO.@X\xac\xbd\x1a@\x9a\xec\xcd\x90\xa9\xa3&\x8eI\x1e\'\x8a\xd6\xa6WExz\x02\x0b\xcdQ\xce\x0eV\x9d\xd1\x17\x9b\xebOc\xe7\x0e\r\'\xc1\xcf\xea\xd8\xa5\xffgL\xfb\xc2\xd8\x0c:\x93\xa18\xbf\xe83\xdd\xeb\x82\x98\xe6W\x80\x1a\x1a\x1d\xcc\xecN\x14\x9c\x87\x89K_8s\xff\xc0O\r\xb7\r\x90\xf7R2\x841\xf3\x9c\xfe\xf50\x11E\x8fk\xd0;\x1d\x1b`\xebR\xa7"$ed\xd8W=\x7f+\x8e\x16\x10\xd6\xa8=p:$\x9e\xde\x90\x03W9?\xa4\x16\x1b\x0b\xf7J\xd75\xe4\xf0|r\xc3\x04<6\x8d8CqB\x1a>\x95\xcf\xfbi\xdd|*\xb4\xa0\xa8\x08\xa2;\x85\xf0"0\xffE\xad\x0b(\r\x0e(_>\xdab\x04)P\xac\xb3\xa6X\xcd\x00\x0c\xb5\n7\x11\xf2Fl\x0e\x16\x9a\xae\xc4\x1b?\xf6j\x01\xfc\xa4\x8c\x10S\x14\xdd\xd8\xe1\x03\x8b\xd4\xbb\xeeI"\rh\x1c\xb9\x04\x9f\xc3\x92\x17P\xe3\xd5\xa0b\xf8\xb8\x13\xdf\x1f?\x95\x9e\x02\x8c\xa1\xe2x\xd8\x84\x11y\xa4\x1cZL\x8b\x86\xd9\x15\x1a=\xf2\x90&\x16\x9b\xcf\xb2\xd1?VuJ\xf3\xa5\x8b\xa7A\xe6\xf1\x01\x00\x15v\xa3\xa3!\xa5\x9e\xd2A\xf3c\xe8#I\xbbs\xb7\xc4\x08f\xd41\r\xd4\xedE\t\x9aK\xa8\x83\xbb\xdf\x0f\xba\xff\x1e\x8cd\r\x133:\x93\xa6\x9d\xa5\x1akO/j\x90\x0boM\xe3\x9bu)uV\x8ad\x8fq\xee\xe1\x15\xe1`\x8b\xd1\xcd\x9eq?n\xb3m\xc1\x9b\xbf\x9d\xf6\x0bju\x90\xb6\x05\x8cd>\xfe\x1c\xf1\x96\xd6\xbfq\xca\xdc$\xce\x80_\xda\xcb\xa1\x93\xc1\xdb^\xa5G_\x7f\x0f\xa7P8r\x89\xd4#=\x182Ig\x85\xe6\xf860\xac\xe9\xe2UD\x9e\xca\xe6\x83\xf4&4$s\xb5\xcd\xef_\x99_\x1b\xba\x0e8\x13\x84 \x97?\xc9\xe1MK\xae\x84\xdc\xa0*m\xbf\xb84?\xae\x17\r\x80\xb6\x06\xa8G\xa9\x91TB\xf61\xe8\xa6\x81i\\\x8d\xc8n\xed\x1da\x88\xd6[\xd0\xed\x15\xcf\xcd\xef\xf5\xc3\x8a\xedFF\x98\xfd\x1a\x11\xf6U\x01\xde\xc77\x04`\x9e\x97\x1f`fH\xd5t\xbf\xff\x7f\xd6\x90\xdeK@\x9e\xe0+\xb6\x90\r\xa2p\xa6\xc1n`\x0fL\xe2rx\xbee\x98`\x86\x14X\xfe\xf8\xba\xa0\xa3*\xad\x1c0\xd2wW\xe4\x9c\xba=\xb6\x00+\x96,\xe3Z;\xf1\xd0A\x81K\'2\xc4(\xdd*\xe7\xb9\xb2\x0b\'-\n\xd1X\xaco\xae\xb2\xcf\xd6\xec\xd6\x89nl~\x18\x93\x92\x14\xc3\xca\x1aW\xdf\xdfn\x1b\xe6\x04w\xc8\xb4\x0c\xdf;\xee\x03\x0b\xdc\x8d?\xfd\xa7F\x83\x07\xe5{\xacO\xe0\xa9\xf3w\x84\x0c\x98`\xf2w\x0cZ\ry\xe5\x1d\x07E\x940\xd7[\xac\xbe_\x8bx\x9a\x1f\xcatxZ\x98\xf5P`\xf68\x08\xce\\\x96\x0b9\xe2\xf3C\xf6U\xdc;\r\xd4\x13\xe6\xf7\xd5\xa8u3\x85\xe0\x903\xff\xcc\x8cs\x9c\xdddX\xe2\x06\xc1\xa2b\xbb\xa9x\n\xe7c\x19\xf7\x93j\xa4\x0f\x08\xfb\xd3\x82d\xb9\x0e5\x17\xfa\x89\xf8\x98\xcd\xda\xf5r\x8dB\xddO\xe8c(?\x81G\xddp\x8a\xc6\x0b,\x07+\xf1"\xe4\n\xc417\x99\x8c\x9a\xde\xccZ\xc8a#&\x9bk)P/x)Y\xd0\x16\xc2\xa2e\xfb\xf6\xf3\xb7\xab,\xb2\xf3\xebK\xe3+\x8fd\x84\xf6$.\xe1\x16\xe6hk\xea\xcb\x06\x1eFU\xf0[\xd6\x00(\xb6d\x9eC%\xa4\xf1\x0b\x846>\xba|\xc88{f\x0b\x9a\xef \xb6v\xce[\xe6\xe8\xd2y|\xd3l\xdd\xdc\xc2I\x9a\xbb\xb1\xb2P\x94\xa2\xda\xdba\x90Q\x01\tkk\xe9z\xf1E;\xdc\x08\x96\x8d\x84x\x11\xf1\x91\xd8\xbd5\'\r\xa5Jlr\xf3O:\x1cu5\xcb\xc2\x83nr\xa9\xf3L\xd2\xb2[p\xd8\xf5\xab\xc2\x9d\xee4\t~n\x8e\xe7C\x18\xa0\x1d5\xb8\x82WJ\xab#Jb\x90\xfe0\xf9\x8d\xd9\xba\x8fG\x9b\x8f_\xf2I \xf4G\xbd\xff\xa6\x87\x99V\x95nO)\xaaz@U\xc8y\rN\xe7z<\x14o\x1a\x84\xc7\xb1\xaf\x91\x1c\x14\x07\xba\xb5;D\xc1\xb9Tg^\nYF\xc7Xm_\x90\x9a\xbfZ\xe5\x08\xa8\xc3\t\xc6\xa1\xd7\x1d\xb9\xb7\r#\x1eme\xb2\x18\x826_AW\x1ex\xb2\x04\x81+\x0f\xa3Z.\x94\x17`\xbb"\xaa\x8e\x82u\xb9u$\xa7\xe3b\xd9\xf5JE@\xfcb\x8f\x90\xce{\x14\xfav\xf5"\x81\x90QsP\xc9\xa0v\xdb\xe2\xbes\xb6\xb0\xbc~1\xb5\x19\xfb\xf2n\xfb\xa8\x95J)L\x00\xffL\x95#s\xf9\xb4S{\xcfm\xf9\xab;\x06\xcf\x9f!\x1a0vg\x1b\xacB#{\xb5\xc8ja\xb8Z.\xd4^S"\x85\x90\x12m\x94\'\xed\xb2\x14V\xb1\xa2\xd2\xd3g-\xc4\xf6\x84z\x1c\xba\xd8\xf7~\xfe\xe5\xfa\xf5\x85\xc8~w\x03\xb9=p9\xb6\xa7\xe3\x18\xef\xa8Y$\x16%G\xb3\xc3f\x97\xf8V\x8a\xc8G\xc0\xc05\x81\x98DuC\t\xcfa\xd9\xb8\xb2\xf2\x9a\x82)\xfe\xc5\xd4\x9d\xe3\x97g\x8b\x18\r\xe8\xd8\x03\xde\x0bx6}\x15\xe5\xd0\x93\x1eG#\xfb\xe4\xb0y8A\xa9\xe0\x08\xef\xae\xdb\xb1\t\xbd\x0e\x04\xd9D\x0c\x86\x12\xf3\x10 K\xf3\xc1\x1fV\x1b\xf9Z^T\xa2x_\x0cA\tS\xe6\xdc\x96\xfaJyR\x02\xef\x8e\xde\xf1\x81\x0e\xbcb\xcf\xae\x9e\xf3h\x95%\xef\xf2I\\\xfc\xe1\xc5p\x06\xe92\xe0U9\xcc]^\x98\xa4&P2j\t\xa4\xf6[\xb07k\x92\x12\'\xdb\xee\x16\x13?\xa3\x17II\xdf\x01I\x0bX\xfdN\x03\xa5\xf3\xf7(vO\xa0V\xfc\xaf\xee\x10\xe7b\xc7[\x08r\x8fM\xce\xe2x\xe3h$\xd7/\xc5\xdbUR`*\xab\x9d\x1e \xc9\xd6\xa2^9\xaa\xbf\xd1\xa7\xef\xb3/\xf10\xe0\x8a\x1e\xfb!\xf0s\xeewo\x95\x0bX^%\xd1\xfb;\xfe\xb4|\x85\xad9cKk\xb2D\xb8\xe5+\x19\x05#\x08\xb5\xe2D\xd3\x8f\xacI"\xb4\xebm)e\x0eP\xaa-\x9f\\\xd4\xad\xfda\x85+`\x82h\xf4\x84\xc1\x87V\x9d\xbc\xb8\xef\xbb\x19\x93P\xd8\xb04\x91*\xa2\xc5\x7fp\xd6\x83f\xddC\xeb\x9c\x15\xff(\xc05a\xc1\x04\xbc\xb2k"\xc0]\xbb<\x0c*T=\xca\xa6P\xfe\xc3Xl\xcf\x8d\xe4\xc4alw\x0b\x93\xaf4\xc9Ep\x05\x0e\xbc\xb3vVw\x1d%\xb2\x85h\xa5\xe8\xcbr\x1bV7\xd6\x04\x12\xaf\xf6 _#1G\xd6\xe2E\xc2\xf4\xd2uf\x95\x89\xefp8\xfc\x9bU/X\x03\xf5\x9aMv\x86\xa3\xf0\x885\x1caY,O\xa8\xeb\xf1\xc5\x07\xe2\x8a\x1fk\xc1\x8e\xb49\xe2\'\xdeL\x8bE\xe2Z\xa5\xd5\xf9S\'=\x100\xe5\xda\x0cB5_t\xc8v\x12N\x87\xe6\xf3\x08\xe5\x92\x02\xdalM\xe2\xcb?\x08n\x00#\x1dfm\xa8\xacR\xf0\xa6\xff \xdc\x0bc\xaa\xd9\xfbqY\xe3\x89S1\x15\xb1\xd0\xc4\xbb\xe6B\xae\n|\xb6\xa65\x1a/\xcf\xdf\xb2o\xfdxY\xd6\xde-\xdf\x81q\x7fJ\xbdL3o\xad}\xda \x1cc\x9b\xdc\xbe\xb6;\x84J\xf7%Q\x8a\x9f\xc9#\xa5B9\x8a\xe4&\x02\xdb\x9b\r\x19\x97hoUri3\xcb\x15I\xebi\xa1s\x06\x17\x02\xb4\x7f\x168\xeeW\x84\x15\xf7{\x03\xa4\x93\x85\xd1/\x18\xac\xedZ\xd4\xb4\xd9\xc5\xe4r`\xb8\xdb\x82\xe6\xe83\xbf\xdeu\xf8\xb9\xfe\xed\xd2\xe8\xf7\xe7\xba6n\xc6U2\x16*\xbd\x15\x85\x9b\x06\x9d\x9ck5\x1a\xd2\xd4\xc7\xea\x04l\x01\xc3\xcbHD\xadK\t@#@\xaa\x1a!c\xed\xb7\xaa\xab\x85\xc1\x04~ #~m\x8d\x1d\xd5<\x11;&\x0e:\x83\xf0\xde\x9a\x0f\xe4\xcfy\xfc?(x%\x02!\xaf\x90\xa7*I\n\xd6&\xc4f?\xf7\x01\xb7\\\x9b\xdd\xa5\xc3\x8bt\xbfx\xfc\x18\x9c\x12\xc8\xa3\xcc\t\xad1\xed\xbd\x8c\xbb\x90\xbb\xb2\x01\x04P\xc9\xe5\x88\x02v\xd9\xea\xf2%o\x95\xc0\x10=\xa3\xdf\xb9>\xd1MM\xeb\xe7\x02O\xcc\xa3sSA\x94\x997=\x9e\x05\x87rK\x15W\x97\xbd\xabk9\xa9\x8a\x15\xe3@\x99wK+\xdf$&I\xecV2]\x9c>\x17uZD\xfdV\xd2\xb1\x96/+\x0f.w\x96Ix\xd07,n\xb5\xef\xf5\xd3\x8eu\x0ey\xd9\xeb\'wM\xc0\xd7\x85\xf5\xd3\x19\x92\xa5\x15\xc8f.S\xd6\xf1d\x8aJ\xe4d\xc6\x1c\xd3R\xb8\x81\xf9\xa7\xe4\xca\xb9\xbcq\xe1\xce\xbb\xd0\xca\xae\x0b\xa4\x85M4.\x1cs:#\x86\x0b\x1b3\xc5\xb6\xcb_]\x00\xbeL \xf9\x116\xa3\x82\xb4\xbf\xe9x\xe5\xb44Z\xc3\x02\xea\x9f\xac\xfc\xb7\x9ff\xa81\xcb=\xd6\xad|\xa2\xc1\xc9\xc7 tlK\xfaU\xe5\xf0\x8f\xf9_\xaeU\x99h\xb8\xf6\x08\xdfwo\\\x10\xefS^\xdf\x1d\x80M\xab\x1c\x85Ke\xc7\xf8\xdf\x9bA\x98\x07\x98\x9aJ\xc3\xc5\xe6\xb5[T\xacZ\xecv^?F:Fi\xb1\x88\x83$\x876\xbcD\xd1\xfc\xc1\xa5\xf6#c\xc7\xde\xf7\x1fT\xaa\xca\xedu\xd3L\xe8\xbc\xcfYdE\x7f\xb2\x0b\xe0&+\xd1\xc9\xa9(\xcb\x0c\xf4pD\xe5\x11\x1a\xb5\xd5\xc1i\xb4\xbf\x0fuE\x9b\xdd\x0ck\xd2.\x8f\x1d\xcd\x91\x85|\x1c\xe4(:\x93\x0c\x12\x9aQH[\x95D\xc6\xb8\x1b4L\x15i-scW\x94\x85[\xec\xd6\x00(ib\x0fuN\xd5i\xa5\xcd\xfck\x81/\xdb\x19:M\xe9\xbf\x1c\xd5HW\x7f\xbf\xd0aO\x1c=\xccq\xd0\xe6\xecsC\xb2\xaa\x03PGE\x9b\x1a\x9bc\xc6{\x0e\t1i\xeb*\xae\xc9H\xa8\xfd%\xba\x1f",\x8e\xe9P\xf4\x13\xaa\xe6\x9c\xb5\xda\n\t\x19\xad$\x12\x1eW\xcf>\xc2\x9d0\xdeBR\xb7\xbb\xd6\\\xfc(\xa4\x9en\x83\x98\xd0~\x9c\xe8\xf4\xf0\xf9\rE\x8d{\x1b\x0fu\xce\xde\x04\x99j\xcfU\xf9\xf3W$\x83\xc1\xe9o\x92\xbb\xf1\xe4\x83\'\xa3@\xf2\x1a\xec\xa6~L\xddg*\xe5\x8e\xbd\xa1\xb07\x92I\x92`\xbf\x0b;\xf8\xf1b\xfb\xc2t\x98Br\x92\x12\x8c*\xfb \x9d1\x8f\xba\xe3\x8c\xa7\x15\xf8)\x06R=\xf4\x84\x93i\xf6ktG\x1e3\xbe\xb1\xfc\xd2_R\xd5\x7f\x8d\xfd\x9a\xcd\xbb\x99\xeb\xe2\x93\x0e\xce\xbd\xd5T1\xe0\xf1\xaf\xed&\x16$\x9b\xc8\x13\xce\x8f}J\xc67^\x08\x12\xedG4\xd2\x8fv\x04\x0cW\xfe=][\x9e,E\xcb2\xbd\xd0\xba\xce\xb0\xf8\xf5\x12v\xcc\xa9\n\xae\xcb\xc6\xbb\x88\x90up\xe6\xc0:\xc6\n\x88\xbeNV\x90\xee\x89\x95\xc3w-wV\x154N<\xd5f\x1d\xfcY\xca\x13c\xfc*\xdd\n\xfa\x08\xee\xcd\x91\xe1L\xcd\xd4h8y0\xa7\x06\x88\xde\x97\x02cR\x89O\x88\xd9\xcd\x93#\xa0\xc5`\x81\x01J\xc8m\xe5`l\x0e\x03\x81j\xc1\xdf\xef?=\x1b!\xff=\xa8\x87\xc8\xe0\xd69>\xdb\xcb\x13)\x9e\xb8\xe9\xe59\xb1H\xae6\xf0\x04\xb7D\xdd\r\x95\xe7\xf0}\xcc\xc3\x0f\x924*\x95\xf8\x917\xe3\x1a\xb7\xa6\xea\x8az\x0f\xa1\xbd4\xbc\xa9Y3\xff\xade\x11\x8a\xf3j\xe4\xa0\x8f\x97$\x8f\x04\xbd\x0bn\x0cV$\xf5\x15\xe4\x81\xae\xa5k\xc4\xc6\x84+f\n\xa2\xf9\x1aq\xe8\\+\xc6\xab\xdb&\x83\x7fy7\xce\xe9\xc06sA\x8f8\xb1g\x0b\x8a\x12\xc8\xed\x8c\xac\xa2J\xc0YA\x1bb\xea\xecQ$\xaa\x0e\\\xce],W[N\xa7\xf2\xde;3\x89\xcb\x07\xbc<\xd62\r\xf0\xc7c\x9aF\'\x06\xea\xce-F\x11\xddu\x0e\xd1g\x01\x04\xe2\xcf\xcb\xb1\xe8X+\xc9\rg\x9c\xf9@h\xe0\x9e@\xc8GN\xd0\x90\xae\xd6;[\x8e\x0f\xa0&\xad\xa5\xc2\xcb\x02h-\xa8) z~Z\xd3\xc2\xa5\xed_+\xbcZ\xe9\x91\x12\xb2\xe5Q\x17Z\xc32\'=Q\x16\xfa\xd4\x83z\x04\xd0&\xaf<\x015v(\xe2\x8f\xac\xd2\x99\x1f\xf5\x95?\x00bu\xda?\xba\xc4u\xc2\xde\xf3\nM\xcc\\\xe6\xdff\xd2\x17\x1dy\xc1\x15Vc\xe1\x01\\\xf3KR\x8b\x12\xe2g\xad\xa2\xdb\xba,|\xd5\x1b\xc9\x85O\xe1\x81y"\n\x0bqJ\x11\xc8DL\'\x18\xc1\x94_[t\x10\x9c\xf3]\xab\x0f\x97\xac)>"-\x99\xfdY\xad^\xbe}$P\xda\x9d\x92\xc8&\xf0k\xcc\x97\x88\xbdom\x10:sO\xd4r\xf3>Q\x94\xb5\x84\xb2\xbd\x1cN$J\xacF\xbe\x80\xb1\x88\xa5!\xa7\xdc\\\xd7l\xb3\xcf\x0eR\xc5G\xf5\x81\xc5\x8c\xf7\x9c\x10~\x82\xa6\xe7q\xb1\x9bK\x07k\x03e\xb7k\xcb:\xf2O\x8f\xd9c\xa4s7c\x8f\x08!\x0e\xfaZ\xfa\x07}\x1dS1\xedx\xfc\r\n5Ax\x12~\x06\xfb\x92Y\x07G\\\xe6Xsk[\xc1\x9c\xfc@\x05\xf9\x92MT\xb4\xbb\x8a\x8a\xfc8\xfb\xef\xaf\x0eg\xa3<\xa8\xba\xf7\x88_`\x07\x01\x1b\x18\x01PZ\x16W\x95\xb8\xd5\xce=U.\x1eh\x0fd\r\xaaAAX\xb1\x0b\xc5W\x01t.\xfc\x8d\xb6\x14\xf0\xae\x9b\x8ceH"4\x8d\xc9fI\xdbx\xb7"\xd7\xb12\x87.\x07h\xb0\x18\x1a\xc8\xba\xbe\x80\x08\xd0!\'\xeb\x17\x03\n\xc4So\xbf \x0e\xa2\x15\x803\x13\xb0b\x7f\x8fW\xace\x1e\xc9\x8d\xd3\xe1\x16\x1e\x82\xc6G\xdc\'\xc2\xa6(\xc1\xc0\xcb\x03G>\x81\xb1G$m:\x12\xa2\x7fr\xd5\xa6@j\xc8\xa8\x93\xf8\x99\xed\x87\x96Yr\xbbc\xe7\x03\xf9\x82\xa46\x88+\xc1\x1f\x8f\x0cR\xdf\xb3ko\xc3V\x8a\xdc\xcc\xc5\x18[r\xddy\x07H\xcc\x07\x92\xf6\x86l\xc9\xfb\xcf@!`\x0bl\x99J\x13\x1eq\xa8\x9b\x8c\xbd\xa6\xf1\xe0t\x16aohg\x92\xcfJ\t\xa9XFzY"/\x07\xa0\xfc\x83ba\xb0\xd5\x0e\xde#p\xc5V\x88\x92\xec,@M3(\x8e{Ob_\x13\xe7\x19\xa2\x86l\xeb/\xb6\xf6\xb9\x05\xcc5Y\xb0G\x19!/3\x996z\x9b\x7f\xa3T!\xc97\xb6\xa8J\x95\xe9\x12\xeb\xa6Q\x81t\xa2\xf3\x02.W\x16\xef%6UR\x87N<\xf5\xf0R?\xda\x059\xbb\xb1\x0b@\xec\xe3\xfe\xc9\xfa\x17\xda\xd9\xd4\xee\xae\x00\x02=XL_n\xa8\xb7FP\xe6.%\xdf!\x08\xb5D:\xbc\xf7\xcd_f\xd3l\r\x10\x9b\x16\xcc\x82\xc17:\xd4M\xed\x1bwC\x9a\'h\xd0Hn?\xbb\xa3\xac\x8d\x14\nnMs\xf3\x7f<\xde\x1f\xb2\xbc.\xc16^\xd8\xe3H\xe0\xfd\xe4h\x96\xf7\xce\xbe\x93\xe7\x17\x8e\xf1\xaa\xdb\xc5\x82aI\xa9*\xbb\xed\xea\xe6\x90HqX\xd6\x82[\xff\xfa\xc0-\xa3f\xa6<\x93LJ\x1eK\xee\xc9\xa9{;\x7f>\x88)\xbd%\xe4xLD\xa1M\xa0\xe5\xe6\xa0\xe2o\x9a\xdf.\xc9}\xcft\xa0\xc9\x8bL\x92\x15\xf9F\x8cw\xe3\xeb\xa1\x88EM\xbeh\x1b6\xf3&Y\xff\xfa\xd2\xabA!w\x9711\xef\x11\xd8bS\xca\x06\xd5\xb9%\xa0\x0e\xbc\x14_\xe1\x04\xdf\'\xd0\x82\x1d\xa2T\xe8\x93y\xb4\xfd\xb4\xab\xe7\xd6\x06=l\xcd\xe6\x19\xf3#\n\'\x92\x11I\xa5d\xf8\xd3\x07\xc9\x01`c\xfe\xd7\x8b\n\x13J(\xea2=\x19!fh\xee5M\xb6\xa0\xee\x8b\xf9c3\xf9\xb0_\xe8\x0e\xf5\xb5\xfe\x02\xff\x12h\x9a\xe9\xa7\x81,\xa6\x99tP\xb7\x9b\xad\xff\xd9\xf5\x055\xaf\x93\xef\xbb\xab\xcf\x95\x17\xb3\xa5*\xb4\x91\xe0\xb4\x8a\x03/\x1c\xb9\n\xd5\xde\xd0\xd9\x81\x89\xb7t::\x81\xf3\xaa\x1b\\ YE\x0cX&\xc5d\xbc1\x86\xdcG3\x7f/\xf5\xcd\xf9\xda\x122\xc3qG\xb89\xc2\x16Z\x8e\xf8=g%\x0e!\x0c\xa6\xd0\x97\n\xf2\x05\xad\xa9#\x01\x90}J\xa9/\xd4\xc2\xea\x17\x98\x1f-\xca\x0f\xc9c\x95\xa0\x16\xb5\n(}\x1aO\xd0c\xe4\xa9]\xb5\xaeB\x8f\x1c\xf4\xf5fI\xf3/\xfa\xbe\xca"kv&\xb6\x94\xe0)\xee\x02\xf6\x02\xa4\xbe\x9b\x99\xd0\x0e\x0f\xf4\x85\xbc\x84\xac\xb2\xe4\xf7\x0e\xefFh\r\x80\r\x89\x9f\x05\xa6\xf3q\xc6\xc1G\x88\x9a\x7f|%\x8d\xe7i$\n\xa9\x96\x07,\xf1\xb1\x9aPj\xacQ\xabr\xbd\xcb[\x00\xb7\x9e\x9ds\x81\x93\xda8\xe89\x84\x10L\xef\xad\xbaX\xdf\xeeW\xe4)\xbf\xf3\xbc|nB\xf7\xb9\xed\x14$\xd4\x8f\xf1}\xbe \xc7)8\x1f\xd1q\x1b\xe9\\M\x95_j\xdf\x99\xa3\xa8\xd9r\xa6\x9f\xa2\xb2R\x98;\x7fp\xa1\xacg\xdc\x83S/,-\r\xdd\xe0\xe4B\x122\x13mp\xf5+\xe3q\xe9\r\xc4\x14\x93\x16\xe2\xd0s\x0f_T\xf6\x15\xf89\x8c\xfb\x83\xa7r\xbd\xa9\x17 \xaf\r\xab\x82\xfb\x95a\x08\x0b\x03\xb8\xaaz\xfbm|\x94v\xa0\xb0v.\xae\xed\xf8\xe4&\x0eO\x8b\x83\',\xb9\xde\xcb\xaa\xa3\xe8\xafDo\x15\xd5R\x12\x93\x84\xc2\xe9\xff\xc8N\xd3\x1f\x81J\xa0\xcb\xcc\xa4\x9b\xa7\x08\x11?\x19cu\xdci\xc6C"d\xefK\xb5|7\xa2\x17F\xdf6a3@\x08\x1e\xfd?\xce\xa1\x7fsL\xca\xb4\xe9i\x0c\xdd7c\xb1\xcfxF\xa1\x88\xb9d7>\xa6\xcd\xf9]&|\x0b\xe6\\4\xef5|\xe1h:\xc8\xb7\xc0\x02\x91>\x91R-\xbb\xf8\xe7\xa3\xaf\xfcb\xc0\x1d\x95\xf1\xf1\xb0\x0b\'\xf9\xe4HJ\xf2\x14\x19\xf8Hf\xfc\xd8I\x03(\xebMoM\xac\\b"O\x1d\xf7\x17\xb68\x86\xf0\xcb\x9a7\x98\xc5\xc9\xb4\x9c\xbf\x04\xa94\x8e\xe4\xaa\xd3R_S\xa0(\r\xf1\xae\xb8S\xce\x1c2Ppd\x87\xea\xe7\xed\xd7\rF\xedC[\xa6\x02\xb7\x99\xeaS\xc2Z5\xae\xbc\xdc\xd7\x9c\x8f+f\xd2F\x0e\x03\xfd\xab\x9bqXHE\xb1\xcd\x92\x06{\x90\x9d\x08\x04\x01\x8cq\xafO\xfb\xab\x1e\x87\xcfp0\xd6\xe5\xad@\xdf~\x03\xf3\xfc\x82\xb4\xe6\xc5\x10\xc5d.\xf2\xe3\x01\x04Z\x8c\xf4\x06\x91\x00\x18\xc4\xda|B`\x88\xed\xce\xbdI\xcd`\xaf\xdf\xc8\xa8^\x03\xd8Ge\xe2\xf5\x9d\xfa\x0fx\xac\xa5\x8f\x18\x97\xd5f5\xc4\x0e\xf6\x8e\x0fW\xba9\xe6\x05\xe8j\x9c\xd3\xd3A\x99\xda\xd5O\xddm\xc1\xbe\xf89\xf8J\t\x8f\xf7V\xdf\xbca\x89\xed\x12\x98\'\x15Q\xe9`\xf6\x04j^\x0e\xe1\xf3+\xf8pT\x9b\xd1C\xb5{\x91\xaa5z\x93\r\x00\x02+\x82\xbe\xeccg\xd9\xb7\x9e\x13\x99\xbe\xf3Tp\xbe\xe8U\xcbE\xdb\rH(f\xf1\xdb\x81w\xb91\xc9\xc1\xc9\xf5-=Hm\xd1\x1b\x1c\x88+\x997M\xff\xe4\xe9.\xde\x9a\x05\xd6\x10\xe3\xa8h`\xe9\xa1\x0c-\xc3z\xf7\xc3,i\x08\x91E\x1eT\xe3\x15b\x7fk<\x0el\x1c\xc4\xb7<\x92\x8f\xf7~\xbc\xb9\xd0\xc3=\xed\xea#\xc5\x08\xa8\x1e\xc2D$\xbc\xa4/\x8bZ\xf7\x89\x80:\x1c\xcd\x10b\xbb>:\x00\x9e\x0f\x85Q\xeb\x90J2<\xddq(\x80\xfa\x9e\x14\xd3\xe0\xca\xd7gX\xd2\xceF\x01\xe1`|2[X\x0e%\xa8\x07x\xe9\xf5N3.M\xf7@x\x88\xeb\x8f\xa7\x81\xa5+m`\xbb\xf4\xf25>\xccl\x18-\x12\xee\xd4TVa\x15nLb[!\x99\x087\xee\xbb\xa0\xe9(h\xd2J\x99\xf2\xea\r\xf9\xfd\xbcg\xe66\xca\xa8\xcbk\xef\xfdICJ\xe9\xbf<\xfa\xf4\xb9\xa0\xcc\xe8\x89\xf9\x93\xac\xeaF\x96\xf6\xad\x96+\x12-_\x14\xf2\xab\xdcB\x05C\x04C\xfcB\x9f\xa5\xee\xdc\x00\x01\x8ai[l\x19(\xcf\xb2y\xa7\\\x12\x92f\x12n#\xce\xef:\xc2P,\x9e6\xe9G\x85Be0uM\xf9n|\x9b[b\x83U\xba\x07w^\xa7Q\xe3\xf0\xcc\xa3"\x84f2zk\x8f\xc2\xd4\xe3&\xd3\x8f\xdf!|Kg4\xe37\xab\x95\x00\x80\r\x08\xf6\x97t\xce\xb11\xe1\xeb\xfef\xc8\xcf\x9b\x9b\xe6At\r\'\x10IB\xf8A\x1dCU\xd7{[9\x14\x10h\n\xab^\x9a\xf0$}\x99\xd9/ch\xc6\xa7@\xf3d\x87\xae8\x97\xe1f\xd1m\xafQ\x9c-\x80-\x047\xfe\x18Z\x1c\x9a\x15U\xc03\xa927\xcf\x0eC\x0eF\x07\x93\x0fd:c\xf6\xad\x95\xf2l\xef\x9c\x1fjZ\xa1;\x94\x1dw\xd3\x85\xef\xbe\x1e3\xeeW\xb7@\xdfm>\xd2\xd4A\xac\xc7Ob\xea\xc3}\xda\xa7/\xfeS\x82\xc6|\x08\x0c\xa4\x9a\xad\xa5P\xf9\x99\xab1\xe1\x02\xec[(#\xc8U3YM\x1fE&\xec\xbe\xadD\x8d\x16\xac\x14;\xb8\xf0\x9e\xf6\x96q\x8f\x97]66n\xb5+L\xba\xbf\x9b`\x06{\xfa\x1b\x89\xad[\xf7\xf3\xe3\xf2]\xdbH\xb8\xfb\'\xac\t\x9es\x84+\xff\xea\x8d\x9c\xb8\x13S\x13\xfeA\xde\x13\xf5B\x18\r1)V\x8b\xe1v\xa4\xe6Mw\x8f\xd1\x8e)z\xbb0\xab\x91ogZ\xc9\x1e8+\x9e\xc1\x91_\'\x14|\xca\xac\x96\x859[\x19\xabf6Mp0\xadr\xde\xda\xc9\x9f\x9f}\xa1\x811\x8eq\x803\xa7\x99Z+\xd1Z\x9eb\xb4\xe9D"\xc4~\x14\xfe\xd8\x87C#\xcc\xdb\xaf`\x11zdQ\x8d\xf9\xdc\x19i\x97E\x0f\x93W\x81\'\xfe\x96+\x0e\xd9\xa2\xa6c\x13;:\x82\x9c\xf0YH\xeb\r\x91kH\x90\x18-S\'\x81\xfa\xcf+\xd8\ry\xdez\xc3\xac\xce\xc2\xeb\x02\x87`\xf2l\xfb\'\x9dr\x04Y\x85\x04\x14:B \x0e\xb4\x99)\x19\xb2O\x9b\xfa\xfd\xa64\xeb\xd5\xa8P\x00\x94\xf1Uh\xb995\xbf\xdfbZ5\x9b\xef\xab\x0c{w\x05\xefcc\x89$}\xac\xdb\xc4\xc4&\x1d\xed\xf1\x13G\x8f\xd8\r\x1d\xb1d\xa7w\xb6\xef\x8f\xc1m\x1cW\xa0Z\xb4#d\xbeS\xf5\xb5\x00?\xb08b\xfb\xcf\xd8\x9f\x0b\x8aW\x91\xe6Y\xab\x89th\xe5^l\xcd\xef.\xdf\xa0\xcd\xfa\x18\x89<\xa9\xe8\x98\xda\xa5\xee\x1e\x03U\xdd?{\xd4\xbd\xc4\xb7K\x1c\xc5\xc9\x11g\xdeG|\xc3h\'\xe4a\xf1/\xcd\xc0\xfc\x82c\xaf\x90\x08\xec\x1fE\xa6\xcd\xbe\x819\xc9\xa0\x13\x13\\\xbd\xdd\xfa\xdd\xc8\xfe\x8b\x07\xae\xae\xa5\xf7\xe7\xfb]\x87\x8c\x88\xcfB\x8em\xa3-\xd2\x96\xc0\xa7\xa0k\xc3<\xf2s\xe8/,\xdd}KU\xac\x98f\xe0{\xc8\x03\xbd\xe8\xfc\xd6\xa9\x1b\xa5\xc2\xef\xc8\x8d;u\x88V0b\xb2^\x05\x82\xc0eG\xb3\xb2|\x19N_D\x1dO\xbe\xf1\x10\xf9\xe4C^n\x18\x96\x9aFhl\xcfL\xa1\xce\xce~eD\xf4\x19X\xd0W`\x0b\xaf\x87\xaf\x1bO\xdao\xb3\xa5{"~\xee\xf0\xfa\xd3\x00\xabKg\xd5?n_\xf2\xb2-\x8b\xef/6\x13\x13\x17\x1e~\xa4v\xb1i?\x00\xd9\xbc\x080\xc2\xb6\xd4\xa4!\xa7\xec\x9e\xff\xa0\xa6\xff*" \x82\xe8\xce\x14\xd1\xd1#a\xd1\xbcA\xe7E\xd8Y\x11\x8e\x96\x17\xc4!\x9et|kM+R\x7f:9_G\x97\xf6\x14\x9c\xdc\x84\x9d\xcbi\xfc\x80#\xbe\x9c\x0c\x9b\x9f\xbc\xd3\x9718u\xc6u\x9f\x1c\xceH\x08L\xd5\x17\xaa\xc3\x80q\x8f9\x98\xf1)\xfeC\xd5\xf7\xe6\'\xa4\xf8\xb9\xa7_D\xbd\x05\xb5cpb\x8b\\MZ\x18\xb3~\x89\xe6A-\xbe\xc31G\xc8\xa9@v\xbb\xf3-T\x03\xbc\t\x9c\xa2\xf1\xccC\xc6\x08j\x1a\xd9\xfd\x84\x0b\xc9\xddZYSjM\x1c\xd3\xa2X\xbb[}\xf0\n\x08,\xbbz\x1eJ\xc7hP4\xe1\xcb\xc8&\xbf\x8c\xf1@\x02\xddf\xac\x1a\xbe\xfc\x01\to\xef\xeb\x13bo\x87\xb7?$\x98\\\xc4\t\xda\x03\xfc$\x7f@0\x92]\xd9\x0fGz\n_\xebs#\x06\xe2\xf1\xa6&l\xdb[J\xda\xa8\n\x06\xc4\xeb]g.K\xa2\xda\x8dR\x12O\x0c\xf6\x8d\x00\x7fo\xe9\x9d0\xeeU\xc1\x0b\rN\x1a\xbb\xc0_\x06Y\xfe\xb4\x84\x80\xd7\xa2\x965a\x0cD\xfe \xb7\x98\xa3\xab\xdea\xeb\xac\xbe]\x18r\xd1\xda\xc4\x8cP\x1e\x0f\xf9\xb2X\x1f\x94\x1a\x9e^\xf7\xbb\x83\\\xbe]\xffD\x96\xd8;\xd7\x04\x83\x84{\xec&\x89\xdc\x02;I\xd8\xe7\xd5\xe4TmY\x0f\n\x1b\xb5)T)\xafO\xab\xb7Y\xbf\xc7o\xe7\xd9Eg\x1d\xb9\xfd\x9f\x91\xadT\x83\xb9\x8d\x93W\x89\xfc\x11\xf8\xe7\x05q\xf9\x9e\xf8\xa2Hp_w\xccZ\xb7\xab\\G\xe2\x9c\xa7k\x06\x81\x81m\xech\xbbC\x01\xdd\xaft\xb5:M!l\xc4\xd7\xdfQ\xb9\xb7\xddz\xab=M\x8a@\x964\x95\x92\xe6\x8b\x0f\'\x1f\xb4)\x83\xe6(\xf7\x9f\xf7\x94@\xc1\xbc\x8f\xc0"+?|\xed\xec\xdb\x177t\xd7T\x07\xd4\xe2\x89*\xc6\x8f\xe3\xefp\x15b\x15\x13\x00\xf1\x7f\xf4Y\xef\x07q\xac\xfd"\x1f\xe7\x9f\xcdI\x05\x82\xac\xfb\xe5\xbev\xc5\xcaQ\x93i\\4]\xc8\x0e\xdc\xe4-\xd4V#\x8at\x1d\x19\x1anr\xf9\xbeRZ\xf5l\x1e\r\xfe\x94\xa7q\x14\xf0\x9c\xdf\xea\x0b\xa0\xc0\x8f`1\xa6\x10\x86\x9b\xcbRF\x84\x8b\xf6\xd3r\x15Y\xf6\xd3\x8e\xea\xce\xed\xc3\xa7A\xdf$\xc7\x02\x04C\xcdz\xb7\xe2\x05\xaf\x9a\xe2\x1d~\xd4\n\x0eI\xbc_\xbf\xaa\xef\xf9\x80h\x06".4w\\\xef\x07\x825\x0c\x95\xb4\xbc\xf5\xf6\xb5a\xbebZu\xec\xda>\xa1\t5\x8fI\xb04h\xdb5Z\x8c\xdd\xe8\xb8\xd3e\xda\x8d&~\x84\x18\x9c\x06\xd4\x06\\\xc1\x07\xe0\x96\xcb:$\xcb\x89\xfb\xbe*\x9d\xb1\xd6hH\x15 \x93\x8f\x84\xdb#W(\xe8\x114\xcb\xcd\xe0\x15F\x9b\xce\x13\'PK:\x1f\x8b\x08_\xbbLI\x96\x82\x92v\xcb\xb4\xb9\xf1\xf1\xfd\xcca\x03\xa5\x1f\x04\xc0\x9f\xdb\x88\xf8QFS\x04?j\xfa\x8e\xd4;\xe63\\g\xe0\x89$\x8f\xe5dGd\x02\xc6\x0c\x0b\x9a \xd7\xe4\xc1\xc5\xfbT\x82-\xc0>\'\xe0\x9cj\xadn\x04)\xeb\xf5\x8d\xef\x1ci\xcd\xa3{\xfb\x8dE$H\xfcJ\x18In\xed\x10\xef\x01\xe0r/\x15\x8dL\xe5\xcb\x88\xe2TH\x97\xbb\x08@\xda\x01@\xb2*@\xbb\xb8s\xf1\xecJb\xec\xa9\x7f}\xac`\xcd:I\x187=\x11pb\x9d\xa7\xf0\x9d-\xa1\x1e:\x12\xd05\x94\xb0z\x96\xa1\\\x1dTd\xc0\x10`\x18\x9eg\xaa\x81t\xd9\xda;\x7fV&L\xe5&\xed\xa9\xb0Q\x06\x18n\xd0\x1f\x04\x0eL8\xe8\x83\xf1 \xd2;s\x7fra\x1a\x90\xab\x98\xf2=\x9f\xa8\x16"\xd8\x1a\xc0J=c`\xc0f\x15xiO\xd9[$\x1ek\xe7\xab\xc3\xe07%\xa5q\xa8&\x95)\xc2\xd5i\xcf\x02]~Os\xbbX\xae\x89\xb9Zv\x86\xda\xe6\x01\xcb\x08\xd1\xb0\xc1\x92\x06\x7f\xdf\x16\xee\xda{\r\x93z\xfc*:\xa5\xe4\xa5\xc24\x9b$D_\xdc\xd3\xfbP\x11\xa1\x85\x1d\xfe\xd5\xa2\x85\x0f\x16\x8d\x94\xe2B\x8a\xcc\x97F\x81\xad\x8e\xd9 \x8a\xab(-+4aeB\xa2\x0e6ot\xce\xd8\xdb-\xe9\xbe\xbb\x99\x8f,\xeb\xd2\xc6\xb1V5\x18X\x89\xe2Y\xde\x96dH\xf4\x92\x17\x1b\x01\x07\'\x96\x9f\x17P\x9d\x8b\x86Q\xdc_W\xab\xbb\x1eE\x14\xc6nn\xa9^\x08\x06\xc6\xccW\'\xc5\x1b\x054\xdar\xe53q\x11,szY\xb0\xd4j\x91$e`\xad\x04\x08?Q`\xfe\xcd@\x8b\x97\x99\x13\xed\xebe*\x1b\x9b\x9f\r\x1b\x84\xe07B\xa49\xe0o\x19\xcfH\x07\xbc\xd7\xe1|\xc9\x12\x94\xa5v\xc6\x06\x86$\xf4\xf1)\xe7\x12\xed\xd7\x90\r\x06\xbfw\x08NS\x8b\x9c\xb2\xa4\x10\x9a\x928\xe6\xad\x9fWm\xbaUF\x8e1\xf3\x8c\xc4M\x05\xae\xc3\x88\xf8\x8a\xfc3Jpw{\x13\xad\xa7S\x83VI7.\xa2R\x1an\x10\xe7\x83L\xeb3O-\x02p\x8bu\xee\xd4"\xec2s&\xdfA\xad\xe1\x95h4\xbd\xb4.4\x8eU\x87\xd3"\xca\xf1;w\xa6\x89\xfa4@\xbe\x07s\x1a\x05\x1c{\xb20\xdc\xc5x\xe9\xc7J\x14U_[\xeb\x1a\x87\xaf\xdf|\x05,\xe2eGx\xf8l\xc9\xd3\x01Wt\x08\xcd\xed\x00\x0c\xa0@\x88#s\xf8J9\xef\xa4\xec\xab\x92[\xc4\xc5O\xa27Z\xc7\x7f\x8e*\x89\\\xd2\x9a\xc3\xdd\xdd\xfc\x8aSp\xda\x15T\x8eX\xfa\x9d \xc4\xe24\x00\x82\x00\\\xd0\x16B\xe2\x88\xc3\xd0\x95\x1a\xd7x>\x04uuX\x16\xa1\xedLq\xdf\xc3v\xc0\xd2k#\xc4D-\x03\xd1nE-\xb8\xe9\xc9\x9dkq&\xc8_B\xddy"vR\xbe\xfd\x9f\'\x00\x85\xff\x18\x98\x9f\x87\xacN3\xe3\x1b\xe3W;\xe9\xc9[\xc9\xf3\xf4\x1b9a\xa9\xec\x04\x95\x04\xa3$=\x19b-\x89\xc19\x8f8\x97U.(\x19*_\tWQ\xc5\x97\x9b\xe83\xd7Y\x020,s\xec3\n\xdb\xc8\xbf\x14\x93\x9f\x04r\xa0\x10\xb4\x9ew\xd3v\xeec\xb9{B\xdb\xec})7z\xe0\x97e\x1f\x9b(\xf9\x82p\x1a\xd0\xc3p\xa9Ig\xf0\xc6\x96\x9ax$\x8e\xa6\xe57!\x07x\xf8\xb8\xf8U\x96\xb2\xe5\xd0\xd0H\xecDDDly\x01e\x0f1z\xf3\xa1\xe5\x85:\x1c .\x11z\xcc\x1c\xdfCC\x1c\xde(\xa0\x19B\xfc#Q\xd3>$8i\xfd\xf8+\xc5"\xa6\nT\xf6\xc7\xf4\xd8\xd7*\xa5\x9e+(\xf9\xf0\xe4\xfc1\xdcKhq\xfd\xbbro\x98\xb9\xed?\xb3\xd1\x9b\xd5\xb8\xdd\xecC\xe7i\xcc\x1dfV8\x8e*\xd5sytp\xab3\x18\xa4\xf9\x80\xaaj\xaa\xdb0f\x15S\xa4\xca\xf1V\'}\x99"A\xc2\xc9\xe3\x8f\x9b\x0c\x86N\xde\x8aza9\x8b\xe4\x96-\xa3\xae[\xef\x1c2\x08\x13\xd1\xd2\xc0\xc2K\x19\xaf8\xd8X\xe5\xfdP#\xba&JJ?U\xfb\xf5hY\xb4\x11\xcf\x91g\xa3\xedn$DD\xb5\xfdy\x1a\x91\xca4\xc4WF!,A\xb4\xab\'d\xd3e\x9f\xfd\xc3\xc1\xd8\x17\xbb\xd3[2\xff\x84\xa9\x16SJb\xedV[*jQ\xc4d\x16Z@\xa97\xd6\x06\xd5/\xfaNj\xc1\x8b\xd5\xd7\'\xc0\x00x\x95o\x07\x8bN\xbf)\x13\x14\xbf\x16\x13dW6\x95\xce\xbffh\x02\xa4y\xc7\xaaF\x96\x8f\x97\xc6\xee\xf7fs\x0c\x8c\x08\xfe\xfa\xbev\x99\x9bl\x10%\xca\xc3\xf9\xa2+\xf3\xebnO\xbf\xa3R2\xe4\x9d\xb1\x95A\x10\x9f\xf9H\x86\xba\xe7\xa3G\xcc\\\xea\x1a\x1b\xfbe\xa2G\x1f\x15\x84y \xdd\xdf|]\x98pH\xff>\x12\x8b\xee\xc3\xd8\x89\xcb\t\x89\xe2\xc2\xdcw\x0e\xd4\xe6^\xc2\x0e#\xffJs\xae\xd1,\xd7\xf3\x18\xcd\xd3\x8d%\x98N3\\k{W \x19hq\xa7\x05\x03\x1a\x82\xc3\xe8\x8d\x11\xaf\xfd0\t\x9f\xab\x05\xbf\x92\x1ct\x80\xdbi\x82\x12\xbd~\xb0\xe7\x9f\xfe\xbb\xc42X\x12\xe2{\xa9\x11\xcf\xb5\xbd$\x9b\xb3\xd9]\xb6\x06\xcdE9\xed\xd2G\xe0\x0f\x07\xa2\xb4]1b \xf7\x1d\xc4\xe3v\xb6\xbc\xee49JX\xfe\x04\x97\x8a\x8c\xc4\xa6\xc8\x8b\x1fr\xfb-iHx\xb6\xe6\xd7\x0eX\x16P=\xd49\xffbL\x8f\x9f\x82X\x85\xc1^bk\xe3J\n\x85\xf7\t\x8cs\xf2p\x87^\xb7\xf1=\xd4\x90\x18\xa6\x98\xea}a\xda"\n\xf0\xc9$\xfa\x08\xae\xf3\xa5\n-$\xf5\x82-\x8b\xe4\x96\x0b\x12\xcd>\xd3\x99y\x0e\x9c\x99x\xfe\xe8\xfe\x1b \xa8}-\xa4\x8cA\xa9\x1eC\xad.\xbcES\x0b,\t.f\x1b\xf3`\xe8\xf6\x80\xa3\x14\xc5h\xe7\x0e\xebw\tVb\x05\xdc\x10\xb9S\x84\x0b\x1d\xf8V\xe3\xc5\x9e\x86k\x06F\x1d\x0c\x06\xf6\xb9\xc3\x14\x12~.\x92\xf2\x8b(\x7f\xf9g\xb3\xdct\x98\x14`\x96\xb3z\x06\x1a\x8eG\x03\x00\xc8(E\xf6\x90\x95\x1a%9[\xfd\x0b\xe9ha,\x07B-*gn\xf0\xe2\xfb\xe8\xe2\xf00?+\x19\xa0\xb0\x10\x8b\xff\xf3\xf3\x90\x8a\x0f\x06\x03z\xf5\x02)\x07{\xc9\xbfeS\x1a\xbc2<\x1b\xd6\xfd\xbc\x84]^\x1e9_\xd0\xb6[\x0eR\xf1\xc3\xd1N\xff\x06\xcf\x9es{\xabX\xae\x99\\\xee\x0c\x17L\xa1\xaeU\xfc\x18\x80\xbb\xe1\xe50\xd9\xbf\xb3=\x120\xf3\xa1\xb0\xd9\xfb\x91\xc3<*\x1f\xaa\x8d\x91i\xfbq\xad\xd6\x87\x1b\xb5)8\xd4\xe2?\xec\xa4A\xde$\x81\x87\x9a\xe7\xc5n\xec\xd6\xbd)\xcf}\xb1I.\xab\xcc\xf0L\x1ew\x9e,utw\x82\xb5(=\xf5\xfa\x16\x0bhK\xad \x84\x84]\x9b\xd9\xa4\xcc\xec\x0c\xb59*\xff\xa4\x01\x12\xc6_\xca\x00A9\xc2\xc3\xf61\xcc\x00~k\x08_\x16r,\xbe\x87Q r-\x027\xe4\xe6\xd54_\xdfJ\xe0F\x15E\xac\xcf~\xae\x16\x8a7iH\xe1\x99g5\xfbG\n\xc7s\xe8\xec6\x1b~N\x9a&\x86\xdfKn\x83\x86\x06*\xc8x\xf1\x82\x06\xcf\x98\xd7\x13\x11\x99\x12wW\x8d\x8b (\x1b\x9f\x08X\x88kwC\x96\x1b\xd3\xf2\n3\n\x8a\x1f\x16_K\xdd[s\xe0\x10\x07\xcdF\x1b\xe31\x07\xb1\x02\xa7\xef\x95\xef\xd14GD\x9d\xf1La\xca\x8eH}5\x14{\xaa\xc5j\x9e\x81\x9c2\xf9J\xf6=\x0c\xfb\x19\x15\xceHT\xae\x15\xe6)\xc8\xd8\xa5\x95Y\xe0\'\x1f\xa4U\x85\xc8\xe6F\xb8\xa4\x0fu\xa8M\xfc\xaaQ\xf9\x10\xcd\x06~(\xb8HC_/6#\xbeq\x8a\x0b\x81Es\xb4l\t2\x1e\xa6w\x1f$`\x01\x14o\xd2=\x84\x04\x02\xf4]K\xc49\xc45\xfauN\xc1\xe3W\xff\x84*\xc0\x023\xc4\xd3/\xdcC&N\x00x\xc7\x1d\xf0`+\xadk\xcd\xd2\n\x82\xfc\xc9\x05\xd0\xf9v\x96.\t\xb8n\xa3\x94\xf5\xf1q(\xe4\xb8e\xc7\xf7t=-\x12\xa8\x94\x0f\x9b\r\x80\x0c\xa1\x1a\xebR9\x80)AoGl\x85\x9a\x0e\x90\x8e\xadh\x7f\xce\t\x9e\x00\xddvx\xabZG\xab\xba-\xba\xf3\x11\x8f\xf2\xc9\xa7R0d>\xd90\xd2\x9e\xac\xb88\xfdxU\xe5\xf8\xc7\xd1I\x8c\xa3\'i\x0c-\x82\x1c5\xc1*\xcd\x02s\xfa\xd9\x07\xa8\xf1E\x1c\xc2p\r\x1aL\xf4\n\xf93\xb0\xbbY\xac\x19\x82\x1b\x01i\x9ex.u\xe4\xcd\xe3\xbai&\xe35\xd5ak\x18\x1d\x01\n8T\xf4\xc6J7\xf8V\x85\xb3T\xfb\x87/\x97\x87\x13jM\xcb!\xb0~i\xc1\x97E\xb6\xb4(Y7\x80\xca\x04\x10<\x9b\x1c\xeaW\xaa\xdd\xd6m\x01\\\x96\xb8gF\xa3Ha\x0c\xfd\x88i\x81\x0c5Eh\x9f\xdb\x88\xd63\xf7\xf6\xec(\xf6\xf4\x9fuE\xf1\x08\xb1\xb6\xa2\xa0mk\x8f\x80\x8e^\xf5\xf4\x0b\x13\xe9\x86\xd2\xd4\xc4\xcb\x1c\r\x96v-\x98\x80\r\xb7\x8bl\x14\xbd(\xbb3\x96\xbb\xa2\x0b\xf2\x1c\xc3\xf5\xb4C\xdd\x9e2\xa7\xfa\xbe\xc8\xb8O\xf1\xf9\x14C\xe8\x10O\n\x89\x99\x13\xf3\x16\xb2)\xae\xdeHm\x05\xd9\x90]FK\xa2y\xf6\xe0\xa3\xb4\x9a\njZ\xea\x87\xdbA\xad0\xfbm|\xe35\xad\x8e4\x8a2\xeb-\xc9yg\xe0\x13\xcb\xa3\xd2\xf4;i\x1d\xa8\xd3RR\x8d\x1f/\xa0\x88\x8cp\xc4\xf5<\x17\xca\xd1}\xfe\x14\xf3.\xc1p\xcd\xae\xe2\xb1p\x1c\xd5\xc5\xf3\x82\xb070\xc3\x14\x9aDu\x1c\x96\xbf\x8aY\xe8-\xe5\t\xe9\x05\xa7"\x9cv\'E7\xa5\x84g\xd1\x03\xdb\r\xcd\xa2\xf5\xea\xf5\x8f\xbcP+?\tl\x88\x90\x0e\xcc\xb7\xe5\x182\xb9\xc4\xe2\xcc\x12\x0f\xa5\xf7c\xb2X7\x897\xfc\xc9\xc0\xe1p\xe5^\xffp\x05\x0e%-\x89\x84\xebh\x85F\x0bFJo\x01\xcb@-\xa1\xb0\x80{9\xc7\xc9\xcc\xb2t\xa8\x84\xa4\xa1\xd4\xc7A\x06\x0c\x95\xb1\x96\x14 \xa0@\xe9\x80\xb5\xcf`\xd2?\xa0,E\xda\x13m\xce\xe0\xb7l\xd9\xfb\x8bZ\x02v\x8c\x0e\xfa\xbbc\x1d\x7f\xaf\xe3\xbeR\x06|\xe2\xc3\xbcP\xe0\x89\xe0\x992} \xdc\x1f\xdc\xafVF\x8d\xaehn\x14\xaa\xe3e\xd3(\xa6gwr\xd4\xb6C\xd28\x8a\xef\x8eV\xe02Xp{\xd8\xadq\xd8\x04\x16HB\x84\x8c\x88\xad\xd1|\x1f\xccX\xf5\x9b\x02\xc2\xdf/\xa2\xd70\xf8\x94\xd4\x88N\xbfkH\xa55C\x88\xbe\x8e>\xf6\xda\xa5b\x18\xb1.\x92w\xe9sd\x15\x12\x1d\xb40\xb2\x0f\x1b&\xf1#$\x97}\xe6~\x0eo\xc1\x05\xb2n{\x88,7J\xb8K\xfb|}\xf30\xe0O\xf9$\xc8\xde+7\t\x9e}\xf6gv2c\x9a\xa4\x1ay\xec\x12t\xe6\x84\xa0\xf2\xbc zb7\xc4\x89\xd6&\x8f\xef\xc9F\xd5\x8a\xa7\x8c\xbd;\x88\x8cn\xb9\xa7A\xc4\xf3wg2\x17X\xa9H\xf7\xfb7kTa\x14\xeaK\xb0\x1c,7\x8cR\xd8\x02\xdd*"\x8b\xd9tA\x026\xf4\xd0\x1b\xd6\xef\xa9v\x8db\x12\xea/\xd3_\x0f\xd3\xbf\x82\xfbJ\x00\xcc3q\xae\x84\xf9\xbb\x8es\x1a\xc7\xc5\x992f\x81\x96P\xf2v\xd8\xd4\xf8\xe3\x1f\xb5\x18\t\xc6\xc5M)2\xb5\xa4\xd7\xe8i\\\x0c\xe4\xc5\x95\xc1!\xbe\xdf\xa0\xf3.\xb8\xfa\x7ff\x8b\xacY\xef\xe1\x94\r\xce)|\xd8\xaf[\xd8\x90\x02\xd1\xa6\xd9`\xc2\xc5z\x9an\x1b{\xfa-G\x9dM\xd0\xb7\xeah\x02}k6\x9d\x07\xffJ\xbb\xe8\xd6\xb5\x0c\xfe+\x94\\\xbe\xacT\x87{\xf3\xe4\x9ag-\xbbs\xe6\xc3\x18u\x0fg\x89+\x94t\x0e\xd9s\xbd\x0e\xech\xe3b\xa0\xdf\xa8\xa0\xcc\xc9\xdd$\xac\xc6&\xe0\x1e\xfaY\x8fL?{\xf5\xb6\x064n\x9e\xa6\xb1\xb2f\xc5\xac1\xca\xa79\xden\xeb\xefz\xabV7}\xbb\xa8{\x9e\x19\xa9\xd8R\x0f\xd1G\xf6\xfe\xa8\xc2\xd6\x050X\xdaj\xb8IJ\xcd\x1c\x14D \xbf_\xda\xba\xbdL\x9e"\xb9\x0e`\xc134\xfd\xeeV\xc7\xfa\xd3-/\xa5^zA@ \x02v\xa3.C\xcb\xf4\xcf\xb8U\xa7\xff\xf2\xe5\xc2\x9f\xd6\t\x17\x0b\x81\x7f\xb3\x9d\xec#\xfe\xc5\x9f^\xbf\x8eHB\xb607\xa6\xc7D\x11\xdb>I%\xcb\x1a[>S\x8a\xc4\x8a@\x8c\x87\x92c\x03\x1ai*\xde\xef\x86Tf\x82\x186F+|\x97Fu\x80\x98\x17{\\\xc3H\x1e~\x00`\xa8#\x84b\xa6\x95\x9d}\x98fs\x86\x0bS\xcf\x8b\xc3S^\x04r\xf6\'Z\xb1\tG\xa8\x1e\xc7\xd4V\xce\xd8\x98\x83\x10\xb7^\xcd\x05&\xdf\x90\xcf\xf3\xc1\x8b\x80\x8c\xa2\xf4y.\xecM\x90\xc0\xa8\xec\xd0\x90<\xde\xb3Z\x93\xdbX\xf5\\\xf1l\xd4\xe5nfB\xf7D\x8c0\x9f\xbdx\x98\x81e\x9aQ\xdc\xcf\x18\xb7\xac\x8cI\xf4N\xc0\x0b\xedQh\t\x82\xe0M\x1by\x9c\x07\rj\xa0\xebO\xa7\xdf\x0f\xd9\x7f\xc1\x8b\xba\xb9\xe9%\xc5dU|\x98\xf4\x11\'w\xd1\xc5D\xdb\xc0\x1fR";\xf6\x17\xb9\x1a\xef\x0bh\xa9\x80\xd6.\xb3\xbaO\x88\xe8]\xd1\x90"<\x1f>\xda\xee\xb0tm\xeaY\\\xc8(\xa7\xa5\x93MA\xa7\xf1\xa8u\x8bh0b\xbc$\xa2\xbd`r\xeb\x0c\xfe\xd0\xec0\xe9\xc5t\x13\xdc\xa3\x1d\x1a]\xd5D\x16\x12\xb4\nW\xc4+\xbb\x89|\xb3\xc3\xb4\x10\xbcP\xe3`?S>\xd9\xbb\x00\xcd\xfa7\xf6\xf5\xc4\x80L\xdb\xa7k\xd8\x84\xb2/\xb2\x15\xd4\x1fn\xcd}\xd0\x91#\x19eH\xad\x9a|\xd7Ctz|\xf1EP\xcc\x19 \x01\xd7\x02\x94i\x15\x07bO\x15\xba\xec\x8d\x1d\x1a\x11\x87\xb0\x89\x86\xb7\x18\xd4\xea\xbe\x9a]\xa0\x1f\xe4\xf0X8\x19\xc6N\xe9\x7f\xa5o\xadfT\xf8{\x90\xc1;#\x1fg\xb6\xdf`\xe3s\xe4\xc0Y\xbb\x9a\xba\xd7&\xb1\xa8.\xd7^f4\xdd\x08v<9\xfdD-\xbe\xb18\x91\xe9h\xdf\xd2\x08L\xf4\nW\xe6\x17\xfa\xc62\x97\xa6\x03\xb7E\xaa\xea\x98\x11\x00<\xaa\t2\xebb\x0cS\x90~mA\x0cIs&\x1d\xf2.\xba9\xa6h\x876BX\x1d\xd85i[\xbc]\x86q\xb0\xbb\xb4\xcf#\\q+)q\x89\xb6\xde\x8d\xf4m\xc2\xbdw\x9bA\xc58D\tm\x05\x08=0\xc0\xf4\xbd\x80C\xc1\xa7e\xbe\x7f\rh\xbb\xbf\x0e\xf9\xca\xfc\xc3\xe2\xee\xfez\xb8\x83\x98\xb4>\xf4\xae&\xf9\x87\xf3\x99Q\x12\x07\xbd\x7fy1z\x9d\x0e\xf5\xc8\x17\x14\xccC\xb6\xee\xbb\x90i\x9dS\x10\xa7\xb2^Eg\xacSL\xe0\x81\xb4\x1c\x84\xfe\xa4\xe3>\x9d\x84\x06\xd0l\x96\xaf\x85\xb92K\xf1\'\xbd\xad\xaf\xe7\x0cc\xac\x97f\x94&V\xd2\xed\xfd\xf8\xa5\xb3oEJ5\xd3\xa1\xe4\xfbYF\x86\xc74+n\x0e\xa3\xaa\xbd\xdeG.X\xd2f\xb9\xb9\xcd\xb8H\x97W\n\x8a\xe3\xb2|\xae\x86^M\xaf~E\xb5[5q\x87\xfd\xdfR^\xd7\x15\x8c\xe4\x1f\xa1\xb9\xec5\xe4\x0c\xcd\x10\xf1?\xc8\xf8\x85&\x03\x86G\xf5\x9c\xe0\xf95\xc9\x8d\x96\xbc\xc8\x97u^\x1b\x13\xd15\xde[\xaa\x8c\x9b5\xfayv\x98NP|\x95g\xbd\xa7e\x81\x89\xe8{uW\xc2\xf2\xc0\x19\xa79\xd5\xbc_\tQ\x0f\x87\xb2\x10\xf1\x88\x88\xb7\xb1\x8dh\xe0\x07\xd7l\xcb\x1a\xe5\xcf2v3\xe1\x86`L\xdb\x92\xf3\x18\xfe4\xc9\xb0M\x7f\xd90\xbf\xe1.\xd1\xbeGR\x7f\xda5\'\x9blM\x82\xc9\x92\x87\xa9\xcc`\xca\xfd\xa9\xae\x83C\x05G\xeeP\xc8\xd17\xae\xab\xb4\x91\xc7|\xd0o\xa6\x93R\x16\x12Q\xeb\r\x0b\x94@\xbd\x96\xb6\x86\n\x87\x85\xcd\x00\xca\xa2ypY%+ZWp\xf82t\xe68\xc1E\'@\x9f\xb7\xc3K\xe1he\xc8\xa4\xac\xe1\xdc\x83\xf7u\xf3\\\x11QW\x80\xf4\xa8I\xcf(`\xcc\x04\xb8[\x94\xc0^j\xa7}\xdc9\x91\x07\x0f\x83\xff\xba\xa7\x05\x0e;[T\xf6Wt\xddjd\x84\x0c\xb8\x84\xc5\x7f[+,W4\xd6\xc5\x97\x0f\x0f~Eo\x88\x83\x19\x08\x05R!\x06\xbc:\x9d\x98\x16\'\xae\xf7\xaao\xea\x8b\xb5\nq.\xbf\x01\x02;\x85\xa5\xdcD\x99\xcf\xa4\xf8\x06\xc1\td\x7f\xa0\x9d\xb2U\x10\xb7\xbb\xf2Y7"\xb7\xa68b\xce\xbb\x04A\xfd\x00\xa3\x86\xe8\xa2@Q\x06\xfe\xf3z\xeb\xba\xde/\t\xa5\xac\xa3\xa8\xbf\x08\xb2\xfd\x9d\x06\x03\xc4\xaa\x1e\xcf\xb3\'UgM\xf2\x81\xfdm\xde\x17\x88\xed\xdfx\xe3\x0f\xc8\x1d\x18\xfc\xb3\xc5\xd5v\xf7\x0b\x8fQX\xc1\xc9(y+ ;U\xe4\xd7d\xb9*\xfdc\x1c\xb3M\xa0\x1d\xcd\xdb\xebE\xc2z\xba%F\xce\x8cHOTG\x01\x84\xf7.Ws\\G\xa9\xe0J\xd1\x88\x17\x8e\xa0\xf0G\xc72\xa4F\xd1\x02K\xdb\xf4\xc2\xdc\x8a\xbaAs\xa9*=\xfd\xb2\xda\x97\xb2^\xf4\x8cm)\xfe\xe0\xe7\xad/]k\xdb|[Z\xf4\x96\x96\xf6p5bp\x92t\xecu\x8f\xdb\xacr|9\xeb\xcf9\xcbL_\x1f\x82\xe5\xb3\xcd\x14\xb7\x07\x8b\xbdn\x9e\xb2\xfd-in\x835>/\xff\x1e\xee@W\x00\xda7\t\x8elG\xae\xef\xe08\x80\xa3\xdd/\x8c\xdd\x17~\xc6\x10\xbb\xf9\x06+XT\xfeX++\xc3\xcd\xa9\x8d)\xc9[\xf0\xe5+\xc11\x14\x99\xea\x9e\x8e\xdb\xa6$\xe3\x7f?\xc2\xac>i\x89E\xf1\x02D\x99\x0e>\xad>\xd6\xb9\xc7"\x1cCk\xc8C\x15G}\xc7\xcc\x88\xe4i\x89\x16\xc6l\xd0xb\x0eVs\xb6\xfc\xd0\x8dp\xa2B\xc9Y\xd4V\x84\x87\'-\x04\xbb\xed/]\xa6\x14\x13g`\x19\x05\x801\xc05\xac\xbe\x9f\xc6S\x82\x03J\xc3\xc3\xf6mG\n\xcf\x10Aa[\xaews\xf3\xa9\xba\x84\xe4z\x1b\x00\x1c\x9dGG3je\x14\xd9vO\x0f\xb2\x93\x84a\xa7\xe4P\x0bt\x8b\x06\xee-\xbcT\xc8O\xaaX\xfd\n\x1b\xe6SD\xa0\x9d(\xf4\x9b`\x08A\xbd\xda\xad\xc5w=\x0c\xb7\xc8\xf2\xb7x~V4l\xa9Q;\'\xea\x7f\xc5J\x0eV\xed\x03\xd0c\xcf\x81\xc89\xf8|ul\x14k\xcb\x94\xf1\xabB\xdbZ}\xba\r\x9a\xdb\xa7\xc7\x85\xdf{`\x9d$\x8f\xf9\xac\xcb\x89\xa0-\x1b|F(\xe0\xd4\xe1\xca\x97\x12\xe9\x99\xaa\xe92\xa5l;\x01\xe9\xf1\xca\x01m\xc7Y\x9b\x9e\xba\x83\x8b\x059\xdf\x1b\x890F\x8fo\xcc#\xee\xed\xf4\x89\xc8\xa1\x1a\x08\x9ae\xc3\x1fj\xaf\rD\x94\x87n\x98\xec}CV\x9f\xb0\x14\x9e\x86\x98\x0f\x85\xa3v":\x92\xbe\xa9\xec\x17\x83)(\xa1h\x89\xf1\xcc},\x133\xbd\x12\xcf\x06\xc6xw\x17\xe5\xa7A\x94\t\xcaZ\xdb\x12\xdd\xf8\xda`,\xe4^\xe9\x08p\xd0\xa6J\x87\xa48\x0b\x01\xee9\xa4\xc2\x12\x80\x1b\xb4\xce\r\xe2\x95k\x8c?\x19\xb2\xeeH\xf2\x1fr\x88\xb7i\xd2\xa4\x9b(\xd4\xc3v,\xa54\x84\x18\xf6~Q\xf4\xcb\x81?\x19\xc1\x1c\xadv=2\xdb\xb3\x9djw\xc6rl\xf1\xb6\x06b\x94\xe0\x17\x04y_\xf1v\x8e\x9d\rS\xdb\xe7\xa9\xac\xfd\x88\x9b\xeaJ"8t\x978\xb3\x80\xac\xbb\xe6\x1a\xb0\x1f\xe8$\x1f{\x97\x0c\xe9*o\x02O!\xa0\xb4\xa6\xb9\xa3\x95\xad\x85\x93H\x10\xdf*\xe2\xf2\xd2M\x10?Vq\xa7\xca\xb1\xc5T ef\xc7eL\xa32\xda\x9exo\x04c\xdcF\xf4\x15\x13\xfc\xa0R\x91A\xa6td\xb5\x12\t\x92\xa4\x80#\xe8\xdfXn/:\x1a\x03V\xb5^\xa7\x823\xd6\xb8\x8d5\xcf\x90\xd3\xc6[.I\xbf\x1f*\x11)\x8a41Q\x18\x1e\x16\xc5\xde\xab\t\xdd\xf9\x18\xe7\xf6mA\xa1Tdb\xa2\xaa\xf2\xbf\xe0\x7f\x16ID\xefb|p0\x93.\x0ez\x89\xd7p\x95z0\x8a\xe3\xba\xa6\xacT1Z\x00:\xd1\xf9\xaeWmDa\x0e-G\xfaO\x12\xe5\xcc\x0e\x97\x03\x02\xb1\x03F\xccR0\xc25\xae=\x93=kr\xb9.\x93%5\xf5\xabt\xa4\x15\xe6\xa5\x97\x00\xb8E*zW\xfa {\xe7Z@k\xc2W\xbc\x88\xc6l\x9e)L1V%1\xae\xa5\xa7\x7fa\xe90\xdb\xa1\xe5D \xd5B\xac&\xe0\x07\xe6ao\x14]4U\xb1w;\xdd\xe5\xfb\xa6\x19\xe3\xf3g\xd2\x0c_\xf9y\x07$\x1c\x97o{U\x1f\xb4\xf6\xf6s\xb5\xc7jX\x16sR\x02k\xe9\'O\xe5e&r7:\xc5\xe1\n\x83\x00\x15VMX`\'"6\x85\xf7\x1f1W\x8d\xfec\xa5\x9eYzh9\x88Df\xa9\xa0\x9bwI\xbb\xa7d\xf9\xaao\x8c\x97y\xfco\x1c\xbd\xc8\xe1\x00\x8dX\xbeg\x11\x17\xbb\xff\x96\xc4\xccw\x04!")c\x8f\x94\x14;^\x16\xc8)\xaa\x96r\xaf.\xe7V\x82 \xd8\xf3Zz\xad\x0fS^r\xe2e\x97\xb9\xe9c\x12\xe6\n\xd3\xb6uS\xfe\x8a\x8d\xda]\xc8\\\xb5\xc9\xb4-\xfd\r\x8c\x07v[\xc9>\xa7Z\x01\xb81\xaa\xd0\x16as\xeb\xdd\xa5\xee\xf4\xe66\xd5F\t\xb2\xdb\x00\xfe!\\g\x07#\x1cE\x8aeR\xec\xfc\xf2\xd20\xed\x82\xb6\xd1\r\xd2\xf9A\x01\xee\xf5QTC\xb2\xb3}.\x06\xf9#\x91L\t\x1c/a\xf6X\xef\xd7\x1b\xf5\x00\xc2*6\xcb-F\x83\xcfb\x96\x0fv\xde\xb9\xe8b\xd7yo_{#\xf7\x19\xd7\x9c\xc6\xba\xd0\xfa\xe1\xb4O\xedHu\xcf\x81p\xc0\xfaZ\xf1R\\\xb0\xbc\xaePu\x08p@\xa5D\xaa\xa0d>\x97uBS.\x03\x84\xb1\x91\x01:\xc2\xff\\\xc7?\xf2\x19\xb2\xbfZ\xc5\xe3\xacE\xf1f[\x0e7`3\x94\xe9\x97\x9b\xdd\xd0\xcf\xd1\xf2\xc3\xacAs\x1d=az\xbe\xeb#<\x07\xafv\x04\x98\xf5a\x17\xce\xb9Q<\xad\xf5\xe2\xe1\x08\xc0K\xeeg-\x1e`A!\x13K\x9e\xf4\x1c\xec\xa9\x95\'K\x91\xe1\x95\x14\xd8<\xcf\xba\\\x14%\xd5\xbe\x94R\x0b\xf5c[`(X\x86)\xb7\x98\xd4\xe9\x93w\x0e=\xe2\xe9\xefi\xcd\xb0\xb2\x97\xfc\x95\xdf\x88VX\'\x8f\x02\xc7S\x12\xfdZ\x0b\x90\xa3?\xe3\xd3\x9f;\x10$(6\x1a9~\x8d\x8c^\xd1\xbf\xd4C\x0c\x9e\xb5\xd3+)(%6\xbf.\xdf\xdb/\x10\xb6~\xe8\x84&[U.\t\xd7\x8c\n\xb3\xebF\xff_O\xc83\x19.\x0e\xc4\xe9\x8b\x86\xd3\x14g\xac\xfe\x85`\xb7\xeflc1`6\xeb7\x14\x88\xbc\xb4\xd6V\xe8\xb2\xecsi>\xbf\xbc\xc8r\xc0\xed\xcb\xd1\x85\xdd9\x8f\x85>\x82\xe5~2\xa9\xde\'uP\xccQJCS\x11\x1b.o\xe3:Cl#\x08\xee\xd6\x89H\x0f\xae\xd7}\x03\xa85\x86\x95\xf3ZJ\xeaj\xadu)\x8fqb\x13\x1d\xd4\xdb`%\xa6\xc8\x9eE\n\xa0B\x98\xc0\xa5\xdaR\x9f\x82\xd4PY\x16\xd0\xf8\xad\x1a\x7f\xf0\xc7G\xf9\x84he\niD\xa2nE\x92\xd8\xedE\x92I-\xa8\x98\xae\x1a\xbf4(\xeb\xfd\xb2\xa7\xac\xfa\xb35r\xde)\x07\x0f2\xb1\xe1(\xdd7\x0e\xa6&\xe8\x9c\x99\xefcp\x16$d\xc3T\x10\xa0+\xcd\x0f\x91\x8f)7\xc5\x89\xf8\x9a\x84m\xe4b\xe1\xd9\xb8_\xb7\x89\xa6Y\'HR\x85\xeb\x02\x04\x8bp\xf0\xad\nCdtCG\x9b\x93\'\xc0\xe9\xbf$J\x07^\rz\xcb\xb3#L\xe4\xc7\xcb\x04\x83U\xde\xb5\x86\xd6\x9c\x93\x94F\x1a.\x1c\xf77\x93\xdf(9&&\xf3W\xa6 \xcc0h \xf9\xcf\x03\x8a\xb3\xbc\x91C\x0e9&\xf3M\x114/\x0f\xaf\xcf\x9e\xe4\xfe)\x1e\x10\xe3\x0c#\x8d\xf7\x0b*9?\xaabY\xc5\xd3\xf7\xec|\xbe\xed\xbea[\xad\xa8\x92H\x18\\\x9fk\x97o\xaa\xd2\xd0\x85p\xf0\xdcIKW\xf9\xb7\',\xfd\x97;\x9c\x1d\xe6\xe9V\xf4\x85\xc9\x1e0\xa7\x0e7\x9e\xdcT\x08 \xb9G\n\xf0\xe5\xae\xe8\xeae\xe0\xe8\x7fj\xa7\xd3.\x87\x89\xc3\x17F\x81f/\x1d(\x9dJ\xdf@}C?\x0f\x1f\xb1kq\x87A\x02\xb1Km\xb5\xaa/"\x96\xa38\x84\xd0\xe2\xcb:3 "Q\r\xb3l\x94\x87y\xb5[\x19\xbf\x1dL\xc1\xee\\tA\x94K\x1b\x9d\xf6\x85\xc8\x9b,\x91\xfc\x13\xf8\x80\xbf-\x06:\xac\'l\xd2\x94H\x82\xbf8\x0b\xddk\xed\xbe\x9d\xb0\xe3]KS\x1f\x15\x01r\xfeR\xd8\x1cP\x9e\x16Ny\x9f\xb8\n\xbc>\xef\xe4\x8dxc\xcff\xfe\x8fU\x82\x92\xe2O\x93\x80\xfeu\xc6\xe7~\x8c\x0c7\xb5\xbev\x1d\xda,\x18\xb3\x83\xed\x96\xdet\xbc\x84\xae^\x82\xca\xf41^x\xc9G\xf4\x86N\xdf0\xc7\xc8\x8f\xb7\xedu"\xa1\xe8\xbcL\x9e.\x03w\xa3\xf7K\xc1\x93\xb23i*\xc2\x90r\x0c\x85\xed\t&\xeb*\xce\xad\xc9.\x83\x07\x8fH\xc2T\x99t\x89\x01:-\xd8\xf1\xcf\x85\x01\xde,B9\x14\xc0$\xc7\xc5\xc2M\x11C\' \x8a:\xeb)\x83\xceY\xf5\x04\xb3\\\xf1\xd5gT\xb1\x90p\xccc\xa8L\xc8I.\xd7\x02?\xb9j\xad}!#\xfa\'\x07Ks6\xa2\x92\xe0\xc4\xa2\xfc\xfe\x89\x87^<%\x94\xce\x91\xd5\xc6\xc5/\xc0\x89v\x98\x04Q\x13B\x192\xea0L\xd88\\\x0c\x8bd*\xf5\xe6P?b&\xb2\xa7\xf5QH\x03\xe5\xa8%\xff<\x14l\x877Q2\xcb\x90Ck*\x1c\xbdb#\xaf\xdf\x98\x18eB}"#uQ\xf2\x07\x05\x1f\xd7+\xb9X\xf1\x130+\xedq\x92\xae\xc0\x1d]w\x89;\xc9j{E\\\x97\\\x1e\xf8\x8fu26\xf80[n\xc5_F\x05\xae\xe3w\xe0O\xd6\x12\x80\xe1h\x8e\xa7%\xe9\xbc\x8b\xbb\xcc\x01\xe3P\xda\x08\xa4\xae\xcf\x15.@\xec\xda\xa4\x9cS\xe7\\\xa7I\xe1\x8ft\xe1l\x90\xbaR2\x04H\xa3\x00\xbd\xb8\xe2K\xdd\xe39\xff\xc2{~\xd9\x8c\x1fmc\x0e\x9e\xc2\xd3\x00%\x8duY\xa2\xe9, \x988>\xf6\xd2\xb4\xf9\xd1\x8d.\xe9\xe3\x1d\n\xcf\x86\xd3\x97\x90n\xc1\x89t\xfc\xc2WO\x03c"\x0e.&\xea\xdeX\xddS\xe8r\xfd\\eA\x1cA\xeb/\xb1\x92\x0b\x95i\x88\x19T0\x12<\x0cz\x87#\x9e}/\xe6\xd8\x83tS\x8d\xe4Q\x8f{\xbf\x94L`^K\xbd\x1b\xdc\x19hP?\x8b\'\xef\x04\x991 o\x9f\xae\x8b\xef\xb6\xe9\xf8#j\xcbn\x8b\xf3#\xd3\x0e\xea\xac\xe6l\x9a\xd1g\x1e:\x89\x8f\x92\xcc\x98\x18Z\xee8A3\xb3j09)\xa3\xe8\xb2\x17\xdc\xb43wyOJ\x8au\x90Y\xd4U-Rn\x9cS\xa5S\x1b\xb3\xf8\x8dw\xed\xc3\x9f<\xe0\xeb\xbf\xe7\xc3!E2\xa8\xd1\xbb%\xd1J\x81*g\xf5\x89\x02,h\xb4\xb0\xb9\x13\xb9\xb5\xfe|\xcf\xe6\xba\xcb\xa2\xc3q\xd3e]\x92\xf2\xc38\x88^+F\xdd\xda\x80\xe1\xda\xca\xaa\xcc\xbf\xd9\x93G\xb9\xc5\x00\x9f\x15;P\x10\x1d2\x04\xd3v\xb9\xe6m\xa6+D\x82\xf7\x8a\xc4\x1b\xde1C\x18\x05m\xebO\x01\x0b8V3\x0e\xf4\x8bKx\x18\xb9\xfe\x8b\xcb\x08<\xae|\x07\xd8R\x8f\xb0\xc4Jx)\xad\xa52\x0c\xcf\xab\xa2)\xbd\xa0\xa9f\xb1\xfb\x08$\xf0n|\x83\xabKJr\x88\x16\xc5\xd0Wh=\x04\xc0\xc7o\xa0GjY\xe4\xaac\x11\xd7\x16\xa2\x0f\xf0|\xc9\x84\x86\t\xcb\x86O\x924\x08\xf9\x11\x9e\xaf\xbfi\r\xf5og\xe3pDrLY\xa5\x90Kk\x19Q\xa0\x99W*GI\xe7\x827@-\x81\xc9e\x1eK\x15\x8b4V\x1d\x93\xdf\x96r\xdc;=\xd9n\xd1IhW\xcb\xde\xack\xa9!\n\xb4\x996\x01\xff\xa6r\x19\x1d\xee\xc3\xe4p\xde.hb\x94[q\xb5\xc6\x19\r\x815\x18\xc7\xb2\x1fr\x95\xaa*\xc7\xaa)\xfa\xdb\x8d#Y0\xc8\xebD\x97\xf5\xe9\x91\x94C\xdde?\xd8\xd0\xf5\tg\xbb\x8e\x073q\x08\xf3\xd2N\xd8/\xcc\x9c\xad\xf6lx\xefSg\x0c\xfe#\xa9\x06,\x94\x81\xe4\xc1\\\xdf\xcfx\xfdQh\x1e\xc2_\'\xbb\x12\xe5\xba\xd3\xbb\xff\xcb\x91\xc2mw\xe4\xf1\xc9\xd2(\xd9\xa94t\x92\x8d[a0\xa5\x1f\x94\x91-\xaf\xa0t}rT\x16T\xc3\r\xbd \x89\x89\xa0\xa2\xdfZ\xa7\xa7\x8f\xcb\xcaLq\x8a\x01M\xd6q\x0c*bw\xe0\xf3?\xe6\xdd\xdf\xaf\x17\\\x05\xa6^\xfbi\x0e9\xf0[\xf7`[\xf4\xd6l\xb8Wmd\x92,8!\x92V{8>\xacX^\x04\xac \xdf\xdbM\xf6\x9f\xc7\xa4\xf8\x05\xee.\x9b~\xb7o.\x9e\xe8\x92\x1d\\G[\x84e\t\xd1D\xd4\n\x80`\x98dj\x05s\x84}\xf9\xae\x8b=4\xaaK~I\x8ew\xce%\xff0_t\x1f\x19$\x08\x9a\xf7\xda\xf2\xdd\x9b\x7f\x96\xa2\x89\xa7\xe9\x05\x89\xab\xef\xd8\x95\xa1\xe2\xbc4\xe2\x07\xeb\x97\x95^\xea\nd+\x9f\xeaM\xfa\xcc\xb4\xf4R4*>\xfe\xcel~o"B]\xba+\x0e\x9ctC\xac\x918\xe5\xc2\xcd\x02T\xa6#+\x87t)nu\xb4\xad\x1d1\x87\x12\xfdJ\x8b\xde\n\xd8\xbb}A\xd1\xe3\x18\xcb\xbc\xffK\xdbz\xf6\xa8\x99\x1e\xbf\xe9\x12N\x19\xd3\xb2\x01\x8fv\x1d(\xc7g\x89\xc4&\xd8\x9c$\xad\xdb\xd2\xad\xf6 \xfa\xb0\x1aB\x87\xfa\x07$MF\xda\xbf9\x81\xdbL\x1fz\xd3d\t\xb6v\xac\xe9\xc5I\x1b\xa7\xf0\x1d\xd9t^X\xb8M/\xcca0\xb3\'\xb9\xa6\x8d\x8f#\x10\xe6\xae\xe7\xcb!\xd1\xae\x8b\xf2m!\x8b\xb4b\xe8\x19\nu\x1e\xf4\x08t\x9aO\xee\xd1Ac\xf1\xd0\x13\xd9b\xf7\n\xb4\xe1\x82\xa9\x8b\xf7\xd7f\xe8@\x8a\x91<\x0e`\x0e\x9d\x12\x17\xf8\xfc\xf4\xf4\xf5<\x1c\xac\x1a\x9fq\xe9\x93\rpbXk\xd9;\xbcO\x83C\xc2\x95\x9a\x9a\xa5\xf3O]\xbe\xe8\xd7\xc5\xcf\xaf\xe9\xcaP\xdb\xcc\x9d\x08^?\xaeDiC\xc0>X\xbd\x84%?x\x92\xd0XR\x9f4\xf7\x006k>\xc5\xea\xa0d\x7f \x1d\x8b\xac78\r+\x07\xd9\xfe{7\x82\xd4\xd9\xc3\x06\xda\r\x0f<\xd2\x86\x06\xa0\xc4\xb8\xb2{\xee\xad\x85\xd0\x93\xba"W\xa7\x15\xad\x93\x1c\x03"`\xd1\x19\xed\xa7\xe2\xb3>L\xba\x92\xe8\xb4=M\xeb\x85\xacf\xfalu\xa2\x00\xd0\xd1\x1e\x91\x1aO\xe2\xa6\xd3\x05\x81\xad\xdbhFa\rWsA6t\xb5\x19JXB$\x99\x0c\xf3\x9f\x8e\x10P\xbd_\xd9~X\x06\xc7W\x7f\x9c\xe6`\x1dZ\xd2\\$\xfe2\xf8G\xca}n\xce\xdd.\xbfi\xf6^\x8b\xa3\x06\xcbp\xbaq\x95 \xc9\x94j\xa6\xc19\x16 \xfc<\x1aL\xad\x07q\xbf$\xd0\xdeL\r\xf3\xe4\xd4ub\x07\xc1\x97?\x8c\xef\xf0\xce\xc3\x8b\x0c\x1cC/\xac\xda\xfe\xe4x!X-\xe2\xaepyE\x1a\x14d\xb6\xbfo\xebB\xf4\x1a\xcc}\xa9\xc5Dp\x02\xdf2\xc8?\xb6D\xe2cZ\xcd\x14\xfd\x00\x03g\x82\x1c>I\x93\r\x963p\xac b\xc0\xa0x\x85\x80-\xde\xcd\x1b\r\'.\x92\rU\x1fW\x00\xa3\xc4\xb1s\x1d\x85\x9e\xa3y\x81\xfcc\xeb3<9\xb0\x9b\x90\xb62(!\x00\x82\xb6\xb8\xf1N*\x7f\x0f\x07:\x99\x95"\x9d\xa0\xda\xcb\x82\x1a\xb3f\xa9G\xa8\xb7e\x1d\x91\x83\x00\xb9\xe2\xacr\t\x00\xd7h\xea\xc0\xca\xe6]\x88\xc3\xb3\x9e\x95I`\x19\xec\xba\x18\xa2\xf8\xb3\xc5d\xbf\xe9\n\xe7\x12h\t\xe6q\xc8\x07\xd5\xc3\x07\x94Q\x00N2\xaa\xe8\x18\xc0\xde\xc4P\xaf`s!\x07\x03\xde\xee\xe9\x03\xc9\xee\xc7\xb1\x04~\x03\xa4\x92\xc8H\x18\xd1\xb9\x83\x1b\x04b\xe5\x12\xa6\xc1\xb1\x94\xc0\xfe\x0bb\xadY\x8f\xb0I\x14\xde\xe4\xedb\x85\xfaA\x9b=\xdc\xed2\xe6d\x89B\xa5\x9e\xdc\x99\x9c\xcc\xa3\xb6oZ6Z4c*&69\x11\xf9\xf6\x05L\x9b\xaa\xf0Q\xa2\xf0h\xcd\x12w\\\xa0:\xd7\xa3\xf7\x8b\xa5\xfc\x89\x14\xa3\xbb\x02\x1akq\t\\?\tQ-\x88\x80\xf9\\\xea\xd6\x88$\xbcx3\xc9\x95\xe8&"\xd0\x17VYZ\xcb\xd2\x8d\xce7\x16t\xff\xf6a\xfcf\xae_\x7f\x89\xd9\xbe\x93\xf2^H\xaf/<\x89\x8eN\xc2tD\x11\xa1\xdbh\x0e\x02\xafj\xecA\xcf\xb1\xf1p\xdf`\x06\x9f\x83\xc7\xcetePjp\xe0m3.>\xbc\xf95\xa9&q\xba\xf8&\xba\x17\xdb\xd5\xf4\xb4\xbb\x04*kR_q\xc8\x1f]&\r\xbd \x97\xb0\x8cS{R\xa3\xe4\x80{\xb3Z\x94\xd9J\x90\xcd\xd0\xd7#\xf64\x84N\x1a\x149\x1aGgW=\xa7\xe7G\x1f\x93i\xc0\x0f\xc3\xef\xcd\xb9\xb2\xc4\xe2\xe9\xa0-\xb4\x1f\xb5\x11\xe3\t,\xfd1P\xac\xa9\x9a&>\xc5m\xb4RY\xd7\x82NT\xd8\x8e\xa3\x7fsWX\x830\xd6\xc0Z\xde6l\x0e\xeaj\x88\xd1\xb8\xc9}\xe1Gh\x8b\x90\x94\x1c\x81\xc1h\xd1\x8c6l\xeb?e\xfd \xdc\x83!8\xdaj\x17\x8eb$N\xaa\xff\x0e\x8f`o\xa9\x8f5O\xd3\x87n\x1f\xec^\x013\x980"\x88\x167\x1a\xe3\xa1\xdf\xdb\xa9\x830\xf9\xaa\xe8!\x84\xa9\xb9\x184y\x12\x88\xeb\xab\xf6 \xaeQ\x9b:\xb3\xfd\xb7\xbbi\xa80x\xbbu\xb8,}\x9eT\xc1\xcf\x15\x07\x80\xcd\xf2\x82Zl\xae\x03\\\xf8\x0e\xdb\xd5[\xfcv\xfcr\xab\xdc+\xc8\xdaj\xa2\xcf\nT<\xd9\x114\xde\xae\xd3\x1d@\xb4\x13\xa9\xf7\x0c8\xdd\xd5\xa1\r\xeb\xc6\xb1\x08\x93\x1b\x10\xd9\x19p\x8ck(_R\xa3\xc3\xd2\x9e\xe2:!\xb2qx0}{J\xb1e\x08\xb4\xdf\xb6\xb1\x91j\x0ej\xa1\xe0\r\xe6\xae\xed\xff\x03\x18\xd6\x03\x9aX`7}*\x8a\x81\xc8\xd3\x12\x1bP\xa3eU\xa2\x8d<8W\xb3.5\x9e\x16\x0f\x18\\sJ/\x8a\xa4\xbb\x87\xbc\xb21Y<\x91\x00\x04\xf9\xfd\xbb\xfb4\xa3\xe3\xe1\x88PasA\x84\x8b\xdf\x972\xd3-\x9f\xd1\x15X\xc0lQ\x82\x14\x08\\\x94\x83\xef\x00\xc2/`om\x83+ M\xc8yi6j\x8a~\xb9E\r\x9f0/)\x81%8\x8f\x95\xe6\xfbt\xb2>\xf0<\x15=\xaa\xbd\xd0\xdb\x1e\xba\xdc\xed\xd5=\x0e\xb9N\xcc\x0b\x89\x8a\x1e\x96\xe0\xdc\xa4]g}\x9f\xf9c\xfe\x04\xbeN\xd6\xa9J\x8f\x00\xa9\x1a\xb8\x19\xf6\x80\xb0@\xe6\x83\x83\x08\xafd}a\x9a\xe6|\x9aF\x02\xda\x19K\xf51\xa2\xec\xba\xf6\xf3N\x95\t\x00\xc8\xddF{wO\x07\xac\x0b\x07!-\xd1q\xa1\xa3\x12\x15|Ib\xaa\x05\x97\x85\x1f\x17\x1a3z,\xa52\x12\x13\xf0yiJ\xc7\x0f\x16t\xff\x95(\x82l\xeeFVC(\n\x8bh\xac\xcdO\xb4\xc2_P\xd6\x14t\x1a\x1e\xc3O\xd1\x93\xbc\xd8F#\x9cbEzN\xae\x99\x0fD\x07\xf1\xfe\xfb\xe2\x0c\xca\xc3b\x86\x98\x9aqd\xa4\xec\x84\xdaK\xdeg\xa8\xf2\xd9\x8c\x16\xa0\x17\xfc\xc8\xfd\xdeL\x0b\x11\x8aj\xb7~\x86\xe2\xdd\xafw\x88:\x19\xfegR\xbe3\x1d\xba!Hx\xeay9\xe0\xf2$\x18\x1b\xcc\x95\x81\xa8\x83-3\x83\xf9b\x10*\x0e;\xea\xf3[\xe2\x00\x0c\x0f\xd4\xfa\xe7~nr\x1dfl\x8ew3_\xd4-Te\x8f\xc6\xd2f=(\xd93\xc31\xa1\xc5z*\xa8w\xc2\x8apu\xddI\xb6\xc5\xd0\x7f\xb8-\x99e\xeda\x9e[S\xaaN,\xd0N\xb7a\x81\xe1\xcct\x8b\x1c\xad*\xd1{\xdcH\x96}\xd7\x06\x8f\x82\\\xb6\x8e\x94p\xb4\x8a\xa4\xabA\x11\xca\x10%*\x8c\xbd\x86R\x1db\xbe\xa9\xb7\x0emf\xbcq\xfd\xbb\xe6hS1T\xd4V\xd0"y\xf7]\xc1\xe9\xf2&\x12\xd8\x86c\xa3\xa5\x0c\xfe\xb5\xb4\x82A{\x10\x88Uy\xe7\xf1\xee\x0ef\xdcw$\x8a\xed4\xa2\x17GX\x1f\x07X\xdd\x01)\xa3\xaa\xb0Oe\xd3O\xba\x1f^+\xdep\xc97k\xde\x14\xc0m\xe6\xc8\xfa\xea\x81\xf9\xeb\x93\x8cz-\xd8i.gU\x0e#)r;\xcf\x8a\xe6kj\xb9\x95\x8c>\x0cxq\xcc\xa4\x87\xdd\x04jUqi\xfd\n\xc9-y.\x0b\x05\x19\xa2\xaab\x0c\xf6xJ\x01\t\x08\x1bG\x8c[ \xa8E\xc8\xce$\xaf\xcb\x0b\x8d_E\x12V\x18\xb6\xc0U!y\x08\\A\'\xe2\x81\xb0\xf7\xeb\xe6W\x03\x0c\xe5\x9b\x982@\xd2\\3#Y\xb33L\x0b\x11A]\x06\x95\x05"\x9d\xb0pj\xb6\\\xb1\x1d\xfd\xac\xbbhl\x88`\xeb\xf7\x980<\xde\xcf~n\xa4\x8d\xe8\x9c\xc3\xde\xba`\x9c\xe7\xff}1\xc27\xe2\x82\x85\x98\x95{k5&\xad\xcc\xa5\xe1\xf0$k\x89\xfb\xbc\xc2\x08\x10\x0en\xc8\\\xedi\xca\xd8\xdcl3\xc8\xc3\x03@\xf92pt\xfb\xf5t\xd5\xc7\x1co;Q\xe8\x19\x83\xd6[\xe7\x15~\x85\xd08\x91)\xceMP\xf6Z#\x926VP0\x17\xed\xa7\x18\x99\xf0\xc7[\xe9B\xb9\xd9:\x80\xae\xfc\xcc\x1d\x87Si\xe0\x9f\x97\x14\xa3\x91\xdf5\x878\x8fQ\xd1\xde\xa6\xe5\x12\xf40g\x90\x98\xaa\xb01\xfd\xc0+)\xb8U\xdcU\xe5\x80\xdc\xc0\x95\x0c\x11S:\xb8\x10\'\xca`B#\x9b\xa9\xac\xcai*Q\x89\xfe\xf7\x92\xe3\x80\xd4\xa0VM\xf2\x1a\xff\xf6[.\xed<\xede\xe0\xf1\xa1\xf1%*\x0bq|\xdb\xda\xef\x0e\xf6Z\xf2~\x9d{\xad\xea\xd3Y\x1a\x9e-\xb8\x96{\xcfW!x\xbb\xb5\x02\x87RA!\xcf\xafx\x86\xdc\x0fP\x82$\x03\x1f\xd8\xe2|\x8a=\xf9Ho\x12\x9bl\x1f\xb7\xff\x02\xd3"\xe2\xe5\xfb\xb2\xe6\xba@\xec\x9e4\xdb\xb6\x8c\xf8\x14\xf12=\x848`m\xbe)\x99\xdat\xbe2u\x87\xd1\xb2i88\xe6\xf0?\xfb\x86\xd1v\x923hUF\xc7\xb3\xc3#8T\xa6Z\x05\x06\xdfn|\x91\xa2]\x1b\xaf0\\\xed7q\x8d\xb4P\xae\xddt\xc9\\or\xea}\x98\xca;J\xf5\xdf\xef\xbd\xcd4%\x96J\x9e\xc1)\x9cM6\xf1s\x1cq7\xa4\x84\xa4\x95\x9c\x1f$\x13w\xac\x1b\x93U\xdc\xb9\xa0,\x13\x82\x7f\xf1t\xb2\x92\xd0L\xf5\xe5sM\xbd\\3_\xbb\x8e}\xbc\xd5\xf4\xf6\xc4k\xf8\x10\x1e\x14\xb5%>\xf5%\x05;\xdd\xc1sXl\xbb\xd8\x8e%\\R\xd0L\xc6\xe3\xcd\x8c\x14G\xdaA\xbc\x8b?h\xde\x97\x0b\xa1\x03{`\xb0\x83j\x84\x12\x12\xed.\x1c\xa3_!\xae\x8dI\xbaj\xf4\x7f\x90\xd2b\xbd\xff\xc4$i.~\x96!\x14\xda\xd0\x82\x07\xfc\x86\xa0Z\x81\x9d\xef\xa9\xb1\x1f0\x16\xff\xd4\x806\x95\x1c\x9f\xcf\xe0\xf8\x11\x80\x13V`}\xb0\x95\x8a\x15!4\x89J\x98`\x87xV\x9c.Vo4\x8c\x0b`~\xf0\x95s\xe16\x91\xaf\xe5\x18t(\x87\xf08~\x0c\xe8\xbb\xef\xc0]\x94\x95\x01WZ\xeb\xa6\xf0\xd7\x0b\xde\r\x0b\x8a\x00\x9fY\x88\x9f\x12-\xe4\xe0:\x88r\xc6\xa3\xc0\xc7\xc1\xc0L\xf0\xcf\x14\xdd\x8f\xc7Q{\xc81\xf4Q\xc4\x0f}\x93\xda\x8fj`\x03D\x1b\x15\n5q\xf0Uk!\xff\x12\xdd\xee\xf4\x86\n\x93\xe5V\xa0\x84\xce\xec\xc1&\x07[\xffP~3_\xec\xd5/\xd4\xd9R\xd0\xc1\t\xe9\x03#\xe3L\xd5#g\xfdZn\xef]`\x0b\nSvl=}\x85\xeez;\x9ej\x16>\x93\xc7\xf5\x82E\x81\'\xfa\x96RR\xbfw\x90\x152\x1c\xcf\x1cJU\xdbD\xc8\xcc\x0e@\x92\xfa;o\x0eY\x0b\xc6.\xc0\xddBh\xb9\x1e\xdd\xf5|vRK.Pl\xd7T\x95$\xb6{\x97\xc7\x8ad\xd4\xd6\xf6Q\xecT\x07\xdc\xf0]\xeb^\xc9\x98\xbc\xf1\xfe0A\x19\x0e`F\xcd\xc2rN\xd5Q\xfe-w\xb4\xb7\x8f\xf5E\x03C\xed\xa1O\xb3V\x1b\xea\x12{\xd6\xac9\xc6\x89\x11S\xa6\xc4\xd3"p\x9f\xc1F\x06\xda\x83\xb6\x14FB\xec\xe2Q|\xb0\xbc\x90\x98\x98K\xf1\xb1E\xcf\x0bp\xdb\xea\\\xba\xfe\x83\xcb\x0b5\'hl\xf3J\xfe2\xb73R}Q\x86p\x8d\x1f\x8e\x0f"\xbc\xa5\xf8X\xc8\x868QO{\x06K.H\x8c\x9aS\xab\xd5\x1e\xe5\xf0\xfb\xe6\x1c\xe6\x05\xff\xe8\xa3+\xcfV\xe6 \x12m\xaf\x89"k\xd2\xa2\xb3Y\xea*\xbc\x96c\xc7\x98c\x87\xbd\xbe\x03\xa6\x85\xeeZ\x01\x82\x86\x80g\xf3a\xb4\xca6\x1eu\xcd \x11\x17\xbc3\x15\xa2\x0c\x1c\xa3.\xc1;\xff\xd0K\xd5Oa5\xfb\x92<:$\x16Wd$\xc3\xd6\x83,\xd2\x88ESU\xe1\x81\x04K~\xd1O\xbe\n\xf3\xcc.4\xf7\xe3\x9eo\x93h=\x01H:\x88+R\xaa\xb1\xb8Q\x16\xbbHb\xa1\xa3v`\x8d\xb1\x1d\xe8\xe5\xe7\xa2O\xb8\xe746\x86<+\x1b?\xd1E\x12\x8b\x03\x0e\x02l\x9d\xefai\xd2\xb1\xc2\x8b\x9d8H\x1bU\xb60\xd6y\xf1\xc8\xfeu\xc9\x12\xfd\x1b\xfe\x06\xc8e\x9dW\x0cIy\xde\\e\x9a\xd7\x8e[\x8aV\xab\x83\xea\xd5\x02#o)M\xab\xf4\x13\xc9\xda\x7f@\xbd\xf8\xd9\x9cgcN\xe4t\xbbV\xb1\xbf{o0d\xbb\x97\xb2[#\xdb\xa4\xf0\x96<\x19\x880fz#&f0\x05\xa4Et\xa0\xfbt\xff\x19.\x93\x16\xc3\xbfXH\xe8\x89\x91A\x10\xb5\xf8\x05\xb8\xc0\x081\xc0\xb7Y+\xb6\x8e7\xe0\xd9U\xca\xd8\x98\'\xb4\xc8\xb0\x9bc\xab\xc8\xf4+\']R\rk9Rm\xbfm\xbc\x16\x0eq\x85\xe7\x04\xd7Jj[\xa2O\x84\x9bb\x07}Ec\xe9\x0c\xea\x89\xef\x12\x87\xe1\x19\x9e{Dm\x05\xc7\x96*\xfd>Q@xT\xe0~ *\x92W-\x91+\xfc\xc3\x16\xe7\x94F\xdf\xd7\xf5\x924\x8b\xadL\xae\x11\xb6T\xfd\x9e\xf8\xc14\xe2!\x8f\x9bT\x88\xe7\x9f\x87\xd1\xc1%\xc9\xeb\xca\xeb\xc9\xd4g\xa8\xbe\xe5\xe6\xbc\xea\xcd\x05\xc0b\xa6/\x81\xdf\xdf\x9f\xe7\xb1\x9d\x9e\xfa\x1a\x07\xe1q\x18\xc2\xc52n\xff\xdd1Y|\xfb)\x08\x13\x8a\xb0\x92\x00no\xc9\x90\xfb/*\xbf2\x8e\x88\xfeC\xff\x98\xe5\xb34\xfd\x1fU!w\x94\xea\xa6\xd1kZ\xe8ps\xbf{\t\xd7b9/\x1a\xe8\xfb(A\xd7\x91bv\x00`\xb6\xddw\x12\x9d\x1e\xc5\x12~\xac3\xf9\x1a\xa3\xad1\xd5\xc10-bu)\xfa\x8e61+s*\x96K!w^\x1a\xed\xbcs\xd5\xeeL-CL5\x10\x961\xbf\x0e\xaf\x92Lr\xe4\x11\xd3\x92\x83|\xfd/\t\xd2\x98\x8d\xf6\xa6Lu\x96\xe1uD19\xaegD\xd9\xcf4!\xca\xd9m\xb5\x90\x92\x88\x98\xe7fX\x17\x98\xf6R\xe9t\xda\xe3I2\xc6\x81\x10\x91\xb2\xc2\xb3\xec\xf4]\x8c\xb6M6\xab\xbf\xf3\xb7\x16\x89r\xe9!\x05^\x93\x7f@\x1a}\xf1\xf5k\xaeZ\xea\x0b4\r\x04\x8a|\x03,\xdf\x84;\xcc!\xe3\x923Z\xa2Y\xab[\xfd;l-\xd0\xee\x18\xea\x89\xdf\xcb\x1e\x17\xf1\xbd\xa00\xc5\xe6sM\xf1\xbf\xa1\x01\x85\xf7\x94\x81&mU\xb0w\x16\xb5\xdaWkv\xe2\xe1\x9a\xe46 O\xe5\xd5\xbdq\xbb\xb0Q\x80\x92ez\xd6\xae\x12\x9a\xa4\xc5\xafrD\x86\x87\xc3\xcc\x97x\xee\xc2\xd5B49\xd3Wi"o,\xab$\xdf\xc3i\xa0\x98\x1cG\xf0\x8a\x1c\xa8\x16\x00(\xc9ng%\xe3\xb1\xee\x00\xf2o\xc209\xc4\xa4D@B\xcdux\x0e\xf3VoF\x91`\x9f-\x82Z)]\x12\x16O\xb9\xf9\xbf\xa2R\x11\rp0B\xfe\xf7\xf0\xb3\xab\x1dm\xa6>\xad\xc5c\x96zt\x9b\xf9Z\xf9\xc0\xa8 u{\xdb\xa1\x9cb\xc6]\x8c \xe0\xdf8\t>\xbaG\xf0\xe7\x9b\xe7\x80W\x98\xf7\xb3\xf3&"\xff\xde\xfc\x00\x8bB\xe7z\xf2d\nw\xadCdt\x0c\xf6\x14\xca\x11\xe3\x7f\x03"N[\xb5\x8b\x95ix\xdc|aH\x1d,\x9c\x8d\x11\x87\xa16\xfb\xf9\xcc\x1c\x91V~\xdb\xb5b\xf1\x03Y\xf6x\xbe:n\xb7\xda^\x1c\xba\xa0\xdb\xb7\xef\xa17\xe2\x85S\xfdz\xe0_k\x94~\xda\x91|\x7f\x1a\xf0\xf1\xf1\x1fC\xf0\x9dE\x1f\x9b\xefs\xa8GoH\x1a\x89\xf2\xadt\xaf\xc9\xf2p(T\x81DK\xf9\x9a\x9a0L\x818\xd2X1\x12i3\xe6\x1a[\xc2\xa9\xe6\xc8)\xee\x12\xb7\xea\x9f\xe6gE\\\xb8o\x06\xe4\x0b\x89XC\xf5e\x84)}4\x9d\xe4\x86U?\xae\xd5O\xaa\xe6\x07\xa4\xf5}\x0b\x82\xdf\xb7\xf1\x05\xc2\xe8\xebbX\\\x81\xc6/%\xed-\xf75\xb3\xd6\x02\x03J\x81C\xd7eoH\xb0\xd4\x8a\'ht\xc6V\xb0\xf5o\xab;\xc0\xb1\x86\xc0aS\xf5L\xf7\x99\x83\x00`\x16\x17\xba\x86\x85\xbeM\xa4\x96e\xbf5\x9f\xed;\x15\xb2\x1b\x07\x15\xae\xaa\x91\x8cEi\xa4X\xa0\xcc\xaf\x87\x99%\xec\xeb\x87\xa7_\x03\x1b7\xda\x05\xd0\xf7\xc4@\xda\x99\xce\xafgSf\xcb\xde\xd8\x132\xc2CA\x9fb\x06\x9d\xeaX;u\xbc\xfa\x11\x86\x8d\xab\xc5\x04\x1d\xfe\xdfy}]u\x17\xe3\x1dn\xa1\xbb\xf2\xef\x8d\x9b\xfd\xc7"(7\xd5\r\x9b8\xe6\xd0X\x13\x99\xbb\x96`\xa5=\xd6%\x8f]\xa5\x89\x86\x0et\xb8\xf8k\xdcI\xa4*cXXNl$\x0e\xc8\x92Y\x1d\xdd\x1dz\x19\x15\xf5\x8e\x82\xe1\xd15!l\xf6$\xa0\x1f\xd9G\xb9I\xd7\x14\xa2\xb8\xafR\x95\xff\x83\xfbj\x96\xe0+\x00\x9d\xae\x8e\xb6\xb1\x98#\xe3\xe1\x1eoD\xd4\xf6\x1d\x1e\x06P+3^\xa5\xcb\xfeYfg%\xd5\x8c\x83M\x89w\xe6\xa9Q\xf6\x8a\x16\xb4\xf1\xfb\xa2\x89\xef\xd2k\x7f\xe5mt/\x15-\x1f\x81&\x89\xad\x97>h\x10\xe9\xfd\xe1w\xf5 \xa9c1m\xa9OX\xc6$\xfc\tA}\xf4\x1f\xfa\xf8W\xf1$\xe6\x85\xf6\x03)\x95\x9aV\xfc]j(\x9c.\x8e~\x86o\xd2\xcfp09\xdd\x1fh\xd8,\x04f`/\xe0\t\xd7\x90:\x7f~\x8fL\xa8\x19J\xc8O\xc80\xcfw$p<3\x1d\x03f\xb4:N2\x1f\x90\xd7j\xefS\xb7uNZK}\xfa3u\x0e[\x92~\xa0\x7fr2\xc2BI\xa3G3\xf7\xbe^\xdau\xc0\xaez\xf2\xbcrg\xfa\xd0ipY\x1c\x0b}#/\x03\xb3\xe3\xfa\x96\xf6I\x17\xd1\x125n\x9a\xfc\xed\x11[D\xbd\x85\x04\xeb\xe3\x82d\xea\x163\xd6@\xc1.1\xc9\x06V\xad\x0e\x86\xf0\x05Ee\xd4\x8a\xcf\x85\x94\xc5\xb0\xf5\xf2_\xc1\xc00=\xe8\x0e\xbb+\xb6B\xba\t\xc3\xcf\x9f\x9f\xf2\x82*F\xb3\xcd\x0e\xd4\xc2L\xd9\xb0\x85\xf0{\xf0\x15\xe1\xb7\x83\xacOf,\x07\xb5\x00Hr\xc6_\xb0\x0e\xe6=y\x9as\xc9*\xed"\xfd\x06\x9a\x12\xd7\xa5\x88(J\xadj^\xf8\n2\x92\x07s\x99&\xa2\xdd3\xa0\x86\xb7\xd5Q\x7fa!^~\xa5_\x117\xd0\x1c\x9b\x93\xd8e\xdc\xa7\x85\x01[\xe5*bxhh\x9b.<|]R\x83*\xfc\x8a\x0c\xe4X\\\xb7\xd3O\x01UV4\x94\xc0\xd8\x96q\x99\xc3\x0f-\x96\xe1fa\x1f&\x9c\x112!\x9c\xdcSb&\xe9\x96\xf0N\x91\x07u\xe7\xe5\x04g\x8c\xfd\xcb&\x8b\x04q0\xda\x91\xd4R\xd6K\xdaT5;\x968\x04\xb5B\x04\x8d/N\xb9\xb2\xa1\x9f-\xd9\x12\xd2\xec6\xcaz\xcd\xac\xcdW\xf5/\xed\x87\xaf\x7f\xfbA\xc2\xc8\xf8\xc1.\xa1\x80\x7f6\xf2W\xc2\x04\x99\xcc\x8e\xac\xe2n\xe4\x0bZ\xec\x90\x17Qq\x9f\xcb\xb8- \xc97\xfd\xda\x15\xa8n\x0f\xd0L\x82A)\xaa\x93\x9d\xbcU\xbc\x0c>{\x9c\\\xb4\x92\xfe\xc6\xe9\xdf\xc5\x86@\xac\xe4V\x08\xca>\x13\x9b\xee\xd9\xf7\x9eoW}\xae|%r\xe6\xead,\x11\xc4U,X\xc8\xd2[\t\xf8u\xb7\xb6i9\x95p\x96\xfc\xf1\xbb\xc0\xd1\xff\rq\xb8\x05(\xd5t\xb1lO\x92\xac\xfe\xef\xf4\xd0#\x90\xa3\x16\x8bS\xdc\x03E2A\x05\xfd\xc1\xfc\xbb\xd6A-t`:.y\x05\x92)\xec\xd3\x0bx=7\x86j\x9f\xbc\x1cU\x02\xeb{C\xc7\xa5&*-G\x1cv\x1e}\xf5xn\xfe\xd2v\x0f`\x1fG&\xaa\xb7\xd0$Z\xa5\x0c\x0b\x16\xb4\x7f\x8b\xf0\x7f\x07\x07u\xacw*\x8a\x8cUH\x80\x97\x98\x055\x8awK\xa4exM\x1c}\x85+=i\x1a\x80\xd0K\x16[\xf2\xa0J\xa8\x87V+3\n\xe7\xfd\xe6\x1a\x9b\xb8\x81|B3.\xfe%\xc4Yw\xe2\xb4T\x87^\xc2D-\x10y[\x89\x1b\xf6!x\xe1\xea\xff\x07\xbe\xdff\x0e\x0c\x055\x0c\xb0\x10\xcf\xcdB\x179\x80\x01/\xf6\x03\xe2^qe\xd8M\xcc\xe3\xd5\x9b5\x84\xec\xc0}3\xa4Hgk\xa3\x01\x85\xce\x9a\xe55\x99y\xe8C\xb7C\xb0\xe5\x88m\xf0U\x94v\x929\x85\x93\xde\x98h\x90\x01Z\x08\xc6\x83\x01\xeb\x85\xe1\xbb\xcd\xca\x91U^\x8f\x92\xe2\x13\xd3\x84\x80\x9bk.\x8f\xb2\xaf\xe3sRd\x88\x8cs\xc329R\x97\x91\xa7A\xa7N~\x04\x13~\x80\x90\\sw\x8aUSN\xc1u\xf1\x91\x98fS\xd3\x9d\r\x92\x89\x10\xcf"\x8f\n\n\x87\x92oZ\xaa?\x90\x19\xc6h\x85\xf7\x18\x94W"k\x1f<\x0b%\xfc_r\xed\xcd\xb4\x93\xb7\xd81r\x9fj\xc8\xaf\xe0F\xc7\xbcXp\xc9\xb3]\xfd4\xf8\xbeGX\x0es\xcf1\x11\xf4a\x0c{\x19\x90#0|8z\xd1T$)\xc7\r\r\x91\x95M\xcf\xe0\x94\xeaX\x88\xbbz\xdb\xd4d[\xac&\xbbu\xb5M\xa8\xa4(\xd1F\x07\x1b\x18X4\x1a]\x9b8\xbb\xd2j\xd7\xea#\x17\x14.\xf7s\x8b\xd3\xc7S\xe2\xf6ya\x10\xd8\xa3\xe5\xf1\xe8v\xd4vk\xc1!\x95\xd2\x0cELD\x17\x0b\xd4<#\xfb-\xf1\xaa\x9c+\x88f\xd8\x0c\xc4.Y\xa3\x89\xb4\xe9\x0b\xea\xf8\xc3\xdd\xe0t?\xb6L`2u@L\xdb4\x04\x98\x9eB\xd7h\x1a\xf2J\xf2JL6\x9d\x9e\xd28\xcdy\x13\x86G\xa1A?\xa1q\x82\xa3\xc5\xae\xbb\xfa0?\xccL\xba\xfan\xf9\xe2\x03\xaf\xdf\x02\xf5/z\xd3\x1f\xac\xf7\xc9\x175\xc9\'\xa2\x10AF\xa2\xe5\xfc#\xd8\xbc\xf5\xfb\x83\t{\xa9\xc8\xc1\xc4l\xdd\x08ED`\xc8\xb9\x08b\x90b\xb9\xc3\x81\x9e\x87\xaa\xa9x6\xd3\x9c\xd0o\\\xf7\xd3\xd0~\xf5\xeb\xba^\x8f\x1e\xbe\xcc\r\xdd\x19\x97\x85\xe7\xbdJ|{7m\xeb@\xbb`\rA\xd2\xd9\x08\x91O,*\xc2Bp\xe1\xde\x15b\xfaR\xb7V\xef\x81\xd3\x19W\xa1.\xa8\xa4\x13\x0c\xd1c\x15\xbbD\xc0:#-\xc5\xc3\x8a\xcfm\xbc\x9e\r\x04E\xaf^\xf3\xac\xc4@\xa8\x03d^T\x1f\x0bv\xc5vC\xe6\x1c0\xaf\x1a[04\xa7\xb9\xe8\x9aI\x05\xe3\x91\x7f\xf8\x8c\x1a\xd0\xc2\xdb\xce/{\xe0\x04\x03\xe6bE\xac\xaf\x93\xd9\xf5\x84\x9fz\xa1\x0f\xdb`\xb3\xb1ee\x88Y\xb0\xbc\xcd\x88\x14\x82\xcd\xafL\n\x9c\x9f\xe5\xab\xd2\x8a\x91\x8a\xcdwq(\x9fc\xb2\xde\xedV\xfd\xee;\x1b\x8e\xa5\x8d\xf3\xa8\xfb6\xd6\x05n\xdd\r\xd66\xffM\xdfO\xd4\xab\x9e\xd0\xee5\\\x19\xac~\x1f\xa8\xeb\xfcoy\x0f-\xc7\xed\x18\x8b\xabc\xea\xa6\xd9\x17\x9e}\x87\xf2\x16\x9d\xeb\xd3\x97#\xf34\t\xb1\xef>\x89\xecYI\x98=p\xa1RU\xd1\x7f\xea\xdb\xc5\xaf5/L\xa9\'\x06\xac\xf5Q\x93\xb7\x04\xc5\x12K#\xb1\x1a\x02&\xfd\xb7\xc0\xb5\x8b\x0b\xe0V.\xd9\x9e\x9e=h)\xc4uf<*gn.1\xf8^\xae\xe5\xa7_\xfe\xb0\x03c\xf5kQ\x93\x89h&\x18\xeb\x12\x87J[e\xb0\xd7\xae\xb1\x9a\x8f\x12se\xa5\xf0\xd3+\xbcs\x85/5\xc9\xdbUX\xf0\xf3g\x18g\xfcTU\xad\xc4\xc5\xe278\xe9_W\xdeH\xbf\x08\x1d\xf7\xde\x02\xa3\xd1\xa7\xd3\xe84\x8f\xd7+\x8a\x0bh\x03\xdd\x12\xf2\xbe\xb9\x16\x9bz\xbd\tk\x8f\xf3\xda<\xd3\xb1\xb4\xcd\xf3\xd4\x1d\xca\xf6\xd9\x0cM@\xcf7\xf3\xcfyi\xa5\x9c\xf9^\xafj\x93\x15mRd\xf8\xf3v\xb5\xca\xca\xfa\x8cT\x98\xa7\xfb\xb1\xac\xcb\x06\xd9-\xbda;\x11\x87\x9f\x8f\xd2r\x0e\x01D\xc5\x9d#\x15OH\xdc\xb9\xa3\x06\xa2,\x93\xe96\xacV"\x10"\xa4\x08\x0e%\x9f\xbe\xcf\xa0`\xb2:\x1d\x19ja\x9aA\xf6\xd3\xa9\xa7%\x99\xa1\x1c\xbd\x81M\x1e4!J\xb8:\x15\x1f\xbe\xf6\x17;\x98\x8a\xdc$\xb4F\x85\x83:+\x92r\x85\xa8\xf7\x83\x0c\xef6\xeds\xc8\xe5\xbb*\x14d\xc9\xf08>:\xc7\x92\xcd\x9d\x1c\x84\x0c\x18\xf4\x85\x02\tnf&\xf3\xee7\x1d\x95\x9a\xf2\xba\xe9\xae\xd6\xe1"\xe7\xe6\xaeG\x1c)\xa4\xf2\x88/\x06>\x03g%c\xea\x0e\xe4`\xcf$\xd8y|\x94$E\x8c\xa2_(\xd2\x9b\x0f\x07=\xfc\xa0\xf9\xb4\xc6m\x00\xec\x03\xa5G\xc4L\xec\xcd_iW\x03%\x05=\xe8r\xbd\xcc\xf1\x10R\x04\xdb=u\x0b\x14\x87s#\x1f\xe3\xf7\n\x07r\xac\xf9\xe2\x8f\r\xb2J&\xed\x82\x18Ne\xe2\x0f\xca!\xfbW\xf2$\\\xac\x86\xbdw\xdf\x0c\x9f\xfc\xfdj\xbd\xcaf\x8cY\xb8TP\x98\xb5`\n\x87\xba\x8a\t\xf8[\r\x96\x96\xf9\xdb\xf8\xfct\x10B\'|\x91[\xb8e\xe4\x84\xab\xa3\xcek\xe4\x97\xb6\xcd\xcc2\x12\xc4 \xd9\x80\x1dq\x18Cb\xb6\x9a{\x85<\xc4t\xc0\x88o\xc3}Og\xf6\xe0\x82\xe80I\xdcF\x01lk.\xe5\xbb\xed\xfa\xc2\xfe\xb0\xad\x99\x8b@\xaf@\xcd\xc2+\xd7\xaa\xaa?\x1f\xd1q\x14C\xc9L\x11\xd0\xd1\x04\xe3\xdeD\x9f\x19l\x1c\x008\xf92\xcc\xa7\x04\xc9 \x16]\xea\'\xed\xe4\x1c\x83\xaa\xff~\xcdif\xa7\x12\x80=\r<\xb3\x1f\x00\xb0\xdc~\x8d\xe9s\x97\xd4{u\x06\xf3J\x9e\xda\xfd\xc0\xe6\x91\x119\x86W;\xa4(a\xf0\xb3\x15f\x07\xa5u\xaa#5k\xd6\xdd|lok\x93C]\xdc$\xb0!QwD\xcf\xbcq#B\xde\x103+\x9f#_u4\xdb/G\xc7\x8aV\xb6,-\xcb\x8a\xc2#I\x16\x9b\xb9\xd5&\xcb\xf6\x8c\x82}\xb3\x16\xaf\xb7%l\x91\xaa\xa7\x91I\x0b1fJ`\x1a\xaf*{[\x99\xd2\x86\x12z\x90\x13\x85b$\x12qv\x9fW\xab\x08{\xe1\x89\x88\xefIg1dN\xe4\xa4O+Q,*\xe3o\xab\x01\xc9a\xd26\xf3\x8d\x96^\xea\xdd\x11JOl\xf7\xa7\t1\x86\xc88\x08i\x04\x13Id:\xed\x86\xd4\x15nK\xab\x81\xfb \xca\xaf\x8fO\x9b\\\x9f\x06\x9b-\x8e-\xf2\xa7\xde \xa3\xda\x85\x84,\x9e\x9f\xca\xbd\x1b=#V\xeb\x80\\\x9a;\x0c\xaa\xc0\x11\xcc\x82ON$"P\x17B\xa6\xed\x95>\xd3\xb92d\xb4 \'5@\xe0\xda\xa2\xde\xf2(q\xf6k]\xd0\x95\xa8\xd1#\xad\x80i\n(\x1fO\xa3\x00\x8e\xf5[\xbb\xeb\xe3\x9f\x9f\xfb\xd3\xff\x11X|y8\x11\xaan\xa0Y\xf7\x1a\x94\xceOl_\x016N\xeay\xb0\xbao\x9c\xb3r\xab\xd5\xb8m\xcfZ\xcd\x99\xc7;\xa6d\x9fl,\x97!\x0e9\xd3\xaa\x8d\xff\xfca\x1d\x8bd\xa9f\x91\xf0,LBW\x8a\x1d\xbf\x17\xe9\xe9,\xfc\x9d\x9a\x96\xd7\xe7\xda\x0bq\xb8\x9f\x81DYw\xee\xeeM\x1f\x16\xb7\x0e\x8aB\xeaC\xef\x95\x9cFu\xc5d=\xae\xbb\xb3\x18\xb8\r\xbff\x9e\x16\x1b\xaf\x8d?x\x1d\xa8\xc6\x87\x06\x86\xb5J\x8f\xfd`tTs\xa6\x9ee\xdcX\x14E\xcc\x80\rm.\xaf\xe2\x01\xac\xe4P\x0bUZ}\x04\x1c\x07\xd4\xb6U\xd4\xbb\xbd_#\xa8S\xe8\xfd"\x9f\xe2s2\xa34u\xf9\x18\xde\xba\xb9\x80m\xe1\xf5lH\xbd\x1a+OCc\n2\xe1\xaerS\x07\xf7\xa5k\xa2\x18\xcc\xaeO>\x1cr\xa6\xe7\'\xa5\xa8(|\x99\xb07\x99\xc0m\tR\x7f,\xbd}\xe7*\xf0q2og\xcei\xd0\x84\xbd%yd\xb2\xa4Zr\xf0\x02\xcf\xa0\xdf.\xc6N\x10V\xb6\xf3\xdc\'<\xc3\x98e!\x8eZ*\x90\xca\x11\xc5\x9f\xbb\x08&\x8e\x1d2\x84J1\x97\xad\x7f>q6\xae\xbci.\x10\x80\xbb\\\xe6r\x16\x9b\xcc8\xe7R\xdc\xf1\xb05.\xb8&\x0b9\'P\t\xe9I.n\xe7O3\x1d\x95?\xcbb\xc4\xe9|\x17\x94\\QN|fX\\C\xedZ%\x16\xc7GbE\t\xfa\xe4:u\xc4\x92\xeb!\x8e\x1f3\x80\x1d\xdd\xccM\x07eC.s\xe2\xab\x02\xac\x8cnqB\xc4\x07\xf3Yg\xcf\x81\xda\xc3\x90\x83\xbf\xef4A\x8b\x8b\x8bb\x81\x89B\x9a\xcaEVI\xe4\xa0\x9ad\x12U\xa7\xe4\x8c,\x10\x84|"sw\xe5&x>\xef~s\x95l\xfe\xf31\x10M5qC+\xc8U\xfd\x9a<\x8a+\xc5C<\n\x1b@\xf7g{\x7fd\xacPt\x88\xf7/\x82l\xac\xf5e\x0fR`V\t\xe0\xf7\x1ar\x90\xc9\xa6Js\xd4\x8c{\xc6\x0cRO\xb7\xff4%n%q\xdb\x8a\xf5\xef\xbf\xc5\x80\x0b\xb7+d\x17\x86V\xcf\xf9R\x029\x06\xd3f!7\xf4!LGN9H\'\xd3\xe7\xfcw\x9eG\xd9\xdat0\xa7\x9d\xd2\x05)i[\xbc\xd8\x1b6\x8fx\xd4\x8e\xbdw%9\xff\xe8\x03\xb0\xb3R\x11,\xa6h\xc3j\x85}8\\\xd6\xabY\x90)\xcb]\xb8\x7f,]\xe9~\xc9\x8e\x07\x94\xdf@\xb1\xc2\xc5\xbelD\xf0\x95(:\xd1\x8a\x92\xa3&g\x18\xe8\x8d\xaf\xa3\xdb\xa1\x8d\xcaI\x1c\xfd\xbf\xac\x1d\xb4\xbd2\x10^6/R,4\x1f\xe8\xd8=\x97\x8a\xf5\xbe\xc4\xb5\xb2\xac\xb6\x12\x9d\x16\x0c\x9dD\x1b^\\\x81E\xf3\x88\x07\x1e\x1e\xae\xae\xf2\t\xcd\xaa\x12\xb5Dq\x97A\xb1\xde\xcd\x12\xeb\xdcH\x0e\xd4 \x84&\n0z\xdf\xc8\xca\xef\xd8\x13\x80\xab=b\x069\x17.EP\xcd\x1b\xbd\n\xe9<\xfa*?\xa8H\xec-9\xa9k\x01\xc8\xb9\xd1}\xe1\x9d>\xa2\xac\xb1\xbb\x7f9!\xa4%v\xdc_k\xe5\x91\xdcw\xfc\xc5\xd0r\xcf\x07\xf5+\x89\x16\x9c\xd3\x11\x0b97\x04\x8dM\xc8U\xf1\xd6\x16\x0c\xc5\xf35;~/\xb3X\xe4\xbbTC\xb89w\x15\xf2\x96[\xcaV\xf2\xba\x1bt\x98\xd9\x9d\xa8\xbb\x8a\xe6\xe3.\x14`\x90\x8b\x08r\xf8\xc3\xf4.\x0b\xc6\xff\xce\t\xe9\\P\xb4\x9c\x1d\xff\xe6\x0c\xfe\x97M\xb15\x82\x11I\\\xe2\xae\xa0\x92\x19\xa0b#!\xcc\xfc\x1ed\xbd\x91\x19\x0b\xb7\xd3 \x13\x19\xc3A\x06=(Y"#q$\x1fg\xd5\x99\xb7t\xcb\x06\x14\xd6\xa2\x00\x0bo\xf3\xcf\xb2\xba\xfe?\xe1\x89\xeav\xf7\xb7\xee/N\xc13\t\xba\x03\xba\x02w0\xa4\x8a\xb4\xa5V\xf0\xe7\xfc\xe4\xc0\x9f"%\x94\xe0\x97\xa6\xe4SZ\x9e\xe6dMJ\x88\xc69CHE\xa5\xd8=,d,\xfa\x19\xc9\xa6\xfc_\x87K~\x10\x9c\xc9\xa1\nI>h\xa92\x9faX\xbe\xfbd\xf0\xc8z\xb3\t\xb1\xde\xdfR\xa2\xf7o\x04\x1f\xae\x9d\x80\xb75\xa8\xa1s\xc3m\x8b\\\xd7\x88\xa0XSo3\xcd\x07\x11\xa45Jz\xb9\xedD\xd5\xab\xfb\xa7\xbc\x16\xa5\x905\x8c\x9c\x12\x11z\x1a3\xf2\xce\xec\xe7\xb1\xf2\xbc\x010_I\xdd\xc7\xeb]\xb3@\xcau"\xfd\x98\x9b\x1d;\xafe3\x06&\xea\x8a^\x8d\x0b\xd4)n\xf8#*B\x99\xeeH\xe4\x1d\x84\xe4\xb78,\x05\x1ea\xa0\xcb\xd9\xa9\x99\xf0\xe0`\xc3W%\xafm\xee\xa1\xbe>r\xcfH\xa3|\xeb\x89\xa0&\x9e0\xe2jvz\xd2\x8a\xd3=\xee>-=w\x82\xcbV\x80\x96\xfe&\xc7R\x17\x07m\xaah\xdf\xec\xda\xd7\x1bH\xd6\n\x1c\x84\x91\xf5`T\xd3\xb8\x1cB\xc0F\xcc\xcb\x92\xe6\x81\x92D\xe5\\\xbfP\xd7-\xff>\xa6e\xf4X6\x8b\xeePi\xb5\xc1\xd3\x18$`\x9e\xb4\xa0z\xfc\xb4\x92\xa3m\x0bR\xab|PUf8\x05\rr\xab\xf4B\x05\x83\x96M;\xa6\xe2\xfd=\x8cn2AP\xef\xefK\x81\x16\xcd\xa8\xbd]=Zu\xcd\xdb`#Co\x95A\xa1\xf7&\xc8\xf4\x9b\x148\xc4\xcf\xe7\x01!@mq\x1e\xfdK|\x00oB\xfc\xa4gN\xc6\xd3}/#\x07\x04h{qF\x8b\xd0\x80\x17\xcb\x8b\xb4\x05\xe8\x0e$\xd81\xbfn\xe4`\xa9\xe5\xa04\xf5\xaa\x17\x9c!8\x06\x10~_N\x02(\'\xa7\xff\x86%+\x95\x10\xe0\x7f|\x0b\x1d,\xc4x\xa5\x92/\xc2\x14\xd8v\x19\xce\x08"\xe3u\x0e*W\'-\x12\xc3j\x8f\xb4\xae\x9c\x970\x9a0\xafV\xf6y\x0e\xa3f\x9bKTGA~!\x12A\xf1~\xbc\x9d\xf6\x8d\xd8\xb6Q\x9d\xce\x0b\x02\x03\x1b\xb7\x18\xeeN\xd9\rLl4\xd6K\x7f\x8cN\n\xbc\xe9\x82\x0f\xcc0S\xa8\x00\xde\xbb\xfe\xd2(\xc2\xe7\xb0j\xc9\x8d\xbd\n\xc5)\xc2\x0c\xbf\xed\x8b?*r\xb7.?\x1d_\xab\xe2\xaa\x9b\x8b-W\x00\n\xe2\x00&(\xff\xa2\xbf@:\xe3[\x1aH\x02B\x18\x0c\xeb9p\xfa\xab\xfcJY\x9e\xc2\xc8\xe8w\x14\xf9\x90\xb4\xdc%\x06\xe9^\xa1\xee\xdeL\x91\xb7L\xd1\xe0{\xb0>\xd2\xc3\xd0\xfby\x88\x90\x930l:\x97L\x1a\x92\xe2 \xfcb\x94y\xcd\xe0\xd9\xed\x98V/\xf7-\x8azG1\xa2\xf2a\xb9\xce\x1b\xd4\x86\x8fqXP\xae\xef6\xbb\xda\xe8RQ\xb3\xfc\xc4\xe7\x9b\x0c\xa5E\xdf\xe3y\xd9#f\x88%\x9b^\xcc\xe8\'"\xc2cfl\xd4\x0b\xe6"\x96Z\x1e\xec\xd7\xb6\x0ey\x00k\xb0a\x82\xa9u\xca\xdc\x04\xe80M-\xe3\xbd\x98f6*\x0b\x99\xe7\x86BR\xb0hW\x0f0\xdd]A\xb1\xd9I\xd9Vk\xbd\xcd\x9bel\r\xe0,w\x0eq\x8a\xc6\x96-\n\xd89j5\xce\xa7\x96\xd0\xe4)\xcf\x10\x04\x91\xf4-\xd7\xae\x98\xf4=\xb1\x854{\x8c\x01\xcd\xe8\x0eZ\xf1\xcao\xa9*L8I8\x0b@s\x8b!~\x1f\x86\xd6\x10\xd2\xccd\xdc\xe0\x933\xb6}\xc7\xe1\xe2\x13\x99\x1c\xf6\xc8k\xb9#\xd4\xc6\x08\xa6-\x02\x87=RY(W\xbf|U\xa3\xc6D\xb0\t".\x8fNrf\xbd\x86\x16\xd0D\xdf\xfb\xccZ\x8e\x1d\xec\x1e\xb8/dC\xab\x9c\x88a( J\xca\xe1\x96\xed\xd0\x96\xa2-\x11"\xc5\xc5;u\x9f\x86\x93,\xac@\x88\x10]\x9eL18\x86\xf2<\xe4\x8b\x0f3\xd1!\x97w\xbe\xb1\x18L\x7f*t\x10\xf9\xed\x84\x984\n\x86\xec_\xdf%\x19\xbd\xfc\x0e\xb9`\xb5I\x0cNX\xbe^\xb1EF\xe24\x07\x99*$\x82$\x1f\xa8T\x01\xa4}\x1f\xf6d\xc8\x02p\xfcM\xa4\x8f\x9a<\xea\x1b\xf9Ha\x06\xc4\xad\xeazE\xb5\xd4\x97\xb4\xe3\xe7\xa5y\x15\xf3\xc5P\xd2\xfc\xb8\x0f.\xca\x9a\xc9\xf9\t\xc1\r\xe3\xee\x16m\xe9f\xf1Q\xda\x07\xc2sk\xd8\xa0q\x85^\x02\xf9\xf7C,\xe0M]\x13\xd4M(\xf3\xd6\x99\xcb\x0c\x0f\x16\xc0\xb2\x00t\xd1\xc1\xa5vc\xe4\r\xdd\x99\xcb*\xd0\x1c\xb1\' \x127YT\x14\xac\xec\xda\t\x86yU\xb7\xfd-t\x01Ey\x80+,\x9as\x90{\xd6x,k\xc8~[\x15iW\x9d\xee\xab8f\x86\xaf\xcb\x7f:84\xba\x8b\xa81c\xfe\x8115\xe7\x01<\xbe\xce{D\x7f\xf1/o\x80\xb9y\x8a\xd3q\xbcf\xfb\xd9\xbe\x93\xb0\xaeO\xf8#G\xe1\xb8\x138l\xe6%\x08h\xff\xd9r-\x83\x89\xed\xef\x08\x7f\x8f\xdc\xe3\x8a\x0fk\xf5^\xa9m\xd6\x1aT7$\x9a\x84\x98g\x8f\xe3\x0e\xbf9\x07\xc7N\x91\x93J)_\xbcD%3\xe6Sa\xf7\xf8\xf6\xee\xb4)\x0c\x07J^7r\xe08\xb8\x9c\x99\xb8(\xf2A\xef\xc8)\xa1IwXP\xcc\xeb\xedJ\x15\xa3&X\xde\x83,E\xea\xd8\xbe\xad\xc6\x1a/\x11-9\xbe\xdd\x98i\xd2\x90\xf6f!\xa2\xa5\xdaU\xe4T\xe6\x07:\xe9q~J\xfd\x11L\xfff(\xe4.\xbbi\xea\x0en\xf6\x92\xf4\xb3\x90\x93\xc0i\xc7\xdacb#\xcf\x82\xab\x8d@\x8c\xe7\x84\xae\xe0(\xf3\xa5\xadnf;\xbf\xc53\xa5\nt\xd2C\xeb\xd3\x80\x0c\r\xe89\t\xc6Nd\xf2Q<\x8c\x81\x16"\xf3\xda\xed\xec4\x16\xb7\xe5mKG\xbd\x85,\x13\x8b\x10\x1f\x03\xe6\xbf\xbf<\x94\xf8\xaaAgQ\xf0\xf6|\xfb\x8e\x86\x0eM,\x13\xe9\x01\x8a\x1f:\xf6\xcf.N\xcf\xcc0\xb8\x83>\x92\xdam\xa8\x94\x88\xa4\xf8o\xeaK\x93\xb5\xe2\x84\xf4>\xf5\x86\x01(\x91\x8b\x89b \x80dI\x8a\xedNZQC\xe1 \xfc\x81\xabQ&\xa0w\xde\xb3\x97D\xba%@\xed\x86]~\xfc\xdf \xb4\x9e\xe6^C\xb7$\xec+72\x01\x1b\xf4l^R\xd1\xa1\xd9\xc2_0\x8e{m\xbb\xe6\xe0\xad\xa2j3"7^~\xb8a\x0f\x83b\x86\xb8\x0f\r\xff\x97\xfe\xd3\xe1\xe6\xf9Q?\xb4u\xbf,\xcc]\x16\xda\xd5\xec^\xa7V\xd5\\\xac#\xd8\xe4\xf8\xfd\xa6\xb9,K\xee\xed\xec\xb1\xf3\x93O\x98c\x91\xed;\xea\x83\xa9\xdf\xcb\xf4\xb8@Ulq\x04\xf3\x87\x00\xdc\xc4\xdc\xf1\x9c\x1e\xa9<(\n)\x99\x8cw\xbc}t\xb3Hv\xd4\xe0<\'\xa5\x94\xbe\x822p\x95\x0f6g\xc2\xfd\x95{-\xc8\xda\xea\\M\x11\x00\xf9]\xc9x,\'\xdf\xa6K\xbb\xf2\xb1\x11\x84\xfa\xa5!DJad\xbe\xa1^x\x1a\x1a\xaf\xaf\xa5\x95\x82\x10d\x07\x1c\xb5\x02\xf6\x81\xc2\xc4\x16_\xa8\xc5\xba\x10\xb6\x10\xd1\xa4L\xf7\x94\x1a-\x81:\x1f\xb4\xd2\xc8yTS\xf8\xabA\xa8\xa3?)\xa8#c\xd0iW\xd3\x1d^\xd6E.\xb1\xac\x15\xd8."\x95\xa38\xf9\x05v\xa5\xda\xfc\xfcJ\x83\xe9\xd3\x8b\xb9\xder0\xdbt\x1d\xe7\x03?{\xca\xf6.\x7f\xda\xae\xbca\xd4\xd1\xabt\xb6*\xb7@)\x04J/\x82S\x93\xdc\x90\x1d\xe4S\x8dg\xa2\xb7\x15R\xb7d\x82\xe1\x87\xe9\xb2\x1a\xa6\xd5Z\x1a43\xaa*\x8d\xa8\xba[\xb9\xea\xb0\n_\xf0\x8a\x84\n\x9e\tt\xfdGZ|\xaeM\xf9\xfa$\xd1T\xc5\\v\x9b\xe8ob\x917)^\x18\xeb\xc8\xe2fD\x7f<\x7f\xdb\xc0j\x1b\xaf\x80\xc3\x82r\xbe\xfc\xd2OW\xa5\xa3&q\x81\x13\x87\xbfy\x93\x88\xdd\xf1n\xf7\xd6\x14\x8d\xe8h\xc5X\xeeT>\'h\x88g\x9dM\xd48`\xe3\x80\xec\xc6/A=6\x14\xce\xa4Y@?\xe8}\x1a\xef\xf8\x11\xa7\x8d\xc2\x0e\xed\xdb\x01)\xcb3\xc4\x1cB\x96j\xcf\x80vh\x18\x1f\x856\x81\xfe\xa2\xdd%\xa7D\x02\x1b\xbe\x85\xb0\x1d1\xccmn\x9aZ\xaa\x8da\xdfo\x1f\xdb\xb1\x87?\x9fv4\xb5\xd7\x05H<\x83\x01\r<\xd7\x01\xa2pL\x8b\xeb\x1c\x12\x0b\xa6F\x1bF\xb2\xb1f\x19\x8c\xb6\x83lf\xb8\xec\xa3\x1f\xc4\x96\xdb\xc15\x92\x1d\xf6\xb4!\x13#\xfd\xf4-\xfa!\xa4D\xfc\xb5t\x1b\xf7\xde\xf5\xf8\x19\xbf>\xa0\xadL\x7f\x83\x9e?A\xa8 \xf5t\x8f2\xa1b\xf3\x19\x94\x857\xf2:\x90\xa9\xdc\xee\xeb\xd9\x94\xe0BX\x94\xa9\xa9e\xe5>k\xaf\xf3\xd4\xf7\x98-\xe8\x068\xb1N\xf7\xb1L\x93\xf3\xe2\x01(+\xa1nw2\xe5\xb1l6$Z\xcf-\x93\x01sJ\xda\xa1&E\xc4m\xf1\x86/\x03\xd1J1\x9d$?W\xd8II\xfa\x95 \x0b}\xd7\x9d&-|\xc4\xad-\x86n#L\xe8\xf0\x06\x11y\xd0v\xf4[\xdd\x1c1\x88\xc8f\'gDq\xf5[\xc6\x1a6\x9f\xe3\x17\x9f}\t\x9c\xc4\x94\xafb\x1a~\xd8\x1e\xf2\xfcHv;P\xba\x19z(\x9fcl}\x12\x99{\t\x02V\xd4\x90\xd7}\xd8(\xc0\xa9\xa1\xf2\x91;\x17r\xe5)J/\x04=\x07AU$D_X\xf2\xda\x84\x12c\x90e\xb0)\xa4\xe8O:P\x00\xa3\xe2IJ\xc6Ad\xa7\x18Qf\xf2\xca\x03\xa5\xc5\xcdD\xef\xe5\xcb\'\x14$M\x02\'\x95\x01\x95\xa3)\xcf\x11\xb4K\xf8*\xe0\xa9\xa9\x89)\x8dw\xd0\x82\xed\xdc\xb6&i\xe6\x10\x06\x8f\xcf \x9e\xc1\x87\x9bK\xdd\x18\xf2\xbf>\x9c\xc8{E\xb2c\xddo\x93\x11\x01\xb3C\xd4Uh\xb0GX\xd2\xbdA\x14\xf4Jr4{\x11\n\x92\xc4J\x89r\xb1c(!\x15M\x95\x9bWcZ/\xef1\xe8\xa4\x05\x97=ei\x033r\xa5}D\'\xe8[Ov\xff\x80m\x01\x7fD\x12\xc7\x92\xf5\xc2\xb9-\xf3\xc9\xb7\xfe\xf33}\xb5U\x9c\xb1\x90\xb0)\xa2\x9d\xca\xe5*\xa2\xa4\xa2\xc3\x9b_\xf1\x8f\xd0\xdes\x91\x13\xaf\xea\xd2%a\xcf`,\xf0"\xabW^[S\xea\xb9{z\xfb`p\x91\x9f\x97\xee\x11uW\xb3\x8eA\x96E\xef\x12adq6\x84\xea"\x0e\xee\x02\xd6\xce&}c\x12Gb)\xd1\x1d)\xbfA\x95\x81\xb8\\0$)\x8cH\x8c\xcf\r\x9e\x9dl\xb2\xf4fK`e\xf4\x01\xf0\x01t6\xa1\x003\x90\xfe\x8a\xcb\x1f>\r:\xed\xf8\xb7\xa6r\xabk\xa2|o\x10\xb8\xe2O\xac~\x16X.W\x0ez\x12\xc1\xf8\xfcN[\x0c^(O\x9a\xda\x82Q\x13\xbc\xe5\xc6\xf3!\xcbqq\x8e\xf1\x8a\x0c\x13\xc7\xa8\x00~\xe3\xa9`\x15`\xf8\x9a,\nv\x96\xc2\xec\x8d}\x9f%\x08o\xc0\xc2\xbag\xa8(c\x1e_8\'\x11\r\xd3\xbe\xd5\xcb\xc5\xacV\xf3\xcd\xe0\xe7\xab\xd1\'\xe6f~\xb4RW&\xccl\xa8\xce \x19\xb8d\xd1\xc51\xf0\xf6\xbc\xe0\xee\x13m\xdc\xbd\\m\xf2\xe2\x15~g\xb7u\xdaM\xd46\n\xb5\xf0\xe6\xca\xad\xcbl\xb3\x91\xc9\xa7\x07o\xedE\xae[\xc1\xd8\xc1\x14a\xaa\x190{E\xb2\xb1\x1f\xf26b\xbf\x98\x1e\xd1$\xfbw\x80\xa8\xcd\xd1m\x06Ry\xc3\xdfn\xca$\xdb\xa7\xee\xaa\xb5\x8a\x8bQ\x00\x97\x1e7\xa1\xc7\t\xb8o\xb7 90\x08\xc9\x90#\xbe{\xf2\x06^_\xb2U\xbf\xa3\xe0\r\xe1\xb4J\xfe/\x91\x81\xde\xe4\xce\xdc\xa6\x05\x8b\x96\xde\xe1`\x07\x07\x82EBj5\x00\x00\xd8|!\xe9!N\xb4Od\xfe\x18\xff\xaf \xf0\x0b0\xf6\xd5\xdc\xd9n\xf7\x81\xbb\xecC\xc6=:\xe0O\xbf\xf3\xf6\x83.`\xa1\x04\x9d\x13\xe7\xa5+G\x18b\xe2\xc0i+\x03,\x89\xf4O0\xef\xa0\x88\x86\x92\xe8jA*\\`\xaa\xb1Z\x981=\x8d\x05\xfb\xa5\xcal\xfe\xc8\xc4+\r\x91qZ\xd0\x99\xcc*\xf2\xf2L\x1eKu\xe1\t\x89:t*\x11,\xdd5\xe6\x94\xb0\xc8D3*\xfb\xfa\xb77\n\x11\x1eTW5G\x12-{f\x1bB\x05\xa5\\\x08e\xea\xbc\x02\xfc7\xa0\xa3u\xae\xb6\xba\xc6\xd4\xb5Q|\x15\x06\xcc\xf7\xda\x04\xa4\x1c\x0cU\xc6\x9b\x18\xbe"1\xb9G)\x9c\x15\xb4\xb6Z\'L,\x92g\x96<\xf3L\xb6\xc8,\xfa\xfc\x95\x06\xa0\xda\xbd^U\xbdm\xa4{}o\x02V_,Z\x08\x05\xe0\x1a{=\xe2\xc5\x1a\xacIi\xe1\x1e\x86\xf5\x0c\x82\x1f\x9b\xc2\xb4\xde-\x18\x16S[t\xa1\x808\x8e\x16\xcb@\xe0\xb5\x1dqm\xe5\x1c\x86\xd0\x88\xf7\n\x99\xddus\x04\x1e\x04\x911\x1e\x87\xa2\xbb\xb7\xbf\x18\xa3\\\x0b\x87;C\x06\xcf\x15Y5\xa8 \xcd4\x04\xe2\xed\xbf\x18\xf8\xa0\xa0-\x80\x95\xb6\xc5\x7f\xcfJNW\x0c\xd6\xc6,R\x85\xaf\x83\x91\xf9\xc6\xbf\x1f\xa1*[*\xf7N]\xcf]?\xf4\x14\xe8r\x90K\xaa:1\xe0\xfa\x11>\\cN`\xca\xc5Xh\xa3\xf0\xf6\xff\x84|\xa80\x80L\xe9\xce\x10@\xae\x1f\xa8\x014\t\xc0C\xee\xab\x17\xda\x99\xe8\x9a\xe0\x0f\x03\xe1\xcc\xc2u\x00b\xe4r4T\x8d\xc2\x07a\xee\xf3iA\xa9\xccb\x14X2\xccUO]\xd3\xbb\xe5\x11\xfb\x18\xda\x15+\xa50\xf1\xe3\x1aA\xb4z\xde\xa2\xd4NH\xa6\x9d\xa2Ce\xd3\xfd\xa0f\xfcx\xe0T\x8bX\xd4\x81\x95\xe4\\\xb9Z7\xf5~n\x16}\x8a\xed\xd8\x02\xdf\x93\xad\xe1h\xd3\xc46\xf1\xf9\x10\xff\xae<\x8ce\x11\x06o\x8e\xac\xa7\xfc(\xe5\x8aLez\x7f\xd4pz\x9e\x17\x03S\xf4m\xcax\xdc\xd39\xf6\xedth\xf1Z,kD\xf3\x04/\x00#\x84\xc1<\x8d\x90\x8e\xed\x02r\xd6\xad\xe6\xe3\xce\x9fB8\xa5Zw\xcbf\x89\xdeA\x8e9\xe9K.\x06\x9e\xa5\xd14lL!v\x92\xc1=\xbb\xa9\x8a\x02\x16\xdaEJp\xa57][E?\r\xba\x8e\xf9tos\x1c\xfc\x1c\x80t\xb5\xce\xc3\x80\x11\x90\x80\xba\xf2\xfa\xb1\x9dq\xbf\x93\x1b[\'D$\xa9\xef\xf3\t\xa9&{\x10\x8eAi6\xe9e\xcaw\xe1\xf4W5\xd1S18\x80Vw\xe4\x0661\x05:\xa9\x17\x1c\xc5\x1a\xbc>Tv\xb9\xcev\xfex\xc5\xbd\xc4K\xae[\xf6\x8a5sf\x1cX\xf3\xf42\x06+\xb9\x0f\xf4kyY\xd9\xe0E\x98t\x87\x19\xb2\xa5`\x85\xbb\xac\xe8+F\x9b\xc5\x8f\xd5\xa8\xfd\xca\x8c\xae\x81\xd4\x92\xc5\xc1\xdcj\x8c\x07\x9f\xa2m@1\xb8\xe4@\xf9\x99\xf1v\xef\x86\x13\x10,8\np\xc1?y\xce=A\x12\xc2\xc8)\xa3\x19c\x98\xea3\x04\x92l]\xba\x01\xfd\xaa\xa5R\xdf\xea\xee\t\xd4\x99Kz\xdc=\xfd\r^\xd6\xb97\xe5\xa4N\x01$\xad\xd5\xa7XmJsYZO#~tk\x9eU\x81\xd55\xb1\xfb\xfbAF\x87\x93\xb1\x05C(\xfcBm\xb7\xcb\xa2W\x00Eo\xdb\x9a\x1b\xe9^\xcc\x13\x1f\xc3\xd4\x1b\xbe\xeea\x8f\x15\x1b?\xcek\x82gr~%E\xd6\x15\x85\x07\xf6\x91\x84a\xfe\x99\x0c\x04\x8bOE\x89Q\x8e\x7f\x95M-\r\xa0\xf3V\xc3d\xf9\xa9\xab\xf1\x8b\x92\xfd\x06=\xd0\xceB@\x16\x05\xd5>Z\xb8#\x05RM\\X\x19\x91&\x12\xdcc\xa5\\IR\xcfE\xbc`*F\xcel\xde\x12WS\xb3\xe0C\xe2IJ[JTJ\xe4\xb6p\xf9\xa8\x8a\x8b\xee\xb5\xc1\xb5\xe71^\xd9<\x06\xa2\x1e\x05\xc0\xba 6C\xcd\x95\x7f\xbc\x08\x89\xe8}\x89FO\xd3\xf9\xd7pI\xa5\xeb\x87\n8\xb2\xd7\xaa\nJ\xc2\x0e\xab\'\xd5\x00\x175\x0f\tG@\x8b!\xe8\xcdA\x91N\xc9\xea\x10\xb0\x00Y\x90\xd5!<\x19\x98\x16\x13\\\x1d\x11\xcez,0\x13\x89\x14)\xb7BN\xfbz\x82\x84\xba\xc9\xe9t=\xb05\xa5\rA\xbba\x18a\x88\xdb\x1cZY\x84)\xef\xbc\x9d\xad\x0bC\x80P\xf1a\xe2J\xa8;w\\\xc3\'\x84\xcb\xdd\x97\x92.\xa9\x18\xbc\x1co\xfd\nu\xa5\xe5\x92\xcd"k=\xf37>\x990\x82\xd7Kzg\x0c\x9bO\x04\xfb\xba\xbf\xbc\x1d\xe8/\xfa\x81\x97\x07C\x96\xc9\x92.S\xf2N\x82\xc8@n81knw\xbc\xe4\x11\xeb\xa8Ie\xddN[\xea;`\xf8s6\x8f\xb5\xc7\xc3\x03Ub\xd6\x8b\xef&\x19\x95\xd1O\xb6H\xc5\x01\x86+5pU)\x92T\x99\xdb\xec^IM\xe2\x848\xfd\xbb\xce\xa6\x94\xc4\xb5\xcd\x06\xff\xf7\xb2\x97\xee\xe7\xe9\xc8qW\x88\xa7e\x10\x14!8\xf6\x0f~:\xb2z\x82>[\x1a\xa1l\xb1.\x84H\xb6UJz\x89\x0bI\xca\x88\x03\xe4\x13\x05\xea\xd1\xaf\x92H"z*\xe8e\x96\xb6\x1dFJ\x90\xfdM\x06\x14\xb0G\xae\xe7\xaa\x88\x03\xfd-$"\xeb\xb4\x90\x0c@V|R\xc7g\xe0r\xe8\xef\x9a\xe5\x1aG\xd3[\xc5W\xb5GrM\xae\x87\x83\x85\xa9\xb4n\xfbR\x98\xf7|&\x1a\xe3J\x1bs%\xc8Tp\xeeWS70\x86\xe7O\xc5\xc15\xc1W\x1b0\x15\xa2\xfcPE#\x0b\xb8\\\xcdw< %\xba^\xb1\xf7t~\x9c\x9e\xf7XN\xcc\x8c8\xcfV\x1dY\xf5\xeb\xaf\x8e2!\xe0\xcdL\x90\xf9\xb6(\xf2\xf5\x8b+{\xd3\x93\x1f\xb0\xaa&\xaf=Z\xbed\x84\x19\x0c*\t\xad\xac\xf6\x06t\xe1\x81\xf5\xb3T\x9f\xc3\xdd\x10\xd89\xe0\x0cW3\xefn2k*\xd8\xa4X\xb9\x1c\x8eTlY\x85\xf1\xdf\x03t\x9a\xb7\x06V\xdc\x17\x9a%\x98PR\x95\xe4\xfeX\xce\xbag\xecx6Kc{\xd34\x1f8HJ\x99\x7f\xbe#\x93\xa1zy\x9d]\x0e\x80\xc5!\x7fbg\x80/\xfb\xe9J+h\xb0\x1d)\x9a=\xf28\xc0\xe6\x93dF/\xa6\xae\xb7\x93Si\xc0i:\xdb\xeb8\xa3\xc8DGve+\t\x06\xd4\x97^E\xfe\x9c\xbe`\xe5\xda\xd4\'1\xa9,\x8e@%\x11\xda\x94\x8b\x16\xec\x17\xfcy\x13[\xf5\xb6\x8e\x049\x9f?\xcc\xda\xcd\xe5\xd6\xd6\x8a\xa8\x97\xfb$A\x0e\xe3\xe7\xbf\x98\xc3\x1c#q\xcd\xa0\x0b>\xd7\x7f\xc9\xfaSV\xae\xd0\xb4\'\xc8\xb9\xe3\xd9\xb9sd\x9e\xcc{}\xd4\xef\xd0r\xe4\x92\x02j1\xd4\xe5\xfa\x0bk;\xb4O\xe3\xb4\xc3+>\x04^u\x82[\xa5\x12\x03\x14\xd7\xb8IgL\xcc?\x12O\xa8\xaf\x82\xf6\x07\xcb\xf7\xd8\xe0\x8fW\xd2\x04\x1at\x11\x89-M\xa9\x15\x1d\xe5\xdf\xff\x9b\x94`9\xe4\x1a\xe7\xd7\xdeZ8\x8f\xb7\xeda\x97\x85\x82\x83\xd1\x0c\xf7U\x17#\xef\xadU\xdb\xb6\x99Ql\xba\x91\xf3\xd5c\x88\xce\x97t\x00\xc4x\xbc\xe7\xcd\xf1\x14\x9aS\x1eo\xac\xf1\xbe\xac\x9cb\x1d\x80hl\x9b\xdaF\xf0%\xa9"\xc7\xeaB\xcda1\x00b\x06\xdd\xfb\x10m\xf0\x15\xb3\xdf\xb0\xe4\x0c|\x8f\x8a!&Lm\x88\xb0\xab\x8dp\xba\x0c\xa5V\x97\xbd\x9b\xf0\xfc"\xc6\xcf9\x1fr\x9e{\xee\x02\x13\xbe\xfc\xa6\xa9\x89Zb\x87\x997\xaem\xa4\xa3\x0e\xaencM!r\x12r\xac\xd4\x98P\x86\x18\x14\x1c\xef\xe0\xfet\xa9\xf0\x1e\xb6\xea\xbcn\x1d}s\x9fB\x8d\x00\xd8\xed\x15\xc2\x1b\xe3.\n\x9e\xc1\x9e\x1d\x03\x84\x8c\xb1K\x9en\x1f\xed\xec\xc4p\xef\xf3\x95\xc1\x98\xd8\x93\xc7\t\xaf\xdd\x89(Ph\xff\xa0\x0e\xcf\xf8\tP\\\xe2\xcf\xb2\x913u\x87\xa4]`,\xeb\x1e\xc2S\xdf\xf0}\xca\xb8`&\xf0\xd6[\xfe\x92\x85Y\xb2\xeb\x00\xe3\xf5\xd7Th\xca\xd4\xc7\xb05\x998\xcd\xd1}\xf1\x11\x1e\x1d\xad;\xf7\xe2\x80+\x93\x8e\x01\x01W\t[\x8c\x1c`\xa0\x13\x92\x89\xef.\x81\xd0\x02\xc0\'\n\x11(=\xad\xcck\x08\xa0%\x1a\x8fm\xc7\x00`\xf2\xce\xe4\xf3U\x9a\xfe\xe1[\xf4\xd5\x8e\xd1\xc8)\x99\xd1\xe8\xf40#ww\xe3\xee\x1e\x01\xe2r\xc8\x89]\x8cMC\xa7\xb9\x160\xe9\xb4\xd0\r\xc4\x03aJ!\xa0j\xccCw.E\xbb\xe6\xa3!\xf1\xaas\xe7\xbc+h{\xbcV8\xf9AW*7\xb2\x0e\x95x\x88\x18\xe7\x88\xd2\xf6\xbb\xb2w%ES]}\xb7\xec\xae\xff\x95\xcc\xbfM\xe5\x97\x01N\xce\x9c%\xea\xb5Q\xc7\xa8\x18R\xaf\xeb\x14\xaeC&\x93!-t1\x99I\t8\'T\n\x00\xa1\r\x86\x1d\x99\x9e\xa9;\x84\xf4\x8c\xb7\x85\x06\x8f\xc9\x0f);GZ\xd9\x04\xce-\xc9\xe0cG\xfbbM\x99\xdf\x05\x1f\xd9\xb1\x02t"W\xcf\x05\n_\x04\x15\x89\x1b\nHm\x9f\x12\x1a\x8b~\xa6\xb38\xe6F\x10J\xe2:\x84\xed5\'\xffD\x987\x8d\xe6\xe0U0\xdfM\x99\xdd\xb9\x86\xbd4\xfa\x08`\xc8J\x9e\xa4\t\xb5E\x8b\t!\xf8\x98\xde\x86\x9em\xb1\xebU\x1e\xd0\xd2f\xa0\x1d\xfc\x0f&\xbc\xe0\xd1\xd6e\xe1\xe7s\xde\x8a\xa0r\xdc{$\xf0\xaf9f\xca\xd6\x06\xfd\x04\xf5\xa63\xaf1\xdeRW\xfe\x90\x89:l\xbe\xe1nIC\x98\xa4\xf8F\xb2Tr\x07\x135s[\xc9\xf4\xcc\x86\xf2oO\xef\xf8\x84\xd9cH\xb4\xdb\\\xfb@8,W\x9d\xb1d}\xdb0\xd4\x7f\xa7\xea\xa7\x1a\xc0\xb5*\xbd\xd43\xe6\xd7\x7feh]\xb84\x9a_\xcb`\xde\xd4\xb4\xde\x9a\xd0U\xcc\'\x84\xe5_\x12("\xaaj\xda\x1c-\x86\x92y\x88\x92)\xed\xb5\xb7SJ\xcdc\x9a\x19\xed.\xdd\x91\xa1\xcc\xa1\x0ei\xc54\x99\x1e\'\x9e\x02,\xbc\x9fH\xae~\n\x1fP\x84>\xdb$\x89D"\xf3\xe1\x8a\xf3\x00*r\xff\x90\xc9\xba\x1632\x7f\xbf\x92>T\x85\xf7\xc2\xee\x19`m\x078l6/\x11\x9ac\xf1\x9c\x0391\xf8\x15\x8a\x08\x94/K\x93w\x7f\xb9@\xebO\xc6\x0c\x04B\xa6\xc2\x8c\xe8\x92\xd4\x05\xd3u\xd2\xfc\xd0\xa8\xd1\x86q\xe9\x7f\x9a\xb0*\xe3\x1c\xe2\xac\xab\xe1\x9f\xb9\xf0\t6\xd9\x9c_\x8d\xf6\x99\x81^g\x01\xa2\xa3\xd5a;\xe9\xd5\xec\xa5\x17\x81#\xc4\xec\xf9\x029noa|S\x04aX\rK\xe5\xe3eZG\x80\xbbHh\xb7|\x91\x18\xdb\n\x8f\xda\xa8\xb1\xbb\x02\x04\x0f\x9c\xc4\x93\xecV#+\x04\xe2\xd5\x1bO\x00\x9ff\xda\xfc\x9e\x98\x93\x9f\xa0\x04y\xd2*d\xe0(69\xfe\xf3\x9b\xe2\x99\x18\xd8W](Z\x10\xd0\x80\xdab%3|\x14\xff\xb4\x02\xca\xa8\x98\xca\xacv\x12\x95\x1c\xc4M\x8e\x1f\x87x/C\xc40\xd6\x87\x12\xf1\xe5\x15\xb9\xb3\xe7\x7fz\xaa\xd4\xe0\'\xea\x16\xac\r~I\x1d0U\\C\x8a\xcf\xd2:d9~\x8fdkOt\x12\xf8\x8bK\x98\x9e\x7f9\x06T\x94I\x8b\xf0\x1d\xd4\xf9\r\xd2\x99\xc2\t\x1a\xf9\xe4@,\xa4\x84\xb0\xc0\xec\xd1\x0f\xb6GD\xdf\xa0\x045h\x19\xc1.\xd7\xe3\x00\xee\xd4\xc0&\xa80\xa8\xeb{if\xffy\xe92m6\'\x8c\xf4l\xda\xd4u@\xae\xffh\xc8\x9a}g\xc6mb\xff=\x8c2\xb9|\xe80\xb0\xeaa\xb1\xc0\xbb\xae\xd5\xb4\x83\xff\xf7\x97\xb1z\x85v3Nt\x9e\n-K\xb5m\x137Yx\x9b\x1d3\x0e\r\x8b\x02KM7\xb9\'\xe4nJ\n\x046\xb96\xc5G\xcf\xf9oek\xd5#!y>\xa6\xc9JJO=g \x17W8\xb0P\x81u\xe0\xba!+T\x196\xf5\xeb\x11\xbb\x8f0\x89\xbdgY\xab\xdc\xea\xb2\xad2j\xe6\x07\xbb\xd4\xfc\x14\xb8\xf8+\xc3\x9c\x1c\xb0\xd1\xe2\x19\xb0\xcee\x19\x05\xdc\x94B\xa7t\xc2\x16\x9e\xdel/\rnV\x18Xy.\xc0\x83\xb0g\x96%\xb6\xee\xc22\xa4QK\xaa\xd2?\xb0;\x98B\x0f:\xc5\xc3\xa9\xf8tk?\x91\xady\x97\xd5\x85,\x12Z\xb7\x97\x16\xe0\x02\xeb\x05\xf0\xb7\x86V\xe5GO\x94[w&j\xc3t;\xfe\x85\xd8>\xb5\x03\x08\xab\x85\xf2\xb9IQ/-~\xf9\x88\x99:,z5\xe2\xce\xe0\x1f\xceni}\xa2\xc7\x80}\x9bH\xd3P\xbf\xb7\x04u\xd3\x0e\xb9\xaby\xde\xdf=&\xa5.\xd8\xe6\x04__\x85W\xad3%!\xd0\xbf\xa6\x92\x91\xb8\xbc!e\xb6\xd4\xa5\xc2\x8c<8)\xe8y1\xd5_\xa1"V\xd6\xad)\xa1h\x92\xe7\x7f\xdd\xc5J\xf6\x95\xb6k\xb3n\x02\x92>N\x95\xfe\x8c \xa2\xa7\x9f\x0b\x17\xd86\xb9G5\x92rXm\xc4G*\xa6N)\xd2Yv6}T7=V\xb2I\x87\xc2o\xe6\xb7\t{h\x90#{\x10\xbc<)\x974\x934\xdc\xc4J\xacF\x19\xc9\xda\x0e\x1d\x85\xa8|L\xe2\xe6%\xc0\xcat\xd8\x9d\xd2\x0fwAT(\xabS\x1d\x01\x9az\x9f\xd6z\xcc\xe5\x88\xb19\x18\xb4RF\xe3_K\xf9I2\x86.\xe1\x82\x06\xc5\xd3\xf9\x1dH\x1f\xff\xae6\xc5\xcd\xeaI\x9a1j\x1c\xb4\x95\x8e\xba\x1a\x8a@\xfe\xdb\xd2\xd5\x1d\x1d\xe3+\nGY%\x14o\xeb5\xe2c\x04\x17\xc5\x04\x0c\x02o\xa5\xb58Uv)\x94\xc7\xc4d\xf8\x14\x8dm4T\xb3\xd4\xe8\x1b\xb3\x83\t\\.\xe0\x87"\xed\x03\x86h\x0b\x11Bs\xef\xd6W?\xf5\xd6W&\x91\x90\x1f\x1d\xbeC\xb0k\xcd\xff\t\xd7\xa4\xd3\xa0!q\xd6\xdf\xe6\xc3\xd7q\xbf~\x9d\xe4\xe3e\xe7\x97\xa2\x13\x12\xfc\xe3\x16\xeb\x1c\x05\x86\x1f\x9c\x15\xb2!\x19\x05\x89\xf4\xab\xcc\xee\xbeF:\x1b5>\xb0\x08b\x9a\xf9|:\x9c`\xfb\xdbl~\x80\xa5I=\x13\x93um\tn,\xf9\xf7\xf2C\xed\xd7\x98\xc8B{\xd4\x01m\x13\xf9W_6\x84p\xff:\x95\xe0\x80\xbe\xe5\xf5\xc6S.\x80%\xb7\x89\x0by\xccH\xe4u\xd9V7\xdaeS\xf6\xc3j\xf76\xdd\xd1\x9d`\xc3\x0c\xfa5\xdfS\xa4\xbc5\xe3\x85\x98\xc0\xa5G\xad\xb6h6i\x1f\x99\xe8\x81\xc0)\xa1\x9b\xec\xbbb\xa5\xef\x01\xae\xe4{jB\xd8P\xba\xbb\xb1\x12\x11\xa0K\xb4\x81\xa15j\x17\x89xVx5\x02\x01Z\x10\xfa#O\x95\x91\xde\xfcXG\xd5\x19+\xf19j\xdd\xde\x19\x89\x18\n\xc2\x02\xdf-\xfc\xf0f*%\xd6\xb4<\x1c\x7f{\x7f\xe9s\x9f0\x9a\xc0OK\x83\x198\xe4u\xed4Q\x15P\xceZ\xe5\xaa\x13\x96{M\x91\xda~\x9f\xe1\x12Q\x83\x7f\xef\x12\x1d\x91\xc5\x01k\x8d3!\xe6\xbe\x14\xed,P> &n\x9f\xb0@\x91C\xa6{\x85\xd3\x8a\xc76 $\xc7\xd8\xaf\xca~\xae2\xb4J\r\x93\x00\xad\xb5\xd4\x9d\xb4\x0c\xda\xa6xv\xec\x83%(\xec\xd5\xfb\xe0\x8018\x1a\xcc0DL*\x02\xee\x97\xf3\x1c1!\x84\x9fL$\x0f\xfc\xb8\x1bO\xdc\xe9\xfd]\xe0\xb4\x12OL\x14\x95\x98Z\x87\xfe\x1e\x93\x1eH\x04\x1e\xbeB!\xc6\xe3\x13\x80DI\x84\xdfa?e\x95\x15^\x84\xadD y\xbf<\x83S\xc9\xb9U\x9c\x0c@-\x9bg6q4\'\x19\xc1\xa8H\x08,g\xe0\xe9e%\xd1.`\xf3\x03\x0f\xd0\x98\xdf\xd8\xdbw\xf8PEx\x1f\x1a\xd4#5\xa3\xb8\x9bL\xb9k\xec\x954\x0f\x91$M\xa5k\x823\xefR\xe3\xd4\xd4g\xb8;\xf5\xd4\rC\xfb\xe0\x8e\xb2\xf0/\xd5_*Y\x11l\x10qX\xbd\x85\xba\xa7\'\x05)T-\xaf\x91\xd4\xcb\xd27\x88\xee,\x88!j\xe7\xbb9\xe3u\xdcn\xf7\xa5\x9f\'\x84\x94\x8a\';2`\xcay\xb9\x02\x05R\x12\xdb~\x97r\xe1<\xb7\x01\x00\\\xa3px\x9a\x80W\x93\xff\xa5\xb3\xfe\x06Xe<\xf8V\xb5\xb7\xf8w\xcf\x84\x08\xb8\xbed\xae]\xc5\xd3&\x93\x81:Tg\xc2\xb1\xb7M\x11\xba7Tf\xa9\x1fS\x83\x1a\x16H0Ou\xb7\xfb\x0c\xb3J\xb8\xb5\xa3\xa4\xe3\x11\xebS\xfd1Vi\x93X\xa3\x11\xe0\xa4\xda\x92\xb7\xc3\xe5\xe1\xc9~n\x06+eh\xad\xd7\x82\xe7\xe9h.\xbc\xe2\xe9\xbdt}Z\xce\xce\xc2\xe9E\xbf#8\x05\r\x971\xff?Jf\xc7$\xce0&\xd4\x97\xde\xf2\xbf|6X&\x9c\x90\xa9\x9a\xa7b\r\xea\x1a\x95\xb3\x92V\xf6u.\xb4\xf6\x92\x8b\x94\\0p\xf7\xa8e\xe0|\x00\xce|b*\x03\xc1\xb4\xe5\xbc\x14M\xf4\x85\xa9qn\xf9\x00\xc1=\xcc^\x1f\xd1^:\x02QVC;w\xd1\x05?C\x9dq\x93\x12\x0b\x04&\xd3\xe5\xe0\xce\xb9\x81>\r\x80\x8e_\xcc\xaaXzq\xaaZ\x1b\xea\x0cO\xb8A\xe6\xbdZV\xcd\x9f\xc0\xcd30\xb0\x00\xcf0~\x16\x0e-\x97dX\x1d\xbf4U\x0f\x99G\x8ac\xf9\xa7\x95! J\xc8\xd9*\x12h\xf4\x7f\x91\x87\x8d\xb2\xbc.\x83\xfbB0\xf7\x82\xe2F;\xe0&\x03\xb8z\x02\xbf\x11\x94\x8e\x82\xfe\xbb\xe6\x1ey\xee\x0c\xef\xbfz\xdcn\xad2\xdf\xe1\x92\xc88\x8e\xee\xaa\x12.\x9e\xc9x\xd0\x04\'\xb8\x8d=\xa1\xad\xe8\x15]\x0fb?\xf3\x0e\xdc\xf7J\xb3\x93W\x02\xd4\x9f\x084\x18\xc8\xc9\xa0\xe3\x11\xff\x16\xa01&\xf3\xd7c\x16\x16q\xa1}d\xd76\xc6)\xa9\x11F\xcf2\x86\x04\xbc\xf7\x1c\x8c\x8a\xb9\xaa|G\xf3{[)\xbe\x8c\xc3\x96@\xe5\x9f\xbf\xec6\x82\xe3@\x89Q\xba \xd7\x10\x82\xc6\x86\xf5d\x87\xc1,\xadP\xad\x91/\x99\x84_\xfa\xb2\x8c\x83\xdfK\xb2\xbfW\x14\xda;u\xb2\xc0\x98\tj\xd4\x91\xfa(\xfe\x88\xed:\x86\xf1\xb1\xea5\x1f/\x87$\x07n\tCW\x9aS\x9eC\xc4\xb2\xb0>\xfbq\x0f\x90}\xbbs\xd9\x1d4\xdd\xf3kY\x07&\xebs\xc1]X\xd1\x0f\xe8\xb4\xd4\xb7\x1a?\xcaoT\xad\x15\xc6Ou\\-%)]7\xb2\x96]w\\\x84\xe8\x14\xb9\xfb\xe6<\xc7\x18\xe4<\x96Z\xd1\x86\xd4;\xadc\xb7\xdee\xc0M\xed\xffQS\xaal\x11\x9f\xa2\x0e2G\xd1\x81\x04de\xf5\x94\x8e\x90\xb0)\xf8\xe5!7r,\xb4vz\x7f7+\xa2\x9bE\xa0Z\xc13\xfb\xec\xb7\r\xc4\xae\xbe\xdb\xf9\xf6\xf0|\xce;!;*4d\thj\xd5\xfe#l\x9a4\x05$\xcd\x85m\xa8#\xf3L\xbd\xbb\tK\xc8\x96\x15\x08\xfd\xbbI\xa2\xbe\xe4\xa5\x8bG\xb5\xed\x9b\x1d\xdc\x92\xac\x80;\xdb\xbb\xb0/\x8c^\xeb\xe4K\xc8\x98\xe3\xca@\xb7\xee\x80\xaaoJ\x14\xfa\xc2*T\xea\xde=\\R\xa2\xf9\x18\xf5\x9a\xd1\x08z\x02\x87\xf9\xd0\xaf\xed\x00\xf8\x98\x10\xee\x13\xe3w\xceZ\xfa\x89\x01\x91\xa1\xf4\xa2\xb0\xa7/\xb9\x85\xb7l\xf9d\xb1\xd8\xec\xe2\x11\x9dj\x8b\xf9\xe6\xa5M\x0fb\xe7\x8bf\x14\x95\x86\x96\xa2\x01R\xe9\t\xeeeio\xd7I\x89p\xf3\x8e\xc5\xd6\xdf~;\xb3\xb2\xe0\xe1\xd6\xc5B@"7;\x15\xce\xea\xad~\t\x9e\xfa\x87VB\x0f\x1b\x9d\x8d\xce<9\x9c\x16\r\x0b\xbe\xac\xc4\xe0\'\xe9p\x17\x02\x1bwbb\xcf\x0b\x0b\x89\xbf\x1b\x97\xc3\xfe\xfc\x05z\xd6\xfe\xe0\xb78\x9d\x01\xab\x1eO\x9av\x172\xb6\x8d\xbbt`\xdd[2\x07Z\xce\xd0\xa9&\xf1e7pO`\xbfY\xce\xc2\x8b`\xc41\xf4\x90\x80\x1d\xd73\x1cJ\xef#\xe1\xff\xd4\xe9\xfb9\xc8\xf4GL\xd2\xd5x\x06\xd7\x83:\xaa-vM^\xf4c1\xa9\xc3\xcf\xe5\xc0T\xa9\x03\xab\xab\xf0\x97\xc4\xf6*]%\x0e\xdc\x84\xdc\xa5\x1f9fw\xceIT\xfe\xa80\xc38d\xb2\x06\xf9s\xf5\x94i\xc7\x94b\xack#\xb6\xe5_\xcb\x90\x82;\xfa\xde\x04mz\xc7\xd5\xcd[\x90o\xdb\xdd\x16\xcf=JR\x11\x85V\xa6f#_4\xa2>\xc9\x82\xf6\x8bq\x16qT\xdd=%\x8eR&\xc6\xb5l\xd7T\x0b\x17\x98\x90s"\xaa\x0b>\xbe\xea\xae\x89\xa3&\xd0)\xdf\x08ewUf\x8ae\x85\x98\xcb\xa5V\xf8\xa4?"*\xc8\x98\x9b\x8d\xebl\x05\x83\xb5&\xe5\x1a\x93Wj\xf4\xb4\xcf\xb6\xb6W\x00\\\xaa\xc1\xf5\x0e\x03\xdd!\xb5\xa4\xeb\xb4]\xb0d\xdb@\xff\x8du:fc\xb0\xaaq\x9e]vA\xf6\xa7\xa7:<\xd9\xbe\xa1_\x82~\x84\x9cz\x80)\t\xc0\xf2 \x03*\x90\xcbjd\xbc\xe1\x9dKo\x9b/[\xffUH\xef\xe7\x14\x8c`\xa8\x86\xb6qw\xb0\xc4\xde\xda\x12\xe7\xc2\xdd\xd3#c\x05\xbf\xac\x91\x83\xfb\xfd\xc4\xa7\xe0\xb3%\xb7c\x83\xc0\x0e%-\xf0\xaa\xc7\xc6\xc3\xd5\xa5\x02zw^\xbcp\x9a8\x88(\xfa\xccJ\xdfR\xc9&\xc3\x92O\x057\x1eL\xf8Z\xd7f\xe4v\x9f\xc0\xc1\x13ya(\x1c\x04\x90\xd9\x02~\xdd\xaf\xec\xf4gk\xfcI\x17\xf9\xbc\xa9\xc9\xef\x19 w\x9c\xc0\x92^|\xf3\xfb\x8c\xa1\xcf\xd7\xa4\xce\xfe\xa8d\xd3\x94\xa7\x0b\x03\x92\xcf\xa1?\xd6%\xa5`\xe3\xe8M\xf0\x9b\x0f\x82\'\x9a\xc2\xc8\xf3a\x83n+\x85\xcb\xd6Q\x88\xc9!~\x8e\x8c\xae!\xff?\x81\xf4\n\xab@\xe7\xf9;N\x1f\xc8g\xaf\xf0\\\xbcr\xfc\x1a\x0c\x14\xda\x1aJ\x16N~\xa4\xae\xdd\x83D\x16B\x1a\x99\xeec\x1f\xfa&\x0e\xf5D\xd3!\x03\xe7\x11\x14<\xfc\xc3\xd6[=\xa5\xa1I\xd8\x13\xf5\'\xf2:R#7T0&\xaby\x1b+\xc0>c\x14\x13\xf6\xc02\xed\x84\xb0VQ;\x1d\xe8\xe6,\x8f\x86g\x8a\xc0w\x1f\xe3\xca\x15T`\x13\xdc\xf7\x10R\x12\xc0\x8c\xa1\xfc\n1zH\x8f\x11\xf9\xa1\x13\xdd\xe6"b\xc3i,\x0b\x9d[L\xd0\xb4\x10\xb5o\x1e\x9f\x03\x1er\xf79%\xd9\x85\xe3Q\xa5}\rP\x0f-\x95J\xab|\x90l\xd2ay\xf0\xd7eN\xb3\xd0\x0f\xea\x8b\xed\x9c\xca{S\xc3\'\xbb\xb4\xc8E \xc6\'\xe2\x81\x0c\xbf\xc3v\xfd\x1a\xe2\xb8\x9c\x17\x84\xcas\xdc\xfbHM\xf37q\x13\x19qf\xb8M\x1d\x82\x03\xb5\x85\xa1*\xeb!\xfa\x8f\xb1\x13\xb6m\xdc\xe9\x80\xe0\x0c=3\xac\xbd\x1a6\xdenx\x86:-qg\x10\xb1h\'D4\x9eih\x89a\xaaOt!\x07\xdd\xe6\x95\xb5\xc4*\xde\x04^\xfe0\xaae\xc8\x18\t^\xfb=\x04\xc6\xb8\xbe\x8e\x8a\xdb\r$\xe9\xdcZ\xcc\xd3\xe4\x05\x80\xc2G\x9d,"e\xc2\x9a>{\xab\xfa\xc7\x9b\xf8+\x0bv*\xd4\xe4\xcf\x9e\xf2\x8a\xf9$H\x04\x06\x942\xed\\3Av\xb4\xe6\xcb\xc1L\xe8\x94\xe9m*M\xd9H\xa6OO\x9c_\xab\xa0h~\xad\x00_\x02\xd7\xd5pF\xb0\x08\xd2J0\xd3\xb2n)\xbc\xd7|\x1d\x0ed\x19\x0b\x8aUQ\n\xc9\x17\n3\xcd\xf85\x7fG~x\xa6\x97?\xe5z\xe2\xc2\x15+"\xd4\xe5\xec\xa8\xbeC\x085\xe1\xfe\x88I\xeb|l\x1f$\xfa\x1bW1\xd8\x83\xba\xd8"\x18\xa8j\x1eLn9\xae<\x88-\x8d\x1c\xa4[|\x0c\x87t\x86\r\xe6\x9b\x18\xfcR\x93\xe4L\xfcD\x8eXn\x92\xc3/O\xec\x98\x87]j\xc0ICv\xear\xed\xfa|\x13j\xa2\xa9\n\xb3\x9f\xb7\'\xe5\x81\xben6\x0b\x17)s\xd3z"\xc4Qf\x95\x16h|\x8d\x91f\x03s\xccr?\x1c\x17\x98\r&\xfdV\x96cs\xb5\x96g\x97\x0f\xdf5)(\xcf=E\xea\x9e\xf3+km\xd6g@\xe0~\x96O5\xfb\xcb\xa3\xa9\xab\x99\x16(\x92\xb8\xdf\xfb\xfbp\xfb~s\xe4\xc2\xc5o\xb5z\x1d\xcex\x87\xea\xf4\xfd\xbfB\xea\xbeK\xfd\xaf\x87\xab\xe4\xac\xfa9\x9d=Xd\xc8V\xa9\x11\x1b"\xa7q\x00N]\x89\xa2D9\x85\x87,lW\x89F\xa8\x16\x88w\x0bJw\xde0\xd1\xcd\x8d\xd7&\xd0;\xbdne\xdbA-\xc4@@\x8aGdj\xb0t%U\xf1\x9eR\xb8\x06kR\x05\xf11\t2h60\x80w\xe1\x83\xa3E\x87\xbe\xb5\xcc\xcc\xb8\xd1\x9c9A<\xd1i\xbcm\xf8XW\xf3\xf6\x0f\xf1\x89\xa0\xaaI9Z\xc7\x0exx\x02r\xc4\xc5xIw\xcfj\xb6\xb9dWf\x01\xab\xc2\x8f[\xfeJ\xf3\x1b\xbe3\xd0N4\xaf\xb3\xa7Yi\x9e\x8f\x05\x9a\x07\x06\x19P \xfc7\x1b\x97\xf5\xb5\x9e\xdc\x8e\xb1K\x18Z-\xb0\xed\xf6\x83\x8b\xac\xe3\x89\x91\xa2\x14IGNj\xe2\xc8\xdb\xe7\xc6\xeb9\xb7\x0b\xdf\x03\x0c\x95\x95\x9f\x9c\xa2\x87^\x87\x84C\xe9\xbfT\xbf\xca^\xfb\x1d\x01.c2\xe6\xb5]h\n\xf8\xb7\x16\xd3\x18\x88)\x0ccJ\xaf\xc8\x9f#*N\xbe53\xc7Jo\xc8\xc9\xb6\xe0\x1cp\xe7\x98i\xf3\x0f\xa8\x89\xf9$\x99D\r\x86\xbf\x9b\xbc\x8fi\xe8\x8a\xc5\x89\xb8\xe90\xed\xae1\xd4\xf4\x9ef\xbaN\xbd1YR<\x87a5)\xb0\x16\xc3\xed\x85\x0b]~:s\xd93\x8b$*\x0c\xe9[\x1b\\F\xcd\xb6\xa7\xf9$>\xa2\x92\xf6\xc6\x10/\xed\x7f\xa7E\x12M$\xcf\x89\xf1\n|\xfdG\xc0\xa4\xd9\xf5=x\r\x08\xa5\x9b5\xbd\xf8\x07aQZ\xd5\xb0\xaa\xd9\xbb6\xf0\xcb\xba\xe5D\xcf\x12\xd9\xf3_J\xfc\x9c\x8bM\\B\x92\xe959c\x9f\x88\xc5y\xbf\xab\x05-\xd2\xd3=)\x1e\x80\x13\xa6\x02\x98}uA\xb19\xfe\x07&\xbf\xa8~\xdbw\x13D\xd9\xe8\xcc\xbdJ!o)j\xf3\x1b\xa9\xce\x81\x94\xef\xc2\xac!\x8f\xdb<\xd3\xf2\xe1p\xec\xa5\x84\xc6ew\xa4\xa4=&\xa1\x9c\xa3\xa7\x14\xaf\xc9\xd9\x93\x99.(7\xc5\xff\xb6\xfe6\xcf\x14:\x02\tu\x9c\xf4\xe8\x03\xc5\xcc\xbb\xb0Kv\x1bk\xf4O\xc4\xef\x1d\xde#M\xf6\xc4pc\x1ch\xc8]e\x83\x06\xcd*\xb9\x11\xe0A>\xc6\x19\xad}9\x12\xb2\xda\x9ae\xda\xb3\xa4\x7f\x8c\xc0\x9a\x88\xe6\x10v\x83m\xc8\x0c\xc8\xe85\x97\x8a\xf3E\xbf\xa2\x1d\xe3\xde\x83K\x91?\xf2?\xa3\xa4\xdc\x82\x7f\xba\x13m\xab\x8e\x9b\x93,\x1a2\x8b\x19\x96\xf2\x04\xa2%\xc2\x88\xe5b\xaf~4\x80Q&\xed)z\x1c\xf7dU5H\xe5\xe0\x0b(\x0f\xc4P\xb9\xbf\x9b\xdfk\xc9H\xdeM\xfd\xb1\'\xb3\xaa\x94\xe89-$\x81\x1c\xc3zG\xfb\xb5\'\xf2m\xf1Am\xcaz\xea\xadq\xef\x8a9\x9e_\xb7\x95\xa9/\xd2H\xc9x\xf7ut\xa3\r\x84\xc4(\xe8\xfd\xc2\xd9\x85+E\xf3\x08\xdc\x12^{Gn\x8c\t%`1\xc7m\x93u\xd3\xf3\x17FY\xdd+FaA\xb9\xfd\x1fb\x05\x95e\xd0\x1d\xa3\xf0\xd3p\xbb}\xcfV\x00\x96\xc5\x9c\xfa\xc9\xda;\x99\xa8`{\x1a\xe0\xb3a\x9d\x8f\xf1c\xf4\xe1\x7fR\xf5j\x07\xd6\x9a\x11D\xa45s\xecx\x15\'O\xd8\x06\n\xecp_\xbf70\x9a5T~=\x91UR\xe0\xa5\xd1\xa8Jki\x0e\xbf\xde*\x1d-\xf0*\xf2\xab\x18\xac\xea\x03\xfa\xd6\x9a\xe18\xc0\xda\x1e\xc7\x90b\xc0$\xd3\x84\xbe\x97\xc5\x7fv\xe9\xa7j\xe8h+A\xa3\xad\r\xf9\xbc\x85W\xc4\x9b\x03\xcd\xc9\r\xcd\xb7\x06\xd3\xae\x9ds\r<\xc48+\x06\x18\x07>\xcf\\\x06\x1dA\xf3\xb8\x8e!SW\xebeSNw\xaa\x80\xf3\xbc\x15\xa3\x90P\xcf\x9f\xbe-/\x10\x8c$\x04\xafT\xee\xfd\x87C\xaaqX\x7fx\x96\x06{\x0e\xcf$\x9d\xa0\x91\xfc\x9a\xf0^\x0b\xc8\x94\x0c\xd2ce4\xab2UW\xcf\x06L\xab$\xef7\xbe@;5I]\x88\xbd7,\x01\xb6\x8c\x7f\xd2\x0b\xd3N\xae\x05NF\x9f\xccRV\x01\xdf^\x1dv0\xaf\x89\x9aQ\xc6\xe95;u\'tG\xb6\xf2\x97\x12\xfc]\xb1\x87\xa8\xe5\x85\x04AV\x9b\xd6\x82\xa0+\xdfq\xc3P\x8e&\xe3\xaa\x07\x85\x9d\x92|\x02OP\xc9\x12\xd4D\x16\xe1,\x80\x05\xcf\xd2\xa6W\xcch\xf8d\xa9\xd3\xc1S\x81\x98xi\xe4\x80V\xf83\xa4\xdd\xbf\xfd\xac\x14\x14\x8f\x9ci\xba\xeb\xbc\xf9\xc6\x92\xb0`\xceG4d\\\xcfc\x029y\xab5\x95\xe8\xcc\x83\x06KC\x93\xff\x0cS\x83\xeb\xa7\x93\xc8\xac\x98\x8c\xeb\x8a\xdf\xe3!\x17\xfa$\xe3\xc3\x9e!\x82m\x15.\x86Pls\x0b\x97oJ\xc2T_b`\xe8\xd7\x03o\xceQ\x04\xa6\xf8\x92\xa8\x00\xa0\x92\x7f\x18\xcd\xcf\x8f\xf5\x9f\x15Ok\ri\xeb\xad\xaeM~\xaa\xf6y\xcf\xe4:\xabl+\x99\xb5i\xa6\x99\x8bR\n\x9f\x9c\xd9\xc6\xd4Z\x84\xea\xceV\x87Ov\x10s\x14Xh\xc3\x1c\\\\\x1f\x99<\xc8\xed\x82k2\xca \xd43{\x8c\xc4\xd3]\x8e\x02\x82J\xc7\xe8\xbb?O\xca1\xe5\x1c\xad1}\xd2c\xcb\xff\x18\x11H8?\x07eC\xada\xcb\x05\xed\x81\xe9]@\xadN\xa6t\xe83\xc5v\xe9\xcf\xd2\xf4e\xf5\xdb\x06\xf8`\xaejS\xbc\x9a\x18\xa4\x18\x9e\x96IR3hT \x97\x87`l\xaf\xfb\xc5gu\xc0\xb26\x97\xfad\xa4\xd34/\x82\xecW\x7f\xf2;\xd0\xc4WJOS~\xa5\x98\x03x\x14\xe4\n\x98\xf5\'R\xf2\x8a\xf6\xa9\x80\x86\x81\xc5\xffR\xca\x84\x9d[{)6\xc6\x11!l\x10\x9a\x83\xd5<\xecO\x14$\x0fF\xff\xab\xc7_\xef\x055w\xe8;\xa4u\xbb\x83y\x0e,\x80\x0c\xfa#]\xc1\x08\x0f\xd5\x0e\x88k\xac]C\xb8\x96\xc9&A\xcd\xf2v?\xcd\xf81\x05\xd9\xe3\xe8Gr_\x1e\x1a6!\xd7\x99\x8a\xa8d\xb5\x91TD\xa7v\x9ct\x05\xba\xad\xc4\xff\x88\xa1B\x15\x9e\x96\x85\xe0,\x079\xfaIy\x17"v\x9f\xd3\xff\xe5Y\x8d\xad%\x1ac\x82\xb9\xfc\x8b\xcd\x80\x9d\xddXx(s\x0c\xa4\x1e\x8bMJ\xfd\\\x81J\x0bV\x04`\x8a>|\x1dVx\x02\x9f\r\xf9}\xd4\xf9:\xc4G\x82d\x1d\xa6\xd7\xdf\xe7\x8c\x05\xad\xa6i"\xa6\xee\xa2\x04&\xb3?\xd6\xf9\x93\xc4\x0f\xfc]\xa8F\xc5\x8a%2,\xcdI\x98\xb9\xf0y\xed6\x13$\'\xd2\x00KCNZW`\xb5\xae\xa0\x1f%\xf9\xdfX&\xbc\xb2\r[Sy\xe5j\xba\xdb[FTY\xb8C\x18+G\xb4\xbb/Fg\xdbpP7\xecX\xb7\x03\xb8\xa6\xc2h\xac\xee\x97~\xf8V\x0f\x0f\x97\x8d\xd3\n+\x11u\x19\xd3\xe5@\x8e\xc0Q\xaa\xfa\x1f%\xaf\xfc]\xe2gO/\xf9co]\x86\xba\x9d\xa5q\x1c\xcb\x9e\xf0dFE\xdc\xcc\xb9\x1b\xb0\x06\xe6\xcc\x917$+fg\xb9\x11Y%\xd3g\x8e\x04ur\x04\x1dK\xb31y\xbb\xceQ\x96\xb9\x1cf\x83\x0er\x04\xe6\xde;\xc5C^\xf1\x85\xfd\xc8\xa6\xe2y\xdfL\x16\x86ud\xe2,\xe3\x0bDm\xeas\xea\xa1\x05\xcb\xc6`I\xbb\xd7\x9c "mj\xd4 \x95;T\xa9\x9e[\x95\xdf\x99PT\xe84HK\xe57n\xa8\xb35k\x85\xe0\xd2\xb9w\xb8p\xd8\xc6\x83\xcd\xa6+y\xda)\x7f\xa0e\x9e4\xb1\x97\x06!k\xae|\x86\xd4\xd5+\xb5\x15\xb7\x1a\xa4H\xbe\xc4\xfeS\xfc\xb9}\x86K\xef\xe3z\xc7?\'JK\x1f#\x99\xf4\xf3\x0b\x1a\xc2|\x98\x03\x08\x0by\x8c0\xe9\xed\x10\xfa\x1eKzO\xac\xc6\xe6Rc\xda\x0c\x98t\x1e\xa16\x1b\xdf\x1c\xc7\x84,\xc9\xdd0\xd7\xdd_\xd3&lGJN\x0fi\xb9\xec\xa4o%\xe9d\x9c?\x16\xe6\xcf,\xb9\t\xd0\xc1s\xa2M\x9f+r\xd2\xb6Q\xa4\\\x08@H\xb5\t\xad\xd2\xde\xa7\xf3\x06\xe3\xd1V\x01\xab\xa7\xd8w\xd8\xf5\n\xa3\xc7\x7f\xf8)\xe8\xd3\xdb\x0e\x9c\xab\x95\xca\x06\xe0S\xee\xd9T\xe3\xcbE\xe0eDRpeZ\xe9\x9e\x02\x85z\xa7\xa6\xa6\x9f\xc9\xc0\xe6\x92>\xdb(\xd7g\xdc\xfa\x99W[\xf3\xcby\xd1\xba\xce\xeb\xad\x89\xea\xe3\xf7\xf7\x86B*\x10\xf1\xfb\n\xb3\xc9\xa7\xaa\xaf\x1f\x1c)g\xa7\x15\xcd\xd5\xdc\x9fZU(\xfa\xa4\xd0we2`\xecg\xb8\x82\x0ci\xce\xdf&\x9deO\xe1b\xa1-\x80M]\xfa^H\xab\xa6\xe3\xae\x16\xf2\x8c\\A\x86\x90\x1eV\x1a\xb2\x12\x8ea[9\xcfA\x02p](A\xe2\x13\xe7E:\x89\x92*\xdf~j%\xe9\xbe\xb2([V\xcd\x7f/\xfb~6\xeb\xc8\x17\xfa\x0e\xf1\xa9v\x99m\xc2.T{\xe1\xca~\x10\x06\xc3\\\x9c\x7f\x8f\xdfR\x08O%\xaf\x8c5\x15\xd0\x1cJ\x92\xb2 !\x8fo\x8b[\x128\x8d#K\xf9\x08\x15N493\xe8\xb2\xf4\x1dP\x11\x0e\xe7f\xc0{}\xb6{\xe8\xdc\xe5O\x9c\x03R^SY\x0c\x8c:\xb2\xf8[\xfe\'\x14J1\x86[\x00/r\xe7\xf8\xa6\xb8\xfb\xfc\xff\x0b\xae\xd4\xdf\x8eQh~\xa2\xfe\x04T\xd42\x0f\x9by|8\x92\x90P/\xed\x97\x9e7\x0c\xea\x18a\xaa\xc1\xbc%s\xb3\x1cjl@\x14\xaa\xa5%\x7f\xeb\\\xe2\x00\xa9\xbf\x10\x01\xecA\x8e\x12R\xbd\xe4\xec\x18J{\x98\x07\x14\x1c\xca\xd4a\x95\xff\xb0t0\x11\xdc\x85\xbb\x172\\Hd]\xf7\x9e1\xabL\xd6w\xebeb\x0f\x97\xa4\xa1T\xdbs2>\xda7[\x8c\xb9*!\xb3\xc4)\x9c\x15\x9c`\xa6s\x92y\xf1\xd0\x9f?\x91y\xe9\xc9|YE\x00{\xed\xe2f\xae\xfd/\x08\xc8(\x1b\xcd1s8\xafpz\xa0\xf7\xcd^Y2\xe6R\xbc!\xd7\xb3\xee\xca>\xe4\xf1\xbf\xbf`\xb0\xe8/MA\x7f\xe5\xd3\xf3\x17,\xa7e\xa7\xd800\xa1\xa1\xabB\xf2\x05Dl\x05`&\x93"\xb5~eM>;@\x9d?\x10\x06EF\xe9\x89\x1ac}\xc1\xfb\x97\xb8\x01\nU\xb9\xcc\xe4Y?h/\xd3mv\x8a\xb8kQ\xe4\xce7\x96\x99N\x03-\xed\x97vKH]\x17h\xed`\x0c\xcc\xf1C/A6O\xf3\xc8\x02R\x82\xe8\xa5\x85P\xb8\x1d\xa2\x1b\x18\x18\xe3\x13X\xc6\xb1\xfaOo\xd3Q\xbdja\xe6\xda\x1b\xcenc\x96\xf7\xa4\xe02\xd0\x83<-\x90\x17\xb7\x0c\xef\x98\xb0\x07\x87\x97\xd3\x86\xe1\xb9\xa6b\xb4\xfb\xd1Ng?\x04\x94\xa0\x04Y\x9bEB\x08\xb3\xce\xb0\xaf\xc7\x86\x1b\xba\x94\x83\xa6 \x8a?\xa7F\xd6\xd7\xb1\xd9\xdfH\xd6\x1d\xb6\xfe\xcf:\xf7\xe4k-\xec`\xdf\xa1o\x85O\x8b\xeaK5\xdehQ\xfaG\x94\x9b\x06\xfd\xc8>I.\xf9^V\xd4\xeebn\xe7\xc9}\x9a\xe7W\x03A\x86\xd9[\x90\x97\xd3\xd3i\xe8\xfc\xfa\xba\x8eO\xed\xe7\x12:\x94g\xa9\xd7\xda\xd7\xe9\xa6t\xd7\xaaX\xe5:\x84\x17\x03\x90\xad\xba\xab\xb7\x8d>\x1fa\xfbp0B&\xb4\xc0\xdc\x01Rc\xe4\xb0\xf6\xec\xd8\xa9W\x7fd\xc8\xf4d\xc3b7\xe4\xbc\xb9j;`l\x8bc_6\xd7\x06\x8e\xf87\x9eVq\xa1\xd4\xb4\xf8@\x81b\xc9\x92\x85Y\xbd\xf5\xef=+\x81\xcc\xa1Q_i\x0fxu\x96f\xddN\x14x\xfd\xeeHjR\xb3D\x97\xc8\x9cR\x85\xed\x06\n3K\xcb\x1b\xb4\xa7\x90\xc9\xa4aH\xe2\x89\x85\xd1\xe02\xc0\xf0\xd5\xbeD\xa3\x00\x86Y\xa6\xee<\xa4\x062}Z0\x9b/\x1e\xa8\xc1\x9f~f\'\xe8\n4\xf3\x00\xe8\xe2~\xa3p\x84{]\xbd\x0b\x9f\xb5\x08\xad\x97\xf9\xdbB>\x99XJ\t\x08W') diff --git a/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/__init__.py b/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..6f552240344d06f4e3f53981af93c87ce5bcfdc9 --- /dev/null +++ b/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/__init__.py @@ -0,0 +1,2 @@ +# Pyarmor 8.5.12 (trial), 000000, 2026-09-09T18:33:48.325537 +from .pyarmor_runtime import __pyarmor__ diff --git a/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/pyarmor_runtime.so b/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/pyarmor_runtime.so new file mode 100755 index 0000000000000000000000000000000000000000..6f0c69a3d075f0cb06d7180f79188924ae0165bf --- /dev/null +++ b/collector/core/gripper/sightac_sdk/pyarmor_runtime_000000/pyarmor_runtime.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6f8655b0125d80acc0d8bf62bc2bf97beae5f88d23f0b0b8f60c8a5473cd68ca +size 796488 diff --git a/collector/core/gripper/slam/__init__.py b/collector/core/gripper/slam/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..faf0994833b995afb08d066a0d5b0707ed19f220 --- /dev/null +++ b/collector/core/gripper/slam/__init__.py @@ -0,0 +1,12 @@ +"""core.gripper SLAM 子集:桥接进程控制器与 stdout 协议。 + +原版 barrel 引用的 frame_reader(/dev/shm 预览 jpg 读取)未复制;主程序 +双目显示走 orb_raw_stream 原始流(recording.fays_raw_client)。 +""" + +from __future__ import annotations + +from .process_controller import SlamProcessController +from .protocol import PoseSample + +__all__ = ["PoseSample", "SlamProcessController"] diff --git a/collector/core/gripper/slam/process_controller.py b/collector/core/gripper/slam/process_controller.py new file mode 100644 index 0000000000000000000000000000000000000000..ed1fae1332ca06aa9513b586fde31c5ccf9e8dcc --- /dev/null +++ b/collector/core/gripper/slam/process_controller.py @@ -0,0 +1,1157 @@ +"""Lifecycle owner for the FaysSense ORB-SLAM3 bridge process. + +Lock order is ``_lifecycle_lock`` then ``SlamState._lock``. Stdout callbacks +are invoked without either lock. All terminate/kill operations are centralized +in this controller; callers only use ``start()``, ``send_origin()`` and +``stop()``. +""" + +from dataclasses import dataclass, replace +import json +import os +import queue +import shutil +import socket +import subprocess +import threading +import time +import traceback + +from core.gripper.runtime.device_access import device_access_guard, FAYS_SDK_INITIALIZATION_LOCK, fays_config_device_guard + +from .protocol import ( + PoseSample, parse_slam_line, pose_rejection_reason, quat_conjugate, + quat_product, rotate_pose_z90, +) + + +STDOUT_QUEUE_CAPACITY = 2000 +NATIVE_LOG_FLUSH_INTERVAL_S = 0.1 +NATIVE_LOG_FLUSH_LINES = 50 +PROCESS_WAIT_TIMEOUT_S = 5.0 +WORKER_JOIN_TIMEOUT_S = 2.0 +STDOUT_JOIN_TIMEOUT_S = 1.0 +FINAL_WAIT_TIMEOUT_S = 3.0 +STALL_TIMEOUT_S = 5.0 +MONITOR_INTERVAL_S = 1.0 +RUNNING_REPORT_INTERVAL_S = 60.0 # 心跳行稀疏化,避免刷屏;卡死检测仍 5s +ALLOWED_NICE_ADJUSTMENTS = frozenset({0, 5}) + + +@dataclass(frozen=True) +class SlamSnapshot: + running: bool + pid: object + status: str + raw_pose_fps: float + valid_pose_fps: float + last_frame_id: int + stalled: bool + error: object + stdout_backpressure_count: int + pose_lost_count: int + + +class SlamState: + """Single mutable state source written only by ``SlamProcessController``.""" + + def __init__(self): + self._lock = threading.RLock() + self.process = None + self.running = False + self.status = "Disconnected" + self.raw_pose_fps = 0.0 + self.valid_pose_fps = 0.0 + self.last_frame_id = -1 + self.stalled = False + self.error = None + self.stdout_backpressure_count = 0 + self.pose_lost_count = 0 + + def snapshot(self): + with self._lock: + process = self.process + return SlamSnapshot( + running=self.running, + pid=getattr(process, "pid", None), + status=self.status, + raw_pose_fps=self.raw_pose_fps, + valid_pose_fps=self.valid_pose_fps, + last_frame_id=self.last_frame_id, + stalled=self.stalled, + error=self.error, + stdout_backpressure_count=self.stdout_backpressure_count, + pose_lost_count=self.pose_lost_count, + ) + + +class SlamProcessController: + """Start, parse, monitor and stop the single Fays bridge process.""" + + def __init__( + self, + state, + *, + executable, + vocabulary, + settings, + device_config, + trajectory, + work_dir, + runtime_env_factory, + cpu_roles, + on_pose=None, + on_fays_rates=None, + on_orb_diagnostic=None, + on_mp_cleanup=None, + on_status=None, + frame_snapshot=None, + log=None, + process_factory=subprocess.Popen, + sdk_device_guard_factory=fays_config_device_guard, + thread_factory=threading.Thread, + clock=time.monotonic, + wall_clock=time.time, + sleep=time.sleep, + taskset_finder=lambda: shutil.which("taskset"), + nice_finder=lambda: shutil.which("nice"), + stdbuf_finder=lambda: shutil.which("stdbuf"), + nice_adjustment=0, + set_affinity=os.sched_setaffinity, + get_affinity=os.sched_getaffinity, + on_process_stop=None, + auto_origin=True, + native_log_path=None, + pose_paths=( + "/dev/shm/orb_pose.json.tmp", + "/dev/shm/orb_pose.json", + ), + ): + self.state = state + self.executable = executable + self.vocabulary = vocabulary + self.settings = settings + self.device_config = device_config + self.trajectory = trajectory + self.work_dir = work_dir + self.runtime_env_factory = runtime_env_factory + self.cpu_roles = cpu_roles + self._on_pose = on_pose or (lambda _pose: None) + self._on_fays_rates = on_fays_rates or (lambda _rates: None) + self._on_orb_diagnostic = ( + on_orb_diagnostic or (lambda _diagnostic: None) + ) + self._on_mp_cleanup = on_mp_cleanup or (lambda _diagnostic: None) + self._on_status = on_status or (lambda _status: None) + self._frame_snapshot = frame_snapshot or (lambda: None) + self._log = log or print + self._process_factory = process_factory + self._sdk_device_guard_factory = sdk_device_guard_factory + self._thread_factory = thread_factory + self._clock = clock + self._wall_clock = wall_clock + self._sleep = sleep + self._taskset_finder = taskset_finder + self._nice_finder = nice_finder + self._stdbuf_finder = stdbuf_finder + self._nice_adjustment = int(nice_adjustment) + if self._nice_adjustment not in ALLOWED_NICE_ADJUSTMENTS: + raise ValueError( + "Fays nice adjustment must be 0 or 5") + self._set_affinity = set_affinity + self._get_affinity = get_affinity + self._on_process_stop = on_process_stop + self._auto_origin = bool(auto_origin) + self._native_log_path = native_log_path + self._pose_tmp_path, self._pose_path = pose_paths + self._backend = "orb" + self._runtime_arguments = None + self._service_container = None + self._service_host = None + self._service_port = None + + self._lifecycle_lock = threading.RLock() + self._process_stop_lock = threading.Lock() + self._service_lock = threading.Lock() + self._service_active = False + self._stop_event = threading.Event() + self._worker_thread = None + self._monitor_thread = None + self._generation = 0 + self._fake_imu = False + self._origin_sent_pids = set() + self._initial_origin_callback = None + self._initial_origin_generation = None + self._pose_buffer = {} + self._pose_buffer_lock = threading.Lock() + self._last_accepted_pose = None + self._pose_rejecting = False + # 原点后姿态相对化:设原点事件后捕获首帧显示姿态作为基准, + # 此后所有姿态左乘基准的逆 → 第一帧姿态恒为单位矩阵, + # 帧轴与轨迹同基准(相对原点),见 _publish_pose。 + self._pose_rotation_zero = None + self._pose_rotation_zero_pending = True + self._last_pose_reject_log = float("-inf") + self._unmatched_lines = 0 + self._started_event = threading.Event() + self._sdk_ready_event = threading.Event() + self._sdk_initialization_done = threading.Event() + self._pose_raw_seq = 0 + self._pose_lost_count = 0 + self._last_accepted_seq = 0 + self._latest_pose = None + self._latest_pose_lock = threading.Lock() + + def wait_sdk_ready(self, timeout=45.0): + """Wait for SDK + factory calibration, not SLAM tracking/origin.""" + if self._backend != "orb": + return self.wait_started(timeout) + if not self._sdk_initialization_done.wait(timeout): + return False + snapshot = self.state.snapshot() + return self._sdk_ready_event.is_set() and snapshot.running and not snapshot.error + + @property + def running(self): + return self.state.snapshot().running + + @property + def backend(self): + return self._backend + + def set_backend(self, backend): + normalized = str(backend or "").strip().lower() + if normalized not in {"orb", "aikit"}: + raise ValueError(f"unsupported localization backend: {backend!r}") + with self._lifecycle_lock: + if self.running: + raise RuntimeError( + "cannot change localization backend while SLAM is running" + ) + self._backend = normalized + self._runtime_arguments = None + self._service_container = None + self._service_host = None + self._service_port = None + self._log(f"[SLAM] Localization backend selected: {normalized}") + + def snapshot(self): + return self.state.snapshot() + + def pose_buffer_snapshot(self): + with self._pose_buffer_lock: + return dict(self._pose_buffer) + + def clear_pose_buffer(self): + with self._pose_buffer_lock: + self._pose_buffer.clear() + + def read_latest_pose(self): + """Single-slot non-blocking read of the most recent accepted pose. + + Returns ``(pose, raw_seq, lost_count)`` or ``(None, 0, 0)`` when + no pose has been accepted yet. This is the dedicated control/GUI + channel — it always returns the freshest sample without queue + contention. + """ + with self._latest_pose_lock: + return ( + self._latest_pose, + self._pose_raw_seq, + self._pose_lost_count, + ) + + def pose_lost_count(self): + with self._latest_pose_lock: + return self._pose_lost_count + + def _set_state(self, **changes): + with self.state._lock: + for name, value in changes.items(): + setattr(self.state, name, value) + status = self.state.status + if "status" in changes: + self._on_status(status) + + def start(self, generation=0, fake_imu=False): + """Start one worker. Existing process ownership is released first.""" + self.stop() + with self._lifecycle_lock: + self._generation = generation + self._fake_imu = bool(fake_imu) + self._initial_origin_generation = None + self._last_accepted_pose = None + self._pose_rejecting = False + self._last_pose_reject_log = float("-inf") + self._pose_raw_seq = 0 + self._pose_lost_count = 0 + self._last_accepted_seq = 0 + with self._latest_pose_lock: + self._latest_pose = None + self._stop_event.clear() + self._started_event.clear() + self._sdk_ready_event.clear() + self._sdk_initialization_done.clear() + self._set_state( + running=True, + process=None, + status="Starting", + raw_pose_fps=0.0, + valid_pose_fps=0.0, + last_frame_id=-1, + stalled=False, + error=None, + stdout_backpressure_count=0, + pose_lost_count=0, + ) + worker = self._thread_factory( + target=self._run, + args=(generation,), + name="slam-supervisor", + daemon=True, + ) + monitor = self._thread_factory( + target=self._monitor_frames, + args=(generation,), + name="slam-monitor", + daemon=True, + ) + self._worker_thread = worker + self._monitor_thread = monitor + worker.start() + monitor.start() + return True + + def set_initial_origin_callback(self, callback): + """Register the lifecycle continuation invoked after READY newline.""" + self._initial_origin_callback = callback + + def initial_origin_sent(self): + return self._initial_origin_generation == self._generation + + def wait_started(self, timeout=10.0): + return self._started_event.wait(timeout) + + @property + def nice_adjustment(self): + return self._nice_adjustment + + def set_nice_adjustment(self, adjustment): + target = int(adjustment) + if target not in ALLOWED_NICE_ADJUSTMENTS: + raise ValueError("Fays nice adjustment must be 0 or 5") + if self.running: + raise RuntimeError( + "cannot change Fays nice adjustment while SLAM is running") + self._nice_adjustment = target + + def configure_runtime( + self, *, executable, settings, calibration_serial=None, + backend="orb", arguments=None, service_container=None, + service_host=None, service_port=None, + ): + """Select one localization bridge/config pair before process start.""" + + with self._lifecycle_lock: + with self.state._lock: + process = self.state.process + active = bool( + self.state.running + or ( + process is not None + and process.poll() is None + ) + ) + if active: + raise RuntimeError( + "cannot change Fays calibration while SLAM is running" + ) + executable_path = os.path.abspath(os.fspath(executable)) + settings_path = os.path.abspath(os.fspath(settings)) + if not os.path.isfile(settings_path): + raise RuntimeError( + "Fays 定位配置不存在,拒绝启动: " + f"{settings_path}" + ) + if not os.path.isfile(executable_path): + raise RuntimeError( + "Fays 定位二进制不存在,拒绝启动: " + f"{executable_path}" + ) + if not os.access(executable_path, os.X_OK): + raise RuntimeError( + "Fays 定位二进制不可执行,拒绝启动: " + f"{executable_path}" + ) + self.executable = executable_path + self.settings = settings_path + normalized_backend = str(backend or "orb").strip().lower() + if normalized_backend not in {"orb", "aikit"}: + raise ValueError( + f"unsupported localization backend: {backend!r}" + ) + self._backend = normalized_backend + self._runtime_arguments = ( + None if arguments is None + else tuple(os.fspath(value) for value in arguments) + ) + self._service_container = ( + str(service_container).strip() + if service_container else None + ) + self._service_host = ( + str(service_host).strip() if service_host else None + ) + self._service_port = ( + int(service_port) if service_port is not None else None + ) + serial = str(calibration_serial or "").strip() + if serial: + self._log( + "[SLAM] Runtime profile selected: " + f"backend={self._backend} serial={serial} " + f"settings={self.settings}" + ) + + def _build_launch(self): + taskset = self._taskset_finder() + if not taskset: + raise RuntimeError( + "taskset is required for Fays CPU9 background isolation" + ) + background = tuple(self.cpu_roles["fays_background"]) + if not background: + raise RuntimeError("Fays background CPU role is empty") + launch_cpus = tuple(sorted({ + cpu + for role in ( + "fays_input", + "fays_prepare", + "fays_left_orb", + "fays_right_orb", + "fays_track", + "fays_background", + ) + for cpu in self.cpu_roles.get(role, ()) + })) + if not launch_cpus: + raise RuntimeError("Fays ORB process CPU domain is empty") + if self._runtime_arguments is None: + if self._backend != "orb": + raise RuntimeError( + "AIKit runtime arguments were not configured" + ) + arguments = ( + self.vocabulary, + self.settings, + self.device_config, + self.trajectory, + ) + else: + arguments = self._runtime_arguments + command = [self.executable, *arguments] + stdbuf = self._stdbuf_finder() + if not stdbuf: + raise RuntimeError( + "stdbuf is required for line-buffered Fays stdout" + ) + command = [stdbuf, "-oL", "-eL", *command] + cpu_spec = ",".join(str(cpu) for cpu in launch_cpus) + launch_command = [taskset, "--cpu-list", cpu_spec, *command] + if self._nice_adjustment: + nice = self._nice_finder() + if not nice: + raise RuntimeError( + "nice is required for the dual-device Fays profile") + launch_command = [ + nice, + "-n", + str(self._nice_adjustment), + *launch_command, + ] + environment = self.runtime_env_factory() + for name in ( + "GOMP_CPU_AFFINITY", + "OMP_PLACES", + "KMP_AFFINITY", + "KMP_HW_SUBSET", + "KMP_PLACE_THREADS", + ): + environment.pop(name, None) + environment.update({ + "OMP_PROC_BIND": "FALSE", + "OMP_DYNAMIC": "FALSE", + "OMP_NUM_THREADS": str(len(launch_cpus)), + "KSQ_FAYS_INPUT_CPU": str( + (self.cpu_roles.get("fays_input") or (4,))[0] + ), + "KSQ_FAYS_PREPARE_CPU": str( + (self.cpu_roles.get("fays_prepare") or (5,))[0] + ), + "KSQ_FAYS_TRACK_CPU": str( + (self.cpu_roles.get("fays_track") or (8,))[0] + ), + "KSQ_FAYS_BACKGROUND_CPU": str( + (self.cpu_roles.get("fays_background") or (9,))[0] + ), + "KSQ_FAYS_ORB_LEFT_CPU": str( + (self.cpu_roles.get("fays_left_orb") or (6,))[0] + ), + "KSQ_FAYS_ORB_RIGHT_CPU": str( + (self.cpu_roles.get("fays_right_orb") or (7,))[0] + ), + }) + # Connect-no-ESP requests fake IMU only from the ORB bridge. AIKit is + # still allowed in that UI mode and continues to consume the real S80M + # IMU inside its service container. + if self._fake_imu and self._backend == "orb": + environment["KSQ_FAYS_FAKE_IMU"] = "1" + else: + environment.pop("KSQ_FAYS_FAKE_IMU", None) + # ASan diagnostic builds must load the sanitizer runtime before any + # instrumented library; the linker cannot guarantee DT_NEEDED order + # across the vendor libraries, so preload it explicitly. Inactive for + # every normal binary name. + if "_asan" in self.executable: + libasan = "/lib/x86_64-linux-gnu/libasan.so.5" + if os.path.exists(libasan): + environment["LD_PRELOAD"] = libasan + ( + os.pathsep + environment["LD_PRELOAD"] + if environment.get("LD_PRELOAD") else "") + return launch_command, environment, launch_cpus + + def _docker_command(self, *arguments, check=True): + docker = shutil.which("docker") + if not docker: + raise RuntimeError("docker is required for AIKit mode") + result = subprocess.run( + [docker, *arguments], + stdin=subprocess.DEVNULL, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + check=False, + ) + if check and result.returncode != 0: + detail = result.stdout.strip() or f"exit={result.returncode}" + raise RuntimeError( + f"docker {' '.join(arguments)} failed: {detail}" + ) + return result + + def _start_aikit_service(self): + if self._backend != "aikit": + return False + if not ( + self._service_container + and self._service_host + and self._service_port + ): + raise RuntimeError("AIKit service profile is incomplete") + with self._service_lock: + self._docker_command("inspect", self._service_container) + running = self._docker_command( + "inspect", "--format", "{{.State.Running}}", + self._service_container, + ).stdout.strip().lower() == "true" + if running: + # The device calibration and volatile /dev/video nodes are + # selected immediately before this call. Restart a lingering + # service so it cannot keep the previous device configuration. + self._log( + "[AIKIT_SERVICE] Reloading current device configuration" + ) + stopped = self._docker_command( + "stop", "--time", "5", self._service_container, + check=False, + ) + if stopped.returncode != 0: + raise RuntimeError( + "AIKit service could not reload configuration: " + + stopped.stdout.strip() + ) + self._log( + "[AIKIT_SERVICE] Starting container=" + + self._service_container + ) + self._docker_command("start", self._service_container) + self._service_active = True + deadline = self._clock() + 20.0 + while not self._stop_event.is_set() and self._clock() < deadline: + try: + with socket.create_connection( + (self._service_host, self._service_port), timeout=0.5 + ): + self._log( + "[AIKIT_SERVICE] Ready address=" + f"{self._service_host}:{self._service_port}" + ) + return True + except OSError: + self._sleep(0.2) + logs = self._docker_command( + "logs", "--tail", "40", self._service_container, + check=False, + ).stdout.strip() + raise RuntimeError( + "AIKit service did not become ready: " + logs[-2000:] + ) + + def _stop_aikit_service(self): + with self._service_lock: + if not self._service_active or not self._service_container: + return + self._service_active = False + result = self._docker_command( + "stop", "--time", "5", self._service_container, + check=False, + ) + if result.returncode != 0: + self._log( + "[AIKIT_SERVICE] Stop failed: " + result.stdout.strip() + ) + else: + self._log("[AIKIT_SERVICE] Stopped") + + def _drain_stdout( + self, process, line_queue, drain_stop, native_log=None, + ): + log_buffer = [] + last_flush = time.monotonic() + try: + for line in process.stdout: + if drain_stop.is_set(): + break + arrival_monotonic = self._clock() + arrival_wall_time = self._wall_clock() + if native_log is not None: + log_buffer.append(json.dumps({ + "time": arrival_wall_time, + "arrival_monotonic": arrival_monotonic, + "line": line.rstrip("\n"), + }, ensure_ascii=False) + "\n") + now = time.monotonic() + if ( + len(log_buffer) >= NATIVE_LOG_FLUSH_LINES + or now - last_flush >= NATIVE_LOG_FLUSH_INTERVAL_S + ): + try: + native_log.writelines(log_buffer) + native_log.flush() + except OSError: + pass + log_buffer.clear() + last_flush = now + item = (line, arrival_monotonic, arrival_wall_time) + while not drain_stop.is_set(): + try: + line_queue.put(item, timeout=0.1) + break + except queue.Full: + with self.state._lock: + self.state.stdout_backpressure_count += 1 + except Exception: + pass + finally: + if native_log is not None and log_buffer: + try: + native_log.writelines(log_buffer) + native_log.flush() + except OSError: + pass + + def _log_native_tail(self): + """进程意外退出时把原生 stdout 日志最后几行打进应用日志。 + + SIGSEGV 类崩溃无回溯可打,最后的输出行是唯一现场;drain 线程 + 可能尚未完成最终 flush,稍等再读。 + """ + path = self._native_log_path + if not path: + return + try: + time.sleep(0.3) + with open(path, encoding="utf-8", errors="replace") as stream: + lines = stream.readlines() + if lines: + self._log("[SLAM] 原生进程最后输出 ({} 行):".format( + len(lines))) + for line in lines[-15:]: + self._log("[SLAM-NATIVE] " + line.rstrip()[:240]) + except OSError as exc: + self._log("[SLAM] 读取原生日志失败: {}".format(exc)) + + def _publish_pose(self, pose): + # S80M 坐标约定(正对=+Y、Z=上、X=右):见 + # protocol.rotate_pose_z90(真机实测定案,位置与姿态统一 + # 纯左乘 R_z(+90°),新 ORB 核心后 native=X=正对 Y=左 Z=上)。 + # 此处是位姿唯一发布入口,UI/落盘/pose.json/回填缓冲全部统一旋转。 + pose = rotate_pose_z90(pose) + # 原点后姿态相对化:C++ 设原点只把位置归零,静止首帧的姿态 + # 仍带部署校正/启动朝向的常数旋转(旋转跳变的根源,两轮 + # 变换形式修正都没能抵消它)。改为捕获首帧显示姿态为基准, + # 全部姿态左乘基准的逆 → 首帧姿态恒为单位矩阵(帧轴与世界 + # 轴对齐,不跳变),此后姿态 = 相对原点的真实转动,与轨迹 + # (位置相对原点)同基准。位置不动,保持已验证的轨迹映射。 + if self._pose_rotation_zero_pending: + self._pose_rotation_zero = pose.rotation + self._pose_rotation_zero_pending = False + if self._pose_rotation_zero is not None: + pose = replace( + pose, + rotation=quat_product( + quat_conjugate(self._pose_rotation_zero), + pose.rotation, + ), + ) + self._on_pose(pose) + timestamp = pose.timestamp + x, y, z = pose.position + qx, qy, qz, qw = pose.rotation + with self._pose_buffer_lock: + self._pose_buffer[timestamp] = ( + x, y, z, qx, qy, qz, qw + ) + cutoff = timestamp - 2.0 + for key in [ + key for key in self._pose_buffer if key < cutoff + ]: + del self._pose_buffer[key] + if not self._pose_tmp_path or not self._pose_path: + return + try: + encoded = json.dumps({ + "ts": timestamp, + "x": x, + "y": y, + "z": z, + "qx": qx, + "qy": qy, + "qz": qz, + "qw": qw, + }) + with open(self._pose_tmp_path, "w", encoding="utf-8") as stream: + stream.write(encoded) + os.replace(self._pose_tmp_path, self._pose_path) + except OSError: + pass + + def send_origin(self, reason="origin reset"): + """Write the bridge's newline protocol; never use SIGUSR1.""" + with self.state._lock: + process = self.state.process + if ( + process is None + or process.poll() is not None + or process.stdin is None + ): + return False + pid = process.pid + if reason == "initial origin" and pid in self._origin_sent_pids: + return True + try: + process.stdin.write("\n") + process.stdin.flush() + except (BrokenPipeError, OSError, ValueError) as error: + self._log(f"[SLAM] Failed to send {reason}: {error}") + return False + if reason == "initial origin": + self._origin_sent_pids.add(pid) + self._initial_origin_generation = self._generation + self._log("[SLAM] READY; automatic origin command sent") + callback = self._initial_origin_callback + if callback is not None: + callback(self._generation) + else: + self._log("[SLAM] Origin reset command sent") + return True + + def _handle_event( + self, event, counters, arrival_monotonic=None, + arrival_wall_time=None, + ): + if event.kind == "fays_rates": + self._on_fays_rates(event.payload) + return + if event.kind == "orb_diagnostic": + self._on_orb_diagnostic(event.payload) + return + if event.kind == "mp_cleanup": + self._on_mp_cleanup(event.payload) + return + # 周期诊断行(ORB_STAGE/FAYS-AFFINITY 每秒各一条)只在 + # slam_stdout.log 全量留档,不打 GUI 日志避免刷屏; + # 崩溃取证由 _log_native_tail 读回。 + if event.kind in ("orb_stage", "affinity"): + return + if event.kind == "ready": + self._set_state(status="READY - Press ENTER") + if self._auto_origin: + self.send_origin("initial origin") + else: + self._log(f"[SLAM] {event.raw}") + return + if event.kind == "origin": + self._last_accepted_pose = None + self._pose_rejecting = False + # 位置在原点帧被 C++ 归零,姿态却带着部署校正/启动朝向的 + # 常数残留(上次跳变的根源);每个 origin 事件(含 NEW + # ORIGIN)都重新捕获首帧姿态基准,与位置重归零保持一致。 + self._pose_rotation_zero = None + self._pose_rotation_zero_pending = True + self._set_state(status="Tracking") + self._log(f"[SLAM] {event.raw}") + return + if event.kind == "status": + self._log(f"[SLAM] {event.raw}") + return + if event.kind == "pose": + pose = event.payload + counters["raw"] += 1 + self._pose_raw_seq += 1 + pose = replace( + pose, + sequence=self._pose_raw_seq, + arrival_monotonic=arrival_monotonic, + arrival_wall_time=arrival_wall_time, + ) + rejection = pose_rejection_reason( + pose, self._last_accepted_pose, + ) + if rejection is not None: + now = self._wall_clock() + if ( + not self._pose_rejecting + or now - self._last_pose_reject_log >= 1.0 + ): + self._log(f"[SLAM] Pose held: {rejection}") + self._last_pose_reject_log = now + if not self._pose_rejecting: + self._set_state(status="Tracking (pose held)") + self._pose_rejecting = True + return + if self._pose_rejecting: + self._log("[SLAM] Pose continuity recovered") + self._pose_rejecting = False + self._last_accepted_pose = pose + counters["valid"] += 1 + self._publish_pose(pose) + with self._latest_pose_lock: + if self._last_accepted_seq: + gap = self._pose_raw_seq - self._last_accepted_seq - 1 + if gap > 0: + self._pose_lost_count += gap + self._last_accepted_seq = self._pose_raw_seq + self._latest_pose = pose + lost_count = self._pose_lost_count + self._set_state(pose_lost_count=lost_count) + self._set_state(status="Tracking") + return + if event.kind == "error": + self._log(f"[SLAM] ⚠ {event.raw}") + self._set_state( + status=f"Error: {event.raw[:60]}", + error=event.raw, + ) + return + self._unmatched_lines += 1 + if self._unmatched_lines <= 50: + self._log(f"[SLAM] {event.raw}") + elif self._unmatched_lines == 51: + self._log("[SLAM] (suppressing further unmatched lines)") + + def _run(self, generation): + sdk_guard = None + sdk_device_guard = None + sdk_deadline = None + process = None + drain_thread = None + drain_stop = threading.Event() + line_queue = queue.Queue(maxsize=STDOUT_QUEUE_CAPACITY) + native_log = None + counters = {"raw": 0, "valid": 0} + fps_started = self._wall_clock() + service_started = self._backend == "aikit" + try: + if service_started: + self._start_aikit_service() + launch_command, environment, launch_cpus = self._build_launch() + role_text = ( + f"input={(self.cpu_roles.get('fays_input') or (4,))[0]}, " + f"prep={(self.cpu_roles.get('fays_prepare') or (5,))[0]}, " + f"ORB={self.cpu_roles['fays_left_orb'][0]}/" + f"{self.cpu_roles['fays_right_orb'][0]}, " + f"track/output=" + f"{(self.cpu_roles.get('fays_track') or (8,))[0]}, " + f"background={self.cpu_roles['fays_background'][0]}, " + f"general={','.join(str(cpu) for cpu in (self.cpu_roles.get('general') or (10, 11)))}, " + f"nice=+{self._nice_adjustment}" + ) + self._log( + f"[SLAM] Starting (Fays {role_text}): " + + " ".join(launch_command) + ) + if self._backend == "orb": + sdk_guard = device_access_guard( + FAYS_SDK_INITIALIZATION_LOCK, timeout=45, + cancelled=self._stop_event.is_set) + sdk_guard.__enter__() + sdk_device_guard = self._sdk_device_guard_factory(self.device_config) + sdk_device_guard.__enter__() + sdk_deadline = time.monotonic() + 30.0 + process = self._process_factory( + launch_command, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + stdin=subprocess.PIPE, + text=True, + cwd=self.work_dir, + env=environment, + ) + if self._native_log_path: + try: + os.makedirs( + os.path.dirname( + os.path.abspath(self._native_log_path) + ), + exist_ok=True, + ) + native_log = open( + self._native_log_path, + "a", + encoding="utf-8", + ) + native_log.write(json.dumps({ + "time": time.time(), + "event": "native_process_started", + "pid": int(process.pid), + "device_config": self.device_config, + }, ensure_ascii=False) + "\n") + native_log.flush() + except OSError: + native_log = None + self._set_affinity(process.pid, set(launch_cpus)) + if set(self._get_affinity(process.pid)) != set(launch_cpus): + raise RuntimeError( + "Fays child did not accept the full Fays CPU boundary: " + f"{','.join(str(cpu) for cpu in launch_cpus)}" + ) + with self.state._lock: + if ( + self._stop_event.is_set() + or generation != self._generation + ): + raise RuntimeError("stale SLAM generation") + self.state.process = process + self.state.status = "Waiting IMU init..." + self._on_status("Waiting IMU init...") + self._started_event.set() + drain_thread = self._thread_factory( + target=self._drain_stdout, + args=(process, line_queue, drain_stop, native_log), + name="slam-stdout-drain", + daemon=True, + ) + drain_thread.start() + + while ( + not self._stop_event.is_set() + and generation == self._generation + ): + if sdk_guard is not None and time.monotonic() > sdk_deadline: + raise RuntimeError("Fays SDK 初始化超时,停止本夹爪连接") + try: + item = line_queue.get(timeout=0.5) + except queue.Empty: + if process.poll() is not None: + if (not self._stop_event.is_set() + and generation == self._generation): + error = f"SLAM subprocess exited unexpectedly (code={process.returncode})" + self._log(f"[SLAM] {error}") + self._log_native_tail() + self._set_state(status=f"Error: {error}", error=error, + running=False) + break + continue + if isinstance(item, tuple): + line, arrival_monotonic, arrival_wall_time = item + else: + line = item + arrival_monotonic = None + arrival_wall_time = None + if any(marker in line for marker in ( + "SetupImu(): VIDIOC_S_FMT failed", "ImuInit(): setup imu failed")): + raise RuntimeError("Fays IMU 初始化失败,停止本夹爪连接: " + line.strip()) + if sdk_guard is not None and "[FAYS-CALIB] orb_runtime_yaml=" in line: + # SDK construction AND calibration/YAML export completed. + sdk_guard.__exit__(None, None, None) + sdk_guard = None + self._sdk_ready_event.set() + self._sdk_initialization_done.set() + event = parse_slam_line(line) + if event is not None: + self._handle_event( + event, + counters, + arrival_monotonic, + arrival_wall_time, + ) + now = self._wall_clock() + elapsed = now - fps_started + if elapsed >= 1.0: + self._set_state( + raw_pose_fps=counters["raw"] / elapsed, + valid_pose_fps=counters["valid"] / elapsed, + ) + counters = {"raw": 0, "valid": 0} + fps_started = now + except Exception as error: + self._log(f"[SLAM] Failed to start/run: {error}") + self._set_state(status=f"Error: {error}", error=str(error)) + traceback.print_exc() + finally: + self._started_event.set() + drain_stop.set() + if ( + drain_thread is not None + and drain_thread.is_alive() + and drain_thread is not threading.current_thread() + ): + drain_thread.join(timeout=STDOUT_JOIN_TIMEOUT_S) + self._terminate_process(process) + if sdk_device_guard is not None: + sdk_device_guard.__exit__(None, None, None) + sdk_device_guard = None + if sdk_guard is not None: + sdk_guard.__exit__(None, None, None) + sdk_guard = None + if service_started: + try: + self._stop_aikit_service() + except Exception as error: + self._log(f"[AIKIT_SERVICE] Stop failed: {error}") + if native_log is not None: + try: + native_log.write(json.dumps({ + "time": time.time(), + "event": "native_process_stopped", + "returncode": ( + None if process is None else process.returncode + ), + }, ensure_ascii=False) + "\n") + native_log.close() + except OSError: + pass + if process is not None and self._on_process_stop is not None: + try: + self._on_process_stop(int(process.pid)) + except Exception: + pass + with self.state._lock: + if self.state.process is process: + self.state.process = None + self.state.running = False + if not str(self.state.status).startswith("Error:"): + self.state.status = "Stopped" + self._on_pose(None) + self._on_status(self.state.snapshot().status) + self._sdk_initialization_done.set() + self._log("[SLAM] Worker stopped.") + + def _monitor_frames(self, generation): + last_frame = -1 + last_change = self._clock() + last_report = 0.0 + stalled = False + while ( + not self._stop_event.wait(MONITOR_INTERVAL_S) + and generation == self._generation + ): + snapshot = self._frame_snapshot() + frame_id = getattr(snapshot, "frame_id", -1) + now = self._clock() + if frame_id >= 0 and frame_id != last_frame: + last_frame = frame_id + last_change = now + self._set_state(last_frame_id=frame_id, stalled=False) + if stalled: + self._log("[SLAM] Fays video stream recovered") + stalled = False + status = self.state.snapshot().status + if frame_id >= 0 and now - last_report >= RUNNING_REPORT_INTERVAL_S: + self._log( + f"[SLAM] Running: frame={frame_id}, state={status}" + ) + last_report = now + if ( + frame_id >= 0 + and now - last_change >= STALL_TIMEOUT_S + and not stalled + ): + stalled = True + self._set_state(stalled=True) + self._log( + "[SLAM] ERROR: Fays video stream has stalled for 5 seconds" + ) + + def _terminate_process(self, process): + if process is None or process.poll() is not None: + return + with self._process_stop_lock: + if process.poll() is not None: + return + try: + process.terminate() + process.wait(timeout=PROCESS_WAIT_TIMEOUT_S) + return + except Exception: + pass + try: + process.kill() + process.wait(timeout=FINAL_WAIT_TIMEOUT_S) + except Exception: + pass + + def stop(self, join=True): + """Stop monitor/stdout/process; safe before or after partial start.""" + with self._lifecycle_lock: + self._generation += 1 + self._stop_event.set() + with self.state._lock: + self.state.running = False + process = self.state.process + self.state.process = None + worker = self._worker_thread + monitor = self._monitor_thread + self._worker_thread = None + self._monitor_thread = None + self._terminate_process(process) + if self._backend == "aikit": + try: + self._stop_aikit_service() + except Exception as error: + self._log(f"[AIKIT_SERVICE] Stop failed: {error}") + if join: + for thread in (worker, monitor): + if ( + thread is not None + and thread.is_alive() + and thread is not threading.current_thread() + ): + thread.join(timeout=WORKER_JOIN_TIMEOUT_S) + self.clear_pose_buffer() + self._on_pose(None) + self._set_state( + status="Disconnected", + raw_pose_fps=0.0, + valid_pose_fps=0.0, + last_frame_id=-1, + stalled=False, + stdout_backpressure_count=0, + pose_lost_count=0, + ) + process_stopped = process is None or process.poll() is not None + return process_stopped and all( + thread is None or not thread.is_alive() + for thread in (worker, monitor) + ) diff --git a/collector/core/gripper/slam/protocol.py b/collector/core/gripper/slam/protocol.py new file mode 100644 index 0000000000000000000000000000000000000000..15ee2ddaa048f7293715e82350a7c1325469232b --- /dev/null +++ b/collector/core/gripper/slam/protocol.py @@ -0,0 +1,440 @@ +"""Strict parsing for the Fays ORB bridge stdout protocol. + +This module is deliberately side-effect free. It does not know about Tk, +process handles, files, or the application composition root. +""" + +from dataclasses import dataclass +import math +import re +from types import MappingProxyType + +# 桥接 stdout 诊断协议的三张字段表。原版挂在 fps_history.FpsHistory 上, +# 本包不复制 fps_history 全模块,只内嵌这三张被协议解析依赖的常量表。 +ORB_DIAGNOSTIC_SPECS = ( + ("state", "orb_tracking_state", "int"), + ("inliers", "orb_inliers", "int"), + ("maps", "orb_maps", "int"), + ("active_kf", "orb_active_kf", "int"), + ("active_mp", "orb_active_mp", "int"), + ("local_kf", "orb_local_kf", "int"), + ("local_mp", "orb_local_mp", "int"), + ("lm_queue", "orb_lm_queue", "int"), + ("imu_batch_avg", "orb_imu_batch_avg", "float"), + ("imu_integrated", "orb_imu_integrated", "int"), + ("imu_queue", "orb_imu_queue", "int"), + ("kf_created", "orb_kf_created", "int"), + ("kf_destroyed", "orb_kf_destroyed", "int"), + ("kf_heap_live", "orb_kf_heap_live", "int"), + ("kf_nonactive_live", "orb_kf_nonactive_live", "int"), + ("mp_created", "orb_mp_created", "int"), + ("mp_destroyed", "orb_mp_destroyed", "int"), + ("mp_heap_live", "orb_mp_heap_live", "int"), + ("mp_nonactive_live", "orb_mp_nonactive_live", "int"), + ("mp_cleanup_passes", "orb_mp_cleanup_passes", "int"), + ("mp_cleanup_candidates", "orb_mp_cleanup_candidates", "int"), + ("mp_cleanup_retired", "orb_mp_cleanup_retired", "int"), + ("rss_kb", "orb_rss_kb", "int"), + ("swap_kb", "orb_swap_kb", "int"), + ("minor_faults", "orb_minor_faults", "int"), + ("major_faults", "orb_major_faults", "int"), +) +ORB_MAP_DIAGNOSTIC_SPECS = ( + ("state", "orb_tracking_state", "int"), + ("inliers", "orb_inliers", "int"), + ("maps", "orb_maps", "int"), + ("active_kf", "orb_active_kf", "int"), + ("active_mp", "orb_active_mp", "int"), + ("local_kf", "orb_local_kf", "int"), + ("local_mp", "orb_local_mp", "int"), + ("lm_queue", "orb_lm_queue", "int"), + ("kf_created", "orb_kf_created", "int"), + ("mp_created", "orb_mp_created", "int"), +) +MP_CLEANUP_SPECS = ( + ("passes", "orb_mp_payload_cleanup_passes", "int"), + ("candidates", "orb_mp_payload_cleanup_candidates", "int"), + ("compacted", "orb_mp_payload_cleanup_compacted", "int"), + ("queued", "orb_mp_payload_cleanup_queued", "int"), + ("duration_ms", "orb_mp_payload_cleanup_duration_ms", "float"), + ("rss_before_kb", "orb_mp_payload_cleanup_rss_before_kb", "int"), + ("rss_after_kb", "orb_mp_payload_cleanup_rss_after_kb", "int"), + ("trigger_elapsed_s", "orb_mp_payload_cleanup_trigger_s", "float"), +) + + +FAYS_STAGE_KEYS = ("wait_ms", "preprocess_ms", "middle_ms", "post_ms") + +# The gripper cannot physically cover these distances between consecutive +# 25 Hz SLAM samples. The small fixed allowance absorbs normal estimator +# corrections; the speed term keeps the gate independent of the exact FPS. +POSE_MAX_ABS_POSITION_M = 10.0 +POSE_STEP_ALLOWANCE_M = 0.05 +POSE_MAX_LINEAR_SPEED_MPS = 3.0 +POSE_MAX_GUARD_INTERVAL_S = 0.1 +POSE_ANGLE_ALLOWANCE_RAD = math.radians(20.0) +POSE_MAX_ANGULAR_SPEED_RAD_S = math.radians(1080.0) + +_POSE_RE = re.compile( + r"\[([\d.]+)\]\s*XYZ:\(([-\d.e+]+),([-\d.e+]+),([-\d.e+]+)\)\s*" + r"Quat:\(w=([-\d.e+]+),x=([-\d.e+]+),y=([-\d.e+]+),z=([-\d.e+]+)\)" +) +_FPS_RE = re.compile( + r"^\[FPS_DATA\]\s+image=([\d.]+)\s+imu=([\d.]+)\s+" + r"process=([\d.]+)" + r"(?:\s+wait_ms=([\d.]+)\s+preprocess_ms=([\d.]+)" + r"\s+middle_ms=([\d.]+)\s+post_ms=([\d.]+))?$" +) +_ERROR_RE = re.compile( + r"(error|failed|exception|cannot|unable|denied|timeout|timed out|" + r"no device|not found|no such|device busy|resource busy)", + re.IGNORECASE, +) +_IGNORED_NON_FATAL_RE = re.compile( + r"^\[FAYS-CALIB\]\s+WARN\s+SetStereoFPS\(\d+\)\s+failed$" +) + + +@dataclass(frozen=True) +class PoseSample: + """One pose emitted by the Fays ORB bridge.""" + + position: tuple + rotation: tuple + timestamp: float + device_name: str = "SLAM" + sequence: int = 0 + arrival_monotonic: object = None + arrival_wall_time: object = None + + @property + def valid(self): + values = (*self.position, *self.rotation) + quaternion_norm = math.sqrt(sum( + value * value for value in self.rotation + )) + arrival_values = ( + self.arrival_monotonic, + self.arrival_wall_time, + ) + return ( + math.isfinite(self.timestamp) + and all(math.isfinite(value) for value in values) + and int(self.sequence) >= 0 + and all( + value is None or math.isfinite(float(value)) + for value in arrival_values + ) + and all( + abs(value) < POSE_MAX_ABS_POSITION_M + for value in self.position + ) + and 0.5 < quaternion_norm < 1.5 + ) + + +def pose_rejection_reason(current, previous=None): + """Return why a live pose must be held, or ``None`` when it is safe. + + The native bridge is the primary continuity owner. This side-effect-free + check is the final boundary before a pose can reach UI/recording state. + """ + + if not isinstance(current, PoseSample) or not current.valid: + return "invalid pose components" + if previous is None: + return None + if not isinstance(previous, PoseSample) or not previous.valid: + return "invalid previous pose" + + interval = current.timestamp - previous.timestamp + if not math.isfinite(interval) or interval <= 0.0: + return "non-monotonic pose timestamp" + guarded_interval = min(interval, POSE_MAX_GUARD_INTERVAL_S) + + distance = math.sqrt(sum( + (current.position[index] - previous.position[index]) ** 2 + for index in range(3) + )) + distance_limit = ( + POSE_STEP_ALLOWANCE_M + + POSE_MAX_LINEAR_SPEED_MPS * guarded_interval + ) + if distance > distance_limit: + return ( + f"translation step {distance:.3f}m exceeds " + f"{distance_limit:.3f}m" + ) + + previous_norm = math.sqrt(sum( + value * value for value in previous.rotation + )) + current_norm = math.sqrt(sum( + value * value for value in current.rotation + )) + dot = abs(sum( + previous.rotation[index] * current.rotation[index] + for index in range(4) + ) / (previous_norm * current_norm)) + angle = 2.0 * math.acos(max(-1.0, min(1.0, dot))) + angle_limit = ( + POSE_ANGLE_ALLOWANCE_RAD + + POSE_MAX_ANGULAR_SPEED_RAD_S * guarded_interval + ) + if angle > angle_limit: + return ( + f"rotation step {math.degrees(angle):.1f}deg exceeds " + f"{math.degrees(angle_limit):.1f}deg" + ) + return None + + +@dataclass(frozen=True) +class FaysRateSample: + image_input: float + imu_input: float + process: float + stage_times: object = None + + +@dataclass(frozen=True) +class ProtocolEvent: + """A classified stdout line. + + ``kind`` is one of ``pose``, ``fays_rates``, ``orb_diagnostic``, + ``orb_stage``, ``affinity``, ``ready``, ``origin``, ``status``, ``error`` + or ``log``. + """ + + kind: str + payload: object + raw: str + + +def parse_orb_diagnostic_line(line): + """Parse one complete ``[ORB_DIAG]`` record or return ``None``.""" + prefix = "[ORB_DIAG] " + if not isinstance(line, str) or not line.startswith(prefix): + return None + + encoded = {} + for token in line[len(prefix):].split(): + name, separator, value = token.partition("=") + if not separator or not name or not value or name in encoded: + return None + encoded[name] = value + + specs = ORB_DIAGNOSTIC_SPECS + expected = {protocol_name for protocol_name, _csv_name, _kind in specs} + if not expected.issubset(encoded): + return None + + parsed = {} + try: + for protocol_name, _csv_name, kind in specs: + if kind == "float": + value = float(encoded[protocol_name]) + if not math.isfinite(value): + return None + else: + value = int(encoded[protocol_name], 10) + if protocol_name != "state" and value < 0: + return None + parsed[protocol_name] = value + except (TypeError, ValueError, OverflowError): + return None + return MappingProxyType(parsed) + + +def parse_orb_map_diagnostic_line(line): + """Parse one complete read-only ``[ORB_MAP_DIAG]`` record.""" + prefix = "[ORB_MAP_DIAG] " + if not isinstance(line, str) or not line.startswith(prefix): + return None + + encoded = {} + for token in line[len(prefix):].split(): + name, separator, value = token.partition("=") + if not separator or not name or not value or name in encoded: + return None + encoded[name] = value + + specs = ORB_MAP_DIAGNOSTIC_SPECS + expected = {protocol_name for protocol_name, _csv_name, _kind in specs} + if set(encoded) != expected: + return None + + parsed = {} + try: + for protocol_name, _csv_name, kind in specs: + value = ( + float(encoded[protocol_name]) + if kind == "float" + else int(encoded[protocol_name], 10) + ) + if kind == "float" and not math.isfinite(value): + return None + if protocol_name != "state" and value < 0: + return None + parsed[protocol_name] = value + except (TypeError, ValueError, OverflowError): + return None + return MappingProxyType(parsed) + + +def parse_mp_cleanup_line(line): + """Parse one complete ``[MP_CLEANUP]`` result or return ``None``.""" + prefix = "[MP_CLEANUP] " + if not isinstance(line, str) or not line.startswith(prefix): + return None + encoded = {} + for token in line[len(prefix):].split(): + name, separator, value = token.partition("=") + if not separator or not name or not value or name in encoded: + return None + encoded[name] = value + parsed = {} + try: + for name, _csv_name, kind in MP_CLEANUP_SPECS: + value = float(encoded[name]) if kind == "float" else int(encoded[name]) + if not math.isfinite(value) or value < 0: + return None + parsed[name] = value + except (KeyError, TypeError, ValueError, OverflowError): + return None + return MappingProxyType(parsed) + + +def _parse_pose(line): + match = _POSE_RE.search(line) + if match is None: + return None + try: + timestamp = float(match.group(1)) + x, y, z = (float(match.group(index)) for index in range(2, 5)) + qw, qx, qy, qz = ( + float(match.group(index)) for index in range(5, 9) + ) + except (TypeError, ValueError, OverflowError): + return None + return PoseSample( + position=(x, y, z), + rotation=(qx, qy, qz, qw), + timestamp=timestamp, + ) + + +def rotate_pose_z90(pose): + """S80M 轨迹坐标约定:绕 Z 轴旋转 +90°(X=右 Y=正对 Z=上)。 + + 真机实测定案(2026-09-09,新 ORB 核心上线后):native 输出 + 相对物理系为 R_z(−90°)——native X=正对、Y=左、Z=上(实测: + 物理 +Y(正对) 位移 → native +X;物理 +X(右) → native −Y), + 与桥接 .cc 注释约定一致。注意:旧核心时代的约定是 R_x(+90°) + (X=右 Y=下 Z=正对),换核后世界系约定已变,此前基于旧核的 + rotate_pose_xm90(绕 X −90°)已随旧核失效。修正 = 位置与姿态 + 统一纯左乘 R_z(+90°)(= native 约定之逆,纯世界重标,无体轴 + 共轭): + 位置 (x,y,z)→(−y,x,z);四元数 q' = q_z(+90°)⊗q 化简为 + c·(x−y, y+x, z+w, w−z),c=√2/2。 + 结果:X=右、Y=夹爪正对、Z=上(右手系,等价 ENU)。 + 静止首帧姿态 = R_z(+90°)·correction(部署校正的常数残留, + 约 R_x(−90°),非单位矩阵)——由 process_controller 的原点后 + 姿态相对化(捕获首帧显示姿态为基准)吸收,首帧显示恒为 + 单位矩阵,帧轴与世界轴对齐、无起始跳变。 + """ + x, y, z = pose.position + qx, qy, qz, qw = pose.rotation + c = math.sqrt(0.5) + return PoseSample( + position=(-y, x, z), + rotation=(c * (qx - qy), c * (qy + qx), c * (qz + qw), + c * (qw - qz)), + timestamp=pose.timestamp, + ) + + +def quat_conjugate(q): + """四元数共轭(单位四元数时即逆)。""" + x, y, z, w = q + return (-x, -y, -z, w) + + +def quat_product(a, b): + """Hamilton 积 a⊗b(等价矩阵左乘 a:先施加 b 再施加 a)。""" + ax, ay, az, aw = a + bx, by, bz, bw = b + return ( + aw * bx + ax * bw + ay * bz - az * by, + aw * by + ay * bw + az * bx - ax * bz, + aw * bz + az * bw + ax * by - ay * bx, + aw * bw - ax * bx - ay * by - az * bz, + ) + + +def _parse_fays_rates(line): + match = _FPS_RE.fullmatch(line) + if match is None: + return None + values = tuple(float(match.group(index)) for index in range(1, 4)) + stages = None + if match.group(4) is not None: + stages = MappingProxyType({ + key: float(match.group(index)) + for key, index in zip(FAYS_STAGE_KEYS, range(4, 8)) + }) + return FaysRateSample(*values, stage_times=stages) + + +def parse_slam_line(line): + """Classify one stripped Fays bridge stdout line.""" + if not isinstance(line, str): + return None + raw = line.strip() + if not raw: + return None + # This SDK build exposes SetStereoFPS as an unavailable/stubbed entry. + # The serial-matched YAML already selects the requested 25 FPS mode, so + # this non-fatal diagnostic must not put the GUI into the Error state. + if _IGNORED_NON_FATAL_RE.fullmatch(raw): + return None + + rates = _parse_fays_rates(raw) + if rates is not None: + return ProtocolEvent("fays_rates", rates, raw) + + map_diagnostic = parse_orb_map_diagnostic_line(raw) + if map_diagnostic is not None: + return ProtocolEvent("orb_diagnostic", map_diagnostic, raw) + + diagnostic = parse_orb_diagnostic_line(raw) + if diagnostic is not None: + return ProtocolEvent("orb_diagnostic", diagnostic, raw) + cleanup = parse_mp_cleanup_line(raw) + if cleanup is not None: + return ProtocolEvent("mp_cleanup", cleanup, raw) + + if raw.startswith("[ORB_STAGE]"): + return ProtocolEvent("orb_stage", raw, raw) + if raw.startswith("[FAYS-AFFINITY]"): + return ProtocolEvent("affinity", raw, raw) + if "READY" in raw and "Press ENTER" in raw: + return ProtocolEvent("ready", raw, raw) + if "NEW ORIGIN" in raw or "ORIGIN SET" in raw: + return ProtocolEvent("origin", raw, raw) + + pose = _parse_pose(raw) + if pose is not None: + return ProtocolEvent("pose", pose, raw) + + if ( + "IMU init" in raw + or "Recording" in raw + or "Segment" in raw + or raw.startswith("[POSE_HOLD]") + or raw.startswith("[POSE_REBASE]") + ): + return ProtocolEvent("status", raw, raw) + if _ERROR_RE.search(raw): + return ProtocolEvent("error", raw, raw) + return ProtocolEvent("log", raw, raw) diff --git a/collector/core/gripper/tactile_process_worker.py b/collector/core/gripper/tactile_process_worker.py new file mode 100644 index 0000000000000000000000000000000000000000..2871f5123a91c550c94bc214439b62966d004e39 --- /dev/null +++ b/collector/core/gripper/tactile_process_worker.py @@ -0,0 +1,1192 @@ +#!/usr/bin/env python3 +"""Sightac 触觉计算子进程。 + +父进程只负责相机读取、界面和结果汇总;本模块在独立进程内保留完整的 +预处理、Hue、光流、力标定、自动标定、力映射及热力图计算。 +""" + +import builtins +import importlib +import os +import pickle +import queue +import sys +import time +import traceback + +import cv2 +import numpy as np + + +# Sightac 当前为 640x480 uint8 图像。描述符 FIFO 有界;处理线程变慢时 +# 槽位耗尽则丢弃新帧,保留队列中较早的帧并限制共享内存占用。 +TACTILE_FRAME_QUEUE_SIZE = 8 +TACTILE_RESULT_QUEUE_SIZE = 4 +# Continuous Sightac frames must not be pickled through a multiprocessing +# Queue. Four 640x480x3 streams otherwise create roughly 100 MB/s of parent +# process serialization/IPC traffic before the actual tactile algorithm runs. +TACTILE_FRAME_SLOT_COUNT = TACTILE_FRAME_QUEUE_SIZE +TACTILE_FRAME_SLOT_BYTES = 640 * 480 * 3 +TACTILE_HEATMAP_SHAPE = (240, 320, 3) +TACTILE_FORCE_MATRIX_SHAPE = (250, 250, 3) +TACTILE_RESULT_HEATMAP_BYTES = int(np.prod(TACTILE_HEATMAP_SHAPE)) +TACTILE_RESULT_FORCE_BYTES = int(np.prod( + TACTILE_FORCE_MATRIX_SHAPE)) * np.dtype(np.float32).itemsize +TACTILE_RESULT_FLAG_OFFSET = ( + TACTILE_RESULT_HEATMAP_BYTES + TACTILE_RESULT_FORCE_BYTES) +TACTILE_RESULT_SLOT_BYTES = TACTILE_RESULT_FLAG_OFFSET + 8 +TACTILE_RESULT_SLOT_COUNT = TACTILE_RESULT_QUEUE_SIZE + 4 +# 输入进程化:采集侧一次标定的采样帧数(与旧主进程基线一致)。 +TACTILE_INITIAL_BASELINE_FRAMES = 5 +_SIGHTAC_API_PACKAGES = frozenset({ + "api", + "api_legacy_2_4_5", + "api_new", + "api_v3_2_2_ksq", +}) + + +def _quantize_force_channel(m): + """与 recording.lerobot_v3.quantize_force_matrix 一致的 int16 行差分。""" + q = np.clip(np.asarray(m, dtype=np.float32), + -32767.0, 32767.0).astype(np.int16) + d = np.empty_like(q) + d[:, 0] = q[:, 0] + d[:, 1:] = q[:, 1:] - q[:, :-1] + return d.tobytes() + + +def create_shared_frame_pool(context, *, slot_count=TACTILE_FRAME_SLOT_COUNT, + slot_bytes=TACTILE_FRAME_SLOT_BYTES): + """Create a bounded shared-memory frame pool for one Sightac side. + + The parent copies one decoded uint8 frame into a free slot and sends only + a small descriptor through ``frame_queue``. The child returns the slot + after processing, so a full pool has the same drop-new semantics as the + old bounded raw-frame FIFO without serializing image payloads. + """ + slot_count = int(slot_count) + slot_bytes = int(slot_bytes) + if slot_count <= 0 or slot_bytes <= 0: + raise ValueError( + f"invalid shared frame pool: slots={slot_count} bytes={slot_bytes}") + storage = context.RawArray("B", slot_count * slot_bytes) + free_slots = context.Queue(maxsize=slot_count) + for slot in range(slot_count): + free_slots.put_nowait(slot) + return storage, free_slots, slot_bytes + + +def shared_frame_view(storage, slot, shape, nbytes, slot_bytes): + """Return a uint8 ndarray view over one shared frame slot.""" + slot = int(slot) + nbytes = int(nbytes) + slot_bytes = int(slot_bytes) + shape = tuple(int(value) for value in shape) + if slot < 0 or nbytes <= 0 or nbytes > slot_bytes: + raise ValueError( + f"invalid shared frame descriptor: slot={slot} " + f"nbytes={nbytes} slot_bytes={slot_bytes}") + expected = int(np.prod(shape, dtype=np.int64)) + if expected != nbytes: + raise ValueError( + f"shared frame shape/size mismatch: shape={shape} " + f"expected={expected} nbytes={nbytes}") + return np.frombuffer( + storage, + dtype=np.uint8, + count=nbytes, + offset=slot * slot_bytes, + ).reshape(shape) + + +def create_shared_result_pool(context, *, + slot_count=TACTILE_RESULT_SLOT_COUNT, + slot_bytes=TACTILE_RESULT_SLOT_BYTES): + """Create a bounded shared-memory pool for tactile result payloads.""" + slot_count = int(slot_count) + slot_bytes = int(slot_bytes) + if slot_count <= 0 or slot_bytes <= 0: + raise ValueError( + f"invalid tactile result pool: slots={slot_count} " + f"bytes={slot_bytes}") + storage = context.RawArray("B", slot_count * slot_bytes) + free_slots = context.Queue(maxsize=slot_count) + for slot in range(slot_count): + free_slots.put_nowait(slot) + return storage, free_slots, slot_bytes + + +def shared_result_view(storage, slot, offset, length): + """Return one contiguous uint8 result region in shared memory.""" + slot = int(slot) + offset = int(offset) + length = int(length) + if slot < 0 or offset < 0 or length <= 0: + raise ValueError( + f"invalid tactile result view: slot={slot} offset={offset} " + f"length={length}") + return np.frombuffer( + storage, + dtype=np.uint8, + count=length, + offset=slot * TACTILE_RESULT_SLOT_BYTES + offset, + ) + + +def write_shared_result(storage, free_slots, slot_bytes, result): + """Copy heatmap/force payload into shared memory and tag the result.""" + heatmap = result.get("heatmap") + force_matrix = result.get("force_matrix") + if heatmap is None: + return None + heatmap = np.ascontiguousarray(heatmap, dtype=np.uint8) + if heatmap.shape != TACTILE_HEATMAP_SHAPE: + raise ValueError( + "unsupported tactile heatmap shape: " + f"{heatmap.shape} expected={TACTILE_HEATMAP_SHAPE}") + if force_matrix is not None: + force_matrix = np.ascontiguousarray(force_matrix, dtype=np.float32) + if force_matrix.shape != TACTILE_FORCE_MATRIX_SHAPE: + raise ValueError( + "unsupported tactile force matrix shape: " + f"{force_matrix.shape} " + f"expected={TACTILE_FORCE_MATRIX_SHAPE}") + try: + slot = int(free_slots.get_nowait()) + except queue.Empty: + return None + heat_dest = shared_result_view( + storage, slot, 0, TACTILE_RESULT_HEATMAP_BYTES).reshape( + TACTILE_HEATMAP_SHAPE) + np.copyto(heat_dest, heatmap) + if force_matrix is None: + force_dest = shared_result_view( + storage, slot, TACTILE_RESULT_HEATMAP_BYTES, + TACTILE_RESULT_FORCE_BYTES).view(np.float32).reshape( + TACTILE_FORCE_MATRIX_SHAPE) + force_dest.fill(0) + result["force_matrix"] = None + else: + force_dest = shared_result_view( + storage, slot, TACTILE_RESULT_HEATMAP_BYTES, + TACTILE_RESULT_FORCE_BYTES).view(np.float32).reshape( + TACTILE_FORCE_MATRIX_SHAPE) + np.copyto(force_dest, force_matrix) + result["force_matrix"] = None + flags = shared_result_view( + storage, slot, TACTILE_RESULT_FLAG_OFFSET, 8) + flags[0:8] = 0 + flags[0] = 1 + flags[1] = 0 if force_matrix is None else 1 + # Both payloads already live in the shared slot. Keeping heatmap here + # accidentally pickles another 230,400 bytes through the result pipe. + result["heatmap"] = None + result["result_slot"] = slot + return slot + + +def snapshot_sensor_state(sensor): + """提取算法状态,排除只能留在父进程的相机/XU硬件句柄。""" + state = {} + for key, value in vars(sensor).items(): + if key in {"cap", "xu_camera"} or key.startswith("_ksq_"): + continue + state[key] = value + state["__ksq_api_package__"] = getattr( + sensor, "_ksq_api_package", "api") + # 在启动子进程前失败,避免硬件运行后才发现某个状态不能跨进程传递。 + pickle.dumps(state, protocol=pickle.HIGHEST_PROTOCOL) + return state + + +def create_frame_queue(context, maxsize=TACTILE_FRAME_QUEUE_SIZE): + """创建有界的单生产者/单消费者帧描述符 FIFO。""" + maxsize = int(maxsize) + if maxsize <= 0: + raise ValueError(f"Sightac frame queue size must be positive, got {maxsize}") + return context.Queue(maxsize=maxsize) + + +def clear_frame_queue(frame_queue, free_slots=None): + """清空阶段切换前尚未处理的帧。标定请求以此作为明确的阶段边界。""" + while True: + try: + item = frame_queue.get_nowait() + if ( + free_slots is not None + and isinstance(item, tuple) + and len(item) >= 5 + and isinstance(item[1], (int, np.integer)) + ): + try: + free_slots.put_nowait(int(item[1])) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + except queue.Empty: + return + except (EOFError, OSError): + return + + +def pressure_to_heatmap(pressure_matrix, device_type="bevel", scale=None): + """0902 定标 JET 显示;不再按每传感器/每帧各自归一化。""" + if pressure_matrix is None: + return None + if scale is None: + scale = 200.0 if device_type == "curved" else 50.0 + fz = np.asarray(pressure_matrix, dtype=np.float32) + scaled = np.clip(fz * float(scale), 0, 255).astype(np.uint8) + heatmap_bgr = cv2.applyColorMap(scaled, cv2.COLORMAP_JET) + heatmap_rgb = cv2.cvtColor(heatmap_bgr, cv2.COLOR_BGR2RGB) + return cv2.resize(heatmap_rgb, (320, 240)) + + +def _finite_nonnegative(value): + try: + value = float(value) + except (TypeError, ValueError): + return None + return max(0.0, value) if np.isfinite(value) else None + + +def process_tactile_frame(sensor, raw_frame, captured_at): + """执行一帧完整触觉算法,返回可跨进程发布的结果。""" + frame_started = time.perf_counter() + queue_wait_ms = max( + 0.0, (time.monotonic() - float(captured_at)) * 1000.0) + processed = sensor.process_raw_frame(raw_frame, mode=0) + if not processed: + return { + "kind": ( + "recalibration_required" + if getattr(sensor, "recalibration_required", False) + else "skip" + ) + } + + sensor_timings = getattr(sensor, "last_process_timings_ms", {}) or {} + diagnostics = { + "preprocess_ms": _finite_nonnegative(sensor_timings.get("preprocess")), + "hue_ms": _finite_nonnegative(sensor_timings.get("hue")), + "optical_flow_ms": _finite_nonnegative( + sensor_timings.get("optical_flow")), + "force_calibration_ms": _finite_nonnegative( + sensor_timings.get("force_calibration")), + "auto_calibration_ms": _finite_nonnegative( + sensor_timings.get("auto_calibration")), + "force_mapping_ms": _finite_nonnegative( + sensor_timings.get("force_mapping")), + "queue_wait_ms": queue_wait_ms, + } + force = ( + sensor.fx_total, + sensor.fy_total, + sensor.fz_total, + ) + # Keep the three calibrated per-cell components from one source frame + # together for native-rate recording. Partial matrices are rejected. + force_matrix = None + fx_matrix = getattr(sensor, "fx_matrix", None) + fy_matrix = getattr(sensor, "fy_matrix", None) + fz_matrix = getattr(sensor, "fz_matrix", None) + # 0902 model 1(响应曲线标定)无正向接触时返回 None;补一张零平面, + # 不因此丢掉一帧本可用的录制样本。 + if (fz_matrix is None and getattr(sensor, "bevel_calibrate_model", None) == 1 + and getattr(sensor, "fz_total", None) == 0.0): + hue = getattr(sensor, "hue_matrix_filtered", None) + if hue is not None: + fz_matrix = np.zeros_like(hue, dtype=np.float32) + if ( + fx_matrix is not None + and fy_matrix is not None + and fz_matrix is not None + and fx_matrix.shape == fy_matrix.shape == fz_matrix.shape + ): + force_matrix = np.stack( + (fx_matrix, fy_matrix, fz_matrix), axis=-1 + ).astype(np.float32, copy=False) + heatmap_started = time.perf_counter() + heatmap = pressure_to_heatmap( + fz_matrix, getattr(sensor, "device_type", "bevel")) + heatmap_ms = (time.perf_counter() - heatmap_started) * 1000.0 + if heatmap is None: + return {"kind": "skip"} + + child_total_ms = (time.perf_counter() - frame_started) * 1000.0 + classified_ms = heatmap_ms + for key in ( + "preprocess_ms", "hue_ms", "optical_flow_ms", + "force_calibration_ms", "auto_calibration_ms", + "force_mapping_ms"): + value = diagnostics.get(key) + if value is not None: + classified_ms += value + diagnostics.update({ + "heatmap_ms": heatmap_ms, + # IPC传输和父进程结果交接耗时在父进程收到结果后补入。 + "publish_ms": 0.0, + "other_ms": max(0.0, child_total_ms - classified_ms), + }) + return { + "kind": "frame", + "heatmap": heatmap, + "force": force, + "force_matrix": force_matrix, + "diagnostics": diagnostics, + "result_ready_at": time.monotonic(), + "captured_at": float(captured_at), + } + + +def _sightac_sdk_candidates(preferred=None): + """Sightac SDK(api_new 等包)的候选导入根目录。""" + candidates = [] + if preferred: + candidates.append(str(preferred)) + explicit = os.environ.get("KSQ_SIGHTAC_ROOT") + if explicit: + candidates.append(str(explicit)) + try: + from core.gripper import paths + candidates.append(paths.SIGHTAC_SDK_ROOT) + except Exception: + pass + module_dir = os.path.dirname(os.path.abspath(__file__)) + candidates.append( + os.path.join(module_dir, "sightac_sdk")) + return candidates + + +def _ensure_sightac_sdk_path(preferred=None): + """把可用的 Sightac SDK 根目录加入 sys.path,返回该目录。""" + for candidate in _sightac_sdk_candidates(preferred): + normalized = os.path.abspath(os.path.normpath(candidate)) + if os.path.isdir(normalized): + if normalized not in sys.path: + sys.path.insert(0, normalized) + return normalized + return None + + +def _pin_entire_process(cpu): + """把当前进程已有及后续线程限制到一个逻辑 CPU。""" + expected = {int(cpu)} + tids = [ + int(name) for name in os.listdir("/proc/self/task") if name.isdigit() + ] + for tid in tids: + os.sched_setaffinity(tid, expected) + for tid in tids: + actual = set(os.sched_getaffinity(tid)) + if actual != expected: + raise RuntimeError( + f"tactile process affinity failed: tid={tid} " + f"expected={sorted(expected)} actual={sorted(actual)}" + ) + return tuple(sorted(os.sched_getaffinity(0))) + + +def _restore_touch_sensor(sensor_state): + # 子进程不打开或持有任何 UVC/XU 设备,只恢复 TouchSensor 的算法状态。 + sensor_state = dict(sensor_state) + api_package = sensor_state.pop("__ksq_api_package__", "api") + if api_package not in _SIGHTAC_API_PACKAGES: + raise RuntimeError( + f"unsupported Sightac worker API package: {api_package!r}") + # 输入进程化后父进程可能不再构造 TouchSensor,sdk 路径由 input 子 + # 进程随 sensor_state 回传(__ksq_sightac_root__);缺失时按本模块 + # 位置/KSQ_SIGHTAC_ROOT 回退,保证 spawn 计算子进程可 import api_*。 + _ensure_sightac_sdk_path( + sensor_state.pop("__ksq_sightac_root__", None)) + TouchSensor = importlib.import_module(api_package).TouchSensor + + module = sys.modules.get(TouchSensor.__module__) + if module is not None: + def concise_sdk_print(*args, **kwargs): + message = " ".join(str(arg) for arg in args).strip() + lowered = message.lower() + if any(token in lowered for token in ( + "error", "failed", "exception", "cannot", "unable", + "timeout", "错误", "失败")): + builtins.print( + f"[TactileSDK:{os.getpid()}] {message}", **kwargs) + module.print = concise_sdk_print + + sensor = TouchSensor.__new__(TouchSensor) + sensor.__dict__.update(sensor_state) + sensor.cap = None + sensor.xu_camera = None + sensor._ksq_api_package = api_package + return sensor + + +def _put_status(status_queue, message): + try: + status_queue.put_nowait(message) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + + +def _run_calibration(sensor, frames): + if getattr(sensor, "map_mask_pending", False): + sensor.get_map_mask() + sensor.map_mask_pending = False + preprocessed_frames = [] + for raw_frame, _captured_at in frames: + frame = sensor.preprocess_raw_frame(raw_frame) + if frame is None: + raise RuntimeError("invalid calibration frame") + preprocessed_frames.append(frame.copy()) + sensor.calibrate_baseline(preprocessed_frames) + return len(preprocessed_frames) + + +def run_tactile_process( + side, cpu, sensor_state, frame_queue, command_queue, result_queue, + status_queue, stop_event, shared_storage=None, free_slots=None, + slot_bytes=TACTILE_FRAME_SLOT_BYTES, + result_storage=None, result_free_slots=None, + result_slot_bytes=TACTILE_RESULT_SLOT_BYTES, + record_queue=None, record_gate=None): + """独立 Left/Right 触觉计算子进程入口。""" + # 父进程停止消费后,子进程退出时不能等待 Queue feeder 把结果刷入 + # 已无人读取的 pipe。 + try: + result_queue.cancel_join_thread() + except (AttributeError, OSError, ValueError): + pass + try: + actual = _pin_entire_process(cpu) + cv2.setNumThreads(1) + cv2.setUseOptimized(True) + sensor = _restore_touch_sensor(sensor_state) + _put_status(status_queue, ("ready", os.getpid(), actual)) + except Exception as exc: + _put_status(status_queue, ( + "fatal", str(exc), traceback.format_exc(limit=12))) + return + + last_sequence = 0 + dropped_results = 0 + awaiting_calibration = False + while not stop_event.is_set(): + command = None + try: + command = command_queue.get_nowait() + except queue.Empty: + pass + except (EOFError, OSError): + break + + if command is not None: + kind = command[0] + if kind == "stop": + break + if kind == "calibrate": + _, job_id, reason, frames = command + try: + samples = _run_calibration(sensor, frames) + _put_status(status_queue, ( + "calibration_result", int(job_id), True, None, + str(reason), int(samples))) + except Exception as exc: + _put_status(status_queue, ( + "calibration_result", int(job_id), False, str(exc), + str(reason), 0)) + finally: + awaiting_calibration = False + frames = None + continue + + if awaiting_calibration: + stop_event.wait(0.01) + continue + + frame_slot = None + try: + item = frame_queue.get(timeout=0.05) + if shared_storage is not None and free_slots is not None: + sequence, frame_slot, shape, nbytes, captured_at = item + raw_frame = shared_frame_view( + shared_storage, frame_slot, shape, nbytes, slot_bytes) + else: + # Compatibility path for direct callers that still provide + # raw ndarray frames instead of a shared pool. + sequence, raw_frame, captured_at = item + except queue.Empty: + continue + except (EOFError, OSError): + break + + if int(sequence) <= int(last_sequence): + _put_status(status_queue, ( + "error", + f"non-increasing Sightac frame sequence={sequence} " + f"last={last_sequence}", + "")) + if frame_slot is not None and free_slots is not None: + try: + free_slots.put_nowait(int(frame_slot)) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + continue + last_sequence = sequence + try: + result = process_tactile_frame(sensor, raw_frame, captured_at) + kind = result.get("kind") + if kind == "recalibration_required": + awaiting_calibration = True + _put_status(status_queue, ( + "recalibration_request", "frame-shape-change")) + continue + if kind != "frame": + continue + result["sequence"] = int(sequence) + record_payload = None + if ( + record_queue is not None + and record_gate is not None + and record_gate.is_set() + ): + try: + force_matrix = result.get("force_matrix") + arr = np.asarray(force_matrix, dtype=np.float32) + if arr.ndim == 3 and arr.shape[2] == 3: + packed = tuple( + _quantize_force_channel(arr[:, :, i]) + for i in range(3) + ) + captured_at = float( + result.get("captured_at", 0.0) or 0.0) + mono_ns = ( + int(captured_at * 1e9) + if captured_at > 0 + else time.monotonic_ns() + ) + record_payload = ( + "tactile", str(side), + tuple(float(v) for v in result.get( + "force", (0.0, 0.0, 0.0))), + int(mono_ns), packed, + ) + except Exception: + record_payload = None + result_slot = None + if result_storage is not None and result_free_slots is not None: + try: + result_slot = write_shared_result( + result_storage, + result_free_slots, + result_slot_bytes, + result, + ) + except Exception as exc: + _put_status(status_queue, ( + "error", f"result shared-memory write failed: {exc}", + traceback.format_exc(limit=8))) + raise + if result_slot is None: + dropped_results += 1 + if ( + dropped_results == 1 or + dropped_results % 100 == 0): + _put_status(status_queue, ( + "result_dropped", int(dropped_results))) + continue + try: + result_queue.put_nowait(result) + except queue.Full: + # 结果队列已满时不等待;等待会把子进程处理结果变成越来越 + # 旧的预览数据。当前 result 已完成计算,按 drop-new 策略丢掉。 + dropped_results += 1 + if dropped_results == 1 or dropped_results % 100 == 0: + _put_status(status_queue, ( + "result_dropped", int(dropped_results))) + except (BrokenPipeError, EOFError, OSError): + stop_event.set() + if record_payload is not None and ( + record_gate is None or record_gate.is_set() + ): + try: + record_queue.put_nowait(record_payload) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + except Exception as exc: + _put_status(status_queue, ( + "error", str(exc), traceback.format_exc(limit=12))) + stop_event.wait(0.05) + finally: + if frame_slot is not None and free_slots is not None: + try: + free_slots.put_nowait(int(frame_slot)) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + + +# --------------------------------------------------------------------------- +# Sightac 输入进程化(阶段1):input 线程从主进程迁入 spawn 子进程。 +# +# 新进程(run_tactile_input_process)负责: +# * TouchSensor 构造 / claim(spawn 不能继承 socket / VideoCapture), +# * 独占读取 Sightac 帧并写入共享帧池(计算子进程继续消费), +# * 原 TactileProcessBridge 的 calibration job 状态与 submit_capture 逻辑。 +# 主进程不再持有 VideoCapture/TouchSensor,也不再创建 input 线程;计算 +# 子进程保持现有 run_tactile_process 不变。 +# --------------------------------------------------------------------------- + + +class _InputCalibrationJob: + """输入进程内一次标定采集任务(迁移自 TactileProcessBridge 的 job)。""" + + __slots__ = ( + "job_id", "reason", "warmup_remaining", "frame_count", + "frames", "ready", "taken", + ) + + def __init__(self, job_id, reason, warmup_frames, frame_count): + self.job_id = int(job_id) + self.reason = str(reason) + self.warmup_remaining = max(0, int(warmup_frames)) + self.frame_count = max(1, int(frame_count)) + self.frames = [] + self.ready = False + self.taken = False + + +class TactileCaptureSubmitter: + """采集侧标定状态机:原 TactileProcessBridge.submit_capture 迁入输入进程。 + + 只允许单生产者使用(输入进程主循环)。无标定任务时把解码后的 uint8 + 帧拷入共享帧池并向计算子进程发布描述符;有标定任务时按 warmup / + 采样数收集原始帧,收集满后把 ("calibrate", ...) 直接发往计算子进程的 + command_queue。``finish_calibration`` 只在本进程收到父进程转发的 + calibration_done 后调用,语义与旧父进程内 job.done 一致。 + """ + + def __init__( + self, + frame_queue, + free_frame_slots, + shared_frame_storage, + frame_slot_bytes, + command_queue, + ): + self.frame_queue = frame_queue + self.free_frame_slots = free_frame_slots + self.shared_frame_storage = shared_frame_storage + self.frame_slot_bytes = int(frame_slot_bytes) + self.command_queue = command_queue + self.calibration_job = None + self.next_sequence = 0 + self.published_count = 0 + self.dropped_new_frames = 0 + self.stopping = False + + def request_calibration( + self, + job_id: int, + reason: str, + warmup_frames: int = 0, + frame_count: int = TACTILE_INITIAL_BASELINE_FRAMES, + ): + """创建一个指定 job_id 的采集任务;已有任务时返回现有任务。""" + if self.stopping: + return None + current = self.calibration_job + if current is not None: + return current + job = _InputCalibrationJob( + job_id, reason, warmup_frames, frame_count) + self.calibration_job = job + clear_frame_queue(self.frame_queue, self.free_frame_slots) + return job + + def finish_calibration(self, job_id: int) -> bool: + """计算子进程完成一次标定后清除任务,恢复普通帧采集。""" + if self.calibration_job is None: + return False + if int(job_id) != int(self.calibration_job.job_id): + return False + self.calibration_job = None + clear_frame_queue(self.frame_queue, self.free_frame_slots) + return True + + def submit_capture(self, frame, captured_at=None): + """与 TactileProcessBridge.submit_capture 语义一致的单生产者版本。""" + captured_at = ( + time.monotonic() + if captured_at is None + else float(captured_at) + ) + job = self.calibration_job + if job is not None: + if job.ready or job.taken: + return "calibration-wait" + if job.warmup_remaining > 0: + job.warmup_remaining -= 1 + return "calibration-warmup" + job.frames.append((frame, captured_at)) + if len(job.frames) >= job.frame_count: + job.ready = True + job.taken = True + frames = job.frames + job.frames = [] + calibration_payload = ( + "calibrate", + int(job.job_id), + job.reason, + frames, + ) + try: + self.command_queue.put(calibration_payload) + except (BrokenPipeError, EOFError, OSError) as exc: + # 计算子进程不可达:任务无法完成,恢复正常帧采集。 + self.calibration_job = None + clear_frame_queue( + self.frame_queue, self.free_frame_slots) + raise RuntimeError( + f"calibration IPC failed: {exc}") + return "calibration-frame" + + self.next_sequence += 1 + sequence = self.next_sequence + slot = None + try: + slot = self.free_frame_slots.get_nowait() + except queue.Empty: + self.dropped_new_frames += 1 + return "dropped-new" + try: + array = np.asarray(frame) + if ( + array.dtype != np.uint8 + or array.nbytes > self.frame_slot_bytes + ): + raise ValueError( + "unsupported Sightac frame for shared transport: " + f"dtype={array.dtype} shape={array.shape} " + f"nbytes={array.nbytes} max={self.frame_slot_bytes}" + ) + destination = shared_frame_view( + self.shared_frame_storage, + slot, + (array.nbytes,), + array.nbytes, + self.frame_slot_bytes, + ) + destination[:] = np.ascontiguousarray(array).reshape(-1) + self.frame_queue.put_nowait( + ( + sequence, + int(slot), + tuple(int(value) for value in array.shape), + int(array.nbytes), + captured_at, + ) + ) + except queue.Full: + try: + self.free_frame_slots.put_nowait(slot) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + self.dropped_new_frames += 1 + return "dropped-new" + except Exception: + try: + self.free_frame_slots.put_nowait(slot) + except (queue.Full, BrokenPipeError, EOFError, OSError): + pass + raise + self.published_count += 1 + return "frame" + + +def _import_ipc_camera(): + """从 checkout 内 camera_service/python 导入 libuvc IPC 客户端。""" + try: + from usb_camera_ipc import Camera as IpcCamera + return IpcCamera + except ImportError: + pass + try: + from core.gripper.fays_runtime import PROJECT_ROOT as _runtime_root + except Exception: + _runtime_root = os.path.dirname( + os.path.dirname(os.path.abspath(__file__))) + _ipc_root = os.path.join(_runtime_root, "camera_service", "python") + if _ipc_root not in sys.path: + sys.path.insert(0, _ipc_root) + from usb_camera_ipc import Camera as IpcCamera + return IpcCamera + + +class _ChildIpcReservedCamera: + """输入子进程内重建的 libuvc IPC 保留相机(spawn 不可继承父句柄)。 + + 只保留 TactileDiscovery.init_sensor 需要的 transport / flash_params / + claim();claim 复刻 IpcReservedCamera.claim 的首帧重试语义。 + """ + + transport = "libuvc-ipc" + + def __init__(self, spec): + spec = dict(spec or {}) + self.socket_path = str(spec.get("socket_path") or "") + self.flash_params = spec.get("flash_params") + raw_format = tuple(spec.get("capture_format") or ()) + if len(raw_format) != 4: + raw_format = (640, 480, 30.0, "MJPG") + self.actual_format = ( + int(raw_format[0]), int(raw_format[1]), + float(raw_format[2]), str(raw_format[3]), + ) + + def claim(self): + if not self.socket_path: + raise RuntimeError("Sightac IPC reservation has no socket path") + camera = _import_ipc_camera()(self.socket_path, timeout=0.5) + try: + camera.open() + first_frame = None + failed_reads = 0 + for attempt in range(20): + ok, frame = camera.read() + if ok and frame is not None and getattr( + frame, "size", 0 + ) > 0: + first_frame = frame + break + failed_reads += 1 + if attempt + 1 < 20: + time.sleep(0.05) + if first_frame is None: + raise RuntimeError( + f"Sightac libuvc IPC has no first frame: " + f"{self.socket_path} failed_reads={failed_reads}" + ) + return camera, first_frame, self.actual_format + except Exception: + try: + camera.release() + except Exception: + pass + raise + + +def _reconstruct_discovery(payload): + """在输入子进程内重建带完整 Flash 缓存的 TactileDiscovery。""" + payload = dict(payload or {}) + from core.gripper.devices.tactile_discovery import TactileDiscovery + + kwargs = {} + sysfs_root = str(payload.get("sysfs_root") or "/sys/class/video4linux") + dev_root = str(payload.get("dev_root") or "/dev") + kwargs["sysfs_root"] = sysfs_root + kwargs["dev_root"] = dev_root + if payload.get("platform") is not None: + kwargs["platform"] = str(payload["platform"]) + if payload.get("sightac_root") is not None: + kwargs["sightac_root"] = str(payload["sightac_root"]) + if payload.get("old_sensor_template_file") is not None: + kwargs["old_sensor_template_file"] = str( + payload["old_sensor_template_file"]) + if payload.get("full_logs") is not None: + kwargs["full_logs"] = bool(payload["full_logs"]) + discovery = TactileDiscovery(**kwargs) + if payload.get("api_package"): + discovery.api_package = str(payload["api_package"]) + cache = payload.get("flash_full_params_cache") or {} + discovery.flash_full_params_cache = { + int(index): dict(params) for index, params in cache.items() + } + labels = payload.get("flash_param_cache") or {} + discovery.flash_param_cache = { + int(index): value for index, value in labels.items() + } + return discovery + + +def _build_input_sensor(config): + """在输入子进程内构造 TouchSensor。 + + 默认重建带完整 Flash 缓存的 TactileDiscovery 并 init_sensor; + 测试/隔离调试可注入 "sensor_builder"("module:attr" 工厂)。 + """ + builder = str(config.get("sensor_builder") or "").strip() + if builder: + module_name, _, attr = builder.partition(":") + if not module_name or not attr: + raise RuntimeError( + f"invalid sensor_builder: {builder!r}") + module = importlib.import_module(module_name) + factory = getattr(module, attr) + return factory(config) + discovery = _reconstruct_discovery(config.get("discovery") or {}) + reserved_spec = config.get("reserved") + reserved_camera = ( + None + if not reserved_spec + else _ChildIpcReservedCamera(reserved_spec) + ) + video_index = int(config["video_index"]) + return discovery.init_sensor( + video_index, reserved_camera=reserved_camera) + + +def run_tactile_input_process( + side, + cpu, + config, + frame_queue, + free_frame_slots, + shared_frame_storage, + frame_slot_bytes, + command_queue, + input_command_queue, + input_status_queue, + stop_event, + begin_event, +): + """独立 Sightac 输入子进程入口(spawn)。 + + config 字段: + video_index : int + mode : "open" | "connected"(仅日志) + initial_job : {"job_id": int, "warmup_frames": int} 或 None + discovery : 父进程 TactileDiscovery 可序列化状态 + reserved : IPC 保留相机 spec 或 None(None 走 V4L2) + + 上报消息(input_status_queue): + ("ready", pid, cpus, sensor_state) 传感器构造完成 + ("calibration_started", job_id, reason) + ("calibration_busy", job_id, reason) + ("frame_activity", monotonic_ns) + ("input_stats", published, dropped_new, empty_reads) + ("error"/"fatal", message, detail) + """ + logger = config.get("_logger") if isinstance(config, dict) else None + + def log(text): + if logger is not None: + try: + logger(str(text)) + except Exception: + pass + + sensor = None + skip_pin = bool(config.get("skip_pin")) \ + if isinstance(config, dict) else False + try: + actual = () if skip_pin else _pin_entire_process(int(cpu)) + except Exception as exc: + _put_status(input_status_queue, ( + "fatal", str(exc), traceback.format_exc(limit=12))) + return + + sensor_name = "sensor2" if side == "left" else "sensor3" + try: + sensor = _build_input_sensor(config) + if sensor is None: + raise RuntimeError("TouchSensor construction failed") + video_index = int(config["video_index"]) + sensor_state = snapshot_sensor_state(sensor) + sightac_root = _ensure_sightac_sdk_path( + (config.get("discovery") or {}).get("sightac_root")) + if sightac_root is not None: + sensor_state["__ksq_sightac_root__"] = sightac_root + log( + f"[TactileInput:{sensor_name}] sensor ready " + f"video{video_index} pid={os.getpid()} " + f"sdk={sightac_root or ''}" + ) + except Exception as exc: + _put_status(input_status_queue, ( + "fatal", str(exc), traceback.format_exc(limit=12))) + try: + if sensor is not None: + cap = getattr(sensor, "cap", None) + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + pass + return + + _put_status(input_status_queue, ( + "ready", os.getpid(), actual, sensor_state)) + + submitter = TactileCaptureSubmitter( + frame_queue, + free_frame_slots, + shared_frame_storage, + int(frame_slot_bytes), + command_queue, + ) + initial_job = config.get("initial_job") or {} + if initial_job.get("job_id") is not None: + submitter.request_calibration( + job_id=int(initial_job["job_id"]), + reason=str(initial_job.get("reason") or "initial"), + warmup_frames=int(initial_job.get("warmup_frames") or 0), + frame_count=int( + initial_job.get("frame_count") + or TACTILE_INITIAL_BASELINE_FRAMES), + ) + _put_status(input_status_queue, ( + "calibration_started", + int(initial_job["job_id"]), + str(initial_job.get("reason") or "initial"), + )) + log( + f"[TactileInput:{sensor_name}] initial calibration queued: " + f"job={int(initial_job['job_id'])} " + f"warmup={int(initial_job.get('warmup_frames') or 0)}" + ) + + # 等父进程完成 Fays open 与计算子进程启动后再开始读帧。 + while not begin_event.wait(timeout=0.05): + if stop_event.is_set(): + break + + empty_reads = 0 + last_stats_at = time.monotonic() + try: + while not stop_event.is_set(): + command = None + try: + command = input_command_queue.get_nowait() + except queue.Empty: + pass + except (EOFError, OSError): + break + if command is not None: + kind = command[0] + if kind == "stop": + break + if kind == "request_calibration": + ( + _kind, job_id, reason, warmup_frames, + frame_count, + ) = command + existing = submitter.request_calibration( + job_id=int(job_id), + reason=str(reason), + warmup_frames=int(warmup_frames or 0), + frame_count=int( + frame_count or TACTILE_INITIAL_BASELINE_FRAMES), + ) + if existing is None: + continue + if int(existing.job_id) == int(job_id): + _put_status(input_status_queue, ( + "calibration_started", + int(existing.job_id), + str(existing.reason), + )) + else: + _put_status(input_status_queue, ( + "calibration_busy", + int(existing.job_id), + str(existing.reason), + )) + elif kind == "calibration_done": + ( + _kind, job_id, success, error, + ) = command + if submitter.finish_calibration(int(job_id)): + log( + f"[TactileInput:{sensor_name}] calibration " + f"done: job={int(job_id)} " + f"success={bool(success)}") + continue + + try: + raw_frame = getattr( + sensor, "_ksq_prefetched_frame", None) + if raw_frame is not None: + sensor._ksq_prefetched_frame = None + else: + raw_frame = sensor.read_raw_frame() + captured_at = time.monotonic() + except Exception as exc: + log( + f"[TactileInput:{sensor_name}] ERROR: {exc}") + _put_status(input_status_queue, ( + "error", str(exc), + traceback.format_exc(limit=8))) + time.sleep(0.05) + continue + + if raw_frame is None: + empty_reads += 1 + capture = getattr(sensor, "cap", None) + transport = getattr(capture, "transport", "") + if transport == "libuvc-ipc": + try: + capture.reconnect() + except Exception as exc: + log( + f"[TactileInput:{sensor_name}] IPC " + f"reconnect failed: {exc}") + if empty_reads in (1, 10, 30, 60): + log( + f"[TactileInput:{sensor_name}] no frame " + f"count={empty_reads} transport={transport!r} " + f"reconnects=" + f"{getattr(capture, 'reconnect_count', 0)} " + f"error=" + f"{getattr(capture, 'last_transport_error', '')!r}") + if empty_reads >= 60: + error_text = ( + f"{sensor_name} Sightac IPC has no frame for " + f"60 reads (reconnects=" + f"{getattr(capture, 'reconnect_count', 0)}, " + f"transport_error=" + f"{getattr(capture, 'last_transport_error', '') or 'unknown'})" + ) + _put_status(input_status_queue, ( + "error", error_text, "", + )) + break + time.sleep(0.01) + continue + + empty_reads = 0 + if stop_event.is_set(): + break + _put_status(input_status_queue, ( + "frame_activity", int(time.monotonic_ns()))) + try: + submitter.submit_capture(raw_frame, captured_at) + except Exception as exc: + log( + f"[TactileInput:{sensor_name}] submit ERROR: {exc}") + _put_status(input_status_queue, ( + "error", str(exc), + traceback.format_exc(limit=8))) + time.sleep(0.05) + + now = time.monotonic() + if now - last_stats_at >= 0.5: + last_stats_at = now + _put_status(input_status_queue, ( + "input_stats", + int(submitter.published_count), + int(submitter.dropped_new_frames), + int(empty_reads), + )) + finally: + try: + if sensor is not None: + cap = getattr(sensor, "cap", None) + if cap is not None and hasattr(cap, "release"): + cap.release() + except Exception: + pass + _put_status(input_status_queue, ( + "input_stats", + int(submitter.published_count), + int(submitter.dropped_new_frames), + int(empty_reads), + )) + log(f"[TactileInput:{sensor_name}] input process exit") diff --git a/collector/core/pipeline.py b/collector/core/pipeline.py index bf53f928b8772314ea19d4f1421ea6e7d4c9b248..1b178f80731bbab306b4ecb07718d5c4ccc4e992 100755 --- a/collector/core/pipeline.py +++ b/collector/core/pipeline.py @@ -137,6 +137,9 @@ class CameraPipeline(QObject): self._pending_imu: Dict[str, list] = {} # slot → 队列满暂存的 IMU 样本 self._pending_imu_lock = threading.Lock() self._imu_overflow_count = 0 # 防丢缓冲超限次数(每 episode 告警一次) + # IMU 批只随主槽位写入的槽位集合(S80M 独立双目左右目共享同一份 + # 样本;夹爪链路不存 IMU/双目视频,只落盘 SLAM 位姿/轨迹) + self._imu_external_slots = {"stereo_left"} # 已注册的传感器名称列表(决定 parquet 中 observation. 列) self._sensor_names: List[str] = [] @@ -153,6 +156,18 @@ class CameraPipeline(QObject): # USB 手套骨架关键点:sensor_name → 63×f32(21×3 米),同节奏快照 self._glove_kpts: Dict[str, np.ndarray] = {} self._glove_kpts_lock = threading.Lock() + # UMI 夹爪稀疏列快照(P3/P4):latest-wins,写入线程每帧取走清空 + # 键:slam_pose / gripper_state / gripper_{left,right}_force / + # gripper_{left,right}_force_matrix(P4 泵线程预编码 int16 列表) + # 双夹爪 rig2 加 "gripper_2_" 前缀(rig1 旧键不变,见 write_*) + self._gripper_snapshots: Dict[str, object] = {} + self._gripper_snapshots_lock = threading.Lock() + # SLAM 轨迹点按帧窗口累积(每点 8 值 [t,x,y,z,qx,qy,qz,qw] 扁平), + # 行写入时并入 snapshot——轨迹 txt 侧车由此废弃(并入 episode parquet) + self._gripper_traj: Dict[str, list] = {} + # 夹爪非视频槽设备 ID(pose/force 槽不走 register_external_source, + # 单独进 status 列) + self._gripper_device_ids: set = set() # 外部帧源(如双目子进程),不经过 CameraWorker # 帧通过队列传入写入线程,以固定帧率均匀消费,避免 GIL 导致的写入抖动 @@ -296,7 +311,7 @@ class CameraPipeline(QObject): # 的 IMU 批次转入防丢缓冲,随后续帧按时间戳挂靠落盘 —— # 丢帧只损失视频帧,不损失 IMU 样本 self._drop_stats.inc(f"ext:{slot_id}") - if slot_id == "stereo_left" and imu_samples: + if slot_id in self._imu_external_slots and imu_samples: with self._pending_imu_lock: buf = self._pending_imu.setdefault(slot_id, []) buf.extend(imu_samples) @@ -427,6 +442,14 @@ class CameraPipeline(QObject): if sensor_name in self._sensor_names: self._sensor_names.remove(sensor_name) + def register_gripper_device_id(self, device_id: str): + """UMI 夹爪非视频槽进 status 列(pose/force 槽,开关时实时调用)。""" + self._gripper_device_ids.add(device_id) + + def unregister_gripper_device_id(self, device_id: str): + """注销夹爪非视频槽设备 ID(开关 OFF)。""" + self._gripper_device_ids.discard(device_id) + # ── 录制控制 ────────────────────────────────────── def start_recording(self, slot_id: str, task_name: str = "", @@ -478,7 +501,9 @@ class CameraPipeline(QObject): w = EgoDataWriter() # 探针日志在 start_episode 内 emit → connect 必须在调用之前 w.log_occurred.connect(self.recording_log) - all_device_ids = list(self._slots.keys()) + list(self._sensor_names) + all_device_ids = (list(self._slots.keys()) + + list(self._sensor_names) + + sorted(self._gripper_device_ids)) # 设备标定(多路):set_device_calibration 注册的按 key 传入; # 旧 set_external_calibration 单值路径存 "_default" 键 calibrations = dict(self._external_calibrations) @@ -540,6 +565,9 @@ class CameraPipeline(QObject): while not self._sensor_queue.empty(): try: self._sensor_queue.get_nowait() except queue.Empty: break + with self._gripper_snapshots_lock: + self._gripper_snapshots.clear() + self._gripper_traj.clear() # B+ 方案: 启动独立写入线程(精确 30fps,完全不受主线程 UI 影响) self._write_thread = threading.Thread( @@ -584,6 +612,8 @@ class CameraPipeline(QObject): # 手套 IMU/骨架快照随本帧行写入(USB 手套;空 dict 无影响) glove_imu = self._pop_glove_imu() glove_kpts = self._pop_glove_keypoints() + # 夹爪稀疏列快照(P3/P4;空 dict 无影响) + gripper = self._pop_gripper_snapshots() # 处理 CameraSlot 队列(排空取最新帧) for sid, sl in self._slots.items(): @@ -603,7 +633,8 @@ class CameraPipeline(QObject): self._write_one_frame(sid, frame, sensor_data, glove_imu=glove_imu, - glove_kpts=glove_kpts) + glove_kpts=glove_kpts, + gripper=gripper) # 处理外部帧源队列(取一帧不排空,保证输出均匀无抖动) # 双目帧已在 _on_stereo_frame 完成垂直翻转,此处不再重复翻转 @@ -616,9 +647,9 @@ class CameraPipeline(QObject): frame, hw_ns, imu_s = item else: # 兼容旧格式(仅帧) frame, hw_ns, imu_s = item, 0, None - # IMU 样本只随 stereo_left 写入(左右目共享同一份, - # 避免 data/imu/ 出现重复行) - if sid != "stereo_left": + # IMU 样本只随主槽位写入(左右目共享同一份, + # 避免 data/imu/ 出现重复行;S80M/夹爪各自的主槽) + if sid not in self._imu_external_slots: imu_s = None else: # v1.0.9:队列满时暂存的 IMU 批次随后续帧挂靠。 @@ -643,7 +674,8 @@ class CameraPipeline(QObject): hardware_ns=hw_ns, imu_samples=imu_s, glove_imu=glove_imu, - glove_kpts=glove_kpts) + glove_kpts=glove_kpts, + gripper=gripper) except Exception: pass @@ -654,7 +686,8 @@ class CameraPipeline(QObject): hardware_ns: int = 0, imu_samples: Optional[List] = None, glove_imu: Optional[Dict[str, tuple]] = None, - glove_kpts: Optional[Dict[str, np.ndarray]] = None): + glove_kpts: Optional[Dict[str, np.ndarray]] = None, + gripper: Optional[Dict] = None): """写入单帧到 MP4 + Parquet。 Args: @@ -665,6 +698,7 @@ class CameraPipeline(QObject): imu_samples: 本帧窗口的 IMU 样本列表(双目,随 stereo_left 携带) glove_imu: {传感器名: (quats 64×f32, valid 16×f32)} USB 手套 IMU 快照 glove_kpts: {传感器名: 63×f32 骨架关键点} USB 手套骨架快照 + gripper: UMI 夹爪稀疏列快照(P3/P4,见 write_gripper_*) """ cam_frame_idx = self._per_cam_frame.get(sid, 0) rel_ts = time.time() - self._episode_start_s @@ -677,6 +711,7 @@ class CameraPipeline(QObject): imu_samples=imu_samples, glove_imu=glove_imu, glove_kpts=glove_kpts, + gripper=gripper, ) self._per_cam_frame[sid] = cam_frame_idx + 1 self._frame_count += 1 @@ -773,6 +808,84 @@ class CameraPipeline(QObject): with self._glove_kpts_lock: self._glove_kpts[sensor_name] = k + # ── UMI 夹爪稀疏列快照(P3/P4;latest-wins,写入线程每帧取走)── + def _put_gripper_snapshot(self, key: str, value): + if self._writer is None or not self._recording: + return + with self._gripper_snapshots_lock: + self._gripper_snapshots[key] = value + + def write_slam_pose(self, pose7, prefix: str = "", timestamp=None): + """SLAM 位姿快照 [x,y,z,qx,qy,qz,qw](P3;桥接 pose_ready 回调)。 + + prefix 为双夹爪命名空间:rig1 空串(旧键 slam_pose 不变), + rig2 "gripper_2_" → gripper_2_slam_pose。 + + 同时把完整轨迹点 [t,x,y,z,qx,qy,qz,qw] 累积进本帧窗口的 + {prefix}slam_trajectory(行写入时取走)——轨迹不再单独落 + txt 侧车,全部信息都在一条 episode parquet 里。 + """ + if pose7 is None: + return + values = [float(value) for value in pose7[:7]] + if len(values) != 7 or not all(np.isfinite(values)): + return + self._put_gripper_snapshot(f"{prefix}slam_pose", values) + if timestamp is not None: + try: + t = float(timestamp) + except (TypeError, ValueError): + return + if not np.isfinite(t): + return + with self._gripper_snapshots_lock: + if self._writer is None or not self._recording: + return + self._gripper_traj.setdefault( + f"{prefix}slam_trajectory", []).extend([t, *values]) + + def write_gripper_state(self, state3, prefix: str = ""): + """夹爪状态快照 [open_pct, gripped, fz_mn](P4;GripState 输出)。""" + if state3 is None: + return + values = [float(value) for value in state3[:3]] + if len(values) != 3 or not all(np.isfinite(values)): + return + self._put_gripper_snapshot(f"{prefix}gripper_state", values) + + def write_tactile_force(self, side: str, force3, prefix: str = ""): + """触觉力快照 [fx,fy,fz] mN(P2/P3;tactile_ready 回调)。""" + if force3 is None or side not in ("left", "right"): + return + values = [float(value) for value in force3[:3]] + if len(values) != 3 or not all(np.isfinite(values)): + return + self._put_gripper_snapshot( + f"{prefix}gripper_{side}_force", values) + + def write_tactile_force_matrix(self, side: str, encoded, + prefix: str = ""): + """触觉力矩阵快照(P4 泵线程预编码的 int16 行差分列表)。""" + if encoded is None or side not in ("left", "right"): + return + self._put_gripper_snapshot( + f"{prefix}gripper_{side}_force_matrix", encoded) + + def _pop_gripper_snapshots(self) -> Dict[str, object]: + """取走并清空本帧窗口内的夹爪快照(写入线程调用)。 + + 轨迹点在此并入:{prefix}slam_trajectory = 本窗口内全部点的 + 扁平 8 值列表(无点则不写键)。 + """ + with self._gripper_snapshots_lock: + snapshot = dict(self._gripper_snapshots) + self._gripper_snapshots.clear() + for key, points in self._gripper_traj.items(): + if points: + snapshot[key] = points + self._gripper_traj.clear() + return snapshot + def _pop_glove_keypoints(self) -> Dict[str, np.ndarray]: """取走并清空本帧窗口内的手套骨架快照(写入线程调用)。""" with self._glove_kpts_lock: diff --git a/collector/core/s80m_manager.py b/collector/core/s80m_manager.py index 5f1c0c81b948796c7f1a0addd12a76a480d52efd..e86e041e4825915ffae03a100aef2193e733671a 100644 --- a/collector/core/s80m_manager.py +++ b/collector/core/s80m_manager.py @@ -213,14 +213,21 @@ class S80MDeviceManager(QObject): self.shutting_down = False @staticmethod - def new_entry(label: str) -> dict: - """注册表条目骨架(kind/slots/label 由主窗口注册,进程字段由 spawn 填充)。""" + def new_entry(label: str, serial: str = "", usb_path: str = "") -> dict: + """注册表条目骨架(kind/slots/label 由主窗口注册,进程字段由 spawn 填充)。 + + serial / usb_path:枚举得到的相机身份(USB 序列号 / 拓扑路径), + spawn 传给子进程 --device-serial / --device-path,多台 S80 接入 + 时每台只打开自己的双目对。 + """ return { "kind": "s80m", # 深度可用时设备 meta 多记录一路深度槽(spawn 后真实生效) "slots": ["stereo_left", "stereo_right"] + (["stereo_depth"] if s80m_depth_available() else []), "label": label, + "serial": serial, # USB 序列号(子进程端口解析选相机) + "usb_path": usb_path, # USB 拓扑路径(同号序列号兜底) "proc": None, "stdin": None, # 曝光命令通道(close 时关闭) "stderr_file": None, @@ -276,11 +283,19 @@ class S80MDeviceManager(QObject): cb_args = (["--cb-bridge"] if settings.STEREO_CB_BRIDGE and os.path.isfile(CB_BRIDGE_LIB) else []) + # 多台 S80 相机区分:设备身份传入子进程,端口解析只选该台 + # (--device-serial 按序列号、--device-path 按 USB 拓扑路径,同给 + # 时路径为准;目标找不到子进程退出码 2,绝不静默开另一台) + dev_args = [] + if entry.get("serial"): + dev_args += ["--device-serial", entry["serial"]] + if entry.get("usb_path"): + dev_args += ["--device-path", entry["usb_path"]] # stdin 管道 = 曝光控制通道(行协议 "SET_EXPOSURE ", # SDK 运行时生效无需重启;子进程句柄创建完成前命令先积在管道缓冲) proc = subprocess.Popen( [sys.executable, STEREO_DEMO, "--pipe", "-"] + cfg_args - + depth_args + cb_args, + + dev_args + depth_args + cb_args, cwd=SDK_ROOT, stdin=subprocess.PIPE, stdout=subprocess.PIPE, diff --git a/collector/core/uploader.py b/collector/core/uploader.py index 9a5fb189ab3d0561d135d7c0ec8a69b8f1db13a2..f29f2278895671d7e8dffa9347ed4ea0ae7bfe0f 100755 --- a/collector/core/uploader.py +++ b/collector/core/uploader.py @@ -16,7 +16,7 @@ import time import zipfile import threading import tempfile -from datetime import datetime +from datetime import datetime, timedelta from typing import Optional from PyQt5.QtCore import QObject, pyqtSignal, QMutex, QMutexLocker @@ -27,6 +27,95 @@ from core.api_client import APIClient from core.helpers import episode_file_suffix +# ═══════════════════════════════════════════════════════ +# 会话名校验(上传后确认服务器是否已入库) +# ═══════════════════════════════════════════════════════ + +# 尾部 episode 标记:_ep000012 / _episode-12 / _000013 +_EP_SUFFIX_RE = re.compile( + r"^(?P.+?)(?:[_-]ep(?:isode)?[_-]?\d{1,6}|[_-]\d{6,})$", re.I) + + +def session_name_base(name: str) -> str: + """会话名去掉尾部 episode 标记与 .zip 后缀 → 任务基名。 + + "UMIGripper_AI" / "UMIGripper_AI_000012" / "UMIGripper_AI_ep000012" + / "UMIGripper_AI_episode-12" / "UMIGripper_AI.zip" → "UMIGripper_AI" + """ + n = (name or "").strip() + if n.lower().endswith(".zip"): + n = n[:-4] + m = _EP_SUFFIX_RE.match(n) + return (m.group("base") if m else n).strip() + + +def session_matches(session_name: str, server_session: dict) -> bool: + """服务器会话记录是否就是本次上传产生的会话(名字相等或基名相等)。""" + srv = str((server_session or {}).get("name", "") or "").strip() + if not srv or not session_name: + return False + if srv == session_name.strip(): + return True + base = session_name_base(session_name) + return bool(base) and session_name_base(srv) == base + + +def _parse_iso(value) -> Optional[datetime]: + """宽松解析时间戳为 naive 本地时间;失败返回 None。""" + if not value: + return None + try: + dt = datetime.fromisoformat(str(value).strip().replace("Z", "+00:00")) + except (ValueError, TypeError): + return None + if dt.tzinfo is not None: + dt = dt.astimezone().replace(tzinfo=None) + return dt + + +def pick_new_session(before_ids: set, sessions: list, + session_name: str) -> Optional[dict]: + """在快照 before_ids 之后新出现的同名会话里取最新一条(无则 None)。""" + best = None + for s in sessions or []: + if str(s.get("id", "")) in before_ids: + continue + if not session_matches(session_name, s): + continue + key = str(s.get("created_at", "") or "") + if best is None or key >= best[0]: + best = (key, s) + return best[1] if best else None + + +def pick_session_in_window(sessions: list, session_name: str, since_iso: str, + until_iso: str = "", tol_s: float = 60.0 + ) -> Optional[dict]: + """名字匹配且 created_at ∈ [since_iso - tol_s, until_iso] 的最新一条。 + + 续传判据:上次进程被杀时 POST 可能已入库而客户端没收到响应。窗口下界 + 是那次 POST 的开始时刻(tol_s 吸收客户端/服务器时钟差),上界是下一个 + POST 的开始时刻——否则"同任务上一条已入库的会话"会被误判成本条的。 + until_iso 为空 = 不限上界。时间戳缺失/不可解析 → None(照常重传)。 + """ + since = _parse_iso(since_iso) + if since is None: + return None + until = _parse_iso(until_iso) if until_iso else None + best = None + for s in sessions or []: + if not session_matches(session_name, s): + continue + dt = _parse_iso(s.get("created_at")) + if dt is None or (since - dt).total_seconds() > tol_s: + continue + if until is not None and dt > until: + continue + if best is None or dt >= best[0]: + best = (dt, s) + return best[1] if best else None + + # ═══════════════════════════════════════════════════════ # 上传任务 # ═══════════════════════════════════════════════════════ @@ -36,11 +125,13 @@ class UploadTask: __slots__ = ("id", "session_path", "session_name", "episode_index", "status", "progress", "retry_count", "server_url", - "server_session_id", "error_message", "created_at", "updated_at") + "server_session_id", "error_message", "created_at", "updated_at", + "resumed") - def __init__(self, session_path: str, server_url: str, episode_index: int = 0): + def __init__(self, session_path: str, server_url: str, episode_index: int = 0, + task_id: str = "", resumed: bool = False, created_at: str = ""): import uuid - self.id = uuid.uuid4().hex[:12] + self.id = task_id or uuid.uuid4().hex[:12] self.session_path = session_path # v1.1.0 池化:session_path = 任务目录,session_name 即任务名 self.session_name = os.path.basename(session_path) @@ -52,8 +143,11 @@ class UploadTask: self.server_session_id = "" self.error_message = "" now = datetime.now().isoformat() - self.created_at = now + # 续传复用原行的 created_at —— 它是"上次尝试是否已入库"的时间基准 + self.created_at = created_at or now self.updated_at = now + # True = 由启动续传从 DB 恢复(上传前多一道"服务器是否已入库"检查) + self.resumed = bool(resumed) def to_dict(self) -> dict: return {k: getattr(self, k, "") for k in self.__slots__} @@ -63,6 +157,7 @@ class UploadTask: t = UploadTask.__new__(UploadTask) for k in UploadTask.__slots__: setattr(t, k, row.get(k, "")) + t.resumed = bool(row.get("resumed", False)) return t @@ -103,6 +198,7 @@ class UploadManager(QObject): self._queue: list[UploadTask] = [] self._active: dict[str, threading.Thread] = {} self._active_tasks: dict[str, UploadTask] = {} # task_id → 任务对象(防重查询用) + self._started_at: dict[str, float] = {} # task_id → 开始时刻(monotonic) self._mutex = QMutex() self._running = False self._worker_thread: Optional[threading.Thread] = None @@ -126,18 +222,24 @@ class UploadManager(QObject): def project_id(self, value: str): self._project_id = (value or "").strip() - def add_task(self, session_path: str, episode_index: int = 0) -> str: + def add_task(self, session_path: str, episode_index: int = 0, + task_id: str = "", resumed: bool = False, + created_at: str = "") -> str: """添加一个上传任务,返回 task_id。 v1.1.0 池化:防重键 (task_dir, episode_index)——同一 episode 已在队列/ 执行中时返回既有任务 id,不重复入队(自动上传与手动上传互防)。 + + task_id/resumed:启动续传时复用 DB 里那行的 id 与创建时间, + 临时文件名随之复用(顺带覆盖上次被杀进程的残留临时文件)。 """ with QMutexLocker(self._mutex): for t in self._queue + list(self._active_tasks.values()): if (t.session_path == session_path and t.episode_index == episode_index): return t.id - task = UploadTask(session_path, self._server_url, episode_index) + task = UploadTask(session_path, self._server_url, episode_index, + task_id=task_id, resumed=resumed, created_at=created_at) self._save_to_db(task) with QMutexLocker(self._mutex): self._queue.append(task) @@ -194,6 +296,187 @@ class UploadManager(QObject): def all_done(self) -> bool: return self.pending_count() == 0 and self.active_count() == 0 + def inflight(self) -> dict: + """{(session_path, episode_index): {task_id, state, progress, elapsed}}。 + + state = "active"(正在打包/上传)| "queued"(排队中)。供上传 + 对话框显示 ⏳ 用——DB 状态只在任务结束时才写,实时状态只能问 + 管理器。线程安全。 + """ + now = time.monotonic() + out = {} + with QMutexLocker(self._mutex): + for t in self._queue + list(self._active_tasks.values()): + out[(t.session_path, t.episode_index)] = { + "task_id": t.id, + "state": "active" if t.id in self._active_tasks else "queued", + "progress": float(t.progress or 0.0), + "elapsed": max(0.0, now - self._started_at.get(t.id, now)), + } + return out + + # ── 启动清理与续传 ──────────────────────────────── + + # 上传临时文件(打包 zip / episodes 单行切片 / 预压缩视频)都落在 + # 录制根目录,命名前缀见 _zip_session/_zip_episode/_episode_slice_parquet/ + # _precompress_videos。 + _TMP_RE = re.compile( + r"^_(?:.+_upload_[0-9a-zA-Z]+\.zip|episodes_.+\.parquet|precomp_.+)$") + + @staticmethod + def sweep_orphan_temp_files(base_dir: str, max_age_hours: float = 24.0) -> int: + """删除被杀死进程遗留的上传临时文件,返回删除个数。 + + 只删 mtime 超过 max_age_hours 的:正在上传的进程可能正在写这些 + 文件(另一实例/另一个版本),年龄门槛保证不会误删。 + """ + if not base_dir or not os.path.isdir(base_dir): + return 0 + cutoff = time.time() - max_age_hours * 3600 + removed = 0 + try: + names = os.listdir(base_dir) + except OSError: + return 0 + for name in names: + if not UploadManager._TMP_RE.match(name): + continue + p = os.path.join(base_dir, name) + try: + if not os.path.isfile(p) or os.path.getmtime(p) > cutoff: + continue + os.remove(p) + removed += 1 + except OSError: + continue + return removed + + @staticmethod + def _local_episode_exists(session_path: str, episode_index: int) -> bool: + """episode 数据文件是否仍在本地(续传前的存在性检查)。 + + 文件已被 UPLOAD_DELETE_AFTER 或手动删除时不能再续传:_zip_episode + 会打出一个缺数据的包。 + """ + if not os.path.isdir(session_path): + return False + if episode_index <= 0: + try: + return bool(os.listdir(session_path)) + except OSError: + return False + from core.helpers import list_task_episodes + return episode_index in list_task_episodes(session_path) + + def _resume_sessions_snapshot(self) -> Optional[list]: + """续传判据用的服务器会话列表;查询失败返回 None(照常重传)。""" + try: + client = APIClient(self._server_url, session=self._shared_session) + except Exception: + return None + try: + return client.try_get_sessions( + limit=getattr(settings, "UPLOAD_SESSION_SNAPSHOT_LIMIT", 200)) + finally: + client.close() + + def resume_pending(self, max_age_hours: float = 24.0) -> tuple: + """启动续传:把上次进程未完成的上传重新入队。 + + Returns: + (resumed, verified, skipped) + resumed = [(task_id, session_path, episode_index), ...] 已重新入队 + verified = [(task_id, session_path, episode_index, session_id), ...] + 服务器上已存在 → 直接按成功收尾,不再上传 + skipped = [{"path", "episode_index", "reason"}, ...] + reason ∈ missing_files | server_changed | already_done | already_queued + + 只取每个 (session_path, episode_index) 最近一次尝试:更早的 pending + 行已被后来的行取代,否则每次启动都会重复入队。 + + 已入库判定(避免"上次 POST 其实成功了"被重复上传):只有上次 + **POST 已经开始**(行状态 uploading,updated_at = POST 开始时刻)的 + 才做预判——打包阶段被杀的肯定没入库,直接重传。判定按时间顺序 + 做"一对一分配":一条服务器会话只认领一次,且必须落在该次 POST 的 + 开始时刻与下一次 POST 开始时刻之间(同任务多条续传时防串位)。 + """ + cutoff = (datetime.now() - timedelta(hours=max_age_hours)).isoformat() + try: + # 最新在前 → 每个键只保留最近一次尝试(更早的 pending 行已被 + # 后来的行取代;用旧行会拿错 POST 时刻、重复上传已入库的件) + rows = db.conn.execute( + "SELECT * FROM upload_task WHERE status IN ('pending', 'uploading') " + "AND created_at >= ? ORDER BY created_at DESC", (cutoff,) + ).fetchall() + except Exception: + return [], [], [] + + cands, skipped, seen = [], [], set() + for row in rows: + row = dict(row) + key = (row.get("session_path", ""), row.get("episode_index", 0)) + if key in seen: + continue + seen.add(key) + path, ep = key + if str(row.get("server_url", "")).rstrip("/") != \ + self._server_url.rstrip("/"): + skipped.append({"path": path, "episode_index": ep, + "reason": "server_changed"}) + continue + if self.get_upload_status(path, ep) == "completed": + skipped.append({"path": path, "episode_index": ep, + "reason": "already_done"}) + continue + if not self._local_episode_exists(path, ep): + skipped.append({"path": path, "episode_index": ep, + "reason": "missing_files"}) + continue + if self.has_task(path, ep): + skipped.append({"path": path, "episode_index": ep, + "reason": "already_queued"}) + continue + cands.append({ + "row": row, "path": path, "episode_index": ep, + # POST 开始时刻(仅 status=uploading 的行有) + "anchor": (str(row.get("updated_at", "") or "") + if row.get("status") == "uploading" else ""), + }) + + cands.reverse() # 回到时间正序(一对一分配按 POST 先后) + + sessions = None + if any(c["anchor"] for c in cands): + sessions = self._resume_sessions_snapshot() + + resumed, verified, claimed = [], [], set() + for i, c in enumerate(cands): + anchor, path, ep = c["anchor"], c["path"], c["episode_index"] + if sessions is not None and anchor: + # 上界 = 下一条"POST 已开始"的续传行的开始时刻(没有则不限) + until = next((c2["anchor"] for c2 in cands[i + 1:] + if c2["anchor"]), "") + hit = pick_session_in_window( + sessions, os.path.basename(path), anchor, until, + tol_s=getattr(settings, "UPLOAD_RESUME_SKEW_TOL_S", 60.0)) + sid = str((hit or {}).get("id", "")) + if hit is not None and sid not in claimed: + claimed.add(sid) + task = UploadTask( + path, self._server_url, ep, + task_id=str(c["row"].get("id", "")), resumed=True, + created_at=str(c["row"].get("created_at", "") or "")) + # emit=False:调用方还没登记 task_id → 收尾由它自己做 + self._mark_upload_verified(task, hit, "上次进程中断前已入库", + emit=False) + verified.append((task.id, path, ep, sid)) + continue + tid = self.add_task( + path, ep, task_id=str(c["row"].get("id", "")), resumed=True, + created_at=str(c["row"].get("created_at", "") or "")) + resumed.append((tid, path, ep)) + return resumed, verified, skipped + # ── 工作循环 ────────────────────────────────────── def _worker_loop(self): @@ -219,11 +502,14 @@ class UploadManager(QObject): def _upload_one(self, task: UploadTask): """执行单个任务的完整上传流程。""" task_id = task.id + with QMutexLocker(self._mutex): + self._started_at[task_id] = time.monotonic() self.task_started.emit(task_id) client = APIClient(self._server_url, session=self._shared_session) zip_path = None precomp = {} + post_started = False # POST 是否已发出(打包/预压失败不必查服务器) try: # ── 步骤 1: 视频预压缩(大会话必备)── @@ -270,6 +556,23 @@ class UploadManager(QObject): if project_id and not self._project_id: self.task_status.emit(task_id, f"已匹配目标项目 {project_id[:8]}…") + # ── 上传前:记录服务器会话列表快照 ── + # 快照 + 失败后复查 = "POST 到底有没有入库"的唯一判据 + # (服务器不提供 GET /session/{id},只能看列表)。 + baseline_ok, before_ids = False, set() + snap = client.try_get_sessions( + limit=getattr(settings, "UPLOAD_SESSION_SNAPSHOT_LIMIT", 200)) + if snap is not None: + baseline_ok = True + before_ids = {str(s.get("id", "")) for s in snap} + + # 标记"POST 已开始"并落库:进程被杀后,续传(resume_pending) + # 凭 status=uploading + updated_at 判断服务器上是否已有本次会话 + task.status = "uploading" + task.updated_at = datetime.now().isoformat() + self._save_to_db(task) + + post_started = True # 之后的异常才需要"查服务器"判定 result = client.upload_session_zip( zip_path, task.session_name, progress_cb=_progress, name=task.session_name, project_id=project_id, @@ -279,6 +582,14 @@ class UploadManager(QObject): ) if not result.get("ok"): + hit = self._verify_after_failure(client, task, before_ids, + baseline_ok) + if hit: + self._mark_upload_verified(task, hit, "POST 返回失败但服务器已入库") + return + # 已复查过 → 不让 except 分支再查一遍(省一次 GET, + # 也避免两次判定之间新出现的会话造成误判) + post_started = False raise RuntimeError(result.get("error", "上传失败")) # ── 完成 ── @@ -295,9 +606,20 @@ class UploadManager(QObject): except Exception as e: task.error_message = str(e)[:500] - task.retry_count += 1 task.updated_at = datetime.now().isoformat() + # POST 已发出却抛异常(读超时/连接断开/进程被杀)——服务器可能 + # 其实已经入库,只是响应没回来。先复查会话列表:是本次的会话 + # 就按成功收尾,绝不重传(重传会在服务器上多出一条重复会话)。 + if post_started: + hit = self._verify_after_failure(client, task, before_ids, + baseline_ok) + if hit: + self._mark_upload_verified(task, hit, "上传中断但服务器已入库") + return + + task.retry_count += 1 + if task.retry_count < self._retry_max: task.status = "pending" self._save_to_db(task) @@ -328,10 +650,49 @@ class UploadManager(QObject): with QMutexLocker(self._mutex): self._active.pop(task_id, None) self._active_tasks.pop(task_id, None) + self._started_at.pop(task_id, None) if self.all_done(): self.all_completed.emit() + # ── 上传结果校验(查服务器)──────────────────────── + + def _mark_upload_verified(self, task: UploadTask, server_session: dict, + reason: str, emit: bool = True): + """服务器上已存在本次上传的会话 → 按成功收尾(不再重复上传)。 + + emit=False 供 resume_pending 用:启动续传时调用方还没拿到 task_id, + 提前发 task_completed 会让主窗口查不到该任务的 session_path(无法 + 标记录制行 / 按开关删本地件),故由调用方拿到返回值后自行收尾。 + """ + task.status = "completed" + task.progress = 1.0 + task.server_session_id = str((server_session or {}).get("id", "") or "") + task.error_message = "" + task.retry_count = 0 + task.updated_at = datetime.now().isoformat() + self._save_to_db(task) + if not emit: + return + self.task_progress.emit(task.id, 1.0) + self.task_status.emit(task.id, f"服务器上已存在本次会话,按成功处理({reason})") + self.task_completed.emit(task.id) + + def _verify_after_failure(self, client: APIClient, task: UploadTask, + before_ids: set, + baseline_ok: bool) -> Optional[dict]: + """POST 失败/异常后重查会话列表:出现新的同名会话 → 判定已入库。 + + 快照或复查失败时返回 None(区分不了新旧,宁可照常重试)。 + """ + if not baseline_ok: + return None + sessions = client.try_get_sessions( + limit=getattr(settings, "UPLOAD_SESSION_SNAPSHOT_LIMIT", 200)) + if sessions is None: + return None + return pick_new_session(before_ids, sessions, task.session_name) + # ── 项目消歧 ────────────────────────────────────── @staticmethod diff --git a/collector/docs/config.md b/collector/docs/config.md index 319319435d5fea707647aa83c1be831d0f8c7bb4..d596ae10327e50d75dd7727add8de1cdf79842a6 100644 --- a/collector/docs/config.md +++ b/collector/docs/config.md @@ -99,6 +99,10 @@ config/ 是应用全局配置、国际化与版本号所在的配置包。版本 | 上传 | `UPLOAD_ENABLED` / `UPLOAD_MAX_CONCURRENT` / `UPLOAD_RETRY_MAX` | bool / int / int | `True` / 1 / 3 | 串行=1(并发时预压缩临时文件会互相覆盖致视频损坏) | | 上传 | `UPLOAD_AUTO_SYNC` / `UPLOAD_DELETE_AFTER` | bool | 启动时从 `server_config.json` 读取(默认 `True` / `False`) | 录制后自动上传 / 上传后删本地 | | 上传 | `UPLOAD_PRECOMPRESS_VIDEO` / `UPLOAD_VIDEO_CRF` | bool / int | `True` / 30 | 上传前视频重编码低码率 / CRF 档(v1.0.9 起 HEVC 录制件自动跳过) | +| 上传 | `UPLOAD_SESSION_SNAPSHOT_LIMIT` | int | 200 | 上传前后拉取的会话列表条数("POST 是否已入库"的判据) | +| 上传 | `UPLOAD_RESUME_MAX_AGE_HOURS` / `UPLOAD_RESUME_SKEW_TOL_S` | float / float | 24 / 60.0 | 启动续传窗口(更早的未完成上传不再自动重传)/ 续传判定容忍的客户端-服务器时钟差(秒) | +| 上传 | `UPLOAD_TMP_SWEEP_AGE_HOURS` | float | 24 | 启动清理残留上传临时文件的年龄门槛(小时) | +| 上传 | `UPLOAD_INFLIGHT_REFRESH_MS` / `UPLOAD_LOG_THROTTLE_S` | int / float | 1500 / 10.0 | 上传对话框 ⏳ 状态刷新间隔(毫秒)/ 主窗口上传进度日志节流(秒) | | 录制编码 | `RECORD_VIDEO_ENCODER` | str | `"auto"` | 录制编码器:`"auto"` 自动探测(nvenc→x265→x264)/ `"nvenc"` / `"x265"` / `"x264"` 显式指定 | | 录制编码 | `RECORD_VIDEO_CRF` / `RECORD_VIDEO_X264_CRF` | int / int | 30 / 23 | HEVC 直出 CRF 档 / x264 回退 CRF 档(与 v1.0.8 现状一致) | | 录制编码 | `ENCODER_PROBE_ENABLED` / `ENCODER_PROBE_FRAME_COUNT` / `ENCODER_PROBE_MAX_STREAMS` / `ENCODER_PROBE_TIMEOUT_S` | bool / int / int / int | `True` / 45 / 4 / 15 | 录前编码器速度探针开关 / 每探针合成帧数 / 并行流上限 / 单进程超时秒 | diff --git a/collector/docs/core.md b/collector/docs/core.md index a5258a618a1ed52f0e6ed58c101999ed2d95b11f..e825e4cd11f6aaf8802ec810af4d14ed943291b6 100644 --- a/collector/docs/core.md +++ b/collector/docs/core.md @@ -498,16 +498,20 @@ settings.DATA_DIR/tasks.json`)。核心设计:进度按**分账模型**持 | `APIClient.upload_session_zip` | `(zip_path, session_name, progress_cb: Optional[Callable[[int, int], None]] = None, name: str = "", project_id: str = "") -> dict` | POST `/api/v1/session/upload` 上传 zip(`progress_cb` 收 `(uploaded_bytes, total_bytes)`);`name`/`project_id` 为服务器目标项目表单字段(同名项目前缀歧义时服务器返回 409,须用 `project_id` 消歧) | `{"ok": True, "session_id": …, "response": …}` 或 `{"ok": False, "error": …, "ambiguous_project": True}`(409 项目歧义时置 `ambiguous_project`;错误文本截断 300 字符) | | `APIClient.get_projects` | `(limit: int = 100) -> list[dict]` | GET `/api/v1/projects` 项目列表(UI 下拉框用) | 异常返回 `[]` | | `APIClient.get_sessions` | `(limit: int = 50) -> list[dict]` | GET `/api/v1/sessions` 查询列表 | `data["sessions"]`;异常返回 `[]` | -| `APIClient.get_session` | `(session_id: str) -> Optional[dict]` | GET `/api/v1/session/{id}` 详情 | 异常返回 `None` | +| `APIClient.try_get_sessions` | `(limit: int = 50) -> Optional[list[dict]]` | 同上的"可区分失败"版本 | **失败返回 `None`**(`[]` 才是"服务器上没有会话");上传前后的"是否已入库"判定必须用它 | +| `APIClient.get_session` | `(session_id: str) -> Optional[dict]` | GET `/api/v1/session/{id}` 详情 | 异常返回 `None`(注:服务器当前对该端点返回 405,实际不可用) | | `APIClient.delete_session` | `(session_id: str) -> bool` | DELETE `/api/v1/session/{id}` | 200 为 `True` | | `_ProgressReader` | 内部类(文件包装) | 上传读取时回调进度 | 用完 `close()` | +| `_PatientSendConnection` | urllib3 连接子类 | 发送阶段用读超时、建连阶段用连接超时(`connect()` 临时换回 `CONNECT_TIMEOUT`)、socket 加 TCP 保活 | 保活 60s+15s×4 ≈ 120s 内发现死连接;`socket_options` 经 `_PatientSendAdapter.init_poolmanager` 注入连接池(Windows 无 `TCP_KEEPIDLE` 时退化为仅 `SO_KEEPALIVE`) | +| `_UPLOAD_RETRY` | `urllib3.util.Retry` | `total=2, connect=2, read=0, status=0, allowed_methods={"POST"}` | 只重试建连阶段错误(请求体未写出,不会重复发送);发送/读阶段一律不自动重发,交由 `UploadManager` 的"查服务器"判定 | **关键数据**: | 名称 | 类型 | 默认值 | 说明 | | --- | --- | --- | --- | -| `CONNECT_TIMEOUT` | int | 10 | 连接超时(秒) | +| `CONNECT_TIMEOUT` | int | 10 | 连接超时(秒);建连失败最多重试 2 次(共 3 次尝试) | | `READ_TIMEOUT` | int | 1800 | 读超时(秒);大会话上传+服务器解包入库可能耗时数分钟,设 30 分钟 | +| `_KEEPALIVE_IDLE_S` / `_KEEPALIVE_INTVL_S` / `_KEEPALIVE_CNT` | int | 60 / 15 / 4 | TCP 保活参数(对端静默消失时约 120s 内报错,而非 Linux 默认 2 小时) | | `User-Agent` | str | `"DAQ-SDK/1.0"` | 自建 session 时写入请求头 | | API 端点 | — | `POST /api/v1/session/upload`、`GET /api/v1/sessions`、`GET /api/v1/session/{id}`、`DELETE /api/v1/session/{id}`、`GET /api/v1/video/{id}/{cam}/stream`、`GET /health` | 模块 docstring 中的真实 API 清单 | @@ -563,20 +567,38 @@ GET `/api/v1/device/tasks?device_name=…`。设计模式参照已移除的 `Syn 全程通过 Qt 信号通知 UI。失败自动重试(最多 `settings.UPLOAD_RETRY_MAX` 次),临时 zip 与预压缩产物用完即删。 +**"上传到底有没有入库"判定**(服务器无 `GET /session/{id}`,只能看列表): +POST 前拉一次会话列表快照,POST 失败/抛异常后复查——出现"新出现的同名会话" +即判成功、不重传;程序被杀导致的遗留任务在启动续传时按"POST 开始时刻 +(`upload_task.updated_at`,仅 `status='uploading'` 的行有)↔ 下一次 POST +开始时刻"的时间窗一对一认领(`pick_session_in_window`),避免同任务多条 +续传互相串位或重复上传。 + **类/函数**: | 名称 | 签名要点 | 作用 | 返回/副作用 | | --- | --- | --- | --- | -| `UploadTask` | `(session_path: str, server_url: str)` | 单个上传任务数据对象(`__slots__` 11 字段) | 状态初值 `pending`,进度 0.0 | -| `UploadTask.to_dict` / `UploadTask.from_row` | `() -> dict` / `(row: dict)`(staticmethod) | 序列化 / 从数据库行还原 | — | +| `session_name_base` | `(name: str) -> str`(模块级) | 去掉会话名尾部 episode 标记与 `.zip` → 任务基名 | `"X_000012"`/`"X_ep000012"`/`"X_episode-12"`/`"X.zip"` → `"X"` | +| `session_matches` | `(session_name, server_session: dict) -> bool`(模块级) | 服务器会话记录是否就是本次上传(同名或基名相等) | 服务器会给会话名加 `_%06d` 序号后缀,故用基名比较 | +| `pick_new_session` | `(before_ids: set, sessions: list, session_name: str) -> Optional[dict]`(模块级) | 快照差集:新出现的同名会话取最新一条 | 无则 `None` | +| `pick_session_in_window` | `(sessions, session_name, since_iso, until_iso="", tol_s=60.0) -> Optional[dict]`(模块级) | 时间窗判定:`created_at ∈ [since-tol, until]` 的最新同名会话 | `until_iso` 空 = 不限上界;时间戳不可解析 → `None` | +| `UploadTask` | `(session_path, server_url, episode_index=0, task_id="", resumed=False, created_at="")` | 单个上传任务数据对象(`__slots__` 13 字段,含 `resumed`) | 状态初值 `pending`,进度 0.0;`task_id`/`created_at` 供续传复用 DB 行 | +| `UploadTask.to_dict` / `UploadTask.from_row` | `() -> dict` / `(row: dict)`(staticmethod) | 序列化 / 从数据库行还原 | `from_row` 把 `resumed` 强转 `bool`;`resumed` 只在内存,不落库 | | `UploadManager` | `(server_url: str = "", session=None)` | 上传队列管理器;URL 缺省 `settings.SERVER_URL`,重试/并发取 `settings.UPLOAD_RETRY_MAX` / `settings.UPLOAD_MAX_CONCURRENT`;`session` 可复用已认证 `requests.Session` | 队列与活跃任务表由 `QMutex` 保护 | | `UploadManager.server_url` | property(可写) | 当前服务器地址 | — | -| `UploadManager.add_task` | `(session_path: str) -> str` | 入队一个任务(先写库再入队) | 返回 `task_id` | -| `UploadManager.add_tasks` | `(session_paths: list[str]) -> list[str]` | 批量入队 | 只收存在的目录 | +| `UploadManager.add_task` | `(session_path: str, episode_index: int = 0, task_id: str = "", resumed: bool = False, created_at: str = "") -> str` | 入队一个任务(先写库再入队) | 返回 `task_id`;`task_id`/`created_at` 非空时复用续传的 DB 行而非新建 | +| `UploadManager.add_tasks` | `(items: list) -> list[str]` | 批量入队 | 元素为 `(session_path, episode_index)` 或裸路径;只收存在的目录 | | `UploadManager.start` / `stop` | `()` | 启动 / 停止 worker 线程 | `stop` 等线程最多 10 秒 | | `UploadManager.pending_count` / `active_count` / `all_done` | `() -> int` / `() -> int` / `() -> bool` | 队列计数查询 | — | +| `UploadManager.inflight` | `() -> dict` | 队列中/执行中的任务快照,键 `(session_path, episode_index)` | 值 `{"task_id", "state"(`active`/`queued`), "progress", "elapsed"(秒,仅 active)}`;供上传对话框显示 ⏳ | +| `UploadManager.resume_pending` | `(max_age_hours: float = 24.0) -> tuple` | 启动续传:捞 `status IN ('pending','uploading')` 且 `created_at` 在窗口内的 DB 行重新入队 | 返回 `(resumed, verified, skipped)`;`resumed` = `(task_id, path, episode_index)`,`verified` = `(task_id, path, episode_index, server_session_id)`(判定服务器已入库、直接收尾),`skipped` = `{"path", "episode_index", "reason"}`;跳过原因 `server_changed`/`already_done`/`missing_files`/`already_queued`;同一任务多行只取最新一条,服务器快照只拉一次 | +| `UploadManager.sweep_orphan_temp_files` | `(base_dir: str, max_age_hours: float = 24.0) -> int`(staticmethod) | 清理上次异常退出遗留的临时 zip / 临时 parquet / 预压缩产物 | 返回删除数;只删 `_*_upload_*.zip`、`_episodes_*.parquet`、`_precomp_*` 且超龄的文件 | +| `UploadManager._local_episode_exists` | `(session_path: str, episode_index: int) -> bool`(staticmethod) | 续传前确认本地 episode 文件还在 | 经 `core.helpers.list_task_episodes` 判断 | +| `UploadManager._resume_sessions_snapshot` | `() -> Optional[list]` | 续传用的服务器会话列表快照(`settings.UPLOAD_SESSION_SNAPSHOT_LIMIT` 条) | 查询失败返回 `None` → 不做"已入库"判定,全部照常重传 | +| `UploadManager._mark_upload_verified` | `(task, server_session: dict, reason: str, emit: bool = True)` | 复查确认服务器已入库后按成功收尾 | 落库 `completed`/进度 1.0/`server_session_id`;`emit=True` 时发 `task_progress`+`task_status`+`task_completed`,`resume_pending` 传 `emit=False`(那时调用方还没登记 `task_id`,收尾由它自己补跑) | +| `UploadManager._verify_after_failure` | `(client, task, before_ids: set, baseline_ok: bool) -> Optional[dict]` | POST 失败/中断后复查服务器会话列表 | 无基线或查询失败返回 `None`(宁可重传);命中 `pick_new_session` | | 信号 | `task_added(str)` / `task_started(str)` / `task_status(str, str)` / `task_progress(str, float)` / `task_completed(str)` / `task_failed(str, str)` / `all_completed()` | 入队 / 开始 / 状态文字 / 进度 0~1 / 完成 / 失败 / 全部完成 | — | -| `UploadManager.get_upload_status` | `(session_path: str) -> str`(staticmethod) | 查某会话最近一条上传状态 | 无记录返回 `"pending"` | +| `UploadManager.get_upload_status` | `(session_path: str, episode_index: int = 0) -> str`(staticmethod) | 查某会话某 episode 最近一条上传状态 | 无记录返回 `"pending"` | | `UploadManager.list_tasks` | `(session_path: str = "") -> list[dict]`(staticmethod) | 查上传记录(可按会话过滤) | 按 `created_at` 倒序 | | 内部 | `_worker_loop` / `_upload_one` / `_zip_session` / `_find_working_ffmpeg` / `_precompress_videos` / `_save_to_db` | 并发调度、单任务全流程、打包、ffmpeg 探测、视频预压缩、写库 | 打包与预压缩的临时文件名均带 `task_id`,避免同进程并发任务互相覆盖 | @@ -585,7 +607,7 @@ GET `/api/v1/device/tasks?device_name=…`。设计模式参照已移除的 `Syn | 名称 | 类型 | 默认值 | 说明 | | --- | --- | --- | --- | | 并发 / 重试 / CRF | 常量 | 取自 `settings.UPLOAD_MAX_CONCURRENT`(默认 1)、`settings.UPLOAD_RETRY_MAX`(默认 3)、`settings.UPLOAD_VIDEO_CRF`(默认 30) | 串行=1 的原因:并发时预压缩临时文件互相覆盖致视频损坏 | -| 上传状态值 | str | `"pending"` / `"completed"` / `"failed"` | 重试期间回 `pending` 重新入队 | +| 上传状态值 | str | `"pending"` / `"uploading"` / `"completed"` / `"failed"` | 重试期间回 `pending` 重新入队;`uploading` 在 POST 发起前落库、其 `updated_at` 即"POST 开始时刻",续传时间窗判定依赖它(程序被杀时这一行会留在 `uploading`) | | `upload_task` 表字段 | — | `id, session_path, session_name, status, progress, retry_count, server_url, server_session_id, error_message, created_at, updated_at` | `INSERT OR REPLACE` 写 `core/database.py` 的 `db` | | 进度区间约定 | — | 预压缩 0~0.08,打包 0.08~0.12,上传 0.12~1.0 | `task_progress` 的 0~1 映射 | | 路径转换 | — | EgoData `chunk-0000` → LeRobot v3 `chunk_0000`;`videos/stereo_left/chunk-0000/stereo_left_aux.mp4` → `videos/stereo_left/chunk_0000/stereo_left_aux.mp4`;旧扁平结构 `videos/.mp4` → `videos//chunk_0000/file-0000.mp4` | 打包时改写 arcname | diff --git a/collector/docs/data.md b/collector/docs/data.md index c6973aa774096f047789365eade163eb3686454d..2697f67264617e40008977c212e29a7d670ad9e7 100644 --- a/collector/docs/data.md +++ b/collector/docs/data.md @@ -141,7 +141,8 @@ | `id` | TEXT PK | 上传任务 ID | | `session_path` | TEXT | 会话目录路径 | | `session_name` | TEXT | 会话名 | -| `status` | TEXT | `pending` / `uploading` / `completed` / `failed` / `skipped` | +| `episode_index` | INTEGER | 池化 episode 全局序号(v1.1.0 起) | +| `status` | TEXT | `pending` / `uploading` / `completed` / `failed` / `skipped`;`uploading` 在 POST 发起前写入,其 `updated_at` 即"POST 开始时刻"(启动续传的时间窗判定依赖它,程序被杀时该行会停在 `uploading`) | | `progress` | REAL | 进度(0.0–1.0) | | `retry_count` | INTEGER | 重试次数 | | `server_url` | TEXT | 目标服务器 | diff --git a/collector/tools/demos/gripper_force_matrix_demo/gripper_force_matrix_demo.py b/collector/tools/demos/gripper_force_matrix_demo/gripper_force_matrix_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..e35fcf9110f4732f81da32603ae0fff1d1b00f7d --- /dev/null +++ b/collector/tools/demos/gripper_force_matrix_demo/gripper_force_matrix_demo.py @@ -0,0 +1,754 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +夹爪力矩阵回放演示(单文件自包含,可直接发给客户) + +用法: + python gripper_force_matrix_demo.py [episode-NNN.parquet | 任务目录] + 不带参数则启动后点"打开"选择数据文件 + +读什么(主程序 v1.3.0+ 池化录制布局): + /data/chunk-NNN/episode-FFF.parquet 每行 = 一个录制帧 + /meta/info.json fps + + 触觉力矩阵列(稀疏变长:本帧没有新样本时为空列表,回放按"保持上一帧" + 处理,与实时画面行为一致): + observation.gripper_{left,right}_force_matrix 夹爪 1 + observation.gripper_2_gripper_{left,right}_force_matrix 夹爪 2 + int16 行差分编码(info.json features.encoding = row_diff_quantized): + 编码: 每行 250×3 个元素横向差分,mod 2^16 有符号补码可逆 + 反解: np.frombuffer(...).reshape(-1, 750) → cumsum(axis=1) + → reshape(250, 250, 3) → [fx, fy, fz] 三力平面 + 力总值列(float32 mN,SDK 同帧输出,可选): + observation.{prefix}gripper_{left,right}_force [fx, fy, fz] + +显示什么(与主程序触觉面板一致): + 每侧 = 热力图(上,可滚轮缩放/拖拽/双击复位)+ 力曲线(下) + 热力图 = core/gripper/tactile_process_worker.pressure_to_heatmap 原样移植: + fz 平面 → max(0) → 3×3 高斯(σ=0.8) → p10/p98 百分位归一化 + → JET → resize(320, 240);无接触帧全零 → JET 深蓝 + 力曲线 = ui/gripper_widgets.ForceCurveWidget 原样移植: + ±3000mN 对称量程、Fx/Fy/Fz 三线、300 点滚动窗口 + 只显示 fz 平面(主程序口径)。矩阵里的 fx/fy 平面在现有录制中逐点值 + 均 < 1,int16 取整后整平面为全零,切过去只会是空画面,故不提供切换。 + +注意(编码有损,回放热力图比实时画面粗): + encode_gripper_force_matrix 把 float32 矩阵 clip 到 ±32767 后直接 + astype(int16)(截断取整,无缩放因子)。SDK 逐点力值多为小数, + 落盘只保留整数部分 —— 空间分布与录制时一致,梯度细节是台阶状。 + 力总值列(float32)不受影响,曲线与录制时一致。 + +内存: 打开一份 episode 会把两侧矩阵列整体读进内存(≈ 帧数 × 375KB/侧, + 696 帧双触觉约 490MB);逐帧解码后只保留当帧矩阵。 + +依赖: numpy, pyarrow, opencv-python, PyQt5 +""" + +import argparse +import json +import os +import re +import sys + +import cv2 +import numpy as np +import pyarrow.parquet as pq + +from PyQt5.QtCore import QLibraryInfo, QPointF, QRectF, Qt, QTimer +from PyQt5.QtGui import QColor, QImage, QPainter, QPen, QPixmap +from PyQt5.QtWidgets import ( + QApplication, + QCheckBox, + QComboBox, + QFileDialog, + QHBoxLayout, + QLabel, + QMainWindow, + QPushButton, + QSizePolicy, + QSlider, + QVBoxLayout, + QWidget, +) + +# opencv-python 打包了自家 Qt 插件并在 import cv2 时写入 +# QT_QPA_PLATFORM_PLUGIN_PATH,会让 PyQt5 去加载 ABI 不匹配的 xcb 插件 +# 而崩溃 —— 在这里指回 PyQt5 自带的插件目录 +os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = QLibraryInfo.location( + QLibraryInfo.PluginsPath) + +MATRIX_DIM = 250 # 触觉力矩阵边长(settings.GRIPPER_FORCE_MATRIX_DIM) +ROW_LEN = MATRIX_DIM * 3 # 行差分以整行 250×3 为一组 +FZ_PLANE = 2 # 显示平面 = fz(主程序触觉面板口径) + +_FORCE_RANGE_MN = 3000.0 # 力曲线量程(主程序同值) +_CURVE_POINTS = 300 # 力曲线滚动窗口点数(主程序同值) +_CURVE_COLORS = { + "fx": QColor("#4fc3f7"), # 蓝 + "fy": QColor("#aed581"), # 绿 + "fz": QColor("#ff8a65"), # 橙 +} + +_MATRIX_COL_RE = re.compile( + r"^observation\.(?P.*?)gripper_(?Pleft|right)_force_matrix$") +_EPISODE_RE = re.compile(r"^episode-(\d+)\.parquet$") + + +# ══════════════════════════════════════════════════════════════════ +# 1. 力矩阵反解 + 热力图(与主程序逐行一致) +# ══════════════════════════════════════════════════════════════════ + +def decode_force_matrix(encoded) -> np.ndarray | None: + """int16 行差分 → (250,250,3) 三力平面。 + + 与 ui/main_window.encode_gripper_force_matrix 的反解口径一致: + reshape(-1,750) → cumsum(axis=1) → reshape(250,250,3)。 + cumsum 走 int32 再截断回 int16(mod 2^16 补码回绕),与编码端 + 的 int16 差分算术可逆。 + """ + arr = np.asarray(encoded, dtype=np.int16).ravel() + if arr.size == 0 or arr.size % ROW_LEN: + return None # 空样本或长度不符(损坏行) + rows = np.cumsum(arr.reshape(-1, ROW_LEN).astype(np.int32), axis=1) + return rows.astype(np.int16).reshape(MATRIX_DIM, MATRIX_DIM, 3) + + +def pressure_to_heatmap(pressure_matrix, device_type="bevel", scale=None): + """压力平面 → 320×240 RGB 热力图。 + + 移植自 core/gripper/tactile_process_worker.pressure_to_heatmap + (0902 定标 JET 显示,不再逐传感器/逐帧归一化),输出 RGB(主程序在 + _on_gripper_tactile 里做 RGB→BGR 再交给 BGR 约定控件,本 demo 直接按 + RGB 上屏,净效果一致)。 + """ + if pressure_matrix is None: + return None + if scale is None: + scale = 200.0 if device_type == "curved" else 50.0 + fz = np.asarray(pressure_matrix, dtype=np.float32) + scaled = np.clip(fz * float(scale), 0, 255).astype(np.uint8) + heatmap_bgr = cv2.applyColorMap(scaled, cv2.COLORMAP_JET) + heatmap_rgb = cv2.cvtColor(heatmap_bgr, cv2.COLOR_BGR2RGB) + return cv2.resize(heatmap_rgb, (320, 240)) + + +# ══════════════════════════════════════════════════════════════════ +# 2. 控件(力曲线 / 热力图 / 单侧面板) +# ══════════════════════════════════════════════════════════════════ + +class ForceCurveWidget(QWidget): + """Fx/Fy/Fz 力曲线(mN),±3000mN 对称量程。 + + 移植自 ui/gripper_widgets.ForceCurveWidget(配色/量程/窗口点数一致)。 + """ + + def __init__(self, parent=None): + super().__init__(parent) + self._series = {axis: [] for axis in ("fx", "fy", "fz")} + self.setMinimumHeight(140) + self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + + def push(self, force): + """force=(fx, fy, fz) mN;非法值跳过。""" + try: + fx, fy, fz = (float(v) for v in force[:3]) + except (TypeError, ValueError, IndexError): + return + if any(abs(v) > _FORCE_RANGE_MN * 4 for v in (fx, fy, fz)): + return + for axis, value in zip(("fx", "fy", "fz"), (fx, fy, fz)): + series = self._series[axis] + series.append(value) + if len(series) > _CURVE_POINTS: + del series[0] + self.update() + + def reset(self): + for series in self._series.values(): + series.clear() + self.update() + + def paintEvent(self, _event): + painter = QPainter(self) + painter.fillRect(self.rect(), QColor("#101418")) + w, h = self.width(), self.height() + mid_y = h / 2 + # 网格 + 零轴 + painter.setPen(QPen(QColor("#2a3038"), 1)) + for frac in (-0.5, 0.0, 0.5): + y = mid_y - frac * h * 0.92 + painter.drawLine(0, int(y), w, int(y)) + painter.setPen(QPen(QColor("#55606d"), 1)) + painter.drawLine(0, int(mid_y), w, int(mid_y)) + # 三线(最新点在右缘) + for axis, series in self._series.items(): + if not series: + continue + painter.setPen(QPen(_CURVE_COLORS[axis], 1.6)) + step = w / max(1, _CURVE_POINTS - 1) + for index in range(1, len(series)): + x0 = w - (len(series) - index) * step + x1 = w - (len(series) - index - 1) * step + y0 = mid_y - series[index - 1] / _FORCE_RANGE_MN * h * 0.46 + y1 = mid_y - series[index] / _FORCE_RANGE_MN * h * 0.46 + painter.drawLine(int(x0), int(y0), int(x1), int(y1)) + painter.end() + + +class HeatmapView(QWidget): + """热力图画布:适应窗口 + 滚轮缩放 + 拖拽平移 + 双击复位。 + + 交互对齐主程序 ZoomableVideoWidget(1.08×/级、0.25×~8×、双击还原)。 + """ + + ZOOM_MIN = 0.25 + ZOOM_MAX = 8.0 + ZOOM_STEP = 1.08 + + def __init__(self, parent=None): + super().__init__(parent) + self._pixmap = None + self._zoom = 1.0 + self._offset = QPointF(0.0, 0.0) + self._drag_from = None + self._status_text = "无触觉数据" + self.setMinimumSize(160, 120) + self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) + self.setStyleSheet("background:#000000;") + self.setCursor(Qt.OpenHandCursor) + + def set_heatmap(self, rgb: np.ndarray): + """传入 320×240 RGB 热力图(None 保持当前画面,与实时行为一致)。""" + if not isinstance(rgb, np.ndarray) or rgb.size == 0 or rgb.ndim != 3: + return + if not rgb.flags.c_contiguous: + rgb = np.ascontiguousarray(rgb) + h, w = rgb.shape[:2] + # Format_RGB888 直接包住 RGB 数据;fromImage 立即拷贝,rgb 可释放 + qimg = QImage(rgb.data, w, h, 3 * w, QImage.Format_RGB888) + self._pixmap = QPixmap.fromImage(qimg) + self.update() + + def reset_view(self): + self._zoom = 1.0 + self._offset = QPointF(0.0, 0.0) + self.update() + + def clear(self): + """清空画面(换夹爪/换 episode 时避免残留上一份数据)。""" + self._pixmap = None + self.reset_view() + + def paintEvent(self, _event): + painter = QPainter(self) + painter.fillRect(self.rect(), QColor("#000000")) + if self._pixmap is None: + painter.setPen(QColor("#666666")) + painter.drawText(self.rect(), Qt.AlignCenter, self._status_text) + painter.end() + return + pw, ph = self._pixmap.width(), self._pixmap.height() + fit = min(self.width() / pw, self.height() / ph) + scale = fit * self._zoom + w, h = pw * scale, ph * scale + cx = self.width() / 2 + self._offset.x() + cy = self.height() / 2 + self._offset.y() + target = QRectF(cx - w / 2, cy - h / 2, w, h) + painter.setRenderHint(QPainter.SmoothPixmapTransform, self._zoom > 1.5) + painter.drawPixmap(target, self._pixmap, QRectF(self._pixmap.rect())) + painter.end() + + def wheelEvent(self, event): + if self._pixmap is None: + return + steps = event.angleDelta().y() / 120.0 + if not steps: + return + factor = self.ZOOM_STEP ** steps + self._zoom = max(self.ZOOM_MIN, + min(self.ZOOM_MAX, self._zoom * factor)) + self.update() + + def mousePressEvent(self, event): + if event.button() == Qt.LeftButton and self._pixmap is not None: + self._drag_from = (event.pos(), QPointF(self._offset)) + self.setCursor(Qt.ClosedHandCursor) + + def mouseMoveEvent(self, event): + if self._drag_from is None: + return + start_pos, start_offset = self._drag_from + delta = event.pos() - start_pos + self._offset = QPointF(start_offset.x() + delta.x(), + start_offset.y() + delta.y()) + self.update() + + def mouseReleaseEvent(self, event): + if event.button() == Qt.LeftButton: + self._drag_from = None + self.setCursor(Qt.OpenHandCursor) + + def mouseDoubleClickEvent(self, _event): + self.reset_view() + + +class TactileSidePanel(QWidget): + """单侧触觉面板:热力图(上)+ 力曲线(下)。 + + 布局对齐主程序 ui/gripper_widgets.GripperSideWidget。 + """ + + def __init__(self, side: str, parent=None): + super().__init__(parent) + self.side = side + layout = QVBoxLayout(self) + layout.setContentsMargins(4, 4, 4, 4) + layout.setSpacing(4) + title = QLabel("触觉 {}".format("L" if side == "left" else "R"), self) + title.setAlignment(Qt.AlignCenter) + title.setStyleSheet("color:#9aa4b0; font-size:12px;") + layout.addWidget(title) + self.view = HeatmapView(self) + layout.addWidget(self.view, 3) + curve_box = QHBoxLayout() + curve_box.setSpacing(4) + caption = QLabel("力 (mN)", self) + caption.setStyleSheet("color:#7f8a96; font-size:11px;") + caption.setFixedWidth(52) + curve_box.addWidget(caption) + self.force_curve = ForceCurveWidget(self) + curve_box.addWidget(self.force_curve, 1) + layout.addLayout(curve_box, 1) + + def show_tactile(self, heatmap, force): + self.view.set_heatmap(heatmap) + if force is not None: + self.force_curve.push(force) + + def reset(self): + self.force_curve.reset() + self.view.clear() + + +# ══════════════════════════════════════════════════════════════════ +# 3. 数据层 +# ══════════════════════════════════════════════════════════════════ + +def _list_column_to_numpy(column): + """list 列 → (offsets int64[n+1], values int16[flat])。 + + 走 pyarrow 缓冲区转 numpy:整段矩阵是上亿个 int16,走 to_pylist + 会生成同等数量的 Python 对象(几 GB),必须绕开。 + """ + offsets, values, base = [], [], 0 + for chunk in column.chunks: + offs = np.asarray(chunk.offsets, dtype=np.int64) + vals = np.asarray(chunk.values, dtype=np.int16) + offsets.append(offs[:-1] + base) + values.append(vals) + base += int(vals.size) + if not offsets: + return np.zeros(1, np.int64), np.zeros(0, np.int16) + all_offsets = np.concatenate(offsets + [np.array([base], np.int64)]) + all_values = (np.concatenate(values) if values + else np.zeros(0, np.int16)) + return all_offsets, all_values + + +def _read_fps(parquet_path: str) -> float: + """从 /meta/info.json 读 fps;缺失回退 30。""" + task_dir = os.path.dirname(os.path.dirname(os.path.dirname(parquet_path))) + try: + with open(os.path.join(task_dir, "meta", "info.json"), + "r", encoding="utf-8") as fh: + return float(json.load(fh).get("fps") or 30.0) + except (OSError, ValueError, TypeError): + return 30.0 + + +class TactileStream: + """单侧触觉流:力矩阵稀疏列(保持上一帧)+ 力总值列。""" + + def __init__(self, table, prefix: str, side: str, n_frames: int): + self.prefix = prefix + self.side = side + name = f"observation.{prefix}gripper_{side}_force_matrix" + self.offsets, self.values = _list_column_to_numpy(table.column(name)) + lengths = np.diff(self.offsets) + # 稀疏列 → 每帧实际显示的样本行:本帧无新样本则沿用上一帧 + # (实时画面同样保持上一次 SDK 结果不动),首个样本之前 = -1 + self.hold = np.maximum.accumulate( + np.where(lengths > 0, np.arange(n_frames, dtype=np.int64), -1)) + force_name = f"observation.{prefix}gripper_{side}_force" + self.force = None + if force_name in table.schema.names: + self.force = np.asarray(table.column(force_name).to_pylist(), + dtype=np.float32) + self._cache_row = -1 + self._cache_matrix = None + + def matrix(self, idx: int): + """第 idx 帧显示的三力平面 (250,250,3) int16;无数据返回 None。""" + if not 0 <= idx < self.hold.size: + return None + row = int(self.hold[idx]) + if row < 0: + return None + if row == self._cache_row: + return self._cache_matrix + start, end = int(self.offsets[row]), int(self.offsets[row + 1]) + matrix = decode_force_matrix(self.values[start:end]) + self._cache_row, self._cache_matrix = row, matrix + return matrix + + def force_at(self, idx: int): + """第 idx 帧的 [fx, fy, fz] mN;力列缺失时回退三平面求和。""" + if self.force is not None and 0 <= idx < len(self.force): + return tuple(float(v) for v in self.force[idx][:3]) + matrix = self.matrix(idx) + if matrix is None: + return None + return tuple(float(v) for v in + matrix.astype(np.float32).sum(axis=(0, 1))) + + +class TactileEpisode: + """一份 episode parquet:发现全部夹爪/左右触觉流并提供逐帧取数。""" + + def __init__(self, parquet_path: str): + self.path = os.path.abspath(parquet_path) + # 只读触觉相关列:整段矩阵本就占内存,别再捎带手套/骨架等列 + schema = pq.read_schema(parquet_path) + matrix_names = [name for name in schema.names + if _MATRIX_COL_RE.match(name)] + wanted = list(matrix_names) + for name in matrix_names: + match = _MATRIX_COL_RE.match(name) + force_name = "observation.{}gripper_{}_force".format( + match.group("prefix"), match.group("side")) + if force_name in schema.names: + wanted.append(force_name) + if not wanted: # 无夹爪列:仍要读出帧数供界面显示 + wanted = [name for name in ("frame_index",) if name in schema.names] + self.table = pq.read_table(parquet_path, columns=wanted) + self.n_frames = self.table.num_rows + self.fps = _read_fps(parquet_path) + self.rigs = {} # prefix → {"left": TactileStream, ...} + for name in self.table.schema.names: + match = _MATRIX_COL_RE.match(name) + if not match: + continue + prefix = match.group("prefix") + side = match.group("side") + self.rigs.setdefault(prefix, {})[side] = TactileStream( + self.table, prefix, side, self.n_frames) + + def rig_label(self, prefix: str) -> str: + match = re.match(r"^gripper_(\d+)_$", prefix or "") + return f"夹爪 {match.group(1)}" if match else "夹爪 1" + + def default_prefix(self) -> str: + """默认选数据最多的那台(双夹爪录制里 rig1 可能只有零星样本)。""" + best, best_count = None, -1 + for prefix, sides in self.rigs.items(): + count = sum(int(np.count_nonzero(np.diff(s.offsets))) + for s in sides.values()) + if count > best_count: + best, best_count = prefix, count + return best or "" + + def matrix_bytes(self) -> int: + return sum(int(s.values.nbytes) for sides in self.rigs.values() + for s in sides.values()) + + +def _resolve_episodes(path: str): + """入参可以是 episode parquet、chunk 目录或任务目录 → 返回 episode 列表。""" + if os.path.isdir(path): + found = [] + for root, _dirs, files in os.walk(path): + for name in files: + if _EPISODE_RE.match(name): + found.append(os.path.join(root, name)) + return sorted(found) + target = os.path.abspath(path) + chunk_dir = os.path.dirname(target) + try: + siblings = sorted( + os.path.join(chunk_dir, name) for name in os.listdir(chunk_dir) + if _EPISODE_RE.match(name)) + except OSError: + siblings = [] + if target not in siblings: # 文件名非 episode-NNN 时也保证可加载 + siblings.insert(0, target) + return siblings + + +# ══════════════════════════════════════════════════════════════════ +# 4. 窗口 +# ══════════════════════════════════════════════════════════════════ + +class DemoWindow(QMainWindow): + + def __init__(self, path=None): + super().__init__() + self.setWindowTitle("夹爪力矩阵回放 · Force Matrix Viewer") + self.resize(1280, 760) + self.data = None + self.idx = 0 + self.playing = False + self._prefix = "" + + central = QWidget() + # 暗色底:面板未出图时空区域不露白色窗口背景(调色板填充, + # 不用 QSS —— 无选择器规则会级联到控制条按钮/滑条把字染暗) + palette = central.palette() + palette.setColor(central.backgroundRole(), QColor("#111111")) + central.setPalette(palette) + central.setAutoFillBackground(True) + self.setCentralWidget(central) + root = QVBoxLayout(central) + root.setContentsMargins(0, 0, 0, 0) + root.setSpacing(0) + + panels = QHBoxLayout() + panels.setContentsMargins(6, 6, 6, 6) + panels.setSpacing(6) + self.panels = {"left": TactileSidePanel("left"), "right": TactileSidePanel("right")} + for panel in self.panels.values(): + panels.addWidget(panel, 1) + root.addLayout(panels, 1) + + # 控制条:独立浅色容器(原生控件在深色面板底上依然清晰) + bar_widget = QWidget() + bar_palette = bar_widget.palette() + bar_palette.setColor(bar_widget.backgroundRole(), QColor("#d9d9d9")) + bar_widget.setPalette(bar_palette) + bar_widget.setAutoFillBackground(True) + bar = QHBoxLayout(bar_widget) + bar.setContentsMargins(6, 4, 6, 4) + + self.btn_open = QPushButton("打开 Parquet") + self.btn_play = QPushButton("播放") + self.btn_play.setEnabled(False) + self.btn_prev = QPushButton("|<") + self.btn_next = QPushButton(">|") + for btn in (self.btn_prev, self.btn_next): + btn.setEnabled(False) + self.slider = QSlider(Qt.Horizontal) + self.slider.setEnabled(False) + self.combo_episode = QComboBox() + self.combo_episode.setEnabled(False) + self.combo_rig = QComboBox() + self.combo_rig.setEnabled(False) + self.chk_loop = QCheckBox("循环") + self.chk_loop.setChecked(True) + self.lbl_frame = QLabel("- / -") + + bar.addWidget(self.btn_open) + bar.addWidget(self.combo_episode) + bar.addWidget(self.btn_play) + bar.addWidget(self.btn_prev) + bar.addWidget(self.slider, 1) + bar.addWidget(self.btn_next) + bar.addWidget(self.combo_rig) + bar.addWidget(self.chk_loop) + bar.addWidget(self.lbl_frame) + root.addWidget(bar_widget) + + self.btn_open.clicked.connect(self.open_file_dialog) + self.btn_play.clicked.connect(self.toggle_play) + self.btn_prev.clicked.connect(lambda: self.seek(self.idx - 1)) + self.btn_next.clicked.connect(lambda: self.seek(self.idx + 1)) + self.slider.sliderMoved.connect(self._on_slider_moved) + self.slider.sliderReleased.connect(self._on_slider_released) + self.combo_episode.activated.connect(self._on_episode_chosen) + self.combo_rig.activated.connect(self._on_rig_chosen) + + self.timer = QTimer(self) + self.timer.setTimerType(Qt.PreciseTimer) # 节奏计时器要精确节拍 + self.timer.setInterval(33) + self.timer.timeout.connect(lambda: self.seek(self.idx + 1, advance=True)) + + if path: + self.load(path) + + # ── 加载 ────────────────────────────────────────── + + def open_file_dialog(self): + path, _ = QFileDialog.getOpenFileName( + self, "选择 episode parquet 或任务目录", "", + "Parquet (*.parquet);;All files (*)") + if path: + self.load(path) + + def load(self, path): + episodes = _resolve_episodes(path) + if not episodes: + return + # 指定文件就加载该文件;目录则取第一份(同目录其余进 episode 下拉) + target = path if os.path.isfile(path) else episodes[0] + try: + data = TactileEpisode(target) + except Exception as exc: # 列缺失/文件损坏:界面不崩 + self.lbl_frame.setText(f"加载失败: {exc}") + return + self.timer.stop() + self.playing = False + self.btn_play.setText("播放") + self.data = data + self.idx = 0 + + self.combo_episode.blockSignals(True) + self.combo_episode.clear() + for episode in episodes: + self.combo_episode.addItem(os.path.basename(episode), episode) + self.combo_episode.setCurrentIndex(episodes.index(data.path) + if data.path in episodes else 0) + self.combo_episode.blockSignals(False) + self.combo_episode.setEnabled(len(episodes) > 1) + + self._prefix = data.default_prefix() + self.combo_rig.blockSignals(True) + self.combo_rig.clear() + for prefix in sorted(data.rigs): + self.combo_rig.addItem(data.rig_label(prefix), prefix) + self.combo_rig.setCurrentIndex( + list(sorted(data.rigs)).index(self._prefix)) + self.combo_rig.blockSignals(False) + self.combo_rig.setEnabled(len(data.rigs) > 1) + + sides = data.rigs.get(self._prefix, {}) + for side, panel in self.panels.items(): + panel.setVisible(side in sides) + panel.reset() + + self.slider.blockSignals(True) + self.slider.setRange(0, max(0, data.n_frames - 1)) + self.slider.setValue(0) + self.slider.blockSignals(False) + self.slider.setEnabled(data.n_frames > 1) + self.btn_play.setEnabled(data.n_frames > 1) + self.btn_prev.setEnabled(data.n_frames > 1) + self.btn_next.setEnabled(data.n_frames > 1) + self.timer.setInterval(max(1, int(round(1000.0 / data.fps)))) + self.setWindowTitle( + "夹爪力矩阵回放 · {} · {:.0f}fps · {} 帧".format( + os.path.basename(data.path), data.fps, data.n_frames)) + print("[力矩阵] {} 帧 {} 台夹爪,矩阵列常驻 {:.0f} MB".format( + data.n_frames, len(data.rigs), data.matrix_bytes() / 1e6)) + self.render_frame(0) + + def _on_episode_chosen(self, index): + if index >= 0: + self.load(self.combo_episode.itemData(index)) + + def _on_rig_chosen(self, index): + if self.data is None or index < 0: + return + self._prefix = self.combo_rig.itemData(index) + sides = self.data.rigs.get(self._prefix, {}) + for side, panel in self.panels.items(): + panel.setVisible(side in sides) + panel.reset() + self.render_frame(self.idx) + + # ── 播放控制 ────────────────────────────────────── + + def toggle_play(self): + if self.data is None: + return + self.playing = not self.playing + self.btn_play.setText("暂停" if self.playing else "播放") + if self.playing: + self.timer.start() + else: + self.timer.stop() + + def seek(self, index, advance=False): + """跳转到第 index 帧;advance=True 时到尾部按循环开关决定回卷/停。""" + if self.data is None: + return + last = self.data.n_frames - 1 + if index > last: + if not (advance and self.chk_loop.isChecked()): + if advance: + self.timer.stop() + self.playing = False + self.btn_play.setText("播放") + index = last + else: + index = 0 + if index < 0: + index = 0 + self.render_frame(index) + + def _on_slider_moved(self, value): + # 拖动中实时渲染(热力图解码 ~1ms + 渲染 ~2ms,跟得上) + self.render_frame(value) + + def _on_slider_released(self): + self.render_frame(self.slider.value()) + + def render_frame(self, index): + if self.data is None: + return + index = max(0, min(index, self.data.n_frames - 1)) + self.idx = index + for side, panel in self.panels.items(): + stream = self.data.rigs.get(self._prefix, {}).get(side) + if stream is None: + continue + matrix = stream.matrix(index) + if matrix is not None: + # 稀疏帧返回 None 时不动画面:与实时画面保持上一次结果一致 + panel.show_tactile( + pressure_to_heatmap(matrix[:, :, FZ_PLANE]), + stream.force_at(index)) + self.slider.blockSignals(True) + self.slider.setValue(index) + self.slider.blockSignals(False) + self.lbl_frame.setText("{} / {} t={:.2f}s".format( + index + 1, self.data.n_frames, index / self.data.fps)) + + def keyPressEvent(self, event): + key = event.key() + if key == Qt.Key_Space: + self.toggle_play() + elif key == Qt.Key_Left: + self.seek(self.idx - 1) + elif key == Qt.Key_Right: + self.seek(self.idx + 1) + elif key == Qt.Key_Home: + self.seek(0) + elif key == Qt.Key_End: + self.seek(self.data.n_frames - 1 if self.data else 0) + else: + super().keyPressEvent(event) + + def closeEvent(self, event): + self.timer.stop() + self.data = None + super().closeEvent(event) + + +# ══════════════════════════════════════════════════════════════════ +# 5. 入口 +# ══════════════════════════════════════════════════════════════════ + +def main(): + parser = argparse.ArgumentParser( + description="夹爪力矩阵回放演示(录制数据 → 触觉热力图 + 力曲线)") + parser.add_argument("path", nargs="?", + help="episode-NNN.parquet / chunk 目录 / 任务目录" + "(可选,用界面打开)") + args = parser.parse_args() + + app = QApplication(sys.argv) + window = DemoWindow(args.path) + window.show() + sys.exit(app.exec_()) + + +if __name__ == "__main__": + main() diff --git a/collector/tools/import_gripper_calibration.py b/collector/tools/import_gripper_calibration.py new file mode 100644 index 0000000000000000000000000000000000000000..dd451fd5b018c6970ebbfd792444e2f264140907 --- /dev/null +++ b/collector/tools/import_gripper_calibration.py @@ -0,0 +1,282 @@ +"""接入新夹爪:把上位机生成的 per-serial 标定搬进 core/gripper/native/。 + +collector 不生成夹爪标定,只按现场探到的产品序列号拼文件名去找: + + core/gripper/native/gripper_version1/fays_config/fays_vikit_.yaml + core/gripper/native/dist/fays_opencv48/s80m__stereo_inertial.yaml + +序列号没出现过的夹爪(没这两个文件)必须先在上位机跑 device_setup / +标定生成它们,再用本脚本搬过来并校验。序列号本身不用手填也能拿: +--detect 现场读一次(需先关闭主程序的夹爪,否则撞 SDK 初始化锁)。 + +用法: + venv/bin/python tools/import_gripper_calibration.py --list + venv/bin/python tools/import_gripper_calibration.py --detect + venv/bin/python tools/import_gripper_calibration.py 3500000262300099 + venv/bin/python tools/import_gripper_calibration.py 3500000262300099 \ + --source /path/to/online [--force] [--dry-run] + +--source 缺省为本仓库的 online/(上位机根目录)。也可以直接指向 +上位机产物目录、或同时含两个 yaml 的任意目录。同名目标已存在且内容 +不同时必须加 --force,旧文件先备份成 *.bak_<时间戳>。 + +注意:native/ 不入库(见 .gitignore),搬进来的标定只存在本机; +换机器/重装要重新搬一次。 +""" + +from __future__ import annotations + +import argparse +import hashlib +import os +import re +import shutil +import sys +import time + +_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +if _ROOT not in sys.path: + sys.path.insert(0, _ROOT) + +from core.gripper import paths # noqa: E402 + +_SERIAL_PATTERN = re.compile(r"^[A-Za-z0-9._:-]+$") +_DEFAULT_SOURCE = os.path.join(_ROOT, "online") + + +def _target_paths(serial): + """collector 实际读取的两个目标路径(与 paths.per_device_fays_yamls 同源)。""" + return ( + os.path.join(paths.FAYS_CONFIG_DIR, f"fays_vikit_{serial}.yaml"), + os.path.join( + paths.ORB_DEVICE_CONFIG_DIR, + f"s80m_{serial}_stereo_inertial.yaml", + ), + ) + + +def _source_paths(source_root, serial): + """在上位机根目录下按候选布局找源文件,返回 (sdk_yaml, orb_yaml) 或 None。""" + layouts = ( + ("gripper_version1/fays_config", "dist/fays_opencv48"), + ("fays_config", "fays_opencv48"), + (".", "."), + ) + for sdk_dir, orb_dir in layouts: + sdk_yaml = os.path.join( + source_root, sdk_dir, f"fays_vikit_{serial}.yaml") + orb_yaml = os.path.join( + source_root, orb_dir, f"s80m_{serial}_stereo_inertial.yaml") + if os.path.isfile(sdk_yaml) and os.path.isfile(orb_yaml): + return sdk_yaml, orb_yaml + return None + + +def _sha256(path): + digest = hashlib.sha256() + with open(path, "rb") as stream: + for chunk in iter(lambda: stream.read(1 << 20), b""): + digest.update(chunk) + return digest.hexdigest() + + +def _read_text(path): + with open(path, encoding="utf-8") as stream: + return stream.read() + + +def _validate_sdk_yaml(text, path): + """SDK 模板必须含两个端口字段的值——materialize_fays_device_config + 靠 `key: <值>` 渲染本次运行配置,字段缺值同样会在打开时炸。""" + for key in ("stereo_dev_port", "imu_dev_port"): + if re.search( + r"^\s*" + key + r"\s*:\s*[^\s#]", text, + re.MULTILINE) is None: + raise RuntimeError( + f"SDK YAML 缺少有效字段 {key}(需形如 {key}: /dev/videoN): {path}") + + +def _validate_orb_yaml(text, path): + """ORB 标定必须含 IMU.T_b_c1(ORB-SLAM3 的 body→cam1 外参)。""" + if "IMU.T_b_c1" not in text: + raise RuntimeError(f"ORB YAML 缺少 IMU.T_b_c1: {path}") + if not text.lstrip().startswith("%YAML"): + print(f" [警告] ORB YAML 缺少 %YAML 头,请确认是 OpenCV FileStorage: {path}") + + +def _copy_verified(source, destination, *, force, dry_run): + """原子拷贝 + sha256 复核;目标已存在时按内容决定跳过/备份/覆盖。""" + same = (os.path.isfile(destination) + and _sha256(source) == _sha256(destination)) + if same: + print(f" 已是最新,跳过 {destination}") + return "skipped" + if os.path.isfile(destination) and not force: + raise RuntimeError( + f"目标已存在且内容不同,加 --force 覆盖(会先备份): {destination}") + if dry_run: + print(f" [dry-run] 将写入 {destination}") + return "dry-run" + os.makedirs(os.path.dirname(destination), exist_ok=True) + if os.path.isfile(destination): + backup = "{}.bak_{}".format( + destination, time.strftime("%Y%m%dT%H%M%S")) + shutil.copy2(destination, backup) + print(f" 旧文件已备份 {backup}") + temporary = f"{destination}.tmp.{os.getpid()}" + try: + shutil.copy2(source, temporary) + os.replace(temporary, destination) + except OSError as exc: + try: + os.unlink(temporary) + except OSError: + pass + raise RuntimeError(f"写入失败 {destination}: {exc}") from exc + if _sha256(source) != _sha256(destination): + raise RuntimeError(f"拷贝后校验不一致: {destination}") + print(f" 已写入 {destination}") + return "copied" + + +def _covered_serials(): + """native/ 里两个目录各自覆盖的序列号。""" + sdk = { + name[len("fays_vikit_"):-len(".yaml")] + for name in os.listdir(paths.FAYS_CONFIG_DIR) + if name.startswith("fays_vikit_") and name.endswith(".yaml") + } if os.path.isdir(paths.FAYS_CONFIG_DIR) else set() + orb = { + name[len("s80m_"):-len("_stereo_inertial.yaml")] + for name in os.listdir(paths.ORB_DEVICE_CONFIG_DIR) + if name.startswith("s80m_") and name.endswith("_stereo_inertial.yaml") + } if os.path.isdir(paths.ORB_DEVICE_CONFIG_DIR) else set() + return sdk, orb + + +def _cmd_list(): + sdk, orb = _covered_serials() + print("native/ 已覆盖的序列号(SDK 模板 / ORB 标定):") + for serial in sorted(sdk | orb): + marks = ("有" if serial in sdk else "缺", + "有" if serial in orb else "缺") + flag = "" if serial in sdk and serial in orb else " ← 不完整,夹爪打不开" + print(f" {serial} SDK={marks[0]} ORB={marks[1]}{flag}") + if not sdk and not orb: + print(" (空)") + print(f"\nSDK 目录: {paths.FAYS_CONFIG_DIR}") + print(f"ORB 目录: {paths.ORB_DEVICE_CONFIG_DIR}") + return 0 + + +def _cmd_detect(): + """现场读一遍插着的 Fays 产品序列号(会调用官方 SDK 探针)。""" + from core.gripper.fays_runtime import ( + build_fays_probe_env, + discover_fays_device_groups, + ) + from core.gripper.fays_serial_probe import probe_product_serial + + groups = discover_fays_device_groups() + if not groups: + print("未发现完整的 Fays S80M(检查 USB3 是否插好)") + return 1 + sdk, orb = _covered_serials() + print(f"发现 {len(groups)} 台完整 S80M,逐台读取产品序列号" + "(主程序的夹爪请先关闭):") + failures = 0 + for group in groups: + ports = group["ports"] + try: + serial = probe_product_serial( + ports, environment=build_fays_probe_env()) + except Exception as exc: # 探针失败不影响其他设备 + failures += 1 + print(f" {group['physical_usb_path']} {ports} 探测失败: {exc}") + continue + covered = "已覆盖" if serial in sdk and serial in orb else "未覆盖 → 需标定" + print(f" {group['physical_usb_path']} {ports} serial={serial} {covered}") + return 1 if failures and failures == len(groups) else 0 + + +def _cmd_import(serial, source_root, *, force, dry_run): + if not _SERIAL_PATTERN.match(serial): + print(f"序列号格式不合法: {serial!r}") + return 2 + found = _source_paths(source_root, serial) + if found is None: + print(f"在 {source_root} 找不到序列号 {serial} 的标定文件。") + print("需要(两者之一存在即可):") + print(f" <源>/gripper_version1/fays_config/fays_vikit_{serial}.yaml") + print(f" <源>/dist/fays_opencv48/s80m_{serial}_stereo_inertial.yaml") + print("新夹爪请先在上位机运行 device_setup / 标定生成这两个文件;" + "或用 --source 指向产物目录。") + return 1 + + sdk_source, orb_source = found + sdk_target, orb_target = _target_paths(serial) + print(f"序列号 {serial}") + print(f" 源 SDK: {sdk_source}") + print(f" 源 ORB: {orb_source}") + _validate_sdk_yaml(_read_text(sdk_source), sdk_source) + _validate_orb_yaml(_read_text(orb_source), orb_source) + + results = [] + for source, target in ((sdk_source, sdk_target), (orb_source, orb_target)): + results.append(_copy_verified( + source, target, force=force, dry_run=dry_run)) + + if dry_run: + print("\n[dry-run] 未写入任何文件") + return 0 + + # 用 collector 自己的解析函数复核:这一步过了,插上夹爪就能开。 + resolved_sdk, resolved_orb = paths.per_device_fays_yamls(serial) + print("\ncollector 解析校验通过:") + print(f" {resolved_sdk}") + print(f" {resolved_orb}") + if all(result == "skipped" for result in results): + print("(两个文件本来就一致,无需改动)") + print("提醒: native/ 不入库,这些标定只存在本机;换机器要重新搬一次。") + return 0 + + +def main(argv=None): + parser = argparse.ArgumentParser( + description="把上位机生成的 Fays per-serial 标定搬进 core/gripper/native/", + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "serial", nargs="?", help="Fays 产品序列号(如 3500000262300099)") + parser.add_argument( + "--source", default=_DEFAULT_SOURCE, + help=f"上位机根目录(缺省 {_DEFAULT_SOURCE})") + parser.add_argument( + "--list", action="store_true", help="列出 native/ 已覆盖的序列号") + parser.add_argument( + "--detect", action="store_true", + help="现场探测插着的 Fays 序列号(需关闭主程序夹爪)") + parser.add_argument( + "--force", action="store_true", + help="目标已存在且内容不同时覆盖(旧文件备份成 *.bak_<时间戳>)") + parser.add_argument( + "--dry-run", action="store_true", help="只报告,不写文件") + args = parser.parse_args(argv) + + if args.list: + return _cmd_list() + if args.detect: + return _cmd_detect() + if not args.serial: + parser.error("需要序列号,或 --list / --detect") + try: + return _cmd_import( + args.serial, os.path.abspath(args.source), + force=args.force, dry_run=args.dry_run) + except RuntimeError as exc: + print(f"失败: {exc}") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/stereo_s80m/read_stereo_rgb.py b/collector/tools/stereo_s80m/read_stereo_rgb.py index d5c2f5c1f754c1e8b8c760787702607a7abae8f6..396ed42c9e5954b1b6b11862d130fb3ed6013f96 100644 --- a/collector/tools/stereo_s80m/read_stereo_rgb.py +++ b/collector/tools/stereo_s80m/read_stereo_rgb.py @@ -49,6 +49,19 @@ if "--depth-sdk-dir" in sys.argv: DEPTH_SDK_DIR = os.path.abspath(sys.argv[_dd_idx + 1]) DEPTH_MODE = DEPTH_SDK_DIR is not None +# --device-serial / --device-path :多台 S80 相机同时接入时 +# 指定要打开的那台(按 USB 序列号 / USB 设备拓扑路径匹配)。两参数可 +# 同给(路径为准,序列号仅校验日志);都不给 = 打开枚举到的第一台 +# (旧行为)。主程序按设备面板枚举出的序列号传入,保证每台相机只读 +# 自己的双目对,不再把多台读成同一台。 +TARGET_SERIAL = None +TARGET_USB_PATH = None +for _i, _a in enumerate(sys.argv): + if _a == "--device-serial" and _i + 1 < len(sys.argv): + TARGET_SERIAL = sys.argv[_i + 1] + elif _a == "--device-path" and _i + 1 < len(sys.argv): + TARGET_USB_PATH = sys.argv[_i + 1] + # --cb-bridge:回调取帧(官方 GUI 同款消费方案,主程序默认开)。 # 轮询 GetStereoFrames 与深度引擎绑定叠加会在交付帧内留下水平错位带 #(8/31 主程序录制回归:25fps 档降缝率但不根治);官方 GUI 用 @@ -119,12 +132,17 @@ else: # 接口 1.2 = IMU / 中置 RGB(取第一个节点) # rgb_dev_port 一律置 NULL 禁用(主程序不用中置 RGB,且 RGB 初始化 # 失败有崩溃史——3.9.1 会段错误) -# 解析失败 → 保持原 yaml 不动(旧行为)。 +# 多台 S80 相机接入时按 USB 设备拓扑路径分组(device 符号链接的父级 +# 1-3.4.1 即 USB 设备节点,serial 文件在其下),--device-serial / +# --device-path 指定目标相机;目标不存在 → 退出码 2 显式报错(绝不 +# 静默打开另一台——那是「多台读成同一台」的根源)。 +# 解析失败(非目标指定)→ 保持原 yaml 不动(旧行为)。 _PORTS_TMP = None try: import re as _re import tempfile as _tempfile - _ports_nodes = {} + _cameras = {} # usb_path → {"serial", "ports": {iface: [node…]}} + _order = [] for _name in sorted(os.listdir("/sys/class/video4linux")): _vp = os.path.join("/sys/class/video4linux", _name) try: @@ -140,9 +158,53 @@ try: _m = _re.match(r".+:(\d+\.\d+)$", _iface) if not _m: continue - _ports_nodes.setdefault(_m.group(1), []).append(f"/dev/{_name}") - _stereo_port = next(iter(_ports_nodes.get("1.0", [])), None) - _imu_port = next(iter(_ports_nodes.get("1.2", [])), None) + _usb = _iface.rsplit(":", 1)[0] + if _usb not in _cameras: + _serial = "" + try: + with open(os.path.join("/sys/bus/usb/devices", _usb, "serial"), + encoding="utf-8") as _sf: + _serial = _sf.read().strip() + except OSError: + pass + _cameras[_usb] = {"serial": _serial, "ports": {}} + _order.append(_usb) + _cameras[_usb]["ports"].setdefault(_m.group(1), []).append(f"/dev/{_name}") + + # 目标相机选择:路径精确优先(USB 拓扑路径每台唯一);仅给序列号时 + # 按序列号匹配(0 台或 >1 台命中都报错退出) + _target = None + if TARGET_USB_PATH: + if TARGET_USB_PATH in _cameras: + _target = TARGET_USB_PATH + if TARGET_SERIAL and _cameras[_target]["serial"].lower() \ + != TARGET_SERIAL.lower(): + print(f"[Ports] 警告: 路径 {TARGET_USB_PATH} 的序列号 " + f"{_cameras[_target]['serial']} 与 --device-serial " + f"{TARGET_SERIAL} 不符", file=sys.stderr) + else: + print(f"[Ports] 未找到 USB 设备 {TARGET_USB_PATH} 的 S80 相机;" + f"可用: {[(p, _cameras[p]['serial']) for p in _order]}", + file=sys.stderr) + sys.exit(2) + elif TARGET_SERIAL: + _hits = [p for p in _order + if _cameras[p]["serial"].lower() == TARGET_SERIAL.lower()] + if len(_hits) == 1: + _target = _hits[0] + else: + print(f"[Ports] 序列号 {TARGET_SERIAL} 命中 {len(_hits)} 台" + f"(需 1 台);可用: " + f"{[(p, _cameras[p]['serial']) for p in _order]}", + file=sys.stderr) + sys.exit(2) + elif _order: + _target = _order[0] + + _stereo_port = _imu_port = None + if _target: + _stereo_port = next(iter(_cameras[_target]["ports"].get("1.0", [])), None) + _imu_port = next(iter(_cameras[_target]["ports"].get("1.2", [])), None) if _stereo_port: _tf = _tempfile.NamedTemporaryFile( mode="w", suffix="_s80m_ports.yaml", delete=False) @@ -158,9 +220,14 @@ try: _tf.close() _PORTS_TMP = _tf.name CONFIG_PATH = _PORTS_TMP - print(f"[Ports] 自动解析: stereo={_stereo_port} " + print(f"[Ports] 相机 {_cameras[_target]['serial'] or _target} " + f"(usb={_target}): stereo={_stereo_port} " f"imu={_imu_port or '?'} rgb=NULL", file=sys.stderr) except Exception as _e: + if TARGET_SERIAL or TARGET_USB_PATH: + # 指定了目标相机就不能静默回退到默认 yaml(会打开错相机) + print(f"[Ports] 目标相机解析失败: {_e}", file=sys.stderr) + sys.exit(2) print(f"[Ports] 解析失败,沿用 yaml 端口: {_e}", file=sys.stderr) # 预加载 OpenCV:3.9.0 的 libfays_vikit.so 依赖 cv::fastFree / cv::cvtColor diff --git a/collector/tools/tests/probe_gripper_rates.py b/collector/tools/tests/probe_gripper_rates.py new file mode 100644 index 0000000000000000000000000000000000000000..1af74f4a0b98561785d6421f6a059d16173f52e0 --- /dev/null +++ b/collector/tools/tests/probe_gripper_rates.py @@ -0,0 +1,149 @@ +"""P3/P5 帧率探针:SLAM 初始化完成后统计 30s 内各流实际速率。 + +用法: + QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/probe_gripper_rates.py [esp_serial1] [esp_serial2] + +单 rig:只给第一个序列号(缺省 CC:BA:97:25:B4:44,与 GUI 同口径)。 +双 rig:给两个序列号,两套同时打开——rig1 旧核表(触觉 0/2 + SLAM +4-9,物理核 0,2,4-9),rig2 独立物理核分区(触觉 1/3 + SLAM +10/11/13/15/22/23,物理核 1,3,10,11;见 core.gripper.bridge 的 +_select_cpu_partition),两 rig 零物理核共享。分别统计帧率与 +双目取帧空桶率(30fps 桶、wall 时钟,口径复用主程序 +s80m_drop_watch)——空桶率>10% 即 SLAM 取帧未达 30fps。 + +输出: 每 rig 的 rgb/stereo_l/pose 计数与 Hz、imu 包计数(raw socket +包级窗口增量,IMU 原始数据不外送)、raw socket 累计 +stereo_packets/imu_packets(原生视角)、30s 窗口双目空桶率。 +""" + +import os +import sys +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname( + os.path.dirname(os.path.abspath(__file__))))) +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +from PyQt5.QtCore import QCoreApplication, QTimer + +from core.gripper.bridge import GripperBridge + + +def main(): + app = QCoreApplication(sys.argv) + serials = list(sys.argv[1:3]) or ["CC:BA:97:25:B4:44"] + rigs = [] + for idx, serial in enumerate(serials, start=1): + bridge = GripperBridge( + stereo_slot=("gripper_stereo_left" if idx == 1 + else f"gripper_{idx}_stereo_left"), + rig_index=idx) + rigs.append({ + "bridge": bridge, + "serial": serial, + "rgb": 0, "stereo_l": 0, "pose": 0, "imu": 0, + "imu_base": None, "pose_first": None, "error": None, + }) + stats = {"window_start": None} + deadline = time.monotonic() + 300.0 + window_s = 30.0 + + def wire(rig): + b, s = rig["bridge"], rig + + def on_rgb(frame, hw_ns, s=s): + s["rgb"] += 1 + + def on_stereo(slot, frame, hw_ns, s=s): + s["stereo_l"] += 1 + + def on_pose(pos, quat, traj=(), timestamp=None, s=s): + s["pose"] += 1 + if s["pose_first"] is None: + s["pose_first"] = time.monotonic() + raw = b._raw_client + if raw is not None: + s["imu_base"] = raw.imu_packets + _maybe_start_window() + + def on_error(msg, s=s): + s["error"] = msg + print(f"[ERROR rig {s['serial']}] {msg}", flush=True) + _maybe_start_window() + + def on_log(msg, s=s): + print(f"[LOG {s['serial'][-4:]}] {msg}", flush=True) + + b.rgb_frame_ready.connect(on_rgb) + b.stereo_frame_ready.connect(on_stereo) + b.pose_ready.connect(on_pose) + b.error.connect(on_error) + b.log.connect(on_log) + + def _maybe_start_window(): + # 所有未报错的 rig 都出首 pose 后统一开窗(对齐统计窗口); + # 全部 rig 报错则直接结束(单 rig 模式=旧行为) + if stats["window_start"] is not None: + return + pending = [r for r in rigs if r["error"] is None] + if not pending: + finish(2) + return + if all(r["pose_first"] is not None for r in pending): + stats["window_start"] = time.monotonic() + # 空桶口径与录制同款:窗口起点重置 + for r in rigs: + r["bridge"].reset_stereo_drop_watch() + print("[WINDOW] 全部 rig 首 pose 已到,开窗 30s", flush=True) + + def finish(code): + if stats["window_start"] is not None: + window = time.monotonic() - stats["window_start"] + for r in rigs: + b = r["bridge"] + raw = b._raw_client + if raw is not None and r["imu_base"] is not None: + r["imu"] = raw.imu_packets - r["imu_base"] + dropped, elapsed = b.stereo_drop_snapshot() + rate = (dropped / elapsed * 100) if elapsed else 0.0 + print(f"── rig {r['serial']} 窗口 {window:.1f}s " + f"rgb={r['rgb']}({r['rgb']/window:.1f}Hz) " + f"stereo_l={r['stereo_l']}" + f"({r['stereo_l']/window:.1f}Hz) " + f"pose={r['pose']}({r['pose']/window:.1f}Hz) " + f"imu={r['imu']}({r['imu']/window:.1f}Hz) " + f"双目空桶={dropped}/{elapsed}({rate:.1f}%)", + flush=True) + if raw is not None: + print(f" raw socket: stereo_packets=" + f"{raw.stereo_packets} " + f"imu_packets={raw.imu_packets}", flush=True) + else: + print("── 首 pose 未出现,无窗口统计", flush=True) + for r in rigs: + r["bridge"].close() + app.exit(code) + + for rig in rigs: + wire(rig) + + def watch(): + if time.monotonic() > deadline: + print("[TIMEOUT] 300s 内未见全部 pose", flush=True) + finish(3) + return + if stats["window_start"] is not None and ( + time.monotonic() - stats["window_start"] >= window_s): + finish(0) + return + QTimer.singleShot(500, watch) + + QTimer.singleShot(500, watch) + print(f"[START] serials={serials} window={window_s:.0f}s", flush=True) + for rig in rigs: + rig["bridge"].open(rig["serial"]) + return app.exec_() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/smoke_gripper_p2.py b/collector/tools/tests/smoke_gripper_p2.py new file mode 100644 index 0000000000000000000000000000000000000000..77d4adc8eec444073d09980be2ece35230fed77e --- /dev/null +++ b/collector/tools/tests/smoke_gripper_p2.py @@ -0,0 +1,86 @@ +"""P2 真机冒烟:GripperBridge 相机组 + DECXIN RGB + 触觉双进程全链。 + +用法: + QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/smoke_gripper_p2.py [esp_serial] + +成功路径: opened 后观察到 RGB 帧与左右触觉结果 → 0 退出。 +""" + +import os +import sys +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname( + os.path.dirname(os.path.abspath(__file__))))) +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +from PyQt5.QtCore import QCoreApplication, QTimer + +from core.gripper.bridge import GripperBridge + + +def main(): + app = QCoreApplication(sys.argv) + esp_serial = sys.argv[1] if len(sys.argv) > 1 else "CC:BA:97:25:B4:44" + bridge = GripperBridge() + stats = {"rgb": 0, "tactile_l": 0, "tactile_r": 0, + "last_force_l": None, "last_force_r": None} + deadline = time.monotonic() + 150.0 + + def on_rgb(frame, hw_ns): + stats["rgb"] += 1 + if stats["rgb"] <= 2 or stats["rgb"] % 300 == 0: + print(f"[RGB] #{stats['rgb']} {frame.shape} hw={hw_ns}", + flush=True) + + def on_tactile(side, heatmap, force, matrix): + key = "tactile_l" if side == "left" else "tactile_r" + stats[key] += 1 + stats[f"last_force_{side[0]}"] = force + if stats[key] <= 2 or stats[key] % 100 == 0: + print(f"[TACTILE] {side} #{stats[key]} force={tuple(force)}" + f" heatmap={heatmap.shape} matrix=" + f"{'None' if matrix is None else matrix.shape}", + flush=True) + + def on_opened(): + print("[OPENED] 相机 + 触觉链路就绪", flush=True) + + def on_error(msg): + print(f"[ERROR] {msg}", flush=True) + finish(2) + + def finish(code): + bridge.close() + print(f"── 汇总: rgb={stats['rgb']} " + f"tactile_l={stats['tactile_l']} tactile_r={stats['tactile_r']} " + f"force_l={stats['last_force_l']} force_r={stats['last_force_r']}", + flush=True) + app.exit(code) + + bridge.rgb_frame_ready.connect(on_rgb) + bridge.tactile_ready.connect(on_tactile) + bridge.opened.connect(on_opened) + bridge.error.connect(on_error) + bridge.log.connect(lambda m: print(f"[LOG] {m}", flush=True)) + + def watch(): + if time.monotonic() > deadline: + print("[TIMEOUT] 150s 未完成验证", flush=True) + finish(3) + return + if (stats["rgb"] >= 3 and stats["tactile_l"] >= 3 + and stats["tactile_r"] >= 3): + print("[DONE] RGB + 左右触觉结果均已到达", flush=True) + finish(0) + return + QTimer.singleShot(500, watch) + + QTimer.singleShot(500, watch) + print(f"[START] esp_serial={esp_serial}", flush=True) + bridge.open(esp_serial) + return app.exec_() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/smoke_gripper_p3.py b/collector/tools/tests/smoke_gripper_p3.py new file mode 100644 index 0000000000000000000000000000000000000000..3e2f48831f6a3cd5271389e5e24e7ac2c7fdf53f --- /dev/null +++ b/collector/tools/tests/smoke_gripper_p3.py @@ -0,0 +1,113 @@ +"""P3 真机冒烟:GripperBridge 全链(相机组 + RGB + 触觉 + SLAM + 双目流)。 + +用法: + QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/smoke_gripper_p3.py [esp_serial] + +前提: 夹爪 USB3 头已插 USB3 口(SLAM IMU 依赖 SuperSpeed)。 +成功路径: opened 后观察到 RGB 帧、左右触觉结果、左右双目帧与 SLAM 位姿 +→ 0 退出。日志顺序应为: + device.serial=3500000262300098 → [FAYS-CALIB] orb_runtime_yaml= → READY +""" + +import os +import sys +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname( + os.path.dirname(os.path.abspath(__file__))))) +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +from PyQt5.QtCore import QCoreApplication, QTimer + +from core.gripper.bridge import GripperBridge + + +def main(): + app = QCoreApplication(sys.argv) + esp_serial = sys.argv[1] if len(sys.argv) > 1 else "CC:BA:97:25:B4:44" + bridge = GripperBridge() + stats = {"rgb": 0, "tactile_l": 0, "tactile_r": 0, + "stereo_l": 0, "pose": 0, + "last_force_l": None, "last_force_r": None, + "last_pos": None} + deadline = time.monotonic() + 600.0 + + def on_rgb(frame, hw_ns): + stats["rgb"] += 1 + if stats["rgb"] <= 2 or stats["rgb"] % 300 == 0: + print(f"[RGB] #{stats['rgb']} {frame.shape} hw={hw_ns}", + flush=True) + + def on_stereo(slot, frame, hw_ns): + stats["stereo_l"] += 1 + if stats["stereo_l"] <= 3: + print(f"[STEREO] {slot} #{stats['stereo_l']} {frame.shape} " + f"hw={hw_ns}", flush=True) + + def on_tactile(side, heatmap, force, matrix): + key = "tactile_l" if side == "left" else "tactile_r" + stats[key] += 1 + stats[f"last_force_{side[0]}"] = force + if stats[key] <= 2 or stats[key] % 100 == 0: + print(f"[TACTILE] {side} #{stats[key]} force={tuple(force)}" + f" heatmap={heatmap.shape} matrix=" + f"{'None' if matrix is None else matrix.shape}", + flush=True) + + def on_pose(pos, quat, traj=(), timestamp=None): + stats["pose"] += 1 + stats["last_pos"] = pos + if stats["pose"] <= 3 or stats["pose"] % 100 == 0: + print(f"[POSE] #{stats['pose']} pos={tuple(pos)} " + f"quat={tuple(quat)}", flush=True) + + def on_opened(): + print("[OPENED] 相机 + 触觉 + SLAM 链路就绪", flush=True) + print("[HINT] 请拿起夹爪缓慢晃动/平移 10-20 秒:ORB-SLAM 需要" + " 运动才能初始化出位姿,静止不会输出 pose", flush=True) + + def on_error(msg): + print(f"[ERROR] {msg}", flush=True) + finish(2) + + def finish(code): + bridge.close() + print(f"── 汇总: rgb={stats['rgb']} " + f"tactile_l={stats['tactile_l']} tactile_r={stats['tactile_r']} " + f"stereo_l={stats['stereo_l']} " + f"pose={stats['pose']} last_pos={stats['last_pos']} " + f"mode={bridge._stereo_mode}", + flush=True) + app.exit(code) + + bridge.rgb_frame_ready.connect(on_rgb) + bridge.stereo_frame_ready.connect(on_stereo) + bridge.tactile_ready.connect(on_tactile) + bridge.pose_ready.connect(on_pose) + bridge.opened.connect(on_opened) + bridge.error.connect(on_error) + bridge.log.connect(lambda m: print(f"[LOG] {m}", flush=True)) + + def watch(): + if time.monotonic() > deadline: + print("[TIMEOUT] 600s 未完成验证", flush=True) + finish(3) + return + if (stats["rgb"] >= 3 and stats["tactile_l"] >= 3 + and stats["tactile_r"] >= 3 + and stats["stereo_l"] >= 3 + and stats["pose"] >= 3): + print("[DONE] RGB + 左右触觉 + 左目 + SLAM 位姿均已到达", + flush=True) + finish(0) + return + QTimer.singleShot(500, watch) + + QTimer.singleShot(500, watch) + print(f"[START] esp_serial={esp_serial}", flush=True) + bridge.open(esp_serial) + return app.exec_() + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/test_device_detector.py b/collector/tools/tests/test_device_detector.py index 6f89cf2b870510526786c9420424b64a08a37b5f..f91f8a98cacd4a2a988d0816495e8c900606a3eb 100644 --- a/collector/tools/tests/test_device_detector.py +++ b/collector/tools/tests/test_device_detector.py @@ -6,7 +6,7 @@ 覆盖: - _parse_by_id_entry 各形态(纯函数) - _list_uvc_devices 排除 RealSense / FTDI(mock list_v4l_devices) - - _list_s80m_devices FTDI 单条(mock _is_sdk_device) + - _list_s80m_devices 多台按序列号区分(mock _ftdi_camera_groups) - detect_devices 子模块异常不崩(mock 抛异常) - DeviceScanner 信号投递(QCoreApplication 事件循环) - 真机段(D435 在位时): _is_realsense_node / _list_d435_devices serial 非空 @@ -100,26 +100,114 @@ def _main(): check(infos[0].video_index == 2 and infos[0].serial == "2024010100", f"webcam 索引/序号正确: idx={infos[0].video_index} serial={infos[0].serial}") - print("── 3. _list_s80m_devices FTDI 单条(mock _is_sdk_device) ──") + print("── 3. _list_s80m_devices 多台按序列号区分(mock _ftdi_camera_groups) ──") + fake_cams = [ + {"usb_path": "1-3.4.1", "serial": "000000000001", "stereo_index": 0}, + {"usb_path": "1-3.4.2", "serial": "000000000002", "stereo_index": 2}, + ] + with patch("core.device_detector._ftdi_camera_groups", return_value=fake_cams): + infos = _list_s80m_devices(16) + check(len(infos) == 2 + and [i.key for i in infos] == ["s80m:000000000001", + "s80m:000000000002"] + and all(i.kind == "s80m" for i in infos) + and [i.usb_path for i in infos] == ["1-3.4.1", "1-3.4.2"], + f"两台按序列号区分: {[(i.key, i.usb_path) for i in infos]}") + check(infos[0].video_index == 0 and infos[1].video_index == 2, + "video_index 取自各相机双目节点") + + # 同序列号两台(FTDI 出厂默认号)→ key 追加 USB 路径兜底唯一 + dup_cams = [ + {"usb_path": "1-3.4.1", "serial": "000000000001", "stereo_index": 0}, + {"usb_path": "1-3.4.2", "serial": "000000000001", "stereo_index": 2}, + ] + with patch("core.device_detector._ftdi_camera_groups", return_value=dup_cams): + infos = _list_s80m_devices(16) + keys = [i.key for i in infos] + check(len(infos) == 2 and len(set(keys)) == 2 + and any("@1-3.4.2" in k for k in keys), + f"同号兜底 key 唯一: {keys}") + + # 无序列号 → USB 路径兜底 + nosn_cams = [{"usb_path": "1-3.4.1", "serial": "", "stereo_index": 0}] + with patch("core.device_detector._ftdi_camera_groups", return_value=nosn_cams): + infos = _list_s80m_devices(16) + check(len(infos) == 1 and infos[0].key == "s80m:usb-1-3.4.1", + f"无序列号兜底: {[i.key for i in infos]}") + + # 老环境兜底:sysfs 扫不到 → 退回旧版 _is_sdk_device 单条 def fake_sdk(i): return i == 7 - with patch("core.device_detector._is_sdk_device", side_effect=fake_sdk): + with patch("core.device_detector._ftdi_camera_groups", return_value=[]), \ + patch("core.device_detector._is_sdk_device", side_effect=fake_sdk): infos = _list_s80m_devices(16) check(len(infos) == 1 and infos[0].key == "s80m:ftdi" and infos[0].video_index == 7, - f"FTDI 单条命中: {[(i.key, i.video_index) for i in infos]}") - with patch("core.device_detector._is_sdk_device", return_value=False): + f"老环境兜底单条: {[(i.key, i.video_index) for i in infos]}") + with patch("core.device_detector._ftdi_camera_groups", return_value=[]), \ + patch("core.device_detector._is_sdk_device", return_value=False): infos = _list_s80m_devices(16) check(infos == [], "无 FTDI 时返回空") print("── 4. detect_devices 子模块异常不崩 ──") - # v1.1.3 起 detect_devices 有第五段 USB 手套枚举,同样要炸掉 + # v1.1.3 起有第五段 USB 手套枚举;夹爪接入后有第六段 UMI 夹爪, + # 真机在位时同样要炸掉(夹爪枚举含 pyserial 真机扫描,必须 mock) with patch("core.device_detector._list_uvc_devices", side_effect=OSError("boom")), \ patch("core.device_detector._list_d435_devices", side_effect=OSError("boom")), \ patch("core.device_detector._list_s80m_devices", side_effect=OSError("boom")), \ patch("core.device_detector._list_ble_devices", side_effect=OSError("boom")), \ - patch("core.device_detector._list_usb_glove_devices", side_effect=OSError("boom")): - check(detect_devices() == [], "五段全炸 → 返回空列表不抛异常") + patch("core.device_detector._list_usb_glove_devices", side_effect=OSError("boom")), \ + patch("core.device_detector._list_gripper_devices", side_effect=OSError("boom")): + check(detect_devices() == [], "六段全炸 → 返回空列表不抛异常") + + print("── 4b. UMI 夹爪枚举 / 组件相机排除 ──") + # 组件相机按 VID/PID 排除(0c45:636f sightac / 1bcf:2d4f decxin / + # 0403:602e fays);VID/PID 缺失时按 by-id 字符串兜底 + check(det._is_gripper_component_camera( + {"vid": "0c45", "pid": "636f"}), "sightac VID/PID 排除") + check(det._is_gripper_component_camera( + {"vid": "1bcf", "pid": "2d4f"}), "decxin VID/PID 排除") + check(not det._is_gripper_component_camera( + {"vid": "32e4", "pid": "0416"}), "无关 VID/PID 保留") + check(det._is_gripper_component_camera( + {"by_id_path": "/dev/v4l/by-id/usb-Sightac_SN0001-video-index0", + "name": "Sightac"}), + "VID/PID 缺失时 by-id 兜底排除") + + # 夹爪枚举:mock 串口枚举 + 资源可用 → 一条 gripper 条目 + class _Port: + def __init__(self, vid, pid, sn, dev): + self.vid, self.pid = vid, pid + self.serial_number, self.device = sn, dev + fake_ports = [ + _Port(0x303A, 0x1001, "CC:BA:97:25:B4:44", "/dev/ttyACM0"), + _Port(0x0483, 0x5740, "glove-sn", "/dev/ttyACM1"), + ] + with patch("core.gripper.paths.gripper_resources_available", + return_value=True), \ + patch("serial.tools.list_ports.comports", + return_value=fake_ports): + infos = det._list_gripper_devices() + check(len(infos) == 1 and infos[0].key == "gripper:CC:BA:97:25:B4:44" + and infos[0].address == "/dev/ttyACM0" + and infos[0].group == "gripper", + f"夹爪枚举唯一命中: {[(i.key, i.address) for i in infos]}") + with patch("core.gripper.paths.gripper_resources_available", + return_value=False), \ + patch("serial.tools.list_ports.comports", + return_value=fake_ports): + infos = det._list_gripper_devices() + check(infos == [], "资源缺失时夹爪条目隐藏") + with patch("core.gripper.paths.gripper_resources_available", + return_value=True), \ + patch("serial.tools.list_ports.comports", + return_value=fake_ports), \ + patch("core.device_detector._list_s80m_devices", + return_value=[DeviceInfo(key="s80m:x", kind="s80m", + display_name="x")]): + devs = detect_devices() + check(not any(d.kind == "s80m" for d in devs), + "夹爪在场时 s80m 条目被抑制") print("── 5. DeviceScanner 信号投递 ──") app = QCoreApplication.instance() or QCoreApplication(sys.argv) diff --git a/collector/tools/tests/test_gripper_bridge.py b/collector/tools/tests/test_gripper_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..c2858eed2592604bc765fa4a1962e8cc00d37269 --- /dev/null +++ b/collector/tools/tests/test_gripper_bridge.py @@ -0,0 +1,544 @@ +"""GripperBridge P3 接线单元测试(无硬件,mock 租约/相机服务/触觉/SLAM)。 + +用法: + QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/test_gripper_bridge.py + +覆盖: + - open 成功链:lease.acquire → select → flash 缓存 → RGB claim/线程 → + 触觉 start_connected → wait_ready → SlamProcessController 启动 + + wait_sdk_ready → FaysRawStreamClient → opened;RGB/触觉/双目/位姿信号投递 + - 双目拆包:side_by_side(1280×400 左右拼合)与 paired_packets + (640×400 相邻两包配对,IMU 批随左目) + - open 失败链:select 抛错 → error 信号 + 无 opened + - wait_ready 超时 → error 信号(含两侧错误文案) + - SLAM wait_sdk_ready 超时 → error 含 USB3 提示 + - close 逆序回收:raw client → slam.stop → RGB 线程 → tactile.stop → + reservation → uvc.stop → lease.release + - P5:rig2 独立物理核分区 / rig1 毒核 6 移出任务集(探针实测 + 左 ORB 落 6 时空桶 23-29%,移出后 0.0%)/ 亲和范围不足回退 + rig1 表 / 双目 30fps 空桶看门狗(91 桶缺口告警一次、正常节奏 + 不误计、reset 放行下一段) +""" + +import os +import sys +import time +from types import SimpleNamespace +from unittest.mock import MagicMock, patch + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__))))) +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +import numpy as np +from PyQt5.QtCore import QCoreApplication + +from core.gripper.bridge import GripperBridge + +FAILS = [] + +# QCoreApplication 必须存活于整个测试进程:局部引用随 _run_open_flow 返回 +# 被回收会销毁 app,挂起的排队信号(RGB 帧)随之丢失 +APP = QCoreApplication.instance() or QCoreApplication([]) + + +def check(cond, msg): + if cond: + print(f" PASS: {msg}") + else: + FAILS.append(msg) + print(f" FAIL: {msg}") + + +def _pump_until(predicate, timeout=3.0): + """泵主线程事件循环直到谓词成立或超时。""" + app = APP + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + app.processEvents() + if predicate(): + return True + time.sleep(0.005) + return predicate() + + +class _FakeNode: + def __init__(self, role): + self.role = role + self.video_index = 1 if role == "left" else 2 + self.flash_params = {"device_type": "bevel", + "fx_params": [1] * 5, "fy_params": [1] * 5, + "fz_params": [1] * 21, "ft_params": [1] * 20, + "fw_params": [1] * 9, + "flash_state": "programmed", + "calibration_source": "hardware-live-flash"} + + +class _FakeReservedCamera: + def __init__(self, role): + self.node = _FakeNode(role) + self.transport = "libuvc-ipc" + self.flash_params = self.node.flash_params + self._camera = MagicMock() + self._released = False + + def claim(self): + frame = np.zeros((480, 640, 3), dtype=np.uint8) + if self.node.role == "decxin": + frame = np.zeros((960, 1280, 3), dtype=np.uint8) + self._camera.read.return_value = (True, frame) + return self._camera, frame, (480, 640, 30.0, "MJPG") + + def release(self): + self._released = True + + +class _FakeReservation: + def __init__(self): + self._cameras = {role: _FakeReservedCamera(role) + for role in ("left", "right", "decxin")} + self.released = False + + def camera(self, role): + return self._cameras[role] + + def release_unclaimed(self): + self.released = True + for cam in self._cameras.values(): + cam.release() + + +def _selected_dict(): + return { + "esp_serial": "ESP-SN", + "esp_tty": "/dev/ttyACM0", + "product_serial": "3500000262300098", + "physical_usb_path": "1-3.4.1", + "usb_speed_mbps": 5000.0, + "ipc_dir": "/dev/shm/ksq-gripper-test", + "orb_binary": "/fake/orb_binary", + "orb_yaml": "/fake/s80m_orb.yaml", + "runtime_config": "/fake/runtime.yaml", + "trajectory": "/fake/traj.txt", + "work_dir": "/fake/work", + } + + +def _stereo_payload(width, height, channels=3): + step = width * channels + return np.zeros((height, step), dtype=np.uint8).tobytes() + + +def _run_open_flow(fail_select=None, wait_ready=True, ready_errors=(), + slam_ready=True): + """跑一次 open 流程,返回 (bridge, fakes)。""" + app = APP + bridge = GripperBridge() + stats = {"rgb": 0, "stereo": [], "tactile": [], "pose": [], + "state": [], "opened": 0, "error": None} + fakes = {} + + reservation = _FakeReservation() + fakes["reservation"] = reservation + + fake_tactile = MagicMock() + fake_tactile.PROCESS_READY_TIMEOUT = 10.0 + fake_tactile.wait_ready.return_value = wait_ready + fake_tactile.snapshot.return_value = MagicMock( + left=MagicMock(error=ready_errors[0] if len(ready_errors) > 0 + else None), + right=MagicMock(error=ready_errors[1] if len(ready_errors) > 1 + else None), + ) + fakes["tactile"] = fake_tactile + fakes["uvc"] = MagicMock() + + fake_slam = MagicMock() + fake_slam.wait_sdk_ready.return_value = slam_ready + fakes["slam"] = fake_slam + fake_raw = MagicMock() + fakes["raw"] = fake_raw + # P4 串口链(无硬件):controller 握手成功,worker/serial 不触真串口 + fake_serial = MagicMock() + fake_serial.last_error = None + fake_worker = MagicMock() + fake_controller = MagicMock() + fake_controller.connect_sync.return_value = True + fakes["serial"] = fake_serial + fakes["worker"] = fake_worker + fakes["controller"] = fake_controller + + def fake_select(provider): + fakes["assignment"] = provider() + if fail_select is not None: + raise fail_select + return reservation + + uvc_instance = MagicMock() + uvc_instance.select.side_effect = fake_select + fakes["uvc_instance"] = uvc_instance + + discovery = MagicMock() + fakes["discovery"] = discovery + + bridge.rgb_frame_ready.connect( + lambda _f, _t: stats.__setitem__("rgb", stats["rgb"] + 1)) + bridge.stereo_frame_ready.connect( + lambda slot, _f, _t: stats["stereo"].append(slot)) + bridge.tactile_ready.connect( + lambda s, h, f, m: stats["tactile"].append((s, tuple(f), m))) + bridge.pose_ready.connect( + lambda p, q, t, ts: stats["pose"].append( + (tuple(p), tuple(q), tuple(t), ts))) + bridge.gripper_state_ready.connect( + lambda payload: stats["state"].append(payload)) + bridge.opened.connect(lambda: stats.__setitem__( + "opened", stats["opened"] + 1)) + bridge.error.connect(lambda m: stats.__setitem__("error", m)) + + selected = _selected_dict() + with patch("core.gripper.bridge.SingleFaysLease") as lease_cls, \ + patch("core.gripper.bridge.TactileDiscovery", + return_value=discovery) as disc_cls, \ + patch("core.gripper.bridge.TactileProcessManager", + return_value=fake_tactile) as tactile_cls, \ + patch("core.gripper.bridge.UvcCameraServiceManager", + return_value=uvc_instance) as uvc_cls, \ + patch("core.gripper.bridge.SlamProcessController", + return_value=fake_slam) as slam_cls, \ + patch("core.gripper.bridge.FaysRawStreamClient", + return_value=fake_raw) as raw_cls, \ + patch("core.gripper.bridge.GripperSerial", + return_value=fake_serial) as serial_cls, \ + patch("core.gripper.bridge.SerialCommandWorker", + return_value=fake_worker) as worker_cls, \ + patch("core.gripper.bridge.GripperConnectionController", + return_value=fake_controller) as controller_cls: + fake_lease = MagicMock() + fake_lease.acquire.return_value = selected + lease_cls.return_value = fake_lease + fakes["lease"] = fake_lease + fakes["slam_cls"] = slam_cls + fakes["raw_cls"] = raw_cls + fakes["controller_cls"] = controller_cls + bridge.open("ESP-SN") + _pump_until(lambda: stats["opened"] or stats["error"], timeout=10.0) + fakes["stats"] = stats + return bridge, fakes + + +def main(): + print("── 1. open 成功链 + RGB/触觉/双目/位姿信号 ──") + bridge, fakes = _run_open_flow() + stats = fakes["stats"] + selected = _selected_dict() + fakes["lease"].acquire.assert_called_once_with("ESP-SN") + check(fakes["assignment"]["esp32"]["serial"] == selected["esp_serial"], + "assignment 由 selected(lease.acquire)构建") + check(fakes["assignment"]["fays"]["product_serial"] + == selected["product_serial"], + "assignment.fays 携带 product_serial") + check(stats["opened"] == 1 and stats["error"] is None, + f"opened 且无 error: opened={stats['opened']} error={stats['error']}") + check(stats["rgb"] >= 1, f"RGB 首帧送达 (rgb={stats['rgb']})") + check(fakes["tactile"].start_connected.called, + "触觉 start_connected 已调用") + left_arg = fakes["tactile"].start_connected.call_args + check(left_arg is not None + and left_arg.kwargs.get("left") is fakes["reservation"].camera("left") + and left_arg.kwargs.get("right") is fakes["reservation"].camera("right"), + "start_connected 传 reservation 的 left/right 保留相机") + check(fakes["discovery"].cache_external_flash_params.call_count == 2, + "左右 Sightac Flash 参数各缓存一次") + check(fakes["tactile"].wait_ready.called, "wait_ready 已等待") + # SLAM 控制器构造参数来自 selected 全链 + slam_kwargs = fakes["slam_cls"].call_args.kwargs + check(slam_kwargs.get("executable") == selected["orb_binary"] + and slam_kwargs.get("settings") == selected["orb_yaml"] + and slam_kwargs.get("device_config") == selected["runtime_config"] + and slam_kwargs.get("trajectory") == selected["trajectory"] + and slam_kwargs.get("work_dir") == selected["work_dir"], + "SlamProcessController 构造参数取自 selected") + check(fakes["slam"].wait_sdk_ready.called, "wait_sdk_ready 已等待") + check(fakes["raw"].start.called, "FaysRawStreamClient 已启动") + + # 触觉结果投递(发布回调 → emitter 线程队列 → 信号) + result_count = len(stats["tactile"]) + heatmap = np.zeros((240, 320, 3), dtype=np.uint8) + matrix = np.zeros((250, 250, 3), dtype=np.float32) + bridge._on_tactile_result("left", heatmap, (12.5, -3.0, 88.0), matrix) + _pump_until(lambda: len(stats["tactile"]) == result_count + 1) + check(len(stats["tactile"]) == result_count + 1 + and stats["tactile"][-1] == ("left", (12.5, -3.0, 88.0), matrix), + "tactile_ready 信号携带 side/force/matrix") + + # 双目 side_by_side:单包 1280×400 只取左半投左目(右目/IMU 不外送) + stereo_base = len(stats["stereo"]) + bridge._on_stereo_packet( + _stereo_payload(1280, 400), 2000, 3000, 7, + 1280, 400, 3, 1280 * 3, 0) + _pump_until(lambda: len(stats["stereo"]) == stereo_base + 1) + got = stats["stereo"][stereo_base:] + check(bridge._stereo_mode == "side_by_side", + f"首包判定 side_by_side (mode={bridge._stereo_mode})") + check(got == ["gripper_stereo_left"], + "side_by_side 只投左目槽") + + # 双目 vertical_stacked:640×800 上下拼合(真机实测),一包即一对 + bridge_v, fakes_v = _run_open_flow() + stats_v = fakes_v["stats"] + bridge_v._on_stereo_packet( + _stereo_payload(640, 800), 2050, 3050, 7, + 640, 800, 3, 640 * 3, 0) + _pump_until(lambda: len(stats_v["stereo"]) == 1) + got_v = stats_v["stereo"] + check(bridge_v._stereo_mode == "vertical_stacked", + f"首包判定 vertical_stacked (mode={bridge_v._stereo_mode})") + check(got_v == ["gripper_stereo_left"], + "vertical_stacked 只投上半左目槽") + bridge_v.deleteLater() + + # 双目 paired_packets:640×400 相邻两包配对(先左后右),右目包丢弃 + bridge2, fakes2 = _run_open_flow() + stats2 = fakes2["stats"] + bridge2._on_stereo_packet( + _stereo_payload(640, 400), 2100, 3100, 8, + 640, 400, 3, 640 * 3, 0) + _pump_until(lambda: len(stats2["stereo"]) == 0 or + bridge2._stereo_mode is not None) + check(bridge2._stereo_mode == "paired_packets" + and len(stats2["stereo"]) == 0, + "paired 首包挂起不发射") + bridge2._on_stereo_packet( + _stereo_payload(640, 400), 2200, 3200, 9, + 640, 400, 3, 640 * 3, 0) + _pump_until(lambda: len(stats2["stereo"]) == 1) + got2 = stats2["stereo"] + check(got2 == ["gripper_stereo_left"], + "paired 两包配对只发左目、右目包丢弃") + bridge2.deleteLater() + + # SLAM 位姿投递(pos3 + quat4 + 轨迹元组 + timestamp) + pose_count = len(stats["pose"]) + pose = SimpleNamespace(position=(1.0, 2.0, 3.0), + rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.5) + bridge._on_slam_pose(pose) + _pump_until(lambda: len(stats["pose"]) == pose_count + 1) + check(stats["pose"][-1] == ((1.0, 2.0, 3.0), (0.0, 0.0, 0.0, 1.0), + ((1.0, 2.0, 3.0),), 0.5), + "pose_ready 信号携带 pos/quat/traj/timestamp") + # 第二个位姿追加进轨迹(同一元组缓存对象随新点重建) + pose2 = SimpleNamespace(position=(2.0, 3.0, 4.0), + rotation=(0.0, 0.0, 0.0, 1.0), timestamp=0.6) + bridge._on_slam_pose(pose2) + _pump_until(lambda: len(stats["pose"]) == pose_count + 2) + check(stats["pose"][-1][2] == ((1.0, 2.0, 3.0), (2.0, 3.0, 4.0)), + "轨迹随位姿滚动累积") + + # P4 串口链接线:构造注入 on_board_update/on_grip_check,握手用 esp_tty + controller_kwargs = fakes["controller_cls"].call_args.kwargs + check(callable(controller_kwargs.get("on_board_update")) + and callable(controller_kwargs.get("on_grip_check")), + "GripperConnectionController 注入板更新/力检查回调") + check(fakes["controller"].connect_sync.called + and fakes["controller"].connect_sync.call_args.args + == (selected["esp_tty"],), + f"connect_sync 使用 esp_tty: {selected['esp_tty']!r}") + + # P4 GripState:板字段 ST=1 → 力超阈值 → 锁存 → gripper_state 事件 + bridge._on_board_update(MagicMock( + board_fields={"ST": "1", "PCT": "50"}, updated="10:00:00")) + bridge._latest_force["left"] = (0.0, 0.0, 400.0) + bridge._on_grip_check() + _pump_until(lambda: len(stats["state"]) >= 1) + check(len(stats["state"]) >= 1 + and stats["state"][-1]["gripped"] is True + and abs(stats["state"][-1]["pct"] - 50.0) < 0.01 + and abs(stats["state"][-1]["fz"] - 400.0) < 0.01, + f"Fz 超阈值锁存: {stats['state'][-1] if stats['state'] else None}") + + # P4 力矩阵最新值 + 序号(泵线程轮询语义) + matrix = np.zeros((250, 250, 3), dtype=np.float32) + left_seq_before = bridge.matrix_seq("left") + bridge._on_tactile_result("right", heatmap, (0.0, 0.0, 0.0), matrix) + check(bridge.matrix_seq("right") == 1 + and bridge.latest_matrix("right") is matrix, + "矩阵最新值/序号递增(右侧)") + check(bridge.matrix_seq("left") == left_seq_before, + "未收到的侧别序号不动") + + # close 逆序回收:串口 → raw → slam → RGB 线程 → 触觉 → 租约 → 服务 + bridge.close() + check(fakes["controller"].close.called, + "close 先回收串口控制器") + check(fakes["raw"].stop.called + and fakes["slam"].stop.called + and fakes["reservation"].released + and fakes["uvc_instance"].stop.called + and fakes["tactile"].stop.called + and fakes["lease"].release.called, + "close 回收 raw/slam/reservation/uvc/tactile/lease") + bridge.deleteLater() + + print("── 2. select 失败 → error 信号 ──") + bridge2b, fakes2b = _run_open_flow(fail_select=RuntimeError("组不存在")) + check(fakes2b["stats"]["error"] == "组不存在" + and fakes2b["stats"]["opened"] == 0, + f"error 透传: {fakes2b['stats']['error']!r}") + check(not fakes2b["tactile"].start_connected.called, + "select 失败后不启动触觉") + bridge2b.deleteLater() + + print("── 3. wait_ready 超时 → error 含两侧文案 ──") + bridge3, fakes3 = _run_open_flow( + wait_ready=False, ready_errors=("左路初始化失败", None)) + err = fakes3["stats"]["error"] + check(err is not None and "左路初始化失败" in err, + f"错误包含侧别详情: {err!r}") + bridge3.deleteLater() + + print("── 4. SLAM wait_sdk_ready 超时 → error 含 USB3 提示 ──") + bridge5, fakes5 = _run_open_flow(slam_ready=False) + err5 = fakes5["stats"]["error"] + check(err5 is not None and "USB3" in err5, + f"SLAM 超时错误含 USB3 提示: {err5!r}") + check(not fakes5["raw"].start.called, + "SLAM 未就绪不启动 raw 流") + bridge5.deleteLater() + + print("── 5. 重复 open 拒绝 ──") + bridge4 = GripperBridge() + with patch("core.gripper.bridge.SingleFaysLease") as lease_cls, \ + patch("core.gripper.bridge.TactileDiscovery", + return_value=MagicMock()), \ + patch("core.gripper.bridge.TactileProcessManager", + return_value=MagicMock()), \ + patch("core.gripper.bridge.UvcCameraServiceManager", + return_value=MagicMock()), \ + patch("core.gripper.bridge.SlamProcessController", + return_value=MagicMock()), \ + patch("core.gripper.bridge.FaysRawStreamClient", + return_value=MagicMock()), \ + patch("core.gripper.bridge.GripperSerial", + return_value=MagicMock()), \ + patch("core.gripper.bridge.SerialCommandWorker", + return_value=MagicMock()), \ + patch("core.gripper.bridge.GripperConnectionController", + return_value=MagicMock()): + fake_lease = MagicMock() + fake_lease.acquire.return_value = _selected_dict() + lease_cls.return_value = fake_lease + bridge4.open("ESP-SN") + try: + bridge4.open("ESP-SN") + check(False, "重复 open 应抛 RuntimeError") + except RuntimeError: + check(True, "重复 open 抛 RuntimeError") + bridge4.close() + bridge4.deleteLater() + + print("── 6. 双夹爪 stereo 槽名参数化 ──") + bridge6 = GripperBridge(stereo_slot="gripper_2_stereo_left") + stats6 = {"stereo": []} + bridge6.stereo_frame_ready.connect( + lambda slot, _f, _t: stats6["stereo"].append(slot)) + bridge6._on_stereo_packet( + _stereo_payload(1280, 400), 2200, 3200, 9, + 1280, 400, 3, 1280 * 3, 0) + _pump_until(lambda: len(stats6["stereo"]) == 1) + check(stats6["stereo"] == ["gripper_2_stereo_left"], + f"rig2 bridge 发自己的槽名: {stats6['stereo']}") + # 未 open 过的 bridge close 早退;手动停 emitter 防解释器退出时核心转储 + bridge6._events.put(("_stop", ())) + bridge6._emitter.join(timeout=2.0) + bridge6.deleteLater() + + print("── 7. P5 双 rig CPU 分区 + 30fps 空桶看门狗 ──") + all24 = {cpu for cpu in range(24)} + only12 = {cpu for cpu in range(12)} + with patch("os.sched_getaffinity", return_value=all24): + bridge7 = GripperBridge(rig_index=2) + check(bridge7._tactile_cpu_map == {"left": 1, "right": 3} + and bridge7._slam_cpu_roles == { + "fays_input": (10,), "fays_prepare": (22,), + "fays_left_orb": (13,), "fays_right_orb": (15,), + "fays_track": (11,), "fays_background": (23,)}, + f"rig2 独立物理核分区: {bridge7._tactile_cpu_map} " + f"{bridge7._slam_cpu_roles}") + bridge7._events.put(("_stop", ())) + bridge7._emitter.join(timeout=2.0) + bridge7.deleteLater() + bridge7a = GripperBridge(rig_index=1) + check(bridge7a._slam_cpu_roles == { + "fays_input": (4,), "fays_prepare": (5,), + "fays_left_orb": (7,), "fays_right_orb": (8,), + "fays_track": (4,), "fays_background": (9,)} + and bridge7a._tactile_cpu_map == {"left": 0, "right": 2}, + "rig1 任务集 {4,5,7,8,9}:毒核 6 移出、track 与 input 共享 4") + bridge7a._events.put(("_stop", ())) + bridge7a._emitter.join(timeout=2.0) + bridge7a.deleteLater() + with patch("os.sched_getaffinity", return_value=only12): + # 构造器内选分区后经 _log 发提示(emitter 线程异步消费, + # 信号侧时序不可断言,直接查 _cpu_note 与回退表) + bridge7b = GripperBridge(rig_index=2) + check(bridge7b._tactile_cpu_map == {"left": 0, "right": 2} + and bridge7b._cpu_note is not None + and "退回 rig1" in bridge7b._cpu_note, + f"亲和范围不足回退 rig1 表并记提示: {bridge7b._cpu_note}") + bridge7b._events.put(("_stop", ())) + bridge7b._emitter.join(timeout=2.0) + bridge7b.deleteLater() + + # 空桶看门狗:30fps 桶长 1/30s。第 1 包后隔 91 桶再来 1 包 → + # elapsed=91、dropped=90、空桶率 99% ≥ 10% → 告警一次 + interval_ns = 33_333_333 + t0 = 1_000_000_000 + logs8 = [] + bridge8 = GripperBridge() + bridge8.log.connect(logs8.append) + bridge8._on_stereo_packet( + _stereo_payload(1280, 400), 2000, t0, 1, + 1280, 400, 3, 1280 * 3, 0) + bridge8._on_stereo_packet( + _stereo_payload(1280, 400), 2000, t0 + 91 * interval_ns, 2, + 1280, 400, 3, 1280 * 3, 0) + _pump_until(lambda: any("空桶率" in m for m in logs8)) + check(any("空桶率 99%" in m for m in logs8), + f"91 桶缺口触发 30fps 告警: {[m for m in logs8 if '告警' in m]}") + check(bridge8.stereo_drop_snapshot() == (90, 91), + f"快照口径与 s80m 一致: {bridge8.stereo_drop_snapshot()}") + # 正常 30fps 节奏 2 包(每包恰 1 桶)不新增空桶;reset 后重来一轮 + bridge8.reset_stereo_drop_watch() + check(bridge8.stereo_drop_snapshot() == (0, 0), "重置清空统计") + bridge8._on_stereo_packet( + _stereo_payload(1280, 400), 2000, t0, 3, + 1280, 400, 3, 1280 * 3, 0) + bridge8._on_stereo_packet( + _stereo_payload(1280, 400), 2000, t0 + interval_ns, 4, + 1280, 400, 3, 1280 * 3, 0) + check(bridge8.stereo_drop_snapshot() == (0, 1), + f"正常节奏不误计空桶: {bridge8.stereo_drop_snapshot()}") + # reset 后 alerted 放行:再来一段 91 桶缺口 → 第二次告警 + bridge8._on_stereo_packet( + _stereo_payload(1280, 400), 2000, t0 + 92 * interval_ns, 5, + 1280, 400, 3, 1280 * 3, 0) + _pump_until(lambda: sum(1 for m in logs8 if "空桶率" in m) >= 2) + check(sum(1 for m in logs8 if "空桶率" in m) == 2, + f"每段录制告警一次(不重复刷屏): " + f"{sum(1 for m in logs8 if '空桶率' in m)}") + bridge8._events.put(("_stop", ())) + bridge8._emitter.join(timeout=2.0) + bridge8.deleteLater() + + if FAILS: + print(f"\nFAILED: {len(FAILS)}") + for f in FAILS: + print(" -", f) + sys.exit(1) + print("\nPASS: GripperBridge P3 接线测试全部通过") + sys.exit(0) + + +if __name__ == "__main__": + main() diff --git a/collector/tools/tests/test_gripper_force_matrix_demo.py b/collector/tools/tests/test_gripper_force_matrix_demo.py new file mode 100644 index 0000000000000000000000000000000000000000..c5cbbabeeae8ef24acb6e4f9b6aeab62d710956c --- /dev/null +++ b/collector/tools/tests/test_gripper_force_matrix_demo.py @@ -0,0 +1,292 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""gripper_force_matrix_demo 离屏自检(无 pytest 依赖,直接运行): + + QT_QPA_PLATFORM=offscreen venv/bin/python \ + tools/tests/test_gripper_force_matrix_demo.py + +覆盖: + 1. 解码/热力图与主程序口径一致(对比 core.gripper.tactile_process_worker) + 2. 合成 episode:稀疏列保持上一帧、rig1/rig2 发现、默认选样本多的夹爪、 + 力列缺失时回退三平面求和 + 3. GUI 路径:加载 / 渲染 / 跳帧 / 播放节拍 / 切平面 / 切夹爪 / 目录加载 + 4. 真实录制(data/recordings 下任一含力矩阵列的 episode)→ 加载并渲染 +退出码 0 = 全部通过。 +""" + +from __future__ import annotations + +import glob +import importlib.util +import json +import os +import shutil +import sys +import tempfile + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +import numpy as np +import pyarrow as pa +import pyarrow.parquet as pq + +REPO_ROOT = os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__)))) +DEMO_PATH = os.path.join(REPO_ROOT, "tools", "demos", + "gripper_force_matrix_demo", + "gripper_force_matrix_demo.py") +sys.path.insert(0, REPO_ROOT) # 供热力图口径对比导入 core.gripper + +_FAILS: list[str] = [] + + +def check(name: str, cond: bool, detail: str = ""): + tag = "PASS" if cond else "FAIL" + print(f" [{tag}] {name}" + (f" — {detail}" if detail else "")) + if not cond: + _FAILS.append(name) + + +def load_demo_module(): + spec = importlib.util.spec_from_file_location("gripper_force_matrix_demo", + DEMO_PATH) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def encode_matrix(matrix: np.ndarray) -> list: + """与 ui/main_window.encode_gripper_force_matrix 同一口径。""" + flat = np.asarray(matrix, np.float32).reshape(matrix.shape[0], -1) + q = np.clip(flat, -32767.0, 32767.0).astype(np.int16) + diff = np.empty_like(q) + diff[:, 0] = q[:, 0] + diff[:, 1:] = q[:, 1:] - q[:, :-1] + return np.frombuffer(diff.tobytes(), dtype=np.int16).tolist() + + +def contact_matrix(value: float, center=(120, 120)) -> np.ndarray: + """250×250×3:中心一个方块接触区,fz=value。""" + matrix = np.zeros((250, 250, 3), np.float32) + y, x = center + matrix[y - 15:y + 15, x - 15:x + 15, 2] = value + matrix[y - 15:y + 15, x - 15:x + 15, 0] = value * 0.25 + return matrix + + +def make_synthetic_episode(root: str, n: int = 12) -> str: + """合成一份双夹爪 episode: + + - rig1 左侧:矩阵只在第 2 帧有新样本,第 3~5 帧为空(测保持上一帧); + 第 6 帧新样本。力列缺失(测回退三平面求和) + - rig1 右侧:每帧都有样本 + 力列(测力列优先) + - rig2 左侧:只有 1 个样本(测默认选样本多的夹爪 = rig1) + """ + task = os.path.join(root, "synthetic_gripper_task") + os.makedirs(os.path.join(task, "data", "chunk-000"), exist_ok=True) + os.makedirs(os.path.join(task, "meta"), exist_ok=True) + with open(os.path.join(task, "meta", "info.json"), "w", + encoding="utf-8") as fh: + json.dump({"fps": 30}, fh) + + empty = [] + left_rows = [empty, empty, encode_matrix(contact_matrix(5.0)), + empty, empty, empty, encode_matrix(contact_matrix(9.0))] + left_rows += [empty] * (n - len(left_rows)) + right_rows = [encode_matrix(contact_matrix(3.0 + i)) + for i in range(n)] + rig2_rows = [empty, empty, empty, encode_matrix(contact_matrix(2.0))] + rig2_rows += [empty] * (n - len(rig2_rows)) + right_force = [[float(i), -float(i) / 2, 100.0 + i] for i in range(n)] + + table = pa.table({ + "frame_index": pa.array(range(n), pa.int64()), + "observation.gripper_left_force_matrix": + pa.array(left_rows, pa.list_(pa.int16())), + "observation.gripper_right_force_matrix": + pa.array(right_rows, pa.list_(pa.int16())), + "observation.gripper_right_force": + pa.array(right_force, pa.list_(pa.float32(), 3)), + "observation.gripper_2_gripper_left_force_matrix": + pa.array(rig2_rows, pa.list_(pa.int16())), + }) + path = os.path.join(task, "data", "chunk-000", "episode-000.parquet") + pq.write_table(table, path) + return path + + +def find_real_episode(recordings_dir: str): + """data/recordings 下任一含 force_matrix 列的 episode。""" + for path in sorted(glob.glob(os.path.join( + recordings_dir, "**", "episode-*.parquet"), recursive=True)): + try: + names = pq.read_schema(path).names + except Exception: + continue + if any(name.endswith("force_matrix") for name in names): + return path + return None + + +def main() -> int: + mod = load_demo_module() + from PyQt5.QtWidgets import QApplication + app = QApplication.instance() or QApplication(sys.argv) + + print("[1] 解码 / 热力图与主程序口径一致") + rng = np.random.default_rng(0) + raw = np.zeros((250, 250, 3), np.float32) + raw[100:140, 110:150, 2] = rng.uniform(0, 40, (40, 40)) + raw[100:140, 110:150, 0] = rng.uniform(-20, 20, (40, 40)) + back = mod.decode_force_matrix(encode_matrix(raw)) + check("行差分解码往返", np.array_equal(back, raw.astype(np.int16)), + f"dtype={back.dtype} shape={back.shape}") + check("长度不符/空样本 → None", + mod.decode_force_matrix(np.zeros(7, np.int16)) is None + and mod.decode_force_matrix([]) is None) + try: + import core.gripper.tactile_process_worker as worker + same = True + for _ in range(3): + plane = rng.uniform(0, 30, (250, 250)).astype(np.float32) + if not np.array_equal(mod.pressure_to_heatmap(plane), + worker.pressure_to_heatmap(plane)): + same = False + break + check("热力图 = tactile_process_worker.pressure_to_heatmap", same) + except Exception as exc: # 主程序模块不可导入时不阻塞 + print(f" [SKIP] 热力图对比({exc})") + + tmp = tempfile.mkdtemp(prefix="force_matrix_demo_") + try: + print("[2] 合成 episode 数据层") + path = make_synthetic_episode(tmp) + episode = mod.TactileEpisode(path) + check("fps 从 meta/info.json 读取", episode.fps == 30.0, + f"fps={episode.fps}") + check("rig 发现", sorted(episode.rigs) == ["", "gripper_2_"], + str(sorted(episode.rigs))) + check("默认选样本最多的夹爪", episode.default_prefix() == "", + repr(episode.default_prefix())) + left = episode.rigs[""]["left"] + check("稀疏列保持上一帧", + left.matrix(2) is not None and left.matrix(4) is not None + and np.array_equal(left.matrix(2), left.matrix(4)), + "第 2 帧样本沿用到第 4 帧") + check("首样本之前无数据", + left.matrix(0) is None and left.matrix(1) is None) + check("新样本覆盖旧值", + not np.array_equal(left.matrix(2), left.matrix(6)), + "第 6 帧新样本") + check("力列缺失 → 三平面求和回退", + left.force is None + and left.force_at(2) == tuple( + float(v) for v in left.matrix(2).astype( + np.float32).sum(axis=(0, 1)))) + right = episode.rigs[""]["right"] + check("力列优先于矩阵求和", + right.force_at(5) == (5.0, -2.5, 105.0), + str(right.force_at(5))) + + print("[3] GUI 路径") + window = mod.DemoWindow() + window.show() # 离屏下 isVisible/isHidden 需先 show + window.load(path) + app.processEvents() + check("加载后帧数/滑条", window.data.n_frames == 12 + and window.slider.maximum() == 11) + check("rig 下拉两项", window.combo_rig.count() == 2, + window.combo_rig.currentText()) + check("面板可见(两侧都有列)", + all(panel.isVisible() for panel in window.panels.values())) + window.render_frame(2) + app.processEvents() + check("渲染出热力图(非占位)", + window.panels["left"].view._pixmap is not None) + held = window.panels["left"].view._pixmap + window.render_frame(0) # 第 0 帧无样本 → 保持第 2 帧画面 + app.processEvents() + check("无数据帧保持上一帧画面", + window.panels["left"].view._pixmap is held and held is not None) + window.render_frame(6) + window._on_rig_chosen(1) # 夹爪 2 + app.processEvents() + check("切夹爪:左侧有列、右侧面板隐藏", + window._prefix == "gripper_2_" + and window.panels["left"].isVisible() + and window.panels["right"].isHidden()) + window._on_rig_chosen(0) + start = window.idx + window.toggle_play() + check("播放启动", window.playing and window.timer.isActive()) + window.timer.timeout.emit() + window.timer.timeout.emit() + app.processEvents() + check("播放推进帧号", window.idx == start + 2, + f"{start} → {window.idx}") + window.toggle_play() + check("暂停停止计时器", + not window.playing and not window.timer.isActive()) + window.seek(11) + window.timer.timeout.emit() # 循环默认开 + app.processEvents() + check("循环回卷", window.idx == 0, f"idx={window.idx}") + window.chk_loop.setChecked(False) + window.seek(11) + window.timer.timeout.emit() + app.processEvents() + check("关循环在尾帧停住", + window.idx == 11 and not window.timer.isActive()) + window.close() + + print("[4] 目录加载") + window = mod.DemoWindow() + window.load(os.path.dirname(path)) + app.processEvents() + check("目录 → episode 下拉", window.combo_episode.count() == 1 + and window.data is not None) + window.close() + + print("[5] 真实录制") + repo = os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__)))) + real = find_real_episode(os.path.join(repo, "data", "recordings")) + if real: + episode = mod.TactileEpisode(real) + prefix = episode.default_prefix() + sides = episode.rigs[prefix] + peaks = {} + for side, stream in sides.items(): + forces = [stream.force_at(i) or (0, 0, 0) + for i in range(episode.n_frames)] + peaks[side] = int(np.argmax([f[2] for f in forces])) + print(f" 真实 episode: {os.path.basename(real)} " + f"n={episode.n_frames} rigs={sorted(episode.rigs)} " + f"默认={prefix!r} 峰值帧={peaks}") + window = mod.DemoWindow() + window.load(real) + app.processEvents() + for side, peak in peaks.items(): + window.render_frame(peak) + app.processEvents() + check(f"真实数据渲染 {side} 峰值帧", + window.panels[side].view._pixmap is not None) + check("真实数据内存占用在预期内", + episode.matrix_bytes() < 2_000_000_000, + f"{episode.matrix_bytes() / 1e6:.0f} MB") + window.close() + else: + print(" [SKIP] data/recordings 下无含力矩阵列的 episode") + finally: + shutil.rmtree(tmp, ignore_errors=True) + + print() + if _FAILS: + print(f"FAILED: {len(_FAILS)} 项 — {_FAILS}") + return 1 + print("ALL PASS") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/test_gripper_matrix_encoding.py b/collector/tools/tests/test_gripper_matrix_encoding.py new file mode 100644 index 0000000000000000000000000000000000000000..68f865898aa2f11c4b72201923086911958174a3 --- /dev/null +++ b/collector/tools/tests/test_gripper_matrix_encoding.py @@ -0,0 +1,50 @@ +"""P4 力矩阵编码器单测:int16 行差分 (250,250,3) 可逆 + 饱和截断。 + +编码函数在 ui/main_window.py(泵线程用),与 online/ 参考实现 +lerobot_v3.quantize_force_matrix 语义一致,仅扩展到三力平面。 +""" +import os +import sys + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") +sys.path.insert(0, os.path.dirname(os.path.dirname( + os.path.dirname(os.path.abspath(__file__))))) + +import numpy as np + +from ui.main_window import encode_gripper_force_matrix + + +def decode(encoded): + raw = np.asarray(encoded, dtype=np.int16).tobytes() + d = np.frombuffer(raw, dtype=np.int16) + q = np.cumsum(d.reshape(250, -1), axis=1).astype(np.int16) + return q.reshape(250, 250, 3) + + +def main(): + rng = np.random.default_rng(7) + m = (rng.random((250, 250, 3)) * 6000 - 3000).astype(np.float32) + enc = encode_gripper_force_matrix(m) + assert len(enc) == 250 * 250 * 3, len(enc) + ref = np.clip(m, -32767, 32767).astype(np.int16) + assert np.array_equal(decode(enc), ref), "round-trip mismatch" + print("PASS: (250,250,3) 行差分往返一致, len =", len(enc)) + + sat = encode_gripper_force_matrix( + np.array([[[40000.0, -40000.0, 1.0]]], dtype=np.float32)) + q = np.frombuffer(np.asarray(sat, dtype=np.int16).tobytes(), + dtype=np.int16) + q = np.cumsum(q.reshape(1, -1), axis=1).astype(np.int16) + assert q[0, 0] == 32767 and q[0, 1] == -32767, q + print("PASS: ±32767 mN 饱和截断, 首行 =", q[0]) + + z = encode_gripper_force_matrix(np.zeros((250, 250, 3), np.float32)) + assert not any(z), "zero matrix must stay zero" + print("PASS: 全零矩阵编码为全零") + + print("PASS: 力矩阵编码器单测全部通过") + + +if __name__ == "__main__": + main() diff --git a/collector/tools/tests/test_gripper_pose_axes.py b/collector/tools/tests/test_gripper_pose_axes.py new file mode 100644 index 0000000000000000000000000000000000000000..9081ba5ef4d79d6ec8b359f195b42a236a6052e5 --- /dev/null +++ b/collector/tools/tests/test_gripper_pose_axes.py @@ -0,0 +1,207 @@ +"""rotate_pose_z90 数学性质单测(离线,无硬件)。 + +验证 S80M 坐标约定(正对=+Y、Z=上、X=右)旋转的几何正确性。 +真机实测定案(2026-09-09 新 ORB 核心上线后):native 输出相对物理系 +为 R_z(−90°)(native X=正对、Y=左、Z=上,与桥接 .cc 注释约定一致; +旧核心时代为 R_x(+90°),已随换核失效); +修正 = 位置与姿态统一纯左乘 R_z(+90°)(纯世界重标,无体轴共轭): +- 位置 (x,y,z)→(−y,x,z);四元数 q' = q_z(+90°)⊗q +- 轴映射:native X(正对)→+Y,native −Y(右)→+X,native Z(上)→+Z +- 用户实测复现:物理 +Y → native +X → 显示 +Y;物理 +X → native −Y + → 显示 +X +- 静止首帧姿态 = R_z(90°)·correction(部署校正常数残留 = + R_x(−90°),非单位矩阵);原点后姿态相对化(process_controller + 捕获首帧显示姿态为基准,q0⁻¹⊗q)后首帧恒为单位矩阵——帧轴与 + 世界轴对齐,无起始跳变;转体后绘制帧轴 = 真实相对姿态轴 +- 随机位姿:R' = R_z(+90°)·R(正规旋转:正交、det=+1) +- 双应用 = R_z(+180°);轨迹相邻点距离不变(旋转是等距变换) +""" +import math +import os +import sys + +import numpy as np + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__))))) + +from core.gripper.slam.protocol import ( + PoseSample, quat_conjugate, quat_product, rotate_pose_z90, +) + + +def quat_to_matrix(qx, qy, qz, qw): + return np.array([ + [1 - 2 * (qy * qy + qz * qz), 2 * (qx * qy - qz * qw), + 2 * (qx * qz + qy * qw)], + [2 * (qx * qy + qz * qw), 1 - 2 * (qx * qx + qz * qz), + 2 * (qy * qz - qx * qw)], + [2 * (qx * qz - qy * qw), 2 * (qy * qz + qx * qw), + 1 - 2 * (qx * qx + qy * qy)], + ]) + + +def random_unit_quaternion(rng): + v = rng.standard_normal(4) + v /= np.linalg.norm(v) + return tuple(v) # (qx, qy, qz, qw) + + +def main(): + rng = np.random.default_rng(20260909) + Rzp90 = np.array([[0.0, -1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]) + # 部署桥接校正矩阵(source 值 R_y(90°)·R_z(−90°)),与新核心 + # 世界系合成 native 约定;静止首帧 native 姿态 = correction + correction = np.array([[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], + [0.0, -1.0, 0.0]]) + c = math.sqrt(0.5) + failures = [] + + # 1. 轴映射(native 系:X=正对 Y=左 Z=上 → 目标:X=右 Y=正对 Z=上) + axis_cases = [ + # (native 位移, 期望显示位移, 说明) + ((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), "正对(native X) → +Y"), + ((0.0, -1.0, 0.0), (1.0, 0.0, 0.0), "右(native −Y) → +X"), + ((0.0, 0.0, 1.0), (0.0, 0.0, 1.0), "上(native Z) → +Z"), + ((0.0, 1.0, 0.0), (-1.0, 0.0, 0.0), "左(native Y) → −X"), + ] + for native, expected, label in axis_cases: + pose = PoseSample(position=native, rotation=(0, 0, 0, 1), + timestamp=1.0) + out = rotate_pose_z90(pose) + if tuple(out.position) != expected: + failures.append(f"轴映射错误 [{label}]: {out.position} != {expected}") + + # 2. 用户实测复现(新核心,2026-09-09):物理 +Y → 显示 +Y; + # 物理 +X → 显示 +X;物理 +Z → 显示 +Z + # native = R_z(−90°)·物理(native X=正对、Y=左、Z=上) + Rzm90 = np.array([[0.0, 1.0, 0.0], [-1.0, 0.0, 0.0], [0.0, 0.0, 1.0]]) + for phys_axis, label in [ + (np.array([0.0, 1.0, 0.0]), "物理+Y"), + (np.array([1.0, 0.0, 0.0]), "物理+X"), + (np.array([0.0, 0.0, 1.0]), "物理+Z"), + ]: + native = tuple(Rzm90 @ phys_axis) + out = rotate_pose_z90(PoseSample(position=native, + rotation=(0, 0, 0, 1), + timestamp=1.0)) + if not np.allclose(np.array(out.position), phys_axis, atol=1e-12): + failures.append(f"{label} 修正后 != 物理轴: {out.position}") + + # 3. 随机位姿:R' = R_z(+90°)·R(纯左乘),正规性 + for i in range(200): + pos = tuple(float(v) for v in rng.uniform(-2, 2, 3)) + quat = random_unit_quaternion(rng) + pose = PoseSample(position=pos, rotation=quat, timestamp=1.0 + i) + out = rotate_pose_z90(pose) + expected_pos = (-pos[1], pos[0], pos[2]) + if tuple(out.position) != expected_pos: + failures.append(f"#{i} position 应为 (−y,x,z)") + continue + R = quat_to_matrix(*quat) + Rm = quat_to_matrix(*out.rotation) + if not np.allclose(Rm, Rzp90 @ R, atol=1e-12): + failures.append(f"#{i} R' != R_z(+90°)·R") + continue + if not np.allclose(Rm @ Rm.T, np.eye(3), atol=1e-12): + failures.append(f"#{i} R' not orthonormal") + if not np.isclose(np.linalg.det(Rm), 1.0, atol=1e-9): + failures.append(f"#{i} det(R') != +1") + + # 4. 静止首帧姿态:native = correction → 显示 R_z(90°)·correction + # = R_x(−90°)(部署校正常数残留,非单位矩阵);经原点相对化 + # q0⁻¹⊗q 后 = 单位矩阵(帧轴与世界轴对齐,无起始跳变) + q_corr = (-0.5, 0.5, -0.5, 0.5) # R_y(90°)·R_z(−90°) 的四元数 + out = rotate_pose_z90(PoseSample(position=(0.0, 0.0, 0.0), + rotation=q_corr, timestamp=1.0)) + Rxm90 = np.array([[1.0, 0.0, 0.0], [0.0, 0.0, 1.0], [0.0, -1.0, 0.0]]) + if not np.allclose(quat_to_matrix(*out.rotation), Rxm90, atol=1e-12): + failures.append("静止首帧显示姿态应为 R_x(−90°)(常数残留)") + q0 = out.rotation # process_controller 捕获的首帧基准 + zeroed = quat_product(quat_conjugate(q0), q0) + if not np.allclose(zeroed, (0.0, 0.0, 0.0, 1.0), atol=1e-12): + failures.append("原点相对化后首帧姿态应为单位矩阵(帧轴=世界轴)") + + # 5. 转体跟踪:夹爪转向右(物理 R_z(−90°),原点 ENTER=I)→ + # native = correction·R_z(−90°);显示 = R_z(90°)·native,再经 + # 相对化(q0⁻¹⊗q,q0 取自用例 4)→ R_z(−90°),帧 Y 轴 = 右 + q_z_m90 = (0.0, 0.0, -c, c) + q_native = quat_product(q_corr, q_z_m90) + out = rotate_pose_z90(PoseSample(position=(0.0, 0.0, 0.0), + rotation=q_native, timestamp=1.0)) + q_disp = quat_product(quat_conjugate(q0), out.rotation) + drawn_y = quat_to_matrix(*q_disp)[:, 1] + if not np.allclose(drawn_y, (1.0, 0.0, 0.0), atol=1e-12): + failures.append(f"转向右后帧 Y 轴应为 (1,0,0),实际 {drawn_y}") + + # 6. 双应用 = R_z(+180°):位置 (−x,−y,z),四元数 (−y,x,w,−z) + pose = PoseSample(position=(1.0, 2.0, 3.0), + rotation=random_unit_quaternion(rng), timestamp=1.0) + twice = rotate_pose_z90(rotate_pose_z90(pose)) + if tuple(twice.position) != (-1.0, -2.0, 3.0): + failures.append("双应用位置应为 (−x,−y,z)") + expected_quat = (-pose.rotation[1], pose.rotation[0], + pose.rotation[3], -pose.rotation[2]) + if not np.allclose(twice.rotation, expected_quat, atol=1e-12): + failures.append("双应用四元数应为 (−y,x,w,−z)") + R2 = quat_to_matrix(*twice.rotation) + Rz180 = Rzp90 @ Rzp90 + if not np.allclose(R2, Rz180 @ quat_to_matrix(*pose.rotation), + atol=1e-12): + failures.append("双应用旋转应为 R_z(+180°)·R") + + # 7. 轨迹形状不变(等距):相邻点距离一致 + traj = [ + PoseSample(position=tuple(float(v) for v in rng.uniform(-1, 1, 3)), + rotation=random_unit_quaternion(rng), timestamp=float(i)) + for i in range(50) + ] + for a, b in zip(traj, traj[1:]): + d1 = np.linalg.norm(np.array(a.position) - np.array(b.position)) + ma, mb = rotate_pose_z90(a), rotate_pose_z90(b) + d2 = np.linalg.norm(np.array(ma.position) - np.array(mb.position)) + if not np.isclose(d1, d2, atol=1e-12): + failures.append("轨迹相邻点距离被旋转改变") + + # 8. 四元数辅助:共轭逆 = 单位矩阵;Hamilton 积 = 矩阵左乘 + for i in range(200): + a = random_unit_quaternion(rng) + b = random_unit_quaternion(rng) + prod = quat_product(quat_conjugate(a), a) + if not np.allclose(prod, (0.0, 0.0, 0.0, 1.0), atol=1e-12): + failures.append(f"#{i} q⁻¹⊗q != 单位四元数") + break + Ra, Rb = quat_to_matrix(*a), quat_to_matrix(*b) + Rab = quat_to_matrix(*quat_product(a, b)) + if not np.allclose(Rab, Ra @ Rb, atol=1e-12): + failures.append(f"#{i} (a⊗b) 矩阵 != A·B") + break + + # 9. 原点相对化:首帧姿态 q0(含部署校正/启动朝向的任意常数 + # 旋转),此后 q0⁻¹⊗q 应还原为相对原点的真实转动 + for i in range(200): + q0r = random_unit_quaternion(rng) + q_rel = random_unit_quaternion(rng) + q = quat_product(q0r, q_rel) + recovered = quat_product(quat_conjugate(q0r), q) + if not np.allclose(recovered, q_rel, atol=1e-12): + failures.append(f"#{i} 相对化未还原相对转动") + break + if not np.allclose( + quat_to_matrix(*recovered), + quat_to_matrix(*q_rel), atol=1e-12, + ): + failures.append(f"#{i} 相对化矩阵不一致") + break + + if failures: + print("FAIL:") + for f in failures[:5]: + print(" ", f) + return 1 + print("PASS: rotate_pose_z90 数学性质全部通过(轴映射/实测复现/200 随机位姿/静止残留+相对化/转体跟踪/双应用/轨迹等距/四元数积)") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/test_gripper_raw_reconnect.py b/collector/tools/tests/test_gripper_raw_reconnect.py new file mode 100644 index 0000000000000000000000000000000000000000..84cf899cc841424f085d30bb0365914322983fad --- /dev/null +++ b/collector/tools/tests/test_gripper_raw_reconnect.py @@ -0,0 +1,144 @@ +"""FaysRawStreamClient 断线自动重连编排单测(离线,无硬件)。 + +直接驱动 _run 的重连状态机,_connect/_stream_loop 用脚本化假实现: +- A: 首连成功 → 中途服务端断开 → 1s 后重连成功 → on_reconnected 触发 + → 流继续,无 error +- B: 中途断开后重连持续失败 → 累计超时 → 致命 error(on_error 触发) +- C: 首连失败 → 立即致命,不进入重连 +""" +import os +import sys +import threading +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname( + os.path.abspath(__file__))))) + +import core.gripper.recording.fays_raw_client as raw_mod +from core.gripper.recording.fays_raw_client import ( + FaysRawStreamClient, FaysRawStreamError) + + +class FakeSock: + def close(self): + pass + + def shutdown(self, how): + pass + + +class ScriptedClient(FaysRawStreamClient): + """_connect 按脚本返回/抛错;_stream_loop 按脚本抛断或等 stop。""" + + def __init__(self, connect_script, stream_script): + super().__init__( + "/tmp/fake_raw.sock", on_stereo=lambda *a: None, + logger=lambda m: None) + self._connect_script = list(connect_script) # sock | FaysRawStreamError + self._stream_script = list(stream_script) # FaysRawStreamError | None(等stop) + self.connect_calls = 0 + self.stream_calls = 0 + + def _connect(self, deadline_s=30.0): + self.connect_calls += 1 + item = self._connect_script.pop(0) + if isinstance(item, Exception): + raise item + return item + + def _stream_loop(self, sock): + self.stream_calls += 1 + item = self._stream_script.pop(0) + if isinstance(item, Exception): + raise item + self._stop.wait(10) + return None + + +def run_scenario(connect_script, stream_script, stop_after=2.0): + client = ScriptedClient(connect_script, stream_script) + errors = [] + reconnects = [] + client._on_error = errors.append + client._on_reconnected = lambda: reconnects.append(1) + client.start() + time.sleep(stop_after) + client.stop() + return client, errors, reconnects + + +def scenario_a_first_connect_ok_then_reconnect(): + sock1, sock2 = FakeSock(), FakeSock() + client, errors, reconnects = run_scenario( + connect_script=[sock1, sock2], + stream_script=[FaysRawStreamError("closed unexpectedly"), None], + ) + ok = ( + not errors + and len(reconnects) == 1 + and client._reconnect_count == 1 + and client.connect_calls == 2 + and client.stream_calls == 2 + and client.connected.is_set() + ) + print((" PASS" if ok else " FAIL"), + "A: 中途断开→重连成功→on_reconnected 触发,无 error", + f"(connect={client.connect_calls} stream={client.stream_calls} " + f"reconnects={len(reconnects)})") + return ok + + +def scenario_b_reconnect_timeout_fatal(): + client, errors, reconnects = run_scenario( + connect_script=[FakeSock()] + [FaysRawStreamError("not ready")] * 50, + stream_script=[FaysRawStreamError("closed unexpectedly")], + ) + ok = ( + len(errors) == 1 + and "reconnect failed" in errors[0] + and not reconnects + and client._reconnect_count == 1 + and client.connect_calls >= 2 + ) + print((" PASS" if ok else " FAIL"), + "B: 重连持续失败→累计超时→致命 error(on_error 触发一次)", + f"(error={errors[:1]})") + return ok + + +def scenario_c_first_connect_fatal(): + client, errors, reconnects = run_scenario( + connect_script=[FaysRawStreamError("raw socket not ready")], + stream_script=[], + stop_after=0.8, + ) + ok = ( + len(errors) == 1 + and not reconnects + and client._reconnect_count == 0 + and client.connect_calls == 1 + and client.stream_calls == 0 + ) + print((" PASS" if ok else " FAIL"), + "C: 首连失败→立即致命,不进入重连循环") + return ok + + +def main(): + # 缩短重连节奏,测试秒级跑完 + raw_mod.RECONNECT_ATTEMPT_INTERVAL_S = 0.05 + raw_mod.RECONNECT_TOTAL_TIMEOUT_S = 0.6 + results = [ + scenario_a_first_connect_ok_then_reconnect(), + scenario_b_reconnect_timeout_fatal(), + scenario_c_first_connect_fatal(), + ] + if all(results): + print("\nPASS: FaysRawStreamClient 重连编排测试全部通过") + return 0 + print("\nFAIL: 存在未通过场景") + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/test_pose_view_qt.py b/collector/tools/tests/test_pose_view_qt.py new file mode 100644 index 0000000000000000000000000000000000000000..14330c4e120d3402aaace25752dfc8ed994c091d --- /dev/null +++ b/collector/tools/tests/test_pose_view_qt.py @@ -0,0 +1,78 @@ +"""PoseViewQt 轨迹常驻回归测试(离屏渲染)。 + +背景:Tk 版 PoseView 的 canvas 图元是持久的,慢路径(世界轴/原点/轨迹) +画一次即常驻;Qt 的 paintEvent 是立即模式、每帧全量重画。移植时把 +_draw_static 留在了 `if full_redraw:` 分支里,导致轨迹只在缩放/改尺寸 +(连续触发 full_redraw)时闪现,其余时间隐藏。 + +本测试用离屏 QImage 像素断言: +1. 首次绘制(初始化 full_redraw)后静态层存在; +2. 快速路径重绘(无缩放/尺寸变化/新轨迹点)后静态层仍然存在; +3. 新轨迹点到来(超过节流间隔)触发缓存重算,轨迹点数增加。 +""" +import os +import sys +import time + +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") +sys.path.insert(0, os.path.dirname(os.path.dirname( + os.path.dirname(os.path.abspath(__file__))))) + +import numpy as np +from PyQt5.QtGui import QImage +from PyQt5.QtWidgets import QApplication + +from ui.pose_view_qt import PoseViewQt + +# 静态层颜色:原点 #50d890(实心椭圆,保证有纯色像素) +ORIGIN_RGB = (0x50, 0xD8, 0x90) + + +def count_color(img: QImage, rgb) -> int: + img = img.convertToFormat(QImage.Format_RGB32) + ptr = img.bits() + ptr.setsize(img.byteCount()) + arr = np.frombuffer(ptr, np.uint8).reshape( + img.height(), img.bytesPerLine()) + arr = arr[:, :img.width() * 4].reshape(img.height(), img.width(), 4) + r, g, b = rgb + return int(((arr[:, :, 2] == r) & (arr[:, :, 1] == g) + & (arr[:, :, 0] == b)).sum()) + + +def main(): + app = QApplication.instance() or QApplication([]) + widget = PoseViewQt() + widget.resize(680, 420) + widget.show() + app.processEvents() + + traj = ((0.0, 0.0, 0.0), (0.5, 0.2, 0.1), (1.0, 0.4, 0.2)) + widget.update_pose((0.2, 0.1, 0.05), np.eye(3), traj) + first = widget.grab().toImage() + n_first = count_color(first, ORIGIN_RGB) + assert n_first > 20, f"首次绘制未见原点(静态层缺失): {n_first}" + + # 同一轨迹、新位姿、立即重绘 → 走快速路径(无 full_redraw 条件) + widget.update_pose((0.3, 0.15, 0.1), np.eye(3), traj) + second = widget.grab().toImage() + n_second = count_color(second, ORIGIN_RGB) + assert n_second > 20, ( + f"快速路径重绘后静态层消失(轨迹常驻回归): {n_second}") + + # 新轨迹点(超过 40ms 节流)→ dirty 标志触发缓存重算 + time.sleep(0.06) + traj2 = traj + ((1.5, 0.6, 0.3), (2.0, 0.8, 0.4)) + widget.update_pose((0.4, 0.2, 0.15), np.eye(3), traj2) + third = widget.grab().toImage() + n_third = count_color(third, ORIGIN_RGB) + assert n_third > 20, f"新轨迹点绘制后静态层缺失: {n_third}" + assert widget._trajectory_point_count == 5, ( + f"轨迹点未刷新: {widget._trajectory_point_count}") + + print("PASS: PoseViewQt 轨迹常驻回归测试通过 " + f"(origin 像素 {n_first}/{n_second}/{n_third})") + + +if __name__ == "__main__": + main() diff --git a/collector/tools/tests/test_upload_hardening.py b/collector/tools/tests/test_upload_hardening.py new file mode 100644 index 0000000000000000000000000000000000000000..23e0ea193e2d74835c85f68bfb796bbd3ae06b26 --- /dev/null +++ b/collector/tools/tests/test_upload_hardening.py @@ -0,0 +1,357 @@ +"""上传链路硬化单测 —— 不联网、不起真实上传线程。 + +覆盖: + 1. 传输层:_UPLOAD_RETRY 只放行建连重试、socket_options 注入到连接池、 + _PatientSendConnection.connect 用连接超时且退出后恢复原值 + 2. 会话名匹配/快照差集/时间窗判定(session_name_base / session_matches / + pick_new_session / pick_session_in_window) + 3. resume_pending:跳过条件、已入库判定(一对一分配、只认 POST 已开始的) + 4. _local_episode_exists / sweep_orphan_temp_files / inflight / UploadTask + +用法: + QT_QPA_PLATFORM=offscreen venv/bin/python tools/tests/test_upload_hardening.py +""" +import os +import sqlite3 +import sys +import tempfile +import time +from datetime import datetime, timedelta + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) +os.environ.setdefault("QT_QPA_PLATFORM", "offscreen") + +from PyQt5.QtWidgets import QApplication + +import core.uploader as up +from core.uploader import ( + UploadManager, UploadTask, session_name_base, session_matches, + pick_new_session, pick_session_in_window, +) +import core.api_client as api + +FAILS = [] + + +def check(cond, msg): + if cond: + print(f" PASS: {msg}") + else: + print(f" FAIL: {msg}") + FAILS.append(msg) + + +def _iso(dt): + return dt.isoformat() + + +def _mk_task_dir(root, name, episodes=(1,)): + """建一个池化任务目录(data/chunk-000/episode-NNN.parquet 即视为存在)。""" + td = os.path.join(root, name) + os.makedirs(os.path.join(td, "data", "chunk-000"), exist_ok=True) + for n in episodes: + open(os.path.join(td, "data", "chunk-000", + f"episode-{n - 1:03d}.parquet"), "w").close() + return td + + +class FakeDb: + """最小 DB 替身:真实 sqlite 内存库 + upload_task 建表。""" + + def __init__(self): + self.conn = sqlite3.connect(":memory:") + self.conn.row_factory = sqlite3.Row + self.conn.execute(""" + CREATE TABLE upload_task ( + id TEXT PRIMARY KEY, session_path TEXT NOT NULL, + session_name TEXT NOT NULL, episode_index INTEGER DEFAULT 0, + status TEXT NOT NULL DEFAULT 'pending', progress REAL DEFAULT 0.0, + retry_count INTEGER DEFAULT 0, server_url TEXT NOT NULL, + server_session_id TEXT DEFAULT '', error_message TEXT DEFAULT '', + created_at TEXT NOT NULL, updated_at TEXT NOT NULL)""") + + def add(self, tid, path, ep, status, created_at, updated_at, + server_url="http://srv:8000"): + self.conn.execute( + "INSERT INTO upload_task (id, session_path, session_name, " + "episode_index, status, server_url, created_at, updated_at) " + "VALUES (?, ?, ?, ?, ?, ?, ?, ?)", + (tid, path, os.path.basename(path), ep, status, server_url, + created_at, updated_at)) + self.conn.commit() + + +def main(): + app = QApplication(sys.argv) # noqa: F841 — Qt 对象需要 + now = datetime.now() + + # ── 1. 传输层 ────────────────────────────────────── + r = api._UPLOAD_RETRY + check(r.allowed_methods == {"POST"}, "重试放行 POST") + check((r.total, r.connect, r.read, r.status) == (2, 2, 0, 0), + "重试参数 total=2/connect=2/read=0/status=0(发送/读阶段不自动重发)") + check(r.respect_retry_after_header is False and r.raise_on_status is False, + "不因 Retry-After 重试、状态码交回调用方") + + ad = api._PatientSendAdapter(max_retries=api._UPLOAD_RETRY) + pool = ad.poolmanager.connection_from_url("http://127.0.0.1:9") + opts = pool.conn_kw.get("socket_options") or [] + check((1, 9, 1) in opts or any(o[0] == 1 and o[2] == 1 for o in opts), + "连接池注入 SO_KEEPALIVE") + import socket as _s + if getattr(_s, "TCP_KEEPIDLE", None) is not None: + check(any(o[1] == _s.TCP_KEEPIDLE for o in opts), + "Linux 注入 TCP_KEEPIDLE(死连接 2 分钟内报错)") + check(all(len(o) == 3 for o in opts), "socket_options 均为三元组") + + # connect() 用连接超时、退出恢复:替换基类 connect 记录当时的 self.timeout + import urllib3 + conn = api._PatientSendConnection("127.0.0.1", timeout=api.READ_TIMEOUT) + seen = {} + orig_connect = urllib3.connection.HTTPConnection.connect + + def _fake_connect(self): + seen["timeout"] = self.timeout + raise OSError("stop here") + urllib3.connection.HTTPConnection.connect = _fake_connect + try: + try: + conn.connect() + except OSError: + pass + finally: + urllib3.connection.HTTPConnection.connect = orig_connect + check(seen.get("timeout") == api.CONNECT_TIMEOUT, + "connect() 建连阶段用 CONNECT_TIMEOUT(不是 30 分钟读窗口)") + check(conn.timeout == api.READ_TIMEOUT, "connect() 退出后恢复原 timeout") + + # ── 2. 会话名匹配 ────────────────────────────────── + check(session_name_base("UMIGripper_AI") == "UMIGripper_AI", "基名:无后缀") + check(session_name_base("UMIGripper_AI_000012") == "UMIGripper_AI", + "基名:_000012") + check(session_name_base("UMIGripper_AI_ep000012") == "UMIGripper_AI", + "基名:_ep000012") + check(session_name_base("UMIGripper_AI_episode-12") == "UMIGripper_AI", + "基名:_episode-12") + check(session_name_base("UMIGripper_AI.zip") == "UMIGripper_AI", "基名:.zip") + check(session_name_base("") == "", "基名:空串") + + check(session_matches("UMIGripper_AI", {"name": "UMIGripper_AI_000002"}), + "匹配:服务器加序号后缀") + check(session_matches("UMIGripper_AI", {"name": "UMIGripper_AI"}), + "匹配:同名") + check(not session_matches("UMIGripper_AI", {"name": "OtherTask_000001"}), + "不匹配:别的任务") + check(not session_matches("UMIGripper_AI", {"name": ""}), "不匹配:空名") + + # ── 3. 快照差集 ──────────────────────────────────── + before = {"a", "b"} + s_new = {"id": "c", "name": "UMIGripper_AI_000002", "created_at": _iso(now)} + s_old = {"id": "a", "name": "UMIGripper_AI_000001", "created_at": _iso(now)} + check(pick_new_session(before, [s_old, s_new], "UMIGripper_AI") is s_new, + "差集:新出现的同名会话命中") + check(pick_new_session(before, [s_old], "UMIGripper_AI") is None, + "差集:没有新会话 → None") + check(pick_new_session(before, [{"id": "c", "name": "Other", + "created_at": _iso(now)}], + "UMIGripper_AI") is None, "差集:新会话名字不符 → None") + s_newer = {"id": "d", "name": "UMIGripper_AI_000003", + "created_at": _iso(now + timedelta(minutes=1))} + check(pick_new_session(before, [s_new, s_newer], "UMIGripper_AI") is s_newer, + "差集:多条取最新") + + # ── 4. 时间窗判定 ────────────────────────────────── + anchor = now - timedelta(minutes=10) + inside = {"id": "x", "name": "UMIGripper_AI_000009", + "created_at": _iso(now - timedelta(minutes=9))} + too_early = {"id": "y", "name": "UMIGripper_AI_000008", + "created_at": _iso(now - timedelta(minutes=30))} + check(pick_session_in_window([inside], "UMIGripper_AI", _iso(anchor)) is inside, + "窗口:锚点之后的会话命中") + check(pick_session_in_window([too_early], "UMIGripper_AI", _iso(anchor)) + is None, "窗口:早于锚点太多 → None") + check(pick_session_in_window([inside], "UMIGripper_AI", _iso(anchor), + _iso(now - timedelta(minutes=9, seconds=30))) + is None, "窗口:晚于上界 → None(防串到下一条的会话)") + check(pick_session_in_window([inside], "UMIGripper_AI", "") is None, + "窗口:锚点缺失 → None") + check(pick_session_in_window( + [{"id": "z", "name": "UMIGripper_AI_000007", "created_at": "bad"}], + "UMIGripper_AI", _iso(anchor)) is None, "窗口:created_at 不可解析 → None") + + # ── 5. resume_pending ────────────────────────────── + with tempfile.TemporaryDirectory() as root: + pA = _mk_task_dir(root, "TaskA", (1, 2)) + pB = _mk_task_dir(root, "TaskB", (1,)) + pF = _mk_task_dir(root, "TaskF", (1,)) + pDone = _mk_task_dir(root, "TaskDone", (1,)) + fake = FakeDb() + up.db = fake + m = UploadManager("http://srv:8000") + t_old = _iso(now - timedelta(hours=48)) + fake.add("r-old", pB, 1, "pending", t_old, t_old) # 超窗口 + fake.add("r1", pA, 1, "uploading", + _iso(now - timedelta(hours=1)), _iso(now - timedelta(minutes=10))) + fake.add("r2", pA, 2, "uploading", + _iso(now - timedelta(hours=1)), _iso(now - timedelta(minutes=5))) + fake.add("r3", pB, 1, "pending", + _iso(now - timedelta(minutes=30)), _iso(now - timedelta(minutes=30))) + fake.add("r4", os.path.join(root, "Gone"), 1, "pending", + _iso(now - timedelta(minutes=30)), _iso(now - timedelta(minutes=30))) + fake.add("r5", _mk_task_dir(root, "TaskSrv"), 1, "pending", + _iso(now - timedelta(minutes=30)), _iso(now - timedelta(minutes=30)), + server_url="http://other:9000") + fake.add("r6", pDone, 1, "pending", + _iso(now - timedelta(minutes=30)), _iso(now - timedelta(minutes=30))) + fake.add("r6b", pDone, 1, "completed", + _iso(now - timedelta(minutes=20)), _iso(now - timedelta(minutes=20))) + fake.add("r7", pF, 1, "pending", + _iso(now - timedelta(minutes=30)), _iso(now - timedelta(minutes=30))) + # r7 已在队列中 + m.add_task(pF, 1) + + srv_hit = {"id": "TaskA_000001", "name": "TaskA_000001", + "created_at": _iso(now - timedelta(minutes=9))} + m._resume_sessions_snapshot = lambda: [srv_hit] + sigs_pre = [] + m.task_completed.connect(lambda tid: sigs_pre.append(tid)) + resumed, verified, skipped = m.resume_pending(max_age_hours=24) + check(sigs_pre == [], + "续传:verified 行不发完成信号(task_id 尚未登记,收尾交调用方)") + + vmap = {v[1:3]: v[3] for v in verified} + rmap = {v[1:3] for v in resumed} + smap = {(s["path"], s["episode_index"]): s["reason"] for s in skipped} + + check((pA, 1) in vmap and vmap[(pA, 1)] == "TaskA_000001", + "续传:POST 已开始且服务器已入库 → 按成功收尾") + check((pA, 2) in rmap, "续传:窗口外的同任务行照常重传") + check((pB, 1) in rmap, "续传:pending 行照常重传") + check(smap.get((pB, 1)) is None, "续传:超窗口的行不被选中") + check(smap.get((os.path.join(root, "Gone"), 1)) == "missing_files", + "跳过:本地文件不存在") + check(smap.get((os.path.join(root, "TaskSrv"), 1)) == "server_changed", + "跳过:服务器地址变更") + check(smap.get((pDone, 1)) == "already_done", "跳过:已有完成记录") + check(smap.get((pF, 1)) == "already_queued", "跳过:已在队列中") + # 复用的 id 必须是 DB 行 id(续传后同一行被更新) + check(any(t[0] == "r2" for t in resumed), "续传:复用 DB 行 id") + rows = {r["id"]: r for r in fake.conn.execute( + "SELECT * FROM upload_task").fetchall()} + check(rows["r1"]["status"] == "completed", "已入库行落库为 completed") + check(rows["r1"]["server_session_id"] == "TaskA_000001", + "已入库行记录 server_session_id") + + # 快照查询失败 → 不做预判,全部照常重传 + fake2 = FakeDb() + up.db = fake2 + m2 = UploadManager("http://srv:8000") + fake2.add("q1", pA, 1, "uploading", + _iso(now - timedelta(hours=1)), _iso(now - timedelta(minutes=10))) + m2._resume_sessions_snapshot = lambda: None + resumed2, verified2, _ = m2.resume_pending() + check(not verified2 and len(resumed2) == 1, + "快照失败:不做已入库判定,照常重传") + + # ── 6. 本地文件存在性 ────────────────────────── + check(UploadManager._local_episode_exists(pA, 1), "存在性:episode 1 在") + check(not UploadManager._local_episode_exists(pA, 9), + "存在性:episode 9 不在") + check(not UploadManager._local_episode_exists( + os.path.join(root, "Gone"), 1), "存在性:目录不存在 → False") + + # ── 7. 残留临时文件清扫 ──────────────────────── + def _touch(name, age_h): + p = os.path.join(root, name) + open(p, "w").close() + ts = time.time() - age_h * 3600 + os.utime(p, (ts, ts)) + return p + stale = [_touch("_TaskA_ep000012_upload_abc123.zip", 25), + _touch("_episodes_abc_1.parquet", 25), + _touch("_precomp_abc_0_cam.mp4", 25)] + fresh = _touch("_TaskA_ep000013_upload_def456.zip", 0.1) + keep = _touch("episode-000.parquet", 25) + n = UploadManager.sweep_orphan_temp_files(root, max_age_hours=24) + check(n == 3, f"清扫:删除 3 个过期临时文件(实得 {n})") + check(all(not os.path.exists(p) for p in stale), "清扫:过期临时文件已删") + check(os.path.exists(fresh), "清扫:未过期的临时文件保留") + check(os.path.exists(keep), "清扫:非临时文件保留") + + # ── 8. inflight ──────────────────────────────── + m3 = UploadManager("http://srv:8000") + m3.add_task(pA, 1) + m3.add_task(pA, 2) + with up.QMutexLocker(m3._mutex): + t1 = m3._queue.pop(0) + m3._active[t1.id] = None + m3._active_tasks[t1.id] = t1 + m3._started_at[t1.id] = time.monotonic() - 5 + st = m3.inflight() + check(st[(pA, 1)]["state"] == "active", "inflight:执行中 → active") + check(st[(pA, 2)]["state"] == "queued", "inflight:排队中 → queued") + check(st[(pA, 1)]["elapsed"] >= 4.9, "inflight:elapsed 从开始时刻算") + + # ── 9. 失败后复查 / 按成功收尾 ────────────────── + class FakeClient: + def __init__(self, sessions): + self._sessions = sessions + + def try_get_sessions(self, limit=200): + return self._sessions + + t = UploadTask(pA, "http://srv:8000", 1) + check(m._verify_after_failure(FakeClient(None), t, set(), True) is None, + "复查:查询失败 → None(宁可重试)") + check(m._verify_after_failure(FakeClient([]), t, set(), False) is None, + "复查:无上传前基线 → None(区分不了新旧)") + s_hit = {"id": "TaskA_000005", "name": "TaskA_000005", + "created_at": _iso(now)} + check(m._verify_after_failure(FakeClient([s_hit]), t, set(), True) + is s_hit, "复查:新出现的同名会话 → 判定已入库") + check(m._verify_after_failure(FakeClient([s_hit]), t, {"TaskA_000005"}, + True) is None, "复查:旧会话不算数") + + up.db = fake # 上面"快照失败"子用例换过 db,这里换回来 + fake.add("rv", pB, 2, "uploading", _iso(now), _iso(now)) + tv = UploadTask(pB, "http://srv:8000", 2, task_id="rv") + m._mark_upload_verified(tv, s_hit, "单测") + row = fake.conn.execute( + "SELECT * FROM upload_task WHERE id='rv'").fetchone() + check(row["status"] == "completed" and row["progress"] == 1.0, + "_mark_upload_verified:落库 completed") + check(row["server_session_id"] == "TaskA_000005", + "_mark_upload_verified:记录会话 id") + + # emit=False(resume_pending 用):只落库、不发完成信号,收尾交给调用方 + sigs = [] + m.task_completed.connect(lambda tid: sigs.append(tid)) + fake.add("rv2", pB, 3, "uploading", _iso(now), _iso(now)) + tv2 = UploadTask(pB, "http://srv:8000", 3, task_id="rv2") + m._mark_upload_verified(tv2, s_hit, "单测", emit=False) + check("rv2" not in sigs, "_mark_upload_verified(emit=False):不发 task_completed") + row2 = fake.conn.execute( + "SELECT * FROM upload_task WHERE id='rv2'").fetchone() + check(row2["status"] == "completed", "_mark_upload_verified(emit=False):仍落库 completed") + m._mark_upload_verified(tv2, s_hit, "单测", emit=True) + check(sigs == ["rv2"], "_mark_upload_verified(emit=True):发 task_completed") + + # ── 10. UploadTask 往返 ──────────────────────── + t = UploadTask.from_row({"id": "z1", "session_path": pA, + "episode_index": 1}) + check(t.resumed is False, "from_row:缺 resumed → False") + t2 = UploadTask.from_row({"id": "z2", "session_path": pA, + "episode_index": 1, "resumed": 1}) + check(t2.resumed is True, "from_row:resumed 强转 bool") + check("resumed" in t2.to_dict(), "to_dict 含 resumed") + + print() + if FAILS: + print(f"FAIL: {len(FAILS)} 项未通过") + return 1 + print("PASS: upload_hardening 单测全部通过") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/tools/tests/upload_e2e_resume.py b/collector/tools/tests/upload_e2e_resume.py new file mode 100644 index 0000000000000000000000000000000000000000..0d0423623c0f529d9598662b7753d2ab30a3dbbe --- /dev/null +++ b/collector/tools/tests/upload_e2e_resume.py @@ -0,0 +1,64 @@ +"""端到端验证:走真实 resume_pending → 打包 → POST → 服务器复查。 + +⚠ 会真的上传数据到 server_config.json 里配置的服务器(不是单测)。 +只上传 DB 里 pending/uploading 的遗留任务,没有遗留任务时什么都不做。 +不动 GUI,只驱动 UploadManager(与主程序启动续传同一条代码路径)。 + +用法: + venv/bin/python tools/tests/upload_e2e_resume.py +""" +import os +import sys +import time + +sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))) + +from core.uploader import UploadManager +from core.task_service import TaskService +from config import settings + + +def main(): + url = settings.load_server_url() + user, pwd = settings.load_credentials() + ok, msg, cookies = TaskService.verify_credentials(url, user, pwd) + print("login:", ok, msg) + if not ok: + return 1 + svc = TaskService(url) + svc.adopt_login(url, user, cookies) + + m = UploadManager(url, session=svc._session) + resumed, verified, skipped = m.resume_pending() + print("resumed:", resumed) + print("verified:", verified) + print("skipped:", skipped) + if not resumed and not verified: + print("没有需要续传的任务") + return 0 + + done = {"n": 0} + m.task_status.connect(lambda tid, msg: print(f" [status {tid}] {msg}")) + m.task_progress.connect( + lambda tid, r: print(f" [progress {tid}] {r*100:.1f}%")) + m.task_completed.connect(lambda tid: (done.__setitem__("n", done["n"] + 1), + print(f" [completed {tid}]"))) + m.task_failed.connect(lambda tid, e: print(f" [failed {tid}] {e}")) + m.start() + t0 = time.time() + while not m.all_done() and time.time() - t0 < 900: + time.sleep(1) + print(f"all_done={m.all_done()} 用时 {time.time()-t0:.0f}s") + + from core.database import db + for r in db.conn.execute( + "SELECT id, episode_index, status, server_session_id, retry_count, " + "error_message, updated_at FROM upload_task " + "WHERE session_name LIKE 'UMIGripper%' ORDER BY created_at DESC " + "LIMIT 3"): + print(dict(r)) + return 0 if m.all_done() else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/collector/ui/device_panel.py b/collector/ui/device_panel.py index 134828432036af6b038996c7715a2b29a512d76f..0ba33e2ebb1ec8a927a93eedc45ba097eef6b035 100644 --- a/collector/ui/device_panel.py +++ b/collector/ui/device_panel.py @@ -23,9 +23,11 @@ from config.i18n import tr from config.settings import save_device_name _ICON = {"uvc": "📹", "d435": "🔭", "s80m": "👁", - "data_ble": "🧤", "usb_glove": "🧤", "ble": "🎧"} -_GROUP_ORDER = ["camera", "glove", "other_ble"] + "data_ble": "🧤", "usb_glove": "🧤", "ble": "🎧", + "gripper": "🤖"} +_GROUP_ORDER = ["camera", "glove", "gripper", "other_ble"] _GROUP_TITLE = {"camera": "📷 相机", "glove": "🧤 手套", + "gripper": "🤖 夹爪", "other_ble": "🎧 其他蓝牙"} @@ -67,6 +69,7 @@ class DevicePanel(QWidget): self._items: dict = {} # device key → QTreeWidgetItem self._last_check: dict = {} # device key → 上次勾选状态(挡文字类变化) self._group_expanded = {"camera": True, "glove": True, + "gripper": True, "other_ble": False} # 组展开状态(重建保留) self._locked = False # 录制中锁死开关 diff --git a/collector/ui/gripper_widgets.py b/collector/ui/gripper_widgets.py new file mode 100644 index 0000000000000000000000000000000000000000..d186e7e98ea2819b0abcc9dd5373c5dbc411fdaf --- /dev/null +++ b/collector/ui/gripper_widgets.py @@ -0,0 +1,130 @@ +"""UMI 夹爪触觉显示控件(P2):单侧热力图 + 力曲线竖排。 + +热力图直接复用 ZoomableVideoWidget(BGR 帧、滚轮缩放/拖拽),力曲线为 +自绘 QPainter 控件:±3000mN 量程、Fx/Fy/Fz 三线、10Hz 定时重绘、 +deque(300) 滚动窗口。后续 P4 的力值落盘复用本控件的 force 快照。 +""" + +from __future__ import annotations + +from collections import deque + +import numpy as np +from PyQt5.QtCore import Qt, QTimer +from PyQt5.QtGui import QColor, QPainter, QPen +from PyQt5.QtWidgets import ( + QHBoxLayout, + QLabel, + QVBoxLayout, + QWidget, +) + +from config import settings +from config.i18n import tr +from ui.camera_widget import ZoomableVideoWidget + +_FORCE_RANGE_MN = 3000.0 +_CURVE_POINTS = 300 +_CURVE_COLORS = { + "fx": QColor("#4fc3f7"), # 蓝 + "fy": QColor("#aed581"), # 绿 + "fz": QColor("#ff8a65"), # 橙 +} + + +class ForceCurveWidget(QWidget): + """Fx/Fy/Fz 力曲线(mN),±3000mN 对称量程。""" + + def __init__(self, parent=None): + super().__init__(parent) + self._series = {axis: deque(maxlen=_CURVE_POINTS) + for axis in ("fx", "fy", "fz")} + self._timer = QTimer(self) + self._timer.setInterval(100) # 10Hz + self._timer.timeout.connect(self.update) + self._timer.start() + self.setMinimumHeight(140) + self.setSizePolicy(self.sizePolicy().horizontalPolicy(), + self.sizePolicy().verticalPolicy()) + + def push(self, force: tuple): + """force=(fx, fy, fz) mN;非法值跳过。""" + try: + fx, fy, fz = (float(v) for v in force[:3]) + except (TypeError, ValueError, IndexError): + return + if any(abs(v) > _FORCE_RANGE_MN * 4 for v in (fx, fy, fz)): + return + self._series["fx"].append(fx) + self._series["fy"].append(fy) + self._series["fz"].append(fz) + + def reset(self): + for axis in self._series.values(): + axis.clear() + self.update() + + def paintEvent(self, _event): + painter = QPainter(self) + painter.fillRect(self.rect(), QColor("#101418")) + w, h = self.width(), self.height() + mid_y = h / 2 + # 网格 + 零轴 + grid_pen = QPen(QColor("#2a3038"), 1) + painter.setPen(grid_pen) + for frac in (-0.5, 0.0, 0.5): + y = mid_y - frac * h * 0.92 + painter.drawLine(0, int(y), w, int(y)) + zero_pen = QPen(QColor("#55606d"), 1) + painter.setPen(zero_pen) + painter.drawLine(0, int(mid_y), w, int(mid_y)) + # 三线(最新点在右缘) + for axis, series in self._series.items(): + if not series: + continue + pen = QPen(_CURVE_COLORS[axis], 1.6) + painter.setPen(pen) + step = w / max(1, _CURVE_POINTS - 1) + for index in range(1, len(series)): + x0 = w - (len(series) - index) * step + x1 = w - (len(series) - index - 1) * step + y0 = mid_y - series[index - 1] / _FORCE_RANGE_MN * h * 0.46 + y1 = mid_y - series[index] / _FORCE_RANGE_MN * h * 0.46 + painter.drawLine(int(x0), int(y0), int(x1), int(y1)) + painter.end() + + +class GripperSideWidget(QWidget): + """单侧触觉:热力图(上)+ 力曲线(下)。""" + + def __init__(self, side: str, parent=None): + super().__init__(parent) + self.side = side + layout = QVBoxLayout(self) + layout.setContentsMargins(4, 4, 4, 4) + layout.setSpacing(4) + self.video_widget = ZoomableVideoWidget(self) + self.video_widget.set_status_text( + tr("触觉 {}(等待 SDK 结果)").format( + "L" if side == "left" else "R")) + layout.addWidget(self.video_widget, 3) + curve_box = QHBoxLayout() + curve_box.setSpacing(4) + caption = QLabel(tr("力 (mN)"), self) + caption.setStyleSheet( + f"color:{settings.COLOR_TEXT_SECONDARY}; font-size:11px;") + caption.setFixedWidth(52) + curve_box.addWidget(caption) + self.force_curve = ForceCurveWidget(self) + curve_box.addWidget(self.force_curve, 1) + layout.addLayout(curve_box, 1) + + def update_tactile(self, heatmap: np.ndarray, force: tuple): + self.video_widget.set_frame(heatmap, flip_vertical=False) + self.force_curve.push(force) + + def reset(self): + self.force_curve.reset() + self.video_widget.set_status_text( + tr("触觉 {}(等待 SDK 结果)").format( + "L" if self.side == "left" else "R")) diff --git a/collector/ui/main_window.py b/collector/ui/main_window.py index 7772f1d1d463b8faaef552faae9f9168005cf232..6d46d2ec7e9896dd3a7f4c9ea8f10a5de0680dce 100755 --- a/collector/ui/main_window.py +++ b/collector/ui/main_window.py @@ -47,6 +47,14 @@ from core.helpers import (format_duration, format_size_mb, hand_kpts_parquet_path, session_summary, episode_file_suffix) +# 启动续传跳过原因(UploadManager.resume_pending 的 reason → 用户可读文案) +_RESUME_SKIP_TEXT = { + "missing_files": "本地文件不存在", + "server_changed": "服务器地址已变更", + "already_done": "已上传完成", + "already_queued": "已在队列中", +} + # 双目相机 —— 子进程/管道/曝光/抽帧口径已入 core/s80m_manager; # 路径常量 re-export 供本窗口可用性检查与离线测试 patch import shutil @@ -107,6 +115,25 @@ except ImportError: _GLOVE_AVAILABLE = False +def encode_gripper_force_matrix(m: np.ndarray) -> list: + """触觉力矩阵 int16 行差分编码(P4 泵线程,返回扁平 int16 列表)。 + + 与 online/recording/lerobot_v3.quantize_force_matrix 一致的有符号 + 补码行差分(mod 2^16 可逆),扩展到 (250,250,3) 三力平面:每行 250×3 + 个元素横向差分;超出 ±32767 mN 饱和截断。反解按 features 的 + shape=[250,250,3] 还原:np.frombuffer(...).reshape(-1,750) → + cumsum(axis=1) → reshape(250,250,3)。 + """ + arr = np.asarray(m, dtype=np.float32) + rows = int(arr.shape[0]) + flat = arr.reshape(rows, -1) + q = np.clip(flat, -32767.0, 32767.0).astype(np.int16) + d = np.empty_like(q) + d[:, 0] = q[:, 0] + d[:, 1:] = q[:, 1:] - q[:, :-1] # int16 mod 2^16 回绕 + return np.frombuffer(d.tobytes(), dtype=np.int16).tolist() + + class MainWindow(QMainWindow): """应用程序主窗口。""" @@ -148,10 +175,12 @@ class MainWindow(QMainWindow): self._open_fns = {"uvc": self._open_uvc, "d435": self._open_d435, "s80m": self._open_s80m, "data_ble": self._open_glove, "usb_glove": self._open_usb_glove, + "gripper": self._open_gripper, "ble": self._open_ble_placeholder} self._close_fns = {"uvc": self._close_uvc, "d435": self._close_d435, "s80m": self._close_s80m, "data_ble": self._close_glove, "usb_glove": self._close_glove, + "gripper": self._close_gripper, "ble": self._close_ble_placeholder} # ── 设备检测面板状态 ────────────────────────── @@ -211,12 +240,24 @@ class MainWindow(QMainWindow): settings.load_server_url(), session=getattr(self._task_service, "_session", None), ) - self._upload_task_map: dict = {} # task_id → session_path(日志用) + self._upload_task_map: dict = {} # task_id → (session_path, episode_index) + self._upload_log_ts: dict = {} # task_id → 上次写日志的 monotonic 时刻 + self._resume_done = False # 启动续传只做一次(重登录不再跑) self._upload_manager.task_completed.connect(self._on_upload_task_done) self._upload_manager.task_failed.connect(self._on_upload_task_failed) + self._upload_manager.task_started.connect(self._on_upload_task_started) + self._upload_manager.task_status.connect(self._on_upload_task_status) + self._upload_manager.task_progress.connect(self._on_upload_task_progress) self._upload_manager.start() self._upload_session_deleted.connect(self._on_upload_session_deleted) + # 清理上次进程被杀留下的上传临时 zip / 切片 / 预压视频(纯文件操作,不需登录) + _n = UploadManager.sweep_orphan_temp_files( + settings.RECORDING_DIR, + getattr(settings, "UPLOAD_TMP_SWEEP_AGE_HOURS", 24)) + if _n: + self._log(tr("🧹 已清理上传残留临时文件 {} 个", _n)) + # ── 监听语言切换 ────────────────────────────── lang_manager.language_changed.connect(self._on_language_changed) @@ -263,6 +304,14 @@ class MainWindow(QMainWindow): self._log_widget.document().setMaximumBlockCount(2000) # 跨线程日志信号(必须在 _log_widget 创建之后连接) self.log_message.connect(self._log_widget.append) + # 日志文件留档:GUI 日志全量追加到 logs/main.log(超过 5MB 轮转 + # 为 main.old.log),事后取证不依赖用户手动复制日志面板。 + self._log_file_path = None + try: + os.makedirs(settings.LOGS_DIR, exist_ok=True) + self._log_file_path = os.path.join(settings.LOGS_DIR, "main.log") + except OSError: + pass self._log_dock = QDockWidget(tr("日志"), self) self._log_dock.setWidget(self._log_widget) @@ -597,8 +646,40 @@ class MainWindow(QMainWindow): self._upload_manager.server_url = url self._task_page.set_server_display(url) self._task_service.start() + self._resume_pending_uploads() return True + def _resume_pending_uploads(self): + """启动续传:上次没传完的任务重新入队(登录后才有认证 cookie)。 + + 只在首次登录后执行一次:切换账号/登录过期重登不重复跑,否则 + 会与正在进行的任务抢同一个 episode。 + """ + if self._resume_done or not hasattr(self, "_upload_manager"): + return + self._resume_done = True + resumed, verified, skipped = self._upload_manager.resume_pending( + max_age_hours=settings.UPLOAD_RESUME_MAX_AGE_HOURS) + for tid, path, ep, sid in verified: + # 入 map:完成回调据此把录制行标「已上传」/按开关删除本地件 + self._upload_task_map[tid] = (path, ep) + self._log(tr("☁ {} 已在服务器上,无需重传: {}", + self._upload_pair_name((path, ep), tid), sid)) + # resume_pending 用 emit=False 收的尾(那时还没登记 task_id), + # 这里补跑完成回调,让录制行标「已上传」/按开关删本地件 + self._on_upload_task_done(tid) + for tid, path, ep in resumed: + self._upload_task_map[tid] = (path, ep) + self._log(tr("☁ 恢复未完成的上传: {}", + self._upload_pair_name((path, ep), tid))) + for row in skipped: + self._log(tr("☁ 跳过恢复 {}: {}", + self._upload_pair_name( + (row["path"], row["episode_index"])), + tr(_RESUME_SKIP_TEXT.get(row["reason"], "")))) + if resumed: + self._log(tr("☁ 已恢复 {} 个未完成的上传任务", len(resumed))) + def _on_switch_account(self): """任务页「切换账号」按钮 → 重开登录对话框。""" self._show_login_flow() @@ -748,6 +829,16 @@ class MainWindow(QMainWindow): if not _STEREO_AVAILABLE: self._log(tr("[错误] 双目 demo 脚本不存在")) return False + if self._device_manager.has_kind("gripper"): + # 夹爪 rig 的 s80m 由 ORB 桥接进程独占打开,与通用 S80M + # 子进程通道互斥(同一 FT602 双开必然冲突) + QMessageBox.warning( + self, tr("设备冲突"), + tr("UMI 夹爪已开启,其双目相机由夹爪的 SLAM 桥接独占。\n" + "请先关闭夹爪,再开启独立 S80M。")) + self._log(tr("[设备] S80M 与 UMI 夹爪冲突,已拒绝开启: {}", + self._device_label(dev))) + return False if self._device_manager.has_kind("d435"): QMessageBox.warning( self, tr("设备冲突"), @@ -757,6 +848,18 @@ class MainWindow(QMainWindow): self._log(tr("[设备] S80M 与 D435 冲突,已拒绝开启: {}", self._device_label(dev))) return False + if self._device_manager.has_kind("s80m"): + # 画面槽位 stereo_left/right 是全局命名,两台 S80M 同开会 + # 互相覆盖预览与录制;每台相机已按序列号区分,但同开仍需 + # 先关一台(子进程端口解析已保证只开被勾选的那台) + QMessageBox.warning( + self, tr("设备冲突"), + tr("暂不支持同时开启两台 S80 双目相机。\n" + "两台相机共用画面槽位,同时开启会串流。\n" + "请先关闭已开启的 S80M,再开启另一台。")) + self._log(tr("[设备] S80M 仅支持单台开启,已拒绝: {}", + self._device_label(dev))) + return False self._log(tr("正在启动双目摄像机 (S80M)…")) @@ -803,7 +906,11 @@ class MainWindow(QMainWindow): heatmap_smooth_k=settings.S80M_DEPTH_SMOOTH_K) # 注册表条目 + 子进程(temp 50fps yaml / stderr / watchdog / reader) - entry = self._s80m_manager.new_entry(self._device_label(dev)) + # 序列号 / USB 路径随条目传给子进程,多台 S80 接入时只开被勾选 + # 的那台相机(--device-serial / --device-path 端口解析) + entry = self._s80m_manager.new_entry(self._device_label(dev), + serial=dev.serial, + usb_path=dev.usb_path) self._workers[dev.key] = entry if not self._s80m_manager.spawn(dev.key, entry): self._workers.pop(dev.key, None) @@ -812,6 +919,10 @@ class MainWindow(QMainWindow): # 曝光入口(☀ 按钮)只放左目主槽;持久化曝光随开随应用 self._show_exposure_button("stereo_left") exp = settings.device_exposure(dev.key) + if exp is None and dev.key != "s80m:ftdi" and \ + sum(1 for k in self._last_device_kinds if k.startswith("s80m:")) == 1: + # 旧版键 s80m:ftdi → 序列号键的一次性曝光迁移(仅单台无歧义) + exp = settings.device_exposure("s80m:ftdi") if exp: self._s80m_set_exposure(dev.key, exp["auto"], exp["value"]) self._log(tr("双目摄像机已启动")) @@ -1121,8 +1232,14 @@ class MainWindow(QMainWindow): """设备扫描结果 → 面板重建 + 插拔 diff 日志 + 激活设备丢失处理。""" # 枚举后统一填用户命名(device_names.json),面板行显示 user_name 优先 names = settings.load_device_names() + _single_s80m = sum(1 for d in devices if d.kind == "s80m") == 1 for dev in devices: entry = names.get(dev.stable_key, "") + if not entry and _single_s80m and dev.kind == "s80m" \ + and dev.stable_key != "s80m:ftdi": + # 旧版键 s80m:ftdi → 序列号键的一次性命名迁移(仅单台时 + # 无歧义;多台时靠面板行尾序列号区分) + entry = names.get("s80m:ftdi", "") dev.user_name = entry["name"] if isinstance(entry, dict) else (entry or "") self._device_panel.set_devices(devices) @@ -1173,6 +1290,8 @@ class MainWindow(QMainWindow): self._close_d435(key) elif entry and entry["kind"] == "s80m": self._close_s80m(key) + elif entry and entry["kind"] == "gripper": + self._close_gripper(key) elif entry and entry["kind"] == "uvc": self._close_uvc(key) elif entry and entry["kind"] == "data_ble": @@ -1254,8 +1373,13 @@ class MainWindow(QMainWindow): """录制锁:所有已显示的曝光入口随录制状态禁用/恢复。""" for sid in self.grid.slot_ids(): w = self.grid.camera_widget(sid) - # isHidden 语义(窗口未 show 时 isVisible 恒 False) - if w is not None and not w.exposure_btn.isHidden(): + # 非相机控件(夹爪姿态/触觉面板等)没有曝光入口,跳过; + # 曾因 w.exposure_btn 直接 AttributeError 炸断整个录制开始 + # 回调(力矩阵泵因此从未启动)。isHidden 语义:窗口未 show + # 时 isVisible 恒 False,故用 isHidden 判断。 + if w is None or not hasattr(w, "exposure_btn"): + continue + if not w.exposure_btn.isHidden(): w.set_exposure_enabled(enabled) # ── 手套 / 其他蓝牙(统一体系:画面进主网格,录制走 write_sensor) ── @@ -1353,6 +1477,398 @@ class MainWindow(QMainWindow): if sid in self.grid.slot_ids(): self.grid.remove_camera(sid) + # ── UMI 夹爪(P1 空壳占位槽;P2/P3 填充 bridge/触觉/SLAM/串口) ── + + @staticmethod + def _gripper_slot_map(index: int) -> dict: + """夹爪槽位表:rig1 保持旧槽名(单夹爪数据契约不变),rig2 加序号。""" + mid = "" if index == 1 else f"_{index}" + return { + "stereo_l": f"gripper{mid}_stereo_left", + "rgb": f"gripper{mid}_rgb", + "pose": f"gripper{mid}_pose", + "force_l": f"gripper{mid}_force_left", + "force_r": f"gripper{mid}_force_right", + } + + def _open_gripper(self, dev) -> bool: + """面板开关打开 UMI 夹爪:建 5 个网格槽 + GripperBridge 后台启动。 + + 启动链(P2):相机组选择 → Sightac Flash 缓存 → DECXIN RGB 线程 → + 触觉输入/计算双进程;P3 起加 SingleFaysLease 全链 + SLAM 桥接 + + raw 双目流,P4 加串口。open() 在 bridge 后台线程执行,opened/ + error 经队列信号回主线程。 + 双夹爪:打开顺序分配 rig 序号(1..2,关闭即释放);槽名/数据列 + rig1 保持旧契约,rig2 带 "gripper_2_" 前缀;帧信号按 dev.key + lambda 捕获路由,互不串台。 + """ + if dev.key in self._workers: + return True # 已打开(幂等) + if self._device_manager.has_kind("s80m"): + QMessageBox.warning( + self, tr("设备冲突"), + tr("已开启独立 S80M,其与夹爪的双目相机互斥。\n" + "请先关闭 S80M,再开启 UMI 夹爪。")) + self._log(tr("[设备] UMI 夹爪与 S80M 冲突,已拒绝开启: {}", + self._device_label(dev))) + return False + gripper_count = sum( + 1 for e in self._workers.values() if e.get("kind") == "gripper") + if gripper_count >= 2: + QMessageBox.warning( + self, tr("夹爪数量上限"), + tr("最多支持同时开启 2 台 UMI 夹爪。\n" + "请先关闭其中一台再开启。")) + self._log(tr("[设备] 夹爪数量已达上限,已拒绝开启: {}", + self._device_label(dev))) + return False + index = 1 if gripper_count == 0 else 2 + try: + from core.gripper import paths + if not paths.gripper_resources_available(): + QMessageBox.warning( + self, tr("夹爪资源缺失"), + tr("未找到夹爪原生资源(core/gripper/native 未随包交付)," + "无法开启。")) + return False + except Exception: + return False + if not dev.serial: + QMessageBox.warning( + self, tr("夹爪无序列号"), + tr("未读取到夹爪 ESP32 序列号,无法唯一定位控制板。")) + return False + slot_map = self._gripper_slot_map(index) + tag = "" if index == 1 else str(index) + for sid, label in [ + (slot_map["stereo_l"], f"UMI{tag} 左目"), + (slot_map["rgb"], f"UMI{tag} RGB"), + ]: + self.grid.add_camera(sid, label) + from ui.pose_view_qt import PoseViewQt + pose_view = PoseViewQt() + self.grid.add_widget(slot_map["pose"], pose_view) + from ui.gripper_widgets import GripperSideWidget + side_widgets = {} + for sid, side in [(slot_map["force_l"], "left"), + (slot_map["force_r"], "right")]: + widget = GripperSideWidget(side) + side_widgets[sid] = widget + self.grid.add_widget(sid, widget) + + from core.gripper.bridge import GripperBridge + bridge = GripperBridge(self, stereo_slot=slot_map["stereo_l"], + rig_index=index) + key = dev.key + # 帧信号全部按 dev.key lambda 捕获路由(不再按 kind 首命中, + # 双夹爪帧流各自归位) + bridge.rgb_frame_ready.connect( + lambda frame, hw_ns, key=key: + self._on_gripper_rgb(key, frame, hw_ns)) + bridge.stereo_frame_ready.connect( + lambda slot, frame, hw_ns, key=key: + self._on_gripper_stereo(key, slot, frame, hw_ns)) + bridge.tactile_ready.connect( + lambda side, heatmap, force, matrix, key=key: + self._on_gripper_tactile(key, side, heatmap, force, matrix)) + bridge.pose_ready.connect( + lambda position, quat, trajectory=(), timestamp=None, key=key: + self._on_gripper_pose(key, position, quat, trajectory, + timestamp)) + bridge.gripper_state_ready.connect( + lambda payload, key=key: self._on_gripper_state(key, payload)) + bridge.log.connect(self._log) + bridge.error.connect( + lambda msg, key=key: self._on_gripper_error(key, msg)) + bridge.opened.connect( + lambda key=key: self._log( + tr("[夹爪] {} 相机 + 触觉 + SLAM 链路已就绪", + self._workers.get(key, {}).get("label", key)))) + entry_label = self._device_label(dev) + (f" #{index}" + if index != 1 else "") + entry = self._device_manager.gripper_entry( + [slot_map["stereo_l"], slot_map["rgb"], slot_map["pose"], + slot_map["force_l"], slot_map["force_r"]], + entry_label, serial=dev.serial or "") + entry["bridge"] = bridge + entry["side_widgets"] = side_widgets + entry["pose_view"] = pose_view + entry["_video_registered"] = set() + entry["matrix_pump_stop"] = None # 录制期力矩阵泵线程停止事件 + entry["_stereo_last_display_ns"] = 0 # 左目显示节流(15fps) + entry["_stereo_display_seq"] = 0 # 每 2 帧显示 1 帧的计数 + entry["gripper_index"] = index + entry["slot_map"] = slot_map + # 双夹爪数据列命名空间:rig1 空串(旧键 slam_pose/gripper_state/ + # gripper_{side}_force…不变),rig2 "gripper_2_" 前缀 + entry["snapshot_prefix"] = ("" if index == 1 + else f"gripper_{index}_") + self._workers[dev.key] = entry + # 非视频槽(pose/左右触觉)单独进 status 列 + for sid in (slot_map["pose"], slot_map["force_l"], + slot_map["force_r"]): + self._pipeline.register_gripper_device_id(sid) + self._pipeline.record_event(dev.key, "connected") + # CPU 预留(主线程掩码收窄,让本 rig 的 SLAM 分区与 raw 专用核 + # 不再被主进程线程/ffmpeg 子进程抢占)——必须在 open() 派生 + # 各工作线程之前生效(子线程继承受限掩码;native SLAM 走 + # taskset 显式设掩码不受影响) + from core.gripper import affinity + affinity.reserve(index, self._log) + bridge.open(dev.serial) + self._log(tr("[夹爪] {} 正在启动相机/触觉/SLAM 链路…", + self._device_label(dev))) + return True + + def _close_gripper(self, dev_key: str): + """关闭 UMI 夹爪:桥接逆序回收 → 撤 5 个网格槽 + 注销条目。 + + 槽位全部取自本条目 slot_map(rig2 前缀不同),关闭一台 + 不碰另一台的共享命名空间。""" + entry = self._workers.pop(dev_key, None) + if not entry or entry["kind"] != "gripper": + return + rig_index = entry.get("gripper_index") or 1 + self._stop_matrix_pump(entry) + bridge = entry.get("bridge") + if bridge is not None: + bridge.close() + # 退还本 rig 的 CPU 预留(掩码扩回;全部 rig 关闭后恢复完整掩码) + from core.gripper import affinity + affinity.release(rig_index, self._log) + slot_map = entry["slot_map"] + # 双目槽只显示不录制(从未注册外部帧源),只有 RGB 需要注销 + self._pipeline.unregister_external_source(slot_map["rgb"]) + for sid in (slot_map["pose"], slot_map["force_l"], + slot_map["force_r"]): + self._pipeline.unregister_gripper_device_id(sid) + self._pipeline.record_event(dev_key, "disconnected") + pose_view = entry.get("pose_view") + if pose_view is not None: + pose_view.reset() + for sid in entry.get("slots", []): + if sid in self.grid.slot_ids(): + self.grid.remove_camera(sid) + + # ── 夹爪桥接信号(dev.key 路由,双夹爪各自归位)── + + def _gripper_entry(self, dev_key: str): + entry = self._workers.get(dev_key) + if entry is None or entry.get("kind") != "gripper": + return None + return entry + + def _on_gripper_rgb(self, dev_key: str, frame, hw_ns: int): + """DECXIN RGB 帧(bridge 线程 → 队列回主线程)。首帧惰性注册 + 外部帧源(分辨率以实际首帧为准),显示全帧直推;录制时写入 + 对应 rig 的 RGB 视频槽。""" + entry = self._gripper_entry(dev_key) + if entry is None: + return + sid = entry["slot_map"]["rgb"] + if sid not in entry.get("_video_registered", set()): + h, w = frame.shape[:2] + self._pipeline.register_external_source(sid, (h, w), fps=30.0) + entry["_video_registered"].add(sid) + self._log(tr("[夹爪] RGB 外部帧源已注册 {}x{}@30", w, h)) + self._note_frame_arrival(sid) + widget = self.grid.camera_widget(sid) + if widget: + widget.video_widget.set_frame(frame, flip_vertical=False) + if self._pipeline.is_recording: + self._pipeline.write_external_frame( + sid, frame.copy(), hardware_ns=hw_ns) + + def _on_gripper_stereo(self, dev_key: str, slot, frame, hw_ns): + """s80m 左目帧(bridge 线程 → 队列回主线程):仅显示,节流到 + 15fps;不注册外部帧源、不入录制。SLAM 解算在桥接进程内部按 + 30fps 取帧进行,与显示节流无关;灰度视频与 IMU 原始数据均不 + 落盘,只存 SLAM 位姿/轨迹。""" + entry = self._gripper_entry(dev_key) + if entry is None or slot != entry["slot_map"]["stereo_l"]: + return + now_ns = time.monotonic_ns() + # 源是 30fps 抽帧流(33.3ms 间隔):按 15fps 的墙钟闸门 + # (66.7ms)会与 30fps 混叠成 3:1,实测只显示 ~10fps。 + # 改成「每 2 帧显示 1 帧」= 稳定 15fps;若断流超 1.5 个 + # 显示间隔(100ms)则立即补显,恢复后首帧不因奇偶错过。 + entry["_stereo_display_seq"] = ( + entry.get("_stereo_display_seq", 0) + 1) + interval_ns = int(1e9 / settings.GRIPPER_STEREO_DISPLAY_FPS) + if ( + entry["_stereo_display_seq"] % 2 == 1 + and now_ns - entry.get("_stereo_last_display_ns", 0) + < interval_ns * 3 // 2 + ): + return + entry["_stereo_last_display_ns"] = now_ns + self._note_frame_arrival(slot) + widget = self.grid.camera_widget(slot) + if widget: + widget.video_widget.set_frame(frame, flip_vertical=False) + + def _on_gripper_pose(self, dev_key: str, position, quat, trajectory=(), + timestamp=None): + """SLAM 位姿(pos3, quat4, traj, t):quat→3x3 驱动 PoseViewQt + (含轨迹) + 落盘快照(rig2 加前缀);t 随位姿进入 + slam_trajectory 列(轨迹并入 episode parquet,无 txt 侧车)。""" + entry = self._gripper_entry(dev_key) + if entry is None: + return + import numpy as np + qx, qy, qz, qw = (float(value) for value in quat) + rotation = np.array([ + [1.0 - 2.0 * (qy * qy + qz * qz), + 2.0 * (qx * qy - qz * qw), + 2.0 * (qx * qz + qy * qw)], + [2.0 * (qx * qy + qz * qw), + 1.0 - 2.0 * (qx * qx + qz * qz), + 2.0 * (qy * qz - qx * qw)], + [2.0 * (qx * qz - qy * qw), + 2.0 * (qy * qz + qx * qw), + 1.0 - 2.0 * (qx * qx + qy * qy)], + ], dtype=float) + pose_view = entry.get("pose_view") + if pose_view is not None: + pose_view.update_pose(position, rotation, trajectory) + self._pipeline.write_slam_pose( + [float(position[0]), float(position[1]), float(position[2]), + qx, qy, qz, qw], + prefix=entry["snapshot_prefix"], timestamp=timestamp) + + def _on_gripper_tactile(self, dev_key: str, side, heatmap, force, + force_matrix): + """触觉结果(左/右):热力图 + 力曲线显示 + 力值落盘; + 力矩阵落盘 P4 泵线程。""" + entry = self._gripper_entry(dev_key) + if entry is None: + return + sid = (entry["slot_map"]["force_l"] if side == "left" + else entry["slot_map"]["force_r"]) + widget = entry.get("side_widgets", {}).get(sid) + if widget: + # worker 输出的热力图已是 RGB(applyColorMap 后已转),而 + # VideoWidget.set_frame 约定输入 BGR(内部再转 RGB 显示), + # 直接透传会红蓝互换——这里补一次反向转换。 + display_heatmap = cv2.cvtColor(heatmap, cv2.COLOR_RGB2BGR) + widget.update_tactile(display_heatmap, force) + if force is not None and len(force) == 3: + self._pipeline.write_tactile_force( + side, force, prefix=entry["snapshot_prefix"]) + + def _on_gripper_state(self, dev_key: str, payload): + """串口夹爪状态 {pct,gripped,fz,event,board}:PoseView 开合板 + + gripper_state 稀疏列快照(录制期随帧行落盘)。""" + entry = self._gripper_entry(dev_key) + if entry is None: + return + pct = payload.get("pct") + gripped = bool(payload.get("gripped", False)) + pose_view = entry.get("pose_view") + if pose_view is not None: + pose_view.set_grip_state(pct, gripped) + if pct is None: + return # 板状态尚未到来:不写列(write 侧要求有限数值) + fz = payload.get("fz", 0.0) + self._pipeline.write_gripper_state( + [float(pct), float(gripped), float(fz)], + prefix=entry["snapshot_prefix"]) + + # ── 力矩阵泵线程(录制期)────────────────────────── + + def _gripper_entries(self): + """全部已开启夹爪条目(双夹爪录制时逐台处理)。""" + return [e for e in self._workers.values() + if e.get("kind") == "gripper"] + + def _start_matrix_pump(self): + """录制开始:为每台已开启的夹爪各起一个 30ms 力矩阵泵线程。""" + started = 0 + for entry in self._gripper_entries(): + bridge = entry.get("bridge") + if bridge is None or entry.get("matrix_pump_stop") is not None: + continue + stop = threading.Event() + entry["matrix_pump_stop"] = stop + entry["matrix_wrote"] = {"left": 0, "right": 0} + thread = threading.Thread( + target=self._matrix_pump_loop, + args=(bridge, stop, entry), + name="gripper-matrix-pump-{}".format( + entry.get("gripper_index", "")), + daemon=True, + ) + thread.start() + entry["matrix_pump_thread"] = thread + started += 1 + if not started: + self._log(tr("[夹爪] 力矩阵泵未启动:无夹爪设备条目")) + + def _matrix_pump_loop(self, bridge, stop, entry): + """泵线程体:仅在有新矩阵时编码(int16 行差分)+ 快照写入。""" + last_seq = {"left": 0, "right": 0} + first_logged = {"left": False, "right": False} + wrote = entry["matrix_wrote"] + started = time.monotonic() + self._log(tr("[夹爪] 力矩阵泵已启动 (L seq={} R seq={})", + bridge.matrix_seq("left"), + bridge.matrix_seq("right"))) + while not stop.is_set(): + for side in ("left", "right"): + seq = bridge.matrix_seq(side) + if seq == last_seq[side]: + continue + last_seq[side] = seq + matrix = bridge.latest_matrix(side) + if matrix is None: + continue + try: + encoded = encode_gripper_force_matrix(matrix) + except Exception as exc: + self._log(tr("[夹爪] 力矩阵编码失败 ({}): {}", + side, exc)) + continue + self._pipeline.write_tactile_force_matrix( + side, encoded, prefix=entry["snapshot_prefix"]) + wrote[side] += 1 + if not first_logged[side]: + first_logged[side] = True + self._log(tr("[夹爪] {} 侧力矩阵首帧落盘 ({} 元素)", + "左" if side == "left" else "右", + len(encoded))) + if (time.monotonic() - started >= 10.0 + and not first_logged["left"] + and not first_logged["right"]): + self._log(tr( + "[夹爪] 力矩阵泵 10s 无新样本 (L seq={} R seq={})", + bridge.matrix_seq("left"), bridge.matrix_seq("right"))) + started = time.monotonic() + stop.wait(0.03) + + def _stop_matrix_pump(self, entry): + """录制结束/设备关闭:停泵线程并等待退出。""" + stop = entry.get("matrix_pump_stop") + if stop is not None: + stop.set() + entry["matrix_pump_stop"] = None + thread = entry.pop("matrix_pump_thread", None) + if thread is not None and thread.is_alive(): + thread.join(timeout=1.0) + wrote = entry.pop("matrix_wrote", None) + if wrote is not None: + self._log(tr("[夹爪] 力矩阵泵停止:L 写 {} 帧 R 写 {} 帧", + wrote["left"], wrote["right"])) + + def _on_gripper_error(self, dev_key: str, msg: str): + """桥接启动失败:弹窗 + 回收槽位 + 面板回退勾选。""" + self._log(tr("[夹爪] 启动失败: {}", msg)) + QMessageBox.critical(self, tr("夹爪启动失败"), msg) + self._close_gripper(dev_key) + self._active_device_keys.discard(dev_key) + self._device_panel.set_checked(dev_key, False) + self._device_panel.set_active_keys(self._active_device_keys) + self._update_status() + def _on_device_toggled(self, dev, on: bool): """面板开关 → 打开/关闭设备(多路并发:只动自己,不互拆)。 @@ -1428,6 +1944,19 @@ class MainWindow(QMainWindow): w["dropped"], w["dropped"] / w["elapsed"] * 100)) + def _gripper_drop_summary(self): + """录制结束汇总夹爪双目空桶统计(30fps 口径,有丢才打日志)。""" + for entry in self._gripper_entries(): + bridge = entry.get("bridge") + if bridge is None: + continue + dropped, elapsed = bridge.stereo_drop_snapshot() + if dropped > 0 and elapsed > 0: + self._log(tr("[夹爪] {} 本次录制双目空桶 {} 个({:.0f}%)" + "——SLAM 取帧未达 30fps,轨迹存在缺帧", + entry.get("label", "UMI"), + dropped, dropped / elapsed * 100)) + def _build_device_meta(self) -> list: """按注册表构建录制设备信息(口径在 core.device_manager)。""" return self._device_manager.build_device_meta() @@ -1471,6 +2000,17 @@ class MainWindow(QMainWindow): batch_index = completed + 1 self._reset_s80m_record_state() + # 夹爪双目 30fps 空桶看门狗随录制段重置(口径与 s80m 一致); + # 同时清空录制前累积的 GUI 轨迹(显示只画本段录制的点, + # parquet slam_trajectory 列由 writer 录制期独立累积不受影响) + for entry in self._gripper_entries(): + bridge = entry.get("bridge") + if bridge is not None: + bridge.reset_stereo_drop_watch() + bridge.clear_trajectory() + pose_view = entry.get("pose_view") + if pose_view is not None: + pose_view.reset() self._pipeline.start_recording(self.grid.slot_ids()[0], task_name=task_name, batch_index=batch_index, @@ -1480,6 +2020,7 @@ class MainWindow(QMainWindow): """停止录制(正常完成)。""" if self._pipeline.is_recording: self._s80m_drop_summary() + self._gripper_drop_summary() self._pipeline.finish_recording("") self._reset_s80m_record_state() @@ -1541,6 +2082,9 @@ class MainWindow(QMainWindow): def _on_recording_started(self, slot_id: str): """录制开始——更新状态栏 + 锁死设备开关。""" + # 力矩阵泵最先启动:后续任何 UI 锁调用即使异常也不影响落盘 + # (夹爪在场时启动泵线程,录制期才落 force_matrix 列) + self._start_matrix_pump() self._device_panel.set_locked(True) # 录制期间停设备轮询:detect_devices() 全量枚举(DShow/S80M/BLE 主动 # 发现,150-210ms)在扫描线程挤占采集线程,帧以「空洞+突发」到达、 @@ -1560,6 +2104,12 @@ class MainWindow(QMainWindow): def _on_recording_finished(self, slot_id: str, session_path: str): """录制完成——保存历史记录并更新任务进度。""" self._device_panel.set_locked(False) + episode_index = getattr( + self._pipeline, "last_episode_index", 0) or 0 + for entry in self._gripper_entries(): + self._stop_matrix_pump(entry) + # 轨迹已随 slam_trajectory 列并入本次 episode parquet, + # 不再归档 txt 侧车 # 恢复设备轮询(_on_recording_started 停掉的;request_scan 有 # _busy 守卫,扫描在途时忽略,不会堆积)。若录制期间已返回任务 # 选择页(中止后切页),_on_page_changed(0) 已停轮询,这里不抢 @@ -1569,8 +2119,6 @@ class MainWindow(QMainWindow): self._device_timer.start() self._set_exposure_buttons_enabled(True) if session_path: - episode_index = getattr( - self._pipeline, "last_episode_index", 0) or 0 cam_list, duration, size_mb = session_summary( session_path, self._pipeline.last_recording_frames, episode_index=episode_index) @@ -1656,6 +2204,8 @@ class MainWindow(QMainWindow): def _on_recording_aborted(self, slot_id: str): """异常停止。""" self._device_panel.set_locked(False) + for entry in self._gripper_entries(): + self._stop_matrix_pump(entry) # 中止走独立信号 recording_aborted,不经过 _on_recording_finished—— # 必须单独恢复轮询,否则设备面板轮询永久停止。但中止后可能已切回 # 任务选择页(轮询应停),守卫同 _on_recording_finished。 @@ -2046,9 +2596,30 @@ class MainWindow(QMainWindow): # 日志 # ═══════════════════════════════════════════════════ + _log_lock = threading.Lock() + def _log(self, msg: str): stamp = datetime.now().strftime("%H:%M:%S") text = f"[{stamp}] {msg}" + if self._log_file_path is not None: + try: + with self._log_lock: + _log_size = ( + os.path.getsize(self._log_file_path) + if os.path.isfile(self._log_file_path) else 0) + if _log_size > 5 * 1024 * 1024: + try: + os.replace( + self._log_file_path, + self._log_file_path + ".old") + except OSError: + pass + with open( + self._log_file_path, "a", + encoding="utf-8") as handle: + handle.write(text + "\n") + except OSError: + pass # 主线程直接写,后台线程通过信号安全投递 if QThread.currentThread() is QApplication.instance().thread(): self._log_widget.append(text) @@ -2066,9 +2637,56 @@ class MainWindow(QMainWindow): # 对话框内删除会话可能改变历史状态(如标「已上传,本地已删」) self._refresh_history() + @staticmethod + def _upload_pair_name(pair, task_id: str = "") -> str: + """(path, episode_index) → 日志用短名(任务目录/episode-xxx)。""" + path = pair[0] if isinstance(pair, tuple) else (pair or "") + episode_index = pair[1] if isinstance(pair, tuple) else 0 + if not path: + return task_id + name = os.path.basename(path) + if episode_index > 0: + name = f"{name}/episode-{episode_file_suffix(episode_index):03d}" + return name + + def _on_upload_task_started(self, task_id: str): + """上传开始——写主窗口日志(此前打包/上传全程静默,用户只能干等)。""" + if task_id not in self._upload_task_map: + return + self._upload_log_ts[task_id] = time.monotonic() + self._log(tr("☁ 开始上传: {}", + self._upload_pair_name(self._upload_task_map[task_id], + task_id))) + + def _on_upload_task_status(self, task_id: str, msg: str): + """上传阶段变化/进度文字——节流写日志(阶段变化立即写)。""" + if task_id not in self._upload_task_map: + return + now = time.monotonic() + urgent = any(k in msg for k in ("重试", "完成", "出错", "失败")) + if not urgent and now - self._upload_log_ts.get(task_id, 0.0) < \ + settings.UPLOAD_LOG_THROTTLE_S: + return + self._upload_log_ts[task_id] = now + self._log(tr("☁ [{}] {}", self._upload_pair_name( + self._upload_task_map[task_id], task_id), msg)) + + def _on_upload_task_progress(self, task_id: str, ratio: float): + """进度心跳——POST 无响应时也要有日志,否则看起来像卡死。""" + if task_id not in self._upload_task_map: + return + now = time.monotonic() + if now - self._upload_log_ts.get(task_id, 0.0) < \ + settings.UPLOAD_LOG_THROTTLE_S: + return + self._upload_log_ts[task_id] = now + self._log(tr("☁ [{}] 上传中… {}%", self._upload_pair_name( + self._upload_task_map[task_id], task_id), int(ratio * 100))) + def _on_upload_task_done(self, task_id: str): """自动上传完成——记录日志;"上传后自动删除"开启时删除本地会话目录, 否则把录制行标为「已上传」(本地保留)并刷新历史。""" + self._upload_log_ts.pop(task_id, None) pair = self._upload_task_map.pop(task_id, ("", 0)) path = pair[0] if isinstance(pair, tuple) else pair episode_index = pair[1] if isinstance(pair, tuple) else 0 @@ -2151,6 +2769,7 @@ class MainWindow(QMainWindow): def _on_upload_task_failed(self, task_id: str, error: str): """自动上传失败——记录日志(重试 3 次后仍失败才触发)。""" + self._upload_log_ts.pop(task_id, None) pair = self._upload_task_map.pop(task_id, ("", 0)) path = pair[0] if isinstance(pair, tuple) else pair episode_index = pair[1] if isinstance(pair, tuple) else 0 @@ -2212,6 +2831,18 @@ class MainWindow(QMainWindow): def closeEvent(self, event): """关闭窗口前停止录制、释放资源。""" + # 上传还没跑完就退出:上传线程是 daemon,进程一退就断在半路 + # (2026-09-09 episode-012 事故)。先问一句,选"否"则整个退出取消。 + if hasattr(self, "_upload_manager"): + n = (self._upload_manager.pending_count() + + self._upload_manager.active_count()) + if n and QMessageBox.question( + self, tr("确认"), + tr("有 {} 个上传任务未完成,确定退出?" + "未完成的任务将在下次启动时自动恢复。", n) + ) != QMessageBox.Yes: + event.ignore() + return self._shutting_down = True self._s80m_manager.shutting_down = True self._device_timer.stop() diff --git a/collector/ui/pose_view_qt.py b/collector/ui/pose_view_qt.py new file mode 100644 index 0000000000000000000000000000000000000000..0fc7a35b250391bbd5f047dd19a54fd85b582059 --- /dev/null +++ b/collector/ui/pose_view_qt.py @@ -0,0 +1,470 @@ +"""SLAM 3D 位姿与轨迹视图(QPainter 等距正交投影,PoseView 的 Qt 移植)。 + +无 OpenGL——与 Tk 版同一理由:避免 GLX/X11 BadWindow 致命错误。 +主窗口按位姿节奏调用 update(position, rotation, trajectory);paintEvent +全量重绘(位姿 ~30Hz 时每条线几十个点,QPainter 开销可忽略)。 +轨迹显示降采样到 DISPLAY_TRAJECTORY_MAX_POINTS 点;左键拖动旋转视角、 +右键/中键拖动平移、滚轮缩放、双击复位视角。 +""" + +from __future__ import annotations + +import math +import time + +import numpy as np +from PyQt5.QtCore import Qt, QPointF, QRectF +from PyQt5.QtGui import QColor, QPainter, QPen, QPolygonF +from PyQt5.QtWidgets import QWidget + +DISPLAY_TRAJECTORY_MAX_POINTS = 400 +TRAJECTORY_UPDATE_MIN_INTERVAL = 1.0 / 25.0 +# 网格降采样:stride 只增不减(2 的幂)且锚定索引 0——旧顶点索引永不滑动, +# 新点只在落上网格时追加;stride 翻倍只发生在点数超过 400×stride 时 +# (一次离散简化,顶点只减不挪,不再每帧整体重抽)。 +# span 自适配:只在探索前沿超过当前 span 的 85% 时外扩一次(缓动 0.3s, +# 目标为前沿 ×1.35),其余时间完全固定——前沿位姿噪声不再牵动整幅画面。 +SPAN_EXPAND_TRIGGER = 0.85 +SPAN_EXPAND_TARGET = 1.35 +SPAN_EXPAND_ANIM_SECONDS = 0.3 +# 默认观测角(与旧固定视角一致);用户拖动后可自由旋转 +AZIMUTH_DEFAULT = math.radians(-150.0) +ELEVATION_DEFAULT = math.radians(30.0) + +BG = QColor("#0c1a2b") +TITLE = QColor("#7d9bc0") +TRAJECTORY = QColor("#e0a840") +WORLD_AXES = ( + (QColor("#f06070"), "X"), + (QColor("#50d890"), "Y"), + (QColor("#5098f0"), "Z"), +) +CAM_AXES = ( + (QColor("#f06070"), "X"), + (QColor("#50d890"), "Y"), + (QColor("#5098f0"), "Z"), +) +PLATE_GRIP = QColor("#e8606c") +PLATE_OPEN = QColor("#58a8e8") +CONNECTOR = QColor("#4a6880") +CAM_ORIGIN = QColor("#d8e858") + + +class PoseViewQt(QWidget): + """Own the 3D pose view and all of its drawing state.""" + + def __init__(self, parent=None): + super().__init__(parent) + self._localization_name = "ORB-SLAM3" + self._zoom = 1.0 + self._azimuth = AZIMUTH_DEFAULT # 观测方位角(弧度) + self._elevation = ELEVATION_DEFAULT # 观测仰角(弧度) + self._pan_x = 0.0 # 平移偏移(世界单位,视图平面) + self._pan_y = 0.0 + self._drag_last = None # 拖动起点;None=未在拖动 + self._drag_button = None + self._view_dirty = False # 视角已变,投影缓存待重算 + self._view_initialized = False + self._trajectory_point_count = 0 + self._rendered_trajectory = None + self._cached_span = 0.5 + self._cached_trajectory_points = [] + self._trajectory_dirty = False # 新轨迹点已存但投影缓存未重算 + self._last_trajectory_update = 0.0 + self._last_size = (0, 0) + self._last_zoom = 1.0 + self._position = np.zeros(3) + self._rotation = np.eye(3) + self._grip_pct = None + self._grip_gripped = False + self._display_stride = 1 # 网格降采样步长,只增不减(2 的幂) + self._fit_span = 0.5 # 世界单位 span(未除 zoom),单调外扩 + self._span_target = None # 外扩缓动目标;None=无缓动进行中 + self._span_anim_from = 0.5 + self._span_anim_start = 0.0 + self.setMinimumSize(280, 200) + + # ---- 外部接口 ---- + def update_pose(self, position, rotation, trajectory=()): + """位姿主路径:更新相机/夹爪绘制并触发重绘。""" + self._position = np.asarray(position, dtype=float).reshape(3) + self._rotation = np.asarray(rotation, dtype=float).reshape(3, 3) + if trajectory: + self._maybe_refresh_trajectory(tuple( + tuple(point) for point in trajectory)) + self.update() + + def set_grip_state(self, percentage, gripped): + """夹爪开合快照(None=未连接不绘制夹爪板)。""" + self._grip_pct = percentage + self._grip_gripped = bool(gripped) + self.update() + + def set_localization_backend(self, backend): + self._localization_name = ( + "AIKit" if str(backend).strip().lower() == "aikit" + else "ORB-SLAM3") + self._view_initialized = False + self.update() + + def reset(self): + self._zoom = 1.0 + self._azimuth = AZIMUTH_DEFAULT + self._elevation = ELEVATION_DEFAULT + self._pan_x = 0.0 + self._pan_y = 0.0 + self._view_dirty = False + self._view_initialized = False + self._trajectory_point_count = 0 + self._rendered_trajectory = None + self._cached_span = 0.5 + self._cached_trajectory_points = [] + self._trajectory_dirty = False + self._last_trajectory_update = 0.0 + self._last_zoom = 1.0 + self._display_stride = 1 + self._fit_span = 0.5 + self._span_target = None + self._span_anim_from = 0.5 + self._span_anim_start = 0.0 + self.update() + + def wheelEvent(self, event): + delta = event.angleDelta().y() + if not delta: + return + factor = 1.15 if delta > 0 else 1.0 / 1.15 + self._zoom = max(0.2, min(10.0, self._zoom * factor)) + self.update() + + # ---- 视角交互 ---- + def mousePressEvent(self, event): + if event.button() in (Qt.LeftButton, Qt.RightButton, + Qt.MiddleButton): + self._drag_last = event.pos() + self._drag_button = event.button() + self.setCursor(Qt.ClosedHandCursor) + event.accept() + + def mouseMoveEvent(self, event): + if self._drag_last is None: + return + delta = event.pos() - self._drag_last + self._drag_last = event.pos() + if self._drag_button == Qt.LeftButton: + # 抓取式旋转:向右拖→方位角增(场景随指针转向), + # 向上拖→仰角增(视点升高);仰角限 ±89° 防极点翻转 + self._azimuth += math.radians(delta.x() * 0.5) + self._elevation -= math.radians(delta.y() * 0.5) + self._elevation = min(math.radians(89.0), + max(math.radians(-89.0), + self._elevation)) + elif self._drag_button in (Qt.RightButton, Qt.MiddleButton): + width = float(self.width()) or 680.0 + height = float(self.height()) or 420.0 + unit = min(width, height) / 2.0 * 0.78 + scale = self._cached_span / unit if unit > 0.0 else 1.0 + self._pan_x += delta.x() * scale + self._pan_y -= delta.y() * scale + # 平移限幅:不让场景彻底拖出视野(reset/双击可复位) + limit = self._fit_span * 6.0 + self._pan_x = min(limit, max(-limit, self._pan_x)) + self._pan_y = min(limit, max(-limit, self._pan_y)) + self._view_dirty = True + self.update() + event.accept() + + def mouseReleaseEvent(self, event): + self._drag_last = None + self._drag_button = None + self.unsetCursor() + event.accept() + + def mouseDoubleClickEvent(self, event): + # 双击复位视角(角度/平移/缩放;轨迹数据不动) + self._azimuth = AZIMUTH_DEFAULT + self._elevation = ELEVATION_DEFAULT + self._pan_x = 0.0 + self._pan_y = 0.0 + self._zoom = 1.0 + self._view_dirty = True + self.update() + event.accept() + + # ---- 轨迹缓存 ---- + def _maybe_refresh_trajectory(self, trajectory): + now = time.perf_counter() + if (trajectory is self._rendered_trajectory + or (now - self._last_trajectory_update) + < TRAJECTORY_UPDATE_MIN_INTERVAL): + return + self._rendered_trajectory = trajectory + self._trajectory_point_count = len(trajectory) + self._last_trajectory_update = now + self._trajectory_dirty = True # 投影缓存需在下一次绘制时重算 + + # ---- 绘制 ---- + def paintEvent(self, _event): + painter = QPainter(self) + painter.fillRect(self.rect(), BG) + painter.setRenderHint(QPainter.Antialiasing) + width = float(self.width()) or 680.0 + height = float(self.height()) or 420.0 + + size_changed = (int(width), int(height)) != self._last_size + zoom_changed = abs(self._zoom - self._last_zoom) > 0.001 + full_redraw = ( + size_changed or zoom_changed or self._view_dirty + or not self._view_initialized + or self._trajectory_dirty + or self._span_target is not None # 外扩缓动期间每帧重算投影 + or self._rendered_trajectory is not None + and self._trajectory_point_count > 0 + and len(self._cached_trajectory_points) == 0 + ) + if full_redraw: + self._last_size = (int(width), int(height)) + self._last_zoom = self._zoom + self._trajectory_dirty = False + self._view_dirty = False + self._refresh_cached(width, height) + + cx = width / 2.0 + cy = height / 2.0 + unit = min(width, height) / 2.0 * 0.78 + span = self._cached_span + + # 静态层(世界轴/原点/轨迹/标题)每帧必画:Tk 版 canvas 图元持久、 + # 慢路径画一次即常驻;Qt 立即模式每次 paintEvent 全量重画,若仍 + # 只在 full_redraw 时绘制,轨迹/世界轴只会在缩放或改尺寸时闪现。 + self._draw_static(painter, width, height, cx, cy, unit, span) + self._draw_frame_axes(painter, cx, cy, unit, span) + self._draw_gripper(painter, cx, cy, unit, span) + self._view_initialized = True + + def _refresh_cached(self, width, height): + trajectory = self._rendered_trajectory + if trajectory: + display_traj = self._decimated_trajectory(trajectory) + else: + display_traj = self._position.reshape(1, 3) + all_points = np.vstack([ + display_traj, + self._position.reshape(1, 3), + np.zeros((1, 3)), + ]) + self._update_fit_span(float(np.max(np.abs(all_points)))) + self._cached_span = self._fit_span / self._zoom + cx = width / 2.0 + cy = height / 2.0 + unit = min(width, height) / 2.0 * 0.78 + self._cached_trajectory_points = [ + self._project(point, self._cached_span, cx, cy, unit) + for point in display_traj] + + def _decimated_trajectory(self, trajectory): + """锚定索引 0 的固定网格降采样,已绘制顶点索引永不滑动。 + + 与每帧 linspace 整体重抽不同:stride 只在点数超过 + ``400 × stride`` 时翻倍(2 的幂,新网格是旧网格的子集, + 顶点只减不挪);末尾始终补上最新点,让轨迹尾部跟着实时位姿。 + """ + length = len(trajectory) + while length > DISPLAY_TRAJECTORY_MAX_POINTS * self._display_stride: + self._display_stride *= 2 + if self._display_stride == 1: + return np.asarray(trajectory, dtype=float) + indices = list(range(0, length, self._display_stride)) + if indices[-1] != length - 1: + indices.append(length - 1) + return np.asarray( + [trajectory[i] for i in indices], dtype=float) + + def _update_fit_span(self, frontier): + """span 只外扩不收缩:前沿超过当前 span 的 85% 才触发一次缓动外扩。 + + 旧实现每次刷新都把 span 精确重拟合到 max(|轨迹|, |当前位姿|), + 前沿移动时整幅画面每帧跟着缩放呼吸;现在 span 平时固定, + 位姿噪声与前沿抖动不再牵动已绘制的轨迹。 + """ + if self._span_target is None: + if frontier > self._fit_span * SPAN_EXPAND_TRIGGER: + self._span_anim_from = self._fit_span + self._span_target = max( + frontier * SPAN_EXPAND_TARGET, + self._fit_span * 1.3) + self._span_anim_start = time.perf_counter() + return + elapsed = time.perf_counter() - self._span_anim_start + if elapsed >= SPAN_EXPAND_ANIM_SECONDS: + self._fit_span = self._span_target + self._span_target = None + return + eased = 1.0 - (1.0 - elapsed / SPAN_EXPAND_ANIM_SECONDS) ** 3 + self._fit_span = ( + self._span_anim_from + + (self._span_target - self._span_anim_from) * eased) + + def _project(self, point, span, cx, cy, unit): + """等距正交投影:绕 Z 转方位角、再绕视图 X 转仰角,加平移偏移。""" + x, y, z = (float(value) for value in point) + cos_a, sin_a = math.cos(self._azimuth), math.sin(self._azimuth) + cos_e, sin_e = math.cos(self._elevation), math.sin(self._elevation) + x1 = x * cos_a - y * sin_a + y1 = (x * sin_a + y * cos_a) * cos_e + z * sin_e + return QPointF( + cx + (x1 + self._pan_x) / span * unit, + cy - (y1 + self._pan_y) / span * unit) + + def _draw_static(self, painter, width, height, cx, cy, unit, span): + def project(point): + return self._project(point, span, cx, cy, unit) + + # 世界坐标轴 + 标签 + world_length = span * 0.3 + for index, (color, label) in enumerate(WORLD_AXES): + tip = np.zeros(3) + tip[index] = world_length + p0 = project((0, 0, 0)) + p1 = project(tip) + painter.setPen(QPen(color, 2.4)) + painter.drawLine(p0, p1) + label_point = project(tip * 1.3) + painter.setPen(QPen(color, 1.0)) + painter.drawText( + QRectF(label_point.x() - 12, label_point.y() - 12, + 24, 24), Qt.AlignCenter, label) + # 原点 + radius = max(2.0, unit * 0.012) + origin = project((0, 0, 0)) + painter.setPen(Qt.NoPen) + painter.setBrush(QColor("#50d890")) + painter.drawEllipse(origin, radius, radius) + # 轨迹线 + if len(self._cached_trajectory_points) >= 2: + painter.setPen(QPen(TRAJECTORY, 1.6)) + path_points = self._cached_trajectory_points + for start, end in zip(path_points, path_points[1:]): + painter.drawLine(start, end) + # 标题 + painter.setPen(TITLE) + display_count = len(self._cached_trajectory_points) + text = ( + f"{self._localization_name} Pose" + f" | Zoom:{self._zoom:.2f}x" + f" | Traj:{self._trajectory_point_count}" + + (f"→{display_count}" + if 0 < display_count < self._trajectory_point_count else "") + + "pts" + ) + painter.drawText( + QRectF(0, 2, width, 16), Qt.AlignHCenter, text) + + def _draw_frame_axes(self, painter, cx, cy, unit, span): + def project(point): + return self._project(point, span, cx, cy, unit) + + origin = self._position + rotation = self._rotation + # 位姿数据已在 ingestion 处统一旋转(正对=+Y, + # protocol.rotate_pose_z90,真机实测校准),帧轴直接按旋转 + # 矩阵列绘制即与轨迹/世界轴一致:X(红)=右、Y(绿)=夹爪正对、 + # Z(蓝)=上 + directions = ( + rotation[:, 0], + rotation[:, 1], + rotation[:, 2], + ) + length = span * 0.15 + for index, (direction, (color, label)) in enumerate( + zip(directions, CAM_AXES)): + tip = origin + direction * length + p0 = project(origin) + p1 = project(tip) + painter.setPen(QPen(color, 2.0)) + painter.drawLine(p0, p1) + # 箭头 + delta = np.array([p1.x() - p0.x(), p1.y() - p0.y()]) + norm = max(1.0, math.hypot(*delta)) + heading = delta / norm + perp = np.array([-heading[1], heading[0]]) + head = max(3.0, length / span * unit * 0.18) + left = QPointF( + p1.x() - heading[0] * head + perp[0] * head * 0.5, + p1.y() - heading[1] * head + perp[1] * head * 0.5) + right = QPointF( + p1.x() - heading[0] * head - perp[0] * head * 0.5, + p1.y() - heading[1] * head - perp[1] * head * 0.5) + painter.drawLine(p1, left) + painter.drawLine(p1, right) + # 标签 + tip_point = project(tip + direction * length * 0.15) + painter.setPen(QPen(color, 1.0)) + painter.drawText( + QRectF(tip_point.x() - 10, tip_point.y() - 10, 20, 20), + Qt.AlignCenter, label) + radius = max(2.0, unit * 0.012) + origin_p = project(origin) + painter.setPen(Qt.NoPen) + painter.setBrush(CAM_ORIGIN) + painter.drawEllipse(origin_p, radius, radius) + + def _draw_gripper(self, painter, cx, cy, unit, span): + def project(point): + return self._project(point, span, cx, cy, unit) + + if self._grip_pct is None: + return + percentage = self._grip_pct + gripped = self._grip_gripped + plate_color = PLATE_GRIP if gripped else PLATE_OPEN + plate_length = 0.20 + plate_width = 0.05 + maximum_half_gap = 0.06 + base_x = 0.10 + half_gap = maximum_half_gap * (1.0 - percentage / 100.0) + position = self._position + rotation = self._rotation + # 局部系 = 新约定(正对=+Y、X=右):基座沿 +Y 前伸,板长沿 Y, + # 两板沿 X(左右)分开 + base = position + rotation @ np.array([0, base_x, 0]) + relative_corners = np.array([ + [0, -plate_length / 2, -plate_width / 2], + [0, plate_length / 2, -plate_width / 2], + [0, plate_length / 2, plate_width / 2], + [0, -plate_length / 2, plate_width / 2], + ]) + painter.setBrush(Qt.NoBrush) + for sign in (1, -1): + plate_center = base + rotation @ np.array( + [sign * half_gap, 0, 0]) + polygon = QPolygonF([ + project(plate_center + rotation @ corner) + for corner in relative_corners]) + painter.setPen(QPen(plate_color, 1.8)) + painter.drawPolygon(polygon) + painter.setPen(QPen(plate_color, 0.6)) + painter.drawLine( + project(plate_center + rotation @ np.array( + [0, -plate_length / 2, 0])), + project(plate_center + rotation @ np.array( + [0, plate_length / 2, 0])), + ) + painter.setPen(QPen(CONNECTOR, 1.0)) + for corner_y in (-plate_length / 2, plate_length / 2): + plate_point = plate_center + rotation @ np.array( + [0, corner_y, 0]) + base_point = base + rotation @ np.array( + [0, corner_y, sign * half_gap]) + painter.drawLine(project(plate_point), project(base_point)) + crossbar = np.array([ + base + rotation @ np.array([-maximum_half_gap, 0, 0]), + base + rotation @ np.array([maximum_half_gap, 0, 0]), + ]) + painter.setPen(QPen(CONNECTOR, 1.2)) + painter.drawLine(project(crossbar[0]), project(crossbar[1])) + base_p = project(base) + radius = max(2.0, unit * 0.010) + painter.setPen(Qt.NoPen) + painter.setBrush(plate_color) + painter.drawEllipse(base_p, radius, radius) diff --git a/collector/ui/upload_dialog.py b/collector/ui/upload_dialog.py index a039ecb43326b007bd164656322db08451b41b40..c5718fedb76b78b569573deae693c10accea1a52 100755 --- a/collector/ui/upload_dialog.py +++ b/collector/ui/upload_dialog.py @@ -20,12 +20,15 @@ from config.i18n import tr from core.uploader import UploadManager from core.recording_repository import RecordingRepo from core.session_catalog import list_recordings -from core.helpers import episode_file_suffix +from core.helpers import episode_file_suffix, format_duration class UploadDialog(QDialog): """录制数据一键上传对话框。""" + # 状态图标(DB 状态 → 列表前缀) + _ICONS = {"completed": "✅", "failed": "❌", "pending": "⬜"} + # 后台删除线程 → 主线程(队列投递) _session_deleted = pyqtSignal(str, str, int) # (session_path, error, episode_index) # 后台拉取项目列表 → 主线程 @@ -59,9 +62,22 @@ class UploadDialog(QDialog): self._setup_ui() self._refresh_list() + # ⏳ 实时状态轮询:DB 只在任务结束时写状态,进行中的任务只能问管理器 + self._inflight_timer = QTimer(self) + self._inflight_timer.setInterval(settings.UPLOAD_INFLIGHT_REFRESH_MS) + self._inflight_timer.timeout.connect(self._refresh_inflight) + QTimer.singleShot(50, self._init_manager) QTimer.singleShot(200, self._refresh_projects) + def showEvent(self, event): + super().showEvent(event) + self._inflight_timer.start() + + def hideEvent(self, event): + self._inflight_timer.stop() + super().hideEvent(event) + def _init_manager(self): url = self._url_edit.text().strip() # 优先复用主窗口的上传管理器:手动上传与自动上传同一队列, @@ -216,8 +232,7 @@ class UploadDialog(QDialog): reverse=True): n = s.get("episode_index", 0) status = UploadManager.get_upload_status(s["path"], n) - icon = {"completed": "✅", "failed": "❌", - "pending": "⬜"}.get(status, "⬜") + icon = self._ICONS.get(status, "⬜") child = QTreeWidgetItem( [f"{icon} episode-{episode_file_suffix(n):03d}"]) child.setFlags(child.flags() | Qt.ItemIsUserCheckable) @@ -230,6 +245,35 @@ class UploadDialog(QDialog): self._select_all_cb.blockSignals(True) self._select_all_cb.setChecked(False) self._select_all_cb.blockSignals(False) + # 打开对话框时可能已有自动上传在跑 → 立即补上 ⏳ + self._refresh_inflight() + + def _refresh_inflight(self): + """就地更新进行中/排队中的行(不重建列表,勾选状态不受影响)。""" + if not self._manager: + return + state = self._manager.inflight() + for i in range(self._list.topLevelItemCount()): + parent = self._list.topLevelItem(i) + for j in range(parent.childCount()): + item = parent.child(j) + s = item.data(0, Qt.UserRole) + if not s: + continue + n = s.get("episode_index", 0) + label = f"episode-{episode_file_suffix(n):03d}" + info = state.get((s["path"], n)) + if info and info["state"] == "active": + item.setText(0, tr("⏳ {}(上传中 {}% · {})", label, + int(info["progress"] * 100), + format_duration(info["elapsed"]))) + elif info: + item.setText(0, tr("⏳ {}(排队中)", label)) + elif item.text(0).startswith("⏳"): + # 任务已结束(或换了管理器)→ 恢复 DB 状态图标 + status = UploadManager.get_upload_status(s["path"], n) + item.setText( + 0, f"{self._ICONS.get(status, '⬜')} {label}") def _on_item_clicked(self, item: QTreeWidgetItem, _col: int = 0): """点击任务目录行 = 展开/收起该目录下的数据;点击 episode 行 = @@ -523,6 +567,7 @@ class UploadDialog(QDialog): # 复用主窗口共享管理器时:关闭对话框只是收起界面,任务继续在 # 后台完成(进度/结果见主窗口日志);自有管理器(无主窗口父级 # 的独立使用)保持原行为:关闭即停止。 + self._inflight_timer.stop() if self._owns_manager: if self._manager: self._manager.stop() diff --git "a/collector/\344\275\277\347\224\250\346\211\213\345\206\214.md" "b/collector/\344\275\277\347\224\250\346\211\213\345\206\214.md" index ca59b4ceff22101e9df089c5bf5f180dd8b98fc3..8790f7a3eeb1839b57983292c03cd9a719b424b7 100644 --- "a/collector/\344\275\277\347\224\250\346\211\213\345\206\214.md" +++ "b/collector/\344\275\277\347\224\250\346\211\213\345\206\214.md" @@ -1830,11 +1830,14 @@ RECORD_VIDEO_ENCODER = "auto" # 自动(默认);也可填 "nvenc" | "x265 2. **会话选择区**:「全选」「刷新」及三个过滤按钮(⬆ 选中已上传 / ⬇ 选中未上传)——列表显示每段会话的任务、时长、上传状态; 3. **「⬆ 一键上传」**:逐条上传,状态栏显示「第 x/y 条」进度,完成后显示「✅ 第 x/y 条上传完成: …」→「全部完成」。 -**上传机制的三个要点**(了解即可,出问题时有用): +**上传机制的要点**(了解即可,出问题时有用): - 每段 episode 打包成一个 zip(视频已压缩,zip 不再二次压缩)POST 到服务器 `/api/v1/session/upload`;大文件单条最长允许 30 分钟; - **失败自动重试 3 次**,仍失败标记 ❌,本地文件不受影响,之后可随时重传; -- 非 HEVC 的视频在上传前会自动预压缩成 H.265(体积约为原来 7%);HEVC 视频直接传、跳过二次压缩。上传状态保存在本地 `data/pipeline.db`,重启程序不丢。 +- **上传中/排队中的段落显示 ⏳**(上传中还会带百分比与已用时),主窗口日志每 10 秒有一行进度心跳——上传看起来「没动静」时先看这两处,30 分钟读超时之内属正常; +- **先查服务器再重传**:上传前后都会查一次服务器会话列表。若上传中断(网络断/程序被杀)但服务器其实已经入库,客户端会按成功处理、**不会重复上传**一条;只有确认服务器上没有才会重传; +- **程序关闭时若还有上传没跑完**,会弹确认框(选「否」取消退出);被强杀/断电导致中断的上传,**下次启动会自动续传**(限 24 小时内、且本地文件仍在的任务;若服务器上其实已经入库,则自动判成功、不重复上传); +- 非 HEVC 的视频在上传前会自动预压缩成 H.265(体积约为原来 7%);HEVC 视频直接传、跳过二次压缩。上传状态保存在本地 `data/pipeline.db`,重启程序不丢;启动时还会顺手清理上次被强杀留下的临时 zip 文件。 ![图 8-3 上传对话框截图](docs/images/fig-8-3.png) @@ -2097,6 +2100,9 @@ data/recordings/<任务名>/ | 上传失败 / 超时 | 检查网络与服务器连通性;确认 `data/server_config.json` 地址正确(首次使用请复制 `server_config.example.json` 改名) | | 上传显示成功但服务器上看不到 | 联系管理员检查服务器导入日志(批量导入失败会静默丢弃),并提供会话名与任务名 | | 大文件上传慢 | 属正常现象,录制文件较大时上传需较长时间,请耐心等待 | +| 上传看着像卡住 | 看列表里的 ⏳(含百分比/已用时)与主窗口日志的 10 秒心跳;单条 30 分钟读超时内属正常,超时会自动重试 | +| 上传到一半程序被强杀 / 断电 | 重启程序后会自动续传(限 24 小时内且本地文件仍在);若上次其实已入库,会自动判成功、不重复上传 | +| 关闭程序时提示「有 N 个上传任务未完成」 | 选「否」可取消退出等它传完;选「是」则退出,未完成的任务下次启动自动恢复 |