API tools faq
paste
andrewchris511

dbkiss

andrewchris511
Jan 16th, 2018
74
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 190.19 KB | None | 0 0
raw download clone embed print report
  1. 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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!