API tools faq
paste
xiaomianao666

插件名：NewPlanConfigFile

xiaomianao666
Dec 3rd, 2024
189
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 155.51 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：网页插件￥js_url￥NewPlanConfigFile@base64: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
Add Comment
Please, Sign In to add comment
Public Pastes
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!