API tools faq
paste
View difference between Paste ID: DsemVkfR and PgWzcU0f
SHOW: | | - or go back to the newest paste.
1
if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end
2
print(" this script was (NOT) edited by An ignorant / zach ")
3
warn(" credits goes to Dark eccentric and Mr steal yo bork ")
4
warn(" im too lazy to edit so here i only convert im tired")
5
warn(" you can just clone it and edit the color yourself")
6
warn(" im tired bruh ")
7-
local Player,game,owner = owner,game
7+
 if game:GetService("RunService"):IsClient()then error("Please run as a server script. Use h/ instead of hl/.")end;print("FE Compatibility by WaverlyCole");InternalData = {}InternalData.RealOwner = owner;InternalData.RealObjs = {};InternalData.SoundLoudness = {};
8-
local RealPlayer = Player
8+
9
    script.Parent = InternalData.RealOwner.Character

10-
    print("FE Compatibility code by Mokiros")

10+
    local Event = Instance.new("RemoteEvent");Event.Name = "UserInput";InternalData.Event = Event

11-
    print("This EDIT was made by Zach the script stealer / aka zach so please stop pretending that you made it")

11+
    local function createObject (connections, index)

12-
    local rp = RealPlayer

12+
        local proxy = newproxy (true);local meta = getmetatable (proxy);

13-
    script.Parent = rp.Character

13+
        local runbind = function (self, i, ...) connections[i]:Fire (...); end;

14-
   

14+
        while (#connections > 0) do connections[table.remove(connections, 1)] = Instance.new ('BindableEvent');end;

15-
    --RemoteEvent for communicating

15+
        meta.__index = function (self, i)

16-
    local Event = Instance.new("RemoteEvent")

16+
            if (i == 'TriggerEvent') then return runbind end;

17-
    Event.Name = "UserInput_Event"

17+
            return connections[i] and connections[i].Event or index[i];

18
        end;

19-
    --Fake event to make stuff like Mouse.KeyDown work

19+
        meta.__newindex = index;meta.__metatable = false;return proxy

20-
    local function fakeEvent()

20+
    end;

21-
        local t = {_fakeEvent=true,Functions={},Connect=function(self,f)table.insert(self.Functions,f) end}

21+
    local Mouse = createObject({"KeyUp","KeyDown","Button1Down","Button1Up"},{["Target"] = nil;["Hit"] = CFrame.new()})

22-
        t.connect = t.Connect

22+
    local UserInputService = createObject({"InputBegan","InputEnded"},{})

23-
        return t

23+
    local ContextActionService = {Actions={},BindAction = function(self,actionName,Func,touch,...)

24
        self.Actions[actionName] = Func and {Name=actionName,Function=Func,Keys={...}} or nil

25
    end};ContextActionService.UnBindAction = ContextActionService.BindAction

26-
    --Creating fake input objects with fake variables

26+
    Event.OnServerEvent:Connect(function(FiredBy,Input)

27-
    local m = {Target=nil,Hit=CFrame.new(),KeyUp=fakeEvent(),KeyDown=fakeEvent(),Button1Up=fakeEvent(),Button1Down=fakeEvent()}

27+
        if FiredBy ~= InternalData.RealOwner then return end

28-
    local UIS = {InputBegan=fakeEvent(),InputEnded=fakeEvent()}

28+
        if Input.MouseEvent then

29-
    local CAS = {Actions={},BindAction=function(self,name,fun,touch,...)

29+
            Mouse.Target = Input.Target;Mouse.Hit = Input.Hit

30-
        CAS.Actions[name] = fun and {Name=name,Function=fun,Keys={...}} or nil

30+
        elseif Input.Sound then

31-
    end}

31+
            if InternalData.SoundLoudness[Input.Sound] then InternalData.SoundLoudness[Input.Sound] = Input.Loudness end

32-
    --Merged 2 functions into one by checking amount of arguments

32+
        else

33-
    CAS.UnbindAction = CAS.BindAction

33+
            local Begin = Input.UserInputState == Enum.UserInputState.Begin

34
            if Input.UserInputType == Enum.UserInputType.MouseButton1 then return Mouse:TriggerEvent(Begin and "Button1Down" or "Button1Up") end

35-
    --This function will trigger the events that have been :Connect()'ed

35+
            for _,Action in pairs(ContextActionService.Actions) do

36-
    local function te(self,ev,...)

36+
                for _,Key in pairs(Action.Keys) do if Key==Input.KeyCode then Action.Function(Action.Name,Input.UserInputState,Input) end end

37-
        local t = m[ev]

37+
38-
        if t and t._fakeEvent then

38+
            Mouse:TriggerEvent(Begin and "KeyDown" or "KeyUp",Input.KeyCode.Name:lower());UserInputService:TriggerEvent(Begin and "InputBegan" or "InputEnded",Input,false)

39-
            for _,f in pairs(t.Functions) do

39+
40-
                f(...)

40+
41
    InternalData["Mouse"] = Mouse;InternalData["ContextActionService"] = ContextActionService;InternalData["UserInputService"] = UserInputService

42
    Event.Parent = NLS([[

43
        local Player = owner;

44-
    m.TrigEvent = te

44+
        local Sounds = {};

45-
    UIS.TrigEvent = te

45+
        local Event = script:WaitForChild("UserInput");

46
        local UserInputService = game:GetService("UserInputService");

47-
    Event.OnServerEvent:Connect(function(plr,io)

47+
        local Mouse = Player:GetMouse();

48-
        if plr~=rp then return end

48+
        local Input = function(Input,gameProcessedEvent)

49-
        m.Target = io.Target

49+
            if gameProcessedEvent then return end

50-
        m.Hit = io.Hit

50+
            Event:FireServer({KeyCode=Input.KeyCode,UserInputType=Input.UserInputType,UserInputState=Input.UserInputState})

51-
        if not io.isMouse then

51+
52-
            local b = io.UserInputState == Enum.UserInputState.Begin

52+
        Event.OnClientEvent:connect(function(Args)

53-
            if io.UserInputType == Enum.UserInputType.MouseButton1 then

53+
            if Args[1] == "NewSound" then table.insert(Sounds,Args[2]) end

54-
                return m:TrigEvent(b and "Button1Down" or "Button1Up")

54+
        end)

55
        UserInputService.InputBegan:Connect(Input);UserInputService.InputEnded:Connect(Input)

56-
            for _,t in pairs(CAS.Actions) do

56+
        local Hit,Target

57-
                for _,k in pairs(t.Keys) do

57+
        while wait(1/30) do

58-
                    if k==io.KeyCode then

58+
            for x,Sound in pairs(Sounds) do

59-
                        t.Function(t.Name,io.UserInputState,io)

59+
                if Sound.Parent then Event:FireServer({["Sound"]=Sound,["Loudness"]=Sound.PlaybackLoudness}) end

60
            end

61
            if Hit ~= Mouse.Hit or Target ~= Mouse.Target then

62
                Hit = Mouse.Hit;Target = Mouse.Target;

63-
            m:TrigEvent(b and "KeyDown" or "KeyUp",io.KeyCode.Name:lower())

63+
                Event:FireServer({["MouseEvent"]=true,["Target"]=Target,["Hit"]=Hit})

64-
            UIS:TrigEvent(b and "InputBegan" or "InputEnded",io,false)

64+
65
        end

66
    ]],InternalData.RealOwner.Character)

67-
    Event.Parent = NLS([==[

67+
68-
    local Player = game:GetService("Players").LocalPlayer

68+
InternalData.NewOwner = setmetatable({},{

69-
    local Event = script:WaitForChild("UserInput_Event")

69+
    __index = function (self,Index)

70
            local Type = type(InternalData.RealOwner[Index])

71-
    local Mouse = Player:GetMouse()

71+
            if Type == "function" then

72-
    local UIS = game:GetService("UserInputService")

72+
                if Index:lower() == "getmouse" or Index:lower() == "mouse" then

73-
    local input = function(io,a)

73+
                return function (self)return InternalData["Mouse"] end

74-
        if a then return end

74+
75-
        --Since InputObject is a client-side instance, we create and pass table instead

75+
            return function (self,...)return InternalData.RealOwner[Index](InternalData.RealOwner,...) end

76-
        Event:FireServer({KeyCode=io.KeyCode,UserInputType=io.UserInputType,UserInputState=io.UserInputState,Hit=Mouse.Hit,Target=Mouse.Target})

76+
        elseif Index == "FakePlayer" then

77
            return true

78-
    UIS.InputBegan:Connect(input)

78+
79-
    UIS.InputEnded:Connect(input)

79+
        return InternalData.RealOwner[Index]

80
    end;

81-
    local h,t

81+
    __tostring = function(self) return tostring(InternalData.RealOwner) end

82-
    --Give the server mouse data 30 times every second, but only if the values changed

82+
})

83-
    --If player is not moving their mouse, client won't fire events

83+
--LoadLibrary("RbxUtility").Create

84-
    while wait(1/30) do

84+
rans=string.reverse'!321enirboreheibmoz yb edam'

85-
        if h~=Mouse.Hit or t~=Mouse.Target then

85+
InternalData.LoadLibrary = LoadLibrary;LoadLibrary = function(Library)

86-
            h,t=Mouse.Hit,Mouse.Target

86+
    if Library == "RbxUtility" then

87-
            Event:FireServer({isMouse=true,Target=t,Hit=h})

87+
        return setmetatable({},{

88
            __tostring = function() return "RbxUtility" end;

89-
    end]==],Player.Character)

89+
            __index = function(self, Index)

90
                if Index:lower() == "create" then

91-
    ----Sandboxed game object that allows the usage of client-side methods and services

91+
                    return function(Type)

92-
    --Real game object

92+
                        return function(Data)

93-
    local _rg = game

93+
                            Data = Data or {}

94
                            local Inst = Instance.new(Type)

95-
    --Metatable for fake service

95+
                            for x,y in pairs(Data) do

96-
    local fsmt = {

96+
                                if InternalData.RealObjs[y] then y = InternalData.RealObjs[y] end

97-
        __index = function(self,k)

97+
                                if y == owner then y = InternalData.RealOwner end

98-
            local s = rawget(self,"_RealService")

98+
                                Inst[x] = y

99-
            if s then return s[k] end

99+
                            end

100-
        end,

100+
                            return Inst

101-
        __newindex = function(self,k,v)

101+
                        end

102-
            local s = rawget(self,"_RealService")

102+
103-
            if s then s[k]=v end

103+
104-
        end,

104+
                return InternalData.LoadLibrary(Library)[Index]

105-
        __call = function(self,...)

105+
106-
            local s = rawget(self,"_RealService")

106+
        })

107-
            if s then return s(...) end

107+
108
    return InternalData.LoadLibrary(Library)

109-
    }

109+
110-
    local function FakeService(t,RealService)

110+
InternalData.RealInstance = Instance;Instance = setmetatable({},{

111-
        t._RealService = typeof(RealService)=="string" and _rg:GetService(RealService) or RealService

111+
    __index = function (self,Index)

112-
        return setmetatable(t,fsmt)

112+
        if Index:lower() == 'new' then

113
            return function (Type, Parent)

114
                if Parent == owner then Parent = InternalData.RealOwner end

115-
    --Fake game object

115+
                if InternalData.RealObjs[Parent] then Parent = InternalData.RealObjs[Parent] end

116-
    local g = {

116+
                local Real = InternalData.RealInstance.new(Type,Parent)

117-
        GetService = function(self,s)

117+
                if not Type then return end

118-
            return self[s]

118+
                if Type == "BillboardGui" then

119-
        end,

119+
                    local ToReturn = setmetatable({},{

120-
        Players = FakeService({

120+
                        __index = function (self,Index)

121-
            LocalPlayer = FakeService({GetMouse=function(self)return m end},Player)

121+
                            if type(Real[Index]) == "function" then

122-
        },"Players"),

122+
                                if Index:lower() == "clone" then

123-
        UserInputService = FakeService(UIS,"UserInputService"),

123+
                                    return function (self)

124-
        ContextActionService = FakeService(CAS,"ContextActionService"),

124+
                                        local Real = Real:Clone()

125-
    }

125+
                                        local ToReturn = setmetatable({RealObject = Real},{

126-
    rawset(g.Players,"localPlayer",g.Players.LocalPlayer)

126+
                                            __index = function (self,Index)

127-
    g.service = g.GetService

127+
                                                if type(Real[Index]) == "function" then return function (self,...) return Real[Index](Real,...)end end

128-
   

128+
                                                return Real[Index]

129-
    g.RunService = FakeService({

129+
                                            end;

130-
        RenderStepped = _rg:GetService("RunService").Heartbeat,

130+
                                            __newindex = function (self,Index,Value)

131-
        BindToRenderStep = function(self,name,_,fun)

131+
                                                if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

132
                                                if Value == owner then Value = InternalData.RealOwner end

133-
        end,

133+
                                                Real[Index] = Value

134-
        UnbindFromRenderStep = function(self,name)

134+
                                            end;

135-
            self._btrs[name]:Disconnect()

135+
                                            __tostring = function(self) return tostring(Real) end;

136-
        end,

136+
                                        })

137-
    },"RunService")

137+
                                        InternalData.RealObjs[ToReturn] = Real;return ToReturn;

138
                                    end

139-
    setmetatable(g,{

139+
                                end

140-
        __index=function(self,s)

140+
                                return function (self,...) return Real[Index](Real,...)end

141-
            return _rg:GetService(s) or typeof(_rg[s])=="function"

141+
                            end

142-
            and function(_,...)return _rg[s](_rg,...)end or _rg[s]

142+
                            return Real[Index]

143-
        end,

143+
                        end;

144-
        __newindex = fsmt.__newindex,

144+
                        __newindex = function (self,Index,Value)

145-
        __call = fsmt.__call

145+
                            if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

146-
    })

146+
                            if Value == owner then Value = InternalData.RealOwner end

147-
    --Changing owner to fake player object to support owner:GetMouse()

147+
                            Real[Index] = Value

148-
    game,owner = g,g.Players.LocalPlayer

148+
                        end;

149
                        __tostring = function(self) return tostring(Real) end;

150
                    })

151
                    InternalData.RealObjs[ToReturn] = Real;return ToReturn;

152
                elseif Type:lower() == "sound" then

153
                    Real.Parent = owner.Character;

154
                    local ToReturn = setmetatable({RealObject = Real},{

155
                        __index = function (self,Index)

156
                            if Index:lower() == "playbackloudness" then

157
                                return InternalData.SoundLoudness[Real] or 0

158
                            elseif type(Real[Index]) == "function" then

159
                                if Index:lower() == "clone" then

160
                                    return function (self)

161
                                        local Real = Real:Clone()

162
                                        local ToReturn = setmetatable({},{

163
                                            __index = function (self,Index)

164
                                                if type(Real[Index]) == "function" then return function (self,...) return Real[Index](Real,...)end end

165
                                                return Real[Index]

166
                                            end;

167
                                            __newindex = function (self,Index,Value)

168
                                                if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

169
                                                if Value == owner then Value = InternalData.RealOwner end

170
                                                Real[Index] = Value

171-
sign.BrickColor = BrickColor.new("Bright bluish green") 

171+
                                            end;

172
                                            __tostring = function(self) return tostring(Real) end;

173
                                        })

174
                                        InternalData.RealObjs[ToReturn] = Real;return ToReturn;

175
                                    end

176
                                end

177
                                return function (self,...) return Real[Index](Real,...)end

178
                            end

179
                            return Real[Index]

180
                        end;

181
                        __newindex = function (self,Index,Value)

182
                            if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

183
                            if Value == owner then Value = InternalData.RealOwner end

184
                            Real[Index] = Value

185
                        end;

186
                        __tostring = function(self) return tostring(Real) end;

187
                    })

188
                    InternalData.RealObjs[ToReturn] = Real;InternalData.SoundLoudness[Real] = 0;repeat wait() until InternalData.Event.Parent InternalData.Event:FireClient(InternalData.RealOwner,{"NewSound",Real}) return ToReturn;

189
                else

190
                    local ToReturn = setmetatable({RealObject = Real},{

191
                        __index = function (self,Index)

192
                            if type(Real[Index]) == "function" then

193
                                if Index:lower() == "clone" then

194
                                    return function (self)

195
                                        local Real = Real:Clone()

196
                                        local ToReturn = setmetatable({},{

197
                                            __index = function (self,Index)

198
                                                if type(Real[Index]) == "function" then return function (self,...) return Real[Index](Real,...)end end

199
                                                return Real[Index]

200
                                            end;

201
                                            __newindex = function (self,Index,Value)

202
                                                if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

203
                                                if Value == owner then Value = InternalData.RealOwner end

204
                                                Real[Index] = Value

205
                                            end;

206
                                            __tostring = function(self) return tostring(Real) end;

207
                                        })

208
                                        InternalData.RealObjs[ToReturn] = Real;return ToReturn;

209
                                    end

210
                                end

211
                                return function (self,...) return Real[Index](Real,...)end

212
                            end

213
                            return Real[Index]

214
                        end;

215
                        __newindex = function (self,Index,Value)

216
                            if InternalData.RealObjs[Value] then Value = InternalData.RealObjs[Value] end

217
                            if Value == owner then Value = InternalData.RealOwner end

218
                            Real[Index] = Value

219
                        end;

220
                        __tostring = function(self) return tostring(Real) end;

221
                    })

222
                    InternalData.RealObjs[ToReturn] = Real;return ToReturn;

223
                end

224
            end

225
        end

226
        return InternalData.RealInstance[Index]

227
    end;

228
    __tostring = function(self) return tostring(InternalData.RealInstance) end;

229
});

230
InternalData.RealGame = game;game = setmetatable({},{

231
    __index = function (self,Index)

232
        if InternalData.RealGame[Index] then

233
            local Type = type(InternalData.RealGame[Index])

234
            if Type == "function" then

235
                if Index:lower() == "getservice" or Index:lower() == "service" then

236
                    return function (self,Service)

237
                        local FakeServices = {

238
                            ["players"] = function()

239
                                return setmetatable({},{

240
                                    __index = function (self2,Index2)

241
                                        local RealService = InternalData.RealGame:GetService(Service)

242
                                        local Type2 = type(RealService[Index2])

243
                                        if Type2 == "function" then

244
                                            return function (self,...) return RealService[Index2](RealService,...)end

245
                                        else

246
                                            if Index2:lower() == "localplayer" then return InternalData.NewOwner end

247
                                            return RealService[Index2]

248
                                        end

249
                                    end;

250
                                    __tostring = function(self) return tostring(InternalData.RealGame:GetService(Service)) end

251
                                })

252
                            end;

253
                            ["contextactionservice"] = function() return InternalData["ContextActionService"] end;

254
                            ["userinputservice"] = function() return InternalData["UserInputService"] end;

255
                            ["debris"] = function()

256
                                return setmetatable({},{

257
                                    __index = function(self2,Index2)

258
                                        local RealService = InternalData.RealGame:GetService(Service)

259
                                        local Type2 = type(RealService[Index2])

260
                                        if Type2 == "function" then

261
                                            if Index2:lower() == "additem" then

262
                                                return function (self,Item,Time)

263
                                                    if InternalData.RealObjs[Item] then Item = InternalData.RealObjs[Item] end

264
                                                    return RealService:AddItem(Item,Time)

265
                                                end

266
                                            end

267
                                            return function (self,...) return RealService[Index2](RealService,...) end

268
                                        end

269
                                        return RealService[Index2]

270
                                    end;

271
                                    __tostring = function(self) return tostring(InternalData.RealGame:GetService("Debris")) end

272
                                })

273
                            end;

274
                            ["runservice"] = function()

275
                                return setmetatable({},{

276
                                    __index = function(self2,Index2)

277
                                        local RealService = InternalData.RealGame:GetService(Service)

278
                                        local Type2 = type(RealService[Index2])

279
                                        if Type2 == "function" then

280
                                            return function (self,...) return RealService[Index2](RealService,...) end

281
                                        else

282
                                            local RunServices = {

283
                                                ["bindtorenderstep"] = function() return function (self,Name,Priority,Function) return InternalData.RealGame:GetService("RunService").Stepped:Connect(Function) end end;

284
                                                ["renderstepped"] = function() return RealService["Stepped"] end

285
                                            }

286
                                            if RunServices[Index2:lower()] then return RunServices[Index2:lower()]() end

287
                                            return RealService[Index2]

288
                                        end

289
                                    end;

290
                                    __tostring = function(self) return tostring(InternalData.RealGame:GetService("RunService")) end

291
                                })

292
                            end

293
                        }

294
                        if FakeServices[Service:lower()] then return FakeServices[Service:lower()]() end

295
                        return InternalData.RealGame:GetService(Service)

296
                    end

297
                end

298
                return function (self,...) return InternalData.RealGame[Index](InternalData.RealGame,...) end

299
            else

300
                if game:GetService(Index) then return game:GetService(Index) end

301
                return InternalData.RealGame[Index]

302
            end

303
        end

304
        return nil

305
    end;

306
    __tostring = function(self) return tostring(InternalData.game) end

307
});Game = game;owner = game:GetService("Players").LocalPlayer;script = Instance.new("Script");print("Complete!")

308
309
p = game.Players.LocalPlayer

310
t = Instance.new("Tool") 

311
t.Parent = p.Backpack 

312
t.Name = "Sign lololo" 

313
local handlelol = Instance.new("Part") 

314
handlelol.Name = "Handle" 

315
handlelol.Parent = t 

316
handlelol.formFactor = "Plate" 

317
handlelol.BrickColor = BrickColor.new("Brown") 

318
handlelol.Size = Vector3.new(1, 4.5, .5) 

319
handlelol.TopSurface = "Smooth" 

320
handlelol.BottomSurface = "Smooth" 

321
handlelol.Reflectance = 0 

322
handlelol.Material = "Wood"

323
local sign = Instance.new("Part") 

324
sign.Name = "Part" 

325
sign.Parent = t 

326
sign.formFactor = "Plate" 

327
sign.BrickColor = BrickColor.new("Brown") 

328
sign.Size = Vector3.new(5, 4, 1) 

329
sign.TopSurface = "Smooth" 

330
sign.BottomSurface = "Smooth" 

331
sign.Reflectance = 0 

332
 

333
mesh123 = Instance.new("BlockMesh") 

334
mesh123.Parent = sign 

335
mesh123.Scale = Vector3.new(1.1, 1.1, 0.8) 

336
337
w2 = Instance.new("Weld")

338
w2.Parent = handlelol

339
w2.Part0 = sign

340
w2.Part1 = handlelol

341
w2.C0 = CFrame.fromEulerAnglesXYZ(0, 0, 0) + Vector3.new(0, -2.5, 0)

342
-----------------------------------------------------------------------

343
local SurfaceGui = Instance.new("SurfaceGui")

344
local TextBox = Instance.new("TextBox")

345
local ScreenGui = Instance.new("ScreenGui")

346
local TextLabel = Instance.new("TextBox")

347
ScreenGui.Parent = p.PlayerGui

348
TextBox.Parent = ScreenGui

349
TextBox.BackgroundColor3 = Color3.new(0.756863, 0.705882, 1)

350
TextBox.Position = UDim2.new(0, 74, 0, 374)

351
TextBox.Size = UDim2.new(0, 176, 0, 50)

352
TextBox.Font = Enum.Font.Highway

353
TextBox.FontSize = Enum.FontSize.Size28

354
TextBox.Text = "Type text you want here"

355
TextBox.TextSize = 10

356
TextBox.TextWrapped = true

357
TextBox.Visible = false

358
SurfaceGui.Parent = sign

359
SurfaceGui.Face = Enum.NormalId.Front

360
TextLabel.Parent = SurfaceGui

361
TextLabel.BackgroundColor3 = Color3.new(1, 1, 1)

362
TextLabel.BackgroundTransparency = 1

363
TextLabel.Size = UDim2.new(0, 800, 0, 600)

364
TextLabel.Font = Enum.Font.SourceSans

365
TextLabel.FontSize = Enum.FontSize.Size96

366
TextLabel.Text = "same"

367
TextLabel.TextColor3 = Color3.new(0.956863, 0.345098, 0.0588235)

368
TextLabel.TextSize = 100

369
TextLabel.TextWrapped = true

370
t.Equipped:connect(function()

371
	TextBox.Visible = true

372
end)

373
374
t.Unequipped:connect(function()

375
	TextBox.Visible = false

376
end)

377
wait(1)

378
TextBox.Changed:connect(function()

379
	TextLabel.Text = TextBox.Text

380
end)
        

    


            


                                


        

            



                
    

        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!