btools Gojo

 Players = :()
 RunService = :()

 player = Players.LocalPlayer
 char = player.Character  player.CharacterAdded:()
 rootPart = char:()


 tool

 _, v  player:() 
	 v.Name ==  
		tool = v.Parent
	


 _, v  .ReplicatedStorage:() 
	 v.Name ==  
		tool = v.Parent
	


 remote = tool
	 tool:()
	 tool.SyncAPI:()

  (args)
	 remote 
		remote:((args))
	


  (part, boolean)
	({
		,
		{
			{
				Part = part,
				CanCollide = boolean
			}
		}
	})


  (cf, parent)
	({
		,
		,
		cf,
		parent
	})


  (part, size, cf)
	({
		,
		{
			{
				Part = part,
				 = cf,
				Size = size
			}
		}
	})


  (part)
	({
		,
		{
			{
				Part = part
			}
		}
	})


  (part, meshid)
	({
		,
		{
			{
				Part = part,
				MeshId =  .. meshid
			}
		}
	})


  (part, name)
	({
		,
		{ part },
		name
	})


  (part, boolean)
	({
		,
		{ part },
		boolean
	})


  (part, transparency)
	({
		,
		{
			{
				Part = part,
				Transparency = transparency
			}
		}
	})


  (part, color)
	({
		,
		{
			{
				Part = part,
				Color = color,
				UnionColoring = 
			}
		}
	})



 char:() 
	(()
		(char[], )
		(char[], )
		(char[], )
		(char[], )
		(char[], )
		(char[], )
	)

	
	 partNames = {
		,
		,
		,
		,
		,
		
	}

	 _, name  (partNames) 
		(
			rootPart.CFrame * .(, , ),
			char.Torso
		)

		 newPart = char.Torso:(, )

		 newPart 
			(newPart, )

			(
				newPart,
				.(, , ),
				rootPart.CFrame * .(, , )
			)

			(newPart, name)
		
	

	
	(()
		 head = char.Torso:()
		 torso = char.Torso:()

		(head)
		(head, )

		(torso)
		(torso, )

		 _, limbName  ({
			,
			,
			,
			
		}) 
			 limb = char.Torso:(limbName)

			(limb)
			(limb, )
		

		
		(head, .(, , ))
		(torso, .(, , ))

		(
			char.Torso:(),
			.(, , )
		)

		(
			char.Torso:(),
			.(, , )
		)

		(
			char.Torso:(),
			.(, , )
		)

		(
			char.Torso:(),
			.(, , )
		)

		
		 _, name  (partNames) 
			 part = char.Torso:(name)

			 part 
				(part, )
			
		
	)

	
	 animTick = 

	RunService.RenderStepped:((dt)
		(()
			 rightArmFE = char.Torso:()
			 leftArmFE = char.Torso:()
			 leftLegFE = char.Torso:()
			 rightLegFE = char.Torso:()
			 headFE = char.Torso:()
			 torsoFE = char.Torso:()

			  (fePart, realPart, targetCF)
				 fePart  realPart 
					 goalCF = targetCF  realPart.CFrame
					 lerpedCF = fePart.CFrame:(goalCF, )

					(
						fePart,
						.(, , ),
						lerpedCF
					)
				
			

			 speed = rootPart.AssemblyLinearVelocity.Magnitude
			 isMoving = speed > 

			  isMoving 
				animTick += dt * 

				 bob = .(animTick) * 

				(
					rightArmFE,
					char[],
					char[].CFrame * .(, bob, )
				)

				(
					leftArmFE,
					char[],
					char[].CFrame * .(, -bob, )
				)

				(
					leftLegFE,
					char[],
					char[].CFrame
				)

				(
					rightLegFE,
					char[],
					char[].CFrame
				)

				(
					headFE,
					char[],
					char[].CFrame * .(, bob * , )
				)

				(
					torsoFE,
					char[],
					char[].CFrame * .(, bob, )
				)
			
				animTick += dt * 

				 swing = .(animTick) * 

				(
					rightArmFE,
					char[],
					char[].CFrame * .(swing, , )
				)

				(
					leftArmFE,
					char[],
					char[].CFrame * .(-swing, , )
				)

				(
					leftLegFE,
					char[],
					char[].CFrame * .(swing, , )
				)

				(
					rightLegFE,
					char[],
					char[].CFrame * .(-swing, , )
				)

				(
					headFE,
					char[]
				)

				(
					torsoFE,
					char[]
				)
			
		)
	)









  (filename, url)
	 success, data = (()
		 :(url)
	)

	 success  (data) ==   #data >  
		(filename, data)
		(, filename)
	
		(, filename)
	


  () 
	(, )


(, )
(, )
(, )
(, )
(, )




 Players = :()
 RunService = :()
 TweenService = :()
 Debris = :()
 Lighting = :()
 ReplicatedStorage = :()

 player = Players.LocalPlayer
 playerGui = player:()




  ()
	 char = player.Character
	 char 
		 bt = char:()
		 bt  bt:() 
			 bt.SyncAPI
		
	
	 _, v  (player:()) 
		 v.Name ==    v 
	
	 _, v  (ReplicatedStorage:()) 
		 v.Name ==    v 
	
	 


  (args)
	 api = ()
	 api 
		(()
			api:((args))
		)
	


  (shape, cf, parent)
	({
		,
		shape  ,
		cf,
		parent  
	})


  (part, size, cf)
	({
		,
		{{Part = part,  = cf, Size = size}}
	})


  (part, bool)
	({
		,
		{{Part = part, CanCollide = bool}}
	})


  (part, col)
	({
		,
		{{Part = part, Color = col, UnionColoring = }}
	})


  (part, name)
	({, {part}, name})


  (part, bool)
	({, {part}, bool})


  (part, t)
	({
		,
		{{Part = part, Transparency = t}}
	})


  (part, anchored)
	  part   part.Parent   
	 api = ()
	  api   
	 endpoint = api:()  api

	(()
		endpoint:(, {part}, )
	)
	.()
	(()
		endpoint:(, {
			{
				Part = part,
				Anchored = anchored
			}
		})
	)


  (...)
	 parts = {...}
	 #parts ==    

	 api = ()
	  api   
	 endpoint = api:()  api

	 _, part  (parts) 
		 part  part.Parent 
			(()
				endpoint:(, {part})
			)
		
	



  (position, radius)
	 api = ()
	  api   
	 endpoint = api:()  api

	 parts = :(position, radius)
	 _, p  (parts) 
		 model = p.Parent
		 model:()  model:()  model ~= player.Character 
			 head = model:()
			 head 
				.(()
					(()
						endpoint:(, {head})
					)
				)
			
		
	


  (cf, size, color, name)
	 oldParts = {}
	 _, p  (:()) 
		 p:() 
			oldParts[p] = 
		
	

	(, cf, )

	 part = 
	 i = ,  
		 _, p  (:()) 
			 p:()   oldParts[p] 
				part = p
				
			
		
		 part   
		.()
	

	  part 
		()
		 
	

	(part, name  )
	(part, )
	(part, size, cf)
	(part, color)
	(part, )

	 part





 EasingStyleMap = {
	[.PoseEasingStyle.Linear]   = .EasingStyle.Linear,
	[.PoseEasingStyle.Bounce]   = .EasingStyle.Bounce,
	[.PoseEasingStyle.Cubic]    = .EasingStyle.Cubic,
	[.PoseEasingStyle.Elastic]  = .EasingStyle.Elastic,
	[.PoseEasingStyle.Constant] = .EasingStyle.Linear,
}
 EasingDirectionMap = {
	[.PoseEasingDirection.In]    = .EasingDirection.In,
	[.PoseEasingDirection.Out]   = .EasingDirection.Out,
	[.PoseEasingDirection.InOut] = .EasingDirection.InOut,
}

  (Model, KeyframeSequence, SpeedMult)
	SpeedMult = SpeedMult  
	 keyframes = {}
	 _, kf  (KeyframeSequence:()) 
		.(keyframes, {Time = kf.Time, KF = kf})
	
	.(keyframes, (a, b)  a.Time < b.Time )
	 #keyframes ==     

	 jointData = {}
	 motorMap, boneMap = {}, {}

	  (pose)
		 name = pose.Name
		 motorMap[name]   motorMap[name],  
		 boneMap[name]   boneMap[name],  
		 _, v  (Model:()) 
			 v:()  v.Part1  v.Part1.Name == name 
				motorMap[name] = v
				 v, 
			 v:()  v.Name == name 
				boneMap[name] = v
				 v, 
			
		
		 , 
	

	 _, entry  (keyframes) 
		 _, pose  (entry.KF:()) 
			 pose:()  pose.Weight >  
				 joint, jtype = (pose)
				 joint 
					  jointData[pose.Name]  jointData[pose.Name] = {} 
					.(jointData[pose.Name], {
						time = entry.Time,
						cframe = pose.CFrame,
						style = pose.EasingStyle,
						dir = pose.EasingDirection,
						joint = joint,
						jtype = jtype
					})
				
			
		
	

	 totalLength = keyframes[#keyframes].Time / SpeedMult
	 isPlaying = 
	 startTime = .()
	 connection

	connection = RunService.Heartbeat:(()
		  isPlaying   Model   Model.Parent 
			 connection  connection:() 
			
		
		 elapsed = (.() - startTime) * SpeedMult
		 timePos = elapsed % totalLength

		 _, poses  (jointData) 
			 #poses <    
			 lastPose, nextPose = poses[], poses[]
			 i = , #poses -  
				 timePos >= poses[i].time  timePos < poses[i + ].time 
					lastPose = poses[i]
					nextPose = poses[i + ]
					
				
			
			 timePos >= poses[#poses].time 
				lastPose = poses[#poses]
				nextPose = poses[#poses]
			

			 alpha = 
			 nextPose.time > lastPose.time 
				alpha = (timePos - lastPose.time) / (nextPose.time - lastPose.time)
			
			 style = EasingStyleMap[nextPose.style]  .EasingStyle.Linear
			 dir = EasingDirectionMap[nextPose.dir]  .EasingDirection.InOut
			 eased = TweenService:(alpha, style, dir)
			lastPose.joint.Transform = lastPose.cframe:(nextPose.cframe, eased)
		
	)

	 {
		Length = totalLength,
		Stop = ()
			isPlaying = 
			 connection  connection:() 
		,
		Play = ()
			startTime = .()
		
	}





 asset = :(())[]
asset.Parent = ReplicatedStorage
 Anims = asset:()
 Effects = asset:()




 introTool = .()
introTool.Name = 
introTool.RequiresHandle = 
introTool.Parent = player:()

 originalLighting = {}
 _, v  (Lighting:()) 
	 v:()  v:()  v:() 
		originalLighting[v.ClassName] = v:()
	

 originalClockTime = Lighting.ClockTime
 originalBrightness = Lighting.Brightness
 originalAmbient = Lighting.Ambient

introTool.Activated:(()
	introTool:()

	 char = player.Character  player.CharacterAdded:()
	 humanoid = char:()
	 root = char:()

	 originalAnimator = humanoid:()
	 originalAnimator  originalAnimator:() 

	 originalSpeed = humanoid.WalkSpeed
	 originalHipHeight = humanoid.HipHeight
	humanoid.WalkSpeed = 

	 keyframe = Anims:()
	  keyframe 
		()
		
	

	 sound = .()
	sound.SoundId = ()
	sound.Volume = 
	sound.Parent = 
	sound:()

	 controller = (char, keyframe, )
	 controller  controller.() 

	TweenService:(humanoid, TweenInfo.(, .EasingStyle.Quad), {
		HipHeight = originalHipHeight + 
	}):()

	 _, v  (Lighting:())  v:() 
	 Bloom = .(, Lighting)
	 Blur = .(, Lighting)
	 ColorCor = .(, Lighting)
	 SunRays = .(, Lighting)
	 Sky = .(, Lighting)
	 Atm = .(, Lighting)

	Bloom.Intensity = 
	Bloom.Size = 
	Bloom.Threshold = 
	Blur.Size = 
	ColorCor.Brightness = 
	ColorCor.Contrast = 
	ColorCor.Saturation = -
	ColorCor.TintColor = .(, , )
	SunRays.Intensity = 
	SunRays.Spread = 
	Sky.SkyboxBk = 
	Sky.SkyboxDn = 
	Sky.SkyboxFt = 
	Sky.SkyboxLf = 
	Sky.SkyboxRt = 
	Sky.SkyboxUp = 
	Sky.SunAngularSize = 
	Lighting.Ambient = .(, , )
	Lighting.Brightness = 
	Lighting.ClockTime = 
	Lighting.ExposureCompensation = 
	Atm.Density = 
	Atm.Offset = 
	Atm.Color = .(, , )
	Atm.Decay = .(, , )
	Atm.Glare = 
	Atm.Haze = 

	 Gui = .(, playerGui)
	Gui.IgnoreGuiInset = 
	 ShadowFrame = .(, Gui)
	ShadowFrame.AnchorPoint = .(, )
	ShadowFrame.Position = .(, , , )
	ShadowFrame.Size = .(, , , )
	ShadowFrame.BackgroundTransparency = 
	ShadowFrame.Image = 
	ShadowFrame.ImageTransparency = 
	ShadowFrame.ZIndex = 

	sound.Ended:()
	 controller  controller.() 
	TweenService:(humanoid, TweenInfo.(, .EasingStyle.Quad), {
		HipHeight = originalHipHeight
	}):()
	humanoid.WalkSpeed = originalSpeed

	 _, v  (Lighting:())  v:() 
	 _, original  (originalLighting) 
		original:().Parent = Lighting
	
	Lighting.ClockTime = originalClockTime
	Lighting.Brightness = originalBrightness
	Lighting.Ambient = originalAmbient

	 humanoid  humanoid.Parent 
		.(, humanoid)
	

	.()
	()
)




 ()

	
	 hpTool = .()
	hpTool.Name = 
	hpTool.RequiresHandle = 
	hpTool.Parent = player.Backpack

	hpTool.Activated:(()
		 char = player.Character
		  char   
		 hum = char:()
		 root = char:()

		 originalSpeed = hum.WalkSpeed
		 originalAnimator = hum:()
		 originalAnimator  originalAnimator.Parent =  
		hum.WalkSpeed = 

		 sound = .()
		sound.SoundId = ()
		sound.Volume = 
		sound.Parent = 
		sound:()

		 purpleAnim = Anims:()
		 animPlayer = purpleAnim  (char, purpleAnim, )
		 animPlayer  animPlayer.() 

		 blueOrb = (root.CFrame * .(-, , ), .(, , ), .(, , ), )
		 blueConn
		 blueOrb 
			blueConn = RunService.Heartbeat:(()
				  blueOrb   blueOrb.Parent 
					 blueConn  blueConn:() 
					
				
				(blueOrb, .(, , ), root.CFrame * .(-, , ))
			)
		

		.()

		 redOrb = (root.CFrame * .(, , ), .(, , ), .(, , ), )
		 redConn
		 redOrb 
			redConn = RunService.Heartbeat:(()
				  redOrb   redOrb.Parent 
					 redConn  redConn:() 
					
				
				(redOrb, .(, , ), root.CFrame * .(, , ))
			)
		

		.()

		 blueOrb  redOrb 
			 blueConn  blueConn:() 
			 redConn  redConn:() 

			 start = .()
			 mergeConn
			mergeConn = RunService.Heartbeat:(()
				 a = .((.() - start) / , , )
				 blueOrb  blueOrb.Parent 
					(blueOrb, .(, , ), root.CFrame * .(- +  * a, , ))
				
				 redOrb  redOrb.Parent 
					(redOrb, .(, , ), root.CFrame * .( -  * a, , ))
				
				 a >=   mergeConn:() 
			)
			.()
		

		 blueConn  blueConn:() 
		 redConn  redConn:() 
		 blueOrb  (blueOrb) 
		 redOrb  (redOrb) 

		
		 purple = (root.CFrame * .(, , -), .(, , ), .(, , ), )
		 purple 
			 look = root.CFrame.LookVector
			 current = root.CFrame * .(, , -)
			 startT = .()
			 alreadyUnanchored = {}

			 moveConn
			moveConn = RunService.Heartbeat:(()
				 .() - startT >    purple   purple.Parent 
					 moveConn  moveConn:() 
					
				

				current = current + look *  * 
				(purple, .(, , ), current)

				
				(current.Position, )

				
				 pos = current.Position
				 _, part  (:()) 
					 part:()
						 part ~= purple
						 part.Anchored
						  alreadyUnanchored[part]
						  part:(player.Character) 

						 (part.Position - pos).Magnitude <  
							(part, )
							alreadyUnanchored[part] = 
						
					
				
			)

			.(, ()
				 purple  (purple) 
			)
		

		.()
		 animPlayer  animPlayer.() 
		 originalAnimator  originalAnimator.Parent = hum 
		hum.WalkSpeed = originalSpeed
	)

	
 upTool = .()
upTool.Name = 
upTool.RequiresHandle = 
upTool.Parent = player.Backpack

upTool.Activated:(()
	 char = player.Character
	  char   
	 hum = char:()
	 root = char:()

	 originalSpeed = hum.WalkSpeed
	 originalHip = hum.HipHeight
	 originalAnimator = hum:()
	 originalAnimator  originalAnimator.Parent =  
	hum.WalkSpeed = 

	 sound = .()
	sound.SoundId = ()
	sound.Volume = 
	sound.Parent = 
	sound:()

	 upAnim = Anims:()
	 animPlayer = upAnim  (char, upAnim, )
	 animPlayer  animPlayer.() 

	
	 blue = (root.CFrame * .(, , -), .(, , ), .(, , ), )
	 orbitStart = .()
	 orbitConn
	 blue 
		orbitConn = RunService.Heartbeat:(()
			  blue   blue.Parent 
				 orbitConn  orbitConn:() 
				
			
			 t = .() - orbitStart
			 angle = t * 
			 offset = .(.(angle) * , , .(angle) * )
			(blue, .(, , ), root.CFrame * .(offset) * .(, angle * , ))
		)
	

	.()

	
	 red = (root.CFrame * .(, , -), .(, , ), .(, , ), )
	 red 
		 redStart = .()
		 redConn
		redConn = RunService.Heartbeat:(()
			  red   red.Parent 
				 redConn  redConn:() 
				
			
			 a = .((.() - redStart) / , , )
			 height =  +  * a
			(red, .(, , ), root.CFrame * .(, height, -))
			 a >=   redConn:() 
		)
	

	.()
	TweenService:(hum, TweenInfo.(, .EasingStyle.Quad), {HipHeight = originalHip + }):()

	.()
	 orbitConn  orbitConn:() 

	
	 blue  red 
		 start = .()
		 mergeConn
		mergeConn = RunService.Heartbeat:(()
			 a = .((.() - start) / , , )
			 blue  blue.Parent 
				(blue, .(, , ), root.CFrame * .( -  * a, , ))
			
			 red  red.Parent 
				(red, .(, , ), root.CFrame * .(- +  * a, , ))
			
			 a >=   mergeConn:() 
		)
		.()
	

	 blue  (blue) 
	 red  (red) 

	
	 startCF = root.CFrame * .(, , -)
	 purple = (startCF, .(, , ), .(, , ), )
	
	 purple 
		 look = root.CFrame.LookVector
		 current = startCF
		 startT = .()

		 moveConn
		moveConn = RunService.Heartbeat:(()
			 .() - startT >    purple   purple.Parent 
				 moveConn  moveConn:() 
				
			

			current = current + look *  * 
			(purple, .(, , ), current)

			
			(current.Position, )
		)

		.(, ()
			
			 explodePos = current
			 purple  (purple) 

			 shockwave = (explodePos, .(, , ), .(, , ), )
			 shockwave 
				(() (shockwave, ) )

				 swStart = .()
				 swConn
				swConn = RunService.Heartbeat:(()
					 a = .((.() - swStart) / , , )
					 size =  +  * a
					(shockwave, .(size, size * , size), explodePos)
					(() (shockwave,  + a * ) )

					 a >=  
						swConn:()
						(shockwave)
					
				)
			
		)
	

	.()

	 animPlayer  animPlayer.() 
	 originalAnimator  originalAnimator.Parent = hum 
	hum.WalkSpeed = originalSpeed
	hum.HipHeight = originalHip
)

	
	 ipTool = .()
	ipTool.Name = 
	ipTool.RequiresHandle = 
	ipTool.Parent = player.Backpack

	ipTool.Activated:(()
		 char = player.Character
		  char   
		 hum = char:()
		 root = char:()

		 originalSpeed = hum.WalkSpeed
		 originalAnimator = hum:()
		 originalAnimator  originalAnimator.Parent =  
		hum.WalkSpeed = 

		 sound = .()
		sound.SoundId = ()
		sound.Volume = 
		sound.Parent = 
		sound:()

		 ipAnim = Anims:()
		 animPlayer = ipAnim  (char, ipAnim, )
		 animPlayer  animPlayer.() 

		.()

		
		 purple = (root.CFrame * .(, , ), .(, , ), .(, , ), )
		 purple 
			 look = root.CFrame.LookVector
			 current = root.CFrame * .(, , )
			 startT = .()
			 alreadyUnanchored = {}

			 moveConn
			moveConn = RunService.Heartbeat:(()
				 .() - startT >    purple   purple.Parent 
					 moveConn  moveConn:() 
					
				

				current = current + look *  * 
				(purple, .(, , ), current)

				
				(current.Position, )

				
				 pos = current.Position
				 _, part  (:()) 
					 part:()
						 part ~= purple
						 part.Anchored
						  alreadyUnanchored[part]
						  part:(player.Character) 

						 (part.Position - pos).Magnitude <  
							(part, )
							alreadyUnanchored[part] = 
						
					
				
			)

			.(, ()
				 purple  (purple) 
			)
		

		.()
		 animPlayer  animPlayer.() 
		 originalAnimator  originalAnimator.Parent = hum 
		hum.WalkSpeed = originalSpeed
	)

	
	 ivTool = .()
	ivTool.Name = 
	ivTool.RequiresHandle = 
	ivTool.Parent = player.Backpack

	 domainSound, breakSound
	 loaded = 

	  ()
		 loaded   
		domainSound = .()
		domainSound.SoundId = ()
		domainSound.Volume = 
		domainSound.Parent = 

		breakSound = .()
		breakSound.SoundId = 
		breakSound.Volume = 
		breakSound.Parent = 
		loaded = 
	

	ivTool.Activated:(()
		()

		 char = player.Character
		  char   
		 humanoid = char:()
		 root = char:()

		 originalSpeed = humanoid.WalkSpeed
		 originalCFrame = root.CFrame
		 originalAnimator = humanoid:()
		 originalAnimator  originalAnimator.Parent =  
		humanoid.WalkSpeed = 

		 keyframeSeq = Anims:()
		 animPlayer = keyframeSeq  (char, keyframeSeq, )
		 animPlayer  animPlayer.() 

		domainSound:()
		domainSound:()

		 oldClock = Lighting.ClockTime
		 oldBright = Lighting.Brightness
		 oldAmbient = Lighting.Ambient
		 oldOutdoor = Lighting.OutdoorAmbient

		.()
		 animPlayer  animPlayer.() 

		 domainCenter = root.CFrame
		 domainPart = (domainCenter, .(, , ), .(, , ), )

		 domainPart 
			(() (domainPart, ) )

			 expandStart = .()
			 expandDuration = 
			 maxSize = 

			 expandConn
			expandConn = RunService.Heartbeat:(()
				 alpha = .((.() - expandStart) / expandDuration, , )
				 size =  + (maxSize - ) * alpha
				(domainPart, .(size, size, size), domainCenter)
				 alpha >=   expandConn:() 
			)
		

		TweenService:(Lighting, TweenInfo.(, .EasingStyle.Quad), {
			ClockTime = ,
			Brightness = ,
			Ambient = .(, , ),
			OutdoorAmbient = .(, , )
		}):()

		 lockConn
		lockConn = RunService.Heartbeat:(()
			  root   root.Parent 
				lockConn:()
				
			
			 dist = (root.Position - domainCenter.Position).Magnitude
			 dist >  
				root.CFrame = domainCenter * .(, , )
			
		)

		.()

		breakSound:()
		breakSound:()

		 domainPart 
			 shrinkStart = .()
			 shrinkConn
			shrinkConn = RunService.Heartbeat:(()
				 alpha = .((.() - shrinkStart) / , , )
				 size =  * ( - alpha)
				 size <   size =  
				(domainPart, .(size, size, size), domainCenter)
				 alpha >=  
					shrinkConn:()
					(domainPart)
				
			)
		

		TweenService:(Lighting, TweenInfo.(, .EasingStyle.Quad), {
			ClockTime = oldClock,
			Brightness = oldBright,
			Ambient = oldAmbient,
			OutdoorAmbient = oldOutdoor
		}):()

		.()
		 lockConn  lockConn:() 

		 originalCFrame 
			root.CFrame = originalCFrame
		
		 originalAnimator  originalAnimator.Parent = humanoid 
		humanoid.WalkSpeed = originalSpeed
	)

	()


()