插件名：global_我只想好好观影

海阔视界规则分享，当前分享的是：网页插件￥js_url￥global_我只想好好观影@base64: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