API tools faq
paste
View difference between Paste ID: cfw45VVe and hVNbE37x
SHOW: | | - or go back to the newest paste.
1
-----------------------
2
--[[ Name : Hell security ]]--
3
-------------------------------------------------------
4
5
--[[ "Haha, I'm a funny guy, but once you anger me..." ]]--

6
	--[[ "There's no coming back =)" ]]--

7
8
--A script By doryna2281337

9
10
-------------------------------------------------------

11
12
local FavIDs = {

13
	340106355, --Nefl Crystals

14
	927529620, --Dimension

15
	876981900, --Fantasy

16
	398987889, --Ordinary Days

17
	1117396305, --Oh wait, it's you.

18
	885996042, --Action Winter Journey

19
	919231299, --Sprawling Idiot Effigy

20
	743466274, --Good Day Sunshine

21
	727411183, --Knife Fight

22
	1402748531, --The Earth Is Counting On You!

23
	595230126 --Robot Language

24
	}

25
26
27
28
--The reality of my life isn't real but a Universe -doryna2281337

29
if game:GetService("RunService"):IsClient() then error("Script must be server-side in order to work; use h/ and not hl/") end

30
local Player,Mouse,mouse,UserInputService,ContextActionService = owner

31
do

32
	print("FE Compatibility code by Me")

33
	script.Parent = Player.Character

34
35
	--RemoteEvent for communicating

36
	local Event = Instance.new("RemoteEvent")

37
	Event.Name = "UserInput_Event"

38
39
	--Fake event to make stuff like Mouse.KeyDown work

40
	local function fakeEvent()

41
		local t = {_fakeEvent=true,Connect=function(self,f)self.Function=f end}

42
		t.connect = t.Connect

43
		return t

44
	end

45
46
	--Creating fake input objects with fake variables

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

48
	local UIS = {InputBegan=fakeEvent(),InputEnded=fakeEvent()}

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

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

51
	end}

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

53
	CAS.UnbindAction = CAS.BindAction

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

56
	local function te(self,ev,...)

57
		local t = m[ev]

58
		if t and t._fakeEvent and t.Function then

59
			t.Function(...)

60
		end

61
	end

62
	m.TrigEvent = te

63
	UIS.TrigEvent = te

64
65
	Event.OnServerEvent:Connect(function(plr,io)

66
	    if plr~=Player then return end

67
		if io.isMouse then

68
			m.Target = io.Target

69
			m.Hit = io.Hit

70
		else

71
			local b = io.UserInputState == Enum.UserInputState.Begin

72
			if io.UserInputType == Enum.UserInputType.MouseButton1 then

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

74
			end

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

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

77
					if k==io.KeyCode then

78
						t.Function(t.Name,io.UserInputState,io)

79
					end

80
				end

81
			end

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

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

84
	    end

85
	end)

86
	Event.Parent = NLS([==[

87
	local Player = game:GetService("Players").LocalPlayer

88
	local Event = script:WaitForChild("UserInput_Event")

89
90
	local UIS = game:GetService("UserInputService")

91
	local input = function(io,a)

92
		if a then return end

93
		--Since InputObject is a client-side instance, we create and pass table instead

94
		Event:FireServer({KeyCode=io.KeyCode,UserInputType=io.UserInputType,UserInputState=io.UserInputState})

95
	end

96
	UIS.InputBegan:Connect(input)

97
	UIS.InputEnded:Connect(input)

98
99
	local Mouse = Player:GetMouse()

100
	local h,t

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

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

103
	while wait(1/30) do

104
		if h~=Mouse.Hit or t~=Mouse.Target then

105
			h,t=Mouse.Hit,Mouse.Target

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

107
		end

108
	end]==],Player.Character)

109
	Mouse,mouse,UserInputService,ContextActionService = m,m,UIS,CAS

110
end

111
wait()

112
local plr = owner

113
print('Local User is '..plr.Name)

114
local char = plr.Character

115
local hum = char.Humanoid

116
local hed = char.Head

117
local root = char.HumanoidRootPart

118
local rootj = root.RootJoint

119
local tors = char.Torso

120
local ra = char["Right Arm"]

121
local la = char["Left Arm"]

122
local rl = char["Right Leg"]

123
local ll = char["Left Leg"]

124
local neck = tors["Neck"]

125
local RootCF = CFrame.fromEulerAnglesXYZ(-1.57, 0, 3.14)

126
local RHCF = CFrame.fromEulerAnglesXYZ(0, 1.6, 0)

127
local LHCF = CFrame.fromEulerAnglesXYZ(0, -1.6, 0)

128
local maincolor = BrickColor.new("Red")

129
130
-------------------------------------------------------

131
--Start Good Stuff--

132
-------------------------------------------------------

133
cam = game.Workspace.CurrentCamera

134
CF = CFrame.new

135
angles = CFrame.Angles

136
attack = false

137
Euler = CFrame.fromEulerAnglesXYZ

138
Rad = math.rad

139
IT = Instance.new

140
BrickC = BrickColor.new

141
Cos = math.cos

142
Acos = math.acos

143
Sin = math.sin

144
Asin = math.asin

145
Abs = math.abs

146
Mrandom = math.random

147
Floor = math.floor

148
-------------------------------------------------------

149
--End Good Stuff--

150
-------------------------------------------------------

151
necko = CF(0, 1, 0, -1, -0, -0, 0, 0, 1, 0, 1, 0)

152
RSH, LSH = nil, nil 

153
RW = Instance.new("Weld") 

154
LW = Instance.new("Weld")

155
RH = tors["Right Hip"]

156
LH = tors["Left Hip"]

157
RSH = tors["Right Shoulder"] 

158
LSH = tors["Left Shoulder"] 

159
RSH.Parent = nil 

160
LSH.Parent = nil 

161
RW.Name = "RW"

162
RW.Part0 = tors 

163
RW.C0 = CF(1.5, 0.5, 0)

164
RW.C1 = CF(0, 0.5, 0) 

165
RW.Part1 = ra

166
RW.Parent = tors 

167
LW.Name = "LW"

168
LW.Part0 = tors 

169
LW.C0 = CF(-1.5, 0.5, 0)

170
LW.C1 = CF(0, 0.5, 0) 

171
LW.Part1 = la

172
LW.Parent = tors

173
Effects = {}

174
-------------------------------------------------------

175
--Start HeartBeat--

176
-------------------------------------------------------

177
ArtificialHB = Instance.new("BindableEvent", script)

178
ArtificialHB.Name = "Heartbeat"

179
script:WaitForChild("Heartbeat")

180
181
frame = 1 / 60

182
tf = 0

183
allowframeloss = false

184
tossremainder = false

185
186
187
lastframe = tick()

188
script.Heartbeat:Fire()

189
190
191
game:GetService("RunService").Heartbeat:connect(function(s, p)

192
	tf = tf + s

193
	if tf >= frame then

194
		if allowframeloss then

195
			script.Heartbeat:Fire()

196
			lastframe = tick()

197
		else

198
			for i = 1, math.floor(tf / frame) do

199
				script.Heartbeat:Fire()

200
			end

201
			lastframe = tick()

202
		end

203
		if tossremainder then

204
			tf = 0

205
		else

206
			tf = tf - frame * math.floor(tf / frame)

207
		end

208
	end

209
end)

210
-------------------------------------------------------

211
--End HeartBeat--

212
-------------------------------------------------------

213
214
-------------------------------------------------------

215
--Start Important Functions--

216
-------------------------------------------------------

217
function CreateWeldOrSnapOrMotor(TYPE, PARENT, PART0, PART1, C0, C1)

218
	local NEWWELD = IT(TYPE)

219
	NEWWELD.Part0 = PART0

220
	NEWWELD.Part1 = PART1

221
	NEWWELD.C0 = C0

222
	NEWWELD.C1 = C1

223
	NEWWELD.Parent = PARENT

224
	return NEWWELD

225
end

226
227
local S = IT("Sound")

228
function CreateSound(ID, PARENT, VOLUME, PITCH, DOESLOOP)

229
	local NEWSOUND = nil

230
	coroutine.resume(coroutine.create(function()

231
		NEWSOUND = S:Clone()

232
		NEWSOUND.Parent = PARENT

233
		NEWSOUND.Volume = VOLUME

234
		NEWSOUND.Pitch = PITCH

235
		NEWSOUND.SoundId = "http://www.roblox.com/asset/?id="..ID

236
		NEWSOUND:play()

237
		if DOESLOOP == true then

238
			NEWSOUND.Looped = true

239
		else

240
			repeat wait(1) until NEWSOUND.Playing == false

241
			NEWSOUND:remove()

242
		end

243
	end))

244
	return NEWSOUND

245
end

246
247
function swait(num)

248
	if num == 0 or num == nil then

249
		game:service("RunService").Stepped:wait(0)

250
	else

251
		for i = 0, num do

252
			game:service("RunService").Stepped:wait(0)

253
		end

254
	end

255
end

256
function thread(f)

257
	coroutine.resume(coroutine.create(f))

258
end

259
function clerp(a, b, t)

260
	local qa = {

261
		QuaternionFromCFrame(a)

262
	}

263
	local qb = {

264
		QuaternionFromCFrame(b)

265
	}

266
	local ax, ay, az = a.x, a.y, a.z

267
	local bx, by, bz = b.x, b.y, b.z

268
	local _t = 1 - t

269
	return QuaternionToCFrame(_t * ax + t * bx, _t * ay + t * by, _t * az + t * bz, QuaternionSlerp(qa, qb, t))

270
end

271
function QuaternionFromCFrame(cf)

272
	local mx, my, mz, m00, m01, m02, m10, m11, m12, m20, m21, m22 = cf:components()

273
	local trace = m00 + m11 + m22

274
	if trace > 0 then

275
		local s = math.sqrt(1 + trace)

276
		local recip = 0.5 / s

277
		return (m21 - m12) * recip, (m02 - m20) * recip, (m10 - m01) * recip, s * 0.5

278
	else

279
		local i = 0

280
		if m00 < m11 then

281
			i = 1

282
		end

283
		if m22 > (i == 0 and m00 or m11) then

284
			i = 2

285
		end

286
		if i == 0 then

287
			local s = math.sqrt(m00 - m11 - m22 + 1)

288
			local recip = 0.5 / s

289
			return 0.5 * s, (m10 + m01) * recip, (m20 + m02) * recip, (m21 - m12) * recip

290
		elseif i == 1 then

291
			local s = math.sqrt(m11 - m22 - m00 + 1)

292
			local recip = 0.5 / s

293
			return (m01 + m10) * recip, 0.5 * s, (m21 + m12) * recip, (m02 - m20) * recip

294
		elseif i == 2 then

295
			local s = math.sqrt(m22 - m00 - m11 + 1)

296
			local recip = 0.5 / s

297
			return (m02 + m20) * recip, (m12 + m21) * recip, 0.5 * s, (m10 - m01) * recip

298
		end

299
	end

300
end

301
function QuaternionToCFrame(px, py, pz, x, y, z, w)

302
	local xs, ys, zs = x + x, y + y, z + z

303
	local wx, wy, wz = w * xs, w * ys, w * zs

304
	local xx = x * xs

305
	local xy = x * ys

306
	local xz = x * zs

307
	local yy = y * ys

308
	local yz = y * zs

309
	local zz = z * zs

310
	return CFrame.new(px, py, pz, 1 - (yy + zz), xy - wz, xz + wy, xy + wz, 1 - (xx + zz), yz - wx, xz - wy, yz + wx, 1 - (xx + yy))

311
end

312
function QuaternionSlerp(a, b, t)

313
	local cosTheta = a[1] * b[1] + a[2] * b[2] + a[3] * b[3] + a[4] * b[4]

314
	local startInterp, finishInterp

315
	if cosTheta >= 1.0E-4 then

316
		if 1 - cosTheta > 1.0E-4 then

317
			local theta = math.acos(cosTheta)

318
			local invSinTheta = 1 / Sin(theta)

319
			startInterp = Sin((1 - t) * theta) * invSinTheta

320
			finishInterp = Sin(t * theta) * invSinTheta

321
		else

322
			startInterp = 1 - t

323
			finishInterp = t

324
		end

325
	elseif 1 + cosTheta > 1.0E-4 then

326
		local theta = math.acos(-cosTheta)

327
		local invSinTheta = 1 / Sin(theta)

328
		startInterp = Sin((t - 1) * theta) * invSinTheta

329
		finishInterp = Sin(t * theta) * invSinTheta

330
	else

331
		startInterp = t - 1

332
		finishInterp = t

333
	end

334
	return a[1] * startInterp + b[1] * finishInterp, a[2] * startInterp + b[2] * finishInterp, a[3] * startInterp + b[3] * finishInterp, a[4] * startInterp + b[4] * finishInterp

335
end

336
function rayCast(Position, Direction, Range, Ignore)

337
	return game:service("Workspace"):FindPartOnRay(Ray.new(Position, Direction.unit * (Range or 999.999)), Ignore)

338
end

339
local RbxUtility = LoadLibrary("RbxUtility")

340
local Create = RbxUtility.Create

341
342
-------------------------------------------------------

343
--Start Damage Function--

344
-------------------------------------------------------

345
function Damage(Part, hit, minim, maxim, knockback, Type, Property, Delay, HitSound, HitPitch)

346
	if hit.Parent == nil then

347
		return

348
	end

349
	local h = hit.Parent:FindFirstChildOfClass("Humanoid")

350
	for _, v in pairs(hit.Parent:children()) do

351
		if v:IsA("Humanoid") then

352
			h = v

353
		end

354
	end

355
         if h ~= nil and hit.Parent.Name ~= char.Name and hit.Parent:FindFirstChild("UpperTorso") ~= nil then

356
	

357
         hit.Parent:FindFirstChild("Head"):BreakJoints()

358
         end

359
360
	if h ~= nil and hit.Parent.Name ~= char.Name and hit.Parent:FindFirstChild("Torso") ~= nil then

361
		if hit.Parent:findFirstChild("DebounceHit") ~= nil then

362
			if hit.Parent.DebounceHit.Value == true then

363
				return

364
			end

365
		end

366
         if insta == true then

367
         hit.Parent:FindFirstChild("Head"):BreakJoints()

368
         end

369
		local c = Create("ObjectValue"){

370
			Name = "creator",

371
			Value = game:service("Players").LocalPlayer,

372
			Parent = h,

373
		}

374
		game:GetService("Debris"):AddItem(c, .5)

375
		if HitSound ~= nil and HitPitch ~= nil then

376
			CFuncs.Sound.Create(HitSound, hit, 1, HitPitch) 

377
		end

378
		local Damage = math.random(minim, maxim)

379
		local blocked = false

380
		local block = hit.Parent:findFirstChild("Block")

381
		if block ~= nil then

382
			if block.className == "IntValue" then

383
				if block.Value > 0 then

384
					blocked = true

385
					block.Value = block.Value - 1

386
					print(block.Value)

387
				end

388
			end

389
		end

390
		if blocked == false then

391
			h.Health = h.Health - Damage

392
			ShowDamage((Part.CFrame * CFrame.new(0, 0, (Part.Size.Z / 2)).p + Vector3.new(0, 1.5, 0)), -Damage, 1.5, tors.BrickColor.Color)

393
		else

394
			h.Health = h.Health - (Damage / 2)

395
			ShowDamage((Part.CFrame * CFrame.new(0, 0, (Part.Size.Z / 2)).p + Vector3.new(0, 1.5, 0)), -Damage, 1.5, tors.BrickColor.Color)

396
		end

397
		if Type == "Knockdown" then

398
			local hum = hit.Parent.Humanoid

399
			hum.PlatformStand = true

400
			coroutine.resume(coroutine.create(function(HHumanoid)

401
				swait(1)

402
				HHumanoid.PlatformStand = false

403
			end), hum)

404
			local angle = (hit.Position - (Property.Position + Vector3.new(0, 0, 0))).unit

405
			local bodvol = Create("BodyVelocity"){

406
				velocity = angle * knockback,

407
				P = 5000,

408
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

409
				Parent = hit,

410
			}

411
			local rl = Create("BodyAngularVelocity"){

412
				P = 3000,

413
				maxTorque = Vector3.new(500000, 500000, 500000) * 50000000000000,

414
				angularvelocity = Vector3.new(math.random(-10, 10), math.random(-10, 10), math.random(-10, 10)),

415
				Parent = hit,

416
			}

417
			game:GetService("Debris"):AddItem(bodvol, .5)

418
			game:GetService("Debris"):AddItem(rl, .5)

419
		elseif Type == "Normal" then

420
			local vp = Create("BodyVelocity"){

421
				P = 500,

422
				maxForce = Vector3.new(math.huge, 0, math.huge),

423
				velocity = Property.CFrame.lookVector * knockback + Property.Velocity / 1.05,

424
			}

425
			if knockback > 0 then

426
				vp.Parent = hit.Parent.Torso

427
			end

428
			game:GetService("Debris"):AddItem(vp, .5)

429
		elseif Type == "Up" then

430
			local bodyVelocity = Create("BodyVelocity"){

431
				velocity = Vector3.new(0, 20, 0),

432
				P = 5000,

433
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

434
				Parent = hit,

435
			}

436
			game:GetService("Debris"):AddItem(bodyVelocity, .5)

437
		elseif Type == "DarkUp" then

438
			coroutine.resume(coroutine.create(function()

439
				for i = 0, 1, 0.1 do

440
					swait()

441
					Effects.Block.Create(BrickColor.new("Black"), hit.Parent.Torso.CFrame, 5, 5, 5, 1, 1, 1, .08, 1)

442
				end

443
			end))

444
			local bodyVelocity = Create("BodyVelocity"){

445
				velocity = Vector3.new(0, 20, 0),

446
				P = 5000,

447
				maxForce = Vector3.new(8e+003, 8e+003, 8e+003),

448
				Parent = hit,

449
			}

450
			game:GetService("Debris"):AddItem(bodyVelocity, 1)

451
		elseif Type == "Snare" then

452
			local bp = Create("BodyPosition"){

453
				P = 2000,

454
				D = 100,

455
				maxForce = Vector3.new(math.huge, math.huge, math.huge),

456
				position = hit.Parent.Torso.Position,

457
				Parent = hit.Parent.Torso,

458
			}

459
			game:GetService("Debris"):AddItem(bp, 1)

460
		elseif Type == "Freeze" then

461
			local BodPos = Create("BodyPosition"){

462
				P = 50000,

463
				D = 1000,

464
				maxForce = Vector3.new(math.huge, math.huge, math.huge),

465
				position = hit.Parent.Torso.Position,

466
				Parent = hit.Parent.Torso,

467
			}

468
			local BodGy = Create("BodyGyro") {

469
				maxTorque = Vector3.new(4e+005, 4e+005, 4e+005) * math.huge ,

470
				P = 20e+003,

471
				Parent = hit.Parent.Torso,

472
				cframe = hit.Parent.Torso.CFrame,

473
			}

474
			hit.Parent.Torso.Anchored = true

475
			coroutine.resume(coroutine.create(function(Part) 

476
				swait(1.5)

477
				Part.Anchored = false

478
			end), hit.Parent.Torso)

479
			game:GetService("Debris"):AddItem(BodPos, 3)

480
			game:GetService("Debris"):AddItem(BodGy, 3)

481
		end

482
		local debounce = Create("BoolValue"){

483
			Name = "DebounceHit",

484
			Parent = hit.Parent,

485
			Value = true,

486
		}

487
		game:GetService("Debris"):AddItem(debounce, Delay)

488
		c = Create("ObjectValue"){

489
			Name = "creator",

490
			Value = Player,

491
			Parent = h,

492
		}

493
		game:GetService("Debris"):AddItem(c, .5)

494
	end

495
end

496
-------------------------------------------------------

497
--End Damage Function--

498
-------------------------------------------------------

499
500
-------------------------------------------------------

501
--Start Damage Function Customization--

502
-------------------------------------------------------

503
function ShowDamage(Pos, Text, Time, Color)

504
	local Rate = (1 / 30)

505
	local Pos = (Pos or Vector3.new(0, 0, 0))

506
	local Text = (Text or "")

507
	local Time = (Time or 2)

508
	local Color = (Color or Color3.new(1, 0, 1))

509
	local EffectPart = CFuncs.Part.Create(workspace, "SmoothPlastic", 0, 1, BrickColor.new(Color), "Effect", Vector3.new(0, 0, 0))

510
	EffectPart.Anchored = true

511
	local BillboardGui = Create("BillboardGui"){

512
		Size = UDim2.new(3, 0, 3, 0),

513
		Adornee = EffectPart,

514
		Parent = EffectPart,

515
	}

516
	local TextLabel = Create("TextLabel"){

517
		BackgroundTransparency = 1,

518
		Size = UDim2.new(1, 0, 1, 0),

519
		Text = Text,

520
		Font = "Bodoni",

521
		TextColor3 = Color,

522
		TextScaled = true,

523
		TextStrokeColor3 = Color3.fromRGB(0,0,0),

524
		Parent = BillboardGui,

525
	}

526
	game.Debris:AddItem(EffectPart, (Time))

527
	EffectPart.Parent = game:GetService("Workspace")

528
	delay(0, function()

529
		local Frames = (Time / Rate)

530
		for Frame = 1, Frames do

531
			wait(Rate)

532
			local Percent = (Frame / Frames)

533
			EffectPart.CFrame = CFrame.new(Pos) + Vector3.new(0, Percent, 0)

534
			TextLabel.TextTransparency = Percent

535
		end

536
		if EffectPart and EffectPart.Parent then

537
			EffectPart:Destroy()

538
		end

539
	end)

540
end

541
-------------------------------------------------------

542
--End Damage Function Customization--

543
-------------------------------------------------------

544
545
function MagniDamage(Part, magni, mindam, maxdam, knock, Type)

546
  for _, c in pairs(workspace:children()) do

547
    local hum = c:findFirstChild("Humanoid")

548
    if hum ~= nil then

549
      local head = c:findFirstChild("Head")

550
      if head ~= nil then

551
        local targ = head.Position - Part.Position

552
        local mag = targ.magnitude

553
        if magni >= mag and c.Name ~= plr.Name then

554
          Damage(head, head, mindam, maxdam, knock, Type, root, 0.1, "http://www.roblox.com/asset/?id=0", 1.2)

555
        end

556
      end

557
    end

558
  end

559
end

560
561
562
CFuncs = {

563
	Part = {

564
		Create = function(Parent, Material, Reflectance, Transparency, BColor, Name, Size)

565
			local Part = Create("Part")({

566
				Parent = Parent,

567
				Reflectance = Reflectance,

568
				Transparency = Transparency,

569
				CanCollide = false,

570
				Locked = true,

571
				BrickColor = BrickColor.new(tostring(BColor)),

572
				Name = Name,

573
				Size = Size,

574
				Material = Material

575
			})

576
			RemoveOutlines(Part)

577
			return Part

578
		end

579
	},

580
	Mesh = {

581
		Create = function(Mesh, Part, MeshType, MeshId, OffSet, Scale)

582
			local Msh = Create(Mesh)({

583
				Parent = Part,

584
				Offset = OffSet,

585
				Scale = Scale

586
			})

587
			if Mesh == "SpecialMesh" then

588
				Msh.MeshType = MeshType

589
				Msh.MeshId = MeshId

590
			end

591
			return Msh

592
		end

593
	},

594
	Mesh = {

595
		Create = function(Mesh, Part, MeshType, MeshId, OffSet, Scale)

596
			local Msh = Create(Mesh)({

597
				Parent = Part,

598
				Offset = OffSet,

599
				Scale = Scale

600
			})

601
			if Mesh == "SpecialMesh" then

602
				Msh.MeshType = MeshType

603
				Msh.MeshId = MeshId

604
			end

605
			return Msh

606
		end

607
	},

608
	Weld = {

609
		Create = function(Parent, Part0, Part1, C0, C1)

610
			local Weld = Create("Weld")({

611
				Parent = Parent,

612
				Part0 = Part0,

613
				Part1 = Part1,

614
				C0 = C0,

615
				C1 = C1

616
			})

617
			return Weld

618
		end

619
	},

620
	Sound = {

621
		Create = function(id, par, vol, pit)

622
			coroutine.resume(coroutine.create(function()

623
				local S = Create("Sound")({

624
					Volume = vol,

625
					Pitch = pit or 1,

626
					SoundId = id,

627
					Parent = par or workspace

628
				})

629
				wait()

630
				S:play()

631
				game:GetService("Debris"):AddItem(S, 6)

632
			end))

633
		end

634
	},

635
	ParticleEmitter = {

636
		Create = function(Parent, Color1, Color2, LightEmission, Size, Texture, Transparency, ZOffset, Accel, Drag, LockedToPart, VelocityInheritance, EmissionDirection, Enabled, LifeTime, Rate, Rotation, RotSpeed, Speed, VelocitySpread)

637
			local fp = Create("ParticleEmitter")({

638
				Parent = Parent,

639
				Color = ColorSequence.new(Color1, Color2),

640
				LightEmission = LightEmission,

641
				Size = Size,

642
				Texture = Texture,

643
				Transparency = Transparency,

644
				ZOffset = ZOffset,

645
				Acceleration = Accel,

646
				Drag = Drag,

647
				LockedToPart = LockedToPart,

648
				VelocityInheritance = VelocityInheritance,

649
				EmissionDirection = EmissionDirection,

650
				Enabled = Enabled,

651
				Lifetime = LifeTime,

652
				Rate = Rate,

653
				Rotation = Rotation,

654
				RotSpeed = RotSpeed,

655
				Speed = Speed,

656
				VelocitySpread = VelocitySpread

657
			})

658
			return fp

659
		end

660
	}

661
}

662
function RemoveOutlines(part)

663
	part.TopSurface, part.BottomSurface, part.LeftSurface, part.RightSurface, part.FrontSurface, part.BackSurface = 10, 10, 10, 10, 10, 10

664
end

665
function CreatePart(FormFactor, Parent, Material, Reflectance, Transparency, BColor, Name, Size)

666
	local Part = Create("Part")({

667
		formFactor = FormFactor,

668
		Parent = Parent,

669
		Reflectance = Reflectance,

670
		Transparency = Transparency,

671
		CanCollide = false,

672
		Locked = true,

673
		BrickColor = BrickColor.new(tostring(BColor)),

674
		Name = Name,

675
		Size = Size,

676
		Material = Material

677
	})

678
	RemoveOutlines(Part)

679
	return Part

680
end

681
function CreateMesh(Mesh, Part, MeshType, MeshId, OffSet, Scale)

682
	local Msh = Create(Mesh)({

683
		Parent = Part,

684
		Offset = OffSet,

685
		Scale = Scale

686
	})

687
	if Mesh == "SpecialMesh" then

688
		Msh.MeshType = MeshType

689
		Msh.MeshId = MeshId

690
	end

691
	return Msh

692
end

693
function CreateWeld(Parent, Part0, Part1, C0, C1)

694
	local Weld = Create("Weld")({

695
		Parent = Parent,

696
		Part0 = Part0,

697
		Part1 = Part1,

698
		C0 = C0,

699
		C1 = C1

700
	})

701
	return Weld

702
end

703
704
705
-------------------------------------------------------

706
--Start Effect Function--

707
-------------------------------------------------------

708
EffectModel = Instance.new("Model", char)

709
Effects = {

710
  Block = {

711
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay, Type)

712
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

713
      prt.Anchored = true

714
      prt.CFrame = cframe

715
      local msh = CFuncs.Mesh.Create("BlockMesh", prt, "", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

716
      game:GetService("Debris"):AddItem(prt, 10)

717
      if Type == 1 or Type == nil then

718
        table.insert(Effects, {

719
          prt,

720
          "Block1",

721
          delay,

722
          x3,

723
          y3,

724
          z3,

725
          msh

726
        })

727
      elseif Type == 2 then

728
        table.insert(Effects, {

729
          prt,

730
          "Block2",

731
          delay,

732
          x3,

733
          y3,

734
          z3,

735
          msh

736
        })

737
      else

738
        table.insert(Effects, {

739
          prt,

740
          "Block3",

741
          delay,

742
          x3,

743
          y3,

744
          z3,

745
          msh

746
        })

747
      end

748
    end

749
  },

750
  Sphere = {

751
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

752
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new())

753
      prt.Anchored = true

754
      prt.CFrame = cframe

755
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "Sphere", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

756
      game:GetService("Debris"):AddItem(prt, 10)

757
      table.insert(Effects, {

758
        prt,

759
        "Cylinder",

760
        delay,

761
        x3,

762
        y3,

763
        z3,

764
        msh

765
      })

766
    end

767
  },

768
  Cylinder = {

769
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

770
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

771
      prt.Anchored = true

772
      prt.CFrame = cframe

773
      local msh = CFuncs.Mesh.Create("CylinderMesh", prt, "", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

774
      game:GetService("Debris"):AddItem(prt, 10)

775
      table.insert(Effects, {

776
        prt,

777
        "Cylinder",

778
        delay,

779
        x3,

780
        y3,

781
        z3,

782
        msh

783
      })

784
    end

785
  },

786
  Wave = {

787
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

788
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new())

789
      prt.Anchored = true

790
      prt.CFrame = cframe

791
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://20329976", Vector3.new(0, 0, 0), Vector3.new(x1 / 60, y1 / 60, z1 / 60))

792
      game:GetService("Debris"):AddItem(prt, 10)

793
      table.insert(Effects, {

794
        prt,

795
        "Cylinder",

796
        delay,

797
        x3 / 60,

798
        y3 / 60,

799
        z3 / 60,

800
        msh

801
      })

802
    end

803
  },

804
  Ring = {

805
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

806
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

807
      prt.Anchored = true

808
      prt.CFrame = cframe

809
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://3270017", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

810
      game:GetService("Debris"):AddItem(prt, 10)

811
      table.insert(Effects, {

812
        prt,

813
        "Cylinder",

814
        delay,

815
        x3,

816
        y3,

817
        z3,

818
        msh

819
      })

820
    end

821
  },

822
  Break = {

823
    Create = function(brickcolor, cframe, x1, y1, z1)

824
      local prt = CFuncs.Part.Create(EffectModel, "Neon", 0, 0, brickcolor, "Effect", Vector3.new(0.5, 0.5, 0.5))

825
      prt.Anchored = true

826
      prt.CFrame = cframe * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50))

827
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "Sphere", "", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

828
      local num = math.random(10, 50) / 1000

829
      game:GetService("Debris"):AddItem(prt, 10)

830
      table.insert(Effects, {

831
        prt,

832
        "Shatter",

833
        num,

834
        prt.CFrame,

835
        math.random() - math.random(),

836
        0,

837
        math.random(50, 100) / 100

838
      })

839
    end

840
  },

841
Spiral = {

842
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

843
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

844
      prt.Anchored = true

845
      prt.CFrame = cframe

846
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://1051557", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

847
      game:GetService("Debris"):AddItem(prt, 10)

848
      table.insert(Effects, {

849
        prt,

850
        "Cylinder",

851
        delay,

852
        x3,

853
        y3,

854
        z3,

855
        msh

856
      })

857
    end

858
  },

859
Push = {

860
    Create = function(brickcolor, cframe, x1, y1, z1, x3, y3, z3, delay)

861
      local prt = CFuncs.Part.Create(EffectModel, "SmoothPlastic", 0, 0, brickcolor, "Effect", Vector3.new())

862
      prt.Anchored = true

863
      prt.CFrame = cframe

864
      local msh = CFuncs.Mesh.Create("SpecialMesh", prt, "FileMesh", "rbxassetid://437347603", Vector3.new(0, 0, 0), Vector3.new(x1, y1, z1))

865
      game:GetService("Debris"):AddItem(prt, 10)

866
      table.insert(Effects, {

867
        prt,

868
        "Cylinder",

869
        delay,

870
        x3,

871
        y3,

872
        z3,

873
        msh

874
      })

875
    end

876
  }

877
}

878
function part(formfactor ,parent, reflectance, transparency, brickcolor, name, size)

879
	local fp = IT("Part")

880
	fp.formFactor = formfactor 

881
	fp.Parent = parent

882
	fp.Reflectance = reflectance

883
	fp.Transparency = transparency

884
	fp.CanCollide = false 

885
	fp.Locked = true

886
	fp.BrickColor = brickcolor

887
	fp.Name = name

888
	fp.Size = size

889
	fp.Position = tors.Position 

890
	RemoveOutlines(fp)

891
	fp.Material = "SmoothPlastic"

892
	fp:BreakJoints()

893
	return fp 

894
end 

895
 

896
function mesh(Mesh,part,meshtype,meshid,offset,scale)

897
	local mesh = IT(Mesh) 

898
	mesh.Parent = part

899
	if Mesh == "SpecialMesh" then

900
		mesh.MeshType = meshtype

901
	if meshid ~= "nil" then

902
		mesh.MeshId = "http://www.roblox.com/asset/?id="..meshid

903
		end

904
	end

905
	mesh.Offset = offset

906
	mesh.Scale = scale

907
	return mesh

908
end

909
910
function Magic(bonuspeed, type, pos, scale, value, color, MType)

911
	local type = type

912
	local rng = Instance.new("Part", char)

913
	rng.Anchored = true

914
	rng.BrickColor = color

915
	rng.CanCollide = false

916
	rng.FormFactor = 3

917
	rng.Name = "Ring"

918
	rng.Material = "Neon"

919
	rng.Size = Vector3.new(1, 1, 1)

920
	rng.Transparency = 0

921
	rng.TopSurface = 0

922
	rng.BottomSurface = 0

923
	rng.CFrame = pos

924
	local rngm = Instance.new("SpecialMesh", rng)

925
	rngm.MeshType = MType

926
	rngm.Scale = scale

927
	local scaler2 = 1

928
	if type == "Add" then

929
		scaler2 = 1 * value

930
	elseif type == "Divide" then

931
		scaler2 = 1 / value

932
	end

933
	coroutine.resume(coroutine.create(function()

934
		for i = 0, 10 / bonuspeed, 0.1 do

935
			swait()

936
			if type == "Add" then

937
				scaler2 = scaler2 - 0.01 * value / bonuspeed

938
			elseif type == "Divide" then

939
				scaler2 = scaler2 - 0.01 / value * bonuspeed

940
			end

941
			rng.Transparency = rng.Transparency + 0.01 * bonuspeed

942
			rngm.Scale = rngm.Scale + Vector3.new(scaler2 * bonuspeed, scaler2 * bonuspeed, scaler2 * bonuspeed)

943
		end

944
		rng:Destroy()

945
	end))

946
end

947
948
function Eviscerate(dude)

949
	if dude.Name ~= char then

950
		local bgf = IT("BodyGyro", dude.Head)

951
		bgf.CFrame = bgf.CFrame * CFrame.fromEulerAnglesXYZ(Rad(-90), 0, 0)

952
		local val = IT("BoolValue", dude)

953
		val.Name = "IsHit"

954
		local ds = coroutine.wrap(function()

955
			dude:WaitForChild("Head"):BreakJoints()

956
			wait(0.5)

957
			target = nil

958
			coroutine.resume(coroutine.create(function()

959
				for i, v in pairs(dude:GetChildren()) do

960
					if v:IsA("Accessory") then

961
						v:Destroy()

962
					end

963
					if v:IsA("Humanoid") then

964
						v:Destroy()

965
					end

966
					if v:IsA("CharacterMesh") then

967
						v:Destroy()

968
					end

969
					if v:IsA("Model") then

970
						v:Destroy()

971
					end

972
					if v:IsA("Part") or v:IsA("MeshPart") then

973
						for x, o in pairs(v:GetChildren()) do

974
							if o:IsA("Decal") then

975
								o:Destroy()

976
							end

977
						end

978
						coroutine.resume(coroutine.create(function()

979
							v.Material = "Neon"

980
							v.CanCollide = false

981
							local PartEmmit1 = IT("ParticleEmitter", v)

982
							PartEmmit1.LightEmission = 1

983
							PartEmmit1.Texture = "rbxassetid://284205403"

984
							PartEmmit1.Color = ColorSequence.new(maincolor.Color)

985
							PartEmmit1.Rate = 150

986
							PartEmmit1.Lifetime = NumberRange.new(1)

987
							PartEmmit1.Size = NumberSequence.new({

988
								NumberSequenceKeypoint.new(0, 0.75, 0),

989
								NumberSequenceKeypoint.new(1, 0, 0)

990
							})

991
							PartEmmit1.Transparency = NumberSequence.new({

992
								NumberSequenceKeypoint.new(0, 0, 0),

993
								NumberSequenceKeypoint.new(1, 1, 0)

994
							})

995
							PartEmmit1.Speed = NumberRange.new(0, 0)

996
							PartEmmit1.VelocitySpread = 30000

997
							PartEmmit1.Rotation = NumberRange.new(-500, 500)

998
							PartEmmit1.RotSpeed = NumberRange.new(-500, 500)

999
							local BodPoss = IT("BodyPosition", v)

1000
							BodPoss.P = 3000

1001
							BodPoss.D = 1000

1002
							BodPoss.maxForce = Vector3.new(50000000000, 50000000000, 50000000000)

1003
							BodPoss.position = v.Position + Vector3.new(Mrandom(-15, 15), Mrandom(-15, 15), Mrandom(-15, 15))

1004
							v.Color = maincolor.Color

1005
							coroutine.resume(coroutine.create(function()

1006
								for i = 0, 49 do

1007
									swait(1)

1008
									v.Transparency = v.Transparency + 0.08

1009
								end

1010
								wait(0.5)

1011
								PartEmmit1.Enabled = false

1012
								wait(3)

1013
								v:Destroy()

1014
								dude:Destroy()

1015
							end))

1016
						end))

1017
					end

1018
				end

1019
			end))

1020
		end)

1021
		ds()

1022
	end

1023
end

1024
1025
function FindNearestHead(Position, Distance, SinglePlayer)

1026
	if SinglePlayer then

1027
		return Distance > (SinglePlayer.Torso.CFrame.p - Position).magnitude

1028
	end

1029
	local List = {}

1030
	for i, v in pairs(workspace:GetChildren()) do

1031
		if v:IsA("Model") and v:findFirstChild("Head") and v ~= char and Distance >= (v.Head.Position - Position).magnitude then

1032
			table.insert(List, v)

1033
		end

1034
	end

1035
	return List

1036
end

1037
1038
function Aura(bonuspeed, FastSpeed, type, pos, x1, y1, z1, value, color, outerpos, MType)

1039
	local type = type

1040
	local rng = Instance.new("Part", char)

1041
	rng.Anchored = true

1042
	rng.BrickColor = color

1043
	rng.CanCollide = false

1044
	rng.FormFactor = 3

1045
	rng.Name = "Ring"

1046
	rng.Material = "Neon"

1047
	rng.Size = Vector3.new(1, 1, 1)

1048
	rng.Transparency = 0

1049
	rng.TopSurface = 0

1050
	rng.BottomSurface = 0

1051
	rng.CFrame = pos

1052
	rng.CFrame = rng.CFrame + rng.CFrame.lookVector * outerpos

1053
	local rngm = Instance.new("SpecialMesh", rng)

1054
	rngm.MeshType = MType

1055
	rngm.Scale = Vector3.new(x1, y1, z1)

1056
	local scaler2 = 1

1057
	local speeder = FastSpeed

1058
	if type == "Add" then

1059
		scaler2 = 1 * value

1060
	elseif type == "Divide" then

1061
		scaler2 = 1 / value

1062
	end

1063
	coroutine.resume(coroutine.create(function()

1064
		for i = 0, 10 / bonuspeed, 0.1 do

1065
			swait()

1066
			if type == "Add" then

1067
				scaler2 = scaler2 - 0.01 * value / bonuspeed

1068
			elseif type == "Divide" then

1069
				scaler2 = scaler2 - 0.01 / value * bonuspeed

1070
			end

1071
			speeder = speeder - 0.01 * FastSpeed * bonuspeed

1072
			rng.CFrame = rng.CFrame + rng.CFrame.lookVector * speeder * bonuspeed

1073
			rng.Transparency = rng.Transparency + 0.01 * bonuspeed

1074
			rngm.Scale = rngm.Scale + Vector3.new(scaler2 * bonuspeed, scaler2 * bonuspeed, 0)

1075
		end

1076
		rng:Destroy()

1077
	end))

1078
end

1079
1080
function SoulSteal(dude)

1081
if dude.Name ~= char then

1082
local bgf = IT("BodyGyro", dude.Head)

1083
bgf.CFrame = bgf.CFrame * CFrame.fromEulerAnglesXYZ(Rad(-90), 0, 0)

1084
local val = IT("BoolValue", dude)

1085
val.Name = "IsHit"

1086
local torso = (dude:FindFirstChild'Head' or dude:FindFirstChild'Torso' or dude:FindFirstChild'UpperTorso' or dude:FindFirstChild'LowerTorso' or dude:FindFirstChild'HumanoidRootPart')

1087
local soulst = coroutine.wrap(function()

1088
local soul = Instance.new("Part",dude)

1089
soul.Size = Vector3.new(1,1,1)

1090
soul.CanCollide = false

1091
soul.Anchored = false

1092
soul.Position = torso.Position

1093
soul.Transparency = 1

1094
local PartEmmit1 = IT("ParticleEmitter", soul)

1095
PartEmmit1.LightEmission = 1

1096
PartEmmit1.Texture = "rbxassetid://569507414"

1097
PartEmmit1.Color = ColorSequence.new(maincolor.Color)

1098
PartEmmit1.Rate = 250

1099
PartEmmit1.Lifetime = NumberRange.new(1.6)

1100
PartEmmit1.Size = NumberSequence.new({

1101
	NumberSequenceKeypoint.new(0, 1, 0),

1102
	NumberSequenceKeypoint.new(1, 0, 0)

1103
})

1104
PartEmmit1.Transparency = NumberSequence.new({

1105
	NumberSequenceKeypoint.new(0, 0, 0),

1106
	NumberSequenceKeypoint.new(1, 1, 0)

1107
})

1108
PartEmmit1.Speed = NumberRange.new(0, 0)

1109
PartEmmit1.VelocitySpread = 30000

1110
PartEmmit1.Rotation = NumberRange.new(-360, 360)

1111
PartEmmit1.RotSpeed = NumberRange.new(-360, 360)

1112
local BodPoss = IT("BodyPosition", soul)

1113
BodPoss.P = 3000

1114
BodPoss.D = 1000

1115
BodPoss.maxForce = Vector3.new(50000000000, 50000000000, 50000000000)

1116
BodPoss.position = torso.Position + Vector3.new(Mrandom(-15, 15), Mrandom(-15, 15), Mrandom(-15, 15))

1117
wait(1.6)

1118
soul.Touched:connect(function(hit)

1119
	if hit.Parent == char then

1120
	soul:Destroy()

1121
	end

1122
end)

1123
wait(1.2)

1124
while soul do

1125
	swait()

1126
	PartEmmit1.Color = ColorSequence.new(maincolor.Color)

1127
	BodPoss.Position = tors.Position

1128
end

1129
end)

1130
	soulst()

1131
	end

1132
end

1133
function FaceMouse()

1134
local	Cam = workspace.CurrentCamera

1135
	return {

1136
		CFrame.new(char.Torso.Position, Vector3.new(mouse.Hit.p.x, char.Torso.Position.y, mouse.Hit.p.z)),

1137
		Vector3.new(mouse.Hit.p.x, mouse.Hit.p.y, mouse.Hit.p.z)

1138
	}

1139
end

1140
-------------------------------------------------------

1141
--End Effect Function--

1142
-------------------------------------------------------

1143
function Cso(ID, PARENT, VOLUME, PITCH)

1144
	local NSound = nil

1145
	coroutine.resume(coroutine.create(function()

1146
		NSound = IT("Sound", PARENT)

1147
		NSound.Volume = VOLUME

1148
		NSound.Pitch = PITCH

1149
		NSound.SoundId = "http://www.roblox.com/asset/?id="..ID

1150
		swait()

1151
		NSound:play()

1152
		game:GetService("Debris"):AddItem(NSound, 10)

1153
	end))

1154
	return NSound

1155
end

1156
function CameraEnshaking(Length, Intensity)

1157
	coroutine.resume(coroutine.create(function()

1158
		local intensity = 1 * Intensity

1159
		local rotM = 0.01 * Intensity

1160
		for i = 0, Length, 0.1 do

1161
			swait()

1162
			intensity = intensity - 0.05 * Intensity / Length

1163
			rotM = rotM - 5.0E-4 * Intensity / Length

1164
			hum.CameraOffset = Vector3.new(Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)))

1165
			cam.CFrame = cam.CFrame * CF(Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity)), Rad(Mrandom(-intensity, intensity))) * Euler(Rad(Mrandom(-intensity, intensity)) * rotM, Rad(Mrandom(-intensity, intensity)) * rotM, Rad(Mrandom(-intensity, intensity)) * rotM)

1166
		end

1167
		hum.CameraOffset = Vector3.new(0, 0, 0)

1168
	end))

1169
end

1170
-------------------------------------------------------

1171
--End Important Functions--

1172
-------------------------------------------------------

1173
1174
1175
-------------------------------------------------------

1176
--Start Customization--

1177
-------------------------------------------------------

1178
local Player_Size = 1

1179
if Player_Size ~= 1 then

1180
root.Size = root.Size * Player_Size

1181
tors.Size = tors.Size * Player_Size

1182
hed.Size = hed.Size * Player_Size

1183
ra.Size = ra.Size * Player_Size

1184
la.Size = la.Size * Player_Size

1185
rl.Size = rl.Size * Player_Size

1186
ll.Size = ll.Size * Player_Size

1187
----------------------------------------------------------------------------------

1188
rootj.Parent = root

1189
neck.Parent = tors

1190
RW.Parent = tors

1191
LW.Parent = tors

1192
RH.Parent = tors

1193
LH.Parent = tors

1194
----------------------------------------------------------------------------------

1195
rootj.C0 = RootCF * CF(0 * Player_Size, 0 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0))

1196
rootj.C1 = RootCF * CF(0 * Player_Size, 0 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0))

1197
neck.C0 = necko * CF(0 * Player_Size, 0 * Player_Size, 0 + ((1 * Player_Size) - 1)) * angles(Rad(0), Rad(0), Rad(0))

1198
neck.C1 = CF(0 * Player_Size, -0.5 * Player_Size, 0 * Player_Size) * angles(Rad(-90), Rad(0), Rad(180))

1199
RW.C0 = CF(1.5 * Player_Size, 0.5 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0)) --* RIGHTSHOULDERC0

1200
LW.C0 = CF(-1.5 * Player_Size, 0.5 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(0), Rad(0)) --* LEFTSHOULDERC0

1201
----------------------------------------------------------------------------------

1202
RH.C0 = CF(1 * Player_Size, -1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1203
LH.C0 = CF(-1 * Player_Size, -1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(-90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1204
RH.C1 = CF(0.5 * Player_Size, 1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1205
LH.C1 = CF(-0.5 * Player_Size, 1 * Player_Size, 0 * Player_Size) * angles(Rad(0), Rad(-90), Rad(0)) * angles(Rad(0), Rad(0), Rad(0))

1206
--hat.Parent = Character

1207
end

1208
----------------------------------------------------------------------------------

1209
local SONG = 415319305

1210
local SONG2 = 1130685064

1211
local Music = Instance.new("Sound",tors)

1212
Music.Volume = 2.5

1213
Music.Looped = true

1214
Music.Pitch = 1 --Pitcher

1215
----------------------------------------------------------------------------------

1216
local equipped = false

1217
local idle = 0

1218
local change = 1

1219
local val = 0

1220
local toim = 0

1221
local idleanim = 0.4

1222
local sine = 0

1223
local Sit = 1

1224
----------------------------------------------------------------------------------

1225
hum.WalkSpeed = 100

1226
hum.JumpPower = 100

1227
hum.Animator.Parent = nil

1228
----------------------------------------------------------------------------------

1229
local naeeym2 = IT("BillboardGui",char)

1230
naeeym2.AlwaysOnTop = true

1231
naeeym2.Size = UDim2.new(5,35,2,15)

1232
naeeym2.StudsOffset = Vector3.new(0,2,0)

1233
naeeym2.MaxDistance = 75

1234
naeeym2.Adornee = hed

1235
naeeym2.Name = "Name"

1236
--naeeym2.PlayerToHideFrom = Player

1237
local tecks2 = IT("TextLabel",naeeym2)

1238
tecks2.BackgroundTransparency = 10

1239
tecks2.TextScaled = true

1240
tecks2.BorderSizePixel = 0

1241
tecks2.Text = "Hell security"

1242
tecks2.Font = "Fantasy"

1243
tecks2.TextSize = 100

1244
tecks2.TextStrokeTransparency = 0

1245
tecks2.TextColor3 = Color3.new(1,1,1)

1246
tecks2.TextStrokeColor3 = Color3.fromRGB(123, 157, 205)

1247
tecks2.Size = UDim2.new(1,0,0.5,0)

1248
tecks2.Parent = naeeym2

1249
local top = Instance.new("Shirt")

1250
top.ShirtTemplate = "rbxassetid://296509446"

1251
top.Parent = char

1252
top.Name = "Cloth"

1253
local bottom = Instance.new("Pants")

1254
bottom.PantsTemplate = "rbxassetid://2055836641"

1255
bottom.Parent = char

1256
bottom.Name = "Cloth"

1257
----------------------------------------------------------------------------------

1258
IT = Instance.new

1259
CF = CFrame.new

1260
VT = Vector3.new

1261
RAD = math.rad

1262
C3 = Color3.new

1263
UD2 = UDim2.new

1264
BRICKC = BrickColor.new

1265
ANGLES = CFrame.Angles

1266
EULER = CFrame.fromEulerAnglesXYZ

1267
COS = math.cos

1268
ACOS = math.acos

1269
SIN = math.sin

1270
ASIN = math.asin

1271
ABS = math.abs

1272
MRANDOM = math.random

1273
FLOOR = math.floor

1274
1275
local LASTPART = Head

1276
for i = 1, 24 do

1277
	local MATH = (1-(i/30))

1278
	if LASTPART == Head then

1279
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1280
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0.8, 0.3, -0.4) * ANGLES(RAD(-25), RAD(220), RAD(90)), CF(0, 0, 0))

1281
		LASTPART = Horn

1282
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1283
	else

1284
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1285
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(5), RAD(3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1286
		LASTPART = Horn

1287
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1288
	end

1289
end

1290
local LASTPART = Head

1291
for i = 1, 24 do

1292
	local MATH = (1-(i/30))

1293
	if LASTPART == Head then

1294
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1295
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(-0.8, 0.3, -0.4) * ANGLES(RAD(-25), RAD(-220), RAD(-90)), CF(0, 0, 0))

1296
		LASTPART = Horn

1297
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1298
	else

1299
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1300
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(5), RAD(-3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1301
		LASTPART = Horn

1302
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1303
	end

1304
end

1305
local LASTPART = Head

1306
for i = 1, 8 do

1307
	local MATH = (1-(i/14))

1308
	if LASTPART == Head then

1309
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1310
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0.65, -0.3, -0.4) * ANGLES(RAD(-25), RAD(250), RAD(90)), CF(0, 0, 0))

1311
		LASTPART = Horn

1312
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1313
	else

1314
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1315
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(10), RAD(3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1316
		LASTPART = Horn

1317
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1318
	end

1319
end

1320
local LASTPART = Head

1321
for i = 1, 8 do

1322
	local MATH = (1-(i/14))

1323
	if LASTPART == Head then

1324
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1325
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(-0.65, -0.3, -0.4) * ANGLES(RAD(-25), RAD(-250), RAD(-90)), CF(0, 0, 0))

1326
		LASTPART = Horn

1327
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1328
	else

1329
		local Horn = CreatePart(3, Character, "SmoothPlastic", 0, 0, "Dirt brown", "Detail", VT(0.25*MATH,0.15,0.25*MATH),false)

1330
		CreateWeldOrSnapOrMotor("Weld", LASTPART, LASTPART, Horn, CF(0, Horn.Size.Y/2, 0) * ANGLES(RAD(10), RAD(-3), RAD(0)), CF(0, -Horn.Size.Y/2, 0))

1331
		LASTPART = Horn

1332
		Horn.Color = C3(1-((i*4-4)/255),1-((i*6-6)/255),1-((i*3-3)/255))

1333
	end

1334
end

1335
-------------------------------------------------------

1336
--End Customization--

1337
-------------------------------------------------------

1338
1339
1340
-------------------------------------------------------

1341
--Start Attacks N Stuff--

1342
-------------------------------------------------------

1343
function Taunt1()

1344
	attack = true

1345
	hum.WalkSpeed = 0

1346
	for i = 0, 9, 0.1 do

1347
		swait()

1348
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(15), Rad(0), Rad(0)), 0.15)

1349
		tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1350
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(0), Rad(78), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(15)), 0.15)

1351
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-78), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-15)), 0.15)

1352
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-9), Rad(0), Rad(155 + 25 * Sin(sine / 2.5))), 0.12)

1353
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1354
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1355
	end

1356
	attack = false

1357
	hum.WalkSpeed = 100

1358
end

1359
function Taunt2()

1360
	attack = true

1361
	hum.WalkSpeed = 0

1362
	--Cso("221057812", hed, 10, 1.1)

1363
	for i = 0, 2, 0.1 do

1364
		swait()

1365
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.5 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1366
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1367
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1368
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1369
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1370
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1371
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1372
	end

1373
	for i = 0, 6, 0.1 do

1374
		swait()

1375
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, .2 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1376
		neck.C0 = clerp(neck.C0, necko * CF(0, 0, 2) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.15)

1377
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1.2 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1378
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -1.2 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1379
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1380
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1381
		HW.C0 = clerp(HW.C0, CF(0, 4 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0 - 255.45 * i), Rad(0), Rad(0)), 0.15)

1382
	end

1383
	for i = 0, 2, 0.1 do

1384
		swait()

1385
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.5 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1386
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1387
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1388
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.6 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1389
		RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1390
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1391
		HW.C0 = clerp(HW.C0, CF(0, 1.8, 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1392
	end

1393
	attack = false

1394
	hum.WalkSpeed = 100

1395
end

1396
function Astigmatism()

1397
	attack = true

1398
	hum.WalkSpeed = 0

1399
	local Ring1 = Instance.new("Part", char)

1400
	Ring1.Anchored = true

1401
	Ring1.BrickColor = maincolor

1402
	Ring1.CanCollide = false

1403
	Ring1.FormFactor = 3

1404
	Ring1.Name = "Ring"

1405
	Ring1.Material = "Neon"

1406
	Ring1.Size = Vector3.new(1, 0.05, 1)

1407
	Ring1.Transparency = 1

1408
	Ring1.TopSurface = 0

1409
	Ring1.BottomSurface = 0

1410
	local Ring1Mesh = Instance.new("SpecialMesh", Ring1)

1411
	Ring1Mesh.MeshType = "Brick"

1412
	Ring1Mesh.Name = "SizeMesh"

1413
	Ring1Mesh.Scale = Vector3.new(0, 1, 0)

1414
	local InnerRing1 = Ring1:Clone()

1415
	InnerRing1.Parent = char

1416
	InnerRing1.Transparency = 0

1417
	InnerRing1.BrickColor = BrickColor.new("New Yeller")

1418
	InnerRing1.Size = Vector3.new(1, 1, 1)

1419
	local InnerRing1Mesh = InnerRing1.SizeMesh

1420
	InnerRing1Mesh.Scale = Vector3.new(0, 0, 0)

1421
	InnerRing1Mesh.MeshType = "Sphere"

1422
	Ring1:Destroy()

1423
	for i = 0, 6, 0.1 do

1424
		swait()

1425
		--orb.CFrame = Pupil.CFrame

1426
		Aura(7, 0.12, "Add", Pupil.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 0.5, 0.5, 5, -0.005, maincolor, 0, "Sphere")

1427
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1428
		neck.C0 = clerp(neck.C0, necko * CF(0, 0, 1) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1429
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1430
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1431
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(165 + 2.5 * Sin(sine / 20))), 0.12)

1432
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-165 + 2.5 * Sin(sine / 20))), 0.12)

1433
		HW.C0 = clerp(HW.C0, CF(0, 3 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1434
	end

1435
	InnerRing1.Transparency = 1

1436
	InnerRing1.CFrame = Pupil.CFrame + root.CFrame.lookVector * 5

1437
	Cso("294188875", char, 2.3, 1)

1438
	local a = IT("Part", char)

1439
	a.Name = "Direction"

1440
	a.Anchored = true

1441
	a.BrickColor = BrickC("Pastel violet")

1442
	a.Material = "SmoothPlastic"

1443
	a.Transparency = 0

1444
	a.Shape = "Cylinder"

1445
	a.CanCollide = false

1446
	local a2 = IT("Part", char)

1447
	a2.Name = "Direction"

1448
	a2.Anchored = true

1449
	a2.BrickColor = maincolor

1450
	a2.Color = maincolor.Color

1451
	a2.Material = "Neon"

1452
	a2.Transparency = 0.7

1453
	a2.Shape = "Cylinder"

1454
	a2.CanCollide = false

1455
	local ba = IT("Part", char)

1456
	ba.Name = "HitDirect"

1457
	ba.Anchored = true

1458
	ba.BrickColor = maincolor

1459
	ba.Material = "Neon"

1460
	ba.Transparency = 1

1461
	ba.CanCollide = false

1462
	local ray = Ray.new(InnerRing1.CFrame.p, (mouse.Hit.p - InnerRing1.CFrame.p).unit * 1000)

1463
	local ignore = char

1464
	local hit, position, normal = workspace:FindPartOnRay(ray, ignore)

1465
	a.BottomSurface = 10

1466
	a.TopSurface = 10

1467
	a2.BottomSurface = 10

1468
	a2.TopSurface = 10

1469
	local distance = (InnerRing1.CFrame.p - position).magnitude

1470
	a.Size = Vector3.new(distance, 1, 1)

1471
	a.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

1472
	a2.Size = Vector3.new(distance, 1, 1)

1473
	a2.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

1474
	ba.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance)

1475
	a.CFrame = a.CFrame * angles(0, Rad(90), 0)

1476
	a2.CFrame = a2.CFrame * angles(0, Rad(90), 0)

1477
	game:GetService("Debris"):AddItem(a, 20)

1478
	game:GetService("Debris"):AddItem(a2, 20)

1479
	game:GetService("Debris"):AddItem(ba, 20)

1480
	local msh = Instance.new("SpecialMesh", a)

1481
	msh.MeshType = "Brick"

1482
	msh.Scale = Vector3.new(1, 5, 5)

1483
	local msh2 = Instance.new("SpecialMesh", a2)

1484
	msh2.MeshType = "Brick"

1485
	msh2.Scale = Vector3.new(1, 7, 7)

1486
	for i = 0, 10, 0.1 do

1487
		swait()

1488
		CameraEnshaking(1, 5)

1489
		a2.Color = maincolor.Color

1490
		root.CFrame = FaceMouse()[1]

1491
		InnerRing1.CFrame = Pupil.CFrame + root.CFrame.lookVector * 4

1492
		ray = Ray.new(InnerRing1.CFrame.p, (mouse.Hit.p - InnerRing1.CFrame.p).unit * 1000)

1493
		hit, position, normal = workspace:FindPartOnRay(ray, ignore)

1494
		distance = (InnerRing1.CFrame.p - position).magnitude

1495
		a.Size = Vector3.new(distance, 1, 1)

1496
		a.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

1497
		a2.Size = Vector3.new(distance, 1, 1)

1498
		a2.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance / 2)

1499
		ba.CFrame = CF(InnerRing1.CFrame.p, position) * CF(0, 0, -distance)

1500
		a.CFrame = a.CFrame * angles(0, Rad(90), 0)

1501
		a2.CFrame = a2.CFrame * angles(0, Rad(90), 0)

1502
		msh.Scale = msh.Scale - Vector3.new(0, 0.05, 0.05)

1503
		msh2.Scale = msh2.Scale - Vector3.new(0, 0.03, 0.03)

1504
		Aura(5, 0.15, "Add", ba.CFrame * angles(Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360)), Rad(Mrandom(-360, 360))), 15, 15, 25, -0.15, maincolor, 0, "Sphere")

1505
		for i, v in pairs(FindNearestHead(ba.CFrame.p, 14.5)) do

1506
		if v:FindFirstChild("Head") then

1507
				Eviscerate(v)

1508
			end

1509
		end

1510
	end

1511
	a:Destroy()

1512
	a2:Destroy()

1513
	ba:Destroy()

1514
	InnerRing1:Destroy()

1515
	attack = false

1516
	hum.WalkSpeed = 100

1517
	hum.CameraOffset = Vector3.new(0,0,0)

1518
end

1519
function EyeThrow()

1520
	attack = true

1521
	hum.WalkSpeed = 1.01

1522
	for i = 0, 6, 0.1 do

1523
		swait()

1524
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1525
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1526
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1527
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1528
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.7 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(215 + 2.5 * Sin(sine / 20))), 0.12)

1529
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1530
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1531
	end

1532
    local Head01 = Eye:Clone()

1533
    Head01.Parent = char

1534
	Eye.Transparency = 1

1535
    local weldHead01 = IT("Weld")

1536
    weldHead01.Parent = Head01

1537
	weldHead01.Part0 = ra

1538
    weldHead01.Part1 = Head01

1539
	weldHead01.C1 = CF(0, 0, 1.2) * angles(Rad(90), Rad(0), Rad(0))

1540
	for i = 0, 6, 0.1 do

1541
		swait()

1542
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(-20)), 0.2)

1543
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(20)), 0.3)

1544
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1545
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1546
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(145 + 2.5 * Sin(sine / 20))), 0.2)

1547
		LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(25), Rad(0), Rad(-15)), 0.2)

1548
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(20), Rad(0)), 0.1)

1549
	end

1550
	local A = IT("Attachment",Head01)

1551
	A.Position = Vector3.new(-0, 0.2, 0.136)

1552
	local B = IT("Attachment",Head01)

1553
	B.Position = Vector3.new(-0, -0.95, -0.982)

1554
	local Trail = IT("Trail",Head01)

1555
	Trail.Attachment0 = B

1556
	Trail.Attachment1 = A

1557
	Trail.Lifetime = 0.6

1558
	Trail.Transparency = NumberSequence.new(0.5, 1)

1559
	Trail.Texture = "http://www.roblox.com/asset/?id=1472703539"

1560
	Trail.Enabled = true

1561
	weldHead01:Destroy()

1562
        Head01.CanCollide = true

1563
        local bodyVelocity2 = Create("BodyVelocity")({

1564
          velocity = (mouse.Hit.p - Head01.CFrame.p).unit * 165,

1565
          P = 5000,

1566
          maxForce = Vector3.new(8000, 8000, 8000),

1567
          Parent = Head01

1568
        })

1569
       game:GetService("Debris"):AddItem(bodyVelocity2, 0.05)

1570
		Head01.Touched:connect(function(hit)

1571
			if(not char:IsAncestorOf(hit))then

1572
				local hum = (hit and hit.Parent and hit.Parent:FindFirstChildOfClass'Humanoid')

1573
				local hedder = (hit and hit.Parent and hit.Parent:FindFirstChild'Head')

1574
				if(hum and hedder and hum.Health > 0)then

1575
				Eviscerate(hit.Parent)

1576
			Cso("491296320", hit.Parent.Torso, 10, 1)

1577
			end

1578
		end

1579
	end)

1580
	for i = 0, 2, 0.1 do

1581
		swait()

1582
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(40)), 0.2)

1583
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(-40)), 0.3)

1584
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1585
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1586
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-134), Rad(0), Rad(145 + 2.5 * Sin(sine / 20))), 0.2)

1587
		LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(-15)), 0.1)

1588
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(-40), Rad(0)), 0.2)

1589
	end

1590
	for i = 0, 6, 0.1 do

1591
		swait()

1592
		Eye.Transparency = Eye.Transparency - 0.05

1593
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(40)), 0.2)

1594
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(-40)), 0.2)

1595
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1596
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.2)

1597
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-134), Rad(0), Rad(145 + 2.5 * Sin(sine / 20))), 0.2)

1598
		LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(-15)), 0.2)

1599
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(-40), Rad(0)), 0.1)

1600
	end

1601
	coroutine.resume(coroutine.create(function() 

1602
		for i = 0, 1.8, 0.05 do

1603
			swait()

1604
			Head01.Transparency = i

1605
		end

1606
		Head01:Destroy()

1607
	end))

1608
	--Head01:Destory()

1609
	attack = false

1610
	Trail.Enabled = false

1611
	hum.WalkSpeed = 100

1612
end

1613
function Call_Upon_The_Eyes()

1614
	attack = true

1615
	hum.WalkSpeed = 0

1616
	for i = 0, 6, 0.1 do

1617
		swait()

1618
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1619
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1620
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1621
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1622
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(145), Rad(0), Rad(15 + 2.5 * Sin(sine / 20))), 0.12)

1623
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1624
		HW.C0 = clerp(HW.C0, CF(0, 3.5 + 0.2 * Cos(sine / 20), 0) * angles(Rad(90), Rad(0), Rad(0)), 0.1)

1625
	end

1626
	Magic(5, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

1627
	Magic(10, "Add", mouse.Hit * CFrame.new(0, -2.9, 0), Vector3.new(0, 0, 0), 2, maincolor, "Sphere")

1628
	Magic(1, "Add", mouse.Hit, Vector3.new(1, 100000, 1), 0.5, maincolor, "Sphere")

1629
	Magic(1, "Add", mouse.Hit, Vector3.new(1, 1, 1), 0.75, maincolor, "Sphere")

1630
	CameraEnshaking(4, 25)

1631
	for i, v in pairs(FindNearestHead(mouse.Hit.p, 14.5)) do

1632
		if v:FindFirstChild("Head") then

1633
			Eviscerate(v)

1634
		end

1635
	end

1636
	for i = 0, 6, 0.1 do

1637
		swait()

1638
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.4 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1639
		neck.C0 = clerp(neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1640
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -.8 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1641
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.8 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1642
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(45), Rad(0), Rad(15 + 2.5 * Sin(sine / 20))), 0.2)

1643
		LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1644
		HW.C0 = clerp(HW.C0, CF(0, 3 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0 - 255.45 * i), Rad(0), Rad(0)), 0.15)

1645
	end

1646
	attack = false

1647
	hum.WalkSpeed = 100

1648
end

1649
function Eyeyeyeyeyeyey_Slammo()

1650
	attack = true

1651
	hum.WalkSpeed = 0

1652
	local Blobby = IT("Part", char)

1653
	Blobby.Name = "Blob"

1654
	Blobby.CanCollide = false

1655
	Blobby.BrickColor = BrickC("Really black")

1656
	Blobby.Transparency = 0

1657
	Blobby.Material = "Plastic"

1658
	Blobby.Size = Vector3.new(1, 1, 2)

1659
	Blobby.TopSurface = Enum.SurfaceType.Smooth

1660
	Blobby.BottomSurface = Enum.SurfaceType.Smooth

1661
1662
	local Weld = IT("Weld", Blobby)

1663
	Weld.Part0 = hed

1664
	Weld.Part1 = Blobby

1665
	Weld.C1 = CF(0, -17.6, 1.4)

1666
	Weld.C0 = angles(Rad(0),0,0)

1667
1668
	local M2 = IT("SpecialMesh")

1669
	M2.Parent = Blobby

1670
	M2.MeshId = "http://www.roblox.com/asset/?id=438269029"

1671
	M2.TextureId = "http://www.roblox.com/asset/?id=77624973"

1672
	M2.Scale = Vector3.new(45.65, 45.65, 45.65)

1673
	for i = 0, 6, 0.1 do

1674
		swait()

1675
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.2)

1676
		neck.C0 = clerp(neck.C0, necko * CF(0, 0, 1) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1677
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1678
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1679
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(165 + 2.5 * Sin(sine / 20))), 0.12)

1680
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-165 + 2.5 * Sin(sine / 20))), 0.12)

1681
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1682
	end

1683
	Magic(1, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(1, 1, 1), 0.75, maincolor, "Sphere")

1684
	Magic(5, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(0, 0, 0), 1, maincolor, "Sphere")

1685
	Magic(10, "Add", root.CFrame * CF(0, -1.9, -20), Vector3.new(0, 0, 0), 2, maincolor, "Sphere")

1686
	for i, v in pairs(FindNearestHead(root.CFrame.p, 25.5)) do

1687
		if v:FindFirstChild("Head") then

1688
			Eviscerate(v)

1689
		end

1690
	end

1691
	CameraEnshaking(4, 25)

1692
	for i = 0, 6, 0.1 do

1693
		swait()

1694
		rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(90 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1695
		neck.C0 = clerp(neck.C0, necko * CF(0, 0, 1) * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1696
		RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1.3 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(90)), 0.15)

1697
		LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -1.3 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-90)), 0.15)

1698
		RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(165 + 2.5 * Sin(sine / 20))), 0.12)

1699
		LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.06 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-165 + 2.5 * Sin(sine / 20))), 0.12)

1700
		HW.C0 = clerp(HW.C0, CF(0, 2 + 0.2 * Cos(sine / 20), 0) * angles(Rad(0), Rad(0), Rad(0)), 0.1)

1701
	end

1702
	Blobby:Destroy()

1703
	attack = false

1704
	hum.WalkSpeed = 100

1705
end

1706
-------------------------------------------------------

1707
--End Attacks N Stuff--

1708
-------------------------------------------------------

1709
mouse.KeyDown:connect(function(key)

1710
	if attack == false then

1711
		if key == 't' then

1712
			

1713
1714
1715
1716
		elseif key == 'l' then

1717
1718
SONG = 1349585859

1719
Mode = 99900

1720
		tecks2.Text = "alone"

1721
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1722
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1723
		elseif key == 'y' then

1724
			

1725
1726
1727
1728
1729
		elseif key == 'k' then

1730
SONG = 1564523997

1731
Mode = 25

1732
		tecks2.Text = "triggered"

1733
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1734
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1735
		elseif key == 'z' then

1736
			

1737
1738
1739
1740
1741
		elseif key == 'j' then

1742
SONG = 1815812713

1743
Mode = 4

1744
		tecks2.Text = "muted"

1745
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1746
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1747
		elseif key == 'x' then

1748
			

1749
1750
1751
1752
		elseif key == 'h' then

1753
SONG = 1166995642

1754
Mode = 25

1755
        tecks2.Text = "punisher"

1756
        tecks2.TextColor3 = Color3.fromRGB(0, 0, 0)

1757
        tecks2.TextStrokeColor3 = Color3.fromRGB(255, 89, 89)

1758
		elseif key == 'c' then

1759
1760
1761
1762
1763
                elseif key == 'g' then

1764
SONG = 599679668

1765
Mode = 111111112

1766
		tecks2.Text = "sunny"

1767
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1768
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1769
		elseif key == 'f' then

1770
SONG = 826762530

1771
Mode = 1555

1772
		tecks2.Text = "hopeless"

1773
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1774
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)               

1775
                elseif key == 'r' then

1776
SONG = 657813878

1777
Mode = 98534

1778
		tecks2.Text = "psyche problems"

1779
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1780
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1781
1782
                elseif key == 'b' then

1783
Mode = 10

1784
SONG = 1138145518

1785
		tecks2.Text = "Dory-god"

1786
		tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1787
		tecks2.TextStrokeColor3 = Color3.fromRGB(255, 255, 255)

1788
1789
                elseif key == 'o' then

1790
        Mode = 6

1791
        SONG = 634322702

1792
        tecks2.Text = "emo"

1793
        tecks2.TextColor3 = Color3.fromRGB(0, 255, 255)

1794
        tecks2.TextStrokeColor3 = Color3.fromRGB(255, 89, 89)

1795
		end

1796
	end

1797
end)

1798
1799
1800
1801
1802
1803
1804
1805
-------------------------------------------------------

1806
--Start Animations--

1807
-------------------------------------------------------

1808
while true do

1809
	swait()

1810
	sine = sine + change

1811
	local torvel = (root.Velocity * Vector3.new(1, 0, 1)).magnitude

1812
	local velderp = root.Velocity.y

1813
	hitfloor, posfloor = rayCast(root.Position, CFrame.new(root.Position, root.Position - Vector3.new(0, 1, 0)).lookVector, 4* Player_Size, char)

1814
	if equipped == true or equipped == false then

1815
		if attack == false then

1816
			idle = idle + 1

1817
		else

1818
			idle = 0

1819
		end

1820
		if 1 < root.Velocity.y and hitfloor == nil then

1821
            Anim = "Jump"

1822
            if attack == false then

1823
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1 * Cos(sine / 20)* Player_Size) * angles(Rad(-16), Rad(0), Rad(0)), 0.08)

1824
                neck.C0 = clerp(neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(10 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1825
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -.2 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * RHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.08)

1826
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.9 - 0.1 * Cos(sine / 20), -.5* Player_Size) * LHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.08)

1827
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25), Rad(-.6), Rad(13 + 4.5 * Sin(sine / 20))), 0.08)

1828
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25), Rad(-.6), Rad(-13 - 4.5 * Sin(sine / 20))), 0.08)

1829
            end

1830
        elseif -1 > root.Velocity.y and hitfloor == nil then

1831
            Anim = "Fall"

1832
            if attack == false then

1833
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1 * Cos(sine / 20)* Player_Size) * angles(Rad(24), Rad(0), Rad(0)), 0.08)

1834
                neck.C0 = clerp(neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(10 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1835
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * RHCF * angles(Rad(-3.5), Rad(0), Rad(0)), 0.08)

1836
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -.8 - 0.1 * Cos(sine / 20)* Player_Size, -.3* Player_Size) * LHCF * angles(Rad(-3.5), Rad(0), Rad(0)), 0.08)

1837
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(65), Rad(-.6), Rad(45 + 4.5 * Sin(sine / 20))), 0.08)

1838
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(55), Rad(-.6), Rad(-45 - 4.5 * Sin(sine / 20))), 0.08)

1839
            end

1840
        elseif torvel < 1 and hitfloor ~= nil then

1841
            Anim = "Idle"

1842
            change = 1

1843
            if attack == false then

1844
                if Mode == 1 then --Normal

1845
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(25)), 0.15)

1846
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(20 - 2.5 * Sin(sine / 20)), Rad(20), Rad(-15)), 0.3)

1847
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

1848
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

1849
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-10 * Cos(sine / 20)), Rad(65 - 2.5 * Sin(sine / 20))), 0.1)

1850
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

1851
                elseif Mode == 99900 then 

1852
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.15)

1853
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(0), Rad(20 * Cos(sine / 12))), 0.3)

1854
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size + 0.06 * Sin(sine / 24) - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(84), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1855
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06 * Sin(sine / 24) - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-84), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1856
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.35 + 0.15 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-6 + 4.5 * Sin(sine / 12)), Rad(25 + 2.5 * Sin(sine / 12)), Rad(25 + 4.5 * Sin(sine / 12))), 0.1)

1857
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.35 + 0.15 * Cos(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(7 + 4.5 * Sin(sine / 12)), Rad(0 + 2.5 * Sin(sine / 12)), Rad(-13 - 4.5 * Sin(sine / 12))), 0.1)

1858
                elseif Mode == 8888 then --idk

1859
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.15)

1860
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 12.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.3)

1861
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(79), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1862
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-79), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.15)

1863
                RW.C0 = clerp(RW.C0, CF(1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(20), Rad(-.6), Rad(43 + 4.5 * Sin(sine / 12))), 0.1)

1864
                LW.C0 = clerp(LW.C0, CF(-1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(20), Rad(-.6), Rad(-43 - 4.5 * Sin(sine / 12))), 0.1)

1865
                elseif Mode == 98534 then

1866
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1867
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(30 - 2.5 * Sin(sine / 18)), Rad(0), Rad(0)), 0.3)

1868
                if Mrandom(1,15) == 1 then

1869
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1870
                end

1871
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(0)), 0.15)

1872
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(0)), 0.15)

1873
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-10 * Cos(sine / 20)), Rad(5 - 2.5 * Sin(sine / 20))), 0.1)

1874
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

1875
                elseif Mode == 56565 then --idk

1876
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(20)), 0.15)

1877
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 7.5 * Sin(sine / 30)), Rad(0), Rad(-20)), 0.3)

1878
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(75), Rad(0)) * angles(Rad(-12.5), Rad(0), Rad(0)), 0.15)

1879
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-75), Rad(0)) * angles(Rad(-12.5), Rad(0), Rad(8)), 0.15)

1880
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(10), Rad(-.6), Rad(15 + 6.5 * Sin(sine / 20))), 0.1)

1881
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-10), Rad(-.6), Rad(-15 - 6.5 * Sin(sine / 20))), 0.1)

1882
                elseif Mode == pIXELATED then --PIXELATED

1883
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(20 + Mrandom(-4,4)), Rad(0), Rad(0)), 0.08)

1884
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 + Mrandom(-30,30)), Rad(-4.5 + Mrandom(-30,30)), Rad(-4.5 + Mrandom(-30,30))), 0.08)

1885
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0 + Mrandom(-6,6)), Rad(80), Rad(0)) * angles(Rad(-10.5 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(20 + Mrandom(-6,6))), 0.08)

1886
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0 + Mrandom(-6,6)), Rad(-80 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6))) * angles(Rad(-10.5 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(-20 + Mrandom(-6,6))), 0.08)

1887
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(5 + Mrandom(-6,6))), 0.08)

1888
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(25 + Mrandom(-6,6)), Rad(0 + Mrandom(-6,6)), Rad(-5 + Mrandom(-6,6))), 0.08)

1889
                elseif Mode == 50 then --ASCENDED

1890
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

1891
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1892
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1893
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1894
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(13 + 4.5 * Sin(sine / 20))), 0.08)

1895
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(-13 - 4.5 * Sin(sine / 20))), 0.08)

1896
            elseif Mode == 7777 then --NOTHING SPECIAL

1897
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(4), Rad(0), Rad(0)), 0.15)

1898
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(20), Rad(0), Rad(0)), 0.3)

1899
                if Mrandom(1,15) == 1 then

1900
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1901
                end

1902
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-1.5), Rad(0), Rad(10)), 0.15)

1903
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-1.5), Rad(0), Rad(10)), 0.15)

1904
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(15 - 4 * Cos(sine / 20)), Rad(0), Rad(5)), 0.1)

1905
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(15 - 4 * Cos(sine / 20)), Rad(0), Rad(-5)), 0.1)

1906
            elseif Mode == 6666 then --MEMER

1907
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.15)

1908
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(0), Rad(0)), 0.3)

1909
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.15)

1910
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5), Rad(0), Rad(0)), 0.15)

1911
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30 * Cos(sine / 20)), Rad(0), Rad(5)), 0.1)

1912
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(30 * Cos(sine / 20)), Rad(0), Rad(-5)), 0.1)

1913
            elseif Mode == 2 then --Machinery

1914
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(20)), 0.08)

1915
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 * Sin(sine / 30)), Rad(-4.5 * Sin(sine / .5)), Rad(-20 - 4.5 * Sin(sine / .5))), 0.08)

1916
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5), Rad(0), Rad(0)), 0.08)

1917
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5), Rad(0), Rad(0)), 0.08)

1918
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(155), Rad(0), Rad(-45)), 0.08)

1919
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(-25)), 0.08)

1920
            elseif Mode == 3 then --ICE

1921
rootj.C0=clerp(rootj.C0,RootCF*CF(0,0,-0.1+0.1*math.cos(sine/20))*angles(math.rad(-20),math.rad(0),math.rad(0)),0.15)

1922
tors.Neck.C0=clerp(tors.Neck.C0,necko*angles(math.rad(-15*math.sin(sine/25)/2),math.rad(0),math.rad(10*math.sin(sine/25))),.3)

1923
RH.C0=clerp(RH.C0,CF(1,-0.9-0.1*math.cos(sine/20),0.025*math.cos(sine/20))*RHCF*angles(math.rad(-10),math.rad(-0),math.rad(-25)),0.15)

1924
LH.C0=clerp(LH.C0,CF(-1,-0.9-0.1*math.cos(sine/20),0.025*math.cos(sine/20))*LHCF*angles(math.rad(-3),math.rad(-4*math.sin(sine/25)),math.rad(15)),0.15)

1925
RW.C0 = clerp(RW.C0, CFrame.new(1.5, 0.5+0.04*math.sin(sine/25), 0) * angles(math.rad(-35 ), math.rad(-7*math.sin(sine/25)), math.rad(5)), 0.1)

1926
LW.C0 = clerp(LW.C0, CFrame.new(-1.5, 0.5+0.04*math.sin(sine/25),0) * angles(math.rad(-35 ), math.rad(7*math.sin(sine/25)), math.rad(-5)), 0.1)

1927
            elseif Mode == 4 then --Infused

1928
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(5), Rad(0), Rad(10)), 0.15)

1929
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-4.5 * Sin(sine / 30)), Rad(0), Rad(-10)), 0.3)

1930
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-20 + 2.5 * Sin(sine / 20))), 0.15)

1931
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(0 + 2.5 * Sin(sine / 20))), 0.15)

1932
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(13 - 2.5 * Sin(sine / 20))), 0.1)

1933
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-13 + 2.5 * Sin(sine / 20))), 0.1)

1934
            elseif Mode == 5 then --Cybernetic

1935
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

1936
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 2.5 * Sin(sine / 30)), Rad(20), Rad(0)), 0.08)

1937
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.08)

1938
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.08)

1939
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(25 + 10.5 * Sin(sine / 20))), 0.08)

1940
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(-25 - 10.5 * Sin(sine / 20))), 0.08)

1941
            elseif Mode == 25 then --Spiritual

1942
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

1943
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 2.5 * Sin(sine / 30)), Rad(20), Rad(0)), 0.08)

1944
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.08)

1945
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.08)

1946
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(25 + 10.5 * Sin(sine / 20))), 0.08)

1947
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(0), Rad(-25 - 10.5 * Sin(sine / 20))), 0.08)

1948
            elseif Mode == 6 then --Controlled Beyond Recognition

1949
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(10), Rad(0), Rad(0)), 0.15)

1950
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(30 - 2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1951
                if Mrandom(1,15) == 1 then

1952
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

1953
                end

1954
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(10)), 0.15)

1955
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), -.2 + 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(0), Rad(-10)), 0.15)

1956
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-20), Rad(215)), 0.1)

1957
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

1958
            elseif Mode == 1800 then --demon

1959
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.1 + 0.1* Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.1)

1960
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(20 - 2.5 * Sin(sine / 20)), Rad(Mrandom(-45, 45)), Rad(Mrandom(-45, 45))), 0.1)

1961
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(85), Rad(0)) * angles(Rad(-5), Rad(Mrandom(-15, 15)), Rad(20)), 0.1)

1962
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9* Player_Size - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-85), Rad(0)) * angles(Rad(-5), Rad(Mrandom(-15, 15)), Rad(-20)), 0.1)

1963
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.8* Player_Size + 0.01 * Sin(sine / 20)* Player_Size, -0.6* Player_Size) * angles(Rad(165), Rad(Mrandom(-15, 15)), Rad(-50)), 0.1)

1964
                LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.8* Player_Size + 0.01 * Sin(sine / 20)* Player_Size, -0.6* Player_Size) * angles(Rad(165), Rad(Mrandom(-15, 15)), Rad(50)), 0.1)

1965
            elseif Mode == 7 or Mode == 9 then --Sucho Wowo --Mr.Balancia  ----------hdfsfhg

1966
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0 - 0.04 * Sin(sine / 24) * Player_Size, 0 + 0.04 * Sin(sine / 12) * Player_Size, 0 + 0.05 * Player_Size * Cos(sine / 12)) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(0 - 2.5 * Sin(sine / 24)), Rad(0)), 0.08)

1967
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(25 - 2.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.08)

1968
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(79), Rad(0)) * angles(Rad(-6 - 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.08)

1969
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -1 * Player_Size - 0.06  - 0.05 * Player_Size * Cos(sine / 12), -0.01 * Player_Size) * angles(Rad(0 - 2.5 * Sin(sine / 12)), Rad(-79), Rad(0)) * angles(Rad(-6 + 2.5 * Sin(sine / 24)), Rad(0), Rad(0)), 0.08)

1970
                RW.C0 = clerp(RW.C0, CF(1 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(-43)), 0.08)

1971
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

1972
            elseif Mode == 1555 then --anime

1973
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(10)), 0.15)

1974
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(20 - 2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

1975
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5), Rad(0), Rad(-10)), 0.15)

1976
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5), Rad(5 * Cos(sine / 20)), Rad(6)), 0.15)

1977
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * angles(Rad(21), Rad(11), Rad(-90 - 2.5 * Sin(sine / 20))), 0.1)

1978
                LW.C0 = clerp(LW.C0, CF(-.8, 0.3 + 0.05 * Sin(sine / 20), -.6 + 0.025 * Cos(sine / 20)) * angles(Rad(8), Rad(5), Rad(90 + 2.5 * Sin(sine / 20))), 0.1)

1979
            elseif Mode == 111111111 then

1980
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 20)) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(0), Rad(0)), 0.15)

1981
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

1982
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, -.2* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1983
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-2 + 2 * Cos(sine / 12)), Rad(-74), Rad(0)) * angles(Rad(-2.5), Rad(0), Rad(-4)), 0.15)

1984
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

1985
                LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.06 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

1986
            elseif Mode == 100 then --Overclocked

1987
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(25)), 0.15)

1988
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(20 - 2.5 * Sin(sine / 20)), Rad(20), Rad(-15)), 0.3)

1989
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

1990
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

1991
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-10 * Cos(sine / 20)), Rad(65 - 2.5 * Sin(sine / 20))), 0.1)

1992
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

1993
            elseif Mode == 8 then --Lunarist

1994
                MagicCharge(7, 0, "Add", ra.CFrame * CF(0, -1.3, 0) * CFrame.Angles(math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360)), math.rad(math.random(-360, 360))), 0.5, 0.5, 1.5 * math.random(-1.8, 2), -0.005, maincolor, 0, "Brick")

1995
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 0.8 + 0.2* Player_Size * Cos(sine / 20)) * angles(Rad(0), Rad(0), Rad(0)), 0.08)

1996
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

1997
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -0.5* Player_Size) * angles(Rad(0), Rad(75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1998
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(0)), 0.08)

1999
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-.6), Rad(135)), 0.08)

2000
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

2001
            elseif Mode == 111111112 then

2002
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 2 + 0.25* Player_Size * Cos(sine / 12)) * angles(Rad(25), Rad(0), Rad(0)), 0.1)

2003
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 6.5 * Sin(sine / 12)), Rad(0), Rad(0)), 0.05)

2004
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.15 * Cos(sine / 20)* Player_Size, -0.1* Player_Size) * angles(Rad(0), Rad(76), Rad(0)) * angles(Rad(-8.5 - 6.5 * Sin(sine / 12)), Rad(0), Rad(15)), 0.1)

2005
                LH.C0 = clerp(LH.C0, CF(-1.1* Player_Size, -0.6 - 0.15 * Cos(sine / 20)* Player_Size, -0.3* Player_Size) * angles(Rad(0), Rad(-76), Rad(0)) * angles(Rad(-8.5 - 6.5 * Sin(sine / 12)), Rad(15), Rad(25)), 0.1)

2006
                RW.C0 = clerp(RW.C0, CF(1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(13 + 6.5 * Sin(sine / 12))), 0.1)

2007
                LW.C0 = clerp(LW.C0, CF(-1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(25 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(-13 - 6.5 * Sin(sine / 12))), 0.1)

2008
            elseif Mode == 10 then --INSANITY

2009
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.2 + 0.1 * Cos(sine / 7)) * angles(Rad(10), Rad(0), Rad(0)), 0.15)

2010
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(45), Rad(0), Rad(-20)), 0.3)

2011
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.1 + 0.1 * Cos(sine / 7)) * angles(Rad(10 + Mrandom(-6,6)), Rad(0), Rad(Mrandom(-6,6))), 0.15)

2012
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(45 + Mrandom(-4,4)), Rad(Mrandom(-4,4)), Rad(-20 + Mrandom(-4,4))), 1)

2013
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 7), 0.025 * Cos(sine / 7)) * angles(Rad(180 + Mrandom(-35,35)), Rad(35 + Mrandom(-35,35)), Rad(-50 - 2.5 * Sin(sine / 20) + Mrandom(-35,35))), 0.1)

2014
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 7), 0.025 * Cos(sine / 7)) * angles(Rad(15 + Mrandom(-35,35)), Rad(Mrandom(-35,35)), Rad(-15 + 2.5 * Sin(sine / 20) + Mrandom(-35,35))), 0.1)

2015
                RH.C0 = clerp(RH.C0, CF(1, -0.9 - 0.1 * Cos(sine / 7), -.2 +  0.025 * Cos(sine / 7)) * RHCF * angles(Rad(-5 + Mrandom(-6,6)), Rad(0), Rad(10 + Mrandom(-6,6))), 0.15)

2016
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 7), 0.025 * Cos(sine / 7)) * LHCF * angles(Rad(-5 + Mrandom(-6,6)), Rad(0), Rad(-10 + Mrandom(-6,6))), 0.15)

2017
            end

2018
            end

2019
        elseif torvel > 2 and torvel < 25 and hitfloor ~= nil then

2020
            Anim = "Walk"

2021
            change = 1.1

2022
            if attack == false then

2023
                if Mode == 6 then

2024
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(4-2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(5 * Cos(sine / 7))), 0.15)

2025
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(30 - 2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

2026
                if Mrandom(1,15) == 1 then

2027
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15)), Rad(Mrandom(-15,15))), 1)

2028
                end

2029
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2030
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2031
                RW.C0 = clerp(RW.C0, CF(.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(-20), Rad(215)), 0.1)

2032
                LW.C0 = clerp(LW.C0, CF(-.8, 0.5 + 0.05 * Sin(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * angles(Rad(0), Rad(20), Rad(-215)), 0.1)

2033
                elseif Mode == 3 then

2034
				rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2035
				tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2036
				RH.C0 = clerp(RH.C0, CF(1, -0.8 - 0.5 * Cos(sine / 7) / 2, 0.6 * Cos(sine / 7) / 2)  * angles(Rad(-15 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2037
         		LH.C0 = clerp(LH.C0, CF(-1, -0.8 + 0.5 * Cos(sine / 7) / 2, -0.6 * Cos(sine / 7) / 2) * angles(Rad(-15 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2038
				RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 7), 0) * angles(Rad(37)  * Cos(sine / 7) , Rad(0), Rad(-.6) - ra.RotVelocity.Y / 75), 0.1)

2039
				LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 7), 0) * angles(Rad(-37)  * Cos(sine / 7) , Rad(0) ,	Rad(.6) + la.RotVelocity.Y / 75), 0.1)

2040
                elseif Mode == 98534 then

2041
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(9-2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(10 * Cos(sine / 7))), 0.15)

2042
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(30 * Cos(sine / 20)), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2043
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 - 35 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2044
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.5 * Cos(sine / 7) / 2) * angles(Rad(-15 + 35 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2045
                RW.C0 = clerp(RW.C0, CF(1.4, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(90), Rad(0), Rad(-15) - ra.RotVelocity.Y / 75), 0.1)

2046
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-70)  * Cos(sine / 7) , Rad(0) ,    Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2047
                elseif Mode == 111111112 then

2048
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 2 + 0.25* Player_Size * Cos(sine / 12)) * angles(Rad(25), Rad(0), Rad(0)), 0.1)

2049
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-15 - 6.5 * Sin(sine / 12)), Rad(20), Rad(0)), 0.1)

2050
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -1 - 0.15 * Cos(sine / 20)* Player_Size, -0.1* Player_Size) * angles(Rad(0), Rad(76), Rad(0)) * angles(Rad(-18.5 - 6.5 * Sin(sine / 12)), Rad(0), Rad(-35)), 0.1)

2051
                LH.C0 = clerp(LH.C0, CF(-1.1* Player_Size, -0.6 - 0.15 * Cos(sine / 20)* Player_Size, -0.2* Player_Size) * angles(Rad(0), Rad(-76), Rad(0)) * angles(Rad(-18.5 - 6.5 * Sin(sine / 12)), Rad(15), Rad(35)), 0.1)

2052
                RW.C0 = clerp(RW.C0, CF(1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-45 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(25 + 6.5 * Sin(sine / 12))), 0.1)

2053
                LW.C0 = clerp(LW.C0, CF(-1.4* Player_Size, 0.4 + 0.08 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-45 - 6.5 * Cos(sine / 12)), Rad(-.6), Rad(-25 - 6.5 * Sin(sine / 12))), 0.1)

2054
                elseif Mode == 111111111 then

2055
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(3 * Cos(sine / 7))), 0.15)

2056
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2057
                RH.C0 = clerp(RH.C0, CF(1, -0.8 - 0.5 * Cos(sine / 7) / 2, 0.6 * Cos(sine / 7) / 2)  * angles(Rad(-15 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2058
                LH.C0 = clerp(LH.C0, CF(-1, -0.8 + 0.5 * Cos(sine / 7) / 2, -0.6 * Cos(sine / 7) / 2) * angles(Rad(-15 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2059
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.3 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(-25 + 2.5 * Sin(sine / 20)), Rad(-55 + 2.5 * Sin(sine / 20))), 0.12)

2060
                LW.C0 = clerp(LW.C0, CF(-1* Player_Size, 0.3 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-35), Rad(25 + 2.5 * Sin(sine / 20)), Rad(55 + 2.5 * Sin(sine / 20))), 0.12)

2061
                elseif Mode == 99900 then

2062
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.13 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(10 * Cos(sine / 7))), 0.15)

2063
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(0), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2064
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 15 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2065
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 15 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2066
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(57)  * Cos(sine / 7) , Rad(10 * Cos(sine / 7)), Rad(10) - ra.RotVelocity.Y / 75), 0.1)

2067
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-57)  * Cos(sine / 7) , Rad(10 * Cos(sine / 7)) ,  Rad(-10) + la.RotVelocity.Y / 75), 0.1)

2068
                elseif Mode == 1 then --Normal

2069
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

2070
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

2071
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

2072
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

2073
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(-10 * Cos(sine / 20)), Rad(15 - 2.5 * Sin(sine / 20))), 0.1)

2074
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

2075
                elseif Mode == 7777 then --NORTHING SPECIAL

2076
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(7-2.5 * Cos(sine / 3.5)), Rad(0), Rad(10 * Cos(sine / 7))), 0.15)

2077
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(0), Rad(0)), 0.3)

2078
                RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.1 * Cos(sine / 3.5), 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-1.5), Rad(0), Rad(70) * Cos(sine / 7) ), 0.15)

2079
                LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.1 * Cos(sine / 3.5), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-1.5), Rad(0), Rad(70) * Cos(sine / 7) ), 0.15)

2080
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(70) * Cos(sine / 7) , Rad(0), Rad(15)), 0.1)

2081
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-70) * Cos(sine / 7) , Rad(0),  Rad(-15)), 0.1)

2082
                elseif Mode == 4 then --Infused

2083
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(25), Rad(0), Rad(0)), 0.15)

2084
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-5 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2085
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-20 + 2.5 * Sin(sine / 20))), 0.15)

2086
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(20 + 2.5 * Sin(sine / 20))), 0.15)

2087
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-25 - 3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(14 - 2.5 * Sin(sine / 20))), 0.1)

2088
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-25 + 4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-14 + 2.5 * Sin(sine / 20))), 0.1)

2089
                elseif Mode == 56565 then --idk

2090
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2091
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2092
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2093
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2094
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)), Rad(6) - ra.RotVelocity.Y / 75), 0.1)

2095
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)) ,   Rad(-6) + la.RotVelocity.Y / 75), 0.1)

2096
                elseif Mode == 8888 then --ik

2097
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2098
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2099
                RH.C0 = clerp(RH.C0, CF(1 * Player_Size, -0.8 * Player_Size - 0.5 * Player_Size * Cos(sine / 7) / 2 * Player_Size, 0.6 * Player_Size * Cos(sine / 7) / 2 * Player_Size)  * angles(Rad(-15 - 35 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2100
                LH.C0 = clerp(LH.C0, CF(-1 * Player_Size, -0.8 * Player_Size + 0.5 * Player_Size * Cos(sine / 7) / 2 * Player_Size, -0.6 * Player_Size * Cos(sine / 7) / 2 * Player_Size) * angles(Rad(-15 + 35 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2101
                RW.C0 = clerp(RW.C0, CF(1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(65) * Cos(sine / 7), Rad(-.6), Rad(15 + 4.5 * Sin(sine / 12))), 0.1)

2102
                LW.C0 = clerp(LW.C0, CF(-1.5 * Player_Size, 0.5 + 0.02 * Sin(sine / 12)* Player_Size, 0* Player_Size) * angles(Rad(-65) * Cos(sine / 7), Rad(-.6), Rad(-15 - 4.5 * Sin(sine / 12))), 0.1)

2103
            elseif Mode == 1555 then --anime

2104
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2105
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2106
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-10 - 25 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2107
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-10 + 25 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 10 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2108
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)), Rad(6) - ra.RotVelocity.Y / 75), 0.1)

2109
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(8 * Cos(sine / 7)) ,   Rad(-6) + la.RotVelocity.Y / 75), 0.1)

2110
            elseif Mode == 6666 then

2111
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(9-2.5 * Cos(sine / 3.5)), Rad(0), Rad(10 * Cos(sine / 7))), 0.15)

2112
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(0), Rad(0), Rad(0)), 0.3)

2113
                RH.C0 = clerp(RH.C0, CFrame.new(1, -0.925 - 0.5 * math.cos(sine / 7) / 2, 0.5 * math.cos(sine / 7) / 2) * angles(math.rad(-15 - 35 * math.cos(sine / 7)) + -math.sin(sine / 7) / 2.5, math.rad(90 - 2 * math.cos(sine / 7)), math.rad(0)) * angles(math.rad(0 + 2.5 * math.cos(sine / 7)), math.rad(0), math.rad(0)), 0.3)

2114
                LH.C0 = clerp(LH.C0, CFrame.new(-1, -0.925 + 0.5 * math.cos(sine / 7) / 2, -0.5 * math.cos(sine / 7) / 2) * angles(math.rad(-15 + 35 * math.cos(sine / 7)) + math.sin(sine / 7) / 2.5, math.rad(-90 - 2 * math.cos(sine / 7)), math.rad(0)) * angles(math.rad(0 - 2.5 * math.cos(sine / 7)), math.rad(0), math.rad(0)), 0.3)

2115
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(70) * Cos(sine / 7) , Rad(0), Rad(5)), 0.1)

2116
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-70) * Cos(sine / 7) , Rad(0),  Rad(-5)), 0.1)

2117
            elseif Mode == 1800 then

2118
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(20 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2119
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(46 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2120
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-5 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(20)), 0.3)

2121
                    LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-5 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(-20)), 0.3)

2122
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(25 + 15 * Cos(sine / 7)), Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.1)

2123
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(25 - 15 * Cos(sine / 7)), Rad(0), Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2124
            elseif Mode == 5 then

2125
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.15)

2126
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2127
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.15)

2128
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.15)

2129
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(25)), 0.1)

2130
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-25)), 0.1)

2131
            elseif Mode == 25 then

2132
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.15)

2133
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2134
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-20)), 0.15)

2135
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(20)), 0.15)

2136
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(25)), 0.1)

2137
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-35), Rad(0), Rad(-25)), 0.1)

2138
            elseif Mode == 100 then

2139
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

2140
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

2141
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-10 + 3 * Sin(sine / 20))), 0.15)

2142
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5 + 3 * Sin(sine / 20)), Rad(0), Rad(10 + 3 * Sin(sine / 20))), 0.15)

2143
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(-10 * Cos(sine / 20)), Rad(15 - 2.5 * Sin(sine / 20))), 0.1)

2144
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-17), Rad(10 * Cos(sine / 20)), Rad(-15 + 2.5 * Sin(sine / 20))), 0.1)

2145
            elseif Mode == 10 then

2146
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * CF(0, 0, 0 + ((1) - 1)) * angles(Rad(55 + Mrandom(-20,20)), Rad(Mrandom(-20,20)), Rad(-0 + Mrandom(-20,20))), 1)

2147
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(30), Rad(0), Rad(0)), 0.15)

2148
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(55), Rad(0), Rad(-0)), 0.3)

2149
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-4.5 + Mrandom(-23,23)), Rad(0 + Mrandom(-23,23)), Rad(35 + Mrandom(-23,23))), 0.15)

2150
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-6.5 + Mrandom(-23,23)), Rad(0 + Mrandom(-23,23)), Rad(-35 + Mrandom(-23,23))), 0.15)

2151
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(35 + Mrandom(-23,23)), Rad(-10 + Mrandom(-23,23)), Rad(15 + Mrandom(-23,23))), 0.1)

2152
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(35 + Mrandom(-23,23)), Rad(10 + Mrandom(-23,23)), Rad(-15 + Mrandom(-23,23))), 0.1)

2153
            elseif Mode == 8 then

2154
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 0.8 + 0.2* Player_Size * Cos(sine / 20)) * angles(Rad(20), Rad(0), Rad(0)), 0.08)

2155
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(15 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.08)

2156
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -0.5* Player_Size) * angles(Rad(0), Rad(75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(-20)), 0.08)

2157
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-75), Rad(0)) * angles(Rad(-6.5), Rad(0), Rad(20)), 0.08)

2158
                RW.C0 = clerp(RW.C0, CF(1* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(-43)), 0.08)

2159
                LW.C0 = clerp(LW.C0, CF(-1 * Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, .6* Player_Size) * angles(Rad(-20), Rad(-.6), Rad(43)), 0.08)

2160
            elseif Mode ~= 6 or Mode ~= 5 or Mode ~= 8 then

2161
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(3 - 2.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(8 * Cos(sine / 7))), 0.15)

2162
                tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(6 - 2.5 * Sin(sine / 7)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2163
                RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.8 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.6 * Cos(sine / 7) / 2* Player_Size)  * angles(Rad(-15 - 5 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2164
                    LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.8 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.6 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-15 + 5 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 3 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 2 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2165
                RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(37)  * Cos(sine / 7) , Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.1)

2166
                LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 7)* Player_Size, 0* Player_Size) * angles(Rad(-37)  * Cos(sine / 7) , Rad(0) ,   Rad(-5) + la.RotVelocity.Y / 75), 0.1)

2167
            end

2168
            end

2169
        elseif torvel >= 25 and hitfloor ~= nil then

2170
            Anim = "Sprint"

2171
            change = 1.35

2172
            if attack == false then

2173
        if Mode == 5 then

2174
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

2175
            tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(5 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2176
            RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-45)), 0.15)

2177
            LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(45)), 0.15)

2178
            RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-65), Rad(0), Rad(25)), 0.1)

2179
            LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-65), Rad(0), Rad(-25)), 0.1)

2180
        elseif Mode == 56565 then

2181
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2182
            tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2183
            RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.7 * Cos(sine / 7) / 2) * angles(Rad(-15 - 55 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2184
            LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.7 * Cos(sine / 7) / 2) * angles(Rad(-15 + 55 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2185
            RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.34 * Cos(sine / 7)) * angles(Rad(110)  * Cos(sine / 7) , Rad(0), Rad(13) - ra.RotVelocity.Y / 75), 0.15)

2186
            LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), -0.34 * Cos(sine / 7)) * angles(Rad(-110)  * Cos(sine / 7) , Rad(0) ,    Rad(-13) + la.RotVelocity.Y / 75), 0.15)

2187
        elseif Mode  == 111111111 then

2188
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2189
            tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2190
            RH.C0 = clerp(RH.C0, CF(1, -0.925 - 0.5 * Cos(sine / 7) / 2, 0.7 * Cos(sine / 7) / 2) * angles(Rad(-15 - 55 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2191
            LH.C0 = clerp(LH.C0, CF(-1, -0.925 + 0.5 * Cos(sine / 7) / 2, -0.7 * Cos(sine / 7) / 2) * angles(Rad(-15 + 55 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2192
            RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.34 * Cos(sine / 7)) * angles(Rad(110)  * Cos(sine / 7) , Rad(0), Rad(13) - ra.RotVelocity.Y / 75), 0.15)

2193
            LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), -0.34 * Cos(sine / 7)) * angles(Rad(-110)  * Cos(sine / 7) , Rad(0) ,    Rad(-13) + la.RotVelocity.Y / 75), 0.15)

2194
        elseif Mode  == 4 then

2195
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.2 + 0.3 * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

2196
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-5 - 4.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2197
                RH.C0 = clerp(RH.C0, CF(1, -0.4 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-34 + 2.5 * Sin(sine / 20))), 0.15)

2198
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-2.5 + 3 * Sin(sine / 20)), Rad(0), Rad(34 + 2.5 * Sin(sine / 20))), 0.15)

2199
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-55 - 3 * Sin(sine / 20)), Rad(-10 * Sin(sine / 20)), Rad(14 - 2.5 * Sin(sine / 20))), 0.1)

2200
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 30), 0.025 * Cos(sine / 20)) * angles(Rad(-55 + 4 * Sin(sine / 20)), Rad(10 * Sin(sine / 20)), Rad(-14 + 2.5 * Sin(sine / 20))), 0.1) 

2201
        elseif Mode == 1 then

2202
                rootj.C0 = clerp(rootj.C0, RootCF * CF(0, 0, 1.3 + 0.6 * Cos(sine / 20)) * angles(Rad(65), Rad(0), Rad(0)), 0.15)

2203
                tors.Neck.C0 = clerp(tors.Neck.C0, necko * angles(Rad(-25 - 2.5 * Sin(sine / 20)), Rad(0), Rad(0)), 0.3)

2204
                RH.C0 = clerp(RH.C0, CF(1, -0.5 - 0.1 * Cos(sine / 20), -.4 + 0.025 * Cos(sine / 20)) * RHCF * angles(Rad(-14.5 + 3 * Sin(sine / 20)), Rad(0), Rad(-35 + 3 * Sin(sine / 20))), 0.15)

2205
                LH.C0 = clerp(LH.C0, CF(-1, -0.9 - 0.1 * Cos(sine / 20), 0.025 * Cos(sine / 20)) * LHCF * angles(Rad(-16.5 + 3 * Sin(sine / 20)), Rad(0), Rad(35 + 3 * Sin(sine / 20))), 0.15)

2206
                RW.C0 = clerp(RW.C0, CF(1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-35), Rad(-10 * Cos(sine / 20)), Rad(25 - 2.5 * Sin(sine / 20))), 0.1)

2207
                LW.C0 = clerp(LW.C0, CF(-1.5, 0.5 + 0.05 * Sin(sine / 20), 0.025 * Cos(sine / 20)) * angles(Rad(-35), Rad(10 * Cos(sine / 20)), Rad(-25 + 2.5 * Sin(sine / 20))), 0.1)

2208
        elseif Mode == 25 or Mode == 10 then

2209
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, 1 + 0.5 * Player_Size * Cos(sine / 20)) * angles(Rad(45), Rad(0), Rad(0)), 0.15)

2210
            tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(5 - 2.5 * Sin(sine / 30)), Rad(0), Rad(0)), 0.3)

2211
            RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.3 - 0.1 * Cos(sine / 20)* Player_Size, -.4* Player_Size) * angles(Rad(0), Rad(80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(-45)), 0.15)

2212
            LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.9 - 0.1 * Cos(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(0), Rad(-80), Rad(0)) * angles(Rad(-10.5 + 3.5 * Sin(sine / 20)), Rad(0), Rad(45)), 0.15)

2213
            RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-65), Rad(0), Rad(25)), 0.1)

2214
            LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.02 * Sin(sine / 20)* Player_Size, 0* Player_Size) * angles(Rad(-65), Rad(0), Rad(-25)), 0.1)

2215
        elseif Mode ~= 5 then

2216
            rootj.C0 = clerp(rootj.C0, RootCF * CF(0* Player_Size, 0* Player_Size, -0.175 + 0.025 * Cos(sine / 3.5) + -Sin(sine / 3.5) / 7* Player_Size) * angles(Rad(26 - 4.5 * Cos(sine / 3.5)), Rad(0) - root.RotVelocity.Y / 75, Rad(15 * Cos(sine / 7))), 0.15)

2217
            tors.Neck.C0 = clerp(tors.Neck.C0, necko* CF(0, 0, 0 + ((1* Player_Size) - 1)) * angles(Rad(-2.5 * Sin(sine / 20)), Rad(0), Rad(0) - hed.RotVelocity.Y / 15), 0.3)

2218
            RH.C0 = clerp(RH.C0, CF(1* Player_Size, -0.925 - 0.5 * Cos(sine / 7) / 2* Player_Size, 0.7 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-15 - 55 * Cos(sine / 7)) - rl.RotVelocity.Y / 75 + -Sin(sine / 7) / 2.5, Rad(90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 + 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2219
                LH.C0 = clerp(LH.C0, CF(-1* Player_Size, -0.925 + 0.5 * Cos(sine / 7) / 2* Player_Size, -0.7 * Cos(sine / 7) / 2* Player_Size) * angles(Rad(-15 + 55 * Cos(sine / 7)) + ll.RotVelocity.Y / 75 + Sin(sine / 7) / 2.5, Rad(-90 - 0.1 * Cos(sine / 7)), Rad(0)) * angles(Rad(0 - 0.1 * Cos(sine / 7)), Rad(0), Rad(0)), 0.3)

2220
            RW.C0 = clerp(RW.C0, CF(1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 30)* Player_Size, 0.34 * Cos(sine / 7* Player_Size)) * angles(Rad(125)  * Cos(sine / 7) , Rad(0), Rad(5) - ra.RotVelocity.Y / 75), 0.15)

2221
            LW.C0 = clerp(LW.C0, CF(-1.5* Player_Size, 0.5 + 0.05 * Sin(sine / 30)* Player_Size, -0.34 * Cos(sine / 7* Player_Size)) * angles(Rad(-125)  * Cos(sine / 7) , Rad(0) , Rad(-5) + la.RotVelocity.Y / 75), 0.15)

2222
            end

2223
            end

2224
        end

2225
    end

2226
    Music.SoundId = "rbxassetid://"..SONG

2227
    Music.Looped = true

2228
    Music.Pitch = 1

2229
    Music.Volume = 2.5

2230
    Music.Parent = tors

2231
    Music:Resume()

2232
    if 0 < #Effects then

2233
        for e = 1, #Effects do

2234
            if Effects[e] ~= nil then

2235
                local Thing = Effects[e]

2236
                if Thing ~= nil then

2237
                    local Part = Thing[1]

2238
                    local Mode = Thing[2]

2239
                    local Delay = Thing[3]

2240
                    local IncX = Thing[4]

2241
                    local IncY = Thing[5]

2242
                    local IncZ = Thing[6]

2243
                    if 1 >= Thing[1].Transparency then

2244
                        if Thing[2] == "Block1" then

2245
                            Thing[1].CFrame = Thing[1].CFrame * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50))

2246
                            local Mesh = Thing[1].Mesh

2247
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2248
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2249
                        elseif Thing[2] == "Block2" then

2250
                            Thing[1].CFrame = Thing[1].CFrame + Vector3.new(0, 0, 0)

2251
                            local Mesh = Thing[7]

2252
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2253
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2254
                        elseif Thing[2] == "Block3" then

2255
                            Thing[1].CFrame = Thing[1].CFrame * CFrame.fromEulerAnglesXYZ(math.random(-50, 50), math.random(-50, 50), math.random(-50, 50)) + Vector3.new(0, 0.15, 0)

2256
                            local Mesh = Thing[7]

2257
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2258
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2259
                        elseif Thing[2] == "Cylinder" then

2260
                            local Mesh = Thing[1].Mesh

2261
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2262
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2263
                        elseif Thing[2] == "Blood" then

2264
                            local Mesh = Thing[7]

2265
                            Thing[1].CFrame = Thing[1].CFrame * Vector3.new(0, 0.5, 0)

2266
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[4], Thing[5], Thing[6])

2267
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2268
                        elseif Thing[2] == "Elec" then                          local Mesh = Thing[1].Mesh

2269
                            Mesh.Scale = Mesh.Scale + Vector3.new(Thing[7], Thing[8], Thing[9])

2270
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2271
                        elseif Thing[2] == "Disappear" then

2272
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2273
                        elseif Thing[2] == "Shatter" then

2274
                            Thing[1].Transparency = Thing[1].Transparency + Thing[3]

2275
                            Thing[4] = Thing[4] * CFrame.new(0, Thing[7], 0)

2276
                            Thing[1].CFrame = Thing[4] * CFrame.fromEulerAnglesXYZ(Thing[6], 0, 0)

2277
                            Thing[6] = Thing[6] + Thing[5]

2278
                        end

2279
                    else

2280
                        Part.Parent = nil

2281
                        table.remove(Effects, e)

2282
                    end

2283
                end

2284
            end

2285
        end

2286
    end

2287
end

2288
-------------------------------------------------------

2289
--End Animations And Script--

2290-
-------------------------------------------------------
2290+
2291
2292
local player = game:GetService("Players").LocalPlayer

2293
local Fire = Instance.new("Fire", player.Character.Torso)

2294
Fire.Size = 20

2295
Fire.Color = Color3.new(1,90,1)

2296
Fire.SecondaryColor = Color3.new(1,1,90)
        

    


            


                                


        

            



                
    

        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!