// ==UserScript== // @name ✅OK学习通网课作业助手｜题库＋ai搜题✨｜稳拿高分✅｜网课作业难题全破解💪｜全科目覆盖 // @namespace http://tampermonkey.net/ // @version 2.13 // @description 救命！学习通作业有这题库直接躺平，还长期更💨内置ai搜题一键傻瓜式操作。主要用于学习通章节视频刷课以及章节测验和考试，为学生减负，测验仅支持单选，多选，判断，填空，计算，简答。可免费使用 // @author ok网课助手 // @grant GM_info // @grant GM_setValue // @grant GM_getValue // @grant GM_listValues // @grant GM_deleteValue // @grant GM_xmlhttpRequest // @connect so.ucuc.net // @connect forestpolice.org // @require https://html2canvas.hertzen.com/dist/html2canvas.min.js // @require https://scriptcat.org/lib/668/1.0/TyprMd5.js // @resource FontTable https://www.forestpolice.org/ttf/2.0/table.json // @grant GM_getResourceText // @match https://space.bilibili.com/* // @match *://*.chaoxing.com/exam-ans/mooc2/exam/preview?* // @match *://*.chaoxing.com/mooc2/work/dowork?* // @match *://*.chaoxing.com/mycourse/studentstudy?* // @match *://*.chaoxing.com/mycourse/studentstudy* // @match *://*.chaoxing.com/mooc-ans/mooc2/work/dowork* // @match *://*.chaoxing.com/mooc-ans/work/doHomeWork* // @match *://*.chaoxing.com/mooc-ans/work/doHomeWorkNew* // @match *://*.chaoxing.com/mooc-ans/knowledge/cards* // @match *://*.chaoxing.com/mooc-ans/exam-ans/* // @match *://*.chaoxing.com/mycourse/* // @match *://*.chaoxing.com/course/* // @match *://*.chaoxing.com/work/* // @match *://*.chaoxing.com/exam/* // @match *://*.chaoxing.com/exam-ans/exam/* // @icon data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIcAAACHCAYAAAA850oKAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKTWlDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVN3WJP3Fj7f92UPVkLY8LGXbIEAIiOsCMgQWaIQkgBhhBASQMWFiApWFBURnEhVxILVCkidiOKgKLhnQYqIWotVXDjuH9yntX167+3t+9f7vOec5/zOec8PgBESJpHmomoAOVKFPDrYH49PSMTJvYACFUjgBCAQ5svCZwXFAADwA3l4fnSwP/wBr28AAgBw1S4kEsfh/4O6UCZXACCRAOAiEucLAZBSAMguVMgUAMgYALBTs2QKAJQAAGx5fEIiAKoNAOz0ST4FANipk9wXANiiHKkIAI0BAJkoRyQCQLsAYFWBUiwCwMIAoKxAIi4EwK4BgFm2MkcCgL0FAHaOWJAPQGAAgJlCLMwAIDgCAEMeE80DIEwDoDDSv+CpX3CFuEgBAMDLlc2XS9IzFLiV0Bp38vDg4iHiwmyxQmEXKRBmCeQinJebIxNI5wNMzgwAABr50cH+OD+Q5+bk4eZm52zv9MWi/mvwbyI+IfHf/ryMAgQAEE7P79pf5eXWA3DHAbB1v2upWwDaVgBo3/ldM9sJoFoK0Hr5i3k4/EAenqFQyDwdHAoLC+0lYqG9MOOLPv8z4W/gi372/EAe/tt68ABxmkCZrcCjg/1xYW52rlKO58sEQjFu9+cj/seFf/2OKdHiNLFcLBWK8ViJuFAiTcd5uVKRRCHJleIS6X8y8R+W/QmTdw0ArIZPwE62B7XLbMB+7gECiw5Y0nYAQH7zLYwaC5EAEGc0Mnn3AACTv/mPQCsBAM2XpOMAALzoGFyolBdMxggAAESggSqwQQcMwRSswA6cwR28wBcCYQZEQAwkwDwQQgbkgBwKoRiWQRlUwDrYBLWwAxqgEZrhELTBMTgN5+ASXIHrcBcGYBiewhi8hgkEQcgIE2EhOogRYo7YIs4IF5mOBCJhSDSSgKQg6YgUUSLFyHKkAqlCapFdSCPyLXIUOY1cQPqQ28ggMor8irxHMZSBslED1AJ1QLmoHxqKxqBz0XQ0D12AlqJr0Rq0Hj2AtqKn0UvodXQAfYqOY4DRMQ5mjNlhXIyHRWCJWBomxxZj5Vg1Vo81Yx1YN3YVG8CeYe8IJAKLgBPsCF6EEMJsgpCQR1hMWEOoJewjtBK6CFcJg4Qxwicik6hPtCV6EvnEeGI6sZBYRqwm7iEeIZ4lXicOE1+TSCQOyZLkTgohJZAySQtJa0jbSC2kU6Q+0hBpnEwm65Btyd7kCLKArCCXkbeQD5BPkvvJw+S3FDrFiOJMCaIkUqSUEko1ZT/lBKWfMkKZoKpRzame1AiqiDqfWkltoHZQL1OHqRM0dZolzZsWQ8ukLaPV0JppZ2n3aC/pdLoJ3YMeRZfQl9Jr6Afp5+mD9HcMDYYNg8dIYigZaxl7GacYtxkvmUymBdOXmchUMNcyG5lnmA+Yb1VYKvYqfBWRyhKVOpVWlX6V56pUVXNVP9V5qgtUq1UPq15WfaZGVbNQ46kJ1Bar1akdVbupNq7OUndSj1DPUV+jvl/9gvpjDbKGhUaghkijVGO3xhmNIRbGMmXxWELWclYD6yxrmE1iW7L57Ex2Bfsbdi97TFNDc6pmrGaRZp3mcc0BDsax4PA52ZxKziHODc57LQMtPy2x1mqtZq1+rTfaetq+2mLtcu0W7eva73VwnUCdLJ31Om0693UJuja6UbqFutt1z+o+02PreekJ9cr1Dund0Uf1bfSj9Rfq79bv0R83MDQINpAZbDE4Y/DMkGPoa5hpuNHwhOGoEctoupHEaKPRSaMnuCbuh2fjNXgXPmasbxxirDTeZdxrPGFiaTLbpMSkxeS+Kc2Ua5pmutG003TMzMgs3KzYrMnsjjnVnGueYb7ZvNv8jYWlRZzFSos2i8eW2pZ8ywWWTZb3rJhWPlZ5VvVW16xJ1lzrLOtt1ldsUBtXmwybOpvLtqitm63Edptt3xTiFI8p0in1U27aMez87ArsmuwG7Tn2YfYl9m32zx3MHBId1jt0O3xydHXMdmxwvOuk4TTDqcSpw+lXZxtnoXOd8zUXpkuQyxKXdpcXU22niqdun3rLleUa7rrStdP1o5u7m9yt2W3U3cw9xX2r+00umxvJXcM970H08PdY4nHM452nm6fC85DnL152Xlle+70eT7OcJp7WMG3I28Rb4L3Le2A6Pj1l+s7pAz7GPgKfep+Hvqa+It89viN+1n6Zfgf8nvs7+sv9j/i/4XnyFvFOBWABwQHlAb2BGoGzA2sDHwSZBKUHNQWNBbsGLww+FUIMCQ1ZH3KTb8AX8hv5YzPcZyya0RXKCJ0VWhv6MMwmTB7WEY6GzwjfEH5vpvlM6cy2CIjgR2yIuB9pGZkX+X0UKSoyqi7qUbRTdHF09yzWrORZ+2e9jvGPqYy5O9tqtnJ2Z6xqbFJsY+ybuIC4qriBeIf4RfGXEnQTJAntieTE2MQ9ieNzAudsmjOc5JpUlnRjruXcorkX5unOy553PFk1WZB8OIWYEpeyP+WDIEJQLxhP5aduTR0T8oSbhU9FvqKNolGxt7hKPJLmnVaV9jjdO31D+miGT0Z1xjMJT1IreZEZkrkj801WRNberM/ZcdktOZSclJyjUg1plrQr1zC3KLdPZisrkw3keeZtyhuTh8r35CP5c/PbFWyFTNGjtFKuUA4WTC+oK3hbGFt4uEi9SFrUM99m/ur5IwuCFny9kLBQuLCz2Lh4WfHgIr9FuxYji1MXdy4xXVK6ZHhp8NJ9y2jLspb9UOJYUlXyannc8o5Sg9KlpUMrglc0lamUycturvRauWMVYZVkVe9ql9VbVn8qF5VfrHCsqK74sEa45uJXTl/VfPV5bdra3kq3yu3rSOuk626s91m/r0q9akHV0IbwDa0b8Y3lG19tSt50oXpq9Y7NtM3KzQM1YTXtW8y2rNvyoTaj9nqdf13LVv2tq7e+2Sba1r/dd3vzDoMdFTve75TsvLUreFdrvUV99W7S7oLdjxpiG7q/5n7duEd3T8Wej3ulewf2Re/ranRvbNyvv7+yCW1SNo0eSDpw5ZuAb9qb7Zp3tXBaKg7CQeXBJ9+mfHvjUOihzsPcw83fmX+39QjrSHkr0jq/dawto22gPaG97+iMo50dXh1Hvrf/fu8x42N1xzWPV56gnSg98fnkgpPjp2Snnp1OPz3Umdx590z8mWtdUV29Z0PPnj8XdO5Mt1/3yfPe549d8Lxw9CL3Ytslt0utPa49R35w/eFIr1tv62X3y+1XPK509E3rO9Hv03/6asDVc9f41y5dn3m978bsG7duJt0cuCW69fh29u0XdwruTNxdeo94r/y+2v3qB/oP6n+0/rFlwG3g+GDAYM/DWQ/vDgmHnv6U/9OH4dJHzEfVI0YjjY+dHx8bDRq98mTOk+GnsqcTz8p+Vv9563Or59/94vtLz1j82PAL+YvPv655qfNy76uprzrHI8cfvM55PfGm/K3O233vuO+638e9H5ko/ED+UPPR+mPHp9BP9z7nfP78L/eE8/sl0p8zAAA/cWlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPD94cGFja2V0IGJlZ2luPSLvu78iIGlkPSJXNU0wTXBDZWhpSHpyZVN6TlRjemtjOWQiPz4KPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iQWRvYmUgWE1QIENvcmUgNS41LWMwMTQgNzkuMTUxNDgxLCAyMDEzLzAzLzEzLTEyOjA5OjE1ICAgICAgICAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOmRjPSJodHRwOi8vcHVybC5vcmcvZGMvZWxlbWVudHMvMS4xLyIKICAgICAgICAgICAgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iCiAgICAgICAgICAgIHhtbG5zOnN0RXZ0PSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VFdmVudCMiCiAgICAgICAgICAgIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIgogICAgICAgICAgICB4bWxuczpwaG90b3Nob3A9Imh0dHA6Ly9ucy5hZG9iZS5jb20vcGhvdG9zaG9wLzEuMC8iCiAgICAgICAgICAgIHhtbG5zOnRpZmY9Imh0dHA6Ly9ucy5hZG9iZS5jb20vdGlmZi8xLjAvIgogICAgICAgICAgICB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyI+CiAgICAgICAgIDx4bXA6Q3JlYXRvclRvb2w+QWRvYmUgUGhvdG9zaG9wIENDIChXaW5kb3dzKTwveG1wOkNyZWF0b3JUb29sPgogICAgICAgICA8eG1wOkNyZWF0ZURhdGU+MjAxNy0xMS0wOVQxNjo1MToxNSswODowMDwveG1wOkNyZWF0ZURhdGU+CiAgICAgICAgIDx4bXA6TWV0YWRhdGFEYXRlPjIwMTctMTEtMDlUMTY6NTc6MDQrMDg6MDA8L3htcDpNZXRhZGF0YURhdGU+CiAgICAgICAgIDx4bXA6TW9kaWZ5RGF0ZT4yMDE3LTExLTA5VDE2OjU3OjA0KzA4OjAwPC94bXA6TW9kaWZ5RGF0ZT4KICAgICAgICAgPGRjOmZvcm1hdD5pbWFnZS9wbmc8L2RjOmZvcm1hdD4KICAgICAgICAgPHhtcE1NOkluc3RhbmNlSUQ+eG1wLmlpZDo5ZWEzZjVhOS05YzFjLWM2NGEtYWVlYy0yNDQ0NmU3NTBkZTI8L3htcE1NOkluc3RhbmNlSUQ+CiAgICAgICAgIDx4bXBNTTpEb2N1bWVudElEPnhtcC5kaWQ6NGNlMmRjYTctY2YwMC01OTQ2LThiMDMtNzE1YTA2MGYxM2Y4PC94bXBNTTpEb2N1bWVudElEPgogICAgICAgICA8eG1wTU06T3JpZ2luYWxEb2N1bWVudElEPnhtcC5kaWQ6NGNlMmRjYTctY2YwMC01OTQ2LThiMDMtNzE1YTA2MGYxM2Y4PC94bXBNTTpPcmlnaW5hbERvY3VtZW50SUQ+CiAgICAgICAgIDx4bXBNTTpIaXN0b3J5PgogICAgICAgICAgICA8cmRmOlNlcT4KICAgICAgICAgICAgICAgPHJkZjpsaSByZGY6cGFyc2VUeXBlPSJSZXNvdXJjZSI+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDphY3Rpb24+Y3JlYXRlZDwvc3RFdnQ6YWN0aW9uPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6aW5zdGFuY2VJRD54bXAuaWlkOjRjZTJkY2E3LWNmMDAtNTk0Ni04YjAzLTcxNWEwNjBmMTNmODwvc3RFdnQ6aW5zdGFuY2VJRD4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OndoZW4+MjAxNy0xMS0wOVQxNjo1MToxNSswODowMDwvc3RFdnQ6d2hlbj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OnNvZnR3YXJlQWdlbnQ+QWRvYmUgUGhvdG9zaG9wIENDIChXaW5kb3dzKTwvc3RFdnQ6c29mdHdhcmVBZ2VudD4KICAgICAgICAgICAgICAgPC9yZGY6bGk+CiAgICAgICAgICAgICAgIDxyZGY6bGkgcmRmOnBhcnNlVHlwZT0iUmVzb3VyY2UiPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6YWN0aW9uPnNhdmVkPC9zdEV2dDphY3Rpb24+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDppbnN0YW5jZUlEPnhtcC5paWQ6NmYyNTNhNzEtNDYwMy04ZjQ1LWEyYTAtMTU1M2Y4MWMwMGI5PC9zdEV2dDppbnN0YW5jZUlEPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6d2hlbj4yMDE3LTExLTA5VDE2OjU3OjA0KzA4OjAwPC9zdEV2dDp3aGVuPgogICAgICAgICAgICAgICAgICA8c3RFdnQ6c29mdHdhcmVBZ2VudD5BZG9iZSBQaG90b3Nob3AgQ0MgKFdpbmRvd3MpPC9zdEV2dDpzb2Z0d2FyZUFnZW50PgogICAgICAgICAgICAgICAgICA8c3RFdnQ6Y2hhbmdlZD4vPC9zdEV2dDpjaGFuZ2VkPgogICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgICAgPHJkZjpsaSByZGY6cGFyc2VUeXBlPSJSZXNvdXJjZSI+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDphY3Rpb24+Y29udmVydGVkPC9zdEV2dDphY3Rpb24+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDpwYXJhbWV0ZXJzPmZyb20gYXBwbGljYXRpb24vdm5kLmFkb2JlLnBob3Rvc2hvcCB0byBpbWFnZS9wbmc8L3N0RXZ0OnBhcmFtZXRlcnM+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICAgICA8cmRmOmxpIHJkZjpwYXJzZVR5cGU9IlJlc291cmNlIj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0OmFjdGlvbj5kZXJpdmVkPC9zdEV2dDphY3Rpb24+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDpwYXJhbWV0ZXJzPmNvbnZlcnRlZCBmcm9tIGFwcGxpY2F0aW9uL3ZuZC5hZG9iZS5waG90b3Nob3AgdG8gaW1hZ2UvcG5nPC9zdEV2dDpwYXJhbWV0ZXJzPgogICAgICAgICAgICAgICA8L3JkZjpsaT4KICAgICAgICAgICAgICAgPHJkZjpsaSByZGY6cGFyc2VUeXBlPSJSZXNvdXJjZSI+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDphY3Rpb24+c2F2ZWQ8L3N0RXZ0OmFjdGlvbj4KICAgICAgICAgICAgICAgICAgPHN0RXZ0Omluc3RhbmNlSUQ+eG1wLmlpZDo5ZWEzZjVhOS05YzFjLWM2NGEtYWVlYy0yNDQ0NmU3NTBkZTI8L3N0RXZ0Omluc3RhbmNlSUQ+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDp3aGVuPjIwMTctMTEtMDlUMTY6NTc6MDQrMDg6MDA8L3N0RXZ0OndoZW4+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDpzb2Z0d2FyZUFnZW50PkFkb2JlIFBob3Rvc2hvcCBDQyAoV2luZG93cyk8L3N0RXZ0OnNvZnR3YXJlQWdlbnQ+CiAgICAgICAgICAgICAgICAgIDxzdEV2dDpjaGFuZ2VkPi88L3N0RXZ0OmNoYW5nZWQ+CiAgICAgICAgICAgICAgIDwvcmRmOmxpPgogICAgICAgICAgICA8L3JkZjpTZXE+CiAgICAgICAgIDwveG1wTU06SGlzdG9yeT4KICAgICAgICAgPHhtcE1NOkRlcml2ZWRGcm9tIHJkZjpwYXJzZVR5cGU9IlJlc291cmNlIj4KICAgICAgICAgICAgPHN0UmVmOmluc3RhbmNlSUQ+eG1wLmlpZDo2ZjI1M2E3MS00NjAzLThmNDUtYTJhMC0xNTUzZjgxYzAwYjk8L3N0UmVmOmluc3RhbmNlSUQ+CiAgICAgICAgICAgIDxzdFJlZjpkb2N1bWVudElEPnhtcC5kaWQ6NGNlMmRjYTctY2YwMC01OTQ2LThiMDMtNzE1YTA2MGYxM2Y4PC9zdFJlZjpkb2N1bWVudElEPgogICAgICAgICAgICA8c3RSZWY6b3JpZ2luYWxEb2N1bWVudElEPnhtcC5kaWQ6NGNlMmRjYTctY2YwMC01OTQ2LThiMDMtNzE1YTA2MGYxM2Y4PC9zdFJlZjpvcmlnaW5hbERvY3VtZW50SUQ+CiAgICAgICAgIDwveG1wTU06RGVyaXZlZEZyb20+CiAgICAgICAgIDxwaG90b3Nob3A6Q29sb3JNb2RlPjM8L3Bob3Rvc2hvcDpDb2xvck1vZGU+CiAgICAgICAgIDxwaG90b3Nob3A6SUNDUHJvZmlsZT5zUkdCIElFQzYxOTY2LTIuMTwvcGhvdG9zaG9wOklDQ1Byb2ZpbGU+CiAgICAgICAgIDx0aWZmOk9yaWVudGF0aW9uPjE8L3RpZmY6T3JpZW50YXRpb24+CiAgICAgICAgIDx0aWZmOlhSZXNvbHV0aW9uPjcyMDAwMC8xMDAwMDwvdGlmZjpYUmVzb2x1dGlvbj4KICAgICAgICAgPHRpZmY6WVJlc29sdXRpb24+NzIwMDAwLzEwMDAwPC90aWZmOllSZXNvbHV0aW9uPgogICAgICAgICA8dGlmZjpSZXNvbHV0aW9uVW5pdD4yPC90aWZmOlJlc29sdXRpb25Vbml0PgogICAgICAgICA8ZXhpZjpDb2xvclNwYWNlPjE8L2V4aWY6Q29sb3JTcGFjZT4KICAgICAgICAgPGV4aWY6UGl4ZWxYRGltZW5zaW9uPjEzNTwvZXhpZjpQaXhlbFhEaW1lbnNpb24+CiAgICAgICAgIDxleGlmOlBpeGVsWURpbWVuc2lvbj4xMzU8L2V4aWY6UGl4ZWxZRGltZW5zaW9uPgogICAgICA8L3JkZjpEZXNjcmlwdGlvbj4KICAgPC9yZGY6UkRGPgo8L3g6eG1wbWV0YT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAKPD94cGFja2V0IGVuZD0idyI/PqY4n4kAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAAKJhJREFUeNrsXXd8VMXafmZrCpseSCAQqigqCCIoIoiiFK+oqNi9KqKIfggCKhYUEASxUFQsWBFsKFa8Xq/lIopdUEFR7NQE0nuyO98fe/bs1LNnd0MSvZn7uz/inp3Zc2aeed/nbXMIpRQHqKUCOAZAfwCHAugCoAOANABt0NqibRUASgDsAvALgC0AvgCwEUDpgfhB0sjgyANwDoCxAAYCcLau6QFvfgCfAngZwIsA/mhp4BgCYAaAUa2AaHagvAXgbgD/bW5wHA9gDoDjWtelxbUPAcwC8EFTgyMXwCIAF7SuQYtvqwypvrspwHE2gEcNwtna/hqtFMAEg5PYbo4ovusBsAzAC63A+Mu1VGPdlgHwNrbk8AFYC+DE1nn+y7f1AM4AUNQY4Mg2GPCRrfP6t2mbAZwEoDAecKQCeA9Av9b5/Nu1rwEMg4UDzRGBY7zcCoy/betrrK8nFnDcB+CE1jn8W7cTjHWOSq2cbbDb1va/0c5RrbcKHB0AfIdggKy1/W+0EgCHA9gRCRwvG6aOZSsc3AuEAJQAhBuR+YeIUAz/QbTXgn/qxoW+m/L3CD8qgj9MzS8H74PKN6D5MSJ/O3K/Zm40AKSs+y7S19YiGDA1m0v4wjA7wAhPKkCoAAjurnTXqGJeiXaeCYm8EBwYVStIqHGJMh2ohGg7i06U4Gu5ACH2XJ1nIOjHeldHSOfY/cFAADCFDg3/Q2noD+YaVVwTvkdp6LrQgYavUcW4LNzE++EwyAwb/kH2O+xvUemS+HtMF3vfbWbJYbPdrrNWhgAYbP8Xw5PJTXSExaQiiARUmcNRChrahszKq/uqQGZ8pACr+Z3QxxJQiARMrdCjimdrwUCJ0AYbOJDAMSMGTAKUBicwQEHFSRZBQgEEZGkifccUT8Exg+MSJQh00ogqgCBJGyp+h0U234Eaz8n9rZGSoGrB9BcByQwRHG0BjIwKFqJkQJBFUnE3Qp4samPXQ1JZIZBQ4Rq1kEY2wSQ8k7ygYQJDqUJFQbPwuu+1bKCMNPBgguN8BTmNQDpUKoQCAUaagGoXhAYQ2zVjhdTXKS+NoJcYyuuSxCPCdUHHUF6i6PiUKJBauNpxGXgwwXFmbExHrXPFBQsuGrVHVmFBcpmJDnWmnLohSokFnWjXcQpm9VjgU0ZCqiQK1UkPp1uWJlRJuVoKWM4MgSOUJR4L3VCAgdkhkr4PSxRbIKF2rB0DeCz4hNnXWkm2VAqnwcL3DyqAJMxNxMfzXjaNB4gwh9LvoNkBcgyAVAeAQYglKVgDBiU5lCRJyBqhaotGVFewAzx2pxPmGuXUUCRuouWkSomjMsFY8Ad/19VnIBKunmUtGUQLqnnVjhPAIAdijLrakRo6QirtfMpaJTyIRDIpbFQZJGAWiVIGKPxCUsbq0FkzolqitiSOoOaM/3CffAY8Z41XTKDGHyOaxk2vdvo7DJ96jOhgdqT4NFRvIVhZDlTFTywlUaQxqYWTjcjWlw0rytp/YvAgkVgA8P7zWjgHDuPIrhaY4iaADeuocduhDgQr0WLCBkxQUEupYV4LWIjwKL2qtvmJ5hqlNLLJC2v/iZboiurSdBw4kHjDIji79NDyE0uQWEngxm9dHADax+yWFZ1IpikLWU1YqSPowEB5tcNdj+xat3S7M447SqH0XNEI1owViIQIQDjO4U1A4uyHQNKzJPJsW41Qje+INqpU6eBAjKF5Uffz1gs1fSFKshqAmiBaLapg3oYtBZtue2qx2KzJyq28DScaBJIMK4liCJCsdkiatRTEm6D3sOqCONCrHimuFB9IUhyItajZkjeEJtogg4GQK1y/Myz1eEDjZKOCKxtq13w0u54fkyoXxsrLCx1ARXOgZ28kXHcHaCjkrHSwMTEmqrdgSGIyXINHgnTobBugNprPFTOuKB+jYkJWrOY1/jXyN2i4Ew3lVtBwH/EZ2NC4CaBQWkaoY2jnG0kgwdA95ckm1PfH3jthjQvG8GDJABFyPpjH4TMAQtcjiHj3kFFI2Pk7ap5aFs4aYDsRXnAwUwbSJgXugcPgOnY4XH0Hwb99K6puuDj8fcJNXcyu0tj5BnPD0oRxn1PhcypAyOhIjLwOIotWcfGoCRKEs4MYQJqLqVhwokAhFQDPfYeETWMSukgZVDD3Soi8eaya99wr4f/jV9S//0b4/jmwhZNGSFo63McMh+vYk+DqPQBwGcvXUI+aZbdLkide+nHgJEekzwlAOMSEA3cqQOh2vyCLwoleACiziJZjKRaSMrfFPTahzMam4DKLxGe2s20JQdLUOajY9Qf8P3wj3aMjuy3cg4bDPfgkOA/tBzhkf2XtS0/C/8fP+sQj2iySI5RxIYhwZnMRxeeSuJdUBQEfuRCkhk7lQJfCJ6gdFVDELEKFRJGusXNgqs3wtqfUZlqYx4vkOQ+g4ppxCBTshiM3D+7BJ8N97HA4D+6tSYUzOP+uP1D77PIgDyOET4KjUOi7JpEcVAAl5fI1qUaMa3mFIAVCq0Epv9xEIZV0UkbOFjSUjsB12IW1zU9Y4kgguWlJlNuWpGYg+c4VoDXVcHY/xPYy1CybDdTWCk9oPAehIJRw/KtpOQczpeaiUMoldUqLRWSdqBT7lEoJwJIGoMIOJzKAZK1BBVJMeU5D+GckxLC4iMB3QgMy18LPQKFPSlU3R17nqNag/r3XUb/pk7D05haFhvNrmlqtiBuCUyGEDWMSk4BSJrwtSkqKCPwkEFQNxOQmwUFCmzYafiLINkHuGbuNKCQaldUb+yUpE542AivUTX9ZCaofuot53vAkkNCH4g03BzhoRJOW/Ywa6kIwBoggBVRjUIAT/ozJZsVPIO50KnAgwm8vypjChOiZP7GweOJcl8jq5LF7QUuLBDCG+RURJ6351IpCephkPMxMKeVpoyRpWH6iM4slnkMgQEa9eBFVmMrCoDzlJlDmXqg0ByUASUlHwqjT4chp36jAaPjmc9T+62W9xSWY1k3u52CtOGrP4gVUEiJEmhTOGyUZpLx+DwGOEPFGiNJCUqow5bNQznHHOsSIMOviNXffo+AdMw6eISeBuD2NKzLq61C9eLYg6RSWFjtvTS45wDuCSATRS4WbJuzDMSYs0SygSkqzQKGKOyQG2aTCPaqcaVaSRpRenAMuNGRKKhJGnoaE08bB2akrDlSree4x+P/8NTwhhA8J8Koyvt9qBM7BEzrdjoeVlWLuXmqQVRK2AAQ3NcuzOAtFtfBhCiwsNpH/Er2cKi8qZSVN0B5x9+6HhNPPgXfYCBCPFwey+Xf8hurVj3BOHVGScnGq+Nwc8XMOdrLs+AmIRm/z3MVQFSGrJMzB1Y4unTpSWRrCAEqHGmUdcwoHnM+HhFGnIfH0c+Dq0h1N0ihF1X2zgbo6gQRT3rknTGY8wdnYJUeA5Q1QBMNMhzbjZrYOrokElMqBa7XaUYhWCXCs+hD4CWViJFaqxXNYHySePg7ek0YHw+1N2AKlxWjYtsV0CkrPIGy6xijZjYNzyCRI50eggtNADNSpUC9+TkVHG6AEHCEKgqmzglhQG/af9H2XCwknj0byBZfC1eNgNFdzpGUgecosVMy7ngtkSlYUkSV781grVjsYPHMkVIYNEfwakm9DRxY5VzYNB9N1Vk1I7WjGo4xHMeRAIikpSBx7DpLGXQBn2xy0hOYZ/g94P9uA2ndeE+aIMvNPuF0YKW3ggHEOotDfWrtf9HuAyFFTK2tHKTapOTmUU1/BIJQUgldwDTH24sjrhOTzL0bSqWNBkpLk56irQ/XLz6Fy5WNwde4K77CTkHD8cDiy2jYJQJKmzkLD1s3w7/xdmnQ1+W8GJ5g29C3xEP2O5z8P6VLwWVXEjivcAEqIGBuAEVUPkV005n+7O+WjzZX/h8QRowGH4kALvx9Vr7+EyhXL4d+7ByBAoLAADT9tA/x+JJ19gbpfIzeSmITkWfeg9OrzgPp6xdxQpRne5H4Owul2EtnhxO5cFjwMwaCUjRHIFokZSyEKXsHSc8L6TYnEfUKfOnPbw3flJCSdegbgdCpFZPXb61Dx0BI07PjDTPYhiUlIPv9SJF90GUhSMu+n2vIN6r78DAlDT4Qzv0ujA8R1UC8kT5iKygfukrLFuGQjQuPBBgiN8WT8n/MPYrK3wPu3iWyJSNdUn0E47okFieL7IOrfUI0duhCSGK7sbPgun4iks8aBuN3KZ6z77huULZqH+m83h8dxOpF85jloM+FqODIyeYuirAzlyxah5vWXzRNTXN16wDd1JjxHHdO4CKEU5TdehbpP1kueQi76bWymzA+2NqVaoQL5pIx6IYJ6kVP2qOJIKLUfgwqZIhr/BitZdOYyKOBNQMol4+GbcIXWHA2UlqBs6b2oemVN8AgjQyJ6eh+BlJmz4O7ZS/Zc/udfKFs0F4GiItM7SxITkXj6OHj6H30A9AtB8o3zUX/ZGaD7CzkfErWyBJvSCQaqZv6EqjRhBP7AuuE5JxRV+07YrDHCqB6qBlDyqFOQet10OHP1gbCqN19H6V3zQUuKzZt0pKUjZcoMJI05Q8o1CJSVomzBHFT/+00u7uLucyRSb5sPZ16nA2fepmfAd/MClE6fYJzDpVgn0sz5HFTrmaSC34NIZqqqn0Rulb4T3jNLoCGxBHDld0b6rNuRcLRetPsLC1EydxZqPngv3JECSaeMQeqNt8CRkiJLiw8/QOncWxHYXxi+X4cTvismoc34icp8z0it/rvNcLZtB4dN89nd/xgknnsZqletUKRdxhdfidsJJjladIvOqhfBY6r6SzUOFX6MNdeocYGjsU4nfBMmIPXqa7S8AgCqXnsFJQvmIVBeFu6amYm0W25H4oknyc/e0IDyxXejYvVTnOx2tc1B2vy74enbn/9+VZXSLJaAseUbFE+8EGhogLNjJ7iPOAqefgPg7jcAznZ6sCRfPhn1X32K+q3fCgnWgpRvKkL6U/seagJKJNUYXnaiIqyMmUGIehyR6wqElGPpxuy4u3dH1oKF8Bx+uIVLuhRFs25G9X/e4Yhs4oiRSL/ldjjS02UJs3MHimZMRd2Wb40Mt+BNeI8ehPQF98KRmsZ9v+Hn7Si5/UZkrVxjvdkqK7D/orHw7/yTe1iTB+d1hPuI/vAcORDuI/rDmduBv6/dO1B86VjQinKI57xSCmRvaEpCqghkUIt4iUqNBAmkUSdKiBHGJ0IcBFI2OFG4x80N7CBIufQypE2ZAuLVR0lrN2/C/qlT4d+zK3zT3kSk3zoLyaePVfap+ehDFF8/zZAwYaLc5uLLkDplmqRGajd+hOIbpoBWVqhzI5lWeuftaNjxp7aQq2HHn2jY8Sdq3lgLEMCZ2wHuvoZk6XsUnO3z4Jt2G8punw4pSamp0wTNImnCVGkZYsKSfLILz1axcXnThOEczGnDumRi429Xfj4yFy5AQv8jLQFd9sTjKL33XlB/Q1h3d8pH1uIlcB+szvyuWPU0ShYuAKjfAC0B8XiRNnsekkb/Q/p+5XOrULpoPhDwm8RVlCqhVv36WlS//SaIUV4gSUlFUZZ/1074d+9EzbpXgpKlXS7cRw6Ao117BPbu4o/mRBNnn4fPt6BcagcralndRzRM2lx0joBSjSXEcAphZyWPGoWsO+fB0UZf+huorMS+66ah+oP3zHskAJJGjkTGHeq+tKEBJfPmouKF5zgxT1JTkLn0QXj79ZfAV3rPXah45gnu3gNlZUpwNPz+K0oXzuGTkbmsNAqroqyQdPXv3Q3/ulfVfqbmMWWpVDbIVqqbDxQgPBBUmec6Istkr6vqVRweNzJunomUiy+0vN+GXbtQcMUVqP/xR25WU6dOReqVV6qfsaYa+6dOQfV/P+Du1dWhA7IeehTurt0E9PlRcsdsVK55gbO0nHl5cPh8yjhNycxpoFXVzGah6qIsicor3ApEEfzkcnebVHIwZqMiG4sy/0HMYJsigCY+kK7O1rRIgn8727VFuweXIuFI65Orar/+GgVXXQ3/vn1h30WiF1l33YWkkerjVwPl5Si8aiJqv/yCez53127IfuIpOLOzpRUqvu1WVL7yknmvBIDnsN7IvH85HGkyuS1bcjfqvt8qFFFbpCdyBUuKjUaFojuCuLJ94jJlCWwEyQymyCcTy/xEdINLFW0EweMXjAKuhD6HI+eR5XC2s46GVr6xDoXX3wBaW2verzMrE20fXg7vEUeofR5FRSgYPx7132/lHth1cE9kP/YEnJmZMjDmzUHl2pe4GfIcPQhZSx5QmrE16z9A5eqVUixIykAzeT81OFooN5ZV6Ioyz0bwdcSVCUZFk0uVti+lBSoyOalcsWflHGszeiTaLl4EkmCdjVX27PPYf8ttZpyDAnDldUDOM0/B3amTVmIUXDYedVu3MKY1hefQQ9H28SfgSJN5Q+nie1GxejV304lDhiJz8f0gHo/C4VaA4ltuBA1Qy+fVeZJVAQU7mfZNbMqGOIVevVBt6poME5UDRzRb0ydNQObMGZZmIQCUrngc++ct5KbH07kzclY9CVd7tfs8UFGBvZdehtotWzjHnLNzZ2SveEwJjIo1L6L0kUe4ksmEwYO1wEDAj6KZM+AvLuHIOw0AcAAkADlJSZKgbE5PqPKPr5FFgMjHQTQpIaVMzYmGTStzRFXnX1Ahg93M8CbByw6C7NtuQtqESyLeW/Hi+1F03xImWkzhOegg5K56UuYKoeepr0fBxEmo+XozVwjkymmHnKefhjMjQ+YyX36JotmzuQPkPL37IGupBhgAyh97FLWffKLOWgtYl0owWBASVLhjckzzkFLIMYimIaSUj6GIGdCKindogm1iXkdYRBqmssuFnMUL4TvztMjAuG8Ziu5dyvhDKLyH9ETu6qfhzMzQPsu+62eieuMnLE2Cw+dDuycehzNHdl379+5F4eTJoHX15mO48vPRdvlDIAmJWmJcsmypsPhUqPgjSp8QS96VJwwI8piwG6/J1QpVaULeZ25LalgG7yjgdNoGRumTz2D/PUs5wLm75CN35RN6YAAoXrwUFa+8yqkq6nIie+kSuLsrSg/8fhROnwF/QWHY0vD5kP3AA3BkZGi4TBmKrp8GNPgjPzPExEmi/j7rL1SeHdJMagUw9CTRLThbaaZwsxO5xlMqxnE6kbPkLqTYAEb5y6+h4JY53H0422Yj9+nH4Gybrbdm3nwLxUsegFjolHnzTUg8Tv1uotJHV6DGkDKhljl3Ltw9emh/p+jWW1G/Y6eWZJraNeQ/JFTIgTU4hVDERJSZ/2gUVhq/5FD5J6hYb0JkFYIIB7k5nMhdshApZ0UGRuU772Hv1BuDJxYipBLaoP3qJ+DunK/tV7f9ZxRMvzFcb2tsweQxpyDlnxcp+9T/tB3FS5ZxN+8771wkjR6t/Z2KNWtQ9da/lKWbXCUFo4p5HwYVEqqsD8OLVFDeJISURigCIlIqLyMeBRnJlzgQ5Nx3J1LOPj3ifdT+8CN2X3UdaF1dmPk7nGi39G54Du6pv/+aGuy96loEKqu4e/B0yUfW/Lka8z2AfTfdAlobrjpzdeyI9Jk3an/HX1CA4vnzzco0ySrTqFYq1N/wKprlFYrAp1BH2zx1K1SftBN+QLamQqwMV9fXZt08Dannjo14C/6SUuy65CoEKip4lXDDdUg++UTLvvvvvBu132/j4yVuF9ouu08bnylf+xqqv/gq/DwAsubNhcMiV6No/nwEyis4Hcp5jgVnoBWv0J2pRgjlSu11h901KTio6PLV1JdKTh3loWxB5ZP2z/ORee3EyL/v92P3Fdei7tffOWaefMpIZFw9wbJr9WdfoOTxlVIIIH3SlfAefpj6caurUXz3fYyVRpA8ehQSjx2kl2pffYXKN9bJIp7LDA/nJkTkD0ovNFOSIWTsUxpf9C3uTDApHV40wQTiSaGKkwRb0tBj0G7BLFu/XzjvHlS+v4Ez4z2dOyHnvgWWDjJaU4O9U2eC+v1gj4/w9OyB9MmT9JbQqudQv3OXMTQBcbqQcf20CGb1Eqn4SzppiKqNUHWNLyIc8ck7FkmcxzDEYa2w2eckopkKCUSUe8CEQ3si7+nlIB53ZAK6/mPsX/YodwQB8biR+/ASOHzWp3UXLXsY9b/8JsQhCLIXztU6rmhNDUqWP8q4dyh8Z50Bd74+ebju+x9Q/dFGboGlIKPypczskRahM9X0LnVVbazsgW4OD6nIpFRMW4F0UdI4Un3ouPphOFJ8tnjGnmtuCAfhjN/LnHYNEo6wfnVMw67dKHpwhVE4Rcwiat+YU5B4lD5BqHzt62jYWxiWgg4H0q66wjqus3KVaeqbSUqaY6xkQs7raSrYJ1xkRUfsFQG8pvVzSEcaEL1nT2vRAO0fWAh3fkdbv7ln+m2o27GL06/efn2QMXmiDVV0t5k7Ycp7rxeZN0+3dq6tfJZTi8nHD7E0kWl9PSpCXIOqF5OKhx+zh9UEgnPKOrfkCKziPBSFGmm+462pSvcpqlgtiGr6xIuRcuoIWz9ZtvZNlL30OieJiMuJ3MXzQFzWZQC1329D2ZrXJP2ddtF5cHfMs+j3A2o2fcupTN8465dpVm/4GP6SMjmvQpICAtGkMsE3k6q40wKJ9mCZeH0bjSY5ZG8L5c0oC6JKACT2Oww5826y9VOBikrsuWkeE3gKDpQxaTy8h0Y+N2P/4oeCqogFlseN9EmXW/arePUtbvIdyUlIHj4sAjg28hadVDRuFRuBvixD2IBSGqGO5zVHVJY1ZaE5F1xGscHGfcnIe/p+WwQUAAoXLEXDrr3c5LrbZSNrxjUR+9b9+jvKX10nsfuUs06Hq7118VD5ureN5wwuQtLxQyyz2kOmMntwLqVKfzEsD5/RElbFywBEK6WlqBXurBARJHwiOYem3DtvgqezPZ5Ru2079i9/UvLIZt86DY7kyMVCxcufAK338xYKgPQrLrEmsHsKULdtO2cuJw6OXPda9+NP+iw3KtYQwzximzvYRqMyVJn8fOCNP5uENBs4BGhaEVFWXPqGH4f0S86x/VO7p88GrWvgdqG3a74tLyqtqUHpmtckYCX07Q1vr56Wfas++sTsF1q6xP79IgBqL/wVVRHOEoHOcEWk17Voj7QQ8jsI93lTH4yvegLFm4rEomZHUgLaL73D9g1XvLcBle9/LKmtrBv+LyIJBYCy19+Gv7gU4eTm4CymXXh2ZIn1zRbebPe44Dmoh7Wpvb+YKytQllIwUpV/5Yhx1CbzThIqlHloa4AUap1/1UczuM+h8uMTwZJh5if7hmtsqxMA2DvnXilW4OneBalnj7HVv+SZNXwZBSGA0wHfmFGRwbF1Gydx3B07gritpyxQWRE+pYiloqqscMhFXhBOUeTiJgBvqShcTY1lxjaqtaLOPOf/9XTvjOwpl9sevuLdDaj+fBO4c74AZE+7ypbUCJSVo+qjz6TXbiQf1RfOjLTI3OH3HZxOd+W0s2/ia0x46bjvSAvMiF+tf0MHBhJXIljj+DkkoGiIWM78G0C89s8CL1j0oLFzw4rfmZ6GlDNPsdW//J31oPUNwk1RtBl5oq3+9Tt2c5aDIzU1Yh/i9YT1qQkSwpwwAOl0Q/UrzhRaW/dGK1HtWB773VScQ0ujZRLaZshApJ42wvb41Zu3oPK/n0iHzKVfOBaORHsHxJa/9W44W43ZSUlDIh/BRGtqEKipMRU6ASKasADgzMoyD6MnRKSd4XfERD7FWRF2kL6vMIuFAqnmUSuhd7abN8MwI4VEyZk7I6rh9y9fKakm6iBIH3++7TGqNnzKy+sAQJISkdC7V2SVVFMrxYzs8Dp3bjsQjwe0rk7OLjePxZStDbbIi00XlFWM4qQCyTrgq+xjxUmcZyNS5pXi7Nuo+fQj38jjkXxMP9ujBsorUfLiG9zr0AEgedBR8Pawdzpf/Z+7ULdjj/SS3oTDDgZxOm2Cn3nZMQ1ymMiiwwlvr0PUry0PQPE54V/BDuEt5oo3Tosve6bCK+PDAT4a88Et8YGDWmAFzLvFKEXOrZOjGrrkhdcRqKjiM6QokBKNWtr0nblL2bdTu22Cyyx8Zl5j3lBQaKtvwlF91W+8hupN2OF31nIgUbyVGzZe625uqADzVu0YEeKIV3AoC3WZ95InDz0aSQOOiBocqtdzp4w52fYYtd9vlyYTFPDk2zvAjbicwXJLZiHq/thpq2/SsQP1CyiAhEoLTs3XlCOg6QNVP914zaBWJExQyMkEoGg748qoxvUXlaBiw+fcLgCAxL6HwdOpg31w/PhLUIKFdDyloKDw5OfZHsOZkc5Ntr+wCA0F+yL2a3Pi0HAeqh1ABBSLbjAHKqo3wASNKVEC4D+HAkBNrlYoJyR4UUkBb/d8pIwYGtWwZeveB61r4KkLBVJGnxDVOPU7d3MzHhrHjn8j1Dz5nXgySoGazVtsmbO+MSOFhVXvdM7bHNCpEYbXsRPD/hmQxxF/p4kJqQAUAahZV14YtV+/9LV3lAQseWh0B73W79mnUE3EthkMAN5De0rPV7l+o62+6RMu5jaKkoMwwKHsG5aopJ3DfwRCJJYqv6xSYWhWcKg4iMeDjEvPjq57fQPK/r1eYNoUxOVE8sC+UaqnUo6IhmbYjq/CJJZ9DpV2fcW7G+z17d0LyScMUVh1lOMOWonCgAEBNbhMdRQQdQmvwmiLAAfTUscMhzM9Nao+VV98g0BFJUOiggZ/wmGHgCRE9/60QHW17GiiMLLO7bXk4wbyqpMCNd98j9qffrHVP/uW60CJQ2O5iKrCQmpA5C1UBopp8RClGmtR4Mi48Iyo+1Ru+NwgV5R76IQ+h8QmxRQi3F9WYZ9zdO4IT5dO0v2UrHrZVv/EvocHo7+S/hd2urng1FKaUAvrReYntBkJqRXLT/UhZeTQqPtVfbZZ6Yzyds+PHhshT60wOYHS8qjGSTltBG8pUKDo8WcRqK6x1b/trOlwZWUqdr/ICwjDKdRWjdLigVUfQTK1BHCknnqi7fQ/TnJ89Z3STvZ2jf5weaevDW/jh8zR4pKoxkk793RBbFP49xWjZPVae/GJrAzkPrgw6M4WSShnclK+UoyxUFRSECJAqOBm4jzWLUhypJ4xIuo+gYoq1P3yJ79RjIf0dI1ecpjEUzC3a3/+I6pxEg4/GMlDjuZ3L4DChfeD1tTaGsM3Yhgyr7qEUw1UZXIynIJ1C4T9HQLXAENKVTyjpRFS4nLCd+KxUfer2fazkpQFdX9e1OO583Jlc44Ctdt/i3qszCsulMap27Eb++5/wvYY7ebNhG/0cAWJVEgGWCw4FFaIykuKFkhIkwb2hTPVF3W/2u2/qwklIXBlpkUPjvZtwxlVzGRVfflt1GOlnDYC7vw8aSEL7lyGepsudeJ0Im/FPfAe3kvtH7Jyf3MLzgecouImzQ0O3wmxva6qfsduLXeIJUHW27Nb2ApA+N+G3YWo+21H1NKw3c2Tpd0eqKrGjkk32ZbbDl8bdHljJby9e1nucGk4acFFPSSopEjjNRc42hw3IEZw7FHfoI3SAyVXOKS7wNCCs0xBUbH+06jHS7vgDCT26SXt6PL/fIh9DzxpnyhnpKHL6yuR2OfQ8MKpuIKV1aKVKFRNVFsCOIjTiaQBfWLq21Bcqt21Mam3AUcoosXB/5etey+mZ+uwZA64cyiN8XbftACVG7+MDiBvPwffyBPksANVeJyhIJaKSC67GVqch9TTrVNMfAOAUT6g8FfU1cc0nrt9O3h7dlUSuvJ/b+CObrINuGP6IevqS+SFq63H7+dMQv3OPfYnvk0SOj3/EDInXcL7JaDgClbudY3/hCJ+0tGo4OBEebSmrMapZNfZpFRxQ4+G4pBD+EvKUPrmuzGNmTNnGjw9u0meyYa9hfh1zKVakOukUe6iW9Fx5TI4fMmc+aokqtCZvhr/R0sipPGAg+rAUVEVOziOP1pKeAn9W/TkmtgmLDkJnVcvgyMpkVMJoEDNt9uCAInSC5s6djS6bXgNiQP6CRKDSs4tRHB8sZuAxheVrXMAqGgJ4NCCxu9HIHSmRrSW0/DB4SIkIX+idN0HsvkchWMs76E7w/yD0fGVn27Cr/+4JGqAeLt3Rrd3X0DugptAkhLVaYOqTLCA3oSl8RHSCgeAkhYBDgtztX7n3piGdGWlw3fCICUpRSCAwqWPx3y76eeNQdvrQwfG8EfrVH7yNX4efh7qdxdEKZYcyJo8Hj0+e8s8s4SC8rEdIQhIoeYmnHc4NnCUOwDsaixweHt2jbmv1ZFPdX/GfosZF2miwxTYv+KFqEik2HLnTkfm5ecqd2f1pq3YftxZqPn+p+iJfddOyH9+Obq8+QwSeh0kxHYgZQgpHV5xekcB7HUA+LUxgOFokwRnSpuY+ztDhEzlPf0x9ltMPXMUXFnpWrK7Z87SuKRdh/vnIuOycUpOUPf7Dvx07NhgdlssnGnYIPT4bB06PrUE3oO6SSUNoHpHWSPkc/zqAPBdY4DDnds2rv6ubP3B9TU//Bw7aBO8yByvP+5h/+MvoPqbH+Ly7XR8+E5kTDjPNCFZXR8oq8RvZ03E7hsXhEszo1Q1aeNOxUFfvY2OTy1BYt/D5HC8KDqEYGOMamWLA8CXjQEOV1ZGfD6Sjvr3y1dv2hrX2NnXXqqt0aUNfvw56da4QtsgBB0fvAPZky8x8zIoC5QARcHdj2D78WejdluMQDdA0v3j19D1neeQMmZE0EGoMHm5epXYH+sLB4CPAfjjBUc8KgUA3B1ztdeqvvouqvQ+lVSzkh6VH32BfQ+tim8CCEGH+2ahwz03Aw62pJ6a/6v6dDO29TsFe+fdH5sUMVry4AHIf345ev64ATlzrw+qHPAmMC8xokaIH8BGB4BSABvjBYejTXJ8kqOTXnIEyitRE4foB4CcW64J+iY0beeMO1H7029xS9DsKePR9dUVcKamyN5NAIHaOuy+7R78eNQ/UPX55jhVeTtkT5+Igza9g27r1yJ76hXwdMoTgBKTUNwIoIQYiSVTANwXTe9Nzi6h9+oFJUdGGrxdOsb8oIHqGtRs1TN7b9dOUScsS9zlx18QKK/UT3ZONtwdcmKUHOF/gtHfAtQbB9zxV5guLicSe/eSK6aJ8LdYQE2sf7/2h+2cZ5k4gcMqfonmaaYCWBwCR1sAOxFF1b0IjtYmLxaBxaKz/h1F9bwVAMw/I3wn9N8OB3BYpW1wNADoAKAg5D4vAPB264o2YqOyFSnHOQjns6AAn6CkqLBXJQhB9//Y1MrbBh642MpdrSva+ADRlj6K1fQAX6ZgAkVjk4pAET+P3RFm4oAFx3oAG1pX9ACDBVFIFM5fYRzIokrSUBRCxVizssHAgQQOALi9dQWbRppA5aDSea2EwBv7uamGAurxo7RkZ3MWqHDxXQC2CjJayWjjgUTFT9S7XqiDteIUrPlsb63WAvgP+4HKOpkMYBiANEu/hotw72JvbY1n5UBtyVqcVc2/9okIB6YTR8QE7RJj3fnf1pTKjQPwfOtK/c+0cwC8IAkAzZdfALC8dc7+J9pyFTCsJAcAeAyb9/jW+fvbtvUATgJQFy04ACATwPsADm+dx79d+9bglvu1vDLCAPsBDAewqXUu/3bAGG4FDDvgAIKu1KGGBGltf/32oUEVIia42i1NKAMwCsADrXP7l24PGhyjyJZVHcOpL2cDeBRAautc/2VaGYDLAbwYTadYippeBHAIgNWtc/6XaM8CODhaYMQKDgDYDeACg+22ButaZvsIwAkAzjfWK+pGKG0UF/hQADMMXuJoXZdmawEAbwFYBOC/8Q7WWOAItU4Iut7HAhgAwNm6Xge8+QF8BuBlBD2dfzTWwI0NDralAjgGQH8EnWhdAGQhGNBrA8Dduq62Wz2CNc0lAPYhWIj2LYAvEEwGLj0QP/r/AwCXd4NJi2v+lgAAAABJRU5ErkJggg== // ==/UserScript== (function () { 'use strict'; const page_url = window.location.href; var base_url = "https://so.ucuc.net/prod-api/system/questionBank/search"; var api_key = ""; var video_speed = '1'; var isAutoSubmit = false; var isQuestionCacheEnabled = true; var isAFKMode = false; // 挂机模式 const logNum = 50; var token = GM_getValue('tikutoken') || api_key; var accuracy = 70; var randomDo = 1; const QUESTION_CACHE_KEY = 'questionAnswerCache_v1'; const QUESTION_CACHE_LIMIT = 1000; var questionAnswerCache = {}; // 字体解密相关变量 var fontHashParams = null; var currentFontData = null; var fontLoaded = false; // 初始化解密表 function initDecryption() { // 如果已经加载成功，直接返回 if (fontHashParams) { return; } // 加载顺序：缓存 -> 本地资源 -> 服务器 -> 内置 // 方法1：尝试从本地缓存加载（最快） try { const cacheTime = GM_getValue('fontHashParams_cache_time', 0); const cacheData = GM_getValue('fontHashParams_cache', ''); // 缓存有效期设置为30天 if (cacheData && Date.now() - cacheTime < 30 * 24 * 60 * 60 * 1000) { fontHashParams = JSON.parse(cacheData); log(`从缓存加载字体映射表成功，条目数: ${Object.keys(fontHashParams).length}`); // 后台尝试从服务器更新（不阻塞） updateFromServer(); return; } } catch (e) { console.error('OK题库助手: 从缓存加载字体映射表失败', e); } // 方法2：使用GM_getResourceText加载字体映射表 try { const tableText = GM_getResourceText('FontTable'); if (tableText && tableText.trim()) { fontHashParams = JSON.parse(tableText); log(`从本地资源加载字体映射表成功，条目数: ${Object.keys(fontHashParams).length}`); // 缓存到本地存储 try { GM_setValue('fontHashParams_cache', JSON.stringify(fontHashParams)); GM_setValue('fontHashParams_cache_time', Date.now()); } catch (e) { console.warn('字体映射表缓存失败:', e); } // 后台尝试从服务器更新（不阻塞） updateFromServer(); return; } else { console.warn('OK题库助手: 字体映射表为空'); } } catch (e) { console.error('OK题库助手: 通过GM_getResourceText加载字体映射表失败', e); } // 方法3：从服务器加载字体映射表 try { const serverUrl = 'https://154.12.87.94:14948/down/6Kb35CIcFRb9.json'; const xhr = new XMLHttpRequest(); xhr.open('GET', serverUrl, false); // 同步请求 xhr.timeout = 5000; // 5秒超时 xhr.send(); if (xhr.status === 200) { const tableText = xhr.responseText; if (tableText && tableText.trim()) { fontHashParams = JSON.parse(tableText); log(`从服务器加载字体映射表成功，条目数: ${Object.keys(fontHashParams).length}`); // 缓存到本地存储 try { GM_setValue('fontHashParams_cache', JSON.stringify(fontHashParams)); GM_setValue('fontHashParams_cache_time', Date.now()); } catch (e) { console.warn('字体映射表缓存失败:', e); } return; } else { console.warn('OK题库助手: 字体映射表为空'); } } else { console.warn('OK题库助手: 从服务器加载字体映射表失败，状态码:', xhr.status); } } catch (e) { console.error('OK题库助手: 通过服务器加载字体映射表失败', e); } // 方法4：使用内置的字体映射表数据（最后的备用） try { // 内置的字体映射表数据（包含常用字符） const builtInFontTable = { "5f4c": "的", "7684": "地", "4e00": "一", "4e86": "了", "662f": "是", "6211": "我", "4eec": "们", "5927": "大", "5bb6": "家", "53d1": "发", "6709": "有", "4e09": "三", "516b": "八", "5176": "其", "4ed6": "他", "5979": "她", "5b83": "它", "667a": "智", "611f": "感", "5f62": "形", "8c61": "物", "5b57": "字", "8bcd": "词", "6587": "文", "540d": "名", "4e2d": "中", "56fd": "国", "4eba": "人", "8425": "经", "6d41": "流", "6c11": "民", "793e": "社", "56e2": "团", "4f1a": "会", "5171": "共", "4e8b": "事", "6027": "性", "4ee5": "以", "53ef": "可", "80fd": "能", "53ca": "及", "548c": "和", "521b": "创", "5efa": "建", "624b": "手", "672c": "本", "8bbe": "管", "7406": "理", "7f51": "网", "7edc": "络" }; fontHashParams = builtInFontTable; log(`使用内置字体映射表，条目数: ${Object.keys(fontHashParams).length}`); // 缓存到本地存储 try { GM_setValue('fontHashParams_cache', JSON.stringify(fontHashParams)); GM_setValue('fontHashParams_cache_time', Date.now()); } catch (e) { console.warn('字体映射表缓存失败:', e); } return; } catch (e) { console.error('OK题库助手: 使用内置字体映射表失败', e); } // 所有方法都失败 console.warn('OK题库助手: 字体映射表加载失败，字体解密功能将不可用'); fontHashParams = null; } // 后台从服务器更新字体映射表（不阻塞） function updateFromServer() { try { const serverUrl = 'https://154.12.87.94:14948/down/6Kb35CIcFRb9.json'; const xhr = new XMLHttpRequest(); xhr.open('GET', serverUrl, true); // 异步请求 xhr.timeout = 10000; // 10秒超时 xhr.onload = function() { if (xhr.status === 200) { const tableText = xhr.responseText; if (tableText && tableText.trim()) { try { const newFontHashParams = JSON.parse(tableText); // 只有当新的映射表比当前的大时才更新 if (!fontHashParams || Object.keys(newFontHashParams).length > Object.keys(fontHashParams).length) { fontHashParams = newFontHashParams; log(`后台从服务器更新字体映射表成功，条目数: ${Object.keys(fontHashParams).length}`); // 缓存到本地存储 try { GM_setValue('fontHashParams_cache', JSON.stringify(fontHashParams)); GM_setValue('fontHashParams_cache_time', Date.now()); } catch (e) { console.warn('字体映射表缓存失败:', e); } } } catch (e) { console.error('OK题库助手: 解析服务器字体映射表失败', e); } } } }; xhr.onerror = function() { // 后台更新失败不影响主流程 }; xhr.send(); } catch (e) { // 后台更新失败不影响主流程 } } // 解析当前页面的加密字体 function parsePageFont() { // 优先查找包含 font-cxsecret 的 style 标签 const styles = document.getElementsByTagName('style'); let fontBase64 = null; for (let style of styles) { const content = style.textContent; if (content.includes('font-cxsecret') && content.includes('base64,')) { // 正则提取 base64 内容，兼容换行和不同结束符 const match = content.match(/base64,([\w\W]+?)'/); if (match && match[1]) { fontBase64 = match[1]; break; } } } if (fontBase64) { try { // 处理 Base64 const binary_string = window.atob(fontBase64); const len = binary_string.length; const bytes = new Uint8Array(len); for (let i = 0; i < len; i++) { bytes[i] = binary_string.charCodeAt(i); } // Typr 解析 const font = Typr.parse(bytes)[0]; currentFontData = font; fontLoaded = true; // console.log('OK题库助手: 页面加密字体解析成功'); } catch (e) { console.error('OK题库助手: 解析字体出错', e); fontLoaded = false; } } else { // console.log('OK题库助手: 未在页面找到加密字体 (font-cxsecret) 或已无需解密'); fontLoaded = false; } } // 获取MD5函数 function getMd5Fn() { // 兼容各种加载方式 if (typeof md5 === 'function') return md5; if (typeof Typr !== 'undefined' && typeof Typr.md5 === 'function') return Typr.md5; if (window.md5) return window.md5; return null; } function normalizeCacheText(text) { if (text == null) return ''; return String(text).replace(/\s+/g, ' ').trim(); } function normalizeCacheOptions(options) { if (!Array.isArray(options)) return []; return options .map(option => normalizeCacheText(option)) .filter(Boolean) .sort(); } function buildQuestionCacheKey(question, type, options) { return JSON.stringify({ type: normalizeCacheText(type), question: normalizeCacheText(question), options: normalizeCacheOptions(options) }); } function loadQuestionAnswerCache() { try { const cacheText = GM_getValue(QUESTION_CACHE_KEY, '{}'); const parsedCache = cacheText ? JSON.parse(cacheText) : {}; questionAnswerCache = parsedCache && typeof parsedCache === 'object' && !Array.isArray(parsedCache) ? parsedCache : {}; } catch (e) { questionAnswerCache = {}; console.warn('OK题库助手: 加载题目缓存失败', e); } } function persistQuestionAnswerCache() { try { GM_setValue(QUESTION_CACHE_KEY, JSON.stringify(questionAnswerCache)); } catch (e) { console.warn('OK题库助手: 保存题目缓存失败', e); } } function trimQuestionAnswerCache() { const cacheKeys = Object.keys(questionAnswerCache); if (cacheKeys.length <= QUESTION_CACHE_LIMIT) return; cacheKeys .sort((a, b) => (questionAnswerCache[a]?.updatedAt || 0) - (questionAnswerCache[b]?.updatedAt || 0)) .slice(0, cacheKeys.length - QUESTION_CACHE_LIMIT) .forEach(key => delete questionAnswerCache[key]); } // 清除所有题目缓存 function clearQuestionCache() { try { // 清空内存中的缓存 questionAnswerCache = {}; // 清除本地存储 GM_setValue(QUESTION_CACHE_KEY, '{}'); GM_setValue('unrival_question_cache', '{}'); // 兼容旧版本缓存键 // 清除所有与缓存相关的存储 let keys = GM_listValues ? GM_listValues() : []; for (let key of keys) { if (key.includes('cache') || key.includes('question') || key.includes('answer')) { try { GM_deleteValue(key); } catch (e) {} } } log('✅ 题目缓存已完全清除'); alert('题目缓存已完全清除！请刷新页面后重新答题。'); } catch (e) { console.warn('OK题库助手: 清除题目缓存失败', e); log('❌ 清除缓存失败: ' + e.message); alert('清除缓存失败: ' + e.message); } } function getCachedAnswer(question, type, options) { if (!isQuestionCacheEnabled) return null; const cacheKey = buildQuestionCacheKey(question, type, options); const cacheItem = questionAnswerCache[cacheKey]; if (!cacheItem) return null; const cachedAnswer = typeof cacheItem === 'string' ? cacheItem : cacheItem.answer; return normalizeCacheText(cachedAnswer) || null; } function setCachedAnswer(question, type, options, answer) { if (!isQuestionCacheEnabled) return; const normalizedAnswer = normalizeCacheText(answer); if (!normalizedAnswer) return; const cacheKey = buildQuestionCacheKey(question, type, options); questionAnswerCache[cacheKey] = { answer: normalizedAnswer, updatedAt: Date.now() }; trimQuestionAnswerCache(); persistQuestionAnswerCache(); } // 将文本中的乱码解密 function decryptText(text) { if (!text) return ""; // 如果没有字体数据或者映射表，直接返回原文本 if (!fontHashParams || !currentFontData) return text; const md5Fn = getMd5Fn(); if (!md5Fn) { console.warn('OK题库助手: 未找到MD5函数，无法解密'); return text; } let result = ""; for (let i = 0; i < text.length; i++) { const char = text[i]; const code = char.charCodeAt(0); // 尝试获取字形索引 const glyphIndex = Typr.U.codeToGlyph(currentFontData, code); // 如果 glyphIndex > 0，说明这个字符在这个自定义字体里有定义 if (glyphIndex > 0) { // 获取字形路径 const path = Typr.U.glyphToPath(currentFontData, glyphIndex); if (path) { const pathStr = JSON.stringify(path); // 【关键修复】：参考"字体解密.js"，需要 slice(24) 截取后8位 const hash = md5Fn(pathStr).slice(24); // 查找 hash 对应的文字 let match = fontHashParams[hash]; if (match) { // 映射表中存储的是 unicode 编码 (int)，需要转回字符 // 有些表存的是字符，有些是int，做个兼容 if (typeof match === 'number') { result += String.fromCharCode(match); } else { result += match; } continue; // 找到替换，跳过原字符 } } } // 没找到或者不用替换，保留原字符 result += char; } return result; } var cardIframes = null; var cardIframe = null; var cardIframeDocument = null; const handleImgs = (s) => { if (!s) return ''; return s.replace(/]*src=["']([^"']+)["'][^>]*>/gi, (match, url) => { return url.replace(/^https?:\/\//, ''); }); }; const trim = (s) => { if (!s) return ''; const replacements = { 'javascript:void(0);': '', ' ': '', '，': ',', '。': '.', '：': ':', '；': ';', '？': '?', '（': '(', '）': ')', '"': '"', '"': '"', '！': '!', '-': ' ' }; let result = handleImgs(s); for (const [old, new_] of Object.entries(replacements)) { result = result.replaceAll(old, new_); } return result.replace(/(<([^>]+)>)/ig, '') .replace(/^\s+/ig, '') .replace(/\s+$/ig, ''); }; // 答案获取函数（集成文本解密） function getAnswerFromAPI(question, type, options) { return new Promise((resolve) => { // 初始化解密功能 initDecryption(); parsePageFont(); // 解密题目文本 let decryptedQuestion = decryptText(question); let normalizedOptions = normalizeCacheOptions(options); let cachedAnswer = getCachedAnswer(decryptedQuestion, type, normalizedOptions); if (cachedAnswer) { log(`题库缓存命中: ${decryptedQuestion.substring(0, 40)}...`); resolve(cachedAnswer); return; } // 优先从输入框获取最新的API密钥 let currentApiKey = api_key; try { const apiKeyInput = window.top.document.getElementById('apikeyInput'); if (apiKeyInput) { const inputValue = apiKeyInput.value.trim(); if (inputValue) { currentApiKey = inputValue; } } } catch (e) {} if (!currentApiKey || currentApiKey === '') { currentApiKey = ''; } const payload = { "question": decryptedQuestion, "apiKey": currentApiKey }; GM_xmlhttpRequest({ method: "POST", url: base_url, headers: { "Content-Type": "application/json", "Accept": "application/json" }, data: JSON.stringify(payload), timeout: 10000, onload: function(response) { try { const result = JSON.parse(response.responseText); if (result.code === 200) { const data = result.data || {}; apiStatus = '正常'; if (data.remainingCount !== undefined) { remainingQueries = data.remainingCount; } updateStatusDisplay(); if (data.answer) { setCachedAnswer(decryptedQuestion, type, normalizedOptions, data.answer); } resolve(data.answer || ''); } else { apiStatus = '异常'; updateStatusDisplay(); log(`题库返回错误码: ${result.code}, 消息: ${result.msg}`); resolve(null); } } catch (e) { apiStatus = '异常'; updateStatusDisplay(); resolve(null); } }, onerror: function() { apiStatus = '异常'; updateStatusDisplay(); resolve(null); }, ontimeout: function() { apiStatus = '异常'; updateStatusDisplay(); resolve(null); } }); }); } (async () => { readScriptStorage(); if (page_url.includes('/mycourse/studentstudy') || page_url.includes('/mycourse/stu') || page_url.includes('/mycourse/')) { await createUi(); versionDetection(); taskOperation(); // UI 加载完后自动开始处理任务 } else if (page_url.includes('/mooc-ans/knowledge/cards') || page_url.includes('/mooc-ans/work/doHomeWork') || page_url.includes('/work/')) { // 旧版页面处理：iframe内直接运行 taskOperation(); } else if (page_url.includes('/mooc-ans/work/doHomeWorkNew') || page_url.includes('/mooc2/work/dowork')) { // 新版作业页面处理：只在顶层窗口运行 if (window.self === window.top) { taskOperation(); } else { log("检测到在iframe内运行，跳过独立执行"); } } else if (page_url.includes('/exam-ans/mooc2/exam/preview') || page_url.includes('/mooc-ans/exam-ans/') || page_url.includes('/exam-ans/exam/')) { // 考试页面处理：创建UI并运行任务 if (window.self === window.top) { await createUi(); versionDetection(); taskOperation(); } else { log("检测到在iframe内运行，跳过独立执行"); } } else if (page_url.includes('1431487463')) { function clickFollowButton() { let followBtn = document.querySelector('i.sic-BDC-plus_add_line'); if (followBtn) { followBtn.click(); } } window.addEventListener('load', clickFollowButton, { passive: true }); } else { log("url错误"); } })() async function createUi() { let templateDiv = document.createElement('div'); templateDiv.id = 'templateDiv'; templateDiv.style.cssText = ` padding: 0; position: fixed; z-index: 999; background: #ffffff; border: 1px solid #e0e0e0; width: 320px; right: 500px; top: 80px; border-radius: 8px; box-shadow: 0 4px 12px rgba(0,0,0,0.15); `; templateDiv.innerHTML = `

OK 学习通小助手 OK题库

使用帮助

注册题库每日免费额度api可以调用，群：1028360747

题库:

接口密钥:

播放速度:

自动提交题库缓存 🤖 挂机模式

🔍 题库状态: 未知剩余次数: 0

🔒 解密状态: 未初始化

设置已实时保存

操作日志

`; document.body.appendChild(templateDiv); await delay(1000); let bigtosmall = document.getElementById("bigtosmall"); let templateDivBody = document.getElementById("templateDivBody"); bigtosmall.addEventListener('change', function () { if (this.checked) { templateDivBody.style.display = "none"; } else { templateDivBody.style.display = ""; } }); templateDiv = document.getElementById("templateDiv"); let templateDivHeader = document.getElementById("templateDivHeader"); dragElement(templateDiv, templateDivHeader); function dragElement(elmnt, elmnt0) { var pos1 = 0, pos2 = 0, pos3 = 0, pos4 = 0; if (document.getElementById(elmnt.id + "Header")) { document.getElementById(elmnt.id + "Header").onmousedown = dragMouseDown; } else { elmnt.onmousedown = dragMouseDown; } function dragMouseDown(e) { e = e || window.event; e.preventDefault(); pos3 = e.clientX; pos4 = e.clientY; document.onmouseup = closeDragElement; document.onmousemove = elementDrag; } function elementDrag(e) { e = e || window.event; e.preventDefault(); const screenWidth = window.innerWidth; const screenHeight = window.innerHeight; const windowWidth = elmnt.offsetWidth; const windowHeight = elmnt0.offsetHeight; pos1 = pos3 - e.clientX; pos2 = pos4 - e.clientY; pos3 = e.clientX; pos4 = e.clientY; let newX = elmnt.offsetLeft - pos1; let newY = elmnt.offsetTop - pos2; newX = Math.max(0, newX); newX = Math.min(newX, screenWidth - windowWidth); newY = Math.max(0, newY); newY = Math.min(newY, screenHeight - windowHeight - 25); elmnt.style.top = newY + "px"; elmnt.style.left = newX + "px"; } function closeDragElement() { document.onmouseup = null; document.onmousemove = null; } } let api_keyInput = document.getElementById('apikeyInput'); if (!api_keyInput) return; let video_speedInput = document.getElementById('speedSelect'); if (!video_speedInput) return; let checkboxes = document.querySelectorAll('input[name="option"]'); if (!checkboxes) return; api_keyInput.value = api_key || ''; video_speedInput.value = video_speed || '1'; for (let checkbox of checkboxes) { if (checkbox.value.includes('isautosubmit')) checkbox.checked = isAutoSubmit; if (checkbox.value.includes('isquestioncache')) checkbox.checked = isQuestionCacheEnabled; if (checkbox.value.includes('isafkmode')) checkbox.checked = isAFKMode; } let testBankBtn = document.getElementById('testBankBtn'); if (testBankBtn) testBankBtn.addEventListener('click', testOKBank); // 清除缓存按钮事件 let clearCacheBtn = document.getElementById('clearCacheBtn'); if (clearCacheBtn) { clearCacheBtn.addEventListener('click', function() { if (confirm('确定要清除所有题目缓存吗？这将清除已保存的所有题目答案。')) { clearQuestionCache(); } }); } // 实时保存设置功能 function updateSettingsImmediately() { let api_keyInput = document.getElementById('apikeyInput'); if (!api_keyInput) return; let video_speedInput = document.getElementById('speedSelect'); if (!video_speedInput) return; let checkboxes = document.querySelectorAll('input[name="option"]'); if (!checkboxes) return; api_key = api_keyInput.value.trim() || ''; video_speed = video_speedInput.value || '1'; for (let checkbox of checkboxes) { if (checkbox.value.includes('isautosubmit')) isAutoSubmit = checkbox.checked; if (checkbox.value.includes('isquestioncache')) isQuestionCacheEnabled = checkbox.checked; if (checkbox.value.includes('isafkmode')) isAFKMode = checkbox.checked; } writeScriptStorage(); log('设置已实时保存'); } // 为输入框和复选框添加实时保存事件监听 if (api_keyInput) { api_keyInput.addEventListener('input', updateSettingsImmediately); api_keyInput.addEventListener('change', updateSettingsImmediately); } if (video_speedInput) { video_speedInput.addEventListener('change', updateSettingsImmediately); } if (checkboxes && checkboxes.length > 0) { for (let checkbox of checkboxes) { checkbox.addEventListener('change', updateSettingsImmediately); } } } async function taskOperation() { await delay(1000); log("开始处理任务..."); // 检测考试页面 if (page_url.includes('/exam-ans/') || page_url.includes('/exam/test/')) { log("检测到考试页面，启动考试答题模式"); await handleExamPage(); return; } if (page_url.includes('/mooc-ans/knowledge/cards') || page_url.includes('/mooc-ans/work/doHomeWork') || page_url.includes('/work/')) { //log("检测到旧版页面URL，使用旧版处理逻辑"); cardIframes = document.querySelectorAll('iframe'); if (cardIframes && cardIframes.length > 0) { await handleOldVersionPage(); return; } else { //log("未找到iframe，尝试直接处理页面内容"); let questions = document.querySelectorAll('.TiMu, .Py-mian1, .singleQuesId, .questionLi'); if (questions && questions.length > 0) { log(`在页面中找到 ${questions.length} 个题目，直接处理`); await workModule(document); return; } } } //log("尝试新版处理逻辑"); await handleNewVersionPage(); } async function handleNewVersionPage() { //log("开始处理新版学习通页面..."); // 新版页面可能有不同的iframe结构 let iframes = document.querySelectorAll('iframe'); let processed = false; for (let iframe of iframes) { let iframeDoc; try { iframeDoc = iframe.contentDocument || iframe.contentWindow.document; if (!iframeDoc) continue; } catch (e) { // log("无法访问iframe（跨域限制），跳过此iframe"); continue; } // 尝试在新版页面中查找题目 let questions = iframeDoc.querySelectorAll('.TiMu, .Py-mian1, .singleQuesId, .questionLi'); if (questions.length > 0) { log(`在新版页面中找到 ${questions.length} 道题目`); await processNewVersionQuestions(iframeDoc); processed = true; break; } // 检查是否是视频页面 let video = iframeDoc.querySelector('video'); if (video) { log("检测到视频页面"); await handleNewVersionVideo(iframeDoc); processed = true; break; } } if (!processed) { log("未找到可处理的内容"); // 检查是否启用了自动提交 if (isAutoSubmit) { log("自动提交已启用，尝试页面导航"); handlePageNavigation(); } else { log("自动提交未启用，不进行页面导航"); } } } async function handleOldVersionPage() { log("开始处理旧版页面..."); let processedWorkTask = false; for (cardIframe of cardIframes) { try { cardIframeDocument = cardIframe.contentDocument || cardIframe.contentWindow.document; if (!cardIframeDocument) { log("任务点iframe文档为空"); continue; } } catch (e) { log("无法访问任务点iframe（跨域限制），跳过此任务"); continue; } if (cardIframe.src.includes('work')) { log("检测到作业任务"); processedWorkTask = true; await workModule(cardIframeDocument); } else if (cardIframe.src.includes('video')) { log("检测到视频任务"); await videoModule(cardIframeDocument); } else if (cardIframe.src.includes('pdf')) { log("检测到PDF任务"); await pdfModule(cardIframeDocument); } else { log("暂不支持该任务点"); } } // 只有在处理了作业任务且未启用自动提交时，才跳过页面导航 if (processedWorkTask && !isAutoSubmit) { log("已处理作业任务且未启用自动提交，跳过页面导航"); } else { log("准备进行页面导航"); await handlePageNavigation(); } } async function processNewVersionQuestions(iframeDoc) { //log("开始处理新版页面题目..."); // 字体解密处理 initDecryption(); parsePageFont(); // 查找题目容器 let questionContainers = iframeDoc.querySelectorAll('.TiMu, .Py-mian1, .singleQuesId, .questionLi'); if (questionContainers.length === 0) { log("未找到题目容器"); return; } log(`发现 ${questionContainers.length} 道题目`); for (let i = 0; i < questionContainers.length; i++) { let container = questionContainers[i]; let questionText = container.textContent || container.innerText; // 解密题目文本 let decryptedQuestion = decryptText(questionText); log(`第 ${i+1} 题: ${decryptedQuestion.substring(0, 50)}...`); // 获取答案 let answer = getCachedAnswer(decryptedQuestion, '单选题', []); if (answer) { log(`第 ${i+1} 题命中本地缓存`); } else { answer = await getAnswerFromAPI(decryptedQuestion, '单选题', []); } if (answer) { log(`答案: ${answer}`); await autoAnswerNewVersion(container, answer); } else { log("未找到答案，尝试随机选择"); await randomSelectAnswerNewVersion(container); } } // 尝试保存答案 await saveNewVersionAnswers(iframeDoc); } async function autoAnswerNewVersion(container, answer) { // 新版页面的自动答题逻辑 // 这里需要根据新版页面的具体结构来实现 log("新版页面自动答题功能开发中..."); } async function randomSelectAnswerNewVersion(container) { // 新版页面的随机选择逻辑 log("新版页面随机选择功能开发中..."); } async function saveNewVersionAnswers(iframeDoc) { // 新版页面的保存答案逻辑 let saveBtn = iframeDoc.querySelector('.btn-submit, .btn-save, [type="submit"]'); if (saveBtn) { saveBtn.click(); log("已点击保存按钮"); } else { log("未找到保存按钮"); } } async function handleNewVersionVideo(iframeDoc) { log("开始处理新版页面视频..."); let video = iframeDoc.querySelector('video'); if (!video) return; video.playbackRate = parseFloat(video_speed); video.autoplay = true; video.muted = true; // 强制播放函数 async function forcePlayVideo() { if (video.paused && !video.ended) { try { await video.play(); } catch (e) {} } } // 页面可见性检测 - 切换窗口时保持播放 document.addEventListener('visibilitychange', async () => { if (!document.hidden && !video.ended && video.paused) { log(`页面重新可见，恢复视频播放...`); await forcePlayVideo(); } }); // 窗口焦点检测 - 防止切换窗口时暂停 window.addEventListener('focus', async () => { if (!video.ended && video.paused) { log(`窗口获得焦点，恢复视频播放...`); await forcePlayVideo(); } }, { passive: true }); // 暂停检测 video.addEventListener('pause', async () => { if (!video.ended) { log(`检测到视频被暂停，正在恢复播放...`); await forcePlayVideo(); } }, { passive: true }); // 等待视频播放完成 await new Promise(resolve => { let checkEnded = () => { if (video.ended) { log("视频播放完成"); resolve(); } else { setTimeout(checkEnded, 1000); } }; checkEnded(); }); // 挂机模式：自动点击下一集 if (isAFKMode) { log('🤖 挂机模式开启，尝试自动播放下一集...'); await delay(2000); await clickNextVideo(); } } async function workModule(cardIframeDocument) { log("开始处理作业..."); let workIframe = cardIframeDocument.querySelector('iframe#frame_content'); if (!workIframe) { // log("未找到作业内容iframe"); return; } let workIframedoc; let isChapterTest = false; try { workIframedoc = workIframe.contentDocument || workIframe.contentWindow.document; if (!workIframedoc) { // log("无法获取作业iframe文档"); return; } } catch (e) { log("无法访问作业iframe（跨域限制）"); return; } // 字体解密处理 log("开始字体解密处理..."); // 方法1：复制CSS样式到当前文档 let secretStyleInHead = workIframedoc.querySelector('#cxSecretStyle'); if (secretStyleInHead) { let cssContent = secretStyleInHead.textContent; log(`找到字体样式，内容长度: ${cssContent.length}`); // 在当前文档中创建样式 let style = document.createElement('style'); style.id = 'cxSecretStyle'; style.textContent = cssContent; document.head.appendChild(style); log("已复制字体样式到当前文档"); } else { log("未找到字体样式元素，尝试其他方法"); } // 方法2：在iframe中应用样式 let iframeStyle = workIframedoc.querySelector('#cxSecretStyle'); if (!iframeStyle) { iframeStyle = workIframedoc.createElement('style'); iframeStyle.id = 'cxSecretStyle'; workIframedoc.head.appendChild(iframeStyle); } if (secretStyleInHead) { iframeStyle.textContent = secretStyleInHead.textContent; log("已在iframe中应用字体样式"); } else { // 如果没有找到字体样式，尝试使用默认的字体解密样式 let defaultFontStyle = ` @font-face { font-family: 'cxSecret'; src: local('Arial'), local('Microsoft YaHei'); } .font-cxsecret { font-family: 'cxSecret' !important; } `; iframeStyle.textContent = defaultFontStyle; log("已应用默认字体解密样式"); } // 方法3：处理字体加密的文本元素 let encryptedElements = workIframedoc.querySelectorAll('.font-cxsecret'); if (encryptedElements.length > 0) { log(`找到 ${encryptedElements.length} 个字体加密元素`); // 应用字体解密样式 for (let element of encryptedElements) { element.style.fontFamily = 'Arial, Microsoft YaHei, sans-serif'; element.style.fontSize = 'inherit'; // 强制重新渲染 element.style.display = 'none'; element.offsetHeight; // 触发重排 element.style.display = ''; } log("已处理字体加密元素"); } // 方法4：处理所有包含加密文本的元素 log("开始处理所有可能包含加密文本的元素..."); let allTextElements = workIframedoc.querySelectorAll('*'); let processedCount = 0; for (let element of allTextElements) { let text = element.textContent || ''; let trimmedText = text.trim(); // 检测是否包含乱码字符（字体加密的特征） if (trimmedText.length > 5 && (trimmedText.includes('擕') || trimmedText.includes('檎') || trimmedText.includes('擏') || trimmedText.includes('擓') || trimmedText.includes('擑') || trimmedText.includes('擐') || trimmedText.includes('撱') || trimmedText.includes('檑') || trimmedText.includes('妭') || trimmedText.includes('戛') || trimmedText.includes('撡') || trimmedText.includes('尼') || trimmedText.includes('擅') || trimmedText.includes('撛') || trimmedText.includes('擃') || trimmedText.includes('撶') || trimmedText.includes('擛') || trimmedText.includes('撝') || trimmedText.includes('撜') || trimmedText.includes('擆') || trimmedText.includes('擙'))) { // 应用字体解密样式 element.style.fontFamily = 'Arial, Microsoft YaHei, sans-serif'; element.style.fontSize = 'inherit'; // 强制重新渲染 element.style.display = 'none'; element.offsetHeight; // 触发重排 element.style.display = ''; processedCount++; } } log(`已处理 ${processedCount} 个可能包含加密文本的元素`); // 方法5：等待字体解密生效 log("等待字体解密生效..."); await delay(2000); // 增加等待时间确保字体解密完全生效 log("字体解密处理完成"); // 采用111的简单直接方法处理题目 log("采用111的简单直接方法处理题目..."); async function selectAnswer(questionEl, questionType, answer, workIframedoc) { // console.log('OK题库助手: selectAnswer函数被调用，题目类型:', questionType, '答案:', answer); // log(`[DEBUG] OK题库助手: selectAnswer函数被调用，题目类型: ${questionType}, 答案: ${answer}`); let questionId = '0'; let idElements = questionEl.getElementsByTagName('input'); // console.log('OK题库助手: 找到的input元素数量:', idElements.length); for (let z = 0, k = idElements.length; z < k; z++) { try { let nameAttr = idElements[z].getAttribute('name'); // console.log('OK题库助手: input元素[', z, '] name属性:', nameAttr); if (nameAttr && nameAttr.indexOf('answer') >= 0) { questionId = nameAttr.replace('type', ''); // console.log('OK题库助手: 找到题目ID:', questionId); break; } } catch (e) { // console.log('OK题库助手: 获取input属性出错:', e); } } if (questionId == '0') { throw new Error("未找到题目ID"); } let answerInput = null; for (let z = 0, k = idElements.length; z < k; z++) { try { let nameAttr = idElements[z].getAttribute('name'); // console.log('OK题库助手: 查找答案输入框，name:', nameAttr, '目标questionId:', questionId); if (nameAttr == questionId) { answerInput = idElements[z]; // console.log('OK题库助手: 找到答案输入框:', answerInput); break; } } catch (e) { // console.log('OK题库助手: 查找答案输入框出错:', e); } } switch (questionType) { case "单选题": { // console.log('OK题库助手: 处理单选题，答案:', answer); // 首先尝试在questionEl中查找li元素（与111一致） let choiceElements = questionEl.getElementsByTagName('li'); // console.log('OK题库助手: 在questionEl中找到li元素数量:', choiceElements.length); let questionIdNum = questionId.replace('answer', ''); // console.log('OK题库助手: 单选题ID数字部分:', questionIdNum); let found = false; // 尝试多种匹配方式 for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let idParam = liElement.getAttribute('id-param'); let innerText = liElement.innerText || liElement.textContent; // let classAttr = liElement.getAttribute('class'); // 显示详细信息 // console.log('OK题库助手: 选项[', i, ']: text="', innerText, '", id-param="', idParam, '", class="', classAttr, '"'); // 查找em元素获取选项值 let emElements = liElement.getElementsByTagName('em'); if (emElements.length > 0) { let emIdParam = emElements[0].getAttribute('id-param'); // console.log('OK题库助手: 选项[', i, '] em id-param:', emIdParam); // 匹配方式：通过选项字母匹配 if (emIdParam == answer && idParam == questionIdNum) { // console.log('OK题库助手: 点击单选题选项:', answer); try { liElement.click(); found = true; log(`已选择单选题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击单选题选项失败:', e); } } } // 备用匹配方式：通过文本内容包含选项字母 else if (innerText && innerText.includes(answer)) { // console.log('OK题库助手: 点击单选题选项（通过文本匹配）:', answer); try { liElement.click(); found = true; log(`已选择单选题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击单选题选项失败:', e); } } } // 如果在questionEl中没有找到，尝试在整个文档中查找（备用方法） if (!found && workIframedoc) { // console.log('OK题库助手: 在questionEl中未找到，尝试在整个文档中查找'); choiceElements = workIframedoc.getElementsByTagName('li'); // console.log('OK题库助手: 在整个文档中找到li元素数量:', choiceElements.length); for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let idParam = liElement.getAttribute('id-param'); // 查找em元素获取选项值 let emElements = liElement.getElementsByTagName('em'); if (emElements.length > 0) { let emIdParam = emElements[0].getAttribute('id-param'); // 匹配方式：通过选项字母匹配 if (emIdParam == answer && idParam == questionIdNum) { // console.log('OK题库助手: 点击单选题选项:', answer); try { liElement.click(); found = true; log(`已选择单选题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击单选题选项失败:', e); } } } } } // 如果仍然未找到，尝试使用输入框方法 if (!found) { // console.log('OK题库助手: 未找到匹配的单选题选项，尝试备用方法使用输入框'); if (answerInput) { // console.log('OK题库助手: 设置单选题答案:', answer, '到输入框:', answerInput); answerInput.value = answer; try { answerInput.dispatchEvent(new Event('input', { bubbles: true })); answerInput.dispatchEvent(new Event('change', { bubbles: true })); // console.log('OK题库助手: 已触发input和change事件'); log(`已选择单选题答案: ${answer}`); } catch (e) { // console.log('OK题库助手: 触发事件失败:', e); } } else { throw new Error(`未找到单选题输入框: ${questionId}`); } } break; } case "多选题": { let found = false; let answerStr = typeof answer === 'string' ? answer : answer.join(""); let answerLetters = answerStr.split(''); // 与111一致的方法：通过em元素的id-param属性匹配 let choiceElements = questionEl.getElementsByTagName('li'); // console.log('OK题库助手: 找到li元素数量:', choiceElements.length); let questionIdNum = questionId.replace('answer', ''); for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let idParam = liElement.getAttribute('id-param'); // 查找em元素获取选项值 let emElements = liElement.getElementsByTagName('em'); if (emElements.length > 0) { let emIdParam = emElements[0].getAttribute('id-param'); // console.log('OK题库助手: 选项em id-param:', emIdParam, 'li id-param:', idParam, 'questionIdNum:', questionIdNum); // 检查该选项是否在答案中且id匹配 if (answerLetters.includes(emIdParam) && idParam == questionIdNum) { // console.log('OK题库助手: 点击多选题选项:', emIdParam); try { // 检查是否已经选中 let classAttr = liElement.getAttribute('class'); if (!classAttr || !classAttr.includes('cur')) { liElement.click(); // 短暂延迟确保点击生效 await new Promise(resolve => setTimeout(resolve, 200)); } found = true; } catch (e) { // console.log('OK题库助手: 点击多选题选项失败:', e); } } } } // 方法2：如果方法1失败，尝试直接点击选项文本（匹配选项字母） if (!found) { for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let innerText = liElement.innerText || liElement.textContent; let trimmedText = innerText.trim(); // 提取选项字母（如 "A 单电级记录" 中的 "A"） let optionLetter = trimmedText.charAt(0); if (/[A-D]/.test(optionLetter) && answerLetters.includes(optionLetter)) { // console.log('OK题库助手: 点击多选题选项（通过文本匹配）:', optionLetter); try { liElement.click(); // 短暂延迟确保点击生效 await new Promise(resolve => setTimeout(resolve, 200)); found = true; } catch (e) { // console.log('OK题库助手: 点击多选题选项失败:', e); } } } } // 方法3：如果在questionEl中没有找到，尝试在整个文档中查找 if (!found && workIframedoc) { // console.log('OK题库助手: 在questionEl中未找到，尝试在整个文档中查找'); let allLiElements = workIframedoc.getElementsByTagName('li'); for (let i = 0, k = allLiElements.length; i < k; i++) { let liElement = allLiElements[i]; let innerText = liElement.innerText || liElement.textContent; let trimmedText = innerText.trim(); // 提取选项字母 let optionLetter = trimmedText.charAt(0); if (/[A-D]/.test(optionLetter) && answerLetters.includes(optionLetter)) { // console.log('OK题库助手: 在整个文档中点击多选题选项:', optionLetter); try { liElement.click(); // 短暂延迟确保点击生效 await new Promise(resolve => setTimeout(resolve, 200)); found = true; } catch (e) { // console.log('OK题库助手: 点击多选题选项失败:', e); } } } } // 方法4：如果仍然未找到，尝试使用输入框方法 if (!found) { // console.log('OK题库助手: 未找到匹配的多选题选项，尝试备用方法使用输入框'); if (answerInput) { // console.log('OK题库助手: 设置多选题答案:', answerStr, '到输入框:', answerInput); answerInput.value = answerStr; try { answerInput.dispatchEvent(new Event('input', { bubbles: true })); answerInput.dispatchEvent(new Event('change', { bubbles: true })); // console.log('OK题库助手: 已触发input和change事件'); } catch (e) { // console.log('OK题库助手: 触发事件失败:', e); } log(`已选择多选题答案: ${answerStr}`); } else { throw new Error(`未找到多选题输入框: ${questionId}`); } } else { log(`已选择多选题答案: ${answerStr}`); } break; } case "判断题": { // console.log('OK题库助手: 处理判断题，原始答案:', answer); // 参照111的逻辑：将答案转换为true/false let judgeAnswer = 'false'; // 处理中文答案：正确是对√Tri if (answer.toLowerCase() === 'true' || answer === '正确' || answer === '是' || answer === '对' || answer === '√' || answer === 'Tri') { judgeAnswer = 'true'; } // console.log('OK题库助手: 判断题答案转换: 原始答案="' + answer + '", 转换后="' + judgeAnswer + '"'); // 首先尝试在questionEl中查找li元素（与111一致） let choiceElements = questionEl.getElementsByTagName('li'); // console.log('OK题库助手: 在questionEl中找到li元素数量:', choiceElements.length); let questionIdNum = questionId.replace('answer', ''); // console.log('OK题库助手: 判断题ID数字部分:', questionIdNum); let found = false; // 尝试多种匹配方式 for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let valParam = liElement.getAttribute('val-param'); let idParam = liElement.getAttribute('id-param'); let innerText = liElement.innerText || liElement.textContent; // let classAttr = liElement.getAttribute('class'); // 显示详细信息 // console.log('OK题库助手: 选项[', i, ']: text="', innerText, '", val-param="', valParam, '", id-param="', idParam, '", class="', classAttr, '"'); // 匹配方式1：val-param和id-param（与111一致） if (valParam == judgeAnswer && idParam == questionIdNum) { // console.log('OK题库助手: 点击判断题选项:', judgeAnswer); try { liElement.click(); found = true; log(`已选择判断题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击判断题选项失败:', e); } } // 匹配方式2：只匹配val-param（忽略id-param） else if (valParam == judgeAnswer) { // console.log('OK题库助手: 点击判断题选项（仅匹配val-param）:', judgeAnswer); try { liElement.click(); found = true; log(`已选择判断题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击判断题选项失败:', e); } } // 匹配方式3：通过文本内容匹配 else if (innerText && ((judgeAnswer === 'true' && (innerText.includes('对') || innerText.includes('正确') || innerText.includes('是'))) || (judgeAnswer === 'false' && (innerText.includes('错') || innerText.includes('错误') || innerText.includes('否'))))) { // console.log('OK题库助手: 点击判断题选项（通过文本匹配）:', innerText); try { liElement.click(); found = true; log(`已选择判断题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击判断题选项失败:', e); } } } // 如果在questionEl中没有找到，尝试在整个文档中查找（备用方法） if (!found && workIframedoc) { // console.log('OK题库助手: 在questionEl中未找到，尝试在整个文档中查找'); choiceElements = workIframedoc.getElementsByTagName('li'); // console.log('OK题库助手: 在整个文档中找到li元素数量:', choiceElements.length); for (let i = 0, k = choiceElements.length; i < k; i++) { let liElement = choiceElements[i]; let valParam = liElement.getAttribute('val-param'); let idParam = liElement.getAttribute('id-param'); // let innerText = liElement.innerText || liElement.textContent; // console.log('OK题库助手: 文档选项[', i, ']: val-param="', valParam, '", id-param="', idParam, '"'); // 匹配方式1：val-param和id-param（与111一致） if (valParam == judgeAnswer && idParam == questionIdNum) { // console.log('OK题库助手: 点击判断题选项:', judgeAnswer); try { liElement.click(); found = true; log(`已选择判断题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击判断题选项失败:', e); } } // 匹配方式2：只匹配val-param（忽略id-param） else if (valParam == judgeAnswer) { // console.log('OK题库助手: 点击判断题选项（仅匹配val-param）:', judgeAnswer); try { liElement.click(); found = true; log(`已选择判断题答案: ${answer}`); return; // 与111一致，点击后立即返回 } catch (e) { // console.log('OK题库助手: 点击判断题选项失败:', e); } } } } // 如果仍然未找到，尝试使用输入框方法 if (!found) { // console.log('OK题库助手: 未找到匹配的判断题选项，尝试备用方法使用输入框'); // 备用方法：使用原来的输入框方法 if (answerInput) { // console.log('OK题库助手: 设置判断题答案:', answer, '到输入框:', answerInput); answerInput.value = answer; try { answerInput.dispatchEvent(new Event('input', { bubbles: true })); answerInput.dispatchEvent(new Event('change', { bubbles: true })); // console.log('OK题库助手: 已触发input和change事件'); log(`已选择判断题答案: ${answer}`); } catch (e) { // console.log('OK题库助手: 触发事件失败:', e); } } else { throw new Error(`未找到判断题输入框: ${questionId}`); } } break; } case "填空题": { let textareas = questionEl.querySelectorAll('textarea'); for (let textarea of textareas) { textarea.remove(); } for (let i = 0; i < answer.length; i++) { let input = document.createElement('input'); input.name = `answerEditor${questionId}${i + 1}`; input.value = answer[i]; questionEl.insertBefore(input, questionEl.firstChild); } break; } case "计算题": { let textarea = questionEl.querySelector('textarea'); textarea.remove(); let input = document.createElement('input'); input.name = `answer${questionId}`; input.value = `

${answer.join('
')}

`; questionEl.insertBefore(input, questionEl.firstChild); break; } case "简答题": { let textarea = questionEl.querySelector('textarea'); textarea.remove(); let input = document.createElement('input'); input.name = `answer${questionId}`; input.value = `

${answer.join('
')}

`; questionEl.insertBefore(input, questionEl.firstChild); break; } default: throw new Error(`不支持的题目类型: ${questionType}`); } } // 随机选择答案函数 async function randomSelectAnswer(questionEl, questionType) { log(`开始随机选择答案，题型: ${questionType}`); try { let questionId = '0'; let idElements = questionEl.getElementsByTagName('input'); // 获取题目ID for (let z = 0, k = idElements.length; z < k; z++) { try { if (idElements[z].getAttribute('name').indexOf('answer') >= 0) { questionId = idElements[z].getAttribute('name').replace('type', ''); break; } } catch (e) { console.log(e); continue; } } if (questionId == '0') { throw new Error("未找到题目ID"); } switch (questionType) { case "单选题": { // 随机选择一个选项 let options = ['A', 'B', 'C', 'D']; let randomAnswer = options[Math.floor(Math.random() * options.length)]; log(`单选题随机选择答案: ${randomAnswer}`); await selectAnswer(questionEl, questionType, randomAnswer); break; } case "多选题": { // 随机选择1-3个选项 let options = ['A', 'B', 'C', 'D']; let selectedCount = Math.floor(Math.random() * 3) + 1; let selectedOptions = []; // 随机选择不重复的选项 while (selectedOptions.length < selectedCount && selectedOptions.length < options.length) { let randomOption = options[Math.floor(Math.random() * options.length)]; if (!selectedOptions.includes(randomOption)) { selectedOptions.push(randomOption); } } let randomAnswer = selectedOptions.join(','); log(`多选题随机选择答案: ${randomAnswer}`); await selectAnswer(questionEl, questionType, randomAnswer); break; } case "判断题": { // 随机选择正确或错误 let options = ['正确', '错误']; let randomAnswer = options[Math.floor(Math.random() * options.length)]; log(`判断题随机选择答案: ${randomAnswer}`); await selectAnswer(questionEl, questionType, randomAnswer); break; } default: log(`不支持随机选择的题型: ${questionType}`); break; } } catch (e) { log(`随机选择答案失败: ${e.message}`); } } // 自动选择答案函数 async function autoSelectAnswer(questionEl, questionType, questionId) { let idElements = questionEl.getElementsByTagName('input'); let answerInput = null; for (let z = 0, k = idElements.length; z < k; z++) { try { if (idElements[z].getAttribute('name') == questionId) { answerInput = idElements[z]; break; } } catch (e) { console.log(e); } } switch (questionType) { case "单选题": { if (answerInput) { answerInput.value = 'B'; log(`第 ${questionId} 题自动选择答案: B`); } else { throw new Error(`未找到单选题输入框: ${questionId}`); } break; } case "多选题": { if (answerInput) { answerInput.value = 'AB'; log(`第 ${questionId} 题自动选择答案: AB`); } else { throw new Error(`未找到多选题输入框: ${questionId}`); } break; } case "判断题": { if (answerInput) { answerInput.value = 'false'; log(`第 ${questionId} 题自动选择答案: false`); } else { throw new Error(`未找到判断题输入框: ${questionId}`); } break; } case "填空题": { let textareas = questionEl.querySelectorAll('textarea'); for (let textarea of textareas) { textarea.remove(); } let input = document.createElement('input'); input.name = `answerEditor${questionId}1`; input.value = '答案'; questionEl.insertBefore(input, questionEl.firstChild); log(`第 ${questionId} 题自动填写答案`); break; } case "计算题": case "简答题": { let textarea = questionEl.querySelector('textarea'); if (textarea) { textarea.remove(); } let input = document.createElement('input'); input.name = `answer${questionId}`; input.value = '

答案

'; questionEl.insertBefore(input, questionEl.firstChild); log(`第 ${questionId} 题自动填写答案`); break; } default: throw new Error(`不支持的题目类型: ${questionType}`); } } async function processAllQuestions() { // 检查是否已完成（超星会显示DividerBox） let DividerBox = workIframedoc.querySelector('div.DividerBox'); if (DividerBox) { log("题目已完成，无需重复处理"); return; } // 采用111的简单直接方法 - 使用固定选择器 let questions = workIframedoc.getElementsByClassName('Py-mian1'); if (questions && questions.length > 0) { log(`使用选择器 Py-mian1 找到 ${questions.length} 个题目容器`); } else { // 备用选择器 questions = workIframedoc.getElementsByClassName('singleQuesId'); if (questions && questions.length > 0) { log(`使用选择器 singleQuesId 找到 ${questions.length} 个题目容器`); } else { log("未找到题目容器，退出"); return; } } log(`发现 ${questions.length} 道题目，开始逐一处理`); // console.log('OK题库助手: 发现题目数量:', questions.length, '开始逐一处理'); for (let i = 0; i < questions.length; i++) { let questionEl = questions[i]; let questionIndex = i + 1; try { log(`------ 开始处理第 ${questionIndex}/${questions.length} 题 ------`); // console.log('OK题库助手: 开始处理第', questionIndex, '题'); showMessage(`处理第 ${questionIndex}/${questions.length} 题`, `blue`); // 获取题目ID - 使用111的方法 let questionId = '0'; let idElements = questionEl.getElementsByTagName('input'); for (let z = 0, k = idElements.length; z < k; z++) { try { if (idElements[z].getAttribute('name').indexOf('answer') >= 0) { questionId = idElements[z].getAttribute('name').replace('type', ''); log(`使用name属性获取题目ID: ${questionId}`); break; } } catch (e) { console.log(e); continue; } } if (questionId == '0') { log(`第 ${questionIndex} 题未找到ID，跳过`); continue; } // 获取题目内容 - 使用ziti.js的简洁方法 let questionText = ''; try { // 使用ziti.js的方法：优先查找包含题目的元素 let titleElement = questionEl.querySelector('.Zy_TItle .clearfix') || questionEl.querySelector('.Zy_TItle') || questionEl.querySelector('.newZy_TItle') || questionEl.querySelector('.fontLabel') || questionEl.querySelector('.Py-m1-title'); if (titleElement) { // 使用innerText获取纯文本，避免HTML标签干扰 questionText = titleElement.innerText.replace(/\s+/g, ' ').trim(); } else { throw new Error("未找到题目标题元素"); } // 初始化解密功能并解密题目文本 initDecryption(); parsePageFont(); let originalQuestionText = questionText; questionText = decryptText(questionText); log(`找到题目: "${originalQuestionText.substring(0, 80)}..."`); log(`解密后题目: "${questionText.substring(0, 80)}..."`); } catch (e) { log(`第 ${questionIndex} 题获取题目内容失败: ${e.message}`); continue; } // 获取题型 - 使用111的方法 let typeText = ''; try { let typeElements = questionEl.getElementsByTagName('input'); let typeN = ''; for (let g = 0, h = typeElements.length; g < h; g++) { if (typeElements[g].id == 'answertype' + questionId.replace('answer', '').replace('check', '')) { typeN = typeElements[g].value; break; } } typeText = { '0': '单选题', '1': '多选题', '3': '判断题' }[typeN]; if (!typeText) { log(`第 ${questionIndex} 题题型未知(typeN=${typeN})，跳过`); continue; } log(`第 ${questionIndex} 题为 ${typeText}`); } catch (e) { log(`第 ${questionIndex} 题获取题型失败: ${e.message}`); continue; } // 获取选项列表 - 使用ziti.js的简洁方法 let optionList = []; let optionMap = {}; // 选项文本到选项字母的映射 if (['单选题', '多选题'].includes(typeText)) { log(`第 ${questionIndex} 题开始查找选项列表...`); // console.log('OK题库助手: 开始查找单选题/多选题选项列表，题目索引:', questionIndex); try { // 使用ziti.js的方法：直接查找选项元素 const options = questionEl.querySelectorAll('ul li'); // console.log('OK题库助手: 找到的选项元素数量:', options.length); if (options.length > 0) { log(`使用标准选择器找到 ${options.length} 个选项`); // console.log('OK题库助手: 成功找到选项元素，开始处理选项文本'); for (let opt of options) { let optText = opt.innerText.replace(/\s+/g, ' ').trim(); // 解密选项文本 let originalOptText = optText; optText = decryptText(optText); // 提取选项值（A、B、C、D等） let optionValue = optText.slice(0, 1); let optionText = optText.slice(1).replace(/(^\s*)|(\s*$)/g, ""); let optionId = opt.getAttribute('id-param'); // 跳过无效选项 if (optionText == '' || !optionValue.match(/[A-D]/)) { continue; } log(`选项 ${optionValue}: 解密后="${optionText}"`); optionList.push(optionText); optionMap[optionText] = optionValue; // 存储映射关系 } log(`第 ${questionIndex} 题找到 ${optionList.length} 个选项`); // console.log('OK题库助手: 选项映射表:', optionMap); } else { throw new Error("未找到选项列表"); } } catch (e) { log(`第 ${questionIndex} 题获取选项失败: ${e.message}`); continue; } } // console.log('OK题库助手: 🚀 准备进入题库请求部分，题目类型:', typeText); // log(`[DEBUG] OK题库助手: 准备进入题库请求部分，题目类型: ${typeText}`); // 通过接口获取答案 log(`第 ${questionIndex} 题正在获取答案...`); // console.log('OK题库助手: 🔥 强制调试：准备调用getAnswerFromAPI，题目类型:', typeText, '题目:', questionText); // log(`[DEBUG] OK题库助手: 🔥 强制调试：准备调用getAnswerFromAPI，题目类型: ${typeText}`); // console.log('OK题库助手: 准备调用getAnswerFromAPI，题目类型:', typeText, '题目:', questionText); // 添加请求间隔，避免频率限制 let answer = getCachedAnswer(questionText, typeText, optionList); if (answer) { log(`第 ${questionIndex} 题命中本地缓存`); } else { if (questionIndex > 1) { // console.log('OK题库助手: 等待1秒间隔，避免频率限制...'); await new Promise(resolve => setTimeout(resolve, 1000)); } try { // console.log('OK题库助手: 🚨 强制调试：即将调用getAnswerFromAPI函数'); // log(`[DEBUG] OK题库助手: 🚨 强制调试：即将调用getAnswerFromAPI函数`); answer = await getAnswerFromAPI(questionText, typeText, optionList); // console.log('OK题库助手: getAnswerFromAPI返回结果:', answer); // log(`[DEBUG] OK题库助手: getAnswerFromAPI返回结果: ${answer}`); } catch (error) { console.error('OK题库助手: 题目处理失败:', error); log(`第 ${questionIndex} 题处理失败，随机选择`); if (randomDo == 1) { await randomSelectAnswer(questionEl, typeText); } continue; } } if (answer) { log(`第 ${questionIndex} 题获取到答案: ${answer}`); // console.log('OK题库助手: 原始答案:', answer, '题目类型:', typeText); // 转换答案格式：如果题库返回选项文本，转换为选项字母 let finalAnswer = answer; if (['单选题', '多选题'].includes(typeText)) { // 检查答案是否是单个字母（A/B/C/D） if (!/^[A-D]+$/.test(answer.trim())) { // console.log('OK题库助手: 答案不是单个字母，尝试转换为选项字母'); // 处理多选题的#分隔答案 let answerParts = answer.split('#').map(part => part.trim()); let matchedAnswers = []; for (let part of answerParts) { // 尝试在选项映射表中查找 if (optionMap[part]) { matchedAnswers.push(optionMap[part]); } else { // 尝试部分匹配 let matched = false; for (let text in optionMap) { if (part.includes(text) || text.includes(part)) { matchedAnswers.push(optionMap[text]); matched = true; break; } } if (!matched) { // 如果没有找到匹配项，尝试提取选项字母 const optionMatch = part.match(/[A-D]/); if (optionMatch) { matchedAnswers.push(optionMatch[0]); log(`第 ${questionIndex} 题从答案中提取选项: ${optionMatch[0]}`); } } } } if (matchedAnswers.length > 0) { // 去重并排序 matchedAnswers = [...new Set(matchedAnswers)].sort(); finalAnswer = matchedAnswers.join(''); log(`第 ${questionIndex} 题多选题答案转换: ${answer} -> ${finalAnswer}`); } else { // 如果没有找到匹配项，尝试提取选项字母 const optionMatch = answer.match(/[A-D]/); if (optionMatch) { finalAnswer = optionMatch[0]; log(`第 ${questionIndex} 题从答案中提取选项: ${finalAnswer}`); } else { throw new Error('无法转换答案为选项字母'); } } } else { // console.log('OK题库助手: 答案已经是选项字母，无需转换:', answer); } } log(`第 ${questionIndex} 题使用答案: ${finalAnswer}`); await selectAnswer(questionEl, typeText, finalAnswer, workIframedoc); } else { if (randomDo == 1) { log(`第 ${questionIndex} 题未找到答案，随机选择`); await randomSelectAnswer(questionEl, typeText); } else { log(`第 ${questionIndex} 题未找到答案，跳过`); } } } catch (e) { log(`第 ${questionIndex} 题处理失败: ${e.message}`); console.error('OK题库助手: 题目处理错误详情:', e); console.error('OK题库助手: 错误堆栈:', e.stack); } } await saveAnswers(); if (isAutoSubmit) { let btnSubmit = workIframedoc.querySelector('.btnSubmit'); if (btnSubmit) { log("已点击确认按钮"); btnSubmit.click(); await submitAnswers(); } else { log("未找到确认按钮"); } } } async function saveAnswers() { log("准备保存答案"); await delay(2000); let tempsave = workIframedoc.querySelector('span#tempsave'); if (!tempsave) { let saveElements = workIframedoc.querySelectorAll('[class*="save"], [id*="save"]'); for (let element of saveElements) { if (element.textContent.includes('保存') || element.innerText.includes('保存')) { tempsave = element; break; } } } if (tempsave) { tempsave.click(); log("已点击保存按钮"); } else { log("未找到保存按钮，将继续执行"); } } await processAllQuestions(); } async function videoModule(cardIframeDocument) { return new Promise((resolve) => { (async () => { try { log("开始处理视频..."); await delay(1000); let courseVideo = cardIframeDocument.querySelector('video'); if (!courseVideo) { log("未找到视频元素，结束视频处理"); resolve(); return; } if (courseVideo.ended) { log("视频已播放完成"); resolve(); return; } log(`找到视频元素，开始自动播放处理...`); let playbackRate = parseFloat(video_speed); courseVideo.playbackRate = playbackRate; courseVideo.autoplay = true; courseVideo.muted = true; async function forcePlay() { if (courseVideo.paused && !courseVideo.ended) { try { await delay(1000); await courseVideo.play(); log(`视频已恢复播放，播放速度: ${playbackRate}x`); } catch (error) { log(`视频播放失败: ${error.message}，1秒后重试`); if (!courseVideo.ended) { await delay(1000); await forcePlay(); } } } } await forcePlay(); setInterval(() => { let currentTime = courseVideo.currentTime; let duration = courseVideo.duration; let progressValue = (currentTime / duration) * 100; log(`速度：${parseFloat(video_speed)}X，播放进度：${progressValue.toFixed(1)}%`); }, 1000) courseVideo.addEventListener('timeupdate', () => { let newSpeed = parseFloat(video_speed); if (newSpeed != playbackRate) { playbackRate = newSpeed; courseVideo.playbackRate = playbackRate; log(`视频速度已调整为: ${playbackRate}x`); } }, { passive: true }); courseVideo.addEventListener('pause', async () => { if (!courseVideo.ended) { log(`检测到视频被暂停，正在恢复播放...`); await forcePlay(); } }, { passive: true }); // 页面可见性检测 - 切换窗口时保持播放 let visibilityHandler = async () => { if (!document.hidden && !courseVideo.ended && courseVideo.paused) { log(`页面重新可见，恢复视频播放...`); await forcePlay(); } }; document.addEventListener('visibilitychange', visibilityHandler); // 窗口焦点检测 - 防止切换窗口时暂停 window.addEventListener('focus', async () => { if (!courseVideo.ended && courseVideo.paused) { log(`窗口获得焦点，恢复视频播放...`); await forcePlay(); } }, { passive: true }); await new Promise(resolveVideo => { let checkEnded = () => { if (courseVideo.ended) { log(`视频播放完成`); resolveVideo(); } else { setTimeout(checkEnded, 1000); } }; checkEnded(); }); // 挂机模式：自动点击下一集 if (isAFKMode) { log('🤖 挂机模式开启，尝试自动播放下一集...'); await delay(2000); await clickNextVideo(); } resolve(); } catch (error) { log(`视频处理出错: ${error.message}`); resolve(); } })(); }); } // 挂机模式：点击下一集视频 async function clickNextVideo() { try { // 尝试多种方式查找下一集按钮 let nextSelectors = [ '.next_lesson', '.next_lesson_bg', '#nextLesson', '#nextBtn', '.next-btn', '[title="下一节"]', '[title="下一章"]', '.next', '.next-chapter', '.next-video' ]; for (let selector of nextSelectors) { let nextBtn = document.querySelector(selector); if (nextBtn) { log(`找到下一集按钮: ${selector}`); nextBtn.click(); log('✅ 已点击下一集按钮'); await delay(3000); return true; } } // 尝试查找包含"下一"文字的按钮 let allButtons = document.querySelectorAll('button, a, span, div'); for (let btn of allButtons) { let text = btn.textContent || btn.innerText || ''; if (text.includes('下一') && (text.includes('节') || text.includes('章') || text.includes('集'))) { log(`找到下一集按钮(文字匹配): ${text}`); btn.click(); log('✅ 已点击下一集按钮'); await delay(3000); return true; } } // 尝试通过父窗口查找 if (window.parent && window.parent !== window) { for (let selector of nextSelectors) { let nextBtn = window.parent.document.querySelector(selector); if (nextBtn) { log(`在父窗口找到下一集按钮: ${selector}`); nextBtn.click(); log('✅ 已点击下一集按钮'); await delay(3000); return true; } } } log('⚠️ 未找到下一集按钮'); return false; } catch (error) { log(`点击下一集按钮出错: ${error.message}`); return false; } } async function pdfModule(cardIframeDocument) { await delay(3000); let pdfIframe = cardIframeDocument.querySelector("iframe#panView"); if (!pdfIframe) { log('pdf iframe is null'); return; } let pdfDoc; try { pdfDoc = pdfIframe.contentDocument || pdfIframe.contentWindow.document; if (!pdfDoc) { log('pdfDoc is null'); return; } } catch (e) { log("无法访问PDF iframe（跨域限制）"); return; } let script = pdfDoc.createElement('script'); script.textContent = ` (function() { try { if (parent && parent !== window) { parent.postMessage({isFinished: 1}, '*'); // console.log('脚本注入成功：已发送完成消息'); } else { // console.log('不在iframe中，无需发送消息'); } } catch(e) { console.error('脚本执行错误:', e); } })(); `; pdfDoc.head.appendChild(script); log('已完成pdf'); } function readScriptStorage() { api_key = GM_getValue('api_key', ''); video_speed = GM_getValue('video_speed', '1'); isAutoSubmit = GM_getValue('isAutoSubmit', true); isQuestionCacheEnabled = GM_getValue('isQuestionCacheEnabled', true); isAFKMode = GM_getValue('isAFKMode', false); loadQuestionAnswerCache(); } function writeScriptStorage() { GM_setValue('api_key', api_key); GM_setValue('video_speed', video_speed); GM_setValue('isAutoSubmit', isAutoSubmit); GM_setValue('isQuestionCacheEnabled', isQuestionCacheEnabled); GM_setValue('isAFKMode', isAFKMode); } function showMessage(text, color) { let messageEl = window.top.document.getElementById('message'); if (messageEl) { messageEl.textContent = text; messageEl.style.color = color; setTimeout(() => { messageEl.textContent = ''; }, 3000); } } function log(message) { let logArea = window.top.document.getElementById('logArea'); if (!logArea) return; let now = new Date(); let timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`; let logEntry = document.createElement('div'); logEntry.style.cssText = 'margin: 3px 0; border-bottom: 1px solid #f0f0f0; padding-bottom: 2px;'; logEntry.innerHTML = `[${timeString}] ${message}`; logArea.appendChild(logEntry); let logs = logArea.querySelectorAll('div'); if (logs.length > logNum) { logs[0].remove(); } logArea.scrollTop = logArea.scrollHeight; } async function handlePageNavigation() { try { log("准备进行页面导航"); let nextChapter = window.top.document.querySelector(`a.nextChapter`); if (nextChapter) { if (isAutoSubmit) { // 如果启用了自动提交，立即换页 log("自动提交已启用，立即执行换页操作"); nextChapter.click(); log("换页操作已执行"); } else { // 如果未启用自动提交，等待3秒后换页 log("等待3秒后执行换页操作"); await delay(3000); nextChapter.click(); log("换页操作已执行"); } } else { log("未找到导航元素，无法换页"); } } catch (error) { log(`换页处理出错: ${error.message}`); } } function captureQuestion(questionEl) { return new Promise((resolve) => { html2canvas(questionEl, { useCORS: true, allowTaint: false }).then(canvas => { let base64 = canvas.toDataURL("image/png"); resolve(base64); }).catch(error => { log(`截图失败: ${error.message}`); resolve(null); }); }); } // 剩余次数和题库状态 let remainingQueries = 0; let apiStatus = '未知'; // 测试OK题库连接 async function testOKBank() { log("正在测试OK题库连接..."); showMessage('正在测试题库连接...', 'blue'); try { let testQuestion = "测试题目：习近平新时代中国特色社会主义思想"; // 优先从输入框获取最新的API密钥 let currentApiKey = api_key; try { const apiKeyInput = window.top.document.getElementById('apikeyInput'); if (apiKeyInput) { const inputValue = apiKeyInput.value.trim(); if (inputValue) { currentApiKey = inputValue; } } } catch (e) { // console.log('OK题库助手: 获取输入框API密钥失败:', e); } // 确保使用有效的API密钥 if (!currentApiKey || currentApiKey === '') { currentApiKey = ''; } let response = await new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "POST", url: `${base_url}`, data: JSON.stringify({ question: testQuestion, apiKey: currentApiKey }), headers: { "Content-Type": "application/json" }, onload: resolve, onerror: reject }); }); try { let data = JSON.parse(response.responseText); // console.log("API响应数据:", data); if (data.code === 200) { apiStatus = '正常'; if (data.data && data.data.remainingCount !== undefined) { remainingQueries = data.data.remainingCount; } showMessage('题库连接正常', 'green'); log(`题库测试成功，状态码: ${response.status}, 剩余次数: ${remainingQueries}`); updateStatusDisplay(); } else { apiStatus = '异常'; showMessage(`题库异常: ${data.msg || '未知错误'}`, 'red'); log(`题库测试失败: ${data.msg || '未知错误'}, 状态码: ${response.status}`); updateStatusDisplay(); } } catch (error) { apiStatus = '异常'; showMessage('题库响应解析失败', 'red'); log(`题库响应解析失败: ${error.message}`); updateStatusDisplay(); } } catch (error) { apiStatus = '异常'; showMessage('题库连接失败', 'red'); log(`题库连接失败: ${error.message}`); updateStatusDisplay(); } } // 更新状态显示 function updateStatusDisplay() { let uiDocument = document; try { if (window.top && window.top.document) { uiDocument = window.top.document; } } catch (e) {} let statusDisplay = uiDocument.getElementById('apiStatusDisplay'); let remainingDisplay = uiDocument.getElementById('remainingQueriesDisplay'); let decryptDisplay = uiDocument.getElementById('decryptStatusDisplay'); if (statusDisplay) { let statusText = apiStatus === '正常' ? '✅ 题库正常' : '❌ 题库异常'; let statusColor = apiStatus === '正常' ? '#4CAF50' : '#f44336'; statusDisplay.innerHTML = `${statusText}`; } if (remainingDisplay) { remainingDisplay.textContent = `剩余次数: ${remainingQueries}`; } if (decryptDisplay) { // 初始化解密功能以获取最新状态 initDecryption(); parsePageFont(); // 确保fontHashParams被正确初始化 if (!fontHashParams) { initDecryption(); } let decryptText = `🔒 解密状态: ${fontLoaded ? '✅ 字体已解析' : '⚠️ 无加密字体'} | 映射表: ${fontHashParams ? '✅ 已加载' : '❌ 未加载'}`; let decryptColor = fontHashParams ? '#28a745' : '#f44336'; decryptDisplay.innerHTML = `${decryptText}`; } } function getAnswer(questionInfo) { return new Promise((resolve, reject) => { // 提取题目文本 let questionText = extractQuestionText(questionInfo); GM_xmlhttpRequest({ method: "POST", url: `${base_url}`, data: JSON.stringify({ question: questionText, apiKey: api_key }), headers: { "Content-Type": "application/json" }, onload: (res) => { try { let data = JSON.parse(res.responseText); if (data.code === 200 && data.data) { let answer = data.data.answer; // 更新剩余次数 if (data.data && data.data.remainingCount !== undefined) { remainingQueries = data.data.remainingCount; updateStatusDisplay(); } resolve(answer); } else { reject(new Error(`题库查询失败: ${data.msg || '未知错误'}`)); } } catch (error) { reject(new Error(`解析答案失败: ${error.message}`)); } }, onerror: () => reject(new Error("题库请求失败")) }); }); } // ==================== 考试自动答题功能 ==================== async function handleExamPage() { log("开始处理考试页面..."); // 等待页面完全加载 await delay(2000); // 检查是否是逐题显示模式（只有一道题可见） let questionSelectors = [ '.questionLi', // 题目列表项 '.Py-mian1', // 题目主容器 '.TiMu', // 题目容器 '[class*="question"]', // 包含question的类 '.exam-question', // 考试题目 '.topic-item' // 题目项 ]; let questions = []; let questionElements = null; // 尝试不同的选择器 for (let selector of questionSelectors) { questionElements = document.querySelectorAll(selector); if (questionElements && questionElements.length > 0) { log(`使用选择器 "${selector}" 找到 ${questionElements.length} 道题目`); questions = Array.from(questionElements); break; } } if (!questions || questions.length === 0) { log("未找到题目，可能页面结构不同或题目尚未加载"); return; } // 如果只有一道题可见，说明是逐题显示模式 if (questions.length === 1) { log("检测到逐题显示模式，开始逐题答题..."); await handleSequentialExam(); return; } // 多题同时显示模式 log(`共找到 ${questions.length} 道题目，开始自动答题...`); for (let i = 0; i < questions.length; i++) { let questionEl = questions[i]; await processExamQuestion(questionEl, i + 1, questions.length); await delay(Math.random() * 1000 + 500); } log("所有题目处理完成"); // 如果启用了自动提交，则提交答案 if (isAutoSubmit) { log("自动提交已启用，准备提交答案..."); await submitExamAnswers(); } else { log("自动提交未启用，请手动检查并提交答案"); } } async function handleSequentialExam() { log("开始逐题答题模式..."); let questionCount = 0; let maxQuestions = 200; // 最大题目数量限制 while (questionCount < maxQuestions) { questionCount++; log(`正在处理第 ${questionCount} 题...`); // 查找当前可见的题目 let questionSelectors = [ '.questionLi', '.Py-mian1', '.TiMu', '[class*="question"]', '.exam-question', '.topic-item' ]; let currentQuestion = null; for (let selector of questionSelectors) { let elements = document.querySelectorAll(selector); if (elements && elements.length === 1) { currentQuestion = elements[0]; break; } } if (!currentQuestion) { log("未找到当前题目，可能已答完所有题目"); break; } // 处理当前题目 await processExamQuestion(currentQuestion, questionCount, '?'); // 等待一下 await delay(Math.random() * 1000 + 800); // 检查是否启用了自动提交 if (!isAutoSubmit) { log("自动提交未启用，停止自动下一题，请手动操作"); break; } // 查找并点击"下一题"按钮 let nextButton = findNextButton(); if (nextButton) { log("点击下一题按钮..."); nextButton.click(); // 等待页面切换 await delay(1500); } else { // 没有下一题按钮，可能是最后一题或需要提交 log("未找到下一题按钮，检查是否需要提交..."); // 查找提交按钮 let submitBtn = findSubmitButton(); if (submitBtn && isAutoSubmit) { log("找到提交按钮，准备提交..."); await submitExamAnswers(); } break; } } log(`逐题答题完成，共处理 ${questionCount} 题`); } function findNextButton() { // 查找"下一题"按钮的各种可能形式 let nextSelectors = [ 'button:contains("下一题")', '.next-btn', '#nextQuestion', '[class*="next"]', 'button:contains("下一")', '.btn-next', 'a:contains("下一题")' ]; // 先尝试通过文本内容查找 let allButtons = document.querySelectorAll('button, a, .btn, [class*="btn"]'); for (let btn of allButtons) { let text = btn.textContent || btn.innerText || ''; text = text.trim(); if (text.includes('下一题') || text.includes('下一') || text === '下一题') { return btn; } } // 再尝试通过选择器查找 for (let selector of nextSelectors) { try { let btn = document.querySelector(selector); if (btn) return btn; } catch (e) { // 某些选择器可能不支持，跳过 } } return null; } function findSubmitButton() { // 查找提交按钮 let submitSelectors = [ '#submitExam', '.btn-submit', '[class*="submit"]', '.exam-submit', 'button:contains("提交")', 'button:contains("交卷")' ]; // 先尝试通过文本内容查找 let allButtons = document.querySelectorAll('button, a, .btn, [class*="btn"]'); for (let btn of allButtons) { let text = btn.textContent || btn.innerText || ''; text = text.trim(); if (text.includes('提交') || text.includes('交卷')) { return btn; } } // 再尝试通过选择器查找 for (let selector of submitSelectors) { try { let btn = document.querySelector(selector); if (btn) return btn; } catch (e) { // 某些选择器可能不支持，跳过 } } return null; } async function processExamQuestion(questionEl, index, total) { try { // 提取题目文本 let questionText = extractQuestionTextFromElement(questionEl); if (!questionText) { log(`第 ${index}/${total} 题: 无法提取题目文本，跳过`); return; } log(`第 ${index}/${total} 题: ${questionText.substring(0, 50)}...`); // 获取题目类型 let questionType = getQuestionType(questionEl); log(`题目类型: ${questionType}`); // 获取选项（只有单选题、多选题、判断题需要选项） let options = []; if (questionType === '单选题' || questionType === '多选题' || questionType === '判断题') { options = extractOptions(questionEl); log(`找到 ${options.length} 个选项: ${options.map(o => `${o.value}:${o.text.substring(0, 10)}`).join(', ')}`); if (options.length === 0) { log(`❌ 第 ${index} 题未找到选项，跳过`); return; } } else { log(`第 ${index} 题是${questionType}，不需要选项`); } // 先检查本地缓存 let answer = getCachedAnswer(questionText, questionType, options); if (answer) { log(`第 ${index} 题命中本地缓存，答案: ${answer}`); } else { // 从API获取答案 try { answer = await getAnswerFromAPI(questionText, questionType, options); if (answer) { log(`第 ${index} 题从API获取答案: ${answer}`); // 缓存答案 setCachedAnswer(questionText, questionType, options, answer); } else { log(`第 ${index} 题未找到答案`); } } catch (error) { log(`第 ${index} 题查询答案失败: ${error.message}`); } } // 如果有答案，自动选择 if (answer) { await selectExamAnswer(questionEl, answer, questionType, options); } else { log(`第 ${index} 题无答案，跳过`); } } catch (error) { log(`处理第 ${index} 题时出错: ${error.message}`); } } function extractQuestionTextFromElement(questionEl) { // 尝试不同的题目文本选择器 let titleSelectors = [ '.Py-m1-title', // 旧版标题 '.question-title', // 新版标题 '.title', // 通用标题 '.topic-title', // 题目标题 '.exam-title', // 考试标题 'h3', 'h4', 'h5', // 标题标签 '.question-stem', // 题干 '.stem', // 题干 '.question-name', // 题目名称 '.name' // 名称 ]; for (let selector of titleSelectors) { let titleEl = questionEl.querySelector(selector); if (titleEl) { let text = titleEl.textContent || titleEl.innerText; // 清理文本 text = text.replace(/^\d+[\.、]/, '').trim(); // 移除题号（如 "1." 或 "1、"） text = text.replace(/$.*?$/g, '').trim(); // 移除括号内容 text = text.replace(/\[.*?\]/g, '').trim(); // 移除标签如 [单选题] text = text.replace(/<[^>]+>/g, ''); // 移除HTML标签 text = text.replace(/\s+/g, ' '); // 合并多个空格 if (text.length > 5) { log(`提取题目文本: ${text.substring(0, 60)}...`); return text; } } } // 如果找不到特定标题，尝试获取整个题目文本（排除选项部分） // 先尝试找题目相关的内容 let questionTexts = []; let allText = questionEl.textContent || questionEl.innerText; if (allText) { // 按行分割 let lines = allText.split('\n').map(line => line.trim()).filter(line => line.length > 0); for (let line of lines) { // 跳过选项行（以A、B、C、D、E、F、G、H开头） if (/^[A-H][\.、\s]/.test(line)) continue; // 跳过纯数字 if (/^\d+$/.test(line)) continue; // 跳过包含"题"、"分"等字样的元信息 if (/$.*题.*$|\[.*题.*\]|单选题|多选题|判断题/.test(line)) { line = line.replace(/$.*?$/g, '').replace(/\[.*?\]/g, ''); } if (line.length > 5 && line.length < 200) { questionTexts.push(line); } } if (questionTexts.length > 0) { let result = questionTexts[0].substring(0, 150); log(`提取题目文本(备选): ${result.substring(0, 60)}...`); return result; } } return ""; } function getQuestionType(questionEl) { // 从题目文本或类名判断题目类型 let text = questionEl.textContent || questionEl.innerText; // 优先从题目头部标签判断 let titleEl = questionEl.querySelector('.title, .question-title, .topic-title, h3, h4, h5, .mark_name, .type_tit'); if (titleEl) { let titleText = titleEl.textContent || titleEl.innerText; if (titleText.includes('单选题') || titleText.includes('单选')) { return '单选题'; } else if (titleText.includes('多选题') || titleText.includes('多选')) { return '多选题'; } else if (titleText.includes('判断题') || titleText.includes('判断')) { return '判断题'; } else if (titleText.includes('填空题') || titleText.includes('填空')) { return '填空题'; } else if (titleText.includes('简答题') || titleText.includes('简答')) { return '简答题'; } else if (titleText.includes('计算题') || titleText.includes('计算')) { return '计算题'; } else if (titleText.includes('名词解释') || titleText.includes('名词')) { return '名词解释'; } else if (titleText.includes('论述题') || titleText.includes('论述')) { return '论述题'; } } // 从整个文本判断 if (text.includes('单选题') || text.includes('单选')) { return '单选题'; } else if (text.includes('多选题') || text.includes('多选')) { return '多选题'; } else if (text.includes('判断题') || text.includes('判断')) { return '判断题'; } else if (text.includes('填空题') || text.includes('填空')) { return '填空题'; } else if (text.includes('简答题') || text.includes('简答')) { return '简答题'; } else if (text.includes('计算题') || text.includes('计算')) { return '计算题'; } else if (text.includes('名词解释') || text.includes('名词')) { return '名词解释'; } else if (text.includes('论述题') || text.includes('论述')) { return '论述题'; } // 尝试从类名或属性判断 if (questionEl.classList.contains('single') || questionEl.getAttribute('data-type') === 'single') { return '单选题'; } else if (questionEl.classList.contains('multiple') || questionEl.getAttribute('data-type') === 'multiple') { return '多选题'; } else if (questionEl.classList.contains('judge') || questionEl.getAttribute('data-type') === 'judge') { return '判断题'; } else if (questionEl.classList.contains('fill') || questionEl.classList.contains('blank') || questionEl.getAttribute('data-type') === 'fill' || questionEl.getAttribute('data-type') === 'blank') { return '填空题'; } // 查找填空输入框（UEditor编辑器） let ueditorTextareas = questionEl.querySelectorAll('textarea[id^="answerEditor"]'); if (ueditorTextareas.length > 0) { // 检查是否有多个输入框（填空题）或一个输入框（简答题等） if (ueditorTextareas.length >= 2) { return '填空题'; } } // 查找普通填空输入框 let fillInputs = questionEl.querySelectorAll('input[type="text"], textarea, .blank-input, .fill-input'); if (fillInputs.length > 0) { // 检查是否有选项，如果没有选项但有输入框，则是填空题 let options = questionEl.querySelectorAll('.answerList li, .option, .answer-item'); if (options.length === 0) { // 根据输入框数量判断是填空题还是简答题 if (fillInputs.length >= 2) { return '填空题'; } else { // 检查是否有大段文本输入区域（简答题） let hasTextarea = false; for (let input of fillInputs) { if (input.tagName === 'TEXTAREA' || input.getAttribute('rows') > 3) { hasTextarea = true; break; } } return hasTextarea ? '简答题' : '填空题'; } } } // 通过选项数量判断 let options = questionEl.querySelectorAll('.answerList li, .option, .answer-item, [class*="option"]'); if (options.length === 2) { // 可能是判断题 let optionTexts = Array.from(options).map(opt => opt.textContent.trim()); if ((optionTexts.includes('对') && optionTexts.includes('错')) || (optionTexts.includes('正确') && optionTexts.includes('错误')) || (optionTexts.includes('√') && optionTexts.includes('×'))) { return '判断题'; } } // 如果没有选项，可能是填空题或简答题 if (options.length === 0) { // 检查是否有输入框 let inputs = questionEl.querySelectorAll('input[type="text"], textarea'); if (inputs.length > 0) { return '填空题'; } return '简答题'; } // 默认单选题 return '单选题'; } function extractOptions(questionEl) { let options = []; let optionSelectors = [ '.answerList li', // 旧版选项 '.option', // 新版选项 '.answer-item', // 答案项 '.topic-option', // 题目选项 '[class*="option"]', // 包含option的类 'li' // 所有li元素（备选） ]; log(`开始提取选项，题目元素: ${questionEl.className || questionEl.tagName}`); for (let selector of optionSelectors) { let optionEls = questionEl.querySelectorAll(selector); log(`选择器 "${selector}" 找到 ${optionEls.length} 个元素`); if (optionEls && optionEls.length > 0) { // 过滤有效的选项（包含A、B、C、D或选项文本） for (let optEl of optionEls) { let text = optEl.textContent || optEl.innerText; text = text.trim(); // 跳过空文本或太短的文本 if (text.length < 1) continue; // 提取选项值（A、B、C、D等） let match = text.match(/^([A-H])[\.、\s]+/i); let value = match ? match[1].toUpperCase() : ''; // 清理选项文本 let cleanText = text.replace(/^([A-H])[\.、\s]+/i, '').trim(); // 只添加有效的选项（必须有选项字母，且清理后的文本有内容） if (value && cleanText.length > 0) { options.push({ element: optEl, text: cleanText, value: value, fullText: text }); log(` 提取选项 ${value}: ${cleanText.substring(0, 20)}`); } } // 如果找到2-8个选项，认为是有效的选项列表 if (options.length >= 2 && options.length <= 8) { log(`✅ 使用选择器 "${selector}" 提取到 ${options.length} 个有效选项`); break; } else { log(`⚠️ 选择器 "${selector}" 找到 ${options.length} 个选项，不符合要求，尝试下一个`); // 否则清空重新尝试下一个选择器 options = []; } } } // 如果上面的选择器都没找到，尝试更通用的方法 if (options.length === 0) { log("尝试使用通用方法提取选项..."); // 查找所有直接子元素li let allLis = questionEl.querySelectorAll(':scope > li, :scope > ul > li, :scope > ol > li'); for (let li of allLis) { let text = li.textContent || li.innerText; text = text.trim(); // 必须以大写字母A-H开头 let match = text.match(/^([A-H])[\.、\s]+(.+)$/i); if (match) { let value = match[1].toUpperCase(); let cleanText = match[2].trim(); if (cleanText.length > 0) { options.push({ element: li, text: cleanText, value: value, fullText: text }); log(` 通用方法提取选项 ${value}: ${cleanText.substring(0, 20)}`); } } } if (options.length >= 2) { log(`✅ 通用方法提取到 ${options.length} 个选项`); } } log(`最终提取到 ${options.length} 个选项: ${options.map(o => o.value).join(',')}`); return options; } async function selectExamAnswer(questionEl, answer, questionType, options) { try { if (questionType === '判断题') { await selectJudgeAnswer(questionEl, answer); } else if (questionType === '多选题') { await selectMultipleAnswer(questionEl, answer, options); } else if (questionType === '填空题') { await selectFillAnswer(questionEl, answer); } else if (questionType === '简答题') { await selectShortAnswer(questionEl, answer); } else { // 单选题 await selectSingleAnswer(questionEl, answer, options); } } catch (error) { log(`选择答案时出错: ${error.message}`); } } async function selectSingleAnswer(questionEl, answer, options) { log(`尝试匹配答案: "${answer}"`); log(`可用选项: ${options.map(o => `"${o.value}:${o.text}"`).join(', ')}`); // 直接使用原始答案匹配，不过滤任何字符 for (let option of options) { // 原始文本匹配 if (option.text === answer || option.text.includes(answer) || answer.includes(option.text)) { await clickOption(option.element); log(`✅ 已选择选项 ${option.value}: ${option.text.substring(0, 30)}`); return; } } // 尝试通过选项字母匹配（支持A-H） let letterMatch = answer.match(/^([A-H])$/i); if (letterMatch) { let letter = letterMatch[1].toUpperCase(); for (let option of options) { if (option.value === letter) { await clickOption(option.element); log(`✅ 已选择选项 ${letter}`); return; } } } // 尝试在完整文本中查找 for (let option of options) { if (option.fullText.includes(answer) || answer.includes(option.fullText)) { await clickOption(option.element); log(`✅ 已选择选项 ${option.value} (完整文本匹配)`); return; } } // 尝试忽略空白字符的匹配 let cleanAnswer = answer.replace(/\s+/g, ''); for (let option of options) { let cleanOption = option.text.replace(/\s+/g, ''); if (cleanOption === cleanAnswer || cleanOption.includes(cleanAnswer) || cleanAnswer.includes(cleanOption)) { await clickOption(option.element); log(`✅ 已选择选项 ${option.value} (去空白匹配)`); return; } } // 尝试查找包含答案文本的选项（备用方案） let optionEls = questionEl.querySelectorAll('.answerList li, .option, .answer-item, .topic-option'); for (let optEl of optionEls) { let text = optEl.textContent || optEl.innerText; if (text.includes(answer) || answer.includes(text.trim())) { await clickOption(optEl); log(`✅ 已选择匹配选项 (备用匹配)`); return; } } log(`❌ 未找到匹配的选项: ${answer}`); } async function selectMultipleAnswer(questionEl, answer, options) { log(`=== 多选题处理 ===`); log(`答案: "${answer}"`); log(`选项数量: ${options.length}`); log(`选项详情: ${options.map(o => `${o.value}:${o.text.substring(0, 15)}`).join(', ')}`); if (options.length === 0) { log(`❌ 没有可用选项，无法选择`); return; } // 多选题可能有多个答案，用逗号、空格、##或|分隔 let answers = answer.split(/[,，\s]+|##|\|/).filter(a => a.trim()); log(`分割后的答案: ${answers.join(', ')}`); for (let ans of answers) { ans = ans.trim(); if (!ans) continue; log(`正在匹配答案: "${ans}"`); let found = false; // 1. 直接文本匹配 for (let option of options) { log(` 尝试匹配选项 ${option.value}: "${option.text.substring(0, 20)}"`); if (option.text === ans || option.text.includes(ans) || ans.includes(option.text)) { await clickOption(option.element); log(`✅ 多选题已选择: ${option.value}`); found = true; break; } } // 2. 尝试通过选项字母匹配（支持A-H） if (!found) { let letterMatch = ans.match(/^([A-H])$/i); if (letterMatch) { let letter = letterMatch[1].toUpperCase(); log(` 尝试字母匹配: ${letter}`); for (let option of options) { if (option.value === letter) { await clickOption(option.element); log(`✅ 多选题已选择: ${letter}`); found = true; break; } } } } // 3. 尝试完整文本匹配 if (!found) { log(` 尝试完整文本匹配`); for (let option of options) { if (option.fullText.includes(ans) || ans.includes(option.fullText)) { await clickOption(option.element); log(`✅ 多选题已选择(完整文本): ${option.value}`); found = true; break; } } } // 4. 尝试去空白匹配 if (!found) { log(` 尝试去空白匹配`); let cleanAns = ans.replace(/\s+/g, ''); for (let option of options) { let cleanOption = option.text.replace(/\s+/g, ''); if (cleanOption === cleanAns || cleanOption.includes(cleanAns) || cleanAns.includes(cleanOption)) { await clickOption(option.element); log(`✅ 多选题已选择(去空白): ${option.value}`); found = true; break; } } } if (!found) { log(`❌ 多选题未找到匹配选项: "${ans}"`); } } log(`=== 多选题处理结束 ===`); } // 填空题处理 - 参考oksouti.js实现 async function selectFillAnswer(questionEl, answer) { log(`=== 填空题处理 ===`); log(`答案: "${answer}"`); // 分割答案 let answerList = answer.split(/##|#/).map(a => a.trim()).filter(a => a); if (answerList.length === 0) { answerList = [answer]; } log(`分割后的答案: ${JSON.stringify(answerList)}`); // 查找所有textarea（使用oksouti.js的选择器） let textareas = questionEl.querySelectorAll('textarea[id^="answerEditor"], .eidtDiv textarea, .divText textarea, .subEditor textarea'); if (textareas.length === 0) { log(`❌ 未找到UEditor编辑器`); return; } log(`找到 ${textareas.length} 个输入框`); // 逐个填写 for (let i = 0; i < textareas.length; i++) { let textarea = textareas[i]; let ans = answerList[i] || answerList[0] || ''; if (!ans) { log(`⚠️ 第 ${i + 1} 空无答案`); continue; } let editorId = textarea.id; log(`开始填写第 ${i + 1} 空，答案: "${ans}"，editorId: ${editorId}`); // 延迟填写，参考oksouti.js setTimeout(() => { fillBlankInput(editorId, ans, i); }, i * 300 + 500); } log(`=== 填空题处理结束 ===`); } // 填写单个填空输入框 - 参考oksouti.js实现 function fillBlankInput(editorId, ans, index) { log(` [延迟执行] 填写第 ${index + 1} 空: ${ans}`); // 方法1: 从 UE.instants 获取（最可靠） if (window.UE && UE.instants) { try { let instantKey = 'ueditorInstant' + index; let editor = UE.instants[instantKey]; if (editor && editor.setContent) { editor.setContent(ans); log(`✅ 第 ${index + 1} 空使用UE.instants['${instantKey}']填写成功`); return; } } catch (e) { log(` UE.instants 失败: ${e.message}`); } } // 方法2: 使用UEditor API if (window.UE && UE.getEditor) { try { let editor = UE.getEditor(editorId); if (editor && editor.setContent) { editor.setContent(ans); log(`✅ 第 ${index + 1} 空使用UE.getEditor填写成功`); return; } } catch (e) { log(` UE.getEditor 失败: ${e.message}`); } } // 方法3: 直接操作iframe的body try { let iframe = document.getElementById('ueditor_' + index); if (iframe && iframe.contentDocument && iframe.contentDocument.body) { let body = iframe.contentDocument.body; body.innerHTML = '

' + ans + '

'; log(`✅ 第 ${index + 1} 空使用iframe body填写成功`); // 同时更新textarea let textarea = document.getElementById(editorId); if (textarea) { textarea.value = ans; } return; } } catch (e) { log(` iframe操作失败: ${e.message}`); } // 方法4: 直接操作textarea let textarea = document.getElementById(editorId); if (textarea) { textarea.value = ans; textarea.dispatchEvent(new Event('input', { bubbles: true })); textarea.dispatchEvent(new Event('change', { bubbles: true })); log(`✅ 第 ${index + 1} 空使用textarea填写成功`); return; } log(`❌ 第 ${index + 1} 空填写失败`); } // 简答题处理 - 参考oksouti.js实现 async function selectShortAnswer(questionEl, answer) { log(`=== 简答题处理 ===`); log(`答案: "${answer.substring(0, 50)}..."`); // 查找文本域（使用oksouti.js的选择器） let textarea = questionEl.querySelector('textarea[name^="answerEditor"], .eidtDiv textarea, .divText textarea, textarea'); if (!textarea) { log(`❌ 未找到简答题输入框`); return; } let editorId = textarea.id; log(`找到简答题输入框，editorId: ${editorId}`); // 延迟填写，等待UEditor初始化 setTimeout(() => { fillShortAnswerInput(editorId, answer); }, 500); log(`=== 简答题处理结束 ===`); } // 填写简答题输入框 function fillShortAnswerInput(editorId, answer) { log(` [延迟执行] 填写简答题答案`); // 方法1: 从 UE.instants 获取（索引0，因为简答题通常只有一个编辑器） if (window.UE && UE.instants) { try { let editor = UE.instants['ueditorInstant0']; if (editor && editor.setContent) { editor.setContent(answer); log(`✅ 简答题使用UE.instants['ueditorInstant0']填写成功`); return; } } catch (e) { log(` UE.instants 失败: ${e.message}`); } } // 方法2: 使用UEditor API if (window.UE && UE.getEditor) { try { let editor = UE.getEditor(editorId); if (editor && editor.setContent) { editor.setContent(answer); log(`✅ 简答题使用UE.getEditor填写成功`); return; } } catch (e) { log(` UE.getEditor 失败: ${e.message}`); } } // 方法3: 直接操作iframe的body try { let iframe = document.getElementById('ueditor_0'); if (iframe && iframe.contentDocument && iframe.contentDocument.body) { let body = iframe.contentDocument.body; body.innerHTML = '

' + answer + '

'; log(`✅ 简答题使用iframe body填写成功`); // 同时更新textarea let textarea = document.getElementById(editorId); if (textarea) { textarea.value = answer; } return; } } catch (e) { log(` iframe操作失败: ${e.message}`); } // 方法4: 直接操作textarea let textarea = document.getElementById(editorId); if (textarea) { textarea.value = answer; textarea.dispatchEvent(new Event('input', { bubbles: true })); textarea.dispatchEvent(new Event('change', { bubbles: true })); log(`✅ 简答题使用textarea填写成功`); return; } log(`❌ 简答题填写失败`); } async function selectJudgeAnswer(questionEl, answer) { log(`=== 判断题处理 ===`); log(`答案: "${answer}"`); let isTrue = /对|正确|是|√|true|正确/i.test(answer); let isFalse = /错|错误|否|×|false|错误/i.test(answer); log(`判断结果: isTrue=${isTrue}, isFalse=${isFalse}`); // 尝试多种选择器查找选项 let selectors = [ 'li', '.option', '.answer-item', '.topic-option', 'label', '.radio', '[class*="option"]', 'input[type="radio"]', '.answerList li' ]; let optionEls = []; for (let selector of selectors) { let els = questionEl.querySelectorAll(selector); if (els.length >= 2) { log(`使用选择器 "${selector}" 找到 ${els.length} 个选项`); optionEls = els; break; } } if (optionEls.length === 0) { log(`❌ 未找到判断题选项`); return; } // 打印所有找到的选项文本 log(`判断题选项:`); for (let i = 0; i < optionEls.length; i++) { let text = optionEls[i].textContent || optionEls[i].innerText || ''; log(` ${i}: "${text.trim()}"`); } for (let optEl of optionEls) { let text = optEl.textContent || optEl.innerText; text = text.trim(); if (isTrue && /对|正确|是|√|A/i.test(text)) { await clickOption(optEl); log(`✅ 判断题已选择: 正确 (匹配文本: "${text}")`); return; } else if (isFalse && /错|错误|否|×|B/i.test(text)) { await clickOption(optEl); log(`✅ 判断题已选择: 错误 (匹配文本: "${text}")`); return; } } // 如果通过文本没找到，尝试通过位置选择（第一个通常是正确，第二个是错误） if (isTrue && optionEls.length > 0) { await clickOption(optionEls[0]); log(`✅ 判断题已选择: 正确 (默认第一个选项)`); return; } else if (isFalse && optionEls.length > 1) { await clickOption(optionEls[1]); log(`✅ 判断题已选择: 错误 (默认第二个选项)`); return; } log(`❌ 判断题未找到匹配选项: ${answer}`); log(`=== 判断题处理结束 ===`); } async function clickOption(optionEl) { // 模拟点击选项 if (optionEl) { // 尝试多种点击方式 try { optionEl.click(); } catch (e) { try { let event = new MouseEvent('click', { bubbles: true, cancelable: true, view: window }); optionEl.dispatchEvent(event); } catch (e2) { // 如果都失败，尝试直接触发元素的onclick if (optionEl.onclick) { optionEl.onclick(); } } } await delay(200); } } async function submitExamAnswers() { await delay(2000); // 使用findSubmitButton查找提交按钮 let submitBtn = findSubmitButton(); if (submitBtn) { log("找到提交按钮，准备提交..."); submitBtn.click(); await delay(1000); // 处理确认弹窗 let confirmBtn = document.querySelector('.btn-confirm, .confirm-btn, .popok, #popok, [class*="confirm"]'); if (confirmBtn) { confirmBtn.click(); log("已确认提交"); } } else { log("未找到提交按钮，请手动提交"); } } function extractQuestionText(questionInfo) { // 这里需要根据实际情况提取题目文本 // 暂时返回空字符串，需要根据具体实现来完善 return ""; } async function submitAnswers() { await delay(2000); let popok = window.top.document.querySelector('#popok'); if (popok) { popok.click(); } } function versionDetection() { // 版本检测功能已移除 log("版本检测功能已禁用"); } function delay(ms) { return new Promise(resolve => setTimeout(resolve, ms)); } })();