diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2aa33f9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.vscode +.idea +**/__pycache__ +**/*.log \ No newline at end of file diff --git a/.idea/JS_Crack.iml b/.idea/JS_Crack.iml index 7c9d48f..cb351b6 100644 --- a/.idea/JS_Crack.iml +++ b/.idea/JS_Crack.iml @@ -1,7 +1,9 @@ - + + + diff --git a/.idea/deployment.xml b/.idea/deployment.xml new file mode 100644 index 0000000..5632da6 --- /dev/null +++ b/.idea/deployment.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/Project_Default.xml b/.idea/inspectionProfiles/Project_Default.xml new file mode 100644 index 0000000..49c79fe --- /dev/null +++ b/.idea/inspectionProfiles/Project_Default.xml @@ -0,0 +1,19 @@ + + + + \ No newline at end of file diff --git a/ahsxx/ahsxx.py b/ahsxx/ahsxx.py new file mode 100644 index 0000000..a6f04d8 --- /dev/null +++ b/ahsxx/ahsxx.py @@ -0,0 +1,45 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +# @Time : 2020/6/8 11:23 +# @Author : Oscar +import json +import random +import execjs +import pprint +import requests + +# http://yc.wswj.net/ahsxx/LOL/public/public.html + +waterData = { + "name": "GetSwInfo", + "time": "202006081126", + "fresh": 0, + "waterEncode": "true" +} + +with open("ahsxx_encode.js", "r", encoding="utf-8") as f: + ctx = execjs.compile(f.read()) + +for key, value in waterData.items(): + waterData[key] = ctx.call("waterEncode", value) + +waterData["random"] = random.random() + +# print(waterData) + +# url = "http://61.191.22.196:5566/ahsxx/cmgp/zqc-CMGP.ashx" +url = "http://yc.wswj.net/ahsxx/service/PublicBusinessHandler.ashx" +headers = { + "User-Agent": "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.70 Safari/537.36", +} + +response = requests.post(url, headers=headers, data=waterData) + +data_json = response.text +print(data_json) + +# content = "2.1jZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCJmaWxlUGF0aFwiOlwi5LiJ57qn5rKz5rWBLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLkuInnuqfmsrPmtYEueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIxXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiaHVwbzFcIixcclxuXHRcdFwibGFiZWxcIjpcIuS4gOe6p+a5luazilwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjZcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIxXCIsXHJcblx0XHRcInpvb21cIjpcIjFcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLkuIDnuqfmuZbms4oueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuS4gOe6p+a5luazii54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjFcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjQkNFM0Y5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiaHVwbzJcIixcclxuXHRcdFwibGFiZWxcIjpcIuS6jOe6p+a5luazilwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjZcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIxXCIsXHJcblx0XHRcInpvb21cIjpcIjFcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLkuoznuqfmuZbms4oueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuS6jOe6p+a5luazii54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjFcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjQkNFM0Y5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiaHVwbzFOYW1l*hgk8memRraDt5Jnlka2g7LyZ6ZGtoO3gmeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJBSFNMX1lYQlpcIixcclxuXHRcdFwibGFiZWxcIjpcIumrmOa4heW9seWDj+agh+azqFwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlRpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiV01UU1wiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vMTAuMzQuMC4xMjo2MDgwL2FyY2dpcy9yZXN0L3NlcnZpY2VzL0FIWVhfWkgwNzE3L01hcFNlcnZlci9XTVRTLzEuMC4wL1dNVFNDYXBhYmlsaXRpZXMueG1sXCIsXHJcblx0XHRcIm9nY1BhcmFtXCI6XCImemRraDtsYXllcjoma2c7JmR5aDtBSFlYX1pIMDcxNyZkeWg7JmRoOyZrZzttYXRyaXhTZXQ6JmtnOyZkeWg7ZGVmYXVsdDAyOG1tJmR5aDsma2c7Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlronlvr3msLTliKnlnLDlvaLlm75cIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJBSFNMX0RYXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXlnLDlvaJcIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjVcIixcclxuXHRcdFwidHlwZVwiOlwiVGlsZVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJYWVpcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovLzEwLjM0LjAuMTI6NjA4MC9hcmNnaXMvcmVzdC9zZXJ2aWNlcy9BSFNMX0RYL01hcFNlcnZlci90aWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiQUhTTF9EWEJaXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXlnLDlvaLmoIfms6hcIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIldNVFNcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDoQ*uimxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vMTAuMzQuMC4xMjo2MDgwL2FyY2dpcy9yZXN0L3NlcnZpY2VzL0FIU0xfWkgwNzE3L01hcFNlcnZlci90aWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlronlvr3msLTliKnlvbHlg4/lm75cIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJBSFNMX1lYXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXlvbHlg49cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjVcIixcclxuXHRcdFwidHlwZVwiOlwiVGlsZVwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwiem9vbU1heFwiOlwiOVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJYWVpcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovLzEwLjM0LjAuMTI6NjA4MC9hcmNnaXMvcmVzdC9zZXJ2aWNlcy9BSFNMSU1HL01hcFNlcnZlci90aWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiQUhTTF9ZWEhEXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXlvbHlg49IRFwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjlcIixcclxuXHRcdFwiem9vbVwiOlwiOVwiLFxyXG5cdFx0XCJ6b29tTWF4XCI6XCIxMFwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJYWVpcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovLzEwLjM0LjAuMTI6NjA4MC9hcmNnaXMvcmVzdC9zZXJ2aWNlcy9BSFNMSU1HMDUvTWFwU2VydmVyL3RpbGUvJnpka2g7eiZ5ZGtoOyuv*AXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vdDMudGlhbmRpdHUuY29tL0RhdGFTZXJ2ZXI/dGsmZGgxOzcyZWFiODZmMjg3YTIxZTdlNGI1MTZjOTQ3OTI0MmY1JlQmZGgxO3Rlcl93JngmZGgxOyZ6ZGtoO3gmeWRraDsmeSZkaDE7Jnpka2g7eSZ5ZGtoOyZsJmRoMTsmemRraDt6Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiVERUX0JaXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKnlnLDlm77nn6Lph4/ms6jorrDmlbDmja5cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vdDMudGlhbmRpdHUuY29tL0RhdGFTZXJ2ZXI/dGsmZGgxOzcyZWFiODZmMjg3YTIxZTdlNGI1MTZjOTQ3OTI0MmY1JlQmZGgxO2N2YV93JngmZGgxOyZ6ZGtoO3gmeWRraDsmeSZkaDE7Jnpka2g7eSZ5ZGtoOyZsJmRoMTsmemRraDt6Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiVERUX0JKXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKnlnLDlm77ovrnnlYzmlbDmja5cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vdDMudGlhbmRpdHUuY29tL0RhdGFTZXJ2ZXI/dGsmZGgxOzcyZWFiODZmMjg3YTIxZTdlNGI1MTZjOTQ3OTI0MmY1JlQmZGgxO2lib193JngmZGgxOyZ6ZGtoO3gmeWRraDsmeSZkaDE7Jnpka2g7eSZ5ZGtoOyZsJmRoMTsmemRraDt6Jnlka2g7XCJcdFxyXG5cdCAgIH1cclxuXHQgIF1cclxufSJ9LHsianNvbiI6IntcclxuXHRcIm5hbWVcIjpcIuWuieW+veawtOWIqeefoumHj+WbvlwiLFxyXG5cdFwic2FtcGxlXCI6XCJodHRwOi8vMTAuMzQuMS4yNS9haHN4eC9sb2wveWMveWMuaHRtbFwiLFxyXG5cdFwiY2VudGVyXCI6XCIxMTcuMjksMzIuMDU4MVwiLFxyXG5cdFwiYm91bmRcIjpcIjcxLjgyODAzMywgNC4wNTMyMDUsIDEzNC45NTkyMDUsIDU3Ljc4NDkxNlwiLFxyXG5cdFwibGF5ZXJzXCI6IFtcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcIkFIU0xfU0xcIixcclxuXHRcdFwibGFiZWxcIjpcIumrmOa4heefoumHj+WbvlwiLFxyXG5cdFx0XCJ2aXNpY*HDlNLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCJHUV9NLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMC4xXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwiZ3JpZFwiLFxyXG5cdFx0XCJmaWxsQ29sb3JcIjpcIiNmZmZmZmZcIixcclxuXHRcdFwibGluZUFscGhhXCI6XCIxXCIsXHJcblx0XHRcImFscGhhTGluZVwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lQ29sb3JcIjpcIiM3N0JCRkZcIixcclxuXHRcdFwibGluZVdpZHRoXCI6XCIxXCIsXHJcblx0XHRcImxpbmVTaXplXCI6XCIxXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJ3cVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5Zyp5Yy6XCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJ3cS54bWxcIixcclxuXHRcdFwicGF0aFwiOlwid3EueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIwLjNcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjOTk2Njk5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwieGhxXCIsXHJcblx0XHRcImxhYmVsXCI6XCLooYzok4TmtKrljLpcIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJQb2x5Z29uXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjBcIixcclxuXHRcdFwiem9vbVwiOlwiMFwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuihjOiThOa0quWMui54bWxcIixcclxuXHRcdFwicGF0aFwiOlwi6KGM6JOE5rSq5Yy6LnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMC4zXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwic2luZ2xlXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiIzk5MzMzM1wiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzk5MDAwMFwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInhocV9OYW1lXCIsXHJcblx0XHRcImxhYmVsXCI6XCLooYzok4TmtKrljLrlkI3np7BcIixcclxuXHRcdFwidmlzaWJsZVwix*quHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJkc2pMaW5lLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCJkc2pMaW5lLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMC44XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjODk1N2ExXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiZHNqXCIsXHJcblx0XHRcImxhYmVsXCI6XCLluILpnaJcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIyXCIsXHJcblx0XHRcInpvb21cIjpcIjJcIixcclxuXHRcdFwiem9vbU1heFwiOlwiMTBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLlnLDluIIueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuWcsOW4gi54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjAuN1wiLFxyXG5cdFx0XCJjb2xvclR5cGVcIjpcImZlYXR1cmVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjY2M2NjAwXCIsXHJcblx0XHRcImNvbG9yRmVhdHVyZVwiOlwi5ZCI6IKl5biCI0QzRkZCRTvmt67ljJfluIIjQkRGQ0IzO+S6s+W3nuW4giNGQ0NEQkI75a6/5bee5biCI0JERkNFMjvpmJzpmLPluIIjQzBEREZDO+iajOWfoOW4giNFQUZDRDc75reu5Y2X5biCI0ZGRkZCRTvmu4Hlt57luIIjRkNDQUQxO+WFreWuieW4giNGQ0Q0RUY75bei5rmW5biCI0VCQ0FGQzvoipzmuZbluIIjRDdGNkZDO+mprOmejeWxseW4giNGQ0YzQkQ75a6J5bqG5biCI0RGRkNCMzvmsaDlt57luIIjQzdGQ0NBO+mTnOmZteW4giNGQ0I4RDk75a6j5Z+O5biCI0IzRkNGQzvpu4TlsbHluIIjQzNCREZDXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjQzBDMEMwXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiZnp4XCIsXHJcblx0XHRcImxhYmVsXCI6XCLliIbkuK3lv4NcIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJQb2x5Z29uXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjJcIixcclxuXHRcdFwiem9vbVwiOlwiMlwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuWIhuS4reW/gy54bWxcIixcclxuXHRcdFwicGF0aFwiOlwi5YiG5Lit5b*QeFIjpcIiZ6ZGtoOyZkeWg7TEFZRVJTJmR5aDs6JmtnOyZkeWg7MSZkaDsyJmRoOzMmZHloOyZkaDsmZHloO1RJTEVEJmR5aDs6JmtnO2ZhbHNlJnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwieWpqaExheWVyMVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5byV5rGf5rWO5reu5LiT6aKY5Zu+MVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNFwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIldNU1wiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vNjAuMTc0LjIwMy4xMTg6NjA4MC9hcmNnaXMvc2VydmljZXMveWluamlhbmdqaWh1YWkvYW5odWl5aW5qaWFuZ2ppaHVhaS9NYXBTZXJ2ZXIvV01TU2VydmVyP1wiLFxyXG5cdFx0XCJvZ2NQYXJhbVwiOlwiJnpka2g7JmR5aDtMQVlFUlMmZHloOzoma2c7JmR5aDswJmR5aDsmZGg7JmR5aDtUSUxFRCZkeWg7OiZrZztmYWxzZSZ5ZGtoO1wiLFxyXG5cdFx0XCJsYXllclR5cGVcIjpcImJhc2VcIixcclxuXHRcdFwiYWxwaGFcIjpcIjAuNVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiWlRfMjAxOFRGXCIsXHJcblx0XHRcImxhYmVsXCI6XCIyMDE45bm0OOaciDE55pel5Y+w6aOO5b2x5ZON5re55rKh6IyD5Zu0XCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwiemluZGV4XCI6XCI4XCIsXHJcblx0XHRcInR5cGVcIjpcIlRpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiV01TXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly82MC4xNzQuMjAzLjExODo2MDgwL2FyY2dpcy9zZXJ2aWNlcy8yMDE4MDgxOS8yMDE4MDgxOXltZncvTWFwU2VydmVyL1dNU1NlcnZlcj9cIixcclxuXHRcdFwib2djUGFyYW1cIjpcIiZ6ZGtoOyZkeWg7TEFZRVJTJmR5aDs6JmtnOyZkeWg7MCZkeWg7JmRoOyZkeWg7VElMRUQmZHloOzoma2c7ZmFsc2UmeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCIsXHJcblx0XHRcImFscGhhXCI6XCIwLjlcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInFkTGF5ZXJcIixcclxuXHRcdFwibGFiZWxcIjpcIua4oOmBk1wiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiM1wiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjBcIixcclxuXHRcdFwiem9vbVwiOlwiMFwiLFxyXG5cdFx0XCJ6b29tTWF4XCI6XCIxMFwiLFxyXG5cdFx0XCJzbf*BywiOlwiTGluZVwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIyXCIsXHJcblx0XHRcInpvb21cIjpcIjJcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLkuoznuqfmsrPmtYEueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuS6jOe6p+ays+a1gS54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjFcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjQkNFM0Y5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiUml2ZXIyTmFtZVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5LqM57qn5rKz5rWB5ZCNXCIsXHJcblx0XHRcInZpc2libGVcIjpcInRydWVcIixcclxuXHRcdFwidmlzYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInR5cGVcIjpcIlBvaW50XCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjNcIixcclxuXHRcdFwiem9vbVwiOlwiM1wiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuS6jOe6p+ays+a1gV9OYW1lLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLkuoznuqfmsrPmtYFfTmFtZS54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjBcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjRkYwMDAwXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjBcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcInJvdGF0aW9uXCI6XCIwXCIsXHJcblx0XHRcInRleHRBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYVRleHRcIjpcIjFcIixcclxuXHRcdFwidGV4dENvbG9yXCI6XCIjOTkwMDAwXCIsXHJcblx0XHRcInRleHRGb250XCI6XCLlrovkvZNcIixcclxuXHRcdFwidGV4dFdlaWdodFwiOlwibm9ybWFsXCIsXHJcblx0XHRcInRleHRTaXplXCI6XCIxM1wiLFxyXG5cdFx0XCJzeW1ib2xSYWRpdXNcIjpcIjVcIixcclxuXHRcdFwic2hkb3dBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJzaGFkb3dDb2xvclwiOlwiIzAwMDBmZlwiLFxyXG5cdFx0XCJzaGRvd1dpZHRoXCI6XCIzXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJSaXZlcjNQXCIsXHJcblx0XHRcImxhYmVsXCI6XCLkuInnuqfmsrPmtYFcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwiemluZGV4XCI6XCI2XCIsXHJcblx0XHRcInR5cGVcIjpcIkxpbmVcIixcclxuXHRcdFwiem9vbU1pblwiOlwiM1wiLFxyXG5cdFx0XCJ6b29tXCI6XCIzXCIsXHJcblx0XHRcInNvdXJLj*wOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJQb2ludFwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIyXCIsXHJcblx0XHRcInpvb21cIjpcIjJcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLooYzok4TmtKrljLrlkI3np7AueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuihjOiThOa0quWMuuWQjeensC54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjBcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjRkYwMDAwXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjBcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcInJvdGF0aW9uXCI6XCIwXCIsXHJcblx0XHRcInRleHRBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYVRleHRcIjpcIjFcIixcclxuXHRcdFwidGV4dENvbG9yXCI6XCIjOTkwMDAwXCIsXHJcblx0XHRcInRleHRGb250XCI6XCLlrovkvZNcIixcclxuXHRcdFwidGV4dFdlaWdodFwiOlwibm9ybWFsXCIsXHJcblx0XHRcInRleHRTaXplXCI6XCIxM1wiLFxyXG5cdFx0XCJzeW1ib2xSYWRpdXNcIjpcIjVcIixcclxuXHRcdFwic2hkb3dBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJzaGFkb3dDb2xvclwiOlwiIzAwMDBmZlwiLFxyXG5cdFx0XCJzaGRvd1dpZHRoXCI6XCIzXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJSaXZlcl9NYWluXCIsXHJcblx0XHRcImxhYmVsXCI6XCLmsrPmtYHpnaJcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwiemluZGV4XCI6XCI2XCIsXHJcblx0XHRcInR5cGVcIjpcIlBvbHlnb25cIixcclxuXHRcdFwiem9vbU1pblwiOlwiMFwiLFxyXG5cdFx0XCJ6b29tXCI6XCIwXCIsXHJcblx0XHRcInNvdXJjZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCJmaWxlUGF0aFwiOlwi5Li76KaB5rKz5rWBLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLkuLvopoHmsrPmtYEueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIxXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwic2luZ2xlXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiI0JDRTNGOVwiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzc3QkJGRlwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcIlJpdmVyMVBcIixcclxuXHRcdFwibGFiZWxcIjpcIuS4gOe6p+ays+a1gVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwidHJ1ZVwiLFxyXp*EeG5cdFx0XCJ6aW5kZXhcIjpcIjZcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIyXCIsXHJcblx0XHRcInpvb21cIjpcIjJcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLkuIDnuqfmsrPmtYEueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuS4gOe6p+ays+a1gS54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjFcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjQkNFM0Y5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiUml2ZXIxTmFtZVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5LiA57qn5rKz5rWB5ZCNXCIsXHJcblx0XHRcInZpc2libGVcIjpcInRydWVcIixcclxuXHRcdFwidmlzYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInR5cGVcIjpcIlBvaW50XCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjJcIixcclxuXHRcdFwiem9vbVwiOlwiMlwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuS4gOe6p+ays+a1gV9OYW1lLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLkuIDnuqfmsrPmtYFfTmFtZS54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjBcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjRkYwMDAwXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjBcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcInRleHRBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYVRleHRcIjpcIjFcIixcclxuXHRcdFwidGV4dENvbG9yXCI6XCIjOTkwMDAwXCIsXHJcblx0XHRcInRleHRGb250XCI6XCLlrovkvZNcIixcclxuXHRcdFwidGV4dFdlaWdodFwiOlwibm9ybWFsXCIsXHJcblx0XHRcInRleHRTaXplXCI6XCIxM1wiLFxyXG5cdFx0XCJ0ZXh0T2Zmc2V0WFwiOlwiMFwiLFxyXG5cdFx0XCJ0ZXh0T2Zmc2V0WVwiOlwiMTBcIixcclxuXHRcdFwic3ltYm9sVHlwZVwiOlwibm9uZVwiLFxyXG5cdFx0XCJzaGRvd0FscGhhXCI6XCIwXCIsXHJcblx0XHRcInNoYWRvd0NvbG9yXCI6XCIjMDAwMGZmXCIsXHJcblx0XHRcInNoZG93V2lkdGhcIjpcIjNcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcIlJpdmVyMlBcIixcclxuXHRcdFwibGFiZWxcIjpcIuS6jOe6p+ays+a1gVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjZcIixcclxuXHRcdFwidHlwZVms*JHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwiemluZGV4XCI6XCI2XCIsXHJcblx0XHRcInR5cGVcIjpcIlBvbHlnb25cIixcclxuXHRcdFwiem9vbU1pblwiOlwiMVwiLFxyXG5cdFx0XCJ6b29tXCI6XCIxXCIsXHJcblx0XHRcInNvdXJjZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCJmaWxlUGF0aFwiOlwi5aSn5Z6L5rC05bqTLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLlpKflnovmsLTlupMueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIxXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwic2luZ2xlXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiI0JDRTNGOVwiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzc3QkJGRlwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInNodWlrdU1haW5OYW1lXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKflnovmsLTlupPlkI3np7BcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwidHlwZVwiOlwiUG9pbnRcIixcclxuXHRcdFwiem9vbU1pblwiOlwiMlwiLFxyXG5cdFx0XCJ6b29tXCI6XCIyXCIsXHJcblx0XHRcInNvdXJjZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCJmaWxlUGF0aFwiOlwi5aSn5Z6L5rC05bqT5ZCN56ewLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLlpKflnovmsLTlupPlkI3np7AueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIwXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiI0ZGMDAwMFwiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjBcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIwXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzc3QkJGRlwiLFxyXG5cdFx0XCJ0ZXh0Q29sb3JcIjpcIiM5OTAwMDBcIixcclxuXHRcdFwidGV4dEZvbnRcIjpcIuWui+S9k1wiLFxyXG5cdFx0XCJ0ZXh0U2l6ZVwiOlwiMTNcIixcclxuXHRcdFwic3ltYm9sUmFkaXVzXCI6XCI1XCIsXHJcblx0XHRcInNoZG93QWxwaGFcIjpcIjBcIixcclxuXHRcdFwic2hhZG93Q29sb3JcIjpcIiMwMDAwZmZcIixcclxuXHRcdFwic2hkb3dXaWR0aFwiOlwiM1wiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwic2h1aWt1X01pZFwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5Lit5Z6L5rC05bqTXCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwiemluZGV4XCI6XCI2XCIsXHJcblx0XHRcInR5cGVcIjpcIlBvbHlnb25cIixcclxuXHRcdFwiem9vbU1pblwiOlwiMVwiLFxyXG5cdFx0XCJ6b29tXCI6XCIxXCIsXHJcblx0XHRcInNvdXJjZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCQZN*XCIsXHJcblx0XHRcImxhYmVsXCI6XCLkuIDnuqfmuZbms4rlkI1cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJQb2ludFwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIyXCIsXHJcblx0XHRcInpvb21cIjpcIjJcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCLkuIDnuqfmuZbms4rlkI3np7AueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcIuS4gOe6p+a5luaziuWQjeensC54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjBcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjRkYwMDAwXCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjBcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjNzdCQkZGXCIsXHJcblx0XHRcInRleHRDb2xvclwiOlwiIzk5MDAwMFwiLFxyXG5cdFx0XCJ0ZXh0Rm9udFwiOlwi5a6L5L2TXCIsXHJcblx0XHRcInRleHRTaXplXCI6XCIxM1wiLFxyXG5cdFx0XCJzeW1ib2xSYWRpdXNcIjpcIjVcIixcclxuXHRcdFwic2hkb3dBbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJzaGFkb3dDb2xvclwiOlwiIzAwMDBmZlwiLFxyXG5cdFx0XCJzaGRvd1dpZHRoXCI6XCIzXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJodXBvMk5hbWVcIixcclxuXHRcdFwibGFiZWxcIjpcIuS6jOe6p+a5luaziuWQjVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlBvaW50XCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjJcIixcclxuXHRcdFwiem9vbVwiOlwiMlwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuS6jOe6p+a5luaziuWQjeensC54bWxcIixcclxuXHRcdFwicGF0aFwiOlwi5LqM57qn5rmW5rOK5ZCN56ewLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJmaWxsQ29sb3JcIjpcIiNGRjAwMDBcIixcclxuXHRcdFwibGluZUFscGhhXCI6XCIwXCIsXHJcblx0XHRcImFscGhhTGluZVwiOlwiMFwiLFxyXG5cdFx0XCJsaW5lQ29sb3JcIjpcIiM3N0JCRkZcIixcclxuXHRcdFwidGV4dENvbG9yXCI6XCIjOTkwMDAwXCIsXHJcblx0XHRcInRleHRGb250XCI6XCLlrovkvZNcIixcclxuXHRcdFwidGV4dFNpemVcIjpcIjEzXCIsXHJcblx0XHRcInN5bWJvbFJhZGl1c1wiOlwiNVwiLFxyXG5cdFx0XCJzaGRvd0FscGhhXCI6XCIwXCIsXHJcblx0XHRcInNoYWRvd0NvbG9yXCI6XCIjMDAwMGZmXCIsXHJcblx0XHRcInNoZG93V2lkdGhcIjpcIjNcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInNodWlrdV9NYWluXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKflnovmsLTlupNcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidfO*Vh0dHA6Ly90NC50aWFuZGl0dS5jb20vRGF0YVNlcnZlcj90ayZkaDE7NzJlYWI4NmYyODdhMjFlN2U0YjUxNmM5NDc5MjQyZjUmVCZkaDE7dmVjX3cmeCZkaDE7Jnpka2g7eCZ5ZGtoOyZ5JmRoMTsmemRraDt5Jnlka2g7JmwmZGgxOyZ6ZGtoO3omeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJURFRfQlpcIixcclxuXHRcdFwibGFiZWxcIjpcIuWkqeWcsOWbvuefoumHj+azqOiusOaVsOaNrlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiMVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vdDMudGlhbmRpdHUuY29tL0RhdGFTZXJ2ZXI/dGsmZGgxOzcyZWFiODZmMjg3YTIxZTdlNGI1MTZjOTQ3OTI0MmY1JlQmZGgxO2N2YV93JngmZGgxOyZ6ZGtoO3gmeWRraDsmeSZkaDE7Jnpka2g7eSZ5ZGtoOyZsJmRoMTsmemRraDt6Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiVERUX0JKXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKnlnLDlm77ovrnnlYzmlbDmja5cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjFcIixcclxuXHRcdFwidHlwZVwiOlwiVGlsZVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJYWVpcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovL3QzLnRpYW5kaXR1LmNvbS9EYXRhU2VydmVyP3RrJmRoMTs3MmVhYjg2ZjI4N2EyMWU3ZTRiNTE2Yzk0NzkyNDJmNSZUJmRoMTtpYm9fdyZ4JmRoMTsmemRraDt4Jnlka2g7JnkmZGgxOyZ6ZGtoO3kmeWRraDsmbCZkaDE7Jnpka2g7eiZ5ZGtoO1wiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlpKnlnLDlm77lvbHlg4/lm75cIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJURFRfWVhcIixcclxuXHRcdFwibGFiZWxcIjpcIuWkqeWcsOWbvuW9seWDj+aVsOaNrlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlRih*x3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJXTVRTXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly8xMC4zNC4xLjgyOjYwODAvYXJjZ2lzL3Jlc3Qvc2VydmljZXMvYWhzenlkaXR1L3F1ZGFvL01hcFNlcnZlci9XTVRTLzEuMC4wL1dNVFNDYXBhYmlsaXRpZXMueG1sXCIsXHJcblx0XHRcIm9nY1BhcmFtXCI6XCImemRraDtsYXllcjoma2c7JmR5aDthaHN6eWRpdHVfcXVkYW8mZHloOyZkaDsma2c7bWF0cml4U2V0OiZrZzsmZHloO2RlZmF1bHQwMjhtbSZkeWg7JmtnOyZ5ZGtoO1wiLFxyXG5cdFx0XCJsYXllclR5cGVcIjpcImJhc2VcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInNrTGF5ZXJcIixcclxuXHRcdFwibGFiZWxcIjpcIuawtOW6k1wiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiM1wiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjBcIixcclxuXHRcdFwiem9vbVwiOlwiMFwiLFxyXG5cdFx0XCJ6b29tTWF4XCI6XCIxMFwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJXTVRTXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly8xMC4zNC4xLjgyOjYwODAvYXJjZ2lzL3Jlc3Qvc2VydmljZXMvJUU1JUFFJTg5JUU1JUJFJUJEJUU2JUIwJUI0JUU1JUJBJTkzLyVFNSVBRSU4OSVFNSVCRSVCRCVFNiVCMCVCNCVFNSVCQSU5My9NYXBTZXJ2ZXIvV01UUy8xLjAuMC9XTVRTQ2FwYWJpbGl0aWVzLnhtbFwiLFxyXG5cdFx0XCJvZ2NQYXJhbVwiOlwiJnpka2g7bGF5ZXI6JmtnOyZkeWg75a6J5b695rC05bqTX+WuieW+veawtOW6kyZkeWg7JmRoOyZrZzttYXRyaXhTZXQ6JmtnOyZkeWg7ZGVmYXVsdDAyOG1tJmR5aDsma2c7Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlpKnlnLDlm77ooZfpgZPlm75cIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJURFRfSkRcIixcclxuXHRcdFwibGFiZWxcIjpcIuWkqeWcsOWbvuefoumHj+aVsOaNrlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlRpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiWFlaXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcIm*CbgpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiWFlaXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly90NC50aWFuZGl0dS5jb20vRGF0YVNlcnZlcj90ayZkaDE7NzJlYWI4NmYyODdhMjFlN2U0YjUxNmM5NDc5MjQyZjUmVCZkaDE7aW1nX3cmeCZkaDE7Jnpka2g7eCZ5ZGtoOyZ5JmRoMTsmemRraDt5Jnlka2g7JmwmZGgxOyZ6ZGtoO3omeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJURFRfQlpcIixcclxuXHRcdFwibGFiZWxcIjpcIuWkqeWcsOWbvuefoumHj+azqOiusOaVsOaNrlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlRpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiWFlaXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly90My50aWFuZGl0dS5jb20vRGF0YVNlcnZlcj90ayZkaDE7NzJlYWI4NmYyODdhMjFlN2U0YjUxNmM5NDc5MjQyZjUmVCZkaDE7Y3ZhX3cmeCZkaDE7Jnpka2g7eCZ5ZGtoOyZ5JmRoMTsmemRraDt5Jnlka2g7JmwmZGgxOyZ6ZGtoO3omeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJURFRfQkpcIixcclxuXHRcdFwibGFiZWxcIjpcIuWkqeWcsOWbvui+ueeVjOaVsOaNrlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIlRpbGVcIixcclxuXHRcdFwic291cmNlXCI6XCJvZ2NcIixcclxuXHRcdFwib2djVHlwZVwiOlwiWFlaXCIsXHJcblx0XHRcIm9nY1BhdGhcIjpcImh0dHA6Ly90My50aWFuZGl0dS5jb20vRGF0YVNlcnZlcj90ayZkaDE7NzJlYWI4NmYyODdhMjFlN2U0YjUxNmM5NDc5MjQyZjUmVCZkaDE7aWJvX3cmeCZkaDE7Jnpka2g7eCZ5ZGtoOyZ5JmRoMTsmemRraDt5Jnlka2g7JmwmZGgxOyZ6ZGtoO3omeWRraDtcIlx0XHJcblx0ICAgfVxyXG5cdCAgXVxyXG59In0seyJqc29uIjoie1xyXG5cdFwibmFtZVwiOlwi5aSp5Zyw5Zu+5Zyw5b2i5Zu+XCIsXHJcblx0XCJzYW1wbGVcIjpcImh0dHA6Ly8xMC4zNC4xLjI1L2Foc3h4L2xvbC95Yy95Yy5odG1sXCIsXHJcblx0XCJjZW50ZXJcIjpcIjExNy4yOSwzMi4wNTgxXCIsXHJcblx0XCJib3VuZFwiOlwiNzEuODI4MDMzLCA0LjA1MzIwNSwgMTM0Ljk1OTIwNSwgNTcuNzg0OTE2XCIsXHJcblx0XCJsYXllcnNcIjogW1xyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiVERUX0RYXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlpKnlnLDlm77lnLDlvaLmlbDmja5cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlIE*hW3sianNvbiI6IntcclxuXHRcIm5hbWVcIjpcIuWuieW+veecgembqOaDheebkeinhuWbvi3nn6Lph49cIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCIxMTQuODc2MTcsMjkuMzk0MDYsMTE5LjY0ODcyLDM0LjY1NDI0XCIsXHJcblx0XCJsYXllcnNcIjogW1xyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwic2hlbmdtaWFuXCIsXHJcblx0XHRcImxhYmVsXCI6XCLnnIHpnaJcIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJzaGVuZy54bWxcIixcclxuXHRcdFwicGF0aFwiOlwic2hlbmcueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIxXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwic2luZ2xlXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiI0U1RkZFOVwiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiI2NjNjYwMFwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcInNoZW5neGlhblwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi55yB57q/XCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidHlwZVwiOlwiTGluZVwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJzaGVuZ0xpbmUueG1sXCIsXHJcblx0XHRcInBhdGhcIjpcInNoZW5nTGluZS54bWxcIixcclxuXHRcdFwiYWxwaGFcIjpcIjFcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjRTVGRkU5XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjY2M2NjAwXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMlwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMlwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiZHNqTGluZVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi5biC55WMXCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidHlwZVwiOlwiTGluZVwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XT*RO+DLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMC43XCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwiZmVhdHVyZVwiLFxyXG5cdFx0XCJmaWxsQ29sb3JcIjpcIiNCQ0UzRjlcIixcclxuXHRcdFwiY29sb3JGZWF0dXJlXCI6XCLlkIjogqUjRDNGRkJFO+a3ruWMlyNCREZDQjM75Lqz5beeI0ZDQ0RCQjvlrr/lt54jQkRGQ0UyO+mYnOmYsyNDMERERkM76JqM5Z+gI0VBRkNENzvmt67ljZcjRkZGRkJFO+a7geW3niNGQ0NBRDE75YWt5a6JI0ZDRDRFRjvlt6LmuZYjRUJDQUZDO+iKnOa5liNEN0Y2RkM76ams6Z6N5bGxI0ZDRjNCRDvlronluoYjREZGQ0IzO+axoOW3niNDN0ZDQ0E76ZOc6Zm1I0ZDQjhEOTvlrqPln44jQjNGQ0ZDO+m7hOWxsSNDM0JERkNcIixcclxuXHRcdFwibGluZUFscGhhXCI6XCIxXCIsXHJcblx0XHRcImFscGhhTGluZVwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lQ29sb3JcIjpcIiNDMEMwQzBcIixcclxuXHRcdFwibGluZVdpZHRoXCI6XCIxXCIsXHJcblx0XHRcImxpbmVTaXplXCI6XCIxXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJzd2ZxXCIsXHJcblx0XHRcImxhYmVsXCI6XCLmsLTmlofliIbljLpcIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJQb2x5Z29uXCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjFcIixcclxuXHRcdFwiem9vbVwiOlwiMVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcImZlbnF1X3JlZ2lvbi54bWxcIixcclxuXHRcdFwicGF0aFwiOlwiZmVucXVfcmVnaW9uLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJjb2xvclR5cGVcIjpcImZlYXR1cmVcIixcclxuXHRcdFwiZmlsbENvbG9yXCI6XCIjZmZmZjAwXCIsXHJcblx0XHRcImNvbG9yRmVhdHVyZVwiOlwi5reu5rKz5Lul5YyXIzB4QkRGQ0UyO+axn+a3ruS5i+mXtCMweEJERkNCMzvlpKfliKvlsbHljLojMHhGQ0NEQkI75rK/5rGf5rGf5Y2XIzB4QkRGQ0UyO+ealuWNl+WxseWMuiMweEMwRERGQ1wiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzc3QkJGRlwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcImdncVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi54GM5Yy6XCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidHlwZVwiOlwiUG9seWdvblwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJHUV9k*RmvLzEwLjM0LjAuMTI6NjA4MC9hcmNnaXMvcmVzdC9zZXJ2aWNlcy9BSERYX1pIMDcxNy9NYXBTZXJ2ZXIvV01UUy8xLjAuMC9XTVRTQ2FwYWJpbGl0aWVzLnhtbFwiLFxyXG5cdFx0XCJvZ2NQYXJhbVwiOlwiJnpka2g7bGF5ZXI6JmtnOyZkeWg7QUhEWF9aSDA3MTcmZHloOyZkaDsma2c7bWF0cml4U2V0OiZrZzsmZHloO2RlZmF1bHQwMjhtbSZkeWg7JmtnOyZ5ZGtoO1wiLFxyXG5cdFx0XCJsYXllclR5cGVcIjpcImJhc2VcIlx0XHJcblx0ICAgfVxyXG5cdCAgXVxyXG59In0seyJqc29uIjoie1xyXG5cdFwibmFtZVwiOlwi5oqk55y85qih5byPXCIsXHJcblx0XCJzYW1wbGVcIjpcImh0dHA6Ly8xMC4zNC4xLjI1L2Foc3h4L2xvbC95Yy95Yy5odG1sXCIsXHJcblx0XCJjZW50ZXJcIjpcIjExNy4yOSwzMi4wNTgxXCIsXHJcblx0XCJib3VuZFwiOlwiNzEuODI4MDMzLCA0LjA1MzIwNSwgMTM0Ljk1OTIwNSwgNTcuNzg0OTE2XCIsXHJcblx0XCJsYXllcnNcIjogW1xyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwiR0VPUVwiLFxyXG5cdFx0XCJsYWJlbFwiOlwi6buR5Zu+XCIsXHJcblx0XHRcInZpc2libGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidHlwZVwiOlwiVGlsZVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJYWVpcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovL21hcC5nZW9xLmNuL0FyY0dJUy9yZXN0L3NlcnZpY2VzL0NoaW5hT25saW5lU3RyZWV0UHVycGxpc2hCbHVlL01hcFNlcnZlci90aWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlronlvr3msLTliKnnn6Lph4/lm77vvIjkuqTpgJrvvIlcIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJBSFNMX1NMX0pUXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXnn6Lph4/lm74o5Lqk6YCaKVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vMTAuMzQuMC4xMjo2MDgwL2FyY2dpcy9yZXN0L3NlcnZpY2VzL0FIU0xfSlQwNzE3L01hcFNlcnZlci90sf*KaWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifSx7Impzb24iOiJ7XHJcblx0XCJuYW1lXCI6XCLlronlvr3msLTliKnnn6Lph4/lm77vvIjmipfml7HvvIlcIixcclxuXHRcInNhbXBsZVwiOlwiaHR0cDovLzEwLjM0LjEuMjUvYWhzeHgvbG9sL3ljL3ljLmh0bWxcIixcclxuXHRcImNlbnRlclwiOlwiMTE3LjI5LDMyLjA1ODFcIixcclxuXHRcImJvdW5kXCI6XCI3MS44MjgwMzMsIDQuMDUzMjA1LCAxMzQuOTU5MjA1LCA1Ny43ODQ5MTZcIixcclxuXHRcImxheWVyc1wiOiBbXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJBSFNMX1NMX0tIXCIsXHJcblx0XHRcImxhYmVsXCI6XCLpq5jmuIXnn6Lph4/lm74o5oqX5pexKVwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vMTAuMzQuMC4xMjo2MDgwL2FyY2dpcy9yZXN0L3NlcnZpY2VzL0FIU0xfS0gvTWFwU2VydmVyL3RpbGUvJnpka2g7eiZ5ZGtoOy8memRraDt5Jnlka2g7LyZ6ZGtoO3gmeWRraDtcIixcclxuXHRcdFwibGF5ZXJUeXBlXCI6XCJiYXNlXCJcdFxyXG5cdCAgIH1cclxuXHQgIF1cclxufSJ9LHsianNvbiI6IntcclxuXHRcIm5hbWVcIjpcIuWuieW+veawtOWIqeS4muWKoeW6leWbvlwiLFxyXG5cdFwic2FtcGxlXCI6XCJodHRwOi8vMTAuMzQuMS4yNS9haHN4eC9sb2wveWMveWMuaHRtbFwiLFxyXG5cdFwiY2VudGVyXCI6XCIxMTcuMjksMzIuMDU4MVwiLFxyXG5cdFwiYm91bmRcIjpcIjcxLjgyODAzMywgNC4wNTMyMDUsIDEzNC45NTkyMDUsIDU3Ljc4NDkxNlwiLFxyXG5cdFwibGF5ZXJzXCI6IFtcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcIkFIU0xfU0xfWVdcIixcclxuXHRcdFwibGFiZWxcIjpcIuWuieW+veawtOWIqeS4muWKoeW6leWbvlwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInppbmRleFwiOlwiNVwiLFxyXG5cdFx0XCJ0eXBlXCI6XCJUaWxlXCIsXHJcblx0XHRcInNvdXJjZVwiOlwib2djXCIsXHJcblx0XHRcIm9nY1R5cGVcIjpcIlhZWlwiLFxyXG5cdFx0XCJvZ2NQYXRoXCI6XCJodHRwOi8vMTAuMzQuMC4xMjo2MDgwL2FyY2dpcy9yZXN0L3NlcnZpY2VzL0FIU0xfWlRTTERUL01hcFNlcnZlci90aWxlLyZ6ZGtoO3omeWRraDsvJnpka2g7eSZ5ZGtoOy8memRraDt4Jnlka2g7XCIsXHJcblx0XHRcImxheWVyVHlwZVwiOlwiYmFzZVwiXHRcclxuXHQgICB9XHJcblx0ICBdXHJcbn0ifV0=aY*VsXHJcblx0XHRcInR5cGVcIjpcIlBvaW50XCIsXHJcblx0XHRcInpvb21NaW5cIjpcIjBcIixcclxuXHRcdFwiem9vbVwiOlwiMFwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcImZpbGVcIixcclxuXHRcdFwiZmlsZVBhdGhcIjpcIuW4guWQjS54bWxcIixcclxuXHRcdFwicGF0aFwiOlwi5biC5ZCNLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMFwiLFxyXG5cdFx0XCJmaWxsQ29sb3JcIjpcIiNGRjAwMDBcIixcclxuXHRcdFwibGluZUFscGhhXCI6XCIwXCIsXHJcblx0XHRcImFscGhhTGluZVwiOlwiMFwiLFxyXG5cdFx0XCJsaW5lQ29sb3JcIjpcIiNCODY3NUVcIixcclxuXHRcdFwibGluZVdpZHRoXCI6XCIxXCIsXHJcblx0XHRcImxpbmVTaXplXCI6XCIxXCIsXHJcblx0XHRcInJvdGF0aW9uXCI6XCIwXCIsXHJcblx0XHRcInRleHRBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYVRleHRcIjpcIjFcIixcclxuXHRcdFwidGV4dENvbG9yXCI6XCIjOTkwMDAwXCIsXHJcblx0XHRcInRleHRGb250XCI6XCLlrovkvZNcIixcclxuXHRcdFwidGV4dFdlaWdodFwiOlwibm9ybWFsXCIsXHJcblx0XHRcInRleHRTaXplXCI6XCIxNVwiLFxyXG5cdFx0XCJ0ZXh0T2Zmc2V0WFwiOlwiMFwiLFxyXG5cdFx0XCJ0ZXh0T2Zmc2V0WVwiOlwiMTBcIixcclxuXHRcdFwic3ltYm9sVHlwZVwiOlwicG9seWdvblwiLFxyXG5cdFx0XCJzeW1ib2xQb2ludE51bWJlclwiOlwiMVwiLFxyXG5cdFx0XCJzeW1ib2xSYWRpdXNcIjpcIjNcIixcclxuXHRcdFwic3ltYm9sUmFkaXVzMlwiOlwiMFwiLFxyXG5cdFx0XCJzeW1ib2xSb3RhdGlvblwiOlwiMFwiLFxyXG5cdFx0XCJzeW1ib2xBbHBoYVwiOlwiMC4xXCIsXHJcblx0XHRcInN5bWJvbENvbG9yXCI6XCIjZmZmZmZmXCIsXHJcblx0XHRcInN5bWJvbExpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJzeW1ib2xMaW5lQ29sb3JcIjpcIiNCODY3NUVcIixcclxuXHRcdFwic3ltYm9sTGluZVdpZHRoXCI6XCIyXCIsXHJcblx0XHRcInNoZG93QWxwaGFcIjpcIjBcIixcclxuXHRcdFwic2hhZG93Q29sb3JcIjpcIiMwMDAwZmZcIixcclxuXHRcdFwic2hkb3dXaWR0aFwiOlwiM1wiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwieWpqaExheWVyXCIsXHJcblx0XHRcImxhYmVsXCI6XCLlvJXmsZ/mtY7mt67kuJPpopjlm75cIixcclxuXHRcdFwidmlzaWJsZVwiOlwiZmFsc2VcIixcclxuXHRcdFwidmlzYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjhcIixcclxuXHRcdFwidHlwZVwiOlwiVGlsZVwiLFxyXG5cdFx0XCJzb3VyY2VcIjpcIm9nY1wiLFxyXG5cdFx0XCJvZ2NUeXBlXCI6XCJXTVNcIixcclxuXHRcdFwib2djUGF0aFwiOlwiaHR0cDovLzYwLjE3NC4yMDMuMTE4OjYwODAvYXJjZ2lzL3NlcnZpY2VzL3lpbmppYW5namlodWFpL2FuaHVpeWluamlhbmdqaWh1YWkvTWFwU2VydmVyL1dNU1NlcnZlcj9cIixcclxuXHRcdFwib2djUGFyYW1cWb*jJmaWxlUGF0aFwiOlwi5Lit5Z6L5rC05bqTLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLkuK3lnovmsLTlupMueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIxXCIsXHJcblx0XHRcImNvbG9yVHlwZVwiOlwic2luZ2xlXCIsXHJcblx0XHRcImZpbGxDb2xvclwiOlwiI0JDRTNGOVwiLFxyXG5cdFx0XCJsaW5lQWxwaGFcIjpcIjFcIixcclxuXHRcdFwiYWxwaGFMaW5lXCI6XCIxXCIsXHJcblx0XHRcImxpbmVDb2xvclwiOlwiIzc3QkJGRlwiLFxyXG5cdFx0XCJsaW5lV2lkdGhcIjpcIjFcIixcclxuXHRcdFwibGluZVNpemVcIjpcIjFcIlx0XHJcblx0ICAgfSxcclxuXHQgICB7XHJcblx0XHRcIm5hbWVcIjpcImhoY2pcIixcclxuXHRcdFwibGFiZWxcIjpcIua3ruays+mVv+axn+eVjFwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJ0cnVlXCIsXHJcblx0XHRcInZpc2JsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ6aW5kZXhcIjpcIjZcIixcclxuXHRcdFwidHlwZVwiOlwiTGluZVwiLFxyXG5cdFx0XCJ6b29tTWluXCI6XCIwXCIsXHJcblx0XHRcInpvb21cIjpcIjBcIixcclxuXHRcdFwic291cmNlXCI6XCJmaWxlXCIsXHJcblx0XHRcImZpbGVQYXRoXCI6XCJoaGNqLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCJoaGNqLnhtbFwiLFxyXG5cdFx0XCJhbHBoYVwiOlwiMC44XCIsXHJcblx0XHRcImxpbmVBbHBoYVwiOlwiMVwiLFxyXG5cdFx0XCJhbHBoYUxpbmVcIjpcIjFcIixcclxuXHRcdFwibGluZUNvbG9yXCI6XCIjY2M2NjAwXCIsXHJcblx0XHRcImxpbmVXaWR0aFwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lU2l6ZVwiOlwiMVwiXHRcclxuXHQgICB9LFxyXG5cdCAgIHtcclxuXHRcdFwibmFtZVwiOlwieGlhbkxpbmVcIixcclxuXHRcdFwibGFiZWxcIjpcIuWOv+eVjFwiLFxyXG5cdFx0XCJ2aXNpYmxlXCI6XCJmYWxzZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcImZhbHNlXCIsXHJcblx0XHRcInR5cGVcIjpcIkxpbmVcIixcclxuXHRcdFwiem9vbU1pblwiOlwiMFwiLFxyXG5cdFx0XCJ6b29tXCI6XCIwXCIsXHJcblx0XHRcInNvdXJjZVwiOlwiZmlsZVwiLFxyXG5cdFx0XCJmaWxlUGF0aFwiOlwi5Y6/55WMLnhtbFwiLFxyXG5cdFx0XCJwYXRoXCI6XCLljr/nlYwueG1sXCIsXHJcblx0XHRcImFscGhhXCI6XCIwLjdcIixcclxuXHRcdFwiY29sb3JUeXBlXCI6XCJzaW5nbGVcIixcclxuXHRcdFwibGluZUFscGhhXCI6XCIxXCIsXHJcblx0XHRcImFscGhhTGluZVwiOlwiMVwiLFxyXG5cdFx0XCJsaW5lQ29sb3JcIjpcIiM4OTU3YTFcIixcclxuXHRcdFwibGluZVdpZHRoXCI6XCIxXCIsXHJcblx0XHRcImxpbmVTaXplXCI6XCIxXCJcdFxyXG5cdCAgIH0sXHJcblx0ICAge1xyXG5cdFx0XCJuYW1lXCI6XCJzaGltaW5nXCIsXHJcblx0XHRcImxhYmVsXCI6XCLluILlkI1cIixcclxuXHRcdFwidmlzaWJsZVwiOlwidHJ1ZVwiLFxyXG5cdFx0XCJ2aXNibGVcIjpcInRydWVcIixcclxuXHRcdFwiemluZGV4XCI6XCI2XCIBJ*aHa*gT*RO*QeFk*Rmx*qup*Eems*JLj*w*hgkfO*VQZN*BJ*aWb*jf*By*Cbgih*xIE*h*HDluv*AQ*uisf*KaY*VHa*g" + +# data = ctx.call("resultDecode", data_json) +# data = json.loads(data) +# print(data) diff --git a/ahsxx/ahsxx_encode.js b/ahsxx/ahsxx_encode.js new file mode 100644 index 0000000..a3f3db1 --- /dev/null +++ b/ahsxx/ahsxx_encode.js @@ -0,0 +1,223 @@ +//沃特水务-前端加密/解密工具 +//1.引用 +//2.实例化 var waterSecurity = new WaterSecurity() +//3.调用属性 waterSecurity.version +//4.调用加密方法 waterSecurity.encode(webCode); +//5.调用解密方法 waterSecurity.decode(webCode) +var WaterSecurity = function() { + this.init() +}; +WaterSecurity.prototype = { + version: "2.1", + init: function() { + String.prototype.gblen = function() { + var len = 0; + for (var i = 0; i < this.length; i++) + if (this.charCodeAt(i) > 127 || this.charCodeAt(i) == 94) + len += 2; + else + len++; + return len + } + }, + encode: function(data) { + this.print(data); + data += ""; + if (data == "") + return ""; + data = encodeURI(data).replace(/\+/g, "%2B"); + var length = data.gblen(); + if (length % 2 != 0) + data += "*"; + this.print(data); + data = this.parityTransposition(data); + this.print(data); + var result = this.version + this.utf16to8(this.base64encode(data)); + this.print(result); + return result + }, + print: function(data) {}, + parityTransposition: function(data) { + var newData = []; + for (var i = 0; i < data.length; i += 2) { + newData.push(data[i + 1]); + newData.push(data[i]) + } + newData = newData.join(""); + return newData + }, + decode: function(data) { + data += ""; + this.print(data); + if (data == "") + return "[]"; + if (this.version) { + var versionS = data.substring(0, 3); + if (versionS !== this.version) + return alert("\u540e\u53f0\u7248\u672c\u4e0d\u4e00\u81f4\uff01"); + data = data.substring(3, data.length) + } + var endTag = data.substring(data.length - 4); + var tagsStr = data.substring(data.indexOf(endTag)); + var tags = new Array; + tagsStr = tagsStr.substring(4, tagsStr.length - 4); + var content = new Array; + for (var i = 0; 4 * i < tagsStr.length; i++) { + var tag = tagsStr.substr(i * 4, 4); + tags[i] = tag; + content[tag] = null + } + var positions = this.getTagsPosition(data, tags); + var index = 0; + for (var i = 0; i < positions.length; i++) { + var msg = data.substring(index, positions[i]); + var tag = data.substr(positions[i], 4); + content[tag] = msg; + index = positions[i] + 4 + } + var result = ""; + for (var i = 0; i < tags.length; i++) + result += content[tags[i]]; + result = this.utf8to16(this.base64decode(result)); + return result + }, + getTagsPosition: function(data, tags) { + var positions = new Array; + for (i = 0; i < tags.length; i++) + positions[i] = data.indexOf(tags[i]); + return positions.sort(function(a, b) { + return a > b ? 1 : -1 + }) + }, + base64EncodeChars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + base64DecodeChars: new Array(-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1), + base64encode: function(str) { + var out, i, len; + var c1, c2, c3; + len = str.length; + i = 0; + out = ""; + while (i < len) { + c1 = str.charCodeAt(i++) & 255; + if (i == len) { + out += this.base64EncodeChars.charAt(c1 >> 2); + out += this.base64EncodeChars.charAt((c1 & 3) << 4); + out += "\x3d\x3d"; + break + } + c2 = str.charCodeAt(i++); + if (i == len) { + out += this.base64EncodeChars.charAt(c1 >> 2); + out += this.base64EncodeChars.charAt((c1 & 3) << 4 | (c2 & 240) >> 4); + out += this.base64EncodeChars.charAt((c2 & 15) << 2); + out += "\x3d"; + break + } + c3 = str.charCodeAt(i++); + out += this.base64EncodeChars.charAt(c1 >> 2); + out += this.base64EncodeChars.charAt((c1 & 3) << 4 | (c2 & 240) >> 4); + out += this.base64EncodeChars.charAt((c2 & 15) << 2 | (c3 & 192) >> 6); + out += this.base64EncodeChars.charAt(c3 & 63) + } + return out + }, + base64decode: function(str) { + var c1, c2, c3, c4; + var i, len, out; + len = str.length; + i = 0; + out = ""; + while (i < len) { + do + c1 = this.base64DecodeChars[str.charCodeAt(i++) & 255]; + while (i < len && c1 == -1);if (c1 == -1) + break; + do + c2 = this.base64DecodeChars[str.charCodeAt(i++) & 255]; + while (i < len && c2 == -1);if (c2 == -1) + break; + out += String.fromCharCode(c1 << 2 | (c2 & 48) >> 4); + do { + c3 = str.charCodeAt(i++) & 255; + if (c3 == 61) + return out; + c3 = this.base64DecodeChars[c3] + } while (i < len && c3 == -1);if (c3 == -1) + break; + out += String.fromCharCode((c2 & 15) << 4 | (c3 & 60) >> 2); + do { + c4 = str.charCodeAt(i++) & 255; + if (c4 == 61) + return out; + c4 = this.base64DecodeChars[c4] + } while (i < len && c4 == -1);if (c4 == -1) + break; + out += String.fromCharCode((c3 & 3) << 6 | c4) + } + return out + }, + utf16to8: function(str) { + var out, i, len, c; + out = ""; + len = str.length; + for (i = 0; i < len; i++) { + c = str.charCodeAt(i); + if (c >= 1 && c <= 127) + out += str.charAt(i); + else if (c > 2047) { + out += String.fromCharCode(224 | c >> 12 & 15); + out += String.fromCharCode(128 | c >> 6 & 63); + out += String.fromCharCode(128 | c >> 0 & 63) + } else { + out += String.fromCharCode(192 | c >> 6 & 31); + out += String.fromCharCode(128 | c >> 0 & 63) + } + } + return out + }, + utf8to16: function(str) { + var out, i, len, c; + var char2, char3; + out = ""; + len = str.length; + i = 0; + while (i < len) { + c = str.charCodeAt(i++); + switch (c >> 4) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + out += str.charAt(i - 1); + break; + case 12: + case 13: + char2 = str.charCodeAt(i++); + out += String.fromCharCode((c & 31) << 6 | char2 & 63); + break; + case 14: + char2 = str.charCodeAt(i++); + char3 = str.charCodeAt(i++); + out += String.fromCharCode((c & 15) << 12 | (char2 & 63) << 6 | (char3 & 63) << 0); + break + } + } + return out + } +}; +var waterSecurity = new WaterSecurity; + +function waterEncode(data) { + return waterSecurity.encode(data) +} + +function resultDecode(data) { + data = waterSecurity.decode(data); + //data = JSON.parse(data); + return data; +} + diff --git a/dns_login/dns.js b/dns_login/dns.js index dc4c66f..d102561 100644 --- a/dns_login/dns.js +++ b/dns_login/dns.js @@ -1,10 +1,12 @@ -var CryptoJS = require("crypto-js"); +var CryptoJS = require("crypto-js"); + function aes(val) { var k = CryptoJS.enc.Utf8.parse('1234567890abcDEF'); var iv = CryptoJS.enc.Utf8.parse('1234567890abcDEF'); - enc = CryptoJS.AES.encrypt($.trim(val), k, {iv: iv, mode:CryptoJS.mode.CBC, padding: CryptoJS.pad.ZeroPadding}).toString(); + enc = CryptoJS.AES.encrypt(val, k, {iv: iv, mode:CryptoJS.mode.CBC, padding: CryptoJS.pad.ZeroPadding}).toString(); return enc; } + diff --git a/tian_aw/login.py b/tian_aw/login.py new file mode 100644 index 0000000..bbcb54c --- /dev/null +++ b/tian_aw/login.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- +import json +import base64 +from Crypto.Cipher import AES + + +class USE_AES(object): + """ + AES + 除了MODE_SIV模式key长度为：32, 48, or 64, + 其余key长度为16, 24 or 32 + 详细见AES内部文档 + CBC模式传入iv参数 + 本例使用常用的ECB模式 + """ + + def __init__(self, key): + if len(key) > 32: + key = key[:32] + self.key = self.to_16(key) + + def to_16(self, key): + """ + 转为16倍数的bytes数据 + :param key: + :return: + """ + key = bytes(key, encoding="utf8") + while len(key) % 16 != 0: + key += b'\0' + return key # 返回bytes + + def aes(self): + return AES.new(self.key, AES.MODE_ECB) # 初始化加密器 + + def encrypt(self, text): + aes = self.aes() + # # 加密 + return str(base64.encodebytes(aes.encrypt(self.to_16(text))), encoding='utf8').replace('\n', '') + + def decode_bytes(self, text): + aes = self.aes() + return str(aes.decrypt(base64.decodebytes(bytes( + text, encoding='utf8'))).rstrip(b'\0').decode("utf8")) # 解密 + + +if __name__ == '__main__': + ase = USE_AES("48") + data = { + "body": { + "loginMethod": "2", + "name": "18126351541", + "verificationCode": "479489" + }, + "head": { + "userCode": "null", + "channelCode": "101", + "transTime": 1572510077571, + "transToken": "", + "customerId": "null", + "transSerialNumber": "" + } + } + + data_str = json.dumps(data) + print(data_str) + print(type(data_str)) + result = ase.encrypt(data_str) + print(result) + diff --git a/tools/rsa-aes-md5-des-des3-sha-hmac.py b/tools/rsa-aes-md5-des-des3-sha-hmac.py index 9f150cc..2ad9e30 100644 --- a/tools/rsa-aes-md5-des-des3-sha-hmac.py +++ b/tools/rsa-aes-md5-des-des3-sha-hmac.py @@ -40,8 +40,8 @@ def aes(self): def encrypt(self, text): aes = self.aes() - return str(base64.encodebytes(aes.encrypt(self.to_16(text))), - encoding='utf8').replace('\n', '') # 加密 + # # 加密 + return str(base64.encodebytes(aes.encrypt(self.to_16(text))), encoding='utf8').replace('\n', '') def decode_bytes(self, text): aes = self.aes() diff --git a/xd_new_rank/xd.js b/xd_new_rank/xd.js new file mode 100644 index 0000000..ab566fb --- /dev/null +++ b/xd_new_rank/xd.js @@ -0,0 +1,217 @@ +function i(e, t) { + var n = (65535 & e) + (65535 & t); + return (((e >> 16) + (t >> 16) + (n >> 16)) << 16) | (65535 & n); + } + +function u(e, t, n, r, o, u) { +return i(((a = i(i(t, e), i(r, u))) << (c = o)) | (a >>> (32 - c)), n); +var a, c; +} + + +function a(e, t, n, r, o, i, a) { +return u((t & n) | (~t & r), e, t, o, i, a); +} + + +function c(e, t, n, r, o, i, a) { +return u((t & r) | (n & ~r), e, t, o, i, a); +} + + +function l(e, t, n, r, o, i, a) { +return u(t ^ n ^ r, e, t, o, i, a); +} + + +function f(e, t, n, r, o, i, a) { +return u(n ^ (t | ~r), e, t, o, i, a); +} + + +function s(e, t) { +var n, r, o, u, s; +(e[t >> 5] |= 128 << t % 32), (e[14 + (((t + 64) >>> 9) << 4)] = t); +var d = 1732584193, + p = -271733879, + h = -1732584194, + v = 271733878; +for (n = 0; n < e.length; n += 16) + (r = d), + (o = p), + (u = h), + (s = v), + (d = a(d, p, h, v, e[n], 7, -680876936)), + (v = a(v, d, p, h, e[n + 1], 12, -389564586)), + (h = a(h, v, d, p, e[n + 2], 17, 606105819)), + (p = a(p, h, v, d, e[n + 3], 22, -1044525330)), + (d = a(d, p, h, v, e[n + 4], 7, -176418897)), + (v = a(v, d, p, h, e[n + 5], 12, 1200080426)), + (h = a(h, v, d, p, e[n + 6], 17, -1473231341)), + (p = a(p, h, v, d, e[n + 7], 22, -45705983)), + (d = a(d, p, h, v, e[n + 8], 7, 1770035416)), + (v = a(v, d, p, h, e[n + 9], 12, -1958414417)), + (h = a(h, v, d, p, e[n + 10], 17, -42063)), + (p = a(p, h, v, d, e[n + 11], 22, -1990404162)), + (d = a(d, p, h, v, e[n + 12], 7, 1804603682)), + (v = a(v, d, p, h, e[n + 13], 12, -40341101)), + (h = a(h, v, d, p, e[n + 14], 17, -1502002290)), + (d = c( + d, + (p = a(p, h, v, d, e[n + 15], 22, 1236535329)), + h, + v, + e[n + 1], + 5, + -165796510 + )), + (v = c(v, d, p, h, e[n + 6], 9, -1069501632)), + (h = c(h, v, d, p, e[n + 11], 14, 643717713)), + (p = c(p, h, v, d, e[n], 20, -373897302)), + (d = c(d, p, h, v, e[n + 5], 5, -701558691)), + (v = c(v, d, p, h, e[n + 10], 9, 38016083)), + (h = c(h, v, d, p, e[n + 15], 14, -660478335)), + (p = c(p, h, v, d, e[n + 4], 20, -405537848)), + (d = c(d, p, h, v, e[n + 9], 5, 568446438)), + (v = c(v, d, p, h, e[n + 14], 9, -1019803690)), + (h = c(h, v, d, p, e[n + 3], 14, -187363961)), + (p = c(p, h, v, d, e[n + 8], 20, 1163531501)), + (d = c(d, p, h, v, e[n + 13], 5, -1444681467)), + (v = c(v, d, p, h, e[n + 2], 9, -51403784)), + (h = c(h, v, d, p, e[n + 7], 14, 1735328473)), + (d = l( + d, + (p = c(p, h, v, d, e[n + 12], 20, -1926607734)), + h, + v, + e[n + 5], + 4, + -378558 + )), + (v = l(v, d, p, h, e[n + 8], 11, -2022574463)), + (h = l(h, v, d, p, e[n + 11], 16, 1839030562)), + (p = l(p, h, v, d, e[n + 14], 23, -35309556)), + (d = l(d, p, h, v, e[n + 1], 4, -1530992060)), + (v = l(v, d, p, h, e[n + 4], 11, 1272893353)), + (h = l(h, v, d, p, e[n + 7], 16, -155497632)), + (p = l(p, h, v, d, e[n + 10], 23, -1094730640)), + (d = l(d, p, h, v, e[n + 13], 4, 681279174)), + (v = l(v, d, p, h, e[n], 11, -358537222)), + (h = l(h, v, d, p, e[n + 3], 16, -722521979)), + (p = l(p, h, v, d, e[n + 6], 23, 76029189)), + (d = l(d, p, h, v, e[n + 9], 4, -640364487)), + (v = l(v, d, p, h, e[n + 12], 11, -421815835)), + (h = l(h, v, d, p, e[n + 15], 16, 530742520)), + (d = f( + d, + (p = l(p, h, v, d, e[n + 2], 23, -995338651)), + h, + v, + e[n], + 6, + -198630844 + )), + (v = f(v, d, p, h, e[n + 7], 10, 1126891415)), + (h = f(h, v, d, p, e[n + 14], 15, -1416354905)), + (p = f(p, h, v, d, e[n + 5], 21, -57434055)), + (d = f(d, p, h, v, e[n + 12], 6, 1700485571)), + (v = f(v, d, p, h, e[n + 3], 10, -1894986606)), + (h = f(h, v, d, p, e[n + 10], 15, -1051523)), + (p = f(p, h, v, d, e[n + 1], 21, -2054922799)), + (d = f(d, p, h, v, e[n + 8], 6, 1873313359)), + (v = f(v, d, p, h, e[n + 15], 10, -30611744)), + (h = f(h, v, d, p, e[n + 6], 15, -1560198380)), + (p = f(p, h, v, d, e[n + 13], 21, 1309151649)), + (d = f(d, p, h, v, e[n + 4], 6, -145523070)), + (v = f(v, d, p, h, e[n + 11], 10, -1120210379)), + (h = f(h, v, d, p, e[n + 2], 15, 718787259)), + (p = f(p, h, v, d, e[n + 9], 21, -343485551)), + (d = i(d, r)), + (p = i(p, o)), + (h = i(h, u)), + (v = i(v, s)); +return [d, p, h, v]; +} + + +function d(e) { +var t, + n = '', + r = 32 * e.length; +for (t = 0; t < r; t += 8) + n += String.fromCharCode((e[t >> 5] >>> t % 32) & 255); +return n; +} + + +function p(e) { +var t, + n = []; +for (n[(e.length >> 2) - 1] = void 0, t = 0; t < n.length; t += 1) + n[t] = 0; +var r = 8 * e.length; +for (t = 0; t < r; t += 8) + n[t >> 5] |= (255 & e.charCodeAt(t / 8)) << t % 32; +return n; +} + + +function h(e) { +var t, + n, + r = ''; +for (n = 0; n < e.length; n += 1) + (t = e.charCodeAt(n)), + (r += + '0123456789abcdef'.charAt((t >>> 4) & 15) + + '0123456789abcdef'.charAt(15 & t)); +return r; +} + + +function v(e) { +return unescape(encodeURIComponent(e)); +} + + +function m(e) { +return (function (e) { + return d(s(p(e), 8 * e.length)); +})(v(e)); +} + + +function y(e, t) { +return (function (e, t) { + var n, + r, + o = p(e), + i = [], + u = []; + for ( + i[15] = u[15] = void 0, + o.length > 16 && (o = s(o, 8 * e.length)), + n = 0; + n < 16; + n += 1 + ) + (i[n] = 909522486 ^ o[n]), (u[n] = 1549556828 ^ o[n]); + return ( + (r = s(i.concat(p(t)), 512 + 8 * t.length)), d(s(u.concat(r), 640)) + ); +})(v(e), v(t)); +} + + +function g(e, t, n) { +return t ? (n ? y(t, e) : h(y(t, e))) : n ? m(e) : h(m(e)); +} + + +g(e = "/xdnphb/nr/cloud/douyin/account/getAccountAll?AppKey=joker&nonce=397d80f12", t = undefined, n = undefined) +// b0bb4d1a3a1d4f98282e97d760c5c929 397d80f12 +// c14d160a16c9725b1bc65236ce528932 /xdnphb/nr/cloud/douyin/DOU/search/type?AppKey=joker&nonce=a49231df5 + + + + diff --git a/xd_new_rank/xd_new.py b/xd_new_rank/xd_new.py new file mode 100644 index 0000000..4057fbc --- /dev/null +++ b/xd_new_rank/xd_new.py @@ -0,0 +1,20 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +# @Time : 2020/10/30 16:49 +# @Author : Oscar +import execjs + + +def get_xyz(keyword): + with open('xd.js', 'r') as file: + js = file.read() + + ctx = execjs.compile(js) + result = ctx.call('g', keyword) + return result + + +if __name__ == '__main__': + params = "/xdnphb/nr/cloud/douyin/account/getAccountAll?AppKey=joker&nonce=397d80f12" + info = get_xyz(params) + print(info)