// ==UserScript==
// @name         教师研修网（仅自动刷课）
// @namespace    https://ipx.yanxiu.com/
// @version      3.15.0
// @description  登录之后，它替你打开课程、自动播放、播完回列表挑下一门。必修、选修全部达标以后，还能继续把没看完的课一门门连播下去。入口有两个：浮窗上的「设置」，或脚本管理器菜单里的「自动看课 · 打开设置」。改完点「保存并应用」立即生效，不需要刷新页面。脚本仅用于减少重复点击，观看行为仍由你本人账号产生。请遵守所在单位与平台的培训规则；因使用产生的考核、学分、账号等后果由使用者自行承担。
// @author       ieeceee
// @match        https://ipx.yanxiu.com/train2/*
// @match        https://ipx.yanxiu.com/grain/*
// @match        https://ipx.yanxiu.com/cms/project/*
// @icon         https://srt-read-online.3ren.cn/basebusiness/headimg/20200711/1594463211851X00rZyPRV8-23.png
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_registerMenuCommand
// @grant        unsafeWindow
// @noframes
// @run-at       document-idle
// @license      GPL-3.0
// @tag          在线教育
// @tag          自动挂课
// @tag          教师研修网
// ==/UserScript==

/* ==UserConfig==
设置:
  静音:
    title: 自动静音
    description: 建议保持开启。浏览器不允许带声音的页面自动播放，关掉可能播不起来。
    type: checkbox
    default: true
  倍速:
    title: 2 倍速播放
    description: 这个网站不允许倍速播放（播放器里压根没有倍速选项），建议保持关闭。
    type: checkbox
    default: false
  连播:
    title: 必修、选修都达标后继续连播
    description: 开启后「自动学习」：即使必修和选修都已经达标，也会把没看完的课一门门接着播完。关掉的话，全达标就停下。
    type: checkbox
    default: true
  自动评价:
    title: 自动提交评价 / 评分（给满分）
    description: 看课中途弹出课程评价、问卷、评分或「验证」浮层时，自动给满分、填好评语并提交，让视频接着播。
    type: checkbox
    default: true
  过滑块:
    title: 自动拖动滑块
    description: 弹出滑块验证时，按人手轨迹把滑块拖到底（先快后慢、带抖动）。只处理「拖到最右」这种线性滑块；拼图缺口型不硬拖，会提示你手动对位。
    type: checkbox
    default: true
  填验证码:
    title: 自动填写验证码
    description: 验证码是算式（如 3+5=?）时直接算出来填上并提交。若是图片验证码，需要配好下面的「打码接口」才能认，否则会提示你手输。
    type: checkbox
    default: true
  打码接口:
    title: 打码接口（可选，留空则不联网）
    description: 填一个 HTTP 地址，脚本会 POST {"image":"data:image/png;base64,..."}，接口返回 {"code":"1234"} 或纯文本即可。用于识别图片验证码；不填则永远不联网，图片验证码转人工。
    type: text
    default: ""
  浮窗:
    title: 显示状态浮窗
    description: 右下角的面板，显示实时进度和「最近做了什么」。点最上面那行可以收起或展开；不想要整个面板就取消勾选这里。
    type: checkbox
    default: true
 ==/UserConfig== */

/* 教师研修网 自动看课 —— 打开「工作台」就自己开始；用法见「使用说明.html」，原因见「开发笔记.md」 */

(function () {
  "use strict";

  if (window !== top) return;

  var LOG = function () {
    console.log.apply(console, ["[自动看课]"].concat([].slice.call(arguments)));
  };

  /* ================= 一、设置 ================= */

  function cfgRaw(key, def) {
    var v = GM_getValue("设置." + key);
    return v === undefined || v === null ? def : v;
  }

  function cfg(key, def) {
    return !!cfgRaw(key, def);
  }

  function isMuted() {
    return cfg("静音", true);
  }
  /* 站点 playbackRates 是空数组，明确不允许倍速；默认关闭，关着时连 playbackRate 都不碰 */
  function speedEnabled() {
    return cfg("倍速", false);
  }
  function hudEnabled() {
    return cfg("浮窗", true);
  }

  /* ---- 观看时长：full = 播到站点提示「您已完成」；fixed = 每门最多 N 分钟 ---- */
  var DUR_MIN_DEFAULT = 30;
  var DUR_MIN_LOW = 1;
  var DUR_MIN_HIGH = 600;

  function watchMode() {
    return cfgRaw("时长模式", "full") === "fixed" ? "fixed" : "full";
  }
  /* 存进去的可能是字符串（用户手改过存储），统一在这儿收口成合法整数 */
  function watchLimitMin() {
    var n = Number(cfgRaw("时长分钟", DUR_MIN_DEFAULT));
    if (!isFinite(n) || n < DUR_MIN_LOW) n = DUR_MIN_DEFAULT;
    return Math.min(DUR_MIN_HIGH, Math.max(DUR_MIN_LOW, Math.round(n)));
  }
  /* 0 表示「不限」，调用方拿 0 就当没有截止时间 */
  function watchLimitMs() {
    return watchMode() === "fixed" ? watchLimitMin() * 60000 : 0;
  }
  /* 一门课达标后要不要自己去开下一门 */
  function autoNextAfterPass() {
    return cfg("达标续播", true);
  }

  /* ---- 必修、选修全达标后继续连播（「自动学习」总开关） ----
     全达标之后，站点上还没看完（进度不到 100%）的课继续一门门自动播完。
     「全达标」这个事实只有工作台页读得出来（考核卡片在那儿），所以由它写进 ak_pt，
     课程列表页 / 看课页读这个标记，三处对同一件事说同一句话。
     ============================================================ */

  var PT_KEY = "ak_pt";

  function autoPlayAfterPass() {
    return cfg("连播", true);
  }

  function setAllPassed(on) {
    try {
      GM_setValue(PT_KEY, !!on);
    } catch (e) {}
  }

  function isAllPassed() {
    return !!GM_getValue(PT_KEY);
  }

  /* 「连播模式」= 考核已全达标 + 用户开着连播 */
  function playThrough() {
    return autoPlayAfterPass() && isAllPassed();
  }

  /* ================= 二、右下角小浮窗 ================= */

  var VERSION = "3.15.0"; /* 必须与头部 @version 一致，「复制状态」报的就是它 */

  var HUD = {
    root: null,
    dot: null,
    line: null,
    head: null,
    body: null,
    arrow: null,
    live: null,
    log: null,
    detail: null,
    toast: null,
    runBtn: null,
    events: [],
    toastTimer: null,
  };

  var COLORS = {
    running: "#378ADD",
    skip: "#1D9E75",
    done: "#1D9E75",
    error: "#E24B4A",
    idle: "#8A94A6",
  };

  function nowText() {
    var d = new Date();
    var p = function (n) {
      return (n < 10 ? "0" : "") + n;
    };
    return p(d.getHours()) + ":" + p(d.getMinutes()) + ":" + p(d.getSeconds());
  }

  function isPanelOpen() {
    var v = GM_getValue("ak_hud_open");
    return v === undefined || v === null ? true : !!v;
  }

  function setPanelOpen(isOpen) {
    GM_setValue("ak_hud_open", !!isOpen);
    if (HUD.body) HUD.body.style.display = isOpen ? "block" : "none";
    if (HUD.arrow) HUD.arrow.textContent = isOpen ? "▴ 收起" : "▾ 展开";
  }

  function buildHud() {
    if (!hudEnabled()) return;
    if (HUD.root && document.body && document.body.contains(HUD.root)) return;
    if (!document.body) return;

    var root = document.createElement("div");
    root.style.cssText =
      "position:fixed;right:14px;bottom:14px;z-index:2147483647;" +
      'font:13px/1.65 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;color:#042C53';

    var toast = document.createElement("div");
    toast.style.cssText =
      "position:absolute;right:0;bottom:100%;margin-bottom:8px;max-width:280px;" +
      "background:#042C53;color:#fff;border-radius:9px;padding:7px 11px;font-size:12px;" +
      "line-height:1.55;box-shadow:0 4px 14px rgba(0,0,0,.22);opacity:0;transform:translateY(6px);" +
      "transition:opacity .25s,transform .25s;pointer-events:none;word-break:break-all";

    var card = document.createElement("div");
    card.style.cssText =
      "background:#fff;border:1px solid #B5D4F4;border-radius:12px;" +
      "box-shadow:0 6px 20px rgba(0,0,0,.14);overflow:hidden;max-width:300px";

    var head = document.createElement("div");
    head.style.cssText =
      "display:flex;align-items:center;gap:8px;padding:10px 13px;" +
      "cursor:pointer;user-select:none";

    var dot = document.createElement("span");
    dot.style.cssText =
      "width:8px;height:8px;border-radius:50%;background:#378ADD;flex:0 0 auto";

    var line = document.createElement("span");
    line.style.cssText =
      "font-weight:500;white-space:nowrap;overflow:hidden;text-overflow:ellipsis";

    var arrow = document.createElement("span");
    arrow.style.cssText =
      "margin-left:auto;color:#6E9BD1;font-size:11px;flex:0 0 auto;white-space:nowrap";

    head.appendChild(dot);
    head.appendChild(line);
    head.appendChild(arrow);

    var body = document.createElement("div");
    body.style.cssText = "padding:0 13px 12px;border-top:1px solid #E6F1FB";

    var live = document.createElement("div");
    live.style.cssText =
      "padding:9px 0 2px;color:#0C447C;font-size:12.5px;" +
      "white-space:pre-line;word-break:break-all";

    var log = document.createElement("div");
    log.style.cssText =
      "display:none;margin-top:8px;padding-top:8px;border-top:1px dashed #E6F1FB;" +
      "color:#7A8798;font-size:11.5px;line-height:1.6;white-space:pre-line;word-break:break-all";

    var detail = document.createElement("div");
    detail.style.cssText =
      "display:none;margin-top:8px;padding:8px 10px;border-radius:8px;" +
      "font-size:12px;white-space:pre-wrap;word-break:break-all";

    var btns = document.createElement("div");
    btns.style.cssText = "display:flex;gap:8px;margin-top:10px";

    var b0 = document.createElement("button");
    b0.textContent = "回到工作台";
    b0.style.cssText = btnStyle("#1D9E75", "#ffffff");
    b0.onclick = function () {
      var back = backUrl();
      if (back) location.href = back;
    };

    var b1 = document.createElement("button");
    b1.textContent = "重新开始";
    b1.style.cssText = btnStyle("#E6F1FB", "#0C447C");
    b1.onclick = function () {
      location.reload();
    };

    var b2 = document.createElement("button");
    b2.textContent = "复制状态";
    b2.style.cssText = btnStyle("#F1EFE8", "#5F5E5A");
    b2.onclick = function () {
      copyText(diagnosticsText());
    };

    var b3 = document.createElement("button");
    b3.textContent = "刷新学分";
    b3.style.cssText = btnStyle("#E6F1FB", "#0C447C");
    b3.onclick = function () {
      logEvent("正在刷新学分…");
      fetchCredits(true).then(function (d) {
        logEvent(
          d
            ? "学分已刷新：" + creditScoreText()
            : "学分没拉回来：" + (creditError || "未知原因"),
        );
      });
    };

    /* 第一行只放「设置」和「启动 / 停止」：这两个是最高频的操作，别跟其他按钮挤一起 */
    var btns0 = document.createElement("div");
    btns0.style.cssText = "display:flex;gap:8px;margin-top:10px";

    var bSet = document.createElement("button");
    bSet.textContent = "⚙ 设置";
    bSet.style.cssText = btnStyle("#E6F1FB", "#0C447C");
    bSet.onclick = function () {
      openSettings();
    };

    var bRun = document.createElement("button");
    bRun.textContent = isRunning() ? "⏸ 停止" : "▶ 启动";
    bRun.style.cssText = btnStyle(
      isRunning() ? "#FCEBEB" : "#E6F6EE",
      isRunning() ? "#A32D2D" : "#0F6E4A",
    );
    bRun.onclick = function () {
      if (isRunning()) stopWork("手动停止");
      else startWork();
      refreshRunUi();
    };

    btns0.appendChild(bSet);
    btns0.appendChild(bRun);

    /* 「回到工作台」只在被站点甩到「项目首页」时才出现，平时不占地方 */
    if (isProjectHome() && backUrl()) btns.appendChild(b0);
    btns.appendChild(b1);
    btns.appendChild(b2);
    btns.appendChild(b3);

    body.appendChild(live);
    body.appendChild(log);
    body.appendChild(detail);
    body.appendChild(btns0);
    body.appendChild(btns);

    /* 打赏入口单独一行细字：按钮行三个 flex:1 已占满 300px，再挤会看不清 */
    var donate = document.createElement("div");
    donate.textContent = "☕ 请作者喝杯蜜雪冰城";
    donate.style.cssText =
      "margin-top:9px;text-align:center;font-size:11.5px;color:#7A8798;" +
      "cursor:pointer;user-select:none";
    donate.onclick = function () {
      openDonate();
    };
    donate.onmouseenter = function () {
      donate.style.color = "#BA7517";
    };
    donate.onmouseleave = function () {
      donate.style.color = "#7A8798";
    };
    body.appendChild(donate);

    card.appendChild(head);
    card.appendChild(body);
    root.appendChild(toast);
    root.appendChild(card);
    document.body.appendChild(root);

    head.onclick = function () {
      setPanelOpen(!isPanelOpen());
    };
    head.onmouseenter = function () {
      head.style.background = "#F2F8FF";
    };
    head.onmouseleave = function () {
      head.style.background = "transparent";
    };

    HUD.root = root;
    HUD.dot = dot;
    HUD.line = line;
    HUD.head = head;
    HUD.body = body;
    HUD.arrow = arrow;
    HUD.live = live;
    HUD.log = log;
    HUD.detail = detail;
    HUD.toast = toast;
    HUD.runBtn = bRun;

    setPanelOpen(isPanelOpen());
  }

  function btnStyle(bg, fg) {
    return (
      "flex:1;padding:6px 10px;border:0;border-radius:8px;background:" +
      bg +
      ";color:" +
      fg +
      ';font:12px -apple-system,"PingFang SC",sans-serif;cursor:pointer'
    );
  }

  function setStatus(text, tone) {
    buildHud();
    if (tone === "error") setPanelOpen(true);
    if (!HUD.line) return;
    HUD.line.textContent = text;
    HUD.dot.style.background = COLORS[tone] || COLORS.running;
  }

  function setLive(text) {
    buildHud();
    if (HUD.live) HUD.live.textContent = text || "";
  }

  function logEvent(text) {
    buildHud();
    HUD.events.push(nowText() + "  " + text);
    while (HUD.events.length > 3) HUD.events.shift();
    if (HUD.log) {
      HUD.log.textContent = HUD.events.join("\n");
      HUD.log.style.display = "block";
    }
    showToast(text);
    LOG(text);
  }

  function setDetail(text, isError) {
    buildHud();
    if (!HUD.detail) return;
    if (!text) {
      HUD.detail.style.display = "none";
      return;
    }
    if (isError) setPanelOpen(true);
    HUD.detail.textContent = text;
    HUD.detail.style.background = isError ? "#FCEBEB" : "#E6F1FB";
    HUD.detail.style.color = isError ? "#A32D2D" : "#0C447C";
    HUD.detail.style.display = "block";
  }

  function setError(text) {
    setDetail(text, true);
  }

  function showToast(text) {
    if (!HUD.toast) return;
    HUD.toast.textContent = text;
    HUD.toast.style.opacity = "1";
    HUD.toast.style.transform = "translateY(0)";
    if (HUD.toastTimer) clearTimeout(HUD.toastTimer);
    HUD.toastTimer = setTimeout(function () {
      HUD.toast.style.opacity = "0";
      HUD.toast.style.transform = "translateY(6px)";
    }, 6000);
  }

  function diagnosticsText() {
    var d = new Date();
    var p = function (n) {
      return (n < 10 ? "0" : "") + n;
    };
    var out = [
      "教师研修网 自动看课 v" + VERSION,
      "时间：" +
        d.getFullYear() +
        "-" +
        p(d.getMonth() + 1) +
        "-" +
        p(d.getDate()) +
        " " +
        nowText(),
      "页面：" + location.href,
      "状态：" + (HUD.line ? HUD.line.textContent : ""),
    ];
    if (HUD.live && HUD.live.textContent)
      out.push("实时：\n" + HUD.live.textContent);
    if (
      HUD.detail &&
      HUD.detail.style.display !== "none" &&
      HUD.detail.textContent
    ) {
      out.push("说明：\n" + HUD.detail.textContent);
    }
    if (HUD.events.length) out.push("最近动态：\n" + HUD.events.join("\n"));
    return out.join("\n");
  }

  function copyText(text) {
    function fallbackCopy() {
      try {
        var ta = document.createElement("textarea");
        ta.value = text;
        ta.style.cssText = "position:fixed;left:-9999px;top:0";
        document.body.appendChild(ta);
        ta.select();
        var ok = document.execCommand("copy");
        document.body.removeChild(ta);
        return !!ok;
      } catch (e) {
        return false;
      }
    }
    function finish(ok) {
      showToast(
        ok
          ? "状态已复制，粘贴给开发者就能定位问题"
          : "复制失败，请直接截图这个面板",
      );
    }
    try {
      if (navigator.clipboard && navigator.clipboard.writeText) {
        navigator.clipboard.writeText(text).then(
          function () {
            finish(true);
          },
          function () {
            finish(fallbackCopy());
          },
        );
        return;
      }
    } catch (e) {}
    finish(fallbackCopy());
  }

  /* ================= 三·1、打赏 ================= */

  /* 赞赏码（Atroswnet）：base64 在文件末尾「九、启动」那节。
     这张码写死在脚本里，界面上不提供任何更换 / 上传 / 清除入口 —— 要换只能改代码。 */
  var DONATE_QR = "";
  var DONATE_QR_LABEL = "Atroswnet 的赞赏码";

  /* 内嵌图被 CSP 拦过一次就记住，之后直接显示提示；blockedURI 是 "data"（无冒号），用 /^data:?/ 兼容 */
  var donateCspBlocked = false;
  try {
    document.addEventListener("securitypolicyviolation", function (e) {
      if (!e || !e.blockedURI) return;
      if (!/^data:?/.test(String(e.blockedURI))) return;
      if (/img-src/.test(e.violatedDirective || "")) donateCspBlocked = true;
    });
  } catch (e) {}

  var donateMask = null;
  var donateWrap = null;
  var donateEsc = null;

  function donateBtn(text, bg, fg, size) {
    var b = document.createElement("button");
    b.textContent = text;
    b.style.cssText =
      "padding:4px 9px;border:0;border-radius:7px;background:" +
      bg +
      ";color:" +
      fg +
      ";font:" +
      (size || "11.5px") +
      ' -apple-system,"PingFang SC",sans-serif;cursor:pointer;white-space:nowrap';
    return b;
  }

  /* 只画「一张图 + 名字」，没有按钮、不收拖拽：
     赞赏码是作者本人的，不给使用者留任何替换的口子 */
  function donateBox() {
    var box = document.createElement("div");
    box.style.cssText =
      "width:100%;border:1px solid #B5D4F4;border-radius:11px;" +
      "padding:11px;text-align:center;background:#fff";

    var img = document.createElement("img");
    img.alt = DONATE_QR_LABEL;
    img.style.cssText =
      "width:100%;max-width:240px;border-radius:8px;display:block;" +
      "margin:0 auto;background:#F7FAFF";

    var note = document.createElement("div");
    note.textContent = "赞赏码显示不出来\n（这个页面限制了图片加载）";
    note.style.cssText =
      "display:none;padding:34px 8px;border:1px dashed #B5D4F4;border-radius:8px;" +
      "background:#F7FAFF;color:#7A8798;font-size:11.5px;line-height:1.7;" +
      "white-space:pre-line";

    var fail = function () {
      img.style.display = "none";
      note.style.display = "block";
    };

    if (!DONATE_QR || donateCspBlocked) {
      /* 没内嵌图，或这个页面拦过 data: 图：直说显示不出来，不做任何兜底替换 */
      fail();
    } else {
      img.onerror = fail;
      /* 万一某个浏览器拦掉图时不派发 error，只把 naturalWidth 留成 0 */
      img.onload = function () {
        if (!img.naturalWidth) fail();
      };
      img.src = DONATE_QR;
      /* 再兜一道：2 秒后还是 0 像素就认为没出来 */
      setTimeout(function () {
        if (img.complete && img.naturalWidth === 0) fail();
      }, 2000);
    }

    box.appendChild(img);
    box.appendChild(note);

    var name = document.createElement("div");
    name.textContent = DONATE_QR_LABEL;
    name.style.cssText = "margin-top:8px;font-weight:500";
    box.appendChild(name);

    return box;
  }

  function renderDonate() {
    if (!donateWrap) return;
    donateWrap.textContent = "";
    donateWrap.appendChild(donateBox());
  }

  function closeDonate() {
    if (donateEsc) {
      document.removeEventListener("keydown", donateEsc);
      donateEsc = null;
    }
    if (donateMask && donateMask.parentNode) {
      donateMask.parentNode.removeChild(donateMask);
    }
    donateMask = null;
    donateWrap = null;
  }

  function openDonate() {
    closeDonate();
    if (!document.body) return;

    /* 与浮窗同为最大 z-index，靠「后插进 DOM」压在浮窗上面 */
    var mask = document.createElement("div");
    mask.style.cssText =
      "position:fixed;left:0;top:0;right:0;bottom:0;z-index:2147483647;" +
      "background:rgba(4,44,83,.42);display:flex;align-items:center;" +
      "justify-content:center;padding:14px";
    mask.onclick = function (e) {
      if (e.target === mask) closeDonate();
    };

    var card = document.createElement("div");
    card.style.cssText =
      "width:340px;max-width:100%;max-height:86vh;overflow:auto;background:#fff;" +
      "border-radius:14px;box-shadow:0 18px 50px rgba(4,44,83,.34);" +
      'font:13px/1.65 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;color:#042C53';

    var head = document.createElement("div");
    head.style.cssText = "padding:15px 17px;background:#0C447C;color:#fff";
    var h = document.createElement("div");
    h.textContent = "请作者喝杯蜜雪冰城";
    h.style.cssText = "font-size:15px;font-weight:500";
    var sub = document.createElement("div");
    sub.textContent = "脚本免费，打赏只是让它能继续被维护";
    sub.style.cssText = "margin-top:4px;font-size:11.5px;opacity:.88";
    head.appendChild(h);
    head.appendChild(sub);

    var body = document.createElement("div");
    body.style.cssText = "padding:15px 17px 17px";

    var tip = document.createElement("div");
    tip.textContent =
      "这不是付费墙 —— 所有功能对所有人开放，没有任何「打赏才能用」的东西。\n" +
      "不打算打赏也完全没关系，关掉这个框就行。";
    tip.style.cssText =
      "padding:10px 12px;border-radius:9px;background:#E6F1FB;color:#0C447C;" +
      "font-size:12px;line-height:1.7;white-space:pre-line;margin-bottom:13px";
    body.appendChild(tip);

    var wrap = document.createElement("div");
    wrap.style.cssText = "display:flex;justify-content:center";
    body.appendChild(wrap);

    var foot = document.createElement("div");
    foot.style.cssText =
      "display:flex;justify-content:flex-end;margin-top:14px";
    var close = donateBtn("关闭", "#0C447C", "#ffffff", "12px");
    close.style.padding = "6px 14px";
    close.onclick = function () {
      closeDonate();
    };
    foot.appendChild(close);
    /* 按钮行必须挂 body：只有 body 带 17px 内边距，挂 card 上会紧贴右下角 */
    body.appendChild(foot);

    card.appendChild(head);
    card.appendChild(body);
    mask.appendChild(card);
    document.body.appendChild(mask);

    donateMask = mask;
    donateWrap = wrap;
    renderDonate();

    donateEsc = function (e) {
      if (e.key === "Escape" || e.keyCode === 27) closeDonate();
    };
    document.addEventListener("keydown", donateEsc);
  }

  /* ================= 三·2、打断弹窗：评价 / 评分 / 验证 ================= */

  /* 站点混用两套 UI 库：iView（.scoring-wrapper / .rate-item / .ivu-btn）和 Element
     （.el-dialog / .el-rate / .el-button），另外还有零散的「继续计时」提醒。
     它们都表现为「视频停了 + 一个浮层」，不处理就会卡在「画面卡住 → 重试播放」的死循环里。

     处理策略：
       1. 只认带「评价 / 评分 / 问卷 / 满意度 / 验证」字样、**且有提交按钮或滑块**的浮层，
          别的弹窗一概不碰（避免误点站点公告、广告）；
       2. 星级点最后一颗 = 满分；问卷单选优先「非常满意 / 满意 / 是」，没有就选第一个；
          文本框填一句中性好评；
       3. 验证交给下面「三·3」：滑块按人手轨迹拖、算式验证码直接算，
          拼图滑块 / 未配接口的图片验证码才提示手动；
       4. 同一个弹窗最多点 2 次、30 秒冷静期，防止和站点互相顶。 */

  var EVAL_WORDS =
    /(评价|评语|评分|打分|问卷|满意度|反馈|验证|继续计时|学习情况)/;
  var EVAL_GOOD = /(非常满意|很满意|满意|符合|同意|已完成|学完)/;
  var EVAL_BAD = /(取消|关闭|暂不|跳过|以后再说|下次再说)/;
  var EVAL_COMMENT = "课程内容充实，讲解清晰，对教学很有帮助，收获很大。";

  var EVAL_REC_KEY = "ak_eval";
  var EVAL_MAX_TRIES = 2;
  var EVAL_QUIET_MS = 30 * 1000; /* 同一弹窗两次点击的最小间隔 */
  var EVAL_HANDLED_MS = 8 * 1000; /* 刚处理过，这段时间内别重复进 */

  var evalTimer = null;
  var evalBusy = false;
  var evalLastSig = "";
  var evalLastTs = 0;

  function autoEvalOn() {
    return cfg("自动评价", true);
  }

  function elShown(el) {
    if (!el) return false;
    if (
      el.style &&
      (el.style.display === "none" || el.style.visibility === "hidden")
    )
      return false;
    /* fixed 定位的浮层 offsetParent 也是 null，所以再用尺寸兜一道 */
    if (el.offsetParent) return true;
    return !!(el.getClientRects && el.getClientRects().length);
  }

  /* 按优先级列浮层：先站点自己那几套，再通用的 dialog / modal，
     最后是滑块 / 验证码这类可能不在弹窗里的独立浮层（仍要过关键词 + 有控件才动） */
  var EVAL_LAYERS = [
    ".scoring-wrapper",
    ".alarmClock-wrapper",
    ".el-dialog__wrapper",
    ".el-message-box__wrapper",
    ".ivu-modal-wrap",
    ".ant-modal-wrap",
    "[class*=modal-wrap]",
    "[class*=dialog-wrapper]",
    "[role=dialog]",
    "[class*=slider-verify]",
    "[class*=verify-wrap]",
    "[class*=verify-box]",
    "[class*=captcha]",
  ];

  function evalLayer() {
    for (var i = 0; i < EVAL_LAYERS.length; i++) {
      var els = document.querySelectorAll(EVAL_LAYERS[i]);
      for (var j = 0; j < els.length; j++) {
        if (elShown(els[j])) return els[j];
      }
    }
    return null;
  }

  function evalText(root) {
    return (root && root.textContent ? root.textContent : "")
      .replace(/\s+/g, " ")
      .trim();
  }

  /* iView 的评分要先 mousemove 才有预览效果，所以这里两个事件都发 */
  function evalClick(el) {
    if (!el) return false;
    try {
      el.dispatchEvent(new Event("mousemove", { bubbles: true }));
    } catch (e) {}
    try {
      el.dispatchEvent(new MouseEvent("mouseover", { bubbles: true }));
    } catch (e) {}
    try {
      el.click();
      return true;
    } catch (e) {
      return false;
    }
  }

  /* 点最后一颗星 = 满星；返回星数（0 表示没找到评分控件） */
  function evalStars(root) {
    var sels = [".rate-item", ".el-rate__item", ".ivu-rate-item"];
    for (var i = 0; i < sels.length; i++) {
      var its = root.querySelectorAll(sels[i]);
      if (!its.length) continue;
      evalClick(its[its.length - 1]);
      return its.length;
    }
    var loose = root.querySelectorAll("[class*=star]");
    if (loose.length) {
      evalClick(loose[loose.length - 1]);
      return loose.length;
    }
    return 0;
  }

  function elChecked(el) {
    var c = " " + (el.className || "") + " ";
    if (/ (is-checked|is-active|checked|active) /.test(c)) return true;
    var inp =
      el.querySelector &&
      el.querySelector("input[type=radio],input[type=checkbox]");
    return !!(inp && inp.checked);
  }

  /* 单选题：一组选项里挑「满意」类，没有就挑第一个；已选过的组不动。
     多选按同样规则勾一个（问卷多选通常允许只选一项，全勾反而像刷）。 */
  function evalChoices(root) {
    var sels = [
      ".el-radio",
      ".ivu-radio-wrapper",
      ".ant-radio-wrapper",
      "[class*=radio-item]",
      "[class*=radio]",
    ];
    var list = [];
    for (var i = 0; i < sels.length; i++) {
      var got = root.querySelectorAll(sels[i]);
      if (got.length) {
        list = [].slice.call(got);
        break;
      }
    }
    if (!list.length) return 0;

    /* 按父节点分组：同一个题目下的选项互为兄弟 */
    var parents = [];
    var groups = [];
    for (var k = 0; k < list.length; k++) {
      var p = list[k].parentNode;
      var idx = parents.indexOf(p);
      if (idx < 0) {
        parents.push(p);
        groups.push([]);
        idx = groups.length - 1;
      }
      groups[idx].push(list[k]);
    }

    var picked = 0;
    for (var g = 0; g < groups.length; g++) {
      var grp = groups[g];
      var done = false;
      for (var m = 0; m < grp.length; m++) {
        if (elChecked(grp[m])) {
          done = true;
          break;
        }
      }
      if (done) continue;

      var target = null;
      for (var n = 0; n < grp.length; n++) {
        if (EVAL_GOOD.test(evalText(grp[n]))) {
          target = grp[n];
          break;
        }
      }
      if (!target) target = grp[0];
      evalClick(target);
      picked++;
    }
    return picked;
  }

  function evalIsCaptchaField(el) {
    var ph = (el.getAttribute && el.getAttribute("placeholder")) || "";
    var nm = (el.getAttribute && el.getAttribute("name")) || "";
    return /验证码|验证|答案|captcha/i.test(ph + " " + nm);
  }

  /* 直接改 value 不会被 Vue / React 的双向绑定认到，必须走原型 setter 再派发 input */
  function evalSetValue(el, val) {
    var proto =
      el.tagName === "TEXTAREA"
        ? HTMLTextAreaElement.prototype
        : HTMLInputElement.prototype;
    try {
      var d = Object.getOwnPropertyDescriptor(proto, "value");
      if (d && d.set) d.set.call(el, val);
      else el.value = val;
    } catch (e) {
      el.value = val;
    }
    try {
      el.dispatchEvent(new Event("input", { bubbles: true }));
    } catch (e) {}
    try {
      el.dispatchEvent(new Event("change", { bubbles: true }));
    } catch (e) {}
    /* 有些组件只监听用户输入，补一个 keyup */
    try {
      el.dispatchEvent(new KeyboardEvent("keyup", { bubbles: true }));
    } catch (e) {}
  }

  function evalFillText(root) {
    var areas = root.querySelectorAll(
      "textarea, .el-textarea__inner, input[type=text], input:not([type])",
    );
    var filled = 0;
    for (var i = 0; i < areas.length; i++) {
      var el = areas[i];
      if (!elShown(el)) continue;
      if (evalIsCaptchaField(el)) continue; /* 验证码不猜 */
      if (el.readOnly || el.disabled) continue;
      if (String(el.value || "").trim()) continue; /* 填过的不覆盖 */
      evalSetValue(el, EVAL_COMMENT);
      filled++;
    }
    return filled;
  }

  /* 找提交按钮：只认明确动作词，取消/关闭一律跳过 */
  function evalSubmitBtn(root) {
    var btns = root.querySelectorAll(
      "button, .el-button, .ivu-btn, .ant-btn, [class*=btn]",
    );
    var best = null;
    var bestRank = 99;
    var bestPrimary = false;
    for (var i = 0; i < btns.length; i++) {
      var b = btns[i];
      if (!elShown(b)) continue;
      if (b.disabled) continue;
      var cls = " " + (b.className || "") + " ";
      if (/ (is-disabled|ivu-btn-disabled|ant-btn-disabled) /.test(cls)) continue;
      var t = evalText(b).slice(0, 10);
      if (!t || EVAL_BAD.test(t)) continue;

      var rank = 99;
      if (t.indexOf("提交") !== -1) rank = 0;
      else if (/^(确定|确认)/.test(t)) rank = 1;
      else if (/^(完成|保存)/.test(t)) rank = 2;
      else if (/^(下一步|继续|开始学习|我知道了|知道了|好的|OK)/i.test(t))
        rank = 3;
      if (rank === 99) continue;

      var primary = /primary/.test(cls);
      if (rank < bestRank || (rank === bestRank && primary && !bestPrimary)) {
        best = b;
        bestRank = rank;
        bestPrimary = primary;
      }
    }
    return best;
  }

  /* 需要人来做的部分（验证码 / 滑块）：先交给 capTrySolve 试，试不动再交回给人。
     返回的字符串会直接拼进提示语，所以要短、要是名词。 */
  function evalHumanReason(root) {
    if (capSlider(root)) return "滑块";
    var t = evalText(root);
    if (/验证码|验证失败/.test(t)) return "验证码";
    if (/拖动滑块|请拖动|短信验证|扫码验证|安全验证|滑块/.test(t)) return "验证";
    if (
      root.querySelector(
        "img[src*=captcha], [class*=captcha], [class*=slider-verify], [class*=verify-wrap], [class*=geetest]",
      )
    )
      return "验证";
    return "";
  }

  function evalSigOf(root) {
    return evalText(root).slice(0, 100);
  }

  function evalRec() {
    var r = GM_getValue(EVAL_REC_KEY);
    return r && typeof r === "object" ? r : {};
  }

  function evalCanTry(sig) {
    var e = evalRec()[sig];
    if (!e) return true;
    if (Date.now() - (e.ts || 0) > EVAL_QUIET_MS) return true; /* 过了冷静期重新计数 */
    return (e.n || 0) < EVAL_MAX_TRIES;
  }

  function evalMark(sig) {
    var r = evalRec();
    var now = Date.now();
    var e = r[sig];
    if (!e || now - (e.ts || 0) > EVAL_QUIET_MS) e = { n: 0, ts: now };
    e.n = (e.n || 0) + 1;
    e.ts = now;
    r[sig] = e;

    /* 只留最近 5 条，别把本地存储塞满 */
    var keys = [];
    for (var k in r) {
      if (Object.prototype.hasOwnProperty.call(r, k)) keys.push(k);
    }
    if (keys.length > 5) {
      keys.sort(function (a, b) {
        return (r[a].ts || 0) - (r[b].ts || 0);
      });
      delete r[keys[0]];
    }
    try {
      GM_setValue(EVAL_REC_KEY, r);
    } catch (err) {}
  }

  /* 返回 "done"（已处理）/ "human"（要人接手）/ ""（没东西可做） */
  function handleEvalLayer() {
    if (!autoEvalOn()) return "";
    if (evalBusy) return "";
    if (Date.now() - evalLastTs < EVAL_HANDLED_MS) return "";

    /* 「继续计时」提醒没有表单，点掉就行 —— 留着它会一直暂停视频 */
    var alarm = document.querySelector(".alarmClock-wrapper");
    if (alarm && elShown(alarm)) {
      evalClick(alarm);
      evalLastTs = Date.now();
      logEvent("弹出了「继续计时」提醒，已点掉");
      return "done";
    }

    var root = evalLayer();
    if (!root) return "";

    var text = evalText(root);
    if (!EVAL_WORDS.test(text)) return "";

    /* 没有提交按钮 → 多半不是评价表单，别乱点。
       但滑块验证是「松手即校验」、根本没有提交按钮，所以有滑块也放行。 */
    var submit = evalSubmitBtn(root);
    if (!submit && !capSlider(root)) return "";

    var sig = evalSigOf(root);

    var human = evalHumanReason(root);
    if (human) {
      /* 先自己试试：滑块按人手轨迹拖、算式验证码直接算。
         搞不定才交回给人，并把「为什么」写清楚，别让人猜。 */
      if (!evalCanTry("cap:" + sig)) {
        if (evalLastSig !== sig) {
          evalLastSig = sig;
          setDetail(
            "这个" + human + "已经试了 " + EVAL_MAX_TRIES + " 次还没过，先停手了。\n" +
              "站点可能加了验证强度，请手动过一下再让它继续。",
            true,
          );
          logEvent(human + "连试 " + EVAL_MAX_TRIES + " 次未过，转手动");
        }
        return "human";
      }

      var cap = capTrySolve(root);
      if (cap && cap.ok) {
        evalMark("cap:" + sig);
        evalLastSig = sig;
        evalLastTs = Date.now();
        logEvent("碰到" + human + "，" + cap.msg);
        setDetail("碰到" + human + "，脚本已自动处理：" + cap.msg + "\n视频马上接着播。", false);
        setTimeout(function () {
          try {
            tryPlay();
          } catch (e) {}
        }, 1200);
        return "done";
      }

      if (evalLastSig !== sig) {
        evalLastSig = sig;
        setDetail(
          "弹出了" +
            human +
            "，这个得你手动过一下。" +
            (cap && cap.msg ? "\n" + cap.msg : "") +
            "\n过完视频会接着播。",
          true,
        );
        logEvent("弹出了" + human + "：" + ((cap && cap.msg) || "等你手动处理"));
      }
      return "human";
    }

    if (!evalCanTry(sig)) {
      if (evalLastSig !== sig) {
        evalLastSig = sig;
        setDetail(
          "这个弹窗点了 " +
            EVAL_MAX_TRIES +
            " 次还没关掉，需要你看一眼。\n" +
            "多半是有必填项没填对，或者提交被站点驳回了。",
          true,
        );
        logEvent("评价弹窗点 " + EVAL_MAX_TRIES + " 次仍未关闭，转为手动");
      }
      return "human";
    }

    evalBusy = true;
    try {
      var stars = evalStars(root);
      var picked = evalChoices(root);
      var filled = evalFillText(root);
      var btn = evalSubmitBtn(root);

      evalMark(sig);
      evalLastSig = sig;
      evalLastTs = Date.now();
      if (btn) evalClick(btn);

      var what = [];
      if (stars) what.push("评分 " + stars + " 星（满）");
      if (picked) what.push("问卷 " + picked + " 题");
      if (filled) what.push("评语 " + filled + " 处");
      logEvent(
        what.length
          ? "弹出了评价表单，" + what.join(" / ") + "，已提交"
          : "弹出了提示框，已点掉",
      );

      /* 视频多半就是被这个浮层顶停的，处理完主动推一把 */
      setTimeout(function () {
        try {
          tryPlay();
        } catch (e) {}
      }, 600);
      return "done";
    } finally {
      evalBusy = false;
    }
  }

  function startEvalWatch() {
    if (evalTimer) clearInterval(evalTimer);
    evalTimer = setInterval(function () {
      try {
        if (!isRunning()) return;
        handleEvalLayer();
      } catch (e) {}
    }, 2500);
  }

  /* ================= 三·3、验证：滑块自动拖动 / 验证码自动填写 =================

     站点拦人有两种：
       ① 拖动滑块（线性「拖到最右」，或拼图「把缺口对上」）；
       ② 图文验证码（多半是「3 + 5 = ?」这种算式，偶尔是歪扭的字母数字图片）。

     做法：
       · 线性滑块：按真人节奏推一条轨迹（先快后慢 + 轻微抖动 + 1px 回弹），
         pointer / mouse 事件都发，松手后交给站点自己的校验；
       · 算式验证码：直接把浮层文字里的算式算出来填进去（支持 + - × ÷ 和中文数字）；
       · 图片验证码：只有填了「打码接口」才会去识别，否则不瞎猜；
       · 拼图缺口型滑块：不硬拖 —— 缺口位置得人眼找，拖错还涨验证强度，直接请你手动。

     每个弹窗最多试 2 次（复用 EVAL_MAX_TRIES）：拖错两次站点大概率会加难度或锁几分钟，
     比手点一次慢得多，见好就收。 */

  function capSliderOn() {
    return cfg("过滑块", true);
  }

  function capCodeOn() {
    return cfg("填验证码", true);
  }

  function capOcrUrl() {
    var v = cfgRaw("打码接口", "");
    return typeof v === "string" ? v.trim() : "";
  }

  var CAP_HANDLE_SEL =
    ".verify-move-block, .nc_iconfont.btn_slide, .geetest_slider_button, " +
    ".slider-btn, [class*=move-block], [class*=slide-btn], [class*=slider-btn], " +
    "[class*=sliderBtn], [class*=slider-handle], [class*=drag-handle], " +
    "[class*=verify-slider-block], [class*=btn-slide]";

  /* 找滑块把手 + 量轨道长度；找不到返回 null */
  function capSlider(root) {
    if (!root) return null;
    var sels = CAP_HANDLE_SEL.split(",");
    var handle = null;
    for (var i = 0; i < sels.length && !handle; i++) {
      var got = root.querySelectorAll(sels[i].trim());
      for (var j = 0; j < got.length; j++) {
        if (elShown(got[j])) {
          handle = got[j];
          break;
        }
      }
    }
    if (!handle) return null;

    /* 轨道就是把手的父节点：可用行程 = 轨道宽 - 把手宽 */
    var track = handle.parentNode;
    var dist = 0;
    try {
      var tw = track.getBoundingClientRect().width;
      var hw = handle.getBoundingClientRect().width || 40;
      if (tw > hw) dist = tw - hw;
    } catch (e) {}
    return { handle: handle, track: track, dist: Math.round(dist) };
  }

  /* 拼图型：两张图叠在一起让你对缺口，拖到底没用。
     注意 querySelector 只查子孙，根节点自己的 class 得单独看。 */
  function capIsJigsaw(root) {
    if (!root) return false;
    if (/jigsaw|puzzle|slice-img|verify-img-panel/i.test(String(root.className || "")))
      return true;
    if (
      root.querySelector(
        "[class*=jigsaw], [class*=puzzle], [class*=slice-img], [class*=verify-img-panel]",
      )
    )
      return true;
    return /拼图|缺口|拖动.*图/.test(evalText(root));
  }

  /* 人手轨迹：ease-out + 抖动 + 收尾回弹 1px（不少前端会校验「全程匀速」） */
  function capTrail(dist, steps) {
    var n = steps || 26;
    var out = [];
    for (var i = 1; i <= n; i++) {
      var t = i / n;
      var e = 1 - Math.pow(1 - t, 3);
      var x = dist * e;
      if (t < 0.96) x += (Math.random() - 0.5) * Math.min(3, Math.max(1, dist * 0.01));
      out.push(Math.max(0, Math.min(dist, x)));
    }
    out.push(dist);
    out.push(dist - 1); /* 手一松一紧的回弹 */
    out.push(dist);
    return out;
  }

  function capEv(target, type, x, y, buttons) {
    if (!target) return;
    var opt = {
      bubbles: true,
      cancelable: true,
      view: window,
      clientX: x,
      clientY: y,
      screenX: x,
      screenY: y,
      button: 0,
      buttons: buttons,
    };
    try {
      target.dispatchEvent(new MouseEvent(type, opt));
    } catch (e) {}
    /* 有些组件只认 pointer 系列 */
    try {
      if (typeof PointerEvent === "function")
        target.dispatchEvent(new PointerEvent(type, opt));
    } catch (e) {}
  }

  /* 从把手按下，按轨迹一路发 move，最后松手 */
  function capDrag(handle, dist, done) {
    if (!handle || !(dist > 0)) return false;
    var doc = handle.ownerDocument || document;
    var rect;
    try {
      rect = handle.getBoundingClientRect();
    } catch (e) {
      return false;
    }
    var sx = rect.left + (rect.width || 40) / 2;
    var sy = rect.top + (rect.height || 30) / 2;
    var pts = capTrail(dist, 26);
    var i = 0;

    capEv(handle, "pointerdown", sx, sy, 1);
    capEv(handle, "mousedown", sx, sy, 1);

    function step() {
      if (i >= pts.length) {
        var ex = sx + dist;
        var ey = sy + (Math.random() - 0.5) * 2;
        capEv(doc, "pointermove", ex, ey, 1);
        capEv(doc, "mousemove", ex, ey, 1);
        capEv(doc, "pointerup", ex, ey, 0);
        capEv(doc, "mouseup", ex, ey, 0);
        capEv(handle, "pointerup", ex, ey, 0);
        capEv(handle, "mouseup", ex, ey, 0);
        if (typeof done === "function") {
          try {
            done();
          } catch (e) {}
        }
        return;
      }
      var dx = pts[i++];
      var x = sx + dx;
      var y = sy + (Math.random() - 0.5) * 1.5;
      capEv(doc, "pointermove", x, y, 1);
      capEv(doc, "mousemove", x, y, 1);
      capEv(handle, "mousemove", x, y, 1);
      setTimeout(step, 14 + Math.random() * 12);
    }

    setTimeout(step, 50);
    return true;
  }

  var CAP_CN_NUM = {
    零: 0,
    一: 1,
    二: 2,
    两: 2,
    三: 3,
    四: 4,
    五: 5,
    六: 6,
    七: 7,
    八: 8,
    九: 9,
    十: 10,
  };

  function capCalc(a, op, b) {
    var r;
    if (op === "+" || op === "加") r = a + b;
    else if (op === "-" || op === "减") r = a - b;
    else if (op === "*" || op === "×" || op === "x" || op === "X" || op === "乘")
      r = a * b;
    else if (op === "/" || op === "÷" || op === "除") {
      if (!b) return "";
      r = a / b;
    } else return "";
    if (!isFinite(r)) return "";
    r = Math.round(r * 100) / 100;
    return String(r);
  }

  /* 从浮层文字里读算式：3+5=?、12 - 4 = ?、五加三、8×7 */
  function capArithmetic(text) {
    var t = String(text || "").replace(/\s+/g, "");
    var m = /(-?\d+(?:\.\d+)?)([+\-×xX*÷/])(-?\d+(?:\.\d+)?)/.exec(t);
    if (m) return capCalc(parseFloat(m[1]), m[2], parseFloat(m[3]));
    var cn = /([零一二两三四五六七八九十])([加减乘除])([零一二两三四五六七八九十])/.exec(t);
    if (cn) {
      var a = CAP_CN_NUM[cn[1]];
      var b = CAP_CN_NUM[cn[3]];
      if (a !== undefined && b !== undefined) return capCalc(a, cn[2], b);
    }
    return "";
  }

  function capCodeField(root) {
    if (!root) return null;
    var ins = root.querySelectorAll(
      "input[type=text], input:not([type]), input[type=tel], input[type=number]",
    );
    var fallback = null;
    for (var i = 0; i < ins.length; i++) {
      var el = ins[i];
      if (!elShown(el) || el.disabled || el.readOnly) continue;
      if (evalIsCaptchaField(el)) return el;
      if (!fallback && !String(el.value || "").trim()) fallback = el;
    }
    return fallback;
  }

  function capImageSrc(root) {
    if (!root) return "";
    var im = root.querySelector(
      "img[src*=captcha], img[src*=code], img[src*=verify], [class*=captcha] img",
    );
    return im && im.src ? String(im.src) : "";
  }

  /* 打码接口（可选）：POST {"image":"data:image/png;base64,..."}，
     返回 {"code":"1234"} 或纯文本都认。没填地址就完全不联网。 */
  function capOcr(src, cb) {
    var url = capOcrUrl();
    if (!url || typeof fetch !== "function") return false;
    try {
      fetch(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ image: src }),
      })
        .then(function (r) {
          return r.text();
        })
        .then(function (t) {
          var code = "";
          try {
            var j = JSON.parse(t);
            code = j.code || j.data || j.result || j.text || "";
          } catch (e) {
            code = t;
          }
          code = String(code || "")
            .replace(/[^0-9a-zA-Z]/g, "")
            .slice(0, 8);
          cb(code);
        })
        .catch(function () {
          cb("");
        });
    } catch (e) {
      return false;
    }
    return true;
  }

  /* 返回 {ok, kind, msg}；ok=false 时 msg 是「为什么没自动过」的原因 */
  function capTrySolve(root) {
    var out = { ok: false, kind: "", msg: "" };
    if (!root) return out;

    /* ---- ① 滑块 ---- */
    var s = capSlider(root);
    if (s) {
      if (!capSliderOn()) {
        out.msg = "「自动拖动滑块」关着，请手动拖一下。";
        return out;
      }
      if (capIsJigsaw(root)) {
        out.msg = "这是拼图滑块，缺口位置得人眼对，脚本不硬拖（拖错会涨验证强度）。";
        return out;
      }
      if (!s.dist || s.dist < 20) {
        out.msg = "滑块轨道量不出宽度，请手动拖一下。";
        return out;
      }
      capDrag(s.handle, s.dist, function () {
        logEvent("滑块已拖到轨道末端，" + s.dist + "px，等站点校验");
        setTimeout(function () {
          try {
            tryPlay();
          } catch (e) {}
        }, 1500);
      });
      return {
        ok: true,
        kind: "slider",
        msg: "已按人手轨迹把滑块拖到底（" + s.dist + "px）",
      };
    }

    /* ---- ② 验证码 ---- */
    var field = capCodeField(root);
    if (field) {
      if (!capCodeOn()) {
        out.msg = "「自动填写验证码」关着，请手动输入。";
        return out;
      }

      var ans = capArithmetic(evalText(root));
      if (ans) {
        evalSetValue(field, ans);
        var sb = evalSubmitBtn(root);
        if (sb) evalClick(sb);
        return { ok: true, kind: "code", msg: "验证码是算式，已算出 " + ans + " 并提交" };
      }

      var src = capImageSrc(root);
      if (src && capOcrUrl()) {
        var sent = capOcr(src, function (code) {
          if (!code) {
            setDetail(
              "打码接口没返回结果，请手动输入这张验证码。\n填好视频会接着播。",
              true,
            );
            logEvent("打码接口没返回结果，转手动");
            try {
              field.focus();
            } catch (e) {}
            return;
          }
          evalSetValue(field, code);
          var b = evalSubmitBtn(root);
          if (b) evalClick(b);
          logEvent("验证码已由打码接口识别为 " + code + " 并提交");
          setTimeout(function () {
            try {
              tryPlay();
            } catch (e) {}
          }, 1500);
        });
        if (sent)
          return {
            ok: true,
            kind: "code",
            msg: "验证码图片已发给打码接口，识别结果会自动填上",
          };
      }

      try {
        field.focus();
      } catch (e) {}
      out.msg = capOcrUrl()
        ? "这张验证码没识别出来，请手动输入（输入框已帮你点好）。"
        : "这是图片验证码，脚本认不出。填了「打码接口」才能自动识别；现在请手动输入一次（输入框已帮你点好）。";
      return out;
    }

    out.msg = "没找到滑块也没找到输入框，请手动处理。";
    return out;
  }

  var liveTimer = null;
  var liveReader = null;

  function startLiveRefresh(reader) {
    liveReader = reader;
    if (liveTimer) clearInterval(liveTimer);
    var tick = function () {
      try {
        setLive(reader());
      } catch (e) {}
    };
    tick();
    liveTimer = setInterval(tick, 1000);
  }

  function refreshLive() {
    if (!liveReader) return;
    try {
      setLive(liveReader());
    } catch (e) {}
  }

  /* 停掉实时区刷新 —— **站内（SPA）路由跳页时必须调它**。
     每个 reader 认的是**某个页面**的结构；跳页后页面没重载，这个每秒的定时器还活着，
     于是它拿新页面的 DOM 去跑旧页面的逻辑，把实时区刷成一片胡话。
     实测：工作台 → myStudy 过渡页之后，实时区显示「板块 · 读不到考核要求」×4
     —— 那 4 行是过渡页上 4 张 .tool-card.pointer 被当成工作台的板块卡片了。 */
  function stopLiveRefresh() {
    if (liveTimer) clearInterval(liveTimer);
    liveTimer = null;
    liveReader = null;
  }

  /* ================= 二·2、学分（服务端算的，只能拉接口） ================= */

  /* 学分接口在 ipx-api.yanxiu.com，不在页面这个域上；写成同源相对路径会被重定向回 HTML */
  var CREDIT_API =
    "https://ipx-api.yanxiu.com/train-project-center/person/summary/statistics";

  /* 网关只认 X-DT-accessToken（存在同名 cookie 里，JS 可读），缺了直接回「为空」 */
  var CREDIT_CLIENT_ID = "ums-teacher-pc";

  /* 这里原本还有一枚站点客户端的 Basic 凭证（CREDIT_BASIC），2026-09-24 删掉了。
     依据：网关真正校验的是 X-DT-accessToken；实测 Basic 填对、填错、甚至不填，
     在令牌这一关没过时响应逐字节相同。拿真登录态把 Basic 换成占位值跑过，
     学分照常读得出来 —— 说明它本来就是多余的。
     删它的原因：脚本要公开发布，带着第三方凭证会被 secret scanning / 爬虫盯上。
     ⚠️ 以后万一学分读不出来，先查 X-DT-accessToken 这个 cookie 在不在，别再去找 Basic。 */

  var creditCache = null;
  var creditLoading = false;
  var creditError = "";
  var creditTimer = null;

  function readCookie(name) {
    var m = document.cookie.match(
      new RegExp("(?:^|;\\s*)" + name + "\\s*=\\s*([^;]*)"),
    );
    return m ? m[1] : "";
  }

  function distinctId() {
    try {
      for (var i = 0; i < localStorage.length; i++) {
        var k = localStorage.key(i);
        if (k && k.toLowerCase().indexOf("distinct") > -1) {
          return localStorage.getItem(k) || "";
        }
      }
    } catch (e) {}
    return "";
  }

  function creditHeaders() {
    return {
      "Content-Type": "application/json",
      /* 占位值。这枚 Basic 网关并不校验（原来是站点客户端的凭证，已删）。
         保留这个头而不是整行删掉：实测过「换个值照样能用」，
         但没测过「这个头完全不发」—— 留着最省事，也不泄露任何东西。 */
      Authorization: "Basic x",
      "X-DT-clientId": CREDIT_CLIENT_ID,
      "X-DT-accessToken": readCookie("X-DT-accessToken"),
      "X-DT-Passport": readCookie("passport"),
      srxUserInfo: readCookie("srxUserInfo") || "distinctId=" + distinctId(),
    };
  }

  /* 这个接口成功失败都回 HTTP 200，错误写在 body 的 status 里 */
  function pickCredits(j) {
    if (!j) return null;
    if (j.toolExamineExternDTOList) return j;
    if (j.data && j.data.toolExamineExternDTOList) return j.data;
    return null;
  }

  function apiErrorText(j) {
    var s = j && j.status;
    if (s && s.desc) return String(s.desc);
    if (s && s.code) return "接口错误码 " + s.code;
    return "";
  }

  function fmt2(v) {
    var n = Number(v);
    if (!isFinite(n)) return "-";

    return (Math.round(n * 100) / 100).toFixed(2).replace(/\.?0+$/, "");
  }

  /* 响应里带着 userId / 姓名 / 学校等，脚本一个都用不上，一律不落盘（分享 .storage.json 会漏） */
  function trimScore(s) {
    if (!s) return s;
    return {
      score: s.score,
      fullScore: s.fullScore,
      passScore: s.passScore,
    };
  }

  function trimCredits(d) {
    if (!d) return null;
    return {
      webScoreOpen: d.webScoreOpen,
      managerWebScoreOpen: d.managerWebScoreOpen,
      f2fScoreOpen: d.f2fScoreOpen,
      netPassState: d.netPassState,
      managerWebPassState: d.managerWebPassState,
      f2fPassState: d.f2fPassState,
      mustFinishTask: d.mustFinishTask,
      netScore: trimScore(d.netScore),
      managerWebScore: trimScore(d.managerWebScore),
      f2fScore: trimScore(d.f2fScore),
      /* 只留个标记：脚本从不读它的内容，只拿它判断「这确实是一份学分数据」 */
      toolExamineExternDTOList: [],
    };
  }

  function readCredits() {
    if (creditCache && creditCache.data) return creditCache;
    var c = GM_getValue("ak_credits");
    if (c && c.data && c.data.toolExamineExternDTOList) {
      var slim = trimCredits(c.data);
      /* 旧版本存的是整包响应，顺手洗一遍覆盖回去，别让多余字段一直留在磁盘上 */
      if (Object.keys(c.data).length !== Object.keys(slim).length) {
        c = { ts: c.ts, data: slim };
        try {
          GM_setValue("ak_credits", c);
        } catch (e) {}
      }
      creditCache = c;
      return c;
    }
    return null;
  }

  /* 学分是分项的：学员看 netScore，管理/辅导看 managerWebScore，面授单列；开关是 xxxScoreOpen */
  function creditSections(d) {
    if (!d) return [];
    var role = pageRole() || "MEMBER";
    var isMember = role === "MEMBER";
    var out = [];

    /* 非学员身份下，管理/辅导任务和网络学习是两个独立的学分桶 */
    if (!isMember && d.webScoreOpen && d.netScore) {
      out.push({
        name: role === "BAR_MANAGER" ? "辅导任务" : "管理任务",
        score: d.netScore,
      });
    }
    var webOpen = isMember ? d.webScoreOpen : d.managerWebScoreOpen;
    var webScore = isMember ? d.netScore : d.managerWebScore;
    if (webOpen && webScore) out.push({ name: "网络学习", score: webScore });
    if (d.f2fScoreOpen && d.f2fScore) {
      out.push({ name: "集中面授", score: d.f2fScore });
    }
    return out;
  }

  function sectionText(sec) {
    var s = sec.score || {};
    var got = Number(s.score || 0),
      max = Number(s.fullScore || 0),
      need = Number(s.passScore || 0);
    var text = sec.name + " " + fmt2(got) + " / " + fmt2(max);
    if (got >= need) return text + " · 已达标";
    return text + " · 未达标（还差 " + fmt2(need - got) + "）";
  }

  /* 单行版给日志和提示用，同时当「学分有没有变」的指纹 —— 每项都要带，只比总分漏面授 */
  function creditText(d) {
    var secs = creditSections(d);
    var out = [];
    for (var i = 0; i < secs.length; i++) {
      var s = secs[i].score || {};
      out.push(secs[i].name + " " + fmt2(s.score) + "/" + fmt2(s.fullScore));
    }
    return out.join(" · ");
  }

  function creditScoreText() {
    var c = readCredits();
    return c ? creditText(c.data) : "";
  }

  function saveCredits(d) {
    if (!d || !d.toolExamineExternDTOList) return false;
    var slim = trimCredits(d);
    var changed = creditText(slim) !== creditScoreText();
    creditCache = { ts: Date.now(), data: slim };
    creditError = "";
    try {
      GM_setValue("ak_credits", creditCache);
    } catch (e) {}
    return changed;
  }

  function creditLine() {
    var c = readCredits();
    if (!c)
      return creditError ? "学分 读取失败：" + creditError : "学分 正在读取…";
    var d = c.data;
    var secs = creditSections(d);
    if (!secs.length) {
      var anyOpen = d.webScoreOpen || d.f2fScoreOpen || d.managerWebScoreOpen;
      return anyOpen ? "学分 暂时没有数据" : "学分 这个项目不显示学分";
    }
    var lines = [];
    for (var i = 0; i < secs.length; i++) {
      lines.push((i === 0 ? "学分 " : "　　") + sectionText(secs[i]));
    }
    return lines.join("\n");
  }

  function fetchCredits(force) {
    return new Promise(function (resolve) {
      var pid = pageProjectId();
      if (!pid) {
        resolve(null);
        return;
      }

      var c = readCredits();
      if (!force && c && Date.now() - c.ts < 60000) {
        resolve(c.data);
        return;
      }
      if (creditLoading) {
        resolve(c ? c.data : null);
        return;
      }
      creditLoading = true;

      var W =
        typeof unsafeWindow !== "undefined" && unsafeWindow
          ? unsafeWindow
          : window;
      /* 站点是按「当前角色」查的；写死 MEMBER 会让非学员账号查到别人的视图 */
      var role = pageRole() || "MEMBER";
      var url =
        CREDIT_API +
        "?trainProjectId=" +
        encodeURIComponent(pid) +
        "&roleLevel=" +
        encodeURIComponent(role) +
        "&userRole=" +
        encodeURIComponent(role);

      var finish = function (d, err) {
        creditLoading = false;
        var changed = saveCredits(d);
        if (changed) logEvent("学分更新：" + creditScoreText());
        else if (!d) creditError = err || "接口没返回学分字段";
        refreshLive();
        resolve(d || null);
      };

      if (!readCookie("X-DT-accessToken")) {
        /* 没令牌就别白发了，省得只换回一句看不懂的接口报错 */
        finish(
          null,
          "没读到登录令牌（cookie X-DT-accessToken），先刷新一次页面再试",
        );
        return;
      }

      try {
        W.fetch(url, { credentials: "include", headers: creditHeaders() })
          .then(function (r) {
            var ct = r.headers.get("content-type") || "";
            if (ct.indexOf("json") === -1) {
              throw new Error(
                "接口返回的不是数据（HTTP " +
                  r.status +
                  "，" +
                  (ct || "没有 content-type") +
                  "）",
              );
            }
            return r.json();
          })
          .then(function (j) {
            var d = pickCredits(j);
            if (d) {
              finish(d, "");
              return;
            }
            var why = apiErrorText(j);
            finish(null, why ? "接口说：" + why : "接口没返回学分字段");
          })
          .catch(function (e) {
            finish(null, e && e.message ? e.message : String(e));
          });
      } catch (e) {
        finish(null, e && e.message ? e.message : String(e));
      }
    });
  }

  /* 顺手截获页面自己发的那次学分请求；站点用 axios 走 XHR，只钩 fetch 是白钩，两个都钩 */
  (function hookCreditApi() {
    try {
      var W =
        typeof unsafeWindow !== "undefined" && unsafeWindow
          ? unsafeWindow
          : window;

      function absorb(text) {
        if (!text || text.indexOf("toolExamineExternDTOList") === -1) return;
        var j;
        try {
          j = JSON.parse(text);
        } catch (e) {
          return;
        }
        var d = pickCredits(j);
        if (!d) return;
        if (saveCredits(d)) logEvent("学分更新：" + creditScoreText());
        refreshLive();
      }

      var XP = W.XMLHttpRequest && W.XMLHttpRequest.prototype;
      if (XP && XP.open && XP.send) {
        var rawOpen = XP.open,
          rawSend = XP.send;
        XP.open = function (method, url) {
          try {
            this.__akCreditUrl =
              String(url || "").indexOf("person/summary/statistics") > -1;
          } catch (e) {}
          return rawOpen.apply(this, arguments);
        };
        XP.send = function () {
          var xhr = this;
          try {
            if (xhr.__akCreditUrl) {
              xhr.addEventListener("load", function () {
                try {
                  var rt = xhr.responseType;
                  if (!rt || rt === "text") absorb(xhr.responseText);
                } catch (e) {}
              });
            }
          } catch (e) {}
          return rawSend.apply(this, arguments);
        };
      }

      var rawFetch = W.fetch;
      if (typeof rawFetch === "function") {
        W.fetch = function (input) {
          var url =
            typeof input === "string" ? input : (input && input.url) || "";
          var p = rawFetch.apply(this, arguments);
          if (url.indexOf("person/summary/statistics") === -1) return p;
          try {
            p.then(function (r) {
              try {
                r.clone()
                  .text()
                  .then(absorb)
                  .catch(function () {});
              } catch (e) {}
            }).catch(function () {});
          } catch (e) {}
          return p;
        };
      }
    } catch (e) {}
  })();

  function startCreditRefresh() {
    fetchCredits(false);
    if (creditTimer) clearInterval(creditTimer);
    creditTimer = setInterval(function () {
      fetchCredits(false);
    }, 60000);
  }

  /* ================= 二·3、运行开关（启动 / 停止） =================
     停止不是「关掉一个变量」这么简单：工作台、课程列表、看课页各有一套循环，
     每套循环在每个检查点都会问一次 halted()，发现停了就**原地退出、不点任何东西**。
     这样「停止」才是真的停手，而不是等你刷新页面才生效。
     ================================================================ */

  var RUN_KEY = "ak_run";

  /* 从没设置过就算「运行中」—— 老用户升级上来不该突然变成停止状态 */
  function isRunning() {
    var v = GM_getValue(RUN_KEY);
    return v === undefined || v === null ? true : !!v;
  }

  function setRunning(on) {
    try {
      GM_setValue(RUN_KEY, !!on);
    } catch (e) {}
  }

  /* 所有长循环的统一检查点 */
  function halted() {
    return !isRunning();
  }

  /* 拆掉浮窗：关掉「显示状态浮窗」时用，buildHud 会因为它不在了而重建 */
  function destroyHud() {
    stopLiveRefresh();
    if (HUD.root && HUD.root.parentNode) {
      HUD.root.parentNode.removeChild(HUD.root);
    }
    HUD.root = null;
    HUD.dot = null;
    HUD.line = null;
    HUD.head = null;
    HUD.body = null;
    HUD.arrow = null;
    HUD.live = null;
    HUD.log = null;
    HUD.detail = null;
    HUD.toast = null;
    HUD.runBtn = null;
  }

  /* 静音 / 倍速改动后立刻作用在当前视频上，不用等下一次刷新 */
  function applyVideoPrefs() {
    var v = findVideo();
    if (!v) return;
    try {
      if (isMuted()) v.muted = true;
      if (speedEnabled()) v.playbackRate = 2;
      else if (v.playbackRate && v.playbackRate !== 1) v.playbackRate = 1;
    } catch (e) {}
  }

  function stopWork(why) {
    setRunning(false);
    stopLiveRefresh();
    if (creditTimer) {
      clearInterval(creditTimer);
      creditTimer = null;
    }
    if (rescanTimer) {
      clearTimeout(rescanTimer);
      rescanTimer = null;
    }
    endWatch();
    try {
      var v = findVideo();
      if (v && !v.paused) v.pause();
    } catch (e) {}
    setStatus("已停止 · 不会自动操作", "idle");
    setDetail(
      "脚本已停止：不会自动开课、不会自动跳页，正在播的视频也暂停了。\n" +
        "设置不会丢，点「启动」接着跑。",
    );
    logEvent("已停止" + (why ? "（" + why + "）" : ""));
    refreshRunUi();
  }

  function startWork() {
    if (isRunning()) return;
    setRunning(true);
    setDetail("");
    logEvent("已启动，接着自动学习");
    refreshRunUi();

    /* 「停止」后旧流程最多还要几秒才退干净（它在 sleep / 等心跳）。
       这段时间里 flowBusy 还是 true，直接派活会被忽略 —— 所以隔一会儿再试几次，
       不然用户会看到「点了启动却没动静」。 */
    var tries = 0;
    var kick = function () {
      if (!isRunning()) return;
      if (flowBusy && tries < 6) {
        tries++;
        setTimeout(kick, 1200);
        return;
      }
      dispatchFlow().catch(reportFatal);
    };
    kick();
  }

  function reportFatal(e) {
    var msg = e && e.message ? e.message : String(e);
    LOG("出错：" + msg);
    setStatus("出了点问题，已停止", "error");
    setError(
      msg +
        "\n\n点「重新开始」刷新页面再试一次；\n还不行就点「复制状态」发给开发者。",
    );
    logEvent("出错停下：" + msg.slice(0, 40));
    endWatch();
  }

  /* 浮窗和弹窗上的运行状态一起刷 —— 两边显示的东西必须是同一份事实 */
  function refreshRunUi() {
    var on = isRunning();
    if (HUD.runBtn) {
      HUD.runBtn.textContent = on ? "⏸ 停止" : "▶ 启动";
      HUD.runBtn.style.cssText = btnStyle(
        on ? "#FCEBEB" : "#E6F6EE",
        on ? "#A32D2D" : "#0F6E4A",
      );
    }
    if (setStateDot) setStateDot.style.background = on ? "#1D9E75" : "#8A94A6";
    if (setStateTxt) {
      setStateTxt.textContent = on ? "运行中" : "已停止";
      setStateTxt.style.color = on ? "#0F6E4A" : "#5F5E5A";
    }
    if (setRunBtn) {
      setRunBtn.textContent = on ? "■ 停止脚本" : "▶ 启动脚本";
      setRunBtn.style.background = on ? "#E24B4A" : "#1D9E75";
    }
  }

  /* ================= 二·4、设置弹窗 =================
     交互约定（一句话版）：
       · 弹窗里改的每一项都只写在「草稿」上，点「保存并应用」才落到本地存储；
       · 「取消」/ 按 Esc / 点遮罩 = 什么都不写，关掉前什么样，关掉后还是什么样；
       · 「启动 / 停止」是即时动作，不走草稿、关掉弹窗也不会被回滚；
       · 时长只在「自定义上限」时生效，切回「跟随课程」时输入框变灰但保留数字，
         下次切回来还是原值（不会因为切模式把用户填的数字清掉）。
     ================================================== */

  var setMask = null;
  var setEsc = null;
  var setRunBtn = null;
  var setStateDot = null;
  var setStateTxt = null;

  function draftFromStore() {
    return {
      mode: watchMode(),
      minutes: watchLimitMin(),
      mute: isMuted(),
      speed: speedEnabled(),
      hud: hudEnabled(),
      autoNext: autoNextAfterPass(),
      autoPlay: autoPlayAfterPass(),
      autoEval: autoEvalOn(),
      slider: capSliderOn(),
      code: capCodeOn(),
      ocr: capOcrUrl(),
    };
  }

  function draftSummary(d) {
    var out = [];
    out.push(d.mode === "fixed" ? "每门最多 " + d.minutes + " 分钟" : "播到站点提示已完成");
    out.push(d.autoNext ? "达标后自动续播" : "达标后停下");
    out.push(d.autoPlay ? "全达标后继续连播" : "全达标后停下");
    if (d.autoEval) out.push("自动提交评价");
    if (d.slider) out.push("自动拖滑块");
    if (d.code) out.push("自动填验证码");
    if (d.ocr) out.push("已配打码接口");
    if (d.mute) out.push("静音");
    if (d.speed) out.push("2 倍速");
    if (!d.hud) out.push("不显示浮窗");
    return out.join(" · ");
  }

  function applyDraft(d) {
    GM_setValue("设置.时长模式", d.mode === "fixed" ? "fixed" : "full");
    GM_setValue("设置.时长分钟", d.minutes);
    GM_setValue("设置.静音", !!d.mute);
    GM_setValue("设置.倍速", !!d.speed);
    GM_setValue("设置.达标续播", !!d.autoNext);
    GM_setValue("设置.连播", !!d.autoPlay);
    GM_setValue("设置.自动评价", !!d.autoEval);
    GM_setValue("设置.过滑块", !!d.slider);
    GM_setValue("设置.填验证码", !!d.code);
    GM_setValue("设置.打码接口", String(d.ocr || "").trim());

    /* 浮窗要特殊处理：关掉得真把 DOM 拆了，打开得重建 */
    GM_setValue("设置.浮窗", !!d.hud);
    if (d.hud) buildHud();
    else destroyHud();

    applyVideoPrefs();
    refreshRunUi();
  }

  function setLabel(text) {
    var el = document.createElement("div");
    el.textContent = text;
    el.style.cssText =
      "font-weight:500;font-size:12.5px;color:#0C447C;margin:16px 0 7px";
    return el;
  }

  function setNote(text) {
    var el = document.createElement("div");
    el.textContent = text;
    el.style.cssText =
      "font-size:11.5px;color:#7A8798;line-height:1.6;margin-top:6px;white-space:pre-line";
    return el;
  }

  /* 单选行：value 变了就调 onPick，选中态靠左边那个圆点表示 */
  function setRadio(name, value, title, desc, current, onPick) {
    var row = document.createElement("label");
    var active = current === value;
    row.style.cssText =
      "display:flex;gap:9px;align-items:flex-start;padding:9px 10px;border-radius:9px;" +
      "border:1px solid " +
      (active ? "#378ADD" : "#E6F1FB") +
      ";background:" +
      (active ? "#F2F8FF" : "#fff") +
      ";margin-bottom:7px;cursor:pointer";

    var box = document.createElement("input");
    box.type = "radio";
    box.name = name;
    box.value = value;
    box.checked = active;
    box.style.cssText = "margin:3px 0 0;flex:0 0 auto;cursor:pointer";
    box.onchange = function () {
      if (box.checked) onPick(value);
    };

    var wrap = document.createElement("div");
    var t = document.createElement("div");
    t.textContent = title;
    t.style.cssText = "font-size:12.5px;font-weight:500;color:#042C53";
    var dd = document.createElement("div");
    dd.textContent = desc;
    dd.style.cssText =
      "font-size:11.5px;color:#7A8798;line-height:1.55;margin-top:2px";
    wrap.appendChild(t);
    wrap.appendChild(dd);
    row.appendChild(box);
    row.appendChild(wrap);
    return row;
  }

  /* 复选行：整行可点，描述写在标题下面 */
  function setCheck(title, desc, checked, onToggle) {
    var row = document.createElement("label");
    row.style.cssText =
      "display:flex;gap:9px;align-items:flex-start;padding:9px 10px;border-radius:9px;" +
      "border:1px solid #E6F1FB;background:#F7FAFF;margin-bottom:7px;cursor:pointer";

    var box = document.createElement("input");
    box.type = "checkbox";
    box.checked = !!checked;
    box.style.cssText =
      "margin:3px 0 0;flex:0 0 auto;width:15px;height:15px;cursor:pointer";
    box.onchange = function () {
      onToggle(box.checked);
    };

    var wrap = document.createElement("div");
    var t = document.createElement("div");
    t.textContent = title;
    t.style.cssText = "font-size:12.5px;font-weight:500;color:#042C53";
    var dd = document.createElement("div");
    dd.textContent = desc;
    dd.style.cssText =
      "font-size:11.5px;color:#7A8798;line-height:1.55;margin-top:2px";
    wrap.appendChild(t);
    wrap.appendChild(dd);
    row.appendChild(box);
    row.appendChild(wrap);
    return row;
  }

  /* 单行文本设置：用在「打码接口」这种可选地址上，留空 = 不启用 */
  function setText(title, desc, value, placeholder, onInput) {
    var row = document.createElement("div");
    row.style.cssText =
      "padding:9px 10px;border-radius:9px;border:1px solid #E6F1FB;" +
      "background:#F7FAFF;margin-bottom:7px";

    var t = document.createElement("div");
    t.textContent = title;
    t.style.cssText = "font-size:12.5px;font-weight:500;color:#042C53";

    var inp = document.createElement("input");
    inp.type = "text";
    inp.value = value || "";
    inp.placeholder = placeholder || "";
    inp.style.cssText =
      "width:100%;box-sizing:border-box;margin-top:6px;padding:6px 8px;border-radius:7px;" +
      'border:1px solid #B5D4F4;font:12px -apple-system,"PingFang SC",sans-serif;' +
      "color:#042C53;background:#fff;outline:none";
    inp.oninput = function () {
      onInput(inp.value);
    };

    var dd = document.createElement("div");
    dd.textContent = desc;
    dd.style.cssText =
      "font-size:11.5px;color:#7A8798;line-height:1.55;margin-top:5px";

    row.appendChild(t);
    row.appendChild(inp);
    row.appendChild(dd);
    return row;
  }

  function setActionBtn(text, bg, fg, size) {
    var b = document.createElement("button");
    b.textContent = text;
    b.style.cssText =
      "padding:7px 14px;border:0;border-radius:9px;background:" +
      bg +
      ";color:" +
      fg +
      ";font:" +
      (size || "12.5px") +
      ' -apple-system,"PingFang SC",sans-serif;cursor:pointer;white-space:nowrap';
    return b;
  }

  function closeSettings() {
    if (setEsc) {
      document.removeEventListener("keydown", setEsc);
      setEsc = null;
    }
    if (setMask && setMask.parentNode) setMask.parentNode.removeChild(setMask);
    setMask = null;
    setRunBtn = null;
    setStateDot = null;
    setStateTxt = null;
  }

  function openSettings() {
    closeSettings();
    if (!document.body) return;

    var d = draftFromStore();
    var minutesInput = null;
    var modeRowFull = null;
    var modeRowFixed = null;
    var minRow = null;
    var preview = null;

    var mask = document.createElement("div");
    mask.style.cssText =
      "position:fixed;left:0;top:0;right:0;bottom:0;z-index:2147483647;" +
      "background:rgba(4,44,83,.42);display:flex;align-items:center;" +
      "justify-content:center;padding:14px";
    mask.onclick = function (e) {
      if (e.target === mask) closeSettings();
    };

    var card = document.createElement("div");
    card.style.cssText =
      "width:372px;max-width:100%;max-height:88vh;overflow:auto;background:#fff;" +
      "border-radius:14px;box-shadow:0 18px 50px rgba(4,44,83,.34);" +
      'font:13px/1.65 -apple-system,BlinkMacSystemFont,"PingFang SC",sans-serif;color:#042C53';

    /* ---- 标题栏 ---- */
    var head = document.createElement("div");
    head.style.cssText =
      "display:flex;align-items:center;gap:7px;padding:13px 16px;background:#0C447C;color:#fff";
    var hTitle = document.createElement("div");
    hTitle.textContent = "自动看课 · 设置";
    hTitle.style.cssText = "font-size:14.5px;font-weight:500";
    var hVer = document.createElement("span");
    hVer.textContent = "v" + VERSION;
    hVer.style.cssText = "font-size:11px;opacity:.78";
    var hClose = document.createElement("button");
    hClose.textContent = "×";
    hClose.title = "关闭（Esc）";
    hClose.style.cssText =
      "margin-left:auto;background:none;border:0;color:#fff;font-size:20px;" +
      "line-height:1;cursor:pointer;padding:0 2px";
    hClose.onclick = function () {
      closeSettings();
    };
    head.appendChild(hTitle);
    head.appendChild(hVer);
    head.appendChild(hClose);

    var body = document.createElement("div");
    body.style.cssText = "padding:14px 16px 16px";

    /* ---- 运行状态 ---- */
    var runBox = document.createElement("div");
    runBox.style.cssText =
      "display:flex;align-items:center;gap:9px;padding:10px 12px;border-radius:10px;" +
      "background:#F2F8FF;border:1px solid #B5D4F4";

    var runDot = document.createElement("span");
    runDot.style.cssText =
      "width:9px;height:9px;border-radius:50%;background:#1D9E75;flex:0 0 auto";

    var runTxt = document.createElement("div");
    runTxt.textContent = "运行中";
    runTxt.style.cssText = "flex:1;font-weight:500;font-size:12.5px";

    var runBtn = setActionBtn("■ 停止脚本", "#E24B4A", "#ffffff");
    runBtn.onclick = function () {
      if (isRunning()) stopWork("手动停止");
      else startWork();
      refreshRunUi();
    };

    runBox.appendChild(runDot);
    runBox.appendChild(runTxt);
    runBox.appendChild(runBtn);
    body.appendChild(runBox);
    body.appendChild(
      setNote(
        "停止后立刻停手：不自动开课、不自动跳页，正在播的视频会暂停。\n" +
          "启动会按当前页面继续（工作台 → 挑下一门；看课页 → 接着播）。",
      ),
    );

    /* ---- 观看时长 ---- */
    body.appendChild(setLabel("一、每门课看多久"));

    var syncMinRow = function () {
      var fixed = d.mode === "fixed";
      if (minRow) {
        minRow.style.opacity = fixed ? "1" : ".5";
        minRow.style.pointerEvents = fixed ? "auto" : "none";
      }
      if (minutesInput) minutesInput.disabled = !fixed;
      if (preview) {
        preview.textContent = fixed
          ? "当前：每门最多看 " + d.minutes + " 分钟，到点自动换下一门"
          : "当前：一直播到站点提示「您已完成」";
      }
    };

    var repaintMode = function () {
      var fixed = d.mode === "fixed";
      modeRowFull.style.borderColor = fixed ? "#E6F1FB" : "#378ADD";
      modeRowFull.style.background = fixed ? "#fff" : "#F2F8FF";
      modeRowFixed.style.borderColor = fixed ? "#378ADD" : "#E6F1FB";
      modeRowFixed.style.background = fixed ? "#F2F8FF" : "#fff";
      syncMinRow();
    };

    modeRowFull = setRadio(
      "ak_dur",
      "full",
      "跟随课程",
      "一直播到站点提示「您已完成」（推荐）",
      d.mode,
      function (v) {
        d.mode = v;
        repaintMode();
      },
    );
    modeRowFixed = setRadio(
      "ak_dur",
      "fixed",
      "自定义上限",
      "每门最多看这么多分钟，到点自动换下一门",
      d.mode,
      function (v) {
        d.mode = v;
        repaintMode();
      },
    );
    body.appendChild(modeRowFull);
    body.appendChild(modeRowFixed);

    /* 数字输入单独一行，跟两个单选分开，免得看着像单选的一部分 */
    minRow = document.createElement("div");
    minRow.style.cssText =
      "display:flex;align-items:center;gap:8px;padding:9px 10px;border-radius:9px;" +
      "background:#F7FAFF;border:1px solid #E6F1FB";

    var minLabel = document.createElement("span");
    minLabel.textContent = "上限";
    minLabel.style.cssText = "font-size:12.5px;color:#042C53";

    minutesInput = document.createElement("input");
    minutesInput.type = "number";
    minutesInput.min = String(DUR_MIN_LOW);
    minutesInput.max = String(DUR_MIN_HIGH);
    minutesInput.step = "1";
    minutesInput.value = String(d.minutes);
    minutesInput.style.cssText =
      "width:72px;padding:4px 7px;border:1px solid #B5D4F4;border-radius:7px;" +
      "font:13px -apple-system,\"PingFang SC\",sans-serif;color:#042C53;background:#fff";
    minutesInput.oninput = function () {
      var n = Number(minutesInput.value);
      if (isFinite(n) && n >= DUR_MIN_LOW) {
        d.minutes = Math.min(DUR_MIN_HIGH, Math.round(n));
        if (preview) {
          preview.textContent =
            "当前：每门最多看 " + d.minutes + " 分钟，到点自动换下一门";
        }
      }
    };
    /* 失焦时把非法值拉回合法区间，别让用户带着 "0" 或 "-3" 点保存 */
    minutesInput.onblur = function () {
      var n = Number(minutesInput.value);
      if (!isFinite(n) || n < DUR_MIN_LOW) n = DUR_MIN_DEFAULT;
      d.minutes = Math.min(DUR_MIN_HIGH, Math.max(DUR_MIN_LOW, Math.round(n)));
      minutesInput.value = String(d.minutes);
      syncMinRow();
    };

    var minUnit = document.createElement("span");
    minUnit.textContent = "分钟 / 门（" + DUR_MIN_LOW + " – " + DUR_MIN_HIGH + "）";
    minUnit.style.cssText = "font-size:11.5px;color:#7A8798";

    minRow.appendChild(minLabel);
    minRow.appendChild(minutesInput);
    minRow.appendChild(minUnit);
    body.appendChild(minRow);

    preview = setNote("");
    body.appendChild(preview);

    /* ---- 行为开关 ---- */
    body.appendChild(setLabel("二、行为"));

    body.appendChild(
      setCheck(
        "一门课达标后自动续播下一门",
        "推荐开启。站点提示「您已完成」后就自动回列表挑下一门，全程不用你点。\n关掉的话，每看完一门就停下来等你点「启动」。",
        d.autoNext,
        function (v) {
          d.autoNext = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "必修、选修都达标后继续连播",
        "开启后就是「自动学习」：必修和选修都达标了也不停，把没看完的课一门门接着播完。\n关掉的话，全达标就收工。",
        d.autoPlay,
        function (v) {
          d.autoPlay = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "自动提交评价 / 评分（给满分）",
        "看课中途弹出课程评价、问卷、评分或「验证」浮层时，自动给满分、填好评语并提交，让视频接着播。",
        d.autoEval,
        function (v) {
          d.autoEval = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "自动拖动滑块",
        "验证滑块按人手轨迹拖到底（先快后慢 + 抖动 + 回弹），只处理「拖到最右」这种线性滑块。\n拼图缺口型不硬拖 —— 缺口得人眼对，拖错还会涨验证强度。",
        d.slider,
        function (v) {
          d.slider = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "自动填写验证码",
        "验证码是算式（3+5=?、八减三）时直接算出来填上并提交。\n图片验证码要靠下面的打码接口才认得出来，没配就提示你手输。",
        d.code,
        function (v) {
          d.code = v;
        },
      ),
    );
    body.appendChild(
      setText(
        "打码接口（可选，留空则永不联网）",
        '填 HTTP 地址后，图片验证码会 POST {"image":"data:image/png;base64,..."} 过去，接口回 {"code":"1234"} 或纯文本都认。\n不填的话脚本不会发任何外部请求。',
        d.ocr,
        "https://your-ocr.example.com/solve",
        function (v) {
          d.ocr = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "自动静音",
        "建议保持开启。浏览器不允许带声音的页面自动播放，关掉可能播不起来。",
        d.mute,
        function (v) {
          d.mute = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "2 倍速播放",
        "这个网站不允许倍速（播放器里压根没有倍速选项），保持关闭。",
        d.speed,
        function (v) {
          d.speed = v;
        },
      ),
    );
    body.appendChild(
      setCheck(
        "显示右下角状态浮窗",
        "显示实时进度和「最近做了什么」。关掉后想再打开，用脚本管理器菜单里的「打开设置」。",
        d.hud,
        function (v) {
          d.hud = v;
        },
      ),
    );

    /* ---- 底部按钮 ---- */
    var foot = document.createElement("div");
    foot.style.cssText =
      "display:flex;justify-content:flex-end;gap:8px;margin-top:16px";

    var cancel = setActionBtn("取消", "#F1EFE8", "#5F5E5A");
    cancel.onclick = function () {
      closeSettings();
      showToast("已取消，设置没有改动");
    };

    var save = setActionBtn("保存并应用", "#0C447C", "#ffffff");
    save.onclick = function () {
      if (d.mode === "fixed") {
        var n = Number(minutesInput.value);
        if (!isFinite(n) || n < DUR_MIN_LOW || n > DUR_MIN_HIGH) {
          showToast(
            "观看上限要填 " + DUR_MIN_LOW + " – " + DUR_MIN_HIGH + " 之间的整数",
          );
          minutesInput.focus();
          return;
        }
        d.minutes = Math.round(n);
      }
      applyDraft(d);
      closeSettings();
      showToast("设置已保存：" + draftSummary(d));
      logEvent("设置已更新：" + draftSummary(d));
    };

    foot.appendChild(cancel);
    foot.appendChild(save);
    body.appendChild(foot);

    card.appendChild(head);
    card.appendChild(body);
    mask.appendChild(card);
    document.body.appendChild(mask);

    setMask = mask;
    setRunBtn = runBtn;
    setStateDot = runDot;
    setStateTxt = runTxt;

    repaintMode();
    refreshRunUi();

    setEsc = function (e) {
      if (e.key === "Escape" || e.keyCode === 27) closeSettings();
    };
    document.addEventListener("keydown", setEsc);
  }

  /* ================= 三、小工具 ================= */

  function sleep(ms) {
    return new Promise(function (r) {
      setTimeout(r, ms);
    });
  }

  function waitFor(selectors, timeoutMs, what) {
    return new Promise(function (resolve, reject) {
      var t0 = Date.now();
      var timer = setInterval(function () {
        for (var i = 0; i < selectors.length; i++) {
          var els = document.querySelectorAll(selectors[i]);
          if (els.length) {
            clearInterval(timer);
            resolve(els);
            return;
          }
        }
        if (Date.now() - t0 > timeoutMs) {
          clearInterval(timer);
          reject(new Error("没有找到" + what));
        }
      }, 400);
    });
  }

  function pageProjectId() {
    var m = location.pathname.match(/\/train2\/workspace\/([^/]+)/);
    if (m) return m[1];
    var q = location.search.match(/[?&]projectId=([^&]+)/);
    return q ? decodeURIComponent(q[1]) : "";
  }

  /* 角色名只可能是路径的**最后一段**（/workspace/<项目>/member）；
     中间那些段是路由词（course / myStudy / list …）。
     旧写法抓的是第一段，于是 /course/list/member 会得出 "COURSE"，
     学分接口就按一个不存在的角色去查了。 */
  function pageRole() {
    var es = location.search.match(/[?&]examineSubstance=([^&]+)/);
    if (es) {
      var ev = decodeURIComponent(es[1]);
      if (/^[A-Za-z]/.test(ev)) return ev.toUpperCase();
    }
    var seg = location.pathname.replace(/\/+$/, "").split("/").pop() || "";
    if (/^[A-Za-z_]+$/.test(seg) && seg.length <= 16) return seg.toUpperCase();
    var q = location.search.match(/[?&]role=([^&]+)/);
    var v = q ? decodeURIComponent(q[1]) : "";
    return /^[A-Za-z]/.test(v) ? v.toUpperCase() : "MEMBER";
  }

  /* ================= 四、跨标签页协调 ================= */

  function beginWatch() {
    GM_setValue("ak_watching", true);
    GM_setValue("ak_beat", Date.now());
  }
  var lastBackTouch = 0;
  function watchHeartbeat() {
    if (GM_getValue("ak_watching")) {
      GM_setValue("ak_beat", Date.now());
      /* 看课页也算「在干活」：顺手续时间戳，否则看完被甩去项目首页时脚本不肯自己跳回来 */
      if (Date.now() - lastBackTouch > 15000) {
        lastBackTouch = Date.now();
        touchBack();
      }
    }
  }
  function endWatch() {
    GM_setValue("ak_watching", false);
    GM_setValue("ak_beat", 0);
  }
  function isWatchTabAlive() {
    if (!GM_getValue("ak_watching")) return false;
    var b = Number(GM_getValue("ak_beat") || 0);
    return Date.now() - b < 30000;
  }

  /* 工作台地址：一个键塞三样 —— 回哪、什么时候记的、看课页怎么打开的。别改用 window.opener 判断，见开发笔记 */
  function saveBack(url, mode) {
    GM_setValue("ak_back", {
      url: url,
      ts: Date.now(),
      mode: mode === "popup" ? "popup" : "same",
    });
  }
  function backRaw() {
    var b = GM_getValue("ak_back");
    if (!b) return null;
    /* 老版本存的是裸地址字符串，兼容一下；没有 mode 就当 "same" */
    if (typeof b === "string") return { url: b, ts: 0, mode: "same" };
    return {
      url: b.url || "",
      ts: Number(b.ts || 0),
      mode: b.mode === "popup" ? "popup" : "same",
    };
  }
  function backUrl() {
    var r = backRaw();
    return r ? r.url : "";
  }
  function backMode() {
    var r = backRaw();
    return r ? r.mode : "same";
  }
  function touchBack() {
    var r = backRaw();
    if (r && r.url) {
      GM_setValue("ak_back", { url: r.url, ts: Date.now(), mode: r.mode });
    }
  }
  function markBackMode(mode) {
    var r = backRaw();
    if (r && r.url) {
      GM_setValue("ak_back", { url: r.url, ts: Date.now(), mode: mode });
    }
  }
  function backFresh(ms) {
    var r = backRaw();
    return !!r && r.ts > 0 && Date.now() - r.ts < ms;
  }

  /* 自动往回跳前先看是否已跳过一次，防工作台打不开时来回跳成走马灯（放 sessionStorage，不落盘） */
  var BOUNCE_KEY = "ak_bounce_ts";
  /* 「刚才还在干活」的判定窗口：后台标签页的定时器会被拖慢到一分钟一次，3 分钟够用 */
  var BACK_FRESH_MS = 3 * 60 * 1000;
  function bouncedRecently() {
    try {
      var t = Number(sessionStorage.getItem(BOUNCE_KEY) || 0);
      return t > 0 && Date.now() - t < 15000;
    } catch (e) {
      return false;
    }
  }
  function markBounced() {
    try {
      sessionStorage.setItem(BOUNCE_KEY, String(Date.now()));
    } catch (e) {}
  }

  /* ================= 四·2、跨页记忆：这门课刚才怎么了 =================
     「达标后自动续播」最容易翻车的地方不是「续」，而是**列表不认账**：
     看课页明明提示「您已完成」，退回工作台后站点表格还是 87%（服务端有延迟），
     脚本照旧把同一门课再开一遍 —— 看着像没完没了地看同一门。
     所以看课页离开前把结论写进本地存储，列表页读到就直接跳过：
       passed  = 刚达标，先别重开（60 分钟内）
       limited = 刚到观看上限，让它先排到后面（30 分钟内）
     窗口一过记录自然失效，真没看完的课照样会被重新捡起来。
     ================================================================ */

  var SEEN_KEY = "ak_seen";
  var CUR_KEY = "ak_cur";
  var SEEN_WINDOW = {
    passed: 60 * 60 * 1000,
    limited: 30 * 60 * 1000,
  };
  /* 连播模式下要看很多门，「站点已提示完成」的课窗口拉长到 12 小时：
     否则一小时后又把它翻出来重播一遍，看着像脚本犯傻 */
  var SEEN_WINDOW_PASSED_LONG = 12 * 60 * 60 * 1000;

  function seenMap() {
    var v = GM_getValue(SEEN_KEY);
    return v && typeof v === "object" ? v : {};
  }

  function seenState(name) {
    if (!name) return "";
    var s = seenMap()[name];
    if (!s || !s.ts || !s.state) return "";
    var win =
      s.state === "passed" && autoPlayAfterPass()
        ? SEEN_WINDOW_PASSED_LONG
        : SEEN_WINDOW[s.state] || 0;
    return Date.now() - s.ts < win ? s.state : "";
  }

  function markSeen(name, state) {
    if (!name) return;
    var m = seenMap();
    m[name] = { ts: Date.now(), state: state };
    /* 只留最近 60 条，别让这个键无限长大 */
    var keys = Object.keys(m);
    if (keys.length > 60) {
      keys.sort(function (a, b) {
        return (m[b].ts || 0) - (m[a].ts || 0);
      });
      for (var i = 60; i < keys.length; i++) delete m[keys[i]];
    }
    try {
      GM_setValue(SEEN_KEY, m);
    } catch (e) {}
  }

  /* 打开课程前把标题存下来：看课页上的地址、标题都不一定带课程名 */
  function saveCurrent(name) {
    try {
      GM_setValue(CUR_KEY, { name: name || "", ts: Date.now() });
    } catch (e) {}
  }

  function currentCourse() {
    var v = GM_getValue(CUR_KEY);
    if (v && v.name && Date.now() - (v.ts || 0) < 30 * 60 * 1000) return v.name;
    return document.title || "";
  }

  /* ================= 四·3、定时复查 =================
     本页的课都「刚处理过」时不要就地空转，也别让用户自己刷新：
     隔几分钟自己再看一遍，这就是「无需手动干预」的兜底。
     同一时刻只允许挂一个复查定时器，免得越滚越多。
     ================================================ */

  var rescanTimer = null;
  var RESCAN_MS = 3 * 60 * 1000;

  function scheduleRescan(ms) {
    if (rescanTimer || !isRunning()) return;
    rescanTimer = setTimeout(function () {
      rescanTimer = null;
      if (!isRunning()) return;
      LOG("定时复查：重新扫一遍");
      logEvent("隔了几分钟，重新核对一次");
      dispatchFlow().catch(function (e) {
        LOG("复查出错：" + (e && e.message ? e.message : e));
      });
    }, ms || RESCAN_MS);
  }

  /* ================= 四·4、按页面派活 =================
     启动、停止后重启、定时复查，走的都是这一条路 —— 只有一份派活逻辑，
     才不会出现「刷新之后行为变了」这种事。
     ================================================== */

  var flowBusy = false;

  function pickFlow() {
    var href = location.href;
    if (href.indexOf("https://ipx.yanxiu.com/train2/") === 0) {
      hookNewTab();
      startCreditRefresh();
      /* /train2/ 下面不止一种页面：工作台是 .tool-card / .course-cell，
         选修课程列表页是另一套 .course-item-pane / .course-item，
         myStudy 过渡页又是一套 .tool-card.pointer —— 必须分开处理 */
      if (isCourseListPage()) return courseListFlow();
      if (isMyStudyPage()) return myStudyFlow();
      return workspaceFlow();
    }
    if (href.indexOf("https://ipx.yanxiu.com/grain/") === 0) {
      startCreditRefresh();
      return courseFlow();
    }
    if (href.indexOf("https://ipx.yanxiu.com/cms/") === 0) return strayFlow();
    return null;
  }

  /* 同一时刻只跑一条流程：连点「启动」不会叠出两条互相抢课的任务 */
  function dispatchFlow() {
    if (!isRunning()) return Promise.resolve(null);
    if (flowBusy) {
      LOG("流程正在跑，这次启动忽略");
      return Promise.resolve(null);
    }
    flowBusy = true;
    var release = function () {
      flowBusy = false;
    };
    var p;
    try {
      p = pickFlow();
    } catch (e) {
      release();
      return Promise.reject(e);
    }
    if (!p) {
      release();
      return Promise.resolve(null);
    }
    return p.then(
      function (v) {
        release();
        return v;
      },
      function (e) {
        release();
        throw e;
      },
    );
  }

  function installMenu() {
    try {
      if (typeof GM_registerMenuCommand !== "function") return;
      GM_registerMenuCommand("自动看课 · 打开设置", function () {
        openSettings();
      });
      GM_registerMenuCommand("自动看课 · 启动 / 停止", function () {
        if (isRunning()) stopWork("菜单操作");
        else startWork();
      });
    } catch (e) {}
  }

  /* ================= 五、考核规则解析 ================= */

  var UNIT_RE = /(\d+(?:\.\d+)?)\s*(分钟|小时|学时|分|个|次|篇|门|条|份|秒)/g;

  function parseAmountUnit(text) {
    var out = [],
      m;
    UNIT_RE.lastIndex = 0;
    while ((m = UNIT_RE.exec(text)) !== null) {
      out.push({ v: parseFloat(m[1]), u: m[2] });
    }
    return out;
  }

  function normalize(text) {
    var raw = parseAmountUnit(text || "");
    var map = {};
    for (var i = 0; i < raw.length; i++) {
      var v = raw[i].v,
        u = raw[i].u;
      if (u === "小时" || u === "学时") {
        v = v * 60;
        u = "分钟";
      } else if (u === "秒") {
        v = v / 60;
        u = "分钟";
      }
      map[u] = (map[u] || 0) + v;
    }
    return map;
  }

  /* 取「某种单位」的那个数：分钟和分同时出现，要能分开取 */
  function amountOf(text, unit) {
    var list = parseAmountUnit(text || "");
    for (var i = 0; i < list.length; i++) {
      if (list[i].u === unit) return list[i].v;
    }
    return null;
  }

  function isPassed(required, achieved) {
    if (!required || !achieved) return null;
    var a = normalize(required),
      b = normalize(achieved);
    var keys = Object.keys(a);
    if (!keys.length || !Object.keys(b).length) return null;
    var allOk = true;
    for (var i = 0; i < keys.length; i++) {
      var u = keys[i];
      if (!(u in b)) return null;
      if (b[u] < a[u]) allOk = false;
    }
    return allOk;
  }

  /* ================= 六、首页「板块」判断 ================= */

  function allCards() {
    return [].slice.call(document.querySelectorAll(".tool-card"));
  }

  function cardName(card) {
    var t = card.querySelector(".tool-card__title");
    return t ? t.textContent.replace(/\s+/g, " ").trim() : "";
  }

  function cardRules(card) {
    var metas = card.querySelectorAll(".tool-card__meta");
    var out = [];
    for (var i = 0; i < metas.length; i++) {
      var p = metas[i].querySelector(".tool-card__participate");
      var a = metas[i].querySelector(".tool-card__achieved");
      out.push({
        required: p ? p.textContent.replace(/\s+/g, " ").trim() : "",
        achieved: a ? a.textContent.replace(/\s+/g, " ").trim() : "",
      });
    }
    return out;
  }

  function cardRulesIncomplete(card) {
    /* 展开箭头：旧版叫 .tool-card__toggle，新版叫 .learn-course-list__toggle，两个都认。
       但**判据不能是「规则条数 <= 1」** —— 实测每张卡片本来就只有一个 .tool-card__meta
       （要求 + 已达成对塞在同一个 meta 里），那样写会让所有卡片都变成「读不全」，
       于是什么都不跳过、连已达标的必修也被重看一遍。
       真正该判的是「卡片处于收起状态、内容还没渲染」：展开态实测 title="收起"。 */
    var tg = card.querySelector(
      ".tool-card__toggle, .learn-course-list__toggle",
    );
    if (!tg) return false;
    var title = tg.getAttribute("title") || "";
    return title.indexOf("展开") > -1 && title.indexOf("收起") < 0;
  }

  function cardCourseCount(card) {
    var tags = card.querySelectorAll(".course-cell__tag");
    var must = 0,
      opt = 0;
    for (var i = 0; i < tags.length; i++) {
      if (tags[i].classList.contains("is-must")) must++;
      else if (tags[i].classList.contains("is-optional")) opt++;
    }
    return { must: must, optional: opt };
  }

  function cardType(card) {
    var name = cardName(card);
    var hasMust = name.indexOf("必修") > -1;
    var hasOptional = name.indexOf("选修") > -1;
    if (hasMust && !hasOptional) return "must";
    if (hasOptional && !hasMust) return "optional";

    var c = cardCourseCount(card);
    if (c.must > 0 && c.optional === 0) return "must";
    if (c.optional > 0 && c.must === 0) return "optional";
    if (c.must > 0 && c.optional > 0) return "both";
    return "unknown";
  }

  function cardPassed(card) {
    if (cardRulesIncomplete(card)) return null;
    var rs = cardRules(card);
    if (!rs.length) return null;
    var allRulesOk = true;
    for (var i = 0; i < rs.length; i++) {
      var ok = isPassed(rs[i].required, rs[i].achieved);
      if (ok === null) return null;
      if (!ok) allRulesOk = false;
    }
    return allRulesOk;
  }

  function cardList() {
    var cards = allCards();
    var out = [];
    for (var i = 0; i < cards.length; i++) {
      out.push({
        el: cards[i],
        label: cardName(cards[i]) || "板块" + (i + 1),
        type: cardType(cards[i]),
        passed: cardPassed(cards[i]),
        courseCount: cardCourseCount(cards[i]),
      });
    }
    return out;
  }

  /* 板块（必修 / 选修）各要多少分、已得多少分，数字直接来自页面文案，脚本不自己算分 */
  function cardScoreLine(card) {
    var name = cardName(card) || "板块";
    var passed = cardPassed(card);
    var state =
      passed === true
        ? "已达标"
        : passed === false
          ? "未达标"
          : "规则没看全，先不判";

    var rs = cardRules(card);
    if (!rs.length) return name + " · 读不到考核要求";

    var need = null,
      got = null;
    for (var i = 0; i < rs.length; i++) {
      if (need === null) need = amountOf(rs[i].required, "分");
      if (got === null) got = amountOf(rs[i].achieved, "分");
    }
    /* 不按「分」考核的项目（学时、篇数）只报状态，不硬凑数字 */
    if (need === null && got === null) return name + " · " + state;

    var gotN = got === null ? 0 : got;
    var text =
      name +
      " " +
      fmt2(gotN) +
      " / " +
      (need === null ? "?" : fmt2(need)) +
      " 分";
    text += " · " + state;
    if (passed === false && need !== null && gotN < need) {
      text += "（还差 " + fmt2(need - gotN) + "）";
    }
    return text;
  }

  function cardScoreLines() {
    var cards = allCards();
    var out = [];
    for (var i = 0; i < cards.length; i++) {
      out.push(cardScoreLine(cards[i]));
    }
    return out;
  }

  function skipPolicy() {
    var bl = cardList();
    var mustSkippable = false,
      optionalSkippable = false;
    var mustUnmet = false,
      optionalUnmet = false;
    var hasData = false;

    for (var i = 0; i < bl.length; i++) {
      var b = bl[i];
      if (b.passed === null) continue;
      hasData = true;
      var involvesMust = b.type === "must" || b.type === "both";
      var involvesOptional = b.type === "optional" || b.type === "both";
      if (b.passed) {
        if (involvesMust) mustSkippable = true;
        if (involvesOptional) optionalSkippable = true;
      } else {
        if (involvesMust) mustUnmet = true;
        if (involvesOptional) optionalUnmet = true;
      }
    }
    return {
      must: mustSkippable && !mustUnmet,
      optional: optionalSkippable && !optionalUnmet,
      hasData: hasData,
    };
  }

  function allCardsPassed() {
    var bl = cardList();
    if (!bl.length) return false;
    var hasData = false;
    for (var i = 0; i < bl.length; i++) {
      if (bl[i].passed === null) continue;
      hasData = true;
      if (!bl[i].passed) return false;
    }
    return hasData;
  }

  function skipSummary() {
    if (playThrough()) return "连播模式：已达标，继续播没看完的课";
    var f = skipPolicy();
    if (!f.hasData) return "未读取到考核信息，按顺序逐门学习";
    var arr = [];
    if (f.must) arr.push("必修（已达标）");
    if (f.optional) arr.push("选修（已达标）");
    return arr.length
      ? "已跳过：" + arr.join("、")
      : "必修、选修都还没达标，按顺序学习";
  }

  /* ================= 七、首页流程 ================= */

  function courseRows() {
    var out = [];
    var all = document.querySelectorAll("tr.el-table__row");
    for (var i = 0; i < all.length; i++) {
      if (all[i].querySelector(".course-cell")) out.push(all[i]);
    }
    return out;
  }

  function rowDone(tr) {
    var pct = tr.querySelector(".progress-cell__percent");
    if (!pct) return false;
    if (pct.classList.contains("is-done")) return true;
    return (pct.textContent || "").trim().indexOf("100%") === 0;
  }

  function rowName(tr) {
    var n = tr.querySelector(".course-cell__name");
    return n ? n.textContent.replace(/\s+/g, " ").trim() : "(未知课程)";
  }

  function rowType(tr) {
    var tag = tr.querySelector(".course-cell__tag");
    if (!tag) return "unknown";
    if (tag.classList.contains("is-must")) return "must";
    if (tag.classList.contains("is-optional")) return "optional";
    return "unknown";
  }

  function cellText(tr, sel) {
    var el = tr.querySelector(sel);
    return el ? el.textContent : "";
  }

  function durationSec(text) {
    var t = String(text == null ? "" : text);
    var h = /(\d+)\s*小时/.exec(t);
    var m = /(\d+)\s*分钟/.exec(t);
    var s = /(\d+)\s*秒/.exec(t);
    return (
      (h ? parseInt(h[1], 10) * 3600 : 0) +
      (m ? parseInt(m[1], 10) * 60 : 0) +
      (s ? parseInt(s[1], 10) : 0)
    );
  }

  function rowProgress(tr) {
    var p = tr.querySelector(".progress-cell__percent");
    if (!p) return 0;
    if (p.classList.contains("is-done")) return 1;
    var m = /(\d+(?:\.\d+)?)\s*%/.exec(p.textContent || "");
    return m ? Math.min(1, parseFloat(m[1]) / 100) : 0;
  }

  function humanDuration(sec) {
    var m = Math.round((sec || 0) / 60);
    if (m < 1) return "不到 1 分钟";
    if (m < 60) return m + " 分钟";
    var h = Math.floor(m / 60),
      r = m % 60;
    return r ? h + " 小时 " + r + " 分钟" : h + " 小时";
  }

  function hms(sec) {
    var t = Math.max(0, Math.round(sec || 0));
    var m = Math.floor(t / 60),
      s = t % 60;
    var p2 = function (n) {
      return (n < 10 ? "0" : "") + n;
    };
    if (m < 60) return m + ":" + p2(s);
    return Math.floor(m / 60) + ":" + p2(m % 60) + ":" + p2(s);
  }

  function rowCard(tr) {
    var el = tr;
    while (el && el.nodeType === 1) {
      if (el.classList && el.classList.contains("tool-card")) return el;
      el = el.parentElement;
    }
    return null;
  }

  function rowSkippable(tr, bl, f) {
    /* 连播模式：考核已全达标，但用户要「接着看」—— 一律不按板块跳过，
       只按这一门自己的进度（100% 才算完）来筛 */
    if (playThrough()) return false;

    var card = rowCard(tr);
    if (card) {
      for (var i = 0; i < bl.length; i++) {
        if (bl[i].el === card) return bl[i].passed === true;
      }
      return false;
    }

    var tp = rowType(tr);
    if (tp === "must" && f.must) return true;
    if (tp === "optional" && f.optional) return true;
    return false;
  }

  function pageSummary() {
    var rows = courseRows();
    var bl = cardList();
    var f = skipPolicy();
    var doneCount = 0,
      skipCount = 0,
      todoCount = 0,
      remainSec = 0,
      withDuration = 0;

    for (var i = 0; i < rows.length; i++) {
      if (rowDone(rows[i])) {
        doneCount++;
        continue;
      }
      if (rowSkippable(rows[i], bl, f)) {
        skipCount++;
        continue;
      }
      todoCount++;
      var d = durationSec(cellText(rows[i], ".duration"));
      if (d > 0) withDuration++;
      remainSec += d * (1 - rowProgress(rows[i]));
    }
    return {
      total: rows.length,
      doneCount: doneCount,
      skipCount: skipCount,
      todoCount: todoCount,
      remainSec: remainSec,
      withDuration: withDuration,
    };
  }

  function workspaceLiveText() {
    var sum = pageSummary();
    /* 学分下面跟着每个板块（必修 / 选修）各要多少分、已得多少分 */
    var head = [creditLine()].concat(cardScoreLines());
    if (!sum.total) return head.concat(["正在读取课程表…"]).join("\n");

    var lines = head.concat([
      "本页 " +
        sum.total +
        " 门课 · 已看完 " +
        sum.doneCount +
        " 门 · 还要看 " +
        sum.todoCount +
        " 门",
    ]);
    if (sum.skipCount)
      lines.push("跳过 " + sum.skipCount + " 门（板块已达标，不用看）");

    if (sum.todoCount > 0) {
      if (sum.withDuration > 0)
        lines.push(
          "预计还要 约 " + humanDuration(sum.remainSec) + "（按课程时长估算）",
        );
      else lines.push("页面没给出课程时长，估不出还要多久");
    }
    if (playThrough()) lines.push("连播模式：已达标，继续播没看完的课");
    if (isWatchTabAlive()) lines.push("看课页正在播，等它看完再继续");
    return lines.join("\n");
  }

  var lastOpenedUrl = null;
  var lastWindow = null;

  function hookNewTab() {
    try {
      var W =
        typeof unsafeWindow !== "undefined" && unsafeWindow
          ? unsafeWindow
          : window;
      var rawOpen = W.open;
      if (typeof rawOpen !== "function") return;
      W.open = function (url) {
        var win = rawOpen.apply(this, arguments);
        lastOpenedUrl = url;
        lastWindow = win;
        return win;
      };
    } catch (e) {}
  }

  async function openCourse(lines, fallbackBtn, backTo) {
    /* 先按 "same" 记下「看完该回哪儿」，只有真开出新标签页才升级成 "popup" —— 宁可多跳一次也不关人标签页。
       backTo 是给课程列表页用的：那边看完要回**工作台页**（好重新核对考核要求），
       不传就是本页（工作台页的老行为）。 */
    saveBack(backTo || location.href, "same");
    var beforeUrl = location.href;
    lastOpenedUrl = null;
    lastWindow = null;

    lines.click();
    await sleep(1500);

    if (!lastOpenedUrl && fallbackBtn) {
      fallbackBtn.click();
      await sleep(1500);
    }

    if (location.href !== beforeUrl) return "跳转";

    if (!lastOpenedUrl) return "没反应";

    var blocked = !lastWindow || lastWindow.closed;
    if (blocked) {
      LOG("新标签页被浏览器拦截，改为当前页跳转");
      location.href = lastOpenedUrl;
      return "跳转";
    }

    /* 到这儿才是「确实开出了一个活着的新标签页」，看课页看完可以把自己关掉 */
    markBackMode("popup");
    return "新标签页";
  }

  async function workspaceFlow() {
    setStatus("正在扫描课程表…", "running");
    setLive("正在读取页面上的课程和考核信息…");

    await waitFor([".tool-card", ".course-cell"], 25000, "课程表");
    await sleep(1500);

    var allPassed = allCardsPassed();
    /* 先落标记：后面的 skipSummary / rowSkippable / 课程列表页都靠它判断「是不是连播」 */
    setAllPassed(allPassed);

    startLiveRefresh(workspaceLiveText);
    logEvent("读到本页 " + courseRows().length + " 门课；" + skipSummary());
    /* 把「必修 / 选修 要求与已达」存下来：课程列表页要靠它判断还要不要继续看 */
    saveCardRequirement();

    if (allPassed && !autoPlayAfterPass()) {
      setStatus("全部完成，没有要看的课了", "done");
      setDetail(
        "必修和选修的考核都已经达标。\n" +
          "想要接着把没看完的课播完，在「⚙ 设置」里打开「必修、选修都达标后继续连播」。",
      );
      logEvent("必修、选修都已达标，不再继续看课");
      return;
    }

    if (allPassed) {
      setStatus("已达标 · 连播模式继续学习", "running");
      logEvent("必修、选修都已达标 —— 连播模式：继续播没看完的课");
    }

    var deadRows = {};
    var deadStreak = 0;
    /* 连播模式下「本页没课了」还要再去课程列表页看一眼，但一次流程只去一趟，防来回跳 */
    var triedList = false;
    /* 一门课在等待期间最多等多久：看了多久由看课页自己掐，这边只做兜底 */
    var waitMax = (watchLimitMs() || 45 * 60 * 1000) + 5 * 60 * 1000;

    /* 连播模式下要看的课更多，允许更多轮，别走两下就撞上限 */
    var maxAttempt = playThrough() ? 200 : 60;

    for (var attempt = 0; attempt < maxAttempt; attempt++) {
      if (halted()) {
        LOG("已停止，退出工作台流程");
        return;
      }
      touchBack();
      var rows = courseRows();
      var f = skipPolicy();
      var bl = cardList();
      var target = null;
      var seenSkip = 0;

      for (var i = 0; i < rows.length; i++) {
        if (rowDone(rows[i])) continue;
        var rowKey = rowName(rows[i]);
        if (deadRows[rowKey]) continue;
        if (rowSkippable(rows[i], bl, f)) continue;
        /* 这门课刚处理过：要么已达标（站点进度还没刷新），要么刚到观看上限。
           先让别的课排前面，省得在原地反复开同一门。 */
        if (seenState(rowKey)) {
          seenSkip++;
          continue;
        }
        target = rows[i];
        break;
      }

      if (!target) {
        var nextPage = document.querySelector(
          ".el-pagination .btn-next:not([disabled])",
        );
        if (nextPage) {
          setStatus("翻到下一页…", "running");
          nextPage.click();
          await sleep(2500);
          continue;
        }

        /* 本页没课可看了。但**还有板块没达标**的话绝不能报「全部完成」——
           选修的课压根不在这一页，它在 /course/list/member 那一页。
           旧版本就是在这儿骗了人：选修没达标、页面上又没选修课，于是说「全部完成」。 */
        var unmet = unmetCards();
        if (unmet.length) {
          var went = await gotoOptionalList();
          if (went === "nav") return;
          if (went === "inline") return courseListFlow();
          setStatus("本页没有要看的课了，但有板块还没达标", "skip");
          setDetail(
            "还没达标：\n" +
              unmetText() +
              "\n\n这些板块的课不在本页。选修的课在「我的学习 → 网络学习 → 看课」那一页，\n" +
              "手动打开一次，脚本会记住它，以后自动去。",
          );
          logEvent(
            "本页没有可看的课，但还有 " + unmet.length + " 个板块没达标",
          );
          return;
        }

        /* 连播模式：本页没课了 ≠ 全部课都看完了 —— 选修的课在课程列表页那一张表上，
           过去接着播。每门看完都会回工作台重新核对，所以不会死循环；
           一次流程只去一趟（triedList），跳不过去就老实收工。 */
        if (playThrough() && !triedList) {
          triedList = true;
          var wentPt = await gotoOptionalList();
          if (wentPt === "nav") return;
          if (wentPt === "inline") return courseListFlow();
        }

        /* 本页的课都「刚处理过」：要么刚达标、站点还没刷新进度，要么刚到观看上限。
           不用你手动刷新，过几分钟脚本自己回来再看一遍。 */
        if (seenSkip > 0) {
          setStatus("本页的课都刚处理过，稍后自动再看", "skip");
          setDetail(
            "有 " +
              seenSkip +
              " 门课刚看过（已达标或到观看上限），站点的进度表还没跟上。\n" +
              "过几分钟脚本会自己回来重新核对，不用手动刷新。",
          );
          logEvent("本页 " + seenSkip + " 门课刚处理过，安排稍后复查");
          scheduleRescan();
          return;
        }

        if (playThrough()) {
          setStatus("连播结束 · 本页的课都看完了", "done");
          setDetail(
            "连播模式：这一页所有课的进度都到 100% 了，没有可播的了。\n" +
              "站点加了新课程的话，刷新一下页面就会接着播。",
          );
          logEvent("连播模式：本页的课都看完了");
          return;
        }

        setStatus("全部完成，没有要看的课了", "done");
        setDetail("本页已全部处理完毕。\n如果还想继续看，可以手动打开课程。");
        logEvent("本页处理完毕，没有要看的课了");
        return;
      }

      var rowTitle = rowName(target);
      setStatus("正在打开：" + rowTitle.slice(0, 14), "running");
      logEvent("打开：" + rowTitle);

      /* 告诉看课页「你正在看的是哪一门」，达标 / 到上限时它才知道该记在谁头上 */
      saveCurrent(rowTitle);
      beginWatch();
      var fallback = target.querySelector(".actions .btn--primary");
      var outcome = await openCourse(target, fallback);

      if (outcome === "跳转") return;

      if (outcome === "没反应") {
        endWatch();
        deadRows[rowTitle] = true;
        deadStreak++;
        logEvent("「" + rowTitle + "」点了没反应，先跳过它");
        if (deadStreak >= 5) {
          setStatus("多门课都打不开，已停止", "error");
          setError(
            "连续 " +
              deadStreak +
              " 门课点击后没有反应。\n" +
              "可能是课程已关闭，或者页面需要刷新。\n点「重新开始」试试。",
          );
          return;
        }
        continue;
      }

      deadStreak = 0;
      var t0 = Date.now();
      var lastTouch = 0;
      while (isWatchTabAlive() && !halted()) {
        if (Date.now() - t0 > waitMax) {
          LOG("等待超时，强制继续");
          logEvent("等太久了，不再等，继续下一门");
          endWatch();
          break;
        }
        var sec = Math.round((Date.now() - t0) / 1000);
        /* 隔一会儿续一次时间戳；按「距上次过了多久」判断，不看 sec 能否被 15 整除（睡 2 秒 + 四舍五入，轮不到） */
        if (Date.now() - lastTouch > 15000) {
          lastTouch = Date.now();
          touchBack();
        }
        setStatus(
          "看课页正在播 " + Math.floor(sec / 60) + " 分 " + (sec % 60) + " 秒",
          "running",
        );
        await sleep(2000);
      }
      endWatch();
      /* 用户按了停止：别再去刷新学分、也别再挑下一门 */
      if (halted()) {
        LOG("已停止，退出工作台流程");
        return;
      }
      await sleep(2000);
      var summary = pageSummary();
      logEvent(
        "「" +
          rowTitle +
          "」这一轮结束（本页还剩 " +
          summary.todoCount +
          " 门要学）",
      );
      fetchCredits(true);
    }
  }

  /* ================= 七·2、选修课程列表页 =================
     选修的课**不在工作台页面上**。路径是：
       我的学习 → 网络学习 → 看课
         → /train2/workspace/<项目>/course/list/member?projectId=..&role=100&toolId=..&stageId=..
     那一页用的是另一套组件（.course-item-pane / .course-item / .learn-btn），
     跟工作台页的 .tool-card / .course-cell 毫无关系 —— 拿工作台的选择器去扫，
     一个都命中不了，等 25 秒后报「出了点问题」，用户看到的就是「选修被整个屏蔽」。

     这里的做法：
       1) 在课程列表页上把地址记进本地存储（不去猜 toolId / stageId：
          实测这两个 ID 既不在 DOM 属性里、也不在内联 script 里）；
       2) 工作台页发现「还有板块没达标、但本页一门课都看不了」时，跳过去；
       3) 每看完一门就回工作台页 —— 那边会重新读一次考核要求，
          达标了就不会再跳过来，所以不会没完没了地看下去。
     ========================================================= */

  var OPT_KEY = "ak_opt";
  /* 同一门课 90 分钟内不重复打开：防止「看完了但页面没更新」时来回死循环 */
  var OPT_OPEN_WINDOW = 90 * 60 * 1000;
  /* 连播模式下要几门课轮着播，90 分钟太久会把所有课全锁死、脚本干等着；
     收窄到 20 分钟，转完一圈还能接着看 */
  var PT_OPEN_WINDOW = 20 * 60 * 1000;

  function olTxt(s) {
    return String(s == null ? "" : s)
      .replace(/\s+/g, " ")
      .trim();
  }

  function olStore() {
    var v = GM_getValue(OPT_KEY);
    return v && typeof v === "object" ? v : {};
  }

  function olEntry(pid) {
    var s = olStore();
    return (pid && s[pid]) || {};
  }

  function olSave(pid, patch) {
    if (!pid) return;
    var s = olStore();
    var e = s[pid] || {};
    for (var k in patch) {
      if (Object.prototype.hasOwnProperty.call(patch, k)) e[k] = patch[k];
    }
    e.ts = Date.now();
    s[pid] = e;
    /* 只留最近 5 个项目，别让这个键无限长大 */
    var keys = Object.keys(s);
    if (keys.length > 5) {
      keys.sort(function (a, b) {
        return (s[b].ts || 0) - (s[a].ts || 0);
      });
      for (var i = 5; i < keys.length; i++) delete s[keys[i]];
    }
    try {
      GM_setValue(OPT_KEY, s);
    } catch (e2) {}
  }

  function workspaceUrl(pid) {
    return pid
      ? "https://ipx.yanxiu.com/train2/workspace/" + pid + "/member"
      : "";
  }

  function isCourseListPage() {
    if (location.pathname.indexOf("/course/list/") > -1) return true;
    return document.querySelectorAll(".course-item-pane").length > 0;
  }

  /* 只在真正的 /course/list/ 地址上记 —— 万一站点是「就地渲染」出课程列表的，
     记下来的会是工作台地址，下次跳过去就白跳了 */
  function rememberOptionalListUrl() {
    if (location.pathname.indexOf("/course/list/") < 0) return;
    var pid = pageProjectId();
    if (!pid) return;
    /* 一条课程都没有的页面不算数：脚本会自己拼地址去试，试错的地址绝不能被记下来 */
    if (!document.querySelector(".course-item")) return;
    var u = location.href.split("#")[0];
    if (olEntry(pid).url !== u) {
      olSave(pid, { url: u });
      LOG("记住了课程列表页：" + u);
    } else {
      olSave(pid, {});
    }
    /* 落地成功了，把「刚才是在试拼地址」的标记清掉 */
    clearGuess();
  }

  /* 工作台页把「必修 / 选修 的要求与已达」存下来，给课程列表页判断还要不要看 */
  function saveCardRequirement() {
    var pid = pageProjectId();
    if (!pid) return;
    var cards = allCards();
    var rec = { ts: Date.now() };
    for (var i = 0; i < cards.length; i++) {
      var t = cardType(cards[i]);
      if (t !== "must" && t !== "optional" && t !== "both") continue;
      var rs = cardRules(cards[i]);
      var r0 = rs.length ? rs[0] : { required: "", achieved: "" };
      var one = {
        required: r0.required,
        achieved: r0.achieved,
        passed: cardPassed(cards[i]),
        rows: cardCourseCount(cards[i]),
      };
      if (t === "must" || t === "both") rec.must = one;
      if (t === "optional" || t === "both") rec.optional = one;
    }
    olSave(pid, { req: rec });
    LOG("记下考核要求：" + JSON.stringify(rec));
  }

  /* 还没达标的板块（passed === false；null 是「读不全，不判定」） */
  function unmetCards() {
    var bl = cardList();
    var out = [];
    for (var i = 0; i < bl.length; i++) {
      if (bl[i].passed === false) out.push(bl[i]);
    }
    return out;
  }

  function unmetText() {
    var out = unmetCards();
    var lines = [];
    for (var i = 0; i < out.length; i++) {
      var rs = cardRules(out[i].el);
      var r0 = rs.length ? rs[0] : { required: "?", achieved: "?" };
      lines.push(
        "· " +
          out[i].label +
          "：" +
          r0.achieved +
          "（要求 " +
          r0.required +
          "）",
      );
    }
    return lines.join("\n");
  }

  /* 工作台左侧「阶段 → 工具」里的「看课」入口。
     实测结构：ul.stage-item__tools > li.tool-line > i.tool-type-icon.learn_course + span.tool-title
     注意：诊断 5 确认这个「看课」是**同页切换工具面板**（在工作台内显示必修/选修卡片），
     不跳转 —— 所以第 ② 条路不再用它（改用 findNetStudyEntry）。保留以备诊断。 */
  function findWatchToolEntry() {
    var lines = document.querySelectorAll(".stage-item__tools .tool-line");
    for (var i = 0; i < lines.length; i++) {
      if (lines[i].querySelector(".tool-type-icon.learn_course"))
        return lines[i];
      var t = lines[i].querySelector(".tool-title");
      if (t && olTxt(t.textContent).indexOf("看课") > -1) return lines[i];
    }
    return null;
  }

  /* ---------- 第 ② 条路（改）：点右侧考核面板的「网络学习」项 ----------
     诊断 5/7 确认的正确导航路径是两步：
       工作台 → 点右侧 .project-assessment 里文本含「网络学习」的项
         → /myStudy/member?tab=net（过渡页）
       → 点 .tool-card.pointer 里文本含「选修课」的卡（或其「查看」按钮）
         → /course/list/member?...&toolId=..&stageId=..（课程列表页）

     旧版第 ② 条点的是左侧「看课」.tool-line —— 那是同页切换工具面板，不跳转，
     所以在真站上永远走不通，用户看到的就是「每次都显示上次记下来的」。 */

  /* 工作台页：右侧考核面板里文本含「网络学习」的可点项。
     结构（诊断 5 A-3）：div.assess-item > div.info > div.name「网络学习 22.88/100分」
     点击是 Vue 绑的（没有 href/onclick），点 .assess-item 整项即可跳 myStudy。 */
  function findNetStudyEntry() {
    /* 右侧考核面板里的每一项 */
    var items = document.querySelectorAll(
      ".project-assessment .assess-item, .assess-list .assess-item",
    );
    for (var i = 0; i < items.length; i++) {
      var t = olTxt(items[i].textContent);
      if (t.indexOf("网络学习") > -1) return items[i];
    }
    /* 兜底：整页找文本含「网络学习」、且像个可点考核项的元素 */
    var nodes = document.querySelectorAll(
      ".assess-item, .piece-item, .score-name-wrapper",
    );
    for (var j = 0; j < nodes.length; j++) {
      if (olTxt(nodes[j].textContent).indexOf("网络学习") > -1) return nodes[j];
    }
    return null;
  }

  /* myStudy 过渡页：文本含「选修课」的 .tool-card.pointer（或其「查看」按钮）。
     结构（诊断 7）：div.tool-card.pointer > div.left > div.left-right > div.flex > p.name「选修课」
                              + div.right > button.el-button「查看」 */
  function findOptionalCardOnMyStudy() {
    var cards = document.querySelectorAll(".tool-card.pointer");
    for (var i = 0; i < cards.length; i++) {
      var name = cards[i].querySelector("p.name, .name");
      if (name && olTxt(name.textContent).indexOf("选修") > -1) return cards[i];
    }
    /* 兜底：按文本找 */
    cards = document.querySelectorAll(".tool-card");
    for (var j = 0; j < cards.length; j++) {
      if (olTxt(cards[j].textContent).indexOf("选修课") > -1) return cards[j];
    }
    return null;
  }

  function isMyStudyPage() {
    return location.pathname.indexOf("/myStudy/") > -1;
  }

  /* myStudy 过渡页的流程：点「选修课」卡跳到课程列表页。
     只做这一件事 —— 这页是工作台和课程列表页之间的过渡页。 */
  async function myStudyFlow() {
    setStatus("在网络学习页找选修课…", "running");
    setLive("正在找「选修课」入口…");

    var card = null;
    try {
      card = await waitFor([".tool-card.pointer"], 15000, "选修课卡片");
      /* waitFor 返回的是第一个匹配的，但可能不是选修课那张 —— 重新定位 */
      card = findOptionalCardOnMyStudy();
    } catch (e) {
      card = findOptionalCardOnMyStudy();
    }

    if (!card) {
      setStatus("网络学习页上没找到「选修课」", "error");
      setError(
        "这一页应该有「必修课 / 选修课」几张卡片，但没找到含「选修」字样的那张。\n" +
          "可能是页面没加载完，刷新一下再试。",
      );
      logEvent("myStudy 页没找到选修课卡片");
      return;
    }

    var pid = pageProjectId();
    /* 看完课回工作台页（不是回这个过渡页） */
    var home = workspaceUrl(pid);
    saveBack(home || location.href, "same");

    /* 优先点「查看」按钮（最明确的可点元素），其次点整张卡 */
    var btn = card.querySelector("button, .btn, .el-button");
    var target = btn || card;

    setStatus("正在打开选修课程…", "running");
    logEvent(
      "在 myStudy 页点「选修课」" + (btn ? "（查看按钮）" : "（整张卡）"),
    );
    var beforeUrl = location.href;
    target.click();

    /* 等它跳走 —— 这页点完应该到 course/list 页。
       和上一跳一样是**站内路由**：判据不是「地址变没变」，而是「地址变了之后我们还在不在跑」。
       还在跑 = 页面没重载 = 课程列表页的流程不会自己起来，得在这儿把它接上。
       （原地渲染出课程列表的情况也在这里一起兜住。） */
    for (var i = 0; i < 20; i++) {
      await sleep(600);
      if (isCourseListPage()) {
        logEvent(
          location.href !== beforeUrl
            ? "已到课程列表页（站内跳转，脚本自己接着跑）"
            : "课程列表就地渲染出来了，脚本接着跑",
        );
        stopLiveRefresh();
        await courseListFlow();
        return;
      }
    }

    setStatus("点了选修课但没跳转", "error");
    setError(
      "点了「选修课」卡片，但页面没有跳到课程列表。\n可能站点的点击逻辑变了。",
    );
    logEvent("myStudy 页点选修课后没跳转");
  }

  /* ---------- 第三条路：自己拼一条地址去试 ----------
     诊断里那串真实地址是
       /course/list/member?projectId=..&role=100&toolId=..&stageId=..&examineSubstance=MEMBER
     其中 toolId / stageId 拿不到（不在 DOM、也不在内联 script 里），但这一页本来就是
     「该工具下的全部课程」列表 —— 不带这两个参数也许照样能打开。
     所以先拼一条试；成不成由落地页面判断（courseListFlow 读不到 .course-item 就退回工作台），
     失败一次就记 guessBad，不再反复试。 */

  var OPT_GUESS_KEY = "ak_optguess";

  function markGuess() {
    try {
      GM_setValue(OPT_GUESS_KEY, Date.now());
    } catch (e) {}
  }
  function guessFresh() {
    var t = Number(GM_getValue(OPT_GUESS_KEY) || 0);
    return t > 0 && Date.now() - t < 60000;
  }
  function clearGuess() {
    try {
      GM_setValue(OPT_GUESS_KEY, 0);
    } catch (e) {}
  }

  function guessListUrl(pid) {
    if (!pid) return "";
    /* role=100 是诊断里那串真实地址上的值（学员身份） */
    return (
      "https://ipx.yanxiu.com/train2/workspace/" +
      pid +
      "/course/list/member?projectId=" +
      encodeURIComponent(pid) +
      "&role=100&examineSubstanceRole=0&examineSubstance=" +
      encodeURIComponent(pageRole())
    );
  }

  /* 拼出来的地址没渲染出课程：退回工作台，并记下这条路不通 */
  function guessFailed(pid) {
    var home = workspaceUrl(pid);
    if (guessFresh() && home) {
      clearGuess();
      olSave(pid, { guessBad: true });
      setStatus("自动拼的地址走不通，正在回工作台…", "skip");
      logEvent("拼出来的课程列表页没有课程，记下这条路不通，退回工作台");
      location.href = home;
      return;
    }
    setStatus("这个页面没有课程列表", "skip");
    setDetail(
      "这一页没找到任何课程。\n如果是脚本自己跳过来的，说明这条自动拼的地址不对。",
    );
    logEvent("页面上没有 .course-item");
  }

  /* 从工作台跳到课程列表页。
     返回 "nav" = 正在跳走；"inline" = 站点就地渲染出了课程列表；"" = 跳不过去
     三条路是「前一条成了就不试后面」：① 记住的地址 → ② 点「网络学习」→ ③ 自己拼地址。
     其中 ② **一旦点到就终结**（点不动也返回 ""，不落到 ③）—— 见下面那段注释。 */
  async function gotoOptionalList() {
    var pid = pageProjectId();
    if (!pid) return "";

    /* 1) 地址记过就直接用 —— 最可靠，不猜 */
    var url = olEntry(pid).url;
    if (url) {
      setStatus("选修的课在另一个页面，正在过去…", "running");
      setLive("正在跳到课程列表页…");
      logEvent("跳到课程列表页（地址是上次记下来的）");
      saveBack(url, "same");
      await sleep(800);
      location.href = url;
      return "nav";
    }

    /* 2) 没记过：点右侧考核面板的「网络学习」项 → 跳到 myStudy 过渡页
          → 那边的 myStudyFlow 会继续点「选修课」跳到课程列表页。
          （旧版点的是左侧「看课」.tool-line，但那只是同页切换工具面板，不跳转 —— 等于死路。）

         这条路是**终点**：只要页面上有「网络学习」入口、也点了，就不许再往下掉到第 ③ 条。
         入口明明在、点了却没反应 = 站点这边变了，如实报「跳不过去」让用户自己去看一眼，
         比偷偷去拼一条地址强。 */
    var entry = findNetStudyEntry();
    if (entry) {
      var before = location.href;
      setStatus("正在打开网络学习…", "running");
      logEvent("还不知道课程列表页地址，先点「网络学习」去过渡页");
      saveBack(workspaceUrl(pid) || location.href, "same");
      entry.click();
      for (var i = 0; i < 12; i++) {
        await sleep(600);
        if (location.href !== before) {
          /* 地址变了、可这段代码还在往下跑 —— 这一定是**站内路由**跳的
             （真·整页跳转的话，这个 JS 上下文早被销毁，根本执行不到这里）。
             页面没重载 → boot() 不会重跑 → 过渡页的流程根本起不来。
             所以必须自己接下去，否则脚本就停在这一页上不动了。 */
          if (isMyStudyPage()) {
            logEvent("已到 myStudy 过渡页（站内跳转，脚本自己接着跑）");
            stopLiveRefresh();
            await myStudyFlow();
          }
          return "nav";
        }
        if (isMyStudyPage()) return "nav";
      }
      /* 点了没跳 —— 到此为止，绝不掉到第 ③ 条。理由：
         拼出来的地址缺 toolId / stageId（这两个拿不到），落不到课 →
         guessFailed() 会把本项目的 guessBad **永久**标死，等于把「这一次失败」
         升级成「这条路以后也别试」。为一次没反应的点击赔上整条退路，不值。 */
      setStatus("点了「网络学习」但页面没跳转", "skip");
      logEvent("点「网络学习」没跳转 —— 入口在却没反应，不再往下试拼地址");
      return "";
    }

    /* 3) 最后自己拼一条地址试。成不成由 courseListFlow 落地后判断：
          读不到课程就自动退回工作台，并记下 guessBad，不再反复试。 */
    if (!olEntry(pid).guessBad) {
      var guess = guessListUrl(pid);
      if (guess) {
        setStatus("正在试一条自动拼的地址…", "running");
        logEvent("试拼课程列表页地址：" + guess);
        markGuess();
        saveBack(workspaceUrl(pid), "same");
        await sleep(600);
        location.href = guess;
        return "nav";
      }
    }
    return "";
  }

  /* ---------- 课程列表页的选择器 ---------- */

  function olPanes() {
    return [].slice.call(document.querySelectorAll(".course-item-pane"));
  }

  function olItems(pane) {
    return [].slice.call(pane.querySelectorAll(".course-item"));
  }

  /* pane 标题里带「来源：必修课 / 来源：选修课」；没有就退回看条目标签 */
  function olPaneKind(pane) {
    var h = pane.querySelector(".course-pane-header");
    var t = h ? olTxt(h.textContent) : "";
    if (t.indexOf("来源：选修课") > -1) return "optional";
    if (t.indexOf("来源：必修课") > -1) return "must";
    var tags = pane.querySelectorAll(".item-info-tag");
    var m = 0,
      o = 0;
    for (var i = 0; i < tags.length; i++) {
      var s = olTxt(tags[i].textContent);
      if (s.indexOf("选修") > -1) o++;
      else if (s.indexOf("必修") > -1) m++;
    }
    if (o > 0 && m === 0) return "optional";
    if (m > 0 && o === 0) return "must";
    return "unknown";
  }

  function olItemTitle(it) {
    var t = it.querySelector(".item-info-title");
    return t ? olTxt(t.textContent) : "";
  }

  /* 「已观看 54%」—— 没有这个元素时返回 -1（未知） */
  function olItemPercent(it) {
    var s = it.querySelector(".learn-status");
    if (!s) return -1;
    var m = olTxt(s.textContent).match(/(\d+(?:\.\d+)?)\s*%/);
    return m ? parseFloat(m[1]) : -1;
  }

  /* 真正能点的是里面的 <button>，.learn-btn 只是个壳 */
  function olItemBtn(it) {
    return (
      it.querySelector(".learn-btn button") || it.querySelector(".learn-btn")
    );
  }

  /* 只有确凿证据才算「看完了」。拿不准就当没看完 —— 宁可多看一遍，也别把没看的课跳过去 */
  function olItemDone(it) {
    if (olItemPercent(it) >= 100) return true;
    var b = olItemBtn(it);
    if (!b) return false;
    if (b.disabled === true || b.getAttribute("aria-disabled") === "true")
      return true;
    return /已完成|已学完|已通过/.test(olTxt(b.textContent));
  }

  function olOpenedMap(pid) {
    var o = olEntry(pid).opened || {};
    var out = {};
    var now = Date.now();
    var win = playThrough() ? PT_OPEN_WINDOW : OPT_OPEN_WINDOW;
    for (var k in o) {
      if (Object.prototype.hasOwnProperty.call(o, k) && now - o[k] < win)
        out[k] = o[k];
    }
    return out;
  }

  function olMarkOpened(pid, title) {
    if (!pid || !title) return;
    var o = olOpenedMap(pid);
    o[title] = Date.now();
    olSave(pid, { opened: o });
  }

  function olNextPageBtn(pane) {
    return (
      pane.querySelector(".el-pagination .btn-next:not([disabled])") ||
      pane.querySelector(".app-pagination .btn-next:not([disabled])")
    );
  }

  /* 找一门「没看完、板块没达标、最近没打开过」的课；本页找不着就逐页往后翻 */
  async function olFindTarget(pid, skipMust, skipOpt) {
    var opened = olOpenedMap(pid);
    var panes = olPanes();
    for (var pi = 0; pi < panes.length; pi++) {
      if (halted()) return null;
      var kind = olPaneKind(panes[pi]);
      if (kind === "must" && skipMust) continue;
      if (kind === "optional" && skipOpt) continue;
      for (var page = 0; page < 8; page++) {
        var its = olItems(panes[pi]);
        for (var i = 0; i < its.length; i++) {
          if (olItemDone(its[i])) continue;
          var t = olItemTitle(its[i]);
          if (opened[t]) continue;
          /* 同一门刚达标 / 刚到上限：让别的课先上 */
          if (seenState(t)) continue;
          return its[i];
        }
        var next = olNextPageBtn(panes[pi]);
        if (!next) break;
        setStatus("往后翻一页找没看的课…", "running");
        next.click();
        await sleep(1600);
      }
    }
    return null;
  }

  async function courseListFlow() {
    var pid = pageProjectId();

    setStatus("正在扫描课程列表…", "running");
    setLive("正在读取这一页的课程…");

    /* 别等满 25 秒：这一页可能是脚本自己拼地址试出来的，可能压根没有课程。
       只有真读到课程才算「这一页有用」，也才值得把地址记下来。 */
    try {
      await waitFor([".course-item"], 10000, "课程列表");
    } catch (e) {
      return guessFailed(pid);
    }
    await sleep(1000);
    rememberOptionalListUrl();

    var req = olEntry(pid).req || {};
    var reqMustPassed = !!(req.must && req.must.passed === true);
    var reqOptPassed = !!(req.optional && req.optional.passed === true);
    /* 只有必修的项目 req.optional 是空的，光看 req 会漏判；工作台写的 ak_pt 更准，两边取并集 */
    var allPassed = isAllPassed() || (reqMustPassed && reqOptPassed);
    /* 连播模式：全达标也不跳过任何板块，只按「这门课看完没」筛 */
    var pt = autoPlayAfterPass() && allPassed;
    var skipMust = !pt && reqMustPassed;
    var skipOpt = !pt && reqOptPassed;

    var panes = olPanes();
    var brief = [];
    for (var i = 0; i < panes.length; i++) {
      var its = olItems(panes[i]);
      var todo = 0;
      for (var j = 0; j < its.length; j++) {
        if (!olItemDone(its[j])) todo++;
      }
      brief.push(olPaneKind(panes[i]) + " 没看完 " + todo + "/" + its.length);
    }
    logEvent("课程列表页 " + panes.length + " 个板块：" + brief.join("；"));
    setLive(
      "本页 " +
        panes.length +
        " 个板块、" +
        document.querySelectorAll(".course-item").length +
        " 门课\n" +
        brief.join("\n"),
    );

    if (pt) {
      setStatus("已达标 · 连播模式继续学习", "running");
      logEvent("连播模式：必修、选修都已达标，继续播没看完的课");
    } else if (skipMust && skipOpt) {
      setStatus("必修、选修都已达标，不用再看了", "done");
      setDetail(
        "工作台页读到的考核显示必修、选修都已达标。\n" +
          "想继续把没看完的课播完，去「⚙ 设置」打开「必修、选修都达标后继续连播」。",
      );
      logEvent("缓存的考核显示必修、选修都已达标，跳过");
      return;
    }

    var target = await olFindTarget(pid, skipMust, skipOpt);
    if (!target) {
      var rest = [];
      if (!skipMust) rest.push("必修");
      if (!skipOpt) rest.push("选修");

      /* 连播模式：这一页翻遍了也没课可播，多半是站点进度还没跟上，
         别报「没找到」就撒手，隔几分钟自己回来再看一遍 */
      if (pt) {
        setStatus("连播中 · 这一页暂时没可播的了", "skip");
        setDetail(
          "连播模式：这一页的课都看过了，站点的进度可能还没刷新。\n" +
            "过几分钟脚本会自己回来重新核对，不用手动刷新。",
        );
        logEvent("连播模式：本页没有可播的课，安排稍后复查");
        scheduleRescan();
        return;
      }

      setStatus(
        rest.length ? "这一页没有要看的课了" : "没有要看的课了",
        rest.length ? "skip" : "done",
      );
      setDetail(
        rest.length
          ? "这一页翻遍了也没找到没看完的课，但「" +
              rest.join("、") +
              "」还没达标。\n回到工作台页会重新核对一次考核要求。"
          : "这一页的课都看完了。",
      );
      logEvent(
        "课程列表页没找到目标课（还缺 " + (rest.join("、") || "无") + "）",
      );
      return;
    }

    var title = olItemTitle(target);
    var pct = olItemPercent(target);
    setStatus("正在打开：" + title.slice(0, 14), "running");
    logEvent("打开：" + title + (pct >= 0 ? "（已观看 " + pct + "%）" : ""));

    olMarkOpened(pid, title);
    /* 这一页的课程名要交给看课页：达标 / 到上限时它按这个名字记账 */
    saveCurrent(title);
    beginWatch();

    /* 看完回工作台页 —— 那边会重新读一次考核要求，达标了就不会再跳过来 */
    var home = workspaceUrl(pid);

    var btn = olItemBtn(target);
    var wrap = target.querySelector(".course-item-info-wrap");
    var outcome = await openCourse(btn || wrap, btn ? wrap : null, home);

    if (outcome === "跳转") return;

    if (outcome === "没反应") {
      endWatch();
      setStatus("这一门点不开，先跳过", "error");
      logEvent("「" + title + "」点了没反应");
      setDetail(
        "「" +
          title +
          "」点了没反应，可能是课程已关闭。\n" +
          "刷新这一页会挑下一门（同一门课 90 分钟内不会重复试）。",
      );
      return;
    }

    var t0 = Date.now();
    var lastTouch = 0;
    var waitMax = (watchLimitMs() || 45 * 60 * 1000) + 5 * 60 * 1000;
    while (isWatchTabAlive() && !halted()) {
      if (Date.now() - t0 > waitMax) {
        LOG("等待超时，强制继续");
        logEvent("等太久了，不再等，继续下一门");
        endWatch();
        break;
      }
      var sec = Math.round((Date.now() - t0) / 1000);
      if (Date.now() - lastTouch > 15000) {
        lastTouch = Date.now();
        touchBack();
      }
      setStatus(
        "看课页正在播 " + Math.floor(sec / 60) + " 分 " + (sec % 60) + " 秒",
        "running",
      );
      await sleep(2000);
    }
    endWatch();
    if (halted()) {
      LOG("已停止，不再跳回工作台");
      return;
    }
    await sleep(1500);

    if (home) {
      logEvent("这一门结束，回工作台页重新核对考核");
      location.href = home;
    } else {
      location.reload();
    }
  }

  /* ================= 八、看课页流程 ================= */

  function findVideo() {
    return (
      document.querySelector(".vcp-player video") ||
      document.querySelector(".player-wrapper video") ||
      document.querySelector("video")
    );
  }

  function timerText() {
    var a = document.querySelector(".action-timer");
    if (!a) return "";
    var s = a.querySelector("span");
    return s ? s.textContent : "";
  }

  function isCourseFinished() {
    var a = document.querySelector(".action-timer");
    return !!a && a.textContent.indexOf("您已完成") !== -1;
  }

  var lastPlayAttempt = 0;

  function clickBigPlay() {
    var b = document.querySelector(".vcp-bigplay");
    if (b) b.click();
  }

  function tryPlay() {
    var v = findVideo();
    if (!v) return;
    if (!v.paused) return;
    if (isMuted()) {
      try {
        v.muted = true;
      } catch (e) {}
    }

    var p = null;
    try {
      p = v.play();
    } catch (e) {
      p = null;
    }

    if (!p || typeof p.then !== "function") {
      clickBigPlay();
      return;
    }
    p.catch(function () {
      if (!v.muted) {
        try {
          v.muted = true;
        } catch (e) {}
        var p2 = null;
        try {
          p2 = v.play();
        } catch (e) {
          p2 = null;
        }
        if (p2 && typeof p2.then === "function") {
          p2.catch(function () {
            clickBigPlay();
          });
          return;
        }
      }
      clickBigPlay();
    });
  }

  function keepMuted() {
    if (!isMuted()) return;
    setInterval(function () {
      var v = findVideo();
      if (v && !v.muted) v.muted = true;
    }, 500);
  }

  var currentRes = null;
  var curSegIndex = 0;

  function escalate(n) {
    var v = findVideo();
    if (n === 1) {
      if (v) {
        try {
          v.muted = true;
        } catch (e) {}
        try {
          v.play();
        } catch (e) {}
      }
      return;
    }
    if (n === 2) {
      var bigPlay = document.querySelector(".vcp-bigplay");
      if (bigPlay) {
        bigPlay.click();
        return;
      }
      var playToggle = document.querySelector(".vcp-playtoggle");
      if (playToggle) playToggle.click();
      return;
    }
    if (n === 3) {
      if (v) {
        try {
          v.click();
        } catch (e) {}
        try {
          v.dispatchEvent(
            new MouseEvent("click", { bubbles: true, cancelable: true }),
          );
        } catch (e) {}
      }
      var container =
        document.querySelector(".vcp-player") ||
        document.querySelector(".player-wrapper");
      if (container) {
        try {
          container.click();
        } catch (e) {}
      }
      return;
    }
    if (currentRes) {
      var p = currentRes.querySelector("p");
      if (p) p.click();
    }
  }

  /* deadline = 这门课的总截止时间戳（0 = 不限）。
     「到点」优先于「看完」以外的任何等待：到点就立刻把控制权交回 courseFlow，
     由它决定是收工还是换下一门，绝不在这儿耗着。 */
  function playResource(deadline) {
    return new Promise(function (resolve) {
      var t0 = Date.now();
      var maxWait = 30 * 60 * 1000;
      var lastPos = -1;
      var stuckSince = Date.now();
      var level = 0;

      var timer = setInterval(function () {
        if (halted()) {
          clearInterval(timer);
          resolve("已停止");
          return;
        }
        if (isCourseFinished()) {
          clearInterval(timer);
          resolve("看完");
          return;
        }
        if (deadline && Date.now() >= deadline) {
          clearInterval(timer);
          resolve("到点");
          return;
        }
        if (Date.now() - t0 > maxWait) {
          clearInterval(timer);
          resolve("超时");
          return;
        }

        /* 评价 / 评分 / 问卷 / 验证 / 「继续计时」：这些浮层会把视频顶停，
           先处理掉再谈播放。要人工完成的（验证码、滑块）就等人。 */
        if (handleEvalLayer() === "human") return;

        var endedMask = document.querySelector(".ended-mask");
        if (endedMask && endedMask.style.display !== "none") {
          clearInterval(timer);
          resolve("看完");
          return;
        }

        if (speedEnabled()) {
          var vb = findVideo();
          if (vb && vb.playbackRate !== 2) vb.playbackRate = 2;
        }

        var v = findVideo();
        var playing = !!(v && !v.paused && v.currentTime > 0);

        if (playing && v.currentTime > lastPos + 0.5) {
          lastPos = v.currentTime;
          stuckSince = Date.now();
          level = 0;
          return;
        }

        if (!playing && Date.now() - lastPlayAttempt > 4000) {
          lastPlayAttempt = Date.now();
          tryPlay();
        }

        if (Date.now() - stuckSince > 120000) {
          stuckSince = Date.now();
          level++;
          logEvent("画面卡住了，第 " + level + " 次尝试恢复播放");
          escalate(level);
          if (level >= 4) {
            clearInterval(timer);
            resolve("播不动");
          }
        }
      }, 3000);
    });
  }

  async function switchToResource(item) {
    var p = item.querySelector("p") || item;
    try {
      p.click();
    } catch (e) {}
    await sleep(3000);
    if (item.classList.contains("active")) return;

    await sleep(2000);
    if (item.classList.contains("active")) return;

    var endedMask = document.querySelector(".ended-mask");
    var nextBtn =
      endedMask && endedMask.style.display !== "none"
        ? endedMask.querySelector(".next")
        : null;
    if (nextBtn) {
      logEvent("这一节点不动，改点播放器的「下一节」");
      try {
        nextBtn.click();
      } catch (e) {}
      await sleep(3000);
    }
  }

  function resourcePosition() {
    var all = document.querySelectorAll(".res-item");
    if (!all.length) return null;
    for (var i = 0; i < all.length; i++) {
      if (all[i].classList.contains("active"))
        return { segNo: i + 1, segTotal: all.length };
    }
    return { segNo: curSegIndex || 1, segTotal: all.length };
  }

  var watchedSeg = { segCount: 0, secSum: 0 };
  var courseStartTs = 0;

  function recordSegment(sec) {
    if (!sec || sec <= 0) return;
    watchedSeg.segCount++;
    watchedSeg.secSum += sec;
  }

  function courseLiveText() {
    var lines = [];
    var v = findVideo();
    var played = v && isFinite(v.currentTime) ? v.currentTime : 0;
    var videoLen = v && isFinite(v.duration) ? v.duration : 0;
    var remain = videoLen > played ? videoLen - played : 0;

    var pos = resourcePosition();
    if (pos) {
      lines.push(
        "第 " +
          pos.segNo +
          "/" +
          pos.segTotal +
          " 段" +
          (videoLen > 0
            ? " · 本段 " + hms(played) + " / " + hms(videoLen)
            : ""),
      );
    }
    if (remain > 0) lines.push("本段还剩 " + hms(remain));

    var timerLabel = timerText();
    if (timerLabel) lines.push(timerLabel);
    if (playThrough()) lines.push("连播模式：这段看完自动换下一门");

    /* 自定义上限时把「还剩多少额度」写在最显眼的地方，看浮窗就知道什么时候会跳走 */
    var limitMs = watchLimitMs();
    if (limitMs && courseStartTs) {
      var leftMs = limitMs - (Date.now() - courseStartTs);
      lines.push(
        leftMs > 0
          ? "离观看上限还有 " + hms(leftMs / 1000)
          : "已到观看上限，准备换下一门",
      );
    }

    var rest = pos ? pos.segTotal - pos.segNo : 0;
    if (rest > 0) {
      if (watchedSeg.segCount > 0) {
        var estimate =
          remain + rest * (watchedSeg.secSum / watchedSeg.segCount);
        lines.push("后面还有 " + rest + " 段 · 预计还要 约 " + hms(estimate));
      } else {
        lines.push("后面还有 " + rest + " 段");
      }
    }
    if (!lines.length) lines.push("正在等播放器就绪…");
    return [creditLine()].concat(lines).join("\n");
  }

  async function courseFlow() {
    setStatus("正在准备播放…", "running");
    setLive("正在等播放器和课程目录就绪…");
    keepMuted();
    beginWatch();
    setInterval(watchHeartbeat, 3000);

    /* 这门课的时间预算：limitMs = 0 表示「跟到底」，等站点自己提示「您已完成」 */
    courseStartTs = Date.now();
    var limitMs = watchLimitMs();
    var deadline = limitMs ? courseStartTs + limitMs : 0;
    var curName = currentCourse();

    var resList;
    try {
      resList = await waitFor([".res-item"], 30000, "课程资源");
    } catch (e) {
      setStatus("这个页面没有找到课程资源", "error");
      setError(
        "没有在页面上找到左侧的课程目录（.res-item）。\n" +
          "可能这门课没有视频，或者页面没加载完。",
      );
      logEvent("找不到课程目录，退出");
      endWatch();
      return;
    }

    var items = [].slice.call(resList);
    startLiveRefresh(courseLiveText);
    logEvent(
      "这门课共 " +
        items.length +
        " 段内容" +
        (limitMs ? "，最多看 " + watchLimitMin() + " 分钟" : ""),
    );

    if (isCourseFinished()) {
      logEvent("这门课的时长已经攒够，不用再看了");
    } else {
      for (var i = 0; i < items.length; i++) {
        if (halted()) {
          LOG("已停止，退出看课流程");
          endWatch();
          return;
        }
        if (deadline && Date.now() >= deadline) {
          logEvent("到了观看上限，剩下的段不再播");
          break;
        }
        curSegIndex = i + 1;
        currentRes = items[i];
        setStatus("播放中 " + (i + 1) + "/" + items.length, "running");
        await switchToResource(items[i]);

        if (items[i].querySelector(".icon-media")) {
          var outcome = await playResource(deadline);
          var vv = findVideo();
          if (vv && isFinite(vv.duration)) recordSegment(vv.duration);
          LOG("资源 " + (i + 1) + "：" + outcome);
          if (outcome === "已停止") {
            LOG("已停止，退出看课流程");
            endWatch();
            return;
          }
          if (outcome === "到点") {
            logEvent("到观看上限了，这一段先停");
            break;
          }
          if (outcome === "播不动") {
            logEvent("第 " + (i + 1) + " 段播不动，已跳到下一段");
          } else if (outcome === "超时") {
            logEvent("第 " + (i + 1) + " 段看了太久，先跳过去");
          }
        } else {
          await sleep(4000);
        }

        if (isCourseFinished()) break;
      }
    }

    if (halted()) {
      LOG("已停止，不记达标也不跳页");
      return;
    }

    /* 这一门到底算什么：达标了 / 只用了时长额度但没达标 */
    var finished = isCourseFinished();
    var hitLimit = !finished && !!deadline && Date.now() >= deadline;

    if (finished) {
      markSeen(curName, "passed");
      logEvent("「" + curName + "」已达标（站点提示已完成）");
    } else if (hitLimit) {
      /* 记一笔，让工作台先把别的课排前面，别一回头又开同一门 */
      markSeen(curName, "limited");
    }

    /* 达标 + 关掉「自动续播」→ 停在这儿，等用户点启动。
       连播模式例外：那是用户明确要「自动学习」，不受这一项约束 */
    if (finished && !autoNextAfterPass() && !playThrough()) {
      setStatus("这门课已达标 · 自动续播已关闭", "done");
      setDetail(
        "「" +
          curName +
          "」已经完成。\n" +
          "设置里关掉了「一门课达标后自动续播」，所以脚本停在这里。\n" +
          "点浮窗或设置里的「启动」可以接着看下一门。",
      );
      logEvent("已达标，自动续播关着，停在这门课");
      setRunning(false);
      endWatch();
      refreshRunUi();
      return;
    }

    var back = backUrl();
    /* 只有确实是脚本自己开出来的看课页才关掉它（不看 window.opener，原因见 saveBack） */
    var isPopup = backMode() === "popup" && !!window.opener;

    var what = finished
      ? "这门课看完了"
      : hitLimit
        ? "这门课到观看上限了，换下一门"
        : "这门课这一段先告一段落";

    setStatus(
      isPopup ? what + "，正在关掉看课页…" : what + "，正在回工作台…",
      "done",
    );
    logEvent(isPopup ? what + "，关掉看课页" : what + "，返回工作台");
    endWatch();
    await sleep(1200);

    if (isPopup) {
      window.close();
      /* 浏览器偶尔拒绝关闭：别导航过去，否则两个工作台标签页互相打架，提示一下就好 */
      await sleep(800);
      setStatus("这门课看完了，这个标签页可以关掉了", "done");
      setLive(
        "工作台那边已经继续下一门了。\n这个标签页没能自动关掉，手动关一下就行。",
      );
      logEvent("看课页没能自动关闭");
      return;
    }

    if (!back) {
      setStatus("看完了，但没记住工作台地址", "error");
      setError("脚本没记下工作台地址，请手动打开工作台页面。");
      logEvent("没有工作台地址可回");
      return;
    }
    location.href = back;
  }

  /* ================= 八·2、被站点送去「项目首页」 ================= */

  /* 有的项目看完课会被送去 /cms/project/index（项目首页，不是工作台）；刚才在干活就自己走回去 */
  function isProjectHome() {
    return location.pathname.indexOf("/cms/project/") === 0;
  }

  async function strayFlow() {
    var back = backUrl();
    setStatus("这里是「项目首页」，不是工作台", "skip");

    if (!back) {
      setLive(
        "当前地址：" +
          location.href +
          "\n脚本没记下工作台地址，手动打开工作台页面就行。",
      );
      logEvent("在项目首页，但没有工作台地址可回");
      return;
    }

    var bounced = bouncedRecently();
    if (!backFresh(BACK_FRESH_MS) || bounced) {
      setLive(
        "当前地址：" +
          location.href +
          "\n工作台地址：" +
          back +
          "\n是它自己跳过来的就点下面的「回到工作台」；自己点进来的不用管。",
      );
      if (bounced) {
        setDetail(
          "已经自动往回跳过一趟，结果又回到这里，就先停手不折腾了。\n" +
            "多半是这个项目的工作台打不开，可以点「复制状态」发给开发者。",
        );
        logEvent("又回到了项目首页，先不自动跳了");
      } else {
        /* 没自动跳有两种情况都不能乱动：脚本已停（全学完了），或你自己点进来看 */
        setDetail(
          "脚本这会儿没在干活，就不擅自把你带走了。\n" +
            "如果确实是它把你甩过来的，点「回到工作台」就回去了。",
        );
        logEvent("在项目首页，脚本没在干活，不自动跳");
      }
      return;
    }

    setStatus("被站点送到了「项目首页」，正在回工作台…", "running");
    setLive("工作台地址：" + back);
    logEvent("站点跳到了项目首页，自动返回工作台");
    markBounced();
    await sleep(1200);
    location.href = back;
  }

  /* ================= 九、启动 ================= */

  /* 赞赏码（Atroswnet）：540×540、128 色 PNG，内嵌 base64。
     界面上不提供更换入口，换图只能改下面这段；别在中间插换行或空格。 */
  DONATE_QR =
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAhwAAAIcCAMAAACKIIdOAAABgFBMVEX////+///9//////3//v/+/v/+/v7//vz9/v79/f38/Pz7" +
    "+/v8+/j5+fn39/f19fXy8vL8+tz6+sb08eX38sPr6+v168jt49H236jl5uXh4uPh4d7b3N7d2tPh1cHS09fvx5DQzcvKy9DFxsrB" +
    "wcO6vcXnr27YnlPWl07SlzXRlzXRlzTRlzPQlzbRljfRljTQljTPljTQljO2t722ramssLynqbSlo6q4nHabn62XmKLEjmCWkJSM" +
    "j5uHiI6Zf3N8fIOHdWyDY0VxcnppanJkYWVZXWpWVV5dTj1JT15ER091NhZuLA1ZNyNaLRRrJQhgJQ1YJQ1XIQs8P0o6NTNJKxwt" +
    "LCtGJBZJIgsvJB8jIiJdHQlTHAlKHgpLGghCHApSFgZFFgZKEgVHDAQ3GxE7GQYiHhwlGBU6EwYrEws4DAUnCgUcHBwaGRkXFRYY" +
    "FBEWEhEVDw4ODg4LCwwQBwYICAgGBgYEBAQDAwMCAgIDAQEBAQEBAQAAAQILAAEAAAA+mwfVAACrrUlEQVR42u19iWMSWbY+PH1X" +
    "i2qWHge7SYhIYLr7accNOvQwPESBwUGNJhCimNUlLk1oBCHJ8H6Tf/13zt3qFlQBWU0it9tsxVr1ce5ZvvMdh2O8xmu8xmu8xmu8" +
    "xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8zt1yKl9Nfxof/yaOj9d4jdd4HfPO4uz/2/j4eT0+" +
    "XuM1XuN1ItHK+Pg3dPxgeBkf/1aPj9d4HXZncY6Pn+vj4zVe4zVe4zVep8H7GO/R5/v4eI3XeI3XMW8mY37Dt3r8m17kiG83XucM" +
    "Hy6djHLtiaZrY4z02pxzzV/Q/LFUKj6hDb2/L5JIJ0Iex7fA7xgvtllM5rbanXohpA28HXH4UpV2p1mO6+Oz9s0sT6a5B6ud9w++" +
    "nStW3YXb7ZQHo2icBzs3x4mDBMpdBMdedXrg/Ykvt01v10rqgx6ffFP8jrPLPyDD70+IFq3Ra77XTg1+/GCF3W435xvzN76RMFVP" +
    "dthF76QHP1Soym63VwqMI96zXzsgmtfn92iD7+9KNLlFyPsGPn6szsFRDAx5frcv4NXHtZXTvbyRdC6XjriJc6BF4NvFXnli4KOl" +
    "2uxm2xnvwH2KTCSy+UwiMHZbT/PSY+VWB2LP2ODYM1AW4JgceLu02H5S+sBdxY+RcbuW8Y2vwCle/jy7nMXJgZ7A0YLDobNtqluN" +
    "jDmkp/h4kMeoW7PaoPsb4JgiAx5f6weH5fP7crv0Zs2URsYc0lO7ItyZaKUHOQkOX2GH3W4Lcp/2FsZfYBd9rx4b6E34CzwyznjG" +
    "xvv0rukKsxzbhYGxpzQJrRSU32zRMSEMTGVyYLTqy4lHI2N9jtN7fIJvK7ulELG/PyGpFjcJCVqbtXl8f7HLd5/AwOfXE3W8YbcS" +
    "GetznGaHtMDy3d1aYqALGeXZrXJwkN/q4gamk/MMzoH5s9Vmu1lN+8YMkNOc5sjyzETLPjOB12+iSJ2OTn5w8Bmrcfd2yDUngdl0" +
    "Nh3/NvIcZ5afoCdqIvfpH3R/d6Ky0+12yhFtwONfBovQ2NnbbeYCw56f6B6vR3cI/8X69UHFzznW5zi2NZS7pUW5R9otTw18IG80" +
    "k8+lQvrgZyP+2Uw+e2SZT46d8dbzlYpqwSKPPivTQ9h/Hp9PH/54usfv0cnXYbCO+RujHycOMvz+PuF01GKHf34iP+9krM/hON38" +
    "A7fP73UNub+ebDBwVGNH+fxD9rNRH98DtVvXmN9x9EsPZwrF/Kx/8HUiIkdaCZ26ncBN30HCP66tHPVxLVLqdPd2qynfEGZfBvNb" +
    "3VY+cNpqF65IEba83a20f1xbOeLly9GE1G55cJnDoYXy1WZzqxA9dYTxQI7VbitR1zi0OFoPf6LEC6TZIcUtzR9NJGMT+mmLCUi0" +
    "yqLsZnLc6HDEp1aQt7qV8NDLrp3CjybxZlsjVYzHHNJ9HsdughIvgrWzvsM/PkanwDb1ugbdnzggGeJ10xiaHPb9acJT3muqZZ8x" +
    "h/QIfQ6MQ45gz4bchTcK5ZCYf5AHo4dSmUziaHYov3z91bHPceSJc1FIBdPhP/zVIr50pdVuVzMBYhuneuPlZrtdL4Q1Qsihya3i" +
    "5XdyvrE+x1Ef9+V5Yrxbnr5MDvv4GsdaNe6yuz8JstJtO4OV+EO+fl/WMBxkrM9x1EuLcW+/u5X0jJy5svvEezjdp5X1DXhCepOd" +
    "YpAc8FkMuxcSNZ8zbzgcp5pZvtcpTI6e07S+bkQ82C7Qfezwk27y+CiqDasTD0OHJ7W1J2o+2lif4+iP60lxgusJMvT+l326Ta2O" +
    "fpuQ1duQ3fN7Mjz23OLhhdXruwyuiQ61lyGvP1jcFsAOOMlYn+MYUh0lzhnfKQ6rT/giqVxmEDMrwPmEAz7J0lJtxl12poHAE2Xh" +
    "iVwDbRjRRDlwD+iLYzrHcYDDl2pI0+EebMWTlWanvZWftI9EMm3RaG8HjqA1Wdm0c3mSZXyiQlBzkAF7i7RT4L9oY32O4zgO4QNP" +
    "hO0WaARqbRkJplPpxWik3HaP7063RL+Si/Q78PjoIie7Wwxavz64VZAZM0h6Dnr9Hmk46knvWJ/jeI7roqMANgOXbe4B9DcS7Hbd" +
    "go/YPL4CDs0yR0aIGRyWr4/EthhcC377109IoNAV3foTY/7GcW0sYR7NQvltkNfhSW8Pa6J3C5x10rrdk9mDQ8Qp7mRTtDgMSJO5" +
    "4pz1DApB2nnikJ6m3D/ot4ni1W4lpg/S32jx3cdHbPuQGmKH8lk/vyZu0cn77fSCwHIM0e8gtFbfkUXD3rh3XFsZMV81/BNFpsuW" +
    "5bf+Eq7ic9gwxsSnueS3fj1ail/Sdtpr+8oMn8M+DaLHOSN+r5kZXo9luyUhY/VH5ZR4AqGgTxtmcqXp2BvYDOtJVnf2us38xKAd" +
    "yizu03dNJThaaQ+xT26h3GCzMCgGkSFxtzycuujxhyfA3JFxvKtsy8FMuVopxId9slyiL2WvFBx0O28sU8glJwddMu4ktu2kN1yG" +
    "5fAMCK9j0P+SnCADm7tFrX6ouIsrRE9DzEvGHFK1oI0b/HYl5hpy/4D4GILfT2weH+NQ3ev3uZ39zp98ZD2xxZyXqE0VzysKfc2k" +
    "m9i/fs3jx/4XYvv+3KmmMBxQqx94frRwodXdg0a86OH5I47zwyHlTJid/LDPlideHVYwG3Fh83OnWbFrfia+Iv/Ab0W1AwcYwBcK" +
    "lUXJLR8YRoXMt7nOx3gvUVhZs1y2rzQ55DoAuxw/iNulQzJm4Dl90VQ2GfHZZT8lOGpQYz8oOoBTlBG1+i37xn/26DIDvFM4tfvK" +
    "SfMHsIiWqMt8weD7Q/tqIl8sZCPuQz7/ZdzivZcd/QZc8EckOCLk4O/PGRYCMF0oudndn+5srqiwMTsQXo/1ORw9ehm7Bf/wT7zu" +
    "m7DrfNuX5XAMrrYHSoKdEznEx9grPI69+uxgRUIykRORWCc73k9MfmZrnzXLQ9vdYQ8QlYmQyYM/FwkWZK3eP4Sdnq6LJHs15hjr" +
    "cxgHtHC+Wt8qp3yqyvzg+5NDPv+w+8dEsSzv63tNpryt7fNjAiyxaSb52L4+lySZ7mG3Hhnrc6itSKFYZNJzivwwUXfrZL0DfWky" +
    "WIaqI2r1g9lr2pSo6gNFYFoba3jsl4l5sstXGMwGIg7vZDiMWV3HIM4557020oN5r35BOwPnJOUjDjLmb/TxI04Rv0FnruROn6/A" +
    "jxNfolAuF9OBAfoeAWE4dktGn57V84MMlTAc7TxMFxtUW/k29TnsPy9OmxF+2ojOpXOIQ2p5fAKyZK16MapZK8nos9VOt7uzlXbZ" +
    "vj8i/ZZm2jeQwR4uimzITimsjfkdh3VSYDRfKhHyHnQ/ovdze30ezT7fFk2kYhMuMlDeuGsjn46+iC8rzEE5PETlti2yIdWYPtbn" +
    "OORxMpGpNFuNUqLnE7mfx/eEU5lsKuq151e4dPv7B8tGdt1aM0qPipIbTHoawPkmXqGBuNetZ/xjfY7DLneSEvS2ywdPo4OYSr3V" +
    "bpSHkJXt4hQx4qse1ex6Y7IKq9E5cA6IsDDbxdB4iq3jqPqSD16AE9euW5o60OXw8/R6dcpmX9Oikpk0sJ4IiTLhcOxVE+4xNg4d" +
    "+Qb53IPdcpAcMHYO8vz41sF60NzpRhf1pWylr71pUauvRMnADLsYFgYzObxnieZzSueDENmU1MQEgu39LyOtg1jOjCQiJdlMeQ7y" +
    "+sgkEHM2K/mw3fFgiW8W7Zx/wONDvW1HRLGFCTLmkB4+Yyb1RoF7Z/tZI26Y+JZNBS39fyIJxAfcmTR/JB6PBHTb8U11YTjiAypG" +
    "rlBBRCrgQI2HxB0FOlxxUbTo2LN23bPQj9ZpFKZdVlVQMSLyoOAAp9Tlss/NyC43mP1iv1cQQ9Slu5XynoW0+WnQjyDE9ji5rDYK" +
    "oddhKXlBpsrcafVbPb4ZHAd9/Xb8E120tOw1qECc5f2JYCuylxkY63OMlJ/SfcHA4LLFrMg+glyHdSbMFW/wxFLUUn6jJvtSjsNj" +
    "loW0UmiAAntYtN/vdYvh8aYy0vLFs4VCJuodkP2cED33nYJNwCI/vC0rhjkJlQd2tB1ueZJ1IwKxv1kgK+zL3pDxQWN9DvEN+k7a" +
    "O9utcsxhz+/QFVkDt+Xje5ItwdDz9/MjiAhlwaV1HjF/ggB7aVvU6ieI7f315FZXKp35xvoco9nkMjf4g8pVQSE+2bFpcNKFV7FX" +
    "nba8v9FrdNRDM/SY6K9pJAdsjVGjFgvmb9zJpFwHEOnTXMSCy0nEDPmybbcQwSRTfTCtTotUpfSnq//+kyWpv3FQFqp9zU5mzsth" +
    "+1tNimQN6/01e07II2Jnh3wz+hzinYLHGY1GY3H4EvS5zL6Fxj1J0GQixFZBFkTYdox4w+oMBgSBfDvr6b+/aFNkY0b3+f48/qDf" +
    "Y8s/kQOjMFKyff1+IzVaT/tNnBbiDUTg7MzC2Yn4veQb0ueA8+KemM2XNmu1ra1arVrKzQY9JpsaFZYjYG1rWdVTqvP0zQl3CikG" +
    "kV/qIek5VUE4i57sYe+PBFKFUiFlKyslFXV3y5YC/WwsnGywhs5fk4nUfNFMoVqr1erwr1JIh73km+FvuPzRbLkhdlt02prlbNTv" +
    "UpPjeHK7zcETnrWYTITZ8DxjcuOZJlbz4HbplNG4vt/dPpBvQttiPWfXwjatCOra+0yy3raj1pY1byhVqHWMs7PXrhaSQQ8537UV" +
    "riDui+Uq7T3z6rYruZgQJkYmRLHWbFTzoYHMQSIbZ/cq1nwtOVK6kXT3H/enyvVmvULnnxBLy2/z/ry8NW0rrllEU4oyDHhDLrvX" +
    "70s3JMGH1WKZPQmliuoHh95gt15MBl3nu7ZC+7oCoCvd3etbAI8064rHmVl6KJFOxYO6c0jPvVD6aVk3sHty2wOUgAgM30glo9az" +
    "n4geCIUmPJbHhJTcdsZtI3uoapdZnwdo+t2VqVGjMOeLFes7/Wdnb3urEPGe92gG6kx1C2jQM9nIB6XHqrk8umuEGcNiby9alt9c" +
    "4iMMnQGWx3XrZ8FO2kSxUiml+ssiUNcRudXdnOVu5kvLLre4XWJLi0iCz05J1n6IN1npWJ8d6L1PnHN0ADbMb94ElHZB5UGNcibi" +
    "WzKH7h408a1b3ldPI2jJJGv40hpWFsknHGFrcIDhUHpe7RrqJWsUCD7yUXypatf27HQrCe955ZDSPSWUFx+qbre9Va1WKtVqrb1r" +
    "oCOsqxqSZNjjB4s9ktfm40LbHiqeCd3eh7B4/AmWgujLgeDxCU40gm1Ft+BfeGSEupUgNvohnuSm3E4zfskBSMqut71OE85OuVqt" +
    "tral314RtuO8cUjRPIPdENjYrZeyyVgsGonFErlyXW6/hbBrPz4M/4AjMzep92OJSNpH2yYVMmyydTXW/6BhsSPUZ12Wc49le+yE" +
    "nRZmqCQueacwpQkXyLAbbQhg4exMQyIoXZDu+04l6SPnNDMKEap4m51SMgiCOBpxaRqkwxIl7qPCVEf//rh+IhHWLQX6dyIiK+K7" +
    "pX1V1+T9gCZmN00BYqSwJdOE10u6VqU0FrEFC20Bg0qM8J5/PSGwsVPNRvweTYPzo7m8/mhOVGC61bh+HvU5iCJO0q1l6RR5Iv53" +
    "TWW57w6MF99+Ht8jJQ5q4jOudgcQmaqsRsk+Xr+kcTXTbtJzXCTPlFq/elzOhVGqvT38D+m0gPHJCDKJNi22yGYRRMGcirygP1Fq" +
    "C+JQSDt/+hyIAFGM2q6wblC1mgImdceUGhhZLV9QvLctbY6kVbRS+3lYb6Ypdiu33TSOrqWSpQxl7MJrQJfSUJ+b0KTooGDF5kOu" +
    "3u66sNiPm1n/udxV/FycpFtN+vpkRwk4Y92DcG+MEUibViZXsvB2s959zXbZEdk10u9yCGMUIwPGMexVIi4bPBsRm5Ea1YTMcSsf" +
    "0vu1TCN8RwYm+znU53BKC19L+S5b6GN4BTqgIXAfjy9VqGEGkr//uEcQfiDsJKO/fj8PSHBQac9xTWxkYppCj8yGMBxtYTh6H9+X" +
    "kfW2BhKBnLxisCNq95rF69PD3LlqZz3nT5+DuPlHHEqoZIAU3L5Nh0dUx7ettHMMBfP9WQ4RrVb6mCDiffBqrh2HxFaRVo9vypjE" +
    "eKc6z9jslG3IghrPBncr4XO4r/A6x47d9BJsNd9hlczQvhJWEZHMtowchQrC/nyOAHdVukjHML8av8iNWwQyRM6OQ91jm3cpUmR7" +
    "naJRDuQ+areW9NqpG/JaTCvlcZw3fQ5BCK4ndLtbiXpWbdZlp5pgUeUCt6Jt8kjNNlNnu9kOpEj3of8RsZ2YQGTFtRrR7C0HdrlZ" +
    "1WWI32ioryQ8Ch95hw/rsYwm8LH4TbrFADlv+hw8wuua8w1Old0vJpy0+jpRUIocXQbLMpjOe1JtmLzeRGmruVWc9e7n9Qu1OL5V" +
    "KUwljxjUonJEjPtrPHpqZNSkm9QIg3BetiI0M3I+Ljpk/aPMCeeG8e8igqpGyXnT5+CMTZVZA3SnUCigVJN8uR1rTiiMUktmbAVl" +
    "oSLRwuHA1iR0ok/GkrHg/pJH0U27+Fj0T+/tZC3NuydRaXXajYL11uiSzdW4v2p9Sbeq0vOm+4PTEz5d8CiJmFvc+Mo09aPP3RN+" +
    "ulmBjA/1TRfLlWJaRvpEjDiphHp3DhDjaDdBbNBa38IfS2dhrLhmp39BIJHldO7n9UvLke+Zfq3J4KiZdFnWfnAMeiY5pVvqAU3k" +
    "hd3ZLcc9al6lxYVsjTgrli9Xyvmo2wiBmSNEZ4aR81RbIfx0V42Wdm+6ttMFHguGfPwsT/MbhfuS2dRvsO1Wd3l9Xt12Sh/Z95lw" +
    "xgxwmBGgC3rr3mbEYf9i3Nb0RqMmt7cFfiVRuAdtbo2IRGEZVKW6LcXp8bMUSjvjdZyvpYKDiIiAhYtKzBe2BAcRGem2XcQxoBf1" +
    "QHx/Xc6OVF0HtO9u2e4wbHwpsWxFEJtKj0o+B8duViLGwzXT64nezNz5A4fGB14pH36R+K7JP5FQ1dLlEizynewJnRaXYJA1e/d3" +
    "o4su7d4X8Ag1Bl25qZgViXgit5ORdFZ/XjyP3nujrO+ccUhdLMnTrUSk5QhVJDjErXi4shk16TKC5ejaDes7Bv0K7ILO7QjHQjfP" +
    "KJXbSi22Pw0zs9boVspnzsiyeg2+QafYQyQ4xPNzcJjY8ueCQ6psK+IDJxJNQ7cVEABrcKU97WtbDlFZaQ0bntK/3HHZ3wb31hwW" +
    "28pO1m24qHxbmZU7FC/NnW+fQzqk9d7ipQ04eCvAVsZ/YurF/DL2h43QxguXqF2K7jeeJFNSa3S3OOVyOCx9DrdAAqcUbReNCTSn" +
    "xOc4DD+AEKvjIpRlcxHYnyYy5VqtnDHymi6WRe1WQj33J4FkvphP+MkJ6VMEJZ0npPXGxe4oCgCE3H33B9qSS7N/fFkDwlYEV89x" +
    "3p8lRorQDSxWrNaqhah+2eA87lqNvxaFTXIG9DmseztFT3s75zMmXPlC0VjIp0YlO6Ki1fsYbt+Ez31iHw4JDqupxS5fwO/V+hWN" +
    "J2KJ2ajfdky2yMgLrdEeP7cukmDyAfTJSCw8YUTorvjAJBg5w2L6PPsJ6n9q9Gny90UFtWVlNwdPzjk2cIzsWbijhWod7KBNmpbo" +
    "sjUT9UT6SCI8yDUPqCWmCy7T5xHtvOlzuGabPG53qbOS1FuJqUa08GY5H4WQk9GvkOAoTYx4f+iYR49iFzLA1o/vE/ShPS5gbT7O" +
    "twwovJn4I06l1jjJ80LFwJnU5wDNAH9kNhENeu3bxHa5JixRLSHh6eEdXia36CQ6PjWI/myF8J6xAjriQ3l5Qb1jp0fryWwPmi4r" +
    "aPK1hMfmhYqaNc5A7js9Ln8YC0gex6lWXclV6vVqMRlwWZBy2kJzmFjumH7OkDoWjS7b7kxfMBKZ7FHx01PtoUqFfV3RXDS3aDMF" +
    "W+MDMNsFy947nbMEt3EST9+nAbnpfONBblo/1yOSq2w1asW4Tk4vv8OTYeFGLR/19XnTshUk5beS/vOmeBqgl35/nPoTWihThKEp" +
    "KXO/rJ7mn/J2asTHdyd4/8xO0Wb+CvCSoQ+02yhEdEs9BUETBAqpZs76U+q+O8K5qe2+YrDT5U+WW4xGFrpMTqk+Byhhia72TiXp" +
    "7+f6ss/jbtWC7QRdorXdLhs87D+5+SK+TGO3292uKzxypPOmOwo4hj4+UWjF2wWfzfNrgWQBZvcEdcvjRNQXutATKmhJJtXBjmA8" +
    "99a7XVO5LaGVnNQd5JTyN7SQ5Nzv1vORHkkJ2ZqwU+1r3ILWBNG6ZsnpdhzbIDdmq0smcRez5Rhhf9Jma3IGl/2+r/sm/fYyG6Lj" +
    "AZiloV7jAq0JbdGa4Os9c9ARJnvxTzY/ti/9DTlmghqPctJvjkb8QpGiW82EvJrEOIxtDmVEankr7Ts57W9NqLvQQW4GP0QkSFtJ" +
    "tTYCrzMwFfTrffNZnHLO324vP9jZV2Gxe32uSIn3wzQLMb+u6IPogYRsCS4q7aKEnbmqoebR6SOunp7aCvHJpg1qINLmlBCZzAud" +
    "pmYxFfa5RFIpbOiVNPOBEzQcugwhkropsJLDqE28kIlUoVjMx7y2Mud7jbTvwKGVR7RDdjuVbCzAZ2tokFzLVTtSRt189f2JYkNp" +
    "xYcBEKc3E6bFFRj37xBaUDbL7jQqucR0OBQKT8/my01jbkDIdYKv153d65exJQY4KkEz/7u+vbvT6de59+e7Uq344HqRuLXK1vtq" +
    "MR2B2ZPhcCxTrInG2t1qwmRWtYl0Vfk0gjPrc5ziPKnPJD6ynXX3NXu1DMvSALG4Sq3W2FEFOvSTVOM0Ytacfxg4HELgra9fhchx" +
    "Xdtpz6EMr3C8KD62alWoPdU7XVWCwTyDrtBUzEYXxG/IqeWQ0pl3IFskjceuOSNE+S6Flo2wDxr3AufcntT8FmKwzAMKf0S6TiZw" +
    "CInAbil0WcnbgscheBrdzehhXj9BqvS27dnZRmwY93QH05Vts2xW0HWKOaRU6wpesxwS0Z8u1MP5LZs3393KhU6aVx3ZFBo8AQvJ" +
    "fHNpJVDsikYn0tMasbtnJ1q5zwUZCxvZJ1CtMO0pnlihrm7h9XzUr53+udJg7Vp9FDdFZzJVtXz/4L+a8qonsrtEahatjYYsdl41" +
    "4xHhL5anNfNcoJZsnT70C/JGiy3LT06zEFZfjDtmQtFOJWU74/S06HPQ4MvpCmZA17672y6FLJp0QWoyX+30iil2qvmYj/R0AB2Y" +
    "n4DziEfiN1hZDqcxKkXMb6MbiPgr68ty9mkLCjrC4fglrmDa8M/F2dlpllKTmsqcDBXVLaVVinsH7RmnQp9DVLK8sWyxXMzRnot+" +
    "BTiXH1oyai25+Wy3auV83BT2ava9Bo5RRHDjiZilrKumKa8Dvod5Xm5X3SoMy6EO9/OJJFVH7WUh6riunnnB5GBnzx1OF6sN6Yd2" +
    "241KMRXymMr3upxESyPfXOhUl9z6koEToaDf1oPQ/aHZTAHE4qqbIItWyMyGTbcl3kg6m477DzZpWgtmK7WtajHWO4WTgNx6OICM" +
    "YdKnpqG2xBgaswo4yGR5z6KBGhJ/Qt6rnfMfQVcEVbcOxlJ5FIurwb9yLhWd7BWZlJMncfMuxk/U2zgKfgAZzH9wQS9kOByNhsPQ" +
    "Eambj0MNDvobN7MTlPOxr+eHK+Kh7ahd6IFmDU3iuBbOlgGJqMgnmXcyAqkqcYYUfIFOAUlz1ORc+kpEsuVRk1JEw4yp0n8WDnL+" +
    "4GH9cHaACQanx+chfcoihtrVdi3Dsu1nWZ/D2opqVgQvjTPq6JCdfdtmIrQ1muZEPISiLZpIiimpFKlgr7bK+IU5qZnMybac7GM1" +
    "nRYSYEELfsshcmLwudCIzQYFlEG27bRLs2dRYJCQUViNVtPZRCN7J3egyFCMZdwpmkdNT/MiW0G5iF7DcliCQ0lfioGD22m35cTg" +
    "/iZ/TzAaj0zoh/fhLM7SRA7T5p2a6KUlZ1qfw1plw2aSTUcohx/k8UU/zF7NVDBxJRqq7KDTBI69mkEicRrgUELTkHQ5WHMFu/9l" +
    "OfMFBbTNNtsTB6+qUoi6Dn3+SH9o4QpBF3opl5jUz4M+x0BUOM196rxTdcdSynHo88sSaaeg3l8GqE0lxy1Y35zZS0zyXIblcCq1" +
    "tYoirkAEIxzVil197U8dmrsKkuPgpxDm8mvnZ/6K7vP7fUPtrM4HCjfSB2InyFZ2mKSiXDC38OFUeSiXEE+nnUJEaNZz3kl5ql+0" +
    "sGvSM5cKyf30QF1sjumzFGZ+Je1z3Ldnc4VCNuoZcn/iz9Y6uzuNfEg7yPMb4722i0r932ANiwwnRCtS4FG0kTmVOpogC1PNJWFN" +
    "minZu0rQdd4104aNV+YT/ba5fo2fk6odOc6I9jkt2VY7OzswENQ9jFg1kcgV8mmucrxvX0vwtCG6VJtrg0KpTZGd1kyWo0f33ACH" +
    "YU0UJ5UoAl/d/jH0KjjGa+jioyY6haF8Hs0N+w/vKtt/LkmOE4beU5/aj9ra6xXekpZDqdn3Ww5FC31XJRATVa2Y2G0rFsTB/b0j" +
    "4iAOh+N8z1oBQfkub6s/Xr4ShDs76ngv6XQ0RCHFL22UsAjdcrBP+B5qJaSn2wwaK5Q2Bl9eqhX3aw7B2BVIgXepQ3qE81bP6Yw3" +
    "4dmbqprW9zf2Eqfy26jPT0DQdc8UoTpNF91IYxGnnLhlTB6WIEJOOn/kCeHGYN+EyD5o01I8OWvBOUdRryqIermspp+SQTPkTO8P" +
    "tE39kz4POX4f5OuqMAiqd2iU4Szy8+LyB02agyMJorfEJSf9E5R2lBznVElaDiIFl1oCWS6jXC9z55rR/irDW9q+2j/PY2I6BrUc" +
    "KUumlJYmQ4ERxz0STyiVL+SSk6ebrHHoNck8fhinSUa0ooRyaXKlMsxwJfvZo/lnetdUCxM1k6YSIgtwKFUzAY6uwiQX4OgY/Gci" +
    "0/y8WYX0A1yzzH97o3l8RyPVFWHWXLnR2elsnZ5pCcejf+GOlRqt5hZwiEe8P/qiriglw9VNHaZD7+/DMKLbpr2FSi93jZIfCpzm" +
    "R9OpOUrD7BSN1nUYirOj9l7RWlyWji3c5jOEhZZ/qrZDmTYxMvL5wfmB5R06NNc/mH+Bj6kHs1tK84TjhPRJvsa+4oGBoOnE5Oh8" +
    "Lxotbg/Umbeb7VIC9nJ+2sQJgU5eGPNcyamTwnSs76NGikfl6sGw7Gox4VO4r0EUmqkUYh6TbfAlS1X1lqNF2nzPq0bJsM3VB1xA" +
    "2ZKin+99BbZhr0e9Mr7AUEUWUfWsx7V9BSyReDw22ZPRdgVi8FdzkzcMl8Vbms68Lwx/CpncHKub4cT0cAxvua+TIEo3Q5WIXZNp" +
    "gwu4nTkVM6mPUf+CKFUknE4FWk5JnNxqd39i5CwaCdfoz4/Vbl3rV/mAkWma67JZHx/q6pqr5/4a3O5yzyPj3/rnq1ymf93P+XEK" +
    "/dWmMSXb8v7AxW6ozWyuy/s6/8Tx9fU5Ds5X8GVAlxh63xIDPbNAQRAuzov5FHzDrYHaiOiJKhTi3UqUHOjCEPK1DM6hnjnCItvd" +
    "aiao22MMCBNd2nsecJyPaWZQCcbWpW6nOGhepSeUVpsHgZrvO4g6GzlurTBby6NB1TjgOSh/wCXZ3FsFIJ7b3Z8EMuV6o1qI6V+L" +
    "f3Kkx5EBFcxU6Dty289/8cYLag/sdnlAKG/3/EA1DIb87q+jz6FHciXgRU84D3Z/rzE/s4Mt1z16JYp9DcUT0UB/b/tJ6Hcc+XHK" +
    "jQQ3Ft6RfVOwFkiZRtqD4ouH7Pf53cEU6NIUEn7n1+BvhFEyoNs8aNFR9oHQWCQXHhC2aCfZXH0ia+A7ckfyTdOWkgns9wRosC2V" +
    "MYOzW097v0Jtxc31l9FTPFBuf7qs9O60wS91OU4fv+ErHHdFzQ1L0mMfubakg6iFVHSpTJ18bQW0OCT75YBeu9JTDttqNTN13tM8" +
    "o62AokRAG4j3V1eCvoUouGkSX/XYVwhXxDyr9kFpcCSQruyaeuxj7jE0YIRYtavII6UC2j7jDX+q3FLOayP+FUp2Xj4hpzF74C0L" +
    "uoabJp88MbR1CySxf/v7/1qsdCaTyeLK4Eqn1QPZbI6tbC6blTdit8yIWyb/N5n8O1/JJH/ETFasnHhotvhDwt/gnn9XFrtn7p//" +
    "/FexWCzJ9a9/ZmL+kTwHyZKnW0pk3588LVEziVzUIo6T55C6Zml9SoTrTppr9LgJ2ccei5UNVShqKxf19Ooa9wxJ++1/rVc6LcCR" +
    "pssMDri29FJmFXBkemCUNIMjnTawwaGl3M8AB9y/BxxwNPfPf+Eq/ktdmelR9DMMcHQqqv7+SD4MXAU5L1mo/fi/BocUzNeWkYAA" +
    "TLhD8VQiuq8GLA200NqmdvGEb5AV9dlhg19MerXZ9U6ypdgUa2ykJTQQG7NmdBjQ+Oc/VXwYgEFwGKj6O32+LBoOxEYJ/qMYYSgZ" +
    "bSQIb74CH/0g3cIm0T5wWfLTX4cI4gtBuD7hlrMm4qV6s1HJ7O8duUP5uskvzYZ0+6xeqA8TEgNsG+jFhrQBmay93eC3RGzgkhfZ" +
    "AME/6RLGxwQOui9xeCR7sGGsIm4y//ptNKYSxvjbW7nwgUptUrMKLHG9kJxwHWmGdB/1f6Ipv/CJyXy40ejzWQJpU8anXaRCHdb3" +
    "NxmOpLyubKdPKxuK3CM4PEz4sAYHvTkHB7c4DAP/lEvZmoQXkzW8Fr6LCWyYwMFWZpTzC/Im2PBNzYbTuW9+hl82ZtQhCNbJV9Dn" +
    "6EcjERK8+f1mxVBHTDUelZTtiOC/K8iQlzQp/MB+aBjeJd91TNgwW5m/K5bDGhtya5HY4OhIK3vbAGyU/jmqBEMkFNBHrmu6PH6f" +
    "oYQCXKVtmnUuJCdPTW5AEx1l5t6vUeIwSOeZRAi38jEbi2reS9QwoWenMfmICjxkOJMxmxlrcEho4MVW4cG3GoEONYwR2LACx79G" +
    "1hjZR0XTF03nMgkQi+Nn2p8sVoDYPDt5TASQg/A3xDjpvYK/R2ti2P2hquKLlzqqCFQ54bfU9zBsxt9N1x8vZ1LdZ9Q9guNDGA9u" +
    "MhRoGHji4EjKCNjAhgke0g9RNhruvXJ/41//KlmBY1R+BRn5/OuJSrMDw9qn5AbimZiOhvz6qdLn4MmbbbWRiJARGR/IbNlRveyM" +
    "5daSTP6vKTgw24ek2aLMzs4a8Ph70ghoMj3eSVJuRKrhkNgo/MsEjn8qLqoKFgEZZjZ67EZxP5bjIA5oO60T054/6pk/oZRpFoeK" +
    "t8oRl4xf/MGAb8SaEWhHq+QWFAD3WYGjd8+wX7PqUnIXhq+hxDQGOJiXYmDjXxIb/yoYcPhnryciEfMva3AUi/+CL0d/1gmXb98t" +
    "+EjfxDNyavQ5tGCqUCpmuZoITEucSGLfdByq7aOwnZFN21CjFiq62g+Ov/99ZGz8Rtes6kikTSmyZLIHHarhUK+1GRz2S960WJQJ" +
    "Uvod4lj829HzR/Qkr8TIPs3Tqc+hef3BCcNS+DK1zs52u1YYrmfG7g+avCr7aRfa7PWe598XNkzgkAGqiFB6kGGyHJDl5NgomMDx" +
    "r5HAUWTgEBARKCkWbS3HIfgjJN60kIY4jfocxIIGiEyvRNA7UnusJ1ZS1a87fcWWv+8fG7/1bC1WNkNNdFBwpC3BofgdAy0HBcS/" +
    "FHAw21E8jm0FJIfYXMmM+9TrcxjqPZpU89zrNEppKDwP6g0VfarT2U3FL93dzJoVr22x0ONhzCrgMDCSMLutRsxj8mIxLkZw5BEb" +
    "o4Cjz9/A/5jlUAFCLcfR8z88yUqr02kUQuQM6XPoKZWW0CimKTHOOcRLgmJLuW1iyJkKDKMgQ6zf+pYJHuLeiQT7I/4o9x9hOfrB" +
    "0QePfmfUqLkVzdA4FssBOcR0LpsKnSkyjJZomDT/W9V81DtKRgxIcqoefI2P9CF24JidHREbwnpwSJgW+6Pcfv53EDr+9U8EiMx6" +
    "ZEV+w+y9KjuMsbscz8fQ6/N5CHGcLa2WnvEQnWo26h8+T0WbTFfVqjNOi+u3HLh3KFbjt6HAUPCBC77JmwuEyF1JhLI2V1w1ISIH" +
    "ZnfT47ccjrOoz+FJmBhJTKU7nzCTZa3ur/kSRYVh222VEz7ur9hZi9+M/2xW7LdYLKZ4qGa8qKhC68LQYU6fW6Mjx3OjObtbcVj8" +
    "S4ayR85B3a9+yWnooobZGtlys9trPXIhMrzjOpypqfzrSoLXCWzA8duQ9bcY/IcrRhdiJSaxYuCDYoiiIym5Pr1Z0l50iF3FFhz/" +
    "kuCAHx3jJRV2fMF073CZ7igTa4jmT6r80m5pSvU5ej3QodgwL4YQ8T1msi/sd7qxpA3Kl63zIX0OmTcfvM7PZnIE+g+gupAB8RET" +
    "PCqh4fcHraOoSgKqxi6rlsO0oczuDxp/s4SKaf32G91Y6BLoKNigQxRpe+HTlzNVwXHc+hpnRJ8DCq7hVKGmwqMa00aaMj+RMer4" +
    "W1yuwAoc9rBAP0OBQYQvS4j8jZsTCpffqNshqak5zHnYmQ5ZhyvQHKpFBaaAyCrgnwvj7aRXu8kTTBRqRuRSjY7GatT8cTlpFAFF" +
    "jG1llD3FhAsFGsYaYEx+w5BFUFDZpmEJDrXaAjdgEPhnTnKCsj0luvOypxxWn8PwoAlxB+IFOdmNi0ar97ls+fhED+a22NYCFHfC" +
    "opXZIdD4G24j7KstNqb5PwYRC7DgzgLGI/F35ntkpWXoA0dBBQf9jePCzFIXtLFj1j853PGvlxLzR7IVqJt0oXlTHXQ0mPJEQIGp" +
    "0ek0y2LO79AoxcoQKKgwLeXPEeU37oiwjIjIh+XtwGGu1OYFbzD9v4J8xiJijpfxfuKwG3yYLZXLxbRf6Z+PxqNhvz6QnJ7K5tJh" +
    "MZFrEDb+ZuN6GtaiBxxWS8XHb9R8pBg48sw0yM2F7iESG3mEhUoplZT4tNJrlU6fu4t6ZPwDl38qPB30SluBcmswwyxLB6La6nN4" +
    "fH6vVFayNRkx+6DEymiMgBAKkN9oyoOSSfP/FPBQFrcWBlmQQgMKNTQlL9tmJMXoLOqLHLc+hfRNyWWDHemKVXZhn4G57VBc001T" +
    "Z5wWeqREgKM/PpFxhu2O0g+A0HQoFJoOse9iwW8GQKIAEIEO7jvk/1ng7sU/83yZOcZ0P0mKRHxC9r+INogzoi9yCrYZoRSMzTfx" +
    "gJuMoCLVazRi9o6GAY1eWISmVUBYLMN+ADoSiWQqleb4yOdVUMiNxMRYTv5d0ozgvkmjFe9/JTjGtZVhx+XwPYRHzabLouf+w9Nc" +
    "pvhDQYZiJYZAQ8HHdCTK4IH4UEMP7kVkxXaRwiW4ALMiO0+rNEmDuWoBjtOkD3Kalhx+xCYPb+VDwzv3bFIadiGrai4OsNjuQnNi" +
    "CQkPw7sU1sLABcVGQoAjRuu9lK0s0DEOS0ZcnrSJ8LHXzA7vwR6Kjb+xyKR3I7FewVAwGAwFxfcg+40dkfiIRKN/4/BQfcuUaiyS" +
    "Jm7ILPWBuOkQ4GC+6jlOeRId9Okm/UfEOdIiJVPRpasOZiUjgCPWnwvtdzFsYMGxYLnoIbP1YJ4pdT0YMnoBYZBBwHAw/1ikSpKp" +
    "tGjDTA88uTCi3X1slB0CQ573O3xiP9ENjKjPlyvlfMx7NPwBmB5QaxvFtS7Ok7fo+LICR09BVcCDWY3IYHAEKTiGLmE9mG8K13o2" +
    "gY4phwYHA0WoOb5Gu/G3KCz6+hRyCAWH7fkhgUQ2j2w/ciw+BjCoSpVKMT1JjsnTgLFGOHuoXTwqyQd9MpGrtA3LERqqi2zGRg86" +
    "zGbD2mDsaxmuKewtsTh1Oyg2EBq/qYV/06v6G8VG9G/MKU0kVHDYLn+m2oauxvzU8fD9fOk65A12ttLHNb/ay6eWNVKeIxPK90dz" +
    "1Y6Yt+cnxDSMxwIc8vyzFDfn6VBwRNXYJHQQbEzAf33ogBgHJspHovEHjx48yOcpNmZnqXWA/YabCAUXFBmI0yjPwtN9hYsO2X9O" +
    "2Iyzbj15LB0GMOSWyUWXQtqx6HMQEXu2cJKiKK/pHu/wjjb7407iBe27Zmd7G6ZG6ly5SPP4JwJ+o0ncKe9vQIODY5ZxQX9jloOn" +
    "MSy3Eks0TExMTuCXySD9Tn+cnJhU0YHAiEbj9x89evT06dNH91OpRByhQcsxzCOhdoLbi6jAKPs77kYcHCj0Ynt+lBHth+LP8Cqm" +
    "pnu9Xl3iwOkSQw1BQv149DnEpCNlzKYriBNUQp7DuUrhdL5QyHAaMUyrgb7KYrGQwlYXwhW8JTj+FjPXTik7mIKD2w2riGQALjgi" +
    "2F8mJoKTQfg7HhHoiMZTDx48QGDQ9fD+g/vxGEIDDApCJxzGdJkZGEYSPgppkiQrz6AMkL3Z53rOnbz/0DwJDdrsE+AEJ6O+3qGG" +
    "3UpUO67YsykH44mxaflas1krRg+3kUEf5UTApykd2Tu7uyBMkwr5XGZ9DxM4sPbB0QHgiAjDMWAjmUQTIbChoIP+dcK0uPUIheP3" +
    "Hz41r0cJwEYYoSEWQwjDRJgvbj1icQQHl5fL2IZjHq5u0s4ezikgbl8wliqU4bI06+Wk19hWdtnk05DjePQ5wCGl2cySnOgMQ4fo" +
    "ECzs0zw4v4CYGdRyrutOA4pyPlO9pY+Ww9HxG7PzPeDoMxeT1DIE0VTg/oFbiNxMJs3g4P7HVPjBw0c94HiaikZUaEh8IDKmw+wX" +
    "utCiIDhoXZeCw6lwxtX5Kdzud9lA5IPyM3R/OJkvbTa3u3wOR1gc97HZp420jxyLPgeBIW1FmFqlaMkGuDhZTWWUH2DOhqosQVxi" +
    "EDDV/c5GVBGHftIWBwfHhj0szKahFwnWKxgMh+MCG4uL/Nvi0wexaB84+hYFR5RZjgytyuRyiuVw+YKh6aAhTepNVZvt1lZu8mDR" +
    "CnF5/aF4ulRV2wX32kk5gDCQgXFllcyxDSYhDn0iEotMGEmwUEVIKLsMxvlEGFQ5NHKwOcrq9Gfm/VZyMcPSCkygqxeVjD4IHpgT" +
    "YAmNyclRsBDA/wIB8TP+NDkZvs+9jblFZT19BG5HeAqfaWqKPsXUAHBAegR2FVasyxospli2XKmUcxHdUG9KZdLxCRfZ/8wbEEIB" +
    "YBTKWz19QupgOCTPREM+7Vj5G8SpZKgmhOWYJgajB0Q6CplEJOizSfcNy8DI4cAC/qXIZRM4ospi6PgtRr0AK2zQ/aMPCj1/CfQv" +
    "utdEmbsxp2BjCcHxKJ8KT+ESzzJlXgId3OXI8HquQRN0847gVp5mpejOquk+t7Zv/gXwXUD+NV+qNnuAwSyHZmr4oM79cepzOOW+" +
    "QWAiFXNzSnLEc6TU2tnd2WnVq6VsQk7G2x+/IFg0v89NY/hvNKpAQ+QSMP+EXkDYym5Q/6IXGQwvzOmYtEQHc0SuPeBGY4ku9p2i" +
    "I0WhMUU9XFxTU+yrsdByADYAHKB2rYKDTYhk5r9bpe9t2FbiHKAFm8qVt5qd3e6exapFe/kx1nu+81i6lmLl1vZ2u5Jw9M58p8pN" +
    "1Xxs/xq8hHhixabaLFszpN0NYMhME82ExQwXsdcFnbA0GwwBAQ4RFRb818nA5A8/XLuPZmNucekFR8eSQEd8isGhfyngAG+UxioZ" +
    "zgPpB8ceS3odxM8AgckQxCXV1p7d2tnK+hxfS58DcAjTG0DZyVDv8ud3TL2x1ZRP5XIRWjUhw3o/9WC6WOuIz0JXaXQRyJBVecxP" +
    "qpaDWfopJXa13FMCwlZM8H8CGXDFp+KpVPyHawCNePwhxYYEB663iI77cQto/MAXxcY1Bg6su2UynCWUy/E4xekRH6JG0mPyzEar" +
    "neCELnQyas0dS4sB/LpOs1pK9s/+OlHOueYLKEpPMCvEvCNAutZQmiRkxIGS5LIvlJStLu38pKMHHBETOHBYLLMcUyHmCEwFlWum" +
    "oIL/ErBb0dSD+A/R/KNHD+Pxa78/wKQo2o2lpbV3bw14LC0+ehCf+sECFgo6JDhSXNCUksekZx9j3Z7dETq8LIxGIJkrVpvbdiaj" +
    "29oq59OxsO+r6wmaslRiLOaexafeMfqkQoJVl3ixTseGl6YND171NwxwwIpicDklnUQFGnSbEAafbhnqLjL5wzVY4XiUXtXfIcPF" +
    "8hoP78cf8ciVguPDO/Q43iJEXr5dfJoPw63h7ld+CPxgsRAc19iuYoADaULGiUrWWEI0sP/rp4UKMN7edjfpVIvpWNDncRHH1xbt" +
    "MD+/O1E127narDQreiASC+2DDOKaiMEo8XJOnTluRgZPM1FswC9TAhwmY4/omIIOiOj9RDiempoMT00ayACv4hEDA10Qtxp5cg4N" +
    "wMaLtbdv373l6+Xbl2A64gCBK7h+sIQHBwf6o4yAmultTQCZiVq7lg25DjDEKGfjZ3R3WtVSLhX2exxDCpgnxSE1Z9wg19LsKBwN" +
    "lsvHW8E0zMpmOR/VB96/p0s/Gg/51ehLQCNsLI4XiY0eRwCMBmTA81geeZDKP0jBvzjCw+/3h6FoAsjozY5DfDLHMl48SFlbW1vi" +
    "uGBraenpfY6NK1fAelijgwUriA5BA0mlTHyFZFbo4e2Ln6FFKxbA2O00a2U0GUq9rce7++ocUs0fzeTLtQ53PbYLgt0F+WHccVqF" +
    "CbKPucWabj7KcWBe6J+G7cABZiPFCqpPwUY8eghQyKeieGX98Uf8AMcELPrD/IsXLxYpNl6sCU8UIPHx7aKwHm/BclwRy2ZjEaaD" +
    "wSNFWSAJs36J/0DleT1R6zMZ2w1wMuLTk17X6VZ/gnr7VCxTqDTb0MdYkql2X475T1vxHp3dfb2baDTShw2+ZIJBWIwA9xNh5+AQ" +
    "gE3jEc14PriGu0JchQbFBgXH3Pz8C/wJsQE2Y41vKB8/SssB4JC7yhXFCTWh49o1atUYPOiCH45izrseNycJQW2tlE2G/OBkkLOg" +
    "z6Hp/lAimUkngm5xJMDnBbZwmKQwkLrP69HIPh4/agbEtTBeAvzhGsXFDxahwzWojjyi3gMDCP3hUfyagRkFHHMKShZxP4H17u07" +
    "AAaAgy66vSzGr3CHQwCBLdPzXuMBi7pMYk0HPL/adHlXWgyIS3KJcMCjOfsD4tOsz0GABWT0rCng4DaD+KGakEnHYOT5yOGcGRds" +
    "TdF/5g/uFf7Jhm8SGwgKkQAHeKgbisQGrPnVF9RwLK2B4UCH460EBgfHy8VHPxjgkMjoBwesqBkdR2E5gPIHSaBudxucjHwmLiaL" +
    "ni01QesulVqMi/oTX6rSaLWa1XIuGQ2MSLtWrYbABlsmayH9gR9+CN9/9FRi4ykNPoQRMSDBfpiHNTe/sfHixfzc3It3a9QTFdsK" +
    "wIKZDQTHffnw10yrx2Zd4/HsEYMDZggUyjCJPJMI+0/ayTgW/QdCIjTt0y4EnJJ/ssP9bBgjmI75yAiPrwJjygYZCjau/HAt+oCD" +
    "g4UfKjgwKlkCPMwx44G+xosXKxsr8AfAxgdAxxKkN9ZofGL4ogCOp3H58Ggc6P5hAQ52VIADvY6kpX5Jz1eXPxj0u51OYn9+wa0L" +
    "TfnRMp8LfQ6k0BYq1Upe1qhNs+y77c2RQn7DYAhcTPXhwmQ5OB2DY0PURuhvc0tgIuaFn/H48dOV1ZWVFcAH/OHFO2o4wGy8+/Dh" +
    "Lct/YbxC1+LDa4bh4Ek5AxtXrl7tB0eCRywjmAV/olCuFCHzTfY1Re2MLz0QhiSYFMh3p1tmjdJCcPhb7gFGv9EAbwMv2/dXvocF" +
    "l+93QdXhWQtmOBbBaqCZeDEvDcfjp3MbGyt0R0HDsfZuY2kFAtk1AMkixcZHYTgWIda5go+P4KDXnoODPf/33/9wleODbitGLJtK" +
    "3R+B5pdCMaMu9BAMSDuS86fPAXQlq5lwUqnYgpXfmyEzgcMqv8A+0t+zBYbjgUHkEkV3BMfc0hLFAUJh7jE1HU8XwGxwH+TF/NLK" +
    "yppx8yXD5/i4dP/aD/zxf6DoMKDBnvuqWAgOxAai4j7QhmAN52ROFHkPQdDK/luxzc+6PoflcTFyQzJTDG4t+Ciajj4q6WGTGXvK" +
    "D1bYuAofXAMbcPWAHSzAIbEB/0MswmzEHAcHuqMLIlwBcMDeIjxYmgJDaLzlgWz8B/kEV4VHis8t/iYXHkBs3BfQeJCzOD+6W030" +
    "adOihyAywvkl51afw5etmwrOHYN9oPmmodQNqWB3z5gWEbz+YLnggnxvWj88EGEJq58xcKytLT5d5PuHzG3ML3Nw4EazASZkifG/" +
    "0CH98AfbU9jXR9fUp+h7TtVuoOFAs/FArN78r8cfnk0lY5PSZmrRqtBcdHzL+hxkMlWsKHXnhtHxEM5VGtDyUMqmwEtxEUNtkGGj" +
    "DxM/iCvSc51+FwnyRWOLYOCYeyEjWLarLAA4MJJFHxXsxgtIcrwDr5T++/Dx7dKSDFYW498PWqrdoIZD7ikP7t839WMEI4l0oVJv" +
    "NreKCZ84P5Ml9oEpBx3kG9bngOJCMAqMlQYrxOyUwpq0KWxe0267AVXGeNCI5a0CRgMXV3uvU/z3+4wgjIBYXOI0UIxHhNWYo3EK" +
    "3VUAFCvopeLGwrDxARaA48PHd7gZSXD8fmUEdPAcWDz+O3M56DKiFU8wBsDY4kXKnXLUZXDpukyPwvGtLxQGSGSLtQakOqIeYxpm" +
    "V6k21nIBEzh+sASH5XW69vtDajkwKl2kXQXojAq3c255FaOVx4/nFig6lldW0Bl9AX4plFXeQQoMohXYjN5RLgeSOVhN9lF8P+AA" +
    "ePxOQ5XfYRm7R9HE4moa+puTmfJWvXKQWv75RIg/Mou0pb59t18PW0Ljau/6y18swUENx+KLpSXJHpfQmJ9HcMAPCwvL+PvC6gp1" +
    "R6EUC7vLGka6S4wFtvSUGQ4OjsXfRwbHtessA4bA+F3JkHoyZkqG4m8BjyUaDXocZ1Bd8uj3QIzaXbpOjLhMC5sJCzWDfY4ByVXL" +
    "ZQkOdDrQGX0hsYF7ihGVYMJ8eWODgYJnOF7A74gQMB0vGJtjiSfBGECWhoHDjA6JD5Y+5+9ZEoxFpJZR+6c1zfG1NMJOs066g1dw" +
    "d/es2eeWuPjedlv5/hrNc3BCF019CatBf5hf2YC1CrvKc2Y+ABw0FQbp83fvXqDngd4KhYgkkS6OBg4TPq5fj1/H5ehln4u3mNBN" +
    "J4OM9xO7bgqXiWyodoZftUGH7XW6hsw/WpV9geDAy0/dT5bVWF4FbCyDKwruKIYr8PeNd2tgN+YwcY6QeEGT6BCwCHAgzn6/Oho4" +
    "FIQgMuCb7ERKmzKA7VxAYdkSx+mts379+R+gL1WotXg38F4rF3Dag+Mvgy/U90DnwDZ53E+wziYNB6wFcDpWl+dFcmNu4QUaEqyu" +
    "oM1Ay7FGjQctza7xrhUEx6P7+0HH1as/yiXerBYt70iPu15Jq/S4r33+Dzgb4+QsiY6RXrnW2unuNAuKGI16yv9K11/++he67K9U" +
    "nKZJERhPWbpcYGMdtpJ1/MuTx0+eP0GPFLaYlRVanEVwYLjy4sWHNVG8l5YD0HFtEDj+or5IEzoUfjEdYdVpVKAzcNp7QueWHNOE" +
    "e3KCNHdqWT0TmCMqFNJqUNcPDo6NQQi5eg17XueWFkUGFDNdK8ury8+fL8Oe8nzuCaznz8EDgbosBrIvVigy1pDuAzvKu3e8KUGA" +
    "4+nD3weD4y/qC4TVDw6HN5YrVoAqHguxth/yNTpJjkifwxMIT/q0k5r/cZmw7LLXH/B7VRkLEziuMstxdQR43KdcDrmnvMDq/MJz" +
    "TJqvLz8Hw4HYeAygYWmwFQTEuzVmQCAR9nZxyehpgsd59Pu1QfvKXxAdfzUtCQ7jXeq+ycgUtE4zGgs5ofkqxBMIBX2a4wj1OTTI" +
    "zFQrhbhXaVsDAqjP53a5XNrxRzJEsRzMUAvjAXgw2Y6/2IW0TxcNIuD8PHU1wF4swAJwwLby/DGCg5ZkVzbevePBCnB+PmE/Ew9i" +
    "BT6AoWwCg2o0+LIBh8Ms9U+OMMaz2v+J5nar2TQ9RC9kzHuEPS2BHDT4d7crMckl0HwR0M3MgbBeIhacYOpMw9gpR/BqTOAQPkcP" +
    "Or7/i6XlMPFEqQMK9mJ+AWJYuqU8fwywWEV/A7FBCyvojH74wFxRAxzYKwt9K1dVOyEA8hcbbPSD48h23wHnGfJHgVgyGQsaZd8A" +
    "nfbdqYA2HzmiaIXEtrjUHZbR6RF/GqRCdjr1ra2tKspxBLRhCrc98zIOxi/48ce/UnAo5/0vFqvHyn9/lRXuZfKLLdxMwOeYfw5r" +
    "4Qkk0TEdBlvOizUasaDLgYQw3raiNssuAeFHPk/fs/+1bwlsXD86fgzhYimKlUBtNdiFFf5MKF+p16v5iNGIznLPu1nfkWXAXCmW" +
    "stktCkUFV9zIRHR3t9tbOSUYQwki81TyI+OHUHD0rb8MAgj+fI2CAxPlgInnDBoIiedPwOdYAGgsLzx+PA/BCmZN0emAuHeReqMv" +
    "aP783bsecDxl4LBaA6BhJMGOgn+hMMJYq4MnnAVRxrBRpvTRVFu3lfMLe5/g6ZViwEmOiN+hpxhzvFv0981KEbM9k7Ia4IlkCsW8" +
    "uf3f5Q0EAx63231IB4WeZAtw/PUvA9fV3x8yQg8DxnNWUQFv4/n6awho118vg8vxfHVlFUuyELCsriE6gBCEdgOTpQiONQkN6Ie7" +
    "f3UEaPxoXvbgONCe4p0IQ1cHUUi6GB3TLYOvqTLPIgoJQU3wdosT5KjyYCRe5yKZHoZWp7+nm35vO+dzCM3BUguFIjOG5XJNgJhE" +
    "CcV/U7FwyO8mVtrmyjRJe8v6ozU67O0Hv2TXH0qP4/kcehq4oSzPP4GvYDaWMWJ5/HgZYlnIjm4AzXiNJsCWsPaGBgTTYG/ViOXp" +
    "738dZC9+tFo0fT6stkH6zgXfkzUfRG4e2VuMM7uhP6GQMNRx+DXpFif4I2uRqhD4EVFEjHVSdvM+eZYPjdIJOuC1W53VLAbpsB2n" +
    "IHccblSqBs8tmEcxiQ5IY0KXSik36yeHshwHwMePEhzgiuIugv9gk0Eb8hzDWFhzywvIPgfzwVJgGMuyVMca66ZGiAiBjuuGJzwU" +
    "FRIawy2H02kZiYDa0TQI+eYSARnhQGcT5Fi3q2CxiZnoUI0IKIgCZlXqxE4W8Lp1N+P60dkwLZSv1mvlpE94Eu5Uvc9y8GNert/S" +
    "TGj8ZXtSja6qOVNNeiy3UI3TKRUfvDfe+nEgOv4yCBzCcIDlwNzo84Xn87SYsoAu6WOMZldfrEDXCjY1IZvjBS2uvBObCUcINxz/" +
    "6H/+HwcgQ2Dj+sDYk7jccAb8KC8TTSSiAa/0KggJF1ud7U49I7wHuPBd1qkeEOdrmnNyazFiLmDuFOWsElcELuRWKeE9Sga7BvpT" +
    "kUnjmpJQsdVVCaAgls+fzc9Lqtj3SFR7Z2hV4WAV0icRFIpnsikUWAgHfD5Q7nZpsGzB8aOd+2G5rfz4UIaxaDioFwp+KAayy4AU" +
    "CFgQJLClYLJ8TQGHtBqsNVIYDuWpfxy6rhurT2QClscLCaMgCtEkUT2/UIFVa7U2y1mjbiAGF1Vj3N3UeADZLcsLPyksx7T0Qmar" +
    "HdjhFesCEzrxQrqPtgrXw2cknki2WKk2Wu0WEN122jCDS4wP1vPbXJtU3Gey0CNDsxXr6yJ2TWUq9e29Vm2ztlkpoBZ0EvkPEVDr" +
    "CbiMZ7Y++z34+OtfTFUXEzgwpYFOBgUHeBzgjL5+DVhZxirLPICDpUbfsVQHL6kwVtgLWWCZe3T9x5HWdRUYCjiwOoDipRF8j2mU" +
    "/SmB+m+tp1fDiDKkj9cSAytc3A3cA5Fi7j348nQ/7xQmDJ81ni8W8wm/ladDjo/ZgUObojFohM7kylA7ShqJFi1ZZ9NTJon0lHrU" +
    "q+pxrV8Y3th6utsdWPWt2latXCqVckqz04AL8ddBSwHHc2olEBxPqN1AcCA2ACHz6GtwXEAODDGBZHXsjJQL6WFzT6/vw1r0gwM+" +
    "Rp5YAd5auQbvsYnv1krFqWu0JwQK7BS20l6h6cmczZ2i1CTWo8XmdqdZVOVx3NBaqUY0J1cd04gHBjdA22bQZ+qnz1SbrXoRIypi" +
    "En03eH/9PRm92qPs7ICHstttZg0H9jp+GkdYZg8Afr7+UEKD7ie4k4D3gfB4/XoZLcfy/PP5jZV3lFP8Dosr3BnFv0ho4B/B5Xh4" +
    "fV/2Qq6fpCs1XQTp0F36Hu1XPUF6AoBmUhfUylybiZlL7XvinkpmMokp3VRjIxr5CvocpEe5iRjeQySRihmDQC+TYMGkogrN1H0P" +
    "FinbniVG9mHPL87yj/td1//xGPMbAhy0Zo+/Ljyn4FjHVMfC+gq1Eh/oYvVY+iNGLu/4wgzI0/u/789gCGz8JNQSe8g+tuAQisZ6" +
    "EpskQemeJTudWO7KVetARA4q81OwkqKR3pEDlx0nr89BBlSANHOk5AqCln+52qjXm9ugKlHsz+wPAofKIe0/4SOCA7CBMSzuKWgu" +
    "kM6xQHOjwAZbXd1YBbf0+TKGKh/Wlt7RhoQXa9SGMENiLGY5pOm4PgQPAhV82dEErVfFaGwKZqsNnJHhM9Gy4xGLrAAhZ6vfGgrF" +
    "UyEUIYBgPW2oXitrsrgzAByaPThUkAxAyk8PERwQs6KxWKBJDkh9IVZgT1lZfb2+Do4HdtmDyWBuB+9nQrux9tbACLKOnz78x/VR" +
    "10+mtS9wtPIBRXo0lkwnwj7zPMmTVwA7Fn0OWuPXof1Pyo2YjhNvqm5nOkDL1CVu+9NP1/e9KDh+f4jJc+D1PEe6KEUHi1gQHPMr" +
    "q9QjXYaayhoFByP5rLG2JgSHgAb6HEtzj/+xX1Qo4HBatCb0i0Z2YFxEWFeiRZfOdQKP6fqcCo65pYIAaEClSrVmq7MDq8dPM2Iz" +
    "BIdpjQoP6nHMzwuHg4GDOqVQSllFljGyBiGWRacDpBdYQZa3vKHNePuOQ4aGK/PW4Php6PpZGgKuYKygAVYHhI5adcxzlLOZVNin" +
    "kfMryLE/pqF7MpZM5YAXCNol1Wp1s9Vut9mkUiU2szrj1/G/69cHIAXNxmMDHJDcwDQY45svb9AF4Hg+93QeLv6K0Ilj4KBVNx7d" +
    "GuBgzzri+tlY8lL7U1UMTjvwJls1eLtlfOO5VBIEKVHaf9Kr6wO9Osf50+cYfNylu/0oLEx1Z2fTNIdShnk1HuNWP+1vUWj84yHo" +
    "bcw9QXAggwPBscDSGhiwMMMBHimyfSCSXUOCD02A8X1k6d1bGsLyf8j0ePzwALj4BZdZwAfeHOoaz6K4Ksoq+z2QPtfJPjuQzqU+" +
    "x4AuFsi2urweL8wGCAVR5FeeL3mqR8bHPx7SZpV5tq0AOF7BjgKeBiS/lrEhkhmODYhknwChg0aunwAc3P+UhRXJN0ZwPPzHcCzw" +
    "9Q/zUt6/G8aHB334LnWi9dhU51e+Pmer66kPHD+PCBNwNh7TkqtMcrx6Bb4Gpr5eg+0Q2HjzGsiC8Asg4xPmOHhwsiaYgcDmoMlz" +
    "WsOff9iPhh5c/PIP62Xpgn11/fpTqM8xynE+OVIe5+cYDPTPNqsXG08e8/WE+xzLlBmINRUIUYTlePMa/vR6Y+MdAwfzNWiWFMUE" +
    "PzDtBWY9QD//Hwdeltrx5Oud3zPWNdujB9bzsvvO9s+D12NlzTN0oC8K+wqCY3UFUhxsV1l/Prf85g3fVZgsB89zwK+fuKoP/mXx" +
    "99//Af8fHTjG6wh499bgsFg/43/MuHObAS1tDx8+5pZjYZ2GsQCON9BOD/mv1wiOhcfPARzMdHx6xzR9ABqf/oD/0JiAHBgr0z6l" +
    "agr7xIQQb7k/vqzHuPZ3TR4+Ni2swi7gvkIDFXA7NuahPZZGK68hdbr+hu8omPaiYSu1Gn/Qv376yNyQtUe//z4SPO5brvNwDU7H" +
    "Hmhx/B/38awfDBxgPBZooLL6epXSe15vUF7gCwTHHPCLqYlAp2MNJzOtsQIc90E+AjpM4AB03LfFgHk9MNbXPn9nUp9j1KWc8uHY" +
    "uNtjOcAnBVIxlGHfvKa2AwiBwAt8AeK0b9bBJcFtBaLWT9jitvRBXeCSfvyDmY7FhwIc+0OFpZrgeB0XOPoW+yirhqMPHFhYgajk" +
    "zZt1jFgg9QVbytrc6sabhcdPYJf5gNlRdEGX1oRjitD4QHXxER0f3j19cB/Clfv3B2HjAaKCIwNngz001gCPipzVPeXk9CEgrLvM" +
    "WSCQCPPg0pXjD4Rm4/0Hwz62/8CLgbsJ/8edDtxOPn1ah9zoPPiiGJ/MzwNP8PETwMyntQ9/0HLb2tonAxzUdPCBGh8WH4FGPqjA" +
    "PBzBTKioUMDB+wZ8PqBKQQIMl1OtOZ0tfY6THCGIP7t8fn8IU+gxOjkv4Tc+VRZX4IEdTtSLcu/ePRrNguGAZBdaDsiDQaF+GdJe" +
    "q3NYdIPOhA1wMFhsgq7GJ2k8WLQixq2As0oZHfi8D4SdGIIJvh49chgdzVk6EjCB7zMME+d0MtZ6GjpfEqoOsUy+UMTaZLXZbrVa" +
    "1aRvIDgUmJjBAfnMOeqIPrx79+69e2g+nj2D8go4HW+WqWM6P7f07tNryK+/Xn48t7IC2PgD/VHui6pLWA4kh0Hv21Pjig8AgwkX" +
    "dMk3Gcw38L21arQGW8jnkN53BneW/fIDCBmkD9F3f5fb69KUv/mzVRiBDqzCLq/bc/Vaety4IuJTaguQB0/fMeVAlBpl96J7C5qM" +
    "T2+QBLa6DEWXNQTHY+Cer75BbPzBQleRJwXb8Qm9DgEOzJpStUkQGmMSp4+GLgMaAA7+LoH2Z/Bk93Z3tjuNEujU2s9PIU7rjkBy" +
    "xPyOr5K9Mqr25sPuUDqXz8QM26An+9iVmwYTjE79pheaf+Mrb0IMg83TOeGIovIsVN4eUisCe8vC6wVkcixjyX7t05u5hadzb16v" +
    "bmCggvsJA8Y7AY8/KGj++IP6pEwbn/ZSP+LjwcqLZVxDQfIUbuSwZ4LtDu5fxY5InWmhkLPpzZIhMx9Byyk8LYRlWDsn0Ol32mzk" +
    "Pa2j+AvdARxS9WQb8MBPcb7HjgM4lDhlbh4yF0/BlsDneH4ZpeIgXFnYgJToJ7Acq3NzH7BniYYpnxSrQW0IwIKC49NHeuTjO1Zn" +
    "WeIqhS+Zvmm5zK0Iaj1QtDwt90Kj/HIQTbAWG0AUJ1DEBZ5lFOdtB4Dz74VZkBrRHMRxsr7Kwev/xJg8ZVloJD5s/i2mg0bHZ4bZ" +
    "iXJY6HdMlvrOmqJg/GjEhYgxgQNVZ9++/eOPd3NzQCimSdJlxvP59Hr5zQZyOAAHawwcn7hHyn74gy8ZvQA6gDiIWwuKSb1kC80H" +
    "R4WyxOuhyIAlzo830w+OBp83Y3l+fbPQ9wRsc2h2KeXRlU3F0JUN+nC5nMfJ3zgafgdxai5s7QtEQQVNt9B/gHG54EzsQAO+OODn" +
    "zXBbcTF43V/sPWk7xdBlcfsSW3DSi8UiP++Pei4Inf348OESSt4/lNsKTpX+CJ/9tZUNKLkBCQxzXqtrUKV/s/GJ7yeYGjXQIf6x" +
    "XeXTJ1Gr/fCOMQfp3BawHRwdFfH04GHS3ysvJTzgO/3j5oDBwXv1WVu5c6cWq9DxAdjHs4v0sXYTe75qjECWiEX8OjnV/A49EE2m" +
    "oP2uWKo1KoXUZL8UR4BPIZJ6EY5gaZd/aoSv7s12evnFCYOtXrZd6PW/hAvF5kCC4Vh8x0YiYOHtxbs/Pi4xRcAVUArEToRldEAh" +
    "C7Y0hz9A3fUTGg5uOT594ARSxAfkRz/9IYv4+AUHA66xjmoFHdR4GL/hYtaDvTqkPm4augW5PteqMm1/fb2DCMnbzcZmIRUY1L1E" +
    "jm1nIRYzo4hD9/hM82A9sXy13ZG02Wa/shAJVWSvLH8sP2/zEwNF4W+RUhPhQVsiG9gRqfRqOCqmVa6UxY/sYjAhyMVF6g6soSLt" +
    "/BM0HO8gucWboZFCTMHxGjGBIrVgQj59WuKmw9hPZDj7libTTb0rWJITDfdP+XRAFRSbm5smc4I/Ija25PnTgrkKSGZttVgvZHe3" +
    "vUl712xqH316KH10dd76ZlKVh1OqexlnXfUFCTnanYX0uw/RVDoZNvrutXDZvI32jxpSwCFQ5eXd46Upw2eNwCCSWrWIcUkaZnyb" +
    "ejXg40fPMy4TLBAZEEE85ULnVLEYZ6dQaTgq4ARCX4zpB+DYAEGfdbQYr5dfU8LgytKnDQYOZjg+GZwfTGugwDXrq15jGwvcgFII" +
    "6TgGeE42zVxi4z0siQ/2CjcBG7Uth9qIgrNEs/g2S5ubJaa9Ybf8hSHgUOR7VB8wEE/DWHC9l312xHuGy+P3qY37/nQVePTlhNTe" +
    "9WR6Xn4z4ep9FRMlYUDlqw/l6+1Os5JQ1B1A9iwMhFv0tDwujN4Uf3wTF3wGq+rCz+mSGB0L+iov6LQDJvmG8x8XQOQLSD1UBR/a" +
    "Dt59+rCKnfVgMSBVuo79K4/nNt58erOy8WmDxbJ0MdOBXxk/8AUnpQuTQntY6NwNhCSgAxBBDch7vjZVSwKrJsFB6GgEFwyLQB8N" +
    "9Reg3XhQ3OHNtob2Tsb6XBYyVdhqteqFaZdJr82nHy06fLFsIZ8KSQjqTDCuW5FCdf58b79Wqk89BlRcdmHOdjPnVz5A8XQmEfJY" +
    "mCmrpo2aWJubEhib8EF9K6QkF5lcApdMoNYDFOCQYw4uKLLM4d+HT1BUAcoPmo/1V89fgbQ1cn/AC1kV4GA0YzAxHzYQTIx0TuEh" +
    "5jcx3gf7M0Umll/M4JDGQ2Jjq//jS0byDUCgb2cIOBqJvmvOp4C3jPNN/PEcXMig6wi9Dx92WXSbhbD4i3CQminRN+Av9CG5LyPn" +
    "DGRKFRhPHnapOnguj5OMyj+oKeigRoRjY2mOggPns+E1W1l7x0Sb1tY21lAbkEpyLDPWF4Djzes3y3S9evWKajG8whuAFMNrZjTQ" +
    "KuCXDdamgF9eCL18Hs3SFDtXOUZnhqKjDxwADwpguqdsbf15YP6FP1UE7YJBe0t1+nLfNl5WNDzoY/nSVfAKqZz8Uelz8FHje82M" +
    "3uMg4YQhHmX0bCs7xYn+zwXxhaKxsF/v+7yMaudq5rVZY9hYlMPoX6xuvEPFt413dC/A8AM+/Cu0VQXBgfD48GkDqedIF0RwID5A" +
    "VnAd5Vtec7sBQQ3sMWtgaODeiLQNAx2sU1K2SsKfNrCfBdHB3A4VHMK4ITS2tuqHmYcXS6Xz1L2tY1Gm08Wl9AXm+3qq5cQrQwiK" +
    "j2ttZ7xHtqloiRZXhRNpbh9Th9hrZbxSnaysNPh1agUcadebCqN6EVa6u/sAB5xjdqbhO/72noKDq8GtYOZiA3aSlRXRcgLXemP+" +
    "xfLc/Dp2w+LVxhD2zbrQfnqFC0iCy3NQqV1l4NhArdoPG3RUD1gQeESKjhWGkJU1Gvq8ZSHMCofMIrqlFB3v0SHF1ydt2yZ9pfVD" +
    "gAOvghv6eGDRjvREBjMcRciL1eswLbFZzfcHwoZgnJSQSzD/f6/gPzJ9Dj3NdUjLPP3v9HDBuK2EW9aSYjDTDnMztWqpkI35XfY2" +
    "kxyYf8A+f3RtiYXg4KMykNkFrGE6FAP0InF/Qe8DKeYLuGug24FOxQb+sr4stFzW14FevI7apG+oywHzeeaQEvQaTA3SgRAk7zbw" +
    "gQAi+JgixKUMdT6gBUOlRe5iADgoiDk4KKLr+LoPwb9QRPRQScyNOXR/BIkNqXw+NW3q/XKaBOO2UTDOydSGeXalFCRHlTEVwrfb" +
    "BaFCR0KF5g6MkckFFCGoIEa3qPg26fO6jqceVBPQQHTUDXDQQRnzC8DsWnkxzy4WOhewHdBPPO13BK9jlWEDwbHMwPHkybNXr9bX" +
    "n1NlhnmWEPu0ikW514gO7F/YoBYERV2om7FBvVK6+awZ4EC3QyTE3ktw1KQnyl/3ML7CiNMwzHfy+HzWCnB6vNKGq2TEgkJQFi3H" +
    "UV0b8Gx2mGSg9HI94TTIFKeCmkkbz+0BZZmjmcxi3WCuYMOwHhCr4Bwu3twISqJ04QXFbeHFEggsoLcB1RTwOLBW8mljZRVKs684" +
    "ONYhdsGfQd3nDe4pqwA0AMUC3uHNm1Xa2mIwOzbWGDGdMj9esL2GZUFA8mcJ4cF8Zb7vCX+jbg2OY62aEQwyC7m4X16REMtIN1Oe" +
    "o9Pn8MTLoIK/lZskkj9w2euf8Hud/WqDlNJxeH6BU83pyeP8HDdwSXQgOBYQHctQNIHpsKjUA+CAniX8zKPsLOwPkApFJscGI22s" +
    "bYDPgc7Gs2fUcrxap9JxmPt4DdiYg20HfBDA1BskmtI+SZo2ZY+3wgt076jK8QoTtcWGJ0izsI3lJYdEjftH9T8NcDjt1PyOfr4K" +
    "cfkCAZ9uXB9votzexkm9mvPo1AT1UDKbjvlPmDYAJFJIEPk14+PFgNFsoBgyg0d968/3SwgO3FaWacQCocmKWKsYuoAVoBpgC9ia" +
    "QsHxYXWdxrEUHc9ePXmF4QvKDKJu3HNwOF4vUP8U0cHa8FlSfY1uIujJwMPQUHaJCmHTFiia73j7/j1PbVA/g9kPbjm2lAypOxgN" +
    "+b36SRMx3OFkJh074mnXUG/VXSfLK9FhmnkKCtWgiWYGR1MsgMefsN4vsuFtC8tU1xyliWFGF3zgmTMAetULqEyLpmODl+A/rczT" +
    "QIUaDuAOvqL7ynPceNDEgBEBiMxRHco3qwwddEt5t8HiFQhYeA2f9Vuz7Ck4pRDPvkfLwdEhYlkaq2wp6XMPjKSuFDLxUMBLTpaT" +
    "qXtZSYycMn2OUY8DJ87jD8MYc5hz391DTWdxvKFAg6KjwcGBsQqKfDGJUXqNqdGYx5QXyN0DcoA3urCyxvkZH5bRZDxDj+PVMyrb" +
    "8YSBA3taoPltHTvj1hEczCfli9qNDUx94MNAq9MHkSmlaTLYVyg4qOkAQGxW6c/VTRF5G5WoYhvUfEAKPp+OTRjz0U7H+T+9+hxM" +
    "TTtZqNS5cutu2Zgr2wOOZuNz4/Ofbxk2UMpp/jk1HKu4S4DzsbGM8cebVTQocMFBkGNpjYHj0+vnTxAdz8HhePb4MfgcAA/49nr9" +
    "1ROMbcGSoMILhr9ohOD/pRcAkhfU08Wy/QdGHTTAgWl7rMF9pOigMQpI9rykZbdN5F7UDHAQKCQIJfhWtZgN9XDPx/ocg6KjvCof" +
    "p3BIe7CB6Pj8mYJjnkrAzT/nngOWUhagWIIF+dUFqmiNVfqNjQ8CHM9YEIvYQFSs030G/j2m4HiFmoPrKIuOfukq5FWXXrAwaOMd" +
    "k619xywQ/gj/6HjztSVpOtBw1DarFVaUrW5iNleCg/TQBDtKAdMx1uewmkllHPeZGZaCQwrHe7HRbAI4PmJVZQF14KjEKA5eopHH" +
    "6irIbixQIwJRKqQ2Xr/59EEFB3oc2KzwBBxSwAPsLzgncnmdZtQhkEXooPzPMhPyWMWi/wamOqhuLXuct0yogdXzWf2epsHQCaXg" +
    "YPtKjaVJBfp7OaTlqDZo/sq3rM/RmxjhE4YsOKSABlTcwy8qOOhkDLapLLDtAD2FZchywhYDcQnOYlp+gwwOBRzM6aAzZXH/WKfY" +
    "wNFNrBbHBAeXeU/+3DI1G4gLSKe/w2wHfSAgo39gGVPEyDs2k/glTZ+DeHuVs00oNhRw9ElNNtM2xQ4n+ea7miAeV7JprljVxIIr" +
    "SIl9B2ID0UERIsDxloJjmdqOeSrPgtf69TrsBq9xSigKB0IeA8KON5Iw/GH9mUQH2oll6pdCV8vrN6/QNwVwUE05qtgAj7DAnFKe" +
    "BYM06craW+51rHF0MKU5ZIe9pBnSer3GHdJNsaTl0M1vEUYr+smZ7J099p1LD4LEZDYhSZCyYMQ3ZGNoGQcHWxwczS9vnyLdC2cu" +
    "oTf6HL0PyGFB3pNmK4ASuI5z62GPeb0hQ9nVV3RbQbvxjLoc4IhScIDdoGh58mR+HRvj0ILAveegSovAwBrLCkuXv/0oSek0Zbq2" +
    "uPaByV+/xIIsK64IZhivwclPgz9dU4VI2xnfKCb129PnuBwqNDowhTQbEL0rAaF13e1sVvJRY5SMo9W3AB4fF9FisJ0FNBYWUOJ+" +
    "GVVnsWlpAWskEKgs06h0g5sOHsnSYPYJIAIS6M/xp8evIFihtRYcK4rVFWxhgHrd/AYFxwoWazaYCuUH0bNA2+8/IG+QaVMCOCjN" +
    "BKs/jG9Cy/eY8ZA+ForyVhuScltL6P3zbVDnXrfUGTzP+hzmzicR1tVmdUncr2AZeLcJA+4iAd0xEBxfvnxcxD4l6iJghPEa9RWY" +
    "u7BA4xQqHYgXGjeGtQ/4gd9YePbMgMc6sgapCcEABm77HGdVz6FuGIS4OFGBZ9DX6Chz0byigAP7Fz6x/nzIhBnVFUyRYp7uT0bt" +
    "qBoGgXhDUE4t1ejMtUZuon9XcU3EEqnZaRiX8m3tMKb51GKWiMENcXhhDlSpXEiGfGxExABwtL6A5XixsQoxLCTDKTjg404zoqzs" +
    "jgUSWl5d5lKS0Nb46cO8AQ7YVN5gegM3GUh8QOyLc0SXX6PpWMfHA+i9oPfFNMeaUYSDh/pDWZBcB5cUiCRPK5uC4EMzuLC2OB9d" +
    "ff8w0s0XiEGmD95oQLOI5ws1CNUrRciSeTXtlPghx63/cNkbjERDhgfq5xMDO1m/UTHyBiaQc6s20VmDo/3ly/vFudXXaCMoOqid" +
    "gOwEeBoLNOEJ4MCq7MrS6saGbFCaew5RLC2tPHmC2ID6PXqkz56AR7qMfimbwgLgAHkGWu5dgSLvCxqoMD1KLNt/+GgCxzuqFrW2" +
    "WK4K0yHB8Z75pv17qtcP0951i/Pny/Not10vF6CupQkf5DzrcxB/EqbDlTMhYqbBquEckZPaez4r/dgAcHxehCoqZYSySRl0MBdG" +
    "LjTvtTqPvSmvV3FaBkLjy5c/IOu9TCsrtOxGA1ma56Bh7Zt1dFQ+rW5gxAMPOgfAAVBBlZdS1z8wcFAk9IODToVbLEtGsQAH7iuK" +
    "5TBNoyfE0iqEjXgGuloq2bD2DUQwrgRKwgMFXfjn7gQbfV6Juoa66RITquWAcIVlMxg28AP/mrkbcNEhdw6xBkzLwEjzI0DjP/8B" +
    "L+HTxvoro2JPfwTLge1xy28WUJEUyv24GUHQg+zS10Avw8IKmg+MWMQkpw9vFXRQSroJHFsKOLYswEHIIL65qSWu2zKPtzqr+hxD" +
    "jvtYG323Ou00hsK1YbwI7Wxz9qlQmL5Je9FWsEE9Uu6P0hzHMv5boJsKbTmAJPr8Cr2SiI3/fMGNZQNNBQMHMxlPniM4YI9ZXcJy" +
    "zBtoeJpHuVJAHY4mnkeOmWAQsRos7W6SXqms0YpQtsZ4HMbGgr2yzr6YxOb8kZh5cm93K2Z3fskZ0ucYsgK8s6lh9A3T7rnQKIRo" +
    "iY12i+Kj3aboWJp7sczGqGCinI4DRZcB8hSY+36NXB/ExscvXzrbaDkoowNdFEx20C+omA+UH7j1Gxr7vnk995TOoH1NqadPQVUO" +
    "FG1XeHGWj5t9p4KDdtQi6XgNOR0MHPX6n40/G6x2jD7p+32cp1DFrEXRSuqKIIPXJ7gg5DwFMxNl2YRjcCI1Nxkp4yOw8aUFTJ/G" +
    "5y/Mcnx5C82PYk/BDzzNn69ThCA4aK8KBClf/vNle5sZDmADLjPL8YT5obgX0djmE2RFoElBTLDG/NnC6hwYHoAGhCrAHMJwdY2x" +
    "i9+9k/sKVYV6+4FKDzL2eR2xAeszIxa83w84oDaX3tq2BgfxAmMnm0mEIYohZ3a+iuXy5ndFp430PkfWl2gys/Hl83ta7vzzM8XG" +
    "l48w/hWZFogNHLi0wHCxzpqYaOyJWwruKf8GcFCO8esF6nQ8oWYD7/eGLsDG8hwQfeZhT8LyDFLL5pmrAf0uGI2srgkBWxRi+Eh9" +
    "3C8MHR+Y8s/Hj2wrYSaDff2TpsL2cf7IRKpUbxvWoxaVGeVYCVtXQH8hxWaaHy9/4yT5Ha4ETRy3sj6jIZCMev868zc+v6+UQOqh" +
    "/LLO0fH5PYoxYQ/CKtbJVoElvDA/z3cBquj1x38QGrig4R6v9eoCxrJUQA6ZpXS9efUK8PEEpwS+pl34YGBot8MKJxcDHmD2LBJI" +
    "Wa/12tJHio0v3HJ8QnAIbAAuGDaGWg7L80e8wRj0lDe2u2yYmWg1cQZZVzVwQZrVIpXMcg7pETsz/A6Q96GhbPAgFrFGIxWYoVl6" +
    "BD09j8rvKTg+4/rjD2grWoOGphUu2SNI46DoQz3Rz58pPL4g93yDqk0+o4VYpJz/wcCx/gR63pAEtkA7V0w91Z/eMZVBQMoaSnl8" +
    "gPsA4fztHwyeFByQFqOGQ6LDcDn+hIYFQ59j1PqaG0bPZ1B0QBlsD0Iuip/aqWVCrhOt2R1nbQVGdU9Mg14RkQp5g+6v6Zr6Xqu0" +
    "8Pb5PWAjn4eOr8qfn/n688+PIMrx9hO0GjGt+w+GlsLbjwgL2PzpR/zDMs2FLD9nu8rzdQMbEK8gOIBRSJ3RVZoXh4z7BhPJf0dV" +
    "5FawjxY0O4B9vvJi6a3JdDDDAWQwAQ762rjhQHAYcQrRuULtkPMHamDheAyF1HgGTJ/d7JkwalSt6YRhcgprK2QfNfrRssHQWxtJ" +
    "RFQGboUqk35+WSxQXcECmA4KDFwv82BJ8CMM+PiEcetHKvWG1+rlF/A1EBsYp2xg2MsaE2hLExqIJcyxr2NV9s0nSGt8ghQr1mM3" +
    "cMPZWPrAJH/QCr1jpXnUOKZtK/AHapcEOJjhAO+CGw5AhkAHpj6Md6IFEun4xCiDYQFJJm53D6PBxHch++o8PjlOhttNjmRKpENt" +
    "iMhU6pWUquxDLUdDAcf7P3nX8p9Poc0Y4hG4Tm8hmERhyI/i4/wZopQ2tRvgV6DwAi7WlYDVeohbkVNMVUrfAD/ozSewHDAMDqYQ" +
    "o9XAlmqmAIW9Sx/4fHvsW1mhg5wAHMwf/YMbDvZ6GDhgW2HwVcFBHNpUfqsFs7l9B5i9GuoZ0FwHpTki02q6x3WKxuWAPqYHe8BT" +
    "saDnSDFLKdrgpie9JnA0m/UK1f1h4BDrbf7Ry5foU0A644/37FLR9f4jhik05mXYAFQ8N+puLGYBFjrNgUEDyxyABTRMofF6eXUJ" +
    "vNHVpY1PXEWOTqTeWNt4x0dv0I4EniX9KC2HfEnCenCfY/P9exm6T+aRCra7mfLunzLnSVQ7ag6knpLdkLo/kkjPhqEhhhUsydfl" +
    "kGq+ALyeAkwMbm6VUj5yhD6Kj3HpdkpcTdCJPgcwwBpbFbQcOQSHoXew+ODRy8//+fK+nH9k5LRBMQMO0bQoIOQL8IHf4BxIyvFR" +
    "ivZQq3/2jIlSYhpsHXTm5mgjNSoxLG1gp9sbiGM3KA/sA29h+fCBkn7e8QILtRnQZv/27ftedAiH9H2fmuBueVrb//nxxSCI6VhM" +
    "7NbCefDKoJKbTcVCfs9X5pBqfupMNxlrZQde5hFidZLrUCp7aq0OVeytzUqJbiuFIrccULV4+ygPHsd/vrxcfPToJb1aX+A/evAz" +
    "A8d/KDheQ4vsM9NCmDzGbAdsKhCoQAF3jpZlMevxgZbc4N8qzvhalREQlOahAsvFXNBKAThe0jlwbwU4mA6DAg58KYY6IC+5biX0" +
    "A5hsfQK4IGXOFeoUjRpmvkUFl3ZajWoplwzqX9P7IBPZSlvJ43UznqNsUCh1exWM6wCOOlS/y0UqT1Gq8I/oy7fgjlbAHf0CLWdP" +
    "F7H0KhIgaDggLfoF95U/Pmy85s6G2FQYi4NvL28YGwTGK0AqDDJoNNwBW4Ft+fDr8irv00fJjlXa4kR3GMr7wfmiKBsnJH0AHFt/" +
    "Kov+vU/BuHGAlmaqKMa6vrYa9U2gygkfNFRVg9x6MaYf22bSa3lI33F3ukfHLO8/On4BCaiWw8nB0WDggBwYzYJJcCzmy2AiPn95" +
    "C7rXcK0WyxwdX/74jAUVCo4/Pr4DTZ9XrxRovJLowOIs7ZJ9TQVsXyM4WHJsA7Mi68hNxWQ8amKvzLOmyBcbjHfOwLH4Ev2Nzfeb" +
    "YlexBYdTsRyu/Z4fOXgA2A/ROOgBS3fEFWuYi3Xl4MHO/4EaCHpVnPrkhnOHbdFVZzNzn2O7KPM/DjAcCI4qF/h8Ka7D27dP808/" +
    "0kwptBX9ARBZpOCgUeaXNoKDGQ6wHBIcT7g3yswGXH6IWBZWgXe6ioW3BWCvb+DeAvcBczP3eI6xD9epNDZ6Iy9oWv0DitbSytvi" +
    "In0tNcoaRdOBhTeR7zBbDj2x2VUmQhz8dOkuRbODRLZ6FR1PpjjHImjd51doS2Sq0vNikoeyYxpIhkWCHkO2qFCHXHlFUTDGPmoE" +
    "B6IDiysyVAGDsQgRK9Rc4DsYjkcvcY/5Y5FlMNs8VnmnYoM2Q74SwQoQzl8hb+wNdtaj4ZjHVuzXVNcDJ5vDCDDsU0BJfaCXMiUQ" +
    "Pt4csiCfJDj+/LNOpajAfmwp4FBqK/StTWbKTdCoNinwHkFRs7Rr7nhI6zJ7AAqe/sM3bdvU/8GYEX8iB0rbxtYxae4+ahUmDjP/" +
    "QwtlQQS6xM8X5gInEmlQgPcZt2KiC8jWNSmzvX+/BNlRMBMADpCrf/vHx0XMh33BXxZffoargOBANWvhcNCthNoL1uj2inbKQnyC" +
    "bXFIV4exxEAkw4bIBconpePO4S/Psaw/T/V+qH/6juowfECB7Lf0Bf2JqhBbfyrRSg84nOxzEE7Be5v2HSF/hqBBMqGjk5K9gu7p" +
    "TCGfCbsH3P+QwMw1wRhCDwHp0bWHmKzT2iqng4dCZoCp0NWoShG3h7pZ0KhRp6ot1Gwr0IBP7aOnnzAfClodIG69CHmwP75AEPN2" +
    "EaTH//wPS4ChrPUrNcEB6a/1V2ygOebRgYG6jl1yb+DL+txzNB/LjCYC81nmKCoQHNAtBUYFKzTgc7x7x9qoP2EJ5y3Dg2ovLC2H" +
    "eG9HzSuHjHK8AA0PO12T3Cf1DmPl7Z4eoKNd7sQWi6uNHoI49BB09zpMSiDk0w6TuSVcB7EzgBDHm9waqJTDrDcHBwACbDuEC0tP" +
    "qZTxEmTCXpYfUbkMWnPDogoUYllvrIhOUEfwMf0NyT4wsRwbarFNDjSNKTkZSvkLtFd2bg6pQ9hyieAAGblPUGMBWgf0sFDxQiAA" +
    "SXDYLHVbGaxI63YRMkp1weoaTUQhiKk02rvAPG0Y8pNBJjLfyU+Q48mDif7mVtqjjAEplkv5dDwc8Nrl9EflF7jiLDHULYVsvWnR" +
    "AYlZx/oWs9yAjY8vwQ2Fnf8T7PuLAA+gd4B3+gfOUHi6CPsLOITYrLL+SgEHo/lg6zR2RNLe6VecYzi/AO4nRCfYuk9pQyDZAThB" +
    "cQckEq3TePYDio+uoNLgC5QxhEzp0pIVOFiWo8fnGDCFwBOKpxIRHzkwPwNEbyJJ6HgoFdJTLlG/jFZ4/NKvSHkk+hwkwJVp21mv" +
    "UlOeDAX9Hhc5PH/AFWfVxt3SlG3tqMHB8RnZVWg66Gn/+HHxURmDyTefVh89AoS8hf85ee/po5cQxPyJrUcbdFN5ZeRFqXQLVW+B" +
    "r9AFiVkOVG5ZwMrKc5wGRzsrAS1QpAXr8Zw10wFbeZVGuKgXBiVgnCQH7SprbxctLQe80kYPOAacHz1e2mo0Kv255n3pm0BHTGjK" +
    "7xWXhYhiXbcScx1PRlQE503DchyljSJRtq3sDNhWqD4HxwaCg30m0eV4CcHI2hxcX5ADpVPYXrKWNKjI8or6hzfojXLyF6eP4lqn" +
    "KsbwD7tX0Ad985pK19J+N6jeQiod54BhJx0y3JFSurCCtDAKDlR6AO7ZChXjf2kNDsrosLUc5ssaKnfNW/eR1Mi1iLAcYXIctRX0" +
    "hWv4wnercf1IaidQyYWZLS75TgJ58He7u5tKoa33/g1DeOGzsplDVILF+k94Vd+sP/3AAsunqDiNbAv0OD5icvQV3UgeM3DQFBgK" +
    "W3Pv4w3014OHil4HdM89p83Vj+fQK5mDTYXGt69xBAdSzKjMKUp2oHwHAwfoTDJw9LqjDUHosAJH7/nxcBlZoRt+VPonk4w91s4H" +
    "yDHVVqCHAPgUlXTg8DkTEDFGnmw6QzUK2YvTw1lIXhRTA0QLMVj5/JnvLJ8bAh0QknzG0gmKOUFAypQz6IQNjGgpTewdDFlZfsZ8" +
    "DN7sBh2Qr/D3V6hRi0kwpBmj8gJ0PK1TyjG6HqjGwHpt37xmrSzQTkfFTlHUEmUpV5Flag8OXpYdzXIIv2634D/SUAb0pRutdr0Y" +
    "1Y+P4RdJZVJR35G8alcgXW4C56+WkWq6mm8iFAoMqvtzDVIqvUD/o0yJl1BrY0yOT6g8CzaAC6ssUnD8KcDxyijGUgnBZ5jeAN+C" +
    "gQOoo9Aii81zEKswdcE5tBnIU16nvTC05YFKpqNM2ALlH6MU3QK1HFy1xWJfoT7Hn1ujgMObZuDYyfuPlvenTyZgLs+E+zgTpRp2" +
    "Nh/+tUKPearU7PLSCRlZkwLLnNR4fBbbC2zn72ku4z8sCfoG2OePBTwYgw8uCiRHQYx0nbmgT1gNFrxQ6KoHg/EKdZ6wkxrzYNgs" +
    "C5U3tCO4y8DDrVOjQRFCdaAwGYLZUyCiLlMxspXleQ6O3nqKGq9gw/1wcOgsXQADKrxHzQnFnNFR5NGtdiLricj73QMZBcU7lSo2" +
    "RC6vmdJH1sCiJ7/B9ha0G1RNEAxHGdka//lCW1I+vMZGWL65ADogF/b+7TugHT9/9URIS9JmFZbkAL+DhizoizwGXwMH9dAOJ0TM" +
    "a8x6sZ6FN7S7CSsrVA+ZEghBgx9SYStYaVkBxaclC3DUZW8Cnbcy9PxM5BvbOzvNYsQlU5m6x+PSDuXjGYi4fOwsDnKouxLQTS9u" +
    "7SiqNqOzoeDk1yU6mOX4/CeM53xvUMBZryMqvnHzAWMu3r59B5MQ2KYiyrBgODA3KiOWV6jcAovuHFTBFjHD5IwptwNlP5bZUB/M" +
    "ggF5EOOWjY15rONDhZbJPTFwMOXtOu+VZb5R3WoYT/9uGwLmVCEbNc5JIJZKJsIeh+Ocq3LgzG1PMAVC6mpFJj26k0TPvYENQAcF" +
    "B7qjuK9QCidGsJ9QXxL7IT/xhhKIVRYYJlgbE0UJNRwo+EQj18dP2B6zTocoPH5GuT9gTSDTsUA9UazIUplCOvLpDeqso5rl3AKV" +
    "rwUtMGo56tgfW6/zqTB1o6tpNHAgUwNE5SWjmATzNSB3lVMhn+ZwnGt9DpcvmhG+hqEkqY18fzzHrMHws1QirVfKL1lHCui4oBtK" +
    "x84jkw+u6FuuD4c9TMwblS7pK+p2oBDpMxrXohEBl5TFtWhUnr9CVilm0OdQHJt3WdJxkji3GJvhUBdkBWX4V+ZxTiQfwsPsBlWl" +
    "pYbuM5Zb6N9GOn9E7NzI3PAzaZvdZiUX9aG/57zsOI/6HEQHIZtKzyC7ThW0wEbep6jFRnBgJNukcUtjq1r5k5FEMSr5zJngH3GK" +
    "8Ie3VHwHa24L868MbUkm2/JMGI5nrwSrFMmk0G6Pe8zjZzw1BlkPqLthWLL+WvTgrtIyyzxt4N/YWEYtyhdrAA4+k4nNS5DgoBL+" +
    "9K/qyRjwrpV5IoZMx3YlGwt6z+uu4ovlKz1WY3erkAjsg0pPZ/DwkRp4zhEnUMJv7Wx/waiWl+E+i04BEa8gOJ4z6R6xsbx6ZnCM" +
    "X7EdhtJI4c+v6I7z+NUTusGgLDZqTkLOA1MgC3QAA53OAIEKJkiXV/BvcygxCUwTBgluN2pcogNfNp2uIYOSiQgwgEfYJ1wxg7+z" +
    "26oU477zqM9BvNFcpdMDjXoBIu/9PL4yxqshJq/82Wh2dnban0V5C4gejA/++SPrpEVnBMBBL/4TWluhtgNdUvoXxjxn37jL+pg6" +
    "HLChoNQ1dTPmERxA+pmT3ffYgP8CR1rP45CXeZzDgzSknhmFNT5Mg6GFvxnvbLECOokRfej506Kmofcd1sVzfPopX2OBr5Gr9gy+" +
    "3K4XE/59NuBU+Sg9dTWa7e1/b/+H5sNo4hTxQTvhvjRphIu5Uw6OJ0J6lDsZzxAUGMNSVKCL8YT3KNBY5fVzqviBCnRPHz/FQAWy" +
    "Yus4sAPRAqBYxUQYzvjZmMcZXlUrcIiJCTi1SXS74gBP4CZMDH/HrNaiDJ6OnjOBYpcffI0eaHQ2C8ngvnO5MJ68SucRsFNO95hm" +
    "GwwH3VdoxeWz2F/+RHpgpwOKHNBZT7eVV6+e8AErMmShApMUHOwH9o1jAyzH8gIr2s8/pcowNFEKQxkoPFAQfRWHTGIJfwUTpGyQ" +
    "+qaBjKqyycAcbQ4Ob26Hj/Qcmhcg3qT5Q9VKnVKF2oMdB18jV2n1bCi1QsKuP27Q4+PwetOHEwACs3h3/v1vBMeXz8p6jx34/wFs" +
    "dP/NLccy74BkzoUQMMZyCzcdj9kvsLBDcg4j13WUx4dS3DoKhdF0xxucGIcJUsx1UKo6goNq074U89MFPrgh2eIztDer7J0FiiL9" +
    "5xpS64QKlC9RrKtDWTMux8nOVzlWfQ49Xu7xNXbA1wjoB3n8chnBoSzc05udf+/sdBAcQo6B/oi7zJftnf+3C3vOH2vIAH0lCaR8" +
    "A+ElWmYynuD+QpHyDFU6lnGkzzpNbjAWGIKDlt5W0XLQMRtQskeix2uY37SG092qEh0qNowJ69xy+ItdzsfWhr9/4g4mCsaEEUvL" +
    "cXbnr4jp1WLXbFfzicABEzp94KBWvLkNi4NDWRQkABtoW/njEyQ9FZYPJwc+k+Bge8xjfugVZtGp6DEk3SGhwWRu4csKHRWJquqQ" +
    "BsPWhWUEBzZcAziYSLFiOoTh2JIAMW8rW7ERPTY/WI8O19mLOc6R9jmZVEdVdyGZE/PrB318K3BUNxsd8Eg7reaX3gXeR3tnm+qA" +
    "rc6zFlm+k1BOB4XF4yfUERXYoJkO+AtVCMMqC7I5sPUeWOlcJwi6sd9gRzbuKq8xWJkDxZ+3L7m+eZVPdVN8jppEB6eexzBu6zYL" +
    "kyO9f9TyCCay0MsAY52UmWbnQftc9bdBbDXqd5EDv6xyhYGjZnxK4VLUISIBr6PTadPVAVvRaUt0wJ6zA6ph8xIdYjthcxIeMy+D" +
    "GhCKDwaOV7TWtowNtDjofOH1xuuNpRU2sniDtbbwcbUgc7r2bumtGF0vp9erjpFwPPjbAJI4iBtlI/rILGKi+6PpbD4zGzgNSXTH" +
    "EWpL7irQ8B1KPUL1R9kcAvxcouf5b1i7gA8Axs7O/+3+H8QvOyAQ9Xmruf3vnX8DOJYZOLgXyhxQ6mTw3gQWxHAuOmTCsOkNy3e0" +
    "HwFLs0DsWaPkQEyILtBgFsSvcY71HHAEARx0RMImR0eVwgNfoAETZd5KIBQN+rX9cMwJ8fhAWuGcZUZ9WZoWBV8jFz4s14Tt4nKM" +
    "/RZmOUCyA/RFERz/R9curP/7v+7/+3//7/92tgEfaDn+83ENODqQGAdlDnQ6qeoCdTV4EuzJK8MF4XW5ZdTHf0WJPqDMAL33cyuQ" +
    "kF/BfkmeBYMdB0nHAJq3dNgw7cSrwDfpmSKY1Y3Q5urD/FzkS5Jvb8abKwJ1RdB4y8b8muOQ+h1VI63E0uifG6xG+/nLv//D4bFr" +
    "rC66o7vdbYhl3iEv9DkWTmgKjPoWEhxPHsslcuqIEyzbv8FJLI8fY+UNuh9RxmWDZkVxwAtNouMobCCel8ulUgn/0VW2WZbvj3gj" +
    "6Ww2HfVd/loz9pxfsd4WTIBCMfoah36smhjwrJQvoPcNola2sUhwdPlX2F3oZvPl0+rzeaHM8URyOoQTKlyPJ6Joi397hQn011QO" +
    "ik0630AdwQ2QsX2N8ydpHozOsEZwoLohW/mCsYo9y4bfyfpm08HztmmMtHQPzrM+AquJuwo32GiyjY9kBRLmHYYODosug8gOYANc" +
    "VMiRzs+/El0rogTHjQX7/oxlO6QVebZOVUnfYIUW06MrdKzG6tI8ap2yWbPLVDQZWGCPHj3I5bKw6Bf8Divfv6ydMhbr7zaKMc+Z" +
    "2Uz2wQ9gkyFcMArbdeT8AvU4M9r0Q0g/pLhyOX4litUv/0Zg7OwALGDxveX/IIrpfHm79oKD4wmT8jFQwLHxjMW0tCJLaem4p3DD" +
    "wcZSg+wCJDpQgGEZp76tIktwBXPoLx7ev59hK81WxlhZZVm9PyLDud1qyn/w84eTyN1UwoIc9vwfC1sjmU7F/MepBYEnWJ51uAYp" +
    "00oXqi3Ilu7udHcNbKD12GmVHzxde0E90mdP1AjW8DV49IJFFTpmg46NhO+PHz7mNFJgDIE4Pqqfw25CJ4kCOBaQB7b4IGWzeoAy" +
    "qJmLVlvykYMyNoB9mYDTH3A5Th8DUA/Ec5UGjJ3KThwjOJLqSvSvTL682WZ2Q6IDVruYit9/urLwXAWHsBq0qMJsBuUI8h4nzvx5" +
    "TEd6YdILFX1W2OAEOoIYkIIOKSZHH0ow0JeVTPBXqCCEgcQmEWRkCVulxAHR4Y4Xt/D0T57EnrIvfoAWiBdqNMG720y6j3Q+i+mr" +
    "AYN4HP5nC3/D//CHRCpT/BNyov9HvQ/8b3f7/zpFvG1qaQ36oJ/jFEjWFIm7B9VyobigWh3rlHTO2u95Ee7Zk2Wmg47tbSiOvErb" +
    "Eli3G/ij0F7/6L6CDGP1wyNt9f5kDzKrO1UTBzt/UyUUSe/WzfWa/Zzf4zEbnmDSqBx2C77j47FTVAxbyWx5Ewr5bUiH/RvrtZ8L" +
    "7E4PYRbGC9TnwcmxdPegHY+8BPeKK9dyl/UVJYVR92P9NYrEQV/b3FNQbVnFdgRYCwvwWNQZfXifI6PXlhngSCngsIhWKqroXjl0" +
    "ENOrJVgf5U7Ba7T+fMVRLKy7SfeFlCYUWMWJAwwqH/FdxEdcidQDEKKEdEO1+Z/On+VChpoO6LAGfCA6ECC8UeEJbYqkSQ0qw/D8" +
    "MRtSjZ0KlC0I2IBBwyss87WCewkq176gHSsba08fpCzNhoCHyftI2Xy4YuoJbMzq+/3UwK31FDM/u0V/72zWr1KFI0yINKs2ocAq" +
    "+EfPs9BeYaL7vANyIOr946Mv3GLS+Qot1b4vP0BwoJbLxw/LlPfzTIhz4CbzmMJhASewrGMg84yBg/I/wBsFLQ6kmAPdnGY1qOV4" +
    "8YJuLmsPDW8jYQUOEzpSNu/PDTreu4awmtv0mR+Nn+FK8ibbok+Z3Ovo6RM7Cn7HqPV/4onkqu1dE1tjF3qU9sMfgMdIQUHJxLa1" +
    "vX90P+hI5crvKXHwCzTFpeLgki6+pwOHoWJC4xAeprxirU04z34Z9xmqAAV/XMaOlufP2eAVlHliM8FeU4eDbjFKnGKJjURSiVsA" +
    "HQmb9wd6TQlJlWuC+uSQ/cDq/ESrvEVM7zm/X4e/4QpE+9h/3VZpfwoQ7inQud3ZrudHat0PjgyN1H0QJn3/USyw/vGHTML+04s5" +
    "1lWPe8lz9EYBDMuIC9pw8JwdRKEn+jMdu4JatagtyMuxELSg6g8M93oqfdFE0spumNCRCtu/M084zwwwldAgB+D2p2ud3R04/YrE" +
    "T2DS5yZfpbbiBqvRo1GLbI1pk6byQH0OHK0bL7a49L8+Qm3AEx3RaNx/AHsIVSNnmtOLD+/Hf7//8Cny0j8tzdEZ9ziJfBn9jOc4" +
    "bRS76LHxAOSelmm/9AIDx7I0HK8ZURCwgWOgMA/24sPTQZYjaUZHyqKvwHh/rkCq1Gh3mhVVnmQftRHNn8wXC5mIR/gb3li2UGTa" +
    "jydfWwkXe5pQus1yJjaxn5l0rol0ubOfIAc1e0dABkADyOBLYqGE3KMHv8fjvz9YouhYW8EB93TMKG1R4OCgXSkLbOAoa4CcB8Px" +
    "hiqev5inWi2rr9Ezpd1uWKr/sPiAm45UIjFkX0nFJ7TBn/1wKptL/+3AnSkefzAgGBHEqcXLrd3dTjX1NfqgPJm2GRudSibkde0j" +
    "eiJ6tNCQvmx5koyk3TAVHbaf3H/w8NFTFBVcRFhQccGnTx89/P13MB1s/sUnnMgDFx5VncAr5ZYDZAIhs4WS1qyrHhmkAI6NlTlo" +
    "jF2hE8vpJHTeu/J0HiLcxYf3B2EjoUAjPEzXBBgbXt8hpqWoAzYJzO/dZr0Moa8ADl/BzBkuZqb3J5Cr+RMKR6xb9DvG6whXgJ/c" +
    "eoycPIc0UFSn0BWTE/r+NKw8oeymYnoaTIXO7v7Edu7y1+M/HPY4cQzrS+iPOJyOi87/svfhlCNBLj3enNVOnkMq5sPCfoJNKPuV" +
    "1fbGC6rL0i4MUT8m5/6jflH8cOEC/kzwe3+m8+LF/3KOdFX9YiBJ5Cu8F1diiwkOV3OxwH6nvriCaVMjV7MQ+daILn1n7KJAxwX6" +
    "I4DDcirexVEroemmeR7tielzoM3zp2HiWrOKshFO9c0Ovz/xRAtNkwxDZlK3fX6X1z+hhuvHqR9yMsfhHQVMCYi+G1+48B2s79nC" +
    "H7+7JO3IiM9PgrnNZqteAP2or6HP4Y8m04moz7HfKo8+kTS1sgADymed98G/eaMQrueTky6bzx45kp2InOA+5ovRdzTR847kbnHp" +
    "u+9++OHatR+vy/XjtWtXf7gCAOGWZbS35IehjPGvRj10ub26a9+2VAfCsVqF3MyEPPZlOe9suQUE4VrGZ6M+B0rOPptdrR+uVgAm" +
    "lgf6kWeFRXIAJAFlFN/RVtaqBnUBkPH9tes///zzL7/cujVzC9fMrV9+gT/8dP3qdxQfF8iF0Z7PBexMchb0ObiOkRM80WLLlB1J" +
    "MFFaq/sThzfBKlLdStjy8XXQVysWcJaH9f17579c7tMFFrBwWnUxK6+f7fvsq/H4Bzg/3ix7/9Xo5d7jAI0ffvzp519uzdyduXPn" +
    "zg36H3y/ffvOzMzMLYaPC4RcVl7F2dfnMDo0gumaaUsZ7Il64mIDqsc0S6nwQhs4X32qzWBQvN7+fJLm8Xq95sch+LeeW2o63Kzn" +
    "M8du1ms3iMUth+7GLDu11+gZDHkRjMbV64iMm7/evXHz9o2bd27cvEn///XejRsAl7u3bv3y04+wvZyE7uPJo8MbzasBbKc6mI4P" +
    "2BAxTSNhtYH5sw0+R6+nXcqfALJpz7xn4o5maH+I6W/TabylX/Xzg8lMNpMwJbtBHhNuFveb9xltkt5ycl8tioHitlGaN9aFS1d+" +
    "vP7zrZnbN+7dvHcDcXGXWo7bzH7A77f/586NuwAPMB8XLjjOhz6H8umbAJVJJSnaLMYtdM6dMusF/kZHTtaNWjy+N1Xt8ikfPjUa" +
    "AimtMk6HS5oz1oFCC/tDEoZykkOPFpt4y5RfsUb5Lei4reWChk6sO1pswM2qab+yfxGYOV6DW26a/aFh58fHWYFbxkRUiE4AGj+B" +
    "0UAcoNG4Df9mwGjcuPcr/P4/t29SnNy8MXNzZuaXn69//91F5sKy+PfixbOqz2HMcJvMqYyx3WpmSrdnokClIW4wYHrHN9H9X49x" +
    "bOx1cubPNNOX360ldKZ+6lAoD9vqLCvRM8KYm4S1bzJr1MzJvQrGxzMqTS3pMQ2gafEi+z7Oj1NPsoFXxSBcU/zP6XBe+O7qT2A1" +
    "KC4QBwADsBWAkzs3f4W/3Ybfb9Pfb8Pvd3BzoXvLf/Gsx8WLZ1WfwzD1mZYq01GZ9Q3cFr1xI+DdthpO5orK2kyrRwU5WOYFm6Bh" +
    "8YkrUedIMj7pUzyPuG3oc4nBBXsV4ebAPfnA1h1VxkvolNso9AyY1FxtNLdggMEFsBgXL4J/CWbj51vged4BzxNQwf63/g6W5MbM" +
    "3bu/COMxCjZOrz6HscJKnW2nluMKznbzP7yGvwHjV2Pevkcmk/m2uEFFzEnnx0O8sFBTNxZflj9gKSTDDDH1eq88JTkjAsPGKHEi" +
    "BB9Br82YPe8RI5d3irIdYxTtd5c/mkhCAuIyuUD/cgnMxi+wh6Cnce+m8DHYTnLnpuJz0ONwZOYehC7gmfK8h1PJmp41fQ65l8eq" +
    "qmQi9ffsvWnvrEEyg6GG3v534ktvScOR9pmPT3NwtHOKpxkscn5ANa71Wg4BDjqQSoJDkCMMjRF19rw7WRfectIzouYIg7Wme1wX" +
    "nbyWSM0G7ChgGGATwd3kJo9TGCJuMlzcpgHMr3dmbt9GP+TOrZ+vX7mEqCD/jZbjouNMLwUcLZoTdQysyxn+xnapf4QM3DsmG8Vo" +
    "1Y5YbCswhtTIUosheGBnIo5+cIQMokq/5fAJI4XDD8UjakFx571icN/5WHE1L125/vPMDPoZ9KrfUPMb4jv8/Y78/fadX9HG3Jn5" +
    "5fpVQAchF9F3uXi20SFGg+5t1zJDuuJMvui29TBUn2wF2i71dXr4cy1KJTCykDAzTHzQd41alOxTpWPfiXm3qPP52pD4cqf4fbfV" +
    "OpYrJSpEdQhLD5RTuHDp++sQo4CbeXeG2Ynb9CvLb9y8d5MlSW/NzNxl+Y6bzIJQ83LrZwhq1cT72dPnkF8DORrHNktJ/5D7m/yN" +
    "csxjEdM4Q1Wp28qnFCvHQROkWm9U8yHNuKcvxz/9Stwrrdk2REMiuk1w0eBW1itypaDiJaxOWMmZB4Vo0XZhkuzz/NBUBUYpt+6A" +
    "twG+xAzzMX79lVsI9DtoVhQWzZrC7XCnoT4p5j/u3Zj5+RqNWs6uPoeRHQ3nytVqOTO0V9gza7SAdRAbFh9KLSJ0nxtUQ63ng6tP" +
    "xpNJc1dxoLhrtgiYxYpvGUNf+NPIxuZO3igqhgQM1GQccYt4BcZNHYjeR7GBduB/EBf4E/tKoxPAC8SsV6/A+v7q9Z9uYUYd/VEM" +
    "bPlxRMcFh+MczFoBNz0UjU75hil1aEpn8Q74G9YVW2E5OjlGPiV9VUGPmesc5UkRHnEwz5APOkZwCAgS4Zso4HDwyRZgI5Q/OrSA" +
    "8HFbfJqjYx/cHohTvqfYmLmDOS/qdWI+4zaNUW7fpF7Fd9/B6yIXvrsCMLpxD9zWe7fx+D04fnvm7g3YWS6dsDd6JPwFmn1y+zy6" +
    "avOdZPj9PXIrp/6G9eMLH7FTCo32+nSRq9gtTsltymQ5eiURODiczBERr6kUUDYQGdl0KxGyr/ODDiT6GwPyGhCuYqLcSV0KvgHd" +
    "QG8UvtzktwPbcfUSuKRHyz85mVJKOJlJz6rEhVFIHzIfgdjwOGyYHlq0WG+1gAsyYt3LJ2iNLSXbrSUswdHvfGpR4eLUo5oagYmQ" +
    "qZXb99DMS99dv3WXZUTpniLyGSK/MfPzj9+RC5cufHfpEn7Ovvvx55mb6nF2+5mfvr90FncWT6JUR66YOZgYeg59fPI1WIXYAPfE" +
    "M53KZFLTIwoUkqmyuLqK1yANQiMlY14tzHc1QROga0LwqTtJ3VT5ax3U66BXm8Ydt5V8xs2bGNfSn27BZb8IRZerV7//7tJ//zfu" +
    "QXf7b3/n1vUrJ1eHOzJ+AMSJO7Qsn/YqLInh93fzNPduOar38y+Mb1hZdxMy2usj0bqR5SBSx4+7EqAarfHJiQ5noMAdiVrUuL8v" +
    "xw1PN+tV60UyedIVk2BHPT+Xrv40g1GKRV6DfgWP4/uL5MKV6z/99BO4ncT5HebYLW4HBubSxSPgdzhOloJc581sAashkUiF8PsF" +
    "H4KYC1ogzgN24wgbPfW02KvUBhmf8DOrUWPD8+d5rLSp+BGuhMjVG7lUmh7LdWWQu59Xe+HCFfAwIb9xk2dEVf4G/HLvzt2fr3/H" +
    "XA3qfBCCaJLH+V3wF3Q7zlwKTDqWpWBfr5svGE0AuSKXB5ZEMho0Ef2IFsoUy6V89Ci19fyFrqECIPUrPOkGN1IRIyYSkcmu+rrJ" +
    "tHA6aiaSjibnbDX213j43Y+/zKi1FO5LSP7GbbQICI6fb92EOtuVS062r/TUXvB33H8cZ4vfQWR8UAyYJ+CCSFS2WNmiMuXwpV4p" +
    "ZuMmTW/NFwyHArrziPglaKfCFUPhwDASrvhmb1EWayYNXpjxKY/vF2mStpm+4S90RPktrI3++i7BRf+V5yt4nf7GbeN3qM7eRXA4" +
    "vruG9VowHZcAKNcRT8btRT7k5i/XvyMnNn/lKPgbgIFIReYA1HjFD/phbVXvpbvbrhViikKHUzA2j+z1GeFxxVSHCbFERV3laWhT" +
    "NOPV3TTRy3SjBmvq6oVUCbdJ9ZRn5NeHmwrEHv38DZbvgJiVWg4n81rBr7iKVuTHn+9Sfgc9zvgd9P4zNNtxpvgbDi9IRmxvt2D0" +
    "NlF5eflaz/hQesq38hHP8XEeZQS0Y27yAcWlLZhMmzFxUIEeVoM/ps3EVJESMYt2EeCXbQvUjKAxgikJqLFf+vHnwbyNOzN3TeD4" +
    "ETIe+DPmzuH3GfX29+7dAvfk5Etv++r9JL1cff9stpDPhHWnjA+ge7rY2bNcnVLC3xfrHk1tB6yVyJ00Upp575uMJRKsBdyYb+Ka" +
    "iCVnp31E5bSToKzRTWsmzabkpnBVgyO8PpqvQsNx5w7PhfbmN+5C1eQ2Wg6wFgCOX5BLilvMZfA/7rLbz6i3h2ouluCc/20R0Z6e" +
    "2gq9qrriW4LjGfDjmG0jEkhVbbCBdOOU75hGEBJJ76pGehtZNN2cRsMdjWhuF+lpW/Hnd/ak9I66rwSF11EJO0YLVNAbvQu+6G0a" +
    "p/TyN4B9fvvGjRsCHLewovILWA4C4JjB3eQ2j1PYnoL59tu3froCn8DTnQzTAthlNeFSLIjJnviSVYVgvLPb6YAUtTIW8LjQIX0O" +
    "cBhGYPAL3qkJHF4R2RR7er7dwp8pj8bquICuJa2i3bthxd+4x3jnHBw0ww45DwDHJbQcSCa8N9N7P5pFd5xucABxu9WuF8Kqhoty" +
    "liVbHIDRqhYgjAXCP2hSSx+klvIfj9uhTdO0p0okHqEPznRDbiEgp9eDYKAfd/fVs4xXeQbNxq+3OT/jNs1f3GZ8jl+pXbg9wyOU" +
    "W7j7IDgwwplht797g91F3P/eXfQ6TjeHlJOo4CwRK/0Iw25s1wrpaMDj0XXdA/OpipvbgpGe9A3SEBuiMQZDbby6g1gd9ySK1a1a" +
    "mTmZB3t/7lgBHqKSDZKe4/psudnpQM+De6Q9/gK74vcYL+PmTYO/ofw+c49mLwjW5uAvv+C1R3CAoQB7c++e0s/C7Qzc+r9OMYeU" +
    "CDWZasjKvuqyStUpJ4NeOZnH5Q0mSiJOLEddh2iZSmfTcb+1Kpk3FEvEp33kEP6UJxhLzEb7R9DjE+fzmegID44hxYVLP/w8w/kb" +
    "v6r5Ch7XYrAKuwXUTC5hUR/wcPsGGAb45Qq0tgArjO8logqH/S0zd2/9+N2p7m8j4eqejdQQodaXO26tQthrst3EMy1Imh1RULfO" +
    "yA9Cji9VaXVatdyEzR6h6YcZB8Q6ZXWXZaJL8/j92FM5tOiMXE+MQAR/49ebRr5C8DnwJ16TdbCUOYLje9xjrkGhhZLCTLdnNdyf" +
    "vr/wVfaUEfkBZEJ0BEw7+497BA+zmYduEqdZzIg2vUoKr/Xj64FoIhH2uWyeX+M8jAZlDZqPEwUkB3x/8iHsjzsdZNjjX7x4AXaV" +
    "n25xPgazHP15DrjWEH9oQPKBJDs1I+CAQH/Ld1e+R1LYz7dmzLefgW6Fn69eOBL9kOMTkWP9Y6VJCyZYSPSICmZnD/1LdNGWrbPQ" +
    "Dnc0X23AzIigZkcDaVl1v31lvZ7erDlg49L3kMvq5W/cMOU7kCAIsQrkQ8A7gSwXDVcuOS/gvUGjAZtqMda5OyP5ILfv3PoRH/wU" +
    "7yvQogrxKWP89hxypUQkGNKtyYE8XdBMW8azAC7KKG9mrLd2ImgYlOx7atcFLJf8ckfyMW7TfAXksVi0golxgAbwioEEdtGBmQ0W" +
    "zWBhFtV9CDTJXfrue0DHrzM36X3YcYhmkddx0jvLfvQ3vNFMoZDl3e3qceL0FXYlKcby/sJf3RF5BPNxf473YEM2wer+XqGL2sn7" +
    "j0tf5PDH8eJBrHLPlKdgvPM7YAeg0fEudLOxTvqLF4FH+Au6o3gcW9wghX4B21QINLv8MtOTH0FK2CnX5yBe6zwWidZ4X4Cd7iCk" +
    "uNscPpqFvK9stK1GNEvDIcqunazvFBsOcDp++PnWvZsKfwMsAPQgoHgPWz8hNID6BzsIMgMhlEHe6G1ocQNO2BVQ90F0IN/YxP+4" +
    "O/PLtQunXyPPUqvLm+lwHlZPfszIQ+m8iaSR6t+VvAnZLlcJWcUEXlFZA2zpX0/BhAyPVwAcd3t8jbtw4X/88dpVvkCeBXcQ8C1+" +
    "hnzIDO+QvQnaC4Cb69dQHIwX5AxfBbR/wOk4o/ocgQKXUvAL/Q1wM5AJpgQSAZ5pRMKd+f6u6ZLoZNkpBEh/NKKMWMTjpg4jvF4u" +
    "beQM0CGOu/zhaHhCH9yEBgyNOwofA/teIWxlmoGAikuIDNqNgNjAKiz0MuHt7/1Ku99+/pluOWg6zPmR2zRJ6jyD+hxapMq9TY9R" +
    "7whn8gWo2cr7u9NtXhPv/TwG87JboWrRHEmIl7u7SObpPU60QCQendCPW38EpfBg3G0h7iW296cs8l/umfgbiI0rly7xTwj6lAS3" +
    "lKushxZ6In+9x/gbyP+AtknooIY953uMY1T+B+RCrjicTufZ0+cQLgf6E0Sq6nVoR5tudNMyykQ13JualF0j3UbaijxodNDv9pMq" +
    "vMDZaNZLCd8x7y/cegHlUBvCD7xz46aRp7h9+xbtLkCtDsyCQLSK6mAg9DNzT+Y/ZujucZfyOCADcon2Ndy8p+p2QHnlykl0zR69" +
    "PocKDh7Z+FkndBfqpMJLCddUcEh+hcuYvNrKTVo+viSB0+mIpmiHsC2pW43rx6tt7k42pYw7sb8/rbNCvd7oP/kFdXrIJbaxfAfd" +
    "j1d/xETXXZpjp5Xb23chGQqKPlQzjBKKaXrsnsEHuXkXyys9aodnRJ+DxNh1r0SJIZPACzEGx5un36sRE9+HeLPbsqHe+lNpNEQX" +
    "+wg3Ou+ub1tGMUc4QFH4xFQUxP5hYT+A/UHlb/wMniT0p1z7ka7rPEUOLELgpt/GG94DDTlMfly//jPuIFDLh34W1vVi9LsgC/1s" +
    "asS7ZuucKCMvbpibg1qM9Mhq1MylGWIMaNhKeMhAcFhQwEXLYqcQ6Kv4AJM5FPAcAzgGXCPeA2nkOSgDFDmAv7CFggtSl0PeDrV8" +
    "0A2BiixUXS46EBx9j+M4k0tuK1FZM50QlmNankq5rZCetgKxZ2SsM+NE49of0Ael9TNZm3syCOob3VCpltNB7Ujeo863Fep0D7Qc" +
    "Sn7iJtsmKDhmYA+BRJiizwHlWfgfcuQzNMtxnfI5KGfwgkHuUPpXHGdSn0PxOUQVzMe0+LArwNnnc6gaW8DBanMau5/YcEwDueYu" +
    "sNi3Ut5ejTFQe6tZisphY0JlB31cLvFyWB9EC5c6e11wsRXWgcX9heUQtRTaKf/fF1gfC+4397j2l/xv5s6tW5AYw5w5jW5YD+1V" +
    "ZjmMfIkVOM6EPocEB4pvEsHxhk7oejEqKZxarN4frdCySxFS591mIazZTgQLZcuVSjE90a/XQIJ0REO7FHH1NTrt8J7Yo9mpvbF8" +
    "uVIuJAZnaNHnMPE30HJQavndOzRuhd0EvzJdBppbh1LLte+/pxK2uH9QQikFB1Mf5PmOM7utyB6WtNfQYZpMpNOzxjgEorMsan+e" +
    "Qw9ny6D6MjUgVaH5JkJTAUuPRA9l4Jrlwu4+qUpBP4mT/WVBdZ9f1yx2Dt0fDAf97sFOLkYrtFZ2m15/tq1cYJbj9k2qvIHYuIuV" +
    "29uYyaBbCq21QUkG2cTM52DgYHwOiqMTAsfRzx8h3G/YRgYhcYpGBt2t3n+CZ0hzfYrAxDsRDnjJ4Oc3cq298128gdCEt2/Is87H" +
    "v+9tZ90jvz949f54vljMxXxO54HOD91WVP7GLelzyL//+uvML1ToCbxNlPf5nmHjLttBpM9x26znIcFxFvQ5zG5hW8SyRKnCqD6E" +
    "zsLdrlVtBUzDiFGa9a2sdC0lOHZz++nY9iQq2ziTM+E+2JlgfHKlX0WAg/ocoF9N+2Ch2IKcnnvMbHx3Bf2N23dpFv2OYTmUfpc7" +
    "N87stiIphKoyaM/VDDBFt66SC+mjGu4bHcT+zrILDi3H6GuSkZZ2ixPkQHMKvqPRipGfuGGAg+lzsNzH1e+vIjyo2YDSPSLhJvKK" +
    "b9M8h4PmOW7fVvU6TgIcx8Rv8HLvT6h7Ons5dzovvGIvKiEG546QgY8/TJ+D9E5blN/8QqyyntD67283jdI5zfMz4MZaTXkhA88P" +
    "q61Y5zl+UfMWUG7BHPp1rN5fonHK4Nvj33/6/uzoc/QYdp6o7JbCuqU8YLgomGDe/U5BOliwIcGxFbVK22HJ2ELbjoh8WzWqHaik" +
    "D1fVrK9hWA6er0Cv8xYtxkEunWLjl1v36F3AyYDjsqFF5kPuAOXj1xOV+DliNcEg55C2rebvEHeYswS7XHIWe+XcPnZ9yLHAwx4c" +
    "8Iy+GJSMs1YjPwQ5oBw8yLNCazSU7E36GmZLgB1L6I/cwjL+RbQ0LL8hdTmAE4ZVWcYulX+H/DqW7C+c0fkrnqQYMmDOV7A9JcKH" +
    "VsAIAo9oYg0kMjk6O4cMeHzN7UPplwO8PhM4nObPt3sW2hw6beze7b0/lwEDwhkh+z8/TidNbd405ydEhpT+fpd6mb/OUHHzC9Tf" +
    "uHlb6ndA3yxYCOeF73v4HFCXQz2Pi2dCn8OirC4ajtvFqK+3K0geE1rARAvmau1OC6/PAH4EjFrM5ykpxPb57eb9qNpfvcafz2EB" +
    "Pmvfm9HC0PPZqhVC2oH0Q5wXsKVJ1ddQLIfBz4B8xy0cuvMd9UVvY7brJj3+K1X84TxBVd8DaIKXuAb6WdDn6N3FI4KttQ3ju+Ro" +
    "NOLyTqaEZPF2SVoVf67Jg98Be7s3Wd3e7ULGWrejtPqnQn5LDWS5P+z2y1JJxWIrPit0iyeTFo1vIy6UX7h9c3Ceg1kWRMdVYBLz" +
    "v/PvXOWH0QSVxwFX5MLZ1T53wqjHHTlLNhML+f0+v98fjGeKDY6anUqCK3Y5vUmumNNM6faPz5V5OvmA1c5CyESqWC4XUgFtwPwX" +
    "IZTvVOV6qmKTc1u9P5d+wPPD2efYRa3ojSo+B+ZO/weUaJHvAQq0P/0kWOasJ/beTdYmSYB+fkedz3LzV8uWt7Ohfc4+xhIdezvN" +
    "aqmQz+Xy+WK1uWNo3Is9RI+ImxoZdyulWhZXmtV2FMOS2tzudrdrlmm1XnCY8mP1PbX/bhCTen9m4wLth2Z8DrYn3DQsB++ERBYH" +
    "KnTcRtLojNDvmGG9tXRXcVAKKZ2/wvU9foVg5WzLoCM6DH2OXRi929neUfQ5qmA3+CmXYkpoOeyuAnHxTzioS1v2K8Q4wkrBfYGD" +
    "6LM1OTyuN6uG2i6EHBQdCBCqeD40b4Ea53fopBW1PwXbJKH17TvB5jD4Hr9cpbOIzzBA0EewVfYxOuWIP103GMXagGIvtxwlS8uh" +
    "CfFRM7dMtsh1rWTCqDMsR46VgxbUMamhf7AZK0j/vIHyHL9SvoYSrdzGfAXLf9CUxr17lK8xc/fXX+Hn20LzGgPZX8BiYDfkbRjF" +
    "gnEMEFGBfXrx+DMdx8OxZNFFvNDctcQGDBIVcSPR49LCdAqTAx6fR0At0R9rPi667PY2hfa0clzwPKikZO+MNjmEqQcc+3v/1nES" +
    "1Mx+ofNS7uG/e3RboVXZW6gRdteqd5ZywlDtGH3USyJWEb4ItSG4qwBH2XE2Z7wZzItKuw8ZMCwyG5ZBBZkoiJsAl3vgWOJYCebC" +
    "gpaQ5Y2EJIRlNlOqNTWS/XeWY3bKQXKwnB/N4PVtiDTShDb7mTs0Lr1xm3atKBlS5G/cvs3nqfTojVIa6RVsl0Z3lE7mocwgzH/A" +
    "rgIyxmfa6aC23h/NVlpm69GqZKM+FxG5UF9ahC97VSzFkAEDv0JACklMWOp2kIQUHw057MFRT1iBo2urEDhSOl8LpfKFXKKXtsry" +
    "ELTIhjig+hqCTf7zzN3b2C8LM4ZRNQ47ZwEWd+E/sCfwF2yv/hHzYihrPEMnvVGNKIhubmJH00XHadbnGPm4J5wqVhstrmDcqBbT" +
    "YY9y3KWMCqRF3MGPr13uEfsQX31CxHxXpY+K43bgoMeDQq+4Mk2sn58oWjAW/BWmVNPM9AhgOf9LKE325DkuGwRj6wU9tNchoU6c" +
    "TjZ6hSU9wN+4g4O/bvwiZWpPqz7H6MsDQizpDKifZzLpRMTM4NLDokMJWxFcB9/BxIzIvXbaqpojtxULyyEnMzUT1pRmPRibjYVs" +
    "41wfYzXvoo+tPsB/8ck6138RXgVyQkGYhcjWBNqd0Ld+/JH20BI6luf6L+CZ3KQz70HRGP0RrLdcdJyXRejUBJ8PpyZoPRObc0bv" +
    "Y8J7mFmlQrO+ZsUQkdKkWwmXfV92K6FZ00UL1c1q0baLTkTi2z0TIzh7jNZXIC6l+hw3sKmJXBBNTbYLemjhtFFsoO7TrzTauYNx" +
    "DKTOgf9z8SvU2o5Nv+Ky9XE5nREJ435CDvz4npRQbSgGLJgXk3znAEXifp1CBRyXLR6fINEcgmBs3LV8frktVaOWx9F0oC4PzVPc" +
    "YsoaUGp1/Dd2RGKvrIM2RuJ3J/3K7c8lmM3z0y80olHzH5j8uHAU1+dU6TWQvnSBlIdC8biJwzy83Bp2cl6L5w6WpJa5RbZusOUQ" +
    "XXTWWiBEmdnSznltEmEzUp8DPvdXqGqP1Hfp/w5KLij5dOUqctDV+Syg9nLzBtbcmF1yOs7bUnU6AkLBByfUa+QQ0yjluE9rv0GA" +
    "YxfB0Stb6xUzEjpp3bK5zbZRSlAQxWTAquXIZBa58nwG1GWvf2+9k5h+A+LgdWiUNGuJoWdKGR700+885lbqY9SvGOG4NyUcBRgY" +
    "azmOc7THv0wg5hGzQqet7m9nOZwsfy7GV+e9Fo8/oIuO5b6M8V67+YDV67tIOxQ4H4MGqT9ek+otVos20f6MKqS981Z6JmqcPX2O" +
    "UY+TyZKRGpWqgwd5fIhGGuKBLEddKODov78W3RJaMF6Leq/Op0rywTwWWsvGiMtqzPL10ZmytHYGedKbquyTzcJeBTEtwaTvgd7o" +
    "hWO9PqclQxaryQptVD/UQ0miV7O/soreTmxTSAVNWDBFeYceDKjzWoVaoUKr2+127PWWSUQUAJqWVeWLFzHrNYPdbTexwY3uMEwb" +
    "Dl1Msy7pbdoBh8NkGX/D3K+C3FHHaWAGOo/5uFuM/urW6QQFcuDHh7qa2PXjutVxkT41OZVOyQXYsgSHOO6J5Erlcj7mtZ7vok7H" +
    "3SmFNYvnv3iBKgLevkc1OO6hRbh97zbakns3FY4p42tw5SfB37gxYxyn+rUXnEd0/k/10uN8r2/n/cR5qDyKMVnJshWWCK/CIuKA" +
    "krywHHulCWuygD8UCQcG9WfKNG/DynQ4HUzX3OhfAS1Sxtz4tWf+Cn6dUfgfN39Vjt+jkzcc5zBKsWpQKBvjGg8XAcmWpX5dDi7S" +
    "ZGI09+oti+yqZd8Csy4DK/ZEbmvdokV9BvLotKMR6rJyzsqvdyznr/CY5A6zHPD9V2VOi3Q4vgV0eFO1zu5Ouxw/7MA3j8w0ZHwD" +
    "k5gVSxj6pCZI9IDdELpUx2ykdBtiB4yIvP2rSY9D0dtQfr99w+b4rV++Iv/ruH2M/uP+RL5YyMW8ZOh8lcGP75Pc8rir/zhW/xLV" +
    "7e7eDqpzWNzfBI7+48S2I04JhwSZbbfUq34p0QGDQa3nrfT8jvi4O6PyN7jdAGeUHNH5PwvL7Q9O+F2HN0Hi0tgxMog/WSyDpIe1" +
    "rs9wyzFCx7Vgs9VndWvWGKJj5g7Nd8xgTvzGTYv5Kwafg/5+d0b8fg8nmp95CsdRzx4YyXvh0cJ23mfLBQmAIpi12jYxwBEjB5ee" +
    "FPk8yLQQ250FshfA4JihcchNaiPM+h1Cf4PPVwEU3WNa+NRuXPg6m8nJ8TuO5fhsjamChrUB9yd29xdy3BDMeA/6+rzpbTni3O2w" +
    "7lVnw+oNvdG7N4bMmwXL8es9zgOhvugxnL/zvwKZyla9VrLRHxxqoWJCEjnvO7jshJxblu+LmHC+7EWWKsWetptcBX3mpprfMOlv" +
    "mH+fwSEb39yecoR0xERqNuw94PZ1BOAwlJeBHW9BJr14kfGNr4DI+c0b926r82IV/Y6+31nO/PrXwMZXmU8CPZF+7IcmR/j4wCdy" +
    "u8gg/Q4y4P4qOA48f0bwlGlfjfn4fyOfFGvsTuSEopb1vRsD8hzsO2Y47tzF7hXowb90xNfn1HqgvliukE9N6afnJUlwFHyH0a1t" +
    "iSytBfvgouCGXaTyLLdgmqiR37ij5jMEfwOSp8j/oEO+vpktxZeq7mLnSlg7wXhm8NQU2dYAnZbkoCLYIP6/ywrDEzbYYHWWi3RI" +
    "AlZd4b+7N8z6HWZf4x5C4xonfn31dRL8Dj6frZ31Dr8/0r7Vj+ExvD78xV8SkUZEG3h/MuDxiS9V2+nubVdmPZZTRFkenU2p9l7l" +
    "Ux8hnw4VuF/78x3IJsYZXz+aoHHc1+fr8TcYSZAIKnAxYDtvQH4YJ+OpZMw/8LM8/PnJQBtE+xqKEhxkAP/EsidSOY4JX9SltH19" +
    "xs+cA3gL9UdBi1TqdyB/g3UwQV81+KFAQh9iO88Jf4Pb8GTDMOFDDHW02Oy0a5nAofXKQVF2etJn6+UMAsd+3p3mDfg9o7xYiG1h" +
    "7OM1mJgwcxem/t27q+Q3oNw2IwYDXjo1PQgnVFsRFJ+if8j9NaYs1q3x6QgHnv/i8MRRizoX9VgedzoNcETJsMcnR3F+UP8LZuwg" +
    "UZROJb+FcGD/8LdfcC4gqE5eNCk7HeX1Oa2LD1oCztaQT6mLszQsNDX2mQWZLneAy9UqWgt7gHhMXtCTk+6BnjH0vTnJEMeZjCTd" +
    "gR228PXSle+vUcKoMS8SmpquXb1idEp/U8sTL7e3O1v5iWHKgV7RplYKHu4Zvbz00kzamHw91Rmi38Ik10OxyIROhm6dI0ZZ/0X7" +
    "VS5hE8KV7yW5GKnply4oI4Wd31S2Ww8lM+nY8DnjOqcRdouBQ9oqXhTbzthcepcCDmLtKkGWLQwj1LdwfNxRxdYUARbXnmZU5Y7y" +
    "NbFx4hxSPM9edNuG3V9Q/nEm16Hmv0wLArHZzVG8G0FYrBtTQMxaxJeR7YVJrt3NWbfTeYTn57/6fSAAB/uf96cc0/U528ufqW93" +
    "d9ulmH5Ilrtojyn67dqweep70DSWCGuN2c37RwrLDvFx/S+wKBcd3+a2orKrBp/gQCJfKmYjnsPZcbfoo93O2nXKe1PUdDStW6vM" +
    "cxeoBzTEWwocbprcqc2IniL+BnFC4sDnPuzju2W7Y8plc38SSJdrtXLGb//4wgMCijoZ/PxuGCdUKWVCLofzsuN082PGPDGPAQ5t" +
    "QCQSjYUGlt34BIXdYWV9Ekb17m6rECTEMV6nPXY2WY4Duwn+HOpTdSrDPCA326Kg/dd/5k/dyehzfM3jhnKPyHPYzUcRGS6nJQsF" +
    "xsfVqoWYZwAb3akIxUBHv3aqz894a3EYyi17h5wMCcPnIqHhMugSi1tJ99hsH6uGxxE8mpyYYKHcsl/9mRGiLI+Q6+gUg45zs6ec" +
    "nuPEMQJ/YuTHF/PdLOQZDsj/GHh/PbHZFd1v7tN5fs+APof9cax9B3tj2AM/vshQsEmUh319ZOj9g8JSdcuTp/P8nukFc+chU3BU" +
    "c+dhMlB7t9ttF8PaicSWHsFYQZ1/xzndWZxf6TiIOFWAb7dbz/iP5PGJK5wtlUtA5yAn8/qlXjZq+JNTd37P9uLyfEc2dx7aWnC0" +
    "uE4cJ5OV8ohkqqWa9ngdbhsoH2ju/GDteuI4CmwQx9DHgWcKiOC5lfKMr+fRgkM0JTcSriPXQT3scvkmggGvNkQpXw5/SnnPSQ79" +
    "a++B8oifj06pRo7GBzjC1+eN5orlQjqkD75/iA9V3oq7TuH5PdMZMDfTDG7lA6fttbmipdZud6eZHyK37E1Q8kenEDwfduNUeaTp" +
    "cr1Ry4ddp+2FCTXjrcQQKqk/Vak3a4XIuQhlTxe/g3inYvGIXzt1r8/P81uKmrHN/b2h2GzE7zr9+iZnsbJCtBH5Yifabxvg02F2" +
    "SqHhj6gde5/veB3+grNIdoSqmjbsdsJygI6169xf9zPN3yCSezv4/po/EgeWl3OwvgfRJ6Oz0aCbDHp+n9AbZXWas3v+voGlaSNU" +
    "S7Sp3GajXhnIyyKooFDcatZL8YHjojxSgD/nG5vuUw0NXzgaCw+9SP5sU/ms264QVYYANeXBXQ5cyWO3GPjmzvcp5XdYHieT6XK1" +
    "Ws4Ehuh38IHT3VJg4ITkZIv3vLkG6XOIkV1Q9znr5++s8DcOdNybrsNV321mfAP3C6cooOMwYqft4/ty29wk+MmA55ccwEbirJ+/" +
    "c70CokstNDigSYsJbqlBlM4JITJbGZj8dInm7lbK5fhW9xTn6T8e4sKfteh/D7q/1+Ce6wMePyCmRlWntQHP7xLqIp3+YX9n6fyd" +
    "9xWqDBgkq2wEZX7VKxFtoEwDVyBuJV2D/VYx23hMLT/N2wrPVlYGc8oDYr+wInQq+09aSFwPpvaJoUz1xPgKnOLlTW/t7nV3Gxnf" +
    "EYDDMSo4YGIYqgS1ixPkm45eT/keCqFsqQJjMkBOjgy4/0TFDhzKIxPDcmxLv9X6+d0x1BfLR90WfW9nywc514tA83MUm58HFUSk" +
    "OMducXDrqlBYGKq/oU9Mx2Di27hL+rTDQ9Po53fArAQ9KSxCZnDsKVWMS4GhuiGosk7OPTrO6nyV0Y+75NTQ9OD7h6oW8j/n/fx8" +
    "47aFBCujTGEiDn9RgGhMGP92HJNCh5VWJskQWQ1mYmoxbXzWvg19DpgIC+1zgI1NOlxrwP2xaRLzqFiLP1/6JOdan+Ow+ZBYtljM" +
    "D+Zp4AJxlkKpkAqMz9i3tHRfYMKnj8AK8vqDfs84Qj0v/INRj2PkOUotqjcuPu/n5yzqcxzpcWLubx02aYd8a+dnTFIfmao+3lXO" +
    "RW1lfNwxrq2M13iN13iN15hDOj7uGHNIx2u8xutb3ky+GX7H+Ph4Zxmv8RqvsT7H+LhjrM8xXuM1XmN+x/i4Y6zPMT7uGPM3xmu8" +
    "xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xmu8xutrr/8PhF0ege1DuMQAAAAASUVORK5C" +
    "YII=";

  /* ================= 调试：控制台命令 =================
     挂到 unsafeWindow 上 —— 油猴沙箱里的 window 跟页面控制台不是同一个对象，
     只写 window.akShow 的话，用户在控制台里根本敲不到。

       akShow()        看脚本现在记住了什么（选修课程页地址、考核缓存、回跳地址…）
       akReset()       全清（选修记忆 + 学分缓存 + 回跳地址 + 看课标记）
       akReset("opt")  只清选修那部分 —— 用来重测「第一次怎么找到课程列表页」
     ==================================================== */
  function installDebugApi() {
    try {
      var W =
        typeof unsafeWindow !== "undefined" && unsafeWindow
          ? unsafeWindow
          : window;
      W.akShow = function () {
        var out = {
          版本: VERSION,
          记忆: olStore(),
          试拼标记: Number(GM_getValue(OPT_GUESS_KEY) || 0) || "(无)",
          看完回哪: backRaw(),
          学分缓存: GM_getValue("ak_credits") ? "(有)" : "(无)",
        };
        console.log("[教师研修] 现在记住了：", out);
        return out;
      };
      W.akReset = function (what) {
        var keys = [
          "ak_opt",
          "ak_optguess",
          "ak_back",
          "ak_credits",
          "ak_watching",
          "ak_beat",
        ];
        if (what === "opt") keys = ["ak_opt", "ak_optguess"];
        for (var i = 0; i < keys.length; i++) {
          try {
            GM_deleteValue(keys[i]);
          } catch (e) {}
        }
        creditCache = null;
        console.log("[教师研修] 已清掉 " + keys.join(" / ") + "，刷新页面生效");
        return keys;
      };
    } catch (e) {}
  }

  (function boot() {
    LOG("已启动 | " + location.href);

    /* 3.13.x 早期版本允许使用者上传自己的赞赏码，存在 ak_qr；这个入口已经彻底删掉，
       顺手把残留数据清掉，免得浏览器存储里留着一张来路不明的收款码 */
    try {
      GM_deleteValue("ak_qr");
    } catch (e) {}

    buildHud();
    installDebugApi();
    installMenu();
    startEvalWatch();
    refreshRunUi();

    var href = location.href;
    if (!/^https:\/\/ipx\.yanxiu\.com\/(train2|grain|cms)\//.test(href)) {
      setStatus("这个页面不需要自动看课", "skip");
      setLive("当前地址：" + href);
      return;
    }

    /* 上次点了「停止」：这次打开页面也保持停止，别再自作主张动起来 */
    if (!isRunning()) {
      setStatus("已停止 · 不会自动操作", "idle");
      setLive(
        "脚本现在是「已停止」状态，所以什么都没做。\n" +
          "点右下角「▶ 启动」（或设置里的「启动脚本」）接着跑。",
      );
      return;
    }

    dispatchFlow().catch(reportFatal);
  })();
})();