Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@飞鸟听书APP@{"last_chapter_rule":"","title":"飞鸟听书APP","author":"zhao","url":"hiker://empty##fypage","version":1,"col_type":"movie_3","class_name":"","type":"music","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d = []\nif (MY_PAGE == 1) {\nvar titles = [\"小中\",\"小兔\",\"小兰\",\"小老\",\"小凡\",\"收音机\"]\nvar urls = [\"0\",\"1\",\"2\",\"3\",\"4\",\"5\"]\n//log(getMyVar('url'))\ntitles.forEach( (item,index) => {\n    var url = urls[index]\n    d.push({\n        title: getMyVar('index','0') == index ? \"““\"+item+\"””\" : item,\n        url: $('#noLoading#').lazyRule((index,url) => {\n            putMyVar('index',index)\n            putMyVar('url',url)\n            refreshPage()\n            return 'hiker://empty'\n        },index,url),\n        col_type: 'flex_button'\n    })\n})\n}\ntry{\nvar apiview = $.require(\"hanshu\");\nswitch (parseInt(getMyVar('url','0'))) {\n    case 0:\n        eval(JSON.parse(request('hiker://page/cla')).rule)\n        break;\n    case 1:\n        eval(JSON.parse(request('hiker://page/cla1')).rule)\n        break;\n    case 2:\n        eval(JSON.parse(request('hiker://page/cla2')).rule)\n        break;\n    case 3:\n        eval(JSON.parse(request('hiker://page/cla3')).rule)\n        break;\n    case 4:\n        eval(JSON.parse(request('hiker://page/cla4')).rule)\n        break;\n    case 5:\n        eval(JSON.parse(request('hiker://page/cla5')).rule)\n        break;\n}\n}catch(e){\n    log(e.message)\n}\n\nsetResult(d)","search_url":"hiker://empty##**","group":"F音频","searchFind":"js:\n\nvar d = []\n\nvar html11 = request('http://search.kuwo.cn/r.s?client=kt&all='+MY_KEYWORD+'&ft=album&newsearch=1&itemset=web_2013&cluster=0&pn=0&rn=10&rformat=json&encoding=utf8&show_copyright_off=1&vipver=MUSIC_8.0.3.0_BCS75&show_series_listen=1&version=9.1.8.1'); //log(html11) \ntry{\nvar list11 = JSON.parse(html11.replace(/'/g,'\"')).albumlist; //log(list11)\nlist11.forEach(item =>{\n    var finished = item.finished == 1 ? '完结' : '连载'\n    var img = item.img\n    d.push({\n        title: item.name,\n        desc: '小中听书',\n        content: item.musiccnt+'集'+'-'+finished+'-'+item.artist,\n        img: img,\n        url: `hiker://page/erji?page=fypage?albumId=${item.id}#immersiveTheme#`,\n        extra: {\n            pageTitle: item.name.split('|')[0],\n            desc: item.musiccnt+'集'+'-'+finished+'-'+item.artist,\n            img: img,\n            albumId: item.id\n        }\n    })\n})\n}catch(e){log(e.message)}\n\nvar html21 = request('https://m.ximalaya.com/m-revision/page/search?kw='+MY_KEYWORD+'&core=album&page=1&rows=20',{\n    headers: {\n        'cookie': '1&_token=30600815&46F02F20240N39A4B993864E14C27EE7422AAFAA2CD42D46FE3CD8B40B9AC88AF3C4301E93D5174M7897A257B9A49AF_;wfp=ACM2MzVjYTU0NTRjOWZkMzM1pdA9r5Odaad4bXdlYl93d3c;'\n    },\n    method: 'GET'\n}); //log(html21)\ntry{\nvar list21 = JSON.parse(html21).data.recommendItems\nlist21.forEach(item =>{\n    var img = 'http://imagev2.xmcdn.com/'+item.albumInfo.cover\n    d.push({\n        title: item.albumInfo.title,\n        desc: '小兔听书',\n        content: item.statCountInfo.trackCount+'集'+'-'+'连载'+'-'+item.pageUriInfo.categoryName,\n        img: img,\n        url: `hiker://page/erji1?page=fypage?albumId=${item.albumInfo.id}#immersiveTheme#`,\n        extra: {\n            pageTitle: item.albumInfo.title.split('|')[0],\n            desc: item.statCountInfo.trackCount+'集'+'-'+'连载'+'-'+item.pageUriInfo.categoryName,\n            desc1: item.albumInfo.shortIntro,\n            img: img,\n            albumId: item.albumInfo.id\n        }\n    })\n})\n}catch(e){log(e.message)}\n\nvar html31 = request('https://m.lrts.me/ajax/searchBook?keyWord='+MY_KEYWORD+'&pageSize=15&pageNum=1'); //log(html31)\ntry{\nvar list31 = JSON.parse(html31).list\nlist31.forEach(item =>{\n    var state = item.state == 2 ? '完结' : '连载'\n    var img = item.cover\n    d.push({\n        title: item.name,\n        desc: '小兰听书',\n        content: state+'-'+item.announcer,\n        img: img,\n        url: `hiker://page/erji2?page=fypage?id=${item.id}#immersiveTheme#`,\n        col_type: 'movie_1_vertical_pic',\n        extra: {\n            pageTitle: item.name.split('|')[0],\n            desc: state+'-'+item.announcer,\n            desc1: item.desc,\n            img: img,\n            albumId: item.id\n        }\n    })\n})\n}catch(e){log(e.message)}\n\nlet PUBLIC_KEY = \"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuTx7ONxN0Ghy55NdLbjSC7yz9Pv1f7XvSCQcjd1P+Pkd2Y6tzpEcyfzEvPgVPp/Co0/YR9zRQYrd/kPg0VXcU4Zn2L5gCI3OiJXdE/kSHEPot+0NVUG1hKnoKrF5ZpL4qKm06L1n/YuF8+6eaWiHEZF/fiZsRgAOJkqJEo9KF+dngDnw5lCdUjzceFvC86OuZwIG0vPIviju3NudeIp3qAzu4A5arZ6otA052cf6u5vJhUmAI/TSssmLiqfhy/NDucPGy2wBXN1YsjF8utVgHnfpiCh5oiVOcLrhvW3rD6Jdh1BohtbycnyJ9SPOgcl9Sms2O4bg8zAM/FsiuGyJ3wIDAQAB\";\nvar json = {\n    \"road\": \"search\",\n    \"keyword\": MY_KEYWORD,\n    \"app_version\": \"1.1.2\"\n}\nvar str = JSON.stringify(json);\nlet body = rsaEncrypt(str, PUBLIC_KEY)\nvar html41 = request('https://apk-lb-play.fodexin.com/?a=api',{\n    headers: {\n        'referer': 'https://apk.jqkan.com/'\n    },\n    body: \"param=\" + body,\n    method: 'POST'\n}); //log(html41)\ntry{\nvar list41 = JSON.parse(html41).data.books\nlist41.forEach(item =>{\n    var status = item.status\n    var img = 'https://pic.iiszg.com/'+item.pic\n    d.push({\n        title: item.name,\n        desc: '小老听书',\n        content: item.count+'集-'+status+'-'+item.teller+'\\n'+item.synopsis,\n        img: img,\n        url: `hiker://page/erji3?id=${item.book_id}#immersiveTheme#`,\n        col_type: 'movie_1_vertical_pic',\n        extra: {\n            pageTitle: item.name.split('|')[0],\n            desc: item.count+'集-'+status+'-'+item.teller,\n            desc1: item.synopsis,\n            img: img,\n            albumId: item.book_id\n        }\n    })\n})\n}catch(e){log(e.message)}\n\nvar html51 = request('https://api5-lf.novelfm.com/novelfm/bookmall/search/page/v1/?iid=734954504327623&device_id=2195048912397567&ac=wifi&channel=update_64&aid=3040&app_name=novel_fm&version_code=480&version_name=4.8.0.18&device_platform=android&os=android&ssmix=a&device_type=V1923A&device_brand=vivo&language=zh&os_api=28&os_version=9&manifest_version_code=480&resolution=900*1600&dpi=240&update_version_code=48018&_rticket=1677649756877&need_personal_recommend=1&comment_tag_c=5&vip_state=0&category_style=1&ab_sdk_version=5548515,5522350,90093450,4855051,90093386&rom_version=PQ3A.190705.003 release-keys&cdid=eb7b44c1-e3d1-44fd-8fcd-f90be1deb3ef',{\n    body: JSON.stringify({\n      \"offset\": 0,\n      \"tab_type\": 2,\n      \"sub_tab_type\": 31,\n      \"query\": MY_KEYWORD,\n      \"limit\": 10\n    }),\n    method: 'POST'\n}); //log(html51) \ntry{\nvar list51 = JSON.parse(html51).data.search_data\nlist51.forEach(item =>{\n    var img = item.books[0].audio_thumb_uri\n    d.push({\n        title: item.books[0].book_name,\n        desc: '小凡听书',\n        content: '连载'+'-'+item.books[0].author+'\\n'+item.books[0].abstract,\n        img: img,\n        url: `hiker://page/erji4?albumId=${item.book_id}#immersiveTheme#`,\n        col_type: 'movie_1_vertical_pic',\n        extra: {\n            pageTitle: item.books[0].book_name.split('|')[0],\n            desc: '连载'+'-'+item.books[0].author,\n            desc1: item.books[0].abstract,\n            img: img,\n            bookId: item.book_id\n        }\n    })\n})\n}catch(e){log(e.message)}\n\nvar html71 = request('http://www.6yueting.com/web/index/search?content='+MY_KEYWORD+'&type=1&pageNum=1'); //log(html71)\ntry{\nvar list71 = JSON.parse(html71).data.list\nlist71.forEach(item =>{\n    var img = 'http://img.6yueting.com:20001/' + item.coverUrlLocal\n    d.push({\n        title: item.name,\n        desc: '小六听书',\n        content: item.broadcaster,\n        img: img,\n        url: `hiker://page/erji6?page=fypage?id=${item.code}#immersiveTheme#`,\n        col_type: 'movie_1_vertical_pic',\n        extra: {\n            pageTitle: item.name.split('|')[0],\n            desc: item.broadcaster,\n            desc1: item.descXx,\n            img: img,\n            code: item.code\n        }\n    })\n})\n}catch(e){log(e.message)}\n\n\nsetResult(d)","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"函数\",\"path\":\"hanshu\",\"rule\":\"const apiview = {\\n    color: (test) => {\\n        return '<font color=\\\"#FA7298\\\">' + test + '</front>';\\n    },\\n    strong: (test) => {\\n        return '<strong>' + test + '</strong>';\\n    },\\n    small: (test) => {\\n        return '<small>' + test + '</small>';\\n    },\\n    center: (test) => {\\n        return '<p style=\\\"text-align: center;\\\">' + test + '</p>'\\n    },\\n    big: (test) => {\\n        return '<big>' + test + '</big>';\\n    },\\n    grey: (text) => {\\n        return \\\"<font color='grey'>\\\" + text + \\\"</font>\\\";\\n\\n    },\\n    gray: (test) => {\\n        return \\\"<font color='gray'>\\\" + test + \\\"</font>\\\";\\n    },\\n    rich: (test) => {\\n        return \\\"‘‘’’\\\" + test;\\n    },\\n    addressTag: (url, text) => {\\n        return \\\"<a href='\\\" + url + \\\"'>\\\" + text + \\\"</a>\\\"\\n    },\\n    empty: \\\"hiker://empty\\\",\\n    noLoad: \\\"#noLoading#\\\",\\n    setDesc: (d, desc, num) => {\\n        //log(desc)\\n        if (desc == undefined) {\\n            return;\\n        }\\n        desc = desc.constructor == Array ? desc.join('<br>') : desc;\\n        if (desc.replace(/(<br>|\\\\s+|<\\\\/?p>|&nbsp;)/g, '').length == 0) {\\n            return;\\n        }\\n        const mark = 'desc';\\n        num = typeof(num) == 'undefined' ? 100 : num\\n        desc = desc.startsWith('　　') ? desc : '　　' + desc;\\n        desc = desc.replace(/'/g, \\\"&#39;\\\");\\n        desc = desc.replace(/\\\\r\\\\n/g, \\\"<br>\\\");\\n        desc = desc.replace(/\\\\r/g, \\\"<br>\\\");\\n        desc = desc.replace(/\\\\n/g, \\\"<br>\\\");\\n\\n        function substr(str, maxLength) {\\n            let len = 0;\\n            for (let i = 0; i < str.length; i++) {\\n                if (str.charCodeAt(i) > 255) {\\n                    len += 2;\\n                } else {\\n                    len++;\\n                }\\n                if (len > maxLength) {\\n                    return str.slice(0, i) + '...';\\n                }\\n            }\\n            return str;\\n        }\\n        let sdesc = substr(desc, num);\\n        var colors = {\\n            show: \\\"black\\\",\\n            hide: \\\"grey\\\"\\n        }\\n        var lazy = $(`#noLoading#`).lazyRule((dc, sdc, m, cs) => {\\n            var show = storage0.getItem(m, '0');\\n            var title = findItem('desc').title;\\n            var re = /(<\\\\/small><br>.*?>).+/g;\\n            var exp = '展开:';\\n            var ret = '收起:';\\n            if (show == '1') {\\n                updateItem('desc', {\\n                    title: title\\n                        .replace(ret, exp)\\n                        .replace(re, '$1' + sdc + '</small>')\\n                        .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.hide + '$2')\\n                })\\n                storage0.setItem(m, '0');\\n            } else {\\n                updateItem('desc', {\\n                    title: title\\n                        .replace(exp, ret)\\n                        .replace(re, '$1' + dc + '</small>')\\n                        .replace(/(<\\\\/small><br>\\\\<font color=\\\").*?(\\\">)/, '$1' + cs.show + '$2')\\n                })\\n                storage0.setItem(m, '1');\\n            }\\n            return `hiker://empty`\\n        }, desc, sdesc, mark, colors)\\n        var sc = storage0.getItem(mark, '0') == '0' ? '展开:' : '收起:';\\n        var dc = storage0.getItem(mark, '0') == '0' ? sdesc : desc;\\n        var cs = storage0.getItem(mark, '0') == '0' ? colors.hide : colors.show;\\n        d.push({\\n            title: '' + '<b><font color=\\\"#098AC1\\\">∷剧情简介\\t</font></b>' + \\\"<small><a style='text-decoration: none;' href='\\\" + lazy + \\\"'>\\\" + sc + '</a></small><br><font color=\\\"' + cs + '\\\">' + `${dc}` + '</small>',\\n            col_type: 'rich_text',\\n            extra: {\\n                id: 'desc',\\n                lineSpacing: 6,\\n                textSize: 15,\\n                lineVisible: true,\\n            }\\n        })\\n    }\\n}\\n\\n$.exports = apiview;\"},{\"col_type\":\"movie_3\",\"name\":\"小中听书一级\",\"path\":\"cla\",\"rule\":\"var html11 = request('http://tingshu.kuwo.cn/v2/api/search/filter/albums?classifyId=44&notrace=0&source=kwplayer_ar_9.1.8.1_tvivo.apk&platform=1&kweexVersion=1.1.5&uid=2511482006&sortType=playCnt&loginUid=540339516&bksource=kwbook_ar_9.1.8.1_tvivo.apk&rn=20&categoryId=2&pn='+MY_PAGE); //log(html11)\\ntry{\\nvar list11 = JSON.parse(html11).data.data\\nlist11.forEach(item =>{\\n    var finished = item.finished == 1 ? '完结' : '连载'\\n    var img = item.coverImg\\n    d.push({\\n        title: item.albumName,\\n        desc: item.nowTotal+'集'+'-'+finished+'-'+item.artistName+'\\\\n'+item.title,\\n        img: img,\\n        url: `hiker://page/erji?page=fypage?albumId=${item.albumId}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.albumName.split('|')[0],\\n            desc: item.nowTotal+'集'+'-'+finished+'-'+item.artistName,\\n            img: img,\\n            albumId: item.albumId\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\"},{\"col_type\":\"movie_3\",\"name\":\"小中听书二级\",\"path\":\"erji\",\"rule\":\"js:\\nvar d = [];\\nvar html21 = request('http://search.kuwo.cn/r.s?stype=albuminfo&user=8d378d72qw28f5f4&uid=2511552006&loginUid=540129516&loginSid=958467960&prod=kwplayer_ar_9.1.8.1&bkprod=kwbook_ar_9.1.8.1&source=kwplayer_ar_9.1.8.1_tvivo.apk&bksource=kwbook_ar_9.1.8.1_tvivo.apk&corp=kuwo&albumid='+MY_PARAMS.albumId+'&pn='+(MY_PAGE-1)+'&rn=800&show_copyright_off=1&vipver=MUSIC_8.2.0.0_BCS17&mobi=1&iskwbook=1'); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21)\\nif (MY_PAGE == 1) {\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,data21.info.replace('\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n',''))\\nd.push({\\n    col_type: 'line_blank'\\n})\\nd.push({\\n    title: '正/反序',\\n    url: $('#noLoading#').lazyRule(() => {\\n        if(getMyVar('fx') != '1'){\\n        putMyVar('fx','1')\\n        toast('反序切换成功')\\n        }else{\\n        clearMyVar('fx')\\n        toast('正序切换成功')\\n        }\\n        refreshPage()\\n        return 'hiker://empty'\\n    }),\\n    col_type: 'text_center_1'\\n})\\n}\\nvar list21 = getMyVar('fx') == '1' ? data21.musiclist.reverse() : data21.musiclist\\nlist21.forEach(item =>{\\n    d.push({\\n        title: item.name,\\n        desc: (item.duration / 60).toFixed(2),\\n        url: $('http://mobi.kuwo.cn/mobi.s?f=web&source=kwplayer_ar_5.1.0.0_B_jiakong_vh.apk&type=convert_url_with_sign&rid='+item.musicrid+'&br=320kmp3').lazyRule(() => {\\n            var html = request(input); //log(html)\\n            try{\\n            var url = JSON.parse(html).data.url\\n            return url + '#isMusic=true#'\\n            }catch(e){log(e.message)}\\n        }),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n    refreshPage()\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"小兔听书一级\",\"path\":\"cla1\",\"rule\":\"var html11 = request('https://m.ximalaya.com/m-revision/page/category/queryCategoryAlbumsByPage?sort=0&pageSize=50&page='+MY_PAGE+'&categoryCode=youshengshu&subCategoryCode=reci235'); //log(html11)\\ntry{\\nvar list11 = JSON.parse(html11).data.albumBriefDetailInfos\\nlist11.forEach(item =>{\\n    var img = 'http://imagev2.xmcdn.com/'+item.albumInfo.cover\\n    d.push({\\n        title: item.albumInfo.title,\\n        desc: item.statCountInfo.trackCount+'集'+'-'+'连载'+'-'+item.anchorInfo.nickname+'\\\\n'+item.albumInfo.shortIntro,\\n        img: img,\\n        url: `hiker://page/erji1?page=fypage?albumId=${item.albumInfo.id}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.albumInfo.title.split('|')[0],\\n            desc: item.statCountInfo.trackCount+'集'+'-'+'连载'+'-'+item.anchorInfo.nickname,\\n            desc1: item.albumInfo.shortIntro,\\n            img: img,\\n            albumId: item.albumInfo.id\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\"},{\"col_type\":\"movie_3\",\"name\":\"小兔听书二级\",\"path\":\"erji1\",\"rule\":\"js:\\nvar d = [];\\nif (MY_PAGE == 1) {\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,MY_PARAMS.desc1)\\nd.push({\\n    col_type: 'line_blank'\\n})\\n}\\nvar page = MY_PAGE == 1 ? 1 : MY_PAGE + 4\\nvar html21 = request('http://zxcfgilkjouow.xima.run/TsApi/zhuanJi',{\\n    headers: {\\n        'biaoShi': 'feiyun',\\n        'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: 'core=XA&paiXu=正序&biaoJi=免费&pageNo='+page+'&isGengXin=true&sign=8e2f65814b942deb5469829478ce86f56094b70eea29021ca6d90a3496e5b17c&albumId='+MY_PARAMS.albumId+'&anNiuBiaoZhi=tingShu&time=_1734974895765&title='+MY_PARAMS.pageTitle+'&isDuoFen=1', \\n    method: 'POST'\\n}); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21).data\\ndata21.albumList.forEach(item =>{\\n    d.push({\\n        title: item.title,\\n        desc: item.riQiSc+'\\\\t\\\\t\\\\t'+item.durationStr,\\n        url: $('https://mobile.ximalaya.com/fmobile-track/fmobile/track/baseInfo/1734769375437?device=android&trackId='+item.trackId).lazyRule(() => {\\n            var html = request(input); //log(html)\\n            try{\\n            var url = JSON.parse(html).trackInfo.downloadAacUrl\\n            return url + '#isMusic=true#'\\n            }catch(e){log(e.message)}\\n        }),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"小兰听书一级\",\"path\":\"cla2\",\"rule\":\"if (MY_PAGE == 1) {\\nvar html11 = request('https://m.lrts.me/ajax/getResourceList?dsize=50&entityId=11&entityType=1&pageNum=1&showFilters=1'); //log(html11)\\ntry{\\nvar list11 = JSON.parse(html11).books\\nlist11.forEach(item =>{\\n    var state = item.state == 2 ? '完结' : '连载'\\n    var img = item.cover\\n    d.push({\\n        title: item.name,\\n        desc: state+'-'+item.announcer+'\\\\n'+item.desc,\\n        img: img,\\n        url: `hiker://page/erji2?page=fypage?id=${item.id}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.name.split('|')[0],\\n            desc: state+'-'+item.announcer,\\n            desc1: item.desc,\\n            img: img,\\n            albumId: item.id\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"小兰听书二级\",\"path\":\"erji2\",\"rule\":\"js:\\nvar d = [];\\nif (MY_PAGE == 1) {\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,MY_PARAMS.desc1)\\nd.push({\\n    col_type: 'line_blank'\\n})\\n}\\nvar html21 = request('https://m.lrts.me/ajax/getBookMenu?bookId='+MY_PARAMS.albumId+'&pageNum='+MY_PAGE+'&pageSize=40&sortType=0'); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21)\\ndata21.list.forEach(item =>{\\n    d.push({\\n        title: item.name,\\n        desc: (item.length / 60).toFixed(2),\\n        url: $('https://m.lrts.me/ajax/getPlayPath?entityId='+MY_PARAMS.albumId+'&entityType=3&opType=1&sections=['+item.section+']&type=0&section='+item.section+'&id='+item.id).lazyRule(() => {\\n            var html = request(input,{\\n                headers: {\\n                    'Cookie': 'token=ac72b3dd41a03d538325b9bfe9fbbda5b80a406064907472ea9f9fb7512fa2f6e1fa2d7ba647a4ab6a58327c88501121e90f2fc8f9cf4565f4d0c6f31d50d6d404f1078c857b1dca9bf97dedd4806f3e36f5985bfc1aa63cd2f1b6f0c80c5523; token.sig=0GLur_HCdyypUNpxxjBcxGzY8iU'\\n                },\\n                method: 'GET'\\n            }); //log(html)\\n            try{\\n            var url = JSON.parse(html).list[0].path\\n            return url + '#isMusic=true#'\\n            }catch(e){log(e.message)}\\n        }),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"小老听书一级\",\"path\":\"cla3\",\"rule\":\"var html11 = request('https://apk-lb-json.fodexin.com/json/v1/cat_list/46/index/'+MY_PAGE+'.json',{\\n    headers: {\\n        'referer': 'https://apk.jqkan.com/'\\n    },\\n    method: 'GET'\\n}); //log(html11)\\ntry{\\nvar list11 = JSON.parse(html11).data.books\\nlist11.forEach(item =>{\\n    var status = item.status\\n    var img = 'https://pic.iiszg.com/'+item.pic\\n    d.push({\\n        title: item.name,\\n        desc: item.count+'集-'+status+'-'+item.teller+'\\\\n'+item.synopsis,\\n        img: img,\\n        url: `hiker://page/erji3?id=${item.book_id}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.name.split('|')[0],\\n            desc: item.count+'集-'+status+'-'+item.teller,\\n            desc1: item.synopsis,\\n            img: img,\\n            albumId: item.book_id\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\"},{\"col_type\":\"movie_3\",\"name\":\"小老听书二级\",\"path\":\"erji3\",\"rule\":\"js:\\nvar d = [];\\nvar albumId = MY_PARAMS.albumId\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,MY_PARAMS.desc1)\\nd.push({\\n    col_type: 'line_blank'\\n})\\nvar html21 = request('https://apk-lb-json.fodexin.com/json/v1/cont/'+albumId+'.json',{\\n    headers: {\\n        'referer': 'https://apk.jqkan.com/'\\n    },\\n    method: 'GET'\\n}); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21).data\\ndata21.play_data.forEach(item =>{\\n    d.push({\\n        title: item.name,\\n        url: $(item.play_id).lazyRule((albumId) => {\\n            function getUnixTimestamp() {\\n                const now = new Date();\\n                // 获取年月日时分，确保秒和毫秒都为 0\\n                now.setSeconds(0, 0);\\n                // 获取 10 位 Unix 时间戳\\n                const timestamp = Math.floor(now.getTime() / 1000);\\n                // 强制转换为字符串后返回\\n                return timestamp.toString();\\n            }\\n            var params1 = JSON.stringify({\\\"m\\\":\\\"play\\\",\\\"aid\\\":albumId,\\\"pid\\\":input,\\\"t\\\":md5(md5('play'+albumId+input)+'1449682949'+getUnixTimestamp())}); //log(params1) \\n            var rsakey = 'MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtSwotbu7UEonUCzCsJXPSpYOrkuMnpyk24PBQskkcwYZsUTwbh8Y9vHuPIerh3AfZZ1luFV9yPC282xiNX+/+IAzWHWG6M+dWmJnDyybeUVTh7H7YVM31eSR9TFT4VASr7NftgCv7hfS2mVNL0sxRrMSPSXa6SbjkIeW4GTpYpWKehKfaqrgDwVfFCu67ogL9JLIdDxvWthIe42uUMnz4II1/pdrPtWRu0CDjaxvsLz26UdMGSL3gFEloaJhp4KuIPK4RlIx+9t28H00+3IpeVirmiayDYJQe1cjiDKoERSkLubJRD2yj5X3trGmgXex3QkcRtx5UNXYkLEuEMNGiwIDAQAB'; \\n            var params = rsaEncrypt(params1, rsakey); //log(params)\\n            var html = request('https://apk-lb-play.fodexin.com/api2/web/index.php/?r=api',{ \\n                headers: {\\n                    'referer': 'https://apk.jqkan.com/'\\n                },\\n                body: 'params='+params+'&version=1.1.5&', \\n                method: 'POST'\\n            }); //log(html)\\n            try{\\n            var url = JSON.parse(html).data.url + '#isMusic=true#'\\n            return JSON.stringify({\\n                urls: [url],\\n                headers: [{\\\"referer\\\": \\\"https://apk-lb.iiszg.com/\\\"}]\\n            })\\n            }catch(e){log(e.message)}\\n        },albumId),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"小凡听书一级\",\"path\":\"cla4\",\"rule\":\"if (MY_PAGE == 1) {\\nvar html11 = request('https://api5-lq.novelfm.com/novelfm/bookmall/recommend/book/list/v1/?iid=2711865059748308&device_id=3696994186429390&ac=wifi&channel=novelfm_yunying_guanwang2&aid=3040&app_name=novel_fm&version_code=504&version_name=5.0.4.32&device_platform=android&os=android&ssmix=a&device_type=HD1910&device_brand=OnePlus&language=zh&os_api=22&os_version=5.1.1&manifest_version_code=504&resolution=720*1280&dpi=192&update_version_code=50432&_rticket=1691654654122&comment_tag_c=5&vip_state=0&rom_version=OnePlus-userdebug+5.1.1+20171130.276299+release-keys&ab_sdk_version=5711287%2C6740315&category_style=1&need_personal_recommend=1&cdid=482eb26f-b798-487d-a2c0-01f50a5f0d71',{\\n    body: JSON.stringify({\\n      \\\"is_opposite\\\": false,\\n      \\\"sticky_ids\\\": [],\\n      \\\"category_id\\\": 7,\\n      \\\"offset\\\": 0,\\n      \\\"req_sequence\\\": 0,\\n      \\\"tab_type\\\": 0,\\n      \\\"background_filter_video\\\": false,\\n      \\\"limit\\\": 300,\\n      \\\"is_k_songs\\\": false,\\n      \\\"cell_id\\\": \\\"\\\",\\n      \\\"scene\\\": 114\\n    }),\\n    method: 'POST'\\n}); //log(html11) \\ntry{\\nvar list11 = JSON.parse(html11).data.books\\nlist11.forEach(item =>{\\n    var img = item.audio_thumb_uri\\n    d.push({\\n        title: item.book_name,\\n        desc: '连载'+'-'+item.author+'\\\\n'+item.abstract,\\n        img: img,\\n        url: `hiker://page/erji4?albumId=${item.book_id}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.book_name.split('|')[0],\\n            desc: '连载'+'-'+item.author,\\n            desc1: item.abstract,\\n            img: img,\\n            bookId: item.book_id\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"小凡听书二级\",\"path\":\"erji4\",\"rule\":\"js:\\nvar d = [];\\nvar bookId = MY_PARAMS.bookId\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,MY_PARAMS.desc1)\\nd.push({\\n    col_type: 'line_blank'\\n})\\nvar html21 = request('https://fanqienovel.com/api/reader/directory/detail?bookId='+bookId); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21).data\\ndata21.chapterListWithVolume[0].forEach(item =>{\\n    d.push({\\n        title: item.title,\\n        url: $(item.itemId).lazyRule((bookId) => {\\n            var html = request('https://api5-lf.novelfm.com/novelfm/playerapi/video_model/mget/v1/?is_retry=false&iid=734954504327623&device_id=2195048912397567&ac=wifi&channel=update_64&aid=3040&app_name=novel_fm&version_code=480&version_name=4.8.0.18&device_platform=android&os=android&ssmix=a&device_type=V1923A&device_brand=vivo&language=zh&os_api=28&os_version=9&manifest_version_code=480&resolution=900*1600&dpi=240&update_version_code=48018&_rticket=1677650441120&need_personal_recommend=1&comment_tag_c=5&vip_state=0&category_style=1&ab_sdk_version=5548515%2C5522350%2C90093450%2C4855051%2C90093386&rom_version=PQ3A.190705.003+release-keys&cdid=eb7b44c1-e3d1-44fd-8fcd-f90be1deb3ef',{ \\n                body: JSON.stringify({\\n                  \\\"tone_id\\\": 0,\\n                  \\\"bgm_used\\\": 0,\\n                  \\\"item_ids\\\": [input],\\n                  \\\"audio_type\\\": 0,\\n                  \\\"source\\\": \\\"preload\\\",\\n                  \\\"book_id\\\": bookId\\n                }),\\n                method: 'POST'\\n            }); //log(html)\\n            try{\\n            var html2 = JSON.parse(html).data.video_model_datas[0].video_model; //log(html2)\\n            var url = JSON.parse(html2).video_list[0].main_url; //log(url)\\n            return url + '#isMusic=true#'\\n            }catch(e){log(e.message)}\\n        },bookId),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"收音机一级\",\"path\":\"cla5\",\"rule\":\"if (MY_PAGE == 1) {\\nvar title51 = [\\\"地方电台\\\",\\\"分类电台\\\",\\\"网络电台\\\"]\\nvar url51 = [\\n    \\\"locationTypeId=0&locationId=440000&pageSize=50&pageNum=1&categoryId=0&\\\",\\n    \\\"locationTypeId=0&locationId=0&pageSize=50&pageNum=1&categoryId=14&\\\",\\n    \\\"locationTypeId=4&locationId=0&pageSize=50&pageNum=1&categoryId=0&\\\"\\n]\\n//log(getMyVar('url51'))\\ntitle51.forEach( (item,index) => {\\n    var url = url51[index]\\n    d.push({\\n        title: getMyVar('index51','0') == index ? \\\"““\\\"+item+\\\"””\\\" : item,\\n        url: $('#noLoading#').lazyRule((index,url) => {\\n            putMyVar('index51',index)\\n            putMyVar('url51',url)\\n            refreshPage()\\n            return 'hiker://empty'\\n        },index,url),\\n        col_type: 'scroll_button'\\n    })\\n})\\nd.push({\\n    col_type: 'blank_block'\\n})\\nvar title52 = [\\\"地方电台\\\",\\\"分类电台\\\",\\\"网络电台\\\"]\\nvar url52 = [\\\"0\\\",\\\"1\\\",\\\"2\\\"]\\n//log(getMyVar('url51'))\\ntitle52.forEach( (item,index) => {\\n    var url = url52[index]\\n    d.push({\\n        title: getMyVar('index52','0') == index ? \\\"““\\\"+item+\\\"””\\\" : item,\\n        url: $('#noLoading#').lazyRule((index,url) => {\\n            putMyVar('index52',index)\\n            putMyVar('url52',url)\\n            refreshPage()\\n            return 'hiker://empty'\\n        },index,url),\\n        col_type: 'scroll_button'\\n    })\\n})\\n}\\nvar html11 = request('https://mobile.ximalaya.com/radio-first-page-app/search?'+getMyVar('url51','locationTypeId=0&locationId=440000&pageSize=50&pageNum=1&categoryId=0&')); //log(html11) \\ntry{\\nvar list11 = JSON.parse(html11).data.radios\\nlist11.forEach(item =>{\\n    var img = item.coverLarge\\n    d.push({\\n        title: item.name,\\n        desc: '直播中：'+item.programName,\\n        img: img,\\n        url: `hiker://page/erji5?id=${item.id}#immersiveTheme#`,\\n        col_type: 'movie_1_vertical_pic',\\n        extra: {\\n            pageTitle: item.name.split('|')[0],\\n            desc: '直播中：'+item.programName,\\n            img: img,\\n            id: item.id\\n        }\\n    })\\n})\\n}catch(e){log(e.message)}\"},{\"col_type\":\"movie_3\",\"name\":\"收音机二级\",\"path\":\"erji5\",\"rule\":\"js:\\nvar d = [];\\nvar id = MY_PARAMS.id\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\nd.push({\\n    col_type: 'line_blank'\\n})\\nvar html21 = request('https://live.ximalaya.com/live-web/v1/getProgramSchedules?radioId='+id+'&device=ios'); //log(html21) \\ntry{\\nvar data21 = JSON.parse(html21).result\\nd.push({\\n    title: '今天的时间表',\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\ndata21.todaySchedules.forEach(item =>{\\n    d.push({\\n        title: item.programName,\\n        desc: item.startTime+'-'+item.endTime,\\n        url: item.listenBackUrl+'#isMusic=true#',\\n        col_type: 'text_1'\\n    })\\n})\\nd.push({\\n    col_type: 'line_blank'\\n})\\nd.push({\\n    title: '明天的时间表',\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\ndata21.tomorrowSchedules.forEach(item =>{\\n    d.push({\\n        title: item.programName,\\n        desc: item.startTime+'-'+item.endTime,\\n        url: item.listenBackUrl+'#isMusic=true#',\\n        col_type: 'text_1'\\n    })\\n})\\nd.push({\\n    col_type: 'line_blank'\\n})\\nd.push({\\n    title: '昨天的时间表',\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1'\\n})\\ndata21.yesterdaySchedules.forEach(item =>{\\n    d.push({\\n        title: item.programName,\\n        desc: item.startTime+'-'+item.endTime,\\n        url: item.listenBackUrl+'#isMusic=true#',\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"小六听书二级\",\"path\":\"erji6\",\"rule\":\"js:\\nvar d = [];\\nvar code = MY_PARAMS.code\\nd.push({\\n    title: MY_PARAMS.pageTitle,\\n    desc: MY_PARAMS.desc,\\n    img: MY_PARAMS.img,\\n    url: 'hiker://empty',\\n    col_type: 'movie_1_vertical_pic_blur',\\n    extra: {\\n        gradient: true\\n    }\\n})\\n$.require(\\\"hanshu\\\").setDesc(d,MY_PARAMS.desc1)\\nd.push({\\n    col_type: 'line_blank'\\n})\\nvar html21 = request('http://m.6yueting.com/list/'+code); //log(html21)\\ntry{\\nvar data21 = pdfa(html21, '.book-list&&a')\\ndata21.forEach(item =>{\\n    d.push({\\n        title: pdfh(item, 'a&&Text'),\\n        url: $(pdfh(item, 'a&&href')).lazyRule(() => {\\n            var t = (new Date().getTime()).toString(); //log(t)\\n            var sign = md5(t+input.split('/')[2]+input.split('/')[3]+'FRDSHFSKVKSKFKS'); //log(sign)\\n            var html = request('http://m.6yueting.com/web/index/video_new?code='+input.split('/')[2]+'&no='+input.split('/')[3]+'&type=0&timestamp='+t+'&sign='+sign); //log(html) \\n            if(html.includes('videoUrl')){\\n            var url = JSON.parse(html).data.videoUrl\\n            return url + ';{Referer@http://m.6yueting.com/}'\\n            }\\n        }),\\n        col_type: 'text_1'\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('获取失败，请重试')\\n}\\nsetResult(d)\"}]","icon":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAIoAAACKCAYAAAB1h9JkAAAAAXNSR0IArs4c6QAAAARzQklUCAgI\nCHwIZIgAAB8bSURBVHic7Z1pcFvZld//5963YN/BBRQpUrvU2qze261ebM9kuu22PbaVZJaKPU7S\nM8n4WyaTfIvyIc4kjr9kEi+TSnmqUzXOWHZc3e1lEi/Tnva0u90tuxe1VkqiNq4AsS9vuzcfAEEk\n9SiRFEECJH5VLBAPwMMF3h/3nnvOuecCXbp06dKlS5cu7QetdwMAcACscctRb5PSeIw17nOX17E1\nad3qI1zuywX/241bp3HMafytG60XyvHjDOPjPJWCmutPhHUHSc6VuKqpUZtRiul6HzStlylKQnIK\nEaOwxpUwCF4wpkNCkxKeuad0SCqyQ4VCgOCS7Jv3JaQkIoMRWVIIA1JWDMvOMyDvOHYBtkgL05yC\n6UwojjVhCSvrVGSaw8ikM7kcxmEh9RcOjt8mwNVud4s4tk8LJw772Z7hAT0Z3QeF9kDTRqAow0xV\nthKjfknkufuJugAApAQjVhOOMyEd54pjWGOKIy6jZp5zssXTtdMXr+d7rTKOnzBb8farL5RnntF9\ng/GY5/4dB7w98WeFzu8nRRkkYv2SoK36+21iSMIE5ISwrGuaJd8uTs68bLwz9m55pjyLE6srmFUV\nSuAPjiWVPYP7I/t3/aGl8qNgFJNSekDtYAptbEhKA0BGNa1XSxevfdX4xan3i998Ob1q51+Vc3zu\nc3osKrf7Hjl4TIlHvmBCxlfhvF1WiCppxsnl/nv51be/k43xURz/SwO3DOYVcW9C+dYx7nsr2Bvf\nt/NJ9ET/paOrH4SU3e6jPZA+gTcq1yf/q3l18mfp96emcOLEimdObtPOpXH8KSWY37M9fGjn53gi\n+qeOwg6gPabbXeqQRdiihAIPybCPk0bXTUfPY2xsRbOjlQnl+efVAPftDN6//1+T3/cHglHvis7T\npeUIyDDz6IeUkD+o27UL1QMP5XHy5LLFsnyhPP+8GtDLOxO/8fh/crzaZ4jIt+xzdFk7iAAiD9O1\nQ57B/kFn7OI75uFHc8sVy/KE8vzzamSLvj/65ANftDTlOQJ1pNNrk8KFwvf6RwaHqZY/VROe9HKG\noaUL5dgxHtyb3Obbv+NfCa/26a5IOhOh0DYeCXk9Ie/7ldiWHE6fXtJsaGlCkZK87/y0P3xg2+cp\n4Ptsd7jpZIgxVR3hQU9N45Vz1Z++VVrKq5YmlCtXPL1Hhj/GE7E/lYyS99TOLusPwaPo+k5ifLR0\neOg8XnnbvttLljR8RMNil5bq+WOHUereW9mlHbAJKbUn+UeBvLF9Kc+/a48S+KPf7gk88dDnnIDv\nd9D1k2woBKdBTzyRFRH9tPWrc+U7PfeOQtl3/JhWGtz+oG9o4EsC6NolGw9SffoBB+qrVQrcwOjo\nop7bOw49V6b9seiO4X9uE2Kr38Yu7YAFREM7h/6pbzB+x2u8uFCO7dP8h4YPmqpydNVb16WtsDR+\n1HNk234cP7ZoGsiiQgknDvs9vfGPEWPdSPBGhyjm7U1+FOcr/sWe4i6U48cZ25YasHXlsJRSb1kD\nu7QFEvAIjR/pe+xICotowl0o4+Pc19e7jxgf7CYdbQ5I4YMI+fbh+eddJziuQtmyx69AY7uJs/7W\nNq9Lu0CM9XOvdzcwobo97iqUDBCTHm27ALrDziZBEumOwrYn7j8QdnvcVSjBYDguFT7c2qa1Dmr8\nMSKw5i2BEzWP33xel1swTdnqVE3XEI3idlAIimuqOtTShSIthBMhourQiENpBLmJACkBAQnTcVBy\nLFTFXUMcmwpS+Fbu9bnOcl2Foio8BkLHxXUYEZKqBw9EerE3EIWfa1CIwMAASEgQHOmgJhxM1sr4\ndTGNU8UMbNmpP4nVhThPMeKujjdXodgK+omoo+wTH1dwOJjEI9E+fDgxiG2+MDgIrDHc3OxSJABH\nShRsA7/MTeFH6Ws4VUzjarUIc5MLRgAe6dH73B5zEwpnPk9HzXYCioYjwQQ+P3QfjgR7ENM9d7U/\nAoqKZ3q82BeI4UfpqzgxMYqxWgGW2Nxiga6kUI8Bzov7uAoFippYk0atAl6m4EgoiS8MH8LDkd6m\nTbIUdMaxKxBFQvPCEALfnRrFWLUIIe9pCUxHw3Qtifok565CYYzzjnDbK8RwXyCGT/ftwMFgHHyO\nSKSUKAsbOdOAIR1IKcGJ4OMqIqoOlVhz9hNWdXysZxhEwF9eO42MZUDe23qpjoUYxVDvUay5x117\nFMl5tN2njgQgomh4LNqPx6J9CChac7gxhIMZo4r3immcKc0iY9UgpITKGAY8QRwKxrHTH0VE1cCJ\ngRNh2BfCE9EBvJmbwi+yEzA3a6+iKFG4pJ+4CYWIIdD6Ft0bBGDIG8LD0T7ENW9TJLYQmDIq+Ob4\nebw0dQkTtRJEY2pMRFBBOBLuwe8P7MFT8QEElXrAVGMcg74gno5vwdvFGZhWS4oCtD8SIbi4mFx7\nFJ2rgXb7mhRiUBq/fk6EoKLiUCiO+4JxqHOGnLRVw4tTl/DX4+cxY1UhJaARA2cMlnBQlQJv5CZR\ndixY0sEnereDN4aguOrBx3u34duTo6g6OZhiXWvXrAseVQ1jyT0KyHePa5rvCQLAQAipOgJcgcY5\n+jQ/tngCCCkqenQf+jQfdvgjCCta09awpcTFcg4/nx1HxqoCAPp1Hz4QTqJX8+FStYBThTQyVg2j\n5Rx+mZvCkXAPhr0hSNQddWFFw9FoCmmjikmzsm7fwXohIL1ux117FGLkWU+hAEBc8+DZ5DAej6UQ\nUjT4Fa0uGsbhYRw+rkJjDBq7Jf6iZeDV2XGcL2dhS4mwquGTfdvxW8khJDQvrlaL+PbkKF6euoSy\nY+N0cRbvFdIY8gSbYmMNe8WvqEC7datrADHmg0tox92FL6W2noEQIkJc8+IjySE8HumHwhjoLukO\nUkrUpMCVagFlp+6a3+GL4IloCodCSSjEkNIDyJoGThdncaY0i8vVAn4+O45nekZAUoIaMaFe3Qed\nMRDW++eyDkgocLFR3JwODESuAlozJKASQ4CrUDm/q0iaL5OyUS2vfnn9XIVfUcEbn1tlDAFFhZcr\nYEQoOxbSVg2ybunWT0KAl3EoxDefSACAkQqXDsTVRhGQ61tbjQBLOMhaNWTMar1HAUFp+D54IyrM\nFzjXFKLGRa4fH6sWcKmSx4gvDA9jqDgOzpWzuNpwqkmqBwlBBNnoUdA8r9yUPYqQ0jVxybXnWO+v\nSEqJKbOKvxo/j19kJ5u9QELzIql5EeR1g7Zf90Fh9f6CGs60A6EkXstNomCbGK+V8f3pMZRsC726\nD2OVAv5v+irSZhWy8T6E+tyZWCPK3DgOok0nEgCgRWwOV6Gst7NNApi1avhJ5ho8dMtwjWoeRBQN\nAa4hpfvxRHwAj8f64eP1pCyfouLBcA/eDCWRNiswpcTfZ8cxVi0gzDXMWDVM1MpNARBRfZiipqMF\nsnEccr1/LuvDYh7pRXqU9vh6hJSoShtVYYOIMGlWmklJPq4ibVWxzRfCsC9UH5YADPtC+HjvNmSs\nKt7Op1FxbIyW8/PyUW4h62eTEmDz3f+btUdZrJtwjfUIgtou39LNZsgFLvWCbWK0mseZUhYpb6Bp\nlwS4iocjfchbNUwaVVyu5OvicPk8GnF4ic/rUQDUh6FN2qM4EBpcJjmuoVbZAQX7NMbBUZ+5zI32\nMiKEVQ2/mdyKAd1/WzSZGq8d8gTxeDSFx2L9YLglEgaCh3FojC86Xm9G1ncavEJUYtjjj+BY/048\nGO6Bh8031JuXd8G0mkAIKyoOh5J4Oj6Ix6L9GPYGwYnNmyL36z4cDiVwtVbEtFFdg0/U/nScULxc\nwW5/BJ/s3YHf7tuOANfmTZNtKTBjVHAyP4PJWrmZ5kgABj0BPBztxUeTw3gw0gc/V6HenO3M8czG\nVQ+eSY7gYqWArDkOa5NnvgEdJhSNcewLRPHPBvfjw/HBupu9gZQSlhS4Xi3h77I38K3x87hWK0Ki\nHlDs1Xz4vYHd+ETvNmzxBu84qKiMY3cggg9GUzhTmsWUUdl0tspCOkYoGjHs8UXw2YF9+HB8ED5+\nq+lCSpRsC2fLWbw0dQk/nBnDtFGFgIRCDFu9QXxh+BB+Iz6IsKovyfLwcw2PRvvwWnYCectAdRNG\nkufSEUJRGcNOXwT/aGAXjsZS8HGlOVRYwsG4UcbPMjfw8vQYRstZzFoGBOoZbSPeEH53YDeeiKYQ\n1nSwJRqoSiM4+Km+7UibVbxfzMDZxP1KRwglpfnxj1O78WxyBEnN0xSJLQWu1kr40cwVfGviAsaq\nRZji1uW8mV/ym4kh9Oi+JYsEqNsqAa7hg9EUfp2fwYRRxoy5eQ3bjigB+ngshQ9G+9Gje5sikVIi\naxn43tRlfOP6GVwo52CI+b/5hyJ9eDo+gEHvrTSC5aAQIaF58NHeEewLRJsJTpuRthaKzjgeCPfg\nmZ5hbPUG5z02bVbx0tQl/J+pUUwa5XnbX6nEMKAH8Inebdjpj9zTh2RE2B+I4ZFIP3q1zVudrG2F\ncjMv5FO9O3AgGIfO674SKSWKtonXc5P4zsQorlSKsBd4bWOaB5/q245DoSR8XF1ymsJi+BUVT8YH\n8Ei0D95N6ohrW6F4uYL9gTgejvYhourNi2NLgTdzU/ju5EWcKWdv83HojGPEG8QzPVuR0DwrGnLc\n2O6P4CPxQdwXjINvPp20p1AIQEhR8XRiCwY9gXm2wZRZwSuzN+pLKlymrCFFw+FQD4Y8QWirWIXd\nxxQ8GuvHww1H3WajLYWiMo7DoSQOBOPwcgWEeiS36th4PVtfd1NyLNfXBhQVu/wReJV7H3LmwogQ\nVzx4Mj6A+8PJeZn/m4G2/LQ+ruChSB/69UBz6HCEwNVaEa9lxzFWLbq+jogQYCqGvKGWXEjOGPYH\n4ngyPoiUvmhdvA1J2wmFAPRqPuzyRxGa46I3pINf52fwbjGNmuNe10Qnhh2BCPp1X8umsmFVx8Ph\nXjwS7ah1/PdM2wmFg7A3EEWP5oEyJypcsi2cLWVxrVrCYkkQPq7iYDCBkNraih3b/GF8JLEFB0MJ\nqLQ55kBtJxSV130nCc3bbJyExKliBu8V0yg79m1JTDdRGpFftcWOMR9X8EC4F5/u3Y6E5t0U0+W2\nEgoD4CGOg6EkQsqtIsqWEHh1dhzvl2bvmKZJROCEVZsSL/o+IMQ0Dx6M9GGvP9b08Wxk2koonBgi\nqgdhRYMyJ4c1ZxmYMSso2+4znebrQVDZ2oSvFGLY7gvj2d5h9Ou+Dd+rtJdQGENIURFUtHkBvIxV\nQ8Eyl5T0LaVYs4vm4wo+EEriidiWVfXZtCNt9ekUEKKaDoXRvOEj18gHuZtMHClgS7lmFZMYEQa9\nQTwe68eIL9ReX+Yq01afzaeo2OWPQqX5Y/6kUUHBvvuKcUkER8o1XZjkZQo+EOrBZ/p3wKdsXI9t\nWwnFyzh2+6NQFjSrYJswllAT1hIO0lYVhrN22WiMCAnVg6fiW3AkmERgg7r320ooGuOIqx5wNr9L\nqC//vPvry46NN7KTmL258HyNUBhDSvfjH6Z2YcgbXFbBwU6h7T6Rythtq67kEocTUzi4YZQxZVSw\n1nnzQUXDI5E+PBTpmze13yi0lVAE6knSkhYoZRk2R9E2cblaWPOyWowISd2Lp+MDGPAENtxkua2E\nUnNsXK+VYIv5QtGJ31biYjGKtoVTxTRqS5glrTacGPYHE/hk7zYk5xQg3Ai0lVAqjoNTxfRttel7\ndB8CfGmOtJJt4kwpi4vlHAyxuLu/FRCAuKrjaCyFQ6FEs8rCRqCthGI4Nm4Y5duEElM9S04WsqTA\nlUoBL05fwlRt7bPmVcaR8vjx0Z4RpHT/sjL/25m2EkrdRjFhSjHPaRZVdfgUZUkxHAkgZ5v4wfQY\n3inOoLgE/8tqE1I0PBXbgg/G+hFrcSR7rWgroVhSIGeZyJm1eb1KXPWgR/Mu2U1uS4EZs4oXpy7h\n/dLsovkrrYITQ0L34tmeYezYIMs82koojpQoWPWSWrU5s5agquFwsAfDPtddzBY91y9yk/hR+iqu\n10pw1njXDAJwMJjAU9EUBhcsNelE2kooAGDBaQ4ZNw1RAvB0YgseCC0vV7VgGfjRzDX8OH0NaasG\nZ42rEgQVDZ/s24HHI6l5a6U7kfYTihB4Mz+Nydp8p5mHMQx6g8tcgkG4XiviWxMX8OLUJVytldbU\nvQ/U7atHo/3Y7g13tMe27VouAIyWc7hcLaAyJ9NeZwr2BWLY4Y/cXqh9ESTqpTAuV/I4MXEB3x6/\ngLPlWRjO2vlYPFzB4VACD0X7EO1gw7bthAIAhYbTbNYymhdUYxxHwj14JNKHiLr0MrgSgCkFzpRm\n8cL4Gbxw/SzeK2aQMaprspcgJ8IWbwC/lRjCfcF4x06X21IoNWHjrfw0btRKzWkya2xo8FR8C46E\nk8ueSUgAWdPAi9OX8O8uvI4TkxcwWs6h5FiwhGhZD0OoZ94dCifxQLgHSc11T4K2x60XDwT/ycf/\nZM1bsgBbSgQVDbt8EfgbmzYREbxMQVXYuF4tIWsby77AthTI2yYulvM4V8nherWIUqNgICMG0ahg\nffP9VgOietXtiKqh7FgYreTbutxX8YWXvgygNPdYGwtFoGLb2B2Iolf3Qm0s3dAYR4/mA2OEs6VZ\nVFdgb9hSoOhYGK+VcK6cw1v5aVyo5FFxLOQsA46U8Cu36rutBkSEkKLDkRIXytn6rmSrdvbVpaOE\n4kgJQzrQGcfuQBSRhiFIRAiqGoJcRc42cL6cq2e1LROJuoOv5FiYtQ2MVQr4VWGmvtePXcVOXwTx\nVR4mFKpv2lC3wTKw2rSCk5tQ2tJGuUnRMvG96cv4u8wNzFq15nFCvUL1Z/p34kML6rmtBCllfR9C\ns4pxo4SrlWI9+tyCgGJc9eBoLIVHo/3QO2i63NYtdSAxY1bxg5kxvFdI18tuNS6ehys4GIzjc1v2\n4lN9O+Dn6pJTEe6EkBIOMG+3jdVEJYa9gRgej6aQ6CDDtiPche8UZvDy1GUEuIb9oTg0sOZuGveH\ne6AxDlsI/Dw7jmmzAvMe3PXN3TZubqCweh+jfn4ihBQNj8VSOFOexYtTl1BZ41jUSugIoRRtCz/J\nXIPCGBRG2BeMQ21cQm+jZwkO7sNufxTfm76MM+XZFX/5Emju39MqGBG2eUP4UGIQ7xczeLeYadl7\nrRaLbcOyxose7oxEfRHYj9NXQUT4XSIcCN7a7N3DFewMRBFTvRjw+PGz2Rv4ceYq0mZt2YZuo5Rg\ncyuWhWXSVwuNc9znj+HDiaGOFYrgYJZd32WhbXCkxIRRwf+buQKdOBwhG2Wy6ovFFGLo9fjwIXUQ\nW30hDHj8OFvO4Uwxg0mziopjNTdzAmjRVYeyMeC0yka5CQHo9/jxVGwAb+an8Ov8NCotMqCXAweZ\nwO0z97ber8eNKaOC706OImvV8HsDe7AnEEWAq81AoZc3YkK+MK7XSjiZn8apYgZj1SJu1ErI2jVU\nHRs1x3F1etEckbTCRpmLxjj2BGL4/JZ9+M9mFRfKOax/fexl7QDWvjvV1IchA6/M3kBVOHiuZwRP\nxAcQUtTmmmNGBJ1xbPOFMegJ4sn4FlytFDBayWPCKKPkWMhbBgwhmp7Ym+IgKbEzUN9PeS3GXi/j\nOBhK4LFIP6aN6jw3wPqwjB3A2stCuR0JiVmrhp9mriFjVpE2qzgUSmDIG0BE9UAh1nTD65yjh3kR\nU3XsC8ZgSwlbCthSNOyX238UOrGWF+O5CWcMCc2Lf5DcinPlLN7ITa1JsHIxlrWnoMLItKVsKxtl\nIUJK1Bwbb+QmcamSxyORPjwRH8BD4T70e/zQGWv6VRgRNKpv1rRwOFk4zLTaNnFDJYYd/jCOxgbw\nfjGD3Drk+d5C2nCxUdw8VI4jREfsIS4bf9NmFS9NX8Z/uPBL/NX4ObyRncDVWgk5y7jt17lQAjdF\nQQvurzVx1YtHIn3Y6Y+sa4ITAa5CcetRJCMy2tVGuRMFx8KJiQv428x1DHkDOBzqwYFgHIPeIPxc\ngb+x26nKOBTQuonCDYUI231hfHZgLyaNkxg3yiuKYd070tWedhOKI4WogbXPl7hUHCmRsWrI2Qau\n1Yp4u5BGUvNilz+CIW8Qg54AenQ/hn1BDHtDUOb0L1XHRqaRVytlfbjyMgURVb8tilywTeQso2EI\n33K33OutLQQGvAFs9YaQtU2U1mMIklTBUqfHAHX0fiOOlKg4NqqOjbRZxcVKHirVe5IezYvfH9iD\ngVQACq8LQEBitJzHd6ZGkTarIBA0xnAwGMczyWH06Lc2S7CFwFu5afzNzFijuI9sFExenVtHivr2\nvevkT5FSVuAynLj2KDXLLDG9rW3ZJXHz0xrCgQEH5Fh4IpbC0VgK2pxeomxbeCM/ib+ZHsNMY5f1\nhObBdm/4tqI+V6pFfH/6Ml6cvlTvUQDMnTutxq0j5ToNO4BlW3ngdnfOYjZKyeV4x9Oj+3BfIFbf\nv6cx7AgpkbNNnCqkkbNN1IQD3ihDutMfgb+RwlBPRRB4IzeJN/NTqHZAIG8lSCkLcOlRXGc9wnay\nrW/S2rPdF8buQBQ6Y01DtiZsnC9lcbo0i2oj69/LFXwkMYS9wSjURmlQASBtVnCunMWUUVmvj9B6\nHJFFfeYzDzehCHKc9o9SrYCDwQR2+6PznEozRhU/yVzDjVoZTuN31KP5cCTcg17d33ymLQUuVgs4\nX8rCcJ8YbAikbc9iqT2KbVrp1jdp7SAA23xh7A/G0bvAMJ00K/jF7AQqwoaEBCeGvf4oehfU089b\nJt7ITuBUKQN7jZenrimOPQPgtoK+rkJBzZpYUtG0DsHDOJ6KDeBQKAGtkaQtAUyYFbyencQ1owRL\nOI0sf47nerehX5tfsuJsaRYnCzPz1hptRESlNoEl9igg25wgovWOTq0KjAh+Rb2tNxFS4lI5j9ey\nE6g6NiTqAbq9gRjuDycRVufP+s6Ws7hcKaxx69cWJqWh2Jhwe8zVj+KYMqs4YgKcjbS2aa1HSglL\nSLyWm0DWMprDiSMFzpSzOFOab47Z0sG3J0fhZUrTGQYAP01fQ2bdI7stRuKGZdqu9qm7UKxqRjrO\nVdoIQgFQsOvb3v6Qrsw5SrClgDXH3qg6Nt4rzuJcObcgiiphSgl7g++mblvWFQdwtU/do8fR0LS0\n7DHS1Cdb27S1QQKNeit3vtAS9dmN7WxgY/VOWPYVo1CZdXvI1UZJv3olz2vmRZLSaG3LurQLBBgw\nnEuRai7n9rirUO4HLMeyz0gpx1vbvC5tgyMmuGOfGx8/6brXjatQTqZSjpkrnZGWfb21revSLgjb\nuVaZyZ5G6jnX8dm9Js0rr8hqJGhH9mzfLXX1MDpk/U+XlcEAQ6mZ36+9ceol47/8uWvmwOKpVJav\nXJma+T4J6WrcdNk4SCEzpanM9/Jpq7zYcxYXyokTJjt76RQ3rFdb0roubYNmOT833nn/XZw4sWim\n1B2TM9PnMrOlc2P/UyW2IaPJXQBFYrZwfux/bO3BHUeOO9fNGx112FC8rA30Ebz6UbT1Io4uy4ZI\nikz+y5WzF16+8cVv3jE+cdcCi9avzpXllr5p/8jAYcHZ0Oq1sst643HEL0uvvfXF/JdeGLvbc5e0\nLqAUHrloTaa/rkiMb6So8maGS4wbEzNfmb1UubSk5y/prK+84uj7d6VZLMhI1w6BaOn1O7u0HSRl\nTpQqXzNOXTxR/doLS7I/l7wFeLVvpKJ7nBsUCsRJ0w6gzas1dXFHSmmLau2vS++d+WruvsxVnDi9\npMDW0veKP31aVrbZBaXqH/P2JIaEwnatuLVd1g3NdH5Y/vXZPytct87h3/6vJWeIL10oAHByQtR2\nHs44Y6O/8o8MDguFbUO3Z+kIpJS2ZoofTvzgZ/+mvJ2fwb//C9eYzmIsTygAcPKkMA8/mqPy7Ps8\nFtKZqo6A0LVZ2hiSMicq1f9dfvfCn5VH2Fn84fJEAqxEKABw8qSoFZyMpzd4mvv8FUXXtwnC0jfT\n6bJmKEJeF6Xy10pnrny1YIXP4U++vKIFSSsTCgBMTIhKdCinwzxLjEZ9wcCARRhA1ynXHhBJbjp/\nLydm/mP27bPfKZ+ZuYavfGXFKXqrcVEJx4/r0fSFnf4nH/gUjwT/2CIkV+G8XVaITixtzeb/W+X1\nd0/MZuQlfOMbBmjhZtLLY1V//cHfeS6hP7jnvsCe7f/CUvlREMUl0Lmb1HQQJKUBiYxqO6+W3jv/\n9drZa6dK3zgxs1rnX/nQ44J56nylEhqYsHLTP5MkX/d6vSXHESbjTBLIB1rd99vsMAlTOuK6tK1T\nqJjfs29Mfyn7t6+9kKxMnJ/8+oururakdfbEsWNaOKH62b7BLd5ofB882m7B2QhpyghXlSEw1i/Q\nnS0tB5KoSSEmpGNflaZ9GaZ9GbZ51pgpnBZnx27k01b5TqkC9/TerTjpAhief54jBTUeSkYFk3E9\nqMeFYFHpUVJQlT7Fo/UKxhKc87BgCOmKGgHIS8Q8DoRGgApJRAQICQgGVUrZqUazVMAsSNGsRglG\nJkkYkNKQQlYtaeekLQskZV5Ydhq2PSWq1UlFyHHLtLLMkLMlx5mO5LX8+PjLFlLPOTh+vKVLB9rh\ny+aNP0I95ZLm3L/pzGO4va2dOoy5zTwc1FeLiAX3ncaxu6816dKlS5cuXbp02YT8f2wRoCSnDpID\nAAAAAElFTkSuQmCC","proxy":""}
Add Comment
Please, Sign In to add comment
