API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：点击查看 IPTV 分类 鲁滨逊漂流记 的聚搜结果-““鲁滨逊漂流记”” 1080P

xiaomianao666
Mar 19th, 2022
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 381.01 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥点击查看 IPTV 分类 鲁滨逊漂流记 的聚搜结果-““鲁滨逊漂流记””
  2. 1080P@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"js:\\neval(JSON.parse(fetch('hiker://page/chapter', {})).rule);\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"接口数据2022/2/7\",\"path\":\"ResCode\",\"rule\":\"{\\n    \\\"data\\\": [{\\n            \\\"title\\\": \\\"优质\\\",\\n            \\\"list\\\": [{\\n                    \\\"title\\\": \\\"1080p\\\",\\n                    \\\"url\\\": \\\"https://1080p.one/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1080p.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"1231D\\\",\\n                    \\\"url\\\": \\\"https://vue.app.yunboys.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1231D.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"300看世界\\\",\\n                    \\\"url\\\": \\\"https://300ys.xyz/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/300看世界.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"4K影院\\\",\\n                    \\\"url\\\": \\\"http://1api.4kdytv.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/4K影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"80K影视\\\",\\n                    \\\"url\\\": \\\"https://1080p.tv/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80K影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"CJT影院\\\",\\n                    \\\"url\\\": \\\"https://www.cjt521.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CJT影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"DC影视\\\",\\n                    \\\"url\\\": \\\"http://chaorenbb.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/DC影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"F7高清\\\",\\n                    \\\"url\\\": \\\"http://bc.haokanju1.cc/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/F7高清.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"HG影视\\\",\\n                    \\\"url\\\": \\\"http://hgyx.vip/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"l0l影院\\\",\\n                    \\\"url\\\": \\\"https://l0l.tv/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/l0l影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱看美剧\\\",\\n                    \\\"url\\\": \\\"https://www.uumjw.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱看美剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱酷影视\\\",\\n                    \\\"url\\\": \\\"https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱酷影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"菜鸟追剧\\\",\\n                    \\\"url\\\": \\\"http://81.71.18.95:5555/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟追剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"白嫖影视\\\",\\n                    \\\"url\\\": \\\"http://zgjxdtg.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白嫖影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱看影院\\\",\\n                    \\\"url\\\": \\\"http://www.a91.cm/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"初心影视\\\",\\n                    \\\"url\\\": \\\"https://www.18mv.club/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/初心影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"独播社\\\",\\n                    \\\"url\\\": \\\"http://35ys.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/独播社.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"叮当影视\\\",\\n                    \\\"url\\\": \\\"https://tv.0573wl.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/叮当影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"段友影视\\\",\\n                    \\\"url\\\": \\\"http://121.204.249.135:4433/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视3.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"段友影视\\\",\\n                    \\\"url\\\": \\\"https://shangjihuoke.com/api.php/tv.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"饭后电影\\\",\\n                    \\\"url\\\": \\\"http://summ.vip/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/饭后电影.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"飞捷影视\\\",\\n                    \\\"url\\\": \\\"https://www.fj6080.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞捷影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"疯狂看\\\",\\n                    \\\"url\\\": \\\"http://app.fkkdy.vip/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/疯狂看电影.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"粉象视界\\\",\\n                    \\\"url\\\": \\\"http://42.157.129.15:34444/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/粉象视界.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"汇聚库TV\\\",\\n                    \\\"url\\\": \\\"https://www.zzclove666.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/汇聚库TV.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"虎猫视频\\\",\\n                    \\\"url\\\": \\\"https://humaosp.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虎猫视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"可米影视\\\",\\n                    \\\"url\\\": \\\"http://www.kmys.vip/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"康耀影视\\\",\\n                    \\\"url\\\": \\\"http://app.ybyyds.cn/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/康耀影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"绿箭影视\\\",\\n                    \\\"url\\\": \\\"http://www.69ty.cc/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿箭影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"懒猫电影\\\",\\n                    \\\"url\\\": \\\"http://www.esellauto.com/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫电影.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"蜜蜂影视\\\",\\n                    \\\"url\\\": \\\"http://app.f8tp.com/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜蜂影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"麻瓜视频\\\",\\n                    \\\"url\\\": \\\"http://aliyun.k8aa.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻瓜视频1.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"美剧虫\\\",\\n                    \\\"url\\\": \\\"https://meijuchong.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧虫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"木子电影\\\",\\n                    \\\"url\\\": \\\"http://www.muzidy.top/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/木子电影.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"奈非迷\\\",\\n                    \\\"url\\\": \\\"https://app.netflixmi.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈非迷影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"南府影视\\\",\\n                    \\\"url\\\": \\\"http://iapp.nfuxs.club/dnmb.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/南府影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"暖光影视\\\",\\n                    \\\"url\\\": \\\"https://app.bl210.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/暖光影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"念念影视\\\",\\n                    \\\"url\\\": \\\"https://998.yuanmajs.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/念念影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"柠柚影视\\\",\\n                    \\\"url\\\": \\\"http://nu.e4tv.cn/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柠柚影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"奇怪视频\\\",\\n                    \\\"url\\\": \\\"https://giguai.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"七零动漫\\\",\\n                    \\\"url\\\": \\\"https://cf.70yu.cn/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七零动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"瑞丰资源\\\",\\n                    \\\"url\\\": \\\"https://tv.yjhan.com:4433/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/瑞丰.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"闪光影视\\\",\\n                    \\\"url\\\": \\\"http://101.35.128.192/mubai_api.php/m2.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/闪光影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"思乐影视\\\",\\n                    \\\"url\\\": \\\"https://www.huandian.top/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思乐影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"天诚影视\\\",\\n                    \\\"url\\\": \\\"http://tcspvip.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天诚影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"天天影视\\\",\\n                    \\\"url\\\": \\\"https://app.daishusc.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"温妮影视\\\",\\n                    \\\"url\\\": \\\"https://www.wenniys.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/温妮影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小白动漫\\\",\\n                    \\\"url\\\": \\\"http://121.62.60.222:20222/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小白动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"星辰视频\\\",\\n                    \\\"url\\\": \\\"https://m.hj0999.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星辰视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小极影视\\\",\\n                    \\\"url\\\": \\\"http://app.8d8q.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"心鸾影视\\\",\\n                    \\\"url\\\": \\\"http://zhiyutv.xyz/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/心鸾影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"雪人影视\\\",\\n                    \\\"url\\\": \\\"https://zy.qd234.cn/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雪人影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"益达影院\\\",\\n                    \\\"url\\\": \\\"http://luobu.yss6080.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/益达影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"雨果影视\\\",\\n                    \\\"url\\\": \\\"http://2.yhys63.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雨果影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"影视大全\\\",\\n                    \\\"url\\\": \\\"http://app.269w.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"月色影视\\\",\\n                    \\\"url\\\": \\\"http://69ty.cc/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月色影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"优视影视\\\",\\n                    \\\"url\\\": \\\"http://cc.ysys.asia/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优视影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"影阅阁\\\",\\n                    \\\"url\\\": \\\"http://221.236.18.12:665/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影阅阁.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"追剧吧\\\",\\n                    \\\"url\\\": \\\"http://zhuiju8.vip/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧吧影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                }\\n            ]\\n        },\\n        {\\n            \\\"title\\\": \\\"普通\\\",\\n            \\\"list\\\": [{\\n                    \\\"title\\\": \\\"51视频\\\",\\n                    \\\"url\\\": \\\"http://51shipin.cc/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/51视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"80影视\\\",\\n                    \\\"url\\\": \\\"http://www.ccc8.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"JDODO\\\",\\n                    \\\"url\\\": \\\"https://appys.jdodo.xyz/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/JDODO影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"QC影视\\\",\\n                    \\\"url\\\": \\\"https://www.qcsvip.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/QC影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"U5影视\\\",\\n                    \\\"url\\\": \\\"https://appx.uy07.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/U5影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"XG影视\\\",\\n                    \\\"url\\\": \\\"http://cms.xggm.top/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/XG影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"yoyo\\\",\\n                    \\\"url\\\": \\\"http://jx.wnvod.net/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/yoyo影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"阿里影视\\\",\\n                    \\\"url\\\": \\\"http://aliys.cn:90/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/阿里影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"嗷呜影院\\\",\\n                    \\\"url\\\": \\\"http://aowu.pro/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嗷呜影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱影视\\\",\\n                    \\\"url\\\": \\\"https://www.hzlff.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱追剧\\\",\\n                    \\\"url\\\": \\\"http://81.71.18.95:520/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱追剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"艾特影视\\\",\\n                    \\\"url\\\": \\\"https://www.aitee.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/艾特影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"白菜追剧\\\",\\n                    \\\"url\\\": \\\"http://lbapp.huimaojia.com:30119/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白菜追剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"比邻影视\\\",\\n                    \\\"url\\\": \\\"http://0hzy.cn:9990/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/比邻影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"百讯视频\\\",\\n                    \\\"url\\\": \\\"https://z.iopenyun.com:99/app_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/百讯视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"菜鸟动漫\\\",\\n                    \\\"url\\\": \\\"http://taikong.huangguay.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"大头影视\\\",\\n                    \\\"url\\\": \\\"http://dy.idsao.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大头影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"段友影视\\\",\\n                    \\\"url\\\": \\\"http://js.66app.me/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视2.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"豆渣影视\\\",\\n                    \\\"url\\\": \\\"http://douzhayss.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/豆渣影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"二九影视\\\",\\n                    \\\"url\\\": \\\"https://app.19kp.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二九影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"风启影视\\\",\\n                    \\\"url\\\": \\\"http://ysw.ee/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/风启影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"辉哥影视\\\",\\n                    \\\"url\\\": \\\"https://app.y.hgyule8.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/辉哥影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"黄河影视\\\",\\n                    \\\"url\\\": \\\"http://i.ledu8.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黄河影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"火星人\\\",\\n                    \\\"url\\\": \\\"https://www.huoxing9.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/火星人影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"晗先森\\\",\\n                    \\\"url\\\": \\\"https://hantv.top/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/晗先森影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"盒子影院\\\",\\n                    \\\"url\\\": \\\"http://i.nihaohezi.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/盒子影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"筋斗云\\\",\\n                    \\\"url\\\": \\\"https://tv.jindcloud.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/筋斗云影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"极光影院\\\",\\n                    \\\"url\\\": \\\"http://app.winxz.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/极光影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"聚合视频\\\",\\n                    \\\"url\\\": \\\"https://app.jhystv.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚合视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"久久影视\\\",\\n                    \\\"url\\\": \\\"http://s9t9.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"剧迷视频\\\",\\n                    \\\"url\\\": \\\"http://pan.hzafw.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/剧迷视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"橘子影视\\\",\\n                    \\\"url\\\": \\\"http://jz.juzidy.vip/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/橘子影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"快播吧\\\",\\n                    \\\"url\\\": \\\"http://app.hd8.pw/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/快播吧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"看剧吧\\\",\\n                    \\\"url\\\": \\\"http://app.ishen520.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看剧吧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"看看剧\\\",\\n                    \\\"url\\\": \\\"https://www.kankanju.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看看剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"酷酷影视\\\",\\n                    \\\"url\\\": \\\"http://www.ccc8.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/酷酷影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"可米影视\\\",\\n                    \\\"url\\\": \\\"http://sj.kmys.vip/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"绿豆视频\\\",\\n                    \\\"url\\\": \\\"https://v.lvdoui.cn/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿豆影音.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"蓝光视频\\\",\\n                    \\\"url\\\": \\\"http://vip.91iqiyi.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蓝光视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"林谷影视\\\",\\n                    \\\"url\\\": \\\"http://ys.linguyy.xyz/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/林谷影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"冷视TV\\\",\\n                    \\\"url\\\": \\\"https://len.tv/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷视TV.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"美剧范\\\",\\n                    \\\"url\\\": \\\"http://ttzmz.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧范.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"喵乐影视\\\",\\n                    \\\"url\\\": \\\"http://miaoleys.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/喵乐影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"名视影\\\",\\n                    \\\"url\\\": \\\"http://app.qqccv.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/名视影.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"麻子追剧\\\",\\n                    \\\"url\\\": \\\"http://b.2maz.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻子追剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"奈飞中文\\\",\\n                    \\\"url\\\": \\\"https://www.naifei.org/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈飞中文.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"苹果影视\\\",\\n                    \\\"url\\\": \\\"https://apple678.xyz/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/苹果影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"皮皮动漫\\\",\\n                    \\\"url\\\": \\\"http://dm.muying.me/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/皮皮动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"奇趣影视\\\",\\n                    \\\"url\\\": \\\"https://app.qiqu.me/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奇趣影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"任性看\\\",\\n                    \\\"url\\\": \\\"https://renxingkan.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/任性看.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"思奇影视\\\",\\n                    \\\"url\\\": \\\"http://app.siqitv.vip/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"三日影院\\\",\\n                    \\\"url\\\": \\\"https://www.3ri.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/三日影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"神马影视\\\",\\n                    \\\"url\\\": \\\"http://xs.78tv.cc/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/神马影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"视听星球\\\",\\n                    \\\"url\\\": \\\"http://zjyapijzys.shynwlkj.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/视听星球.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"土豆TV\\\",\\n                    \\\"url\\\": \\\"http://xiuxian.qd234.cn/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/土豆TV.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"淘剧社\\\",\\n                    \\\"url\\\": \\\"https://app.shuhai99.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/淘剧社.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"天空影视\\\",\\n                    \\\"url\\\": \\\"https://tv.51aizn.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"天天视频\\\",\\n                    \\\"url\\\": \\\"http://app.qianju.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"兔子窝\\\",\\n                    \\\"url\\\": \\\"http://cj.huimaojia.com:12345/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/兔子窝.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"我爱跟剧\\\",\\n                    \\\"url\\\": \\\"https://www.genmov.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/我爱跟剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"吾爱影视\\\",\\n                    \\\"url\\\": \\\"http://app.5lp.net/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"吾爱影视\\\",\\n                    \\\"url\\\": \\\"http://52ysw.xyz/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视1.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"吻痕视频\\\",\\n                    \\\"url\\\": \\\"http://www.kissone.cn/ruifenglb_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吻痕视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"蜗牛动漫\\\",\\n                    \\\"url\\\": \\\"http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜗牛动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"寻常影视\\\",\\n                    \\\"url\\\": \\\"http://tv.91ymz.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/寻常影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"熊猫动漫\\\",\\n                    \\\"url\\\": \\\"http://dongman.k8aa.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"熊猫视频\\\",\\n                    \\\"url\\\": \\\"http://anegh.com/lvdou_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"玺娜影视\\\",\\n                    \\\"url\\\": \\\"https://pp.wxina.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺娜影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小蜻蜓\\\",\\n                    \\\"url\\\": \\\"http://3ketv.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小蜻蜓视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"星球视频\\\",\\n                    \\\"url\\\": \\\"http://119.29.121.48:8088/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星球视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"玺心影视\\\",\\n                    \\\"url\\\": \\\"https://tv.arbd.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺心影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"新享影视\\\",\\n                    \\\"url\\\": \\\"https://app.jiagan.cx/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/新享影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"星影相随\\\",\\n                    \\\"url\\\": \\\"http://app.rootthree.top/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星影相随.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小易影视\\\",\\n                    \\\"url\\\": \\\"http://xy.irop.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小易影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"云城影院\\\",\\n                    \\\"url\\\": \\\"https://ayyf.cn/mubai_api.php/m2.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/云城影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"月儿影视\\\",\\n                    \\\"url\\\": \\\"https://yue52.xyz/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"樱花动漫\\\",\\n                    \\\"url\\\": \\\"https://www.dmwu.cc/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/樱花动漫.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"月亮影视\\\",\\n                    \\\"url\\\": \\\"http://ys.13tv.top/acj_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月亮影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"影视大全\\\",\\n                    \\\"url\\\": \\\"https://xc.xixi2yy.xyz/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全HD.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"影视热剧\\\",\\n                    \\\"url\\\": \\\"http://lb.26ys.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视热剧.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"渔渔影视\\\",\\n                    \\\"url\\\": \\\"http://luobo.yugenye.site/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/渔渔影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"优优影院\\\",\\n                    \\\"url\\\": \\\"http://xin.jjsvip.cc/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优优影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"柚子视频\\\",\\n                    \\\"url\\\": \\\"http://yz.26ys.cn/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柚子视频.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"鱼仔影视\\\",\\n                    \\\"url\\\": \\\"http://yuzaio.top/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/鱼仔影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"追剧达人\\\",\\n                    \\\"url\\\": \\\"https://www.zhuijudaren.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧达人.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"追剧猫\\\",\\n                    \\\"url\\\": \\\"http://tv.kmtvb.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧猫1.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"侦探影视\\\",\\n                    \\\"url\\\": \\\"http://ys.huangguay.com/mogai_api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/侦探影视.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"猪猪影院\\\",\\n                    \\\"url\\\": \\\"http://app.2zdyy.com/api.php/v1.vod\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/猪猪影院.png\\\",\\n                    \\\"murl\\\": \\\"q:APP影视\\\"\\n                }\\n            ]\\n        },\\n        {\\n            \\\"title\\\": \\\"IPTV\\\",\\n            \\\"list\\\": [{\\n                    \\\"title\\\": \\\"2号币\\\",\\n                    \\\"url\\\": \\\"http://phoebe.cf/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/2号币影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"CV影视\\\",\\n                    \\\"url\\\": \\\"http://www.cccvvv.top/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CV影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"HG影视\\\",\\n                    \\\"url\\\": \\\"http://api.hgyx.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"傲视影院\\\",\\n                    \\\"url\\\": \\\"http://j.zjj.life:88/mv/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/傲视影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"爱西西TV\\\",\\n                    \\\"url\\\": \\\"http://tv.aixixi.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱西西TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"白熊影院\\\",\\n                    \\\"url\\\": \\\"http://qt.yhzy.xyz/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白熊影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"刺桐影视\\\",\\n                    \\\"url\\\": \\\"http://tv.cttv.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/刺桐影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"尘梓TV\\\",\\n                    \\\"url\\\": \\\"http://cztv.vip:83/api.php/chenziystv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/尘梓TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"嘀哩嘀哩\\\",\\n                    \\\"url\\\": \\\"https://api.diliktv.xyz/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘀哩嘀哩TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"动力影视\\\",\\n                    \\\"url\\\": \\\"http://www.love9989.com/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/动力影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"大师兄\\\",\\n                    \\\"url\\\": \\\"http://dsxtv.tv.ci/api.php/dsx/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大师兄影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"二货影视\\\",\\n                    \\\"url\\\": \\\"http://d.zjj.life:88/mv/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二货影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"非凡影院\\\",\\n                    \\\"url\\\": \\\"http://cms.feifan12.xyz/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/非凡影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"飞扬TV\\\",\\n                    \\\"url\\\": \\\"http://diancj.zhenfy.cn/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞扬TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"嘿荼锋\\\",\\n                    \\\"url\\\": \\\"http://tv.hfys8.vip/api.php/Sntv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘿荼锋.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"黑龙影视\\\",\\n                    \\\"url\\\": \\\"http://vip.ji-ding-he.site/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黑龙影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"河马影院\\\",\\n                    \\\"url\\\": \\\"http://1.14.63.101/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/河马影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"聚多影视\\\",\\n                    \\\"url\\\": \\\"http://jdyy.weetai.cn/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚多影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"久久影院\\\",\\n                    \\\"url\\\": \\\"http://l.bhtv.org.cn/mv/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"乐酷TV\\\",\\n                    \\\"url\\\": \\\"http://150.138.78.177:2021/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/乐酷TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"懒猫TV\\\",\\n                    \\\"url\\\": \\\"http://www.esellauto.com/api.php/lh/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"六维影视\\\",\\n                    \\\"url\\\": \\\"http://liuweiiptv.gq:1357/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/六维影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"流星雨\\\",\\n                    \\\"url\\\": \\\"http://nn.lxyyy.xyz:8/c/api.php/WAiLaowang/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/流星雨影院.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"冷月TV\\\",\\n                    \\\"url\\\": \\\"https://tv.521x5.com/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷月TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"荔枝影视\\\",\\n                    \\\"url\\\": \\\"http://api.zjys.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/荔枝影视TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"免费看TV\\\",\\n                    \\\"url\\\": \\\"http://www.freekan.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/免费看TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"蜜果TV\\\",\\n                    \\\"url\\\": \\\"http://vv.miguotv.net/m/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜果TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"米来影视\\\",\\n                    \\\"url\\\": \\\"http://42.51.37.161:2346/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米来影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"米奇TV\\\",\\n                    \\\"url\\\": \\\"http://www.s6ep3.top/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米奇TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"七科影视\\\",\\n                    \\\"url\\\": \\\"http://tv.7kfm.cn/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七科影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"若惜影视\\\",\\n                    \\\"url\\\": \\\"http://rxw.ruoxinew.com/api.php/Sntv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/若惜影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"思奇TV\\\",\\n                    \\\"url\\\": \\\"http://tv.siqitv.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"双子星\\\",\\n                    \\\"url\\\": \\\"http://tv.diyoui.cc/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/双子星.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"山楂影视\\\",\\n                    \\\"url\\\": \\\"http://dy6.dcd1.cn/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/山楂影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"天空TV\\\",\\n                    \\\"url\\\": \\\"http://tv.tkys.tv/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"虾皮视频\\\",\\n                    \\\"url\\\": \\\"http://tv.cmt8.xyz/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虾皮视频.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小极TV\\\",\\n                    \\\"url\\\": \\\"http://api.8d8q.com/mmv/api.php/Chengcheng/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"小熊猫TV\\\",\\n                    \\\"url\\\": \\\"http://tv2.hetaoys.vip/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小熊猫TV.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                },\\n                {\\n                    \\\"title\\\": \\\"紫曦影视\\\",\\n                    \\\"url\\\": \\\"http://appys.azx.tools:88/api.php/iptv/vod/\\\",\\n                    \\\"img\\\": \\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/紫曦影视.png\\\",\\n                    \\\"murl\\\": \\\"q:TV影视\\\"\\n                }\\n            ]\\n        }\\n    ]\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"sear\",\"rule\":\"var res = {};\\nvar items = [];\\n//设置搜索线程\\nvar ssmode = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\nvar key = MY_URL.split('$$$')[1];\\n//setError(le);\\nif (ssmode == '0') {\\n    setPageTitle(key + ' 的搜索结果')\\n};\\ntry {\\n    var appfile = fetchCache('https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/APP.json', 24);\\n} catch (e) {\\n    appfile = '';\\n}\\nif (/emory/.test(appfile)) {\\n    var html = JSON.parse(appfile);\\n} else {\\n    log('当前加载的是内置数据');\\n    var html = JSON.parse(JSON.parse(fetch('hiker://page/ResCode', {})).rule);\\n};\\nvar dlist = html.data;\\n\\nfunction randomSort3(arr) {\\n    /*\\n        arr.sort(function(a, b) {\\n            return Math.random() - 0.5;\\n        });\\n    */\\n    return arr;\\n}\\n\\n//打乱顺序\\nvar random = true;\\nif (ssmode == '1' || MY_TYPE == 'home') {\\n    for (var l = 0; l < dlist.length; l++) {\\n        var list = dlist[l].list;\\n        var tytit = dlist[l].title;\\n        if (random) {\\n            let k = getVar(MY_RULE.title + \\\"-\\\" + tytit, \\\"\\\");\\n            if (k == \\\"\\\") {\\n                list = randomSort3(list)\\n                putVar(MY_RULE.title + \\\"-\\\" + tytit, JSON.stringify(list))\\n            } else {\\n                list = JSON.parse(k)\\n            }\\n        }\\n\\n\\n        items.push({\\n            title: MY_TYPE == \\\"home\\\" ? \\\"点击查看 \\\" + tytit + \\\" 分类 ““\\\" + key + \\\"”” 的聚搜结果\\\" : \\\"点击查看 \\\" + tytit + \\\" 分类 \\\" + key + \\\" 的聚搜结果\\\",\\n            url: $('hiker://empty$$$' + key + '$$$fypage$$$').rule((list, tytit) => {\\n                var res = {};\\n                var items = [];\\n                var nowDate = new Date();\\n                var month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\n                var day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\n                var dateStr = month + '' + day;\\n                //取搜索线程设置\\n                var ssxc = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).sscount;\\n                //设置超时时间，越小越快，单位毫秒\\n                var timeou = getItem('apptimout', '3000');\\n                var key = MY_URL.split('$$$')[1];\\n                var num = MY_URL.split('$$$')[2];\\n                var le = parseInt(num * ssxc);\\n                var Data = [];\\n                var Tit = [];\\n                for (var j = le - ssxc; j < le; j++) {\\n                    if (j < list.length) {\\n                        var link = list[j].url;\\n                        var litit = list[j].murl;\\n                        if (/TV/i.test(litit)) {\\n                            if (/19jx|293ys|zhaikanys|ji\\\\-ding\\\\-he|phoebe|yunbo\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(link)) {\\n                                var hmurl = link + '?ac=list&zm=' + key + '&page=1';\\n                            } else {\\n                                var hmurl = link + '?ac=list&wd=' + key + '&page=1';\\n                            }\\n                        } else {\\n                            if (/dijiaxia/.test(link)) {\\n                                link = 'http://www.dijiaxia.com/api.php/app/'\\n                            };\\n                            if (link.indexOf('api.php/app/') != -1) {\\n                                var hmurl = link + 'search?pg=1&text=' + key + '&token=';\\n                            } else if (link.indexOf('xgapp.php/v1/') != -1) {\\n                                var hmurl = link + 'search?pg=1&text=' + key;\\n                            } else {\\n                                if (/iopenyun/.test(link)) {\\n                                    var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\n                                } else {\\n                                    var hmurl = link + '?page=1&limit=10&wd=' + key;\\n                                }\\n                            }\\n                        }\\n                        //Data.push({url: hmurl,options: {headers: {\\\"User-Agent\\\": \\\"Dart/2.14 (dart:io)\\\"},timeout: timeou}});\\n                        Data.push({\\n                            url: hmurl,\\n                            options: {\\n                                headers: {\\n                                    \\\"User-Agent\\\": link.indexOf(\\\"mogai_api\\\") != -1 ? \\\"Dart/2.14 (dart:io)\\\" : \\\"okhttp/4.1.0\\\"\\n                                },\\n                                timeout: timeou\\n                            }\\n                        });\\n                        Tit.push({\\n                            tit: list[j].title,\\n                            link: link,\\n                            typnm: litit\\n                        });\\n                    } //if\\n                } //for j\\n\\n                //---代码分界线---- \\n                if (Data != '') {\\n                    var bhtml = batchFetch(Data);\\n                    //writeFile(\\\"hiker://files/rules/xyq/appError.json\\\",JSON.stringify(bhtml));\\n\\n                    for (var k = 0; k < bhtml.length; k++) {\\n                        var html = bhtml[k];\\n                        //log(html);\\n                        try {\\n                            html = html.substring(0, 2) == '\\\\r\\\\n' ? html.replace('\\\\r\\\\n', '') : html;\\n                        } catch (e) {}\\n                        if (/btwaf/.test(html)) {\\n                            html = fetch(Data[k].url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\"/)[1], {});\\n\\n                        }\\n                        if (html == \\\"\\\" || html == null || html.substring(0, 5) == 'error' || !html.startsWith('{')) {\\n\\n                            items.push({\\n                                title: Tit[k].tit + ' ' + '未搜索到，点击访问原网页',\\n                                url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\n                                col_type: 'text_1'\\n                            });\\n\\n                        } else if (html.length < 80) {\\n                            items.push({\\n                                title: Tit[k].tit + ' ' + '返回数据不完整，点击访问原网页',\\n                                url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\n                                col_type: 'text_1'\\n                            });\\n                        } else {\\n                            var html = JSON.parse(html);\\n                            //log(html);\\n                            var typet = Tit[k].typnm;\\n                            var tdomin = Tit[k].link;\\n                            if (html.list) {\\n                                var list = html.list;\\n                            } else if (html.data.list) {\\n                                var list = html.data.list;\\n                            } else if (html.data) {\\n                                var list = html.data;\\n                            } else {\\n                                var list = [];\\n                            }\\n                            if (list.length < 1) {\\n\\n                                items.push({\\n                                    title: Tit[k].tit + ' ' + '列表小于1，无法展示，点击访问原网页',\\n                                    url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\n                                    col_type: 'text_1'\\n                                });\\n\\n                            } else {\\n                                for (var i = 0; i < list.length; i++) {\\n                                    if (/TV/i.test(typet)) {\\n                                        var title = list[i].title;\\n                                        var pic = list[i].pic;\\n                                        var vid = list[i].nextlink;\\n                                        var rem = list[i].state;\\n                                    } else {\\n\\n                                        if (tdomin.indexOf('api.php/app/') != -1) {\\n                                            var title = list[i].vod_name;\\n                                            var pic = list[i].vod_pic;\\n                                            if (/fantuan/.test(tdomin)) {\\n                                                var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\n                                            } else {\\n                                                var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\n                                            }\\n                                            var rem = list[i].vod_remarks;\\n                                            //var con=list[i].type.type_des;\\n                                        } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\n                                            var title = list[i].vod_name;\\n                                            var pic = list[i].vod_pic;\\n                                            var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\n                                            var rem = list[i].vod_remarks;\\n                                            //var con=list[i].type.type_des;\\n                                        } else {\\n                                            var title = list[i].vod_name;\\n                                            var pic = list[i].vod_pic;\\n                                            if (/iopenyun/.test(tdomin)) {\\n                                                var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\n                                            } else {\\n                                                var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\n                                            }\\n                                            var rem = list[i].vod_remarks;\\n                                            //var con=list[i].type.type_des;\\n                                        }\\n\\n                                    }\\n                                    //var con=list[i].state;\\n                                    //log(vid);\\n\\n                                    items.push({\\n                                        title: MY_TYPE == \\\"home\\\" ? title.replace(key, '““' + key + '””') + '\\\\n' + rem : title + rem,\\n                                        pic_url: pic + '@Referer=',\\n                                        url: $(tdomin.indexOf(\\\"mogai_api\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((typet) => {\\n                                            var res = {};\\n                                            var items = [];\\n                                            var html = JSON.parse(getResCode());\\n                                            items.push({\\n                                                title: '',\\n                                                desc: '255&&float',\\n                                                url: '',\\n                                                col_type: 'x5_webview_single'\\n                                            });\\n                                            var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                                            if (/TV/i.test(typet)) {\\n                                                eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n                                            } else {\\n                                                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                                            }\\n\\n                                            res.data = items;\\n                                            setHomeResult(res);\\n                                        }, typet),\\n                                        //content: rem,\\n                                        desc: tytit + ' => ' + Tit[k].tit,\\n                                        col_type: 'movie_1_vertical_pic'\\n                                    });\\n                                } //for i\\n                            } //if list.length\\n                        }\\n                    } //for k bhtml.length\\n                }\\n\\n                res.data = items;\\n                setHomeResult(res);\\n            }, list, tytit),\\n            col_type: 'text_1'\\n        });\\n\\n    } //for i\\n}; //end mode 1\\n\\nif (ssmode == '0' || MY_TYPE == 'home') {\\n    for (var i = 0; i < dlist.length; i++) {\\n        var list = dlist[i].list;\\n        var tytit = dlist[i].title;\\n        if (random) {\\n            let k = getVar(MY_RULE.title + \\\"-\\\" + tytit, \\\"\\\");\\n            if (k == \\\"\\\") {\\n                list = randomSort3(list)\\n                putVar(MY_RULE.title + \\\"-\\\" + tytit, JSON.stringify(list))\\n            } else {\\n                list = JSON.parse(k)\\n            }\\n        }\\n\\n        items.push({\\n            title: MY_TYPE == \\\"home\\\" ? \\\" 选择一个 \\\" + dlist[i].title + \\\" 项目查看 ““\\\" + key + \\\"”” 的搜索结果\\\" : \\\" 选择一个 \\\" + dlist[i].title + \\\" 项目查看 \\\" + key + \\\" 的搜索结果\\\",\\n            col_type: 'text_1'\\n        });\\n\\n        for (var j = 0; j < list.length; j++) {\\n            var link = list[j].url;\\n            var litit = list[j].murl;\\n            if (/TV/i.test(litit)) {\\n                if (/19jx|293ys|zhaikanys|ji\\\\-ding\\\\-he|phoebe|yunbo\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(link)) {\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=fypage';\\n                } else {\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=fypage';\\n                }\\n            } else {\\n                if (/dijiaxia/.test(link)) {\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\n                };\\n                if (link.indexOf('api.php/app/') != -1) {\\n                    var hmurl = link + 'search?pg=fypage&text=' + key + '&token=';\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\n                    var hmurl = link + 'search?pg=fypage&text=' + key;\\n                } else {\\n                    if (/iopenyun/.test(link)) {\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\n                    } else {\\n                        var hmurl = link + '?page=fypage&limit=10&wd=' + key;\\n                    }\\n                }\\n            }\\n            items.push({\\n                title: list[j].title,\\n                img: list[j].img,\\n                url: $('hiker://empty#x#' + hmurl + '#x#' + link + '#x#' + litit + '#x#' + key + '#x#').rule(() => {\\n                    $.require('hiker://page/searerj');\\n                }),\\n                col_type: 'icon_round_small_4'\\n                //col_type: 'text_3'\\n                //link:link,\\n                //type: i\\n            });\\n\\n        } //for j\\n\\n\\n    } //for i\\n\\n} //end mode 0\\n\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"APP分类列表\",\"path\":\"applistdata\",\"rule\":\"if (html.list) {\\n    var list = html.list;\\n} else if (html.data && html.data.list) {\\n    var list = html.data.list;\\n} else {\\n    var list = html.data;\\n}\\n//log(list);\\nfor (var i = 0; i < list.length; i++) {\\n    var title = list[i].vod_name;\\n    var img = list[i].vod_pic;\\n    var url = list[i].vod_id;\\n    var desc = list[i].vod_remarks;\\n    var nowDate = new Date();\\n    var month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\n    var day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\n    var dateStr = month + '' + day;\\n    if (html.list) {\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (html.data && html.data.list) {\\n        if (murl.search(/mogai_api/) != -1) {\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else {\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\n        }\\n    } else {\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    };\\n    if (/fantuan/.test(murl)) {\\n        var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (/iopenyun/.test(murl)) {\\n        var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (/dijiaxia/.test(murl)) {\\n        var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\n    }\\n    items.push({\\n        title: title,\\n        pic_url: img + '@Referer=',\\n        url: $(link).rule(() => {\\n            var res = {};\\n            var items = [];\\n            items.push({\\n                title: '',\\n                desc: '255&&float',\\n                url: '',\\n                col_type: 'x5_webview_single'\\n            });\\n            refreshX5WebView('');\\n            var html = JSON.parse(getResCode());\\n            var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n            try {\\n                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n            } catch (e) {}\\n            res.data = items;\\n            setHomeResult(res);\\n        }),\\n        desc: desc,\\n        col_type: 'movie_3_marquee'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"TV列表解析\",\"path\":\"tvlistdata\",\"rule\":\"var list = html.data;\\nfor (var i = 0; i < list.length; i++) {\\n    var title = list[i].title;\\n    var img = list[i].pic;\\n    var url = list[i].nextlink;\\n    var desc = list[i].state;\\n    url = url.startsWith('http') ? url : murl + '?ac=detail&ids=' + url;\\n    items.push({\\n        title: title,\\n        pic_url: img + '@Referer=',\\n        url: $(url).rule(() => {\\n            var res = {};\\n            var items = [];\\n            var html = JSON.parse(getResCode());\\n            var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n            items.push({\\n                title: '',\\n                desc: '255&&float',\\n                url: '',\\n                col_type: 'x5_webview_single'\\n            });\\n            refreshX5WebView('');\\n            try {\\n            eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n            } catch (e) {}\\n            res.data = items;\\n            setHomeResult(res);\\n        }),\\n        desc: desc,\\n        col_type: 'movie_3_marquee'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"APP简介与选集\",\"path\":\"appmovlist\",\"rule\":\"if (html.data.vod_url_with_player) {\\n    var conts = html.data.vod_url_with_player;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_play_from.split('$$$');\\n    }\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n    var conts = html.data.vod_info.vod_url_with_player;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_info.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_info.vod_play_from.split('$$$');\\n    }\\n} else {\\n    var conts = html.data.vod_play_list;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_play_from.split('$$$');\\n    }\\n}\\n\\n//log(conts);\\n\\nvar thumb = html.data.vod_info ? html.data.vod_info.vod_pic : html.data.vod_pic;\\nvar des = html.data.vod_info ? html.data.vod_info.vod_content : html.data.vod_content;\\nitems.push({\\n    title: '剧情简介：',\\n    desc: des,\\n    pic_url: thumb,\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\n        setResult([{\\n            title: des,\\n            col_type: 'long_text'\\n        }]);\\n    }, des),\\n    col_type: 'movie_1_vertical_pic'\\n});\\nvar jiek = '';\\nfor (var i = 0; i < conts.length; i++) {\\n    if (getVar('appmappsort', '1') == '1') {\\n        if (conts[i].urls) {\\n            var list = conts[i].urls;\\n        } else if (conts[i].url) {\\n            var list = conts[i].url.split(\\\"#\\\");\\n        } else {\\n            var list = conts[i].split(\\\"#\\\");\\n        };\\n    } else {\\n        if (conts[i].urls) {\\n            var list = conts[i].urls.reverse();\\n        } else if (conts[i].url) {\\n            var list = conts[i].url.split(\\\"#\\\").reverse();\\n        } else {\\n            var list = conts[i].split(\\\"#\\\").reverse();\\n        }\\n    };\\n    //setError(list.length);\\n    if (html.data.vod_url_with_player) {\\n        var ptab = conts[i].code ? conts[i].code : tabs[i];\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n        var ptab = conts[i].code ? conts[i].code : tabs[i];\\n    } else {\\n        var ptab = conts[i].from ? conts[i].from : tabs[i];\\n    }\\n    items.push({\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [conts.length] + \\\"““↓↑””\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\",\\n        col_type: 'scroll_button'\\n    });\\n    eval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\n\\n    for (var j = 0; j < list.length; j++) {\\n        if (conts[i].urls) {\\n            var vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\n            var title = list[j].name;\\n        } else {\\n            var vlink = list[j].split(\\\"$\\\")[1];\\n            var title = list[j].split(\\\"$\\\")[0];\\n        }\\n        try {\\n            if (html.data.vod_url_with_player) {\\n                var jiek = conts[i].parse_api;\\n            } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n                var jiek = conts[i].parse_api;\\n            } else {\\n                if (conts[i].player_info.parse2 && (conts[i].player_info.parse2).indexOf(\\\"=\\\") != -1) {\\n                    var jiek = (conts[i].player_info.parse2).match(/.*?url=|.*?v=|.*?vid=/)[0].replace(\\\"..\\\", \\\".\\\").replace('jsonbs', '');\\n                } else if (conts[i].player_info.parse && (conts[i].player_info.parse).indexOf(\\\"=\\\") != -1) {\\n                    var jiek = (conts[i].player_info.parse).match(/.*?url=|.*?v=|.*?vid=/)[0].replace(\\\"..\\\", \\\".\\\");\\n                } else {\\n                    var jiek = \\\"\\\";\\n                }\\n                //setError(jiek);                \\n            }\\n        } catch (e) {}\\n        //jiek拼接\\n        if (jiek != '' && jiek != null) {\\n            if (jiek.substring(0, 4) == 'http') {\\n                jiek = jiek;\\n            } else if (jiek.substring(0, 2) == '\\\\/\\\\/') {\\n                jiek = 'https:' + jiek;\\n            }\\n        } else {\\n            jiek = \\\"\\\";\\n        }\\n        //对失效接口进行替换\\n        if (/cokemv/.test(myurl) && /cokeqie|xin|90mm/.test(ptab)) {\\n            jiek = 'https://player.90mm.me/play.php?url=';\\n        } else if (/json\\\\.m3u8\\\\.tv|www\\\\.x-n\\\\.cc/.test(jiek)) {\\n            jiek = 'https://jx.m3u8.tv/jiexi/?url=';\\n        } else if (/cjt521/.test(myurl)) {\\n            jiek = conts[i].player_info.parse;\\n        } else if (jiek.indexOf('jpg.hou.lu/jm/za/index.php') != -1) {\\n            jiek = 'http://vip.mengx.vip/home/api?type=ys&uid=3249696&key=aefqrtuwxyEFHKNOQY&url=';\\n        } else if (ptab == 'renrenmi' && jiek.search(/jhdyw/) != -1) {\\n            jiek = 'http://www.1080kan.cc/jiexi/rrmi.php?url=';\\n        } else if (ptab == 'fqfilm' && jiek.search(/jhdyw/) != -1) {\\n            jiek = 'http://www.1080kan.cc/jiexi/fq.php?url=';\\n        } else if (ptab == 'rrsp' && jiek.search(/jhdyw/) != -1) {\\n            jiek = 'http://www.1080kan.cc/jiexi/rr.php?url=';\\n        } else if (/jhyun\\\\.php/.test(jiek)) {\\n            jiek = jiek.replace('http://svip.jhyun.jx.cn:1234/jhyun.php?url=', 'https://api.jhdyw.vip/?url=');\\n        };\\n        //打印接口\\n        try {\\n            if (j == '0') {\\n                if (html.data.vod_url_with_player) {\\n                    log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n                } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n                    log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n                } else {\\n                    if (conts[i].player_info.parse2 && (conts[i].player_info.parse2).indexOf(\\\"=\\\") != -1) {\\n                        log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + conts[i].player_info.parse2.replace(/\\\\.\\\\./g, \\\".\\\").replace(/\\\\,/g, \\\"\\\\n\\\\n\\\"));\\n                    } else if (conts[i].player_info.parse && (conts[i].player_info.parse).indexOf(\\\"=\\\") != -1) {\\n                        log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + conts[i].player_info.parse.replace(/\\\\.\\\\./g, \\\".\\\").replace(/\\\\,/g, \\\"\\\\n\\\\n\\\"));\\n                    } else {\\n                        log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n                    }\\n                    //setError(jiek);                \\n                }\\n            }\\n        } catch (e) {}\\n        //声明链接\\n        var link = jiek + vlink;\\n        /*\\n        if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos/.test(vlink) && /http/.test(vlink)) {\\n            link = vlink;\\n        }\\n        */\\n        //log(link);\\n        title = title.match(/(第|\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\n        if (list.length <= 4) {\\n            var clt = 'text_2';\\n        } else {\\n            var clt = isNaN(title) ? 'flex_button' : 'text_5'\\n        };\\n        items.push({\\n            title: title,\\n            url: $('').lazyRule((ptab, link, myurl, vlink) => {\\n                    function openurl(resurl) {\\n                        if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili|ixigua/) != -1) {\\n                            //html网页调用断插解析\\n                            var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                            if (enDn == '1') {\\n                                log('调用断插解析html');\\n                                eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                                eval(fetch(config.cj));\\n                                return aytmParse(resurl);\\n                            } else {\\n                                return resurl\\n                            };\\n                        } else if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(resurl) && /http/.test(resurl) && !/\\\\.html/.test(resurl) && !/\\\\=http/.test(resurl) && ptab != 'duoduozy') {\\n                            if (/wkfile/.test(resurl)) {\\n                                return resurl + ';{Referer@https://fantuan.wkfile.com/}'\\n                            } else {\\n                                return /\\\\=/.test(resurl) ? resurl.split('=')[1] : resurl + '#isVideo=true#';\\n                            }\\n                        } else {\\n                            //调用断插通用函数解析\\n                            var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                            if (enDn == '1') {\\n                                log('调用断插通用函数解析\\\\n' + ptab + '(通用函数)');\\n                                eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                                eval(fetch(config.cj));\\n                                var name = ptab + '(通用函数)';\\n                                return ParseS[name](resurl, myurl);\\n\\n                            } else if (ptab == 'duoduozy') {\\n                                eval(getCryptoJS());\\n\\n                                function De(word) {\\n                                    var a = CryptoJS.enc.Utf8.parse(md5('rXjWvXl6'))\\n                                    var t = CryptoJS.enc.Utf8.parse('NXbHoWJbpsEOin8b')\\n                                    return CryptoJS.AES.decrypt(word, a, {\\n                                        iv: t,\\n                                        mode: CryptoJS.mode.CBC,\\n                                        padding: CryptoJS.pad.Pkcs7\\n                                    }).toString(CryptoJS.enc.Utf8)\\n                                };\\n                                //var ddzy = 'adHuRo0dcuHoM163L1y4' + base64Encode(srcurl).slice(10);                                                       \\n                                var ddwy = fetch('https://jhpc.manduhu.com/duoduo/api.php', {\\n                                    headers: {\\n                                        \\\"User-Agent\\\": MOBILE_UA\\n                                    },\\n                                    body: 'url=' + resurl,\\n                                    method: 'POST'\\n                                });\\n                                //log(ddwy);\\n                                return De(JSON.parse(ddwy).url);\\n                            } else {\\n                                return resurl\\n                            };\\n                        }\\n                    };\\n                    var srcurl = link;\\n                    //log(srcurl);\\n                    //动态解析代码开始\\n                    try {\\n                        //处理指定视频与线路\\n                        if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\.html/.test(srcurl) && !/\\\\=http/.test(srcurl)) {\\n                            if (/wkfile/.test(srcurl)) {\\n                                return srcurl + ';{Referer@https://fantuan.wkfile.com/}'\\n                            } else {\\n                                return /\\\\=/.test(srcurl) ? srcurl.split('=')[1] : srcurl + '#isVideo=true#';\\n                            }\\n                        } else if (srcurl.indexOf(\\\"/share/\\\") != -1) {\\n                            try {\\n                                var link = srcurl.split(\\\"/share\\\")[0];\\n                                var fc = fetch(srcurl, {}).replace(\\\"var purl\\\", \\\"var main\\\");\\n                                if (fc.indexOf(\\\"main\\\") != -1) {\\n                                    var mat = fc.match(/var main.*?;/)[0];\\n                                    eval(mat);\\n                                    var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main);\\n                                } else {\\n                                    var main = fc.match(/url:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1];\\n                                    var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main)\\n                                };\\n                                return play;\\n                            } catch (e) {\\n                                return 'x5WebView://' + (srcurl)\\n                            }\\n\\n                        } else if (/983vip/.test(srcurl)) {\\n                            return JSON.parse(fetch(srcurl, {\\n                                headers: {\\n                                    \\\"User-Agent\\\": MOBILE_UA\\n                                },\\n                                redirect: false,\\n                                withHeaders: true\\n                            })).headers.location[0];\\n                        } else if (/x\\\\-n\\\\.cc|nhdz666/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                            return openurl(vlink);\\n                        }\\n                        //处理指定视频和线路结束\\n                        //----分割线----//\\n                        var scode = JSON.parse(fetch(srcurl, {\\n                            headers: {\\n                                \\\"User-Agent\\\": \\\"Dart/2.14 (dart:io)\\\"\\n                            },\\n                            redirect: false,\\n                            withStatusCode: true\\n                        }));\\n                        //log(scode);\\n                        if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                            //打开解析有302重定向的链接\\n                            var redurl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                            if (/\\\\=http/.test(redurl) && /html|bilibili/.test(redurl)) {\\n                                return JSON.parse(fetch(redurl, {})).url;\\n                            } else if (/\\\\=http/.test(redurl) && /\\\\.m3u8|\\\\.mp4|\\\\.flv/.test(redurl)) {\\n                                return redurl.substring(redurl.indexOf('=http') + 1);\\n                            } else {\\n                                return redurl\\n                            }\\n                        } else {\\n                            //var html = request(srcurl);\\n                            var html = scode.body;\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\n                                return openurl(vlink);\\n                            } else if (/\\\\<body/.test(html)) {\\n                                log('尝试非JSON接口网页解析');\\n                                requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\n                                return x5rule(srcurl, srcurl);\\n                                //return openurl(srcurl);\\n                            } else {\\n                                //json解析的取链接\\n                                var purl = html.match(/[\\\\'\\\\\\\"]url[\\\\'\\\\\\\"]:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1].replace(/\\\\\\\\/g, '');\\n                                //log(purl);\\n                                if (/http/.test(purl)) {\\n                                    if (ptab == 'bilibili') {\\n                                        return purl + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n                                    } else if (ptab == 'mgtv') {\\n                                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                                    } else if (/ojbk/.test(purl)) {\\n                                        return purl + ';{Referer@https://bak.ojbkjx.com/}';\\n                                    } else {\\n                                        return purl\\n                                    };\\n                                } else {\\n                                    //非http开头的打开原链接                                                                \\n                                    return openurl(vlink)\\n                                }\\n                            }\\n                        }\\n                    } catch (e) {\\n                        //报错判断处理\\n                        log('执行报错跳转处理');\\n                        /*if (srcurl.substring(0, 2) == '\\\\/\\\\/') {\\n                            return openurl('https:' + srcurl);\\n                        } else if (/\\\\=http/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                            //return srcurl.split('=')[1];\\n                            return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                        } else {*/\\n                        return openurl(vlink)\\n                        //return 'x5WebView://'+srcurl\\n                        //}\\n                    }\\n                    //动态解析代码结束\\n                },\\n                ptab,\\n                link,\\n                myurl,\\n                vlink),\\n            col_type: clt\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"TV简介与选集\",\"path\":\"tvmovlist\",\"rule\":\"var tabs = Object.keys(html.videolist);\\nvar thumb = html.img_url;\\nitems.push({\\n    title: '剧情简介：',\\n    desc: html.intro,\\n    pic_url: thumb,\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\n        setResult([{\\n            title: des,\\n            col_type: 'long_text'\\n        }]);\\n    }, html.intro),\\n    col_type: 'movie_1_vertical_pic'\\n});\\n\\nfor (var i = 0; i < tabs.length; i++) {\\n    if (getVar('appmtvsort', '1') == '1') {\\n        var list = html.videolist[tabs[i]];\\n    } else {\\n        var list = html.videolist[tabs[i]].reverse();\\n    };\\n    var ptab = tabs[i];\\n    items.push({\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [tabs.length] + \\\"““↓↑””\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('appmtvsort', getVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\",\\n        col_type: 'scroll_button'\\n    });\\n    eval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\n    for (var j = 0; j < list.length; j++) {\\n        var srcurl = list[j].url;\\n        if (/293jx1/.test(srcurl)) {\\n            srcurl = srcurl.replace('293jx1', 'jx');\\n        } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\:8|ppzhu/.test(myurl)) {\\n            srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\n        }\\n        var title = list[j].title;\\n        title = title.match(/(第|\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\n        if (list.length <= 4) {\\n            var clt = 'text_2';\\n        } else {\\n            var clt = isNaN(title) ? 'flex_button' : 'text_5'\\n        };\\n        items.push({\\n            title: title,\\n            url: $().lazyRule((ptab, srcurl, myurl) => {\\n                function openurl(resurl) {\\n                    if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili/) != -1) {\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                        if (enDn == '1') {\\n                            log('调用断插解析');\\n                            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                            eval(fetch(config.cj));\\n                            return aytmParse(resurl);\\n                        } else {\\n                            return resurl\\n                        };\\n                    } else {\\n                        return resurl\\n                    }\\n                };\\n                //log(srcurl);\\n                //动态解析代码开始\\n                try {\\n                    if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos/.test(srcurl) && /http/.test(srcurl)) {\\n                        return /\\\\=/.test(srcurl) ? srcurl.split('=')[1] : srcurl + '#isVideo=true#';\\n                    } else if (srcurl.indexOf(\\\"/share/\\\") != -1) {\\n                        try {\\n                            var link = srcurl.split(\\\"/share\\\")[0];\\n                            var fc = fetch(srcurl, {}).replace(\\\"var purl\\\", \\\"var main\\\");\\n                            if (fc.indexOf(\\\"main\\\") != -1) {\\n                                var mat = fc.match(/var main.*?;/)[0];\\n                                eval(mat);\\n                                var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main);\\n                            } else {\\n                                var main = fc.match(/url:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1];\\n                                var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main)\\n                            };\\n                            return play;\\n                        } catch (e) {\\n                            return 'x5WebView://' + (srcurl)\\n                        }\\n                    } else if (ptab == 'alizy') {\\n                        var purl = fetch('https://foubin.com/jiexi.php?url=' + srcurl, {}).match(/\\\\\\\"url\\\\\\\":\\\\\\\"(.*?)\\\\\\\"/)[1];\\n                        return purl;\\n                    } else if (/19jx\\\\.vip|nfyingshi/.test(srcurl)) {\\n                        var purl = JSON.parse(fetch(srcurl.replace('http://', 'https://'), {\\n                            headers: {\\n                                \\\"User-Agent\\\": MOBILE_UA\\n                            },\\n                            redirect: false,\\n                            withHeaders: true\\n                        })).headers.location[0];\\n                        if (/titan.mgtv/.test(purl)) {\\n                            return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                        } else if (/obj\\\\/tos/.test(purl)) {\\n                            return purl + '#isVideo=true#';\\n                        } else {\\n                            return purl\\n                        };\\n                    }\\n                    /*else if (/zhaikanys/.test(srcurl)) {\\n                                           var purl = JSON.parse(fetch(srcurl + '&app=10003&account=272775028&password=qq272775028', {\\n                                               headers: {\\n                                                   \\\"User-Agent\\\": MOBILE_UA\\n                                               },\\n                                               redirect: false,\\n                                               withHeaders: true\\n                                           })).headers.location[0];\\n                                           if (/titan.mgtv/.test(purl)) {\\n                                               return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                                           } else if (/obj\\\\/tos/.test(purl)) {\\n                                               return purl + '#isVideo=true#';\\n                                           } else {\\n                                               return purl\\n                                           };\\n                                       }*/\\n\\n                    //----分割线----//\\n                    var scode = JSON.parse(fetch(srcurl, {\\n                        headers: {\\n                            \\\"User-Agent\\\": MOBILE_UA\\n                        },\\n                        redirect: false,\\n                        withStatusCode: true\\n                    }));\\n                    //log(scode);\\n                    if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                        var purl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                    } else {\\n                        //var html = request(srcurl);\\n                        var html = scode.body;\\n                        //log(html);\\n                        if (/404 Not Found|备案后可继续访问/.test(html)) {\\n                            return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                        } else if (/\\\\\\\"url\\\\\\\"\\\\:\\\\\\\"http/.test(html)) {\\n                            var purl = html.match(/\\\\\\\"url\\\\\\\":\\\\\\\"(.*?)\\\\\\\"/)[1].replace(/\\\\\\\\/g, '');\\n                        } else if (html.startsWith('{')) {\\n                            var purl = srcurl.substring(srcurl.indexOf('=http') + 1);\\n                        } else {\\n                            //var purl = srcurl\\n                            requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\n                            return x5rule(srcurl, srcurl);\\n                            //return 'x5WebView://'+(srcurl) \\n                        }\\n                    };\\n                    //log(purl);\\n                    if (/titan.mgtv/.test(purl)) {\\n                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                    } else if (/obj\\\\/tos/.test(purl)) {\\n                        return purl + '#isVideo=true#';\\n                    } else {\\n                        return purl\\n                    };\\n\\n                } catch (e) {\\n                    if (srcurl.substring(0, 2) == '\\\\/\\\\/') {\\n                        return openurl('https:' + srcurl);\\n                    } else if (/\\\\=http/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                        //return srcurl.split('=')[1];\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                    } else {\\n                        return openurl(srcurl)\\n                    }\\n                }\\n                //动态解析代码结束\\n            }, ptab, srcurl, myurl),\\n            col_type: clt\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"列表模式搜索二级\",\"path\":\"searerj\",\"rule\":\"var res = {};\\nvar items = [];\\nvar nowDate = new Date();\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\nvar day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\nvar dateStr = month + '' + day;\\nvar spl = getResCode().split('#x#');\\nvar typet = spl[3];\\nvar tdomin = spl[2];\\nvar key = spl[4];\\n\\nif (/vipmv/.test(tdomin)) {\\n    var bhtml = request(spl[1]);\\n} else {\\n    var bhtml = fetch(spl[1], {\\n        headers: {\\n            \\\"User-Agent\\\": tdomin.indexOf(\\\"mogai_api\\\") != -1 ? \\\"Dart/2.14 (dart:io)\\\" : \\\"okhttp/4.1.0\\\"\\n        }\\n    });\\n}\\ntry {\\n    bhtml = bhtml.startsWith('\\\\r\\\\n') ? bhtml.replace('\\\\r\\\\n', '') : bhtml;\\n} catch (e) {}\\nif (/btwaf/.test(bhtml)) {\\n    /*\\n                items.push({\\n                    title:'有宝塔验证，点击访问原网页',\\n                    url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n                    col_type: 'text_1'\\n                });\\n                */\\n\\n    bhtml = fetch(spl[1] + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\"/)[1], {});\\n\\n}\\n\\nif (bhtml == \\\"\\\" || bhtml == null || bhtml.substring(0, 5) == 'error' || !bhtml.startsWith('{')) {\\n    items.push({\\n        title: '未搜索到相关资源，点击访问原网页',\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n        col_type: 'text_1'\\n    });\\n} else if (bhtml.length < 80) {\\n    items.push({\\n        title: '返回数据不完整，点击访问原网页',\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n        col_type: 'text_1'\\n    });\\n} else {\\n    var html = JSON.parse(bhtml);\\n    //log(spl[1]);\\n    if (html.list) {\\n        var list = html.list;\\n    } else if (html.data.list) {\\n        var list = html.data.list;\\n    } else if (html.data) {\\n        var list = html.data;\\n    }\\n\\n    if (list.length < 1) {\\n        items.push({\\n            title: '未搜索到，点击访问原网页',\\n            url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n            col_type: 'text_1'\\n        });\\n    } else {\\n        for (var i = 0; i < list.length; i++) {\\n\\n            if (/TV/.test(typet)) {\\n                var title = list[i].title;\\n                var pic = list[i].pic;\\n                //var vid=tdomin+'/detail?vod_id='+list[i].nextlink+'&rel_limit=10';\\n                var vid = list[i].nextlink;\\n                var rem = list[i].state;\\n                //var con=list[i].state;\\n            } else {\\n                if (tdomin.indexOf('api.php/app/') != -1) {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    if (/fantuan/.test(tdomin)) {\\n                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\n                    } else {\\n                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\n                    }\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                } else {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    if (/iopenyun/.test(tdomin)) {\\n                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\n                    } else {\\n                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\n                    }\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                }\\n            }\\n\\n            items.push({\\n                title: title.replace(key, '““' + key + '””'),\\n                pic_url: pic + '@Referer=',\\n                url: $(tdomin.indexOf(\\\"mogai_api\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((typet) => {\\n                    var res = {};\\n                    var items = [];\\n                    var html = JSON.parse(getResCode());\\n                    items.push({\\n                        title: '',\\n                        desc: '255&&float',\\n                        url: '',\\n                        col_type: 'x5_webview_single'\\n                    });\\n                    refreshX5WebView('');\\n                    var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                    if (/TV/.test(typet)) {\\n                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n                    } else {\\n                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                    }\\n                    res.data = items;\\n                    setHomeResult(res);\\n                }, typet),\\n                //content:rem,\\n                desc: rem,\\n                col_type: 'movie_1_vertical_pic'\\n            });\\n        } //for i\\n    } //else list.length\\n}\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"APP首页列表\",\"path\":\"appindexdata\",\"rule\":\"if (html.list) {\\n    var list = html.list;\\n} else if (html.data && html.data.list) {\\n    var list = html.data.list;\\n} else {\\n    var list = html.data;\\n}\\n\\nfor (var i = 0; i < list.length; i++) {\\n    if (list[i].vod_list) {\\n        var lists = list[i].vod_list;\\n        var typename = list[i].vod_type_name;\\n    } else {\\n        var lists = list[i].vlist;\\n        var typename = list[i].type_name\\n    }\\n    items.push({\\n        title: typename,\\n        col_type: 'text_1'\\n\\n    });\\n\\n    for (var j = 0; j < lists.length; j++) {\\n        var title = lists[j].vod_name;\\n        var img = lists[j].vod_pic;\\n        var url = lists[j].vod_id;\\n        var desc = lists[j].vod_remarks;\\n        var nowDate = new Date();\\n        var month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\n        var day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\n        var dateStr = month + '' + day;\\n        if (html.list) {\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (html.data && html.data.list) {\\n            if (murl.search(/mogai_api/) != -1) {\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n            } else {\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\n            }\\n        } else {\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        };\\n        if (/fantuan/.test(murl)) {\\n            var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (/iopenyun/.test(murl)) {\\n            var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (/dijiaxia/.test(murl)) {\\n            var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\n        }\\n        items.push({\\n            title: title,\\n            pic_url: img + '@Referer=',\\n            url: $(link).rule(() => {\\n                var res = {};\\n                var items = [];\\n                items.push({\\n                    title: '',\\n                    desc: '255&&float',\\n                    url: '',\\n                    col_type: 'x5_webview_single'\\n                });\\n                refreshX5WebView('');\\n                var html = JSON.parse(getResCode());\\n                var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                try {\\n                    eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                } catch (e) {}\\n                res.data = items;\\n                setHomeResult(res);\\n            }),\\n            desc: desc,\\n            col_type: 'movie_3_marquee'\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"首次导入等待\",\"path\":\"wait\",\"rule\":\"function canUse() {\\n    /*\\n    //如果更新了规则也要限流，可以修改key\\n    let key = \\\"lock4\\\"\\n    //等待分钟数\\n    let waitMin = 10\\n    \\n    let min = Math.round(Math.random() * 1000 * 60 * waitMin)\\n    let unlock = new Date().getTime() + min;\\n    let time = getItem(key, \\\"\\\");\\n    if (time == \\\"\\\") {\\n        setItem(key, \\\"\\\" + unlock)\\n        let st = new Date(unlock).toLocaleString().replace(/:\\\\d{1,2}$/, ' ');\\n        let msg = \\\"这是您第一次使用该版本规则，为避免第一次导入使用人数激增，规则将在\\\" + st + \\\"解锁使用。<br><br>好规则不怕晚，请耐心等待！该提示仅在第一次导入（更新）时出现，后续使用过程中不会出现！\\\"\\n        setResult([{\\n            title: msg,\\n            col_type: \\\"rich_text\\\"\\n        }])\\n        return false\\n    } else if (parseInt(time) < new Date().getTime()) {\\n        return true\\n    } else {\\n        let st = new Date(parseInt(time)).toLocaleString().replace(/:\\\\d{1,2}$/, ' ');\\n        let msg = \\\"为避免使用人数激增，规则将在\\\" + st + \\\"解锁使用。<br><br>好规则不怕晚，请耐心等待！该提示仅在第一次导入（更新）时出现，后续使用过程中不会出现！\\\"\\n        setResult([{\\n            title: msg,\\n            col_type: \\\"rich_text\\\"\\n        }])\\n        return false\\n    }*/\\n    return true\\n}\\n$.exports = canUse();\"},{\"col_type\":\"movie_3\",\"name\":\"断念插件调用\",\"path\":\"dnplugin\",\"rule\":\"var dnen = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\nitems.push({\\n    title: '断插：' + (dnen == '1' ? '““✅””' : '❎'),\\n    url: $('').lazyRule((dnen) => {\\n        if (dnen == '1') {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"enDn\\\\\\\":\\\\\\\"1\\\\\\\"', '\\\\\\\"enDn\\\\\\\":\\\\\\\"0\\\\\\\"');\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            refreshPage(false);\\n            return 'toast://已禁用断插调用！';\\n        } else {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"enDn\\\\\\\":\\\\\\\"0\\\\\\\"', '\\\\\\\"enDn\\\\\\\":\\\\\\\"1\\\\\\\"');\\n            //log(fileUrl);\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            refreshPage(false);\\n            return 'toast://已开启断插调用！'\\n        }\\n    }, dnen),\\n    col_type: 'scroll_button'\\n});\\nif (dnen == '1') {\\n    items.push({\\n        title: '线路配置',\\n        url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n        col_type: 'scroll_button'\\n    });\\n    items.push({\\n        title: '解析管理',\\n        url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\",\\n        col_type: 'scroll_button'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"设置页代码\",\"path\":\"setting\",\"rule\":\"var d = [];\\nvar setjson = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {}));\\nvar ssmd = setjson.ssmode;\\nvar ssxc = setjson.sscount;\\nd.push({\\n    title: '搜索设置',\\n    col_type: 'text_center_1'\\n});\\nd.push({\\n    title: '当前：' + '(' + (ssmd == 1 ? '聚合结果' : '引擎列表') + ')',\\n    url: $('hiker://empty').lazyRule(() => {\\n        var md = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\n\\n        if (md == 1) {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"ssmode\\\\\\\":\\\\\\\"1\\\\\\\"', '\\\\\\\"ssmode\\\\\\\":\\\\\\\"0\\\\\\\"');\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            back(true);\\n            return 'toast://切换为搜索引擎列表单选模式成功！';\\n        } else {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"ssmode\\\\\\\":\\\\\\\"0\\\\\\\"', '\\\\\\\"ssmode\\\\\\\":\\\\\\\"1\\\\\\\"');\\n            //log(fileUrl);\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            back(true);\\n            return 'toast://切换为聚合搜索模式成功！'\\n        }\\n    }),\\n    col_type: 'text_2'\\n})\\nd.push({\\n    title: '搜索超时(' + '' + getItem('apptimout', '')+')',\\n    url: \\\"input://\\\" + '3000' + \\\"////请设置超时时间，1000为一秒。.js:var num = parseInt(input).toString();if (num == 'NaN'||num<1000) {'toast://输入的值好像不正确。';} else {setItem('apptimout', num);refreshPage();'toast://设置成功。'}\\\",\\n    col_type: 'text_2'\\n});\\n\\nd.push({\\n    title: '搜索线程' + '(' + ssxc + ')',\\n    url: \\\"input://\\\" + JSON.stringify({\\n        value: \\\"5\\\",\\n        hint: \\\"请输入一个整数数字，推荐最大不要超过15。\\\",\\n        js: $.toString(() => {\\n            var num = parseInt(input).toString();\\n            if (num == 'NaN' || num < 1) {\\n                return 'toast://输入的值好像不正确。';\\n            } else {\\n                var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace(/\\\\\\\"sscount\\\\\\\":\\\\\\\"[\\\\d]*\\\\\\\"/, '\\\\\\\"sscount\\\\\\\":\\\\\\\"' + num + '\\\\\\\"');\\n                writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n                back(true);\\n                return 'toast://保存设置搜索线程完成！'\\n            }\\n        }),\\n    }),\\n    col_type: 'text_2'\\n});\\n\\nd.push({\\n    title: '更新相关',\\n    col_type: 'text_center_1'\\n});\\nd.push({\\n    title: '检测更新',\\n    url: $('').lazyRule((locver) => {\\n        try {\\n            var remf = fetchCache('https://codeberg.org/lzk23559/cloudrule/raw/branch/master/appmovie.txt', 24);\\n        } catch (e) {\\n            remf = '';\\n        }\\n        if (/￥base64/.test(remf)) {\\n            var remv = JSON.parse(base64Decode(remf.split('@')[2])).version;\\n        } else if (/￥home_rule￥/.test(remf)) {\\n            var remv = JSON.parse(remf.split('￥home_rule￥')[1]).version;\\n        };\\n        if (/￥home_rule/.test(remf)) {\\n            log('远程版本：' + remv);\\n            log('本地版本：' + locver);\\n            if (locver != remv) {\\n                putVar('appnver', remf);\\n                refreshPage();\\n                return 'toast://有新版本，点导入更新可更新规则。';\\n            } else {\\n                return 'toast://暂无新版本，24小时内检测无效。'\\n            };\\n        } else {\\n            return 'toast://检测更新失败，可能云端抽风了。'\\n        }\\n    }, locver),\\n    col_type: 'text_2'\\n});\\nif (getVar('appnver')) {\\n    d.push({\\n        title: '导入更新',\\n        url: $('').lazyRule(() => {\\n            return getVar('appnver');\\n        }),\\n        col_type: 'text_2'\\n    });\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"最新章节\",\"path\":\"chapter\",\"rule\":\"var chp = [];\\ntry {\\n    var html = JSON.parse(getResCode());\\n    if (html.videolist) {\\n        var conts = Object.keys(html.videolist);\\n    } else if (html.data.vod_url_with_player) {\\n        var conts = html.data.vod_url_with_player;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_play_url.split('$$$');\\n        }\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n        var conts = html.data.vod_info.vod_url_with_player;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_info.vod_play_url.split('$$$');\\n        }\\n    } else {\\n        var conts = html.data.vod_play_list;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_play_url.split('$$$');\\n        }\\n    }\\n\\n    for (var i = 0; i < conts.length; i++) {\\n        if (html.videolist) {\\n            var list = html.videolist[conts[i]];\\n        } else if (conts[i].urls) {\\n            var list = conts[i].urls;\\n        } else if (conts[i].url) {\\n            var list = conts[i].url.split(\\\"#\\\");\\n        } else {\\n            var list = conts[i].split(\\\"#\\\");\\n        }\\n        chp.push(list.length);\\n    }\\n} catch (e) {}\\n//log(Math.max.apply(Math,chp));\\nsetResult('更新至:' + (Math.max.apply(Math, chp)));\"}],\"saved\":false,\"title\":\"APP影视(P)\",\"version\":0,\"url\":\"http://tv.0573wl.com/api.php/iptv/vod/?ac=detail&ids=134331;get;utf-8;{User-Agent@okhttp/4.1.0}\",\"col_type\":\"movie_1\",\"find_rule\":\"js:(\\n(typet) => {\\n    var res = {};\\n    var items = [];\\n    var html = JSON.parse(getResCode());\\n    items.push({title: \\\"\\\", desc: \\\"255&&float\\\", url: \\\"\\\", col_type: \\\"x5_webview_single\\\"});\\n    var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n    if (/TV/i.test(typet)) {\\n        eval(JSON.parse(fetch(\\\"hiker://page/tvmovlist\\\", {})).rule);\\n    } else {\\n        eval(JSON.parse(fetch(\\\"hiker://page/appmovlist\\\", {})).rule);\\n    }\\n    res.data = items;\\n    setHomeResult(res);\\n}\\n)(\\\"q:TV影视\\\")\",\"group\":\"②影搜\",\"ua\":\"mobile\",\"preRule\":\"if (!fileExist('hiker://files/rules/xyq/appmset.json')) {\\n    let set = `{\\\"ssmode\\\":\\\"0\\\",\\\"sscount\\\":\\\"5\\\",\\\"enDn\\\":\\\"0\\\"}`;\\n    writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", set);\\n}\\nvar ruleset = fetch('hiker://files/rules/xyq/appmset.json', {});\\nif (!JSON.parse(ruleset).enDn) {\\n    let set = ruleset.replace('\\\\\\\"\\\\}', '\\\\\\\"\\\\,\\\\\\\"enDn\\\\\\\"\\\\:\\\\\\\"0\\\\\\\"\\\\}');\\n    writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", set);\\n}\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"接口数据2022/2/7\\\",\\\"path\\\":\\\"ResCode\\\",\\\"rule\\\":\\\"{\\\\n    \\\\\\\"data\\\\\\\": [{\\\\n            \\\\\\\"title\\\\\\\": \\\\\\\"优质\\\\\\\",\\\\n            \\\\\\\"list\\\\\\\": [{\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"1080p\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://1080p.one/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1080p.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"1231D\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://vue.app.yunboys.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/1231D.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"300看世界\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://300ys.xyz/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/300看世界.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"4K影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://1api.4kdytv.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/4K影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"80K影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://1080p.tv/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80K影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"CJT影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.cjt521.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CJT影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"DC影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://chaorenbb.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/DC影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"F7高清\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://bc.haokanju1.cc/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/F7高清.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"HG影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://hgyx.vip/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"l0l影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://l0l.tv/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/l0l影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱看美剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.uumjw.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱看美剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱酷影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱酷影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"菜鸟追剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://81.71.18.95:5555/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟追剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"白嫖影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://zgjxdtg.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白嫖影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱看影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.a91.cm/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"初心影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.18mv.club/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/初心影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"独播社\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://35ys.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/独播社.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"叮当影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.0573wl.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/叮当影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"段友影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://121.204.249.135:4433/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视3.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"段友影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://shangjihuoke.com/api.php/tv.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"饭后电影\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://summ.vip/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/饭后电影.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"飞捷影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.fj6080.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞捷影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"疯狂看\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.fkkdy.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/疯狂看电影.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"粉象视界\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://42.157.129.15:34444/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/粉象视界.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"汇聚库TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.zzclove666.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/汇聚库TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"虎猫视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://humaosp.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虎猫视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"可米影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.kmys.vip/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"康耀影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.ybyyds.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/康耀影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"绿箭影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.69ty.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿箭影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"懒猫电影\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.esellauto.com/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫电影.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"蜜蜂影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.f8tp.com/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜蜂影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"麻瓜视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://aliyun.k8aa.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻瓜视频1.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"美剧虫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://meijuchong.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧虫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"木子电影\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.muzidy.top/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/木子电影.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"奈非迷\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.netflixmi.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈非迷影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"南府影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://iapp.nfuxs.club/dnmb.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/南府影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"暖光影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.bl210.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/暖光影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"念念影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://998.yuanmajs.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/念念影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"柠柚影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://nu.e4tv.cn/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柠柚影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"奇怪视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://giguai.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"七零动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://cf.70yu.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七零动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"瑞丰资源\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.yjhan.com:4433/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/瑞丰.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"闪光影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://101.35.128.192/mubai_api.php/m2.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/闪光影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"思乐影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.huandian.top/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思乐影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"天诚影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tcspvip.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天诚影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"天天影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.daishusc.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"温妮影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.wenniys.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/温妮影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小白动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://121.62.60.222:20222/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小白动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"星辰视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://m.hj0999.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星辰视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小极影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.8d8q.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"心鸾影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://zhiyutv.xyz/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/心鸾影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"雪人影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://zy.qd234.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雪人影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"益达影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://luobu.yss6080.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/益达影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"雨果影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://2.yhys63.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/雨果影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"影视大全\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.269w.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"月色影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://69ty.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月色影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"优视影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://cc.ysys.asia/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优视影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"影阅阁\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://221.236.18.12:665/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影阅阁.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"追剧吧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://zhuiju8.vip/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧吧影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                }\\\\n            ]\\\\n        },\\\\n        {\\\\n            \\\\\\\"title\\\\\\\": \\\\\\\"普通\\\\\\\",\\\\n            \\\\\\\"list\\\\\\\": [{\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"51视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://51shipin.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/51视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"80影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.ccc8.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/80影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"JDODO\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://appys.jdodo.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/JDODO影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"QC影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.qcsvip.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/QC影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"U5影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://appx.uy07.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/U5影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"XG影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://cms.xggm.top/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/XG影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"yoyo\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://jx.wnvod.net/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/yoyo影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"阿里影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://aliys.cn:90/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/阿里影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"嗷呜影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://aowu.pro/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嗷呜影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.hzlff.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱追剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://81.71.18.95:520/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱追剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"艾特影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.aitee.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/艾特影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"白菜追剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://lbapp.huimaojia.com:30119/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白菜追剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"比邻影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://0hzy.cn:9990/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/比邻影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"百讯视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://z.iopenyun.com:99/app_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/百讯视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"菜鸟动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://taikong.huangguay.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/菜鸟动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"大头影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://dy.idsao.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大头影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"段友影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://js.66app.me/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/段友影视2.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"豆渣影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://douzhayss.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/豆渣影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"二九影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.19kp.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二九影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"风启影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://ysw.ee/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/风启影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"辉哥影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.y.hgyule8.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/辉哥影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"黄河影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://i.ledu8.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黄河影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"火星人\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.huoxing9.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/火星人影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"晗先森\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://hantv.top/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/晗先森影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"盒子影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://i.nihaohezi.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/盒子影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"筋斗云\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.jindcloud.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/筋斗云影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"极光影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.winxz.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/极光影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"聚合视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.jhystv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚合视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"久久影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://s9t9.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"剧迷视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://pan.hzafw.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/剧迷视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"橘子影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://jz.juzidy.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/橘子影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"快播吧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.hd8.pw/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/快播吧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"看剧吧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.ishen520.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看剧吧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"看看剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.kankanju.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/看看剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"酷酷影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.ccc8.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/酷酷影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"可米影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://sj.kmys.vip/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/可米影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"绿豆视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://v.lvdoui.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/绿豆影音.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"蓝光视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://vip.91iqiyi.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蓝光视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"林谷影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://ys.linguyy.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/林谷影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"冷视TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://len.tv/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷视TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"美剧范\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://ttzmz.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/美剧范.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"喵乐影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://miaoleys.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/喵乐影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"名视影\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.qqccv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/名视影.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"麻子追剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://b.2maz.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/麻子追剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"奈飞中文\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.naifei.org/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奈飞中文.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"苹果影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://apple678.xyz/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/苹果影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"皮皮动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://dm.muying.me/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/皮皮动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"奇趣影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.qiqu.me/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/奇趣影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"任性看\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://renxingkan.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/任性看.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"思奇影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.siqitv.vip/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"三日影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.3ri.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/三日影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"神马影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://xs.78tv.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/神马影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"视听星球\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://zjyapijzys.shynwlkj.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/视听星球.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"土豆TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://xiuxian.qd234.cn/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/土豆TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"淘剧社\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.shuhai99.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/淘剧社.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"天空影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.51aizn.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"天天视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.qianju.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天天视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"兔子窝\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://cj.huimaojia.com:12345/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/兔子窝.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"我爱跟剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.genmov.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/我爱跟剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"吾爱影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.5lp.net/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"吾爱影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://52ysw.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吾爱影视1.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"吻痕视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.kissone.cn/ruifenglb_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/吻痕视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"蜗牛动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜗牛动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"寻常影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.91ymz.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/寻常影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"熊猫动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://dongman.k8aa.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"熊猫视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://anegh.com/lvdou_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/熊猫视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"玺娜影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://pp.wxina.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺娜影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小蜻蜓\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://3ketv.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小蜻蜓视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"星球视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://119.29.121.48:8088/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星球视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"玺心影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.arbd.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/玺心影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"新享影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://app.jiagan.cx/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/新享影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"星影相随\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.rootthree.top/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/星影相随.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小易影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://xy.irop.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小易影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"云城影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://ayyf.cn/mubai_api.php/m2.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/云城影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"月儿影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://yue52.xyz/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"樱花动漫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.dmwu.cc/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/樱花动漫.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"月亮影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://ys.13tv.top/acj_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/月亮影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"影视大全\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://xc.xixi2yy.xyz/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视大全HD.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"影视热剧\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://lb.26ys.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/影视热剧.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"渔渔影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://luobo.yugenye.site/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/渔渔影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"优优影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://xin.jjsvip.cc/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/优优影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"柚子视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://yz.26ys.cn/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/柚子视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"鱼仔影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://yuzaio.top/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/鱼仔影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"追剧达人\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://www.zhuijudaren.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧达人.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"追剧猫\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.kmtvb.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/追剧猫1.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"侦探影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://ys.huangguay.com/mogai_api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/侦探影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"猪猪影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://app.2zdyy.com/api.php/v1.vod\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/猪猪影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:APP影视\\\\\\\"\\\\n                }\\\\n            ]\\\\n        },\\\\n        {\\\\n            \\\\\\\"title\\\\\\\": \\\\\\\"IPTV\\\\\\\",\\\\n            \\\\\\\"list\\\\\\\": [{\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"2号币\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://phoebe.cf/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/2号币影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"CV影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.cccvvv.top/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/CV影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"HG影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://api.hgyx.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/HG影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"傲视影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://j.zjj.life:88/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/傲视影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"爱西西TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.aixixi.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/爱西西TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"白熊影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://qt.yhzy.xyz/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/白熊影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"刺桐影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.cttv.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/刺桐影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"尘梓TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://cztv.vip:83/api.php/chenziystv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/尘梓TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"嘀哩嘀哩\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://api.diliktv.xyz/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘀哩嘀哩TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"动力影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.love9989.com/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/动力影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"大师兄\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://dsxtv.tv.ci/api.php/dsx/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/大师兄影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"二货影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://d.zjj.life:88/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/二货影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"非凡影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://cms.feifan12.xyz/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/非凡影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"飞扬TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://diancj.zhenfy.cn/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/飞扬TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"嘿荼锋\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.hfys8.vip/api.php/Sntv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/嘿荼锋.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"黑龙影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://vip.ji-ding-he.site/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/黑龙影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"河马影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://1.14.63.101/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/河马影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"聚多影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://jdyy.weetai.cn/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/聚多影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"久久影院\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://l.bhtv.org.cn/mv/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/久久影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"乐酷TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://150.138.78.177:2021/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/乐酷TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"懒猫TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.esellauto.com/api.php/lh/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/懒猫TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"六维影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://liuweiiptv.gq:1357/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/六维影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"流星雨\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://nn.lxyyy.xyz:8/c/api.php/WAiLaowang/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/流星雨影院.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"冷月TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"https://tv.521x5.com/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/冷月TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"荔枝影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://api.zjys.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/荔枝影视TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"免费看TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.freekan.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/免费看TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"蜜果TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://vv.miguotv.net/m/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/蜜果TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"米来影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://42.51.37.161:2346/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米来影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"米奇TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://www.s6ep3.top/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/米奇TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"七科影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.7kfm.cn/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/七科影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"若惜影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://rxw.ruoxinew.com/api.php/Sntv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/若惜影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"思奇TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.siqitv.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/思奇TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"双子星\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.diyoui.cc/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/双子星.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"山楂影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://dy6.dcd1.cn/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/山楂影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"天空TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.tkys.tv/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/天空TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"虾皮视频\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv.cmt8.xyz/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/虾皮视频.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小极TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://api.8d8q.com/mmv/api.php/Chengcheng/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小极TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"小熊猫TV\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://tv2.hetaoys.vip/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/小熊猫TV.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                },\\\\n                {\\\\n                    \\\\\\\"title\\\\\\\": \\\\\\\"紫曦影视\\\\\\\",\\\\n                    \\\\\\\"url\\\\\\\": \\\\\\\"http://appys.azx.tools:88/api.php/iptv/vod/\\\\\\\",\\\\n                    \\\\\\\"img\\\\\\\": \\\\\\\"https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/AppIcon/紫曦影视.png\\\\\\\",\\\\n                    \\\\\\\"murl\\\\\\\": \\\\\\\"q:TV影视\\\\\\\"\\\\n                }\\\\n            ]\\\\n        }\\\\n    ]\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"sear\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar items = [];\\\\n//设置搜索线程\\\\nvar ssmode = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\\\nvar key = MY_URL.split('$$$')[1];\\\\n//setError(le);\\\\nif (ssmode == '0') {\\\\n    setPageTitle(key + ' 的搜索结果')\\\\n};\\\\ntry {\\\\n    var appfile = fetchCache('https://inmemory.coding.net/p/InMemory/d/MBrowser/git/raw/master/AppFile/APP.json', 24);\\\\n} catch (e) {\\\\n    appfile = '';\\\\n}\\\\nif (/emory/.test(appfile)) {\\\\n    var html = JSON.parse(appfile);\\\\n} else {\\\\n    log('当前加载的是内置数据');\\\\n    var html = JSON.parse(JSON.parse(fetch('hiker://page/ResCode', {})).rule);\\\\n};\\\\nvar dlist = html.data;\\\\n\\\\nfunction randomSort3(arr) {\\\\n    /*\\\\n        arr.sort(function(a, b) {\\\\n            return Math.random() - 0.5;\\\\n        });\\\\n    */\\\\n    return arr;\\\\n}\\\\n\\\\n//打乱顺序\\\\nvar random = true;\\\\nif (ssmode == '1' || MY_TYPE == 'home') {\\\\n    for (var l = 0; l < dlist.length; l++) {\\\\n        var list = dlist[l].list;\\\\n        var tytit = dlist[l].title;\\\\n        if (random) {\\\\n            let k = getVar(MY_RULE.title + \\\\\\\"-\\\\\\\" + tytit, \\\\\\\"\\\\\\\");\\\\n            if (k == \\\\\\\"\\\\\\\") {\\\\n                list = randomSort3(list)\\\\n                putVar(MY_RULE.title + \\\\\\\"-\\\\\\\" + tytit, JSON.stringify(list))\\\\n            } else {\\\\n                list = JSON.parse(k)\\\\n            }\\\\n        }\\\\n\\\\n\\\\n        items.push({\\\\n            title: MY_TYPE == \\\\\\\"home\\\\\\\" ? \\\\\\\"点击查看 \\\\\\\" + tytit + \\\\\\\" 分类 ““\\\\\\\" + key + \\\\\\\"”” 的聚搜结果\\\\\\\" : \\\\\\\"点击查看 \\\\\\\" + tytit + \\\\\\\" 分类 \\\\\\\" + key + \\\\\\\" 的聚搜结果\\\\\\\",\\\\n            url: $('hiker://empty$$$' + key + '$$$fypage$$$').rule((list, tytit) => {\\\\n                var res = {};\\\\n                var items = [];\\\\n                var nowDate = new Date();\\\\n                var month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\n                var day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\n                var dateStr = month + '' + day;\\\\n                //取搜索线程设置\\\\n                var ssxc = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).sscount;\\\\n                //设置超时时间，越小越快，单位毫秒\\\\n                var timeou = getItem('apptimout', '3000');\\\\n                var key = MY_URL.split('$$$')[1];\\\\n                var num = MY_URL.split('$$$')[2];\\\\n                var le = parseInt(num * ssxc);\\\\n                var Data = [];\\\\n                var Tit = [];\\\\n                for (var j = le - ssxc; j < le; j++) {\\\\n                    if (j < list.length) {\\\\n                        var link = list[j].url;\\\\n                        var litit = list[j].murl;\\\\n                        if (/TV/i.test(litit)) {\\\\n                            if (/19jx|293ys|zhaikanys|ji\\\\\\\\-ding\\\\\\\\-he|phoebe|yunbo\\\\\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(link)) {\\\\n                                var hmurl = link + '?ac=list&zm=' + key + '&page=1';\\\\n                            } else {\\\\n                                var hmurl = link + '?ac=list&wd=' + key + '&page=1';\\\\n                            }\\\\n                        } else {\\\\n                            if (/dijiaxia/.test(link)) {\\\\n                                link = 'http://www.dijiaxia.com/api.php/app/'\\\\n                            };\\\\n                            if (link.indexOf('api.php/app/') != -1) {\\\\n                                var hmurl = link + 'search?pg=1&text=' + key + '&token=';\\\\n                            } else if (link.indexOf('xgapp.php/v1/') != -1) {\\\\n                                var hmurl = link + 'search?pg=1&text=' + key;\\\\n                            } else {\\\\n                                if (/iopenyun/.test(link)) {\\\\n                                    var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\\\n                                } else {\\\\n                                    var hmurl = link + '?page=1&limit=10&wd=' + key;\\\\n                                }\\\\n                            }\\\\n                        }\\\\n                        //Data.push({url: hmurl,options: {headers: {\\\\\\\"User-Agent\\\\\\\": \\\\\\\"Dart/2.14 (dart:io)\\\\\\\"},timeout: timeou}});\\\\n                        Data.push({\\\\n                            url: hmurl,\\\\n                            options: {\\\\n                                headers: {\\\\n                                    \\\\\\\"User-Agent\\\\\\\": link.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? \\\\\\\"Dart/2.14 (dart:io)\\\\\\\" : \\\\\\\"okhttp/4.1.0\\\\\\\"\\\\n                                },\\\\n                                timeout: timeou\\\\n                            }\\\\n                        });\\\\n                        Tit.push({\\\\n                            tit: list[j].title,\\\\n                            link: link,\\\\n                            typnm: litit\\\\n                        });\\\\n                    } //if\\\\n                } //for j\\\\n\\\\n                //---代码分界线---- \\\\n                if (Data != '') {\\\\n                    var bhtml = batchFetch(Data);\\\\n                    //writeFile(\\\\\\\"hiker://files/rules/xyq/appError.json\\\\\\\",JSON.stringify(bhtml));\\\\n\\\\n                    for (var k = 0; k < bhtml.length; k++) {\\\\n                        var html = bhtml[k];\\\\n                        //log(html);\\\\n                        try {\\\\n                            html = html.substring(0, 2) == '\\\\\\\\r\\\\\\\\n' ? html.replace('\\\\\\\\r\\\\\\\\n', '') : html;\\\\n                        } catch (e) {}\\\\n                        if (/btwaf/.test(html)) {\\\\n                            html = fetch(Data[k].url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], {});\\\\n\\\\n                        }\\\\n                        if (html == \\\\\\\"\\\\\\\" || html == null || html.substring(0, 5) == 'error' || !html.startsWith('{')) {\\\\n\\\\n                            items.push({\\\\n                                title: Tit[k].tit + ' ' + '未搜索到，点击访问原网页',\\\\n                                url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                                col_type: 'text_1'\\\\n                            });\\\\n\\\\n                        } else if (html.length < 80) {\\\\n                            items.push({\\\\n                                title: Tit[k].tit + ' ' + '返回数据不完整，点击访问原网页',\\\\n                                url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                                col_type: 'text_1'\\\\n                            });\\\\n                        } else {\\\\n                            var html = JSON.parse(html);\\\\n                            //log(html);\\\\n                            var typet = Tit[k].typnm;\\\\n                            var tdomin = Tit[k].link;\\\\n                            if (html.list) {\\\\n                                var list = html.list;\\\\n                            } else if (html.data.list) {\\\\n                                var list = html.data.list;\\\\n                            } else if (html.data) {\\\\n                                var list = html.data;\\\\n                            } else {\\\\n                                var list = [];\\\\n                            }\\\\n                            if (list.length < 1) {\\\\n\\\\n                                items.push({\\\\n                                    title: Tit[k].tit + ' ' + '列表小于1，无法展示，点击访问原网页',\\\\n                                    url: Data[k].url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                                    col_type: 'text_1'\\\\n                                });\\\\n\\\\n                            } else {\\\\n                                for (var i = 0; i < list.length; i++) {\\\\n                                    if (/TV/i.test(typet)) {\\\\n                                        var title = list[i].title;\\\\n                                        var pic = list[i].pic;\\\\n                                        var vid = list[i].nextlink;\\\\n                                        var rem = list[i].state;\\\\n                                    } else {\\\\n\\\\n                                        if (tdomin.indexOf('api.php/app/') != -1) {\\\\n                                            var title = list[i].vod_name;\\\\n                                            var pic = list[i].vod_pic;\\\\n                                            if (/fantuan/.test(tdomin)) {\\\\n                                                var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\\\n                                            } else {\\\\n                                                var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\\\n                                            }\\\\n                                            var rem = list[i].vod_remarks;\\\\n                                            //var con=list[i].type.type_des;\\\\n                                        } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\\\n                                            var title = list[i].vod_name;\\\\n                                            var pic = list[i].vod_pic;\\\\n                                            var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\\\n                                            var rem = list[i].vod_remarks;\\\\n                                            //var con=list[i].type.type_des;\\\\n                                        } else {\\\\n                                            var title = list[i].vod_name;\\\\n                                            var pic = list[i].vod_pic;\\\\n                                            if (/iopenyun/.test(tdomin)) {\\\\n                                                var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\\\n                                            } else {\\\\n                                                var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\\\n                                            }\\\\n                                            var rem = list[i].vod_remarks;\\\\n                                            //var con=list[i].type.type_des;\\\\n                                        }\\\\n\\\\n                                    }\\\\n                                    //var con=list[i].state;\\\\n                                    //log(vid);\\\\n\\\\n                                    items.push({\\\\n                                        title: MY_TYPE == \\\\\\\"home\\\\\\\" ? title.replace(key, '““' + key + '””') + '\\\\\\\\n' + rem : title + rem,\\\\n                                        pic_url: pic + '@Referer=',\\\\n                                        url: $(tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((typet) => {\\\\n                                            var res = {};\\\\n                                            var items = [];\\\\n                                            var html = JSON.parse(getResCode());\\\\n                                            items.push({\\\\n                                                title: '',\\\\n                                                desc: '255&&float',\\\\n                                                url: '',\\\\n                                                col_type: 'x5_webview_single'\\\\n                                            });\\\\n                                            var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                                            if (/TV/i.test(typet)) {\\\\n                                                eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n                                            } else {\\\\n                                                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                                            }\\\\n\\\\n                                            res.data = items;\\\\n                                            setHomeResult(res);\\\\n                                        }, typet),\\\\n                                        //content: rem,\\\\n                                        desc: tytit + ' => ' + Tit[k].tit,\\\\n                                        col_type: 'movie_1_vertical_pic'\\\\n                                    });\\\\n                                } //for i\\\\n                            } //if list.length\\\\n                        }\\\\n                    } //for k bhtml.length\\\\n                }\\\\n\\\\n                res.data = items;\\\\n                setHomeResult(res);\\\\n            }, list, tytit),\\\\n            col_type: 'text_1'\\\\n        });\\\\n\\\\n    } //for i\\\\n}; //end mode 1\\\\n\\\\nif (ssmode == '0' || MY_TYPE == 'home') {\\\\n    for (var i = 0; i < dlist.length; i++) {\\\\n        var list = dlist[i].list;\\\\n        var tytit = dlist[i].title;\\\\n        if (random) {\\\\n            let k = getVar(MY_RULE.title + \\\\\\\"-\\\\\\\" + tytit, \\\\\\\"\\\\\\\");\\\\n            if (k == \\\\\\\"\\\\\\\") {\\\\n                list = randomSort3(list)\\\\n                putVar(MY_RULE.title + \\\\\\\"-\\\\\\\" + tytit, JSON.stringify(list))\\\\n            } else {\\\\n                list = JSON.parse(k)\\\\n            }\\\\n        }\\\\n\\\\n        items.push({\\\\n            title: MY_TYPE == \\\\\\\"home\\\\\\\" ? \\\\\\\" 选择一个 \\\\\\\" + dlist[i].title + \\\\\\\" 项目查看 ““\\\\\\\" + key + \\\\\\\"”” 的搜索结果\\\\\\\" : \\\\\\\" 选择一个 \\\\\\\" + dlist[i].title + \\\\\\\" 项目查看 \\\\\\\" + key + \\\\\\\" 的搜索结果\\\\\\\",\\\\n            col_type: 'text_1'\\\\n        });\\\\n\\\\n        for (var j = 0; j < list.length; j++) {\\\\n            var link = list[j].url;\\\\n            var litit = list[j].murl;\\\\n            if (/TV/i.test(litit)) {\\\\n                if (/19jx|293ys|zhaikanys|ji\\\\\\\\-ding\\\\\\\\-he|phoebe|yunbo\\\\\\\\.bxin|lanrentk|hetaoys|pxun|139\\\\\\\\.155|fkkdy|056158|aixixi|ruoxinew|feifan123|siqitv/.test(link)) {\\\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=fypage';\\\\n                } else {\\\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=fypage';\\\\n                }\\\\n            } else {\\\\n                if (/dijiaxia/.test(link)) {\\\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\\\n                };\\\\n                if (link.indexOf('api.php/app/') != -1) {\\\\n                    var hmurl = link + 'search?pg=fypage&text=' + key + '&token=';\\\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\\\n                    var hmurl = link + 'search?pg=fypage&text=' + key;\\\\n                } else {\\\\n                    if (/iopenyun/.test(link)) {\\\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\\\n                    } else {\\\\n                        var hmurl = link + '?page=fypage&limit=10&wd=' + key;\\\\n                    }\\\\n                }\\\\n            }\\\\n            items.push({\\\\n                title: list[j].title,\\\\n                img: list[j].img,\\\\n                url: $('hiker://empty#x#' + hmurl + '#x#' + link + '#x#' + litit + '#x#' + key + '#x#').rule(() => {\\\\n                    $.require('hiker://page/searerj');\\\\n                }),\\\\n                col_type: 'icon_round_small_4'\\\\n                //col_type: 'text_3'\\\\n                //link:link,\\\\n                //type: i\\\\n            });\\\\n\\\\n        } //for j\\\\n\\\\n\\\\n    } //for i\\\\n\\\\n} //end mode 0\\\\n\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP分类列表\\\",\\\"path\\\":\\\"applistdata\\\",\\\"rule\\\":\\\"if (html.list) {\\\\n    var list = html.list;\\\\n} else if (html.data && html.data.list) {\\\\n    var list = html.data.list;\\\\n} else {\\\\n    var list = html.data;\\\\n}\\\\n//log(list);\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    var title = list[i].vod_name;\\\\n    var img = list[i].vod_pic;\\\\n    var url = list[i].vod_id;\\\\n    var desc = list[i].vod_remarks;\\\\n    var nowDate = new Date();\\\\n    var month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\n    var day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\n    var dateStr = month + '' + day;\\\\n    if (html.list) {\\\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (html.data && html.data.list) {\\\\n        if (murl.search(/mogai_api/) != -1) {\\\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else {\\\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\\\n        }\\\\n    } else {\\\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    };\\\\n    if (/fantuan/.test(murl)) {\\\\n        var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (/iopenyun/.test(murl)) {\\\\n        var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (/dijiaxia/.test(murl)) {\\\\n        var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\\\n    }\\\\n    items.push({\\\\n        title: title,\\\\n        pic_url: img + '@Referer=',\\\\n        url: $(link).rule(() => {\\\\n            var res = {};\\\\n            var items = [];\\\\n            items.push({\\\\n                title: '',\\\\n                desc: '255&&float',\\\\n                url: '',\\\\n                col_type: 'x5_webview_single'\\\\n            });\\\\n            refreshX5WebView('');\\\\n            var html = JSON.parse(getResCode());\\\\n            var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n            try {\\\\n                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n            } catch (e) {}\\\\n            res.data = items;\\\\n            setHomeResult(res);\\\\n        }),\\\\n        desc: desc,\\\\n        col_type: 'movie_3_marquee'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"TV列表解析\\\",\\\"path\\\":\\\"tvlistdata\\\",\\\"rule\\\":\\\"var list = html.data;\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    var title = list[i].title;\\\\n    var img = list[i].pic;\\\\n    var url = list[i].nextlink;\\\\n    var desc = list[i].state;\\\\n    url = url.startsWith('http') ? url : murl + '?ac=detail&ids=' + url;\\\\n    items.push({\\\\n        title: title,\\\\n        pic_url: img + '@Referer=',\\\\n        url: $(url).rule(() => {\\\\n            var res = {};\\\\n            var items = [];\\\\n            var html = JSON.parse(getResCode());\\\\n            var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n            items.push({\\\\n                title: '',\\\\n                desc: '255&&float',\\\\n                url: '',\\\\n                col_type: 'x5_webview_single'\\\\n            });\\\\n            refreshX5WebView('');\\\\n            try {\\\\n            eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n            } catch (e) {}\\\\n            res.data = items;\\\\n            setHomeResult(res);\\\\n        }),\\\\n        desc: desc,\\\\n        col_type: 'movie_3_marquee'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP简介与选集\\\",\\\"path\\\":\\\"appmovlist\\\",\\\"rule\\\":\\\"if (html.data.vod_url_with_player) {\\\\n    var conts = html.data.vod_url_with_player;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_play_from.split('$$$');\\\\n    }\\\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n    var conts = html.data.vod_info.vod_url_with_player;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_info.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_info.vod_play_from.split('$$$');\\\\n    }\\\\n} else {\\\\n    var conts = html.data.vod_play_list;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_play_from.split('$$$');\\\\n    }\\\\n}\\\\n\\\\n//log(conts);\\\\n\\\\nvar thumb = html.data.vod_info ? html.data.vod_info.vod_pic : html.data.vod_pic;\\\\nvar des = html.data.vod_info ? html.data.vod_info.vod_content : html.data.vod_content;\\\\nitems.push({\\\\n    title: '剧情简介：',\\\\n    desc: des,\\\\n    pic_url: thumb,\\\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\\\n        setResult([{\\\\n            title: des,\\\\n            col_type: 'long_text'\\\\n        }]);\\\\n    }, des),\\\\n    col_type: 'movie_1_vertical_pic'\\\\n});\\\\nvar jiek = '';\\\\nfor (var i = 0; i < conts.length; i++) {\\\\n    if (getVar('appmappsort', '1') == '1') {\\\\n        if (conts[i].urls) {\\\\n            var list = conts[i].urls;\\\\n        } else if (conts[i].url) {\\\\n            var list = conts[i].url.split(\\\\\\\"#\\\\\\\");\\\\n        } else {\\\\n            var list = conts[i].split(\\\\\\\"#\\\\\\\");\\\\n        };\\\\n    } else {\\\\n        if (conts[i].urls) {\\\\n            var list = conts[i].urls.reverse();\\\\n        } else if (conts[i].url) {\\\\n            var list = conts[i].url.split(\\\\\\\"#\\\\\\\").reverse();\\\\n        } else {\\\\n            var list = conts[i].split(\\\\\\\"#\\\\\\\").reverse();\\\\n        }\\\\n    };\\\\n    //setError(list.length);\\\\n    if (html.data.vod_url_with_player) {\\\\n        var ptab = conts[i].code ? conts[i].code : tabs[i];\\\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n        var ptab = conts[i].code ? conts[i].code : tabs[i];\\\\n    } else {\\\\n        var ptab = conts[i].from ? conts[i].from : tabs[i];\\\\n    }\\\\n    items.push({\\\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [conts.length] + \\\\\\\"““↓↑””\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n    eval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\\\n\\\\n    for (var j = 0; j < list.length; j++) {\\\\n        if (conts[i].urls) {\\\\n            var vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\\\n            var title = list[j].name;\\\\n        } else {\\\\n            var vlink = list[j].split(\\\\\\\"$\\\\\\\")[1];\\\\n            var title = list[j].split(\\\\\\\"$\\\\\\\")[0];\\\\n        }\\\\n        try {\\\\n            if (html.data.vod_url_with_player) {\\\\n                var jiek = conts[i].parse_api;\\\\n            } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n                var jiek = conts[i].parse_api;\\\\n            } else {\\\\n                if (conts[i].player_info.parse2 && (conts[i].player_info.parse2).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                    var jiek = (conts[i].player_info.parse2).match(/.*?url=|.*?v=|.*?vid=/)[0].replace(\\\\\\\"..\\\\\\\", \\\\\\\".\\\\\\\").replace('jsonbs', '');\\\\n                } else if (conts[i].player_info.parse && (conts[i].player_info.parse).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                    var jiek = (conts[i].player_info.parse).match(/.*?url=|.*?v=|.*?vid=/)[0].replace(\\\\\\\"..\\\\\\\", \\\\\\\".\\\\\\\");\\\\n                } else {\\\\n                    var jiek = \\\\\\\"\\\\\\\";\\\\n                }\\\\n                //setError(jiek);                \\\\n            }\\\\n        } catch (e) {}\\\\n        //jiek拼接\\\\n        if (jiek != '' && jiek != null) {\\\\n            if (jiek.substring(0, 4) == 'http') {\\\\n                jiek = jiek;\\\\n            } else if (jiek.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                jiek = 'https:' + jiek;\\\\n            }\\\\n        } else {\\\\n            jiek = \\\\\\\"\\\\\\\";\\\\n        }\\\\n        //对失效接口进行替换\\\\n        if (/cokemv/.test(myurl) && /cokeqie|xin|90mm/.test(ptab)) {\\\\n            jiek = 'https://player.90mm.me/play.php?url=';\\\\n        } else if (/json\\\\\\\\.m3u8\\\\\\\\.tv|www\\\\\\\\.x-n\\\\\\\\.cc/.test(jiek)) {\\\\n            jiek = 'https://jx.m3u8.tv/jiexi/?url=';\\\\n        } else if (/cjt521/.test(myurl)) {\\\\n            jiek = conts[i].player_info.parse;\\\\n        } else if (jiek.indexOf('jpg.hou.lu/jm/za/index.php') != -1) {\\\\n            jiek = 'http://vip.mengx.vip/home/api?type=ys&uid=3249696&key=aefqrtuwxyEFHKNOQY&url=';\\\\n        } else if (ptab == 'renrenmi' && jiek.search(/jhdyw/) != -1) {\\\\n            jiek = 'http://www.1080kan.cc/jiexi/rrmi.php?url=';\\\\n        } else if (ptab == 'fqfilm' && jiek.search(/jhdyw/) != -1) {\\\\n            jiek = 'http://www.1080kan.cc/jiexi/fq.php?url=';\\\\n        } else if (ptab == 'rrsp' && jiek.search(/jhdyw/) != -1) {\\\\n            jiek = 'http://www.1080kan.cc/jiexi/rr.php?url=';\\\\n        } else if (/jhyun\\\\\\\\.php/.test(jiek)) {\\\\n            jiek = jiek.replace('http://svip.jhyun.jx.cn:1234/jhyun.php?url=', 'https://api.jhdyw.vip/?url=');\\\\n        };\\\\n        //打印接口\\\\n        try {\\\\n            if (j == '0') {\\\\n                if (html.data.vod_url_with_player) {\\\\n                    log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n                } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n                    log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n                } else {\\\\n                    if (conts[i].player_info.parse2 && (conts[i].player_info.parse2).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                        log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + conts[i].player_info.parse2.replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").replace(/\\\\\\\\,/g, \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\"));\\\\n                    } else if (conts[i].player_info.parse && (conts[i].player_info.parse).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                        log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + conts[i].player_info.parse.replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").replace(/\\\\\\\\,/g, \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\"));\\\\n                    } else {\\\\n                        log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n                    }\\\\n                    //setError(jiek);                \\\\n                }\\\\n            }\\\\n        } catch (e) {}\\\\n        //声明链接\\\\n        var link = jiek + vlink;\\\\n        /*\\\\n        if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos/.test(vlink) && /http/.test(vlink)) {\\\\n            link = vlink;\\\\n        }\\\\n        */\\\\n        //log(link);\\\\n        title = title.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\\\n        if (list.length <= 4) {\\\\n            var clt = 'text_2';\\\\n        } else {\\\\n            var clt = isNaN(title) ? 'flex_button' : 'text_5'\\\\n        };\\\\n        items.push({\\\\n            title: title,\\\\n            url: $('').lazyRule((ptab, link, myurl, vlink) => {\\\\n                    function openurl(resurl) {\\\\n                        if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili|ixigua/) != -1) {\\\\n                            //html网页调用断插解析\\\\n                            var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                            if (enDn == '1') {\\\\n                                log('调用断插解析html');\\\\n                                eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                                eval(fetch(config.cj));\\\\n                                return aytmParse(resurl);\\\\n                            } else {\\\\n                                return resurl\\\\n                            };\\\\n                        } else if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(resurl) && /http/.test(resurl) && !/\\\\\\\\.html/.test(resurl) && !/\\\\\\\\=http/.test(resurl) && ptab != 'duoduozy') {\\\\n                            if (/wkfile/.test(resurl)) {\\\\n                                return resurl + ';{Referer@https://fantuan.wkfile.com/}'\\\\n                            } else {\\\\n                                return /\\\\\\\\=/.test(resurl) ? resurl.split('=')[1] : resurl + '#isVideo=true#';\\\\n                            }\\\\n                        } else {\\\\n                            //调用断插通用函数解析\\\\n                            var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                            if (enDn == '1') {\\\\n                                log('调用断插通用函数解析\\\\\\\\n' + ptab + '(通用函数)');\\\\n                                eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                                eval(fetch(config.cj));\\\\n                                var name = ptab + '(通用函数)';\\\\n                                return ParseS[name](resurl, myurl);\\\\n\\\\n                            } else if (ptab == 'duoduozy') {\\\\n                                eval(getCryptoJS());\\\\n\\\\n                                function De(word) {\\\\n                                    var a = CryptoJS.enc.Utf8.parse(md5('rXjWvXl6'))\\\\n                                    var t = CryptoJS.enc.Utf8.parse('NXbHoWJbpsEOin8b')\\\\n                                    return CryptoJS.AES.decrypt(word, a, {\\\\n                                        iv: t,\\\\n                                        mode: CryptoJS.mode.CBC,\\\\n                                        padding: CryptoJS.pad.Pkcs7\\\\n                                    }).toString(CryptoJS.enc.Utf8)\\\\n                                };\\\\n                                //var ddzy = 'adHuRo0dcuHoM163L1y4' + base64Encode(srcurl).slice(10);                                                       \\\\n                                var ddwy = fetch('https://jhpc.manduhu.com/duoduo/api.php', {\\\\n                                    headers: {\\\\n                                        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                    },\\\\n                                    body: 'url=' + resurl,\\\\n                                    method: 'POST'\\\\n                                });\\\\n                                //log(ddwy);\\\\n                                return De(JSON.parse(ddwy).url);\\\\n                            } else {\\\\n                                return resurl\\\\n                            };\\\\n                        }\\\\n                    };\\\\n                    var srcurl = link;\\\\n                    //log(srcurl);\\\\n                    //动态解析代码开始\\\\n                    try {\\\\n                        //处理指定视频与线路\\\\n                        if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\\\\\.html/.test(srcurl) && !/\\\\\\\\=http/.test(srcurl)) {\\\\n                            if (/wkfile/.test(srcurl)) {\\\\n                                return srcurl + ';{Referer@https://fantuan.wkfile.com/}'\\\\n                            } else {\\\\n                                return /\\\\\\\\=/.test(srcurl) ? srcurl.split('=')[1] : srcurl + '#isVideo=true#';\\\\n                            }\\\\n                        } else if (srcurl.indexOf(\\\\\\\"/share/\\\\\\\") != -1) {\\\\n                            try {\\\\n                                var link = srcurl.split(\\\\\\\"/share\\\\\\\")[0];\\\\n                                var fc = fetch(srcurl, {}).replace(\\\\\\\"var purl\\\\\\\", \\\\\\\"var main\\\\\\\");\\\\n                                if (fc.indexOf(\\\\\\\"main\\\\\\\") != -1) {\\\\n                                    var mat = fc.match(/var main.*?;/)[0];\\\\n                                    eval(mat);\\\\n                                    var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main);\\\\n                                } else {\\\\n                                    var main = fc.match(/url:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1];\\\\n                                    var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main)\\\\n                                };\\\\n                                return play;\\\\n                            } catch (e) {\\\\n                                return 'x5WebView://' + (srcurl)\\\\n                            }\\\\n\\\\n                        } else if (/983vip/.test(srcurl)) {\\\\n                            return JSON.parse(fetch(srcurl, {\\\\n                                headers: {\\\\n                                    \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                },\\\\n                                redirect: false,\\\\n                                withHeaders: true\\\\n                            })).headers.location[0];\\\\n                        } else if (/x\\\\\\\\-n\\\\\\\\.cc|nhdz666/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                            return openurl(vlink);\\\\n                        }\\\\n                        //处理指定视频和线路结束\\\\n                        //----分割线----//\\\\n                        var scode = JSON.parse(fetch(srcurl, {\\\\n                            headers: {\\\\n                                \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Dart/2.14 (dart:io)\\\\\\\"\\\\n                            },\\\\n                            redirect: false,\\\\n                            withStatusCode: true\\\\n                        }));\\\\n                        //log(scode);\\\\n                        if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                            //打开解析有302重定向的链接\\\\n                            var redurl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                            if (/\\\\\\\\=http/.test(redurl) && /html|bilibili/.test(redurl)) {\\\\n                                return JSON.parse(fetch(redurl, {})).url;\\\\n                            } else if (/\\\\\\\\=http/.test(redurl) && /\\\\\\\\.m3u8|\\\\\\\\.mp4|\\\\\\\\.flv/.test(redurl)) {\\\\n                                return redurl.substring(redurl.indexOf('=http') + 1);\\\\n                            } else {\\\\n                                return redurl\\\\n                            }\\\\n                        } else {\\\\n                            //var html = request(srcurl);\\\\n                            var html = scode.body;\\\\n                            if (/404 Not Found|备案后可继续访问/.test(html)) {\\\\n                                return openurl(vlink);\\\\n                            } else if (/\\\\\\\\<body/.test(html)) {\\\\n                                log('尝试非JSON接口网页解析');\\\\n                                requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\\\n                                return x5rule(srcurl, srcurl);\\\\n                                //return openurl(srcurl);\\\\n                            } else {\\\\n                                //json解析的取链接\\\\n                                var purl = html.match(/[\\\\\\\\'\\\\\\\\\\\\\\\"]url[\\\\\\\\'\\\\\\\\\\\\\\\"]:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                                //log(purl);\\\\n                                if (/http/.test(purl)) {\\\\n                                    if (ptab == 'bilibili') {\\\\n                                        return purl + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\\\n                                    } else if (ptab == 'mgtv') {\\\\n                                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                                    } else if (/ojbk/.test(purl)) {\\\\n                                        return purl + ';{Referer@https://bak.ojbkjx.com/}';\\\\n                                    } else {\\\\n                                        return purl\\\\n                                    };\\\\n                                } else {\\\\n                                    //非http开头的打开原链接                                                                \\\\n                                    return openurl(vlink)\\\\n                                }\\\\n                            }\\\\n                        }\\\\n                    } catch (e) {\\\\n                        //报错判断处理\\\\n                        log('执行报错跳转处理');\\\\n                        /*if (srcurl.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                            return openurl('https:' + srcurl);\\\\n                        } else if (/\\\\\\\\=http/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                            //return srcurl.split('=')[1];\\\\n                            return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                        } else {*/\\\\n                        return openurl(vlink)\\\\n                        //return 'x5WebView://'+srcurl\\\\n                        //}\\\\n                    }\\\\n                    //动态解析代码结束\\\\n                },\\\\n                ptab,\\\\n                link,\\\\n                myurl,\\\\n                vlink),\\\\n            col_type: clt\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"TV简介与选集\\\",\\\"path\\\":\\\"tvmovlist\\\",\\\"rule\\\":\\\"var tabs = Object.keys(html.videolist);\\\\nvar thumb = html.img_url;\\\\nitems.push({\\\\n    title: '剧情简介：',\\\\n    desc: html.intro,\\\\n    pic_url: thumb,\\\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\\\n        setResult([{\\\\n            title: des,\\\\n            col_type: 'long_text'\\\\n        }]);\\\\n    }, html.intro),\\\\n    col_type: 'movie_1_vertical_pic'\\\\n});\\\\n\\\\nfor (var i = 0; i < tabs.length; i++) {\\\\n    if (getVar('appmtvsort', '1') == '1') {\\\\n        var list = html.videolist[tabs[i]];\\\\n    } else {\\\\n        var list = html.videolist[tabs[i]].reverse();\\\\n    };\\\\n    var ptab = tabs[i];\\\\n    items.push({\\\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [tabs.length] + \\\\\\\"““↓↑””\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('appmtvsort', getVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n    eval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\\\n    for (var j = 0; j < list.length; j++) {\\\\n        var srcurl = list[j].url;\\\\n        if (/293jx1/.test(srcurl)) {\\\\n            srcurl = srcurl.replace('293jx1', 'jx');\\\\n        } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\\\\\:8|ppzhu/.test(myurl)) {\\\\n            srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\\\n        }\\\\n        var title = list[j].title;\\\\n        title = title.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\\\n        if (list.length <= 4) {\\\\n            var clt = 'text_2';\\\\n        } else {\\\\n            var clt = isNaN(title) ? 'flex_button' : 'text_5'\\\\n        };\\\\n        items.push({\\\\n            title: title,\\\\n            url: $().lazyRule((ptab, srcurl, myurl) => {\\\\n                function openurl(resurl) {\\\\n                    if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili/) != -1) {\\\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                        if (enDn == '1') {\\\\n                            log('调用断插解析');\\\\n                            eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                            eval(fetch(config.cj));\\\\n                            return aytmParse(resurl);\\\\n                        } else {\\\\n                            return resurl\\\\n                        };\\\\n                    } else {\\\\n                        return resurl\\\\n                    }\\\\n                };\\\\n                //log(srcurl);\\\\n                //动态解析代码开始\\\\n                try {\\\\n                    if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos/.test(srcurl) && /http/.test(srcurl)) {\\\\n                        return /\\\\\\\\=/.test(srcurl) ? srcurl.split('=')[1] : srcurl + '#isVideo=true#';\\\\n                    } else if (srcurl.indexOf(\\\\\\\"/share/\\\\\\\") != -1) {\\\\n                        try {\\\\n                            var link = srcurl.split(\\\\\\\"/share\\\\\\\")[0];\\\\n                            var fc = fetch(srcurl, {}).replace(\\\\\\\"var purl\\\\\\\", \\\\\\\"var main\\\\\\\");\\\\n                            if (fc.indexOf(\\\\\\\"main\\\\\\\") != -1) {\\\\n                                var mat = fc.match(/var main.*?;/)[0];\\\\n                                eval(mat);\\\\n                                var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main);\\\\n                            } else {\\\\n                                var main = fc.match(/url:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1];\\\\n                                var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main)\\\\n                            };\\\\n                            return play;\\\\n                        } catch (e) {\\\\n                            return 'x5WebView://' + (srcurl)\\\\n                        }\\\\n                    } else if (ptab == 'alizy') {\\\\n                        var purl = fetch('https://foubin.com/jiexi.php?url=' + srcurl, {}).match(/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"(.*?)\\\\\\\\\\\\\\\"/)[1];\\\\n                        return purl;\\\\n                    } else if (/19jx\\\\\\\\.vip|nfyingshi/.test(srcurl)) {\\\\n                        var purl = JSON.parse(fetch(srcurl.replace('http://', 'https://'), {\\\\n                            headers: {\\\\n                                \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                            },\\\\n                            redirect: false,\\\\n                            withHeaders: true\\\\n                        })).headers.location[0];\\\\n                        if (/titan.mgtv/.test(purl)) {\\\\n                            return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                        } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                            return purl + '#isVideo=true#';\\\\n                        } else {\\\\n                            return purl\\\\n                        };\\\\n                    }\\\\n                    /*else if (/zhaikanys/.test(srcurl)) {\\\\n                                           var purl = JSON.parse(fetch(srcurl + '&app=10003&account=272775028&password=qq272775028', {\\\\n                                               headers: {\\\\n                                                   \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                               },\\\\n                                               redirect: false,\\\\n                                               withHeaders: true\\\\n                                           })).headers.location[0];\\\\n                                           if (/titan.mgtv/.test(purl)) {\\\\n                                               return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                                           } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                                               return purl + '#isVideo=true#';\\\\n                                           } else {\\\\n                                               return purl\\\\n                                           };\\\\n                                       }*/\\\\n\\\\n                    //----分割线----//\\\\n                    var scode = JSON.parse(fetch(srcurl, {\\\\n                        headers: {\\\\n                            \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                        },\\\\n                        redirect: false,\\\\n                        withStatusCode: true\\\\n                    }));\\\\n                    //log(scode);\\\\n                    if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                        var purl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                    } else {\\\\n                        //var html = request(srcurl);\\\\n                        var html = scode.body;\\\\n                        //log(html);\\\\n                        if (/404 Not Found|备案后可继续访问/.test(html)) {\\\\n                            return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                        } else if (/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\"\\\\\\\\:\\\\\\\\\\\\\\\"http/.test(html)) {\\\\n                            var purl = html.match(/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"(.*?)\\\\\\\\\\\\\\\"/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                        } else if (html.startsWith('{')) {\\\\n                            var purl = srcurl.substring(srcurl.indexOf('=http') + 1);\\\\n                        } else {\\\\n                            //var purl = srcurl\\\\n                            requireCache('https://code.aliyun.com/lzk23559/PublicRule/raw/master/x5rule.js', 24);\\\\n                            return x5rule(srcurl, srcurl);\\\\n                            //return 'x5WebView://'+(srcurl) \\\\n                        }\\\\n                    };\\\\n                    //log(purl);\\\\n                    if (/titan.mgtv/.test(purl)) {\\\\n                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                    } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                        return purl + '#isVideo=true#';\\\\n                    } else {\\\\n                        return purl\\\\n                    };\\\\n\\\\n                } catch (e) {\\\\n                    if (srcurl.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                        return openurl('https:' + srcurl);\\\\n                    } else if (/\\\\\\\\=http/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                        //return srcurl.split('=')[1];\\\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                    } else {\\\\n                        return openurl(srcurl)\\\\n                    }\\\\n                }\\\\n                //动态解析代码结束\\\\n            }, ptab, srcurl, myurl),\\\\n            col_type: clt\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"列表模式搜索二级\\\",\\\"path\\\":\\\"searerj\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar items = [];\\\\nvar nowDate = new Date();\\\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\nvar day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\nvar dateStr = month + '' + day;\\\\nvar spl = getResCode().split('#x#');\\\\nvar typet = spl[3];\\\\nvar tdomin = spl[2];\\\\nvar key = spl[4];\\\\n\\\\nif (/vipmv/.test(tdomin)) {\\\\n    var bhtml = request(spl[1]);\\\\n} else {\\\\n    var bhtml = fetch(spl[1], {\\\\n        headers: {\\\\n            \\\\\\\"User-Agent\\\\\\\": tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? \\\\\\\"Dart/2.14 (dart:io)\\\\\\\" : \\\\\\\"okhttp/4.1.0\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\ntry {\\\\n    bhtml = bhtml.startsWith('\\\\\\\\r\\\\\\\\n') ? bhtml.replace('\\\\\\\\r\\\\\\\\n', '') : bhtml;\\\\n} catch (e) {}\\\\nif (/btwaf/.test(bhtml)) {\\\\n    /*\\\\n                items.push({\\\\n                    title:'有宝塔验证，点击访问原网页',\\\\n                    url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n                    col_type: 'text_1'\\\\n                });\\\\n                */\\\\n\\\\n    bhtml = fetch(spl[1] + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], {});\\\\n\\\\n}\\\\n\\\\nif (bhtml == \\\\\\\"\\\\\\\" || bhtml == null || bhtml.substring(0, 5) == 'error' || !bhtml.startsWith('{')) {\\\\n    items.push({\\\\n        title: '未搜索到相关资源，点击访问原网页',\\\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n        col_type: 'text_1'\\\\n    });\\\\n} else if (bhtml.length < 80) {\\\\n    items.push({\\\\n        title: '返回数据不完整，点击访问原网页',\\\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n        col_type: 'text_1'\\\\n    });\\\\n} else {\\\\n    var html = JSON.parse(bhtml);\\\\n    //log(spl[1]);\\\\n    if (html.list) {\\\\n        var list = html.list;\\\\n    } else if (html.data.list) {\\\\n        var list = html.data.list;\\\\n    } else if (html.data) {\\\\n        var list = html.data;\\\\n    }\\\\n\\\\n    if (list.length < 1) {\\\\n        items.push({\\\\n            title: '未搜索到，点击访问原网页',\\\\n            url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n            col_type: 'text_1'\\\\n        });\\\\n    } else {\\\\n        for (var i = 0; i < list.length; i++) {\\\\n\\\\n            if (/TV/.test(typet)) {\\\\n                var title = list[i].title;\\\\n                var pic = list[i].pic;\\\\n                //var vid=tdomin+'/detail?vod_id='+list[i].nextlink+'&rel_limit=10';\\\\n                var vid = list[i].nextlink;\\\\n                var rem = list[i].state;\\\\n                //var con=list[i].state;\\\\n            } else {\\\\n                if (tdomin.indexOf('api.php/app/') != -1) {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    if (/fantuan/.test(tdomin)) {\\\\n                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\\\n                    } else {\\\\n                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\\\n                    }\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                } else {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    if (/iopenyun/.test(tdomin)) {\\\\n                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\\\n                    } else {\\\\n                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\\\n                    }\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                }\\\\n            }\\\\n\\\\n            items.push({\\\\n                title: title.replace(key, '““' + key + '””'),\\\\n                pic_url: pic + '@Referer=',\\\\n                url: $(tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((typet) => {\\\\n                    var res = {};\\\\n                    var items = [];\\\\n                    var html = JSON.parse(getResCode());\\\\n                    items.push({\\\\n                        title: '',\\\\n                        desc: '255&&float',\\\\n                        url: '',\\\\n                        col_type: 'x5_webview_single'\\\\n                    });\\\\n                    refreshX5WebView('');\\\\n                    var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                    if (/TV/.test(typet)) {\\\\n                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n                    } else {\\\\n                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                    }\\\\n                    res.data = items;\\\\n                    setHomeResult(res);\\\\n                }, typet),\\\\n                //content:rem,\\\\n                desc: rem,\\\\n                col_type: 'movie_1_vertical_pic'\\\\n            });\\\\n        } //for i\\\\n    } //else list.length\\\\n}\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP首页列表\\\",\\\"path\\\":\\\"appindexdata\\\",\\\"rule\\\":\\\"if (html.list) {\\\\n    var list = html.list;\\\\n} else if (html.data && html.data.list) {\\\\n    var list = html.data.list;\\\\n} else {\\\\n    var list = html.data;\\\\n}\\\\n\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    if (list[i].vod_list) {\\\\n        var lists = list[i].vod_list;\\\\n        var typename = list[i].vod_type_name;\\\\n    } else {\\\\n        var lists = list[i].vlist;\\\\n        var typename = list[i].type_name\\\\n    }\\\\n    items.push({\\\\n        title: typename,\\\\n        col_type: 'text_1'\\\\n\\\\n    });\\\\n\\\\n    for (var j = 0; j < lists.length; j++) {\\\\n        var title = lists[j].vod_name;\\\\n        var img = lists[j].vod_pic;\\\\n        var url = lists[j].vod_id;\\\\n        var desc = lists[j].vod_remarks;\\\\n        var nowDate = new Date();\\\\n        var month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\n        var day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\n        var dateStr = month + '' + day;\\\\n        if (html.list) {\\\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (html.data && html.data.list) {\\\\n            if (murl.search(/mogai_api/) != -1) {\\\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n            } else {\\\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\\\n            }\\\\n        } else {\\\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        };\\\\n        if (/fantuan/.test(murl)) {\\\\n            var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (/iopenyun/.test(murl)) {\\\\n            var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (/dijiaxia/.test(murl)) {\\\\n            var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\\\n        }\\\\n        items.push({\\\\n            title: title,\\\\n            pic_url: img + '@Referer=',\\\\n            url: $(link).rule(() => {\\\\n                var res = {};\\\\n                var items = [];\\\\n                items.push({\\\\n                    title: '',\\\\n                    desc: '255&&float',\\\\n                    url: '',\\\\n                    col_type: 'x5_webview_single'\\\\n                });\\\\n                refreshX5WebView('');\\\\n                var html = JSON.parse(getResCode());\\\\n                var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                try {\\\\n                    eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                } catch (e) {}\\\\n                res.data = items;\\\\n                setHomeResult(res);\\\\n            }),\\\\n            desc: desc,\\\\n            col_type: 'movie_3_marquee'\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"首次导入等待\\\",\\\"path\\\":\\\"wait\\\",\\\"rule\\\":\\\"function canUse() {\\\\n    /*\\\\n    //如果更新了规则也要限流，可以修改key\\\\n    let key = \\\\\\\"lock4\\\\\\\"\\\\n    //等待分钟数\\\\n    let waitMin = 10\\\\n    \\\\n    let min = Math.round(Math.random() * 1000 * 60 * waitMin)\\\\n    let unlock = new Date().getTime() + min;\\\\n    let time = getItem(key, \\\\\\\"\\\\\\\");\\\\n    if (time == \\\\\\\"\\\\\\\") {\\\\n        setItem(key, \\\\\\\"\\\\\\\" + unlock)\\\\n        let st = new Date(unlock).toLocaleString().replace(/:\\\\\\\\d{1,2}$/, ' ');\\\\n        let msg = \\\\\\\"这是您第一次使用该版本规则，为避免第一次导入使用人数激增，规则将在\\\\\\\" + st + \\\\\\\"解锁使用。<br><br>好规则不怕晚，请耐心等待！该提示仅在第一次导入（更新）时出现，后续使用过程中不会出现！\\\\\\\"\\\\n        setResult([{\\\\n            title: msg,\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\n        }])\\\\n        return false\\\\n    } else if (parseInt(time) < new Date().getTime()) {\\\\n        return true\\\\n    } else {\\\\n        let st = new Date(parseInt(time)).toLocaleString().replace(/:\\\\\\\\d{1,2}$/, ' ');\\\\n        let msg = \\\\\\\"为避免使用人数激增，规则将在\\\\\\\" + st + \\\\\\\"解锁使用。<br><br>好规则不怕晚，请耐心等待！该提示仅在第一次导入（更新）时出现，后续使用过程中不会出现！\\\\\\\"\\\\n        setResult([{\\\\n            title: msg,\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\n        }])\\\\n        return false\\\\n    }*/\\\\n    return true\\\\n}\\\\n$.exports = canUse();\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"断念插件调用\\\",\\\"path\\\":\\\"dnplugin\\\",\\\"rule\\\":\\\"var dnen = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\nitems.push({\\\\n    title: '断插：' + (dnen == '1' ? '““✅””' : '❎'),\\\\n    url: $('').lazyRule((dnen) => {\\\\n        if (dnen == '1') {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"');\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            refreshPage(false);\\\\n            return 'toast://已禁用断插调用！';\\\\n        } else {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"');\\\\n            //log(fileUrl);\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            refreshPage(false);\\\\n            return 'toast://已开启断插调用！'\\\\n        }\\\\n    }, dnen),\\\\n    col_type: 'scroll_button'\\\\n});\\\\nif (dnen == '1') {\\\\n    items.push({\\\\n        title: '线路配置',\\\\n        url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n    items.push({\\\\n        title: '解析管理',\\\\n        url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"设置页代码\\\",\\\"path\\\":\\\"setting\\\",\\\"rule\\\":\\\"var d = [];\\\\nvar setjson = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {}));\\\\nvar ssmd = setjson.ssmode;\\\\nvar ssxc = setjson.sscount;\\\\nd.push({\\\\n    title: '搜索设置',\\\\n    col_type: 'text_center_1'\\\\n});\\\\nd.push({\\\\n    title: '当前：' + '(' + (ssmd == 1 ? '聚合结果' : '引擎列表') + ')',\\\\n    url: $('hiker://empty').lazyRule(() => {\\\\n        var md = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\\\n\\\\n        if (md == 1) {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"');\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            back(true);\\\\n            return 'toast://切换为搜索引擎列表单选模式成功！';\\\\n        } else {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"');\\\\n            //log(fileUrl);\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            back(true);\\\\n            return 'toast://切换为聚合搜索模式成功！'\\\\n        }\\\\n    }),\\\\n    col_type: 'text_2'\\\\n})\\\\nd.push({\\\\n    title: '搜索超时(' + '' + getItem('apptimout', '')+')',\\\\n    url: \\\\\\\"input://\\\\\\\" + '3000' + \\\\\\\"////请设置超时时间，1000为一秒。.js:var num = parseInt(input).toString();if (num == 'NaN'||num<1000) {'toast://输入的值好像不正确。';} else {setItem('apptimout', num);refreshPage();'toast://设置成功。'}\\\\\\\",\\\\n    col_type: 'text_2'\\\\n});\\\\n\\\\nd.push({\\\\n    title: '搜索线程' + '(' + ssxc + ')',\\\\n    url: \\\\\\\"input://\\\\\\\" + JSON.stringify({\\\\n        value: \\\\\\\"5\\\\\\\",\\\\n        hint: \\\\\\\"请输入一个整数数字，推荐最大不要超过15。\\\\\\\",\\\\n        js: $.toString(() => {\\\\n            var num = parseInt(input).toString();\\\\n            if (num == 'NaN' || num < 1) {\\\\n                return 'toast://输入的值好像不正确。';\\\\n            } else {\\\\n                var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace(/\\\\\\\\\\\\\\\"sscount\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"[\\\\\\\\d]*\\\\\\\\\\\\\\\"/, '\\\\\\\\\\\\\\\"sscount\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"' + num + '\\\\\\\\\\\\\\\"');\\\\n                writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n                back(true);\\\\n                return 'toast://保存设置搜索线程完成！'\\\\n            }\\\\n        }),\\\\n    }),\\\\n    col_type: 'text_2'\\\\n});\\\\n\\\\nd.push({\\\\n    title: '更新相关',\\\\n    col_type: 'text_center_1'\\\\n});\\\\nd.push({\\\\n    title: '检测更新',\\\\n    url: $('').lazyRule((locver) => {\\\\n        try {\\\\n            var remf = fetchCache('https://codeberg.org/lzk23559/cloudrule/raw/branch/master/appmovie.txt', 24);\\\\n        } catch (e) {\\\\n            remf = '';\\\\n        }\\\\n        if (/￥base64/.test(remf)) {\\\\n            var remv = JSON.parse(base64Decode(remf.split('@')[2])).version;\\\\n        } else if (/￥home_rule￥/.test(remf)) {\\\\n            var remv = JSON.parse(remf.split('￥home_rule￥')[1]).version;\\\\n        };\\\\n        if (/￥home_rule/.test(remf)) {\\\\n            log('远程版本：' + remv);\\\\n            log('本地版本：' + locver);\\\\n            if (locver != remv) {\\\\n                putVar('appnver', remf);\\\\n                refreshPage();\\\\n                return 'toast://有新版本，点导入更新可更新规则。';\\\\n            } else {\\\\n                return 'toast://暂无新版本，24小时内检测无效。'\\\\n            };\\\\n        } else {\\\\n            return 'toast://检测更新失败，可能云端抽风了。'\\\\n        }\\\\n    }, locver),\\\\n    col_type: 'text_2'\\\\n});\\\\nif (getVar('appnver')) {\\\\n    d.push({\\\\n        title: '导入更新',\\\\n        url: $('').lazyRule(() => {\\\\n            return getVar('appnver');\\\\n        }),\\\\n        col_type: 'text_2'\\\\n    });\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"最新章节\\\",\\\"path\\\":\\\"chapter\\\",\\\"rule\\\":\\\"var chp = [];\\\\ntry {\\\\n    var html = JSON.parse(getResCode());\\\\n    if (html.videolist) {\\\\n        var conts = Object.keys(html.videolist);\\\\n    } else if (html.data.vod_url_with_player) {\\\\n        var conts = html.data.vod_url_with_player;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_play_url.split('$$$');\\\\n        }\\\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n        var conts = html.data.vod_info.vod_url_with_player;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_info.vod_play_url.split('$$$');\\\\n        }\\\\n    } else {\\\\n        var conts = html.data.vod_play_list;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_play_url.split('$$$');\\\\n        }\\\\n    }\\\\n\\\\n    for (var i = 0; i < conts.length; i++) {\\\\n        if (html.videolist) {\\\\n            var list = html.videolist[conts[i]];\\\\n        } else if (conts[i].urls) {\\\\n            var list = conts[i].urls;\\\\n        } else if (conts[i].url) {\\\\n            var list = conts[i].url.split(\\\\\\\"#\\\\\\\");\\\\n        } else {\\\\n            var list = conts[i].split(\\\\\\\"#\\\\\\\");\\\\n        }\\\\n        chp.push(list.length);\\\\n    }\\\\n} catch (e) {}\\\\n//log(Math.max.apply(Math,chp));\\\\nsetResult('更新至:' + (Math.max.apply(Math, chp)));\\\"}]\"}","picUrl":"https://img2.doubanio.com/view/photo/s_ratio_poster/public/p2653117123.jpg@Referer=","title":"点击查看 IPTV 分类 鲁滨逊漂流记 的聚搜结果-““鲁滨逊漂流记””\n1080P"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!