bnjh

:():(, { 
	Title = ;
	Text = ;
	Icon = })
Duration = ;

  :() 
	.Loaded:()


  (Parent, ClassName, Name)
	 _,   (Parent:()) 
		 :(ClassName)  .Name == Name 
			 
		
	


  (Parent, ClassName)
	  = Parent:(ClassName)

	    Parent 
		Parent.ChildAdded:()
		 = Parent:(ClassName)
	

	 


  (Parent, ...)
	  = (Parent, ...)

	    Parent 
		Parent.ChildAdded:()
		 = (Parent, ...)
	

	 


 Fling = { }
 Aligns = { }
 Blacklist = { }
 Accessories = { }
 Attachments = { }

 Instancenew = .new

 taskwait = .wait
 taskspawn = .spawn
 taskdefer = .defer

 mathabs = .abs
 mathcos = .cos
 mathrandom = .random

 stringmatch = .match

 osclock = .clock

 tableinsert = .insert
 tableclear = .clear
 tablefind = .find

 CFramenew = .new
 CFrameAngles = .Angles
 CFrameidentity = .identity

 Vector3new = .new
 Vector3zero = .zero

 Sleep = CFrameidentity
 Velocity = (, , )
 Angular = 
 Linear = 

 Workspace = :()
 CurrentCamera = Workspace.CurrentCamera

 Players = :()

 LocalPlayer = Players.LocalPlayer
 Mouse = LocalPlayer:()

 PostSimulation = :().PostSimulation

 Character = LocalPlayer.Character
 CharacterClone = ()

 StarterGui = :()
 BindableEvent = ()

 UserInputService = :()
 UserInputType = .UserInputType

 MouseButton1 = UserInputType.MouseButton1
 Touch = UserInputType.Touch

 InputBegan = UserInputService.InputBegan:((Input, GameProcessed)
	 Type = Input.UserInputType
	
	  GameProcessed  ( Type == MouseButton1  Type == Touch ) 
		 Target = Mouse.Target

		 Target   Target.Anchored   Target:(CharacterClone)   Target:(Character)   (Fling, Target) 
			 Parent = Target.Parent

			 Parent:()  Parent ~= Character  Parent:() 
				 HumanoidRootPart = (Parent, , )  (Parent, , )  (Parent, , )

				 HumanoidRootPart   (Fling, HumanoidRootPart) 
					(Fling, HumanoidRootPart)
					
				
			

			(Fling, Target)
		
	
)

  (Name, Size)
	 Part = ()
	Part.Name = Name
	Part.Size = Size
	Part.Transparency = 
	Part.Parent = CharacterClone

	 Part


  (Name, Part0, Part1, C0, C1)
	 Motor6D = ()
	Motor6D.Name = Name
	Motor6D.Part0 = Part0
	Motor6D.Part1 = Part1
	Motor6D.C0 = C0
	Motor6D.C1 = C1
	Motor6D.Parent = Part0

	 Motor6D


  (Name, , Parent)
	 Attachment = ()
	Attachment.Name = Name
	Attachment.CFrame = 
	Attachment.Parent = Parent

	(Attachments, Attachment)
	 Attachment


 LimbSize = (, , )
 TorsoSize = (, , )

 Head = (, (, , ))
 Torso = (, TorsoSize)
 LeftArm = (, LimbSize)
 RightArm = (, LimbSize)
 LeftLeg = (, LimbSize)
 RightLeg = (, LimbSize)
 HumanoidRootPart = (, TorsoSize)

 Part = 

 Character 
	Part = (Character, , )  (Character, , )  (Character, , )  (Character, , )


 Part 
	HumanoidRootPart.CFrame = Part.CFrame

	 SpawnLocations = { }

	 _, SpawnLocation  (Workspace:()) 
		 SpawnLocation:() 
			(SpawnLocations, SpawnLocation)
		
	

	 Amount = # SpawnLocations

	 Amount >  
		 SpawnLocation = SpawnLocations[(, Amount)]
		HumanoidRootPart.CFrame = SpawnLocation.CFrame * (, SpawnLocation.Size.Y /  + , )
	
		HumanoidRootPart.CFrame = CFrameidentity
	


 face = ()
face.Name = 
face.Parent = Head

 AccessoryTable = { 
	{ Mesh = , Texture = ,  = Torso },
	{ Mesh = , Texture = ,  = RightArm,  = (, , ) },
	{ Mesh = , Texture = ,  = LeftArm,  = (, - , ) },
	{ Mesh = , Texture = ,  = RightLeg,  = (, - , ) },
	{ Mesh = , Texture = ,  = LeftLeg,  = (, , ) },
}

 _, Table  (AccessoryTable) 
	 (Table.Mesh) ~=  
		Table.Mesh = 
	
	 (Table.Texture) ~=  
		Table.Texture = 
	


(, Torso, RightArm, (, , , , , , , , , -, -, -), (-, , , , , , , , , -, -, -))
(, Torso, LeftArm, (-, , , -, -, -, , , , , , ), (, , , -, -, -, , , , , , ))
(, Torso, RightLeg, (, -, , , , , , , , -, -, -), (, , , , , , , , , -, -, -))
(, Torso, LeftLeg, (-, -, , -, -, -, , , , , , ), (-, , , -, -, -, , , , , , ))
(, Torso, Head, (, , , -, -, -, , , , , , ), (, -, , -, -, -, , , , , , ))
(, HumanoidRootPart, Torso, (, , , -, -, -, , , , , , ), (, , , -, -, -, , , , , , ))

(, (, , , , , , , , , , , ), Head)
(, (, , , , , , , , , , , ), Head)
(, (, , -, , , , , , , , , ), Head)
(, (, , , , , , , , , , , ), Head)
(, (, , , , , , , , , , , ), Torso)
(, (, , -, , , , , , , , , ), Torso)
(, (, , , , , , , , , , , ), Torso)
(, (-, , , , , , , , , , , ), Torso)
(, (, , , , , , , , , , , ), Torso)
(, (, -, -, , , , , , , , , ), Torso)
(, (, -, , , , , , , , , , ), Torso)
(, (, -, , , , , , , , , , ), Torso)
(, (, , , , , , , , , , , ), LeftArm)
(, (, -, , , , , , , , , , ), LeftArm)
(, (, , , , , , , , , , , ), RightArm)
(, (, -, , , , , , , , , , ), RightArm)
(, (, -, , , , , , , , , , ), LeftLeg)
(, (, -, , , , , , , , , , ), RightLeg)
(, (, , , , , , , , , , , ), HumanoidRootPart)

 Humanoid = (, CharacterClone)
(, Humanoid)

(, CharacterClone).Name = 

CharacterClone.PrimaryPart = Head
CharacterClone.Parent = Workspace

  ()
	 :() 
		(()
			 Handle = (, , )
			 Attachment = (Handle, )

			 Clone = :()

			 CloneHandle = (Clone, , )
			CloneHandle.Transparency = 
			CloneHandle:()

			 AccessoryWeld = ()
			AccessoryWeld.Name = 
			AccessoryWeld.Part0 = CloneHandle
			AccessoryWeld.C0 = Attachment.CFrame

			 Name = Attachment.Name

			 _, TableAttachment  (Attachments) 
				 TableAttachment.Name == Name 
					AccessoryWeld.Part1 = TableAttachment.Parent
					AccessoryWeld.C1 = TableAttachment.CFrame
				
			

			AccessoryWeld.Parent = CloneHandle
			Clone.Parent = CharacterClone

			(Accessories, Clone)

			 IsAMeshPart = CloneHandle:()
			 Mesh = IsAMeshPart  CloneHandle  (CloneHandle, )
			 Id = IsAMeshPart    

			 _, Table  (AccessoryTable) 
				  = Table.Instance

				  
					 (Mesh.MeshId, Table.Mesh)  (Mesh[Id], Table.Texture)   (Blacklist, ) 
						(Blacklist, )
						(Aligns, { Handle, , Table.CFrame  CFrameidentity })
						
					
				
			

			(Aligns, { Handle, CloneHandle, CFrameidentity })
		)
	 :() 
		(()
			()
			:()
		)
	


  (Character)
	 Character ~= CharacterClone 		
		PostSimulation:()

		 Backpack = LocalPlayer:()

		 Backpack 
			Backpack:()
		

		(Aligns)
		(Blacklist)

		 _, Accessory  (Accessories) 
			Accessory:()
		

		 CurrentCameraCFrame = CurrentCamera.CFrame

		LocalPlayer.Character = CharacterClone
		CurrentCamera.CameraSubject = CharacterClone.Head

		(()
			CurrentCamera:():()
			CurrentCamera.CFrame = CurrentCameraCFrame
		)

		 CharacterHumanoidRootPart = (Character, , )

		 Index, Value  (Fling) 
			 BasePart = 

			 (Value) ==   
				 Value:() 
					BasePart = Value
				 Value:() 
					 Model = Value.Parent

					 Model ~= Character  Model:() 
						BasePart = (Model, , )  (Model, , )  Model:()
					
				 Value:()  Value ~= Character 
					BasePart = (Value, , )  (Value, , )  Value:()
				
			

			 BasePart 
				 clock = ()

				 CharacterHumanoidRootPart  BasePart  () - clock <=   BasePart.AssemblyLinearVelocity.Magnitude <=  
					CharacterHumanoidRootPart.AssemblyAngularVelocity = Velocity
					CharacterHumanoidRootPart.AssemblyLinearVelocity = Velocity

					CharacterHumanoidRootPart.CFrame = BasePart.CFrame + (, - , )
					PostSimulation:()
				
			
		

		(Fling)

		 CharacterHumanoidRootPart 
			CharacterHumanoidRootPart.AssemblyAngularVelocity = Vector3zero
			CharacterHumanoidRootPart.AssemblyLinearVelocity = Vector3zero

			CharacterHumanoidRootPart.CFrame = (HumanoidRootPart.Position + ((- , ), , (- , )))
			PostSimulation:()
		

		Character:()

		 _,   (Character:()) 
			()
		

		Character.DescendantAdded:(DescendantAdded)
	


  (Part0, Part1, )
	 Part0.ReceiveAge ==    Part0.Anchored  # Part0:() ==  
		Part0.AssemblyAngularVelocity = (, Angular, )

		 Part1CFrame = Part1.CFrame
		 LinearVelocity = Part1.AssemblyLinearVelocity * Linear
		 Magnitude = LinearVelocity.Magnitude < Linear

		 Magnitude 
			 LookVector = Part1CFrame.LookVector * Linear
			Part0.AssemblyLinearVelocity = (LookVector.X, Linear, LookVector.Z)
		
			Part0.AssemblyLinearVelocity = (LinearVelocity.X, Linear, LinearVelocity.Z)
		

		Part0.CFrame = Part1CFrame * ( Magnitude  Sleep  CFrameidentity ) * 
	


 Character 
	(Character)


 Added = LocalPlayer.CharacterAdded:(CharacterAdded)

 Connection = :().PostSimulation:(()
	 osclock = ()
	 Axis =  * (osclock * )

	Sleep = (, Axis, )
	Angular = (osclock)
	Linear = 

	 _, Table  (Aligns) 
		(Table[], Table[], Table[])
	

	 sethiddenproperty 
		(LocalPlayer, , )
	

	StarterGui:(, BindableEvent) 
)

  ()
	CharacterClone:()


BindableEvent.Event:(Event)

CharacterClone:():(()
	  CharacterClone.Parent 
		Added:()
		Connection:()

		CharacterClone:()

		 BindableEvent 
			BindableEvent:()
		

		StarterGui:(, )
	
)

BindableEvent:():(Event)



 RNG = (()
     RNG = Random.();
     (min,max,int)
         int  RNG:(min,max)  RNG:(min,max)
    ;
)();
 S = ({},{__index = (s,i)  :(i) })
 CF = {
	N=.new;
	A=.Angles;
	fEA=.fromEulerAnglesXYZ;
}
 C3 = {
	N=.new;
	RGB=.fromRGB;
	HSV=(...) data={...}((data)==)  .(...)  .(...);;
}
 V3 = {
	N=.new;
	FNI=.FromNormalId;
	A=.FromAxis;
}
 M = {
	C=.cos;
	R=.rad;
	S=.sin;
	T=.tan;
	AT=.atan;
	AT2=.atan2;
	AS=.asin;
	AC=.acos;
	A=.abs;
	F=.floor;
	CE=.ceil;
	P=.pi;
	RNG=RNG;
	H=.huge;
	RRNG=(...)  .((...)) 
}
 R3 = Region3.new
 De = S.Debris
 WS = 
 Lght = S.Lighting
 RepS = S.ReplicatedStorage
 IN = .new
 Plrs = S.Players


 Plr = Plrs.LocalPlayer
(Plr)
 Char = Plr.Character
 Hum = Char:
(Hum  Hum.RigType==.HumanoidRigType.R6,)
 Head = Char.Head
 RArm = Char[]
 LArm = Char[]
 RLeg = Char[]
 LLeg = Char[]	
 Torso= Char.Torso
 Root = Char.HumanoidRootPart
 NeutralAnims = 
 Attack = 
 legAnims = 
 Mouse = Plr:()
 EffectFolder=.()
EffectFolder.Name=
EffectFolder.Parent=Char

 Movement = 
 Sine = ;
 Change = ;
 wsVal = 


 baseSound = ()
 (parent,id,pitch,volume,looped,effect,autoPlay)
	 Sound = baseSound:()
	Sound.SoundId = .. (id  )
	Sound.Pitch = pitch  
	Sound.Volume = volume  
	Sound.Looped = looped  
	(autoPlay)
		.(()
			 ()  Sound.IsLoaded
			Sound.Playing = autoPlay  
		)()
	
	( looped  effect)
		Sound.Stopped:(()
			Sound.Volume = 
			Sound:()
		)
	(effect)
		()
	
	Sound.Parent =parent  
	 Sound

 (parent,color,material,size,cframe,anchored,cancollide)
	 part = ()
	part[(color) ==     ] = color  C3.(,,)
	part.Material = material  .Material.SmoothPlastic
	part.TopSurface,part.BottomSurface=,
	part.Size = size  V3.(,,)
	part.CFrame = cframe  CF.(,,)
	part.CanCollide = cancollide  
	part.Anchored = anchored  
	part.Parent = parent
	 part


 (part0,part1,c0,c1)
	 weld = ()
	weld.Part0 = part0
	weld.Part1 = part1
	weld.C0 = c0  CF.()
	weld.C1 = c1  CF.()
	weld.Parent = part0
	 weld


 (parent,meshtype,meshid,textid,scale,offset)
	 part = ()
	part.MeshId = meshid  
	part.TextureId = textid  
	part.Scale = scale  V3.(,,)
	part.Offset = offset  V3.(,,)
	part.MeshType = meshtype  .MeshType.Sphere
	part.Parent = parent
	 part


 (id,pitch,volume,looped,effect,autoPlay,cf)
	 soundPart = (EffectFolder,C3.(,,),.Material.SmoothPlastic,V3.(,,),cf,,)
	soundPart.Transparency=
	 Sound = ()
	Sound.SoundId = .. (id  )
	Sound.Pitch = pitch  
	Sound.Volume = volume  
	Sound.Looped = looped  
	(autoPlay)
		.(()
			 ()  Sound.IsLoaded
			Sound.Playing = autoPlay  
		)()
	
	( looped  effect)
		Sound.Stopped:(()
			Sound.Volume = 
			soundPart:()
		)
	(effect)
		()
	
	Sound.Parent = soundPart
	 Sound


 (name,part0,part1,c0,c1,)
	 joint = (  )
	joint.Part0 = part0
	joint.Part1 = part1
	joint.C0 = c0  CF.()
	joint.C1 = c1  CF.()
	joint.Parent=part0
	joint.Name=name  part0....part1....joint.ClassName
	 joint


 (joint,c0,alpha,style,dir)
	(style==)
		joint.C0 = joint.C0:(c0,alpha)
	
		 info = TweenInfo.(alpha  ,style  .EasingStyle.Linear,dir  .EasingDirection.Out,,,)
		 tween = S.TweenService:(joint,info,{C0=c0})
		tween:();
		 tween;
	


 (instance,parent,properties)(properties.Parent) properties.Parent=parent ; new = (instance)(properties)  prop,val  , properties  (() new[prop]=val );;new.Parent=parent; new;

 (part)
	  (part)
		 n = 
		 clone = part:()
		
		clone.Transparency = 
		clone.BrickColor = BrickColor.()
		clone.Size = clone.Size + .(n, n, n)
		clone.Name = 
		clone.CFrame = part.CFrame
		clone.Anchored=
		clone.CanCollide=
		
		 (clone:()) 
			clone.Size = clone.Size + .(, n, n)
			clone.CFrame = part.CFrame * .(, n / , -n /)
		
		
		 (clone:()) 
			clone.Size = clone.Size + .(n, n, n)
			clone.CFrame = part.CFrame * .(-n / , n / , n / )
		
		clone.Parent = part
		
		 clone
	
	
	 hitbox = (part)
	 touchingParts = hitbox:()
	hitbox:()
	
	 (()
		 adjacent={}
		 _,v  , touchingParts  (v~=part) .(adjacent,v);
		 adjacent;
	)()



 DamageColor = BrickColor.new;
 MusicData = {Parent=Torso,ID=;Pitch=;Volume=;}
 God = 
 WalkSpeed = 

 Music = (MusicData.Parent,MusicData.ID,MusicData.Pitch,MusicData.Volume,,,)
Music.Name = 



 RJ = (,Root,Torso,CF.(),CF.())
 NK = (,Torso,Head,CF.(,,),CF.())
 LS = (,Torso,LArm,CF.(-,-,),CF.(,,))
 RS = (,Torso,RArm,CF.(,-,),CF.(,,))
 LH = (,Torso,LLeg,CF.(,,),CF.(,,))
 RH = (,Torso,RLeg,CF.(,,),CF.(,,))



 LSC0 = LS.C0
 RSC0 = RS.C0
 NKC0 = NK.C0
 LHC0 = LH.C0
 RHC0 = RH.C0
 RJC0 = RJ.C0



 ArtificialHB = (, )
ArtificialHB.Name = 

:()

 tf = 
 allowframeloss = 
 tossremainder = 
 lastframe = ()
 frame = /
ArtificialHB:()

:().Heartbeat:((s, p)
	tf = tf + s
	 tf >= frame 
		 allowframeloss 
			.Heartbeat:()
			lastframe = ()
		
			 i = , .(tf / frame) 
				ArtificialHB:()
			
			lastframe = ()
		
		 tossremainder 
			tf = 
		
			tf = tf - frame * .(tf / frame)
		
	
)

 (num)
	 num ==   num ==  
		ArtificialHB.Event:()
	
		 i = , num 
			ArtificialHB.Event:()
		
	



 _,v  , Hum:() 
	v:();


(.Destroy,Char:)
(.Destroy,Hum:)





 fromaxisangle = (x, y, z) 
	  y 
		x, y, z = x.x, x.y, x.z
	
	 m = (x * x + y * y + z * z) ^ 
	 m >  
		 si = .(m / ) / m
		 .(, , , si * x, si * y, si * z, .(m / ))
	
		 .()
	


 (elapsed,cframe,velocity,rotation,acceleration)
	 pos = cframe.p
	 matrix = cframe-pos
	 (elapsed*rotation)*matrix+pos+elapsed*velocity+elapsed*elapsed*acceleration


 (startPos,endPos,range,ignoreList)
	 ray = Ray.(startPos,(endPos-startPos).unit*range)
	 part,pos,norm = :(ray,ignoreList  {},,)
	 part,pos,norm,(pos  (startPos-pos).magnitude)


 (char)
	 char:  char:  char:  char:


 (data)
	 Size = data.Size  ;
	 Origin = data.Origin  .();
	 Velocity = data.Velocity  .(,,);
	 Gravity = data.Gravity  .Gravity;
	 Color = data.Color  .(,,);
	 Lifetime = data.Lifetime  ;
	 Material = data.Material  .Material.Glass;
	 ignore = data.Ignorelist  {Char};
	 Init = data.Init;
	 Update = data.Update;
	 HitFunc = data.Hit;
	 ShouldCollide = data.BeforeCollision;
	 DeleteOnHit =   data.DeleteOnHit;
	 ProjectilePart = data.Projectile  ;
	 Look = data.AimAtPos  ;
	 drop = ProjectilePart  (,Color,Material,.(Size,Size,Size),Origin,,)
	 StartTravel = ()
	 currCF = data.Origin
	( ProjectilePart)
		(drop,.MeshType.Sphere)
		drop.Parent=EffectFolder
	
	drop.Material = Material
	drop.Color = Color
	drop.CFrame=Origin
	 object=({Part=drop},{
		__newindex=(s,i,v)
			(i==) StartTravel = () data.Origin = currCF Origin=currCF data.Gravity = v Gravity=v
			(i==) StartTravel = () data.Origin = currCF Origin=currCF data.Velocity = v Velocity=v
			(i==) data.Lifetime = v Lifetime=v 
			(i==) data.Ignorelist = v ignore=v
			(i==) data.DeleteOnHit = v DeleteOnHit=v 
			
				(()
					drop[i]=v
				)
			
		;
		__index=data;
	})
	
	
	(Init)
		(drop)
	
	 startTick = ();
	.(()
		  
			 elapsed = ()-startTick
			 trElapsed = ()-StartTravel
			(elapsed>Lifetime)
				drop:();
				
			
			 newCF = (trElapsed,Origin,Velocity,.(),.(,-Gravity,))
			 nextCF = (trElapsed+,Origin,Velocity,.(),.(,-Gravity,))
			 dist = (drop.Position-newCF.p).magnitude
			 hit,pos,norm = (drop.Position,newCF.p,dist,ignore)
			currCF=newCF
			 doCollide = hit  ((hit.Parent)  hit.CanCollide)  ( ShouldCollide  (hit))
			(hit   doCollide) .(ignore,hit) 
			(Look)
				drop.CFrame = .(newCF.p,nextCF.p)
			
				drop.CFrame = .(newCF.p)
			
			(Update) (drop,object,elapsed) 
			(doCollide)
				(DeleteOnHit   HitFunc) drop:() 
				(HitFunc) ((hit,pos,norm,object,drop))   
			
			( drop.Parent)
				
			
			()
		
	)()
	 object
	
	
 (txt,timer,clr)
	(Head:  Head.Chattie:)
		Head.Chattie.Killchat.Value=
	(Head:)
		Head.Chattie:()
	
	 nig = V3.(,,)
	 clr = ((clr)==  clr.Color  (clr)==  clr  C3.(,,))
	 bg = (,Head,{
		Name=;
		Adornee=Head;
		LightInfluence=;
		Size=.(,,,);
	})
	 dismiss = (,bg,{
		Name=;
	})
	
	 text = (,bg,{
		BackgroundTransparency=;
		Size=.(,,,);
		Font=.Font.Fantasy;
		Text=txt;
		TextColor3=clr;
		TextStrokeColor3=C3.(,,);
		TextScaled=;
		TextTransparency=;
		TextStrokeTransparency=;
	})
	.(()
		 i = , , - 
			bg.StudsOffsetWorldSpace=nig:(nig+V3.(,,),EasingFunctions.(-i,,,,))
			(dismiss.Value)  
			()
		
		 start = ()
		nig=bg.StudsOffsetWorldSpace
		 ()  dismiss.Value  ()-start>=timer
		bg.Name=
		 i = , ,  
			bg.StudsOffsetWorldSpace=nig:(nig+V3.(,,),EasingFunctions.(i,,,))
			text.TextTransparency=i;
			text.TextStrokeTransparency=+i/;
			()
		
		bg:()
	)()


 (pos,txt,timer,clr)
	 nig = (pos)==  CF.(pos)  pos
	 part = (EffectFolder,clr,.Material.SmoothPlastic,V3.(,,),nig,,)
	part.Transparency=
	 bg = (,part,{
		Adornee=part;
		LightInfluence=;
		Size=.(,,,);
	})
	 text = (,bg,{
		BackgroundTransparency=;
		Size=.(,,,);
		Font=.Font.Fantasy;
		Text=txt;
		TextColor3=part.Color;
		TextStrokeColor3=C3.(,,);
		TextScaled=;
		TextTransparency=;
		TextStrokeTransparency=;
	})
	.(()
		 i = , , - 
			part.CFrame=nig:(nig+V3.(,,),EasingFunctions.(-i,,,,))
			text.TextTransparency=i;
			text.TextTransparency=text.TextTransparency-;
			text.TextStrokeTransparency=text.TextStrokeTransparency-;
			()
		
		 start = ()
		 ()  ()-start>=timer
		 endRot=M.(-,)
		 i = , ,  
			part.CFrame=(nig+V3.(,,)):(nig+V3.(,-,),EasingFunctions.(i,,,,))
			text.TextTransparency=i;
			text.TextTransparency=text.TextTransparency+;
			text.TextStrokeTransparency=text.TextStrokeTransparency+;
			()
		
		part:()
	)()


 (p,settings)
	 sh = ::()	
	 optionFolder = sh:
	 _,v  , optionFolder:() 
		(settings[v.Name])
			v.Value=settings[v.Name]
		
	
	 originVal;
	((settings.Origin)==)
		originVal=()
	((settings.Origin)==)
		originVal=()
	((settings.Origin)==)
		originVal=()
	
	(originVal)
		originVal.Name = 
		originVal.Value = settings.Origin
		originVal.Parent=optionFolder
	
	 parent = p.Character  p:  p:
	(parent)
		 nig = sh:();
		nig.Parent=parent
		nig.Disabled=
		S.Debris:(nig,(settings.Duration  )+)
	


 (settings)
	 _,p  , ::() 
		(p,settings)
	

 (object,properties,time,style,dir,repeats,reverse,)
	 info = TweenInfo.(time  ,style  .EasingStyle.Linear,dir  .EasingDirection.Out,repeats  ,reverse  ,  )
	 tween = S.TweenService:(object,info,properties)
	tween:()
	 tween;


  (Start,Finish,Alpha)
     Start + (Finish- Start) * Alpha

 (val,enum,def)
	 enum = [(enum)]
	 succ,err=(()  enum[val.Name] )
	( err)
		 val
	
		 def
	


 (val,,def)
	(()==)
		 ((val)==  val  def)
	(()==)
		 i,v  ,  
			((val)==v)
				 val
			
		
	
	 def


 FXInformation = {}
 (data)
	((data)==  data:)	data=(data)
	((data)==,)
	data.Parent=EffectFolder
	(data.BeamEffect)
		 (data)
	
	
	 Lifetime = data.Lifetime  ;
	 Color = data.Color  .(,,)
	 EndColor = data.EndColor
	 Size = data.Size  .(,,)
	 EndSize = data.EndSize
	 Transparency = data.Transparency  
	 EndTransparency = data.EndTransparency  
	 Material = data.Material  .Material.Neon;
	 Part = (data.RefPart)==  data.RefPart  (data.RefPart)==  FXFolder:(data.RefPart);
	 CF = data.CFrame  .(,,)
	 EndCF = data.EndCFrame  data.EndPos
	 Mesh = data.MeshData  data.Mesh  {MeshType=.MeshType.Brick}
	 Rotation = data.Rotation  {,,}
	 UpdateCF = data.UpdateCFrame;
	 Update = data.Update;
	
	 CSQ,SSQ,TSQ,CFQ;
	((Color)==) Color = Color.Color 
	((EndColor)==) EndColor = EndColor.Color 
	((Color)==)
		CSQ = Color
	((Color)==  (EndColor)==)
		CSQ = ColorSequence.(Color,EndColor)
	((Color)==)
		CSQ = ColorSequence.(Color)
	
		CSQ = ColorSequence.(.(,,))
	
	
	
	((Size)==  Size.Keypoints  (Size.Keypoints[].Value)==)
		SSQ = Size
	((Size)==  (EndSize)==)
		SSQ = Vector3Sequence.(Size,EndSize)
	((Size)==)
		SSQ = Vector3Sequence.(Size)
	
		SSQ = Vector3Sequence.(.(,,))
	
	
	((CF)==  CF.Keypoints  (CF.Keypoints[].Value)==)
		CFQ = CF
	((CF)==  (EndCF)==)
		CFQ = CFrameSequence.(CF,EndCF)
	((CF)==)
		CFQ = CFrameSequence.(CF)
	
		CFQ = CFrameSequence.(.(,,))
	
		
	((Transparency)==)
		TSQ = Transparency
	((Transparency)==  (EndTransparency)==)
		TSQ = NumberSequence.(Transparency,EndTransparency)
	((Transparency)==)
		TSQ = NumberSequence.(Transparency)
	
		TSQ = NumberSequence.(,)
	
	
	
	 part,mesh;
	( Part   Part:)
		part = .()
		mesh = .(,part)
	
		part=Part:();
		mesh=part:
	
	part.Color = CSQ.Keypoints[].Value
	part.Transparency = TSQ.Keypoints[].Value
	part.Size = ( mesh  SSQ.Keypoints[].Value  .(,,))
	part.Anchored = 
	part.CanCollide = 
	part.CFrame = CFQ.Keypoints[].Value
	part.Material = Material
	part.Locked = 
	part.Parent = EffectFolder
	(mesh)
		mesh.Scale = SSQ.Keypoints[].Value
		mesh.MeshType = Mesh.MeshType  Mesh.Type  .MeshType.Brick
		mesh.MeshId = Mesh.MeshId  Mesh.Id  
		mesh.TextureId = Mesh.TextureId  Mesh.Texture  
	
	::(part,Lifetime*)
	.(FXInformation,{
		Part=part;
		Mesh=mesh;
		Lifetime=Lifetime;
		Create=();
		ColorSeq=CSQ;
		SizeSeq=SSQ;
		TranSeq=TSQ;
		CFSeq=CFQ;
		ColorPoint=CSQ.Keypoints[];
		SizePoint=SSQ.Keypoints[];
		TranPoint=TSQ.Keypoints[];
		CFPoint=CFQ.Keypoints[];
		Rotation=Rotation;
		CurrRot=.();
		UpdateCF=((UpdateCF)==  UpdateCF  (UpdateCF)==  UpdateCF:  (UpdateCF)  );
		OnUpdate=((Update)==  Update  (Update)==  Update:  (Update)  )
	})


 (sequence,currentTime,lifeTime)
	 scale = currentTime/lifeTime
	 i = ,#sequence.Keypoints 
		 keyframe = sequence.Keypoints[i]
		 nframe = sequence.Keypoints[i+]
		( nframe  keyframe.Time>=scale  keyframe.Time<nframe.Time)
			 keyframe
		
	
	 sequence.Keypoints[];
;

.(()
	  
		()
		 queue={}
		 i,dat  , FXInformation 
			 part,mesh,lifetime,created,csq,ssq,tsq,cfq,rot,ucf,upd = 
																	dat.Part,
																	dat.Mesh,
																	dat.Lifetime,
																	dat.Create,
																	dat.ColorSeq,
																	dat.SizeSeq,
																	dat.TranSeq,
																	dat.CFSeq,
																	dat.Rotation,
																	dat.UpdateCF,
																	dat.OnUpdate;
			 current = ();
			 elapsed = ()-created
			 currentcpoint = (csq,elapsed,lifetime)
			 currentspoint = (ssq,elapsed,lifetime)
			 currenttpoint = (tsq,elapsed,lifetime)
			 currentcfpoint = (cfq,elapsed,lifetime)
			
			 currentcolor = currentcpoint.Value
			 currenttrans = currenttpoint.Value
			 currentsize = currentspoint.Value
			 currentcf = currentcfpoint.Value
			
			(currentcpoint~=dat.ColorPoint)
				(part,{Color=currentcolor},(currentcpoint.Time-dat.ColorPoint.Time)*lifetime)
				dat.ColorPoint=currentcpoint
			
			(currenttpoint~=dat.TranPoint)
				(part,{Transparency=currenttrans},(currenttpoint.Time-dat.TranPoint.Time)*lifetime)
				dat.TranPoint=currenttpoint
			
			(currentspoint~=dat.SizePoint)
				(mesh)
					(mesh,{Scale=currentsize},(currentspoint.Time-dat.SizePoint.Time)*lifetime)
				
					(part,{Size=currentsize},(currentspoint.Time-dat.SizePoint.Time)*lifetime)
				
				
				dat.SizePoint=currentspoint
			
			 newRot={,,}
			(rot==)
				dat.CurrRot = .(.(Random.():(,)),.(Random.():(,)),.(Random.():(,)))
			((rot)==)
				dat.CurrRot = dat.CurrRot*.(.(rot[]),.(rot[]),.(rot[]))
			
			(ucf  (ucf)==)
				part.CFrame=(dat)
			(#cfq.Keypoints==)
				part.CFrame=cfq.Keypoints[].Value:(cfq.Keypoints[].Value,elapsed/lifetime)*dat.CurrRot
			
				(currentcfpoint~=dat.CFPoint)
					(part,{=currentcf},(currentcfpoint.Time-dat.CFPoint.Time)*lifetime)
					dat.CFPoint=currentcfpoint
				
			
			((upd)==) (dat) 
			( part   part.Parent)
				.(queue,(i))
			
			(elapsed>=lifetime)
				part:()
			
		
		 _,v  , queue  FXInformation[(v)]=; 
	
)()

 (data) 
	 Parent = (data.Parent,,)
	 Color = (data.Color,{,},.(,,))
	 Width = (data.Width,,);
	 EndWidth = (data.EndWidth,,);
	 Length = (data.Length,,);
	 EndLength = (data.EndLength,,Length*);
	 Curve = (data.Curve,,);
	 EndCurve = (data.EndCurve,,Curve*);
	 SCFrame = (data.CFrame,,.(,,))
	 Lifetime = (data.Lifetime,,)
	 Offset = (data.Offset,,.())
	 Style = ((data.EasingStyle,,.EasingStyle.Quad),.EasingStyle,.EasingStyle.Quad)
	 Direction = ((data.EasingDirection,,.EasingDirection.Out),.EasingDirection,.EasingDirection.Out)
	 Delay = (data.Delay,,)
	 BeamProperties = (data.BeamProps,,{})
	 FadeAway = (data.Fades,,)
	 FadeStyle = ((data.FadeStyle,,.EasingStyle.Linear),.EasingStyle,.EasingStyle.Linear)
	 FadeDir = ((data.FadeDirection,,.EasingDirection.Out),.EasingDirection,.EasingDirection.Out)
	 CSQ;
	 TSQ;
	((Color)==)
		CSQ = Color
	((Color)==)
		CSQ = ColorSequence.(Color)
	((Color)==)
		CSQ = ColorSequence.(Color.Color)
	
		CSQ = ColorSequence.(.(,,))
	
	
	 P = (Parent,Color,.Material.SmoothPlastic,.(,,),SCFrame,,)
	P.Transparency = 
	 A0 = .()
	 A1 = .()
	A0.Position = .(,,Length)
	A1.Position = .(,,-Length)
	A0.Parent=P
	A1.Parent=P
	 Beam = .()
	Beam.Attachment0=A0
	Beam.Attachment1=A1
	Beam.FaceCamera=
	Beam.LightInfluence=BeamProperties.LightInfluence  
	Beam.LightEmission=BeamProperties.LightEmission  
	 i,v  , BeamProperties 
		(() Beam[i]=v )
	
	Beam.Color = CSQ
	Beam.CurveSize0 = Curve
	Beam.CurveSize1 = -Curve
	Beam.Width0=Width
	Beam.Width1=Width
	Beam.Parent=P
	 ti = {Lifetime,Style,Direction,,,Delay}
	(P,{ = SCFrame*Offset},(ti))
	(Beam,{Width0=EndWidth,Width1=EndWidth,CurveSize0=EndCurve,CurveSize1=-EndCurve},(ti))
	(A0,{Position=.(,,EndLength)},(ti))
	(A1,{Position=.(,,-EndLength)},(ti)).Completed:(() P:() )
	(FadeAway)
		 part = .()
		part.Transparency = Beam.Transparency.Keypoints[].Value  
		(part,{Transparency=},Lifetime,FadeStyle,FadeDir,,,Delay)
		 ()
			Beam.Transparency=NumberSequence.(part.Transparency)
		  P.Parent
	


 EffectInfo={}
 (data)
	 color = data.Color  .(,,);
	 transparency = data.Transparency  {,}
	 lifetime = data.Lifetime  
	 cframe = data.CFrame  .(,,)
	 acceleration = data.Acceleration  .(,,)
	 endpos = data.EndPos
	 rotation = data.Rotation  {,,}
	 meshData = data.Mesh  {Type=.MeshType.Brick}
	 size = data.Size  .(,,)
	 material = data.Material  .Material.Neon
	 setpart = (data.Part)==  FXFolder:((data.Part)):()  (data.Part)==  data.Part  
	 endSize = data.EndSize  size
	 reverse = data.Reverse  
	 sizeTween = data.TweenSize  EasingFunctions[data.TweenSize];
	 moveTween = data.TweenPos  EasingFunctions[data.TweenPos];
	 transTween = data.TweenTrans  EasingFunctions[data.TweenTrans];
	 accelTween = data.TweenAccel  EasingFunctions[data.TweenAccel];
	(endSize  (size)==) size={size,endSize} 
	((size)==) size={size,size}
	((transparency)==) transparency={transparency,transparency} 
	((color)==) color=color.Color 
	
	 PM;
	
	 part = setpart  (,color,material,.(,,),cframe,,)
	
	( part:   part:)
		 scale = size[]
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale,.(,,-scale.X/))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale,.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,.(scale.X/,,scale.Z/),.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,.(scale.X/,scale.Y/,scale.Z/),.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale/,.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale/,.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale*,.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale,.(,,))
		(meshData == )
			PM = (part,.MeshType.FileMesh,,,scale,.(,,))
		((meshData) ==   (meshData) == )
			 Type = meshData.MeshType  meshData.Type  .MeshType.Brick
			 ID = meshData.MeshId  meshData.Mesh  ;
			 Tex = meshData.TextureId  meshData.Texture  ;
			 Offset = meshData.Offset  .(,,)
			PM = (part,Type,ID,Tex,scale,Offset)
		( part:())
			PM = (part,.MeshType.Brick,,,scale)
		
			PM = part:()
		
	
	
	
	part.Material = material
	part.CFrame = cframe
	part.Color = color
	part.Anchored = 
	part.CanCollide = 
	part.Transparency = transparency[]
	part.Size = (PM  .(,,)  size[])
	part.Parent = EffectFolder
	
	 start = ()
	 t0 = ()
	 t01 = ()
	 lastTrans=;
	 lastSize=;
	 lastColor=;
	 info = {start,lifetime,t0,transTween,sizeTween,moveTween,accelTween,color,transparency,size,part,PM,rotation,acceleration,endpos,cframe,reverse,acceleration}
	.(EffectInfo,info)


.(()
	  
		()
		 i,v  , EffectInfo 
			 start,lifetime,t0,transTween,sizeTween,moveTween,accelTween,color,transparency,size,part,mesh,rotation,acceleration,endpos,cframe,reverse,startacc=(v)
			 elapsed = ()-start
			 left = elapsed/lifetime
			 dt = ()-t0
			t0 = ()
			(mesh)
				mesh.Scale = size[]:(size[],(sizeTween  (elapsed,,,lifetime)  left))
			
				part.Size = size[]:(size[],(sizeTween  (elapsed,,,lifetime)  left))
			
			part.Transparency = (transparency[],transparency[],(transTween  (elapsed,,,lifetime)  left))
			
			 newRot={,,}
			(rotation==)
				newRot={.(Random.():(,)),.(Random.():(,)),.(Random.():(,))}
			((rotation)==)
				 x,y,z=.(rotation[]),.(rotation[]),.(rotation[])
				(rotation[]==) x= 
				(rotation[]==) y= 
				(rotation[]==) z= 
				newRot={x,y,z}
			
			
			 accelMult=(accelTween  -(elapsed,,,lifetime)  )

			 accel=(acceleration*dt)
			(endpos)
				part.CFrame = cframe:(endpos,(moveTween  (elapsed,,,lifetime)  left))
			(accel  (accel.x~=  accel.y~=  accel.z~=))
				part.CFrame = part.CFrame*.((newRot))+(accel*accelMult)
			(newRot  (newRot[]~=  newRot[]~=  newRot[]~=))
				part.CFrame = part.CFrame*.((newRot))
			
			(reverse>)
				acceleration=acceleration-.(
					*startacc.x/(reverse/),
					*startacc.y/(reverse/),
					*startacc.z/(reverse/)
				)
			
			(elapsed>lifetime)
				part:()
				EffectInfo[i]=
			
				EffectInfo[i]={start,lifetime,t0,transTween,sizeTween,moveTween,accelTween,color,transparency,size,part,mesh,rotation,acceleration,endpos,cframe,reverse,startacc}
			
		
	
)()
 

 (char)
	 char:  char:  char:  char:


 (startPos,endPos,range,ignoreList)
	 ray = Ray.(startPos,(endPos-startPos).unit*range)
	 part,pos,norm = :(ray,ignoreList  {Char},,)
	 part,pos,norm,(pos  (startPos-pos).magnitude)


 (point,range,ignore)
     :((point-V3.(,,)*range/,point+V3.(,,)*range/),ignore,)




 (data)
	 Who = data.Who;
	 MinDam = data.MinimumDamage  ;
	 MaxDam = data.MaximumDamage  ;
	 MaxHP = data.MaxHP  ; 
	 DamageIsPercentage = data.PercentageDamage  
	
	 DB = data.Debounce  ;
	
	 CritData = data.Crit  {}
	 CritChance = CritData.Chance  ;
	 CritMultiplier = CritData.Multiplier  ;
	
	
	 OnHitFunc = data.OnHit
	 DeathFunction = data.OnDeath
	
	(Who,)	
	
	 Humanoid = Who:
	 Critical = M.(,,) <= CritChance
	 DoneDamage = M.(MinDam,MaxDam,) * (Critical  CritMultiplier  )
	
	 canHit = 
	(Humanoid)
		(canHit)
			 HitTorso = (Who)
			 player = S.Players:(Who)
			
			( player  player.UserId ~=   player.UserId ~= )
				(Humanoid.MaxHealth >= MaxHP  Humanoid.Health > )
					
					Humanoid.Health = ;
					Who:();
					(DeathFunction) (Who,Humanoid) 
				
					  c = .(,Hum)
					c.Name = 
					c.Value = Plr
					S.Debris:(c,)	
					(Who:  Humanoid.Health > )
						((Who.Head.CFrame * CF.(, , (Who.Head.Size.Z / )).p+V3.(,,)+V3.(M.(-,),,M.(-,))), DoneDamage, , DamageColor)
					
					 DoneDamage = DoneDamage*(DamageIsPercentage  Humanoid.MaxHealth/  )
					(Humanoid.Health >   Humanoid.Health-DoneDamage <= )  (DeathFunction) (Who,Humanoid)  
					Humanoid.Health = Humanoid.Health - DoneDamage
					(OnHitFunc)
						(Who,HitTorso)
					
				
			
		
			


 (where,range,func)
	 hit = {}
	 _,v  , (where,range,{Char}) 
		 hum = (v.Parent  v.Parent:)
		(hum   hit[hum])
			hit[hum] = 
			(v.Parent,hum)
		
	
	 hit


 (where,range,data)
	(where,range,(c,h)
		data.Who=c
		(data)
	)




 (velocity,decay)
	 (w,t)
		 BV = ()
		BV.P=
		BV.MaxForce=V3.(M.H,M.H,M.H)
		BV.Velocity=velocity  V3.(,,)+(Root.CFrame.lookVector*)
		BV.Parent=t
		S.Debris:(BV,decay  )
	


S.UserInputService.InputBegan:((io,gpe)
	(gpe  Attack)  
)


  
	()
	Sine=Sine+Change
	( Music   Music.Parent)
		 tp = (Music  Music.TimePosition)
		Music = (MusicData.Parent,MusicData.ID,MusicData.Pitch,MusicData.Volume,,,)
		Music.Name = 
		Music.TimePosition = tp
	
	Music.SoundId = ..MusicData.ID
	Music.Parent = MusicData.Parent
	Music.Pitch = MusicData.Pitch
	Music.Volume = MusicData.Volume
	
	
	 Hit,Pos = (Root.Position,Root.Position-V3.(,,),)
	 Walking = Hum.MoveDirection.magnitude>
	 State = ( Hit  Root.Velocity.Y<-     Hit  Root.Velocity.Y>    Walking    )
	( EffectFolder  EffectFolder.Parent~=Char)
		EffectFolder=.()
		EffectFolder.Name=
		EffectFolder.Parent=Char
	
	
	
	
	 FwdDir = (Walking  Hum.MoveDirection*Root.CFrame.lookVector  V3.())
	 RigDir = (Walking  Hum.MoveDirection*Root.CFrame.rightVector  V3.())
	 Vec = {
		X=RigDir.X+RigDir.Z,
		Z=FwdDir.X+FwdDir.Z
	};
	 Divide = 
	(Vec.Z<)
		Divide=.(-(*Vec.Z),,)
	
	Vec.Z = Vec.Z/Divide
	Vec.X = Vec.X/Divide
	Hum.WalkSpeed = WalkSpeed/Divide
	 Value = Movement/
	(legAnims)
		(State==)
			Change=
		(State==)
			Change=
			( NeutralAnims)

			
		(State==  State==)
			Change=
		
	
	(NeutralAnims)	
		(State == )
		  	 Alpha = 
			(NK,CF.(,,-)*CF.(M.(- +  * M.(Sine/)),M.(),M.()),Alpha,)
		  	(LS,CF.(-,- -  * M.(Sine/),-)*CF.(M.( -  * M.(Sine/)),M.(),M.(-)),Alpha,)
		  	(LH,CF.(-,- -  * M.(Sine/),-)*CF.(M.( +  * M.(Sine/)),M.(),M.()),Alpha,)
		  	(RJ,CF.(, +  * M.(Sine/),)*CF.(M.(-),M.(),M.()),Alpha,)
		  	(RH,CF.(,- -  * M.(Sine/),-)*CF.(M.( +   * M.(Sine/)),M.(-),M.()),Alpha,)
		  	(RS,CF.(,- -  * M.(Sine/),-)*CF.(M.( -  * M.(Sine/)),M.(-),M.()),Alpha,)


		(State == )
			 Alpha = 
			

			(NK,CF.(,,)*CF.(M.( +  * M.(Sine/)),M.(),M.()),Alpha,)
		  	(LS,CF.(M.(-(Sine*)),M.(),M.())*CF.(-,-,)*CF.(M.(),M.(),M.()),Alpha,)
		  	(LH,CF.(M.(-(Sine*)),M.(),M.())*CF.(-,-,)*CF.(M.(),M.(),M.()),Alpha,)
		  	(RJ,CF.( -  * M.(Sine/), +  * M.(Sine/),)*CF.(M.(- +  * M.(Sine/)),M.(),M.()),Alpha,)
		  	(RH,CF.(M.(-(Sine*) + ),M.(),M.())*CF.(,-,)*CF.(M.(),M.(),M.()),Alpha,)
		  	(RS,CF.(M.(-(Sine*) + ),M.(),M.())*CF.(,-,)*CF.(M.(),M.(),M.()),Alpha,)
	  	
		(State == )
			 idk = .(.(Root.Velocity.Y/,-M.()),M.())
			(NK,CF.(,,)*CF.(M.(),M.(),M.()),,)
		  	(LS,CF.(-,-,-)*CF.(M.(-),M.(),M.()),,)
		  	(LH,CF.(-,-,)*CF.(M.(-),M.(),M.()),,)
		  	(RJ,CF.(,,)*CF.(M.(),M.(),M.()),,)
		  	(RH,CF.(,-,)*CF.(M.(-),M.(),M.()),,)
		  	(RS,CF.(,-,-)*CF.(M.(-),M.(),M.()),,)
		(State == )
			 idk = .(.(Root.Velocity.Y/,-M.()),M.())
			(NK,CF.(,,-)*CF.(M.(-),M.(),M.()),,)
		  	(LS,CF.(-,-,-)*CF.(M.(),M.(),M.()),,)
		  	(LH,CF.(-,-,-)*CF.(M.(),M.(),M.()),,)
		  	(RJ,CF.(,,-)*CF.(M.(-),M.(),M.()),,)
		  	(RH,CF.(,-,-)*CF.(M.(),M.(),M.()),,)
		  	(RS,CF.(,-,-)*CF.(M.(),M.(),M.()),,)